icuSources/test/intltest/simpleformattertest.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2014-2016, International Business Machines Corporation and
   6 * others. All Rights Reserved.
   7 *******************************************************************************
   8 *
   9 * simpleformattertest.cpp
  10 *
  11 ********************************************************************************
  12 */
  13
  14 #include "unicode/msgfmt.h"
  15 #include "unicode/unistr.h"
  16 #include "cstring.h"
  17 #include "intltest.h"
  18 #include "unicode/simpleformatter.h"
  19
  20 class SimpleFormatterTest : public IntlTest {
  21 public:
  22     SimpleFormatterTest() {
  23     }
  24     void TestNoArguments();
  25     void TestSyntaxErrors();
  26     void TestOneArgument();
  27     void TestBigArgument();
  28     void TestManyArguments();
  29     void TestTooFewArgumentValues();
  30     void TestBadArguments();
  31     void TestTextWithNoArguments();
  32     void TestFormatReplaceNoOptimization();
  33     void TestFormatReplaceNoOptimizationLeadingText();
  34     void TestFormatReplaceOptimization();
  35     void TestFormatReplaceNoOptimizationLeadingArgumentUsedTwice();
  36     void TestFormatReplaceOptimizationNoOffsets();
  37     void TestFormatReplaceNoOptimizationNoOffsets();
  38     void TestQuotingLikeMessageFormat();
  39     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
  40 private:
  41     void verifyOffsets(
  42             const int32_t *expected,
  43             const int32_t *actual,
  44             int32_t count);
  45 };
  46
  47 void SimpleFormatterTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  48   TESTCASE_AUTO_BEGIN;
  49   TESTCASE_AUTO(TestNoArguments);
  50   TESTCASE_AUTO(TestSyntaxErrors);
  51   TESTCASE_AUTO(TestOneArgument);
  52   TESTCASE_AUTO(TestBigArgument);
  53   TESTCASE_AUTO(TestManyArguments);
  54   TESTCASE_AUTO(TestTooFewArgumentValues);
  55   TESTCASE_AUTO(TestBadArguments);
  56   TESTCASE_AUTO(TestTextWithNoArguments);
  57   TESTCASE_AUTO(TestFormatReplaceNoOptimization);
  58   TESTCASE_AUTO(TestFormatReplaceNoOptimizationLeadingText);
  59   TESTCASE_AUTO(TestFormatReplaceOptimization);
  60   TESTCASE_AUTO(TestFormatReplaceNoOptimizationLeadingArgumentUsedTwice);
  61   TESTCASE_AUTO(TestFormatReplaceOptimizationNoOffsets);
  62   TESTCASE_AUTO(TestFormatReplaceNoOptimizationNoOffsets);
  63   TESTCASE_AUTO(TestQuotingLikeMessageFormat);
  64   TESTCASE_AUTO_END;
  65 }
  66
  67 void SimpleFormatterTest::TestNoArguments() {
  68     UErrorCode status = U_ZERO_ERROR;
  69     SimpleFormatter fmt("This doesn''t have templates '{0}", status);
  70     assertEquals("getArgumentLimit", 0, fmt.getArgumentLimit());
  71     UnicodeString appendTo;
  72     assertEquals(
  73             "format",
  74             "This doesn't have templates {0}",
  75             fmt.format("unused", appendTo, status));
  76     appendTo.remove();
  77     int32_t offsets[] = { 0 };
  78     assertEquals(
  79             "formatAndAppend",
  80             "This doesn't have templates {0}",
  81             fmt.formatAndAppend(NULL, 0, appendTo, offsets, 1, status));
  82     assertEquals("formatAndAppend offsets[0]", -1, offsets[0]);
  83     assertEquals(
  84             "formatAndReplace",
  85             "This doesn't have templates {0}",
  86             fmt.formatAndReplace(NULL, 0, appendTo, NULL, 0, status));
  87     assertSuccess("Status", status);
  88 }
  89
  90 void SimpleFormatterTest::TestSyntaxErrors() {
  91     UErrorCode status = U_ZERO_ERROR;
  92     SimpleFormatter fmt("{}", status);
  93     assertEquals("syntax error {}", (int32_t)U_ILLEGAL_ARGUMENT_ERROR, status);
  94     status = U_ZERO_ERROR;
  95     fmt.applyPattern("{12d", status);
  96     assertEquals("syntax error {12d", (int32_t)U_ILLEGAL_ARGUMENT_ERROR, status);
  97 }
  98
  99 void SimpleFormatterTest::TestOneArgument() {
 100     UErrorCode status = U_ZERO_ERROR;
 101     SimpleFormatter fmt;
 102     fmt.applyPattern("{0} meter", status);
 103     if (!assertSuccess("Status", status)) {
 104         return;
 105     }
 106     assertEquals("getArgumentLimit", 1, fmt.getArgumentLimit());
 107     UnicodeString appendTo;
 108     assertEquals(
 109             "format",
 110             "1 meter",
 111             fmt.format("1", appendTo, status));
 112
 113     // assignment
 114     SimpleFormatter s;
 115     s = fmt;
 116     appendTo.remove();
 117     assertEquals(
 118             "Assignment",
 119             "1 meter",
 120             s.format("1", appendTo, status));
 121
 122     // Copy constructor
 123     SimpleFormatter r(fmt);
 124     appendTo.remove();
 125     assertEquals(
 126             "Copy constructor",
 127             "1 meter",
 128             r.format("1", appendTo, status));
 129     assertSuccess("Status", status);
 130 }
 131
 132 void SimpleFormatterTest::TestBigArgument() {
 133     UErrorCode status = U_ZERO_ERROR;
 134     SimpleFormatter fmt("a{20}c", status);
 135     if (!assertSuccess("Status", status)) {
 136         return;
 137     }
 138     assertEquals("{20} count", 21, fmt.getArgumentLimit());
 139     UnicodeString b("b");
 140     UnicodeString *values[] = {
 141         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 142         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 143         &b
 144     };
 145     UnicodeString result;
 146     assertEquals("{20}=b", "abc", fmt.formatAndAppend(values, 21, result, NULL, 0, status));
 147     assertSuccess("Status", status);
 148 }
 149
 150 void SimpleFormatterTest::TestManyArguments() {
 151     UErrorCode status = U_ZERO_ERROR;
 152     SimpleFormatter fmt;
 153     fmt.applyPattern(
 154             "Templates {2}{1}{5} and {4} are out of order.", status);
 155     if (!assertSuccess("Status", status)) {
 156         return;
 157     }
 158     assertEquals("getArgumentLimit", 6, fmt.getArgumentLimit());
 159     UnicodeString values[] = {
 160             "freddy", "tommy", "frog", "billy", "leg", "{0}"};
 161     UnicodeString *params[] = {
 162            &values[0], &values[1], &values[2], &values[3], &values[4], &values[5]};
 163     int32_t offsets[6];
 164     int32_t expectedOffsets[6] = {-1, 22, 18, -1, 35, 27};
 165     UnicodeString appendTo("Prefix: ");
 166     assertEquals(
 167             "format",
 168             "Prefix: Templates frogtommy{0} and leg are out of order.",
 169             fmt.formatAndAppend(
 170                     params,
 171                     UPRV_LENGTHOF(params),
 172                     appendTo,
 173                     offsets,
 174                     UPRV_LENGTHOF(offsets),
 175                     status));
 176     if (!assertSuccess("Status", status)) {
 177         return;
 178     }
 179     verifyOffsets(expectedOffsets, offsets, UPRV_LENGTHOF(expectedOffsets));
 180     appendTo.remove();
 181
 182     // Ensure we don't write to offsets array beyond its length.
 183     status = U_ZERO_ERROR;
 184     offsets[UPRV_LENGTHOF(offsets) - 1] = 289;
 185     appendTo.remove();
 186     fmt.formatAndAppend(
 187             params,
 188             UPRV_LENGTHOF(params),
 189             appendTo,
 190             offsets,
 191             UPRV_LENGTHOF(offsets) - 1,
 192             status);
 193     assertEquals("Offsets buffer length", 289, offsets[UPRV_LENGTHOF(offsets) - 1]);
 194
 195     // Test assignment
 196     SimpleFormatter s;
 197     s = fmt;
 198     appendTo.remove();
 199     assertEquals(
 200             "Assignment",
 201             "Templates frogtommy{0} and leg are out of order.",
 202             s.formatAndAppend(
 203                     params,
 204                     UPRV_LENGTHOF(params),
 205                     appendTo,
 206                     NULL,
 207                     0,
 208                     status));
 209
 210     // Copy constructor
 211     SimpleFormatter r(fmt);
 212     appendTo.remove();
 213     assertEquals(
 214             "Copy constructor",
 215             "Templates frogtommy{0} and leg are out of order.",
 216             r.formatAndAppend(
 217                     params,
 218                     UPRV_LENGTHOF(params),
 219                     appendTo,
 220                     NULL,
 221                     0,
 222                     status));
 223     r.applyPattern("{0} meter", status);
 224     assertEquals("getArgumentLimit", 1, r.getArgumentLimit());
 225     appendTo.remove();
 226     assertEquals(
 227             "Replace with new applyPattern",
 228             "freddy meter",
 229             r.format("freddy", appendTo, status));
 230     r.applyPattern("{0}, {1}", status);
 231     assertEquals("getArgumentLimit", 2, r.getArgumentLimit());
 232     appendTo.remove();
 233     assertEquals(
 234             "2 arg",
 235             "foo, bar",
 236             r.format("foo", "bar", appendTo, status));
 237     r.applyPattern("{0}, {1} and {2}", status);
 238     assertEquals("getArgumentLimit", 3, r.getArgumentLimit());
 239     appendTo.remove();
 240     assertEquals(
 241             "3 arg",
 242             "foo, bar and baz",
 243             r.format("foo", "bar", "baz", appendTo, status));
 244     assertSuccess("Status", status);
 245 }
 246
 247 void SimpleFormatterTest::TestTooFewArgumentValues() {
 248     UErrorCode status = U_ZERO_ERROR;
 249     SimpleFormatter fmt("{0} and {1}", status);
 250     UnicodeString appendTo;
 251     UnicodeString firstValue;
 252     UnicodeString *params[] = {&firstValue};
 253
 254     fmt.format(
 255             firstValue, appendTo, status);
 256     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 257         errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
 258     }
 259
 260     status = U_ZERO_ERROR;
 261     fmt.formatAndAppend(
 262             params, UPRV_LENGTHOF(params), appendTo, NULL, 0, status);
 263     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 264         errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
 265     }
 266
 267     status = U_ZERO_ERROR;
 268     fmt.formatAndReplace(
 269             params, UPRV_LENGTHOF(params), appendTo, NULL, 0, status);
 270     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 271         errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
 272     }
 273 }
 274
 275 void SimpleFormatterTest::TestBadArguments() {
 276     UErrorCode status = U_ZERO_ERROR;
 277     SimpleFormatter fmt("pickle", status);
 278     UnicodeString appendTo;
 279
 280     // These succeed
 281     fmt.formatAndAppend(
 282             NULL, 0, appendTo, NULL, 0, status);
 283     fmt.formatAndReplace(
 284             NULL, 0, appendTo, NULL, 0, status);
 285     assertSuccess("", status);
 286     status = U_ZERO_ERROR;
 287
 288     // fails
 289     fmt.formatAndAppend(
 290             NULL, 1, appendTo, NULL, 0, status);
 291     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 292         errln("Expected U_ILLEGAL_ARGUMENT_ERROR: formatAndAppend() values=NULL but length=1");
 293     }
 294     status = U_ZERO_ERROR;
 295
 296     // fails
 297     fmt.formatAndAppend(
 298             NULL, 0, appendTo, NULL, 1, status);
 299     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 300         errln("Expected U_ILLEGAL_ARGUMENT_ERROR: formatAndAppend() offsets=NULL but length=1");
 301     }
 302     status = U_ZERO_ERROR;
 303
 304     // fails because appendTo used as a parameter value
 305     SimpleFormatter fmt2("Arguments {0} and {1}", status);
 306     UnicodeString frog("frog");
 307     const UnicodeString *params[] = { &appendTo, &frog };
 308     fmt2.formatAndAppend(params, 2, appendTo, NULL, 0, status);
 309     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 310         errln("Expected U_ILLEGAL_ARGUMENT_ERROR: formatAndAppend() value=appendTo");
 311     }
 312     status = U_ZERO_ERROR;
 313
 314
 315     // fails
 316     fmt.formatAndReplace(
 317             NULL, 1, appendTo, NULL, 0, status);
 318     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 319         errln("Expected U_ILLEGAL_ARGUMENT_ERROR: formatAndReplace() values=NULL but length=1");
 320     }
 321     status = U_ZERO_ERROR;
 322
 323     // fails
 324     fmt.formatAndReplace(
 325             NULL, 0, appendTo, NULL, 1, status);
 326     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 327         errln("Expected U_ILLEGAL_ARGUMENT_ERROR: formatAndReplace() offsets=NULL but length=1");
 328     }
 329 }
 330
 331 void SimpleFormatterTest::TestTextWithNoArguments() {
 332     IcuTestErrorCode status(*this, "TestTextWithNoArguments");
 333     SimpleFormatter fmt("{0} has no {1} arguments.", status);
 334     assertEquals("String output 1",
 335         " has no  arguments.", fmt.getTextWithNoArguments());
 336
 337     // Test offset positions
 338     int32_t offsets[3];
 339     assertEquals("String output 2",
 340         u" has no  arguments.", fmt.getTextWithNoArguments(offsets, 3));
 341     assertEquals("Offset at 0",
 342         0, offsets[0]);
 343     assertEquals("Offset at 1",
 344         8, offsets[1]);
 345     assertEquals("Offset at 2",
 346         -1, offsets[2]);
 347 }
 348
 349 void SimpleFormatterTest::TestFormatReplaceNoOptimization() {
 350     UErrorCode status = U_ZERO_ERROR;
 351     SimpleFormatter fmt;
 352     fmt.applyPattern("{2}, {0}, {1} and {3}", status);
 353     if (!assertSuccess("Status", status)) {
 354         return;
 355     }
 356     UnicodeString result("original");
 357     int32_t offsets[4];
 358     UnicodeString freddy("freddy");
 359     UnicodeString frog("frog");
 360     UnicodeString by("by");
 361     const UnicodeString *params[] = {&result, &freddy, &frog, &by};
 362     assertEquals(
 363             "",
 364             "frog, original, freddy and by",
 365             fmt.formatAndReplace(
 366                     params,
 367                     UPRV_LENGTHOF(params),
 368                     result,
 369                     offsets,
 370                     UPRV_LENGTHOF(offsets),
 371                     status));
 372     if (!assertSuccess("Status", status)) {
 373         return;
 374     }
 375     int32_t expectedOffsets[] = {6, 16, 0, 27};
 376     verifyOffsets(expectedOffsets, offsets, UPRV_LENGTHOF(expectedOffsets));
 377 }
 378
 379 void SimpleFormatterTest::TestFormatReplaceNoOptimizationLeadingText() {
 380     UErrorCode status = U_ZERO_ERROR;
 381     SimpleFormatter fmt;
 382     fmt.applyPattern("boo {2}, {0}, {1} and {3}", status);
 383     if (!assertSuccess("Status", status)) {
 384         return;
 385     }
 386     UnicodeString result("original");
 387     int32_t offsets[4];
 388     UnicodeString freddy("freddy");
 389     UnicodeString frog("frog");
 390     UnicodeString by("by");
 391     const UnicodeString *params[] = {&freddy, &frog, &result, &by};
 392     assertEquals(
 393             "",
 394             "boo original, freddy, frog and by",
 395             fmt.formatAndReplace(
 396                     params,
 397                     UPRV_LENGTHOF(params),
 398                     result,
 399                     offsets,
 400                     UPRV_LENGTHOF(offsets),
 401                     status));
 402     if (!assertSuccess("Status", status)) {
 403         return;
 404     }
 405     int32_t expectedOffsets[] = {14, 22, 4, 31};
 406     verifyOffsets(expectedOffsets, offsets, UPRV_LENGTHOF(expectedOffsets));
 407 }
 408
 409 void SimpleFormatterTest::TestFormatReplaceOptimization() {
 410     UErrorCode status = U_ZERO_ERROR;
 411     SimpleFormatter fmt;
 412     fmt.applyPattern("{2}, {0}, {1} and {3}", status);
 413     if (!assertSuccess("Status", status)) {
 414         return;
 415     }
 416     UnicodeString result("original");
 417     int32_t offsets[4];
 418     UnicodeString freddy("freddy");
 419     UnicodeString frog("frog");
 420     UnicodeString by("by");
 421     const UnicodeString *params[] = {&freddy, &frog, &result, &by};
 422     assertEquals(
 423             "",
 424             "original, freddy, frog and by",
 425             fmt.formatAndReplace(
 426                     params,
 427                     UPRV_LENGTHOF(params),
 428                     result,
 429                     offsets,
 430                     UPRV_LENGTHOF(offsets),
 431                     status));
 432     if (!assertSuccess("Status", status)) {
 433         return;
 434     }
 435     int32_t expectedOffsets[] = {10, 18, 0, 27};
 436     verifyOffsets(expectedOffsets, offsets, UPRV_LENGTHOF(expectedOffsets));
 437 }
 438
 439 void SimpleFormatterTest::TestFormatReplaceNoOptimizationLeadingArgumentUsedTwice() {
 440     UErrorCode status = U_ZERO_ERROR;
 441     SimpleFormatter fmt;
 442     fmt.applyPattern("{2}, {0}, {1} and {3} {2}", status);
 443     if (!assertSuccess("Status", status)) {
 444         return;
 445     }
 446     UnicodeString result("original");
 447     int32_t offsets[4];
 448     UnicodeString freddy("freddy");
 449     UnicodeString frog("frog");
 450     UnicodeString by("by");
 451     const UnicodeString *params[] = {&freddy, &frog, &result, &by};
 452     assertEquals(
 453             "",
 454             "original, freddy, frog and by original",
 455             fmt.formatAndReplace(
 456                     params,
 457                     UPRV_LENGTHOF(params),
 458                     result,
 459                     offsets,
 460                     UPRV_LENGTHOF(offsets),
 461                     status));
 462     if (!assertSuccess("Status", status)) {
 463         return;
 464     }
 465     int32_t expectedOffsets[] = {10, 18, 30, 27};
 466     verifyOffsets(expectedOffsets, offsets, UPRV_LENGTHOF(expectedOffsets));
 467 }
 468
 469 void SimpleFormatterTest::TestFormatReplaceOptimizationNoOffsets() {
 470     UErrorCode status = U_ZERO_ERROR;
 471     SimpleFormatter fmt;
 472     fmt.applyPattern("{2}, {0}, {1} and {3}", status);
 473     if (!assertSuccess("Status", status)) {
 474         return;
 475     }
 476     UnicodeString result("original");
 477     UnicodeString freddy("freddy");
 478     UnicodeString frog("frog");
 479     UnicodeString by("by");
 480     const UnicodeString *params[] = {&freddy, &frog, &result, &by};
 481     assertEquals(
 482             "",
 483             "original, freddy, frog and by",
 484             fmt.formatAndReplace(
 485                     params,
 486                     UPRV_LENGTHOF(params),
 487                     result,
 488                     NULL,
 489                     0,
 490                     status));
 491     assertSuccess("Status", status);
 492 }
 493
 494 void SimpleFormatterTest::TestFormatReplaceNoOptimizationNoOffsets() {
 495     UErrorCode status = U_ZERO_ERROR;
 496     SimpleFormatter fmt("Arguments {0} and {1}", status);
 497     UnicodeString result("previous:");
 498     UnicodeString frog("frog");
 499     const UnicodeString *params[] = {&result, &frog};
 500     assertEquals(
 501             "",
 502             "Arguments previous: and frog",
 503             fmt.formatAndReplace(
 504                     params,
 505                     UPRV_LENGTHOF(params),
 506                     result,
 507                     NULL,
 508                     0,
 509                     status));
 510     assertSuccess("Status", status);
 511 }
 512
 513 void SimpleFormatterTest::TestQuotingLikeMessageFormat() {
 514 #if !UCONFIG_NO_FORMATTING
 515     UErrorCode status = U_ZERO_ERROR;
 516     UnicodeString pattern = "{0} don't can''t '{5}''}{a' again '}'{1} to the '{end";
 517     SimpleFormatter spf(pattern, status);
 518     MessageFormat mf(pattern, Locale::getRoot(), status);
 519     UnicodeString expected = "X don't can't {5}'}{a again }Y to the {end";
 520     UnicodeString x("X"), y("Y");
 521     Formattable values[] = { x, y };
 522     UnicodeString result;
 523     FieldPosition ignore(FieldPosition::DONT_CARE);
 524     assertEquals("MessageFormat", expected, mf.format(values, 2, result, ignore, status));
 525     assertEquals("SimpleFormatter", expected, spf.format(x, y, result.remove(), status));
 526 #endif /* !UCONFIG_NO_FORMATTING */
 527 }
 528
 529 void SimpleFormatterTest::verifyOffsets(
 530         const int32_t *expected, const int32_t *actual, int32_t count) {
 531     for (int32_t i = 0; i < count; ++i) {
 532         if (expected[i] != actual[i]) {
 533             errln("Expected %d, got %d", expected[i], actual[i]);
 534         }
 535     }
 536 }
 537
 538 extern IntlTest *createSimpleFormatterTest() {
 539     return new SimpleFormatterTest();
 540 }