icuSources/test/cintltst/cmsgtst.c

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