1/******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2010, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ******************************************************************** 6 * 7 * File CMSGTST.C 8 * 9 * Modification History: 10 * Name Description 11 * Madhu Katragadda Creation 12 ********************************************************************/ 13/* C API TEST FOR MESSAGE FORMAT */ 14 15#include "unicode/utypes.h" 16 17#if !UCONFIG_NO_FORMATTING 18 19#include <stdlib.h> 20#include <string.h> 21#include <stdarg.h> 22#include "unicode/uloc.h" 23#include "unicode/umsg.h" 24#include "unicode/udat.h" 25#include "unicode/umsg.h" 26#include "unicode/ustring.h" 27#include "cintltst.h" 28#include "cmsgtst.h" 29#include "cformtst.h" 30 31static const char* const txt_testCasePatterns[] = { 32 "Quotes '', '{', a {0,number,integer} '{'0}", 33 "Quotes '', '{', a {0,number,integer} '{'0}", 34 "You deposited {0,number,integer} times an amount of {1,number,currency} on {2,date,short}", 35 "'{'2,time,full}, for {1, number }, {0,number,integer} is {2,time,full} and full date is {2,date,full}", 36 "'{'1,number,percent} for {0,number,integer} is {1,number,percent}", 37}; 38 39static const char* const txt_testResultStrings[] = { 40 "Quotes ', {, a 1 {0}", 41 "Quotes ', {, a 1 {0}", 42 "You deposited 1 times an amount of $3,456.00 on 1/12/70", 43 "{2,time,full}, for 3,456, 1 is 5:46:40 AM Pacific Standard Time and full date is Monday, January 12, 1970", 44 "{1,number,percent} for 1 is 345,600%" 45}; 46 47const int32_t cnt_testCases = 5; 48static UChar* testCasePatterns[5]; 49 50static UChar* testResultStrings[5]; 51 52static UBool strings_initialized = FALSE; 53 54/* function used to create the test patterns for testing Message formatting */ 55static void InitStrings( void ) 56{ 57 int32_t i; 58 if (strings_initialized) 59 return; 60 61 for (i=0; i < cnt_testCases; i++ ) { 62 uint32_t strSize = (uint32_t)strlen(txt_testCasePatterns[i]) + 1; 63 testCasePatterns[i]=(UChar*)malloc(sizeof(UChar) * strSize); 64 u_uastrncpy(testCasePatterns[i], txt_testCasePatterns[i], strSize); 65 } 66 for (i=0; i < cnt_testCases; i++ ) { 67 uint32_t strSize = (uint32_t)strlen(txt_testResultStrings[i]) + 1; 68 testResultStrings[i] = (UChar*)malloc(sizeof(UChar) * strSize); 69 u_uastrncpy(testResultStrings[i], txt_testResultStrings[i], strSize); 70 } 71 72 strings_initialized = TRUE; 73} 74 75static void FreeStrings( void ) 76{ 77 int32_t i; 78 if (!strings_initialized) 79 return; 80 81 for (i=0; i < cnt_testCases; i++ ) { 82 free(testCasePatterns[i]); 83 } 84 for (i=0; i < cnt_testCases; i++ ) { 85 free(testResultStrings[i]); 86 } 87 strings_initialized = FALSE; 88} 89 90/* Platform dependent test to detect if this type will return NULL when interpreted as a pointer. */ 91static UBool returnsNullForType(int firstParam, ...) { 92 UBool isNULL; 93 va_list marker; 94 va_start(marker, firstParam); 95 isNULL = (UBool)(va_arg(marker, void*) == NULL); 96 va_end(marker); 97 return isNULL; 98} 99 100/* Test u_formatMessage() with various test patterns() */ 101static void MessageFormatTest( void ) 102{ 103 UChar *str; 104 UChar* result; 105 int32_t resultLengthOut,resultlength,i, patternlength; 106 UErrorCode status = U_ZERO_ERROR; 107 UDate d1=1000000000.0; 108 109 ctest_setTimeZone(NULL, &status); 110 111 str=(UChar*)malloc(sizeof(UChar) * 7); 112 u_uastrncpy(str, "MyDisk", 7); 113 resultlength=1; 114 result=(UChar*)malloc(sizeof(UChar) * 1); 115 log_verbose("Testing u_formatMessage()\n"); 116 InitStrings(); 117 for (i = 0; i < cnt_testCases; i++) { 118 status=U_ZERO_ERROR; 119 patternlength=u_strlen(testCasePatterns[i]); 120 resultLengthOut=u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, 121 &status, 1, 3456.00, d1); 122 if(status== U_BUFFER_OVERFLOW_ERROR) 123 { 124 status=U_ZERO_ERROR; 125 resultlength=resultLengthOut+1; 126 result=(UChar*)realloc(result,sizeof(UChar) * resultlength); 127 u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, 128 &status, 1, 3456.00, d1); 129 } 130 if(U_FAILURE(status)){ 131 log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) ); 132 continue; 133 } 134 if(u_strcmp(result, testResultStrings[i])==0){ 135 log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); 136 } 137 else{ 138 log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, 139 austrdup(result), austrdup(testResultStrings[i]) ); 140 } 141 } 142 free(result); 143 result = NULL; 144 free(str); 145 { 146 147 for (i = 0; i < cnt_testCases; i++) { 148 UParseError parseError; 149 status=U_ZERO_ERROR; 150 patternlength=u_strlen(testCasePatterns[i]); 151 resultlength=0; 152 resultLengthOut=u_formatMessageWithError( "en_US",testCasePatterns[i], patternlength, result, resultlength, 153 &parseError,&status, 1, 3456.00, d1); 154 if(status== U_BUFFER_OVERFLOW_ERROR) 155 { 156 status=U_ZERO_ERROR; 157 resultlength=resultLengthOut+1; 158 result=(UChar*)malloc(sizeof(UChar) * resultlength); 159 u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, 160 &status, 1, 3456.00, d1); 161 } 162 if(U_FAILURE(status)){ 163 log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) ); 164 continue; 165 } 166 if(u_strcmp(result, testResultStrings[i])==0){ 167 log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); 168 } 169 else{ 170 log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, 171 austrdup(result), austrdup(testResultStrings[i]) ); 172 } 173 free(result); 174 result=NULL; 175 } 176 } 177 { 178 UErrorCode ec = U_ZERO_ERROR; 179 int32_t patternLength = u_strlen(testCasePatterns[0]); 180 181 UMessageFormat formatter = umsg_open(testCasePatterns[0],patternLength,"en_US",NULL,&ec); 182 183 if(U_FAILURE(ec)){ 184 log_data_err("umsg_open() failed for testCasePattens[%d]. -> %s (Are you missing data?)\n",i, u_errorName(ec)); 185 return; 186 } 187 for(i = 0;i<cnt_testCases; i++){ 188 UParseError parseError; 189 int32_t resultLength =0,count=0; 190 int32_t one=0; 191 int32_t two=0; 192 UDate d2=0; 193 194 result=NULL; 195 patternLength = u_strlen(testCasePatterns[i]); 196 197 umsg_applyPattern(formatter,testCasePatterns[i],patternLength,&parseError,&ec); 198 if(U_FAILURE(ec)){ 199 log_err("umsg_applyPattern() failed for testCasePattens[%d].\n",i); 200 return; 201 } 202 /* pre-flight */ 203 resultLength = umsg_format(formatter,result,resultLength,&ec,1,3456.00,d1); 204 if(ec==U_BUFFER_OVERFLOW_ERROR){ 205 ec=U_ZERO_ERROR; 206 result = (UChar*) malloc(U_SIZEOF_UCHAR*resultLength+2); 207 resultLength = umsg_format(formatter,result,resultLength+2,&ec,1,3456.00,d1); 208 if(U_FAILURE(ec)){ 209 log_err("ERROR: failure in message format on testcase %d: %s\n", i, u_errorName(status) ); 210 free(result); 211 return; 212 } 213 214 if(u_strcmp(result, testResultStrings[i])==0){ 215 log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); 216 } 217 else{ 218 log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, 219 austrdup(result), austrdup(testResultStrings[i]) ); 220 } 221 222 if (returnsNullForType(1, (double)2.0)) { 223 /* HP/UX and possibly other platforms don't properly check for this case. 224 We pass in a UDate, but the function expects a UDate *. When va_arg is used, 225 most compilers will return NULL, but HP-UX won't do that and will return 2 226 in this case. This is a platform dependent test. 227 228 This relies upon "undefined" behavior, as indicated by C99 7.15.1.1 paragraph 2 229 */ 230 umsg_parse(formatter,result,resultLength,&count,&ec,one,two,d2); 231 if(ec!=U_ILLEGAL_ARGUMENT_ERROR){ 232 log_err("FAIL: Did not get expected error for umsg_parse(). Expected: U_ILLEGAL_ARGUMENT_ERROR Got: %s \n",u_errorName(ec)); 233 }else{ 234 ec = U_ZERO_ERROR; 235 } 236 } 237 else { 238 log_verbose("Warning: Returning NULL for a mismatched va_arg type isn't supported on this platform.\n", i); 239 } 240 241 umsg_parse(formatter,result,resultLength,&count,&ec,&one,&two,&d2); 242 if(U_FAILURE(ec)){ 243 log_err("umsg_parse could not parse the pattern. Error: %s.\n",u_errorName(ec)); 244 } 245 free(result); 246 }else{ 247 log_err("FAIL: Expected U_BUFFER_OVERFLOW error while preflighting got: %s for testCasePatterns[%d]",u_errorName(ec),i); 248 } 249 } 250 umsg_close(formatter); 251 } 252 FreeStrings(); 253 254 ctest_resetTimeZone(); 255} 256 257 258/*test u_formatMessage() with sample patterns */ 259static void TestSampleMessageFormat(void) 260{ 261 UChar *str; 262 UChar *result; 263 UChar pattern[100], expected[100]; 264 int32_t resultLengthOut, resultlength; 265 UDate d = 837039928046.0; 266 UErrorCode status = U_ZERO_ERROR; 267 268 ctest_setTimeZone(NULL, &status); 269 270 str=(UChar*)malloc(sizeof(UChar) * 15); 271 u_uastrcpy(str, "abc"); 272 273 u_uastrcpy(pattern, "There are {0} files on {1,date}"); 274 u_uastrcpy(expected, "There are abc files on Jul 10, 1996"); 275 result=(UChar*)malloc(sizeof(UChar) * 1); 276 log_verbose("\nTesting a sample for Message format test#1\n"); 277 resultlength=1; 278 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d); 279 if(status==U_BUFFER_OVERFLOW_ERROR) 280 { 281 status=U_ZERO_ERROR; 282 resultlength=resultLengthOut+1; 283 result=(UChar*)realloc(result, sizeof(UChar) * resultlength); 284 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d); 285 } 286 if(U_FAILURE(status)){ 287 log_data_err("Error: failure in message format on test#1: %s (Are you missing data?)\n", myErrorName(status)); 288 } 289 else if(u_strcmp(result, expected)==0) 290 log_verbose("PASS: MessagFormat successful on test#1\n"); 291 else{ 292 log_err("FAIL: Error in MessageFormat on test#1 \n GOT: %s EXPECTED: %s\n", 293 austrdup(result), austrdup(expected) ); 294 } 295 296 297 log_verbose("\nTesting message format with another pattern test#2\n"); 298 u_uastrcpy(pattern, "The disk \"{0}\" contains {1,number,integer} file(s)"); 299 u_uastrcpy(expected, "The disk \"MyDisk\" contains 23 file(s)"); 300 u_uastrcpy(str, "MyDisk"); 301 302 resultLengthOut=u_formatMessage( "en_US", 303 pattern, 304 u_strlen(pattern), 305 result, 306 resultlength, 307 &status, 308 str, 309 235); 310 if(status==U_BUFFER_OVERFLOW_ERROR) 311 { 312 status=U_ZERO_ERROR; 313 resultlength=resultLengthOut+1; 314 result=(UChar*)realloc(result, sizeof(UChar) * (resultlength+1)); 315 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 23); 316 } 317 if(U_FAILURE(status)){ 318 log_data_err("Error: failure in message format on test#2 : %s (Are you missing data?)\n", myErrorName(status)); 319 } 320 else if(u_strcmp(result, expected)==0) 321 log_verbose("PASS: MessagFormat successful on test#2\n"); 322 else{ 323 log_err("FAIL: Error in MessageFormat on test#2\n GOT: %s EXPECTED: %s\n", 324 austrdup(result), austrdup(expected) ); 325 } 326 327 328 329 log_verbose("\nTesting message format with another pattern test#3\n"); 330 u_uastrcpy(pattern, "You made a {0} of {1,number,currency}"); 331 u_uastrcpy(expected, "You made a deposit of $500.00"); 332 u_uastrcpy(str, "deposit"); 333 resultlength=0; 334 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, str, 500.00); 335 if(status==U_BUFFER_OVERFLOW_ERROR) 336 { 337 status=U_ZERO_ERROR; 338 resultlength=resultLengthOut+1; 339 result=(UChar*)realloc(result, sizeof(UChar) * resultlength); 340 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 500.00); 341 } 342 if(U_FAILURE(status)){ 343 log_data_err("Error: failure in message format on test#3 : %s (Are you missing data?)\n", myErrorName(status)); 344 } 345 else if(u_strcmp(result, expected)==0) 346 log_verbose("PASS: MessagFormat successful on test#3\n"); 347 else{ 348 log_err("FAIL: Error in MessageFormat on test#3\n GOT: %s EXPECTED %s\n", austrdup(result), 349 austrdup(expected) ); 350 } 351 352 free(result); 353 free(str); 354 355 ctest_resetTimeZone(); 356} 357 358/* Test umsg_format() and umsg_parse() , format and parse sequence and round trip */ 359static void TestNewFormatAndParseAPI(void) 360{ 361 362 UChar *result, tzID[4], str[25]; 363 UChar pattern[100]; 364 UChar expected[100]; 365 int32_t resultLengthOut, resultlength; 366 UCalendar *cal; 367 UDate d1,d; 368 UDateFormat *def1; 369 UErrorCode status = U_ZERO_ERROR; 370 int32_t value = 0; 371 UChar ret[30]; 372 UParseError parseError; 373 UMessageFormat* fmt = NULL; 374 int32_t count=0; 375 376 ctest_setTimeZone(NULL, &status); 377 378 log_verbose("Testing format and parse with parse error\n"); 379 380 u_uastrcpy(str, "disturbance in force"); 381 u_uastrcpy(tzID, "PST"); 382 cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status); 383 if(U_FAILURE(status)){ 384 log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) ); 385 return; 386 } 387 ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status); 388 d1=ucal_getMillis(cal, &status); 389 if(U_FAILURE(status)){ 390 log_err("Error: failure in get millis: %s\n", myErrorName(status) ); 391 return; 392 } 393 394 log_verbose("\nTesting with pattern test#4"); 395 u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}"); 396 u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7"); 397 resultlength=1; 398 fmt = umsg_open(pattern,u_strlen(pattern),"en_US",&parseError,&status); 399 if(U_FAILURE(status)){ 400 log_data_err("error in umsg_open : %s (Are you missing data?)\n", u_errorName(status) ); 401 return; 402 } 403 result=(UChar*)malloc(sizeof(UChar) * resultlength); 404 405 resultLengthOut=umsg_format(fmt ,result, resultlength,&status, d1, str, 7); 406 if(status==U_BUFFER_OVERFLOW_ERROR) 407 { 408 status=U_ZERO_ERROR; 409 resultlength=resultLengthOut+1; 410 result=(UChar*)realloc(result, sizeof(UChar) * resultlength); 411 u_formatMessageWithError( "en_US", pattern, u_strlen(pattern), result, resultlength,&parseError, &status, d1, str, 7); 412 413 } 414 if(U_FAILURE(status)){ 415 log_err("ERROR: failure in message format test#4: %s\n", myErrorName(status)); 416 } 417 if(u_strcmp(result, expected)==0) 418 log_verbose("PASS: MessagFormat successful on test#4\n"); 419 else{ 420 log_err("FAIL: Error in MessageFormat on test#4\n GOT: %s EXPECTED: %s\n", austrdup(result), 421 austrdup(expected) ); 422 } 423 424 425 /*try to parse this and check*/ 426 log_verbose("\nTesting the parse Message test#5\n"); 427 428 umsg_parse(fmt, result, u_strlen(result),&count,&status, &d, ret, &value); 429 if(U_FAILURE(status)){ 430 log_err("ERROR: error in parsing: test#5: %s\n", myErrorName(status)); 431 } 432 if(value!=7 && u_strcmp(str,ret)!=0) 433 log_err("FAIL: Error in parseMessage on test#5 \n"); 434 else 435 log_verbose("PASS: parseMessage successful on test#5\n"); 436 437 def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status); 438 if(U_FAILURE(status)) 439 { 440 log_err("error in creating the dateformat using short date and time style:\n %s\n", myErrorName(status)); 441 }else{ 442 443 if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0) 444 log_verbose("PASS: parseMessage successful test#5\n"); 445 else{ 446 log_err("FAIL: parseMessage didn't parse the date successfully\n GOT: %s EXPECTED %s\n", 447 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) ); 448 } 449 } 450 umsg_close(fmt); 451 udat_close(def1); 452 ucal_close(cal); 453 454 free(result); 455 456 ctest_resetTimeZone(); 457} 458 459/* Test u_formatMessageWithError() and u_parseMessageWithError() , format and parse sequence and round trip */ 460static void TestSampleFormatAndParseWithError(void) 461{ 462 463 UChar *result, *tzID, *str; 464 UChar pattern[100]; 465 466 UChar expected[100]; 467 int32_t resultLengthOut, resultlength; 468 UCalendar *cal; 469 UDate d1,d; 470 UDateFormat *def1; 471 UErrorCode status = U_ZERO_ERROR; 472 int32_t value = 0; 473 UChar ret[30]; 474 UParseError parseError; 475 476 ctest_setTimeZone(NULL, &status); 477 478 log_verbose("Testing format and parse with parse error\n"); 479 480 str=(UChar*)malloc(sizeof(UChar) * 25); 481 u_uastrcpy(str, "disturbance in force"); 482 tzID=(UChar*)malloc(sizeof(UChar) * 4); 483 u_uastrcpy(tzID, "PST"); 484 cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status); 485 if(U_FAILURE(status)){ 486 log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) ); 487 } 488 ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status); 489 d1=ucal_getMillis(cal, &status); 490 if(U_FAILURE(status)){ 491 log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) ); 492 } 493 494 log_verbose("\nTesting with pattern test#4"); 495 u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}"); 496 u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7"); 497 resultlength=1; 498 result=(UChar*)malloc(sizeof(UChar) * resultlength); 499 resultLengthOut=u_formatMessageWithError( "en_US", pattern, u_strlen(pattern), result, resultlength,&parseError, &status, d1, str, 7); 500 if(status==U_BUFFER_OVERFLOW_ERROR) 501 { 502 status=U_ZERO_ERROR; 503 resultlength=resultLengthOut+1; 504 result=(UChar*)realloc(result, sizeof(UChar) * resultlength); 505 u_formatMessageWithError( "en_US", pattern, u_strlen(pattern), result, resultlength,&parseError, &status, d1, str, 7); 506 507 } 508 if(U_FAILURE(status)){ 509 log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status)); 510 } 511 else if(u_strcmp(result, expected)==0) 512 log_verbose("PASS: MessagFormat successful on test#4\n"); 513 else{ 514 log_err("FAIL: Error in MessageFormat on test#4\n GOT: %s EXPECTED: %s\n", austrdup(result), 515 austrdup(expected) ); 516 } 517 518 519 /*try to parse this and check*/ 520 log_verbose("\nTesting the parse Message test#5\n"); 521 522 u_parseMessageWithError("en_US", pattern, u_strlen(pattern), result, u_strlen(result), &parseError,&status, &d, ret, &value); 523 if(U_FAILURE(status)){ 524 log_data_err("ERROR: error in parsing: test#5: %s (Are you missing data?)\n", myErrorName(status)); 525 } 526 else if(value!=7 && u_strcmp(str,ret)!=0) 527 log_err("FAIL: Error in parseMessage on test#5 \n"); 528 else 529 log_verbose("PASS: parseMessage successful on test#5\n"); 530 531 def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status); 532 if(U_FAILURE(status)) 533 { 534 log_data_err("error in creating the dateformat using short date and time style: %s (Are you missing data?)\n", myErrorName(status)); 535 }else{ 536 537 if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0) 538 log_verbose("PASS: parseMessage successful test#5\n"); 539 else{ 540 log_err("FAIL: parseMessage didn't parse the date successfully\n GOT: %s EXPECTED %s\n", 541 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) ); 542 } 543 } 544 udat_close(def1); 545 ucal_close(cal); 546 547 free(result); 548 free(str); 549 free(tzID); 550 551 ctest_resetTimeZone(); 552} 553 554/* Test u_formatMessage() and u_parseMessage() , format and parse sequence and round trip */ 555static void TestSampleFormatAndParse(void) 556{ 557 558 UChar *result, *tzID, *str; 559 UChar pattern[100]; 560 UChar expected[100]; 561 int32_t resultLengthOut, resultlength; 562 UCalendar *cal; 563 UDate d1,d; 564 UDateFormat *def1; 565 UErrorCode status = U_ZERO_ERROR; 566 int32_t value = 0; 567 UChar ret[30]; 568 569 ctest_setTimeZone(NULL, &status); 570 571 log_verbose("Testing format and parse\n"); 572 573 str=(UChar*)malloc(sizeof(UChar) * 25); 574 u_uastrcpy(str, "disturbance in force"); 575 tzID=(UChar*)malloc(sizeof(UChar) * 4); 576 u_uastrcpy(tzID, "PST"); 577 cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status); 578 if(U_FAILURE(status)){ 579 log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) ); 580 } 581 ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status); 582 d1=ucal_getMillis(cal, &status); 583 if(U_FAILURE(status)){ 584 log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) ); 585 } 586 587 log_verbose("\nTesting with pattern test#4"); 588 u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}"); 589 u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7"); 590 resultlength=1; 591 result=(UChar*)malloc(sizeof(UChar) * resultlength); 592 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7); 593 if(status==U_BUFFER_OVERFLOW_ERROR) 594 { 595 status=U_ZERO_ERROR; 596 resultlength=resultLengthOut+1; 597 result=(UChar*)realloc(result, sizeof(UChar) * resultlength); 598 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7); 599 600 } 601 if(U_FAILURE(status)){ 602 log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status)); 603 } 604 else if(u_strcmp(result, expected)==0) 605 log_verbose("PASS: MessagFormat successful on test#4\n"); 606 else{ 607 log_err("FAIL: Error in MessageFormat on test#4\n GOT: %s EXPECTED: %s\n", austrdup(result), 608 austrdup(expected) ); 609 } 610 611 612 /*try to parse this and check*/ 613 log_verbose("\nTesting the parse Message test#5\n"); 614 615 u_parseMessage("en_US", pattern, u_strlen(pattern), result, u_strlen(result), &status, &d, ret, &value); 616 if(U_FAILURE(status)){ 617 log_data_err("ERROR: error in parsing: test#5: %s (Are you missing data?)\n", myErrorName(status)); 618 } 619 else if(value!=7 && u_strcmp(str,ret)!=0) 620 log_err("FAIL: Error in parseMessage on test#5 \n"); 621 else 622 log_verbose("PASS: parseMessage successful on test#5\n"); 623 624 def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status); 625 if(U_FAILURE(status)) 626 { 627 log_data_err("error in creating the dateformat using short date and time style: %s (Are you missing data?)\n", myErrorName(status)); 628 }else{ 629 630 if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0) 631 log_verbose("PASS: parseMessage successful test#5\n"); 632 else{ 633 log_err("FAIL: parseMessage didn't parse the date successfully\n GOT: %s EXPECTED %s\n", 634 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) ); 635 } 636 } 637 udat_close(def1); 638 ucal_close(cal); 639 640 free(result); 641 free(str); 642 free(tzID); 643 644 ctest_resetTimeZone(); 645} 646 647/* Test message format with a Select option */ 648static void TestMsgFormatSelect(void) 649{ 650 UChar* str; 651 UChar* str1; 652 UErrorCode status = U_ZERO_ERROR; 653 UChar *result; 654 UChar pattern[100]; 655 UChar expected[100]; 656 int32_t resultlength,resultLengthOut; 657 658 str=(UChar*)malloc(sizeof(UChar) * 25); 659 u_uastrcpy(str, "Kirti"); 660 str1=(UChar*)malloc(sizeof(UChar) * 25); 661 u_uastrcpy(str1, "female"); 662 log_verbose("Testing message format with Select test #1\n:"); 663 u_uastrcpy(pattern, "{0} est {1, select, female {all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris."); 664 u_uastrcpy(expected, "Kirti est all\\u00E9e \\u00E0 Paris."); 665 resultlength=0; 666 resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1); 667 if(status==U_BUFFER_OVERFLOW_ERROR) 668 { 669 status=U_ZERO_ERROR; 670 resultlength=resultLengthOut+1; 671 result=(UChar*)malloc(sizeof(UChar) * resultlength); 672 u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1); 673 if(u_strcmp(result, expected)==0) 674 log_verbose("PASS: MessagFormat successful on Select test#1\n"); 675 else{ 676 log_err("FAIL: Error in MessageFormat on Select test#1\n GOT %s EXPECTED %s\n", austrdup(result), 677 austrdup(expected) ); 678 } 679 free(result); 680 } 681 if(U_FAILURE(status)){ 682 log_data_err("ERROR: failure in message format on Select test#1 : %s \n", myErrorName(status)); 683 } 684 free(str); 685 free(str1); 686 687 /*Test a nested pattern*/ 688 str=(UChar*)malloc(sizeof(UChar) * 25); 689 u_uastrcpy(str, "Noname"); 690 str1=(UChar*)malloc(sizeof(UChar) * 25); 691 u_uastrcpy(str1, "other"); 692 log_verbose("Testing message format with Select test #2\n:"); 693 u_uastrcpy(pattern, "{0} est {1, select, female {{2,number,integer} all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris."); 694 u_uastrcpy(expected, "Noname est all\\u00E9 \\u00E0 Paris."); 695 resultlength=0; 696 resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1,6); 697 if(status==U_BUFFER_OVERFLOW_ERROR) 698 { 699 status=U_ZERO_ERROR; 700 resultlength=resultLengthOut+1; 701 result=(UChar*)malloc(sizeof(UChar) * resultlength); 702 u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1); 703 if(u_strcmp(result, expected)==0) 704 log_verbose("PASS: MessagFormat successful on Select test#2\n"); 705 else{ 706 log_err("FAIL: Error in MessageFormat on Select test#2\n GOT %s EXPECTED %s\n", austrdup(result), 707 austrdup(expected) ); 708 } 709 free(result); 710 } 711 if(U_FAILURE(status)){ 712 log_data_err("ERROR: failure in message format on Select test#2 : %s \n", myErrorName(status)); 713 } 714 free(str); 715 free(str1); 716} 717 718/* test message format with a choice option */ 719static void TestMsgFormatChoice(void) 720{ 721 UChar* str; 722 UErrorCode status = U_ZERO_ERROR; 723 UChar *result; 724 UChar pattern[100]; 725 UChar expected[100]; 726 int32_t resultlength,resultLengthOut; 727 728 str=(UChar*)malloc(sizeof(UChar) * 25); 729 u_uastrcpy(str, "MyDisk"); 730 log_verbose("Testing message format with choice test #6\n:"); 731 /*There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.*/ 732 u_uastrcpy(pattern, "The disk {1} contains {0,choice,0#no files|1#one file|1<{0,number,integer} files}"); 733 u_uastrcpy(expected, "The disk MyDisk contains 100 files"); 734 resultlength=0; 735 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 100., str); 736 if(status==U_BUFFER_OVERFLOW_ERROR) 737 { 738 status=U_ZERO_ERROR; 739 resultlength=resultLengthOut+1; 740 result=(UChar*)malloc(sizeof(UChar) * resultlength); 741 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 100., str); 742 if(u_strcmp(result, expected)==0) 743 log_verbose("PASS: MessagFormat successful on test#6\n"); 744 else{ 745 log_err("FAIL: Error in MessageFormat on test#6\n GOT %s EXPECTED %s\n", austrdup(result), 746 austrdup(expected) ); 747 } 748 free(result); 749 } 750 if(U_FAILURE(status)){ 751 log_data_err("ERROR: failure in message format on test#6 : %s (Are you missing data?)\n", myErrorName(status)); 752 } 753 754 log_verbose("Testing message format with choice test #7\n:"); 755 u_uastrcpy(expected, "The disk MyDisk contains no files"); 756 resultlength=0; 757 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 0., str); 758 if(status==U_BUFFER_OVERFLOW_ERROR) 759 { 760 status=U_ZERO_ERROR; 761 resultlength=resultLengthOut+1; 762 result=(UChar*)malloc(sizeof(UChar) * resultlength); 763 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 0., str); 764 765 if(u_strcmp(result, expected)==0) 766 log_verbose("PASS: MessagFormat successful on test#7\n"); 767 else{ 768 log_err("FAIL: Error in MessageFormat on test#7\n GOT: %s EXPECTED %s\n", austrdup(result), 769 austrdup(expected) ); 770 } 771 free(result); 772 } 773 if(U_FAILURE(status)){ 774 log_data_err("ERROR: failure in message format on test#7 : %s (Are you missing data?)\n", myErrorName(status)); 775 } 776 777 log_verbose("Testing message format with choice test #8\n:"); 778 u_uastrcpy(expected, "The disk MyDisk contains one file"); 779 resultlength=0; 780 resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 1., str); 781 if(status==U_BUFFER_OVERFLOW_ERROR) 782 { 783 status=U_ZERO_ERROR; 784 resultlength=resultLengthOut+1; 785 result=(UChar*)malloc(sizeof(UChar) * resultlength); 786 u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 1., str); 787 788 if(u_strcmp(result, expected)==0) 789 log_verbose("PASS: MessagFormat successful on test#8\n"); 790 else{ 791 log_err("FAIL: Error in MessageFormat on test#8\n GOT %s EXPECTED: %s\n", austrdup(result), 792 austrdup(expected) ); 793 } 794 795 free(result); 796 } 797 if(U_FAILURE(status)){ 798 log_data_err("ERROR: failure in message format on test#8 : %s (Are you missing data?)\n", myErrorName(status)); 799 } 800 801 free(str); 802 803} 804 805/*test u_parseMessage() with various test patterns */ 806static void TestParseMessage(void) 807{ 808 UChar pattern[100]; 809 UChar source[100]; 810 UErrorCode status = U_ZERO_ERROR; 811 int32_t value; 812 UChar str[10]; 813 UChar res[10]; 814 815 log_verbose("\nTesting a sample for parse Message test#9\n"); 816 817 u_uastrcpy(source, "You deposited an amount of $500.00"); 818 u_uastrcpy(pattern, "You {0} an amount of {1,number,currency}"); 819 u_uastrcpy(res,"deposited"); 820 821 u_parseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, str, &value); 822 if(U_FAILURE(status)){ 823 log_data_err("ERROR: failure in parse Message on test#9: %s (Are you missing data?)\n", myErrorName(status)); 824 } 825 else if(value==500.00 && u_strcmp(str,res)==0) 826 log_verbose("PASS: parseMessage successful on test#9\n"); 827 else 828 log_err("FAIL: Error in parseMessage on test#9 \n"); 829 830 831 832 log_verbose("\nTesting a sample for parse Message test#10\n"); 833 834 u_uastrcpy(source, "There are 123 files on MyDisk created"); 835 u_uastrcpy(pattern, "There are {0,number,integer} files on {1} created"); 836 u_uastrcpy(res,"MyDisk"); 837 838 u_parseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, &value, str); 839 if(U_FAILURE(status)){ 840 log_data_err("ERROR: failure in parse Message on test#10: %s (Are you missing data?)\n", myErrorName(status)); 841 } 842 else if(value==123.00 && u_strcmp(str,res)==0) 843 log_verbose("PASS: parseMessage successful on test#10\n"); 844 else 845 log_err("FAIL: Error in parseMessage on test#10 \n"); 846} 847 848static int32_t CallFormatMessage(const char* locale, UChar* testCasePattern, int32_t patternLength, 849 UChar* result, int32_t resultLength, UErrorCode *status, ...) 850{ 851 int32_t len = 0; 852 va_list ap; 853 va_start(ap, status); 854 len = u_vformatMessage(locale, testCasePattern, patternLength, result, resultLength, ap, status); 855 va_end(ap); 856 return len; 857} 858 859/* Test u_vformatMessage() with various test patterns. */ 860static void TestMessageFormatWithValist( void ) 861{ 862 863 UChar *str; 864 UChar* result; 865 int32_t resultLengthOut,resultlength,i, patternlength; 866 UErrorCode status = U_ZERO_ERROR; 867 UDate d1=1000000000.0; 868 869 ctest_setTimeZone(NULL, &status); 870 871 str=(UChar*)malloc(sizeof(UChar) * 7); 872 u_uastrcpy(str, "MyDisk"); 873 resultlength=1; 874 result=(UChar*)malloc(sizeof(UChar) * 1); 875 log_verbose("Testing u_formatMessage90\n"); 876 InitStrings(); 877 for (i = 0; i < cnt_testCases; i++) { 878 status=U_ZERO_ERROR; 879 patternlength=u_strlen(testCasePatterns[i]); 880 resultLengthOut=CallFormatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, 881 &status, 1, 3456.00, d1); 882 if(status== U_BUFFER_OVERFLOW_ERROR) 883 { 884 status=U_ZERO_ERROR; 885 resultlength=resultLengthOut+1; 886 result=(UChar*)realloc(result,sizeof(UChar) * resultlength); 887 CallFormatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, 888 &status, 1, 3456.00, d1); 889 } 890 if(U_FAILURE(status)){ 891 log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) ); 892 } 893 else if(u_strcmp(result, testResultStrings[i])==0){ 894 log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); 895 } 896 else{ 897 log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, 898 austrdup(result), austrdup(testResultStrings[i]) ); 899 } 900 } 901 free(result); 902 free(str); 903 FreeStrings(); 904 905 ctest_resetTimeZone(); 906} 907 908static void CallParseMessage(const char* locale, UChar* pattern, int32_t patternLength, 909 UChar* source, int32_t sourceLength, UErrorCode *status, ...) 910{ 911 va_list ap; 912 va_start(ap, status); 913 u_vparseMessage(locale, pattern, patternLength, source, sourceLength, ap, status); 914 va_end(ap); 915} 916 917/*test u_vparseMessage() with various test patterns */ 918static void TestParseMessageWithValist(void) 919{ 920 UChar pattern[100]; 921 UChar source[100]; 922 UErrorCode status = U_ZERO_ERROR; 923 int32_t value; 924 UChar str[10]; 925 UChar res[10]; 926 927 log_verbose("\nTesting a sample for parse Message test#9\n"); 928 929 u_uastrcpy(source, "You deposited an amount of $500.00"); 930 u_uastrcpy(pattern, "You {0} an amount of {1,number,currency}"); 931 u_uastrcpy(res,"deposited"); 932 933 CallParseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, str, &value); 934 if(U_FAILURE(status)){ 935 log_data_err("ERROR: failure in parse Message on test#9: %s (Are you missing data?)\n", myErrorName(status)); 936 } 937 else if(value==500.00 && u_strcmp(str,res)==0) 938 log_verbose("PASS: parseMessage successful on test#9\n"); 939 else 940 log_err("FAIL: Error in parseMessage on test#9\n"); 941 942 943 log_verbose("\nTesting a sample for parse Message test#10\n"); 944 945 u_uastrcpy(source, "There are 123 files on MyDisk created"); 946 u_uastrcpy(pattern, "There are {0,number,integer} files on {1} created"); 947 u_uastrcpy(res,"MyDisk"); 948 949 CallParseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, &value, str); 950 if(U_FAILURE(status)){ 951 log_data_err("ERROR: failure in parse Message on test#10: %s (Are you missing data?)\n", myErrorName(status)); 952 } 953 else if(value==123.00 && u_strcmp(str,res)==0) 954 log_verbose("PASS: parseMessage successful on test#10\n"); 955 else 956 log_err("FAIL: Error in parseMessage on test#10 \n"); 957} 958 959/** 960 * Regression test for ICU4C Jitterbug 904 961 */ 962static void TestJ904(void) { 963 UChar pattern[256]; 964 UChar result[256]; 965 UChar string[16]; 966 char cresult[256]; 967 int32_t length; 968 UErrorCode status = U_ZERO_ERROR; 969 const char* PAT = "Number {1,number,#0.000}, String {0}, Date {2,date,12:mm:ss.SSS}"; 970 const char* EXP = "Number 0,143, String foo, Date 12:34:56.789"; 971 972 ctest_setTimeZone(NULL, &status); 973 974 u_uastrcpy(string, "foo"); 975 /* Slight hack here -- instead of date pattern HH:mm:ss.SSS, use 976 * 12:mm:ss.SSS. Why? So this test generates the same output -- 977 * "12:34:56.789" -- regardless of time zone (as long as we aren't 978 * in one of the 30 minute offset zones!). */ 979 u_uastrcpy(pattern, PAT); 980 length = u_formatMessage("nl", pattern, u_strlen(pattern), 981 result, 256, &status, 982 string, 1/7.0, 983 789.0+1000*(56+60*(34+60*12))); 984 985 u_austrncpy(cresult, result, sizeof(cresult)); 986 987 /* This test passes if it DOESN'T CRASH. However, we test the 988 * output anyway. If the string doesn't match in the date part, 989 * check to see that the machine doesn't have an unusual time zone 990 * offset, that is, one with a non-zero minutes/seconds offset 991 * from GMT -- see above. */ 992 if (strcmp(cresult, EXP) == 0) { 993 log_verbose("Ok: \"%s\"\n", cresult); 994 } else { 995 log_data_err("FAIL: got \"%s\", expected \"%s\" -> %s (Are you missing data?)\n", cresult, EXP, u_errorName(status)); 996 } 997 998 ctest_resetTimeZone(); 999} 1000 1001static void OpenMessageFormatTest(void) 1002{ 1003 UMessageFormat *f1, *f2, *f3; 1004 UChar pattern[256]; 1005 UChar result[256]; 1006 char cresult[256]; 1007 UParseError parseError; 1008 const char* locale = "hi_IN"; 1009 char* retLoc; 1010 const char* PAT = "Number {1,number,#0.000}, String {0}, Date {2,date,12:mm:ss.SSS}"; 1011 int32_t length=0; 1012 UErrorCode status = U_ZERO_ERROR; 1013 1014 u_uastrncpy(pattern, PAT, sizeof(pattern)/sizeof(pattern[0])); 1015 1016 /* Test umsg_open */ 1017 f1 = umsg_open(pattern,length,NULL,NULL,&status); 1018 1019 if(U_FAILURE(status)) 1020 { 1021 log_err("umsg_open failed with pattern %s. Error: \n", PAT, u_errorName(status)); 1022 return; 1023 } 1024 1025 /* Test umsg_open with parse error */ 1026 status = U_ZERO_ERROR; 1027 f2 = umsg_open(pattern,length,NULL,&parseError,&status); 1028 1029 if(U_FAILURE(status)) 1030 { 1031 log_err("umsg_open with parseError failed with pattern %s. Error: %s\n", PAT, u_errorName(status)); 1032 return; 1033 } 1034 1035 /* Test umsg_clone */ 1036 status = U_ZERO_ERROR; 1037 f3 = umsg_clone(f1,&status); 1038 if(U_FAILURE(status)) 1039 { 1040 log_err("umsg_clone failed. Error %s \n", u_errorName(status)); 1041 } 1042 1043 /* Test umsg_setLocale */ 1044 umsg_setLocale(f1,locale); 1045 /* Test umsg_getLocale */ 1046 retLoc = (char*)umsg_getLocale(f1); 1047 if(strcmp(retLoc,locale)!=0) 1048 { 1049 log_err("umsg_setLocale and umsg_getLocale methods failed. Expected:%s Got: %s \n", locale, retLoc); 1050 } 1051 1052 /* Test umsg_applyPattern */ 1053 status = U_ZERO_ERROR; 1054 umsg_applyPattern(f1,pattern,(int32_t)strlen(PAT),NULL,&status); 1055 if(U_FAILURE(status)) 1056 { 1057 log_data_err("umsg_applyPattern failed. Error %s (Are you missing data?)\n",u_errorName(status)); 1058 } 1059 1060 /* Test umsg_toPattern */ 1061 umsg_toPattern(f1,result,256,&status); 1062 if(U_FAILURE(status) ){ 1063 log_data_err("umsg_toPattern method failed. Error: %s (Are you missing data?)\n",u_errorName(status)); 1064 } else { 1065 if(u_strcmp(result,pattern)!=0){ 1066 u_UCharsToChars(result,cresult,256); 1067 log_err("umsg_toPattern method failed. Expected: %s Got: %s \n",PAT,cresult); 1068 } 1069 } 1070 /* umsg_format umsg_parse */ 1071 1072 umsg_close(f1); 1073 umsg_close(f2); 1074 umsg_close(f3); 1075} 1076 1077static void MessageLength(void) 1078{ 1079 UErrorCode status = U_ZERO_ERROR; 1080 const char patChars[] = {"123{0}456{0}"}; 1081 const char expectedChars[] = {"123abc"}; 1082 UChar pattern[sizeof(patChars)]; 1083 UChar arg[] = {0x61,0x62,0x63,0}; 1084 UChar result[128] = {0}; 1085 UChar expected[sizeof(expectedChars)]; 1086 1087 u_uastrncpy(pattern, patChars, sizeof(pattern)/sizeof(pattern[0])); 1088 u_uastrncpy(expected, expectedChars, sizeof(expected)/sizeof(expected[0])); 1089 1090 u_formatMessage("en_US", pattern, 6, result, sizeof(result)/sizeof(result[0]), &status, arg); 1091 if (U_FAILURE(status)) { 1092 log_err("u_formatMessage method failed. Error: %s \n",u_errorName(status)); 1093 } 1094 if (u_strcmp(result, expected) != 0) { 1095 log_err("u_formatMessage didn't return expected result\n"); 1096 } 1097} 1098 1099static void TestErrorChaining(void) { 1100 UErrorCode status = U_USELESS_COLLATOR_ERROR; 1101 1102 umsg_open(NULL, 0, NULL, NULL, &status); 1103 umsg_applyPattern(NULL, NULL, 0, NULL, &status); 1104 umsg_toPattern(NULL, NULL, 0, &status); 1105 umsg_clone(NULL, &status); 1106 umsg_format(NULL, NULL, 0, &status); 1107 umsg_parse(NULL, NULL, 0, NULL, &status); 1108 umsg_close(NULL); 1109 1110 /* All of this code should have done nothing. */ 1111 if (status != U_USELESS_COLLATOR_ERROR) { 1112 log_err("Status got changed to %s\n", u_errorName(status)); 1113 } 1114 1115 status = U_ZERO_ERROR; 1116 umsg_open(NULL, 0, NULL, NULL, &status); 1117 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1118 log_err("Status should be U_ILLEGAL_ARGUMENT_ERROR instead of %s\n", u_errorName(status)); 1119 } 1120 status = U_ZERO_ERROR; 1121 umsg_applyPattern(NULL, NULL, 0, NULL, &status); 1122 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1123 log_err("Status should be U_ILLEGAL_ARGUMENT_ERROR instead of %s\n", u_errorName(status)); 1124 } 1125 status = U_ZERO_ERROR; 1126 umsg_toPattern(NULL, NULL, 0, &status); 1127 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1128 log_err("Status should be U_ILLEGAL_ARGUMENT_ERROR instead of %s\n", u_errorName(status)); 1129 } 1130 status = U_ZERO_ERROR; 1131 umsg_clone(NULL, &status); 1132 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1133 log_err("Status should be U_ILLEGAL_ARGUMENT_ERROR instead of %s\n", u_errorName(status)); 1134 } 1135} 1136 1137void addMsgForTest(TestNode** root); 1138 1139void addMsgForTest(TestNode** root) 1140{ 1141 addTest(root, &OpenMessageFormatTest, "tsformat/cmsgtst/OpenMessageFormatTest"); 1142 addTest(root, &MessageFormatTest, "tsformat/cmsgtst/MessageFormatTest"); 1143 addTest(root, &TestSampleMessageFormat, "tsformat/cmsgtst/TestSampleMessageFormat"); 1144 addTest(root, &TestSampleFormatAndParse, "tsformat/cmsgtst/TestSampleFormatAndParse"); 1145 addTest(root, &TestSampleFormatAndParseWithError, "tsformat/cmsgtst/TestSampleFormatAndParseWithError"); 1146 addTest(root, &TestNewFormatAndParseAPI, "tsformat/cmsgtst/TestNewFormatAndParseAPI"); 1147 addTest(root, &TestMsgFormatChoice, "tsformat/cmsgtst/TestMsgFormatChoice"); 1148 addTest(root, &TestParseMessage, "tsformat/cmsgtst/TestParseMessage"); 1149 addTest(root, &TestMessageFormatWithValist, "tsformat/cmsgtst/TestMessageFormatWithValist"); 1150 addTest(root, &TestParseMessageWithValist, "tsformat/cmsgtst/TestParseMessageWithValist"); 1151 addTest(root, &TestJ904, "tsformat/cmsgtst/TestJ904"); 1152 addTest(root, &MessageLength, "tsformat/cmsgtst/MessageLength"); 1153 addTest(root, &TestErrorChaining, "tsformat/cmsgtst/TestErrorChaining"); 1154 addTest(root, &TestMsgFormatSelect, "tsformat/cmsgtst/TestMsgFormatSelect"); 1155} 1156 1157#endif /* #if !UCONFIG_NO_FORMATTING */ 1158