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
31void
32MessageFormatRegressionTest::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
60UBool
61MessageFormatRegressionTest::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 */
79void 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/*
158void 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 */
178void 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
281void 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
333void 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
361void 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 */
389void 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
414void 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 */
454void 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 */
475void 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++?
528void 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 */
562void 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 */
586void 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 */
638void 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 */
697void 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 */
737void 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 */
787void 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 */
828void 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 */
864void 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 */
917void 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 */
972void 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
990void 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