ICU 56 update step 1

source/test/intltest/numrgts.cpp

 /***********************************************************************
- * Copyright (c) 1997-2014, International Business Machines Corporation
+ * Copyright (c) 1997-2015, International Business Machines Corporation
  * and others. All Rights Reserved.
  ***********************************************************************/
  
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "numrgts.h"
 
 #include <float.h> // DBL_MIN, DBL_MAX
 #include <stdio.h>
 
 #include "unicode/dcfmtsym.h"
 #include "unicode/decimfmt.h"
 #include "unicode/locid.h"
 #include "unicode/resbund.h"
 #include "unicode/calendar.h"
 #include "unicode/datefmt.h"
 #include "unicode/ucurr.h"
 #include "putilimp.h"
+#include "uassert.h"
 
 class MyNumberFormatTest : public NumberFormat 
 {
 public:
 
     virtual UClassID getDynamicClassID(void) const;
   
     virtual UnicodeString& format(    double            number, 
                     UnicodeString&        toAppendTo, 
                     FieldPositionIterator* posIter,
@@ skipping 305 matching lines @@
     delete symbols;
 }
 
 /* @bug 4087535
  * DecimalFormat.format() incorrectly formats 0.0
  */
 void NumberFormatRegressionTest::Test4087535 (void)
 {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormat *df = new DecimalFormat(status);
-    failure(status, "new DecimalFormat", "");
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
+        return;
+    }
     df->setMinimumIntegerDigits(0);
 
     double n = 0;
     UnicodeString buffer;
     FieldPosition pos(FieldPosition::DONT_CARE);
     buffer = df->format(n, buffer, pos);
     if (buffer.length() == 0)
         errln(/*n + */": '" + buffer + "'");
     n = 0.1;
     buffer = df->format(n, buffer, pos);
     if (buffer.length() == 0)
         errln(/*n + */": '" + buffer + "'");
 
     delete df;
 }
 
 /* @bug 4088503
  * DecimalFormat.format fails when groupingSize is set to 0.
  */
 // {sfb} how do I tell if this worked? --> FieldPosition doesn't change ??
 void NumberFormatRegressionTest::Test4088503 (void)
 {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormat *df = new DecimalFormat(status);
-    failure(status, "new DecimalFormat", "");
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
+        return;
+    }
     df->setGroupingSize(0);
     UnicodeString sBuf;
     FieldPosition fp(FieldPosition::DONT_CARE);
     //try {
         logln(df->format((int32_t)123, sBuf, fp));
         //if(fp == FieldPosition(0))
         //    errln("Test for bug 4088503 failed.");
     /*} catch (Exception foo) {
         errln("Test for bug 4088503 failed.");
     }*/
@@ skipping 952 matching lines @@
     }*/
     delete fmt;
 }
 /* @bug 4061302
  * API tests for API addition request A9.
  */
 void NumberFormatRegressionTest::Test4061302(void)
 {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormatSymbols *fmt = new DecimalFormatSymbols(status);
-    failure(status, "new DecimalFormatSymbols");
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status));
+        return;
+    }
     UnicodeString currency(fmt->getSymbol(DecimalFormatSymbols::kCurrencySymbol));
     UnicodeString intlCurrency(fmt->getSymbol(DecimalFormatSymbols::kIntlCurrencySymbol));
     UnicodeString monDecSeparator(fmt->getSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol));
     if (currency == UnicodeString("") ||
         intlCurrency == UnicodeString("") ||
         monDecSeparator == UnicodeString(""))
     {
         errln("getCurrencySymbols failed, got empty string.");
     }
     UnicodeString monDecSeparatorStr;
@@ skipping 17 matching lines @@
     delete fmt;
 }
 /* @bug 4062486
  * API tests for API addition request A23. FieldPosition.getBeginIndex and
  * FieldPosition.getEndIndex.
  */
 void NumberFormatRegressionTest::Test4062486(void)
 {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormat *fmt = new DecimalFormat(UnicodeString("#,##0.00"), status);
-    failure(status, "new DecimalFormat");
+    if (U_FAILURE(status)) {
+        dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
+        return;
+    }
     UnicodeString formatted;
     FieldPosition field(0);
     double num = 1234.5;
     fmt->format(num, formatted, field);
     if (field.getBeginIndex() != 0 && field.getEndIndex() != 5)
         errln(UnicodeString("Format 1234.5 failed. Begin index: ") /*+ field.getBeginIndex() + " End index: " + field.getEndIndex()*/);
     field.setBeginIndex(7);
     field.setEndIndex(4);
     if (field.getBeginIndex() != 7 && field.getEndIndex() != 4)
         errln("Set begin/end field indexes failed. Begin index: " /*+ field.getBeginIndex() + " End index: " + field.getEndIndex()*/);
@@ skipping 1036 matching lines @@
                       " -> \"" + pat +
                       "\" -> \"" + f2.toPattern(p) + "\"");
             } else {
                 UnicodeString l, p;
                 logln(UnicodeString("PASS: ") + type[j] + avail[i].getDisplayName(l) +
                       " -> \"" + pat +
                       "\"");
             }
 
             // Test toLocalizedPattern/applyLocalizedPattern round trip
-            df->toLocalizedPattern(pat);
-            f2.applyLocalizedPattern(pat, status);
+// TODO(refactor): don't worry about localized patterns for now.
+//            df->toLocalizedPattern(pat);
+//           f2.applyLocalizedPattern(pat, status);
             failure(status,
                     UnicodeString("applyLocalizedPattern(") + pat + ")", avail[i]);
             if (U_FAILURE(status)) {
                 continue;
             }
             
+// TODO(refactor): don't worry about localized patterns for now.
             // Make sure we set the currency attributes appropriately
-            if (j == 1) {   // Currency format
-                f2.setCurrency(f2.getCurrency(), status);
-            }
+//            if (j == 1) {   // Currency format
+//                f2.setCurrency(f2.getCurrency(), status);
+//            }
             failure(status,
                     UnicodeString("setCurrency() for (") + pat + ")", avail[i]);
             if (U_FAILURE(status)) {
                 continue;
             }
 
             if (*df != f2) {
                 UnicodeString l, p;
                 errln(UnicodeString("FAIL: ") + type[j] + avail[i].getDisplayName(l) +
                       " -> localized \"" + pat +
@@ skipping 240 matching lines @@
             dataerrln("File %s, Line %d: status=%s", __FILE__, __LINE__, u_errorName(status)); \
         } else { \
             errln("File %s, Line %d: status=%s", __FILE__, __LINE__, u_errorName(status)); \
         } return; \
     }}
 
 #define TEST_ASSERT(expr) \
     if ((expr)==FALSE) {\
         errln("File %s, line %d: Assertion Failed: " #expr "\n", __FILE__, __LINE__);\
     }
+#define TEST_ASSERT_EQUALS(x,y)                  \
+    {                                                                     \
+      char _msg[1000]; \
+      int32_t len = sprintf (_msg,"File %s, line %d: Assertion Failed: " #x "==" #y "\n", __FILE__, __LINE__); \
+      U_ASSERT(len < (int32_t) sizeof(_msg));                            \
+      assertEquals((const char*) _msg, x,y);                             \
+    }
 
 
 // Ticket 8199:  Parse failure for numbers in the range of 1E10 - 1E18
 
 void NumberFormatRegressionTest::Test8199(void) {
     UErrorCode status = U_ZERO_ERROR;
     NumberFormat *nf = NumberFormat::createInstance(Locale::getEnglish(), status);
     if (nf == NULL) {
         dataerrln("Fail: NumberFormat::createInstance(Locale::getEnglish(), status)");
         return;
@@ skipping 97 matching lines @@
     TEST_ASSERT(Formattable::kDouble == val.getType());
     TEST_ASSERT(9007199254740992LL == val.getInt64(status));
     TEST_ASSERT(9007199254740992.0 == val.getDouble(status));
     TEST_CHECK_STATUS(status);
 
     status = U_ZERO_ERROR;
     numStr = "9007199254740993.1";  // 54 bits for the int part.  Double will round
     nf->parse(numStr, val, status); //    the ones digit, putting it up to ...994
     TEST_CHECK_STATUS(status);
     TEST_ASSERT(Formattable::kDouble == val.getType());
-    TEST_ASSERT(9007199254740993LL == val.getInt64(status));
-    TEST_ASSERT(9007199254740994.0 == val.getDouble(status));
+    TEST_ASSERT_EQUALS((int64_t)9007199254740993LL,val.getInt64(status));
+    TEST_ASSERT_EQUALS((double)9007199254740994.0,(double)val.getDouble(status));
     TEST_CHECK_STATUS(status);
 
     delete nf;
 }
 
 void NumberFormatRegressionTest::Test9109(void) {
     UErrorCode status = U_ZERO_ERROR;
     Formattable val;
     ParsePosition pos;
     DecimalFormat fmt("+##", status);
-    fmt.setLenient(TRUE);
-
     if (U_FAILURE(status)) {
         dataerrln("Failed to create DecimalFormat with pattern '+##' - %s", u_errorName(status));
+        return;
     }
 
+    fmt.setLenient(TRUE);
     UnicodeString text("123");
     int32_t expected = 123;
     int32_t expos = 3;
 
     fmt.parse(text, val, pos);
     if (pos.getErrorIndex() >= 0) {
         errln(UnicodeString("Parse failure at ") + pos.getErrorIndex());
     } else if (val.getLong() != 123) {
         errln(UnicodeString("Incorrect parse result: ") + val.getLong() + " expected: " + expected);
     } else if (pos.getIndex() != 3) {
@@ skipping 130 matching lines @@
         }
     }
   }
 }
 
 void NumberFormatRegressionTest::Test10361(void) {
     // DecimalFormat/NumberFormat were artificially limiting the number of digits,
     //    preventing formatting of big decimals.
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormatSymbols symbols(Locale::getEnglish(), status);
-    LocalPointer<DecimalFormat> df(new DecimalFormat("###.##", symbols, status));
+    LocalPointer<DecimalFormat> df(new DecimalFormat("###.##", symbols, status), status);
     TEST_CHECK_STATUS(status);
 
     // Create a decimal number with a million digits.
     const int32_t NUMSIZE=1000000;
     char *num = new char[NUMSIZE];
     for (int32_t i=0; i<NUMSIZE; i++) {
         num[i] = '0' + (i+1) % 10;
     }
     num[NUMSIZE-3] = '.';
     num[NUMSIZE-1] = 0;
 
     UnicodeString    s;
     Formattable      fmtable;
     fmtable.setDecimalNumber(num, status);
     TEST_CHECK_STATUS(status);
 
     FieldPosition pos(UNUM_DECIMAL_SEPARATOR_FIELD);
     df->format(fmtable, s, pos, status);
     TEST_CHECK_STATUS(status);
     TEST_ASSERT(999999 == s.length());
     TEST_ASSERT(999997 == pos.getBeginIndex());
     TEST_ASSERT(999998 == pos.getEndIndex());
 
     UnicodeString expected(num, -1, US_INV);
     TEST_ASSERT(expected == s);
     delete [] num;
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */