ICU 56 update step 1

source/test/intltest/dcfmapts.cpp

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1997-2014, International Business Machines Corporation and
+ * Copyright (c) 1997-2015, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "dcfmapts.h"
 
 #include "unicode/currpinf.h"
@@ skipping 92 matching lines @@
         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.");
     }
+    noGrouping.setGroupingUsed(TRUE);
+    if (noGrouping.getGroupingSize() != 0) {
+      errln("Grouping size should still be 0.");
+    }
     // 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;
     }
 
@@ skipping 310 matching lines @@
     }
 
     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));
+        return;
     }
 
     df->adoptCurrencyPluralInfo(cpi);
 
     df->getCurrencyPluralInfo();
 
     df->setCurrencyPluralInfo(cpi1);
 
     delete df;
 }
@@ skipping 138 matching lines @@
     }
 }
 
 
 #define ASSERT_EQUAL(expect, actual) { char tmp[200]; sprintf(tmp, "(%g==%g)", (double)(expect), (double)(actual)); \
     assertTrue(tmp, ((expect)==(actual)), FALSE, TRUE, __FILE__, __LINE__); }
 
 void IntlTestDecimalFormatAPI::TestFixedDecimal() {
     UErrorCode status = U_ZERO_ERROR;
 
-    LocalPointer<DecimalFormat> df(new DecimalFormat("###", status));
+    LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status);
     TEST_ASSERT_STATUS(status);
+    if (status == U_MISSING_RESOURCE_ERROR) {
+        return;
+    }
     FixedDecimal fd = df->getFixedDecimal(44, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(44, fd.source);
     ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
+    ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("###.00##", status));
+    fd = df->getFixedDecimal(-44, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(44, fd.source);
+    ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
+    ASSERT_EQUAL(TRUE, fd.isNegative);
+
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.00##", status), status);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(123.456, status);
     TEST_ASSERT_STATUS(status);
-    ASSERT_EQUAL(3, fd.visibleDecimalDigitCount);
-    ASSERT_EQUAL(456, fd.decimalDigits);
-    ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros);
-    ASSERT_EQUAL(123, fd.intValue);
+    ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(456, fd.decimalDigits); // f
+    ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(123, fd.intValue); // i
+    ASSERT_EQUAL(123.456, fd.source); // n
     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("###", status));
+    fd = df->getFixedDecimal(-123.456, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(456, fd.decimalDigits); // f
+    ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(123, fd.intValue); // i
+    ASSERT_EQUAL(123.456, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(TRUE, fd.isNegative);
+
+    // test max int digits
+    df->setMaximumIntegerDigits(2);
+    fd = df->getFixedDecimal(123.456, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(456, fd.decimalDigits); // f
+    ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(23, fd.intValue); // i
+    ASSERT_EQUAL(23.456, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(FALSE, fd.isNegative);
+
+    fd = df->getFixedDecimal(-123.456, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(456, fd.decimalDigits); // f
+    ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(23, fd.intValue); // i
+    ASSERT_EQUAL(23.456, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(TRUE, fd.isNegative);
+
+    // test max fraction digits
+    df->setMaximumIntegerDigits(2000000000);
+    df->setMaximumFractionDigits(2);
+    fd = df->getFixedDecimal(123.456, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(46, fd.decimalDigits); // f
+    ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(123, fd.intValue); // i
+    ASSERT_EQUAL(123.46, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(FALSE, fd.isNegative);
+
+    fd = df->getFixedDecimal(-123.456, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(46, fd.decimalDigits); // f
+    ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(123, fd.intValue); // i
+    ASSERT_EQUAL(123.46, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(TRUE, fd.isNegative);
+
+    // test esoteric rounding
+    df->setMaximumFractionDigits(6);
+    df->setRoundingIncrement(7.3);
+
+    fd = df->getFixedDecimal(30.0, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(20, fd.decimalDigits); // f
+    ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(29, fd.intValue); // i
+    ASSERT_EQUAL(29.2, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(FALSE, fd.isNegative);
+
+    fd = df->getFixedDecimal(-30.0, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
+    ASSERT_EQUAL(20, fd.decimalDigits); // f
+    ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t
+    ASSERT_EQUAL(29, fd.intValue); // i
+    ASSERT_EQUAL(29.2, fd.source); // n
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(TRUE, fd.isNegative);
+
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###", status), status);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(123.456, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(0, fd.decimalDigits);
     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(123, fd.intValue);
     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("###.0", status));
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(123.01, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(1, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(0, fd.decimalDigits);
     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(123, fd.intValue);
     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("###.0", status));
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(123.06, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(1, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(1, fd.decimalDigits);
     ASSERT_EQUAL(1, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(123, fd.intValue);
     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("@@@@@", status));  // Significant Digits
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status);  // Significant Digits
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(123, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(0, fd.decimalDigits);
     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(123, fd.intValue);
     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
-    df.adoptInstead(new DecimalFormat("@@@@@", status));  // Significant Digits
+    df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status);  // Significant Digits
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(1.23, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(4, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(2300, fd.decimalDigits);
     ASSERT_EQUAL(23, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(1, fd.intValue);
     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
     fd = df->getFixedDecimal(uprv_getInfinity(), status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(TRUE, fd.isNanOrInfinity);
     fd = df->getFixedDecimal(0.0, status);
     ASSERT_EQUAL(FALSE, fd.isNanOrInfinity);
     fd = df->getFixedDecimal(uprv_getNaN(), status);
     ASSERT_EQUAL(TRUE, fd.isNanOrInfinity);
     TEST_ASSERT_STATUS(status);
 
     // Test Big Decimal input.
     // 22 digits before and after decimal, will exceed the precision of a double
     //    and force DecimalFormat::getFixedDecimal() to work with a digit list.
-    df.adoptInstead(new DecimalFormat("#####################0.00####################", status));
+    df.adoptInsteadAndCheckErrorCode(
+        new DecimalFormat("#####################0.00####################", status), status);
     TEST_ASSERT_STATUS(status);
     Formattable fable("12.34", status);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(fable, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(34, fd.decimalDigits);
     ASSERT_EQUAL(34, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(12, fd.intValue);
     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
@@ skipping 63 matching lines @@
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(fable, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(30, fd.decimalDigits);
     ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(100000000000000000LL, fd.intValue);
     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
     ASSERT_EQUAL(FALSE, fd.isNegative);
 
+    fable.setDecimalNumber("1000000000000000050000.3", status);
+    TEST_ASSERT_STATUS(status);
+    fd = df->getFixedDecimal(fable, status);
+    TEST_ASSERT_STATUS(status);
+    ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
+    ASSERT_EQUAL(30, fd.decimalDigits);
+    ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros);
+    ASSERT_EQUAL(50000LL, fd.intValue);
+    ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
+    ASSERT_EQUAL(FALSE, fd.isNegative);
+
     // Test some int64_t values that are out of the range of a double
     fable.setInt64(4503599627370496LL);
     TEST_ASSERT_STATUS(status);
     fd = df->getFixedDecimal(fable, status);
     TEST_ASSERT_STATUS(status);
     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
     ASSERT_EQUAL(0, fd.decimalDigits);
     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
     ASSERT_EQUAL(4503599627370496LL, fd.intValue);
     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
@@ skipping 24 matching lines @@
         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));
+    LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), 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);
+    df->setGroupingSize(3);
     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));
+    LocalPointer<DecimalFormat> df(new DecimalFormat(pat1, status), 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");
     }
@@ skipping 19 matching lines @@
         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 */