icuSources/test/cintltst/udatpg_test.c

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