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