icuSources/test/intltest/tsnmfmt.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /***********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2012, International Business Machines Corporation
   6  * and others. All Rights Reserved.
   7  ***********************************************************************/
   8
   9 #include "unicode/utypes.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12
  13 #include "unicode/decimfmt.h"
  14 #include "tsnmfmt.h"
  15 #include "putilimp.h"
  16 #include "cstring.h"
  17 #include <float.h>
  18 #include <stdlib.h>
  19
  20 IntlTestNumberFormat::~IntlTestNumberFormat() {}
  21
  22 static const char * formattableTypeName(Formattable::Type t)
  23 {
  24   switch(t) {
  25   case Formattable::kDate: return "kDate";
  26   case Formattable::kDouble: return "kDouble";
  27   case Formattable::kLong: return "kLong";
  28   case Formattable::kString: return "kString";
  29   case Formattable::kArray: return "kArray";
  30   case Formattable::kInt64: return "kInt64";
  31   default: return "??unknown??";
  32   }
  33 }
  34
  35 /**
  36  * This test does round-trip testing (format -> parse -> format -> parse -> etc.) of
  37  * NumberFormat.
  38  */
  39 void IntlTestNumberFormat::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  40 {
  41
  42     if (exec) logln((UnicodeString)"TestSuite NumberFormat");
  43     switch (index) {
  44         case 0: name = "createInstance";
  45             if (exec)
  46             {
  47                 logln(name);
  48                 fStatus = U_ZERO_ERROR;
  49                 fFormat = NumberFormat::createInstance(fStatus);
  50                 testFormat(/*par*/);
  51             }
  52             break;
  53
  54         case 1: name = "DefaultLocale";
  55             if (exec) testLocale(/*par, */Locale::getDefault(), name);
  56             break;
  57
  58         case 2: name = "testAvailableLocales";
  59             if (exec) {
  60                 logln(name);
  61                 testAvailableLocales(/*par*/);
  62             }
  63             break;
  64
  65         case 3: name = "monsterTest";
  66             if (exec) {
  67                 logln(name);
  68                 monsterTest(/*par*/);
  69             }
  70             break;
  71
  72         default: name = ""; break;
  73     }
  74 }
  75
  76 void
  77 IntlTestNumberFormat::testLocale(/* char* par, */const Locale& locale, const UnicodeString& localeName)
  78 {
  79     const char* name;
  80
  81     fLocale = locale;
  82     name = "Number test";
  83     logln((UnicodeString)name + " (" + localeName + ")");
  84     fStatus = U_ZERO_ERROR;
  85     fFormat = NumberFormat::createInstance(locale, fStatus);
  86     testFormat(/* par */);
  87
  88     name = "Currency test";
  89     logln((UnicodeString)name + " (" + localeName + ")");
  90     fStatus = U_ZERO_ERROR;
  91     fFormat = NumberFormat::createCurrencyInstance(locale, fStatus);
  92     testFormat(/* par */);
  93
  94     name = "Percent test";
  95     logln((UnicodeString)name + " (" + localeName + ")");
  96     fStatus = U_ZERO_ERROR;
  97     fFormat = NumberFormat::createPercentInstance(locale, fStatus);
  98     testFormat(/* par */);
  99
 100     if (uprv_strcmp(locale.getName(), "en_US_POSIX") != 0) {
 101         name = "Scientific test";
 102         logln((UnicodeString)name + " (" + localeName + ")");
 103         fStatus = U_ZERO_ERROR;
 104         fFormat = NumberFormat::createScientificInstance(locale, fStatus);
 105         testFormat(/* par */);
 106     }
 107 }
 108
 109 double IntlTestNumberFormat::randDouble()
 110 {
 111     // Assume 8-bit (or larger) rand values.  Also assume
 112     // that the system rand() function is very poor, which it always is.
 113     // Call srand(currentTime) in intltest to make it truly random.
 114     double d;
 115     uint32_t i;
 116     char* poke = (char*)&d;
 117     do {
 118         for (i=0; i < sizeof(double); ++i)
 119         {
 120             poke[i] = (char)(rand() & 0xFF);
 121         }
 122     } while (uprv_isNaN(d) || uprv_isInfinite(d)
 123         || !((-DBL_MAX < d && d < DBL_MAX) || (d < -DBL_MIN && DBL_MIN < d)));
 124
 125     return d;
 126 }
 127
 128 /*
 129  * Return a random uint32_t
 130  **/
 131 uint32_t IntlTestNumberFormat::randLong()
 132 {
 133     // Assume 8-bit (or larger) rand values.  Also assume
 134     // that the system rand() function is very poor, which it always is.
 135     // Call srand(currentTime) in intltest to make it truly random.
 136     uint32_t d;
 137     uint32_t i;
 138     char* poke = (char*)&d;
 139     for (i=0; i < sizeof(uint32_t); ++i)
 140     {
 141         poke[i] = (char)(rand() & 0xFF);
 142     }
 143     return d;
 144 }
 145
 146
 147 /* Make sure that we don't get something too large and multiply into infinity.
 148    @param smallerThanMax the requested maximum value smaller than DBL_MAX */
 149 double IntlTestNumberFormat::getSafeDouble(double smallerThanMax) {
 150     double it;
 151     double high = (DBL_MAX/smallerThanMax)/10.0;
 152     double low = -high;
 153     do {
 154         it = randDouble();
 155     } while (low > it || it > high);
 156     return it;
 157 }
 158
 159 void
 160 IntlTestNumberFormat::testFormat(/* char* par */)
 161 {
 162     if (U_FAILURE(fStatus))
 163     {
 164         dataerrln((UnicodeString)"**** FAIL: createXxxInstance failed. - " + u_errorName(fStatus));
 165         if (fFormat != 0)
 166             errln("**** FAIL: Non-null format returned by createXxxInstance upon failure.");
 167         delete fFormat;
 168         fFormat = 0;
 169         return;
 170     }
 171
 172     if (fFormat == 0)
 173     {
 174         errln((UnicodeString)"**** FAIL: Null format returned by createXxxInstance.");
 175         return;
 176     }
 177
 178     UnicodeString str;
 179
 180     // Assume it's a DecimalFormat and get some info
 181     DecimalFormat *s = (DecimalFormat*)fFormat;
 182     logln((UnicodeString)"  Pattern " + s->toPattern(str));
 183
 184 #if U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400
 185     tryIt(-2.02147304840132e-68);
 186     tryIt(3.88057859588817e-68); // Test rounding when only some digits are shown because exponent is close to -maxfrac
 187     tryIt(-2.64651110485945e+65); // Overflows to +INF when shown as a percent
 188     tryIt(9.29526819488338e+64); // Ok -- used to fail?
 189 #else
 190     tryIt(-2.02147304840132e-100);
 191     tryIt(3.88057859588817e-096); // Test rounding when only some digits are shown because exponent is close to -maxfrac
 192     tryIt(-2.64651110485945e+306); // Overflows to +INF when shown as a percent
 193     tryIt(9.29526819488338e+250); // Ok -- used to fail?
 194 #endif
 195
 196     // These PASS now, with the sprintf/atof based format-parse.
 197
 198     // These fail due to round-off
 199     // The least significant digit drops by one during each format-parse cycle.
 200     // Both numbers DON'T have a round-off problem when multiplied by 100! (shown as %)
 201 #if U_PLATFORM == U_PF_OS390
 202     tryIt(-9.18228054496402e+64);
 203     tryIt(-9.69413034454191e+64);
 204 #else
 205     tryIt(-9.18228054496402e+255);
 206     tryIt(-9.69413034454191e+273);
 207 #endif
 208
 209 #if U_PLATFORM != U_PF_OS390
 210     tryIt(1.234e-200);
 211     tryIt(-2.3e-168);
 212
 213     tryIt(uprv_getNaN());
 214     tryIt(uprv_getInfinity());
 215     tryIt(-uprv_getInfinity());
 216 #endif
 217
 218     tryIt((int32_t)251887531);
 219     tryIt(5e-20 / 9);
 220     tryIt(5e20 / 9);
 221     tryIt(1.234e-50);
 222     tryIt(9.99999999999996);
 223     tryIt(9.999999999999996);
 224
 225         tryIt(5.06e-27);
 226
 227     tryIt((int32_t)INT32_MIN);
 228     tryIt((int32_t)INT32_MAX);
 229     tryIt((double)INT32_MIN);
 230     tryIt((double)INT32_MAX);
 231     tryIt((double)INT32_MIN - 1.0);
 232     tryIt((double)INT32_MAX + 1.0);
 233
 234     tryIt(5.0 / 9.0 * 1e-20);
 235     tryIt(4.0 / 9.0 * 1e-20);
 236     tryIt(5.0 / 9.0 * 1e+20);
 237     tryIt(4.0 / 9.0 * 1e+20);
 238
 239     tryIt(2147483647.);
 240     tryIt((int32_t)0);
 241     tryIt(0.0);
 242     tryIt((int32_t)1);
 243     tryIt((int32_t)10);
 244     tryIt((int32_t)100);
 245     tryIt((int32_t)-1);
 246     tryIt((int32_t)-10);
 247     tryIt((int32_t)-100);
 248     tryIt((int32_t)-1913860352);
 249
 250     for (int32_t z=0; z<10; ++z)
 251     {
 252         double d = randFraction() * 2e10 - 1e10;
 253         tryIt(d);
 254     }
 255
 256     double it = getSafeDouble(100000.0);
 257
 258     tryIt(0.0);
 259     tryIt(it);
 260     tryIt((int32_t)0);
 261     tryIt(uprv_floor(it));
 262     tryIt((int32_t)randLong());
 263
 264     // try again
 265     it = getSafeDouble(100.0);
 266     tryIt(it);
 267     tryIt(uprv_floor(it));
 268     tryIt((int32_t)randLong());
 269
 270     // try again with very large numbers
 271     it = getSafeDouble(100000000000.0);
 272     tryIt(it);
 273
 274     // try again with very large numbers
 275     // and without going outside of the int32_t range
 276     it = randFraction() * INT32_MAX;
 277     tryIt(it);
 278     tryIt((int32_t)uprv_floor(it));
 279
 280     delete fFormat;
 281 }
 282
 283 void
 284 IntlTestNumberFormat::tryIt(double aNumber)
 285 {
 286     const int32_t DEPTH = 10;
 287     Formattable number[DEPTH];
 288     UnicodeString string[DEPTH];
 289
 290     int32_t numberMatch = 0;
 291     int32_t stringMatch = 0;
 292     UnicodeString errMsg;
 293     int32_t i;
 294     for (i=0; i<DEPTH; ++i)
 295     {
 296         errMsg.truncate(0); // if non-empty, we failed this iteration
 297         UErrorCode status = U_ZERO_ERROR;
 298         string[i] = "(n/a)"; // "format was never done" value
 299         if (i == 0) {
 300             number[i].setDouble(aNumber);
 301         } else {
 302             fFormat->parse(string[i-1], number[i], status);
 303             if (U_FAILURE(status)) {
 304                 number[i].setDouble(1234.5); // "parse failed" value
 305                 errMsg = "**** FAIL: Parse of " + prettify(string[i-1]) + " failed.";
 306                 --i; // don't show empty last line: "1234.5 F> (n/a) P>"
 307                 break;
 308             }
 309         }
 310         // Convert from long to double
 311         if (number[i].getType() == Formattable::kLong)
 312             number[i].setDouble(number[i].getLong());
 313         else if (number[i].getType() == Formattable::kInt64)
 314             number[i].setDouble((double)number[i].getInt64());
 315         else if (number[i].getType() != Formattable::kDouble)
 316         {
 317             errMsg = ("**** FAIL: Parse of " + prettify(string[i-1])
 318                 + " returned non-numeric Formattable, type " + UnicodeString(formattableTypeName(number[i].getType()))
 319                 + ", Locale=" + UnicodeString(fLocale.getName())
 320                 + ", longValue=" + number[i].getLong());
 321             break;
 322         }
 323         string[i].truncate(0);
 324         fFormat->format(number[i].getDouble(), string[i]);
 325         if (i > 0)
 326         {
 327             if (numberMatch == 0 && number[i] == number[i-1])
 328                 numberMatch = i;
 329             else if (numberMatch > 0 && number[i] != number[i-1])
 330             {
 331                 errMsg = ("**** FAIL: Numeric mismatch after match.");
 332                 break;
 333             }
 334             if (stringMatch == 0 && string[i] == string[i-1])
 335                 stringMatch = i;
 336             else if (stringMatch > 0 && string[i] != string[i-1])
 337             {
 338                 errMsg = ("**** FAIL: String mismatch after match.");
 339                 break;
 340             }
 341         }
 342         if (numberMatch > 0 && stringMatch > 0)
 343             break;
 344     }
 345     if (i == DEPTH)
 346         --i;
 347
 348     if (stringMatch > 2 || numberMatch > 2)
 349     {
 350         errMsg = ("**** FAIL: No string and/or number match within 2 iterations.");
 351     }
 352
 353     if (errMsg.length() != 0)
 354     {
 355         for (int32_t k=0; k<=i; ++k)
 356         {
 357             logln((UnicodeString)"" + k + ": " + number[k].getDouble() + " F> " +
 358                   prettify(string[k]) + " P> ");
 359         }
 360         errln(errMsg);
 361     }
 362 }
 363
 364 void
 365 IntlTestNumberFormat::tryIt(int32_t aNumber)
 366 {
 367     Formattable number(aNumber);
 368     UnicodeString stringNum;
 369     UErrorCode status = U_ZERO_ERROR;
 370
 371     fFormat->format(number, stringNum, status);
 372     if (U_FAILURE(status))
 373     {
 374         errln(UnicodeString("**** FAIL: Formatting ") + aNumber);
 375         return;
 376     }
 377     fFormat->parse(stringNum, number, status);
 378     if (U_FAILURE(status))
 379     {
 380         errln("**** FAIL: Parse of " + prettify(stringNum) + " failed.");
 381         return;
 382     }
 383     if (number.getType() != Formattable::kLong)
 384     {
 385         errln("**** FAIL: Parse of " + prettify(stringNum)
 386             + " returned non-long Formattable, type " + UnicodeString(formattableTypeName(number.getType()))
 387             + ", Locale=" + UnicodeString(fLocale.getName())
 388             + ", doubleValue=" + number.getDouble()
 389             + ", longValue=" + number.getLong()
 390             + ", origValue=" + aNumber
 391             );
 392     }
 393     if (number.getLong() != aNumber) {
 394         errln("**** FAIL: Parse of " + prettify(stringNum) + " failed. Got:" + number.getLong()
 395             + " Expected:" + aNumber);
 396     }
 397 }
 398
 399 void IntlTestNumberFormat::testAvailableLocales(/* char* par */)
 400 {
 401     int32_t count = 0;
 402     const Locale* locales = NumberFormat::getAvailableLocales(count);
 403     logln((UnicodeString)"" + count + " available locales");
 404     if (locales && count)
 405     {
 406         UnicodeString name;
 407         UnicodeString all;
 408         for (int32_t i=0; i<count; ++i)
 409         {
 410             if (i!=0)
 411                 all += ", ";
 412             all += locales[i].getName();
 413         }
 414         logln(all);
 415     }
 416     else
 417         dataerrln((UnicodeString)"**** FAIL: Zero available locales or null array pointer");
 418 }
 419
 420 void IntlTestNumberFormat::monsterTest(/* char* par */)
 421 {
 422     const char *SEP = "============================================================\n";
 423     int32_t count;
 424     const Locale* allLocales = NumberFormat::getAvailableLocales(count);
 425     Locale* locales = (Locale*)allLocales;
 426     Locale quickLocales[6];
 427     if (allLocales && count)
 428     {
 429         if (quick && count > 6) {
 430             logln("quick test: testing just 6 locales!");
 431             count = 6;
 432             locales = quickLocales;
 433             locales[0] = allLocales[0];
 434             locales[1] = allLocales[1];
 435             locales[2] = allLocales[2];
 436             // In a quick test, make sure we test locales that use
 437             // currency prefix, currency suffix, and choice currency
 438             // logic.  Otherwise bugs in these areas can slip through.
 439             locales[3] = Locale("ar", "AE", "");
 440             locales[4] = Locale("cs", "CZ", "");
 441             locales[5] = Locale("en", "IN", "");
 442         }
 443         for (int32_t i=0; i<count; ++i)
 444         {
 445             UnicodeString name(locales[i].getName(), "");
 446             logln(SEP);
 447             testLocale(/* par, */locales[i], name);
 448         }
 449     }
 450
 451     logln(SEP);
 452 }
 453
 454 #endif /* #if !UCONFIG_NO_FORMATTING */