]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/cintltst/cdtrgtst.c
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-400.38.tar.gz
[apple/icu.git] / icuSources / test / cintltst / cdtrgtst.c
1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2008, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6 /********************************************************************************
7 *
8 * File CDTRGTST.C
9 *
10 * Madhu Katragadda Ported for C API
11 * Modification History:
12 * Date Name Description
13 * 07/15/99 helena Ported to HPUX 10/11 CC.
14 *********************************************************************************
15 */
16 /* REGRESSION 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 "cdtrgtst.h"
29 #include "cmemory.h"
30
31 void addDateForRgrTest(TestNode** root);
32
33 void addDateForRgrTest(TestNode** root)
34 {
35 addTest(root, &Test4029195, "tsformat/cdtrgtst/Test4029195");
36 addTest(root, &Test4056591, "tsformat/cdtrgtst/Test4056591");
37 addTest(root, &Test4059917, "tsformat/cdtrgtst/Test4059917");
38 addTest(root, &Test4060212, "tsformat/cdtrgtst/Test4060212");
39 addTest(root, &Test4061287, "tsformat/cdtrgtst/Test4061287");
40 addTest(root, &Test4073003, "tsformat/cdtrgtst/Test4073003");
41 addTest(root, &Test4162071, "tsformat/cdtrgtst/Test4162071");
42 addTest(root, &Test714, "tsformat/cdtrgtst/Test714");
43 addTest(root, &Test_GEec, "tsformat/cdtrgtst/Test_GEec"); /* tests for format chars GEec, jitterbugs 5726 6072 6585 */
44 }
45
46 /**
47 * @bug 4029195
48 */
49 void Test4029195()
50 {
51 int32_t resultlength, resultlengthneeded;
52 UChar *fmdt, *todayS, *rt;
53 UChar *pat=NULL;
54 UChar *temp;
55 UDate today, d1;
56 UDateFormat *df;
57 int32_t parsepos;
58 UErrorCode status = U_ZERO_ERROR;
59
60 log_verbose("Testing date format and parse function in regression test\n");
61 today = ucal_getNow();
62
63 df = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status);
64 if(U_FAILURE(status))
65 {
66 log_err("FAIL: error in creating the dateformat using default date and time style : %s\n", myErrorName(status));
67 return;
68 }
69 resultlength=0;
70 resultlengthneeded=udat_toPattern(df, TRUE, NULL, resultlength, &status);
71 if(status==U_BUFFER_OVERFLOW_ERROR)
72 {
73 status=U_ZERO_ERROR;
74 resultlength=resultlengthneeded + 1;
75 pat=(UChar*)malloc(sizeof(UChar) * resultlength);
76 udat_toPattern(df, TRUE, pat, resultlength, &status);
77 }
78
79 log_verbose("pattern: %s\n", austrdup(pat));
80
81
82 fmdt = myFormatit(df, today);
83 if(fmdt) {
84 log_verbose("today: %s\n", austrdup(fmdt));
85 } else {
86 log_data_err("ERROR: couldn't format, exitting test");
87 return;
88 }
89
90 temp=(UChar*)malloc(sizeof(UChar) * 10);
91 u_uastrcpy(temp, "M yyyy dd");
92 udat_applyPattern(df, TRUE, temp, u_strlen(temp));
93
94 todayS =myFormatit(df, today);
95 log_verbose("After teh pattern is applied\n today: %s\n", austrdup(todayS) );
96 parsepos=0;
97 d1=udat_parse(df, todayS, u_strlen(todayS), &parsepos, &status);
98 if(U_FAILURE(status))
99 {
100 log_err("FAIL: Error in parsing using udat_parse(.....): %s\n", myErrorName(status));
101 }
102
103 rt =myFormatit(df, d1);
104 log_verbose("today: %s\n", austrdup(rt) );
105
106 log_verbose("round trip: %s\n", austrdup(rt) );
107
108 if(u_strcmp(rt, todayS)!=0) {
109 log_err("Fail: Want %s Got %s\n", austrdup(todayS), austrdup(rt) );
110 }
111 else
112 log_verbose("Pass: parse and format working fine\n");
113 udat_close(df);
114 free(temp);
115 if(pat != NULL) {
116 free(pat);
117 }
118 }
119
120
121 /**
122 * @bug 4056591
123 * Verify the function of the [s|g]et2DigitYearStart() API.
124 */
125 void Test4056591()
126 {
127 int i;
128 UCalendar *cal;
129 UDateFormat *def;
130 UDate start,exp,got;
131 UChar s[10];
132 UChar *gotdate, *expdate;
133 UChar pat[10];
134 UDate d[4];
135 UErrorCode status = U_ZERO_ERROR;
136 const char* strings[] = {
137 "091225",
138 "091224",
139 "611226",
140 "991227"
141 };
142
143 log_verbose("Testing s[get] 2 digit year start regressively\n");
144 cal=ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status);
145 if(U_FAILURE(status)){
146 log_err("error in ucal_open caldef : %s\n", myErrorName(status));
147 }
148 ucal_setDateTime(cal, 1809, UCAL_DECEMBER, 25, 17, 40, 30, &status);
149 d[0]=ucal_getMillis(cal, &status);
150 if(U_FAILURE(status)){
151 log_err("Error: failure in get millis: %s\n", myErrorName(status));
152 }
153 ucal_setDateTime(cal, 1909, UCAL_DECEMBER, 24, 17, 40, 30, &status);
154 d[1]=ucal_getMillis(cal, &status);
155 ucal_setDateTime(cal, 1861, UCAL_DECEMBER, 26, 17, 40, 30, &status);
156 d[2]=ucal_getMillis(cal, &status);
157 ucal_setDateTime(cal, 1999, UCAL_DECEMBER, 27, 17, 40, 30, &status);
158 d[3]=ucal_getMillis(cal, &status);
159
160
161 u_uastrcpy(pat, "yyMMdd");
162 def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL, NULL, 0, pat, u_strlen(pat), &status);
163 if(U_FAILURE(status))
164 {
165 log_err("FAIL: error in creating the dateformat using u_openPattern(): %s\n", myErrorName(status));
166 return;
167 }
168 start = 1800;
169 udat_set2DigitYearStart(def, start, &status);
170 if(U_FAILURE(status))
171 log_err("ERROR: in setTwoDigitStartDate: %s\n", myErrorName(status));
172 if( (udat_get2DigitYearStart(def, &status) != start))
173 log_err("ERROR: get2DigitYearStart broken\n");
174
175
176 for(i = 0; i < 4; ++i) {
177 u_uastrcpy(s, strings[i]);
178 exp = d[i];
179 got = udat_parse(def, s, u_strlen(s), 0, &status);
180 gotdate=myFormatit(def, got);
181 expdate=myFormatit(def, exp);
182
183 if (gotdate == NULL || expdate == NULL) {
184 log_err("myFormatit failed!\n");
185 }
186 else if(u_strcmp(gotdate, expdate) !=0){
187 log_err("set2DigitYearStart broken for %s \n got: %s, expected: %s\n", austrdup(s),
188 austrdup(gotdate), austrdup(expdate) );
189 }
190 }
191
192 udat_close(def);
193 ucal_close(cal);
194 }
195
196
197 /**
198 * SimpleDateFormat does not properly parse date strings without delimiters
199 * @bug 4059917
200 */
201 void Test4059917()
202 {
203 UDateFormat* def;
204 UChar *myDate;
205 UErrorCode status = U_ZERO_ERROR;
206 UChar pattern[11];
207 UChar tzID[4];
208
209 log_verbose("Testing apply pattern and to pattern regressively\n");
210 u_uastrcpy(tzID, "PST");
211 u_uastrcpy(pattern, "yyyy/MM/dd");
212 log_verbose("%s\n", austrdup(pattern) );
213 def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,tzID,-1,pattern, u_strlen(pattern),&status);
214 if(U_FAILURE(status))
215 {
216 log_err("FAIL: error in creating the dateformat using openPattern: %s\n", myErrorName(status));
217 return;
218 }
219 myDate=(UChar*)malloc(sizeof(UChar) * 11);
220 u_uastrcpy(myDate, "1970/01/12");
221
222 aux917( def, myDate );
223 udat_close(def);
224
225 u_uastrcpy(pattern, "yyyyMMdd");
226 def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,tzID,-1,pattern, u_strlen(pattern),&status);
227 if(U_FAILURE(status))
228 {
229 log_err("FAIL: error in creating the dateformat using openPattern: %s\n", myErrorName(status));
230 return;
231 }
232 u_uastrcpy(myDate, "19700112");
233 aux917( def, myDate );
234 udat_close(def);
235 free(myDate);
236 }
237
238 void aux917( UDateFormat *fmt, UChar* str)
239 {
240 int32_t resultlength, resultlengthneeded;
241 UErrorCode status = U_ZERO_ERROR;
242 UChar* formatted=NULL;
243 UChar *pat=NULL;
244 UDate d1=1000000000.0;
245
246 resultlength=0;
247 resultlengthneeded=udat_toPattern(fmt, TRUE, NULL, resultlength, &status);
248 if(status==U_BUFFER_OVERFLOW_ERROR)
249 {
250 status=U_ZERO_ERROR;
251 resultlength=resultlengthneeded + 1;
252 pat=(UChar*)malloc(sizeof(UChar) * (resultlength));
253 udat_toPattern(fmt, TRUE, pat, resultlength, &status);
254 }
255 if(U_FAILURE(status)){
256 log_err("failure in retrieving the pattern: %s\n", myErrorName(status));
257 }
258 log_verbose("pattern: %s\n", austrdup(pat) );
259
260 status = U_ZERO_ERROR;
261 formatted = myFormatit(fmt, d1);
262 if( u_strcmp(formatted,str)!=0) {
263 log_err("Fail: Want %s Got: %s\n", austrdup(str), austrdup(formatted) );
264 }
265 free(pat);
266 }
267
268 /**
269 * @bug 4060212
270 */
271 void Test4060212()
272 {
273 int32_t pos;
274 UCalendar *cal;
275 UDateFormat *formatter, *fmt;
276 UErrorCode status = U_ZERO_ERROR;
277 UDate myDate;
278 UChar *myString;
279 UChar dateString[30], pattern[20], tzID[4];
280 u_uastrcpy(dateString, "1995-040.05:01:29 -8");
281 u_uastrcpy(pattern, "yyyy-DDD.hh:mm:ss z");
282
283 log_verbose( "dateString= %s Using yyyy-DDD.hh:mm:ss\n", austrdup(dateString) );
284 status = U_ZERO_ERROR;
285 u_uastrcpy(tzID, "PST");
286
287 formatter = udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US",tzID,-1,pattern, u_strlen(pattern), &status);
288 pos=0;
289 myDate = udat_parse(formatter, dateString, u_strlen(dateString), &pos, &status);
290
291
292 fmt = udat_open(UDAT_FULL,UDAT_LONG ,NULL, tzID, -1, NULL, 0, &status);
293 if(U_FAILURE(status))
294 {
295 log_err("FAIL: error in creating the dateformat using default date and time style: %s\n",
296 myErrorName(status) );
297 return;
298 }
299 myString = myFormatit(fmt, myDate);
300 cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_GREGORIAN, &status);
301 if(U_FAILURE(status)){
302 log_err("FAIL: error in ucal_open caldef : %s\n", myErrorName(status));
303 }
304 ucal_setMillis(cal, myDate, &status);
305 if ((ucal_get(cal, UCAL_DAY_OF_YEAR, &status) != 40)){
306 log_err("Fail: Got %d Expected 40\n", ucal_get(cal, UCAL_DAY_OF_YEAR, &status));
307 }
308
309 udat_close(formatter);
310 ucal_close(cal);
311 udat_close(fmt);
312
313 }
314
315 /**
316 * @bug 4061287
317 */
318 void Test4061287()
319 {
320 UBool ok;
321 int32_t pos;
322 UDateFormat *df;
323 UErrorCode status = U_ZERO_ERROR;
324 UDate myDate;
325 UChar pattern[21], dateString[11];
326
327 u_uastrcpy(dateString, "35/13/1971");
328 u_uastrcpy(pattern, "dd/mm/yyyy");
329 status = U_ZERO_ERROR;
330 log_verbose("Testing parsing by changing the attribute lenient\n");
331 df = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,NULL,0,pattern, u_strlen(pattern),&status);
332 if(U_FAILURE(status)){
333 log_err("ERROR: failure in open pattern of test4061287: %s\n", myErrorName(status));
334 return;
335 }
336
337 pos=0;
338
339 udat_setLenient(df, FALSE);
340 ok=udat_isLenient(df);
341 if(ok==TRUE)
342 log_err("setLenient nor working\n");
343 ok = FALSE;
344 myDate = udat_parse(df, dateString, u_strlen(dateString), &pos, &status);
345 if(U_FAILURE(status))
346 ok = TRUE;
347 if(ok!=TRUE)
348 log_err("Fail: Lenient not working: does lenient parsing in spite of setting Leninent as FALSE ");
349
350 udat_close(df);
351
352 }
353
354
355
356 /* The java.text.DateFormat.parse(String) method expects for the
357 US locale a string formatted according to mm/dd/yy and parses it
358 correctly.
359
360 When given a string mm/dd/yyyy it only parses up to the first
361 two y's, typically resulting in a date in the year 1919.
362
363 Please extend the parsing method(s) to handle strings with
364 four-digit year values (probably also applicable to various
365 other locales. */
366 /**
367 * @bug 4073003
368 */
369 void Test4073003()
370 {
371 int32_t pos,i;
372 UDate d,dd;
373 UChar *datestr;
374 UChar temp[15];
375 UErrorCode status = U_ZERO_ERROR;
376 UDateFormat *fmt;
377 UChar *result, *result2;
378 const char* tests [] = {
379 "12/25/61",
380 "12/25/1961",
381 "4/3/1999",
382 "4/3/99"
383 };
384
385 fmt= udat_open(UDAT_SHORT,UDAT_SHORT ,NULL, NULL, 0, NULL, 0, &status);
386 if(U_FAILURE(status))
387 {
388 log_err("FAIL: error in creating the dateformat using short date and time style: %s\n",
389 myErrorName(status));
390 return;
391 }
392 u_uastrcpy(temp, "m/D/yy");
393 udat_applyPattern(fmt, FALSE, temp, u_strlen(temp));
394
395 for(i= 0; i < 4; i+=2) {
396 status=U_ZERO_ERROR;
397 datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i])+1));
398 u_uastrcpy(datestr, tests[i]);
399
400 pos=0;
401 d = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);
402 if(U_FAILURE(status)){
403 log_err("ERROR : in test 4073003: %s\n", myErrorName(status));
404 }
405
406 free(datestr);
407 datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i+1])+1));
408 u_uastrcpy(datestr, tests[i+1]);
409
410 pos=0;
411 status=U_ZERO_ERROR;
412 dd = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);
413 if(U_FAILURE(status)){
414 log_err("ERROR : in test 4073003: %s\n", myErrorName(status));
415 }
416 free(datestr);
417
418 result =myFormatit(fmt, d);
419 result2 =myFormatit(fmt, dd);
420 if(!result || !result2) {
421 log_data_err("Fail: could not format - exitting test\n");
422 return;
423 }
424 if (u_strcmp(result, result2)!=0){
425 log_err("Fail: %s != %s\n", austrdup(result), austrdup(result2) );
426 }
427 else{
428 log_verbose("Ok: %s == %s\n", austrdup(result), austrdup(result2) );
429 }
430
431 }
432 udat_close(fmt);
433 }
434
435 /**
436 * @bug 4162071
437 **/
438 void Test4162071()
439 {
440 int32_t pos;
441 UDate x;
442 UErrorCode status = U_ZERO_ERROR;
443 UDateFormat *df;
444 UChar datestr[30];
445 UChar format[50];
446 u_uastrcpy(datestr, "Thu, 30-Jul-1999 11:51:14 GMT");
447 u_uastrcpy(format, "EEE', 'dd-MMM-yyyy HH:mm:ss z"); /* RFC 822/1123 */
448 status = U_ZERO_ERROR;
449 /* Can't hardcode the result to assume the default locale is "en_US". */
450 df = udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US",NULL,0,format, u_strlen(format),&status);
451 if(U_FAILURE(status)){
452 log_data_err("ERROR: couldn't create date format: %s\n", myErrorName(status));
453 return;
454 }
455 pos=0;
456 x = udat_parse(df, datestr, u_strlen(datestr), &pos, &status);
457 if(U_FAILURE(status)){
458 log_data_err("ERROR : parse format %s fails : %s\n", austrdup(format), myErrorName(status));
459 }
460 else{
461 log_verbose("Parse format \"%s \" ok.\n", austrdup(format) );
462 }
463 /*log_verbose("date= %s\n", austrdup(myFormatit(df, x)) );*/
464 udat_close(df);
465 }
466
467 void Test714(void)
468 {
469 UDate d=978103543000.0;
470 UChar temp[20];
471 UErrorCode status = U_ZERO_ERROR;
472 UDateFormat *fmt;
473 UChar *result;
474 const char* expect = "7:25:43 AM";
475
476 ctest_setTimeZone(NULL, &status);
477
478 fmt= udat_open(UDAT_MEDIUM,UDAT_NONE ,"en_US_CA", NULL, -1, NULL, 0, &status);
479 if(U_FAILURE(status))
480 {
481 log_err("FAIL: error in creating the dateformat using medium time style and NO date style: %s\n",
482 myErrorName(status));
483 return;
484 }
485 result =myFormatit(fmt, d);
486 if(!result) {
487 log_data_err("Fail: could not format - exitting test\n");
488 return;
489 }
490 u_uastrcpy(temp, expect);
491 if (u_strcmp(result, temp)!=0){
492 log_err("Fail: %s != %s\n", austrdup(result), expect);
493 }
494 else{
495 log_verbose("Ok: %s == %s\n", austrdup(result), expect );
496 }
497
498 udat_close(fmt);
499
500 ctest_resetTimeZone();
501 }
502
503 enum { DATE_TEXT_MAX_CHARS = 64 };
504 static const UChar zonePST[] = { 0x50,0x53,0x54,0 }; /* "PST" */
505 static const UDate july022008 = 1.215e+12; /* 02 July 2008 5:00 AM PDT (approx ICU 4.0 release date :-) */
506 static const double dayMillisec = 8.64e+07;
507
508 static const UChar dMyGGGPattern[] = { 0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0x20,0x47,0x47,0x47,0 }; /* "dd MMM yyyy GGG" */
509 static const UChar dMyGGGGGPattern[] = { 0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0x20,0x47,0x47,0x47,0x47,0x47,0 }; /* "dd MMM yyyy GGGGG" */
510 static const UChar dMyGGGText[] = { 0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0x20,0x41,0x44,0 }; /* "02 Jul 2008 AD" */
511 static const UChar dMyGGGGGText[] = { 0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0x20,0x41,0 }; /* "02 Jul 2008 A" */
512 static const UChar edMyPattern[] = { 0x65,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "e dd MMM yyyy" */
513 static const UChar eedMyPattern[] = { 0x65,0x65,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "ee dd MMM yyyy" */
514 static const UChar cdMyPattern[] = { 0x63,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "c dd MMM yyyy" */
515 static const UChar ccdMyPattern[] = { 0x63,0x63,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "cc dd MMM yyyy" */
516 static const UChar edMyText[] = { 0x33,0x20,0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0 }; /* "3 02 Jul 2008" */
517 static const UChar eedMyText[] = { 0x30,0x33,0x20,0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0 }; /* "03 02 Jul 2008" */
518 static const UChar eeedMyPattern[] = { 0x65,0x65,0x65,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "eee dd MMM yyyy" */
519 static const UChar EEEdMyPattern[] = { 0x45,0x45,0x45,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "EEE dd MMM yyyy" */
520 static const UChar EEdMyPattern[] = { 0x45,0x45,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "EE dd MMM yyyy" */
521 static const UChar eeedMyText[] = { 0x57,0x65,0x64,0x20,0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0 }; /* "Wed 02 Jul 2008" */
522 static const UChar eeeedMyPattern[] = { 0x65,0x65,0x65,0x65,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "eeee dd MMM yyyy" */
523 static const UChar eeeedMyText[] = { 0x57,0x65,0x64,0x6E,0x65,0x73,0x64,0x61,0x79,0x20,0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0 }; /* "Wednesday 02 Jul 2008" */
524 static const UChar eeeeedMyPattern[] = { 0x65,0x65,0x65,0x65,0x65,0x20,0x64,0x64,0x20,0x4D,0x4D,0x4D,0x20,0x79,0x79,0x79,0x79,0 }; /* "eeeee dd MMM yyyy" */
525 static const UChar eeeeedMyText[] = { 0x57,0x20,0x30,0x32,0x20,0x4A,0x75,0x6C,0x20,0x32,0x30,0x30,0x38,0 }; /* "W 02 Jul 2008" */
526 static const UChar ewYPattern[] = { 0x65,0x20,0x77,0x77,0x20,0x59,0x59,0x59,0x59,0 }; /* "e ww YYYY" */
527 static const UChar cwYPattern[] = { 0x63,0x20,0x77,0x77,0x20,0x59,0x59,0x59,0x59,0 }; /* "c ww YYYY" */
528 static const UChar ewYText[] = { 0x33,0x20,0x32,0x37,0x20,0x32,0x30,0x30,0x38,0 }; /* "3 27 2008" */
529
530 typedef struct {
531 const UChar * pattern;
532 const UChar * text;
533 const char * label;
534 } DatePatternAndText;
535 static const DatePatternAndText datePatternsAndText[] = {
536 { dMyGGGPattern, dMyGGGText, "dd MMM yyyy GGG" },
537 { dMyGGGGGPattern, dMyGGGGGText, "dd MMM yyyy GGGGG" },
538 { edMyPattern, edMyText, "e dd MMM yyyy" },
539 { eedMyPattern, eedMyText, "ee dd MMM yyyy" },
540 { cdMyPattern, edMyText, "c dd MMM yyyy" },
541 { ccdMyPattern, edMyText, "cc dd MMM yyyy" },
542 { eeedMyPattern, eeedMyText, "eee dd MMM yyyy" },
543 { EEEdMyPattern, eeedMyText, "EEE dd MMM yyyy" },
544 { EEdMyPattern, eeedMyText, "EE dd MMM yyyy" },
545 { eeeedMyPattern, eeeedMyText, "eeee dd MMM yyyy" },
546 { eeeeedMyPattern, eeeeedMyText, "eeeee dd MMM yyyy" },
547 { ewYPattern, ewYText, "e ww YYYY" },
548 { cwYPattern, ewYText, "c ww YYYY" },
549 { NULL, NULL, NULL }
550 };
551 void Test_GEec(void)
552 {
553 UErrorCode status = U_ZERO_ERROR;
554 UDateFormat * dtfmt = udat_open(UDAT_LONG, UDAT_LONG, "en", zonePST, -1, NULL, 0, &status);
555 if ( U_SUCCESS(status) ) {
556 const DatePatternAndText *patTextPtr;
557 for (patTextPtr = datePatternsAndText; patTextPtr->pattern != NULL; ++patTextPtr) {
558 UChar dmyGnText[DATE_TEXT_MAX_CHARS];
559 int32_t dmyGnTextLen;
560 UDate dateResult;
561
562 udat_applyPattern(dtfmt, FALSE, patTextPtr->pattern, -1);
563 dmyGnTextLen = udat_format(dtfmt, july022008, dmyGnText, DATE_TEXT_MAX_CHARS, NULL, &status);
564 if ( U_FAILURE(status) ) {
565 log_err("FAIL: udat_format with %s: %s\n", patTextPtr->label, myErrorName(status) );
566 status = U_ZERO_ERROR;
567 } else if ( u_strcmp(dmyGnText, patTextPtr->text) != 0 ) {
568 log_err("FAIL: udat_format with %s: wrong UChar[] result\n", patTextPtr->label );
569 }
570
571 dateResult = udat_parse(dtfmt, patTextPtr->text, -1, NULL, &status); /* no time, dateResult != july022008 by some hours */
572 if ( U_FAILURE(status) ) {
573 log_err("FAIL: udat_parse with %s: %s\n", patTextPtr->label, myErrorName(status) );
574 status = U_ZERO_ERROR;
575 } else if ( july022008 - dateResult > dayMillisec ) {
576 log_err("FAIL: udat_parse with %s: wrong UDate result\n", patTextPtr->label );
577 }
578 }
579 udat_close(dtfmt);
580 } else {
581 log_err("FAIL: udat_open fails: %s\n", myErrorName(status));
582 }
583 }
584
585 /*INTERNAL FUNCTION USED */
586
587 UChar* myFormatit(UDateFormat* datdef, UDate d1)
588 {
589 UChar *result1=NULL;
590 int32_t resultlength, resultlengthneeded;
591 UErrorCode status = U_ZERO_ERROR;
592
593 resultlength=0;
594 resultlengthneeded=udat_format(datdef, d1, NULL, resultlength, NULL, &status);
595 if(status==U_BUFFER_OVERFLOW_ERROR)
596 {
597 status=U_ZERO_ERROR;
598 resultlength=resultlengthneeded+1;
599 /*result1=(UChar*)malloc(sizeof(UChar) * resultlength);*/ /*this leaks*/
600 result1=(UChar*)ctst_malloc(sizeof(UChar) * resultlength); /*this won't*/
601 udat_format(datdef, d1, result1, resultlength, NULL, &status);
602 }
603 if(U_FAILURE(status))
604 {
605 log_err("FAIL: Error in formatting using udat_format(.....): %s\n", myErrorName(status));
606 return 0;
607 }
608
609
610 return result1;
611
612 }
613
614 #endif /* #if !UCONFIG_NO_FORMATTING */
615
616 /*eof*/
mirror of ICU