icuSources/test/intltest/msfmrgts.cpp

   1 /***********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2009, International Business Machines Corporation
   4  * and others. All Rights Reserved.
   5  ***********************************************************************/
   6
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include "msfmrgts.h"
  12
  13 #include "unicode/format.h"
  14 #include "unicode/decimfmt.h"
  15 #include "unicode/locid.h"
  16 #include "unicode/msgfmt.h"
  17 #include "unicode/numfmt.h"
  18 #include "unicode/choicfmt.h"
  19 #include "unicode/gregocal.h"
  20 #include "putilimp.h"
  21
  22 // *****************************************************************************
  23 // class MessageFormatRegressionTest
  24 // *****************************************************************************
  25
  26 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
  27
  28 void
  29 MessageFormatRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  30 {
  31     // if (exec) logln((UnicodeString)"TestSuite MessageFormatRegressionTest");
  32     switch (index) {
  33         CASE(0,Test4074764)
  34         CASE(1,Test4058973)
  35         CASE(2,Test4031438)
  36         CASE(3,Test4052223)
  37         CASE(4,Test4104976)
  38         CASE(5,Test4106659)
  39         CASE(6,Test4106660)
  40         CASE(7,Test4111739)
  41         CASE(8,Test4114743)
  42         CASE(9,Test4116444)
  43         CASE(10,Test4114739)
  44         CASE(11,Test4113018)
  45         CASE(12,Test4106661)
  46         CASE(13,Test4094906)
  47         CASE(14,Test4118592)
  48         CASE(15,Test4118594)
  49         CASE(16,Test4105380)
  50         CASE(17,Test4120552)
  51         CASE(18,Test4142938)
  52         CASE(19,TestChoicePatternQuote)
  53         CASE(20,Test4112104)
  54         CASE(21,TestAPI)
  55
  56         default: name = ""; break;
  57     }
  58 }
  59
  60 UBool
  61 MessageFormatRegressionTest::failure(UErrorCode status, const char* msg, UBool possibleDataError)
  62 {
  63     if(U_FAILURE(status)) {
  64         if (possibleDataError) {
  65             dataerrln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
  66         } else {
  67             errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
  68         }
  69         return TRUE;
  70     }
  71
  72     return FALSE;
  73 }
  74
  75 /* @bug 4074764
  76  * Null exception when formatting pattern with MessageFormat
  77  * with no parameters.
  78  */
  79 void MessageFormatRegressionTest::Test4074764() {
  80     UnicodeString pattern [] = {
  81         "Message without param",
  82         "Message with param:{0}",
  83         "Longer Message with param {0}"
  84     };
  85     //difference between the two param strings are that
  86     //in the first one, the param position is within the
  87     //length of the string without param while it is not so
  88     //in the other case.
  89
  90     UErrorCode status = U_ZERO_ERROR;
  91     MessageFormat *messageFormatter = new MessageFormat("", status);
  92
  93     failure(status, "couldn't create MessageFormat");
  94
  95     //try {
  96         //Apply pattern with param and print the result
  97         messageFormatter->applyPattern(pattern[1], status);
  98         failure(status, "messageFormat->applyPattern");
  99         //Object[] params = {new UnicodeString("BUG"), new Date()};
 100         Formattable params [] = {
 101             Formattable(UnicodeString("BUG")),
 102             Formattable(0, Formattable::kIsDate)
 103         };
 104         UnicodeString tempBuffer;
 105         FieldPosition pos(FieldPosition::DONT_CARE);
 106         tempBuffer = messageFormatter->format(params, 2, tempBuffer, pos, status);
 107         if( tempBuffer != "Message with param:BUG" || failure(status, "messageFormat->format"))
 108             errln("MessageFormat with one param test failed.");
 109         logln("Formatted with one extra param : " + tempBuffer);
 110
 111         //Apply pattern without param and print the result
 112         messageFormatter->applyPattern(pattern[0], status);
 113         failure(status, "messageFormatter->applyPattern");
 114
 115         // {sfb} how much does this apply in C++?
 116         // do we want to verify that the Formattable* array is not NULL,
 117         // or is that the user's responsibility?
 118         // additionally, what should be the item count?
 119         // for bug testing purposes, assume that something was set to
 120         // NULL by mistake, and that the length should be non-zero
 121
 122         //tempBuffer = messageFormatter->format(NULL, 1, tempBuffer, FieldPosition(FieldPosition::DONT_CARE), status);
 123         tempBuffer.remove();
 124         tempBuffer = messageFormatter->format(NULL, 0, tempBuffer, pos, status);
 125
 126         if( tempBuffer != "Message without param" || failure(status, "messageFormat->format"))
 127             errln("MessageFormat with no param test failed.");
 128         logln("Formatted with no params : " + tempBuffer);
 129
 130         tempBuffer.remove();
 131         tempBuffer = messageFormatter->format(params, 2, tempBuffer, pos, status);
 132          if (tempBuffer != "Message without param" || failure(status, "messageFormat->format"))
 133             errln("Formatted with arguments > subsitution failed. result = " + tempBuffer);
 134          logln("Formatted with extra params : " + tempBuffer);
 135         //This statement gives an exception while formatting...
 136         //If we use pattern[1] for the message with param,
 137         //we get an NullPointerException in MessageFormat.java(617)
 138         //If we use pattern[2] for the message with param,
 139         //we get an StringArrayIndexOutOfBoundsException in MessageFormat.java(614)
 140         //Both are due to maxOffset not being reset to -1
 141         //in applyPattern() when the pattern does not
 142         //contain any param.
 143     /*} catch (Exception foo) {
 144         errln("Exception when formatting with no params.");
 145     }*/
 146
 147     delete messageFormatter;
 148 }
 149
 150 /* @bug 4058973
 151  * MessageFormat.toPattern has weird rounding behavior.
 152  */
 153 void MessageFormatRegressionTest::Test4058973()
 154 {
 155     UErrorCode status = U_ZERO_ERROR;
 156     MessageFormat *fmt = new MessageFormat("{0,choice,0#no files|1#one file|1< {0,number,integer} files}", status);
 157     failure(status, "new MessageFormat");
 158
 159     UnicodeString pat;
 160     pat = fmt->toPattern(pat);
 161     UnicodeString exp("{0,choice,0#no files|1#one file|1< {0,number,integer} files}");
 162     if (pat != exp) {
 163         errln("MessageFormat.toPattern failed");
 164         errln("Exp: " + exp);
 165         errln("Got: " + pat);
 166     }
 167
 168     delete fmt;
 169 }
 170 /* @bug 4031438
 171  * More robust message formats.
 172  */
 173 void MessageFormatRegressionTest::Test4031438()
 174 {
 175     UErrorCode status = U_ZERO_ERROR;
 176
 177     UnicodeString pattern1("Impossible {1} has occurred -- status code is {0} and message is {2}.");
 178     UnicodeString pattern2("Double '' Quotes {0} test and quoted '{1}' test plus 'other {2} stuff'.");
 179
 180     MessageFormat *messageFormatter = new MessageFormat("", status);
 181     failure(status, "new MessageFormat");
 182
 183     const UBool possibleDataError = TRUE;
 184
 185     //try {
 186         logln("Apply with pattern : " + pattern1);
 187         messageFormatter->applyPattern(pattern1, status);
 188         failure(status, "messageFormat->applyPattern");
 189         //Object[] params = {new Integer(7)};
 190         Formattable params []= {
 191             Formattable((int32_t)7)
 192         };
 193         UnicodeString tempBuffer;
 194         FieldPosition pos(FieldPosition::DONT_CARE);
 195         tempBuffer = messageFormatter->format(params, 1, tempBuffer, pos, status);
 196         if(tempBuffer != "Impossible {1} has occurred -- status code is 7 and message is {2}." || failure(status, "MessageFormat::format"))
 197             dataerrln("Tests arguments < substitution failed");
 198         logln("Formatted with 7 : " + tempBuffer);
 199         ParsePosition pp(0);
 200         int32_t count = 0;
 201         Formattable *objs = messageFormatter->parse(tempBuffer, pp, count);
 202         //if(objs[7/*params.length*/] != NULL)
 203         //    errln("Parse failed with more than expected arguments");
 204
 205         NumberFormat *fmt = 0;
 206         UnicodeString temp, temp1;
 207
 208         for (int i = 0; i < count; i++) {
 209
 210             // convert to string if not already
 211             Formattable obj = objs[i];
 212             temp.remove();
 213             if(obj.getType() == Formattable::kString)
 214                 temp = obj.getString(temp);
 215             else {
 216                 fmt = NumberFormat::createInstance(status);
 217                 switch (obj.getType()) {
 218                 case Formattable::kLong: fmt->format(obj.getLong(), temp); break;
 219                 case Formattable::kInt64: fmt->format(obj.getInt64(), temp); break;
 220                 case Formattable::kDouble: fmt->format(obj.getDouble(), temp); break;
 221                 default: break;
 222                 }
 223             }
 224
 225             // convert to string if not already
 226             Formattable obj1 = params[i];
 227             temp1.remove();
 228             if(obj1.getType() == Formattable::kString)
 229                 temp1 = obj1.getString(temp1);
 230             else {
 231                 fmt = NumberFormat::createInstance(status);
 232                 switch (obj1.getType()) {
 233                 case Formattable::kLong: fmt->format(obj1.getLong(), temp1); break;
 234                 case Formattable::kInt64: fmt->format(obj1.getInt64(), temp1); break;
 235                 case Formattable::kDouble: fmt->format(obj1.getDouble(), temp1); break;
 236                 default: break;
 237                 }
 238             }
 239
 240             //if (objs[i] != NULL && objs[i].getString(temp1) != params[i].getString(temp2)) {
 241             if (temp != temp1) {
 242                 errln("Parse failed on object " + objs[i].getString(temp1) + " at index : " + i);
 243             }
 244         }
 245
 246         delete fmt;
 247         delete [] objs;
 248
 249         // {sfb} does this apply?  no way to really pass a null Formattable,
 250         // only a null array
 251
 252         /*tempBuffer = messageFormatter->format(null, tempBuffer, FieldPosition(FieldPosition::DONT_CARE), status);
 253         if (tempBuffer != "Impossible {1} has occurred -- status code is {0} and message is {2}." || failure(status, "messageFormat->format"))
 254             errln("Tests with no arguments failed");
 255         logln("Formatted with null : " + tempBuffer);*/
 256         logln("Apply with pattern : " + pattern2);
 257         messageFormatter->applyPattern(pattern2, status);
 258         failure(status, "messageFormatter->applyPattern", possibleDataError);
 259         tempBuffer.remove();
 260         tempBuffer = messageFormatter->format(params, 1, tempBuffer, pos, status);
 261         if (tempBuffer != "Double ' Quotes 7 test and quoted {1} test plus other {2} stuff.")
 262             dataerrln("quote format test (w/ params) failed. - %s", u_errorName(status));
 263         logln("Formatted with params : " + tempBuffer);
 264
 265         /*tempBuffer = messageFormatter->format(null);
 266         if (!tempBuffer.equals("Double ' Quotes {0} test and quoted {1} test plus other {2} stuff."))
 267             errln("quote format test (w/ null) failed.");
 268         logln("Formatted with null : " + tempBuffer);
 269         logln("toPattern : " + messageFormatter.toPattern());*/
 270     /*} catch (Exception foo) {
 271         errln("Exception when formatting in bug 4031438. "+foo.getMessage());
 272     }*/
 273         delete messageFormatter;
 274 }
 275
 276 void MessageFormatRegressionTest::Test4052223()
 277 {
 278
 279     ParsePosition pos(0);
 280     if (pos.getErrorIndex() != -1) {
 281         errln("ParsePosition.getErrorIndex initialization failed.");
 282     }
 283
 284     UErrorCode status = U_ZERO_ERROR;
 285     MessageFormat *fmt = new MessageFormat("There are {0} apples growing on the {1} tree.", status);
 286     failure(status, "new MessageFormat");
 287     UnicodeString str("There is one apple growing on the peach tree.");
 288
 289     int32_t count = 0;
 290     fmt->parse(str, pos, count);
 291
 292     logln(UnicodeString("unparsable string , should fail at ") + pos.getErrorIndex());
 293     if (pos.getErrorIndex() == -1)
 294         errln("Bug 4052223 failed : parsing string " + str);
 295     pos.setErrorIndex(4);
 296     if (pos.getErrorIndex() != 4)
 297         errln(UnicodeString("setErrorIndex failed, got ") + pos.getErrorIndex() + " instead of 4");
 298
 299     ChoiceFormat *f = new ChoiceFormat(
 300         "-1#are negative|0#are no or fraction|1#is one|1.0<is 1+|2#are two|2<are more than 2.", status);
 301     failure(status, "new ChoiceFormat");
 302     pos.setIndex(0);
 303     pos.setErrorIndex(-1);
 304     Formattable obj;
 305     f->parse("are negative", obj, pos);
 306     if (pos.getErrorIndex() != -1 && obj.getDouble() == -1.0)
 307         errln(UnicodeString("Parse with \"are negative\" failed, at ") + pos.getErrorIndex());
 308     pos.setIndex(0);
 309     pos.setErrorIndex(-1);
 310     f->parse("are no or fraction ", obj, pos);
 311     if (pos.getErrorIndex() != -1 && obj.getDouble() == 0.0)
 312         errln(UnicodeString("Parse with \"are no or fraction\" failed, at ") + pos.getErrorIndex());
 313     pos.setIndex(0);
 314     pos.setErrorIndex(-1);
 315     f->parse("go postal", obj, pos);
 316     if (pos.getErrorIndex() == -1 && ! uprv_isNaN(obj.getDouble()))
 317         errln(UnicodeString("Parse with \"go postal\" failed, at ") + pos.getErrorIndex());
 318
 319     delete fmt;
 320     delete f;
 321 }
 322 /* @bug 4104976
 323  * ChoiceFormat.equals(null) throws NullPointerException
 324  */
 325
 326 // {sfb} not really applicable in C++?? (kind of silly)
 327
 328 void MessageFormatRegressionTest::Test4104976()
 329 {
 330     double limits [] = {1, 20};
 331     UnicodeString formats [] = {
 332         UnicodeString("xyz"),
 333         UnicodeString("abc")
 334     };
 335     int32_t formats_length = (int32_t)(sizeof(formats)/sizeof(formats[0]));
 336     UErrorCode status = U_ZERO_ERROR;
 337     ChoiceFormat *cf = new ChoiceFormat(limits, formats, formats_length);
 338     failure(status, "new ChoiceFormat");
 339     //try {
 340         log("Compares to null is always false, returned : ");
 341         logln(cf == NULL ? "TRUE" : "FALSE");
 342     /*} catch (Exception foo) {
 343         errln("ChoiceFormat.equals(null) throws exception.");
 344     }*/
 345
 346     delete cf;
 347 }
 348
 349 /* @bug 4106659
 350  * ChoiceFormat.ctor(double[], String[]) doesn't check
 351  * whether lengths of input arrays are equal.
 352  */
 353
 354 // {sfb} again, not really applicable in C++
 355
 356 void MessageFormatRegressionTest::Test4106659()
 357 {
 358     /*
 359     double limits [] = {
 360         1, 2, 3
 361     };
 362     UnicodeString formats [] = {
 363         "one", "two"
 364     };
 365     ChoiceFormat *cf = NULL;
 366     //try {
 367     //    cf = new ChoiceFormat(limits, formats, 3);
 368     //} catch (Exception foo) {
 369     //    logln("ChoiceFormat constructor should check for the array lengths");
 370     //    cf = null;
 371     //}
 372     //if (cf != null)
 373     //    errln(cf->format(5));
 374     //
 375     delete cf;
 376     */
 377 }
 378
 379 /* @bug 4106660
 380  * ChoiceFormat.ctor(double[], String[]) allows unordered double array.
 381  * This is not a bug, added javadoc to emphasize the use of limit
 382  * array must be in ascending order.
 383  */
 384 void MessageFormatRegressionTest::Test4106660()
 385 {
 386     double limits [] = {3, 1, 2};
 387     UnicodeString formats [] = {
 388         UnicodeString("Three"),
 389             UnicodeString("One"),
 390             UnicodeString("Two")
 391     };
 392     ChoiceFormat *cf = new ChoiceFormat(limits, formats, 3);
 393     double d = 5.0;
 394     UnicodeString str;
 395     FieldPosition pos(FieldPosition::DONT_CARE);
 396     str = cf->format(d, str, pos);
 397     if (str != "Two")
 398         errln( (UnicodeString) "format(" + d + ") = " + str);
 399
 400     delete cf;
 401 }
 402
 403 /* @bug 4111739
 404  * MessageFormat is incorrectly serialized/deserialized.
 405  */
 406
 407 // {sfb} doesn't apply in C++
 408
 409 void MessageFormatRegressionTest::Test4111739()
 410 {
 411     /*MessageFormat format1 = null;
 412     MessageFormat format2 = null;
 413     ObjectOutputStream ostream = null;
 414     ByteArrayOutputStream baos = null;
 415     ObjectInputStream istream = null;
 416
 417     try {
 418         baos = new ByteArrayOutputStream();
 419         ostream = new ObjectOutputStream(baos);
 420     } catch(IOException e) {
 421         errln("Unexpected exception : " + e.getMessage());
 422         return;
 423     }
 424
 425     try {
 426         format1 = new MessageFormat("pattern{0}");
 427         ostream.writeObject(format1);
 428         ostream.flush();
 429
 430         byte bytes[] = baos.toByteArray();
 431
 432         istream = new ObjectInputStream(new ByteArrayInputStream(bytes));
 433         format2 = (MessageFormat)istream.readObject();
 434     } catch(Exception e) {
 435         errln("Unexpected exception : " + e.getMessage());
 436     }
 437
 438     if (!format1.equals(format2)) {
 439         errln("MessageFormats before and after serialization are not" +
 440             " equal\nformat1 = " + format1 + "(" + format1.toPattern() + ")\nformat2 = " +
 441             format2 + "(" + format2.toPattern() + ")");
 442     } else {
 443         logln("Serialization for MessageFormat is OK.");
 444     }*/
 445 }
 446 /* @bug 4114743
 447  * MessageFormat.applyPattern allows illegal patterns.
 448  */
 449 void MessageFormatRegressionTest::Test4114743()
 450 {
 451     UnicodeString originalPattern("initial pattern");
 452     UErrorCode status = U_ZERO_ERROR;
 453     MessageFormat *mf = new MessageFormat(originalPattern, status);
 454     failure(status, "new MessageFormat");
 455     //try {
 456         UnicodeString illegalPattern("ab { '}' de");
 457         mf->applyPattern(illegalPattern, status);
 458         if( ! U_FAILURE(status))
 459             errln("illegal pattern: \"" + illegalPattern + "\"");
 460     /*} catch (IllegalArgumentException foo) {
 461         if (!originalPattern.equals(mf.toPattern()))
 462             errln("pattern after: \"" + mf.toPattern() + "\"");
 463     }*/
 464     delete mf;
 465 }
 466
 467 /* @bug 4116444
 468  * MessageFormat.parse has different behavior in case of null.
 469  */
 470 void MessageFormatRegressionTest::Test4116444()
 471 {
 472     UnicodeString patterns [] = {
 473         (UnicodeString)"",
 474         (UnicodeString)"one",
 475         (UnicodeString) "{0,date,short}"
 476     };
 477
 478     UErrorCode status = U_ZERO_ERROR;
 479     MessageFormat *mf = new MessageFormat("", status);
 480     failure(status, "new MessageFormat");
 481
 482     for (int i = 0; i < 3; i++) {
 483         UnicodeString pattern = patterns[i];
 484         mf->applyPattern(pattern, status);
 485         failure(status, "mf->applyPattern", TRUE);
 486
 487         //try {
 488         int32_t count = 0;
 489         ParsePosition pp(0);
 490         Formattable *array = mf->parse(UnicodeString(""), pp, count);
 491             logln("pattern: \"" + pattern + "\"");
 492             log(" parsedObjects: ");
 493             if (array != NULL) {
 494                 log("{");
 495                 for (int j = 0; j < count; j++) {
 496                     //if (array[j] != null)
 497                     UnicodeString dummy;
 498                     err("\"" + array[j].getString(dummy) + "\"");
 499                     //else
 500                      //   log("null");
 501                     if (j < count- 1)
 502                         log(",");
 503                 }
 504                 log("}") ;
 505                 delete[] array;
 506             } else {
 507                 log("null");
 508             }
 509             logln("");
 510         /*} catch (Exception e) {
 511             errln("pattern: \"" + pattern + "\"");
 512             errln("  Exception: " + e.getMessage());
 513         }*/
 514     }
 515
 516     delete mf;
 517 }
 518 /* @bug 4114739 (FIX and add javadoc)
 519  * MessageFormat.format has undocumented behavior about empty format objects.
 520  */
 521
 522 // {sfb} doesn't apply in C++?
 523 void MessageFormatRegressionTest::Test4114739()
 524 {
 525
 526     UErrorCode status = U_ZERO_ERROR;
 527     MessageFormat *mf = new MessageFormat("<{0}>", status);
 528     failure(status, "new MessageFormat");
 529
 530     Formattable *objs1 = NULL;
 531     //Formattable objs2 [] = {};
 532     //Formattable *objs3 [] = {NULL};
 533     //try {
 534     UnicodeString pat;
 535     UnicodeString res;
 536         logln("pattern: \"" + mf->toPattern(pat) + "\"");
 537         log("format(null) : ");
 538         FieldPosition pos(FieldPosition::DONT_CARE);
 539         logln("\"" + mf->format(objs1, 0, res, pos, status) + "\"");
 540         failure(status, "mf->format");
 541         /*log("format({})   : ");
 542         logln("\"" + mf->format(objs2, 0, res, FieldPosition(FieldPosition::DONT_CARE), status) + "\"");
 543         failure(status, "mf->format");
 544         log("format({null}) :");
 545         logln("\"" + mf->format(objs3, 0, res, FieldPosition(FieldPosition::DONT_CARE), status) + "\"");
 546         failure(status, "mf->format");*/
 547     /*} catch (Exception e) {
 548         errln("Exception thrown for null argument tests.");
 549     }*/
 550
 551     delete mf;
 552 }
 553
 554 /* @bug 4113018
 555  * MessageFormat.applyPattern works wrong with illegal patterns.
 556  */
 557 void MessageFormatRegressionTest::Test4113018()
 558 {
 559     UnicodeString originalPattern("initial pattern");
 560     UErrorCode status = U_ZERO_ERROR;
 561     MessageFormat *mf = new MessageFormat(originalPattern, status);
 562     failure(status, "new messageFormat");
 563     UnicodeString illegalPattern("format: {0, xxxYYY}");
 564     UnicodeString pat;
 565     logln("pattern before: \"" + mf->toPattern(pat) + "\"");
 566     logln("illegal pattern: \"" + illegalPattern + "\"");
 567     //try {
 568         mf->applyPattern(illegalPattern, status);
 569         if( ! U_FAILURE(status))
 570             errln("Should have thrown IllegalArgumentException for pattern : " + illegalPattern);
 571     /*} catch (IllegalArgumentException e) {
 572         if (!originalPattern.equals(mf.toPattern()))
 573             errln("pattern after: \"" + mf.toPattern() + "\"");
 574     }*/
 575     delete mf;
 576 }
 577
 578 /* @bug 4106661
 579  * ChoiceFormat is silent about the pattern usage in javadoc.
 580  */
 581 void MessageFormatRegressionTest::Test4106661()
 582 {
 583     UErrorCode status = U_ZERO_ERROR;
 584     ChoiceFormat *fmt = new ChoiceFormat(
 585       "-1#are negative| 0#are no or fraction | 1#is one |1.0<is 1+ |2#are two |2<are more than 2.", status);
 586     failure(status, "new ChoiceFormat");
 587     UnicodeString pat;
 588     logln("Formatter Pattern : " + fmt->toPattern(pat));
 589
 590     FieldPosition bogus(FieldPosition::DONT_CARE);
 591     UnicodeString str;
 592
 593     // Will this work for -inf?
 594     logln("Format with -INF : " + fmt->format(Formattable(-uprv_getInfinity()), str, bogus, status));
 595     failure(status, "fmt->format");
 596     str.remove();
 597     logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status));
 598     failure(status, "fmt->format");
 599     str.remove();
 600     logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status));
 601     failure(status, "fmt->format");
 602     str.remove();
 603     logln("Format with 0 : " + fmt->format(Formattable((int32_t)0), str, bogus, status));
 604     failure(status, "fmt->format");
 605     str.remove();
 606     logln("Format with 0.9 : " + fmt->format(Formattable(0.9), str, bogus, status));
 607     failure(status, "fmt->format");
 608     str.remove();
 609     logln("Format with 1.0 : " + fmt->format(Formattable(1.0), str, bogus, status));
 610     failure(status, "fmt->format");
 611     str.remove();
 612     logln("Format with 1.5 : " + fmt->format(Formattable(1.5), str, bogus, status));
 613     failure(status, "fmt->format");
 614     str.remove();
 615     logln("Format with 2 : " + fmt->format(Formattable((int32_t)2), str, bogus, status));
 616     failure(status, "fmt->format");
 617     str.remove();
 618     logln("Format with 2.1 : " + fmt->format(Formattable(2.1), str, bogus, status));
 619     failure(status, "fmt->format");
 620     str.remove();
 621     logln("Format with NaN : " + fmt->format(Formattable(uprv_getNaN()), str, bogus, status));
 622     failure(status, "fmt->format");
 623     str.remove();
 624     logln("Format with +INF : " + fmt->format(Formattable(uprv_getInfinity()), str, bogus, status));
 625     failure(status, "fmt->format");
 626
 627     delete fmt;
 628 }
 629
 630 /* @bug 4094906
 631  * ChoiceFormat should accept \u221E as eq. to INF.
 632  */
 633 void MessageFormatRegressionTest::Test4094906()
 634 {
 635     UErrorCode status = U_ZERO_ERROR;
 636     UnicodeString pattern("-");
 637     pattern += (UChar) 0x221E;
 638     pattern += "<are negative|0<are no or fraction|1#is one|1<is 1+|";
 639     pattern += (UChar) 0x221E;
 640     pattern += "<are many.";
 641
 642     ChoiceFormat *fmt = new ChoiceFormat(pattern, status);
 643     failure(status, "new ChoiceFormat");
 644     UnicodeString pat;
 645     if (fmt->toPattern(pat) != pattern) {
 646         errln( (UnicodeString) "Formatter Pattern : " + pat);
 647         errln( (UnicodeString) "Expected Pattern  : " + pattern);
 648     }
 649     FieldPosition bogus(FieldPosition::DONT_CARE);
 650     UnicodeString str;
 651
 652     // Will this work for -inf?
 653     logln("Format with -INF : " + fmt->format(Formattable(-uprv_getInfinity()), str, bogus, status));
 654     failure(status, "fmt->format");
 655     str.remove();
 656     logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status));
 657     failure(status, "fmt->format");
 658     str.remove();
 659     logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status));
 660     failure(status, "fmt->format");
 661     str.remove();
 662     logln("Format with 0 : " + fmt->format(Formattable((int32_t)0), str, bogus, status));
 663     failure(status, "fmt->format");
 664     str.remove();
 665     logln("Format with 0.9 : " + fmt->format(Formattable(0.9), str, bogus, status));
 666     failure(status, "fmt->format");
 667     str.remove();
 668     logln("Format with 1.0 : " + fmt->format(Formattable(1.0), str, bogus, status));
 669     failure(status, "fmt->format");
 670     str.remove();
 671     logln("Format with 1.5 : " + fmt->format(Formattable(1.5), str, bogus, status));
 672     failure(status, "fmt->format");
 673     str.remove();
 674     logln("Format with 2 : " + fmt->format(Formattable((int32_t)2), str, bogus, status));
 675     failure(status, "fmt->format");
 676     str.remove();
 677     logln("Format with 2.1 : " + fmt->format(Formattable(2.1), str, bogus, status));
 678     failure(status, "fmt->format");
 679     str.remove();
 680     logln("Format with NaN : " + fmt->format(Formattable(uprv_getNaN()), str, bogus, status));
 681     failure(status, "fmt->format");
 682     str.remove();
 683     logln("Format with +INF : " + fmt->format(Formattable(uprv_getInfinity()), str, bogus, status));
 684     failure(status, "fmt->format");
 685
 686     delete fmt;
 687 }
 688
 689 /* @bug 4118592
 690  * MessageFormat.parse fails with ChoiceFormat.
 691  */
 692 void MessageFormatRegressionTest::Test4118592()
 693 {
 694     UErrorCode status = U_ZERO_ERROR;
 695     MessageFormat *mf = new MessageFormat("", status);
 696     failure(status, "new messageFormat");
 697     UnicodeString pattern("{0,choice,1#YES|2#NO}");
 698     UnicodeString prefix("");
 699     Formattable *objs = 0;
 700
 701     for (int i = 0; i < 5; i++) {
 702         UnicodeString formatted;
 703         formatted = prefix + "YES";
 704         mf->applyPattern(prefix + pattern, status);
 705         failure(status, "mf->applyPattern");
 706         prefix += "x";
 707         //Object[] objs = mf.parse(formatted, new ParsePosition(0));
 708         int32_t count = 0;
 709         ParsePosition pp(0);
 710         objs = mf->parse(formatted, pp, count);
 711         UnicodeString pat;
 712         logln(UnicodeString("") + i + ". pattern :\"" + mf->toPattern(pat) + "\"");
 713         log(" \"" + formatted + "\" parsed as ");
 714         if (objs == NULL)
 715             logln("  null");
 716         else {
 717             UnicodeString temp;
 718             if(objs[0].getType() == Formattable::kString)
 719                 logln((UnicodeString)"  " + objs[0].getString(temp));
 720             else
 721                 logln((UnicodeString)"  " + (objs[0].getType() == Formattable::kLong ? objs[0].getLong() : objs[0].getDouble()));
 722             delete[] objs;
 723
 724         }
 725     }
 726
 727     delete mf;
 728 }
 729 /* @bug 4118594
 730  * MessageFormat.parse fails for some patterns.
 731  */
 732 void MessageFormatRegressionTest::Test4118594()
 733 {
 734     UErrorCode status = U_ZERO_ERROR;
 735     const UBool possibleDataError = TRUE;
 736     MessageFormat *mf = new MessageFormat("{0}, {0}, {0}", status);
 737     failure(status, "new MessageFormat");
 738     UnicodeString forParsing("x, y, z");
 739     //Object[] objs = mf.parse(forParsing, new ParsePosition(0));
 740     int32_t count = 0;
 741     ParsePosition pp(0);
 742     Formattable *objs = mf->parse(forParsing, pp, count);
 743     UnicodeString pat;
 744     logln("pattern: \"" + mf->toPattern(pat) + "\"");
 745     logln("text for parsing: \"" + forParsing + "\"");
 746     UnicodeString str;
 747     if (objs[0].getString(str) != "z")
 748         errln("argument0: \"" + objs[0].getString(str) + "\"");
 749     mf->applyPattern("{0,number,#.##}, {0,number,#.#}", status);
 750     failure(status, "mf->applyPattern", possibleDataError);
 751     //Object[] oldobjs = {new Double(3.1415)};
 752     Formattable oldobjs [] = {Formattable(3.1415)};
 753     UnicodeString result;
 754     FieldPosition pos(FieldPosition::DONT_CARE);
 755     result = mf->format( oldobjs, 1, result, pos, status );
 756     failure(status, "mf->format", possibleDataError);
 757     pat.remove();
 758     logln("pattern: \"" + mf->toPattern(pat) + "\"");
 759     logln("text for parsing: \"" + result + "\"");
 760     // result now equals "3.14, 3.1"
 761     if (result != "3.14, 3.1")
 762         dataerrln("result = " + result + " - " + u_errorName(status));
 763     //Object[] newobjs = mf.parse(result, new ParsePosition(0));
 764     int32_t count1 = 0;
 765     pp.setIndex(0);
 766     Formattable *newobjs = mf->parse(result, pp, count1);
 767     // newobjs now equals {new Double(3.1)}
 768     if (newobjs == NULL) {
 769         dataerrln("Error calling MessageFormat::parse");
 770     } else {
 771         if (newobjs[0].getDouble() != 3.1)
 772             errln( UnicodeString("newobjs[0] = ") + newobjs[0].getDouble());
 773     }
 774
 775     delete [] objs;
 776     delete [] newobjs;
 777     delete mf;
 778 }
 779 /* @bug 4105380
 780  * When using ChoiceFormat, MessageFormat is not good for I18n.
 781  */
 782 void MessageFormatRegressionTest::Test4105380()
 783 {
 784     UnicodeString patternText1("The disk \"{1}\" contains {0}.");
 785     UnicodeString patternText2("There are {0} on the disk \"{1}\"");
 786     UErrorCode status = U_ZERO_ERROR;
 787     const UBool possibleDataError = TRUE;
 788     MessageFormat *form1 = new MessageFormat(patternText1, status);
 789     failure(status, "new MessageFormat");
 790     MessageFormat *form2 = new MessageFormat(patternText2, status);
 791     failure(status, "new MessageFormat");
 792     double filelimits [] = {0,1,2};
 793     UnicodeString filepart [] = {
 794         (UnicodeString)"no files",
 795             (UnicodeString)"one file",
 796             (UnicodeString)"{0,number} files"
 797     };
 798     ChoiceFormat *fileform = new ChoiceFormat(filelimits, filepart, 3);
 799     form1->setFormat(1, *fileform);
 800     form2->setFormat(0, *fileform);
 801     //Object[] testArgs = {new Long(12373), "MyDisk"};
 802     Formattable testArgs [] = {
 803         Formattable((int32_t)12373),
 804             Formattable((UnicodeString)"MyDisk")
 805     };
 806
 807     FieldPosition bogus(FieldPosition::DONT_CARE);
 808
 809     UnicodeString result;
 810     logln(form1->format(testArgs, 2, result, bogus, status));
 811     failure(status, "form1->format", possibleDataError);
 812     result.remove();
 813     logln(form2->format(testArgs, 2, result, bogus, status));
 814     failure(status, "form1->format", possibleDataError);
 815
 816     delete form1;
 817     delete form2;
 818     delete fileform;
 819 }
 820 /* @bug 4120552
 821  * MessageFormat.parse incorrectly sets errorIndex.
 822  */
 823 void MessageFormatRegressionTest::Test4120552()
 824 {
 825     UErrorCode status = U_ZERO_ERROR;
 826     MessageFormat *mf = new MessageFormat("pattern", status);
 827     failure(status, "new MessageFormat");
 828     UnicodeString texts[] = {
 829         (UnicodeString)"pattern",
 830             (UnicodeString)"pat",
 831             (UnicodeString)"1234"
 832     };
 833     UnicodeString pat;
 834     logln("pattern: \"" + mf->toPattern(pat) + "\"");
 835     for (int i = 0; i < 3; i++) {
 836         ParsePosition pp(0);
 837         //Object[] objs = mf.parse(texts[i], pp);
 838         int32_t count = 0;
 839         Formattable *objs = mf->parse(texts[i], pp, count);
 840         log("  text for parsing: \"" + texts[i] + "\"");
 841         if (objs == NULL) {
 842             logln("  (incorrectly formatted string)");
 843             if (pp.getErrorIndex() == -1)
 844                 errln(UnicodeString("Incorrect error index: ") + pp.getErrorIndex());
 845         } else {
 846             logln("  (correctly formatted string)");
 847             delete[] objs;
 848         }
 849     }
 850     delete mf;
 851 }
 852
 853 /**
 854  * @bug 4142938
 855  * MessageFormat handles single quotes in pattern wrong.
 856  * This is actually a problem in ChoiceFormat; it doesn't
 857  * understand single quotes.
 858  */
 859 void MessageFormatRegressionTest::Test4142938()
 860 {
 861     UnicodeString pat = CharsToUnicodeString("''Vous'' {0,choice,0#n''|1#}avez s\\u00E9lectionn\\u00E9 "
 862         "{0,choice,0#aucun|1#{0}} client{0,choice,0#s|1#|2#s} "
 863         "personnel{0,choice,0#s|1#|2#s}.");
 864     UErrorCode status = U_ZERO_ERROR;
 865     MessageFormat *mf = new MessageFormat(pat, status);
 866     failure(status, "new MessageFormat");
 867
 868     UnicodeString PREFIX [] = {
 869         CharsToUnicodeString("'Vous' n'avez s\\u00E9lectionn\\u00E9 aucun clients personnels."),
 870         CharsToUnicodeString("'Vous' avez s\\u00E9lectionn\\u00E9 "),
 871         CharsToUnicodeString("'Vous' avez s\\u00E9lectionn\\u00E9 ")
 872     };
 873     UnicodeString SUFFIX [] = {
 874         UnicodeString(),
 875         UNICODE_STRING(" client personnel.", 18),
 876         UNICODE_STRING(" clients personnels.", 20)
 877     };
 878
 879     for (int i=0; i<3; i++) {
 880         UnicodeString out;
 881         //out = mf->format(new Object[]{new Integer(i)});
 882         Formattable objs [] = {
 883             Formattable((int32_t)i)
 884         };
 885         FieldPosition pos(FieldPosition::DONT_CARE);
 886         out = mf->format(objs, 1, out, pos, status);
 887         if (!failure(status, "mf->format", TRUE)) {
 888             if (SUFFIX[i] == "") {
 889                 if (out != PREFIX[i])
 890                     errln((UnicodeString)"" + i + ": Got \"" + out + "\"; Want \"" + PREFIX[i] + "\"");
 891             }
 892             else {
 893                 if (!out.startsWith(PREFIX[i]) ||
 894                     !out.endsWith(SUFFIX[i]))
 895                     errln((UnicodeString)"" + i + ": Got \"" + out + "\"; Want \"" + PREFIX[i] + "\"...\"" +
 896                           SUFFIX[i] + "\"");
 897             }
 898         }
 899     }
 900
 901     delete mf;
 902 }
 903
 904 /**
 905  * @bug 4142938
 906  * Test the applyPattern and toPattern handling of single quotes
 907  * by ChoiceFormat.  (This is in here because this was a bug reported
 908  * against MessageFormat.)  The single quote is used to quote the
 909  * pattern characters '|', '#', '<', and '\u2264'.  Two quotes in a row
 910  * is a quote literal.
 911  */
 912 void MessageFormatRegressionTest::TestChoicePatternQuote()
 913 {
 914     UnicodeString DATA [] = {
 915         // Pattern                  0 value           1 value
 916         // {sfb} hacked - changed \u2264 to = (copied from Character Map)
 917         (UnicodeString)"0#can''t|1#can",           (UnicodeString)"can't",          (UnicodeString)"can",
 918         (UnicodeString)"0#'pound(#)=''#'''|1#xyz", (UnicodeString)"pound(#)='#'",   (UnicodeString)"xyz",
 919         (UnicodeString)"0#'1<2 | 1=1'|1#''",  (UnicodeString)"1<2 | 1=1", (UnicodeString)"'",
 920     };
 921     for (int i=0; i<9; i+=3) {
 922         //try {
 923             UErrorCode status = U_ZERO_ERROR;
 924             ChoiceFormat *cf = new ChoiceFormat(DATA[i], status);
 925             failure(status, "new ChoiceFormat");
 926             for (int j=0; j<=1; ++j) {
 927                 UnicodeString out;
 928                 FieldPosition pos(FieldPosition::DONT_CARE);
 929                 out = cf->format((double)j, out, pos);
 930                 if (out != DATA[i+1+j])
 931                     errln("Fail: Pattern \"" + DATA[i] + "\" x "+j+" -> " +
 932                           out + "; want \"" + DATA[i+1+j] + '"');
 933             }
 934             UnicodeString pat;
 935             pat = cf->toPattern(pat);
 936             UnicodeString pat2;
 937             ChoiceFormat *cf2 = new ChoiceFormat(pat, status);
 938             pat2 = cf2->toPattern(pat2);
 939             if (pat != pat2)
 940                 errln("Fail: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
 941             else
 942                 logln("Ok: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
 943         /*}
 944         catch (IllegalArgumentException e) {
 945             errln("Fail: Pattern \"" + DATA[i] + "\" -> " + e);
 946         }*/
 947
 948         delete cf;
 949         delete cf2;
 950     }
 951 }
 952
 953 /**
 954  * @bug 4112104
 955  * MessageFormat.equals(null) throws a NullPointerException.  The JLS states
 956  * that it should return false.
 957  */
 958 void MessageFormatRegressionTest::Test4112104()
 959 {
 960     UErrorCode status = U_ZERO_ERROR;
 961     MessageFormat *format = new MessageFormat("", status);
 962     failure(status, "new MessageFormat");
 963     //try {
 964         // This should NOT throw an exception
 965         if (format == NULL) {
 966             // It also should return false
 967             errln("MessageFormat.equals(null) returns false");
 968         }
 969     /*}
 970     catch (NullPointerException e) {
 971         errln("MessageFormat.equals(null) throws " + e);
 972     }*/
 973     delete format;
 974 }
 975
 976 void MessageFormatRegressionTest::TestAPI() {
 977     UErrorCode status = U_ZERO_ERROR;
 978     MessageFormat *format = new MessageFormat("", status);
 979     failure(status, "new MessageFormat");
 980
 981     // Test adoptFormat
 982     MessageFormat *fmt = new MessageFormat("",status);
 983     format->adoptFormat("",fmt,status);
 984     failure(status, "adoptFormat");
 985
 986     // Test getFormat
 987     format->setFormat((int32_t)0,*fmt);
 988     format->getFormat("",status);
 989     failure(status, "getFormat");
 990     delete format;
 991 }
 992
 993 #endif /* #if !UCONFIG_NO_FORMATTING */