Update ICU to 54.1 step 1

source/test/intltest/dcfmapts.cpp

 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "dcfmapts.h"
 
 #include "unicode/currpinf.h"
 #include "unicode/dcfmtsym.h"
 #include "unicode/decimfmt.h"
 #include "unicode/fmtable.h"
 #include "unicode/localpointer.h"
 #include "unicode/parseerr.h"
 #include "unicode/stringpiece.h"
 
 #include "putilimp.h"
 #include "plurrule_impl.h"
 #include <stdio.h>
 
-#define LENGTHOF(array) ((int32_t)(sizeof(array)/sizeof((array)[0])))
-
 // This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
 // try to test the full functionality.  It just calls each function in the class and
 // verifies that it works on a basic level.
 
 void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
 {
     if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
     switch (index) {
-        case 0: name = "DecimalFormat API test"; 
+        case 0: name = "DecimalFormat API test";
                 if (exec) {
                     logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
                     UErrorCode status = U_ZERO_ERROR;
                     Locale saveLocale;
                     Locale::setDefault(Locale::getEnglish(), status);
                     if(U_FAILURE(status)) {
                         errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
                     }
                     testAPI(/*par*/);
                     Locale::setDefault(saveLocale, status);
@@ skipping 22 matching lines @@
                logln((UnicodeString)"Scale test---");
                TestScale();
             }
             break;
          case 5: name = "TestFixedDecimal";
             if(exec) {
                logln((UnicodeString)"TestFixedDecimal ---");
                TestFixedDecimal();
             }
             break;
+         case 6: name = "TestBadFastpath";
+            if(exec) {
+               logln((UnicodeString)"TestBadFastpath ---");
+               TestBadFastpath();
+            }
+            break;
+         case 7: name = "TestRequiredDecimalPoint";
+            if(exec) {
+               logln((UnicodeString)"TestRequiredDecimalPoint ---");
+               TestRequiredDecimalPoint();
+            }
+            break;
        default: name = ""; break;
     }
 }
 
 /**
  * This test checks various generic API methods in DecimalFormat to achieve 100%
  * API coverage.
  */
 void IntlTestDecimalFormatAPI::testAPI(/*char *par*/)
 {
     UErrorCode status = U_ZERO_ERROR;
 
 // ======= Test constructors
 
     logln((UnicodeString)"Testing DecimalFormat constructors");
 
     DecimalFormat def(status);
     if(U_FAILURE(status)) {
         errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
         return;
     }
 
+    // bug 10864
+    status = U_ZERO_ERROR;
+    DecimalFormat noGrouping("###0.##", status);
+    if (noGrouping.getGroupingSize() != 0) {
+      errln("Grouping size should be 0 for no grouping.");
+    }
+    // end bug 10864
+
     status = U_ZERO_ERROR;
     const UnicodeString pattern("#,##0.# FF");
     DecimalFormat pat(pattern, status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
         return;
     }
 
     status = U_ZERO_ERROR;
     DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
@@ skipping 39 matching lines @@
 
     logln((UnicodeString)"Testing various format() methods");
 
     double d = -10456.0037;
     int32_t l = 100000000;
     Formattable fD(d);
     Formattable fL(l);
 
     UnicodeString res1, res2, res3, res4;
     FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
-    
+
     res1 = def.format(d, res1, pos1);
     logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
 
     res2 = pat.format(l, res2, pos2);
     logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
 
     status = U_ZERO_ERROR;
     res3 = cust1.format(fD, res3, pos3, status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
@@ skipping 110 matching lines @@
         errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
     }
 
     // Added by Ken Liu testing set/isScientificNotation
     pat.setScientificNotation(TRUE);
     UBool sn = pat.isScientificNotation();
     logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
     if(sn != TRUE) {
         errln((UnicodeString)"ERROR: setScientificNotation() failed");
     }
-    
+
     // Added by Ken Liu testing set/getMinimumExponentDigits
     int8_t MinimumExponentDigits = 0;
     pat.setMinimumExponentDigits(2);
     MinimumExponentDigits = pat.getMinimumExponentDigits();
     logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
     if(MinimumExponentDigits != 2) {
         errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
     }
 
     // Added by Ken Liu testing set/getRoundingIncrement
@@ skipping 108 matching lines @@
 
     cpi->setCurrencyPluralPattern("","",status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPattern");
     }
 
     cpi->setLocale(Locale::getCanada(), status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale");
     }
-    
+
     cpi->setPluralRules("",status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules");
     }
 
     DecimalFormat *df = new DecimalFormat(status);
     if(U_FAILURE(status)) {
         errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
     }
 
@@ skipping 11 matching lines @@
     UErrorCode status = U_ZERO_ERROR;
     double Roundingnumber = 2.55;
     double Roundingnumber1 = -2.55;
                       //+2.55 results   -2.55 results
     double result[]={   3.0,            -2.0,    //  kRoundCeiling  0,
                         2.0,            -3.0,    //  kRoundFloor    1,
                         2.0,            -2.0,    //  kRoundDown     2,
                         3.0,            -3.0,    //  kRoundUp       3,
                         3.0,            -3.0,    //  kRoundHalfEven 4,
                         3.0,            -3.0,    //  kRoundHalfDown 5,
-                        3.0,            -3.0     //  kRoundHalfUp   6 
+                        3.0,            -3.0     //  kRoundHalfUp   6
     };
     DecimalFormat pat(status);
     if(U_FAILURE(status)) {
       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
       return;
     }
     uint16_t mode;
     uint16_t i=0;
     UnicodeString message;
     UnicodeString resultStr;
@@ skipping 46 matching lines @@
       return;
     }
 
     // get default rounding increment
     double roundingInc = pat.getRoundingIncrement();
     if (roundingInc != 0.0) {
       errln((UnicodeString)"ERROR: Rounding increment not zero");
       return;
     }
 
