| Index: source/test/intltest/tsnmfmt.cpp
|
| diff --git a/source/test/intltest/tsnmfmt.cpp b/source/test/intltest/tsnmfmt.cpp
|
| deleted file mode 100644
|
| index 3f2e8d16f971256924666743f5f69b96869099e0..0000000000000000000000000000000000000000
|
| --- a/source/test/intltest/tsnmfmt.cpp
|
| +++ /dev/null
|
| @@ -1,452 +0,0 @@
|
| -/***********************************************************************
|
| - * COPYRIGHT:
|
| - * Copyright (c) 1997-2012, 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 "cstring.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 */);
|
| -
|
| - if (uprv_strcmp(locale.getName(), "en_US_POSIX") != 0) {
|
| - name = "Scientific test";
|
| - logln((UnicodeString)name + " (" + localeName + ")");
|
| - fStatus = U_ZERO_ERROR;
|
| - fFormat = NumberFormat::createScientificInstance(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 U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_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 %)
|
| -#if U_PLATFORM == U_PF_OS390
|
| - tryIt(-9.18228054496402e+64);
|
| - tryIt(-9.69413034454191e+64);
|
| -#else
|
| - tryIt(-9.18228054496402e+255);
|
| - tryIt(-9.69413034454191e+273);
|
| -#endif
|
| -
|
| -#if U_PLATFORM != U_PF_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(5.06e-27);
|
| -
|
| - 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(UnicodeString("**** 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 */
|
|
|
Chromium Code Reviews