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