| OLD | NEW |
|---|
| (Empty) | |
| 1 /******************************************************************** |
| 2 * COPYRIGHT: |
| 3 * Copyright (c) 1997-2010, International Business Machines Corporation and |
| 4 * others. All Rights Reserved. |
| 5 ******************************************************************** |
| 6 * File TMSGFMT.CPP |
| 7 * |
| 8 * Modification History: |
| 9 * |
| 10 * Date Name Description |
| 11 * 03/24/97 helena Converted from Java. |
| 12 * 07/11/97 helena Updated to work on AIX. |
| 13 * 08/04/97 jfitz Updated to intltest |
| 14 *******************************************************************/ |
| 15 |
| 16 #include "unicode/utypes.h" |
| 17 |
| 18 #if !UCONFIG_NO_FORMATTING |
| 19 |
| 20 #include "tmsgfmt.h" |
| 21 |
| 22 #include "unicode/format.h" |
| 23 #include "unicode/decimfmt.h" |
| 24 #include "unicode/locid.h" |
| 25 #include "unicode/msgfmt.h" |
| 26 #include "unicode/numfmt.h" |
| 27 #include "unicode/choicfmt.h" |
| 28 #include "unicode/selfmt.h" |
| 29 #include "unicode/gregocal.h" |
| 30 #include <stdio.h> |
| 31 |
| 32 #define E_WITH_ACUTE ((char)0x00E9) |
| 33 static const char E_ACCENTED[]={E_WITH_ACUTE,0}; |
| 34 |
| 35 void |
| 36 TestMessageFormat::runIndexedTest(int32_t index, UBool exec, |
| 37 const char* &name, char* /*par*/) { |
| 38 switch (index) { |
| 39 TESTCASE(0,testBug1); |
| 40 TESTCASE(1,testBug2); |
| 41 TESTCASE(2,sample); |
| 42 TESTCASE(3,PatternTest); |
| 43 TESTCASE(4,testStaticFormat); |
| 44 TESTCASE(5,testSimpleFormat); |
| 45 TESTCASE(6,testMsgFormatChoice); |
| 46 TESTCASE(7,testCopyConstructor); |
| 47 TESTCASE(8,testAssignment); |
| 48 TESTCASE(9,testClone); |
| 49 TESTCASE(10,testEquals); |
| 50 TESTCASE(11,testNotEquals); |
| 51 TESTCASE(12,testSetLocale); |
| 52 TESTCASE(13,testFormat); |
| 53 TESTCASE(14,testParse); |
| 54 TESTCASE(15,testAdopt); |
| 55 TESTCASE(16,testCopyConstructor2); |
| 56 TESTCASE(17,TestUnlimitedArgsAndSubformats); |
| 57 TESTCASE(18,TestRBNF); |
| 58 TESTCASE(19,TestTurkishCasing); |
| 59 TESTCASE(20,testAutoQuoteApostrophe); |
| 60 TESTCASE(21,testMsgFormatPlural); |
| 61 TESTCASE(22,testCoverage); |
| 62 TESTCASE(23,testMsgFormatSelect); |
| 63 default: name = ""; break; |
| 64 } |
| 65 } |
| 66 |
| 67 void TestMessageFormat::testBug3() |
| 68 { |
| 69 double myNumber = -123456; |
| 70 DecimalFormat *form = 0; |
| 71 Locale locale[] = { |
| 72 Locale("ar", "", ""), |
| 73 Locale("be", "", ""), |
| 74 Locale("bg", "", ""), |
| 75 Locale("ca", "", ""), |
| 76 Locale("cs", "", ""), |
| 77 Locale("da", "", ""), |
| 78 Locale("de", "", ""), |
| 79 Locale("de", "AT", ""), |
| 80 Locale("de", "CH", ""), |
| 81 Locale("el", "", ""), // 10 |
| 82 Locale("en", "CA", ""), |
| 83 Locale("en", "GB", ""), |
| 84 Locale("en", "IE", ""), |
| 85 Locale("en", "US", ""), |
| 86 Locale("es", "", ""), |
| 87 Locale("et", "", ""), |
| 88 Locale("fi", "", ""), |
| 89 Locale("fr", "", ""), |
| 90 Locale("fr", "BE", ""), |
| 91 Locale("fr", "CA", ""), // 20 |
| 92 Locale("fr", "CH", ""), |
| 93 Locale("he", "", ""), |
| 94 Locale("hr", "", ""), |
| 95 Locale("hu", "", ""), |
| 96 Locale("is", "", ""), |
| 97 Locale("it", "", ""), |
| 98 Locale("it", "CH", ""), |
| 99 Locale("ja", "", ""), |
| 100 Locale("ko", "", ""), |
| 101 Locale("lt", "", ""), // 30 |
| 102 Locale("lv", "", ""), |
| 103 Locale("mk", "", ""), |
| 104 Locale("nl", "", ""), |
| 105 Locale("nl", "BE", ""), |
| 106 Locale("no", "", ""), |
| 107 Locale("pl", "", ""), |
| 108 Locale("pt", "", ""), |
| 109 Locale("ro", "", ""), |
| 110 Locale("ru", "", ""), |
| 111 Locale("sh", "", ""), // 40 |
| 112 Locale("sk", "", ""), |
| 113 Locale("sl", "", ""), |
| 114 Locale("sq", "", ""), |
| 115 Locale("sr", "", ""), |
| 116 Locale("sv", "", ""), |
| 117 Locale("tr", "", ""), |
| 118 Locale("uk", "", ""), |
| 119 Locale("zh", "", ""), |
| 120 Locale("zh", "TW", "") // 49 |
| 121 }; |
| 122 int32_t i; |
| 123 for (i= 0; i < 49; i++) { |
| 124 UnicodeString buffer; |
| 125 logln(locale[i].getDisplayName(buffer)); |
| 126 UErrorCode success = U_ZERO_ERROR; |
| 127 // form = (DecimalFormat*)NumberFormat::createCurrencyInstance(locale[i],
success); |
| 128 form = (DecimalFormat*)NumberFormat::createInstance(locale[i], success); |
| 129 if (U_FAILURE(success)) { |
| 130 errln("Err: Number Format "); |
| 131 logln("Number format creation failed."); |
| 132 continue; |
| 133 } |
| 134 Formattable result; |
| 135 FieldPosition pos(0); |
| 136 buffer.remove(); |
| 137 form->format(myNumber, buffer, pos); |
| 138 success = U_ZERO_ERROR; |
| 139 ParsePosition parsePos; |
| 140 form->parse(buffer, result, parsePos); |
| 141 logln(UnicodeString(" -> ") /* + << dec*/ + toString(result) + UnicodeSt
ring("[supposed output for result]")); |
| 142 if (U_FAILURE(success)) { |
| 143 errln("Err: Number Format parse"); |
| 144 logln("Number format parse failed."); |
| 145 } |
| 146 delete form; |
| 147 } |
| 148 } |
| 149 |
| 150 void TestMessageFormat::testBug1() |
| 151 { |
| 152 const double limit[] = {0.0, 1.0, 2.0}; |
| 153 const UnicodeString formats[] = {"0.0<=Arg<1.0", |
| 154 "1.0<=Arg<2.0", |
| 155 "2.0<-Arg"}; |
| 156 ChoiceFormat *cf = new ChoiceFormat(limit, formats, 3); |
| 157 FieldPosition status(0); |
| 158 UnicodeString toAppendTo; |
| 159 cf->format((int32_t)1, toAppendTo, status); |
| 160 if (toAppendTo != "1.0<=Arg<2.0") { |
| 161 errln("ChoiceFormat cmp in testBug1"); |
| 162 } |
| 163 logln(toAppendTo); |
| 164 delete cf; |
| 165 } |
| 166 |
| 167 void TestMessageFormat::testBug2() |
| 168 { |
| 169 UErrorCode status = U_ZERO_ERROR; |
| 170 UnicodeString result; |
| 171 // {sfb} use double format in pattern, so result will match (not strictly ne
cessary) |
| 172 const UnicodeString pattern = "There {0,choice,0#are no files|1#is one file|
1<are {0, number} files} on disk {1}. "; |
| 173 logln("The input pattern : " + pattern); |
| 174 MessageFormat *fmt = new MessageFormat(pattern, status); |
| 175 if (U_FAILURE(status)) { |
| 176 errln("MessageFormat pattern creation failed."); |
| 177 return; |
| 178 } |
| 179 logln("The output pattern is : " + fmt->toPattern(result)); |
| 180 if (pattern != result) { |
| 181 errln("MessageFormat::toPattern() failed."); |
| 182 } |
| 183 delete fmt; |
| 184 } |
| 185 |
| 186 #if 0 |
| 187 #if defined(_DEBUG) && U_IOSTREAM_SOURCE!=0 |
| 188 //---------------------------------------------------- |
| 189 // console I/O |
| 190 //---------------------------------------------------- |
| 191 |
| 192 #if U_IOSTREAM_SOURCE >= 199711 |
| 193 # include <iostream> |
| 194 std::ostream& operator<<(std::ostream& stream, const Formattable& obj); |
| 195 #elif U_IOSTREAM_SOURCE >= 198506 |
| 196 # include <iostream.h> |
| 197 ostream& operator<<(ostream& stream, const Formattable& obj); |
| 198 #endif |
| 199 |
| 200 #include "unicode/datefmt.h" |
| 201 #include <stdlib.h> |
| 202 #include <string.h> |
| 203 |
| 204 IntlTest& |
| 205 operator<<( IntlTest& stream, |
| 206 const Formattable& obj) |
| 207 { |
| 208 static DateFormat *defDateFormat = 0; |
| 209 |
| 210 UnicodeString buffer; |
| 211 switch(obj.getType()) { |
| 212 case Formattable::kDate : |
| 213 if (defDateFormat == 0) { |
| 214 defDateFormat = DateFormat::createInstance(); |
| 215 } |
| 216 defDateFormat->format(obj.getDate(), buffer); |
| 217 stream << buffer; |
| 218 break; |
| 219 case Formattable::kDouble : |
| 220 char convert[20]; |
| 221 sprintf( convert, "%lf", obj.getDouble() ); |
| 222 stream << convert << "D"; |
| 223 break; |
| 224 case Formattable::kLong : |
| 225 stream << obj.getLong() << "L"; |
| 226 break; |
| 227 case Formattable::kString: |
| 228 stream << "\"" << obj.getString(buffer) << "\""; |
| 229 break; |
| 230 case Formattable::kArray: |
| 231 int32_t i, count; |
| 232 const Formattable* array; |
| 233 array = obj.getArray(count); |
| 234 stream << "["; |
| 235 for (i=0; i<count; ++i) stream << array[i] << ( (i==(count-1)) ? ""
: ", " ); |
| 236 stream << "]"; |
| 237 break; |
| 238 default: |
| 239 stream << "INVALID_Formattable"; |
| 240 } |
| 241 return stream; |
| 242 } |
| 243 #endif /* defined(_DEBUG) && U_IOSTREAM_SOURCE!=0 */ |
| 244 #endif |
| 245 |
| 246 void TestMessageFormat::PatternTest() |
| 247 { |
| 248 Formattable testArgs[] = { |
| 249 Formattable(double(1)), Formattable(double(3456)), |
| 250 Formattable("Disk"), Formattable(UDate((int32_t)1000000000L), Format
table::kIsDate) |
| 251 }; |
| 252 UnicodeString testCases[] = { |
| 253 "Quotes '', '{', 'a' {0} '{0}'", |
| 254 "Quotes '', '{', 'a' {0,number} '{0}'", |
| 255 "'{'1,number,'#',##} {1,number,'#',##}", |
| 256 "There are {1} files on {2} at {3}.", |
| 257 "On {2}, there are {1} files, with {0,number,currency}.", |
| 258 "'{1,number,percent}', {1,number,percent},", |
| 259 "'{1,date,full}', {1,date,full},", |
| 260 "'{3,date,full}', {3,date,full},", |
| 261 "'{1,number,#,##}' {1,number,#,##}", |
| 262 }; |
| 263 |
| 264 UnicodeString testResultPatterns[] = { |
| 265 "Quotes '', '{', a {0} '{'0}", |
| 266 "Quotes '', '{', a {0,number} '{'0}", |
| 267 "'{'1,number,#,##} {1,number,'#'#,##}", |
| 268 "There are {1} files on {2} at {3}.", |
| 269 "On {2}, there are {1} files, with {0,number,currency}.", |
| 270 "'{'1,number,percent}, {1,number,percent},", |
| 271 "'{'1,date,full}, {1,date,full},", |
| 272 "'{'3,date,full}, {3,date,full},", |
| 273 "'{'1,number,#,##} {1,number,#,##}" |
| 274 }; |
| 275 |
| 276 UnicodeString testResultStrings[] = { |
| 277 "Quotes ', {, a 1 {0}", |
| 278 "Quotes ', {, a 1 {0}", |
| 279 "{1,number,#,##} #34,56", |
| 280 "There are 3,456 files on Disk at 1/12/70 5:46 AM.", |
| 281 "On Disk, there are 3,456 files, with $1.00.", |
| 282 "{1,number,percent}, 345,600%,", |
| 283 "{1,date,full}, Wednesday, December 31, 1969,", |
| 284 "{3,date,full}, Monday, January 12, 1970,", |
| 285 "{1,number,#,##} 34,56" |
| 286 }; |
| 287 |
| 288 |
| 289 for (int32_t i = 0; i < 9; ++i) { |
| 290 //it_out << "\nPat in: " << testCases[i]); |
| 291 |
| 292 MessageFormat *form = 0; |
| 293 UErrorCode success = U_ZERO_ERROR; |
| 294 UnicodeString buffer; |
| 295 form = new MessageFormat(testCases[i], Locale::getUS(), success); |
| 296 if (U_FAILURE(success)) { |
| 297 dataerrln("MessageFormat creation failed.#1 - %s", u_errorName(succe
ss)); |
| 298 logln(((UnicodeString)"MessageFormat for ") + testCases[i] + " creat
ion failed.\n"); |
| 299 continue; |
| 300 } |
| 301 if (form->toPattern(buffer) != testResultPatterns[i]) { |
| 302 errln(UnicodeString("TestMessageFormat::PatternTest failed test #2,
i = ") + i); |
| 303 //form->toPattern(buffer); |
| 304 errln(((UnicodeString)" Orig: ") + testCases[i]); |
| 305 errln(((UnicodeString)" Exp: ") + testResultPatterns[i]); |
| 306 errln(((UnicodeString)" Got: ") + buffer); |
| 307 } |
| 308 |
| 309 //it_out << "Pat out: " << form->toPattern(buffer)); |
| 310 UnicodeString result; |
| 311 int32_t count = 4; |
| 312 FieldPosition fieldpos(0); |
| 313 form->format(testArgs, count, result, fieldpos, success); |
| 314 if (U_FAILURE(success)) { |
| 315 dataerrln("MessageFormat failed test #3 - %s", u_errorName(success))
; |
| 316 logln("TestMessageFormat::PatternTest failed test #3"); |
| 317 continue; |
| 318 } |
| 319 if (result != testResultStrings[i]) { |
| 320 errln("TestMessageFormat::PatternTest failed test #4"); |
| 321 logln("TestMessageFormat::PatternTest failed #4."); |
| 322 logln(UnicodeString(" Result: ") + result ); |
| 323 logln(UnicodeString(" Expected: ") + testResultStrings[i] ); |
| 324 } |
| 325 |
| 326 |
| 327 //it_out << "Result: " << result); |
| 328 #if 0 |
| 329 /* TODO: Look at this test and see if this is still a valid test */ |
| 330 logln("---------------- test parse ----------------"); |
| 331 |
| 332 form->toPattern(buffer); |
| 333 logln("MSG pattern for parse: " + buffer); |
| 334 |
| 335 int32_t parseCount = 0; |
| 336 Formattable* values = form->parse(result, parseCount, success); |
| 337 if (U_FAILURE(success)) { |
| 338 errln("MessageFormat failed test #5"); |
| 339 logln(UnicodeString("MessageFormat failed test #5 with error code ")
+(int32_t)success); |
| 340 } else if (parseCount != count) { |
| 341 errln("MSG count not %d as expected. Got %d", count, parseCount); |
| 342 } |
| 343 UBool failed = FALSE; |
| 344 for (int32_t j = 0; j < parseCount; ++j) { |
| 345 if (values == 0 || testArgs[j] != values[j]) { |
| 346 errln(((UnicodeString)"MSG testargs[") + j + "]: " + toString(te
stArgs[j])); |
| 347 errln(((UnicodeString)"MSG values[") + j + "] : " + toString(va
lues[j])); |
| 348 failed = TRUE; |
| 349 } |
| 350 } |
| 351 if (failed) |
| 352 errln("MessageFormat failed test #6"); |
| 353 #endif |
| 354 delete form; |
| 355 } |
| 356 } |
| 357 |
| 358 void TestMessageFormat::sample() |
| 359 { |
| 360 MessageFormat *form = 0; |
| 361 UnicodeString buffer1, buffer2; |
| 362 UErrorCode success = U_ZERO_ERROR; |
| 363 form = new MessageFormat("There are {0} files on {1}", success); |
| 364 if (U_FAILURE(success)) { |
| 365 errln("Err: Message format creation failed"); |
| 366 logln("Sample message format creation failed."); |
| 367 return; |
| 368 } |
| 369 UnicodeString abc("abc"); |
| 370 UnicodeString def("def"); |
| 371 Formattable testArgs1[] = { abc, def }; |
| 372 FieldPosition fieldpos(0); |
| 373 assertEquals("format", |
| 374 "There are abc files on def", |
| 375 form->format(testArgs1, 2, buffer2, fieldpos, success)); |
| 376 assertSuccess("format", success); |
| 377 delete form; |
| 378 } |
| 379 |
| 380 void TestMessageFormat::testStaticFormat() |
| 381 { |
| 382 UErrorCode err = U_ZERO_ERROR; |
| 383 Formattable arguments[] = { |
| 384 (int32_t)7, |
| 385 Formattable(UDate(8.71068e+011), Formattable::kIsDate), |
| 386 "a disturbance in the Force" |
| 387 }; |
| 388 |
| 389 UnicodeString result; |
| 390 result = MessageFormat::format( |
| 391 "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.", |
| 392 arguments, |
| 393 3, |
| 394 result, |
| 395 err); |
| 396 |
| 397 if (U_FAILURE(err)) { |
| 398 dataerrln("TestMessageFormat::testStaticFormat #1 - %s", u_errorName(err
)); |
| 399 logln(UnicodeString("TestMessageFormat::testStaticFormat failed test #1
with error code ")+(int32_t)err); |
| 400 return; |
| 401 } |
| 402 |
| 403 const UnicodeString expected( |
| 404 "At 12:20:00 PM on Aug 8, 1997, there was a disturbance in the Force
on planet 7.", ""); |
| 405 if (result != expected) { |
| 406 errln("TestMessageFormat::testStaticFormat failed on test"); |
| 407 logln( UnicodeString(" Result: ") + result ); |
| 408 logln( UnicodeString(" Expected: ") + expected ); |
| 409 } |
| 410 } |
| 411 |
| 412 /* When the default locale is tr, make sure that the pattern can still be parsed
. */ |
| 413 void TestMessageFormat::TestTurkishCasing() |
| 414 { |
| 415 UErrorCode err = U_ZERO_ERROR; |
| 416 Locale saveDefaultLocale; |
| 417 Locale::setDefault( Locale("tr"), err ); |
| 418 |
| 419 Formattable arguments[] = { |
| 420 (int32_t)7, |
| 421 Formattable(UDate(8.71068e+011), Formattable::kIsDate), |
| 422 "a disturbance in the Force" |
| 423 }; |
| 424 |
| 425 UnicodeString result; |
| 426 result = MessageFormat::format( |
| 427 "At {1,TIME} on {1,DATE,SHORT}, there was {2} on planet {0,NUMBER,INTEGE
R}.", |
| 428 arguments, |
| 429 3, |
| 430 result, |
| 431 err); |
| 432 |
| 433 if (U_FAILURE(err)) { |
| 434 dataerrln("TestTurkishCasing #1 with error code %s", u_errorName(err)); |
| 435 return; |
| 436 } |
| 437 |
| 438 const UnicodeString expected( |
| 439 "At 12:20:00 on 08.08.1997, there was a disturbance in the Force on
planet 7.", ""); |
| 440 if (result != expected) { |
| 441 errln("TestTurkishCasing failed on test"); |
| 442 errln( UnicodeString(" Result: ") + result ); |
| 443 errln( UnicodeString(" Expected: ") + expected ); |
| 444 } |
| 445 Locale::setDefault( saveDefaultLocale, err ); |
| 446 } |
| 447 |
| 448 void TestMessageFormat::testSimpleFormat(/* char* par */) |
| 449 { |
| 450 logln("running TestMessageFormat::testSimpleFormat"); |
| 451 |
| 452 UErrorCode err = U_ZERO_ERROR; |
| 453 |
| 454 Formattable testArgs1[] = {(int32_t)0, "MyDisk"}; |
| 455 Formattable testArgs2[] = {(int32_t)1, "MyDisk"}; |
| 456 Formattable testArgs3[] = {(int32_t)12, "MyDisk"}; |
| 457 |
| 458 MessageFormat* form = new MessageFormat( |
| 459 "The disk \"{1}\" contains {0} file(s).", err); |
| 460 |
| 461 UnicodeString string; |
| 462 FieldPosition ignore(FieldPosition::DONT_CARE); |
| 463 form->format(testArgs1, 2, string, ignore, err); |
| 464 if (U_FAILURE(err) || string != "The disk \"MyDisk\" contains 0 file(s).") { |
| 465 dataerrln(UnicodeString("TestMessageFormat::testSimpleFormat failed on t
est #1 - ") + u_errorName(err)); |
| 466 } |
| 467 |
| 468 ignore.setField(FieldPosition::DONT_CARE); |
| 469 string.remove(); |
| 470 form->format(testArgs2, 2, string, ignore, err); |
| 471 if (U_FAILURE(err) || string != "The disk \"MyDisk\" contains 1 file(s).") { |
| 472 logln(string); |
| 473 dataerrln(UnicodeString("TestMessageFormat::testSimpleFormat failed on t
est #2")+string + " - " + u_errorName(err)); |
| 474 } |
| 475 |
| 476 ignore.setField(FieldPosition::DONT_CARE); |
| 477 string.remove(); |
| 478 form->format(testArgs3, 2, string, ignore, err); |
| 479 if (U_FAILURE(err) || string != "The disk \"MyDisk\" contains 12 file(s).")
{ |
| 480 dataerrln(UnicodeString("TestMessageFormat::testSimpleFormat failed on t
est #3")+string + " - " + u_errorName(err)); |
| 481 } |
| 482 |
| 483 delete form; |
| 484 } |
| 485 |
| 486 void TestMessageFormat::testMsgFormatChoice(/* char* par */) |
| 487 { |
| 488 logln("running TestMessageFormat::testMsgFormatChoice"); |
| 489 |
| 490 UErrorCode err = U_ZERO_ERROR; |
| 491 |
| 492 MessageFormat* form = new MessageFormat("The disk \"{1}\" contains {0}.", er
r); |
| 493 double filelimits[] = {0,1,2}; |
| 494 UnicodeString filepart[] = {"no files","one file","{0,number} files"}; |
| 495 ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3); |
| 496 form->setFormat(1,*fileform); // NOT zero, see below |
| 497 //is the format adopted? |
| 498 |
| 499 FieldPosition ignore(FieldPosition::DONT_CARE); |
| 500 UnicodeString string; |
| 501 Formattable testArgs1[] = {(int32_t)0, "MyDisk"}; |
| 502 form->format(testArgs1, 2, string, ignore, err); |
| 503 if (string != "The disk \"MyDisk\" contains no files.") { |
| 504 errln("TestMessageFormat::testMsgFormatChoice failed on test #1"); |
| 505 } |
| 506 |
| 507 ignore.setField(FieldPosition::DONT_CARE); |
| 508 string.remove(); |
| 509 Formattable testArgs2[] = {(int32_t)1, "MyDisk"}; |
| 510 form->format(testArgs2, 2, string, ignore, err); |
| 511 if (string != "The disk \"MyDisk\" contains one file.") { |
| 512 errln("TestMessageFormat::testMsgFormatChoice failed on test #2"); |
| 513 } |
| 514 |
| 515 ignore.setField(FieldPosition::DONT_CARE); |
| 516 string.remove(); |
| 517 Formattable testArgs3[] = {(int32_t)1273, "MyDisk"}; |
| 518 form->format(testArgs3, 2, string, ignore, err); |
| 519 if (string != "The disk \"MyDisk\" contains 1,273 files.") { |
| 520 dataerrln("TestMessageFormat::testMsgFormatChoice failed on test #3 - %s
", u_errorName(err)); |
| 521 } |
| 522 |
| 523 delete form; |
| 524 delete fileform; |
| 525 } |
| 526 |
| 527 |
| 528 void TestMessageFormat::testMsgFormatPlural(/* char* par */) |
| 529 { |
| 530 logln("running TestMessageFormat::testMsgFormatPlural"); |
| 531 |
| 532 UErrorCode err = U_ZERO_ERROR; |
| 533 UnicodeString t1("{0, plural, one{C''est # fichier} other{Ce sont # fichiers
}} dans la liste."); |
| 534 UnicodeString t2("{argument, plural, one{C''est # fichier} other {Ce sont #
fichiers}} dans la liste."); |
| 535 UnicodeString t3("There {0, plural, one{is # zavod}few{are {0, number,###.0}
zavoda} other{are # zavodov}} in the directory."); |
| 536 UnicodeString t4("There {argument, plural, one{is # zavod}few{are {argument,
number,###.0} zavoda} other{are #zavodov}} in the directory."); |
| 537 UnicodeString t5("{0, plural, one {{0, number,C''''est #,##0.0# fichier}} ot
her {Ce sont # fichiers}} dans la liste."); |
| 538 MessageFormat* mfNum = new MessageFormat(t1, Locale("fr"), err); |
| 539 if (U_FAILURE(err)) { |
| 540 dataerrln("TestMessageFormat::testMsgFormatPlural #1 - argumentIndex - %
s", u_errorName(err)); |
| 541 logln(UnicodeString("TestMessageFormat::testMsgFormatPlural #1 with erro
r code ")+(int32_t)err); |
| 542 return; |
| 543 } |
| 544 Formattable testArgs1((int32_t)0); |
| 545 FieldPosition ignore(FieldPosition::DONT_CARE); |
| 546 UnicodeString numResult1; |
| 547 mfNum->format(&testArgs1, 1, numResult1, ignore, err); |
| 548 |
| 549 MessageFormat* mfAlpha = new MessageFormat(t2, Locale("fr"), err); |
| 550 UnicodeString argName[] = {UnicodeString("argument")}; |
| 551 UnicodeString argNameResult; |
| 552 mfAlpha->format(argName, &testArgs1, 1, argNameResult, err); |
| 553 if (U_FAILURE(err)) { |
| 554 errln("TestMessageFormat::testMsgFormatPlural #1 - argumentName"); |
| 555 logln(UnicodeString("TestMessageFormat::testMsgFormatPlural #1 with erro
r code ")+(int32_t)err); |
| 556 delete mfNum; |
| 557 return; |
| 558 } |
| 559 if ( numResult1 != argNameResult){ |
| 560 errln("TestMessageFormat::testMsgFormatPlural #1"); |
| 561 logln(UnicodeString("The results of argumentName and argumentIndex are n
ot the same.")); |
| 562 } |
| 563 if ( numResult1 != UnicodeString("C\'est 0 fichier dans la liste.")) { |
| 564 errln("TestMessageFormat::testMsgFormatPlural #1"); |
| 565 logln(UnicodeString("The results of argumentName and argumentIndex are n
ot the same.")); |
| 566 } |
| 567 err = U_ZERO_ERROR; |
| 568 |
| 569 delete mfNum; |
| 570 delete mfAlpha; |
| 571 |
| 572 MessageFormat* mfNum2 = new MessageFormat(t3, Locale("ru"), err); |
| 573 numResult1.remove(); |
| 574 Formattable testArgs2((int32_t)4); |
| 575 mfNum2->format(&testArgs2, 1, numResult1, ignore, err); |
| 576 MessageFormat* mfAlpha2 = new MessageFormat(t4, Locale("ru"), err); |
| 577 argNameResult.remove(); |
| 578 mfAlpha2->format(argName, &testArgs2, 1, argNameResult, err); |
| 579 |
| 580 if (U_FAILURE(err)) { |
| 581 errln("TestMessageFormat::testMsgFormatPlural #2 - argumentName"); |
| 582 logln(UnicodeString("TestMessageFormat::testMsgFormatPlural #2 with erro
r code ")+(int32_t)err); |
| 583 delete mfNum2; |
| 584 return; |
| 585 } |
| 586 if ( numResult1 != argNameResult){ |
| 587 errln("TestMessageFormat::testMsgFormatPlural #2"); |
| 588 logln(UnicodeString("The results of argumentName and argumentIndex are n
ot the same.")); |
| 589 } |
| 590 if ( numResult1 != UnicodeString("There are 4,0 zavoda in the directory."))
{ |
| 591 errln("TestMessageFormat::testMsgFormatPlural #2"); |
| 592 logln(UnicodeString("The results of argumentName and argumentIndex are n
ot the same.")); |
| 593 } |
| 594 |
| 595 delete mfNum2; |
| 596 delete mfAlpha2; |
| 597 |
| 598 // nested formats |
| 599 err = U_ZERO_ERROR; |
| 600 MessageFormat* msgFmt = new MessageFormat(t5, Locale("fr"), err); |
| 601 if (U_FAILURE(err)) { |
| 602 errln("TestMessageFormat::test nested PluralFormat with argumentName"); |
| 603 logln(UnicodeString("TestMessageFormat::test nested PluralFormat with er
ror code ")+(int32_t)err); |
| 604 delete msgFmt; |
| 605 return; |
| 606 } |
| 607 Formattable testArgs3((int32_t)0); |
| 608 argNameResult.remove(); |
| 609 msgFmt->format(&testArgs3, 1, argNameResult, ignore, err); |
| 610 if (U_FAILURE(err)) { |
| 611 errln("TestMessageFormat::test nested PluralFormat with argumentName"); |
| 612 } |
| 613 if ( argNameResult!= UnicodeString("C'est 0,0 fichier dans la liste.")) { |
| 614 errln(UnicodeString("TestMessageFormat::test nested named PluralFormat."
)); |
| 615 logln(UnicodeString("The unexpected nested named PluralFormat.")); |
| 616 } |
| 617 delete msgFmt; |
| 618 } |
| 619 |
| 620 void TestMessageFormat::internalFormat(MessageFormat* msgFmt , |
| 621 Formattable* args , int32_t numOfArgs , |
| 622 UnicodeString expected ,char* errMsg) |
| 623 { |
| 624 UnicodeString result; |
| 625 FieldPosition ignore(FieldPosition::DONT_CARE); |
| 626 UErrorCode status = U_ZERO_ERROR; |
| 627 |
| 628 //Format with passed arguments |
| 629 msgFmt->format( args , numOfArgs , result, ignore, status); |
| 630 if (U_FAILURE(status)) { |
| 631 dataerrln( "%serror while formatting with ErrorCode as %s" ,errMsg,
u_errorName(status) ); |
| 632 } |
| 633 //Compare expected with obtained result |
| 634 if ( result!= expected ) { |
| 635 UnicodeString err = UnicodeString(errMsg); |
| 636 err+= UnicodeString(":Unexpected Result \n Expected: " + expected +
"\n Obtained: " + result + "\n"); |
| 637 dataerrln(err); |
| 638 } |
| 639 } |
| 640 |
| 641 MessageFormat* TestMessageFormat::internalCreate( |
| 642 UnicodeString pattern ,Locale locale ,UErrorCode &status , char* errMsg
) |
| 643 { |
| 644 //Create the MessageFormat with simple SelectFormat |
| 645 MessageFormat* msgFmt = new MessageFormat(pattern, locale, status); |
| 646 if (U_FAILURE(status)) { |
| 647 dataerrln( "%serror while constructing with ErrorCode as %s" ,errMsg, u_
errorName(status) ); |
| 648 logln(UnicodeString("TestMessageFormat::testMsgFormatSelect #1 with erro
r code ")+(int32_t)status); |
| 649 return NULL; |
| 650 } |
| 651 return msgFmt; |
| 652 } |
| 653 |
| 654 void TestMessageFormat::testMsgFormatSelect(/* char* par */) |
| 655 { |
| 656 logln("running TestMessageFormat::testMsgFormatSelect"); |
| 657 |
| 658 UErrorCode err = U_ZERO_ERROR; |
| 659 //French Pattern |
| 660 UnicodeString t1("{0} est {1, select, female {all\\u00E9e} other {all\\u00E9
}} \\u00E0 Paris."); |
| 661 |
| 662 err = U_ZERO_ERROR; |
| 663 //Create the MessageFormat with simple French pattern |
| 664 MessageFormat* msgFmt1 = internalCreate(t1.unescape(), Locale("fr"),err,(cha
r*)"From TestMessageFormat::TestSelectFormat create t1"); |
| 665 if (!U_FAILURE(err)) { |
| 666 //Arguments |
| 667 Formattable testArgs10[] = {"Kirti","female"}; |
| 668 Formattable testArgs11[] = {"Victor","other"}; |
| 669 Formattable testArgs12[] = {"Ash","unknown"}; |
| 670 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12}; |
| 671 UnicodeString exp[] = { |
| 672 "Kirti est all\\u00E9e \\u00E0 Paris." , |
| 673 "Victor est all\\u00E9 \\u00E0 Paris.", |
| 674 "Ash est all\\u00E9 \\u00E0 Paris."}; |
| 675 //Format |
| 676 for( int i=0; i< 3; i++){ |
| 677 internalFormat( msgFmt1 , testArgs[i], 2, exp[i].unescape() ,(char*)
"From TestMessageFormat::testSelectFormat format t1"); |
| 678 } |
| 679 } |
| 680 delete msgFmt1; |
| 681 |
| 682 //Quoted French Pattern |
| 683 UnicodeString t2("{0} est {1, select, female {all\\u00E9e c''est} other {all
\\u00E9 c''est}} \\u00E0 Paris."); |
| 684 err = U_ZERO_ERROR; |
| 685 //Create the MessageFormat with Quoted French pattern |
| 686 MessageFormat* msgFmt2 = internalCreate(t2.unescape(), Locale("fr"),err,(cha
r*)"From TestMessageFormat::TestSelectFormat create t2"); |
| 687 if (!U_FAILURE(err)) { |
| 688 //Arguments |
| 689 Formattable testArgs10[] = {"Kirti","female"}; |
| 690 Formattable testArgs11[] = {"Victor","other"}; |
| 691 Formattable testArgs12[] = {"Ash","male"}; |
| 692 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12}; |
| 693 UnicodeString exp[] = { |
| 694 "Kirti est all\\u00E9e c'est \\u00E0 Paris." , |
| 695 "Victor est all\\u00E9 c'est \\u00E0 Paris.", |
| 696 "Ash est all\\u00E9 c'est \\u00E0 Paris."}; |
| 697 //Format |
| 698 for( int i=0; i< 3; i++){ |
| 699 internalFormat( msgFmt2 , testArgs[i], 2, exp[i].unescape() ,(char*)
"From TestMessageFormat::testSelectFormat format t2"); |
| 700 } |
| 701 } |
| 702 delete msgFmt2; |
| 703 |
| 704 //English Pattern |
| 705 UnicodeString t3("{0, select , male {MALE FR company} female {FEMALE FR comp
any} other {FR otherValue}} published new books."); |
| 706 err = U_ZERO_ERROR; |
| 707 //Create the MessageFormat with English pattern |
| 708 MessageFormat* msgFmt3 = internalCreate(t3, Locale("en"),err,(char*)"From Te
stMessageFormat::TestSelectFormat create t3"); |
| 709 if (!U_FAILURE(err)) { |
| 710 //Arguments |
| 711 Formattable testArgs10[] = {"female"}; |
| 712 Formattable testArgs11[] = {"other"}; |
| 713 Formattable testArgs12[] = {"male"}; |
| 714 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12}; |
| 715 UnicodeString exp[] = { |
| 716 "FEMALE FR company published new books." , |
| 717 "FR otherValue published new books.", |
| 718 "MALE FR company published new books."}; |
| 719 //Format |
| 720 for( int i=0; i< 3; i++){ |
| 721 internalFormat( msgFmt3 , testArgs[i], 1, exp[i] ,(char*)"From TestM
essageFormat::testSelectFormat format t3"); |
| 722 } |
| 723 } |
| 724 delete msgFmt3; |
| 725 |
| 726 //Nested patterns with plural, number ,choice ,select format etc. |
| 727 //Select Format with embedded number format |
| 728 UnicodeString t4("{0} est {1, select, female {{2,number,integer} all\\u00E9e
} other {all\\u00E9}} \\u00E0 Paris."); |
| 729 //Create the MessageFormat with Select Format with embedded number format (n
ested pattern) |
| 730 MessageFormat* msgFmt4 = internalCreate(t4.unescape(), Locale("fr"),err,(cha
r*)"From TestMessageFormat::TestSelectFormat create t4"); |
| 731 if (!U_FAILURE(err)) { |
| 732 //Arguments |
| 733 Formattable testArgs10[] = {"Kirti","female",(int32_t)6}; |
| 734 Formattable testArgs11[] = {"Kirti","female",100.100}; |
| 735 Formattable testArgs12[] = {"Kirti","other",(int32_t)6}; |
| 736 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12}; |
| 737 UnicodeString exp[] = { |
| 738 "Kirti est 6 all\\u00E9e \\u00E0 Paris." , |
| 739 "Kirti est 100 all\\u00E9e \\u00E0 Paris.", |
| 740 "Kirti est all\\u00E9 \\u00E0 Paris."}; |
| 741 //Format |
| 742 for( int i=0; i< 3; i++){ |
| 743 internalFormat( msgFmt4 , testArgs[i], 3, exp[i].unescape() ,(char*)
"From TestMessageFormat::testSelectFormat format t4"); |
| 744 } |
| 745 } |
| 746 delete msgFmt4; |
| 747 |
| 748 err = U_ZERO_ERROR; |
| 749 //Plural format with embedded select format |
| 750 UnicodeString t5("{0} {1, plural, one {est {2, select, female {all\\u00E9e}
other {all\\u00E9}}} other {sont {2, select, female {all\\u00E9es} other {all\\u
00E9s}}}} \\u00E0 Paris."); |
| 751 err = U_ZERO_ERROR; |
| 752 //Create the MessageFormat with Plural format with embedded select format(ne
sted pattern) |
| 753 MessageFormat* msgFmt5 = internalCreate(t5.unescape(), Locale("fr"),err,(cha
r*)"From TestMessageFormat::TestSelectFormat create t5"); |
| 754 if (!U_FAILURE(err)) { |
| 755 //Arguments |
| 756 Formattable testArgs10[] = {"Kirti",(int32_t)6,"female"}; |
| 757 Formattable testArgs11[] = {"Kirti",(int32_t)1,"female"}; |
| 758 Formattable testArgs12[] = {"Ash",(int32_t)1,"other"}; |
| 759 Formattable testArgs13[] = {"Ash",(int32_t)5,"other"}; |
| 760 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12,testArgs13}; |
| 761 UnicodeString exp[] = { |
| 762 "Kirti sont all\\u00E9es \\u00E0 Paris." , |
| 763 "Kirti est all\\u00E9e \\u00E0 Paris.", |
| 764 "Ash est all\\u00E9 \\u00E0 Paris.", |
| 765 "Ash sont all\\u00E9s \\u00E0 Paris."}; |
| 766 //Format |
| 767 for( int i=0; i< 4; i++){ |
| 768 internalFormat( msgFmt5 , testArgs[i], 3, exp[i].unescape() ,(char*)
"From TestMessageFormat::testSelectFormat format t5"); |
| 769 } |
| 770 } |
| 771 delete msgFmt5; |
| 772 |
| 773 err = U_ZERO_ERROR; |
| 774 //Select, plural, and number formats heavily nested |
| 775 UnicodeString t6("{0} und {1, select, female {{2, plural, one {{3, select, f
emale {ihre Freundin} other {ihr Freund}} } other {ihre {2, number, integer} {3,
select, female {Freundinnen} other {Freunde}} } }} other{{2, plural, one {{3, s
elect, female {seine Freundin} other {sein Freund}}} other {seine {2, number, in
teger} {3, select, female {Freundinnen} other {Freunde}}}}} } gingen nach Paris.
"); |
| 776 //Create the MessageFormat with Select, plural, and number formats heavily n
ested |
| 777 MessageFormat* msgFmt6 = internalCreate(t6, Locale("de"),err,(char*)"From Te
stMessageFormat::TestSelectFormat create t6"); |
| 778 if (!U_FAILURE(err)) { |
| 779 //Arguments |
| 780 Formattable testArgs10[] = {"Kirti","other",(int32_t)1,"other"}; |
| 781 Formattable testArgs11[] = {"Kirti","other",(int32_t)6,"other"}; |
| 782 Formattable testArgs12[] = {"Kirti","other",(int32_t)1,"female"}; |
| 783 Formattable testArgs13[] = {"Kirti","other",(int32_t)3,"female"}; |
| 784 Formattable testArgs14[] = {"Kirti","female",(int32_t)1,"female"}; |
| 785 Formattable testArgs15[] = {"Kirti","female",(int32_t)5,"female"}; |
| 786 Formattable testArgs16[] = {"Kirti","female",(int32_t)1,"other"}; |
| 787 Formattable testArgs17[] = {"Kirti","female",(int32_t)5,"other"}; |
| 788 Formattable testArgs18[] = {"Kirti","mixed",(int32_t)1,"mixed"}; |
| 789 Formattable testArgs19[] = {"Kirti","mixed",(int32_t)1,"other"}; |
| 790 Formattable testArgs20[] = {"Kirti","female",(int32_t)1,"mixed"}; |
| 791 Formattable testArgs21[] = {"Kirti","mixed",(int32_t)5,"mixed"}; |
| 792 Formattable testArgs22[] = {"Kirti","mixed",(int32_t)5,"other"}; |
| 793 Formattable testArgs23[] = {"Kirti","female",(int32_t)5,"mixed"}; |
| 794 Formattable* testArgs[] = {testArgs10,testArgs11,testArgs12,testArgs13, |
| 795 testArgs14,testArgs15,testArgs16,testArgs17, |
| 796 testArgs18,testArgs19,testArgs20,testArgs21, |
| 797 testArgs22,testArgs23 }; |
| 798 UnicodeString exp[] = { |
| 799 "Kirti und sein Freund gingen nach Paris." , |
| 800 "Kirti und seine 6 Freunde gingen nach Paris." , |
| 801 "Kirti und seine Freundin gingen nach Paris.", |
| 802 "Kirti und seine 3 Freundinnen gingen nach Paris.", |
| 803 "Kirti und ihre Freundin gingen nach Paris.", |
| 804 "Kirti und ihre 5 Freundinnen gingen nach Paris.", |
| 805 "Kirti und ihr Freund gingen nach Paris.", |
| 806 "Kirti und ihre 5 Freunde gingen nach Paris.", |
| 807 "Kirti und sein Freund gingen nach Paris.", |
| 808 "Kirti und sein Freund gingen nach Paris.", |
| 809 "Kirti und ihr Freund gingen nach Paris.", |
| 810 "Kirti und seine 5 Freunde gingen nach Paris." , |
| 811 "Kirti und seine 5 Freunde gingen nach Paris." , |
| 812 "Kirti und ihre 5 Freunde gingen nach Paris." |
| 813 }; |
| 814 //Format |
| 815 for( int i=0; i< 14; i++){ |
| 816 internalFormat( msgFmt6 , testArgs[i], 4, exp[i] ,(char*)"From TestM
essageFormat::testSelectFormat format t6"); |
| 817 } |
| 818 } |
| 819 delete msgFmt6; |
| 820 } |
| 821 |
| 822 //--------------------------------- |
| 823 // API Tests |
| 824 //--------------------------------- |
| 825 |
| 826 void TestMessageFormat::testCopyConstructor() |
| 827 { |
| 828 UErrorCode success = U_ZERO_ERROR; |
| 829 MessageFormat *x = new MessageFormat("There are {0} files on {1}", success); |
| 830 MessageFormat *z = new MessageFormat("There are {0} files on {1} created", s
uccess); |
| 831 MessageFormat *y = 0; |
| 832 y = new MessageFormat(*x); |
| 833 if ( (*x == *y) && |
| 834 (*x != *z) && |
| 835 (*y != *z) ) |
| 836 logln("First test (operator ==): Passed!"); |
| 837 else { |
| 838 errln("TestMessageFormat::testCopyConstructor failed #1"); |
| 839 logln("First test (operator ==): Failed!"); |
| 840 } |
| 841 if ( ((*x == *y) && (*y == *x)) && |
| 842 ((*x != *z) && (*z != *x)) && |
| 843 ((*y != *z) && (*z != *y)) ) |
| 844 logln("Second test (equals): Passed!"); |
| 845 else { |
| 846 errln("TestMessageFormat::testCopyConstructor failed #2"); |
| 847 logln("Second test (equals): Failed!"); |
| 848 } |
| 849 |
| 850 delete x; |
| 851 delete y; |
| 852 delete z; |
| 853 } |
| 854 |
| 855 |
| 856 void TestMessageFormat::testAssignment() |
| 857 { |
| 858 UErrorCode success = U_ZERO_ERROR; |
| 859 MessageFormat *x = new MessageFormat("There are {0} files on {1}", success); |
| 860 MessageFormat *z = new MessageFormat("There are {0} files on {1} created", s
uccess); |
| 861 MessageFormat *y = new MessageFormat("There are {0} files on {1} created", s
uccess); |
| 862 *y = *x; |
| 863 if ( (*x == *y) && |
| 864 (*x != *z) && |
| 865 (*y != *z) ) |
| 866 logln("First test (operator ==): Passed!"); |
| 867 else { |
| 868 errln( "TestMessageFormat::testAssignment failed #1"); |
| 869 logln("First test (operator ==): Failed!"); |
| 870 } |
| 871 if ( ((*x == *y) && (*y == *x)) && |
| 872 ((*x != *z) && (*z != *x)) && |
| 873 ((*y != *z) && (*z != *y)) ) |
| 874 logln("Second test (equals): Passed!"); |
| 875 else { |
| 876 errln("TestMessageFormat::testAssignment failed #2"); |
| 877 logln("Second test (equals): Failed!"); |
| 878 } |
| 879 |
| 880 delete x; |
| 881 delete y; |
| 882 delete z; |
| 883 } |
| 884 |
| 885 void TestMessageFormat::testClone() |
| 886 { |
| 887 UErrorCode success = U_ZERO_ERROR; |
| 888 MessageFormat *x = new MessageFormat("There are {0} files on {1}", success); |
| 889 MessageFormat *z = new MessageFormat("There are {0} files on {1} created", s
uccess); |
| 890 MessageFormat *y = 0; |
| 891 y = (MessageFormat*)x->clone(); |
| 892 if ( (*x == *y) && |
| 893 (*x != *z) && |
| 894 (*y != *z) ) |
| 895 logln("First test (operator ==): Passed!"); |
| 896 else { |
| 897 errln("TestMessageFormat::testClone failed #1"); |
| 898 logln("First test (operator ==): Failed!"); |
| 899 } |
| 900 if ( ((*x == *y) && (*y == *x)) && |
| 901 ((*x != *z) && (*z != *x)) && |
| 902 ((*y != *z) && (*z != *y)) ) |
| 903 logln("Second test (equals): Passed!"); |
| 904 else { |
| 905 errln("TestMessageFormat::testClone failed #2"); |
| 906 logln("Second test (equals): Failed!"); |
| 907 } |
| 908 |
| 909 delete x; |
| 910 delete y; |
| 911 delete z; |
| 912 } |
| 913 |
| 914 void TestMessageFormat::testEquals() |
| 915 { |
| 916 UErrorCode success = U_ZERO_ERROR; |
| 917 MessageFormat x("There are {0} files on {1}", success); |
| 918 MessageFormat y("There are {0} files on {1}", success); |
| 919 if (!(x == y)) { |
| 920 errln( "TestMessageFormat::testEquals failed #1"); |
| 921 logln("First test (operator ==): Failed!"); |
| 922 } |
| 923 |
| 924 } |
| 925 |
| 926 void TestMessageFormat::testNotEquals() |
| 927 { |
| 928 UErrorCode success = U_ZERO_ERROR; |
| 929 MessageFormat x("There are {0} files on {1}", success); |
| 930 MessageFormat y(x); |
| 931 y.setLocale(Locale("fr")); |
| 932 if (!(x != y)) { |
| 933 errln( "TestMessageFormat::testEquals failed #1"); |
| 934 logln("First test (operator !=): Failed!"); |
| 935 } |
| 936 y = x; |
| 937 y.applyPattern("There are {0} files on {1} the disk", success); |
| 938 if (!(x != y)) { |
| 939 errln( "TestMessageFormat::testEquals failed #1"); |
| 940 logln("Second test (operator !=): Failed!"); |
| 941 } |
| 942 } |
| 943 |
| 944 |
| 945 void TestMessageFormat::testSetLocale() |
| 946 { |
| 947 UErrorCode err = U_ZERO_ERROR; |
| 948 GregorianCalendar cal(err); |
| 949 Formattable arguments[] = { |
| 950 456.83, |
| 951 Formattable(UDate(8.71068e+011), Formattable::kIsDate), |
| 952 "deposit" |
| 953 }; |
| 954 |
| 955 UnicodeString result; |
| 956 |
| 957 //UnicodeString formatStr = "At {1,time} on {1,date}, you made a {2} of {0,n
umber,currency}."; |
| 958 UnicodeString formatStr = "At <time> on {1,date}, you made a {2} of {0,numbe
r,currency}."; |
| 959 // {sfb} to get $, would need Locale::US, not Locale::ENGLISH |
| 960 // Just use unlocalized currency symbol. |
| 961 //UnicodeString compareStrEng = "At <time> on Aug 8, 1997, you made a deposi
t of $456.83."; |
| 962 UnicodeString compareStrEng = "At <time> on Aug 8, 1997, you made a deposit
of "; |
| 963 compareStrEng += (UChar) 0x00a4; |
| 964 compareStrEng += "456.83."; |
| 965 // {sfb} to get DM, would need Locale::GERMANY, not Locale::GERMAN |
| 966 // Just use unlocalized currency symbol. |
| 967 //UnicodeString compareStrGer = "At <time> on 08.08.1997, you made a deposit
of 456,83 DM."; |
| 968 UnicodeString compareStrGer = "At <time> on 08.08.1997, you made a deposit o
f "; |
| 969 compareStrGer += "456,83"; |
| 970 compareStrGer += (UChar) 0x00a0; |
| 971 compareStrGer += (UChar) 0x00a4; |
| 972 compareStrGer += "."; |
| 973 |
| 974 MessageFormat msg( formatStr, err); |
| 975 result = ""; |
| 976 FieldPosition pos(0); |
| 977 result = msg.format( |
| 978 arguments, |
| 979 3, |
| 980 result, |
| 981 pos, |
| 982 err); |
| 983 |
| 984 logln(result); |
| 985 if (result != compareStrEng) { |
| 986 dataerrln("*** MSG format err. - %s", u_errorName(err)); |
| 987 } |
| 988 |
| 989 msg.setLocale(Locale::getEnglish()); |
| 990 UBool getLocale_ok = TRUE; |
| 991 if (msg.getLocale() != Locale::getEnglish()) { |
| 992 errln("*** MSG getLocal err."); |
| 993 getLocale_ok = FALSE; |
| 994 } |
| 995 |
| 996 msg.setLocale(Locale::getGerman()); |
| 997 |
| 998 if (msg.getLocale() != Locale::getGerman()) { |
| 999 errln("*** MSG getLocal err."); |
| 1000 getLocale_ok = FALSE; |
| 1001 } |
| 1002 |
| 1003 msg.applyPattern( formatStr, err); |
| 1004 |
| 1005 pos.setField(0); |
| 1006 result = ""; |
| 1007 result = msg.format( |
| 1008 arguments, |
| 1009 3, |
| 1010 result, |
| 1011 pos, |
| 1012 err); |
| 1013 |
| 1014 logln(result); |
| 1015 if (result == compareStrGer) { |
| 1016 logln("MSG setLocale tested."); |
| 1017 }else{ |
| 1018 dataerrln( "*** MSG setLocale err. - %s", u_errorName(err)); |
| 1019 } |
| 1020 |
| 1021 if (getLocale_ok) { |
| 1022 logln("MSG getLocale tested."); |
| 1023 } |
| 1024 } |
| 1025 |
| 1026 void TestMessageFormat::testFormat() |
| 1027 { |
| 1028 UErrorCode err = U_ZERO_ERROR; |
| 1029 GregorianCalendar cal(err); |
| 1030 |
| 1031 const Formattable ftarray[] = |
| 1032 { |
| 1033 Formattable( UDate(8.71068e+011), Formattable::kIsDate ) |
| 1034 }; |
| 1035 const int32_t ft_cnt = sizeof(ftarray) / sizeof(Formattable); |
| 1036 Formattable ft_arr( ftarray, ft_cnt ); |
| 1037 |
| 1038 Formattable* fmt = new Formattable(UDate(8.71068e+011), Formattable::kIsDate
); |
| 1039 |
| 1040 UnicodeString result; |
| 1041 |
| 1042 //UnicodeString formatStr = "At {1,time} on {1,date}, you made a {2} of {0,n
umber,currency}."; |
| 1043 UnicodeString formatStr = "On {0,date}, it began."; |
| 1044 UnicodeString compareStr = "On Aug 8, 1997, it began."; |
| 1045 |
| 1046 err = U_ZERO_ERROR; |
| 1047 MessageFormat msg( formatStr, err); |
| 1048 FieldPosition fp(0); |
| 1049 |
| 1050 result = ""; |
| 1051 fp = 0; |
| 1052 result = msg.format( |
| 1053 *fmt, |
| 1054 result, |
| 1055 //FieldPosition(0), |
| 1056 fp, |
| 1057 err); |
| 1058 |
| 1059 if (err != U_ILLEGAL_ARGUMENT_ERROR) { |
| 1060 dataerrln("*** MSG format without expected error code. - %s", u_errorNam
e(err)); |
| 1061 } |
| 1062 err = U_ZERO_ERROR; |
| 1063 |
| 1064 result = ""; |
| 1065 fp = 0; |
| 1066 result = msg.format( |
| 1067 ft_arr, |
| 1068 result, |
| 1069 //FieldPosition(0), |
| 1070 fp, |
| 1071 err); |
| 1072 |
| 1073 logln("MSG format( Formattable&, ... ) expected:" + compareStr); |
| 1074 logln("MSG format( Formattable&, ... ) result:" + result); |
| 1075 if (result != compareStr) { |
| 1076 dataerrln("*** MSG format( Formattable&, .... ) err. - %s", u_errorName
(err)); |
| 1077 }else{ |
| 1078 logln("MSG format( Formattable&, ... ) tested."); |
| 1079 } |
| 1080 |
| 1081 delete fmt; |
| 1082 |
| 1083 } |
| 1084 |
| 1085 void TestMessageFormat::testParse() |
| 1086 { |
| 1087 UErrorCode err = U_ZERO_ERROR; |
| 1088 int32_t count; |
| 1089 UnicodeString msgFormatString = "{0} =sep= {1}"; |
| 1090 MessageFormat msg( msgFormatString, err); |
| 1091 UnicodeString source = "abc =sep= def"; |
| 1092 UnicodeString tmp1, tmp2; |
| 1093 |
| 1094 Formattable* fmt_arr = msg.parse( source, count, err ); |
| 1095 if (U_FAILURE(err) || (!fmt_arr)) { |
| 1096 errln("*** MSG parse (ustring, count, err) error."); |
| 1097 }else{ |
| 1098 logln("MSG parse -- count: %d", count); |
| 1099 if (count != 2) { |
| 1100 errln("*** MSG parse (ustring, count, err) count err."); |
| 1101 }else{ |
| 1102 if ((fmt_arr[0].getType() == Formattable::kString) |
| 1103 && (fmt_arr[1].getType() == Formattable::kString) |
| 1104 && (fmt_arr[0].getString(tmp1) == "abc") |
| 1105 && (fmt_arr[1].getString(tmp2) == "def")) { |
| 1106 logln("MSG parse (ustring, count, err) tested."); |
| 1107 }else{ |
| 1108 errln("*** MSG parse (ustring, count, err) result err."); |
| 1109 } |
| 1110 } |
| 1111 } |
| 1112 delete[] fmt_arr; |
| 1113 |
| 1114 ParsePosition pp(0); |
| 1115 |
| 1116 fmt_arr = msg.parse( source, pp, count ); |
| 1117 if ((pp == 0) || (!fmt_arr)) { |
| 1118 errln("*** MSG parse (ustring, parsepos., count) error."); |
| 1119 }else{ |
| 1120 logln("MSG parse -- count: %d", count); |
| 1121 if (count != 2) { |
| 1122 errln("*** MSG parse (ustring, parsepos., count) count err."); |
| 1123 }else{ |
| 1124 if ((fmt_arr[0].getType() == Formattable::kString) |
| 1125 && (fmt_arr[1].getType() == Formattable::kString) |
| 1126 && (fmt_arr[0].getString(tmp1) == "abc") |
| 1127 && (fmt_arr[1].getString(tmp2) == "def")) { |
| 1128 logln("MSG parse (ustring, parsepos., count) tested."); |
| 1129 }else{ |
| 1130 errln("*** MSG parse (ustring, parsepos., count) result err."); |
| 1131 } |
| 1132 } |
| 1133 } |
| 1134 delete[] fmt_arr; |
| 1135 |
| 1136 pp = 0; |
| 1137 Formattable fmta; |
| 1138 |
| 1139 msg.parseObject( source, fmta, pp ); |
| 1140 if (pp == 0) { |
| 1141 errln("*** MSG parse (ustring, Formattable, parsepos ) error."); |
| 1142 }else{ |
| 1143 logln("MSG parse -- count: %d", count); |
| 1144 fmta.getArray(count); |
| 1145 if (count != 2) { |
| 1146 errln("*** MSG parse (ustring, Formattable, parsepos ) count err."); |
| 1147 }else{ |
| 1148 if ((fmta[0].getType() == Formattable::kString) |
| 1149 && (fmta[1].getType() == Formattable::kString) |
| 1150 && (fmta[0].getString(tmp1) == "abc") |
| 1151 && (fmta[1].getString(tmp2) == "def")) { |
| 1152 logln("MSG parse (ustring, Formattable, parsepos ) tested."); |
| 1153 }else{ |
| 1154 errln("*** MSG parse (ustring, Formattable, parsepos ) result er
r."); |
| 1155 } |
| 1156 } |
| 1157 } |
| 1158 } |
| 1159 |
| 1160 |
| 1161 void TestMessageFormat::testAdopt() |
| 1162 { |
| 1163 UErrorCode err = U_ZERO_ERROR; |
| 1164 |
| 1165 UnicodeString formatStr("{0,date},{1},{2,number}", ""); |
| 1166 UnicodeString formatStrChange("{0,number},{1,number},{2,date}", ""); |
| 1167 err = U_ZERO_ERROR; |
| 1168 MessageFormat msg( formatStr, err); |
| 1169 MessageFormat msgCmp( formatStr, err); |
| 1170 int32_t count, countCmp; |
| 1171 const Format** formats = msg.getFormats(count); |
| 1172 const Format** formatsCmp = msgCmp.getFormats(countCmp); |
| 1173 const Format** formatsChg = 0; |
| 1174 const Format** formatsAct = 0; |
| 1175 int32_t countAct; |
| 1176 const Format* a; |
| 1177 const Format* b; |
| 1178 UnicodeString patCmp; |
| 1179 UnicodeString patAct; |
| 1180 Format** formatsToAdopt; |
| 1181 |
| 1182 if (!formats || !formatsCmp || (count <= 0) || (count != countCmp)) { |
| 1183 dataerrln("Error getting Formats"); |
| 1184 return; |
| 1185 } |
| 1186 |
| 1187 int32_t i; |
| 1188 |
| 1189 for (i = 0; i < count; i++) { |
| 1190 a = formats[i]; |
| 1191 b = formatsCmp[i]; |
| 1192 if ((a != NULL) && (b != NULL)) { |
| 1193 if (*a != *b) { |
| 1194 errln("a != b"); |
| 1195 return; |
| 1196 } |
| 1197 }else if ((a != NULL) || (b != NULL)) { |
| 1198 errln("(a != NULL) || (b != NULL)"); |
| 1199 return; |
| 1200 } |
| 1201 } |
| 1202 |
| 1203 msg.applyPattern( formatStrChange, err ); //set msg formats to something dif
ferent |
| 1204 int32_t countChg; |
| 1205 formatsChg = msg.getFormats(countChg); // tested function |
| 1206 if (!formatsChg || (countChg != count)) { |
| 1207 errln("Error getting Formats"); |
| 1208 return; |
| 1209 } |
| 1210 |
| 1211 UBool diff; |
| 1212 diff = TRUE; |
| 1213 for (i = 0; i < count; i++) { |
| 1214 a = formatsChg[i]; |
| 1215 b = formatsCmp[i]; |
| 1216 if ((a != NULL) && (b != NULL)) { |
| 1217 if (*a == *b) { |
| 1218 logln("formatsChg == formatsCmp at index %d", i); |
| 1219 diff = FALSE; |
| 1220 } |
| 1221 } |
| 1222 } |
| 1223 if (!diff) { |
| 1224 errln("*** MSG getFormats diff err."); |
| 1225 return; |
| 1226 } |
| 1227 |
| 1228 logln("MSG getFormats tested."); |
| 1229 |
| 1230 msg.setFormats( formatsCmp, countCmp ); //tested function |
| 1231 |
| 1232 formatsAct = msg.getFormats(countAct); |
| 1233 if (!formatsAct || (countAct <=0) || (countAct != countCmp)) { |
| 1234 errln("Error getting Formats"); |
| 1235 return; |
| 1236 } |
| 1237 |
| 1238 assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove
())); |
| 1239 assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove())); |
| 1240 |
| 1241 for (i = 0; i < countAct; i++) { |
| 1242 a = formatsAct[i]; |
| 1243 b = formatsCmp[i]; |
| 1244 if ((a != NULL) && (b != NULL)) { |
| 1245 if (*a != *b) { |
| 1246 logln("formatsAct != formatsCmp at index %d", i); |
| 1247 errln("a != b"); |
| 1248 return; |
| 1249 } |
| 1250 }else if ((a != NULL) || (b != NULL)) { |
| 1251 errln("(a != NULL) || (b != NULL)"); |
| 1252 return; |
| 1253 } |
| 1254 } |
| 1255 logln("MSG setFormats tested."); |
| 1256 |
| 1257 //---- |
| 1258 |
| 1259 msg.applyPattern( formatStrChange, err ); //set msg formats to something dif
ferent |
| 1260 |
| 1261 formatsToAdopt = new Format* [countCmp]; |
| 1262 if (!formatsToAdopt) { |
| 1263 errln("memory allocation error"); |
| 1264 return; |
| 1265 } |
| 1266 |
| 1267 for (i = 0; i < countCmp; i++) { |
| 1268 if (formatsCmp[i] == NULL) { |
| 1269 formatsToAdopt[i] = NULL; |
| 1270 }else{ |
| 1271 formatsToAdopt[i] = formatsCmp[i]->clone(); |
| 1272 if (!formatsToAdopt[i]) { |
| 1273 errln("Can't clone format at index %d", i); |
| 1274 return; |
| 1275 } |
| 1276 } |
| 1277 } |
| 1278 msg.adoptFormats( formatsToAdopt, countCmp ); // function to test |
| 1279 delete[] formatsToAdopt; |
| 1280 |
| 1281 assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove
())); |
| 1282 assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove())); |
| 1283 |
| 1284 formatsAct = msg.getFormats(countAct); |
| 1285 if (!formatsAct || (countAct <=0) || (countAct != countCmp)) { |
| 1286 errln("Error getting Formats"); |
| 1287 return; |
| 1288 } |
| 1289 |
| 1290 for (i = 0; i < countAct; i++) { |
| 1291 a = formatsAct[i]; |
| 1292 b = formatsCmp[i]; |
| 1293 if ((a != NULL) && (b != NULL)) { |
| 1294 if (*a != *b) { |
| 1295 errln("a != b"); |
| 1296 return; |
| 1297 } |
| 1298 }else if ((a != NULL) || (b != NULL)) { |
| 1299 errln("(a != NULL) || (b != NULL)"); |
| 1300 return; |
| 1301 } |
| 1302 } |
| 1303 logln("MSG adoptFormats tested."); |
| 1304 |
| 1305 //---- adoptFormat |
| 1306 |
| 1307 msg.applyPattern( formatStrChange, err ); //set msg formats to something dif
ferent |
| 1308 |
| 1309 formatsToAdopt = new Format* [countCmp]; |
| 1310 if (!formatsToAdopt) { |
| 1311 errln("memory allocation error"); |
| 1312 return; |
| 1313 } |
| 1314 |
| 1315 for (i = 0; i < countCmp; i++) { |
| 1316 if (formatsCmp[i] == NULL) { |
| 1317 formatsToAdopt[i] = NULL; |
| 1318 }else{ |
| 1319 formatsToAdopt[i] = formatsCmp[i]->clone(); |
| 1320 if (!formatsToAdopt[i]) { |
| 1321 errln("Can't clone format at index %d", i); |
| 1322 return; |
| 1323 } |
| 1324 } |
| 1325 } |
| 1326 |
| 1327 for ( i = 0; i < countCmp; i++ ) { |
| 1328 msg.adoptFormat( i, formatsToAdopt[i] ); // function to test |
| 1329 } |
| 1330 delete[] formatsToAdopt; // array itself not needed in this case; |
| 1331 |
| 1332 assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove
())); |
| 1333 assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove())); |
| 1334 |
| 1335 formatsAct = msg.getFormats(countAct); |
| 1336 if (!formatsAct || (countAct <=0) || (countAct != countCmp)) { |
| 1337 errln("Error getting Formats"); |
| 1338 return; |
| 1339 } |
| 1340 |
| 1341 for (i = 0; i < countAct; i++) { |
| 1342 a = formatsAct[i]; |
| 1343 b = formatsCmp[i]; |
| 1344 if ((a != NULL) && (b != NULL)) { |
| 1345 if (*a != *b) { |
| 1346 errln("a != b"); |
| 1347 return; |
| 1348 } |
| 1349 }else if ((a != NULL) || (b != NULL)) { |
| 1350 errln("(a != NULL) || (b != NULL)"); |
| 1351 return; |
| 1352 } |
| 1353 } |
| 1354 logln("MSG adoptFormat tested."); |
| 1355 } |
| 1356 |
| 1357 // This test is a regression test for a fixed bug in the copy constructor. |
| 1358 // It is kept as a global function rather than as a method since the test depend
s on memory values. |
| 1359 // (At least before the bug was fixed, whether it showed up or not depended on m
emory contents, |
| 1360 // which is probably why it didn't show up in the regular test for the copy cons
tructor.) |
| 1361 // For this reason, the test isn't changed even though it contains function call
s whose results are |
| 1362 // not tested and had no problems. Actually, the test failed by *crashing*. |
| 1363 static void _testCopyConstructor2() |
| 1364 { |
| 1365 UErrorCode status = U_ZERO_ERROR; |
| 1366 UnicodeString formatStr("Hello World on {0,date,full}", ""); |
| 1367 UnicodeString resultStr(" ", ""); |
| 1368 UnicodeString result; |
| 1369 FieldPosition fp(0); |
| 1370 UDate d = Calendar::getNow(); |
| 1371 const Formattable fargs( d, Formattable::kIsDate ); |
| 1372 |
| 1373 MessageFormat* fmt1 = new MessageFormat( formatStr, status ); |
| 1374 MessageFormat* fmt2 = new MessageFormat( *fmt1 ); |
| 1375 MessageFormat* fmt3; |
| 1376 MessageFormat* fmt4; |
| 1377 |
| 1378 if (fmt1 == NULL) it_err("testCopyConstructor2: (fmt1 != NULL)"); |
| 1379 |
| 1380 result = fmt1->format( &fargs, 1, resultStr, fp, status ); |
| 1381 |
| 1382 if (fmt2 == NULL) it_err("testCopyConstructor2: (fmt2 != NULL)"); |
| 1383 |
| 1384 fmt3 = (MessageFormat*) fmt1->clone(); |
| 1385 fmt4 = (MessageFormat*) fmt2->clone(); |
| 1386 |
| 1387 if (fmt3 == NULL) it_err("testCopyConstructor2: (fmt3 != NULL)"); |
| 1388 if (fmt4 == NULL) it_err("testCopyConstructor2: (fmt4 != NULL)"); |
| 1389 |
| 1390 result = fmt1->format( &fargs, 1, resultStr, fp, status ); |
| 1391 result = fmt2->format( &fargs, 1, resultStr, fp, status ); |
| 1392 result = fmt3->format( &fargs, 1, resultStr, fp, status ); |
| 1393 result = fmt4->format( &fargs, 1, resultStr, fp, status ); |
| 1394 delete fmt1; |
| 1395 delete fmt2; |
| 1396 delete fmt3; |
| 1397 delete fmt4; |
| 1398 } |
| 1399 |
| 1400 void TestMessageFormat::testCopyConstructor2() { |
| 1401 _testCopyConstructor2(); |
| 1402 } |
| 1403 |
| 1404 /** |
| 1405 * Verify that MessageFormat accomodates more than 10 arguments and |
| 1406 * more than 10 subformats. |
| 1407 */ |
| 1408 void TestMessageFormat::TestUnlimitedArgsAndSubformats() { |
| 1409 UErrorCode ec = U_ZERO_ERROR; |
| 1410 const UnicodeString pattern = |
| 1411 "On {0,date} (aka {0,date,short}, aka {0,date,long}) " |
| 1412 "at {0,time} (aka {0,time,short}, aka {0,time,long}) " |
| 1413 "there were {1,number} werjes " |
| 1414 "(a {3,number,percent} increase over {2,number}) " |
| 1415 "despite the {4}''s efforts " |
| 1416 "and to delight of {5}, {6}, {7}, {8}, {9}, and {10} {11}."; |
| 1417 MessageFormat msg(pattern, ec); |
| 1418 if (U_FAILURE(ec)) { |
| 1419 dataerrln("FAIL: constructor failed - %s", u_errorName(ec)); |
| 1420 return; |
| 1421 } |
| 1422 |
| 1423 const Formattable ARGS[] = { |
| 1424 Formattable(UDate(1e13), Formattable::kIsDate), |
| 1425 Formattable((int32_t)1303), |
| 1426 Formattable((int32_t)1202), |
| 1427 Formattable(1303.0/1202 - 1), |
| 1428 Formattable("Glimmung"), |
| 1429 Formattable("the printers"), |
| 1430 Formattable("Nick"), |
| 1431 Formattable("his father"), |
| 1432 Formattable("his mother"), |
| 1433 Formattable("the spiddles"), |
| 1434 Formattable("of course"), |
| 1435 Formattable("Horace"), |
| 1436 }; |
| 1437 const int32_t ARGS_LENGTH = sizeof(ARGS) / sizeof(ARGS[0]); |
| 1438 Formattable ARGS_OBJ(ARGS, ARGS_LENGTH); |
| 1439 |
| 1440 UnicodeString expected = |
| 1441 "On Nov 20, 2286 (aka 11/20/86, aka November 20, 2286) " |
| 1442 "at 9:46:40 AM (aka 9:46 AM, aka 9:46:40 AM PST) " |
| 1443 "there were 1,303 werjes " |
| 1444 "(a 8% increase over 1,202) " |
| 1445 "despite the Glimmung's efforts " |
| 1446 "and to delight of the printers, Nick, his father, " |
| 1447 "his mother, the spiddles, and of course Horace."; |
| 1448 UnicodeString result; |
| 1449 msg.format(ARGS_OBJ, result, ec); |
| 1450 if (result == expected) { |
| 1451 logln(result); |
| 1452 } else { |
| 1453 errln((UnicodeString)"FAIL: Got " + result + |
| 1454 ", expected " + expected); |
| 1455 } |
| 1456 } |
| 1457 |
| 1458 // test RBNF extensions to message format |
| 1459 void TestMessageFormat::TestRBNF(void) { |
| 1460 // WARNING: this depends on the RBNF formats for en_US |
| 1461 Locale locale("en", "US", ""); |
| 1462 |
| 1463 UErrorCode ec = U_ZERO_ERROR; |
| 1464 |
| 1465 UnicodeString values[] = { |
| 1466 // decimal values do not format completely for ordinal or duration, and |
| 1467 // do not always parse, so do not include them |
| 1468 "0", "1", "12", "100", "123", "1001", "123,456", "-17", |
| 1469 }; |
| 1470 int32_t values_count = sizeof(values)/sizeof(values[0]); |
| 1471 |
| 1472 UnicodeString formats[] = { |
| 1473 "There are {0,spellout} files to search.", |
| 1474 "There are {0,spellout,%simplified} files to search.", |
| 1475 "The bogus spellout {0,spellout,%BOGUS} files behaves like the default."
, |
| 1476 "This is the {0,ordinal} file to search.", // TODO fix bug, ordinal does
not parse |
| 1477 "Searching this file will take {0,duration} to complete.", |
| 1478 "Searching this file will take {0,duration,%with-words} to complete.", |
| 1479 }; |
| 1480 int32_t formats_count = sizeof(formats)/sizeof(formats[0]); |
| 1481 |
| 1482 Formattable args[1]; |
| 1483 |
| 1484 NumberFormat* numFmt = NumberFormat::createInstance(locale, ec); |
| 1485 if (U_FAILURE(ec)) { |
| 1486 dataerrln("Error calling NumberFormat::createInstance()"); |
| 1487 return; |
| 1488 } |
| 1489 |
| 1490 for (int i = 0; i < formats_count; ++i) { |
| 1491 MessageFormat* fmt = new MessageFormat(formats[i], locale, ec); |
| 1492 logln((UnicodeString)"Testing format pattern: '" + formats[i] + "'"); |
| 1493 |
| 1494 for (int j = 0; j < values_count; ++j) { |
| 1495 ec = U_ZERO_ERROR; |
| 1496 numFmt->parse(values[j], args[0], ec); |
| 1497 if (U_FAILURE(ec)) { |
| 1498 errln((UnicodeString)"Failed to parse test argument " + values[j
]); |
| 1499 } else { |
| 1500 FieldPosition fp(0); |
| 1501 UnicodeString result; |
| 1502 fmt->format(args, 1, result, fp, ec); |
| 1503 logln((UnicodeString)"value: " + toString(args[0]) + " --> " + r
esult + UnicodeString(" ec: ") + u_errorName(ec)); |
| 1504 |
| 1505 if (i != 3) { // TODO: fix this, for now skip ordinal parsing (f
ormat string at index 3) |
| 1506 int32_t count = 0; |
| 1507 Formattable* parseResult = fmt->parse(result, count, ec); |
| 1508 if (count != 1) { |
| 1509 errln((UnicodeString)"parse returned " + count + " args"
); |
| 1510 } else if (parseResult[0] != args[0]) { |
| 1511 errln((UnicodeString)"parsed argument " + toString(parse
Result[0]) + " != " + toString(args[0])); |
| 1512 } |
| 1513 delete []parseResult; |
| 1514 } |
| 1515 } |
| 1516 } |
| 1517 delete fmt; |
| 1518 } |
| 1519 delete numFmt; |
| 1520 } |
| 1521 |
| 1522 void TestMessageFormat::testAutoQuoteApostrophe(void) { |
| 1523 const char* patterns[] = { // pattern, expected pattern |
| 1524 "'", "''", |
| 1525 "''", "''", |
| 1526 "'{", "'{'", |
| 1527 "' {", "'' {", |
| 1528 "'a", "''a", |
| 1529 "'{'a", "'{'a", |
| 1530 "'{a'", "'{a'", |
| 1531 "'{}", "'{}'", |
| 1532 "{'", "{'", |
| 1533 "{'a", "{'a", |
| 1534 "{'a{}'a}'a", "{'a{}'a}''a", |
| 1535 "'}'", "'}'", |
| 1536 "'} '{'}'", "'} '{'}''", |
| 1537 "'} {{{''", "'} {{{'''", |
| 1538 }; |
| 1539 int32_t pattern_count = sizeof(patterns)/sizeof(patterns[0]); |
| 1540 |
| 1541 for (int i = 0; i < pattern_count; i += 2) { |
| 1542 UErrorCode status = U_ZERO_ERROR; |
| 1543 UnicodeString result = MessageFormat::autoQuoteApostrophe(patterns[i], s
tatus); |
| 1544 UnicodeString target(patterns[i+1]); |
| 1545 if (target != result) { |
| 1546 const int BUF2_LEN = 64; |
| 1547 char buf[256]; |
| 1548 char buf2[BUF2_LEN]; |
| 1549 int32_t len = result.extract(0, result.length(), buf2, BUF2_LEN); |
| 1550 if (len >= BUF2_LEN) { |
| 1551 buf2[BUF2_LEN-1] = 0; |
| 1552 } |
| 1553 sprintf(buf, "[%2d] test \"%s\": target (\"%s\") != result (\"%s\")\
n", i/2, patterns[i], patterns[i+1], buf2); |
| 1554 errln(buf); |
| 1555 } |
| 1556 } |
| 1557 } |
| 1558 |
| 1559 void TestMessageFormat::testCoverage(void) { |
| 1560 UErrorCode status = U_ZERO_ERROR; |
| 1561 UnicodeString testformat("{argument, plural, one{C''est # fichier} other {Ce
sont # fichiers}} dans la liste."); |
| 1562 MessageFormat *msgfmt = new MessageFormat(testformat, Locale("fr"), status); |
| 1563 if (msgfmt == NULL || U_FAILURE(status)) { |
| 1564 dataerrln("FAIL: Unable to create MessageFormat.: %s", u_errorName(statu
s)); |
| 1565 return; |
| 1566 } |
| 1567 if (!msgfmt->usesNamedArguments()) { |
| 1568 errln("FAIL: Unable to detect usage of named arguments."); |
| 1569 } |
| 1570 const double limit[] = {0.0, 1.0, 2.0}; |
| 1571 const UnicodeString formats[] = {"0.0<=Arg<1.0", |
| 1572 "1.0<=Arg<2.0", |
| 1573 "2.0<-Arg"}; |
| 1574 ChoiceFormat cf(limit, formats, 3); |
| 1575 |
| 1576 msgfmt->setFormat("set", cf, status); |
| 1577 |
| 1578 StringEnumeration *en = msgfmt->getFormatNames(status); |
| 1579 if (en == NULL || U_FAILURE(status)) { |
| 1580 errln("FAIL: Unable to get format names enumeration."); |
| 1581 } else { |
| 1582 int32_t count = 0; |
| 1583 en->reset(status); |
| 1584 count = en->count(status); |
| 1585 if (U_FAILURE(status)) { |
| 1586 errln("FAIL: Unable to get format name enumeration count."); |
| 1587 } else { |
| 1588 for (int32_t i = 0; i < count; i++) { |
| 1589 en->snext(status); |
| 1590 if (U_FAILURE(status)) { |
| 1591 errln("FAIL: Error enumerating through names."); |
| 1592 break; |
| 1593 } |
| 1594 } |
| 1595 } |
| 1596 } |
| 1597 |
| 1598 msgfmt->adoptFormat("adopt", &cf, status); |
| 1599 |
| 1600 delete en; |
| 1601 delete msgfmt; |
| 1602 |
| 1603 msgfmt = new MessageFormat("'", status); |
| 1604 if (msgfmt == NULL || U_FAILURE(status)) { |
| 1605 errln("FAIL: Unable to create MessageFormat."); |
| 1606 return; |
| 1607 } |
| 1608 if (msgfmt->usesNamedArguments()) { |
| 1609 errln("FAIL: Unable to detect usage of named arguments."); |
| 1610 } |
| 1611 |
| 1612 msgfmt->setFormat("formatName", cf, status); |
| 1613 if (!U_FAILURE(status)) { |
| 1614 errln("FAIL: Should fail to setFormat instead of passing."); |
| 1615 } |
| 1616 status = U_ZERO_ERROR; |
| 1617 en = msgfmt->getFormatNames(status); |
| 1618 if (!U_FAILURE(status)) { |
| 1619 errln("FAIL: Should fail to get format names enumeration instead of pass
ing."); |
| 1620 } |
| 1621 |
| 1622 delete en; |
| 1623 delete msgfmt; |
| 1624 } |
| 1625 |
| 1626 #endif /* #if !UCONFIG_NO_FORMATTING */ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 5516007:
Check in the pristine copy of ICU 4.6... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/