| OLD | NEW |
|---|
| (Empty) |
| 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 }; /* yy
MMM */ | |
| 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, 0x
4d, 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[len
gth]!=0) { | |
| 106 log_err("udatpg_getDecimal(cloned object) did not return the expected st
ring\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,0x
0069,0} }, /* "kuukausi" */ | |
| 122 { UDATPG_WEEKDAY_FIELD, {0x0076,0x0069,0x0069,0x006B,0x006F,0x006E,0x0070,0x
00E4,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(e
rrorCode)); | |
| 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[l
ength]!=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, &errorCod
e); | |
| 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 < U
DATPG_FIELD_COUNT; appItemNameDataPtr++) { | |
| 212 int32_t nameLength; | |
| 213 const UChar * namePtr = udatpg_getAppendItemName(dtpg, appItemNameDataPt
r->field, &nameLength); | |
| 214 if ( namePtr == NULL || u_strncmp(appItemNameDataPtr->name, namePtr, nam
eLength) != 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], pLe
ngth)!=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[c
ount], 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 User
guide.\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 evreyda
y. */ | |
| 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, 0x
0061, 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, 0x
0020, 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, 0x
0061, 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, 0x
0020, 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, &s
tatus); | |
| 417 if ( U_SUCCESS(status) ) { | |
| 418 UChar pattern[kTestOptionsPatLenMax]; | |
| 419 int32_t patLen = udatpg_getBestPatternWithOptions(dtpgen, testDataPt
r->skel, -1, | |
| 420 testDataPtr->optio
ns, pattern, | |
| 421 kTestOptionsPatLen
Max, &status); | |
| 422 if ( U_FAILURE(status) || u_strncmp(pattern, testDataPtr->expectedPa
ttern, patLen+1) != 0 ) { | |
| 423 char skelBytes[kTestOptionsPatLenMax]; | |
| 424 char expectedPatternBytes[kTestOptionsPatLenMax]; | |
| 425 char patternBytes[kTestOptionsPatLenMax]; | |
| 426 log_err("ERROR udatpg_getBestPatternWithOptions, locale %s, skel
eton %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->expectedPa
ttern,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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
