Check in the pristine copy of ICU 4.6...

icu46/source/test/intltest/tsnmfmt.cpp

+/***********************************************************************
+ * COPYRIGHT: 
+ * Copyright (c) 1997-2009, International Business Machines Corporation
+ * and others. All Rights Reserved.
+ ***********************************************************************/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/decimfmt.h"
+#include "tsnmfmt.h"
+#include "putilimp.h"
+#include <float.h>
+#include <stdlib.h>
+
+IntlTestNumberFormat::~IntlTestNumberFormat() {}
+
+static const char * formattableTypeName(Formattable::Type t)
+{
+  switch(t) {
+  case Formattable::kDate: return "kDate";
+  case Formattable::kDouble: return "kDouble";
+  case Formattable::kLong: return "kLong";
+  case Formattable::kString: return "kString";
+  case Formattable::kArray: return "kArray";
+  case Formattable::kInt64: return "kInt64";
+  default: return "??unknown??";
+  }
+}
+
+/**
+ * This test does round-trip testing (format -> parse -> format -> parse -> etc.) of
+ * NumberFormat.
+ */
+void IntlTestNumberFormat::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
+{
+
+    if (exec) logln((UnicodeString)"TestSuite NumberFormat");
+    switch (index) {
+        case 0: name = "createInstance"; 
+            if (exec)
+            {
+                logln(name);
+                fStatus = U_ZERO_ERROR;
+                fFormat = NumberFormat::createInstance(fStatus);
+                testFormat(/*par*/);
+            }
+            break;
+
+        case 1: name = "DefaultLocale";
+            if (exec) testLocale(/*par, */Locale::getDefault(), name);
+            break;
+
+        case 2: name = "testAvailableLocales"; 
+            if (exec) {
+                logln(name);
+                testAvailableLocales(/*par*/);
+            }
+            break;
+
+        case 3: name = "monsterTest";
+            if (exec) {
+                logln(name);
+                monsterTest(/*par*/);
+            }
+            break;
+
+        default: name = ""; break;
+    }
+}
+
+void
+IntlTestNumberFormat::testLocale(/* char* par, */const Locale& locale, const UnicodeString& localeName)
+{
+    const char* name;
+    
+    fLocale = locale;
+    name = "Number test";
+    logln((UnicodeString)name + " (" + localeName + ")");
+    fStatus = U_ZERO_ERROR;
+    fFormat = NumberFormat::createInstance(locale, fStatus);
+    testFormat(/* par */);
+
+    name = "Currency test";
+    logln((UnicodeString)name + " (" + localeName + ")");
+    fStatus = U_ZERO_ERROR;
+    fFormat = NumberFormat::createCurrencyInstance(locale, fStatus);
+    testFormat(/* par */);
+
+    name = "Percent test";
+    logln((UnicodeString)name + " (" + localeName + ")");
+    fStatus = U_ZERO_ERROR;
+    fFormat = NumberFormat::createPercentInstance(locale, fStatus);
+    testFormat(/* par */);
+}
+
+double IntlTestNumberFormat::randDouble()
+{
+    // Assume 8-bit (or larger) rand values.  Also assume
+    // that the system rand() function is very poor, which it always is.
+    // Call srand(currentTime) in intltest to make it truly random.
+    double d;
+    uint32_t i;
+    char* poke = (char*)&d;
+    do {
+        for (i=0; i < sizeof(double); ++i)
+        {
+            poke[i] = (char)(rand() & 0xFF);
+        }
+    } while (uprv_isNaN(d) || uprv_isInfinite(d)
+        || !((-DBL_MAX < d && d < DBL_MAX) || (d < -DBL_MIN && DBL_MIN < d)));
+
+    return d;
+}
+
+/*
+ * Return a random uint32_t
+ **/
+uint32_t IntlTestNumberFormat::randLong()
+{
+    // Assume 8-bit (or larger) rand values.  Also assume
+    // that the system rand() function is very poor, which it always is.
+    // Call srand(currentTime) in intltest to make it truly random.
+    uint32_t d;
+    uint32_t i;
+    char* poke = (char*)&d;
+    for (i=0; i < sizeof(uint32_t); ++i)
+    {
+        poke[i] = (char)(rand() & 0xFF);
+    }
+    return d;
+}
+
+
+/* Make sure that we don't get something too large and multiply into infinity.
+   @param smallerThanMax the requested maximum value smaller than DBL_MAX */
+double IntlTestNumberFormat::getSafeDouble(double smallerThanMax) {
+    double it;
+    double high = (DBL_MAX/smallerThanMax)/10.0;
+    double low = -high;
+    do {
+        it = randDouble();
+    } while (low > it || it > high);
+    return it;
+}
+
+void
+IntlTestNumberFormat::testFormat(/* char* par */)
+{
+    if (U_FAILURE(fStatus))
+    { 
+        dataerrln((UnicodeString)"**** FAIL: createXxxInstance failed. - " + u_errorName(fStatus));
+        if (fFormat != 0)
+            errln("**** FAIL: Non-null format returned by createXxxInstance upon failure.");
+        delete fFormat;
+        fFormat = 0;
+        return;
+    }
+                    
+    if (fFormat == 0)
+    {
+        errln((UnicodeString)"**** FAIL: Null format returned by createXxxInstance.");
+        return;
+    }
+
+    UnicodeString str;
+
+    // Assume it's a DecimalFormat and get some info
+    DecimalFormat *s = (DecimalFormat*)fFormat;
+    logln((UnicodeString)"  Pattern " + s->toPattern(str));
+
+#if defined(OS390) || defined(OS400)
+    tryIt(-2.02147304840132e-68);
+    tryIt(3.88057859588817e-68); // Test rounding when only some digits are shown because exponent is close to -maxfrac
+    tryIt(-2.64651110485945e+65); // Overflows to +INF when shown as a percent
+    tryIt(9.29526819488338e+64); // Ok -- used to fail?
+#else
+    tryIt(-2.02147304840132e-100);
+    tryIt(3.88057859588817e-096); // Test rounding when only some digits are shown because exponent is close to -maxfrac
+    tryIt(-2.64651110485945e+306); // Overflows to +INF when shown as a percent
+    tryIt(9.29526819488338e+250); // Ok -- used to fail?
+#endif
+
+    // These PASS now, with the sprintf/atof based format-parse.
+
+    // These fail due to round-off
+    // The least significant digit drops by one during each format-parse cycle.
+    // Both numbers DON'T have a round-off problem when multiplied by 100! (shown as %)
+#ifdef OS390
+    tryIt(-9.18228054496402e+64);
+    tryIt(-9.69413034454191e+64);
+#else
+    tryIt(-9.18228054496402e+255);
+    tryIt(-9.69413034454191e+273);
+#endif
+
+#ifndef OS390
+    tryIt(1.234e-200);
+    tryIt(-2.3e-168);
+
+    tryIt(uprv_getNaN());
+    tryIt(uprv_getInfinity());
+    tryIt(-uprv_getInfinity());
+#endif
+
+    tryIt((int32_t)251887531);
+    tryIt(5e-20 / 9);
+    tryIt(5e20 / 9);
+    tryIt(1.234e-50);
+    tryIt(9.99999999999996);
+    tryIt(9.999999999999996);
+
+    tryIt((int32_t)INT32_MIN);
+    tryIt((int32_t)INT32_MAX);
+    tryIt((double)INT32_MIN);
+    tryIt((double)INT32_MAX);
+    tryIt((double)INT32_MIN - 1.0);
+    tryIt((double)INT32_MAX + 1.0);
+
+    tryIt(5.0 / 9.0 * 1e-20);
+    tryIt(4.0 / 9.0 * 1e-20);
+    tryIt(5.0 / 9.0 * 1e+20);
+    tryIt(4.0 / 9.0 * 1e+20);
+
+    tryIt(2147483647.);
+    tryIt((int32_t)0);
+    tryIt(0.0);
+    tryIt((int32_t)1);
+    tryIt((int32_t)10);
+    tryIt((int32_t)100);
+    tryIt((int32_t)-1);
+    tryIt((int32_t)-10);
+    tryIt((int32_t)-100);
+    tryIt((int32_t)-1913860352);
+
+    for (int32_t z=0; z<10; ++z)
+    {
+        double d = randFraction() * 2e10 - 1e10;
+        tryIt(d);
+    }
+
+    double it = getSafeDouble(100000.0);
+
+    tryIt(0.0);
+    tryIt(it);
+    tryIt((int32_t)0);
+    tryIt(uprv_floor(it));
+    tryIt((int32_t)randLong());
+
+    // try again
+    it = getSafeDouble(100.0);
+    tryIt(it);
+    tryIt(uprv_floor(it));
+    tryIt((int32_t)randLong());
+
+    // try again with very large numbers
+    it = getSafeDouble(100000000000.0);
+    tryIt(it);
+
+    // try again with very large numbers
+    // and without going outside of the int32_t range
+    it = randFraction() * INT32_MAX;
+    tryIt(it);
+    tryIt((int32_t)uprv_floor(it));
+
+    delete fFormat;
+}
+
+void 
+IntlTestNumberFormat::tryIt(double aNumber)
+{
+    const int32_t DEPTH = 10;
+    Formattable number[DEPTH];
+    UnicodeString string[DEPTH];
+
+    int32_t numberMatch = 0;
+    int32_t stringMatch = 0;
+    UnicodeString errMsg;
+    int32_t i;
+    for (i=0; i<DEPTH; ++i)
+    {
+        errMsg.truncate(0); // if non-empty, we failed this iteration
+        UErrorCode status = U_ZERO_ERROR;
+        string[i] = "(n/a)"; // "format was never done" value
+        if (i == 0) {
+            number[i].setDouble(aNumber);
+        } else {
+            fFormat->parse(string[i-1], number[i], status);
+            if (U_FAILURE(status)) {
+                number[i].setDouble(1234.5); // "parse failed" value
+                errMsg = "**** FAIL: Parse of " + prettify(string[i-1]) + " failed.";
+                --i; // don't show empty last line: "1234.5 F> (n/a) P>"
+                break;
+            }
+        }
+        // Convert from long to double
+        if (number[i].getType() == Formattable::kLong)
+            number[i].setDouble(number[i].getLong());
+        else if (number[i].getType() == Formattable::kInt64)
+            number[i].setDouble((double)number[i].getInt64());
+        else if (number[i].getType() != Formattable::kDouble)
+        {
+            errMsg = ("**** FAIL: Parse of " + prettify(string[i-1])
+                + " returned non-numeric Formattable, type " + UnicodeString(formattableTypeName(number[i].getType()))
+                + ", Locale=" + UnicodeString(fLocale.getName())
+                + ", longValue=" + number[i].getLong());
+            break;
+        }
+        string[i].truncate(0);
+        fFormat->format(number[i].getDouble(), string[i]);
+        if (i > 0)
+        {
+            if (numberMatch == 0 && number[i] == number[i-1])
+                numberMatch = i;
+            else if (numberMatch > 0 && number[i] != number[i-1])
+            {
+                errMsg = ("**** FAIL: Numeric mismatch after match.");
+                break;
+            }
+            if (stringMatch == 0 && string[i] == string[i-1])
+                stringMatch = i;
+            else if (stringMatch > 0 && string[i] != string[i-1])
+            {
+                errMsg = ("**** FAIL: String mismatch after match.");
+                break;
+            }
+        }
+        if (numberMatch > 0 && stringMatch > 0)
+            break;
+    }
+    if (i == DEPTH)
+        --i;
+
+    if (stringMatch > 2 || numberMatch > 2)
+    {
+        errMsg = ("**** FAIL: No string and/or number match within 2 iterations.");
+    }
+
+    if (errMsg.length() != 0)
+    {
+        for (int32_t k=0; k<=i; ++k)
+        {
+            logln((UnicodeString)"" + k + ": " + number[k].getDouble() + " F> " +
+                  prettify(string[k]) + " P> ");
+        }
+        errln(errMsg);
+    }
+}
+
+void 
+IntlTestNumberFormat::tryIt(int32_t aNumber)
+{
+    Formattable number(aNumber);
+    UnicodeString stringNum;
+    UErrorCode status = U_ZERO_ERROR;
+
+    fFormat->format(number, stringNum, status);
+    if (U_FAILURE(status))
+    {
+        errln("**** FAIL: Formatting " + aNumber);
+        return;
+    }
+    fFormat->parse(stringNum, number, status);
+    if (U_FAILURE(status))
+    {
+        errln("**** FAIL: Parse of " + prettify(stringNum) + " failed.");
+        return;
+    }
+    if (number.getType() != Formattable::kLong)
+    {
+        errln("**** FAIL: Parse of " + prettify(stringNum)
+            + " returned non-long Formattable, type " + UnicodeString(formattableTypeName(number.getType()))
+            + ", Locale=" + UnicodeString(fLocale.getName())
+            + ", doubleValue=" + number.getDouble()
+            + ", longValue=" + number.getLong()
+            + ", origValue=" + aNumber
+            );
+    }
+    if (number.getLong() != aNumber) {
+        errln("**** FAIL: Parse of " + prettify(stringNum) + " failed. Got:" + number.getLong()
+            + " Expected:" + aNumber);
+    }
+}
+
+void IntlTestNumberFormat::testAvailableLocales(/* char* par */)
+{
+    int32_t count = 0;
+    const Locale* locales = NumberFormat::getAvailableLocales(count);
+    logln((UnicodeString)"" + count + " available locales");
+    if (locales && count)
+    {
+        UnicodeString name;
+        UnicodeString all;
+        for (int32_t i=0; i<count; ++i)
+        {
+            if (i!=0)
+                all += ", ";
+            all += locales[i].getName();
+        }
+        logln(all);
+    }
+    else
+        dataerrln((UnicodeString)"**** FAIL: Zero available locales or null array pointer");
+}
+
+void IntlTestNumberFormat::monsterTest(/* char* par */)
+{
+    const char *SEP = "============================================================\n";
+    int32_t count;
+    const Locale* allLocales = NumberFormat::getAvailableLocales(count);
+    Locale* locales = (Locale*)allLocales;
+    Locale quickLocales[6];
+    if (allLocales && count)
+    {
+        if (quick && count > 6) {
+            logln("quick test: testing just 6 locales!");
+            count = 6;
+            locales = quickLocales;
+            locales[0] = allLocales[0];
+            locales[1] = allLocales[1];
+            locales[2] = allLocales[2];
+            // In a quick test, make sure we test locales that use
+            // currency prefix, currency suffix, and choice currency
+            // logic.  Otherwise bugs in these areas can slip through.
+            locales[3] = Locale("ar", "AE", "");
+            locales[4] = Locale("cs", "CZ", "");
+            locales[5] = Locale("en", "IN", "");
+        }
+        for (int32_t i=0; i<count; ++i)
+        {
+            UnicodeString name(locales[i].getName(), "");
+            logln(SEP);
+            testLocale(/* par, */locales[i], name);
+        }
+    }
+
+    logln(SEP);
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */