Update ICU to 54.1 step 1

source/test/intltest/dtfmrgts.cpp

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2012, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
-
 #include "dtfmrgts.h"
 
 #include "unicode/timezone.h"
 #include "unicode/gregocal.h"
 #include "unicode/smpdtfmt.h"
 #include "unicode/datefmt.h"
 #include "unicode/simpletz.h"
 #include "unicode/resbund.h"
 
 // *****************************************************************************
@@ skipping 29 matching lines @@
         CASE(19,Test4151631)
         CASE(20,Test4151706)
         CASE(21,Test4162071)
         CASE(22,Test4182066)
         CASE(23,Test4210209)
         CASE(24,Test714)
         CASE(25,Test1684)
         CASE(26,Test5554)
         CASE(27,Test9237)
         CASE(28,TestParsing)
+        CASE(29,TestT10334)
+        CASE(30,TestT10619)
+        CASE(31,TestT10855)
+        CASE(32,TestT10906)
         default: name = ""; break;
     }
 }
 
 /**
  * @bug 4029195
  */
 void DateFormatRegressionTest::Test4029195(void) 
 {
     UErrorCode status = U_ZERO_ERROR;
 
     UDate today = Calendar::getNow();
     logln((UnicodeString) "today: " + today);
 
     SimpleDateFormat *sdf = (SimpleDateFormat*) DateFormat::createDateInstance();
     if (failure(status, "SimpleDateFormat::createDateInstance")) {
         return;
     }
     UnicodeString pat;
     if(sdf == NULL){
         dataerrln("Error calling DateFormat::createDateTimeInstance");
         return;
     }
 
     pat = sdf->toPattern(pat);
     logln("pattern: " + pat);
     UnicodeString fmtd;
+
     FieldPosition pos(FieldPosition::DONT_CARE);
     fmtd = sdf->format(today, fmtd, pos);
     logln("today: " + fmtd);
 
     sdf->applyPattern("G yyyy DDD");
     UnicodeString todayS;
     todayS = sdf->format(today, todayS, pos);
     logln("today: " + todayS);
     //try {
         today = sdf->parse(todayS, status);
@@ skipping 1421 matching lines @@
     ParsePosition pos(0);
     format.parse(text, *cal, pos);
 
     if (cal->get(UCAL_DAY_OF_MONTH, status) != expectedDay) {
         errln("Parsing failed: day of month should be '7' with pattern: \"" + pattern + "\" for text: \"" + text + "\"");
     }
 
     delete cal;
 }
 
