Home | History | Annotate | Download | only in cintltst 
      1 //  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-2014, International Business Machines Corporation and
      6  * others. All Rights Reserved.
      7  ********************************************************************/
      8 /********************************************************************************
      9 *
     10 * File CDTDPTST.C
     11 *
     12 * Modification History:
     13 *        Name                     Description
     14 *     Madhu Katragadda               Creation
     15 *********************************************************************************
     16 */
     17 /* INDEPTH TEST FOR DATE FORMAT */
     18 
     19 #include "unicode/utypes.h"
     20 
     21 #if !UCONFIG_NO_FORMATTING
     22 
     23 #include "unicode/uloc.h"
     24 #include "unicode/udat.h"
     25 #include "unicode/ucal.h"
     26 #include "unicode/unum.h"
     27 #include "unicode/ustring.h"
     28 #include "cintltst.h"
     29 #include "cdtdptst.h"
     30 #include "cformtst.h"
     31 
     32 #include "cmemory.h"
     33 
     34 void addDtFrDepTest(TestNode** root);
     35 
     36 void addDtFrDepTest(TestNode** root)
     37 {
     38     addTest(root, &TestTwoDigitYearDSTParse, "tsformat/cdtdptst/TestTwoDigitYearDSTParse");
     39     addTest(root, &TestPartialParse994, "tsformat/cdtdptst/TestPartialParse994");
     40     addTest(root, &TestRunTogetherPattern985, "tsformat/cdtdptst/TestRunTogetherPattern985");
     41     addTest(root, &TestCzechMonths459, "tsformat/cdtdptst/TestCzechMonths459");
     42     addTest(root, &TestQuotePattern161, "tsformat/cdtdptst/TestQuotePattern161");
     43     addTest(root, &TestBooleanAttributes, "tsformat/cdtdptst/TestBooleanAttributes");
     44 
     45 
     46 }
     47 
     48 /**
     49  * Test the parsing of 2-digit years.
     50  */
     51 void TestTwoDigitYearDSTParse()
     52 {
     53     UDateFormat *fullFmt, *fmt;
     54     UErrorCode status = U_ZERO_ERROR;
     55     UChar *pattern;
     56     UDate d;
     57     UChar *s;
     58     int32_t pos;
     59 
     60     ctest_setTimeZone(NULL, &status);
     61 
     62     pattern=(UChar*)malloc(sizeof(UChar) * (strlen("EEE MMM dd HH:mm:ss.SSS zzz yyyy G")+1 ));
     63     u_uastrcpy(pattern, "EEE MMM dd HH:mm:ss.SSS zzz yyyy G");
     64     fullFmt= udat_open(UDAT_PATTERN, UDAT_PATTERN,"en_US",NULL,0,pattern, u_strlen(pattern),&status);
     65     if(U_FAILURE(status))    {
     66         log_data_err("FAIL: Error in creating a date format using udat_openPattern %s - (Are you missing data?)\n",
     67             myErrorName(status) );
     68     }
     69     else {
     70         log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
     71 
     72         u_uastrcpy(pattern, "dd-MMM-yy h:mm:ss 'o''clock' a z");
     73         fmt= udat_open(UDAT_PATTERN,UDAT_PATTERN,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
     74 
     75 
     76         s=(UChar*)malloc(sizeof(UChar) * (strlen("03-Apr-04 2:20:47 o'clock AM PST")+1) );
     77         u_uastrcpy(s, "03-Apr-04 2:20:47 o'clock AM PST");
     78         pos=0;
     79         d = udat_parse(fmt, s, u_strlen(s), &pos, &status);
     80         if (U_FAILURE(status)) {
     81             log_err("FAIL: Could not parse \"%s\"\n", austrdup(s));
     82         } else {
     83             UCalendar *cal = ucal_open(NULL, 0, uloc_getDefault(), UCAL_TRADITIONAL, &status);
     84             if (U_FAILURE(status)) {
     85                 log_err_status(status, "FAIL: Could not open calendar: %s\n", u_errorName(status));
     86             } else {
     87                 int32_t h;
     88                 ucal_setMillis(cal, d, &status);
     89                 h = ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
     90                 if (U_FAILURE(status)) {
     91                     log_err("FAIL: Some calendar operations failed");
     92                 } else if (h != 2) {
     93                     log_err("FAIL: Parse of \"%s\" returned HOUR_OF_DAY %d\n",
     94                             austrdup(s), h);
     95                 }
     96                 ucal_close(cal);
     97             }
     98         }
     99 
    100         udat_close(fullFmt);
    101         udat_close(fmt);
    102         free(s);
    103     }
    104     free(pattern);
    105 
    106     ctest_resetTimeZone();
    107 }
    108 
    109 
    110 /**
    111  * Verify that strings which contain incomplete specifications are parsed
    112  * correctly.  In some instances, this means not being parsed at all, and
    113  * returning an appropriate error.
    114  */
    115 void TestPartialParse994()
    116 {
    117     int32_t pos;
    118     UDateFormat *f;
    119     UErrorCode status = U_ZERO_ERROR;
    120     UChar *s;
    121     UChar *fmtChars;
    122     UDate d, null;
    123     null=0;
    124 
    125     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
    126        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
    127     /* f = udat_open(UDAT_DEFAULT, UDAT_SHORT, NULL, NULL, 0, &status); */
    128     f = udat_open(UDAT_DEFAULT, UDAT_SHORT, "en_US", NULL, 0,  NULL, 0,&status);
    129     if(U_FAILURE(status)){
    130         log_data_err("FAIL: ErrorCode received during test: %s (Are you missing data?)\n", myErrorName(status));
    131         return;
    132     }
    133     s=(UChar*)malloc(sizeof(UChar) * (strlen("01/01/1997 10:11:42 AM")+1) );
    134     u_uastrcpy(s, "01/01/1997 10:11:42 AM");
    135     pos=0;
    136     d = udat_parse(f, s, u_strlen(s), &pos, &status);
    137     if(U_FAILURE(status)) {
    138       log_data_err("FAIL: could not parse - exitting");
    139       return;
    140     }
    141     fmtChars = myDateFormat(f, d);
    142     if(fmtChars) {
    143       log_verbose("%s\n", fmtChars);
    144     } else {
    145       log_data_err("FAIL: could not format \n");
    146       return;
    147     }
    148     tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10:11:42", d);
    149     tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10:", null);
    150     tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10", null);
    151     tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 ", null);
    152     tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01", null);
    153     udat_close(f);
    154     free(s);
    155 }
    156 
    157 
    158 
    159 void tryPat994(UDateFormat* format, const char* pattern, const char* s, UDate expected)
    160 {
    161     UChar *f;
    162     UChar *str, *pat;
    163     UDate date;
    164     UDate null=0;
    165     int32_t pos;
    166     UErrorCode status = U_ZERO_ERROR;
    167     str=(UChar*)malloc(sizeof(UChar) * (strlen(s) + 1) );
    168     u_uastrcpy(str, s);
    169     pat=(UChar*)malloc(sizeof(UChar) * (strlen(pattern) + 1) );
    170     u_uastrcpy(pat, pattern);
    171     log_verbose("Pattern : %s ;  String : %s\n", austrdup(pat), austrdup(str));
    172     udat_applyPattern(format, FALSE, pat, u_strlen(pat));
    173     pos=0;
    174     date = udat_parse(format, str, u_strlen(str), &pos, &status);
    175     if(U_FAILURE(status) || date == null) {
    176         log_verbose("ParseException: : %s\n", myErrorName(status) );
    177          if (expected != null)
    178              log_err("FAIL: Expected: %s\n", austrdup(myDateFormat(format, expected)) );
    179         }
    180     else {
    181         f=myDateFormat(format, date);
    182         log_verbose(" parse( %s ) -> %s\n", austrdup(str), austrdup(f));
    183         if (expected == null || date != expected)
    184             log_err("FAIL: Expected null for \"%s\"\n", s);
    185         if (u_strcmp(f, str) !=0)
    186             log_err("FAIL: Expected : %s\n", austrdup(str) );
    187     }
    188 
    189     free(str);
    190     free(pat);
    191 }
    192 
    193 
    194 /**
    195  * Verify the behavior of patterns in which digits for different fields run together
    196  * without intervening separators.
    197  */
    198 void TestRunTogetherPattern985()
    199 {
    200     int32_t pos;
    201     UChar *pattern=NULL, *now=NULL, *then=NULL;
    202     UDateFormat *format;
    203     UDate date1, date2;
    204     UErrorCode status = U_ZERO_ERROR;
    205     pattern=(UChar*)malloc(sizeof(UChar) * (strlen("yyyyMMddHHmmssSSS")+1) );
    206     u_uastrcpy(pattern, "yyyyMMddHHmmssSSS");
    207     format = udat_open(UDAT_PATTERN, UDAT_PATTERN, NULL, NULL, 0,pattern, u_strlen(pattern), &status);
    208     if(U_FAILURE(status)){
    209         log_data_err("FAIL: Error in date format construction with pattern: %s - (Are you missing data?)\n", myErrorName(status));
    210         return;
    211     }
    212     date1 = ucal_getNow();
    213     now=myDateFormat(format, date1);
    214     log_verbose("%s\n", austrdup(now) );
    215     pos = 0;
    216     date2 = udat_parse(format, now, u_strlen(now), &pos, &status);
    217     if (date2 == 0) log_verbose("Parse stopped at : %d\n", pos);
    218     else then=myDateFormat(format, date2);
    219     log_verbose("%s\n", austrdup(then) );
    220     if (!(date2 == date1)) log_err("FAIL\n");
    221 
    222     udat_close(format);
    223     free(pattern);
    224 
    225 }
    226 
    227 /**
    228  * Verify the handling of Czech June and July, which have the unique attribute that
    229  * one is a proper prefix substring of the other.
    230  */
    231 void TestCzechMonths459()
    232 {
    233     int32_t lneed, pos;
    234     UChar *pattern=NULL, *tzID=NULL;
    235     UChar *juneStr, *julyStr;
    236     UDateFormat *fmt;
    237     UCalendar *cal;
    238     UDate june, july, d;
    239     UErrorCode status = U_ZERO_ERROR;
    240     UChar *date;
    241 
    242     ctest_setTimeZone(NULL, &status);
    243     fmt = udat_open(UDAT_FULL, UDAT_FULL, "cs", NULL, 0, NULL, 0, &status);
    244     if(U_FAILURE(status)){
    245         log_data_err("Error in constructing the date format -> %s (Are you missing data?)\n", u_errorName(status));
    246         ctest_resetTimeZone();
    247         return;
    248     }
    249     lneed=0;
    250     lneed=udat_toPattern(fmt, TRUE, NULL, lneed, &status);
    251     if(status==U_BUFFER_OVERFLOW_ERROR){
    252         status=U_ZERO_ERROR;
    253         pattern=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
    254         udat_toPattern(fmt, TRUE, pattern, lneed+1, &status);
    255     }
    256     if(U_FAILURE(status)){ log_err("Error in extracting the pattern\n"); }
    257     tzID=(UChar*)malloc(sizeof(UChar) * 4);
    258     u_uastrcpy(tzID, "GMT");
    259     cal=ucal_open(tzID, u_strlen(tzID), "cs", UCAL_GREGORIAN, &status);
    260     if(U_FAILURE(status)){ log_err("error in ucal_open caldef : %s\n", myErrorName(status));    }
    261 
    262     ucal_setDate(cal, 1997, UCAL_JUNE, 15, &status);
    263     june=ucal_getMillis(cal, &status);
    264     ucal_setDate(cal, 1997, UCAL_JULY, 15, &status);
    265     july=ucal_getMillis(cal, &status);
    266 
    267     juneStr = myDateFormat(fmt, june);
    268     julyStr = myDateFormat(fmt, july);
    269     pos=0;
    270     if(juneStr == NULL) {
    271       log_data_err("Can't load juneStr. Quitting.\n");
    272       return;
    273     }
    274     d = udat_parse(fmt, juneStr, u_strlen(juneStr), &pos, &status);
    275     date = myDateFormat(fmt, d);
    276 
    277     if(U_SUCCESS(status)){
    278         UChar* out1 = myDateFormat(fmt, june);
    279         UChar* out2 = myDateFormat(fmt, d);
    280         if(u_strcmp(out1, out2) !=0)
    281             log_err("Error in handling the czech month june\n");
    282         else
    283             log_verbose("Pass: Date = %s (czech month June)\n", aescstrdup(date, -1));
    284     }else{
    285         log_err("udat_parse failed. Error. %s\n",u_errorName(status));
    286     }
    287     pos=0;
    288     d = udat_parse(fmt, julyStr, u_strlen(julyStr), &pos, &status);
    289     date = myDateFormat(fmt, d);
    290     if(u_strcmp(myDateFormat(fmt, july), myDateFormat(fmt, d) ) !=0)
    291         log_err("Error in handling the czech month july\n");
    292     else
    293         log_verbose("Pass: Date = %s (czech month July)\n", aescstrdup(date, -1));
    294 
    295     ctest_resetTimeZone();
    296     udat_close(fmt);
    297     ucal_close(cal);
    298     free(pattern);
    299     free(tzID);
    300 }
    301 
    302 /**
    303  * Test the handling of single quotes in patterns.
    304  */
    305 void TestQuotePattern161()
    306 {
    307     UDateFormat *format;
    308     UCalendar *cal;
    309     UDate currentTime_1;
    310     UChar *pattern, *tzID, *exp;
    311     UChar *dateString;
    312     UErrorCode status = U_ZERO_ERROR;
    313     const char* expStr = "04/13/1999 at 10:42:28 AM ";
    314 
    315     ctest_setTimeZone(NULL, &status);
    316 
    317     pattern=(UChar*)malloc(sizeof(UChar) * (strlen("MM/dd/yyyy 'at' hh:mm:ss a zzz")+1) );
    318     u_uastrcpy(pattern, "MM/dd/yyyy 'at' hh:mm:ss a zzz");
    319 
    320     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
    321        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
    322     /* format= udat_openPattern(pattern, u_strlen(pattern), NULL, &status); */
    323     format= udat_open(UDAT_PATTERN, UDAT_PATTERN,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
    324     if(U_FAILURE(status)){
    325         log_data_err("error in udat_open: %s - (Are you missing data?)\n", myErrorName(status));
    326         return;
    327     }
    328     tzID=(UChar*)malloc(sizeof(UChar) * 4);
    329     u_uastrcpy(tzID, "PST");
    330     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
    331        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
    332     /* cal=ucal_open(tzID, u_strlen(tzID), NULL, UCAL_TRADITIONAL, &status); */
    333     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
    334     if(U_FAILURE(status)){ log_err("error in ucal_open cal : %s\n", myErrorName(status));    }
    335 
    336     ucal_setDateTime(cal, 1999, UCAL_APRIL, 13, 10, 42, 28, &status);
    337     currentTime_1 = ucal_getMillis(cal, &status);
    338 
    339     dateString = myDateFormat(format, currentTime_1);
    340     exp=(UChar*)malloc(sizeof(UChar) * (strlen(expStr) + 1) );
    341     u_uastrcpy(exp, expStr);
    342 
    343     log_verbose("%s\n", austrdup(dateString) );
    344     if(u_strncmp(dateString, exp, (int32_t)strlen(expStr)) !=0)
    345         log_err("Error in formatting a pattern with single quotes\n");
    346 
    347     udat_close(format);
    348     ucal_close(cal);
    349     free(exp);
    350     free(tzID);
    351     free(pattern);
    352 
    353     ctest_resetTimeZone();
    354 }
    355 
    356 /*
    357  * Testing udat_getBooleanAttribute and  unum_setBooleanAttribute() to make sure basic C wrapper functionality is present
    358  */
    359 void TestBooleanAttributes(void)
    360 {
    361     UDateFormat *en;
    362     UErrorCode status=U_ZERO_ERROR;
    363     UBool initialState = TRUE;
    364     UBool switchedState = FALSE;
    365 
    366     log_verbose("\ncreating a date format with english locale\n");
    367     en = udat_open(UDAT_FULL, UDAT_DEFAULT, "en_US", NULL, 0, NULL, 0, &status);
    368     if(U_FAILURE(status)) {
    369         log_data_err("error in creating the dateformat -> %s (Are you missing data?)\n",
    370             myErrorName(status) );
    371         return;
    372     }
    373 
    374 
    375     initialState = udat_getBooleanAttribute(en, UDAT_PARSE_ALLOW_NUMERIC, &status);
    376     if(initialState != TRUE) switchedState = TRUE;  // if it wasn't the default of TRUE, then flip what we expect
    377 
    378     udat_setBooleanAttribute(en, UDAT_PARSE_ALLOW_NUMERIC, switchedState, &status);
    379     if(switchedState != udat_getBooleanAttribute(en, UDAT_PARSE_ALLOW_NUMERIC, &status)) {
    380         log_err("unable to switch states!");
    381         return;
    382     }
    383 
    384     udat_close(en);
    385 }
    386 
    387 #endif /* #if !UCONFIG_NO_FORMATTING */
    388