1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2007-2015, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: udatpg_test.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2007aug01
14 * created by: Markus W. Scherer
15 *
16 * Test of the C wrapper for the DateTimePatternGenerator.
17 * Calls each C API function and exercises code paths in the wrapper,
18 * but the full functionality is tested in the C++ intltest.
19 *
20 * One item to note: C API functions which return a const UChar *
21 * should return a NUL-terminated string.
22 * (The C++ implementation needs to use getTerminatedBuffer()
23 * on UnicodeString objects which end up being returned this way.)
24 */
25
26 #include "unicode/utypes.h"
27
28 #if !UCONFIG_NO_FORMATTING
29 #include "unicode/udat.h"
30 #include "unicode/udatpg.h"
31 #include "unicode/ustring.h"
32 #include "cintltst.h"
33
34 void addDateTimePatternGeneratorTest(TestNode** root);
35
36 #define TESTCASE(x) addTest(root, &x, "tsformat/udatpg_test/" #x)
37
38 static void TestOpenClose(void);
39 static void TestUsage(void);
40 static void TestBuilder(void);
41 static void TestOptions(void);
42
addDateTimePatternGeneratorTest(TestNode ** root)43 void addDateTimePatternGeneratorTest(TestNode** root) {
44 TESTCASE(TestOpenClose);
45 TESTCASE(TestUsage);
46 TESTCASE(TestBuilder);
47 TESTCASE(TestOptions);
48 }
49
50 /*
51 * Pipe symbol '|'. We pass only the first UChar without NUL-termination.
52 * The second UChar is just to verify that the API does not pick that up.
53 */
54 static const UChar pipeString[]={ 0x7c, 0x0a };
55
56 static const UChar testSkeleton1[]={ 0x48, 0x48, 0x6d, 0x6d, 0 }; /* HHmm */
57 static const UChar expectingBestPattern[]={ 0x48, 0x2e, 0x6d, 0x6d, 0 }; /* H.mm */
58 static const UChar testPattern[]={ 0x48, 0x48, 0x3a, 0x6d, 0x6d, 0 }; /* HH:mm */
59 static const UChar expectingSkeleton[]= { 0x48, 0x48, 0x6d, 0x6d, 0 }; /* HHmm */
60 static const UChar expectingBaseSkeleton[]= { 0x48, 0x6d, 0 }; /* HHmm */
61 static const UChar redundantPattern[]={ 0x79, 0x79, 0x4d, 0x4d, 0x4d, 0 }; /* yyMMM */
62 static const UChar testFormat[]= {0x7B, 0x31, 0x7D, 0x20, 0x7B, 0x30, 0x7D, 0}; /* {1} {0} */
63 static const UChar appendItemName[]= {0x68, 0x72, 0}; /* hr */
64 static const UChar testPattern2[]={ 0x48, 0x48, 0x3a, 0x6d, 0x6d, 0x20, 0x76, 0 }; /* HH:mm v */
65 static const UChar replacedStr[]={ 0x76, 0x76, 0x76, 0x76, 0 }; /* vvvv */
66 /* results for getBaseSkeletons() - {Hmv}, {yMMM} */
67 static const UChar resultBaseSkeletons[2][10] = {{0x48,0x6d, 0x76, 0}, {0x79, 0x4d, 0x4d, 0x4d, 0 } };
68 static const UChar sampleFormatted[] = {0x31, 0x30, 0x20, 0x6A, 0x75, 0x69, 0x6C, 0x2E, 0}; /* 10 juil. */
69 static const UChar skeleton[]= {0x4d, 0x4d, 0x4d, 0x64, 0}; /* MMMd */
70 static const UChar timeZoneGMT[] = { 0x0047, 0x004d, 0x0054, 0x0000 }; /* "GMT" */
71
TestOpenClose()72 static void TestOpenClose() {
73 UErrorCode errorCode=U_ZERO_ERROR;
74 UDateTimePatternGenerator *dtpg, *dtpg2;
75 const UChar *s;
76 int32_t length;
77
78 /* Open a DateTimePatternGenerator for the default locale. */
79 dtpg=udatpg_open(NULL, &errorCode);
80 if(U_FAILURE(errorCode)) {
81 log_err_status(errorCode, "udatpg_open(NULL) failed - %s\n", u_errorName(errorCode));
82 return;
83 }
84 udatpg_close(dtpg);
85
86 /* Now one for German. */
87 dtpg=udatpg_open("de", &errorCode);
88 if(U_FAILURE(errorCode)) {
89 log_err("udatpg_open(de) failed - %s\n", u_errorName(errorCode));
90 return;
91 }
92
93 /* Make some modification which we verify gets passed on to the clone. */
94 udatpg_setDecimal(dtpg, pipeString, 1);
95
96 /* Clone the generator. */
97 dtpg2=udatpg_clone(dtpg, &errorCode);
98 if(U_FAILURE(errorCode) || dtpg2==NULL) {
99 log_err("udatpg_clone() failed - %s\n", u_errorName(errorCode));
100 return;
101 }
102
103 /* Verify that the clone has the custom decimal symbol. */
104 s=udatpg_getDecimal(dtpg2, &length);
105 if(s==pipeString || length!=1 || 0!=u_memcmp(s, pipeString, length) || s[length]!=0) {
106 log_err("udatpg_getDecimal(cloned object) did not return the expected string\n");
107 return;
108 }
109
110 udatpg_close(dtpg);
111 udatpg_close(dtpg2);
112 }
113
114 typedef struct {
115 UDateTimePatternField field;
116 UChar name[12];
117 } AppendItemNameData;
118
119 static const AppendItemNameData appendItemNameData[] = { /* for Finnish */
120 { UDATPG_YEAR_FIELD, {0x0076,0x0075,0x006F,0x0073,0x0069,0} }, /* "vuosi" */
121 { UDATPG_MONTH_FIELD, {0x006B,0x0075,0x0075,0x006B,0x0061,0x0075,0x0073,0x0069,0} }, /* "kuukausi" */
122 { UDATPG_WEEKDAY_FIELD, {0x0076,0x0069,0x0069,0x006B,0x006F,0x006E,0x0070,0x00E4,0x0069,0x0076,0x00E4,0} },
123 { UDATPG_DAY_FIELD, {0x0070,0x00E4,0x0069,0x0076,0x00E4,0} },
124 { UDATPG_HOUR_FIELD, {0x0074,0x0075,0x006E,0x0074,0x0069,0} }, /* "tunti" */
125 { UDATPG_FIELD_COUNT, {0} } /* terminator */
126 };
127
TestUsage()128 static void TestUsage() {
129 UErrorCode errorCode=U_ZERO_ERROR;
130 UDateTimePatternGenerator *dtpg;
131 const AppendItemNameData * appItemNameDataPtr;
132 UChar bestPattern[20];
133 UChar result[20];
134 int32_t length;
135 UChar *s;
136 const UChar *r;
137
138 dtpg=udatpg_open("fi", &errorCode);
139 if(U_FAILURE(errorCode)) {
140 log_err_status(errorCode, "udatpg_open(fi) failed - %s\n", u_errorName(errorCode));
141 return;
142 }
143 length = udatpg_getBestPattern(dtpg, testSkeleton1, 4,
144 bestPattern, 20, &errorCode);
145 if(U_FAILURE(errorCode)) {
146 log_err("udatpg_getBestPattern failed - %s\n", u_errorName(errorCode));
147 return;
148 }
149 if((u_memcmp(bestPattern, expectingBestPattern, length)!=0) || bestPattern[length]!=0) {
150 log_err("udatpg_getBestPattern did not return the expected string\n");
151 return;
152 }
153
154
155 /* Test skeleton == NULL */
156 s=NULL;
157 length = udatpg_getBestPattern(dtpg, s, 0, bestPattern, 20, &errorCode);
158 if(!U_FAILURE(errorCode)&&(length!=0) ) {
159 log_err("udatpg_getBestPattern failed in illegal argument - skeleton is NULL.\n");
160 return;
161 }
162
163 /* Test udatpg_getSkeleton */
164 length = udatpg_getSkeleton(dtpg, testPattern, 5, result, 20, &errorCode);
165 if(U_FAILURE(errorCode)) {
166 log_err("udatpg_getSkeleton failed - %s\n", u_errorName(errorCode));
167 return;
168 }
169 if((u_memcmp(result, expectingSkeleton, length)!=0) || result[length]!=0) {
170 log_err("udatpg_getSkeleton did not return the expected string\n");
171 return;
172 }
173
174 /* Test pattern == NULL */
175 s=NULL;
176 length = udatpg_getSkeleton(dtpg, s, 0, result, 20, &errorCode);
177 if(!U_FAILURE(errorCode)&&(length!=0) ) {
178 log_err("udatpg_getSkeleton failed in illegal argument - pattern is NULL.\n");
179 return;
180 }
181
182 /* Test udatpg_getBaseSkeleton */
183 length = udatpg_getBaseSkeleton(dtpg, testPattern, 5, result, 20, &errorCode);
184 if(U_FAILURE(errorCode)) {
185 log_err("udatpg_getBaseSkeleton failed - %s\n", u_errorName(errorCode));
186 return;
187 }
188 if((u_memcmp(result, expectingBaseSkeleton, length)!=0) || result[length]!=0) {
189 log_err("udatpg_getBaseSkeleton did not return the expected string\n");
190 return;
191 }
192
193 /* Test pattern == NULL */
194 s=NULL;
195 length = udatpg_getBaseSkeleton(dtpg, s, 0, result, 20, &errorCode);
196 if(!U_FAILURE(errorCode)&&(length!=0) ) {
197 log_err("udatpg_getBaseSkeleton failed in illegal argument - pattern is NULL.\n");
198 return;
199 }
200
201 /* set append format to {1}{0} */
202 udatpg_setAppendItemFormat( dtpg, UDATPG_MONTH_FIELD, testFormat, 7 );
203 r = udatpg_getAppendItemFormat(dtpg, UDATPG_MONTH_FIELD, &length);
204
205
206 if(length!=7 || 0!=u_memcmp(r, testFormat, length) || r[length]!=0) {
207 log_err("udatpg_setAppendItemFormat did not return the expected string\n");
208 return;
209 }
210
211 for (appItemNameDataPtr = appendItemNameData; appItemNameDataPtr->field < UDATPG_FIELD_COUNT; appItemNameDataPtr++) {
212 int32_t nameLength;
213 const UChar * namePtr = udatpg_getAppendItemName(dtpg, appItemNameDataPtr->field, &nameLength);
214 if ( namePtr == NULL || u_strncmp(appItemNameDataPtr->name, namePtr, nameLength) != 0 ) {
215 log_err("udatpg_getAppendItemName returns invalid name for field %d\n", (int)appItemNameDataPtr->field);
216 }
217 }
218
219 /* set append name to hr */
220 udatpg_setAppendItemName(dtpg, UDATPG_HOUR_FIELD, appendItemName, 2);
221 r = udatpg_getAppendItemName(dtpg, UDATPG_HOUR_FIELD, &length);
222
223 if(length!=2 || 0!=u_memcmp(r, appendItemName, length) || r[length]!=0) {
224 log_err("udatpg_setAppendItemName did not return the expected string\n");
225 return;
226 }
227
228 /* set date time format to {1}{0} */
229 udatpg_setDateTimeFormat( dtpg, testFormat, 7 );
230 r = udatpg_getDateTimeFormat(dtpg, &length);
231
232 if(length!=7 || 0!=u_memcmp(r, testFormat, length) || r[length]!=0) {
233 log_err("udatpg_setDateTimeFormat did not return the expected string\n");
234 return;
235 }
236 udatpg_close(dtpg);
237 }
238
TestBuilder()239 static void TestBuilder() {
240 UErrorCode errorCode=U_ZERO_ERROR;
241 UDateTimePatternGenerator *dtpg;
242 UDateTimePatternConflict conflict;
243 UEnumeration *en;
244 UChar result[20];
245 int32_t length, pLength;
246 const UChar *s, *p;
247 const UChar* ptrResult[2];
248 int32_t count=0;
249 UDateTimePatternGenerator *generator;
250 int32_t formattedCapacity, resultLen,patternCapacity ;
251 UChar pattern[40], formatted[40];
252 UDateFormat *formatter;
253 UDate sampleDate = 837039928046.0;
254 static const char locale[]= "fr";
255 UErrorCode status=U_ZERO_ERROR;
256
257 /* test create an empty DateTimePatternGenerator */
258 dtpg=udatpg_openEmpty(&errorCode);
259 if(U_FAILURE(errorCode)) {
260 log_err("udatpg_openEmpty() failed - %s\n", u_errorName(errorCode));
261 return;
262 }
263
264 /* Add a pattern */
265 conflict = udatpg_addPattern(dtpg, redundantPattern, 5, FALSE, result, 20,
266 &length, &errorCode);
267 if(U_FAILURE(errorCode)) {
268 log_err("udatpg_addPattern() failed - %s\n", u_errorName(errorCode));
269 return;
270 }
271 /* Add a redundant pattern */
272 conflict = udatpg_addPattern(dtpg, redundantPattern, 5, FALSE, result, 20,
273 &length, &errorCode);
274 if(conflict == UDATPG_NO_CONFLICT) {
275 log_err("udatpg_addPattern() failed to find the duplicate pattern.\n");
276 return;
277 }
278 /* Test pattern == NULL */
279 s=NULL;
280 length = udatpg_addPattern(dtpg, s, 0, FALSE, result, 20,
281 &length, &errorCode);
282 if(!U_FAILURE(errorCode)&&(length!=0) ) {
283 log_err("udatpg_addPattern failed in illegal argument - pattern is NULL.\n");
284 return;
285 }
286
287 /* replace field type */
288 errorCode=U_ZERO_ERROR;
289 conflict = udatpg_addPattern(dtpg, testPattern2, 7, FALSE, result, 20,
290 &length, &errorCode);
291 if((conflict != UDATPG_NO_CONFLICT)||U_FAILURE(errorCode)) {
292 log_err("udatpg_addPattern() failed to add HH:mm v. - %s\n", u_errorName(errorCode));
293 return;
294 }
295 length = udatpg_replaceFieldTypes(dtpg, testPattern2, 7, replacedStr, 4,
296 result, 20, &errorCode);
297 if (U_FAILURE(errorCode) || (length==0) ) {
298 log_err("udatpg_replaceFieldTypes failed!\n");
299 return;
300 }
301
302 /* Get all skeletons and the crroespong pattern for each skeleton. */
303 ptrResult[0] = testPattern2;
304 ptrResult[1] = redundantPattern;
305 count=0;
306 en = udatpg_openSkeletons(dtpg, &errorCode);
307 if (U_FAILURE(errorCode) || (length==0) ) {
308 log_err("udatpg_openSkeletons failed!\n");
309 return;
310 }
311 while ( (s=uenum_unext(en, &length, &errorCode))!= NULL) {
312 p = udatpg_getPatternForSkeleton(dtpg, s, length, &pLength);
313 if (U_FAILURE(errorCode) || p==NULL || u_memcmp(p, ptrResult[count], pLength)!=0 ) {
314 log_err("udatpg_getPatternForSkeleton failed!\n");
315 return;
316 }
317 count++;
318 }
319 uenum_close(en);
320
321 /* Get all baseSkeletons */
322 en = udatpg_openBaseSkeletons(dtpg, &errorCode);
323 count=0;
324 while ( (s=uenum_unext(en, &length, &errorCode))!= NULL) {
325 p = udatpg_getPatternForSkeleton(dtpg, s, length, &pLength);
326 if (U_FAILURE(errorCode) || p==NULL || u_memcmp(p, resultBaseSkeletons[count], pLength)!=0 ) {
327 log_err("udatpg_getPatternForSkeleton failed!\n");
328 return;
329 }
330 count++;
331 }
332 if (U_FAILURE(errorCode) || (length==0) ) {
333 log_err("udatpg_openSkeletons failed!\n");
334 return;
335 }
336 uenum_close(en);
337
338 udatpg_close(dtpg);
339
340 /* sample code in Userguide */
341 patternCapacity = (int32_t)(sizeof(pattern)/sizeof((pattern)[0]));
342 status=U_ZERO_ERROR;
343 generator=udatpg_open(locale, &status);
344 if(U_FAILURE(status)) {
345 return;
346 }
347
348 /* get a pattern for an abbreviated month and day */
349 length = udatpg_getBestPattern(generator, skeleton, 4,
350 pattern, patternCapacity, &status);
351 formatter = udat_open(UDAT_PATTERN, UDAT_PATTERN, locale, timeZoneGMT, -1,
352 pattern, length, &status);
353 if (formatter==NULL) {
354 log_err("Failed to initialize the UDateFormat of the sample code in Userguide.\n");
355 udatpg_close(generator);
356 return;
357 }
358
359 /* use it to format (or parse) */
360 formattedCapacity = (int32_t)(sizeof(formatted)/sizeof((formatted)[0]));
361 resultLen=udat_format(formatter, ucal_getNow(), formatted, formattedCapacity,
362 NULL, &status);
363 /* for French, the result is "13 sept." */
364
365 /* cannot use the result from ucal_getNow() because the value change evreyday. */
366 resultLen=udat_format(formatter, sampleDate, formatted, formattedCapacity,
367 NULL, &status);
368 if ( u_memcmp(sampleFormatted, formatted, resultLen) != 0 ) {
369 log_err("Failed udat_format() of sample code in Userguide.\n");
370 }
371 udatpg_close(generator);
372 udat_close(formatter);
373 }
374
375 typedef struct DTPtnGenOptionsData {
376 const char * locale;
377 const UChar * skel;
378 UDateTimePatternMatchOptions options;
379 const UChar * expectedPattern;
380 } DTPtnGenOptionsData;
381 enum { kTestOptionsPatLenMax = 32 };
382
383 static const UChar skel_Hmm[] = { 0x0048, 0x006D, 0x006D, 0 };
384 static const UChar skel_HHmm[] = { 0x0048, 0x0048, 0x006D, 0x006D, 0 };
385 static const UChar skel_hhmm[] = { 0x0068, 0x0068, 0x006D, 0x006D, 0 };
386 static const UChar patn_hcmm_a[] = { 0x0068, 0x003A, 0x006D, 0x006D, 0x0020, 0x0061, 0 }; /* h:mm a */
387 static const UChar patn_HHcmm[] = { 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0 }; /* HH:mm */
388 static const UChar patn_hhcmm_a[] = { 0x0068, 0x0068, 0x003A, 0x006D, 0x006D, 0x0020, 0x0061, 0 }; /* hh:mm a */
389 static const UChar patn_HHpmm[] = { 0x0048, 0x0048, 0x002E, 0x006D, 0x006D, 0 }; /* HH.mm */
390 static const UChar patn_hpmm_a[] = { 0x0068, 0x002E, 0x006D, 0x006D, 0x0020, 0x0061, 0 }; /* h.mm a */
391 static const UChar patn_Hpmm[] = { 0x0048, 0x002E, 0x006D, 0x006D, 0 }; /* H.mm */
392 static const UChar patn_hhpmm_a[] = { 0x0068, 0x0068, 0x002E, 0x006D, 0x006D, 0x0020, 0x0061, 0 }; /* hh.mm a */
393
TestOptions()394 static void TestOptions() {
395 const DTPtnGenOptionsData testData[] = {
396 /*loc skel options expectedPattern */
397 { "en", skel_Hmm, UDATPG_MATCH_NO_OPTIONS, patn_HHcmm },
398 { "en", skel_HHmm, UDATPG_MATCH_NO_OPTIONS, patn_HHcmm },
399 { "en", skel_hhmm, UDATPG_MATCH_NO_OPTIONS, patn_hcmm_a },
400 { "en", skel_Hmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHcmm },
401 { "en", skel_HHmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHcmm },
402 { "en", skel_hhmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_hhcmm_a },
403 { "da", skel_Hmm, UDATPG_MATCH_NO_OPTIONS, patn_HHpmm },
404 { "da", skel_HHmm, UDATPG_MATCH_NO_OPTIONS, patn_HHpmm },
405 { "da", skel_hhmm, UDATPG_MATCH_NO_OPTIONS, patn_hpmm_a },
406 { "da", skel_Hmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_Hpmm },
407 { "da", skel_HHmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHpmm },
408 { "da", skel_hhmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_hhpmm_a },
409 };
410
411 int count = sizeof(testData) / sizeof(testData[0]);
412 const DTPtnGenOptionsData * testDataPtr = testData;
413
414 for (; count-- > 0; ++testDataPtr) {
415 UErrorCode status = U_ZERO_ERROR;
416 UDateTimePatternGenerator * dtpgen = udatpg_open(testDataPtr->locale, &status);
417 if ( U_SUCCESS(status) ) {
418 UChar pattern[kTestOptionsPatLenMax];
419 int32_t patLen = udatpg_getBestPatternWithOptions(dtpgen, testDataPtr->skel, -1,
420 testDataPtr->options, pattern,
421 kTestOptionsPatLenMax, &status);
422 if ( U_FAILURE(status) || u_strncmp(pattern, testDataPtr->expectedPattern, patLen+1) != 0 ) {
423 char skelBytes[kTestOptionsPatLenMax];
424 char expectedPatternBytes[kTestOptionsPatLenMax];
425 char patternBytes[kTestOptionsPatLenMax];
426 log_err("ERROR udatpg_getBestPatternWithOptions, locale %s, skeleton %s, options 0x%04X, expected pattern %s, got %s, status %d\n",
427 testDataPtr->locale, u_austrncpy(skelBytes,testDataPtr->skel,kTestOptionsPatLenMax), testDataPtr->options,
428 u_austrncpy(expectedPatternBytes,testDataPtr->expectedPattern,kTestOptionsPatLenMax),
429 u_austrncpy(patternBytes,pattern,kTestOptionsPatLenMax), status );
430 }
431 udatpg_close(dtpgen);
432 } else {
433 log_data_err("ERROR udatpg_open failed for locale %s : %s - (Are you missing data?)\n", testDataPtr->locale, myErrorName(status));
434 }
435 }
436 }
437
438 #endif
439