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