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
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)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
failure(UErrorCode status,const char * msg,UBool possibleDataError)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 */
Test4074764()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 */
Test4031438()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
Test4052223()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
Test4104976()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
Test4106659()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 */
Test4106660()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
Test4111739()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 */
Test4114743()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 */
Test4116444()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++?
Test4114739()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 */
Test4113018()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 */
Test4106661()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 */
Test4094906()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 */
Test4118592()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 */
Test4118594()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 */
Test4105380()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 */
Test4120552()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 */
Test4142938()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 */
TestChoicePatternQuote()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 */
Test4112104()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
TestAPI()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