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