source/test/cintltst/cdattst.c

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2016, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8 /********************************************************************************
   9 *
  10 * File CDATTST.C
  11 *
  12 * Modification History:
  13 *        Name                     Description
  14 *     Madhu Katragadda               Creation
  15 *********************************************************************************
  16 */
  17
  18 /* C API TEST FOR DATE FORMAT */
  19
  20 #include "unicode/utypes.h"
  21
  22 #if !UCONFIG_NO_FORMATTING
  23
  24 #include "unicode/uloc.h"
  25 #include "unicode/udat.h"
  26 #include "unicode/udatpg.h"
  27 #include "unicode/ucal.h"
  28 #include "unicode/unum.h"
  29 #include "unicode/ustring.h"
  30 #include "unicode/ufieldpositer.h"
  31 #include "cintltst.h"
  32 #include "cdattst.h"
  33 #include "cformtst.h"
  34 #include "cmemory.h"
  35
  36 #include <math.h>
  37
  38 static void TestExtremeDates(void);
  39 static void TestAllLocales(void);
  40 static void TestRelativeCrash(void);
  41 static void TestContext(void);
  42 static void TestCalendarDateParse(void);
  43 static void TestParseErrorReturnValue(void);
  44 static void TestFormatForFields(void);
  45
  46 void addDateForTest(TestNode** root);
  47
  48 #define TESTCASE(x) addTest(root, &x, "tsformat/cdattst/" #x)
  49
  50 void addDateForTest(TestNode** root)
  51 {
  52     TESTCASE(TestDateFormat);
  53     TESTCASE(TestRelativeDateFormat);
  54     TESTCASE(TestSymbols);
  55     TESTCASE(TestDateFormatCalendar);
  56     TESTCASE(TestExtremeDates);
  57     TESTCASE(TestAllLocales);
  58     TESTCASE(TestRelativeCrash);
  59     TESTCASE(TestContext);
  60     TESTCASE(TestCalendarDateParse);
  61     TESTCASE(TestOverrideNumberFormat);
  62     TESTCASE(TestParseErrorReturnValue);
  63     TESTCASE(TestFormatForFields);
  64 }
  65 /* Testing the DateFormat API */
  66 static void TestDateFormat()
  67 {
  68     UDateFormat *def, *fr, *it, *de, *def1, *fr_pat;
  69     UDateFormat *any;
  70     UDateFormat *copy;
  71     UErrorCode status = U_ZERO_ERROR;
  72     UChar* result = NULL;
  73     const UCalendar *cal;
  74     const UNumberFormat *numformat1, *numformat2;
  75     UNumberFormat *adoptNF;
  76     UChar temp[50];
  77     int32_t numlocales;
  78     UDate d1;
  79     int i;
  80     int32_t resultlength;
  81     int32_t resultlengthneeded;
  82     int32_t parsepos;
  83     UDate d = 837039928046.0;
  84     double num = -10456.37;
  85     /*const char* str="yyyy.MM.dd G 'at' hh:mm:ss z";
  86     const char t[]="2/3/76 2:50 AM";*/
  87     /*Testing udat_open() to open a dateformat */
  88
  89     ctest_setTimeZone(NULL, &status);
  90
  91     log_verbose("\nTesting udat_open() with various parameters\n");
  92     fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL,0, NULL, 0,&status);
  93     if(U_FAILURE(status))
  94     {
  95         log_data_err("FAIL: error in creating the dateformat using full time style with french locale -> %s (Are you missing data?)\n",
  96             myErrorName(status) );
  97         return;
  98     }
  99     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
 100        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
 101     /* def = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status); */
 102     def = udat_open(UDAT_SHORT, UDAT_SHORT, "en_US", NULL, 0,NULL, 0, &status);
 103     if(U_FAILURE(status))
 104     {
 105         log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
 106             myErrorName(status) );
 107         return;
 108     }
 109     it = udat_open(UDAT_DEFAULT, UDAT_MEDIUM, "it_IT", NULL, 0, NULL, 0,&status);
 110     if(U_FAILURE(status))
 111     {
 112         log_err("FAIL: error in creating the dateformat using medium date style with italian locale\n %s\n",
 113             myErrorName(status) );
 114         return;
 115     }
 116     de = udat_open(UDAT_LONG, UDAT_LONG, "de_DE", NULL, 0, NULL, 0,&status);
 117     if(U_FAILURE(status))
 118     {
 119         log_err("FAIL: error in creating the dateformat using long time and date styles with german locale\n %s\n",
 120             myErrorName(status));
 121         return;
 122     }
 123     /*creating a default dateformat */
 124     def1 = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0,NULL, 0, &status);
 125     if(U_FAILURE(status))
 126     {
 127         log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
 128             myErrorName(status) );
 129         return;
 130     }
 131
 132
 133     /*Testing udat_getAvailable() and udat_countAvailable()*/
 134     log_verbose("\nTesting getAvailableLocales and countAvailable()\n");
 135     numlocales=udat_countAvailable();
 136     /* use something sensible w/o hardcoding the count */
 137     if(numlocales < 0)
 138         log_data_err("FAIL: error in countAvailable\n");
 139     log_verbose("The number of locales for which date/time formatting patterns are available is %d\n", numlocales);
 140
 141     for(i=0;i<numlocales;i++) {
 142       UErrorCode subStatus = U_ZERO_ERROR;
 143       log_verbose("Testing open of %s\n", udat_getAvailable(i));
 144       any = udat_open(UDAT_SHORT, UDAT_SHORT, udat_getAvailable(i), NULL ,0, NULL, 0, &subStatus);
 145       if(U_FAILURE(subStatus)) {
 146         log_data_err("FAIL: date format %s (getAvailable(%d)) is not instantiable: %s\n", udat_getAvailable(i), i, u_errorName(subStatus));
 147       }
 148       udat_close(any);
 149     }
 150
 151     /*Testing udat_clone()*/
 152     log_verbose("\nTesting the udat_clone() function of date format\n");
 153     copy=udat_clone(def, &status);
 154     if(U_FAILURE(status)){
 155         log_err("Error in creating the clone using udat_clone: %s\n", myErrorName(status) );
 156     }
 157     /*if(def != copy)
 158         log_err("Error in udat_clone");*/ /*how should i check for equality???? */
 159
 160     /*Testing udat_format()*/
 161     log_verbose("\nTesting the udat_format() function of date format\n");
 162     u_uastrcpy(temp, "7/10/96, 4:05 PM");
 163     /*format using def */
 164     resultlength=0;
 165     resultlengthneeded=udat_format(def, d, NULL, resultlength, NULL, &status);
 166     if(status==U_BUFFER_OVERFLOW_ERROR)
 167     {
 168         status=U_ZERO_ERROR;
 169         resultlength=resultlengthneeded+1;
 170         if(result != NULL) {
 171             free(result);
 172             result = NULL;
 173         }
 174         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 175         udat_format(def, d, result, resultlength, NULL, &status);
 176     }
 177     if(U_FAILURE(status) || !result)
 178     {
 179         log_err("FAIL: Error in formatting using udat_format(.....) %s\n", myErrorName(status) );
 180         return;
 181     }
 182     else
 183         log_verbose("PASS: formatting successful\n");
 184     if(u_strcmp(result, temp)==0)
 185         log_verbose("PASS: Date Format for US locale successful using udat_format()\n");
 186     else {
 187         char xbuf[2048];
 188         char gbuf[2048];
 189         u_austrcpy(xbuf, temp);
 190         u_austrcpy(gbuf, result);
 191         log_err("FAIL: Date Format for US locale failed using udat_format() - expected %s got %s\n", xbuf, gbuf);
 192     }
 193     /*format using fr */
 194
 195     u_unescape("10 juil. 1996 \\u00E0 16:05:28 heure d\\u2019\\u00E9t\\u00E9 du Pacifique", temp, 50);
 196     if(result != NULL) {
 197         free(result);
 198         result = NULL;
 199     }
 200     result=myDateFormat(fr, d);
 201     if(u_strcmp(result, temp)==0)
 202         log_verbose("PASS: Date Format for french locale successful using udat_format()\n");
 203     else
 204         log_data_err("FAIL: Date Format for french locale failed using udat_format().\n" );
 205
 206     /*format using it */
 207     u_uastrcpy(temp, "10 lug 1996, 16:05:28");
 208
 209     {
 210         UChar *fmtted;
 211         char g[100];
 212         char x[100];
 213
 214         fmtted = myDateFormat(it,d);
 215         u_austrcpy(g, fmtted);
 216         u_austrcpy(x, temp);
 217         if(u_strcmp(fmtted, temp)==0) {
 218             log_verbose("PASS: Date Format for italian locale successful uisng udat_format() - wanted %s, got %s\n", x, g);
 219         } else {
 220             log_data_err("FAIL: Date Format for italian locale failed using udat_format() - wanted %s, got %s\n", x, g);
 221         }
 222     }
 223
 224     /*Testing parsing using udat_parse()*/
 225     log_verbose("\nTesting parsing using udat_parse()\n");
 226     u_uastrcpy(temp,"2/3/76, 2:50 AM");
 227     parsepos=0;
 228     status=U_ZERO_ERROR;
 229
 230     d1=udat_parse(def, temp, u_strlen(temp), &parsepos, &status);
 231     if(U_FAILURE(status))
 232     {
 233         log_err("FAIL: Error in parsing using udat_parse(.....) %s\n", myErrorName(status) );
 234     }
 235     else
 236         log_verbose("PASS: parsing succesful\n");
 237     /*format it back and check for equality */
 238
 239
 240     if(u_strcmp(myDateFormat(def, d1),temp)!=0)
 241         log_err("FAIL: error in parsing\n");
 242
 243     /*Testing parsing using udat_parse()*/
 244     log_verbose("\nTesting parsing using udat_parse()\n");
 245     u_uastrcpy(temp,"2/Don't parse this part");
 246     status=U_ZERO_ERROR;
 247
 248     d1=udat_parse(def, temp, u_strlen(temp), NULL, &status);
 249     if(status != U_PARSE_ERROR)
 250     {
 251         log_err("FAIL: udat_parse(\"bad string\") passed when it should have failed\n");
 252     }
 253     else
 254         log_verbose("PASS: parsing succesful\n");
 255
 256
 257
 258     /*Testing udat_openPattern()  */
 259     status=U_ZERO_ERROR;
 260     log_verbose("\nTesting the udat_openPattern with a specified pattern\n");
 261     /*for french locale */
 262     fr_pat=udat_open(UDAT_PATTERN, UDAT_PATTERN,"fr_FR",NULL,0,temp, u_strlen(temp), &status);
 263     if(U_FAILURE(status))
 264     {
 265         log_err("FAIL: Error in creating a date format using udat_openPattern \n %s\n",
 266             myErrorName(status) );
 267     }
 268     else
 269         log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
 270
 271
 272         /*Testing applyPattern and toPattern */
 273     log_verbose("\nTesting applyPattern and toPattern()\n");
 274     udat_applyPattern(def1, FALSE, temp, u_strlen(temp));
 275     log_verbose("Extracting the pattern\n");
 276
 277     resultlength=0;
 278     resultlengthneeded=udat_toPattern(def1, FALSE, NULL, resultlength, &status);
 279     if(status==U_BUFFER_OVERFLOW_ERROR)
 280     {
 281         status=U_ZERO_ERROR;
 282         resultlength=resultlengthneeded + 1;
 283         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 284         udat_toPattern(def1, FALSE, result, resultlength, &status);
 285     }
 286     if(U_FAILURE(status))
 287     {
 288         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
 289             myErrorName(status) );
 290     }
 291     if(u_strcmp(result, temp)!=0)
 292         log_err("FAIL: Error in extracting the pattern\n");
 293     else
 294         log_verbose("PASS: applyPattern and toPattern work fine\n");
 295
 296     if(result != NULL) {
 297         free(result);
 298         result = NULL;
 299     }
 300
 301
 302     /*Testing getter and setter functions*/
 303     /*isLenient and setLenient()*/
 304     log_verbose("\nTesting the isLenient and setLenient properties\n");
 305     udat_setLenient(fr, udat_isLenient(it));
 306     if(udat_isLenient(fr) != udat_isLenient(it))
 307         log_err("ERROR: setLenient() failed\n");
 308     else
 309         log_verbose("PASS: setLenient() successful\n");
 310
 311
 312     /*Test get2DigitYearStart set2DigitYearStart */
 313     log_verbose("\nTesting the get and set 2DigitYearStart properties\n");
 314     d1= udat_get2DigitYearStart(fr_pat,&status);
 315     if(U_FAILURE(status)) {
 316             log_err("ERROR: udat_get2DigitYearStart failed %s\n", myErrorName(status) );
 317     }
 318     status = U_ZERO_ERROR;
 319     udat_set2DigitYearStart(def1 ,d1, &status);
 320     if(U_FAILURE(status)) {
 321         log_err("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
 322     }
 323     if(udat_get2DigitYearStart(fr_pat, &status) != udat_get2DigitYearStart(def1, &status))
 324         log_err("FAIL: error in set2DigitYearStart\n");
 325     else
 326         log_verbose("PASS: set2DigitYearStart successful\n");
 327     /*try setting it to another value */
 328     udat_set2DigitYearStart(de, 2000.0, &status);
 329     if(U_FAILURE(status)){
 330         log_verbose("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
 331     }
 332     if(udat_get2DigitYearStart(de, &status) != 2000)
 333         log_err("FAIL: error in set2DigitYearStart\n");
 334     else
 335         log_verbose("PASS: set2DigitYearStart successful\n");
 336
 337
 338
 339     /*Test getNumberFormat() and setNumberFormat() */
 340     log_verbose("\nTesting the get and set NumberFormat properties of date format\n");
 341     numformat1=udat_getNumberFormat(fr_pat);
 342     udat_setNumberFormat(def1, numformat1);
 343     numformat2=udat_getNumberFormat(def1);
 344     if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
 345         log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
 346     else
 347         log_verbose("PASS:setNumberFormat and getNumberFormat succesful\n");
 348
 349     /*Test getNumberFormat() and adoptNumberFormat() */
 350     log_verbose("\nTesting the get and adopt NumberFormat properties of date format\n");
 351     adoptNF= unum_open(UNUM_DEFAULT, NULL, 0, NULL, NULL, &status);
 352     udat_adoptNumberFormat(def1, adoptNF);
 353     numformat2=udat_getNumberFormat(def1);
 354     if(u_strcmp(myNumformat(adoptNF, num), myNumformat(numformat2, num)) !=0)
 355         log_err("FAIL: error in adoptNumberFormat or getNumberFormat()\n");
 356     else
 357         log_verbose("PASS:adoptNumberFormat and getNumberFormat succesful\n");
 358
 359     /*try setting the number format to another format */
 360     numformat1=udat_getNumberFormat(def);
 361     udat_setNumberFormat(def1, numformat1);
 362     numformat2=udat_getNumberFormat(def1);
 363     if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
 364         log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
 365     else
 366         log_verbose("PASS: setNumberFormat and getNumberFormat succesful\n");
 367
 368
 369
 370     /*Test getCalendar and setCalendar*/
 371     log_verbose("\nTesting the udat_getCalendar() and udat_setCalendar() properties\n");
 372     cal=udat_getCalendar(fr_pat);
 373
 374
 375     udat_setCalendar(def1, cal);
 376     if(!ucal_equivalentTo(udat_getCalendar(fr_pat), udat_getCalendar(def1)))
 377         log_err("FAIL: Error in setting and getting the calendar\n");
 378     else
 379         log_verbose("PASS: getting and setting calendar successful\n");
 380
 381     if(result!=NULL) {
 382         free(result);
 383     }
 384
 385     /*Closing the UDateForamt */
 386     udat_close(def);
 387     udat_close(fr);
 388     udat_close(it);
 389     udat_close(de);
 390     udat_close(def1);
 391     udat_close(fr_pat);
 392     udat_close(copy);
 393
 394     ctest_resetTimeZone();
 395 }
 396
 397 /*
 398 Test combined relative date formatting (relative date + non-relative time).
 399 This is a bit tricky since we can't have static test data for comparison, the
 400 relative date formatting is relative to the time the tests are run. We generate
 401 the data for comparison dynamically. However, the tests could fail if they are
 402 run right at midnight Pacific time and the call to ucal_getNow() is before midnight
 403 while the calls to udat_format are after midnight or span midnight.
 404 */
 405 static const UDate dayInterval = 24.0*60.0*60.0*1000.0;
 406 static const UChar trdfZone[] = { 0x0055, 0x0053, 0x002F, 0x0050, 0x0061, 0x0063, 0x0069, 0x0066, 0x0069, 0x0063, 0 }; /* US/Pacific */
 407 static const char trdfLocale[] = "en_US";
 408 static const UChar minutesPatn[] = { 0x006D, 0x006D, 0 }; /* "mm" */
 409 static const UChar monthLongPatn[] = { 0x004D, 0x004D, 0x004D, 0x004D, 0 }; /* "MMMM" */
 410 static const UChar monthMediumPatn[] = { 0x004D, 0x004D, 0x004D, 0 }; /* "MMM" */
 411 static const UChar monthShortPatn[] = { 0x004D, 0 }; /* "M" */
 412 static const UDateFormatStyle dateStylesList[] = { UDAT_FULL, UDAT_LONG, UDAT_MEDIUM, UDAT_SHORT, UDAT_NONE };
 413 static const UChar *monthPatnsList[] = { monthLongPatn, monthLongPatn, monthMediumPatn, monthShortPatn, NULL };
 414 static const UChar newTimePatn[] = { 0x0048, 0x0048, 0x002C, 0x006D, 0x006D, 0 }; /* "HH,mm" */
 415 static const UChar minutesStr[] = { 0x0034, 0x0039, 0 }; /* "49", minutes string to search for in output */
 416 enum { kDateOrTimeOutMax = 96, kDateAndTimeOutMax = 192 };
 417
 418 static const UDate minutesTolerance = 2 * 60.0 * 1000.0;
 419 static const UDate daysTolerance = 2 * 24.0 * 60.0 * 60.0 * 1000.0;
 420
 421 static void TestRelativeDateFormat()
 422 {
 423     UDate today = 0.0;
 424     const UDateFormatStyle * stylePtr;
 425     const UChar ** monthPtnPtr;
 426     UErrorCode status = U_ZERO_ERROR;
 427     UCalendar * ucal = ucal_open(trdfZone, -1, trdfLocale, UCAL_GREGORIAN, &status);
 428     if ( U_SUCCESS(status) ) {
 429         int32_t    year, month, day;
 430         ucal_setMillis(ucal, ucal_getNow(), &status);
 431         year = ucal_get(ucal, UCAL_YEAR, &status);
 432         month = ucal_get(ucal, UCAL_MONTH, &status);
 433         day = ucal_get(ucal, UCAL_DATE, &status);
 434         ucal_setDateTime(ucal, year, month, day, 18, 49, 0, &status); /* set to today at 18:49:00 */
 435         today = ucal_getMillis(ucal, &status);
 436         ucal_close(ucal);
 437     }
 438     if ( U_FAILURE(status) || today == 0.0 ) {
 439         log_data_err("Generate UDate for a specified time today fails, error %s - (Are you missing data?)\n", myErrorName(status) );
 440         return;
 441     }
 442     for (stylePtr = dateStylesList, monthPtnPtr = monthPatnsList; *stylePtr != UDAT_NONE; ++stylePtr, ++monthPtnPtr) {
 443         UDateFormat* fmtRelDateTime;
 444         UDateFormat* fmtRelDate;
 445         UDateFormat* fmtTime;
 446         int32_t dayOffset, limit;
 447         UFieldPosition fp;
 448         UChar   strDateTime[kDateAndTimeOutMax];
 449         UChar   strDate[kDateOrTimeOutMax];
 450         UChar   strTime[kDateOrTimeOutMax];
 451         UChar * strPtr;
 452         int32_t dtpatLen;
 453
 454         fmtRelDateTime = udat_open(UDAT_SHORT, *stylePtr | UDAT_RELATIVE, trdfLocale, trdfZone, -1, NULL, 0, &status);
 455         if ( U_FAILURE(status) ) {
 456             log_data_err("udat_open timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s (Are you missing data?)\n", *stylePtr, myErrorName(status) );
 457             continue;
 458         }
 459         fmtRelDate = udat_open(UDAT_NONE, *stylePtr | UDAT_RELATIVE, trdfLocale, trdfZone, -1, NULL, 0, &status);
 460         if ( U_FAILURE(status) ) {
 461             log_err("udat_open timeStyle NONE dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 462             udat_close(fmtRelDateTime);
 463             continue;
 464         }
 465         fmtTime = udat_open(UDAT_SHORT, UDAT_NONE, trdfLocale, trdfZone, -1, NULL, 0, &status);
 466         if ( U_FAILURE(status) ) {
 467             log_err("udat_open timeStyle SHORT dateStyle NONE fails, error %s\n", myErrorName(status) );
 468             udat_close(fmtRelDateTime);
 469             udat_close(fmtRelDate);
 470             continue;
 471         }
 472
 473         dtpatLen = udat_toPatternRelativeDate(fmtRelDateTime, strDate, kDateAndTimeOutMax, &status);
 474         if ( U_FAILURE(status) ) {
 475             log_err("udat_toPatternRelativeDate timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 476             status = U_ZERO_ERROR;
 477         } else if ( u_strstr(strDate, *monthPtnPtr) == NULL || dtpatLen != u_strlen(strDate) ) {
 478             log_err("udat_toPatternRelativeDate timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) date pattern incorrect\n", *stylePtr );
 479         }
 480         dtpatLen = udat_toPatternRelativeTime(fmtRelDateTime, strTime, kDateAndTimeOutMax, &status);
 481         if ( U_FAILURE(status) ) {
 482             log_err("udat_toPatternRelativeTime timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 483             status = U_ZERO_ERROR;
 484         } else if ( u_strstr(strTime, minutesPatn) == NULL || dtpatLen != u_strlen(strTime) ) {
 485             log_err("udat_toPatternRelativeTime timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) time pattern incorrect\n", *stylePtr );
 486         }
 487         dtpatLen = udat_toPattern(fmtRelDateTime, FALSE, strDateTime, kDateAndTimeOutMax, &status);
 488         if ( U_FAILURE(status) ) {
 489             log_err("udat_toPattern timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 490             status = U_ZERO_ERROR;
 491         } else if ( u_strstr(strDateTime, strDate) == NULL || u_strstr(strDateTime, strTime) == NULL || dtpatLen != u_strlen(strDateTime) ) {
 492             log_err("udat_toPattern timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) dateTime pattern incorrect\n", *stylePtr );
 493         }
 494         udat_applyPatternRelative(fmtRelDateTime, strDate, u_strlen(strDate), newTimePatn, u_strlen(newTimePatn), &status);
 495         if ( U_FAILURE(status) ) {
 496             log_err("udat_applyPatternRelative timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 497             status = U_ZERO_ERROR;
 498         } else {
 499             udat_toPattern(fmtRelDateTime, FALSE, strDateTime, kDateAndTimeOutMax, &status);
 500             if ( U_FAILURE(status) ) {
 501                 log_err("udat_toPattern timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 502                 status = U_ZERO_ERROR;
 503             } else if ( u_strstr(strDateTime, newTimePatn) == NULL ) {
 504                 log_err("udat_applyPatternRelative timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) didn't update time pattern\n", *stylePtr );
 505             }
 506         }
 507         udat_applyPatternRelative(fmtRelDateTime, strDate, u_strlen(strDate), strTime, u_strlen(strTime), &status); /* restore original */
 508
 509         fp.field = UDAT_MINUTE_FIELD;
 510         for (dayOffset = -2, limit = 2; dayOffset <= limit; ++dayOffset) {
 511             UDate   dateToUse = today + (float)dayOffset*dayInterval;
 512
 513             udat_format(fmtRelDateTime, dateToUse, strDateTime, kDateAndTimeOutMax, &fp, &status);
 514             if ( U_FAILURE(status) ) {
 515                 log_err("udat_format timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 516                 status = U_ZERO_ERROR;
 517             } else {
 518                 int32_t parsePos = 0;
 519                 UDate dateResult = udat_parse(fmtRelDateTime, strDateTime, -1, &parsePos, &status);
 520                 UDate dateDiff =  (dateResult >= dateToUse)? dateResult - dateToUse: dateToUse - dateResult;
 521                 if ( U_FAILURE(status) || dateDiff > minutesTolerance ) {
 522                     log_err("udat_parse timeStyle SHORT dateStyle (%d | UDAT_RELATIVE) fails, error %s, expect approx %.1f, got %.1f, parsePos %d\n",
 523                             *stylePtr, myErrorName(status), dateToUse, dateResult, parsePos );
 524                     status = U_ZERO_ERROR;
 525                 }
 526
 527                 udat_format(fmtRelDate, dateToUse, strDate, kDateOrTimeOutMax, NULL, &status);
 528                 if ( U_FAILURE(status) ) {
 529                     log_err("udat_format timeStyle NONE dateStyle (%d | UDAT_RELATIVE) fails, error %s\n", *stylePtr, myErrorName(status) );
 530                     status = U_ZERO_ERROR;
 531                 } else if ( u_strstr(strDateTime, strDate) == NULL ) {
 532                     log_err("relative date string not found in udat_format timeStyle SHORT dateStyle (%d | UDAT_RELATIVE)\n", *stylePtr );
 533                 } else {
 534                     parsePos = 0;
 535                     dateResult = udat_parse(fmtRelDate, strDate, -1, &parsePos, &status);
 536                     dateDiff =  (dateResult >= dateToUse)? dateResult - dateToUse: dateToUse - dateResult;
 537                     if ( U_FAILURE(status) || dateDiff > daysTolerance ) {
 538                         log_err("udat_parse timeStyle NONE dateStyle (%d | UDAT_RELATIVE) fails, error %s, expect approx %.1f, got %.1f, parsePos %d\n",
 539                                 *stylePtr, myErrorName(status), dateToUse, dateResult, parsePos );
 540                         status = U_ZERO_ERROR;
 541                     }
 542                 }
 543
 544                 udat_format(fmtTime, dateToUse, strTime, kDateOrTimeOutMax, NULL, &status);
 545                 if ( U_FAILURE(status) ) {
 546                     log_err("udat_format timeStyle SHORT dateStyle NONE fails, error %s\n", myErrorName(status) );
 547                     status = U_ZERO_ERROR;
 548                 } else if ( u_strstr(strDateTime, strTime) == NULL ) {
 549                     log_err("time string not found in udat_format timeStyle SHORT dateStyle (%d | UDAT_RELATIVE)\n", *stylePtr );
 550                 }
 551
 552                 strPtr = u_strstr(strDateTime, minutesStr);
 553                 if ( strPtr != NULL ) {
 554                     int32_t beginIndex = strPtr - strDateTime;
 555                     if ( fp.beginIndex != beginIndex ) {
 556                         log_err("UFieldPosition beginIndex %d, expected %d, in udat_format timeStyle SHORT dateStyle (%d | UDAT_RELATIVE)\n", fp.beginIndex, beginIndex, *stylePtr );
 557                     }
 558                 } else {
 559                     log_err("minutes string not found in udat_format timeStyle SHORT dateStyle (%d | UDAT_RELATIVE)\n", *stylePtr );
 560                 }
 561             }
 562         }
 563
 564         udat_close(fmtRelDateTime);
 565         udat_close(fmtRelDate);
 566         udat_close(fmtTime);
 567      }
 568 }
 569
 570 /*Testing udat_getSymbols() and udat_setSymbols() and udat_countSymbols()*/
 571 static void TestSymbols()
 572 {
 573     UDateFormat *def, *fr, *zhChiCal;
 574     UErrorCode status = U_ZERO_ERROR;
 575     UChar *value=NULL;
 576     UChar *result = NULL;
 577     int32_t resultlength;
 578     int32_t resultlengthout;
 579     UChar *pattern;
 580
 581
 582     /*creating a dateformat with french locale */
 583     log_verbose("\ncreating a date format with french locale\n");
 584     fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL, 0, NULL, 0, &status);
 585     if(U_FAILURE(status))
 586     {
 587         log_data_err("error in creating the dateformat using full time style with french locale -> %s (Are you missing data?)\n",
 588             myErrorName(status) );
 589         return;
 590     }
 591     /*creating a default dateformat */
 592     log_verbose("\ncreating a date format with default locale\n");
 593     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
 594        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
 595     /* def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, &status); */
 596     def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status);
 597     if(U_FAILURE(status))
 598     {
 599         log_err("error in creating the dateformat using short date and time style\n %s\n",
 600             myErrorName(status) );
 601         return;
 602     }
 603     /*creating a dateformat with zh locale */
 604     log_verbose("\ncreating a date format with zh locale for chinese calendar\n");
 605     zhChiCal = udat_open(UDAT_NONE, UDAT_FULL, "zh@calendar=chinese", NULL, 0, NULL, 0, &status);
 606     if(U_FAILURE(status))
 607     {
 608         log_data_err("error in creating the dateformat using full date, no time, locale zh@calendar=chinese -> %s (Are you missing data?)\n",
 609             myErrorName(status) );
 610         return;
 611     }
 612
 613
 614     /*Testing countSymbols, getSymbols and setSymbols*/
 615     log_verbose("\nTesting countSymbols\n");
 616     /*since the month names has the last string empty and week names are 1 based 1.e first string in the weeknames array is empty */
 617     if(udat_countSymbols(def, UDAT_ERAS)!=2 || udat_countSymbols(def, UDAT_MONTHS)!=12 ||
 618         udat_countSymbols(def, UDAT_SHORT_MONTHS)!=12 || udat_countSymbols(def, UDAT_WEEKDAYS)!=8 ||
 619         udat_countSymbols(def, UDAT_SHORT_WEEKDAYS)!=8 || udat_countSymbols(def, UDAT_AM_PMS)!=2 ||
 620         udat_countSymbols(def, UDAT_QUARTERS) != 4 || udat_countSymbols(def, UDAT_SHORT_QUARTERS) != 4 ||
 621         udat_countSymbols(def, UDAT_LOCALIZED_CHARS)!=1 || udat_countSymbols(def, UDAT_SHORTER_WEEKDAYS)!=8 ||
 622         udat_countSymbols(zhChiCal, UDAT_CYCLIC_YEARS_NARROW)!=60 || udat_countSymbols(zhChiCal, UDAT_ZODIAC_NAMES_NARROW)!=12)
 623     {
 624         log_err("FAIL: error in udat_countSymbols\n");
 625     }
 626     else
 627         log_verbose("PASS: udat_countSymbols() successful\n");
 628
 629     /*testing getSymbols*/
 630     log_verbose("\nTesting getSymbols\n");
 631     pattern=(UChar*)malloc(sizeof(UChar) * 10);
 632     u_uastrcpy(pattern, "jeudi");
 633     resultlength=0;
 634     resultlengthout=udat_getSymbols(fr, UDAT_WEEKDAYS, 5 , NULL, resultlength, &status);
 635     if(status==U_BUFFER_OVERFLOW_ERROR)
 636     {
 637         status=U_ZERO_ERROR;
 638         resultlength=resultlengthout+1;
 639         if(result != NULL) {
 640             free(result);
 641             result = NULL;
 642         }
 643         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 644         udat_getSymbols(fr, UDAT_WEEKDAYS, 5, result, resultlength, &status);
 645
 646     }
 647     if(U_FAILURE(status))
 648     {
 649         log_err("FAIL: Error in udat_getSymbols().... %s\n", myErrorName(status) );
 650     }
 651     else
 652         log_verbose("PASS: getSymbols succesful\n");
 653
 654     if(u_strcmp(result, pattern)==0)
 655         log_verbose("PASS: getSymbols retrieved the right value\n");
 656     else
 657         log_data_err("FAIL: getSymbols retrieved the wrong value\n");
 658
 659     /*run series of tests to test getsymbols regressively*/
 660     log_verbose("\nTesting getSymbols() regressively\n");
 661     VerifygetSymbols(fr, UDAT_WEEKDAYS, 1, "dimanche");
 662     VerifygetSymbols(def, UDAT_WEEKDAYS, 1, "Sunday");
 663     VerifygetSymbols(fr, UDAT_SHORT_WEEKDAYS, 7, "sam.");
 664     VerifygetSymbols(fr, UDAT_SHORTER_WEEKDAYS, 7, "sa");
 665     VerifygetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Sat");
 666     VerifygetSymbols(def, UDAT_MONTHS, 11, "December");
 667     VerifygetSymbols(def, UDAT_MONTHS, 0, "January");
 668     VerifygetSymbols(fr, UDAT_ERAS, 0, "av. J.-C.");
 669     VerifygetSymbols(def, UDAT_AM_PMS, 0, "AM");
 670     VerifygetSymbols(def, UDAT_AM_PMS, 1, "PM");
 671     VerifygetSymbols(fr, UDAT_SHORT_MONTHS, 0, "janv.");
 672     VerifygetSymbols(def, UDAT_SHORT_MONTHS, 11, "Dec");
 673     VerifygetSymbols(fr, UDAT_QUARTERS, 0, "1er trimestre");
 674     VerifygetSymbols(def, UDAT_QUARTERS, 3, "4th quarter");
 675     VerifygetSymbols(fr, UDAT_SHORT_QUARTERS, 1, "T2");
 676     VerifygetSymbols(def, UDAT_SHORT_QUARTERS, 2, "Q3");
 677     VerifygetSymbols(zhChiCal, UDAT_CYCLIC_YEARS_ABBREVIATED, 0, "\\u7532\\u5B50");
 678     VerifygetSymbols(zhChiCal, UDAT_CYCLIC_YEARS_NARROW, 59, "\\u7678\\u4EA5");
 679     VerifygetSymbols(zhChiCal, UDAT_ZODIAC_NAMES_ABBREVIATED, 0, "\\u9F20");
 680     VerifygetSymbols(zhChiCal, UDAT_ZODIAC_NAMES_WIDE, 11, "\\u732A");
 681 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
 682     VerifygetSymbols(def,UDAT_LOCALIZED_CHARS, 0, "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB:");
 683 #else
 684     VerifygetSymbols(def,UDAT_LOCALIZED_CHARS, 0, "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB");
 685 #endif
 686
 687
 688     if(result != NULL) {
 689         free(result);
 690         result = NULL;
 691     }
 692 free(pattern);
 693
 694     log_verbose("\nTesting setSymbols\n");
 695     /*applying the pattern so that setSymbolss works */
 696     resultlength=0;
 697     resultlengthout=udat_toPattern(fr, FALSE, NULL, resultlength, &status);
 698     if(status==U_BUFFER_OVERFLOW_ERROR)
 699     {
 700         status=U_ZERO_ERROR;
 701         resultlength=resultlengthout + 1;
 702         pattern=(UChar*)malloc(sizeof(UChar) * resultlength);
 703         udat_toPattern(fr, FALSE, pattern, resultlength, &status);
 704     }
 705     if(U_FAILURE(status))
 706     {
 707         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
 708             myErrorName(status) );
 709     }
 710
 711     udat_applyPattern(def, FALSE, pattern, u_strlen(pattern));
 712     resultlength=0;
 713     resultlengthout=udat_toPattern(def, FALSE, NULL, resultlength,&status);
 714     if(status==U_BUFFER_OVERFLOW_ERROR)
 715     {
 716         status=U_ZERO_ERROR;
 717         resultlength=resultlengthout + 1;
 718         if(result != NULL) {
 719             free(result);
 720             result = NULL;
 721         }
 722         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 723         udat_toPattern(fr, FALSE,result, resultlength, &status);
 724     }
 725     if(U_FAILURE(status))
 726     {
 727         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
 728             myErrorName(status) );
 729     }
 730     if(u_strcmp(result, pattern)==0)
 731         log_verbose("Pattern applied properly\n");
 732     else
 733         log_err("pattern could not be applied properly\n");
 734
 735 free(pattern);
 736     /*testing set symbols */
 737     resultlength=0;
 738     resultlengthout=udat_getSymbols(fr, UDAT_MONTHS, 11 , NULL, resultlength, &status);
 739     if(status==U_BUFFER_OVERFLOW_ERROR){
 740         status=U_ZERO_ERROR;
 741         resultlength=resultlengthout+1;
 742         if(result != NULL) {
 743             free(result);
 744             result = NULL;
 745         }
 746         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 747         udat_getSymbols(fr, UDAT_MONTHS, 11, result, resultlength, &status);
 748
 749     }
 750     if(U_FAILURE(status))
 751         log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
 752     resultlength=resultlengthout+1;
 753
 754     udat_setSymbols(def, UDAT_MONTHS, 11, result, resultlength, &status);
 755     if(U_FAILURE(status))
 756         {
 757             log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
 758         }
 759     else
 760         log_verbose("PASS: SetSymbols successful\n");
 761
 762     resultlength=0;
 763     resultlengthout=udat_getSymbols(def, UDAT_MONTHS, 11, NULL, resultlength, &status);
 764     if(status==U_BUFFER_OVERFLOW_ERROR){
 765         status=U_ZERO_ERROR;
 766         resultlength=resultlengthout+1;
 767         value=(UChar*)malloc(sizeof(UChar) * resultlength);
 768         udat_getSymbols(def, UDAT_MONTHS, 11, value, resultlength, &status);
 769     }
 770     if(U_FAILURE(status))
 771         log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n");
 772
 773     if(u_strcmp(result, value)!=0)
 774         log_data_err("FAIL: Error in settting and getting symbols\n");
 775     else
 776         log_verbose("PASS: setSymbols successful\n");
 777
 778
 779     /*run series of tests to test setSymbols regressively*/
 780     log_verbose("\nTesting setSymbols regressively\n");
 781     VerifysetSymbols(def, UDAT_ERAS, 0, "BeforeChrist");
 782     VerifysetSymbols(def, UDAT_ERA_NAMES, 1, "AnnoDomini");
 783     VerifysetSymbols(def, UDAT_WEEKDAYS, 1, "Sundayweek");
 784     VerifysetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Satweek");
 785     VerifysetSymbols(def, UDAT_NARROW_WEEKDAYS, 4, "M");
 786     VerifysetSymbols(def, UDAT_STANDALONE_WEEKDAYS, 1, "Sonntagweek");
 787     VerifysetSymbols(def, UDAT_STANDALONE_SHORT_WEEKDAYS, 7, "Sams");
 788     VerifysetSymbols(def, UDAT_STANDALONE_NARROW_WEEKDAYS, 4, "V");
 789     VerifysetSymbols(fr, UDAT_MONTHS, 11, "december");
 790     VerifysetSymbols(fr, UDAT_SHORT_MONTHS, 0, "Jan");
 791     VerifysetSymbols(fr, UDAT_NARROW_MONTHS, 1, "R");
 792     VerifysetSymbols(fr, UDAT_STANDALONE_MONTHS, 11, "dezember");
 793     VerifysetSymbols(fr, UDAT_STANDALONE_SHORT_MONTHS, 7, "Aug");
 794     VerifysetSymbols(fr, UDAT_STANDALONE_NARROW_MONTHS, 2, "M");
 795     VerifysetSymbols(fr, UDAT_QUARTERS, 0, "1. Quart");
 796     VerifysetSymbols(fr, UDAT_SHORT_QUARTERS, 1, "QQ2");
 797     VerifysetSymbols(fr, UDAT_STANDALONE_QUARTERS, 2, "3rd Quar.");
 798     VerifysetSymbols(fr, UDAT_STANDALONE_SHORT_QUARTERS, 3, "4QQ");
 799     VerifysetSymbols(zhChiCal, UDAT_CYCLIC_YEARS_ABBREVIATED, 1, "yi-chou");
 800     VerifysetSymbols(zhChiCal, UDAT_ZODIAC_NAMES_ABBREVIATED, 1, "Ox");
 801
 802
 803     /*run series of tests to test get and setSymbols regressively*/
 804     log_verbose("\nTesting get and set symbols regressively\n");
 805     VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 1);
 806     VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 7);
 807     VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 1);
 808     VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 7);
 809     VerifygetsetSymbols(fr, def, UDAT_MONTHS, 0);
 810     VerifygetsetSymbols(fr, def, UDAT_SHORT_MONTHS, 0);
 811     VerifygetsetSymbols(fr, def, UDAT_ERAS,1);
 812     VerifygetsetSymbols(fr, def, UDAT_LOCALIZED_CHARS, 0);
 813     VerifygetsetSymbols(fr, def, UDAT_AM_PMS, 1);
 814
 815
 816     /*closing*/
 817
 818     udat_close(fr);
 819     udat_close(def);
 820     udat_close(zhChiCal);
 821     if(result != NULL) {
 822         free(result);
 823         result = NULL;
 824     }
 825     free(value);
 826
 827 }
 828
 829 /**
 830  * Test DateFormat(Calendar) API
 831  */
 832 static void TestDateFormatCalendar() {
 833     UDateFormat *date=0, *time=0, *full=0;
 834     UCalendar *cal=0;
 835     UChar buf[256];
 836     char cbuf[256];
 837     int32_t pos;
 838     UDate when;
 839     UErrorCode ec = U_ZERO_ERROR;
 840     UChar buf1[256];
 841     int32_t len1;
 842     const char *expected;
 843     UChar uExpected[32];
 844
 845     ctest_setTimeZone(NULL, &ec);
 846
 847     /* Create a formatter for date fields. */
 848     date = udat_open(UDAT_NONE, UDAT_SHORT, "en_US", NULL, 0, NULL, 0, &ec);
 849     if (U_FAILURE(ec)) {
 850         log_data_err("FAIL: udat_open(NONE, SHORT, en_US) failed with %s (Are you missing data?)\n",
 851                 u_errorName(ec));
 852         goto FAIL;
 853     }
 854
 855     /* Create a formatter for time fields. */
 856     time = udat_open(UDAT_SHORT, UDAT_NONE, "en_US", NULL, 0, NULL, 0, &ec);
 857     if (U_FAILURE(ec)) {
 858         log_err("FAIL: udat_open(SHORT, NONE, en_US) failed with %s\n",
 859                 u_errorName(ec));
 860         goto FAIL;
 861     }
 862
 863     /* Create a full format for output */
 864     full = udat_open(UDAT_FULL, UDAT_FULL, "en_US", NULL, 0, NULL, 0, &ec);
 865     if (U_FAILURE(ec)) {
 866         log_err("FAIL: udat_open(FULL, FULL, en_US) failed with %s\n",
 867                 u_errorName(ec));
 868         goto FAIL;
 869     }
 870
 871     /* Create a calendar */
 872     cal = ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &ec);
 873     if (U_FAILURE(ec)) {
 874         log_err("FAIL: ucal_open(en_US) failed with %s\n",
 875                 u_errorName(ec));
 876         goto FAIL;
 877     }
 878
 879     /* Parse the date */
 880     ucal_clear(cal);
 881     u_uastrcpy(buf, "4/5/2001");
 882     pos = 0;
 883     udat_parseCalendar(date, cal, buf, -1, &pos, &ec);
 884     if (U_FAILURE(ec)) {
 885         log_err("FAIL: udat_parseCalendar(4/5/2001) failed at %d with %s\n",
 886                 pos, u_errorName(ec));
 887         goto FAIL;
 888     }
 889
 890     /* Check if formatCalendar matches the original date */
 891     len1 = udat_formatCalendar(date, cal, buf1, UPRV_LENGTHOF(buf1), NULL, &ec);
 892     if (U_FAILURE(ec)) {
 893         log_err("FAIL: udat_formatCalendar(4/5/2001) failed with %s\n",
 894                 u_errorName(ec));
 895         goto FAIL;
 896     }
 897     expected = "4/5/01";
 898     u_uastrcpy(uExpected, expected);
 899     if (u_strlen(uExpected) != len1 || u_strncmp(uExpected, buf1, len1) != 0) {
 900         log_err("FAIL: udat_formatCalendar(4/5/2001), expected: %s", expected);
 901     }
 902
 903     /* Parse the time */
 904     u_uastrcpy(buf, "5:45 PM");
 905     pos = 0;
 906     udat_parseCalendar(time, cal, buf, -1, &pos, &ec);
 907     if (U_FAILURE(ec)) {
 908         log_err("FAIL: udat_parseCalendar(17:45) failed at %d with %s\n",
 909                 pos, u_errorName(ec));
 910         goto FAIL;
 911     }
 912
 913     /* Check if formatCalendar matches the original time */
 914     len1 = udat_formatCalendar(time, cal, buf1, UPRV_LENGTHOF(buf1), NULL, &ec);
 915     if (U_FAILURE(ec)) {
 916         log_err("FAIL: udat_formatCalendar(17:45) failed with %s\n",
 917                 u_errorName(ec));
 918         goto FAIL;
 919     }
 920     expected = "5:45 PM";
 921     u_uastrcpy(uExpected, expected);
 922     if (u_strlen(uExpected) != len1 || u_strncmp(uExpected, buf1, len1) != 0) {
 923         log_err("FAIL: udat_formatCalendar(17:45), expected: %s", expected);
 924     }
 925
 926     /* Check result */
 927     when = ucal_getMillis(cal, &ec);
 928     if (U_FAILURE(ec)) {
 929         log_err("FAIL: ucal_getMillis() failed with %s\n", u_errorName(ec));
 930         goto FAIL;
 931     }
 932     udat_format(full, when, buf, sizeof(buf), NULL, &ec);
 933     if (U_FAILURE(ec)) {
 934         log_err("FAIL: udat_format() failed with %s\n", u_errorName(ec));
 935         goto FAIL;
 936     }
 937     u_austrcpy(cbuf, buf);
 938     /* Thursday, April 5, 2001 5:45:00 PM PDT 986517900000 */
 939     if (when == 986517900000.0) {
 940         log_verbose("Ok: Parsed result: %s\n", cbuf);
 941     } else {
 942         log_err("FAIL: Parsed result: %s, exp 4/5/2001 5:45 PM\n", cbuf);
 943     }
 944
 945  FAIL:
 946     udat_close(date);
 947     udat_close(time);
 948     udat_close(full);
 949     ucal_close(cal);
 950
 951     ctest_resetTimeZone();
 952 }
 953
 954
 955
 956 /**
 957  * Test parsing two digit year against "YY" vs. "YYYY" patterns
 958  */
 959 static void TestCalendarDateParse() {
 960
 961     int32_t result;
 962     UErrorCode ec = U_ZERO_ERROR;
 963     UDateFormat* simpleDateFormat = 0;
 964     int32_t parsePos = 0;
 965     int32_t twoDigitCenturyStart = 75;
 966     int32_t currentTwoDigitYear = 0;
 967     int32_t startCentury = 0;
 968     UCalendar* tempCal = 0;
 969     UCalendar* calendar = 0;
 970
 971     U_STRING_DECL(pattern, "yyyy", 4);
 972     U_STRING_DECL(pattern2, "yy", 2);
 973     U_STRING_DECL(text, "75", 2);
 974
 975     U_STRING_INIT(pattern, "yyyy", 4);
 976     U_STRING_INIT(pattern2, "yy", 2);
 977     U_STRING_INIT(text, "75", 2);
 978
 979     simpleDateFormat = udat_open(UDAT_FULL, UDAT_FULL, "en-GB", 0, 0, 0, 0, &ec);
 980     if (U_FAILURE(ec)) {
 981         log_data_err("udat_open(UDAT_FULL, UDAT_FULL, \"en-GB\", 0, 0, 0, 0, &ec) failed: %s - (Are you missing data?)\n", u_errorName(ec));
 982         return;
 983     }
 984     udat_applyPattern(simpleDateFormat, 0, pattern, u_strlen(pattern));
 985     udat_setLenient(simpleDateFormat, 0);
 986
 987     currentTwoDigitYear = getCurrentYear() % 100;
 988     startCentury = getCurrentYear() - currentTwoDigitYear;
 989     if (twoDigitCenturyStart > currentTwoDigitYear) {
 990       startCentury -= 100;
 991     }
 992     tempCal = ucal_open(NULL, -1, NULL, UCAL_GREGORIAN, &ec);
 993     ucal_setMillis(tempCal, 0, &ec);
 994     ucal_setDateTime(tempCal, startCentury + twoDigitCenturyStart, UCAL_JANUARY, 1, 0, 0, 0, &ec);
 995     udat_set2DigitYearStart(simpleDateFormat, ucal_getMillis(tempCal, &ec), &ec);
 996
 997     calendar = ucal_open(NULL, -1, NULL, UCAL_GREGORIAN, &ec);
 998     ucal_setMillis(calendar, 0, &ec);
 999     ucal_setDateTime(calendar, twoDigitCenturyStart, UCAL_JANUARY, 1, 0, 0, 0, &ec);
1000
1001     udat_parseCalendar(simpleDateFormat, calendar, text, u_strlen(text), &parsePos, &ec);
1002
1003     /* Check result */
1004     result = ucal_get(calendar, UCAL_YEAR, &ec);
1005     if (U_FAILURE(ec)) {
1006         log_err("FAIL: ucal_get(UCAL_YEAR) failed with %s\n", u_errorName(ec));
1007         goto FAIL;
1008     }
1009
1010     if (result != 75) {
1011         log_err("FAIL: parsed incorrect year: %d\n", result);
1012         goto FAIL;
1013     }
1014
1015     parsePos = 0;
1016     udat_applyPattern(simpleDateFormat, 0, pattern2, u_strlen(pattern2));
1017     udat_parseCalendar(simpleDateFormat, calendar, text, u_strlen(text), &parsePos, &ec);
1018
1019     /* Check result */
1020     result = ucal_get(calendar, UCAL_YEAR, &ec);
1021     if (U_FAILURE(ec)) {
1022         log_err("FAIL: ucal_get(UCAL_YEAR) failed with %s\n", u_errorName(ec));
1023         goto FAIL;
1024     }
1025
1026     if (result != 1975) {
1027         log_err("FAIL: parsed incorrect year: %d\n", result);
1028         goto FAIL;
1029     }
1030
1031  FAIL:
1032     udat_close(simpleDateFormat);
1033     udat_close(tempCal);
1034     udat_close(calendar);
1035 }
1036
1037
1038 /*INTERNAL FUNCTIONS USED*/
1039 static int getCurrentYear() {
1040     static int currentYear = 0;
1041     if (currentYear == 0) {
1042         UErrorCode status = U_ZERO_ERROR;
1043         UCalendar *cal = ucal_open(NULL, -1, NULL, UCAL_GREGORIAN, &status);
1044         if (!U_FAILURE(status)) {
1045             /* Get the current year from the default UCalendar */
1046             currentYear = ucal_get(cal, UCAL_YEAR, &status);
1047             ucal_close(cal);
1048         }
1049     }
1050
1051     return currentYear;
1052 }
1053
1054 /* N.B.:  use idx instead of index to avoid 'shadow' warnings in strict mode. */
1055 static void VerifygetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t idx, const char* expected)
1056 {
1057     UChar *pattern=NULL;
1058     UErrorCode status = U_ZERO_ERROR;
1059     UChar *result=NULL;
1060     int32_t resultlength, resultlengthout;
1061     int32_t patternSize = strlen(expected) + 1;
1062
1063     pattern=(UChar*)malloc(sizeof(UChar) * patternSize);
1064     u_unescape(expected, pattern, patternSize);
1065     resultlength=0;
1066     resultlengthout=udat_getSymbols(datfor, type, idx , NULL, resultlength, &status);
1067     if(status==U_BUFFER_OVERFLOW_ERROR)
1068     {
1069         status=U_ZERO_ERROR;
1070         resultlength=resultlengthout+1;
1071         result=(UChar*)malloc(sizeof(UChar) * resultlength);
1072         udat_getSymbols(datfor, type, idx, result, resultlength, &status);
1073
1074     }
1075     if(U_FAILURE(status))
1076     {
1077         log_err("FAIL: Error in udat_getSymbols()... %s\n", myErrorName(status) );
1078         return;
1079     }
1080     if(u_strcmp(result, pattern)==0)
1081         log_verbose("PASS: getSymbols retrieved the right value\n");
1082     else{
1083         log_data_err("FAIL: getSymbols retrieved the wrong value\n Expected %s Got %s\n", expected,
1084             aescstrdup(result,-1) );
1085     }
1086     free(result);
1087     free(pattern);
1088 }
1089
1090 static void VerifysetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t idx, const char* expected)
1091 {
1092     UChar *result=NULL;
1093     UChar *value=NULL;
1094     int32_t resultlength, resultlengthout;
1095     UErrorCode status = U_ZERO_ERROR;
1096     int32_t valueLen, valueSize = strlen(expected) + 1;
1097
1098     value=(UChar*)malloc(sizeof(UChar) * valueSize);
1099     valueLen = u_unescape(expected, value, valueSize);
1100     udat_setSymbols(datfor, type, idx, value, valueLen, &status);
1101     if(U_FAILURE(status))
1102         {
1103             log_err("FAIL: Error in udat_setSymbols()  %s\n", myErrorName(status) );
1104             return;
1105         }
1106
1107     resultlength=0;
1108     resultlengthout=udat_getSymbols(datfor, type, idx, NULL, resultlength, &status);
1109     if(status==U_BUFFER_OVERFLOW_ERROR){
1110         status=U_ZERO_ERROR;
1111         resultlength=resultlengthout+1;
1112         result=(UChar*)malloc(sizeof(UChar) * resultlength);
1113         udat_getSymbols(datfor, type, idx, result, resultlength, &status);
1114     }
1115     if(U_FAILURE(status)){
1116         log_err("FAIL: error in retrieving the value using getSymbols after setting it previously\n %s\n",
1117             myErrorName(status) );
1118         return;
1119     }
1120
1121     if(u_strcmp(result, value)!=0){
1122         log_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", expected,
1123             aescstrdup(result,-1) );
1124     }
1125     else
1126         log_verbose("PASS: setSymbols successful\n");
1127
1128     free(value);
1129     free(result);
1130 }
1131
1132
1133 static void VerifygetsetSymbols(UDateFormat* from, UDateFormat* to, UDateFormatSymbolType type, int32_t idx)
1134 {
1135     UChar *result=NULL;
1136     UChar *value=NULL;
1137     int32_t resultlength, resultlengthout;
1138     UErrorCode status = U_ZERO_ERROR;
1139
1140     resultlength=0;
1141     resultlengthout=udat_getSymbols(from, type, idx , NULL, resultlength, &status);
1142     if(status==U_BUFFER_OVERFLOW_ERROR){
1143         status=U_ZERO_ERROR;
1144         resultlength=resultlengthout+1;
1145         result=(UChar*)malloc(sizeof(UChar) * resultlength);
1146         udat_getSymbols(from, type, idx, result, resultlength, &status);
1147     }
1148     if(U_FAILURE(status)){
1149         log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
1150         return;
1151     }
1152
1153     resultlength=resultlengthout+1;
1154     udat_setSymbols(to, type, idx, result, resultlength, &status);
1155     if(U_FAILURE(status))
1156         {
1157             log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
1158             return;
1159         }
1160
1161     resultlength=0;
1162     resultlengthout=udat_getSymbols(to, type, idx, NULL, resultlength, &status);
1163     if(status==U_BUFFER_OVERFLOW_ERROR){
1164         status=U_ZERO_ERROR;
1165         resultlength=resultlengthout+1;
1166         value=(UChar*)malloc(sizeof(UChar) * resultlength);
1167         udat_getSymbols(to, type, idx, value, resultlength, &status);
1168     }
1169     if(U_FAILURE(status)){
1170         log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n %s\n",
1171             myErrorName(status) );
1172         return;
1173     }
1174
1175     if(u_strcmp(result, value)!=0){
1176         log_data_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(result),
1177             austrdup(value) );
1178     }
1179     else
1180         log_verbose("PASS: setSymbols successful\n");
1181
1182     free(value);
1183     free(result);
1184 }
1185
1186
1187 static UChar* myNumformat(const UNumberFormat* numfor, double d)
1188 {
1189     UChar *result2=NULL;
1190     int32_t resultlength, resultlengthneeded;
1191     UErrorCode status = U_ZERO_ERROR;
1192
1193     resultlength=0;
1194     resultlengthneeded=unum_formatDouble(numfor, d, NULL, resultlength, NULL, &status);
1195     if(status==U_BUFFER_OVERFLOW_ERROR)
1196     {
1197         status=U_ZERO_ERROR;
1198         resultlength=resultlengthneeded+1;
1199         /*result2=(UChar*)malloc(sizeof(UChar) * resultlength);*/ /* this leaks */
1200         result2=(UChar*)ctst_malloc(sizeof(UChar) * resultlength); /*this won't*/
1201         unum_formatDouble(numfor, d, result2, resultlength, NULL, &status);
1202     }
1203     if(U_FAILURE(status))
1204     {
1205         log_err("FAIL: Error in formatting using unum_format(.....) %s\n", myErrorName(status) );
1206         return 0;
1207     }
1208
1209     return result2;
1210 }
1211
1212 /**
1213  * The search depth for TestExtremeDates.  The total number of
1214  * dates that will be tested is (2^EXTREME_DATES_DEPTH) - 1.
1215  */
1216 #define EXTREME_DATES_DEPTH 8
1217
1218 /**
1219  * Support for TestExtremeDates (below).
1220  *
1221  * Test a single date to see whether udat_format handles it properly.
1222  */
1223 static UBool _aux1ExtremeDates(UDateFormat* fmt, UDate date,
1224                                UChar* buf, int32_t buflen, char* cbuf,
1225                                UErrorCode* ec) {
1226     int32_t len = udat_format(fmt, date, buf, buflen, 0, ec);
1227     if (!assertSuccess("udat_format", ec)) return FALSE;
1228     u_austrncpy(cbuf, buf, buflen);
1229     if (len < 4) {
1230         log_err("FAIL: udat_format(%g) => \"%s\"\n", date, cbuf);
1231     } else {
1232         log_verbose("udat_format(%g) => \"%s\"\n", date, cbuf);
1233     }
1234     return TRUE;
1235 }
1236
1237 /**
1238  * Support for TestExtremeDates (below).
1239  *
1240  * Recursively test between 'small' and 'large', up to the depth
1241  * limit specified by EXTREME_DATES_DEPTH.
1242  */
1243 static UBool _aux2ExtremeDates(UDateFormat* fmt, UDate small, UDate large,
1244                                UChar* buf, int32_t buflen, char* cbuf,
1245                                int32_t count,
1246                                UErrorCode* ec) {
1247     /* Logarithmic midpoint; see below */
1248     UDate mid = (UDate) exp((log(small) + log(large)) / 2);
1249     if (count == EXTREME_DATES_DEPTH) {
1250         return TRUE;
1251     }
1252     return
1253         _aux1ExtremeDates(fmt, mid, buf, buflen, cbuf, ec) &&
1254         _aux2ExtremeDates(fmt, small, mid, buf, buflen, cbuf, count+1, ec) &&
1255         _aux2ExtremeDates(fmt, mid, large, buf, buflen, cbuf, count+1, ec);
1256 }
1257
1258 /**
1259  * http://www.jtcsv.com/cgibin/icu-bugs?findid=3659
1260  *
1261  * For certain large dates, udat_format crashes on MacOS.  This test
1262  * attempts to reproduce this problem by doing a recursive logarithmic*
1263  * binary search of a predefined interval (from 'small' to 'large').
1264  *
1265  * The limit of the search is given by EXTREME_DATES_DEPTH, above.
1266  *
1267  * *The search has to be logarithmic, not linear.  A linear search of the
1268  *  range 0..10^30, for example, will find 0.5*10^30, then 0.25*10^30 and
1269  *  0.75*10^30, etc.  A logarithmic search will find 10^15, then 10^7.5
1270  *  and 10^22.5, etc.
1271  */
1272 static void TestExtremeDates() {
1273     UDateFormat *fmt;
1274     UErrorCode ec;
1275     UChar buf[256];
1276     char cbuf[256];
1277     const double small = 1000; /* 1 sec */
1278     const double large = 1e+30; /* well beyond usable UDate range */
1279
1280     /* There is no need to test larger values from 1e+30 to 1e+300;
1281        the failures occur around 1e+27, and never above 1e+30. */
1282
1283     ec = U_ZERO_ERROR;
1284     fmt = udat_open(UDAT_LONG, UDAT_LONG, "en_US",
1285                     0, 0, 0, 0, &ec);
1286     if (U_FAILURE(ec)) {
1287         log_data_err("FAIL: udat_open (%s) (Are you missing data?)\n", u_errorName(ec));
1288         return;
1289     }
1290
1291     _aux2ExtremeDates(fmt, small, large, buf, UPRV_LENGTHOF(buf), cbuf, 0, &ec);
1292
1293     udat_close(fmt);
1294 }
1295
1296 static void TestAllLocales(void) {
1297     int32_t idx, dateIdx, timeIdx, localeCount;
1298     static const UDateFormatStyle style[] = {
1299         UDAT_FULL, UDAT_LONG, UDAT_MEDIUM, UDAT_SHORT
1300     };
1301     localeCount = uloc_countAvailable();
1302     for (idx = 0; idx < localeCount; idx++) {
1303         for (dateIdx = 0; dateIdx < UPRV_LENGTHOF(style); dateIdx++) {
1304             for (timeIdx = 0; timeIdx < UPRV_LENGTHOF(style); timeIdx++) {
1305                 UErrorCode status = U_ZERO_ERROR;
1306                 udat_close(udat_open(style[dateIdx], style[timeIdx],
1307                     uloc_getAvailable(idx), NULL, 0, NULL, 0, &status));
1308                 if (U_FAILURE(status)) {
1309                     log_err("FAIL: udat_open(%s) failed with (%s) dateIdx=%d, timeIdx=%d\n",
1310                         uloc_getAvailable(idx), u_errorName(status), dateIdx, timeIdx);
1311                 }
1312             }
1313         }
1314     }
1315 }
1316
1317 static void TestRelativeCrash(void) {
1318        static const UChar tzName[] = { 0x0055, 0x0053, 0x002F, 0x0050, 0x0061, 0x0063, 0x0069, 0x0066, 0x0069, 0x0063, 0 };
1319        static const UDate aDate = -631152000000.0;
1320
1321     UErrorCode status = U_ZERO_ERROR;
1322     UErrorCode expectStatus = U_ILLEGAL_ARGUMENT_ERROR;
1323     UDateFormat icudf;
1324
1325     icudf = udat_open(UDAT_NONE, UDAT_SHORT_RELATIVE, "en", tzName, -1, NULL, 0, &status);
1326     if ( U_SUCCESS(status) ) {
1327         const char *what = "???";
1328         {
1329             UErrorCode subStatus = U_ZERO_ERROR;
1330             what = "udat_set2DigitYearStart";
1331             log_verbose("Trying %s on a relative date..\n", what);
1332             udat_set2DigitYearStart(icudf, aDate, &subStatus);
1333             if(subStatus == expectStatus) {
1334                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1335             } else {
1336                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1337             }
1338         }
1339         {
1340             /* clone works polymorphically. try it anyways */
1341             UErrorCode subStatus = U_ZERO_ERROR;
1342             UDateFormat *oth;
1343             what = "clone";
1344             log_verbose("Trying %s on a relative date..\n", what);
1345             oth = udat_clone(icudf, &subStatus);
1346             if(subStatus == U_ZERO_ERROR) {
1347                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1348                 udat_close(oth); /* ? */
1349             } else {
1350                 log_err("FAIL: didn't crash on %s, but got  %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1351             }
1352         }
1353         {
1354             UErrorCode subStatus = U_ZERO_ERROR;
1355             what = "udat_get2DigitYearStart";
1356             log_verbose("Trying %s on a relative date..\n", what);
1357             udat_get2DigitYearStart(icudf, &subStatus);
1358             if(subStatus == expectStatus) {
1359                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1360             } else {
1361                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1362             }
1363         }
1364         {
1365             /* Now udat_toPattern works for relative date formatters, unless localized is TRUE */
1366             UErrorCode subStatus = U_ZERO_ERROR;
1367             what = "udat_toPattern";
1368             log_verbose("Trying %s on a relative date..\n", what);
1369             udat_toPattern(icudf, TRUE,NULL,0, &subStatus);
1370             if(subStatus == expectStatus) {
1371                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1372             } else {
1373                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1374             }
1375         }
1376         {
1377             UErrorCode subStatus = U_ZERO_ERROR;
1378             what = "udat_applyPattern";
1379             log_verbose("Trying %s on a relative date..\n", what);
1380             udat_applyPattern(icudf, FALSE,tzName,-1);
1381             subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* what it should be, if this took an errorcode. */
1382             if(subStatus == expectStatus) {
1383                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1384             } else {
1385                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1386             }
1387         }
1388         {
1389             UChar erabuf[32];
1390             UErrorCode subStatus = U_ZERO_ERROR;
1391             what = "udat_getSymbols";
1392             log_verbose("Trying %s on a relative date..\n", what);
1393             udat_getSymbols(icudf, UDAT_ERAS,0,erabuf,UPRV_LENGTHOF(erabuf), &subStatus);
1394             if(subStatus == U_ZERO_ERROR) {
1395                 log_verbose("Success: %s returned %s.\n", what, u_errorName(subStatus));
1396             } else {
1397                 log_err("FAIL: didn't crash on %s, but got %s instead of U_ZERO_ERROR.\n", what, u_errorName(subStatus));
1398             }
1399         }
1400         {
1401             UErrorCode subStatus = U_ZERO_ERROR;
1402             UChar symbolValue = 0x0041;
1403             what = "udat_setSymbols";
1404             log_verbose("Trying %s on a relative date..\n", what);
1405             udat_setSymbols(icudf, UDAT_ERAS,0,&symbolValue,1, &subStatus);  /* bogus values */
1406             if(subStatus == expectStatus) {
1407                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1408             } else {
1409                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1410             }
1411         }
1412         {
1413             UErrorCode subStatus = U_ZERO_ERROR;
1414             what = "udat_countSymbols";
1415             log_verbose("Trying %s on a relative date..\n", what);
1416             udat_countSymbols(icudf, UDAT_ERAS);
1417             subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* should have an errorcode. */
1418             if(subStatus == expectStatus) {
1419                 log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
1420             } else {
1421                 log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
1422             }
1423         }
1424
1425         udat_close(icudf);
1426     } else {
1427          log_data_err("FAIL: err calling udat_open() ->%s (Are you missing data?)\n", u_errorName(status));
1428     }
1429 }
1430
1431 static const UChar skeleton_yMMMM[] = { 0x79,0x4D,0x4D,0x4D,0x4D,0 }; /* "yMMMM"; fr maps to "MMMM y", cs maps to "LLLL y" */
1432 static const UChar july2008_frDefault[] = { 0x6A,0x75,0x69,0x6C,0x6C,0x65,0x74,0x20,0x32,0x30,0x30,0x38,0 }; /* "juillet 2008" */
1433 static const UChar july2008_frTitle[] = { 0x4A,0x75,0x69,0x6C,0x6C,0x65,0x74,0x20,0x32,0x30,0x30,0x38,0 };  /* "Juillet 2008" sentence-begin, standalone */
1434 static const UChar july2008_csDefault[] = { 0x10D,0x65,0x72,0x76,0x65,0x6E,0x65,0x63,0x20,0x32,0x30,0x30,0x38,0 }; /* "c(hacek)ervenec 2008" */
1435 static const UChar july2008_csTitle[] = { 0x10C,0x65,0x72,0x76,0x65,0x6E,0x65,0x63,0x20,0x32,0x30,0x30,0x38,0 }; /* "C(hacek)ervenec 2008" sentence-begin, uiListOrMenu */
1436
1437 typedef struct {
1438     const char * locale;
1439     const UChar * skeleton;
1440     UDisplayContext capitalizationContext;
1441     const UChar * expectedFormat;
1442 } TestContextItem;
1443
1444 static const TestContextItem textContextItems[] = {
1445     { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_NONE,                   july2008_frDefault },
1446 #if !UCONFIG_NO_BREAK_ITERATION
1447     { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, july2008_frDefault },
1448     { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, july2008_frTitle },
1449     { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU,    july2008_frDefault },
1450     { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_STANDALONE,         july2008_frTitle },
1451 #endif
1452     { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_NONE,                   july2008_csDefault },
1453 #if !UCONFIG_NO_BREAK_ITERATION
1454     { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, july2008_csDefault },
1455     { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, july2008_csTitle },
1456     { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU,    july2008_csTitle },
1457     { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_STANDALONE,         july2008_csDefault },
1458 #endif
1459     { NULL, NULL, (UDisplayContext)0, NULL }
1460 };
1461
1462 static const UChar today_enDefault[]     = { 0x74,0x6F,0x64,0x61,0x79,0 }; /* "today" */
1463 static const UChar today_enTitle[]       = { 0x54,0x6F,0x64,0x61,0x79,0 };  /* "Today" sentence-begin, uiListOrMenu, standalone */
1464 static const UChar yesterday_enDefault[] = { 0x79,0x65,0x73,0x74,0x65,0x72,0x64,0x61,0x79,0 }; /* "yesterday" */
1465 static const UChar yesterday_enTitle[]   = { 0x59,0x65,0x73,0x74,0x65,0x72,0x64,0x61,0x79,0 };  /* "Yesterday" sentence-begin, uiListOrMenu, standalone */
1466 static const UChar today_nbDefault[]     = { 0x69,0x20,0x64,0x61,0x67,0 }; /* "i dag" */
1467 static const UChar today_nbTitle[]       = { 0x49,0x20,0x64,0x61,0x67,0 };  /* "I dag" sentence-begin, standalone */
1468 static const UChar yesterday_nbDefault[] = { 0x69,0x20,0x67,0xE5,0x72,0 };
1469 static const UChar yesterday_nbTitle[]   = { 0x49,0x20,0x67,0xE5,0x72,0 };
1470
1471 typedef struct {
1472     const char * locale;
1473     UDisplayContext capitalizationContext;
1474     const UChar * expectedFormatToday;
1475     const UChar * expectedFormatYesterday;
1476 } TestRelativeContextItem;
1477
1478 static const TestRelativeContextItem textContextRelativeItems[] = {
1479     { "en", UDISPCTX_CAPITALIZATION_NONE,                   today_enDefault, yesterday_enDefault },
1480 #if !UCONFIG_NO_BREAK_ITERATION
1481     { "en", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, today_enDefault, yesterday_enDefault },
1482     { "en", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, today_enTitle, yesterday_enTitle },
1483     { "en", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU,    today_enTitle, yesterday_enTitle },
1484     { "en", UDISPCTX_CAPITALIZATION_FOR_STANDALONE,         today_enTitle, yesterday_enTitle },
1485 #endif
1486     { "nb", UDISPCTX_CAPITALIZATION_NONE,                   today_nbDefault, yesterday_nbDefault },
1487 #if !UCONFIG_NO_BREAK_ITERATION
1488     { "nb", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, today_nbDefault, yesterday_nbDefault },
1489     { "nb", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, today_nbTitle, yesterday_nbTitle },
1490     { "nb", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU,    today_nbDefault, yesterday_nbDefault },
1491     { "nb", UDISPCTX_CAPITALIZATION_FOR_STANDALONE,         today_nbTitle, yesterday_nbTitle },
1492 #endif
1493     { NULL, (UDisplayContext)0, NULL, NULL }
1494 };
1495
1496 static const UChar zoneGMT[] = { 0x47,0x4D,0x54,0 }; /* "GMT" */
1497 static const UDate july022008 = 1215000000000.0;
1498 enum { kUbufMax = 64, kBbufMax = 3*kUbufMax };
1499
1500 static void TestContext(void) {
1501     const TestContextItem* textContextItemPtr;
1502     const TestRelativeContextItem* textRelContextItemPtr;
1503     for (textContextItemPtr = textContextItems; textContextItemPtr->locale != NULL; ++textContextItemPtr) {
1504         UErrorCode status = U_ZERO_ERROR;
1505         UDateTimePatternGenerator* udtpg = udatpg_open(textContextItemPtr->locale, &status);
1506         if ( U_SUCCESS(status) ) {
1507             UChar ubuf[kUbufMax];
1508             int32_t len = udatpg_getBestPattern(udtpg, textContextItemPtr->skeleton, -1, ubuf, kUbufMax, &status);
1509             if ( U_SUCCESS(status) ) {
1510                 UDateFormat* udfmt = udat_open(UDAT_PATTERN, UDAT_PATTERN, textContextItemPtr->locale, zoneGMT, -1, ubuf, len, &status);
1511                 if ( U_SUCCESS(status) ) {
1512                     udat_setContext(udfmt, textContextItemPtr->capitalizationContext, &status);
1513                     if ( U_SUCCESS(status) ) {
1514                         UDisplayContext getContext;
1515                         len = udat_format(udfmt, july022008, ubuf, kUbufMax, NULL, &status);
1516                         if ( U_FAILURE(status) ) {
1517                             log_err("FAIL: udat_format for locale %s, capitalizationContext %d, status %s\n",
1518                                     textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
1519                             status = U_ZERO_ERROR;
1520                         } else if (u_strncmp(ubuf, textContextItemPtr->expectedFormat, kUbufMax) != 0) {
1521                             char bbuf1[kBbufMax];
1522                             char bbuf2[kBbufMax];
1523                             log_err("FAIL: udat_format for locale %s, capitalizationContext %d, expected %s, got %s\n",
1524                                     textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext,
1525                                     u_austrncpy(bbuf1,textContextItemPtr->expectedFormat,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
1526                         }
1527                         getContext = udat_getContext(udfmt, UDISPCTX_TYPE_CAPITALIZATION, &status);
1528                         if ( U_FAILURE(status) ) {
1529                             log_err("FAIL: udat_getContext for locale %s, capitalizationContext %d, status %s\n",
1530                                     textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
1531                         } else if (getContext != textContextItemPtr->capitalizationContext) {
1532                             log_err("FAIL: udat_getContext for locale %s, capitalizationContext %d, got context %d\n",
1533                                     textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, (int)getContext );
1534                         }
1535                     } else {
1536                         log_err("FAIL: udat_setContext for locale %s, capitalizationContext %d, status %s\n",
1537                                 textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
1538                     }
1539                     udat_close(udfmt);
1540                 } else {
1541                     log_data_err("FAIL: udat_open for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
1542                 }
1543             } else {
1544                 log_err("FAIL: udatpg_getBestPattern for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
1545             }
1546             udatpg_close(udtpg);
1547         } else {
1548             log_data_err("FAIL: udatpg_open for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
1549         }
1550     }
1551     for (textRelContextItemPtr = textContextRelativeItems; textRelContextItemPtr->locale != NULL; ++textRelContextItemPtr) {
1552         UErrorCode status = U_ZERO_ERROR;
1553         UCalendar* ucal = ucal_open(zoneGMT, -1, "root", UCAL_GREGORIAN, &status);
1554         if ( U_SUCCESS(status) ) {
1555             UDateFormat* udfmt = udat_open(UDAT_NONE, UDAT_LONG_RELATIVE, textRelContextItemPtr->locale, zoneGMT, -1, NULL, 0, &status);
1556             if ( U_SUCCESS(status) ) {
1557                 udat_setContext(udfmt, textRelContextItemPtr->capitalizationContext, &status);
1558                 if ( U_SUCCESS(status) ) {
1559                     UDate yesterday, today = ucal_getNow();
1560                     UChar ubuf[kUbufMax];
1561                     char bbuf1[kBbufMax];
1562                     char bbuf2[kBbufMax];
1563                     int32_t len = udat_format(udfmt, today, ubuf, kUbufMax, NULL, &status);
1564                     (void)len;
1565                     if ( U_FAILURE(status) ) {
1566                         log_err("FAIL: udat_format today for locale %s, capitalizationContext %d, status %s\n",
1567                                 textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
1568                     } else if (u_strncmp(ubuf, textRelContextItemPtr->expectedFormatToday, kUbufMax) != 0) {
1569                         log_err("FAIL: udat_format today for locale %s, capitalizationContext %d, expected %s, got %s\n",
1570                                 textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext,
1571                                 u_austrncpy(bbuf1,textRelContextItemPtr->expectedFormatToday,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
1572                     }
1573                     status = U_ZERO_ERROR;
1574                     ucal_setMillis(ucal, today, &status);
1575                     ucal_add(ucal, UCAL_DATE, -1, &status);
1576                     yesterday = ucal_getMillis(ucal, &status);
1577                     if ( U_SUCCESS(status) ) {
1578                         len = udat_format(udfmt, yesterday, ubuf, kUbufMax, NULL, &status);
1579                         if ( U_FAILURE(status) ) {
1580                             log_err("FAIL: udat_format yesterday for locale %s, capitalizationContext %d, status %s\n",
1581                                     textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
1582                         } else if (u_strncmp(ubuf, textRelContextItemPtr->expectedFormatYesterday, kUbufMax) != 0) {
1583                             log_err("FAIL: udat_format yesterday for locale %s, capitalizationContext %d, expected %s, got %s\n",
1584                                     textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext,
1585                                     u_austrncpy(bbuf1,textRelContextItemPtr->expectedFormatYesterday,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
1586                         }
1587                     }
1588                 } else {
1589                     log_err("FAIL: udat_setContext relative for locale %s, capitalizationContext %d, status %s\n",
1590                             textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
1591                 }
1592                 udat_close(udfmt);
1593             } else {
1594                 log_data_err("FAIL: udat_open relative for locale %s, status %s\n", textRelContextItemPtr->locale, u_errorName(status) );
1595             }
1596             ucal_close(ucal);
1597         } else {
1598             log_data_err("FAIL: ucal_open for locale root, status %s\n", u_errorName(status) );
1599         }
1600     }
1601 }
1602
1603
1604 // overrideNumberFormat[i][0] is to tell which field to set,
1605 // overrideNumberFormat[i][1] is the expected result
1606 static const char * overrideNumberFormat[][2] = {
1607         {"", "\\u521D\\u4E03 \\u521D\\u4E8C"},
1608         {"d", "07 \\u521D\\u4E8C"},
1609         {"do", "07 \\u521D\\u4E8C"},
1610         {"Md", "\\u521D\\u4E03 \\u521D\\u4E8C"},
1611         {"MdMMd", "\\u521D\\u4E03 \\u521D\\u4E8C"},
1612         {"mixed", "\\u521D\\u4E03 \\u521D\\u4E8C"}
1613 };
1614
1615 static void TestOverrideNumberFormat(void) {
1616     UErrorCode status = U_ZERO_ERROR;
1617     UChar pattern[50];
1618     UChar expected[50];
1619     UChar fields[50];
1620     char bbuf1[kBbufMax];
1621     char bbuf2[kBbufMax];
1622     const char* localeString = "zh@numbers=hanidays";
1623     UDateFormat* fmt;
1624     const UNumberFormat* getter_result;
1625     int32_t i;
1626
1627     u_uastrcpy(fields, "d");
1628     u_uastrcpy(pattern,"MM d");
1629
1630     fmt=udat_open(UDAT_PATTERN, UDAT_PATTERN, "en_US", zoneGMT, -1, pattern, u_strlen(pattern), &status);
1631     if (!assertSuccess("udat_open()", &status)) {
1632         return;
1633     }
1634
1635     // loop 5 times to check getter/setter
1636     for (i = 0; i < 5; i++){
1637         UNumberFormat* overrideFmt;
1638         overrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
1639         assertSuccess("unum_open()", &status);
1640         udat_adoptNumberFormatForFields(fmt, fields, overrideFmt, &status);
1641         overrideFmt = NULL; // no longer valid
1642         assertSuccess("udat_setNumberFormatForField()", &status);
1643
1644         getter_result = udat_getNumberFormatForField(fmt, 0x0064 /*'d'*/);
1645         if(getter_result == NULL) {
1646             log_err("FAIL: udat_getNumberFormatForField did not return a valid pointer\n");
1647         }
1648     }
1649     {
1650       UNumberFormat* overrideFmt;
1651       overrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
1652       assertSuccess("unum_open()", &status);
1653       udat_setNumberFormat(fmt, overrideFmt); // test the same override NF will not crash
1654       unum_close(overrideFmt);
1655     }
1656     udat_close(fmt);
1657
1658     for (i=0; i<UPRV_LENGTHOF(overrideNumberFormat); i++){
1659         UChar ubuf[kUbufMax];
1660         UDateFormat* fmt2;
1661         UNumberFormat* overrideFmt2;
1662
1663         fmt2 =udat_open(UDAT_PATTERN, UDAT_PATTERN,"en_US", zoneGMT, -1, pattern, u_strlen(pattern), &status);
1664         assertSuccess("udat_open() with en_US", &status);
1665
1666         overrideFmt2 = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
1667         assertSuccess("unum_open() in loop", &status);
1668
1669         u_uastrcpy(fields, overrideNumberFormat[i][0]);
1670         u_unescape(overrideNumberFormat[i][1], expected, UPRV_LENGTHOF(expected));
1671
1672         if ( strcmp(overrideNumberFormat[i][0], "") == 0 ) { // use the one w/o field
1673             udat_adoptNumberFormat(fmt2, overrideFmt2);
1674         } else if ( strcmp(overrideNumberFormat[i][0], "mixed") == 0 ) { // set 1 field at first but then full override, both(M & d) should be override
1675             const char* singleLocale = "en@numbers=hebr";
1676             UNumberFormat* singleOverrideFmt;
1677             u_uastrcpy(fields, "d");
1678
1679             singleOverrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, singleLocale, NULL, &status);
1680             assertSuccess("unum_open() in mixed", &status);
1681
1682             udat_adoptNumberFormatForFields(fmt2, fields, singleOverrideFmt, &status);
1683             assertSuccess("udat_setNumberFormatForField() in mixed", &status);
1684
1685             udat_adoptNumberFormat(fmt2, overrideFmt2);
1686         } else if ( strcmp(overrideNumberFormat[i][0], "do") == 0 ) { // o is an invalid field
1687             udat_adoptNumberFormatForFields(fmt2, fields, overrideFmt2, &status);
1688             if(status == U_INVALID_FORMAT_ERROR) {
1689                 udat_close(fmt2);
1690                 status = U_ZERO_ERROR;
1691                 continue;
1692             }
1693         } else {
1694             udat_adoptNumberFormatForFields(fmt2, fields, overrideFmt2, &status);
1695             assertSuccess("udat_setNumberFormatForField() in loop", &status);
1696         }
1697
1698         udat_format(fmt2, july022008, ubuf, kUbufMax, NULL, &status);
1699         assertSuccess("udat_format() july022008", &status);
1700
1701         if (u_strncmp(ubuf, expected, kUbufMax) != 0)
1702             log_err("fail: udat_format for locale, expected %s, got %s\n",
1703                     u_austrncpy(bbuf1,expected,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
1704
1705         udat_close(fmt2);
1706     }
1707 }
1708
1709 /*
1710  * Ticket #11523
1711  * udat_parse and udat_parseCalendar should have the same error code when given the same invalid input.
1712  */
1713 static void TestParseErrorReturnValue(void) {
1714     UErrorCode status = U_ZERO_ERROR;
1715     UErrorCode expectStatus = U_PARSE_ERROR;
1716     UDateFormat* df;
1717     UCalendar* cal;
1718
1719     df = udat_open(UDAT_DEFAULT, UDAT_DEFAULT, NULL, NULL, -1, NULL, -1, &status);
1720     if (!assertSuccessCheck("udat_open()", &status, TRUE)) {
1721         return;
1722     }
1723
1724     cal = ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status);
1725     if (!assertSuccess("ucal_open()", &status)) {
1726         return;
1727     }
1728
1729     udat_parse(df, NULL, -1, NULL, &status);
1730     if (status != expectStatus) {
1731         log_err("%s should have been returned by udat_parse when given an invalid input, instead got - %s\n", u_errorName(expectStatus), u_errorName(status));
1732     }
1733
1734     status = U_ZERO_ERROR;
1735     udat_parseCalendar(df, cal, NULL, -1, NULL, &status);
1736     if (status != expectStatus) {
1737         log_err("%s should have been returned by udat_parseCalendar when given an invalid input, instead got - %s\n", u_errorName(expectStatus), u_errorName(status));
1738     }
1739
1740     ucal_close(cal);
1741     udat_close(df);
1742 }
1743
1744 /*
1745  * Ticket #11553
1746  * Test new udat_formatForFields, udat_formatCalendarForFields (and UFieldPositionIterator)
1747  */
1748 static const char localeForFields[] = "en_US";
1749 /* zoneGMT[]defined above */
1750 static const UDate date2015Feb25 = 1424841000000.0; /* Wednesday, February 25, 2015 at 5:10:00 AM GMT */
1751 static const UChar patNoFields[] = { 0x0027, 0x0078, 0x0078, 0x0078, 0x0027, 0 }; /* "'xxx'" */
1752
1753 typedef struct {
1754     int32_t field;
1755     int32_t beginPos;
1756     int32_t endPos;
1757 } FieldsData;
1758 static const FieldsData expectedFields[] = {
1759     { UDAT_DAY_OF_WEEK_FIELD /* 9*/,      0,  9 },
1760     { UDAT_MONTH_FIELD /* 2*/,           11, 19 },
1761     { UDAT_DATE_FIELD /* 3*/,            20, 22 },
1762     { UDAT_YEAR_FIELD /* 1*/,            24, 28 },
1763     { UDAT_HOUR1_FIELD /*15*/,           32, 33 },
1764 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
1765     { UDAT_TIME_SEPARATOR_FIELD /*35*/,  33, 34 },
1766 #endif
1767     { UDAT_MINUTE_FIELD /* 6*/,          34, 36 },
1768 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
1769     { UDAT_TIME_SEPARATOR_FIELD /*35*/,  36, 37 },
1770 #endif
1771     { UDAT_SECOND_FIELD /* 7*/,          37, 39 },
1772     { UDAT_AM_PM_FIELD /*14*/,           40, 42 },
1773     { UDAT_TIMEZONE_FIELD /*17*/,        43, 46 },
1774     { -1,                                -1, -1 },
1775 };
1776
1777 enum {kUBufFieldsLen = 128, kBBufFieldsLen = 256 };
1778
1779 static void TestFormatForFields(void) {
1780     UErrorCode status = U_ZERO_ERROR;
1781     UFieldPositionIterator* fpositer = ufieldpositer_open(&status);
1782     if ( U_FAILURE(status) ) {
1783         log_err("ufieldpositer_open fails, status %s\n", u_errorName(status));
1784     } else {
1785         UDateFormat* udfmt = udat_open(UDAT_LONG, UDAT_FULL, localeForFields, zoneGMT, -1, NULL, 0, &status);
1786         UCalendar* ucal = ucal_open(zoneGMT, -1, localeForFields, UCAL_DEFAULT, &status);
1787         if ( U_FAILURE(status) ) {
1788             log_data_err("udat_open or ucal_open fails for locale %s, status %s (Are you missing data?)\n", localeForFields, u_errorName(status));
1789         } else {
1790             int32_t ulen, field, beginPos, endPos;
1791             UChar ubuf[kUBufFieldsLen];
1792             const FieldsData * fptr;
1793
1794             status = U_ZERO_ERROR;
1795             ulen = udat_formatForFields(udfmt, date2015Feb25, ubuf, kUBufFieldsLen, fpositer, &status);
1796             if ( U_FAILURE(status) ) {
1797                 log_err("udat_formatForFields fails, status %s\n", u_errorName(status));
1798             } else {
1799                 for (fptr = expectedFields; ; fptr++) {
1800                     field = ufieldpositer_next(fpositer, &beginPos, &endPos);
1801                     if (field != fptr->field || (field >= 0 && (beginPos != fptr->beginPos || endPos != fptr->endPos))) {
1802                         if (fptr->field >= 0) {
1803                             log_err("udat_formatForFields as \"%s\"; expect field %d range %d-%d, get field %d range %d-%d\n",
1804                                     aescstrdup(ubuf, ulen), fptr->field, fptr->beginPos, fptr->endPos, field, beginPos, endPos);
1805                         } else {
1806                             log_err("udat_formatForFields as \"%s\"; expect field < 0, get field %d range %d-%d\n",
1807                                     aescstrdup(ubuf, ulen), field, beginPos, endPos);
1808                         }
1809                         break;
1810                     }
1811                     if (field < 0) {
1812                         break;
1813                     }
1814                 }
1815             }
1816
1817             ucal_setMillis(ucal, date2015Feb25, &status);
1818             status = U_ZERO_ERROR;
1819             ulen = udat_formatCalendarForFields(udfmt, ucal, ubuf, kUBufFieldsLen, fpositer, &status);
1820             if ( U_FAILURE(status) ) {
1821                 log_err("udat_formatCalendarForFields fails, status %s\n", u_errorName(status));
1822             } else {
1823                 for (fptr = expectedFields; ; fptr++) {
1824                     field = ufieldpositer_next(fpositer, &beginPos, &endPos);
1825                     if (field != fptr->field || (field >= 0 && (beginPos != fptr->beginPos || endPos != fptr->endPos))) {
1826                         if (fptr->field >= 0) {
1827                             log_err("udat_formatFudat_formatCalendarForFieldsorFields as \"%s\"; expect field %d range %d-%d, get field %d range %d-%d\n",
1828                                     aescstrdup(ubuf, ulen), fptr->field, fptr->beginPos, fptr->endPos, field, beginPos, endPos);
1829                         } else {
1830                             log_err("udat_formatCalendarForFields as \"%s\"; expect field < 0, get field %d range %d-%d\n",
1831                                     aescstrdup(ubuf, ulen), field, beginPos, endPos);
1832                         }
1833                         break;
1834                     }
1835                     if (field < 0) {
1836                         break;
1837                     }
1838                 }
1839             }
1840
1841             udat_applyPattern(udfmt, FALSE, patNoFields, -1);
1842             status = U_ZERO_ERROR;
1843             ulen = udat_formatForFields(udfmt, date2015Feb25, ubuf, kUBufFieldsLen, fpositer, &status);
1844             if ( U_FAILURE(status) ) {
1845                 log_err("udat_formatForFields with no-field pattern fails, status %s\n", u_errorName(status));
1846             } else {
1847                 field = ufieldpositer_next(fpositer, &beginPos, &endPos);
1848                 if (field >= 0) {
1849                     log_err("udat_formatForFields with no-field pattern as \"%s\"; expect field < 0, get field %d range %d-%d\n",
1850                             aescstrdup(ubuf, ulen), field, beginPos, endPos);
1851                 }
1852             }
1853
1854             ucal_close(ucal);
1855             udat_close(udfmt);
1856         }
1857         ufieldpositer_close(fpositer);
1858     }
1859 }
1860
1861 #endif /* #if !UCONFIG_NO_FORMATTING */