+void DateFormatRegressionTest::TestT10334(void) {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString pattern("--: EEE-WW-MMMM-yyyy");
+    UnicodeString text("--mon-02-march-2011");
+    SimpleDateFormat format(pattern, status);
+
+    logln("pattern["+pattern+"] text["+text+"]");
+
+    if (U_FAILURE(status)) {
+        dataerrln("Fail creating SimpleDateFormat object - %s", u_errorName(status));
+        return;
+    }
+
+    format.setBooleanAttribute(UDAT_PARSE_PARTIAL_MATCH, FALSE, status);
+    format.parse(text, status);
+    if (!U_FAILURE(status)) {
+        errln("parse partial match did NOT fail in strict mode - %s", u_errorName(status));
+    }
+
+    status = U_ZERO_ERROR;
+    format.setBooleanAttribute(UDAT_PARSE_PARTIAL_MATCH, TRUE, status);
+    format.parse(text, status);
+    if (U_FAILURE(status)) {
+        errln("parse partial match failure in lenient mode - %s", u_errorName(status));
+    }
+
+    status = U_ZERO_ERROR;
+    pattern = UnicodeString("YYYY MM dd");
+    text =    UnicodeString("2013 12 10");
+    format.applyPattern(pattern);
+    UDate referenceDate = format.parse(text, status);
+
+    FieldPosition fp(0);
+    UnicodeString formattedString("");
+    pattern = UnicodeString("YYYY LL dd ee cc qq QQ");
+    format.applyPattern(pattern);
+    format.format(referenceDate, formattedString, fp, status);
+    logln("ref date: " + formattedString);
+
+
+    char patternArray[] = "YYYY LLL dd eee ccc qqq QQQ";
+    pattern = UnicodeString(patternArray);
+    text = UnicodeString("2013 12 10 03 3 04 04");
+    status = U_ZERO_ERROR;
+    format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, TRUE, status);
+    format.applyPattern(pattern);
+    ParsePosition pp(0);
+    format.parse(text, pp);
+    if (pp.getErrorIndex() != -1) {
+        errln("numeric parse error");
+    }
+
+    status = U_ZERO_ERROR;
+    format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, FALSE, status);
+    format.parse(text, status);
+    if (!U_FAILURE(status)) {
+        errln("numeric parse did NOT fail in strict mode", u_errorName(status));
+    }
+
+}
+
+
+typedef struct {
+    const char * locale;
+    UBool leniency;
+    UnicodeString parseString;
+    UnicodeString pattern;
+    UnicodeString expectedResult;       // null indicates expected error
+} TestDateFormatLeniencyItem;
+
+
+void DateFormatRegressionTest::TestT10619(void) {
+    const UDate july022008 = 1215000001979.0;
+    const TestDateFormatLeniencyItem items[] = {
+        //locale    leniency    parse String                    pattern                             expected result
+        { "en",     true,       UnicodeString("2008-07 02"),    UnicodeString("yyyy-LLLL dd"),      UnicodeString("2008-July 02") },
+        { "en",     false,      UnicodeString("2008-07 03"),    UnicodeString("yyyy-LLLL dd"),      UnicodeString("") },
+        { "en",     true,       UnicodeString("2008-Jan. 04"),  UnicodeString("yyyy-LLL dd"),       UnicodeString("2008-Jan 04") },
+        { "en",     false,      UnicodeString("2008-Jan. 05"),  UnicodeString("yyyy-LLL dd"),       UnicodeString("") },
+        { "en",     true,       UnicodeString("2008-Jan--06"),  UnicodeString("yyyy-MMM -- dd"),    UnicodeString("2008-Jan 06") },
+        { "en",     false,      UnicodeString("2008-Jan--07"),  UnicodeString("yyyy-MMM -- dd"),    UnicodeString("") },
+        { "en",     true,       UnicodeString("6 Jan 08 2008"), UnicodeString("eee MMM dd yyyy"),   UnicodeString("Sat Jan 08 2008") },
+        { "en",     false,      UnicodeString("6 Jan 09 2008"), UnicodeString("eee MMM dd yyyy"),   UnicodeString("") },
+        // terminator
+        { NULL,     true,       UnicodeString(""),              UnicodeString(""),                  UnicodeString("") }                
+    };
+    UErrorCode status = U_ZERO_ERROR;
+    Calendar* cal = Calendar::createInstance(status);
+    if (U_FAILURE(status)) {
+        dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale."));
+    } else {
+        cal->setTime(july022008, status);
+        const TestDateFormatLeniencyItem * itemPtr;
+        for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) {
+                                            
+            Locale locale = Locale::createFromName(itemPtr->locale);
+            status = U_ZERO_ERROR;
+            ParsePosition pos(0);
+            SimpleDateFormat * sdmft = new SimpleDateFormat(itemPtr->pattern, locale, status);
+            if (U_FAILURE(status)) {
+                dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status));
+                continue;
+            }
+            logln("parsing " + itemPtr->parseString);
+            sdmft->setLenient(itemPtr->leniency);
+            sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->leniency, status);
+            sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->leniency, status);
+            sdmft->setBooleanAttribute(UDAT_PARSE_PARTIAL_MATCH, itemPtr->leniency, status);
+            sdmft->parse(itemPtr->parseString, pos);
+
+            delete sdmft;
+            if(pos.getErrorIndex() > -1) {
+                if(itemPtr->expectedResult.length() != 0) {
+                   errln("error: unexpected error - " + itemPtr->parseString + " - error index " + pos.getErrorIndex() +
+                           " - leniency " + itemPtr->leniency);
+                   continue;
+                } else {
+                   continue;
+                }
+            }
+        }
+    }
+    delete cal;
+
+}
+
+
+typedef struct {
+    UnicodeString text;
+    UnicodeString pattern;
+    int initialParsePos;
+} T10855Data;
+    
+void DateFormatRegressionTest::TestT10855(void) {
+    // NOTE: these should NOT parse
+    const T10855Data items[] = {
+        //parse String                          pattern                         initial parse pos
+        { UnicodeString("September 30, 1998"),  UnicodeString("MM-dd-yyyy"),    0},
+        { UnicodeString("123-73-1950"),         UnicodeString("MM-dd-yyyy"),    -1},
+        { UnicodeString("12-23-1950"),          UnicodeString("MM-dd-yyyy"),    -1},
+        // terminator
+        { UnicodeString(""),                    UnicodeString(""),              0}                
+    };
+    UErrorCode status = U_ZERO_ERROR;
+
+    int x = 0;
+    while(items[x].pattern.length() > 0)
+    {
+        status = U_ZERO_ERROR;
+        logln("Date to parse: \""+items[x].text+"\"");
+        logln("Starting Index: %d", items[x].initialParsePos);
+
+        SimpleDateFormat dateFmt(items[x].pattern, status);
+        if(U_FAILURE(status)) { 
+            errcheckln(status, "Failed dateFmt: %s", u_errorName(status));
+            ++x;
+            continue;
+        } 
+        status = U_ZERO_ERROR;  
+
+        dateFmt.setLenient(false);
+        dateFmt.setTimeZone(*TimeZone::getGMT());
+
+        ParsePosition position(items[x].initialParsePos);
+        logln("set position is now: %d", position.getIndex());
+        UDate d = dateFmt.parse(items[x].text, position);
+        if (position.getErrorIndex() != -1 || position.getIndex() == items[x].initialParsePos) {
+            logln("Parse Failed. ErrorIndex is %d - Index is %d", position.getErrorIndex(), position.getIndex());
+        } else {
+            errln("Parse Succeeded...should have failed. Index is %d - ErrorIndex is %d", position.getIndex(), position.getErrorIndex());
+        }
+        logln("Parsed date returns %d\n", d);
+
+        ++x;
+    }
+}
+
+void DateFormatRegressionTest::TestT10906(void) {
+
+      UErrorCode status = U_ZERO_ERROR;
+      UnicodeString pattern = "MM-dd-yyyy";
+      UnicodeString text = "06-10-2014";
+      SimpleDateFormat format(pattern, status);
+      int32_t errorIdx = 0;
+      ParsePosition pp(-1);
+      format.parse(text, pp);
+      errorIdx = pp.getErrorIndex();
+      if (errorIdx == -1) {          
+          errln("failed to report invalid (negative) starting parse position");
+      }
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof