icuSources/test/intltest/simplepatternformattertest.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2014, International Business Machines Corporation and         *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 *
   7 * File SIMPLEPATTERNFORMATTERTEST.CPP
   8 *
   9 ********************************************************************************
  10 */
  11 #include "cstring.h"
  12 #include "intltest.h"
  13 #include "simplepatternformatter.h"
  14
  15 #define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
  16
  17 class SimplePatternFormatterTest : public IntlTest {
  18 public:
  19     SimplePatternFormatterTest() {
  20     }
  21     void TestNoPlaceholders();
  22     void TestOnePlaceholder();
  23     void TestManyPlaceholders();
  24     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
  25 private:
  26 };
  27
  28 void SimplePatternFormatterTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  29   TESTCASE_AUTO_BEGIN;
  30   TESTCASE_AUTO(TestNoPlaceholders);
  31   TESTCASE_AUTO(TestOnePlaceholder);
  32   TESTCASE_AUTO(TestManyPlaceholders);
  33   TESTCASE_AUTO_END;
  34 }
  35
  36 void SimplePatternFormatterTest::TestNoPlaceholders() {
  37     UErrorCode status = U_ZERO_ERROR;
  38     SimplePatternFormatter fmt("This doesn''t have templates '{0}");
  39     assertEquals("PlaceholderCount", 0, fmt.getPlaceholderCount());
  40     UnicodeString appendTo;
  41     assertEquals(
  42             "Evaluate",
  43             "This doesn't have templates {0}",
  44             fmt.format("unused", appendTo, status));
  45     fmt.compile("This has {} bad {012d placeholders", status);
  46     assertEquals("PlaceholderCount", 0, fmt.getPlaceholderCount());
  47     appendTo.remove();
  48     assertEquals(
  49             "Evaluate",
  50             "This has {} bad {012d placeholders",
  51             fmt.format("unused", appendTo, status));
  52     assertSuccess("Status", status);
  53 }
  54
  55 void SimplePatternFormatterTest::TestOnePlaceholder() {
  56     UErrorCode status = U_ZERO_ERROR;
  57     SimplePatternFormatter fmt;
  58     fmt.compile("{0} meter", status);
  59     assertEquals("PlaceholderCount", 1, fmt.getPlaceholderCount());
  60     UnicodeString appendTo;
  61     assertEquals(
  62             "Evaluate",
  63             "1 meter",
  64             fmt.format("1", appendTo, status));
  65     assertSuccess("Status", status);
  66
  67     // assignment
  68     SimplePatternFormatter s;
  69     s = fmt;
  70     appendTo.remove();
  71     assertEquals(
  72             "Assignment",
  73             "1 meter",
  74             s.format("1", appendTo, status));
  75
  76     // Copy constructor
  77     SimplePatternFormatter r(fmt);
  78     appendTo.remove();
  79     assertEquals(
  80             "Copy constructor",
  81             "1 meter",
  82             r.format("1", appendTo, status));
  83     assertSuccess("Status", status);
  84 }
  85
  86 void SimplePatternFormatterTest::TestManyPlaceholders() {
  87     UErrorCode status = U_ZERO_ERROR;
  88     SimplePatternFormatter fmt;
  89     fmt.compile(
  90             "Templates {2}{1}{5} and {4} are out of order.", status);
  91     assertEquals("PlaceholderCount", 6, fmt.getPlaceholderCount());
  92     UnicodeString values[] = {
  93             "freddy", "tommy", "frog", "billy", "leg", "{0}"};
  94     UnicodeString *params[] = {
  95            &values[0], &values[1], &values[2], &values[3], &values[4], &values[5]};
  96     int32_t offsets[6];
  97     int32_t expectedOffsets[6] = {-1, 22, 18, -1, 35, 27};
  98     UnicodeString appendTo("Prefix: ");
  99     assertEquals(
 100             "Evaluate",
 101             "Prefix: Templates frogtommy{0} and leg are out of order.",
 102             fmt.format(
 103                     params,
 104                     LENGTHOF(params),
 105                     appendTo,
 106                     offsets,
 107                     LENGTHOF(offsets),
 108                     status));
 109     assertSuccess("Status", status);
 110     for (int32_t i = 0; i < LENGTHOF(expectedOffsets); ++i) {
 111         if (expectedOffsets[i] != offsets[i]) {
 112             errln("Expected %d, got %d", expectedOffsets[i], offsets[i]);
 113         }
 114     }
 115     appendTo.remove();
 116     fmt.format(
 117             params,
 118             LENGTHOF(params) - 1,
 119             appendTo,
 120             offsets,
 121             LENGTHOF(offsets),
 122             status);
 123     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 124         errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
 125     }
 126     status = U_ZERO_ERROR;
 127     offsets[LENGTHOF(offsets) - 1] = 289;
 128     appendTo.remove();
 129     fmt.format(
 130             params,
 131             LENGTHOF(params),
 132             appendTo,
 133             offsets,
 134             LENGTHOF(offsets) - 1,
 135             status);
 136     assertEquals("Offsets buffer length", 289, offsets[LENGTHOF(offsets) - 1]);
 137
 138     // Test assignment
 139     SimplePatternFormatter s;
 140     s = fmt;
 141     appendTo.remove();
 142     assertEquals(
 143             "Assignment",
 144             "Templates frogtommy{0} and leg are out of order.",
 145             s.format(
 146                     params,
 147                     LENGTHOF(params),
 148                     appendTo,
 149                     NULL,
 150                     0,
 151                     status));
 152
 153     // Copy constructor
 154     SimplePatternFormatter r(fmt);
 155     appendTo.remove();
 156     assertEquals(
 157             "Copy constructor",
 158             "Templates frogtommy{0} and leg are out of order.",
 159             r.format(
 160                     params,
 161                     LENGTHOF(params),
 162                     appendTo,
 163                     NULL,
 164                     0,
 165                     status));
 166     r.compile("{0} meter", status);
 167     assertEquals("PlaceholderCount", 1, r.getPlaceholderCount());
 168     appendTo.remove();
 169     assertEquals(
 170             "Replace with new compile",
 171             "freddy meter",
 172             r.format("freddy", appendTo, status));
 173     r.compile("{0}, {1}", status);
 174     assertEquals("PlaceholderCount", 2, r.getPlaceholderCount());
 175     appendTo.remove();
 176     assertEquals(
 177             "2 arg",
 178             "foo, bar",
 179             r.format("foo", "bar", appendTo, status));
 180     r.compile("{0}, {1} and {2}", status);
 181     assertEquals("PlaceholderCount", 3, r.getPlaceholderCount());
 182     appendTo.remove();
 183     assertEquals(
 184             "3 arg",
 185             "foo, bar and baz",
 186             r.format("foo", "bar", "baz", appendTo, status));
 187     assertSuccess("Status", status);
 188 }
 189
 190 extern IntlTest *createSimplePatternFormatterTest() {
 191     return new SimplePatternFormatterTest();
 192 }