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