• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /********************************************************************
3  * COPYRIGHT:
4  * Copyright (c) 1997-2011, International Business Machines Corporation and
5  * others. All Rights Reserved.
6  ********************************************************************/
7 
8 #include "unicode/utypes.h"
9 
10 #if !UCONFIG_NO_FORMATTING
11 
12 #include "intltest.h"
13 #include "tchcfmt.h"
14 #include "cmemory.h"
15 #include "unicode/msgfmt.h"
16 #include "unicode/choicfmt.h"
17 
18 #include <float.h>
19 
20 // tests have obvious memory leaks!
21 
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)22 void TestChoiceFormat::runIndexedTest(int32_t index, UBool exec,
23                                       const char* &name, char* /*par*/) {
24     switch (index) {
25         TESTCASE(0,TestSimpleExample);
26         TESTCASE(1,TestComplexExample);
27         TESTCASE(2,TestClosures);
28         TESTCASE(3,TestPatterns);
29         TESTCASE(4,TestChoiceFormatToPatternOverflow);
30         default: name = ""; break;
31     }
32 }
33 
chkstatus(UErrorCode & status,const char * msg=NULL)34 static UBool chkstatus( UErrorCode &status, const char* msg = NULL )
35 {
36     UBool ok = U_SUCCESS(status);
37     if (!ok) it_errln( msg );
38     return ok;
39 }
40 
41 void
TestSimpleExample(void)42 TestChoiceFormat::TestSimpleExample( void )
43 {
44     double limits[] = {1,2,3,4,5,6,7};
45     UnicodeString monthNames[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
46     ChoiceFormat* form = new ChoiceFormat(limits, monthNames, 7);
47     ParsePosition parse_pos;
48     // TODO Fix this ParsePosition stuff...
49     UnicodeString str;
50     UnicodeString res1, res2;
51     UErrorCode status;
52     FieldPosition fpos(0);
53     Formattable f;
54     int32_t ix;
55     //for (double i = 0.0; i <= 8.0; ++i) {
56     for (ix = 0; ix <= 8; ++ix) {
57         double i = ix; //nos
58         status = U_ZERO_ERROR;
59         fpos = 0;
60         str = "";
61         res1 = form->format(i, str, fpos, status );
62         if (!chkstatus( status, "***  test_simple_example format" )) {
63             delete form;
64             return;
65         }
66         //form->parse(res1, f, parse_pos);
67         res2 = " ??? ";
68         it_logln(UnicodeString("") + ix + UnicodeString(" -> ") + res1 + UnicodeString(" -> ") + res2);
69     }
70     //Testing ==operator
71     const double filelimits[] = {0,1,2};
72     const UnicodeString filepart[] = {"are no files","is one file","are {2} files"};
73     ChoiceFormat* formnew=new ChoiceFormat(filelimits, filepart, 3);
74     ChoiceFormat* formequal=new ChoiceFormat(limits, monthNames, 7);
75     if(*formnew == *form){
76         errln("ERROR: ==operator failed\n");
77     }
78     if(!(*form == *formequal)){
79         errln("ERROR: ==operator failed\n");
80     }
81     delete formequal;
82     delete formnew;
83 
84     //Testing getLimits()
85     int32_t count=0;
86     const double *gotLimits=form->getLimits(count);
87 #if 1  // ICU 4.8 deprecates and disables the ChoiceFormat getters.
88     if(count != 0 || gotLimits != NULL) {
89         errln("getLimits() returns something, should be disabled");
90     }
91     const UnicodeString *gotFormats=form->getFormats(count);
92     if(count != 0 || gotFormats != NULL) {
93         errln("getFormats() returns something, should be disabled");
94     }
95     const UBool *gotClosures=form->getClosures(count);
96     if(count != 0 || gotClosures != NULL) {
97         errln("getClosures() returns something, should be disabled");
98     }
99 #else
100     if(count != 7){
101         errln("getLimits didn't update the count correctly\n");
102     }
103     for(ix=0; ix<count; ix++){
104         if(gotLimits[ix] != limits[ix]){
105             errln((UnicodeString)"getLimits didn't get the limits correctly.  Expected " + limits[ix] + " Got " + gotLimits[ix]);
106         }
107     }
108     //Testing getFormats()
109     count=0;
110     const UnicodeString *gotFormats=form->getFormats(count);
111     if(count != 7){
112         errln("getFormats didn't update the count correctly\n");
113     }
114     for(ix=0; ix<count; ix++){
115         if(gotFormats[ix] != monthNames[ix]){
116             errln((UnicodeString)"getFormats didn't get the Formats correctly.  Expected " + monthNames[ix] + " Got " + gotFormats[ix]);
117         }
118     }
119 #endif
120 
121     delete form;
122 }
123 
124 void
TestComplexExample(void)125 TestChoiceFormat::TestComplexExample( void )
126 {
127     UErrorCode status = U_ZERO_ERROR;
128     const double filelimits[] = {-1, 0,1,2};
129     const UnicodeString filepart[] = {"are corrupted files", "are no files","is one file","are {2} files"};
130 
131     ChoiceFormat* fileform = new ChoiceFormat( filelimits, filepart, 4);
132 
133     if (!fileform) {
134         it_errln("***  test_complex_example fileform");
135         return;
136     }
137 
138     Format* filenumform = NumberFormat::createInstance( status );
139     if (!filenumform) {
140         dataerrln((UnicodeString)"***  test_complex_example filenumform - " + u_errorName(status));
141         delete fileform;
142         return;
143     }
144     if (!chkstatus( status, "***  test_simple_example filenumform" )) {
145         delete fileform;
146         delete filenumform;
147         return;
148     }
149 
150     //const Format* testFormats[] = { fileform, NULL, filenumform };
151     //pattform->setFormats( testFormats, 3 );
152 
153     MessageFormat* pattform = new MessageFormat("There {0} on {1}", status );
154     if (!pattform) {
155         it_errln("***  test_complex_example pattform");
156         delete fileform;
157         delete filenumform;
158         return;
159     }
160     if (!chkstatus( status, "***  test_complex_example pattform" )) {
161         delete fileform;
162         delete filenumform;
163         delete pattform;
164         return;
165     }
166 
167     pattform->setFormat( 0, *fileform );
168     pattform->setFormat( 2, *filenumform );
169 
170 
171     Formattable testArgs[] = {(int32_t)0, "Disk_A", (int32_t)0};
172     UnicodeString str;
173     UnicodeString res1, res2;
174     pattform->toPattern( res1 );
175     it_logln("MessageFormat toPattern: " + res1);
176     fileform->toPattern( res1 );
177     it_logln("ChoiceFormat toPattern: " + res1);
178     if (res1 == "-1#are corrupted files|0#are no files|1#is one file|2#are {2} files") {
179         it_logln("toPattern tested!");
180     }else{
181         it_errln("***  ChoiceFormat to Pattern result!");
182     }
183 
184     FieldPosition fpos(0);
185 
186     UnicodeString checkstr[] = {
187         "There are corrupted files on Disk_A",
188         "There are no files on Disk_A",
189         "There is one file on Disk_A",
190         "There are 2 files on Disk_A",
191         "There are 3 files on Disk_A"
192     };
193 
194     // if (status != U_ZERO_ERROR) return; // TODO: analyze why we have such a bad bail out here!
195 
196     if (U_FAILURE(status)) {
197         delete fileform;
198         delete filenumform;
199         delete pattform;
200         return;
201     }
202 
203 
204     int32_t i;
205     int32_t start = -1;
206     for (i = start; i < 4; ++i) {
207         str = "";
208         status = U_ZERO_ERROR;
209         testArgs[0] = Formattable((int32_t)i);
210         testArgs[2] = testArgs[0];
211         res2 = pattform->format(testArgs, 3, str, fpos, status );
212         if (!chkstatus( status, "***  test_complex_example format" )) {
213             delete fileform;
214             delete filenumform;
215             delete pattform;
216             return;
217         }
218         it_logln(i + UnicodeString(" -> ") + res2);
219         if (res2 != checkstr[i - start]) {
220             it_errln("***  test_complex_example res string");
221             it_errln(UnicodeString("*** ") + i + UnicodeString(" -> '") + res2 + UnicodeString("' unlike '") + checkstr[i] + UnicodeString("' ! "));
222         }
223     }
224     it_logln();
225 
226     it_logln("------ additional testing in complex test ------");
227     it_logln();
228     //
229 #if 0  // ICU 4.8 deprecates and disables the ChoiceFormat getters.
230     int32_t retCount;
231     const double* retLimits = fileform->getLimits( retCount );
232     if ((retCount == 4) && (retLimits)
233     && (retLimits[0] == -1.0)
234     && (retLimits[1] == 0.0)
235     && (retLimits[2] == 1.0)
236     && (retLimits[3] == 2.0)) {
237         it_logln("getLimits tested!");
238     }else{
239         it_errln("***  getLimits unexpected result!");
240     }
241 
242     const UnicodeString* retFormats = fileform->getFormats( retCount );
243     if ((retCount == 4) && (retFormats)
244     && (retFormats[0] == "are corrupted files")
245     && (retFormats[1] == "are no files")
246     && (retFormats[2] == "is one file")
247     && (retFormats[3] == "are {2} files")) {
248         it_logln("getFormats tested!");
249     }else{
250         it_errln("***  getFormats unexpected result!");
251     }
252 #endif
253 
254     UnicodeString checkstr2[] = {
255         "There is no folder on Disk_A",
256         "There is one folder on Disk_A",
257         "There are many folders on Disk_A",
258         "There are many folders on Disk_A"
259     };
260 
261     fileform->applyPattern("0#is no folder|1#is one folder|2#are many folders", status );
262     if (status == U_ZERO_ERROR)
263         it_logln("status applyPattern OK!");
264     if (!chkstatus( status, "***  test_complex_example pattform" )) {
265         delete fileform;
266         delete filenumform;
267         delete pattform;
268         return;
269     }
270     pattform->setFormat( 0, *fileform );
271     fpos = 0;
272     for (i = 0; i < 4; ++i) {
273         str = "";
274         status = U_ZERO_ERROR;
275         testArgs[0] = Formattable((int32_t)i);
276         testArgs[2] = testArgs[0];
277         res2 = pattform->format(testArgs, 3, str, fpos, status );
278         if (!chkstatus( status, "***  test_complex_example format 2" )) {
279             delete fileform;
280             delete filenumform;
281             delete pattform;
282             return;
283         }
284         it_logln(UnicodeString() + i + UnicodeString(" -> ") + res2);
285         if (res2 != checkstr2[i]) {
286             it_errln("***  test_complex_example res string");
287             it_errln(UnicodeString("*** ") + i + UnicodeString(" -> '") + res2 + UnicodeString("' unlike '") + checkstr2[i] + UnicodeString("' ! "));
288         }
289     }
290 
291     const double limits_A[] = {1,2,3,4,5,6,7};
292     const UnicodeString monthNames_A[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
293     ChoiceFormat* form_A = new ChoiceFormat(limits_A, monthNames_A, 7);
294     ChoiceFormat* form_A2 = new ChoiceFormat(limits_A, monthNames_A, 7);
295     const double limits_B[] = {1,2,3,4,5,6,7};
296     const UnicodeString monthNames_B[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat_BBB"};
297     ChoiceFormat* form_B = new ChoiceFormat(limits_B, monthNames_B, 7);
298     if (!form_A || !form_B || !form_A2) {
299         it_errln("***  test-choiceFormat not allocatable!");
300     }else{
301         if (*form_A == *form_A2) {
302             it_logln("operator== tested.");
303         }else{
304             it_errln("***  operator==");
305         }
306 
307         if (*form_A != *form_B) {
308             it_logln("operator!= tested.");
309         }else{
310             it_errln("***  operator!=");
311         }
312 
313         ChoiceFormat* form_A3 = (ChoiceFormat*) form_A->clone();
314         if (!form_A3) {
315             it_errln("***  ChoiceFormat->clone is nil.");
316         }else{
317             if ((*form_A3 == *form_A) && (*form_A3 != *form_B)) {
318                 it_logln("method clone tested.");
319             }else{
320                 it_errln("***  ChoiceFormat clone or operator==, or operator!= .");
321             }
322         }
323 
324         ChoiceFormat form_Assigned( *form_A );
325         UBool ok = (form_Assigned == *form_A) && (form_Assigned != *form_B);
326         form_Assigned = *form_B;
327         ok = ok && (form_Assigned != *form_A) && (form_Assigned == *form_B);
328         if (ok) {
329             it_logln("copy constructor and operator= tested.");
330         }else{
331             it_errln("***  copy constructor or operator= or operator == or operator != .");
332         }
333         delete form_A3;
334     }
335 
336 
337     delete form_A; delete form_A2; delete form_B;
338 
339     const char* testPattern = "0#none|1#one|2#many";
340     ChoiceFormat form_pat( testPattern, status );
341     if (!chkstatus( status, "***  ChoiceFormat contructor( newPattern, status)" )) {
342         delete fileform;
343         delete filenumform;
344         delete pattform;
345         return;
346     }
347 
348     form_pat.toPattern( res1 );
349     if (res1 == "0#none|1#one|2#many") {
350         it_logln("ChoiceFormat contructor( newPattern, status) tested");
351     }else{
352         it_errln("***  ChoiceFormat contructor( newPattern, status) or toPattern result!");
353     }
354 
355     double d_a2[] = { 3.0, 4.0 };
356     UnicodeString s_a2[] = { "third", "forth" };
357 
358     form_pat.setChoices( d_a2, s_a2, 2 );
359     form_pat.toPattern( res1 );
360     it_logln(UnicodeString("ChoiceFormat adoptChoices toPattern: ") + res1);
361     if (res1 == "3#third|4#forth") {
362         it_logln("ChoiceFormat adoptChoices tested");
363     }else{
364         it_errln("***  ChoiceFormat adoptChoices result!");
365     }
366 
367     str = "";
368     fpos = 0;
369     status = U_ZERO_ERROR;
370     double arg_double = 3.0;
371     res1 = form_pat.format( arg_double, str, fpos );
372     it_logln(UnicodeString("ChoiceFormat format:") + res1);
373     if (res1 != "third") it_errln("***  ChoiceFormat format (double, ...) result!");
374 
375     str = "";
376     fpos = 0;
377     status = U_ZERO_ERROR;
378     int64_t arg_64 = 3;
379     res1 = form_pat.format( arg_64, str, fpos );
380     it_logln(UnicodeString("ChoiceFormat format:") + res1);
381     if (res1 != "third") it_errln("***  ChoiceFormat format (int64_t, ...) result!");
382 
383     str = "";
384     fpos = 0;
385     status = U_ZERO_ERROR;
386     int32_t arg_long = 3;
387     res1 = form_pat.format( arg_long, str, fpos );
388     it_logln(UnicodeString("ChoiceFormat format:") + res1);
389     if (res1 != "third") it_errln("***  ChoiceFormat format (int32_t, ...) result!");
390 
391     Formattable ft( (int32_t)3 );
392     str = "";
393     fpos = 0;
394     status = U_ZERO_ERROR;
395     res1 = form_pat.format( ft, str, fpos, status );
396     if (!chkstatus( status, "***  test_complex_example format (int32_t, ...)" )) {
397         delete fileform;
398         delete filenumform;
399         delete pattform;
400         return;
401     }
402     it_logln(UnicodeString("ChoiceFormat format:") + res1);
403     if (res1 != "third") it_errln("***  ChoiceFormat format (Formattable, ...) result!");
404 
405     Formattable fta[] = { (int32_t)3 };
406     str = "";
407     fpos = 0;
408     status = U_ZERO_ERROR;
409     res1 = form_pat.format( fta, 1, str, fpos, status );
410     if (!chkstatus( status, "***  test_complex_example format (int32_t, ...)" )) {
411         delete fileform;
412         delete filenumform;
413         delete pattform;
414         return;
415     }
416     it_logln(UnicodeString("ChoiceFormat format:") + res1);
417     if (res1 != "third") it_errln("***  ChoiceFormat format (Formattable[], cnt, ...) result!");
418 
419     ParsePosition parse_pos = 0;
420     Formattable result;
421     UnicodeString parsetext("third");
422     form_pat.parse( parsetext, result, parse_pos );
423     double rd = (result.getType() == Formattable::kLong) ? result.getLong() : result.getDouble();
424     if (rd == 3.0) {
425         it_logln("parse( ..., ParsePos ) tested.");
426     }else{
427         it_errln("*** ChoiceFormat parse( ..., ParsePos )!");
428     }
429 
430     form_pat.parse( parsetext, result, status );
431     rd = (result.getType() == Formattable::kLong) ? result.getLong() : result.getDouble();
432     if (rd == 3.0) {
433         it_logln("parse( ..., UErrorCode ) tested.");
434     }else{
435         it_errln("*** ChoiceFormat parse( ..., UErrorCode )!");
436     }
437 
438     /*
439     UClassID classID = ChoiceFormat::getStaticClassID();
440     if (classID == form_pat.getDynamicClassID()) {
441         it_out << "getStaticClassID and getDynamicClassID tested." << endl;
442     }else{
443         it_errln("*** getStaticClassID and getDynamicClassID!");
444     }
445     */
446 
447     it_logln();
448 
449     delete fileform;
450     delete filenumform;
451     delete pattform;
452 }
453 
454 
455 /**
456  * Test new closure API
457  */
TestClosures(void)458 void TestChoiceFormat::TestClosures(void) {
459     // Construct open, half-open, half-open (the other way), and closed
460     // intervals.  Do this both using arrays and using a pattern.
461 
462     // 'fmt1' is created using arrays
463     UBool T = TRUE, F = FALSE;
464     // 0:   ,1)
465     // 1: [1,2]
466     // 2: (2,3]
467     // 3: (3,4)
468     // 4: [4,5)
469     // 5: [5,
470     double limits[]  = { 0, 1, 2, 3, 4, 5 };
471     UBool closures[] = { F, F, T, T, F, F };
472     UnicodeString fmts[] = {
473         ",1)", "[1,2]", "(2,3]", "(3,4)", "[4,5)", "[5,"
474     };
475     ChoiceFormat fmt1(limits, closures, fmts, 6);
476 
477     // 'fmt2' is created using a pattern; it should be equivalent
478     UErrorCode status = U_ZERO_ERROR;
479     const char* PAT = "0#,1)|1#[1,2]|2<(2,3]|3<(3,4)|4#[4,5)|5#[5,";
480     ChoiceFormat fmt2(PAT, status);
481     if (U_FAILURE(status)) {
482         errln("FAIL: ChoiceFormat constructor failed");
483         return;
484     }
485 
486     // Check the patterns
487     UnicodeString str;
488     fmt1.toPattern(str);
489     if (str == PAT) {
490         logln("Ok: " + str);
491     } else {
492         errln("FAIL: " + str + ", expected " + PAT);
493     }
494     str.truncate(0);
495 
496     // Check equality
497     if (fmt1 != fmt2) {
498         errln("FAIL: fmt1 != fmt2");
499     }
500 
501 #if 0  // ICU 4.8 deprecates and disables the ChoiceFormat getters.
502     int32_t i;
503     int32_t count2 = 0;
504     const double *limits2 = fmt2.getLimits(count2);
505     const UBool *closures2 = fmt2.getClosures(count2);
506 
507     if((count2 != 6) || !limits2 || !closures2) {
508         errln("FAIL: couldn't get limits or closures");
509     } else {
510         for(i=0;i<count2;i++) {
511           logln("#%d/%d: limit %g closed %s\n",
512                 i, count2,
513                 limits2[i],
514                 closures2[i] ?"T":"F");
515           if(limits2[i] != limits[i]) {
516             errln("FAIL: limit #%d = %g, should be %g\n", i, limits2[i], limits[i]);
517           }
518           if((closures2[i]!=0) != (closures[i]!=0)) {
519             errln("FAIL: closure #%d = %s, should be %s\n", i, closures2[i]?"T":"F", closures[i]?"T":"F");
520           }
521         }
522     }
523 #endif
524 
525     // Now test both format objects
526     UnicodeString exp[] = {
527         /*-0.5 => */ ",1)",
528         /* 0.0 => */ ",1)",
529         /* 0.5 => */ ",1)",
530         /* 1.0 => */ "[1,2]",
531         /* 1.5 => */ "[1,2]",
532         /* 2.0 => */ "[1,2]",
533         /* 2.5 => */ "(2,3]",
534         /* 3.0 => */ "(2,3]",
535         /* 3.5 => */ "(3,4)",
536         /* 4.0 => */ "[4,5)",
537         /* 4.5 => */ "[4,5)",
538         /* 5.0 => */ "[5,",
539         /* 5.5 => */ "[5,"
540     };
541 
542     // Each format object should behave exactly the same
543     ChoiceFormat* FMT[] = { &fmt1, &fmt2 };
544     for (int32_t pass=0; pass<2; ++pass) {
545         int32_t j=0;
546         for (int32_t ix=-5; ix<=55; ix+=5) {
547             double x = ix / 10.0; // -0.5 to 5.5 step +0.5
548             FMT[pass]->format(x, str);
549             if (str == exp[j]) {
550                 logln((UnicodeString)"Ok: " + x + " => " + str);
551             } else {
552                 errln((UnicodeString)"FAIL: " + x + " => " + str +
553                       ", expected " + exp[j]);
554             }
555             str.truncate(0);
556             ++j;
557         }
558     }
559 }
560 
561 /**
562  * Helper for TestPatterns()
563  */
_testPattern(const char * pattern,UBool isValid,double v1,const char * str1,double v2,const char * str2,double v3,const char * str3)564 void TestChoiceFormat::_testPattern(const char* pattern,
565                                     UBool isValid,
566                                     double v1, const char* str1,
567                                     double v2, const char* str2,
568                                     double v3, const char* str3) {
569     UErrorCode ec = U_ZERO_ERROR;
570     ChoiceFormat fmt(pattern, ec);
571     if (!isValid) {
572         if (U_FAILURE(ec)) {
573             logln((UnicodeString)"Ok: " + pattern + " failed");
574         } else {
575             logln((UnicodeString)"FAIL: " + pattern + " accepted");
576         }
577         return;
578     }
579     if (U_FAILURE(ec)) {
580         errln((UnicodeString)"FAIL: ChoiceFormat(" + pattern + ") failed");
581         return;
582     } else {
583         logln((UnicodeString)"Ok: Pattern: " + pattern);
584     }
585     UnicodeString out;
586     logln((UnicodeString)"  toPattern: " + fmt.toPattern(out));
587 
588     double v[] = {v1, v2, v3};
589     const char* str[] = {str1, str2, str3};
590     for (int32_t i=0; i<3; ++i) {
591         out.truncate(0);
592         fmt.format(v[i], out);
593         if (out == str[i]) {
594             logln((UnicodeString)"Ok: " + v[i] + " => " + out);
595         } else {
596             errln((UnicodeString)"FAIL: " + v[i] + " => " + out +
597                   ", expected " + str[i]);
598         }
599     }
600 }
601 
602 /**
603  * Test applyPattern
604  */
TestPatterns(void)605 void TestChoiceFormat::TestPatterns(void) {
606     // Try a pattern that isolates a single value.  Create
607     // three ranges: [-Inf,1.0) [1.0,1.0] (1.0,+Inf]
608     _testPattern("0.0#a|1.0#b|1.0<c", TRUE,
609                  1.0 - 1e-9, "a",
610                  1.0, "b",
611                  1.0 + 1e-9, "c");
612 
613 #if 0  // ICU 4.8 only checks the pattern syntax, not whether the ranges make sense.
614     // Try an invalid pattern that isolates a single value.
615     // [-Inf,1.0) [1.0,1.0) [1.0,+Inf]
616     _testPattern("0.0#a|1.0#b|1.0#c", FALSE,
617                  0, 0, 0, 0, 0, 0);
618 
619     // Another
620     // [-Inf,1.0] (1.0,1.0) [1.0,+Inf]
621     _testPattern("0.0#a|1.0<b|1.0#c", FALSE,
622                  0, 0, 0, 0, 0, 0);
623     // Another
624     // [-Inf,1.0] (1.0,1.0] (1.0,+Inf]
625     _testPattern("0.0#a|1.0<b|1.0<c", FALSE,
626                  0, 0, 0, 0, 0, 0);
627 
628     // Try a grossly invalid pattern.
629     // [-Inf,2.0) [2.0,1.0) [1.0,+Inf]
630     _testPattern("0.0#a|2.0#b|1.0#c", FALSE,
631                  0, 0, 0, 0, 0, 0);
632 #endif
633 }
634 
TestChoiceFormatToPatternOverflow()635 void TestChoiceFormat::TestChoiceFormatToPatternOverflow()
636 {
637     static const double limits[] = {0.1e-78, 1e13, 0.1e78};
638     UnicodeString monthNames[] = { "one", "two", "three" };
639     ChoiceFormat fmt(limits, monthNames, sizeof(limits)/sizeof(limits[0]));
640     UnicodeString patStr, expectedPattern1("1e-79#one|10000000000000#two|1e+77#three"),
641         expectedPattern2("1e-079#one|10000000000000#two|1e+077#three");
642     fmt.toPattern(patStr);
643     if (patStr != expectedPattern1 && patStr != expectedPattern2) {
644         errln("ChoiceFormat returned \"" + patStr + "\" instead of \"" + expectedPattern1 + " or " + expectedPattern2 + "\"");
645     }
646 }
647 
648 #endif /* #if !UCONFIG_NO_FORMATTING */
649