-    // With rounding now being handled by decNumber, we no longer 
+    // With rounding now being handled by decNumber, we no longer
     // set a rounding increment to enable non-default mode rounding,
     // checking of which was the original point of this test.
 
-    // set rounding mode with zero increment.  Rounding 
+    // set rounding mode with zero increment.  Rounding
     // increment should not be set by this operation
     pat.setRoundingMode((DecimalFormat::ERoundingMode)0);
     roundingInc = pat.getRoundingIncrement();
     if (roundingInc != 0.0) {
       errln((UnicodeString)"ERROR: Rounding increment not zero after setRoundingMode");
       return;
     }
 }
 
 void IntlTestDecimalFormatAPI::TestScale()
@@ skipping 20 matching lines @@
       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
       return;
     }
 
     UnicodeString message;
     UnicodeString resultStr;
     UnicodeString exp;
     UnicodeString percentPattern("#,##0%");
     pat.setMaximumFractionDigits(4);
 
-    for(int32_t i=0; i < LENGTHOF(testData); i++) {
+    for(int32_t i=0; i < UPRV_LENGTHOF(testData); i++) {
         if ( i > 2 ) {
             pat.applyPattern(percentPattern,status);
         }
         pat.setAttribute(UNUM_SCALE,testData[i].inputScale,status);
         pat.format(testData[i].inputValue, resultStr);
-        message = UnicodeString("Unexpected output for ") + testData[i].inputValue + UnicodeString(" and scale ") + 
+        message = UnicodeString("Unexpected output for ") + testData[i].inputValue + UnicodeString(" and scale ") +
                   testData[i].inputScale + UnicodeString(". Got: ");
         exp = testData[i].expectedOutput;
         verifyString(message, resultStr, exp);
         message.remove();
         resultStr.remove();
         exp.remove();
     }
 }
 
 
@@ skipping 205 matching lines @@
     // note: going through DigitList path to FixedDecimal, which is trimming
     //       int64_t fields to 18 digits. See ticket Ticket #10374
     // ASSERT_EQUAL(223372036854775807LL, fd.intValue);
     if (!(fd.intValue == 223372036854775807LL || fd.intValue == 9223372036854775807LL)) {
         dataerrln("File %s, Line %d, fd.intValue = %lld", __FILE__, __LINE__, fd.intValue);
     }
     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
 }
-    
+
+void IntlTestDecimalFormatAPI::TestBadFastpath() {
+    UErrorCode status = U_ZERO_ERROR;
+
+    LocalPointer<DecimalFormat> df(new DecimalFormat("###", status));
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
+        return;
+    }
+
+    UnicodeString fmt;
+    fmt.remove();
+    assertEquals("Format 1234", "1234", df->format(1234, fmt));
+    df->setGroupingUsed(FALSE);
+    fmt.remove();
+    assertEquals("Format 1234", "1234", df->format(1234, fmt));
+    df->setGroupingUsed(TRUE);
+    fmt.remove();
+    assertEquals("Format 1234 w/ grouping", "1,234", df->format(1234, fmt));
+}
+
+void IntlTestDecimalFormatAPI::TestRequiredDecimalPoint() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString text("99");
+    Formattable result1;
+    UnicodeString pat1("##.0000");
+    UnicodeString pat2("00.0");
+
+    LocalPointer<DecimalFormat> df(new DecimalFormat(pat1, status));
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
+        return;
+    }
+
+    status = U_ZERO_ERROR;
+    df->applyPattern(pat1, status);
+    if(U_FAILURE(status)) {
+        errln((UnicodeString)"ERROR: applyPattern() failed");
+    }
+    df->parse(text, result1, status);
+    if(U_FAILURE(status)) {
+        errln((UnicodeString)"ERROR: parse() failed");
+    }
+    df->setDecimalPatternMatchRequired(TRUE);
+    df->parse(text, result1, status);
+    if(U_SUCCESS(status)) {
+        errln((UnicodeString)"ERROR: unexpected parse()");
+    }
+
+
+    status = U_ZERO_ERROR;
+    df->applyPattern(pat2, status);
+    df->setDecimalPatternMatchRequired(FALSE);
+    if(U_FAILURE(status)) {
+        errln((UnicodeString)"ERROR: applyPattern(2) failed");
+    }
+    df->parse(text, result1, status);
+    if(U_FAILURE(status)) {
+        errln((UnicodeString)"ERROR: parse(2) failed - " + u_errorName(status));
+    }
+    df->setDecimalPatternMatchRequired(TRUE);
+    df->parse(text, result1, status);
+    if(U_SUCCESS(status)) {
+        errln((UnicodeString)"ERROR: unexpected parse(2)");
+    }
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */