]> git.saurik.com Git - apple/icu.git/blame - icuSources/test/cintltst/cdattst.c
ICU-6.2.4.tar.gz
[apple/icu.git] / icuSources / test / cintltst / cdattst.c
CommitLineData
b75a7d8f
A
1/********************************************************************
2 * COPYRIGHT:
374ca955 3 * Copyright (c) 1997-2004, International Business Machines Corporation and
b75a7d8f
A
4 * others. All Rights Reserved.
5 ********************************************************************/
6/********************************************************************************
7*
8* File CDATTST.C
9*
10* Modification History:
11* Name Description
12* Madhu Katragadda Creation
13*********************************************************************************
14*/
15
16/* C API TEST FOR DATE FORMAT */
17
18#include "unicode/utypes.h"
19
20#if !UCONFIG_NO_FORMATTING
21
22#include "unicode/uloc.h"
23#include "unicode/udat.h"
24#include "unicode/ucal.h"
25#include "unicode/unum.h"
26#include "unicode/ustring.h"
27#include "cintltst.h"
28#include "cdattst.h"
29#include "cformtst.h"
30#include "cmemory.h"
31
374ca955
A
32#include <math.h>
33
34static void TestExtremeDates(void);
35
36#define LEN(a) (sizeof(a)/sizeof(a[0]))
37
b75a7d8f
A
38void addDateForTest(TestNode** root);
39
374ca955 40#define TESTCASE(x) addTest(root, &x, "tsformat/cdattst/" #x)
b75a7d8f
A
41
42void addDateForTest(TestNode** root)
43{
374ca955
A
44 TESTCASE(TestDateFormat);
45 TESTCASE(TestSymbols);
46 TESTCASE(TestDateFormatCalendar);
47 TESTCASE(TestExtremeDates);
b75a7d8f
A
48}
49/* Testing the DateFormat API */
50static void TestDateFormat()
51{
52 UDateFormat *def, *fr, *it, *de, *def1, *fr_pat;
53 UDateFormat *any;
54 UDateFormat *copy;
55 UErrorCode status = U_ZERO_ERROR;
56 UChar* result = NULL;
57 const UCalendar *cal;
58 const UNumberFormat *numformat1, *numformat2;
59 UChar temp[30];
60 int32_t numlocales;
61 UDate d1;
62 int i;
63 int32_t resultlength;
64 int32_t resultlengthneeded;
65 int32_t parsepos;
66 UDate d = 837039928046.0;
67 double num = -10456.37;
68 /*const char* str="yyyy.MM.dd G 'at' hh:mm:ss z";
69 const char t[]="2/3/76 2:50 AM";*/
70 /*Testing udat_open() to open a dateformat */
374ca955
A
71
72 ctest_setTimeZone(NULL, &status);
73
b75a7d8f
A
74 log_verbose("\nTesting udat_open() with various parameters\n");
75 fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL,0, NULL, 0,&status);
76 if(U_FAILURE(status))
77 {
78 log_err("FAIL: error in creating the dateformat using full time style with french locale\n %s\n",
79 myErrorName(status) );
80 return;
81 }
82 /* this is supposed to open default date format, but later on it treats it like it is "en_US"
83 - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
84 /* def = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status); */
85 def = udat_open(UDAT_SHORT, UDAT_SHORT, "en_US", NULL, 0,NULL, 0, &status);
86 if(U_FAILURE(status))
87 {
88 log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
89 myErrorName(status) );
90 return;
91 }
92 it = udat_open(UDAT_DEFAULT, UDAT_MEDIUM, "it_IT", NULL, 0, NULL, 0,&status);
93 if(U_FAILURE(status))
94 {
95 log_err("FAIL: error in creating the dateformat using medium date style with italian locale\n %s\n",
96 myErrorName(status) );
97 return;
98 }
99 de = udat_open(UDAT_LONG, UDAT_LONG, "de_DE", NULL, 0, NULL, 0,&status);
100 if(U_FAILURE(status))
101 {
102 log_err("FAIL: error in creating the dateformat using long time and date styles with german locale\n %s\n",
103 myErrorName(status));
104 return;
105 }
106 /*creating a default dateformat */
107 def1 = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0,NULL, 0, &status);
108 if(U_FAILURE(status))
109 {
110 log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
111 myErrorName(status) );
112 return;
113 }
114
115
116 /*Testing udat_getAvailable() and udat_countAvailable()*/
117 log_verbose("\nTesting getAvailableLocales and countAvailable()\n");
118 numlocales=udat_countAvailable();
119 /* use something sensible w/o hardcoding the count */
120 if(numlocales < 0)
121 log_data_err("FAIL: error in countAvailable\n");
122 log_verbose("The number of locales for which date/time formatting patterns are available is %d\n", numlocales);
123
124 for(i=0;i<numlocales;i++) {
125 UErrorCode subStatus = U_ZERO_ERROR;
126 log_verbose("Testing open of %s\n", udat_getAvailable(i));
127 any = udat_open(UDAT_SHORT, UDAT_SHORT, udat_getAvailable(i), NULL ,0, NULL, 0, &status);
128 if(U_FAILURE(subStatus)) {
374ca955 129 log_data_err("FAIL: date format %s (getAvailable(%d)) is not instantiable: %s\n", udat_getAvailable(i), i, u_errorName(subStatus));
b75a7d8f
A
130 }
131 udat_close(any);
132 }
133
134 /*Testing udat_clone()*/
135 log_verbose("\nTesting the udat_clone() function of date format\n");
136 copy=udat_clone(def, &status);
137 if(U_FAILURE(status)){
138 log_err("Error in creating the clone using udat_clone: %s\n", myErrorName(status) );
139 }
140 /*if(def != copy)
141 log_err("Error in udat_clone");*/ /*how should i check for equality???? */
142
143 /*Testing udat_format()*/
144 log_verbose("\nTesting the udat_format() function of date format\n");
145 u_uastrcpy(temp, "7/10/96 4:05 PM");
146 /*format using def */
147 resultlength=0;
148 resultlengthneeded=udat_format(def, d, NULL, resultlength, NULL, &status);
149 if(status==U_BUFFER_OVERFLOW_ERROR)
150 {
151 status=U_ZERO_ERROR;
152 resultlength=resultlengthneeded+1;
153 if(result != NULL) {
154 free(result);
155 result = NULL;
156 }
157 result=(UChar*)malloc(sizeof(UChar) * resultlength);
158 udat_format(def, d, result, resultlength, NULL, &status);
159 }
160 if(U_FAILURE(status) || !result)
161 {
162 log_err("FAIL: Error in formatting using udat_format(.....) %s\n", myErrorName(status) );
163 return;
164 }
165 else
166 log_verbose("PASS: formatting successful\n");
167 if(u_strcmp(result, temp)==0)
168 log_verbose("PASS: Date Format for US locale successful uisng udat_format()\n");
169 else
170 log_err("FAIL: Date Format for US locale failed using udat_format()\n");
171 /*format using fr */
172
374ca955 173 u_unescape("10 juil. 96 16 h 05 HAP (\\u00c9UA)", temp, 30);
b75a7d8f
A
174 if(result != NULL) {
175 free(result);
176 result = NULL;
177 }
178 result=myDateFormat(fr, d);
179 if(u_strcmp(result, temp)==0)
374ca955 180 log_verbose("PASS: Date Format for french locale successful using udat_format()\n");
b75a7d8f 181 else
374ca955
A
182 log_data_err("FAIL: Date Format for french locale failed using udat_format(). Expected:\n");
183 /*format using it */
b75a7d8f
A
184 u_uastrcpy(temp, "10/lug/96 16:05:28");
185
186 if(u_strcmp(myDateFormat(it,d), temp)==0)
187 log_verbose("PASS: Date Format for italian locale successful uisng udat_format()\n");
188 else
189 log_data_err("FAIL: Date Format for italian locale failed using udat_format()\n");
190
191
192 /*Testing parsing using udat_parse()*/
193 log_verbose("\nTesting parsing using udat_parse()\n");
194 u_uastrcpy(temp,"2/3/76 2:50 AM");
195 parsepos=0;
374ca955 196 status=U_ZERO_ERROR;
b75a7d8f
A
197
198 d1=udat_parse(def, temp, u_strlen(temp), &parsepos, &status);
199 if(U_FAILURE(status))
200 {
201 log_err("FAIL: Error in parsing using udat_parse(.....) %s\n", myErrorName(status) );
202 }
203 else
204 log_verbose("PASS: parsing succesful\n");
205 /*format it back and check for equality */
206
207
208 if(u_strcmp(myDateFormat(def, d1),temp)!=0)
209 log_err("FAIL: error in parsing\n");
210
374ca955
A
211 /*Testing parsing using udat_parse()*/
212 log_verbose("\nTesting parsing using udat_parse()\n");
213 u_uastrcpy(temp,"2/Don't parse this part");
214 status=U_ZERO_ERROR;
215
216 d1=udat_parse(def, temp, u_strlen(temp), NULL, &status);
217 if(status != U_PARSE_ERROR)
218 {
219 log_err("FAIL: udat_parse(\"bad string\") passed when it should have failed\n");
220 }
221 else
222 log_verbose("PASS: parsing succesful\n");
b75a7d8f
A
223
224
225
226 /*Testing udat_openPattern() */
227 status=U_ZERO_ERROR;
228 log_verbose("\nTesting the udat_openPattern with a specified pattern\n");
229 /*for french locale */
230 fr_pat=udat_open(UDAT_IGNORE, UDAT_IGNORE,"fr_FR",NULL,0,temp, u_strlen(temp), &status);
231 if(U_FAILURE(status))
232 {
233 log_err("FAIL: Error in creating a date format using udat_openPattern \n %s\n",
234 myErrorName(status) );
235 }
236 else
237 log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
238
239
240 /*Testing applyPattern and toPattern */
241 log_verbose("\nTesting applyPattern and toPattern()\n");
242 udat_applyPattern(def1, FALSE, temp, u_strlen(temp));
243 log_verbose("Extracting the pattern\n");
244
245 resultlength=0;
246 resultlengthneeded=udat_toPattern(def1, FALSE, NULL, resultlength, &status);
247 if(status==U_BUFFER_OVERFLOW_ERROR)
248 {
249 status=U_ZERO_ERROR;
250 resultlength=resultlengthneeded + 1;
251 result=(UChar*)malloc(sizeof(UChar) * resultlength);
252 udat_toPattern(def1, FALSE, result, resultlength, &status);
253 }
254 if(U_FAILURE(status))
255 {
256 log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
257 myErrorName(status) );
258 }
259 if(u_strcmp(result, temp)!=0)
260 log_err("FAIL: Error in extracting the pattern\n");
261 else
262 log_verbose("PASS: applyPattern and toPattern work fine\n");
263
264 if(result != NULL) {
265 free(result);
266 result = NULL;
267 }
268
269
270 /*Testing getter and setter functions*/
271 /*isLenient and setLenient()*/
272 log_verbose("\nTesting the isLenient and setLenient properties\n");
273 udat_setLenient(fr, udat_isLenient(it));
274 if(udat_isLenient(fr) != udat_isLenient(it))
275 log_err("ERROR: setLenient() failed\n");
276 else
277 log_verbose("PASS: setLenient() successful\n");
278
279
280 /*Test get2DigitYearStart set2DigitYearStart */
281 log_verbose("\nTesting the get and set 2DigitYearStart properties\n");
282 d1= udat_get2DigitYearStart(fr_pat,&status);
283 if(U_FAILURE(status)) {
284 log_err("ERROR: udat_get2DigitYearStart failed %s\n", myErrorName(status) );
285 }
286 status = U_ZERO_ERROR;
287 udat_set2DigitYearStart(def1 ,d1, &status);
288 if(U_FAILURE(status)) {
289 log_err("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
290 }
291 if(udat_get2DigitYearStart(fr_pat, &status) != udat_get2DigitYearStart(def1, &status))
292 log_err("FAIL: error in set2DigitYearStart\n");
293 else
294 log_verbose("PASS: set2DigitYearStart successful\n");
295 /*try setting it to another value */
296 udat_set2DigitYearStart(de, 2000.0, &status);
297 if(U_FAILURE(status)){
298 log_verbose("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
299 }
300 if(udat_get2DigitYearStart(de, &status) != 2000)
301 log_err("FAIL: error in set2DigitYearStart\n");
302 else
303 log_verbose("PASS: set2DigitYearStart successful\n");
304
305
306
307 /*Test getNumberFormat() and setNumberFormat() */
308 log_verbose("\nTesting the get and set NumberFormat properties of date format\n");
309 numformat1=udat_getNumberFormat(fr_pat);
310 udat_setNumberFormat(def1, numformat1);
311 numformat2=udat_getNumberFormat(def1);
312 if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
313 log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
314 else
315 log_verbose("PASS:setNumberFormat and getNumberFormat succesful\n");
316
317 /*try setting the number format to another format */
318 numformat1=udat_getNumberFormat(def);
319 udat_setNumberFormat(def1, numformat1);
320 numformat2=udat_getNumberFormat(def1);
321 if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
322 log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
323 else
324 log_verbose("PASS: setNumberFormat and getNumberFormat succesful\n");
325
326
327
328 /*Test getCalendar and setCalendar*/
329 log_verbose("\nTesting the udat_getCalendar() and udat_setCalendar() properties\n");
330 cal=udat_getCalendar(fr_pat);
331
332
333 udat_setCalendar(def1, cal);
334 if(!ucal_equivalentTo(udat_getCalendar(fr_pat), udat_getCalendar(def1)))
335 log_err("FAIL: Error in setting and getting the calendar\n");
336 else
337 log_verbose("PASS: getting and setting calendar successful\n");
338
339 if(result!=NULL) {
340 free(result);
341 }
342
343 /*Closing the UDateForamt */
344 udat_close(def);
345 udat_close(fr);
346 udat_close(it);
347 udat_close(de);
348 udat_close(def1);
349 udat_close(fr_pat);
350 udat_close(copy);
351
374ca955 352 ctest_resetTimeZone();
b75a7d8f
A
353}
354
355/*Testing udat_getSymbols() and udat_setSymbols() and udat_countSymbols()*/
356static void TestSymbols()
357{
358 UDateFormat *def, *fr;
359 UErrorCode status = U_ZERO_ERROR;
360 UChar *value=NULL;
361 UChar *result = NULL;
362 int32_t resultlength;
363 int32_t resultlengthout;
364 UChar *pattern;
365
366
367 /*creating a dateformat with french locale */
368 log_verbose("\ncreating a date format with french locale\n");
369 fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL, 0, NULL, 0, &status);
370 if(U_FAILURE(status))
371 {
372 log_err("error in creating the dateformat using full time style with french locale\n %s\n",
373 myErrorName(status) );
374 return;
375 }
376 /*creating a default dateformat */
377 log_verbose("\ncreating a date format with default locale\n");
378 /* this is supposed to open default date format, but later on it treats it like it is "en_US"
379 - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
380 /* def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, &status); */
381 def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status);
382 if(U_FAILURE(status))
383 {
384 log_err("error in creating the dateformat using short date and time style\n %s\n",
385 myErrorName(status) );
386 return;
387 }
388
389
390 /*Testing countSymbols, getSymbols and setSymbols*/
391 log_verbose("\nTesting countSymbols\n");
392 /*since the month names has the last string empty and week names are 1 based 1.e first string in the weeknames array is empty */
393 if(udat_countSymbols(def, UDAT_ERAS)!=2 || udat_countSymbols(def, UDAT_MONTHS)!=12 ||
394 udat_countSymbols(def, UDAT_SHORT_MONTHS)!=12 || udat_countSymbols(def, UDAT_WEEKDAYS)!=8 ||
395 udat_countSymbols(def, UDAT_SHORT_WEEKDAYS)!=8 || udat_countSymbols(def, UDAT_AM_PMS)!=2 ||
396 udat_countSymbols(def, UDAT_LOCALIZED_CHARS)!=1)
397 {
398 log_err("FAIL: error in udat_countSymbols\n");
399 }
400 else
401 log_verbose("PASS: udat_countSymbols() successful\n");
402
403 /*testing getSymbols*/
404 log_verbose("\nTesting getSymbols\n");
405 pattern=(UChar*)malloc(sizeof(UChar) * 10);
406 u_uastrcpy(pattern, "jeudi");
407 resultlength=0;
408 resultlengthout=udat_getSymbols(fr, UDAT_WEEKDAYS, 5 , NULL, resultlength, &status);
409 if(status==U_BUFFER_OVERFLOW_ERROR)
410 {
411 status=U_ZERO_ERROR;
412 resultlength=resultlengthout+1;
413 if(result != NULL) {
414 free(result);
415 result = NULL;
416 }
417 result=(UChar*)malloc(sizeof(UChar) * resultlength);
418 udat_getSymbols(fr, UDAT_WEEKDAYS, 5, result, resultlength, &status);
419
420 }
421 if(U_FAILURE(status))
422 {
423 log_err("FAIL: Error in udat_getSymbols().... %s\n", myErrorName(status) );
424 }
425 else
426 log_verbose("PASS: getSymbols succesful\n");
427
428 if(u_strcmp(result, pattern)==0)
429 log_verbose("PASS: getSymbols retrieved the right value\n");
430 else
431 log_data_err("FAIL: getSymbols retrieved the wrong value\n");
432
433 /*run series of tests to test getsymbols regressively*/
434 log_verbose("\nTesting getSymbols() regressively\n");
435 VerifygetSymbols(fr, UDAT_WEEKDAYS, 1, "dimanche");
436 VerifygetSymbols(def, UDAT_WEEKDAYS, 1, "Sunday");
437 VerifygetSymbols(fr, UDAT_SHORT_WEEKDAYS, 7, "sam.");
438 VerifygetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Sat");
439 VerifygetSymbols(def, UDAT_MONTHS, 11, "December");
440 VerifygetSymbols(def, UDAT_MONTHS, 0, "January");
441 VerifygetSymbols(fr, UDAT_ERAS, 0, "av. J.-C.");
442 VerifygetSymbols(def, UDAT_AM_PMS, 0, "AM");
443 VerifygetSymbols(def, UDAT_AM_PMS, 1, "PM");
444 VerifygetSymbols(fr, UDAT_SHORT_MONTHS, 0, "janv.");
445 VerifygetSymbols(def, UDAT_SHORT_MONTHS, 11, "Dec");
374ca955 446 VerifygetSymbols(def,UDAT_LOCALIZED_CHARS, 0, "GyMdkHmsSEDFwWahKzYeugAZ");
b75a7d8f
A
447
448
449 if(result != NULL) {
450 free(result);
451 result = NULL;
452 }
453free(pattern);
454
455 log_verbose("\nTesting setSymbols\n");
456 /*applying the pattern so that setSymbolss works */
457 resultlength=0;
458 resultlengthout=udat_toPattern(fr, FALSE, NULL, resultlength, &status);
459 if(status==U_BUFFER_OVERFLOW_ERROR)
460 {
461 status=U_ZERO_ERROR;
462 resultlength=resultlengthout + 1;
463 pattern=(UChar*)malloc(sizeof(UChar) * resultlength);
464 udat_toPattern(fr, FALSE, pattern, resultlength, &status);
465 }
466 if(U_FAILURE(status))
467 {
468 log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
469 myErrorName(status) );
470 }
471
472 udat_applyPattern(def, FALSE, pattern, u_strlen(pattern));
473 resultlength=0;
474 resultlengthout=udat_toPattern(def, FALSE, NULL, resultlength,&status);
475 if(status==U_BUFFER_OVERFLOW_ERROR)
476 {
477 status=U_ZERO_ERROR;
478 resultlength=resultlengthout + 1;
479 if(result != NULL) {
480 free(result);
481 result = NULL;
482 }
483 result=(UChar*)malloc(sizeof(UChar) * resultlength);
484 udat_toPattern(fr, FALSE,result, resultlength, &status);
485 }
486 if(U_FAILURE(status))
487 {
488 log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
489 myErrorName(status) );
490 }
491 if(u_strcmp(result, pattern)==0)
492 log_verbose("Pattern applied properly\n");
493 else
494 log_err("pattern could not be applied properly\n");
495
496free(pattern);
497 /*testing set symbols */
498 resultlength=0;
499 resultlengthout=udat_getSymbols(fr, UDAT_MONTHS, 11 , NULL, resultlength, &status);
500 if(status==U_BUFFER_OVERFLOW_ERROR){
501 status=U_ZERO_ERROR;
502 resultlength=resultlengthout+1;
503 if(result != NULL) {
504 free(result);
505 result = NULL;
506 }
507 result=(UChar*)malloc(sizeof(UChar) * resultlength);
508 udat_getSymbols(fr, UDAT_MONTHS, 11, result, resultlength, &status);
509
510 }
511 if(U_FAILURE(status))
512 log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
513 resultlength=resultlengthout+1;
514
515 udat_setSymbols(def, UDAT_MONTHS, 11, result, resultlength, &status);
516 if(U_FAILURE(status))
517 {
518 log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
519 }
520 else
521 log_verbose("PASS: SetSymbols successful\n");
522
523 resultlength=0;
524 resultlengthout=udat_getSymbols(def, UDAT_MONTHS, 11, NULL, resultlength, &status);
525 if(status==U_BUFFER_OVERFLOW_ERROR){
526 status=U_ZERO_ERROR;
527 resultlength=resultlengthout+1;
528 value=(UChar*)malloc(sizeof(UChar) * resultlength);
529 udat_getSymbols(def, UDAT_MONTHS, 11, value, resultlength, &status);
530 }
531 if(U_FAILURE(status))
532 log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n");
533
534 if(u_strcmp(result, value)!=0)
535 log_data_err("FAIL: Error in settting and getting symbols\n");
536 else
537 log_verbose("PASS: setSymbols successful\n");
538
539
540 /*run series of tests to test setSymbols regressively*/
541 log_verbose("\nTesting setSymbols regressively\n");
542 VerifysetSymbols(def, UDAT_WEEKDAYS, 1, "Sundayweek");
543 VerifysetSymbols(def, UDAT_ERAS, 0, "BeforeChrist");
544 VerifysetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Satweek");
545 VerifysetSymbols(fr, UDAT_MONTHS, 11, "december");
546 VerifysetSymbols(fr, UDAT_SHORT_MONTHS, 0, "Jan");
547
548
549 /*run series of tests to test get and setSymbols regressively*/
550 log_verbose("\nTesting get and set symbols regressively\n");
551 VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 1);
552 VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 7);
553 VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 1);
554 VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 7);
555 VerifygetsetSymbols(fr, def, UDAT_MONTHS, 0);
556 VerifygetsetSymbols(fr, def, UDAT_SHORT_MONTHS, 0);
557 VerifygetsetSymbols(fr, def, UDAT_ERAS,1);
558 VerifygetsetSymbols(fr, def, UDAT_LOCALIZED_CHARS, 0);
559 VerifygetsetSymbols(fr, def, UDAT_AM_PMS, 1);
560
561
562 /*closing*/
563
564 udat_close(fr);
565 udat_close(def);
566 if(result != NULL) {
567 free(result);
568 result = NULL;
569 }
570 free(value);
571
572}
573
574/**
575 * Test DateFormat(Calendar) API
576 */
577static void TestDateFormatCalendar() {
578 UDateFormat *date=0, *time=0, *full=0;
579 UCalendar *cal=0;
580 UChar buf[256];
581 char cbuf[256];
582 int32_t pos;
583 UDate when;
584 UErrorCode ec = U_ZERO_ERROR;
585
374ca955
A
586 ctest_setTimeZone(NULL, &ec);
587
b75a7d8f
A
588 /* Create a formatter for date fields. */
589 date = udat_open(UDAT_NONE, UDAT_SHORT, "en_US", NULL, 0, NULL, 0, &ec);
590 if (U_FAILURE(ec)) {
591 log_err("FAIL: udat_open(NONE, SHORT, en_US) failed with %s\n",
592 u_errorName(ec));
593 goto FAIL;
594 }
595
596 /* Create a formatter for time fields. */
597 time = udat_open(UDAT_SHORT, UDAT_NONE, "en_US", NULL, 0, NULL, 0, &ec);
598 if (U_FAILURE(ec)) {
599 log_err("FAIL: udat_open(SHORT, NONE, en_US) failed with %s\n",
600 u_errorName(ec));
601 goto FAIL;
602 }
603
604 /* Create a full format for output */
605 full = udat_open(UDAT_FULL, UDAT_FULL, "en_US", NULL, 0, NULL, 0, &ec);
606 if (U_FAILURE(ec)) {
607 log_err("FAIL: udat_open(FULL, FULL, en_US) failed with %s\n",
608 u_errorName(ec));
609 goto FAIL;
610 }
611
612 /* Create a calendar */
613 cal = ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &ec);
614 if (U_FAILURE(ec)) {
615 log_err("FAIL: ucal_open(en_US) failed with %s\n",
616 u_errorName(ec));
617 goto FAIL;
618 }
619
620 /* Parse the date */
621 ucal_clear(cal);
622 u_uastrcpy(buf, "4/5/2001");
623 pos = 0;
624 udat_parseCalendar(date, cal, buf, -1, &pos, &ec);
625 if (U_FAILURE(ec)) {
626 log_err("FAIL: udat_parseCalendar(4/5/2001) failed at %d with %s\n",
627 pos, u_errorName(ec));
628 goto FAIL;
629 }
630
631 /* Parse the time */
632 u_uastrcpy(buf, "5:45 PM");
633 pos = 0;
634 udat_parseCalendar(time, cal, buf, -1, &pos, &ec);
635 if (U_FAILURE(ec)) {
636 log_err("FAIL: udat_parseCalendar(17:45) failed at %d with %s\n",
637 pos, u_errorName(ec));
638 goto FAIL;
639 }
640
641 /* Check result */
642 when = ucal_getMillis(cal, &ec);
643 if (U_FAILURE(ec)) {
644 log_err("FAIL: ucal_getMillis() failed with %s\n", u_errorName(ec));
645 goto FAIL;
646 }
647 udat_format(full, when, buf, sizeof(buf), NULL, &ec);
648 if (U_FAILURE(ec)) {
649 log_err("FAIL: udat_format() failed with %s\n", u_errorName(ec));
650 goto FAIL;
651 }
652 u_austrcpy(cbuf, buf);
653 /* Thursday, April 5, 2001 5:45:00 PM PDT 986517900000 */
654 if (when == 986517900000.0) {
655 log_verbose("Ok: Parsed result: %s\n", cbuf);
656 } else {
374ca955 657 log_err("FAIL: Parsed result: %s, exp 4/5/2001 5:45 PM\n", cbuf);
b75a7d8f
A
658 }
659
660 FAIL:
661 udat_close(date);
662 udat_close(time);
663 udat_close(full);
664 ucal_close(cal);
374ca955
A
665
666 ctest_resetTimeZone();
b75a7d8f
A
667}
668
669/*INTERNAL FUNCTIONS USED*/
670static void VerifygetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t index, const char* expected)
671{
672 UChar *pattern=NULL;
673 UErrorCode status = U_ZERO_ERROR;
674 UChar *result=NULL;
675 int32_t resultlength, resultlengthout;
676
677
678 pattern=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1));
679 u_uastrcpy(pattern, expected);
680 resultlength=0;
681 resultlengthout=udat_getSymbols(datfor, type, index , NULL, resultlength, &status);
682 if(status==U_BUFFER_OVERFLOW_ERROR)
683 {
684 status=U_ZERO_ERROR;
685 resultlength=resultlengthout+1;
686 result=(UChar*)malloc(sizeof(UChar) * resultlength);
687 udat_getSymbols(datfor, type, index, result, resultlength, &status);
688
689 }
690 if(U_FAILURE(status))
691 {
692 log_err("FAIL: Error in udat_getSymbols()... %s\n", myErrorName(status) );
693 return;
694 }
695 if(u_strcmp(result, pattern)==0)
696 log_verbose("PASS: getSymbols retrieved the right value\n");
697 else{
698 log_data_err("FAIL: getSymbols retrieved the wrong value\n Expected %s Got %s\n", austrdup(pattern),
699 austrdup(result) );
700 }
701 free(result);
702 free(pattern);
703}
704
705static void VerifysetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t index, const char* expected)
706{
707 UChar *result=NULL;
708 UChar *value=NULL;
709 int32_t resultlength, resultlengthout;
710 UErrorCode status = U_ZERO_ERROR;
711
712 value=(UChar*)malloc(sizeof(UChar) * (strlen(expected) + 1));
713 u_uastrcpy(value, expected);
714 udat_setSymbols(datfor, type, index, value, u_strlen(value), &status);
715 if(U_FAILURE(status))
716 {
717 log_err("FAIL: Error in udat_setSymbols() %s\n", myErrorName(status) );
718 return;
719 }
720
721 resultlength=0;
722 resultlengthout=udat_getSymbols(datfor, type, index, NULL, resultlength, &status);
723 if(status==U_BUFFER_OVERFLOW_ERROR){
724 status=U_ZERO_ERROR;
725 resultlength=resultlengthout+1;
726 result=(UChar*)malloc(sizeof(UChar) * resultlength);
727 udat_getSymbols(datfor, type, index, result, resultlength, &status);
728 }
729 if(U_FAILURE(status)){
730 log_err("FAIL: error in retrieving the value using getSymbols after setting it previously\n %s\n",
731 myErrorName(status) );
732 return;
733 }
734
735 if(u_strcmp(result, value)!=0){
736 log_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(value),
737 austrdup(result) );
738 }
739 else
740 log_verbose("PASS: setSymbols successful\n");
741
742 free(value);
743 free(result);
744}
745
746
747static void VerifygetsetSymbols(UDateFormat* from, UDateFormat* to, UDateFormatSymbolType type, int32_t index)
748{
749 UChar *result=NULL;
750 UChar *value=NULL;
751 int32_t resultlength, resultlengthout;
752 UErrorCode status = U_ZERO_ERROR;
753
754 resultlength=0;
755 resultlengthout=udat_getSymbols(from, type, index , NULL, resultlength, &status);
756 if(status==U_BUFFER_OVERFLOW_ERROR){
757 status=U_ZERO_ERROR;
758 resultlength=resultlengthout+1;
759 result=(UChar*)malloc(sizeof(UChar) * resultlength);
760 udat_getSymbols(from, type, index, result, resultlength, &status);
761 }
762 if(U_FAILURE(status)){
763 log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
764 return;
765 }
766
767 resultlength=resultlengthout+1;
768 udat_setSymbols(to, type, index, result, resultlength, &status);
769 if(U_FAILURE(status))
770 {
771 log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
772 return;
773 }
774
775 resultlength=0;
776 resultlengthout=udat_getSymbols(to, type, index, NULL, resultlength, &status);
777 if(status==U_BUFFER_OVERFLOW_ERROR){
778 status=U_ZERO_ERROR;
779 resultlength=resultlengthout+1;
780 value=(UChar*)malloc(sizeof(UChar) * resultlength);
781 udat_getSymbols(to, type, index, value, resultlength, &status);
782 }
783 if(U_FAILURE(status)){
784 log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n %s\n",
785 myErrorName(status) );
786 return;
787 }
788
789 if(u_strcmp(result, value)!=0){
790 log_data_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(result),
791 austrdup(value) );
792 }
793 else
794 log_verbose("PASS: setSymbols successful\n");
795
796 free(value);
797 free(result);
798}
799
800
801static UChar* myNumformat(const UNumberFormat* numfor, double d)
802{
803 UChar *result2=NULL;
804 int32_t resultlength, resultlengthneeded;
805 UErrorCode status = U_ZERO_ERROR;
806
807 resultlength=0;
808 resultlengthneeded=unum_formatDouble(numfor, d, NULL, resultlength, NULL, &status);
809 if(status==U_BUFFER_OVERFLOW_ERROR)
810 {
811 status=U_ZERO_ERROR;
812 resultlength=resultlengthneeded+1;
813 /*result2=(UChar*)malloc(sizeof(UChar) * resultlength);*/ /* this leaks */
814 result2=(UChar*)ctst_malloc(sizeof(UChar) * resultlength); /*this won't*/
815 unum_formatDouble(numfor, d, result2, resultlength, NULL, &status);
816 }
817 if(U_FAILURE(status))
818 {
819 log_err("FAIL: Error in formatting using unum_format(.....) %s\n", myErrorName(status) );
820 return 0;
821 }
822
823 return result2;
824}
825
374ca955
A
826/**
827 * The search depth for TestExtremeDates. The total number of
828 * dates that will be tested is (2^EXTREME_DATES_DEPTH) - 1.
829 */
830#define EXTREME_DATES_DEPTH 8
831
832/**
833 * Support for TestExtremeDates (below).
834 *
835 * Test a single date to see whether udat_format handles it properly.
836 */
837static UBool _aux1ExtremeDates(UDateFormat* fmt, UDate date,
838 UChar* buf, int32_t buflen, char* cbuf,
839 UErrorCode* ec) {
840 int32_t len = udat_format(fmt, date, buf, buflen, 0, ec);
841 if (!assertSuccess("udat_format", ec)) return FALSE;
842 u_austrncpy(cbuf, buf, buflen);
843 if (len < 4) {
844 log_err("FAIL: udat_format(%g) => \"%s\"\n", date, cbuf);
845 } else {
846 log_verbose("udat_format(%g) => \"%s\"\n", date, cbuf);
847 }
848 return TRUE;
849}
850
851/**
852 * Support for TestExtremeDates (below).
853 *
854 * Recursively test between 'small' and 'large', up to the depth
855 * limit specified by EXTREME_DATES_DEPTH.
856 */
857static UBool _aux2ExtremeDates(UDateFormat* fmt, UDate small, UDate large,
858 UChar* buf, int32_t buflen, char* cbuf,
859 int32_t count,
860 UErrorCode* ec) {
861 /* Logarithmic midpoint; see below */
862 UDate mid = (UDate) exp((log(small) + log(large)) / 2);
863 if (count == EXTREME_DATES_DEPTH) {
864 return TRUE;
865 }
866 return
867 _aux1ExtremeDates(fmt, mid, buf, buflen, cbuf, ec) &&
868 _aux2ExtremeDates(fmt, small, mid, buf, buflen, cbuf, count+1, ec) &&
869 _aux2ExtremeDates(fmt, mid, large, buf, buflen, cbuf, count+1, ec);
870}
871
872/**
873 * http://www.jtcsv.com/cgibin/icu-bugs?findid=3659
874 *
875 * For certain large dates, udat_format crashes on MacOS. This test
876 * attempts to reproduce this problem by doing a recursive logarithmic*
877 * binary search of a predefined interval (from 'small' to 'large').
878 *
879 * The limit of the search is given by EXTREME_DATES_DEPTH, above.
880 *
881 * *The search has to be logarithmic, not linear. A linear search of the
882 * range 0..10^30, for example, will find 0.5*10^30, then 0.25*10^30 and
883 * 0.75*10^30, etc. A logarithmic search will find 10^15, then 10^7.5
884 * and 10^22.5, etc.
885 */
886static void TestExtremeDates() {
887 UDateFormat *fmt;
888 UErrorCode ec;
889 UChar buf[256];
890 char cbuf[256];
891 const double small = 1000; /* 1 sec */
892 const double large = 1e+30; /* well beyond usable UDate range */
893
894 /* There is no need to test larger values from 1e+30 to 1e+300;
895 the failures occur around 1e+27, and never above 1e+30. */
896
897 ec = U_ZERO_ERROR;
898 fmt = udat_open(UDAT_LONG, UDAT_LONG, "en_US",
899 0, 0, 0, 0, &ec);
900 if (!assertSuccess("udat_open", &ec)) return;
901
902 _aux2ExtremeDates(fmt, small, large, buf, LEN(buf), cbuf, 0, &ec);
903
904 udat_close(fmt);
905}
906
b75a7d8f 907#endif /* #if !UCONFIG_NO_FORMATTING */