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 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 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 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 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 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
