X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/374ca955a76ecab1204ca8bfa63ff9238d998416..HEAD:/icuSources/test/cintltst/cnumtst.c diff --git a/icuSources/test/cintltst/cnumtst.c b/icuSources/test/cintltst/cnumtst.c index c5d8598a..c5826c53 100644 --- a/icuSources/test/cintltst/cnumtst.c +++ b/icuSources/test/cintltst/cnumtst.c @@ -1,6 +1,8 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html /******************************************************************** * COPYRIGHT: - * Copyright (c) 1997-2004, International Business Machines Corporation and + * Copyright (c) 1997-2016, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ /******************************************************************************** @@ -24,61 +26,179 @@ #if !UCONFIG_NO_FORMATTING #include "unicode/uloc.h" +#include "unicode/umisc.h" #include "unicode/unum.h" +#include "unicode/unumsys.h" #include "unicode/ustring.h" +#include "unicode/udisplaycontext.h" +#include "unicode/uchar.h" +#include "unicode/ures.h" // TAKE ME OUT!!! + #include "cintltst.h" #include "cnumtst.h" #include "cmemory.h" +#include "cstring.h" #include "putilimp.h" +#include "uassert.h" +#include +#include + +#define APPLE_ADDITIONS 1 + +static const char *tagAssert(const char *f, int32_t l, const char *msg) { + static char _fileline[1000]; + sprintf(_fileline, "%s:%d: ASSERT_TRUE(%s)", f, l, msg); + return _fileline; +} -#define LENGTH(arr) (sizeof(arr)/sizeof(arr[0])) +#define ASSERT_TRUE(x) assertTrue(tagAssert(__FILE__, __LINE__, #x), (x)) void addNumForTest(TestNode** root); +static void TestTextAttributeCrash(void); +static void TestNBSPInPattern(void); +static void TestInt64Parse(void); +static void TestParseCurrency(void); +static void TestMaxInt(void); +static void TestNoExponent(void); +static void TestSignAlwaysShown(void); +static void TestMinimumGroupingDigits(void); +static void TestParseCaseSensitive(void); +static void TestUFormattable(void); +static void TestUNumberingSystem(void); +static void TestCurrencyIsoPluralFormat(void); +static void TestContext(void); +static void TestCurrencyUsage(void); +static void TestCurrFmtNegSameAsPositive(void); +static void TestVariousStylesAndAttributes(void); +static void TestParseCurrPatternWithDecStyle(void); +static void TestFormatForFields(void); +static void TestRBNFRounding(void); +static void Test12052_NullPointer(void); +static void TestParseCases(void); +static void TestSetMaxFracAndRoundIncr(void); +static void TestIgnorePadding(void); +static void TestSciNotationMaxFracCap(void); + +static void TestParseAltNum(void); +static void TestParseCurrPatternWithDecStyle(void); +static void TestFormatPrecision(void); +static void TestSetSigDigAndRoundIncr(void); // Apple +static void TestSetAffixOnCurrFmt(void); // Apple +static void TestParseWithEmptyCurr(void); // Apple +static void TestSciNotationNumbers(void); // Apple +static void TestSciNotationPrecision(void); // Apple +static void TestMinimumGrouping(void); // Apple +static void TestNumberSystemsMultiplier(void); // Apple +static void TestParseScientific(void); // Apple +static void TestCurrForUnkRegion(void); // Apple +static void TestMinIntMinFracZero(void); // Apple +#if APPLE_ADDITIONS +static void TestFormatDecPerf(void); // Apple +static void TestCountryFallback(void); // Apple +#endif #define TESTCASE(x) addTest(root, &x, "tsformat/cnumtst/" #x) void addNumForTest(TestNode** root) { TESTCASE(TestNumberFormat); + TESTCASE(TestSpelloutNumberParse); TESTCASE(TestSignificantDigits); + TESTCASE(TestSigDigRounding); TESTCASE(TestNumberFormatPadding); TESTCASE(TestInt64Format); TESTCASE(TestNonExistentCurrency); + TESTCASE(TestCurrencyRegression); + TESTCASE(TestTextAttributeCrash); TESTCASE(TestRBNFFormat); + TESTCASE(TestRBNFRounding); + TESTCASE(TestNBSPInPattern); + TESTCASE(TestInt64Parse); + TESTCASE(TestParseZero); + TESTCASE(TestParseCurrency); + TESTCASE(TestCloneWithRBNF); + TESTCASE(TestMaxInt); + TESTCASE(TestNoExponent); + TESTCASE(TestSignAlwaysShown); + TESTCASE(TestMinimumGroupingDigits); + TESTCASE(TestParseCaseSensitive); + TESTCASE(TestUFormattable); + TESTCASE(TestUNumberingSystem); + TESTCASE(TestCurrencyIsoPluralFormat); + TESTCASE(TestContext); + TESTCASE(TestCurrencyUsage); + TESTCASE(TestCurrFmtNegSameAsPositive); + TESTCASE(TestVariousStylesAndAttributes); + TESTCASE(TestParseCurrPatternWithDecStyle); + TESTCASE(TestFormatForFields); + TESTCASE(Test12052_NullPointer); + TESTCASE(TestParseCases); + TESTCASE(TestSetMaxFracAndRoundIncr); + TESTCASE(TestIgnorePadding); + TESTCASE(TestSciNotationMaxFracCap); + + TESTCASE(TestParseAltNum); + TESTCASE(TestParseCurrPatternWithDecStyle); + TESTCASE(TestFormatPrecision); + TESTCASE(TestSetSigDigAndRoundIncr); // Apple + TESTCASE(TestSetAffixOnCurrFmt); // Apple + TESTCASE(TestParseWithEmptyCurr); // Apple + TESTCASE(TestSciNotationNumbers); // Apple + TESTCASE(TestSciNotationPrecision); // Apple + TESTCASE(TestMinimumGrouping); // Apple + TESTCASE(TestNumberSystemsMultiplier); // Apple + TESTCASE(TestParseScientific); // Apple + TESTCASE(TestCurrForUnkRegion); // Apple + TESTCASE(TestMinIntMinFracZero); // Apple +#if APPLE_ADDITIONS + TESTCASE(TestFormatDecPerf); // Apple + TESTCASE(TestCountryFallback); // Apple +#endif } -/** copy src to dst with unicode-escapes for values < 0x20 and > 0x7e, null terminate if possible */ -static int32_t ustrToAstr(const UChar* src, int32_t srcLength, char* dst, int32_t dstLength) { - static const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; - - char *p = dst; - const char *e = p + dstLength; - if (srcLength < 0) { - const UChar* s = src; - while (*s) { - ++s; - } - srcLength = (int32_t)(s - src); - } - while (p < e && --srcLength >= 0) { - UChar c = *src++; - if (c == 0xd || c == 0xa || c == 0x9 || (c>= 0x20 && c <= 0x7e)) { - *p++ = (char) c & 0x7f; - } else if (e - p >= 6) { - *p++ = '\\'; - *p++ = 'u'; - *p++ = hex[(c >> 12) & 0xf]; - *p++ = hex[(c >> 8) & 0xf]; - *p++ = hex[(c >> 4) & 0xf]; - *p++ = hex[c & 0xf]; - } else { - break; - } +/* test Parse int 64 */ + +static void TestInt64Parse() +{ + + UErrorCode st = U_ZERO_ERROR; + UErrorCode* status = &st; + + const char* st1 = "009223372036854775808"; + const int size = 21; + UChar text[21]; + + + UNumberFormat* nf; + + int64_t a; + + u_charsToUChars(st1, text, size); + nf = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, status); + + if(U_FAILURE(*status)) + { + log_data_err("Error in unum_open() %s \n", myErrorName(*status)); + return; + } + + log_verbose("About to test unum_parseInt64() with out of range number\n"); + + a = unum_parseInt64(nf, text, size, 0, status); + (void)a; /* Suppress set but not used warning. */ + + + if(!U_FAILURE(*status)) + { + log_err("Error in unum_parseInt64(): %s \n", myErrorName(*status)); } - if (p < e) { - *p = 0; + else + { + log_verbose("unum_parseInt64() successful\n"); } - return (int32_t)(p - dst); + + unum_close(nf); + return; } /* test Number Format API */ @@ -96,7 +216,7 @@ static void TestNumberFormat() int32_t resultlength; int32_t resultlengthneeded; int32_t parsepos; - double d1; + double d1 = -1.0; int32_t l1; double d = -10456.37; double a = 1234.56, a1 = 1235.0; @@ -119,8 +239,13 @@ static void TestNumberFormat() status = U_ZERO_ERROR; log_verbose("Testing unum_open() with default style and locale\n"); def=unum_open(style, NULL,0,NULL, NULL,&status); + + /* Might as well pack it in now if we can't even get a default NumberFormat... */ if(U_FAILURE(status)) - log_err("Error in creating NumberFormat default using unum_open(): %s\n", myErrorName(status)); + { + log_data_err("Error in creating default NumberFormat using unum_open(): %s (Are you missing data?)\n", myErrorName(status)); + return; + } log_verbose("\nTesting unum_open() with french locale and default style(decimal)\n"); fr=unum_open(style,NULL,0, "fr_FR",NULL, &status); @@ -138,7 +263,7 @@ static void TestNumberFormat() log_verbose("\nTesting unum_open(currency, frenchlocale, status)\n"); cur_fr=unum_open(style,NULL,0, "fr_FR", NULL, &status); if(U_FAILURE(status)) - log_err("Error: could not create NumberFormat using unum_open(currency, french, &status): %s\n", + log_err("Error: could not create NumberFormat using unum_open(currency, french, &status): %s\n", myErrorName(status)); log_verbose("\nTesting unum_open(percent, NULL, status)\n"); @@ -193,7 +318,7 @@ static void TestNumberFormat() log_verbose("\nTesting unum_format() \n"); resultlength=0; - pos1.field = 0; /* Integer Section */ + pos1.field = UNUM_INTEGER_FIELD; resultlengthneeded=unum_format(cur_def, l, NULL, resultlength, &pos1, &status); if(status==U_BUFFER_OVERFLOW_ERROR) { @@ -220,13 +345,13 @@ static void TestNumberFormat() log_err("Fail: Error in complete number Formatting using unum_format()\nGot: b=%d end=%d\nExpected: b=1 end=12\n", pos1.beginIndex, pos1.endIndex); -free(result); + free(result); result = 0; log_verbose("\nTesting unum_formatDouble()\n"); - u_uastrcpy(temp1, "($10,456.37)"); + u_uastrcpy(temp1, "-$10,456.37"); resultlength=0; - pos2.field = 1; /* Fractional Section */ + pos2.field = UNUM_FRACTION_FIELD; resultlengthneeded=unum_formatDouble(cur_def, d, NULL, resultlength, &pos2, &status); if(status==U_BUFFER_OVERFLOW_ERROR) { @@ -242,10 +367,12 @@ free(result); { log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status)); } - if(u_strcmp(result, temp1)==0) + if(result && u_strcmp(result, temp1)==0) log_verbose("Pass: Number Formatting using unum_formatDouble() Successful\n"); - else - log_err("FAIL: Error in number formatting using unum_formatDouble()\n"); + else { + log_err("FAIL: Error in number formatting using unum_formatDouble() - got '%s' expected '%s'\n", + aescstrdup(result, -1), aescstrdup(temp1, -1)); + } if(pos2.beginIndex == 9 && pos2.endIndex == 11) log_verbose("Pass: Complete number formatting using unum_format() successful\n"); else @@ -256,13 +383,14 @@ free(result); /* Testing unum_parse() and unum_parseDouble() */ log_verbose("\nTesting unum_parseDouble()\n"); /* for (i = 0; i < 100000; i++)*/ - { - parsepos=0; - d1=unum_parseDouble(cur_def, result, u_strlen(result), &parsepos, &status); + parsepos=0; + if (result != NULL) { + d1=unum_parseDouble(cur_def, result, u_strlen(result), &parsepos, &status); + } else { + log_err("result is NULL\n"); } - if(U_FAILURE(status)) - { - log_err("parse failed. The error is : %s\n", myErrorName(status)); + if(U_FAILURE(status)) { + log_err("parse of '%s' failed. Parsepos=%d. The error is : %s\n", aescstrdup(result,u_strlen(result)),parsepos, myErrorName(status)); } if(d1!=d) @@ -273,14 +401,14 @@ free(result); free(result); result = 0; - + status = U_ZERO_ERROR; /* Testing unum_formatDoubleCurrency / unum_parseDoubleCurrency */ log_verbose("\nTesting unum_formatDoubleCurrency\n"); u_uastrcpy(temp1, "Y1,235"); temp1[0] = 0xA5; /* Yen sign */ u_uastrcpy(temp, "JPY"); resultlength=0; - pos2.field = 0; /* integer part */ + pos2.field = UNUM_INTEGER_FIELD; resultlengthneeded=unum_formatDoubleCurrency(cur_def, a, temp, NULL, resultlength, &pos2, &status); if (status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; @@ -289,39 +417,46 @@ free(result); unum_formatDoubleCurrency(cur_def, a, temp, result, resultlength, &pos2, &status); } if (U_FAILURE(status)) { - log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status)); + log_err("Error in formatting using unum_formatDoubleCurrency(.....): %s\n", myErrorName(status)); } if (result && u_strcmp(result, temp1)==0) { - log_verbose("Pass: Number Formatting using unum_formatDouble() Successful\n"); + log_verbose("Pass: Number Formatting using unum_formatDoubleCurrency() Successful\n"); } else { - log_err("FAIL: Error in number formatting using unum_formatDouble()\n"); + log_err("FAIL: Error in number formatting using unum_formatDoubleCurrency() - got '%s' expected '%s'\n", + aescstrdup(result, -1), aescstrdup(temp1, -1)); } if (pos2.beginIndex == 1 && pos2.endIndex == 6) { log_verbose("Pass: Complete number formatting using unum_format() successful\n"); } else { - log_err("Fail: Error in complete number Formatting using unum_formatDouble()\nGot: b=%d end=%d\nExpected: b=1 end=6", + log_err("Fail: Error in complete number Formatting using unum_formatDouble()\nGot: b=%d end=%d\nExpected: b=1 end=6\n", pos1.beginIndex, pos1.endIndex); } log_verbose("\nTesting unum_parseDoubleCurrency\n"); parsepos=0; - d1=unum_parseDoubleCurrency(cur_def, result, u_strlen(result), &parsepos, temp2, &status); - if (U_FAILURE(status)) { - log_err("parse failed. The error is : %s\n", myErrorName(status)); - } - /* Note: a==1234.56, but on parse expect a1=1235.0 */ - if (d1!=a1) { - log_err("Fail: Error in parsing currency, got %f, expected %f\n", d1, a1); - } else { - log_verbose("Pass: parsed currency ammount successfully\n"); + if (result == NULL) { + log_err("result is NULL\n"); } - if (u_strcmp(temp2, temp)==0) { - log_verbose("Pass: parsed correct currency\n"); - } else { - log_err("Fail: parsed incorrect currency\n"); + else { + d1=unum_parseDoubleCurrency(cur_def, result, u_strlen(result), &parsepos, temp2, &status); + if (U_FAILURE(status)) { + log_err("parseDoubleCurrency '%s' failed. The error is : %s\n", aescstrdup(result, u_strlen(result)), myErrorName(status)); + } + /* Note: a==1234.56, but on parse expect a1=1235.0 */ + if (d1!=a1) { + log_err("Fail: Error in parsing currency, got %f, expected %f\n", d1, a1); + } else { + log_verbose("Pass: parsed currency amount successfully\n"); + } + if (u_strcmp(temp2, temp)==0) { + log_verbose("Pass: parsed correct currency\n"); + } else { + log_err("Fail: parsed incorrect currency\n"); + } } + status = U_ZERO_ERROR; /* reset */ -free(result); + free(result); result = 0; @@ -335,10 +470,16 @@ free(result); } if(U_FAILURE(status)) { - log_err("parse failed. The error is : %s\n", myErrorName(status)); + log_err("parseDouble('%s') failed. The error is : %s\n", aescstrdup(temp1, resultlength), myErrorName(status)); } - if(d1!=462.12345) + /* + * Note: "for strict standard conformance all operations and constants are now supposed to be + evaluated in precision of long double". So, we assign a1 before comparing to a double. Bug #7932. + */ + a1 = 462.12345; + + if(d1!=a1) log_err("Fail: Error in parsing\n"); else log_verbose("Pass: parsing successful\n"); @@ -399,7 +540,7 @@ free(result); pattern=unum_open(UNUM_IGNORE,temp1, u_strlen(temp1), NULL, NULL,&status); if(U_FAILURE(status)) { - log_err("error in unum_openPattern(): %s\n", myErrorName(status) );; + log_err("error in unum_openPattern(): %s\n", myErrorName(status) ); } else log_verbose("Pass: unum_openPattern() works fine\n"); @@ -512,7 +653,7 @@ free(result); { log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status)); } - /* TODO: + /* TODO: * This test fails because we have not called unum_applyPattern(). * Currently, such an applyPattern() does not exist on the C API, and * we have jitterbug 411 for it. @@ -541,7 +682,7 @@ free(result); } } for(i = 0; i < UNUM_FORMAT_SYMBOL_COUNT; ++i) { - resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status); + resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status); if(U_FAILURE(status)) { log_err("Error from unum_getSymbol(%d): %s\n", i, myErrorName(status)); return; @@ -551,7 +692,7 @@ free(result); } } /*try getting from a bogus symbol*/ - unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status); + unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status); if(U_SUCCESS(status)){ log_err("Error : Expected U_ILLEGAL_ARGUMENT_ERROR for bogus symbol"); } @@ -601,7 +742,7 @@ free(result); log_err("error in getting the text attributes : %s\n", myErrorName(status)); } - if(u_strcmp(prefix, temp)!=0) + if(u_strcmp(prefix, temp)!=0) log_err("ERROR: get and setTextAttributes with positive prefix failed\n"); else log_verbose("Pass: get and setTextAttributes with positive prefix works fine\n"); @@ -617,7 +758,7 @@ free(result); { log_err("error in getting the text attributes : %s\n", myErrorName(status)); } - if(u_strcmp(prefix, temp)!=0) + if(u_strcmp(prefix, temp)!=0) log_err("ERROR: get and setTextAttributes with negative prefix failed\n"); else log_verbose("Pass: get and setTextAttributes with negative prefix works fine\n"); @@ -634,7 +775,7 @@ free(result); { log_err("error in getting the text attributes : %s\n", myErrorName(status)); } - if(u_strcmp(suffix, temp)!=0) + if(u_strcmp(suffix, temp)!=0) log_err("ERROR: get and setTextAttributes with negative suffix failed\n"); else log_verbose("Pass: get and settextAttributes with negative suffix works fine\n"); @@ -651,7 +792,7 @@ free(result); { log_err("error in getting the text attributes : %s\n", myErrorName(status)); } - if(u_strcmp(suffix, temp)!=0) + if(u_strcmp(suffix, temp)!=0) log_err("ERROR: get and setTextAttributes with negative suffix failed\n"); else log_verbose("Pass: get and settextAttributes with negative suffix works fine\n"); @@ -681,7 +822,8 @@ free(result); newvalue=2; unum_setAttribute(def, attr, newvalue); if(unum_getAttribute(def,attr) != 2) - log_err("error in setting and getting attributes for UNUM_SECONDARY_GROUPING_SIZE\n"); + log_err("error in setting and getting attributes for UNUM_SECONDARY_GROUPING_SIZE: got %d\n", + unum_getAttribute(def,attr)); else log_verbose("Pass:setting and getting attributes for UNUM_SECONDARY_GROUPING_SIZE works fine\n"); @@ -702,20 +844,19 @@ free(result); if (spellout_def) { static const int32_t values[] = { 0, -5, 105, 1005, 105050 }; - for (i = 0; i < LENGTH(values); ++i) { + for (i = 0; i < UPRV_LENGTHOF(values); ++i) { UChar buffer[128]; int32_t len; int32_t value = values[i]; status = U_ZERO_ERROR; - len = unum_format(spellout_def, value, buffer, LENGTH(buffer), NULL, &status); + len = unum_format(spellout_def, value, buffer, UPRV_LENGTHOF(buffer), NULL, &status); if(U_FAILURE(status)) { log_err("Error in formatting using unum_format(spellout_fmt, ...): %s\n", myErrorName(status)); } else { int32_t pp = 0; int32_t parseResult; - char logbuf[256]; - ustrToAstr(buffer, len, logbuf, LENGTH(logbuf)); - log_verbose("formatted %d as '%s', length: %d\n", value, logbuf, len); + /*ustrToAstr(buffer, len, logbuf, UPRV_LENGTHOF(logbuf));*/ + log_verbose("formatted %d as '%s', length: %d\n", value, aescstrdup(buffer, len), len); parseResult = unum_parse(spellout_def, buffer, len, &pp, &status); if (U_FAILURE(status)) { @@ -730,6 +871,160 @@ free(result); log_err("Spellout format is unavailable\n"); } + { /* Test for ticket #7079 */ + UNumberFormat* dec_en; + UChar groupingSep[] = { 0 }; + UChar numPercent[] = { 0x0031, 0x0032, 0x0025, 0 }; /* "12%" */ + double parseResult = 0.0; + + status=U_ZERO_ERROR; + dec_en = unum_open(UNUM_DECIMAL, NULL, 0, "en_US", NULL, &status); + unum_setAttribute(dec_en, UNUM_LENIENT_PARSE, 0); + unum_setSymbol(dec_en, UNUM_GROUPING_SEPARATOR_SYMBOL, groupingSep, 0, &status); + parseResult = unum_parseDouble(dec_en, numPercent, -1, NULL, &status); + /* Without the fix in #7079, the above call will hang */ + if ( U_FAILURE(status) || parseResult != 12.0 ) { + log_err("unum_parseDouble with empty groupingSep: status %s, parseResult %f not 12.0\n", + myErrorName(status), parseResult); + } else { + log_verbose("unum_parseDouble with empty groupingSep: no hang, OK\n"); + } + unum_close(dec_en); + } + + { /* Test parse & format of big decimals. Use a number with too many digits to fit in a double, + to verify that it is taking the pure decimal path. */ + UNumberFormat *fmt; + const char *bdpattern = "#,##0.#########"; + const char *numInitial = "12345678900987654321.1234567896"; + const char *numFormatted = "12,345,678,900,987,654,321.12345679"; + const char *parseExpected = "1.234567890098765432112345679E+19"; + const char *parseExpected2 = "3.4567890098765432112345679E+17"; + int32_t resultSize = 0; + int32_t parsePos = 0; /* Output parameter for Parse operations. */ + #define DESTCAPACITY 100 + UChar dest[DESTCAPACITY]; + char desta[DESTCAPACITY]; + UFieldPosition fieldPos = {0}; + + /* Format */ + + status = U_ZERO_ERROR; + u_uastrcpy(dest, bdpattern); + fmt = unum_open(UNUM_PATTERN_DECIMAL, dest, -1, "en", NULL /*parseError*/, &status); + if (U_FAILURE(status)) log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + + resultSize = unum_formatDecimal(fmt, numInitial, -1, dest, DESTCAPACITY, NULL, &status); + if (U_FAILURE(status)) { + log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + } + u_austrncpy(desta, dest, DESTCAPACITY); + if (strcmp(numFormatted, desta) != 0) { + log_err("File %s, Line %d, (expected, acutal) = (\"%s\", \"%s\")\n", + __FILE__, __LINE__, numFormatted, desta); + } + if ((int32_t)strlen(numFormatted) != resultSize) { + log_err("File %s, Line %d, (expected, actual) = (%d, %d)\n", + __FILE__, __LINE__, (int32_t)strlen(numFormatted), resultSize); + } + + /* Format with a FieldPosition parameter */ + + fieldPos.field = UNUM_DECIMAL_SEPARATOR_FIELD; + resultSize = unum_formatDecimal(fmt, numInitial, -1, dest, DESTCAPACITY, &fieldPos, &status); + if (U_FAILURE(status)) { + log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + } + u_austrncpy(desta, dest, DESTCAPACITY); + if (strcmp(numFormatted, desta) != 0) { + log_err("File %s, Line %d, (expected, acutal) = (\"%s\", \"%s\")\n", + __FILE__, __LINE__, numFormatted, desta); + } + if (fieldPos.beginIndex != 26) { /* index of "." in formatted number */ + log_err("File %s, Line %d, (expected, acutal) = (%d, %d)\n", + __FILE__, __LINE__, 0, fieldPos.beginIndex); + } + if (fieldPos.endIndex != 27) { + log_err("File %s, Line %d, (expected, acutal) = (%d, %d)\n", + __FILE__, __LINE__, 0, fieldPos.endIndex); + } + + /* Parse */ + + status = U_ZERO_ERROR; + u_uastrcpy(dest, numFormatted); /* Parse the expected output of the formatting test */ + resultSize = unum_parseDecimal(fmt, dest, -1, NULL, desta, DESTCAPACITY, &status); + if (U_FAILURE(status)) { + log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + } + if (uprv_strcmp(parseExpected, desta) != 0) { + log_err("File %s, Line %d, (expected, actual) = (\"%s\", \"%s\")\n", + __FILE__, __LINE__, parseExpected, desta); + } else { + log_verbose("File %s, Line %d, got expected = \"%s\"\n", + __FILE__, __LINE__, desta); + } + if ((int32_t)strlen(parseExpected) != resultSize) { + log_err("File %s, Line %d, (expected, actual) = (%d, %d)\n", + __FILE__, __LINE__, (int32_t)strlen(parseExpected), resultSize); + } + + /* Parse with a parsePos parameter */ + + status = U_ZERO_ERROR; + u_uastrcpy(dest, numFormatted); /* Parse the expected output of the formatting test */ + parsePos = 3; /* 12,345,678,900,987,654,321.12345679 */ + /* start parsing at the the third char */ + resultSize = unum_parseDecimal(fmt, dest, -1, &parsePos, desta, DESTCAPACITY, &status); + if (U_FAILURE(status)) { + log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + } + if (strcmp(parseExpected2, desta) != 0) { /* "3.4567890098765432112345679E+17" */ + log_err("File %s, Line %d, (expected, actual) = (\"%s\", \"%s\")\n", + __FILE__, __LINE__, parseExpected2, desta); + } else { + log_verbose("File %s, Line %d, got expected = \"%s\"\n", + __FILE__, __LINE__, desta); + } + if ((int32_t)strlen(numFormatted) != parsePos) { + log_err("File %s, Line %d, parsePos (expected, actual) = (\"%d\", \"%d\")\n", + __FILE__, __LINE__, (int32_t)strlen(parseExpected), parsePos); + } + + unum_close(fmt); + } + + status = U_ZERO_ERROR; + /* Test invalid symbol argument */ + { + int32_t badsymbolLarge = UNUM_FORMAT_SYMBOL_COUNT + 1; + int32_t badsymbolSmall = -1; + UChar value[10]; + int32_t valueLength = 10; + UNumberFormat *fmt = unum_open(UNUM_DEFAULT, NULL, 0, NULL, NULL, &status); + if (U_FAILURE(status)) { + log_err("File %s, Line %d, status = %s\n", __FILE__, __LINE__, u_errorName(status)); + } else { + unum_getSymbol(fmt, (UNumberFormatSymbol)badsymbolLarge, NULL, 0, &status); + if (U_SUCCESS(status)) log_err("unum_getSymbol()'s status should be ILLEGAL_ARGUMENT with invalid symbol (> UNUM_FORMAT_SYMBOL_COUNT) argument\n"); + + status = U_ZERO_ERROR; + unum_getSymbol(fmt, (UNumberFormatSymbol)badsymbolSmall, NULL, 0, &status); + if (U_SUCCESS(status)) log_err("unum_getSymbol()'s status should be ILLEGAL_ARGUMENT with invalid symbol (less than 0) argument\n"); + + status = U_ZERO_ERROR; + unum_setSymbol(fmt, (UNumberFormatSymbol)badsymbolLarge, value, valueLength, &status); + if (U_SUCCESS(status)) log_err("unum_setSymbol()'s status should be ILLEGAL_ARGUMENT with invalid symbol (> UNUM_FORMAT_SYMBOL_COUNT) argument\n"); + + status = U_ZERO_ERROR; + unum_setSymbol(fmt, (UNumberFormatSymbol)badsymbolSmall, value, valueLength, &status); + if (U_SUCCESS(status)) log_err("unum_setSymbol()'s status should be ILLEGAL_ARGUMENT with invalid symbol (less than 0) argument\n"); + + unum_close(fmt); + } + } + + /*closing the NumberFormat() using unum_close(UNumberFormat*)")*/ unum_close(def); unum_close(fr); @@ -744,6 +1039,276 @@ free(result); } +static void TestParseZero(void) +{ + UErrorCode errorCode = U_ZERO_ERROR; + UChar input[] = {0x30, 0}; /* Input text is decimal '0' */ + UChar pat[] = {0x0023,0x003b,0x0023,0}; /* {'#', ';', '#', 0}; */ + double dbl; + +#if 0 + UNumberFormat* unum = unum_open( UNUM_DECIMAL /*or UNUM_DEFAULT*/, NULL, -1, NULL, NULL, &errorCode); +#else + UNumberFormat* unum = unum_open( UNUM_PATTERN_DECIMAL /*needs pattern*/, pat, -1, NULL, NULL, &errorCode); +#endif + + dbl = unum_parseDouble( unum, input, -1 /*u_strlen(input)*/, 0 /* 0 = start */, &errorCode ); + if (U_FAILURE(errorCode)) { + log_data_err("Result - %s\n", u_errorName(errorCode)); + } else { + log_verbose("Double: %f\n", dbl); + } + unum_close(unum); +} + +static const UChar dollars2Sym[] = { 0x24,0x32,0x2E,0x30,0x30,0 }; /* $2.00 */ +static const UChar dollars4Sym[] = { 0x24,0x34,0 }; /* $4 */ +static const UChar dollarsUS4Sym[] = { 0x55,0x53,0x24,0x34,0 }; /* US$4 */ +static const UChar dollars9Sym[] = { 0x39,0xA0,0x24,0 }; /* 9 $ */ +static const UChar pounds3Sym[] = { 0xA3,0x33,0x2E,0x30,0x30,0 }; /* [POUND]3.00 */ +static const UChar pounds5Sym[] = { 0xA3,0x35,0 }; /* [POUND]5 */ +static const UChar pounds7Sym[] = { 0x37,0xA0,0xA3,0 }; /* 7 [POUND] */ +static const UChar euros4Sym[] = { 0x34,0x2C,0x30,0x30,0xA0,0x20AC,0 }; /* 4,00 [EURO] */ +static const UChar euros6Sym[] = { 0x36,0xA0,0x20AC,0 }; /* 6 [EURO] */ +static const UChar euros8Sym[] = { 0x20AC,0x38,0 }; /* [EURO]8 */ +static const UChar dollars4PluEn[] = { 0x34,0x20,0x55,0x53,0x20,0x64,0x6F,0x6C,0x6C,0x61,0x72,0x73,0 }; /* 4 US dollars*/ +static const UChar pounds5PluEn[] = { 0x35,0x20,0x42,0x72,0x69,0x74,0x69,0x73,0x68,0x20,0x70,0x6F,0x75,0x6E,0x64,0x73,0x20,0x73,0x74,0x65,0x72,0x6C,0x69,0x6E,0x67,0 }; /* 5 British pounds sterling */ +static const UChar euros8PluEn[] = { 0x38,0x20,0x65,0x75,0x72,0x6F,0x73,0 }; /* 8 euros*/ +static const UChar euros6PluFr[] = { 0x36,0x20,0x65,0x75,0x72,0x6F,0x73,0 }; /* 6 euros*/ + +typedef struct { + const char * locale; + const char * descrip; + const UChar * currStr; + const UChar * plurStr; + UErrorCode parsDoubExpectErr; + int32_t parsDoubExpectPos; + double parsDoubExpectVal; + UErrorCode parsCurrExpectErr; + int32_t parsCurrExpectPos; + double parsCurrExpectVal; + const char * parsCurrExpectCurr; +} ParseCurrencyItem; + +static const ParseCurrencyItem parseCurrencyItems[] = { + { "en_US", "dollars2", dollars2Sym, NULL, U_ZERO_ERROR, 5, 2.0, U_ZERO_ERROR, 5, 2.0, "USD" }, + { "en_US", "dollars4", dollars4Sym, dollars4PluEn, U_ZERO_ERROR, 2, 4.0, U_ZERO_ERROR, 2, 4.0, "USD" }, + { "en_US", "dollars9", dollars9Sym, NULL, U_PARSE_ERROR, 1, 0.0, U_PARSE_ERROR, 1, 0.0, "" }, + { "en_US", "pounds3", pounds3Sym, NULL, U_PARSE_ERROR, 0, 0.0, U_ZERO_ERROR, 5, 3.0, "GBP" }, + { "en_US", "pounds5", pounds5Sym, pounds5PluEn, U_PARSE_ERROR, 0, 0.0, U_ZERO_ERROR, 2, 5.0, "GBP" }, + { "en_US", "pounds7", pounds7Sym, NULL, U_PARSE_ERROR, 1, 0.0, U_PARSE_ERROR, 1, 0.0, "" }, + { "en_US", "euros8", euros8Sym, euros8PluEn, U_PARSE_ERROR, 0, 0.0, U_ZERO_ERROR, 2, 8.0, "EUR" }, + + { "en_GB", "pounds3", pounds3Sym, NULL, U_ZERO_ERROR, 5, 3.0, U_ZERO_ERROR, 5, 3.0, "GBP" }, + { "en_GB", "pounds5", pounds5Sym, pounds5PluEn, U_ZERO_ERROR, 2, 5.0, U_ZERO_ERROR, 2, 5.0, "GBP" }, + { "en_GB", "pounds7", pounds7Sym, NULL, U_PARSE_ERROR, 1, 0.0, U_PARSE_ERROR, 1, 0.0, "" }, + { "en_GB", "euros4", euros4Sym, NULL, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, 0.0, "" }, + { "en_GB", "euros6", euros6Sym, NULL, U_PARSE_ERROR, 1, 0.0, U_PARSE_ERROR, 1, 0.0, "" }, + { "en_GB", "euros8", euros8Sym, euros8PluEn, U_PARSE_ERROR, 0, 0.0, U_ZERO_ERROR, 2, 8.0, "EUR" }, + { "en_GB", "dollars4", dollarsUS4Sym,dollars4PluEn, U_PARSE_ERROR, 0, 0.0, U_ZERO_ERROR, 4, 4.0, "USD" }, + + { "fr_FR", "euros4", euros4Sym, NULL, U_ZERO_ERROR, 6, 4.0, U_ZERO_ERROR, 6, 4.0, "EUR" }, + { "fr_FR", "euros6", euros6Sym, euros6PluFr, U_ZERO_ERROR, 3, 6.0, U_ZERO_ERROR, 3, 6.0, "EUR" }, + { "fr_FR", "euros8", euros8Sym, NULL, U_PARSE_ERROR, 2, 0.0, U_PARSE_ERROR, 2, 0.0, "" }, + { "fr_FR", "dollars2", dollars2Sym, NULL, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, 0.0, "" }, + { "fr_FR", "dollars4", dollars4Sym, NULL, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, 0.0, "" }, + + { NULL, NULL, NULL, NULL, 0, 0, 0.0, 0, 0, 0.0, NULL } +}; + +static void TestParseCurrency() +{ + const ParseCurrencyItem * itemPtr; + for (itemPtr = parseCurrencyItems; itemPtr->locale != NULL; ++itemPtr) { + UNumberFormat* unum; + UErrorCode status; + double parseVal; + int32_t parsePos; + UChar parseCurr[4]; + char parseCurrB[4]; + + status = U_ZERO_ERROR; + unum = unum_open(UNUM_CURRENCY, NULL, 0, itemPtr->locale, NULL, &status); + if (U_SUCCESS(status)) { + const UChar * currStr = itemPtr->currStr; + status = U_ZERO_ERROR; + parsePos = 0; + parseVal = unum_parseDouble(unum, currStr, -1, &parsePos, &status); + if (status != itemPtr->parsDoubExpectErr || parsePos != itemPtr->parsDoubExpectPos || parseVal != itemPtr->parsDoubExpectVal) { + log_err("UNUM_CURRENCY parseDouble %s/%s, expect %s pos %d val %.1f, get %s pos %d val %.1f\n", + itemPtr->locale, itemPtr->descrip, + u_errorName(itemPtr->parsDoubExpectErr), itemPtr->parsDoubExpectPos, itemPtr->parsDoubExpectVal, + u_errorName(status), parsePos, parseVal ); + } + status = U_ZERO_ERROR; + parsePos = 0; + parseCurr[0] = 0; + parseVal = unum_parseDoubleCurrency(unum, currStr, -1, &parsePos, parseCurr, &status); + u_austrncpy(parseCurrB, parseCurr, 4); + if (status != itemPtr->parsCurrExpectErr || parsePos != itemPtr->parsCurrExpectPos || parseVal != itemPtr->parsCurrExpectVal || + strncmp(parseCurrB, itemPtr->parsCurrExpectCurr, 4) != 0) { + log_err("UNUM_CURRENCY parseDoubleCurrency %s/%s, expect %s pos %d val %.1f cur %s, get %s pos %d val %.1f cur %s\n", + itemPtr->locale, itemPtr->descrip, + u_errorName(itemPtr->parsCurrExpectErr), itemPtr->parsCurrExpectPos, itemPtr->parsCurrExpectVal, itemPtr->parsCurrExpectCurr, + u_errorName(status), parsePos, parseVal, parseCurrB ); + } + unum_close(unum); + } else { + log_data_err("unexpected error in unum_open UNUM_CURRENCY for locale %s: '%s'\n", itemPtr->locale, u_errorName(status)); + } + + if (itemPtr->plurStr != NULL) { + status = U_ZERO_ERROR; + unum = unum_open(UNUM_CURRENCY_PLURAL, NULL, 0, itemPtr->locale, NULL, &status); + if (U_SUCCESS(status)) { + status = U_ZERO_ERROR; + parsePos = 0; + parseVal = unum_parseDouble(unum, itemPtr->plurStr, -1, &parsePos, &status); + if (status != itemPtr->parsDoubExpectErr || parseVal != itemPtr->parsDoubExpectVal) { + log_err("UNUM_CURRENCY parseDouble Plural %s/%s, expect %s val %.1f, get %s val %.1f\n", + itemPtr->locale, itemPtr->descrip, + u_errorName(itemPtr->parsDoubExpectErr), itemPtr->parsDoubExpectVal, + u_errorName(status), parseVal ); + } + status = U_ZERO_ERROR; + parsePos = 0; + parseCurr[0] = 0; + parseVal = unum_parseDoubleCurrency(unum, itemPtr->plurStr, -1, &parsePos, parseCurr, &status); + u_austrncpy(parseCurrB, parseCurr, 4); + if (status != itemPtr->parsCurrExpectErr || parseVal != itemPtr->parsCurrExpectVal || + strncmp(parseCurrB, itemPtr->parsCurrExpectCurr, 4) != 0) { + log_err("UNUM_CURRENCY parseDoubleCurrency Plural %s/%s, expect %s val %.1f cur %s, get %s val %.1f cur %s\n", + itemPtr->locale, itemPtr->descrip, + u_errorName(itemPtr->parsCurrExpectErr), itemPtr->parsCurrExpectVal, itemPtr->parsCurrExpectCurr, + u_errorName(status), parseVal, parseCurrB ); + } + unum_close(unum); + } else { + log_data_err("unexpected error in unum_open UNUM_CURRENCY_PLURAL for locale %s: '%s'\n", itemPtr->locale, u_errorName(status)); + } + } + } +} + +typedef struct { + const char * testname; + const char * locale; + UBool lenient; + const UChar * source; + int32_t startPos; + int32_t value; + int32_t endPos; + UErrorCode status; +} NumParseTestItem; + +static const UChar ustr_zh50d[] = {0x4E94, 0x3007, 0}; /* decimal 50 */ +static const UChar ustr_zh05a[] = {0x96F6, 0x4E94, 0}; /* decimal-alt 05 */ +static const UChar ustr_zh05d[] = {0x3007, 0x4E94, 0}; /* decimal 05 */ + +static const NumParseTestItem altnumParseTests[] = { + /* name loc lenent src start val end status */ + { "zh@hd,50dL","zh@numbers=hanidec", TRUE, ustr_zh50d, 0, 50, 2, U_USING_DEFAULT_WARNING }, + { "zh@hd,05aL","zh@numbers=hanidec", TRUE, ustr_zh05a, 0, 5, 2, U_USING_DEFAULT_WARNING }, + { "zh@hd,05dL","zh@numbers=hanidec", TRUE, ustr_zh05d, 0, 5, 2, U_USING_DEFAULT_WARNING }, + { NULL, NULL, FALSE, NULL, 0, 0, 0, 0 } /* terminator */ +}; + +static void TestParseAltNum(void) +{ + const NumParseTestItem * testPtr; + for (testPtr = altnumParseTests; testPtr->testname != NULL; ++testPtr) { + UErrorCode status = U_ZERO_ERROR; + int32_t value, position = testPtr->startPos; + UNumberFormat *nf = unum_open(UNUM_DECIMAL, NULL, 0, testPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_err_status(status, "unum_open fails for UNUM_DECIMAL with locale %s, status %s\n", testPtr->locale, myErrorName(status)); + continue; + } + unum_setAttribute(nf, UNUM_LENIENT_PARSE, testPtr->lenient); + value = unum_parse(nf, testPtr->source, -1, &position, &status); + if ( value != testPtr->value || position != testPtr->endPos || status != testPtr->status ) { + log_err("unum_parse DECIMAL, locale %s, testname %s, startPos %d: for value / endPos / status, expected %d / %d / %s, got %d / %d / %s\n", + testPtr->locale, testPtr->testname, testPtr->startPos, + testPtr->value, testPtr->endPos, myErrorName(testPtr->status), + value, position, myErrorName(status) ); + } + unum_close(nf); + } +} + +static const UChar ustr_en0[] = {0x7A, 0x65, 0x72, 0x6F, 0}; /* zero */ +static const UChar ustr_123[] = {0x31, 0x32, 0x33, 0}; /* 123 */ +static const UChar ustr_en123[] = {0x6f, 0x6e, 0x65, 0x20, 0x68, 0x75, 0x6e, 0x64, 0x72, 0x65, 0x64, + 0x20, 0x74, 0x77, 0x65, 0x6e, 0x74, 0x79, + 0x2d, 0x74, 0x68, 0x72, 0x65, 0x65, 0}; /* one hundred twenty-three */ +static const UChar ustr_fr123[] = {0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x69, 0x6e, 0x67, 0x74, 0x2d, + 0x74, 0x72, 0x6f, 0x69, 0x73, 0}; /* cent vingt-trois */ +static const UChar ustr_ja123[] = {0x767e, 0x4e8c, 0x5341, 0x4e09, 0}; /* kanji 100(+)2(*)10(+)3 */ +static const UChar ustr_zh50s[] = {0x4E94, 0x5341, 0}; /* spellout 50 */ +//static const UChar ustr_zh50d[] = [reuse from above] /* decimal 50 */ +//static const UChar ustr_zh05a[] = [reuse from above] /* decimal-alt 05 */ +//static const UChar ustr_zh05d[] = [reuse from above] /* decimal 05 */ + +#define NUMERIC_STRINGS_NOT_PARSEABLE 1 // ticket/8224 + +static const NumParseTestItem spelloutParseTests[] = { + /* name loc lenent src start val end status */ + { "en0", "en", FALSE, ustr_en0, 0, 0, 4, U_ZERO_ERROR }, + { "en0", "en", FALSE, ustr_en0, 2, 0, 2, U_PARSE_ERROR }, + { "en0", "ja", FALSE, ustr_en0, 0, 0, 0, U_PARSE_ERROR }, +#if NUMERIC_STRINGS_NOT_PARSEABLE + { "123", "en", FALSE, ustr_123, 0, 0, 0, U_PARSE_ERROR }, +#else + { "123", "en", FALSE, ustr_123, 0, 123, 3, U_ZERO_ERROR }, +#endif + { "123L", "en", TRUE, ustr_123, 0, 123, 3, U_ZERO_ERROR }, + { "en123", "en", FALSE, ustr_en123, 0, 123, 24, U_ZERO_ERROR }, + { "en123", "en", FALSE, ustr_en123, 12, 23, 24, U_ZERO_ERROR }, + { "en123", "fr", FALSE, ustr_en123, 16, 0, 16, U_PARSE_ERROR }, + { "fr123", "fr", FALSE, ustr_fr123, 0, 123, 16, U_ZERO_ERROR }, + { "fr123", "fr", FALSE, ustr_fr123, 5, 23, 16, U_ZERO_ERROR }, + { "fr123", "en", FALSE, ustr_fr123, 0, 0, 0, U_PARSE_ERROR }, + { "ja123", "ja", FALSE, ustr_ja123, 0, 123, 4, U_ZERO_ERROR }, + { "ja123", "ja", FALSE, ustr_ja123, 1, 23, 4, U_ZERO_ERROR }, + { "ja123", "fr", FALSE, ustr_ja123, 0, 0, 0, U_PARSE_ERROR }, + { "zh,50s", "zh", FALSE, ustr_zh50s, 0, 50, 2, U_ZERO_ERROR }, + // from ICU50m2, NUMERIC_STRINGS_NOT_PARSEABLE no longer affects the next three + { "zh@hd,50d", "zh@numbers=hanidec", FALSE, ustr_zh50d, 0, 50, 2, U_ZERO_ERROR }, + { "zh@hd,05a", "zh@numbers=hanidec", FALSE, ustr_zh05a, 0, 5, 2, U_ZERO_ERROR }, + { "zh@hd,05d", "zh@numbers=hanidec", FALSE, ustr_zh05d, 0, 5, 2, U_ZERO_ERROR }, + { "zh@hd,50dL","zh@numbers=hanidec", TRUE, ustr_zh50d, 0, 50, 2, U_ZERO_ERROR }, + { "zh@hd,05aL","zh@numbers=hanidec", TRUE, ustr_zh05a, 0, 5, 2, U_ZERO_ERROR }, + { "zh@hd,05dL","zh@numbers=hanidec", TRUE, ustr_zh05d, 0, 5, 2, U_ZERO_ERROR }, + { "zh,50dL","zh", TRUE, ustr_zh50d, 0, 50, 2, U_ZERO_ERROR }, /* changed in ICU50m2 */ + { "zh,05aL","zh", TRUE, ustr_zh05a, 0, 0, 1, U_ZERO_ERROR }, + { "zh,05dL","zh", TRUE, ustr_zh05d, 0, 5, 2, U_ZERO_ERROR }, /* changed in ICU50m2 */ + { NULL, NULL, FALSE, NULL, 0, 0, 0, 0 } /* terminator */ +}; + +static void TestSpelloutNumberParse() +{ + const NumParseTestItem * testPtr; + for (testPtr = spelloutParseTests; testPtr->testname != NULL; ++testPtr) { + UErrorCode status = U_ZERO_ERROR; + int32_t value, position = testPtr->startPos; + UNumberFormat *nf = unum_open(UNUM_SPELLOUT, NULL, 0, testPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_err_status(status, "unum_open fails for UNUM_SPELLOUT with locale %s, status %s\n", testPtr->locale, myErrorName(status)); + continue; + } + unum_setAttribute(nf, UNUM_LENIENT_PARSE, testPtr->lenient); + status = U_ZERO_ERROR; + value = unum_parse(nf, testPtr->source, -1, &position, &status); + if ( value != testPtr->value || position != testPtr->endPos || status != testPtr->status ) { + log_err("unum_parse SPELLOUT, locale %s, testname %s, startPos %d: for value / endPos / status, expected %d / %d / %s, got %d / %d / %s\n", + testPtr->locale, testPtr->testname, testPtr->startPos, + testPtr->value, testPtr->endPos, myErrorName(testPtr->status), + value, position, myErrorName(status) ); + } + unum_close(nf); + } +} + static void TestSignificantDigits() { UChar temp[128]; @@ -755,9 +1320,10 @@ static void TestSignificantDigits() double d = 123456.789; u_uastrcpy(temp, "###0.0#"); - fmt=unum_open(UNUM_IGNORE, temp, -1, NULL, NULL,&status); + fmt=unum_open(UNUM_IGNORE, temp, -1, "en", NULL, &status); if (U_FAILURE(status)) { - log_err("got unexpected error for unum_open: '%s'\n", u_errorName(status)); + log_data_err("got unexpected error for unum_open: '%s'\n", u_errorName(status)); + return; } unum_setAttribute(fmt, UNUM_SIGNIFICANT_DIGITS_USED, TRUE); unum_setAttribute(fmt, UNUM_MAX_SIGNIFICANT_DIGITS, 6); @@ -785,10 +1351,48 @@ static void TestSignificantDigits() unum_close(fmt); } +static void TestSigDigRounding() +{ + UErrorCode status = U_ZERO_ERROR; + UChar expected[128]; + UChar result[128]; + char temp1[128]; + char temp2[128]; + UNumberFormat* fmt; + double d = 123.4; + + fmt=unum_open(UNUM_DECIMAL, NULL, 0, "en", NULL, &status); + if (U_FAILURE(status)) { + log_data_err("got unexpected error for unum_open: '%s'\n", u_errorName(status)); + return; + } + unum_setAttribute(fmt, UNUM_LENIENT_PARSE, FALSE); + unum_setAttribute(fmt, UNUM_SIGNIFICANT_DIGITS_USED, TRUE); + unum_setAttribute(fmt, UNUM_MAX_SIGNIFICANT_DIGITS, 2); + /* unum_setAttribute(fmt, UNUM_MAX_FRACTION_DIGITS, 0); */ + + unum_setAttribute(fmt, UNUM_ROUNDING_MODE, UNUM_ROUND_UP); + unum_setDoubleAttribute(fmt, UNUM_ROUNDING_INCREMENT, 20.0); + + (void)unum_formatDouble(fmt, d, result, UPRV_LENGTHOF(result), NULL, &status); + if(U_FAILURE(status)) + { + log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status)); + return; + } + + u_uastrcpy(expected, "140"); + if(u_strcmp(result, expected)!=0) + log_err("FAIL: Error in unum_formatDouble result %s instead of %s\n", u_austrcpy(temp1, result), u_austrcpy(temp2, expected) ); + + unum_close(fmt); +} + static void TestNumberFormatPadding() { UChar *result=NULL; UChar temp1[512]; + UChar temp2[512]; UErrorCode status=U_ZERO_ERROR; int32_t resultlength; @@ -806,7 +1410,7 @@ static void TestNumberFormatPadding() pattern=unum_open(UNUM_IGNORE,temp1, u_strlen(temp1), NULL, NULL,&status); if(U_SUCCESS(status)) { - log_err("error in unum_openPattern(%s): %s\n", temp1, myErrorName(status) );; + log_err("error in unum_openPattern(%s): %s\n", temp1, myErrorName(status) ); } else { @@ -814,12 +1418,13 @@ static void TestNumberFormatPadding() } /* u_uastrcpy(temp1, "*x#,###,###,##0.0#;(*x#,###,###,##0.0#)"); */ - u_uastrcpy(temp1, "*x#,###,###,##0.0#;*x(###,###,##0.0#)"); + u_uastrcpy(temp1, "*x#,###,###,##0.0#;*x(###,###,##0.0#)"); // input pattern + u_uastrcpy(temp2, "*x#########,##0.0#;(#########,##0.0#)"); // equivalent (?) output pattern status=U_ZERO_ERROR; pattern=unum_open(UNUM_IGNORE,temp1, u_strlen(temp1), "en_US",NULL, &status); if(U_FAILURE(status)) { - log_err("error in padding unum_openPattern(%s): %s\n", temp1, myErrorName(status) );; + log_err_status(status, "error in padding unum_openPattern(%s): %s\n", temp1, myErrorName(status) ); } else { log_verbose("Pass: padding unum_openPattern() works fine\n"); @@ -841,16 +1446,21 @@ static void TestNumberFormatPadding() } else { - if(u_strcmp(result, temp1)!=0) - log_err("FAIL: Error in extracting the padding pattern using unum_toPattern()\n"); - else + if(u_strncmp(result, temp2, resultlengthneeded)!=0) { + log_err( + "FAIL: Error in extracting the padding pattern using unum_toPattern(): %d: %s != %s\n", + resultlengthneeded, + austrdup(temp2), + austrdup(result)); + } else { log_verbose("Pass: extracted the padding pattern correctly using unum_toPattern()\n"); -free(result); + } } + free(result); /* u_uastrcpy(temp1, "(xxxxxxx10,456.37)"); */ u_uastrcpy(temp1, "xxxxx(10,456.37)"); resultlength=0; - pos1.field = 1; /* Fraction field */ + pos1.field = UNUM_FRACTION_FIELD; resultlengthneeded=unum_formatDouble(pattern, d, NULL, resultlength, &pos1, &status); if(status==U_BUFFER_OVERFLOW_ERROR) { @@ -868,7 +1478,7 @@ free(result); if(u_strcmp(result, temp1)==0) log_verbose("Pass: Number Formatting using unum_formatDouble() padding Successful\n"); else - log_err("FAIL: Error in number formatting using unum_formatDouble() with padding\n"); + log_data_err("FAIL: Error in number formatting using unum_formatDouble() with padding\n"); if(pos1.beginIndex == 13 && pos1.endIndex == 15) log_verbose("Pass: Complete number formatting using unum_formatDouble() successful\n"); else @@ -898,7 +1508,7 @@ free(result); static UBool withinErr(double a, double b, double err) { - return uprv_fabs(a - b) < uprv_fabs(a * err); + return uprv_fabs(a - b) < uprv_fabs(a * err); } static void TestInt64Format() { @@ -908,7 +1518,7 @@ static void TestInt64Format() { UErrorCode status = U_ZERO_ERROR; const double doubleInt64Max = (double)U_INT64_MAX; const double doubleInt64Min = (double)U_INT64_MIN; - const double doubleBig = 10.0 * (double)U_INT64_MAX; + const double doubleBig = 10.0 * (double)U_INT64_MAX; int32_t val32; int64_t val64; double valDouble; @@ -917,9 +1527,9 @@ static void TestInt64Format() { /* create a number format using unum_openPattern(....) */ log_verbose("\nTesting Int64Format\n"); u_uastrcpy(temp1, "#.#E0"); - fmt = unum_open(UNUM_IGNORE, temp1, u_strlen(temp1), NULL, NULL, &status); + fmt = unum_open(UNUM_IGNORE, temp1, u_strlen(temp1), "en_US", NULL, &status); if(U_FAILURE(status)) { - log_err("error in unum_openPattern(): %s\n", myErrorName(status)); + log_data_err("error in unum_openPattern() - %s\n", myErrorName(status)); } else { unum_setAttribute(fmt, UNUM_MAX_FRACTION_DIGITS, 20); unum_formatInt64(fmt, U_INT64_MAX, result, 512, NULL, &status); @@ -1017,6 +1627,15 @@ static void TestInt64Format() { log_err("parseDouble returned incorrect value, got: %g\n", valDouble); } } + + u_uastrcpy(result, "5.06e-27"); + parsepos = 0; + valDouble = unum_parseDouble(fmt, result, u_strlen(result), &parsepos, &status); + if (U_FAILURE(status)) { + log_err("parseDouble() returned error: %s\n", myErrorName(status)); + } else if (!withinErr(valDouble, 5.06e-27, 1e-15)) { + log_err("parseDouble() returned incorrect value, got: %g\n", valDouble); + } } unum_close(fmt); } @@ -1025,13 +1644,13 @@ static void TestInt64Format() { static void test_fmt(UNumberFormat* fmt, UBool isDecimal) { char temp[512]; UChar buffer[512]; - int32_t BUFSIZE = sizeof(buffer)/sizeof(buffer[0]); + int32_t BUFSIZE = UPRV_LENGTHOF(buffer); double vals[] = { -.2, 0, .2, 5.5, 15.2, 250, 123456789 }; int i; - for (i = 0; i < sizeof(vals)/sizeof(vals[0]); ++i) { + for (i = 0; i < UPRV_LENGTHOF(vals); ++i) { UErrorCode status = U_ZERO_ERROR; unum_formatDouble(fmt, vals[i], buffer, BUFSIZE, NULL, &status); if (U_FAILURE(status)) { @@ -1056,13 +1675,13 @@ static void test_fmt(UNumberFormat* fmt, UBool isDecimal) { { int isLenient = unum_getAttribute(fmt, UNUM_LENIENT_PARSE); log_verbose("lenient: 0x%x\n", isLenient); - if (isDecimal ? (isLenient != -1) : (isLenient == TRUE)) { + if (isLenient != FALSE) { log_err("didn't expect lenient value: %d\n", isLenient); } unum_setAttribute(fmt, UNUM_LENIENT_PARSE, TRUE); isLenient = unum_getAttribute(fmt, UNUM_LENIENT_PARSE); - if (isDecimal ? (isLenient != -1) : (isLenient == FALSE)) { + if (isLenient != TRUE) { log_err("didn't expect lenient value after set: %d\n", isLenient); } } @@ -1107,7 +1726,7 @@ static void test_fmt(UNumberFormat* fmt, UBool isDecimal) { /* set the default ruleset to the first one found, and retry */ if (len > 0) { - for (i = 0; i < len && temp[i] != ';'; ++i){}; + for (i = 0; i < len && temp[i] != ';'; ++i){} if (i < len) { buffer[i] = 0; unum_setTextAttribute(fmt, UNUM_DEFAULT_RULESET, buffer, -1, &status); @@ -1121,7 +1740,7 @@ static void test_fmt(UNumberFormat* fmt, UBool isDecimal) { u_austrcpy(temp, buffer); log_err("unexpected ruleset len: %d ex: %d val: %s\n", len2, i, temp); } else { - for (i = 0; i < sizeof(vals)/sizeof(vals[0]); ++i) { + for (i = 0; i < UPRV_LENGTHOF(vals); ++i) { status = U_ZERO_ERROR; unum_formatDouble(fmt, vals[i], buffer, BUFSIZE, NULL, &status); if (U_FAILURE(status)) { @@ -1174,13 +1793,13 @@ static void TestNonExistentCurrency() { /* Get a non-existent currency and make sure it returns the correct currency code. */ format = unum_open(UNUM_CURRENCY, NULL, 0, "th_TH@currency=QQQ", NULL, &status); if (format == NULL || U_FAILURE(status)) { - log_err("unum_open did not return expected result for non-existent requested currency: '%s'\n", u_errorName(status)); + log_data_err("unum_open did not return expected result for non-existent requested currency: '%s' (Are you missing data?)\n", u_errorName(status)); } else { unum_getSymbol(format, UNUM_CURRENCY_SYMBOL, currencySymbol, - sizeof(currencySymbol)/sizeof(currencySymbol[0]), + UPRV_LENGTHOF(currencySymbol), &status); if (u_strcmp(currencySymbol, QQQ) != 0) { log_err("unum_open set the currency to QQQ\n"); @@ -1195,7 +1814,7 @@ static void TestRBNFFormat() { UChar pat[1024]; UChar tempUChars[512]; UNumberFormat *formats[5]; - int COUNT = sizeof(formats)/sizeof(formats[0]); + int COUNT = UPRV_LENGTHOF(formats); int i; for (i = 0; i < COUNT; ++i) { @@ -1207,25 +1826,29 @@ static void TestRBNFFormat() { u_uastrcpy(pat, "#,##0.0#;(#,##0.0#)"); formats[0] = unum_open(UNUM_PATTERN_DECIMAL, pat, -1, "en_US", &perr, &status); if (U_FAILURE(status)) { - log_err("unable to open decimal pattern"); + log_err_status(status, "unable to open decimal pattern -> %s\n", u_errorName(status)); + return; } status = U_ZERO_ERROR; formats[1] = unum_open(UNUM_SPELLOUT, NULL, 0, "en_US", &perr, &status); if (U_FAILURE(status)) { - log_err("unable to open spellout"); + log_err_status(status, "unable to open spellout -> %s\n", u_errorName(status)); + return; } status = U_ZERO_ERROR; formats[2] = unum_open(UNUM_ORDINAL, NULL, 0, "en_US", &perr, &status); if (U_FAILURE(status)) { - log_err("unable to open ordinal"); + log_err_status(status, "unable to open ordinal -> %s\n", u_errorName(status)); + return; } status = U_ZERO_ERROR; formats[3] = unum_open(UNUM_DURATION, NULL, 0, "en_US", &perr, &status); if (U_FAILURE(status)) { - log_err("unable to open duration"); + log_err_status(status, "unable to open duration %s\n", u_errorName(status)); + return; } status = U_ZERO_ERROR; @@ -1268,7 +1891,11 @@ static void TestRBNFFormat() { u_strcat(pat, tempUChars); formats[4] = unum_open(UNUM_PATTERN_RULEBASED, pat, -1, "en_US", &perr, &status); if (U_FAILURE(status)) { - log_err("unable to open rulebased pattern"); + log_err_status(status, "unable to open rulebased pattern -> %s\n", u_errorName(status)); + } + if (U_FAILURE(status)) { + log_err_status(status, "Something failed with %s\n", u_errorName(status)); + return; } for (i = 0; i < COUNT; ++i) { @@ -1276,9 +1903,2881 @@ static void TestRBNFFormat() { test_fmt(formats[i], (UBool)(i == 0)); } + #define FORMAT_BUF_CAPACITY 64 + { + UChar fmtbuf[FORMAT_BUF_CAPACITY]; + int32_t len; + double nanvalue = uprv_getNaN(); + status = U_ZERO_ERROR; + len = unum_formatDouble(formats[1], nanvalue, fmtbuf, FORMAT_BUF_CAPACITY, NULL, &status); + if (U_FAILURE(status)) { + log_err_status(status, "unum_formatDouble NAN failed with %s\n", u_errorName(status)); + } else { + UChar nansym[] = { 0x4E, 0x61, 0x4E, 0 }; /* NaN */ + if ( len != 3 || u_strcmp(fmtbuf, nansym) != 0 ) { + log_err("unum_formatDouble NAN produced wrong answer for en_US\n"); + } + } + } + for (i = 0; i < COUNT; ++i) { unum_close(formats[i]); } } +static void TestRBNFRounding() { + UChar fmtbuf[FORMAT_BUF_CAPACITY]; + UChar expectedBuf[FORMAT_BUF_CAPACITY]; + int32_t len; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* fmt = unum_open(UNUM_SPELLOUT, NULL, 0, "en_US", NULL, &status); + if (U_FAILURE(status)) { + log_err_status(status, "unable to open spellout -> %s\n", u_errorName(status)); + return; + } + len = unum_formatDouble(fmt, 10.123456789, fmtbuf, FORMAT_BUF_CAPACITY, NULL, &status); + U_ASSERT(len < FORMAT_BUF_CAPACITY); + (void)len; + if (U_FAILURE(status)) { + log_err_status(status, "unum_formatDouble 10.123456789 failed with %s\n", u_errorName(status)); + } + u_uastrcpy(expectedBuf, "ten point one two three four five six seven eight nine"); + if (u_strcmp(expectedBuf, fmtbuf) != 0) { + log_err("Wrong result for unrounded value\n"); + } + unum_setAttribute(fmt, UNUM_MAX_FRACTION_DIGITS, 3); + if (unum_getAttribute(fmt, UNUM_MAX_FRACTION_DIGITS) != 3) { + log_err("UNUM_MAX_FRACTION_DIGITS was incorrectly ignored -> %d\n", unum_getAttribute(fmt, UNUM_MAX_FRACTION_DIGITS)); + } + if (unum_getAttribute(fmt, UNUM_ROUNDING_MODE) != UNUM_ROUND_UNNECESSARY) { + log_err("UNUM_ROUNDING_MODE was set -> %d\n", unum_getAttribute(fmt, UNUM_ROUNDING_MODE)); + } + unum_setAttribute(fmt, UNUM_ROUNDING_MODE, UNUM_ROUND_HALFUP); + if (unum_getAttribute(fmt, UNUM_ROUNDING_MODE) != UNUM_ROUND_HALFUP) { + log_err("UNUM_ROUNDING_MODE was not set -> %d\n", unum_getAttribute(fmt, UNUM_ROUNDING_MODE)); + } + len = unum_formatDouble(fmt, 10.123456789, fmtbuf, FORMAT_BUF_CAPACITY, NULL, &status); + U_ASSERT(len < FORMAT_BUF_CAPACITY); + if (U_FAILURE(status)) { + log_err_status(status, "unum_formatDouble 10.123456789 failed with %s\n", u_errorName(status)); + } + u_uastrcpy(expectedBuf, "ten point one two three"); + if (u_strcmp(expectedBuf, fmtbuf) != 0) { + char temp[512]; + u_austrcpy(temp, fmtbuf); + log_err("Wrong result for rounded value. Got: %s\n", temp); + } + unum_close(fmt); +} + +static void TestCurrencyRegression(void) { +/* + I've found a case where unum_parseDoubleCurrency is not doing what I +expect. The value I pass in is $1234567890q123460000.00 and this +returns with a status of zero error & a parse pos of 22 (I would +expect a parse error at position 11). + +I stepped into DecimalFormat::subparse() and it looks like it parses +the first 10 digits and then stops parsing at the q but doesn't set an +error. Then later in DecimalFormat::parse() the value gets crammed +into a long (which greatly truncates the value). + +This is very problematic for me 'cause I try to remove chars that are +invalid but this allows my users to enter bad chars and truncates +their data! +*/ + + UChar buf[1024]; + UChar currency[8]; + char acurrency[16]; + double d; + UNumberFormat *cur; + int32_t pos; + UErrorCode status = U_ZERO_ERROR; + const int32_t expected = 11; + + currency[0]=0; + u_uastrcpy(buf, "$1234567890q643210000.00"); + cur = unum_open(UNUM_CURRENCY, NULL,0,"en_US", NULL, &status); + + if(U_FAILURE(status)) { + log_data_err("unum_open failed: %s (Are you missing data?)\n", u_errorName(status)); + return; + } + + status = U_ZERO_ERROR; /* so we can test it later. */ + pos = 0; + + d = unum_parseDoubleCurrency(cur, + buf, + -1, + &pos, /* 0 = start */ + currency, + &status); + + u_austrcpy(acurrency, currency); + + if(U_FAILURE(status) || (pos != expected)) { + log_err("unum_parseDoubleCurrency should have failed with pos %d, but gave: value %.9f, err %s, pos=%d, currency [%s]\n", + expected, d, u_errorName(status), pos, acurrency); + } else { + log_verbose("unum_parseDoubleCurrency failed, value %.9f err %s, pos %d, currency [%s]\n", d, u_errorName(status), pos, acurrency); + } + + unum_close(cur); +} + +static void TestTextAttributeCrash(void) { + UChar ubuffer[64] = {0x0049,0x004E,0x0052,0}; + static const UChar expectedNeg[] = {0x0049,0x004E,0x0052,0x0031,0x0032,0x0033,0x0034,0x002E,0x0035,0}; + static const UChar expectedPos[] = {0x0031,0x0032,0x0033,0x0034,0x002E,0x0035,0}; + int32_t used; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *nf = unum_open(UNUM_CURRENCY, NULL, 0, "en_US", NULL, &status); + if (U_FAILURE(status)) { + log_data_err("FAILED 1 -> %s (Are you missing data?)\n", u_errorName(status)); + return; + } + unum_setTextAttribute(nf, UNUM_CURRENCY_CODE, ubuffer, 3, &status); + /* + * the usual negative prefix and suffix seem to be '($' and ')' at this point + * also crashes if UNUM_NEGATIVE_SUFFIX is substituted for UNUM_NEGATIVE_PREFIX here + */ + used = unum_getTextAttribute(nf, UNUM_NEGATIVE_PREFIX, ubuffer, 64, &status); + unum_setTextAttribute(nf, UNUM_NEGATIVE_PREFIX, ubuffer, used, &status); + if (U_FAILURE(status)) { + log_err("FAILED 2\n"); exit(1); + } + log_verbose("attempting to format...\n"); + used = unum_formatDouble(nf, -1234.5, ubuffer, 64, NULL, &status); + if (U_FAILURE(status) || 64 < used) { + log_err("Failed formatting %s\n", u_errorName(status)); + return; + } + if (u_strcmp(expectedNeg, ubuffer) == 0) { + log_err("Didn't get expected negative result\n"); + } + used = unum_formatDouble(nf, 1234.5, ubuffer, 64, NULL, &status); + if (U_FAILURE(status) || 64 < used) { + log_err("Failed formatting %s\n", u_errorName(status)); + return; + } + if (u_strcmp(expectedPos, ubuffer) == 0) { + log_err("Didn't get expected positive result\n"); + } + unum_close(nf); +} + +static void TestNBSPPatternRtNum(const char *testcase, int line, UNumberFormat *nf, double myNumber) { + UErrorCode status = U_ZERO_ERROR; + UChar myString[20]; + char tmpbuf[200]; + double aNumber = -1.0; + unum_formatDouble(nf, myNumber, myString, 20, NULL, &status); + log_verbose("%s:%d: formatted %.2f into %s\n", testcase, line, myNumber, u_austrcpy(tmpbuf, myString)); + if(U_FAILURE(status)) { + log_err("%s:%d: failed format of %.2g with %s\n", testcase, line, myNumber, u_errorName(status)); + return; + } + aNumber = unum_parse(nf, myString, -1, NULL, &status); + if(U_FAILURE(status)) { + log_err("%s:%d: failed parse with %s\n", testcase, line, u_errorName(status)); + return; + } + if(uprv_fabs(aNumber-myNumber)>.001) { + log_err("FAIL: %s:%d formatted %.2f, parsed into %.2f\n", testcase, line, myNumber, aNumber); + } else { + log_verbose("PASS: %s:%d formatted %.2f, parsed into %.2f\n", testcase, line, myNumber, aNumber); + } +} + +static void TestNBSPPatternRT(const char *testcase, UNumberFormat *nf) { + TestNBSPPatternRtNum(testcase, __LINE__, nf, 12345.); + TestNBSPPatternRtNum(testcase, __LINE__, nf, -12345.); +} + +static void TestNBSPInPattern(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* nf = NULL; + const char *testcase; + + + testcase="ar_AE UNUM_CURRENCY"; + nf = unum_open(UNUM_CURRENCY, NULL, -1, "ar_AE", NULL, &status); + if(U_FAILURE(status) || nf == NULL) { + log_data_err("%s:%d: %s: unum_open failed with %s (Are you missing data?)\n", __FILE__, __LINE__, testcase, u_errorName(status)); + return; + } + TestNBSPPatternRT(testcase, nf); + + /* if we don't have CLDR 1.6 data, bring out the problem anyways */ + { +#define SPECIAL_PATTERN "\\u00A4\\u00A4'\\u062f.\\u0625.\\u200f\\u00a0'###0.00" + UChar pat[200]; + testcase = "ar_AE special pattern: " SPECIAL_PATTERN; + u_unescape(SPECIAL_PATTERN, pat, UPRV_LENGTHOF(pat)); + unum_applyPattern(nf, FALSE, pat, -1, NULL, &status); + if(U_FAILURE(status)) { + log_err("%s: unum_applyPattern failed with %s\n", testcase, u_errorName(status)); + } else { + TestNBSPPatternRT(testcase, nf); + } +#undef SPECIAL_PATTERN + } + unum_close(nf); status = U_ZERO_ERROR; + + testcase="ar_AE UNUM_DECIMAL"; + nf = unum_open(UNUM_DECIMAL, NULL, -1, "ar_AE", NULL, &status); + if(U_FAILURE(status)) { + log_err("%s: unum_open failed with %s\n", testcase, u_errorName(status)); + } + TestNBSPPatternRT(testcase, nf); + unum_close(nf); status = U_ZERO_ERROR; + + testcase="ar_AE UNUM_PERCENT"; + nf = unum_open(UNUM_PERCENT, NULL, -1, "ar_AE", NULL, &status); + if(U_FAILURE(status)) { + log_err("%s: unum_open failed with %s\n", testcase, u_errorName(status)); + } + TestNBSPPatternRT(testcase, nf); + unum_close(nf); status = U_ZERO_ERROR; + + + +} +static void TestCloneWithRBNF(void) { + UChar pattern[1024]; + UChar pat2[512]; + UErrorCode status = U_ZERO_ERROR; + UChar buffer[256]; + UChar buffer_cloned[256]; + char temp1[256]; + char temp2[256]; + UNumberFormat *pform_cloned; + UNumberFormat *pform; + + u_uastrcpy(pattern, + "%main:\n" + "0.x: >%%millis-only>;\n" + "x.0: <%%duration<;\n" + "x.x: <%%durationwithmillis<>%%millis-added>;\n" + "-x: ->>;%%millis-only:\n" + "1000: 00:00.<%%millis<;\n" + "%%millis-added:\n" + "1000: .<%%millis<;\n" + "%%millis:\n" + "0: =000=;\n" + "%%duration:\n" + "0: =%%seconds-only=;\n" + "60: =%%min-sec=;\n" + "3600: =%%hr-min-sec=;\n" + "86400/86400: <%%ddaayyss<[, >>];\n" + "%%durationwithmillis:\n" + "0: =%%seconds-only=;\n" + "60: =%%min-sec=;\n" + "3600: =%%hr-min-sec=;\n" + "86400/86400: <%%ddaayyss<, >>;\n"); + u_uastrcpy(pat2, + "%%seconds-only:\n" + "0: 0:00:=00=;\n" + "%%min-sec:\n" + "0: :=00=;\n" + "0/60: 0:<00<>>;\n" + "%%hr-min-sec:\n" + "0: :=00=;\n" + "60/60: <00<>>;\n" + "3600/60: <0<:>>>;\n" + "%%ddaayyss:\n" + "0 days;\n" + "1 day;\n" + "=0= days;"); + + /* This is to get around some compiler warnings about char * string length. */ + u_strcat(pattern, pat2); + + pform = unum_open(UNUM_PATTERN_RULEBASED, pattern, -1, "en_US", NULL, &status); + unum_formatDouble(pform, 3600, buffer, 256, NULL, &status); + + pform_cloned = unum_clone(pform,&status); + unum_formatDouble(pform_cloned, 3600, buffer_cloned, 256, NULL, &status); + + unum_close(pform); + unum_close(pform_cloned); + + if (u_strcmp(buffer,buffer_cloned)) { + log_data_err("Result from cloned formatter not identical to the original. Original: %s Cloned: %s - (Are you missing data?)",u_austrcpy(temp1, buffer),u_austrcpy(temp2,buffer_cloned)); + } +} + + +static void TestNoExponent(void) { + UErrorCode status = U_ZERO_ERROR; + UChar str[100]; + const char *cstr; + UNumberFormat *fmt; + int32_t pos; + int32_t expect = 0; + int32_t num; + + fmt = unum_open(UNUM_DECIMAL, NULL, -1, "en_US", NULL, &status); + + if(U_FAILURE(status) || fmt == NULL) { + log_data_err("%s:%d: unum_open failed with %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status)); + return; + } + + cstr = "10E6"; + u_uastrcpy(str, cstr); + expect = 10000000; + pos = 0; + num = unum_parse(fmt, str, -1, &pos, &status); + ASSERT_TRUE(pos==4); + if(U_FAILURE(status)) { + log_data_err("%s:%d: unum_parse failed with %s for %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status), cstr); + } else if(expect!=num) { + log_data_err("%s:%d: unum_parse failed, got %d expected %d for '%s'(Are you missing data?)\n", __FILE__, __LINE__, num, expect, cstr); + } else { + log_verbose("%s:%d: unum_parse returned %d for '%s'\n", __FILE__, __LINE__, num, cstr); + } + + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_PARSE_NO_EXPONENT)==0); + + unum_setAttribute(fmt, UNUM_PARSE_NO_EXPONENT, 1); /* no error code */ + log_verbose("set UNUM_PARSE_NO_EXPONENT\n"); + + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_PARSE_NO_EXPONENT)==1); + + pos = 0; + expect=10; + num = unum_parse(fmt, str, -1, &pos, &status); + if(num==10000000) { + log_err("%s:%d: FAIL: unum_parse should have returned 10, not 10000000 on %s after UNUM_PARSE_NO_EXPONENT\n", __FILE__, __LINE__, cstr); + } else if(num==expect) { + log_verbose("%s:%d: unum_parse gave %d for %s - good.\n", __FILE__, __LINE__, num, cstr); + } + ASSERT_TRUE(pos==2); + + status = U_ZERO_ERROR; + + unum_close(fmt); + + /* ok, now try scientific */ + fmt = unum_open(UNUM_SCIENTIFIC, NULL, -1, "en_US", NULL, &status); + assertSuccess("unum_open(UNUM_SCIENTIFIC, ...)", &status); + + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_PARSE_NO_EXPONENT)==0); + + cstr = "10E6"; + u_uastrcpy(str, cstr); + expect = 10000000; + pos = 0; + num = unum_parse(fmt, str, -1, &pos, &status); + ASSERT_TRUE(pos==4); + if(U_FAILURE(status)) { + log_data_err("%s:%d: unum_parse failed with %s for %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status), cstr); + } else if(expect!=num) { + log_data_err("%s:%d: unum_parse failed, got %d expected %d for '%s'(Are you missing data?)\n", __FILE__, __LINE__, num, expect, cstr); + } else { + log_verbose("%s:%d: unum_parse returned %d for '%s'\n", __FILE__, __LINE__, num, cstr); + } + + unum_setAttribute(fmt, UNUM_PARSE_NO_EXPONENT, 1); /* no error code */ + log_verbose("set UNUM_PARSE_NO_EXPONENT\n"); + + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_PARSE_NO_EXPONENT)==1); + + // A scientific formatter should parse the exponent even if UNUM_PARSE_NO_EXPONENT is set + cstr = "10E6"; + u_uastrcpy(str, cstr); + expect = 10000000; + pos = 0; + num = unum_parse(fmt, str, -1, &pos, &status); + ASSERT_TRUE(pos==4); + if(U_FAILURE(status)) { + log_data_err("%s:%d: unum_parse failed with %s for %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status), cstr); + } else if(expect!=num) { + log_data_err("%s:%d: unum_parse failed, got %d expected %d for '%s'(Are you missing data?)\n", __FILE__, __LINE__, num, expect, cstr); + } else { + log_verbose("%s:%d: unum_parse returned %d for '%s'\n", __FILE__, __LINE__, num, cstr); + } + + unum_close(fmt); +} + +static void TestMaxInt(void) { + UErrorCode status = U_ZERO_ERROR; + UChar pattern_hash[] = { 0x23, 0x00 }; /* "#" */ + UChar result1[1024] = { 0 }, result2[1024] = { 0 }; + int32_t len1, len2; + UChar expect[] = { 0x0039, 0x0037, 0 }; + UNumberFormat *fmt = unum_open( + UNUM_PATTERN_DECIMAL, /* style */ + &pattern_hash[0], /* pattern */ + u_strlen(pattern_hash), /* patternLength */ + "en", + 0, /* parseErr */ + &status); + if(U_FAILURE(status) || fmt == NULL) { + log_data_err("%s:%d: %s: unum_open failed with %s (Are you missing data?)\n", __FILE__, __LINE__, "TestMaxInt", u_errorName(status)); + return; + } + + unum_setAttribute(fmt, UNUM_MAX_INTEGER_DIGITS, 2); + + status = U_ZERO_ERROR; + /* #1 */ + len1 = unum_formatInt64(fmt, 1997, result1, 1024, NULL, &status); + result1[len1]=0; + if(U_FAILURE(status) || u_strcmp(expect, result1)) { + log_err("unum_formatInt64 Expected %s but got %s status %s\n", austrdup(expect), austrdup(result1), u_errorName(status)); + } + + status = U_ZERO_ERROR; + /* #2 */ + len2 = unum_formatDouble(fmt, 1997.0, result2, 1024, NULL, &status); + result2[len2]=0; + if(U_FAILURE(status) || u_strcmp(expect, result2)) { + log_err("unum_formatDouble Expected %s but got %s status %s\n", austrdup(expect), austrdup(result2), u_errorName(status)); + } + + + + /* test UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS */ + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS)==0); + + unum_setAttribute(fmt, UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS, 1); + /* test UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS */ + ASSERT_TRUE(unum_getAttribute(fmt, UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS)==1); + + status = U_ZERO_ERROR; + /* max int digits still '2' */ + len1 = unum_formatInt64(fmt, 1997, result1, 1024, NULL, &status); + ASSERT_TRUE(status==U_ILLEGAL_ARGUMENT_ERROR); + status = U_ZERO_ERROR; + + /* But, formatting 97->'97' works fine. */ + + /* #1 */ + len1 = unum_formatInt64(fmt, 97, result1, 1024, NULL, &status); + result1[len1]=0; + if(U_FAILURE(status) || u_strcmp(expect, result1)) { + log_err("unum_formatInt64 Expected %s but got %s status %s\n", austrdup(expect), austrdup(result1), u_errorName(status)); + } + + status = U_ZERO_ERROR; + /* #2 */ + len2 = unum_formatDouble(fmt, 97.0, result2, 1024, NULL, &status); + result2[len2]=0; + if(U_FAILURE(status) || u_strcmp(expect, result2)) { + log_err("unum_formatDouble Expected %s but got %s status %s\n", austrdup(expect), austrdup(result2), u_errorName(status)); + } + + + unum_close(fmt); +} + +static void TestSignAlwaysShown(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *fmt = unum_open( + UNUM_DECIMAL, /* style */ + NULL, /* pattern */ + 0, /* patternLength */ + "en-US", + NULL, /* parseErr */ + &status); + assertSuccess("Creating UNumberFormat", &status); + unum_setAttribute(fmt, UNUM_SIGN_ALWAYS_SHOWN, 1); + UChar result[100]; + unum_formatDouble(fmt, 42, result, 100, NULL, &status); + assertSuccess("Formatting with UNumberFormat", &status); + assertUEquals("Result with sign always shown", u"+42", result); + unum_close(fmt); +} + +static void TestMinimumGroupingDigits(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *fmt = unum_open( + UNUM_DECIMAL, /* style */ + NULL, /* pattern */ + 0, /* patternLength */ + "en-US", + NULL, /* parseErr */ + &status); + assertSuccess("Creating UNumberFormat", &status); + unum_setAttribute(fmt, UNUM_MINIMUM_GROUPING_DIGITS, 2); + UChar result[100]; + unum_formatDouble(fmt, 1234, result, 100, NULL, &status); + assertSuccess("Formatting with UNumberFormat A", &status); + assertUEquals("Result with minimum grouping digits A", u"1234", result); + unum_formatDouble(fmt, 12345, result, 100, NULL, &status); + assertSuccess("Formatting with UNumberFormat B", &status); + assertUEquals("Result with minimum grouping digits B", u"12,345", result); + unum_close(fmt); +} + +static void TestParseCaseSensitive(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *fmt = unum_open( + UNUM_DECIMAL, /* style */ + NULL, /* pattern */ + 0, /* patternLength */ + "en-US", + NULL, /* parseErr */ + &status); + assertSuccess("Creating UNumberFormat", &status); + double result = unum_parseDouble(fmt, u"1e2", -1, NULL, &status); + assertSuccess("Parsing with UNumberFormat, case insensitive", &status); + assertIntEquals("Result with case sensitive", 100, (int64_t)result); + unum_setAttribute(fmt, UNUM_PARSE_CASE_SENSITIVE, 1); + int32_t ppos = 0; + result = unum_parseDouble(fmt, u"1e2", -1, &ppos, &status); + assertSuccess("Parsing with UNumberFormat, case sensitive", &status); + assertIntEquals("Position with case sensitive", 1, ppos); + assertIntEquals("Result with case sensitive", 1, (int64_t)result); + unum_close(fmt); +} + +static void TestUFormattable(void) { + UChar out2k[2048]; + // simple test for API docs + { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *unum = unum_open(UNUM_DEFAULT, NULL, -1, "en_US_POSIX", NULL, &status); + if(assertSuccessCheck("calling unum_open()", &status, TRUE)) { + //! [unum_parseToUFormattable] + const UChar str[] = { 0x0031, 0x0032, 0x0033, 0x0000 }; /* 123 */ + int32_t result = 0; + UFormattable *ufmt = ufmt_open(&status); + unum_parseToUFormattable(unum, ufmt, str, -1, NULL, &status); + if (ufmt_isNumeric(ufmt)) { + result = ufmt_getLong(ufmt, &status); /* == 123 */ + } /* else { ... } */ + ufmt_close(ufmt); + //! [unum_parseToUFormattable] + assertTrue("result == 123", (result == 123)); + } + unum_close(unum); + } + // test with explicitly created ufmt_open + { + UChar buffer[2048]; + UErrorCode status = U_ZERO_ERROR; + UFormattable *ufmt; + UNumberFormat *unum; + const char *pattern = ""; + + ufmt = ufmt_open(&status); + unum = unum_open(UNUM_DEFAULT, NULL, -1, "en_US_POSIX", NULL, &status); + if(assertSuccessCheck("calling ufmt_open() || unum_open()", &status, TRUE)) { + + pattern = "31337"; + log_verbose("-- pattern: %s\n", pattern); + u_uastrcpy(buffer, pattern); + unum_parseToUFormattable(unum, ufmt, buffer, -1, NULL, &status); + if(assertSuccess("unum_parseToUFormattable(31337)", &status)) { + assertTrue("ufmt_getLong()=31337", ufmt_getLong(ufmt, &status) == 31337); + assertTrue("ufmt_getType()=UFMT_LONG", ufmt_getType(ufmt, &status) == UFMT_LONG); + log_verbose("long = %d\n", ufmt_getLong(ufmt, &status)); + assertSuccess("ufmt_getLong()", &status); + } + unum_formatUFormattable(unum, ufmt, out2k, 2048, NULL, &status); + if(assertSuccess("unum_formatUFormattable(31337)", &status)) { + assertEquals("unum_formatUFormattable r/t", austrdup(buffer), austrdup(out2k)); + } + + pattern = "3.14159"; + log_verbose("-- pattern: %s\n", pattern); + u_uastrcpy(buffer, pattern); + unum_parseToUFormattable(unum, ufmt, buffer, -1, NULL, &status); + if(assertSuccess("unum_parseToUFormattable(3.14159)", &status)) { + assertTrue("ufmt_getDouble()==3.14159", withinErr(ufmt_getDouble(ufmt, &status), 3.14159, 1e-15)); + assertSuccess("ufmt_getDouble()", &status); + assertTrue("ufmt_getType()=UFMT_DOUBLE", ufmt_getType(ufmt, &status) == UFMT_DOUBLE); + log_verbose("double = %g\n", ufmt_getDouble(ufmt, &status)); + } + unum_formatUFormattable(unum, ufmt, out2k, 2048, NULL, &status); + if(assertSuccess("unum_formatUFormattable(3.14159)", &status)) { + assertEquals("unum_formatUFormattable r/t", austrdup(buffer), austrdup(out2k)); + } + } + ufmt_close(ufmt); + unum_close(unum); + } + + // test with auto-generated ufmt + { + UChar buffer[2048]; + UErrorCode status = U_ZERO_ERROR; + UFormattable *ufmt = NULL; + UNumberFormat *unum; + const char *pattern = "73476730924573500000000"; // weight of the moon, kg + + log_verbose("-- pattern: %s (testing auto-opened UFormattable)\n", pattern); + u_uastrcpy(buffer, pattern); + + unum = unum_open(UNUM_DEFAULT, NULL, -1, "en_US_POSIX", NULL, &status); + if(assertSuccessCheck("calling unum_open()", &status, TRUE)) { + + ufmt = unum_parseToUFormattable(unum, NULL, /* will be ufmt_open()'ed for us */ + buffer, -1, NULL, &status); + if(assertSuccess("unum_parseToUFormattable(weight of the moon)", &status)) { + log_verbose("new formattable allocated at %p\n", (void*)ufmt); + assertTrue("ufmt_isNumeric() TRUE", ufmt_isNumeric(ufmt)); + unum_formatUFormattable(unum, ufmt, out2k, 2048, NULL, &status); + if(assertSuccess("unum_formatUFormattable(3.14159)", &status)) { + assertEquals("unum_formatUFormattable r/t", austrdup(buffer), austrdup(out2k)); + } + + log_verbose("double: %g\n", ufmt_getDouble(ufmt, &status)); + assertSuccess("ufmt_getDouble()", &status); + + log_verbose("long: %ld\n", ufmt_getLong(ufmt, &status)); + assertTrue("failure on ufmt_getLong() for huge number:", U_FAILURE(status)); + // status is now a failure due to ufmt_getLong() above. + // the intltest does extensive r/t testing of Formattable vs. UFormattable. + } + } + + unum_close(unum); + ufmt_close(ufmt); // was implicitly opened for us by the first unum_parseToUFormattable() + } +} + +typedef struct { + const char* locale; + const char* numsys; + int32_t radix; + UBool isAlgorithmic; + const UChar* description; +} NumSysTestItem; + + +static const UChar latnDesc[] = {0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039,0}; // 0123456789 +static const UChar romanDesc[] = {0x25,0x72,0x6F,0x6D,0x61,0x6E,0x2D,0x75,0x70,0x70,0x65,0x72,0}; // %roman-upper +static const UChar arabDesc[] = {0x0660,0x0661,0x0662,0x0663,0x0664,0x0665,0x0666,0x0667,0x0668,0x0669,0}; // +static const UChar arabextDesc[] = {0x06F0,0x06F1,0x06F2,0x06F3,0x06F4,0x06F5,0x06F6,0x06F7,0x06F8,0x06F9,0}; // +static const UChar hanidecDesc[] = {0x3007,0x4E00,0x4E8C,0x4E09,0x56DB,0x4E94,0x516D,0x4E03,0x516B,0x4E5D,0}; // +static const UChar hantDesc[] = {0x7A,0x68,0x5F,0x48,0x61,0x6E,0x74,0x2F,0x53,0x70,0x65,0x6C,0x6C,0x6F,0x75,0x74, + 0x52,0x75,0x6C,0x65,0x73,0x2F,0x25,0x73,0x70,0x65,0x6C,0x6C,0x6F,0x75,0x74,0x2D, + 0x63,0x61,0x72,0x64,0x69,0x6E,0x61,0x6C,0}; // zh_Hant/SpelloutRules/%spellout-cardinal + +static const NumSysTestItem numSysTestItems[] = { + //locale numsys radix isAlgo description + { "en", "latn", 10, FALSE, latnDesc }, + { "en@numbers=roman", "roman", 10, TRUE, romanDesc }, + { "en@numbers=finance", "latn", 10, FALSE, latnDesc }, + { "ar-EG", "arab", 10, FALSE, arabDesc }, + { "fa", "arabext", 10, FALSE, arabextDesc }, + { "zh_Hans@numbers=hanidec", "hanidec", 10, FALSE, hanidecDesc }, + { "zh_Hant@numbers=traditional", "hant", 10, TRUE, hantDesc }, + { NULL, NULL, 0, FALSE, NULL }, +}; +enum { kNumSysDescripBufMax = 64 }; + +static void TestUNumberingSystem(void) { + const NumSysTestItem * itemPtr; + UNumberingSystem * unumsys; + UEnumeration * uenum; + const char * numsys; + UErrorCode status; + + for (itemPtr = numSysTestItems; itemPtr->locale != NULL; itemPtr++) { + status = U_ZERO_ERROR; + unumsys = unumsys_open(itemPtr->locale, &status); + if ( U_SUCCESS(status) ) { + UChar ubuf[kNumSysDescripBufMax]; + int32_t ulen, radix = unumsys_getRadix(unumsys); + UBool isAlgorithmic = unumsys_isAlgorithmic(unumsys); + numsys = unumsys_getName(unumsys); + if ( uprv_strcmp(numsys, itemPtr->numsys) != 0 || radix != itemPtr->radix || !isAlgorithmic != !itemPtr->isAlgorithmic ) { + log_data_err("unumsys name/radix/isAlgorithmic for locale %s, expected %s/%d/%d, got %s/%d/%d\n", + itemPtr->locale, itemPtr->numsys, itemPtr->radix, itemPtr->isAlgorithmic, numsys, radix, isAlgorithmic); + } + ulen = unumsys_getDescription(unumsys, ubuf, kNumSysDescripBufMax, &status); + (void)ulen; // Suppress variable not used warning. + if ( U_FAILURE(status) || u_strcmp(ubuf, itemPtr->description) != 0 ) { + log_data_err("unumsys description for locale %s, description unexpected and/or status %\n", myErrorName(status)); + } + unumsys_close(unumsys); + } else { + log_data_err("unumsys_open for locale %s fails with status %s\n", itemPtr->locale, myErrorName(status)); + } + } + + for (int i=0; i<3; ++i) { + // Run the test of unumsys_openAvailableNames() multiple times. + // Helps verify the management of the internal cache of the names. + status = U_ZERO_ERROR; + uenum = unumsys_openAvailableNames(&status); + if ( U_SUCCESS(status) ) { + int32_t numsysCount = 0; + // sanity check for a couple of number systems that must be in the enumeration + UBool foundLatn = FALSE; + UBool foundArab = FALSE; + while ( (numsys = uenum_next(uenum, NULL, &status)) != NULL && U_SUCCESS(status) ) { + status = U_ZERO_ERROR; + unumsys = unumsys_openByName(numsys, &status); + if ( U_SUCCESS(status) ) { + numsysCount++; + if ( uprv_strcmp(numsys, "latn") ) foundLatn = TRUE; + if ( uprv_strcmp(numsys, "arab") ) foundArab = TRUE; + unumsys_close(unumsys); + } else { + log_err("unumsys_openAvailableNames includes %s but unumsys_openByName on it fails with status %s\n", + numsys, myErrorName(status)); + } + } + uenum_close(uenum); + if ( numsysCount < 40 || !foundLatn || !foundArab ) { + log_err("unumsys_openAvailableNames results incomplete: numsysCount %d, foundLatn %d, foundArab %d\n", + numsysCount, foundLatn, foundArab); + } + } else { + log_data_err("unumsys_openAvailableNames fails with status %s\n", myErrorName(status)); + } + } +} + +/* plain-C version of test in numfmtst.cpp */ +enum { kUBufMax = 64, kBBufMax = 128 }; +static void TestCurrencyIsoPluralFormat(void) { + static const char* DATA[][8] = { + // the data are: + // locale, + // currency amount to be formatted, + // currency ISO code to be formatted, + // format result using CURRENCYSTYLE, + // format result using CURRENCY_STANDARD, + // format result using CURRENCY_ACCOUNTING, + // format result using ISOCURRENCYSTYLE, + // format result using PLURALCURRENCYSTYLE, + + // locale amount ISOcode CURRENCYSTYLE CURRENCY_STANDARD CURRENCY_ACCOUNTING ISOCURRENCYSTYLE PLURALCURRENCYSTYLE + {"en_US", "1", "USD", "$1.00", "$1.00", "$1.00", "USD\\u00A01.00", "1.00 US dollars"}, + {"en_US", "1234.56", "USD", "$1,234.56", "$1,234.56", "$1,234.56", "USD\\u00A01,234.56", "1,234.56 US dollars"}, + {"en_US@cf=account", "1234.56", "USD", "$1,234.56", "$1,234.56", "$1,234.56", "USD\\u00A01,234.56", "1,234.56 US dollars"}, + {"en_US", "-1234.56", "USD", "-$1,234.56", "-$1,234.56", "($1,234.56)", "-USD\\u00A01,234.56", "-1,234.56 US dollars"}, + {"en_US@cf=account", "-1234.56", "USD", "($1,234.56)", "-$1,234.56", "($1,234.56)", "-USD\\u00A01,234.56", "-1,234.56 US dollars"}, + {"en_US@cf=standard", "-1234.56", "USD", "-$1,234.56", "-$1,234.56", "($1,234.56)", "-USD\\u00A01,234.56", "-1,234.56 US dollars"}, + {"zh_CN", "1", "USD", "US$1.00", "US$1.00", "US$1.00", "USD\\u00A01.00", "1.00\\u00A0\\u7F8E\\u5143"}, + {"zh_CN", "-1", "USD", "-US$1.00", "-US$1.00", "(US$1.00)", "-USD\\u00A01.00", "-1.00\\u00A0\\u7F8E\\u5143"}, + {"zh_CN@cf=account", "-1", "USD", "(US$1.00)", "-US$1.00", "(US$1.00)", "-USD\\u00A01.00", "-1.00\\u00A0\\u7F8E\\u5143"}, + {"zh_CN@cf=standard", "-1", "USD", "-US$1.00", "-US$1.00", "(US$1.00)", "-USD\\u00A01.00", "-1.00\\u00A0\\u7F8E\\u5143"}, + {"zh_CN", "1234.56", "USD", "US$1,234.56", "US$1,234.56", "US$1,234.56", "USD\\u00A01,234.56", "1,234.56\\u00A0\\u7F8E\\u5143"}, + // {"zh_CN", "1", "CHY", "CHY1.00", "CHY1.00", "CHY1.00", "CHY1.00", "1.00 CHY"}, // wrong ISO code + // {"zh_CN", "1234.56", "CHY", "CHY1,234.56", "CHY1,234.56", "CHY1,234.56", "CHY1,234.56", "1,234.56 CHY"}, // wrong ISO code + {"zh_CN", "1", "CNY", "\\u00A51.00", "\\u00A51.00", "\\u00A51.00", "CNY\\u00A01.00", "1.00\\u00A0\\u4EBA\\u6C11\\u5E01"}, + {"zh_CN", "1234.56", "CNY", "\\u00A51,234.56", "\\u00A51,234.56", "\\u00A51,234.56", "CNY\\u00A01,234.56", "1,234.56\\u00A0\\u4EBA\\u6C11\\u5E01"}, + {"ru_RU", "1", "RUB", "1,00\\u00A0\\u20BD", "1,00\\u00A0\\u20BD", "1,00\\u00A0\\u20BD", "1,00\\u00A0RUB", "1,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E " + "\\u0440\\u0443\\u0431\\u043B\\u044F"}, + {"ru_RU", "2", "RUB", "2,00\\u00A0\\u20BD", "2,00\\u00A0\\u20BD", "2,00\\u00A0\\u20BD", "2,00\\u00A0RUB", "2,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E " + "\\u0440\\u0443\\u0431\\u043B\\u044F"}, + {"ru_RU", "5", "RUB", "5,00\\u00A0\\u20BD", "5,00\\u00A0\\u20BD", "5,00\\u00A0\\u20BD", "5,00\\u00A0RUB", "5,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E " + "\\u0440\\u0443\\u0431\\u043B\\u044F"}, + {"ja_JP", "42", NULL, "\\u00A542", "\\u00A542", "\\u00A542", "JPY\\u00A042", "42\\u00A0\\u5186"}, + {"ja_JP@currency=USD", "42", NULL, "$42.00", "$42.00", "$42.00", "USD\\u00A042.00", "42.00\\u00A0\\u7C73\\u30C9\\u30EB"}, + {"ms_MY", "1234.56", "MYR", "RM1,234.56", "RM1,234.56", "RM1,234.56", "MYR1,234.56", "1,234.56 Ringgit Malaysia"}, + {"id_ID", "1234.56", "IDR", "Rp1.235", "Rp1.235", "Rp1.235", "IDR\\u00A01.235", "1.235 Rupiah Indonesia"}, + // test locale without currency information + {"root", "-1.23", "USD", "-US$\\u00A01.23", "-US$\\u00A01.23", "-US$\\u00A01.23", "-USD\\u00A01.23", "-1.23 USD"}, + {"root@cf=account", "-1.23", "USD", "-US$\\u00A01.23", "-US$\\u00A01.23", "-US$\\u00A01.23", "-USD\\u00A01.23", "-1.23 USD"}, + // test choice format + {"es_AR", "1", "INR", "INR\\u00A01,00", "INR\\u00A01,00", "INR\\u00A01,00", "INR\\u00A01,00", "1,00 rupia india"}, + // test EUR format for some now-redundant locale data removed in rdar://62544359 + {"en_NO", "1234.56", "EUR", "\\u20AC\\u00A01\\u00A0234,56", "\\u20AC\\u00A01\\u00A0234,56", "\\u20AC\\u00A01\\u00A0234,56", "EUR\\u00A01\\u00A0234,56", "1\\u00A0234,56 euros"}, + {"en_PL", "1234.56", "EUR", "1\\u00A0234,56\\u00A0\\u20AC", "1\\u00A0234,56\\u00A0\\u20AC", "1\\u00A0234,56\\u00A0\\u20AC", "1\\u00A0234,56\\u00A0EUR", "1\\u00A0234,56 euros"}, + }; + static const UNumberFormatStyle currencyStyles[] = { + UNUM_CURRENCY, + UNUM_CURRENCY_STANDARD, + UNUM_CURRENCY_ACCOUNTING, + UNUM_CURRENCY_ISO, + UNUM_CURRENCY_PLURAL + }; + + int32_t i, sIndex; + + for (i=0; ilocale != NULL; itemPtr++) { + UChar ubufResult[kUBufMax]; + int32_t ulenRes; + + status = U_ZERO_ERROR; + unum = unum_open(itemPtr->style, NULL, 0, itemPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("FAIL: unum_open, locale %s, style %d - %s\n", + itemPtr->locale, (int)itemPtr->style, myErrorName(status)); + continue; + } + unum_setContext(unum, itemPtr->context, &status); + ulenRes = unum_formatDouble(unum, 123.45, ubufResult, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("FAIL: unum_formatDouble, locale %s, style %d, context %d - %s\n", + itemPtr->locale, (int)itemPtr->style, (int)itemPtr->context, myErrorName(status)); + } else { + UChar ubufExpected[kUBufMax]; + int32_t ulenExp = u_unescape(itemPtr->expectedResult, ubufExpected, kUBufMax); + if (ulenRes != ulenExp || u_strncmp(ubufResult, ubufExpected, ulenExp) != 0) { + char bbuf[kUBufMax*2]; + u_austrncpy(bbuf, ubufResult, sizeof(bbuf)); + log_err("FAIL: unum_formatDouble, locale %s, style %d, context %d, expected %d:\"%s\", got %d:\"%s\"\n", + itemPtr->locale, (int)itemPtr->style, (int)itemPtr->context, ulenExp, + itemPtr->expectedResult, ulenRes, bbuf); + } + } + unum_close(unum); + } +#endif /* #if !UCONFIG_NO_NORMALIZATION && !UCONFIG_NO_BREAK_ITERATION */ +} + +static void TestCurrencyUsage(void) { + static const char* DATA[][2] = { + /* the data are: + * currency ISO code to be formatted, + * format result using CURRENCYSTYLE with CASH purpose,- + * Note that as of CLDR 26:- + * - TWD switches from 0 decimals to 2; PKR still has 0, so change test to that + * - CAD rounds to .05 + */ + + {"PKR", "PKR\\u00A0124"}, + {"CAD", "CA$123.55"}, + {"USD", "$123.57"} + }; + + // 1st time for getter/setter, 2nd for factory method + int32_t i; + for(i=0; i<2; i++){ + const char* localeString = "en_US"; + double numberToBeFormat = 123.567; + UNumberFormat* unumFmt; + UNumberFormatStyle style = UNUM_CURRENCY; + UErrorCode status = U_ZERO_ERROR; + int32_t j; + + if(i == 1){ // change for factory method + style = UNUM_CASH_CURRENCY; + } + + unumFmt = unum_open(style, NULL, 0, localeString, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("FAIL: unum_open, locale %s, style %d - %s\n", + localeString, (int)style, myErrorName(status)); + continue; + } + + if(i == 0){ // this is for the getter/setter + if(unum_getAttribute(unumFmt, UNUM_CURRENCY_USAGE) != UCURR_USAGE_STANDARD) { + log_err("FAIL: currency usage attribute is not UNUM_CURRENCY_STANDARD\n"); + } + + unum_setAttribute(unumFmt, UNUM_CURRENCY_USAGE, UCURR_USAGE_CASH); + } + + if(unum_getAttribute(unumFmt, UNUM_CURRENCY_USAGE) != UCURR_USAGE_CASH) { + log_err("FAIL: currency usage attribute is not UNUM_CURRENCY_CASH\n"); + } + + for (j=0; jlocale != NULL; lsaTestPtr++) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat * unum = unum_open(lsaTestPtr->style, NULL, 0, lsaTestPtr->locale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("FAIL: unum_open style %d, locale %s: error %s\n", (int)lsaTestPtr->style, lsaTestPtr->locale, u_errorName(status)); + } else { + const ValueAndExpectedString * veItemPtr; + if (lsaTestPtr->attribute >= 0) { + unum_setAttribute(unum, (UNumberFormatAttribute)lsaTestPtr->attribute, lsaTestPtr->attrValue); + } + // ICU 62: should call minSignificantDigits in tandem with maxSignificantDigits. + if (lsaTestPtr->attribute == UNUM_MIN_SIGNIFICANT_DIGITS) { + unum_setAttribute(unum, UNUM_MAX_SIGNIFICANT_DIGITS, lsaTestPtr->attrValue); + } + for (veItemPtr = lsaTestPtr->veItems; veItemPtr->expected != NULL; veItemPtr++) { + UChar uexp[kUBufSize]; + UChar uget[kUBufSize]; + int32_t uexplen, ugetlen; + + status = U_ZERO_ERROR; + uexplen = u_unescape(veItemPtr->expected, uexp, kUBufSize); + ugetlen = unum_formatDouble(unum, veItemPtr->value, uget, kUBufSize, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("FAIL: unum_formatDouble style %d, locale %s, attr %d, value %.2f: error %s\n", + (int)lsaTestPtr->style, lsaTestPtr->locale, lsaTestPtr->attribute, veItemPtr->value, u_errorName(status)); + } else if (ugetlen != uexplen || u_strncmp(uget, uexp, uexplen) != 0) { + char bexp[kBBufSize]; + char bget[kBBufSize]; + u_strToUTF8(bexp, kBBufSize, NULL, uexp, uexplen, &status); + u_strToUTF8(bget, kBBufSize, NULL, uget, ugetlen, &status); + log_err("FAIL: unum_formatDouble style %d, locale %s, attr %d, value %.2f: expect \"%s\", get \"%s\"\n", + (int)lsaTestPtr->style, lsaTestPtr->locale, lsaTestPtr->attribute, veItemPtr->value, bexp, bget); + } + status = U_ZERO_ERROR; + ugetlen = unum_formatDecimal(unum, veItemPtr->valueStr, -1, uget, kUBufSize, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("FAIL: unum_formatDecimal style %d, locale %s, attr %d, valueStr %s: error %s\n", + (int)lsaTestPtr->style, lsaTestPtr->locale, lsaTestPtr->attribute, veItemPtr->valueStr, u_errorName(status)); + } else if (ugetlen != uexplen || u_strncmp(uget, uexp, uexplen) != 0) { + char bexp[kBBufSize]; + char bget[kBBufSize]; + u_strToUTF8(bexp, kBBufSize, NULL, uexp, uexplen, &status); + u_strToUTF8(bget, kBBufSize, NULL, uget, ugetlen, &status); + log_err("FAIL: unum_formatDecimal style %d, locale %s, attr %d, valueStr %s: expect \"%s\", get \"%s\"\n", + (int)lsaTestPtr->style, lsaTestPtr->locale, lsaTestPtr->attribute, veItemPtr->valueStr, bexp, bget); + } + } + unum_close(unum); + } + } +} + +static const UChar currpat[] = { 0xA4,0x23,0x2C,0x23,0x23,0x30,0x2E,0x30,0x30,0}; /* ¤#,##0.00 */ +static const UChar parsetxt[] = { 0x78,0x30,0x79,0x24,0 }; /* x0y$ */ + +static void TestParseCurrPatternWithDecStyle() { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *unumfmt = unum_open(UNUM_DECIMAL, NULL, 0, "en_US", NULL, &status); + if (U_FAILURE(status)) { + log_data_err("unum_open DECIMAL failed for en_US: %s (Are you missing data?)\n", u_errorName(status)); + } else { + unum_applyPattern(unumfmt, FALSE, currpat, -1, NULL, &status); + if (U_FAILURE(status)) { + log_err_status(status, "unum_applyPattern failed: %s\n", u_errorName(status)); + } else { + int32_t pos = 0; + double value = unum_parseDouble(unumfmt, parsetxt, -1, &pos, &status); + if (U_SUCCESS(status)) { + log_err_status(status, "unum_parseDouble expected to fail but got status %s, value %f\n", u_errorName(status), value); + } + } + unum_close(unumfmt); + } +} + +/* + * Ticket #12684 + * Test unum_formatDoubleForFields (and UFieldPositionIterator) + */ + +typedef struct { + int32_t field; + int32_t beginPos; + int32_t endPos; +} FieldsData; + +typedef struct { + const char * locale; + UNumberFormatStyle style; + double value; + const FieldsData * expectedFields; +} FormatForFieldsItem; + +static const UChar patNoFields[] = { 0x0027, 0x0078, 0x0027, 0 }; /* "'x'", for UNUM_PATTERN_DECIMAL */ + + +/* "en_US", UNUM_CURRENCY, 123456.0 : "¤#,##0.00" => "$123,456.00" */ +static const FieldsData fields_en_CURR[] = { + { UNUM_CURRENCY_FIELD /*7*/, 0, 1 }, + { UNUM_GROUPING_SEPARATOR_FIELD /*6*/, 4, 5 }, + { UNUM_INTEGER_FIELD /*0*/, 1, 8 }, + { UNUM_DECIMAL_SEPARATOR_FIELD /*2*/, 8, 9 }, + { UNUM_FRACTION_FIELD /*1*/, 9, 11 }, + { -1, -1, -1 }, +}; +/* "en_US"/"es_US/MX" , UNUM_PERCENT, -34 : "#,##0%" => "-34%" */ +static const FieldsData fields_en_PRCT[] = { + { UNUM_SIGN_FIELD /*10*/, 0, 1 }, + { UNUM_INTEGER_FIELD /*0*/, 1, 3 }, + { UNUM_PERCENT_FIELD /*8*/, 3, 4 }, + { -1, -1, -1 }, +}; +/* "fr_FR", UNUM_CURRENCY, 123456.0 : "#,##0.00 ¤" => "123,456.00 €" */ +static const FieldsData fields_fr_CURR[] = { + { UNUM_GROUPING_SEPARATOR_FIELD /*6*/, 3, 4 }, + { UNUM_INTEGER_FIELD /*0*/, 0, 7 }, + { UNUM_DECIMAL_SEPARATOR_FIELD /*2*/, 7, 8 }, + { UNUM_FRACTION_FIELD /*1*/, 8, 10 }, + { UNUM_CURRENCY_FIELD /*7*/, 11, 12 }, + { -1, -1, -1 }, +}; +/* "en_US", UNUM_PATTERN_DECIMAL, 12.0 : "'x'" => "x12" */ +static const FieldsData fields_en_PATN[] = { + { UNUM_INTEGER_FIELD /*0*/, 1, 3 }, + { -1, -1, -1 }, +}; + +static const FormatForFieldsItem fffItems[] = { + { "en_US", UNUM_CURRENCY_STANDARD, 123456.0, fields_en_CURR }, + { "en_US", UNUM_PERCENT, -0.34, fields_en_PRCT }, + { "es_US", UNUM_PERCENT, -0.34, fields_en_PRCT }, // rdar://57000745 + { "es_MX", UNUM_PERCENT, -0.34, fields_en_PRCT }, // rdar://42948387 + { "fr_FR", UNUM_CURRENCY_STANDARD, 123456.0, fields_fr_CURR }, + { "en_US", UNUM_PATTERN_DECIMAL, 12.0, fields_en_PATN }, + { NULL, (UNumberFormatStyle)0, 0, NULL }, +}; + +static void TestFormatForFields(void) { + UErrorCode status = U_ZERO_ERROR; + UFieldPositionIterator* fpositer = ufieldpositer_open(&status); + if ( U_FAILURE(status) ) { + log_err("ufieldpositer_open fails, status %s\n", u_errorName(status)); + } else { + const FormatForFieldsItem * itemPtr; + for (itemPtr = fffItems; itemPtr->locale != NULL; itemPtr++) { + UNumberFormat* unum; + status = U_ZERO_ERROR; + unum = (itemPtr->style == UNUM_PATTERN_DECIMAL)? + unum_open(itemPtr->style, patNoFields, -1, itemPtr->locale, NULL, &status): + unum_open(itemPtr->style, NULL, 0, itemPtr->locale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open fails for locale %s, style %d: status %s (Are you missing data?)\n", itemPtr->locale, itemPtr->style, u_errorName(status)); + } else { + UChar ubuf[kUBufSize]; + int32_t ulen = unum_formatDoubleForFields(unum, itemPtr->value, ubuf, kUBufSize, fpositer, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDoubleForFields fails for locale %s, style %d: status %s\n", itemPtr->locale, itemPtr->style, u_errorName(status)); + } else { + const FieldsData * fptr; + int32_t field, beginPos, endPos; + for (fptr = itemPtr->expectedFields; TRUE; fptr++) { + field = ufieldpositer_next(fpositer, &beginPos, &endPos); + if (field != fptr->field || (field >= 0 && (beginPos != fptr->beginPos || endPos != fptr->endPos))) { + if (fptr->field >= 0) { + log_err("unum_formatDoubleForFields for locale %s as \"%s\"; expect field %d range %d-%d, get field %d range %d-%d\n", + itemPtr->locale, aescstrdup(ubuf, ulen), fptr->field, fptr->beginPos, fptr->endPos, field, beginPos, endPos); + } else { + log_err("unum_formatDoubleForFields for locale %s as \"%s\"; expect field < 0, get field %d range %d-%d\n", + itemPtr->locale, aescstrdup(ubuf, ulen), field, beginPos, endPos); + } + break; + } + if (field < 0) { + break; + } + } + } + unum_close(unum); + } + } + ufieldpositer_close(fpositer); + } +} + +static void Test12052_NullPointer() { + UErrorCode status = U_ZERO_ERROR; + static const UChar input[] = u"199a"; + UChar currency[200] = {0}; + UNumberFormat *theFormatter = unum_open(UNUM_CURRENCY, NULL, 0, "en_US", NULL, &status); + if (!assertSuccessCheck("unum_open() failed", &status, TRUE)) { return; } + status = U_ZERO_ERROR; + unum_setAttribute(theFormatter, UNUM_LENIENT_PARSE, 1); + int32_t pos = 1; + unum_parseDoubleCurrency(theFormatter, input, -1, &pos, currency, &status); + assertEquals("should fail gracefully", "U_PARSE_ERROR", u_errorName(status)); + unum_close(theFormatter); +} + +typedef struct { + const char* locale; + const UChar* text; // text to parse + UBool lenient; // leniency to use + UBool intOnly; // whether to set PARSE_INT_ONLY + UErrorCode intStatus; // expected status from parse + int32_t intPos; // expected final pos from parse + int32_t intValue; // expected value from parse + UErrorCode doubStatus; // expected status from parseDouble + int32_t doubPos; // expected final pos from parseDouble + double doubValue; // expected value from parseDouble + UErrorCode decStatus; // expected status from parseDecimal + int32_t decPos; // expected final pos from parseDecimal + const char* decString; // expected output string from parseDecimal + +} ParseCaseItem; + +static const ParseCaseItem parseCaseItems[] = { + { "en", u"0,000", FALSE, FALSE, U_ZERO_ERROR, 5, 0, U_ZERO_ERROR, 5, 0.0, U_ZERO_ERROR, 5, "0" }, + { "en", u"0,000", TRUE, FALSE, U_ZERO_ERROR, 5, 0, U_ZERO_ERROR, 5, 0.0, U_ZERO_ERROR, 5, "0" }, + { "en", u",024", FALSE, FALSE, U_ZERO_ERROR, 4, 24, U_ZERO_ERROR, 4, 24.0, U_ZERO_ERROR, 4, "24" }, + { "en", u",024", TRUE, FALSE, U_ZERO_ERROR, 4, 24, U_ZERO_ERROR, 4, 24.0, U_ZERO_ERROR, 4, "24" }, + { "en", u"1000,000", FALSE, FALSE, U_PARSE_ERROR, 0, 0, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, "" }, + { "en", u"1000,000", TRUE, FALSE, U_ZERO_ERROR, 8, 1000000, U_ZERO_ERROR, 8, 1000000.0, U_ZERO_ERROR, 8, "1000000" }, + { "en", u"", FALSE, FALSE, U_PARSE_ERROR, 0, 0, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, "" }, + { "en", u"", TRUE, FALSE, U_PARSE_ERROR, 0, 0, U_PARSE_ERROR, 0, 0.0, U_PARSE_ERROR, 0, "" }, + { "en", u"9999990000503021", FALSE, FALSE, U_INVALID_FORMAT_ERROR, 16, 2147483647, U_ZERO_ERROR, 16, 9999990000503020.0, U_ZERO_ERROR, 16, "9999990000503021" }, + { "en", u"9999990000503021", FALSE, TRUE, U_INVALID_FORMAT_ERROR, 16, 2147483647, U_ZERO_ERROR, 16, 9999990000503020.0, U_ZERO_ERROR, 16, "9999990000503021" }, + { "en", u"1000000.5", FALSE, FALSE, U_ZERO_ERROR, 9, 1000000, U_ZERO_ERROR, 9, 1000000.5, U_ZERO_ERROR, 9, "1.0000005E+6" /* change from ICU-62nnn */}, + { "en", u"1000000.5", FALSE, TRUE, U_ZERO_ERROR, 7, 1000000, U_ZERO_ERROR, 7, 1000000.0, U_ZERO_ERROR, 7, "1000000" }, + { "en", u"123.5", FALSE, FALSE, U_ZERO_ERROR, 5, 123, U_ZERO_ERROR, 5, 123.5, U_ZERO_ERROR, 5, "123.5" }, + { "en", u"123.5", FALSE, TRUE, U_ZERO_ERROR, 3, 123, U_ZERO_ERROR, 3, 123.0, U_ZERO_ERROR, 3, "123" }, + { NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0.0, 0, 0, NULL } +}; + +static void TestParseCases(void) { + const ParseCaseItem* itemPtr; + for (itemPtr = parseCaseItems; itemPtr->locale != NULL; itemPtr++) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unumDec = unum_open(UNUM_DECIMAL, NULL, 0, itemPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("unum_open UNUM_DECIMAL fails for locale %s: %s\n", itemPtr->locale, u_errorName(status)); + continue; + } + int32_t intValue, parsePos, dclen; + double doubValue; + char decstr[32]; + unum_setAttribute(unumDec, UNUM_LENIENT_PARSE, itemPtr->lenient); + unum_setAttribute(unumDec, UNUM_PARSE_INT_ONLY, itemPtr->intOnly); + + parsePos = 0; + status = U_ZERO_ERROR; + intValue = unum_parse(unumDec, itemPtr->text, -1, &parsePos, &status); + if (status != itemPtr->intStatus || parsePos != itemPtr->intPos || intValue != itemPtr->intValue) { + char btext[32]; + u_austrcpy(btext, itemPtr->text); + log_err("locale %s, text \"%s\", lenient %d, intOnly %d;\n parse expected status %s, pos %d, value %d;\n got %s, %d, %d\n", + itemPtr->locale, btext, itemPtr->lenient, itemPtr->intOnly, + u_errorName(itemPtr->intStatus), itemPtr->intPos, itemPtr->intValue, + u_errorName(status), parsePos, intValue); + } + + parsePos = 0; + status = U_ZERO_ERROR; + doubValue = unum_parseDouble(unumDec, itemPtr->text, -1, &parsePos, &status); + if (status != itemPtr->doubStatus || parsePos != itemPtr->doubPos || doubValue != itemPtr->doubValue) { + char btext[32]; + u_austrcpy(btext, itemPtr->text); + log_err("locale %s, text \"%s\", lenient %d, intOnly %d;\n parseDouble expected status %s, pos %d, value %.1f;\n got %s, %d, %.1f\n", + itemPtr->locale, btext, itemPtr->lenient, itemPtr->intOnly, + u_errorName(itemPtr->doubStatus), itemPtr->doubPos, itemPtr->doubValue, + u_errorName(status), parsePos, doubValue); + } + + parsePos = 0; + status = U_ZERO_ERROR; + decstr[0] = 0; + dclen = unum_parseDecimal(unumDec, itemPtr->text, -1, &parsePos, decstr, 32, &status); + (void)dclen; + if (status != itemPtr->decStatus || parsePos != itemPtr->decPos || uprv_strcmp(decstr,itemPtr->decString) != 0) { + char btext[32]; + u_austrcpy(btext, itemPtr->text); + log_err("locale %s, text \"%s\", lenient %d, intOnly %d;\n parseDecimal expected status %s, pos %d, str \"%s\";\n got %s, %d, \"%s\"\n", + itemPtr->locale, btext, itemPtr->lenient, itemPtr->intOnly, + u_errorName(itemPtr->decStatus), itemPtr->decPos, itemPtr->decString, + u_errorName(status), parsePos, decstr); + } + + unum_close(unumDec); + } +} + +typedef struct { + const char* descrip; + const char* locale; + UNumberFormatStyle style; + int32_t minInt; + int32_t minFrac; + int32_t maxFrac; + double roundIncr; + const UChar* expPattern; + double valueToFmt; + const UChar* expFormat; +} SetMaxFracAndRoundIncrItem; + +static const SetMaxFracAndRoundIncrItem maxFracAndRoundIncrItems[] = { + // descrip locale style mnI mnF mxF rdInc expPat value expFmt + { "01 en_US DEC 1/0/3/0.0", "en_US", UNUM_DECIMAL, 1, 0, 3, 0.0, u"#,##0.###", 0.128, u"0.128" }, + { "02 en_US DEC 1/0/1/0.0", "en_US", UNUM_DECIMAL, 1, 0, 1, 0.0, u"#,##0.#", 0.128, u"0.1" }, + { "03 en_US DEC 1/0/1/0.01", "en_US", UNUM_DECIMAL, 1, 0, 1, 0.01, u"#,##0.#", 0.128, u"0.1" }, + { "04 en_US DEC 1/1/1/0.01", "en_US", UNUM_DECIMAL, 1, 1, 1, 0.01, u"#,##0.0", 0.128, u"0.1" }, + { "05 en_US DEC 1/0/1/0.1", "en_US", UNUM_DECIMAL, 1, 0, 1, 0.1, u"#,##0.1", 0.128, u"0.1" }, // use incr + { "06 en_US DEC 1/1/1/0.1", "en_US", UNUM_DECIMAL, 1, 1, 1, 0.1, u"#,##0.1", 0.128, u"0.1" }, // use incr + + { "10 en_US DEC 1/0/1/0.02", "en_US", UNUM_DECIMAL, 1, 0, 1, 0.02, u"#,##0.#", 0.128, u"0.1" }, + { "11 en_US DEC 1/0/2/0.02", "en_US", UNUM_DECIMAL, 1, 0, 2, 0.02, u"#,##0.02", 0.128, u"0.12" }, // use incr + { "12 en_US DEC 1/0/3/0.02", "en_US", UNUM_DECIMAL, 1, 0, 3, 0.02, u"#,##0.02#", 0.128, u"0.12" }, // use incr + { "13 en_US DEC 1/1/1/0.02", "en_US", UNUM_DECIMAL, 1, 1, 1, 0.02, u"#,##0.0", 0.128, u"0.1" }, + { "14 en_US DEC 1/1/2/0.02", "en_US", UNUM_DECIMAL, 1, 1, 2, 0.02, u"#,##0.02", 0.128, u"0.12" }, // use incr + { "15 en_US DEC 1/1/3/0.02", "en_US", UNUM_DECIMAL, 1, 1, 3, 0.02, u"#,##0.02#", 0.128, u"0.12" }, // use incr + { "16 en_US DEC 1/2/2/0.02", "en_US", UNUM_DECIMAL, 1, 2, 2, 0.02, u"#,##0.02", 0.128, u"0.12" }, // use incr + { "17 en_US DEC 1/2/3/0.02", "en_US", UNUM_DECIMAL, 1, 2, 3, 0.02, u"#,##0.02#", 0.128, u"0.12" }, // use incr + { "18 en_US DEC 1/3/3/0.02", "en_US", UNUM_DECIMAL, 1, 3, 3, 0.02, u"#,##0.020", 0.128, u"0.120" }, // use incr + + { "20 en_US DEC 1/1/1/0.0075", "en_US", UNUM_DECIMAL, 1, 1, 1, 0.0075, u"#,##0.0", 0.019, u"0.0" }, + { "21 en_US DEC 1/1/2/0.0075", "en_US", UNUM_DECIMAL, 1, 1, 2, 0.0075, u"#,##0.0075", 0.004, u"0.0075" }, // use incr + { "22 en_US DEC 1/1/2/0.0075", "en_US", UNUM_DECIMAL, 1, 1, 2, 0.0075, u"#,##0.0075", 0.019, u"0.0225" }, // use incr + { "23 en_US DEC 1/1/3/0.0075", "en_US", UNUM_DECIMAL, 1, 1, 3, 0.0075, u"#,##0.0075", 0.004, u"0.0075" }, // use incr + { "24 en_US DEC 1/1/3/0.0075", "en_US", UNUM_DECIMAL, 1, 1, 3, 0.0075, u"#,##0.0075", 0.019, u"0.0225" }, // use incr + { "25 en_US DEC 1/2/2/0.0075", "en_US", UNUM_DECIMAL, 1, 2, 2, 0.0075, u"#,##0.0075", 0.004, u"0.0075" }, // use incr + { "26 en_US DEC 1/2/2/0.0075", "en_US", UNUM_DECIMAL, 1, 2, 2, 0.0075, u"#,##0.0075", 0.019, u"0.0225" }, // use incr + { "27 en_US DEC 1/2/3/0.0075", "en_US", UNUM_DECIMAL, 1, 2, 3, 0.0075, u"#,##0.0075", 0.004, u"0.0075" }, // use incr + { "28 en_US DEC 1/2/3/0.0075", "en_US", UNUM_DECIMAL, 1, 2, 3, 0.0075, u"#,##0.0075", 0.019, u"0.0225" }, // use incr + { "29 en_US DEC 1/3/3/0.0075", "en_US", UNUM_DECIMAL, 1, 3, 3, 0.0075, u"#,##0.0075", 0.004, u"0.0075" }, // use incr + { "2A en_US DEC 1/3/3/0.0075", "en_US", UNUM_DECIMAL, 1, 3, 3, 0.0075, u"#,##0.0075", 0.019, u"0.0225" }, // use incr + + // Additions for rdar://51452216 + { "30 en_US DEC 1/0/1/0.01", "en_US", UNUM_DECIMAL, 1, 1, 3, 0.001, u"#,##0.001", 1.23456789, u"1.235" }, + { "31 en_US DEC 1/1/1/0.01", "en_US", UNUM_DECIMAL, 1, 1, 3, 0.001f, u"#,##0.001", 1.23456789, u"1.235" }, + + { NULL, NULL, UNUM_IGNORE, 0, 0, 0, 0.0, NULL, 0.0, NULL } +}; + +// The following is copied from C++ number_patternstring.cpp for this C test. +// +// Determine whether a given roundingIncrement should be ignored for formatting +// based on the current maxFrac value (maximum fraction digits). For example a +// roundingIncrement of 0.01 should be ignored if maxFrac is 1, but not if maxFrac +// is 2 or more. Note that roundingIncrements are rounded in significance, so +// a roundingIncrement of 0.006 is treated like 0.01 for this determination, i.e. +// it should not be ignored if maxFrac is 2 or more (but a roundingIncrement of +// 0.005 is treated like 0.001 for significance). This is the reason for the +// initial doubling below. +// roundIncr must be non-zero +static UBool ignoreRoundingIncrement(double roundIncr, int32_t maxFrac) { + if (maxFrac < 0) { + return FALSE; + } + int32_t frac = 0; + roundIncr *= 2.0; + for (frac = 0; frac <= maxFrac && roundIncr <= 1.0; frac++, roundIncr *= 10.0); + return (frac > maxFrac); +} + +static void TestSetMaxFracAndRoundIncr(void) { + const SetMaxFracAndRoundIncrItem* itemPtr; + for (itemPtr = maxFracAndRoundIncrItems; itemPtr->descrip != NULL; itemPtr++) { + UChar ubuf[kUBufMax]; + char bbufe[kBBufMax]; + char bbufg[kBBufMax]; + int32_t ulen; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unf = unum_open(itemPtr->style, NULL, 0, itemPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("locale %s: unum_open style %d fails with %s\n", itemPtr->locale, itemPtr->style, u_errorName(status)); + continue; + } + + unum_setAttribute(unf, UNUM_MIN_INTEGER_DIGITS, itemPtr->minInt); + unum_setAttribute(unf, UNUM_MIN_FRACTION_DIGITS, itemPtr->minFrac); + unum_setAttribute(unf, UNUM_MAX_FRACTION_DIGITS, itemPtr->maxFrac); + unum_setDoubleAttribute(unf, UNUM_ROUNDING_INCREMENT, itemPtr->roundIncr); + + UBool roundIncrUsed = (itemPtr->roundIncr != 0.0 && !ignoreRoundingIncrement(itemPtr->roundIncr, itemPtr->maxFrac)); + + int32_t minInt = unum_getAttribute(unf, UNUM_MIN_INTEGER_DIGITS); + if (minInt != itemPtr->minInt) { + log_err("test %s: unum_getAttribute UNUM_MIN_INTEGER_DIGITS, expected %d, got %d\n", + itemPtr->descrip, itemPtr->minInt, minInt); + } + int32_t minFrac = unum_getAttribute(unf, UNUM_MIN_FRACTION_DIGITS); + if (minFrac != itemPtr->minFrac) { + log_err("test %s: unum_getAttribute UNUM_MIN_FRACTION_DIGITS, expected %d, got %d\n", + itemPtr->descrip, itemPtr->minFrac, minFrac); + } + // If incrementRounding is used, maxFrac is set equal to minFrac + int32_t maxFrac = unum_getAttribute(unf, UNUM_MAX_FRACTION_DIGITS); + // If incrementRounding is used, maxFrac is set equal to minFrac + int32_t expMaxFrac = (roundIncrUsed)? itemPtr->minFrac: itemPtr->maxFrac; + if (maxFrac != expMaxFrac) { + log_err("test %s: unum_getAttribute UNUM_MAX_FRACTION_DIGITS, expected %d, got %d\n", + itemPtr->descrip, expMaxFrac, maxFrac); + } + double roundIncr = unum_getDoubleAttribute(unf, UNUM_ROUNDING_INCREMENT); + // If incrementRounding is not used, roundIncr is set to 0.0 + double expRoundIncr = (roundIncrUsed)? itemPtr->roundIncr: 0.0; + if (roundIncr != expRoundIncr) { + log_err("test %s: unum_getDoubleAttribute UNUM_ROUNDING_INCREMENT, expected %f, got %f\n", + itemPtr->descrip, expRoundIncr, roundIncr); + } + + status = U_ZERO_ERROR; + ulen = unum_toPattern(unf, FALSE, ubuf, kUBufMax, &status); + (void)ulen; + if ( U_FAILURE(status) ) { + log_err("test %s: unum_toPattern fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expPattern)!=0) { + u_austrcpy(bbufe, itemPtr->expPattern); + u_austrcpy(bbufg, ubuf); + log_err("test %s: unum_toPattern expect \"%s\", get \"%s\"\n", itemPtr->descrip, bbufe, bbufg); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unf, itemPtr->valueToFmt, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("test %s: unum_formatDouble fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expFormat)!=0) { + u_austrcpy(bbufe, itemPtr->expFormat); + u_austrcpy(bbufg, ubuf); + log_err("test %s: unum_formatDouble expect \"%s\", get \"%s\"\n", itemPtr->descrip, bbufe, bbufg); + } + + unum_close(unf); + } +} + +static void TestIgnorePadding(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_PATTERN_DECIMAL, NULL, 0, "en_US", NULL, &status); + if (U_FAILURE(status)) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL for en_US and NULL pattern fails:%s\n", u_errorName(status)); + } else { + unum_setAttribute(unum, UNUM_GROUPING_USED, 0); + unum_setAttribute(unum, UNUM_FORMAT_WIDTH, 0); + unum_setTextAttribute(unum, UNUM_PADDING_CHARACTER, u"*", 1, &status); + if (U_FAILURE(status)) { + log_err("unum_setTextAttribute UNUM_PADDING_CHARACTER to '*' fails: %s\n", u_errorName(status)); + } else { + unum_setAttribute(unum, UNUM_PADDING_POSITION, 0); + unum_setAttribute(unum, UNUM_MIN_INTEGER_DIGITS, 0); + unum_setAttribute(unum, UNUM_MAX_INTEGER_DIGITS, 8); + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 0); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 0); + + UChar ubuf[kUBufMax]; + int32_t ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("unum_toPattern fails: %s\n", u_errorName(status)); + } else { + char bbuf[kBBufMax]; + if (ulen > 0 && ubuf[0]==u'*') { + ubuf[kUBufMax-1] = 0; // ensure zero termination + u_austrncpy(bbuf, ubuf, kBBufMax); + log_err("unum_toPattern result should ignore padding but get %s\n", bbuf); + } + unum_applyPattern(unum, FALSE, ubuf, ulen, NULL, &status); + if (U_FAILURE(status)) { + log_err("unum_applyPattern fails: %s\n", u_errorName(status)); + } else { + ulen = unum_formatDecimal(unum, "24", -1, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("unum_formatDecimal fails: %s\n", u_errorName(status)); + } else if (u_strcmp(ubuf, u"24") != 0) { + ubuf[kUBufMax-1] = 0; // ensure zero termination + u_austrncpy(bbuf, ubuf, kBBufMax); + log_err("unum_formatDecimal result expect 24 but get %s\n", bbuf); + } + } + } + } + unum_close(unum); + } +} + +static void TestSciNotationMaxFracCap(void) { + static const UChar* pat1 = u"#.##E+00;-#.##E+00"; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_PATTERN_DECIMAL, pat1, -1, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL with scientific pattern for \"en_US\" fails with %s\n", u_errorName(status)); + } else { + double value; + UChar ubuf[kUBufMax]; + char bbuf[kBBufMax]; + int32_t ulen; + + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 0); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 2147483647); + ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + if ( U_SUCCESS(status) ) { + u_austrncpy(bbuf, ubuf, kUBufMax); + log_info("unum_toPattern (%d): %s\n", ulen, bbuf); + } + + for (value = 10.0; value < 1000000000.0; value *= 10.0) { + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, value, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble value %.1f status %s\n", value, u_errorName(status)); + } else if (u_strncmp(ubuf,u"1E+0",4) != 0) { + u_austrncpy(bbuf, ubuf, kUBufMax); + log_err("unum_formatDouble value %.1f expected result to begin with 1E+0, got %s\n", value, bbuf); + } + } + unum_close(unum); + } +} + +typedef struct { + const char* locale; + double value; + const UChar* formatLimitPrecision; + const UChar* formatFullPrecision; +} FormatPrecisionItem; + +static const FormatPrecisionItem formatPrecisionItems[] = { + { "en_US", 0.33333333 - 0.00333333, u"0.33", u"0.32999999999999996" }, + { "en_US", 0.07 * 100.0, u"7", u"7.000000000000001" }, + { NULL, 0.0, NULL, NULL } +}; + +static const UChar* patternTestPrecision = u"#0.################################################################################"; // 80 fraction places + +// Currently Apple only +static void TestFormatPrecision(void) { + const FormatPrecisionItem* itemPtr; + for (itemPtr = formatPrecisionItems; itemPtr->locale != NULL; itemPtr++) { + UErrorCode status = U_ZERO_ERROR; + UParseError perr; + UNumberFormat *unum = unum_open(UNUM_PATTERN_DECIMAL, patternTestPrecision, -1, itemPtr->locale, &perr, &status); + if (U_FAILURE(status)) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL fails for locale %s: %s\n", itemPtr->locale, u_errorName(status)); + continue; + } + UChar ubuf[kUBufSize]; + int32_t ulen; + UFieldPosition fpos; + UBool formatFullPrecision; + + formatFullPrecision = (UBool)unum_getAttribute(unum, UNUM_FORMAT_WITH_FULL_PRECISION); + if (formatFullPrecision) { + log_err("unum_getAttribute, default for UNUM_FORMAT_WITH_FULL_PRECISION is not FALSE\n"); + } else { + fpos.field = UNUM_DECIMAL_SEPARATOR_FIELD; + fpos.beginIndex = 0; + fpos.endIndex = 0; + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, itemPtr->value, ubuf, kUBufSize, &fpos, &status); + if (U_FAILURE(status)) { + log_err("unum_formatDouble locale %s val %.20f limit precision fails with %s\n", itemPtr->locale, itemPtr->value, u_errorName(status)); + } else if (ulen != u_strlen(itemPtr->formatLimitPrecision) || u_strcmp(ubuf, itemPtr->formatLimitPrecision) != 0) { + char bbufe[kBBufSize]; + char bbufg[kBBufSize]; + u_strToUTF8(bbufe, kBBufSize, NULL, itemPtr->formatLimitPrecision, -1, &status); + u_strToUTF8(bbufg, kBBufSize, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble locale %s val %.20f limit precision, expect %s, get %s\n", itemPtr->locale, itemPtr->value, bbufe, bbufg); + } + } + + unum_setAttribute(unum, UNUM_FORMAT_WITH_FULL_PRECISION, TRUE); + formatFullPrecision = (UBool)unum_getAttribute(unum, UNUM_FORMAT_WITH_FULL_PRECISION); + if (!formatFullPrecision) { + log_err("unum_getAttribute, after set UNUM_FORMAT_WITH_FULL_PRECISION is not TRUE\n"); + } else { + fpos.field = UNUM_DECIMAL_SEPARATOR_FIELD; + fpos.beginIndex = 0; + fpos.endIndex = 0; + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, itemPtr->value, ubuf, kUBufSize, &fpos, &status); + if (U_FAILURE(status)) { + log_err("unum_formatDouble locale %s val %.20f full precision fails with %s\n", itemPtr->locale, itemPtr->value, u_errorName(status)); + } else if (ulen != u_strlen(itemPtr->formatFullPrecision) || u_strcmp(ubuf, itemPtr->formatFullPrecision) != 0) { + char bbufe[kBBufSize]; + char bbufg[kBBufSize]; + u_strToUTF8(bbufe, kBBufSize, NULL, itemPtr->formatFullPrecision, -1, &status); + u_strToUTF8(bbufg, kBBufSize, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble locale %s val %.20f full precision, expect %s, get %s\n", itemPtr->locale, itemPtr->value, bbufe, bbufg); + } + } + + unum_close(unum); + } +} + +// Apple only for +static void TestSetSigDigAndRoundIncr(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_PATTERN_DECIMAL, u"#", 1, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL # for \"en_US\" fails with %s\n", u_errorName(status)); + } else { + static const double value = 1.034000; + UChar ubuf[kUBufMax]; + char bbuf[kBBufMax]; + int32_t ulen; + + unum_setAttribute(unum, UNUM_MAX_INTEGER_DIGITS, 42); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 0); + unum_setAttribute(unum, UNUM_ROUNDING_MODE, UNUM_ROUND_HALFUP); // =6 + unum_setDoubleAttribute(unum, UNUM_ROUNDING_INCREMENT, 0.01); + unum_setAttribute(unum, UNUM_SIGNIFICANT_DIGITS_USED, 1); + unum_setAttribute(unum, UNUM_MAX_SIGNIFICANT_DIGITS, 5); + unum_setAttribute(unum, UNUM_MIN_SIGNIFICANT_DIGITS, 1); + + log_info("unum_getAttribute minSig %d maxSig %d sigUsed %d\n", + unum_getAttribute(unum,UNUM_MIN_SIGNIFICANT_DIGITS), unum_getAttribute(unum,UNUM_MAX_SIGNIFICANT_DIGITS), + unum_getAttribute(unum,UNUM_SIGNIFICANT_DIGITS_USED)); + log_info("unum_getDoubleAttribute UNUM_ROUNDING_INCREMENT %f\n", unum_getDoubleAttribute(unum,UNUM_SIGNIFICANT_DIGITS_USED)); + ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + if ( U_SUCCESS(status) ) { + log_info("unum_toPattern (%d): %s\n", ulen, bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, value, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble value %.1f status %s\n", value, u_errorName(status)); + } else if (u_strcmp(ubuf,u"1.03") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble value %.1f expected 1.03, got %s\n", value, bbuf); + } + unum_close(unum); + } +} + +// Apple for +typedef struct { + const char* descrip; + const char* locale; + const UChar* setPosPrefix; + const UChar* setPosSuffix; + const UChar* setNegPrefix; + const UChar* setNegSuffix; + const UChar* expPosPrefix; + const UChar* expPosSuffix; + const UChar* expNegPrefix; + const UChar* expNegSuffix; + const UChar* expPattern; + double value; + const UChar* expPosFormat; + const UChar* expNegFormat; +} SetAffixOnCurrFmtItem; + +static const SetAffixOnCurrFmtItem affixOnCurrFmtItems[] = { + // descrip loc sPP sPS sNP sNS ePP ePS eNP eNS ePattern value ePosFmt eNegFmt + { "01 en set no affix ", "en", NULL, NULL, NULL, NULL, u"¤", u"", u"-¤", u"", u"¤#,##0.00", 123.4, u"¤123.40", u"-¤123.40" }, + { "02 en set + prefix", "en", u"$", NULL, NULL, NULL, u"$", u"", u"-¤", u"", u"$#,##0.00;-¤#,##0.00", 123.4, u"$123.40", u"-¤123.40" }, + { "03 en set +- prefix", "en", u"$", NULL, u"-$", NULL, u"$", u"", u"-$", u"", u"$#,##0.00;'-'$#,##0.00", 123.4, u"$123.40", u"-$123.40" }, + { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,0.0,NULL,NULL } +}; + +// Apple only for +static void TestSetAffixOnCurrFmt(void) { + const SetAffixOnCurrFmtItem* itemPtr; + for (itemPtr = affixOnCurrFmtItems; itemPtr->descrip != NULL; itemPtr++) { + UChar ubuf[kUBufMax]; + char bbufe[kBBufMax]; + char bbufg[kBBufMax]; + int32_t ulen; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unf = unum_open(UNUM_CURRENCY, NULL, 0, itemPtr->locale, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("locale %s: unum_open UNUM_CURRENCY fails with %s\n", itemPtr->locale, u_errorName(status)); + continue; + } + + if (itemPtr->setPosPrefix) { + status = U_ZERO_ERROR; + unum_setTextAttribute(unf, UNUM_POSITIVE_PREFIX, itemPtr->setPosPrefix, -1, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_setTextAttribute UNUM_POSITIVE_PREFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } + } + if (itemPtr->setPosSuffix) { + status = U_ZERO_ERROR; + unum_setTextAttribute(unf, UNUM_POSITIVE_SUFFIX, itemPtr->setPosSuffix, -1, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_setTextAttribute UNUM_POSITIVE_SUFFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } + } + if (itemPtr->setNegPrefix) { + status = U_ZERO_ERROR; + unum_setTextAttribute(unf, UNUM_NEGATIVE_PREFIX, itemPtr->setNegPrefix, -1, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_setTextAttribute UNUM_NEGATIVE_PREFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } + } + if (itemPtr->setNegSuffix) { + status = U_ZERO_ERROR; + unum_setTextAttribute(unf, UNUM_NEGATIVE_SUFFIX, itemPtr->setNegSuffix, -1, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_setTextAttribute UNUM_NEGATIVE_SUFFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } + } + + status = U_ZERO_ERROR; + ulen = unum_getTextAttribute(unf, UNUM_POSITIVE_PREFIX, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_getTextAttribute UNUM_POSITIVE_PREFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expPosPrefix)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expPosPrefix, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_getTextAttribute UNUM_POSITIVE_PREFIX expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + status = U_ZERO_ERROR; + ulen = unum_getTextAttribute(unf, UNUM_POSITIVE_SUFFIX, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_getTextAttribute UNUM_POSITIVE_SUFFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expPosSuffix)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expPosSuffix, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_getTextAttribute UNUM_POSITIVE_SUFFIX expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + status = U_ZERO_ERROR; + ulen = unum_getTextAttribute(unf, UNUM_NEGATIVE_PREFIX, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_getTextAttribute UNUM_NEGATIVE_PREFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expNegPrefix)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expNegPrefix, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_getTextAttribute UNUM_NEGATIVE_PREFIX expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + status = U_ZERO_ERROR; + ulen = unum_getTextAttribute(unf, UNUM_NEGATIVE_SUFFIX, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_getTextAttribute UNUM_NEGATIVE_SUFFIX fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expNegSuffix)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expNegSuffix, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_getTextAttribute UNUM_NEGATIVE_SUFFIX expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + status = U_ZERO_ERROR; + ulen = unum_toPattern(unf, FALSE, ubuf, kUBufMax, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_toPattern fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expPattern)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expPattern, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_toPattern expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unf, itemPtr->value, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_formatDouble positive fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expPosFormat)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expPosFormat, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_formatDouble positive expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unf, -1.0*itemPtr->value, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("test %s: unum_formatDouble negative fails with %s\n", itemPtr->descrip, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expNegFormat)!=0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expNegFormat, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("test %s: unum_formatDouble negative expect %s, get %s\n", itemPtr->descrip, bbufe, bbufg); + } + + unum_close(unf); + } +} + +// Apple only for +static void TestParseWithEmptyCurr(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_CURRENCY, NULL, 0, "en_US", NULL, &status); + if (U_FAILURE(status)) { + log_data_err("unum_open UNUM_CURRENCY for \"en_US\" fails with %s\n", u_errorName(status)); + } else { + unum_setSymbol(unum, UNUM_CURRENCY_SYMBOL, u"", 0, &status); + if (U_FAILURE(status)) { + log_err("unum_setSymbol UNUM_CURRENCY_SYMBOL u\"\" fails with %s\n", u_errorName(status)); + } else { + char bbuf[kBBufMax] = { 0 }; + UChar curr[4] = { 0 }; + int32_t ppos, blen; + double val; + const UChar* text = u"3"; + + status = U_ZERO_ERROR; + ppos = 0; + blen = unum_parseDecimal(unum, text, -1, &ppos, bbuf, kBBufMax, &status); + if (U_FAILURE(status)) { + log_err("unum_parseDecimal u\"3\" with empty curr symbol fails with %s, ppos %d\n", u_errorName(status), ppos); + } else if (ppos != 1 || blen != 1 || bbuf[0] != '3') { + log_err("unum_parseDecimal expect ppos 1, blen 1, str 3; get %d, %d, %s\n", ppos, blen, bbuf); + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDouble(unum, text, -1, &ppos, &status); + if (U_FAILURE(status)) { + log_err("unum_parseDouble u\"3\" with empty curr symbol fails with %s, ppos %d\n", u_errorName(status), ppos); + } else if (ppos != 1 || val != 3.0) { + log_err("unum_parseDouble expect ppos 1, val 3.0; get %d, %.2f\n", ppos, val); + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDoubleCurrency(unum, text, -1, &ppos, curr, &status); + if (U_SUCCESS(status)) { + log_err("unum_parseDoubleCurrency u\"3\" with empty curr symbol succeeds, get ppos %d, val %.2f\n", ppos, val); + } + } + unum_close(unum); + } + + // Additions for + // "¤#,##0.00" "¤ #,##0.00" "#,##0.00 ¤" "#,##,##0.00¤" + static const char* locales[] = {"en_US", "en_NO", "en_CZ", "en_BD", NULL }; + const char ** localesPtr = locales; + const char* locale; + while ((locale = *localesPtr++) != NULL) { + status = U_ZERO_ERROR; + unum = unum_open(UNUM_CURRENCY, NULL, 0, locale, NULL, &status); + if (U_FAILURE(status)) { + log_data_err("locale %s unum_open UNUM_CURRENCY fails with %s\n", locale, u_errorName(status)); + } else { + char bbuf[kBBufMax] = { 0 }; + UChar curr[4] = { 0 }; + UChar ubuf[kUBufMax]; + int32_t ppos, blen, ulen; + const double posValToUse = 37.0; + const double negValToUse = -3.0; + double val; + + status = U_ZERO_ERROR; + unum_setSymbol(unum, UNUM_CURRENCY_SYMBOL, u"", 0, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_setSymbol UNUM_CURRENCY_SYMBOL u\"\" fails with %s, skipping\n", locale, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, posValToUse, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_formatDouble %.1f fails with %s, skipping\n", locale, posValToUse, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDouble(unum, ubuf, ulen, &ppos, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_parseDouble fails with %s, ppos %d, expect %.1f\n", locale, u_errorName(status), ppos, posValToUse); + } else if (ppos != ulen || val != posValToUse) { + log_err("locale %s unum_parseDouble expect ppos %d, val %.1f; get %d, %.2f\n", locale, ulen, posValToUse, ppos, val); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, negValToUse, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_formatDouble %.1f fails with %s, skipping\n", locale, negValToUse, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDouble(unum, ubuf, ulen, &ppos, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_parseDouble fails with %s, ppos %d, expect %.1f\n", locale, u_errorName(status), ppos, negValToUse); + } else if (ppos != ulen || val != negValToUse) { + log_err("locale %s unum_parseDouble expect ppos %d, val %.1f; get %d, %.2f\n", locale, ulen, negValToUse, ppos, val); + } + + status = U_ZERO_ERROR; + unum_applyPattern(unum, FALSE, u"#,##0.00¤", -1, NULL, &status); + if (U_FAILURE(status)) { + log_err("locale %s unum_applyPattern \"#,##0.00¤\" fails with %s, skipping\n", locale, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, posValToUse, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("locale %s with \"#,##0.00¤\" unum_formatDouble %.1f fails with %s, skipping\n", locale, posValToUse, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDouble(unum, ubuf, ulen, &ppos, &status); + if (U_FAILURE(status)) { + log_err("locale %s with \"#,##0.00¤\" unum_parseDouble fails with %s, ppos %d, expect %.1f\n", locale, u_errorName(status), ppos, posValToUse); + } else if (ppos != ulen || val != posValToUse) { + log_err("locale %s with \"#,##0.00¤\" unum_parseDouble expect ppos %d, val %.1f; get %d, %.2f\n", locale, ulen, posValToUse, ppos, val); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, negValToUse, ubuf, kUBufMax, NULL, &status); + if (U_FAILURE(status)) { + log_err("locale %s with \"#,##0.00¤\" unum_formatDouble %.1f fails with %s, skipping\n", locale, negValToUse, u_errorName(status)); + continue; + } + + status = U_ZERO_ERROR; + ppos = 0; + val = unum_parseDouble(unum, ubuf, ulen, &ppos, &status); + if (U_FAILURE(status)) { + log_err("locale %s with \"#,##0.00¤\" unum_parseDouble fails with %s, ppos %d, expect %.1f\n", locale, u_errorName(status), ppos, negValToUse); + } else if (ppos != ulen || val != negValToUse) { + log_err("locale %s with \"#,##0.00¤\" unum_parseDouble expect ppos %d, val %.1f; get %d, %.2f\n", locale, ulen, negValToUse, ppos, val); + } + + unum_close(unum); + } + } +} + +// Apple only for +static const UChar* pat1 = u"#.##E+00;-#.##E+00"; +static void TestSciNotationNumbers(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_PATTERN_DECIMAL, NULL, 0, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL with null pattern for \"en_US\" fails with %s\n", u_errorName(status)); + } else { + unum_applyPattern(unum, FALSE, pat1, u_strlen(pat1), NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_applyPattern fails with %s\n", u_errorName(status)); + } else { + double value; + UChar ubuf[kUBufMax]; + char bbuf[kBBufMax]; + int32_t ulen; + + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 0); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 2147483647); + log_info("unum_getAttribute minInt %d maxInt %d minFrac %d maxFrac %d\n", + unum_getAttribute(unum,UNUM_MIN_INTEGER_DIGITS), unum_getAttribute(unum,UNUM_MAX_INTEGER_DIGITS), + unum_getAttribute(unum,UNUM_MIN_FRACTION_DIGITS), unum_getAttribute(unum,UNUM_MAX_FRACTION_DIGITS)); + ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + if ( U_SUCCESS(status) ) { + log_info("unum_toPattern (%d): %s\n", ulen, bbuf); + } + + for (value = 10.0; value < 1000000000.0; value *= 10.0) { + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, value, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble value %.1f status %s\n", value, u_errorName(status)); + } else if (u_strncmp(ubuf,u"1E+0",4) != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble value %.1f expected result to begin with 1E+0, got %s\n", value, bbuf); + } + } + } + unum_close(unum); + } +} + +// Apple only for +static const UChar* patFmt3Exp = u"0.000E+00"; +static void TestSciNotationPrecision(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_PATTERN_DECIMAL, NULL, 0, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL with null pattern for \"en_US\" fails with %s\n", u_errorName(status)); + } else { + unum_applyPattern(unum, FALSE, pat1, u_strlen(pat1), NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_applyPattern fails with %s\n", u_errorName(status)); + } else { + double value; + UChar ubuf[kUBufMax]; + char bexp[kBBufMax]; + char bget[kBBufMax]; + int32_t ulen; + + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 3); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 3); + unum_setAttribute(unum, UNUM_GROUPING_USED, 0); + + status = U_ZERO_ERROR; + ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + if ( U_FAILURE(status) ) { + log_err("unum_toPattern fails with %s\n", u_errorName(status)); + } else if (u_strcmp(ubuf,patFmt3Exp) != 0) { + u_strToUTF8(bget, kBBufMax, NULL, ubuf, ulen, &status); + log_info("unum_toPattern, get \"%s\"\n", bget); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.0, ubuf, ulen, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble fails with %s\n", u_errorName(status)); + } else if (u_strcmp(ubuf,patFmt3Exp) != 0) { + u_strToUTF8(bexp, kBBufMax, NULL, patFmt3Exp, -1, &status); + u_strToUTF8(bget, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble error, expect \"%s\", get \"%s\"\n", bexp, bget); + } + } + unum_close(unum); + } +} + +// Apple only for +static const char* minGroupLocale = "pt_PT"; // has minimumGroupingDigits{"2"} +typedef struct { + double value; + const char* string; + const UChar* expectDecimal; + const UChar* expectCurrency; +} TestMinGroupItem; +static const TestMinGroupItem minGroupItems[] = { + { 123.0, "123.0", u"123,00", u"123,00 €" }, + { 1234.0, "1234.0", u"1234,00", u"1234,00 €" }, + { 12345.0, "12345.0", u"12 345,00", u"12 345,00 €" }, + { 123456.0, "123456.0", u"123 456,00", u"123 456,00 €" }, + { 1234567.0, "1234567.0", u"1 234 567,00", u"1 234 567,00 €" }, + { 12345678.0, "12345678.0", u"12 345 678,00", u"12 345 678,00 €" }, + { 0.0, NULL, NULL, NULL } // terminator +}; +static void TestMinimumGrouping(void) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unumd = unum_open(UNUM_DECIMAL, NULL, 0, minGroupLocale, NULL, &status); + UNumberFormat* unumc = unum_open(UNUM_CURRENCY, NULL, 0, minGroupLocale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_PATTERN_DECIMAL/CURRENCY for %s fails with %s\n", minGroupLocale, u_errorName(status)); + } else { + const TestMinGroupItem* itemPtr; + unum_setAttribute(unumd, UNUM_MIN_FRACTION_DIGITS, 2); + for (itemPtr = minGroupItems; itemPtr->value != 0.0; itemPtr++) { + UChar ubuf[kUBufMax]; + char bbufe[kBBufMax]; + char bbufg[kBBufMax]; + int32_t ulen; + + status = U_ZERO_ERROR; + ulen = unum_formatDecimal(unumd, itemPtr->string, -1, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDecimal DEC for locale %s, value %.1f fails with %s\n", minGroupLocale, itemPtr->value, u_errorName(status)); + } else if (u_strcmp(ubuf, itemPtr->expectDecimal) != 0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expectDecimal, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDecimal DEC for locale %s, value %.1f, expected \"%s\" but got \"%s\"\n", + minGroupLocale, itemPtr->value, bbufe, bbufg); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unumd, itemPtr->value, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble DEC for locale %s, value %.1f fails with %s\n", minGroupLocale, itemPtr->value, u_errorName(status)); + } else if (u_strcmp(ubuf, itemPtr->expectDecimal) != 0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expectDecimal, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble DEC for locale %s, value %.1f, expected \"%s\" but got \"%s\"\n", + minGroupLocale, itemPtr->value, bbufe, bbufg); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unumc, itemPtr->value, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble CUR for locale %s, value %.1f fails with %s\n", minGroupLocale, itemPtr->value, u_errorName(status)); + } else if (u_strcmp(ubuf, itemPtr->expectCurrency) != 0) { + u_strToUTF8(bbufe, kBBufMax, NULL, itemPtr->expectCurrency, -1, &status); + u_strToUTF8(bbufg, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble CUR for locale %s, value %.1f, expected \"%s\" but got \"%s\"\n", + minGroupLocale, itemPtr->value, bbufe, bbufg); + } + } + unum_close(unumc); + unum_close(unumd); + } +} + +// Apple only for +static const char* const numSysLocales[] = { + "en_US", "en_US@numbers=arab", "en_US@numbers=roman", "en_US@numbers=grek", "en_US@numbers=hebr", + "zh@numbers=hanidec", "zh_Hant@numbers=traditional", "en@numbers=finance", NULL +}; +static void TestNumberSystemsMultiplier(void) { + const char* const* localesPtr = numSysLocales; + const char* locale; + while ((locale = *localesPtr++) != NULL) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *unum = unum_open(UNUM_DECIMAL, NULL, 0, locale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_DECIMAL for %s fails with %s\n", locale, u_errorName(status)); + } else { + int32_t multiplier = unum_getAttribute(unum, UNUM_MULTIPLIER); + log_info("for locale %s with UNUM_DECIMAL, UNUM_MULTIPLIER is %d\n", locale, multiplier); + unum_close(unum); + } + } +} + +// Apple only for +typedef struct { + const char* locale; + const UChar* stringToParse; + double expectValue; + int32_t expectPos; +} ParseScientificItem; +static const ParseScientificItem parseSciItems[] = { + { "en_US", u"4E\u200E+05", 400000.0, 6 }, + { "en_US", u"4E+05", 400000.0, 5 }, + { "en_US", u"4E\u200E-02", 0.04, 6 }, + { "en_US", u"4E-02", 0.04, 5 }, + { "he_IL", u"4E\u200E+05", 400000.0, 6 }, + { "he_IL", u"4E+05", 400000.0, 5 }, + { "he_IL", u"4E\u200E-02", 0.04, 6 }, + { "he_IL", u"4E-02", 0.04, 5 }, + { "en@numbers=arabext", u"\u06F4\u00D7\u06F1\u06F0^\u200E+\u200E\u06F0\u06F5", 400000.0, 10 }, + { "en@numbers=arabext", u"\u06F4\u00D7\u06F1\u06F0^+\u06F0\u06F5", 400000.0, 8 }, + { NULL,NULL, 0.0, 0 } // terminator +}; +static void TestParseScientific(void) { + const ParseScientificItem* itemPtr; + for (itemPtr = parseSciItems; itemPtr->locale != NULL; itemPtr++) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *unum = unum_open(UNUM_SCIENTIFIC, NULL, 0, itemPtr->locale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_SCIENTIFIC for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else { + int32_t parsePos = 0; + double result = unum_parseDouble(unum, itemPtr->stringToParse, -1, &parsePos, &status); + if ( U_FAILURE(status) ) { + log_err("unum_parseDouble for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else if (result != itemPtr->expectValue || parsePos != itemPtr->expectPos) { + log_err("unum_parseDouble for %s, expected result %.1f pos %d, got %.1f %d\n", + itemPtr->locale, itemPtr->expectValue, itemPtr->expectPos, result, parsePos); + } + unum_close(unum); + } + } +} + +// Apple only for +typedef struct { + const char* locale; + const UChar* expCurrCode; +} LocaleCurrCodeItem; +static const LocaleCurrCodeItem currCodeItems[] = { + { "en", u"" }, // curr ICU has "XXX" + { "en@currency=EUR", u"EUR" }, + { "en_US", u"USD" }, + { "en_ZZ", u"XAG" }, + { "_US", u"USD" }, + { "_ZZ", u"XAG" }, + { "us", u"" }, // curr ICU has "XXX" + { "", u"" }, // curr ICU has "XXX" + { NULL, NULL } +}; +static void TestCurrForUnkRegion(void) { + const LocaleCurrCodeItem* itemPtr; + for (itemPtr = currCodeItems; itemPtr->locale != NULL; itemPtr++) { + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_CURRENCY, NULL, 0, itemPtr->locale, NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_CURRENCY for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else { + UChar ubuf[kUBufMax]; + int32_t ulen = unum_getTextAttribute(unum, UNUM_CURRENCY_CODE, ubuf, kUBufMax, &status); + if ( U_FAILURE(status) ) { + log_err("unum_getTextAttribute UNUM_CURRENCY_CODE for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else if (u_strcmp(ubuf,itemPtr->expCurrCode)!=0) { + char bexp[kBBufMax]; + char bget[kBBufMax]; + u_strToUTF8(bexp, kBBufMax, NULL, itemPtr->expCurrCode, -1, &status); + u_strToUTF8(bget, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_getTextAttribute UNUM_CURRENCY_CODE error for %s, expect \"%s\" but get \"%s\"\n", itemPtr->locale, bexp, bget); + } + status = U_ZERO_ERROR; + unum_setTextAttribute(unum, UNUM_CURRENCY_CODE, u"XXX", 3, &status); + if ( U_FAILURE(status) ) { + log_err("unum_setTextAttribute UNUM_CURRENCY_CODE for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else { + ulen = unum_getTextAttribute(unum, UNUM_CURRENCY_CODE, ubuf, kUBufMax, &status); + if ( U_FAILURE(status) ) { + log_err("unum_getTextAttribute UNUM_CURRENCY_CODE XXX for %s fails with %s\n", itemPtr->locale, u_errorName(status)); + } else if (u_strcmp(ubuf,u"XXX")!=0) { + char bget[kBBufMax]; + u_strToUTF8(bget, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_getTextAttribute UNUM_CURRENCY_CODE error for %s, expect XXX but get \"%s\"\n", itemPtr->locale, bget); + } + } + unum_close(unum); + } + } +} + +static void TestMinIntMinFracZero(void) { + UChar ubuf[kUBufMax]; + char bbuf[kBBufMax]; + int minInt, minFrac, maxFrac, ulen; + + UErrorCode status = U_ZERO_ERROR; + UNumberFormat* unum = unum_open(UNUM_DECIMAL, NULL, 0, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_DECIMAL for en_US fails with %s\n", u_errorName(status)); + } else { + unum_setAttribute(unum, UNUM_MIN_INTEGER_DIGITS, 0); + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 0); + minInt = unum_getAttribute(unum, UNUM_MIN_INTEGER_DIGITS); + minFrac = unum_getAttribute(unum, UNUM_MIN_FRACTION_DIGITS); + if (minInt != 0 || minFrac != 0) { + log_err("after setting minInt=minFrac=0, get minInt %d, minFrac %d\n", minInt, minFrac); + } + + ulen = unum_toPattern(unum, FALSE, ubuf, kUBufMax, &status); + if ( U_FAILURE(status) ) { + log_err("unum_toPattern fails with %s\n", u_errorName(status)); + } else if (ulen < 3 || u_strstr(ubuf, u"#.#")==NULL) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("after setting minInt=minFrac=0, expect pattern to contain \"#.#\", but get (%d): \"%s\"\n", ulen, bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 10.0, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble 10.0 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u"10") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble 10.0 expected \"10\", got \"%s\"\n", bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.9, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble 0.9 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u".9") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble 0.9 expected \".9\", got \"%s\"\n", bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.0, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble 0.0 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u"0") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble 0.0 expected \"0\", got \"%s\"\n", bbuf); + } + + unum_close(unum); + } + + status = U_ZERO_ERROR; + unum = unum_open(UNUM_CURRENCY, NULL, 0, "en_US", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_CURRENCY for en_US fails with %s\n", u_errorName(status)); + } else { + unum_setAttribute(unum, UNUM_MIN_INTEGER_DIGITS, 0); + unum_setAttribute(unum, UNUM_MIN_FRACTION_DIGITS, 0); + minInt = unum_getAttribute(unum, UNUM_MIN_INTEGER_DIGITS); + minFrac = unum_getAttribute(unum, UNUM_MIN_FRACTION_DIGITS); + if (minInt != 0 || minFrac != 0) { + log_err("after setting CURRENCY minInt=minFrac=0, get minInt %d, minFrac %d\n", minInt, minFrac); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 10.0, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble (CURRRENCY) 10.0 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u"$10") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble (CURRRENCY) 10.0 expected \"$10\", got \"%s\"\n", bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.9, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble (CURRRENCY) 0.9 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u"$.9") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble (CURRRENCY) 0.9 expected \"$.9\", got \"%s\"\n", bbuf); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.0, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble (CURRRENCY) 0.0 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u"$0") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble (CURRRENCY) 0.0 expected \"$0\", got \"%s\"\n", bbuf); + } + + unum_close(unum); + } + + // addition for rdar://57291456 + status = U_ZERO_ERROR; + unum = unum_open(UNUM_PATTERN_DECIMAL, NULL, 0, "en_IE", NULL, &status); + if ( U_FAILURE(status) ) { + log_data_err("unum_open UNUM_DECIMAL for en_US fails with %s\n", u_errorName(status)); + } else { + unum_setAttribute(unum, UNUM_MIN_INTEGER_DIGITS, 0); + unum_setAttribute(unum, UNUM_MAX_FRACTION_DIGITS, 1); + minInt = unum_getAttribute(unum, UNUM_MIN_INTEGER_DIGITS); + maxFrac = unum_getAttribute(unum, UNUM_MAX_FRACTION_DIGITS); + if (minInt != 0 || maxFrac != 1) { + log_err("after setting minInt=0, maxFrac=1, get minInt %d, maxFrac %d\n", minInt, maxFrac); + } + + status = U_ZERO_ERROR; + ulen = unum_formatDouble(unum, 0.0, ubuf, kUBufMax, NULL, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDouble (maxFrac 1) 0.0 ulen %d fails with %s\n", ulen, u_errorName(status)); + } else if (u_strcmp(ubuf, u".0") != 0) { + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + log_err("unum_formatDouble (maxFrac 1) 0.0 expected \".0\", got \"%s\"\n", bbuf); + } + + unum_close(unum); + } +} + +#if APPLE_ADDITIONS +#include +#if U_PLATFORM_IS_DARWIN_BASED +#include +#include +#define GET_START() mach_absolute_time() +#define GET_DURATION(start, info) ((mach_absolute_time() - start) * info.numer)/info.denom +#elif !U_PLATFORM_HAS_WIN32_API +#include +#include "putilimp.h" +#define GET_START() (uint64_t)uprv_getUTCtime() +#define GET_DURATION(start, info) ((uint64_t)uprv_getUTCtime() - start) +#else +#include "putilimp.h" +#define GET_START() (unsigned long long)uprv_getUTCtime() +#define GET_DURATION(start, info) ((unsigned long long)uprv_getUTCtime() - start) +#endif + +// Apple only for + +static void TestFormatDecPerf(void) { + static const char* locales[] = + { "en_US", "ar_EG", "ar_EG@numbers=latn", "zh_CN@numbers=traditional", NULL }; + static const UNumberFormatStyle styles[] = + { UNUM_DECIMAL, UNUM_CURRENCY, UNUM_PATTERN_DECIMAL, UNUM_FORMAT_STYLE_COUNT }; + static const char* values[] = + { "123.4", "234.5", "345.6", "456.7", NULL }; + static const UChar* pattern = u"#"; +#if U_PLATFORM_IS_DARWIN_BASED + mach_timebase_info_data_t info; + mach_timebase_info(&info); +#endif + const char** localesPtr = locales; + const char* locale; + while ((locale = *localesPtr++) != NULL) { + const UNumberFormatStyle* stylesPtr = styles; + UNumberFormatStyle style; + while ((style = *stylesPtr++) < UNUM_FORMAT_STYLE_COUNT) { +#if !U_PLATFORM_HAS_WIN32_API + uint64_t start, duration; +#else + unsigned long long start, duration; +#endif + UErrorCode status = U_ZERO_ERROR; + const UChar* patternPtr = (style == UNUM_PATTERN_DECIMAL)? pattern: NULL; + int32_t patternLen = (style == UNUM_PATTERN_DECIMAL)? u_strlen(pattern): 0; + UNumberFormat *unum; + + start = GET_START(); + unum = unum_open(style, patternPtr, patternLen, locale, NULL, &status); + duration = GET_DURATION(start, info); + log_info("== start locale %s, style %d\n", locale, (int)style); + if ( U_FAILURE(status) ) { + log_data_err("unum_open fails with %s\n", u_errorName(status)); + } else { + log_info("unum_open nsec %5llu\n", duration); + const char** valuesPtr = values; + const char* value; + while ((value = *valuesPtr++) != NULL) { + UChar ubuf[kUBufMax]; + char bbuf[kBBufMax]; + int32_t ulen; + + status = U_ZERO_ERROR; + start = GET_START(); + ulen = unum_formatDecimal(unum, value, strlen(value), ubuf, kUBufMax, NULL, &status); + duration = GET_DURATION(start, info); + u_strToUTF8(bbuf, kBBufMax, NULL, ubuf, ulen, &status); + if ( U_FAILURE(status) ) { + log_err("unum_formatDecimal %s fails with %s\n", value, u_errorName(status)); + } else { + log_info("unum_formatDecimal %s, nsec %5llu, result %s\n", value, duration, bbuf); + } + } + unum_close(unum); + } + } + } +} + +// Apple only for and + +static void TestCountryFallback(void) { + // Locales to check fallback behavior for-- the first column (subscript % 3 == 0) + // is the locale to test with; the second column (subscript % 3 == 1) is the locale + // whose number-formatting properties we should be matching when we use the test locale, + // and the third column (subscript % 3 == 2) is the locale we should be inheriting + // certain language-dependent symbols from (generally, the locale you'd normally get + // as a fallback). + // NOTE: The currency format always follows the country locale, except for the Euro in a handful + // of countries, where it follows the US English currency format. If the country-fallback locale + // ID begins with a *, that's a signal that the currency format comes from the language locale + // instead of the country locale. + char* testLocales[] = { + // locales we still have synthetic resources for that were working okay to begin with + "en_BG", "bg_BG", "en_150", + "en_CN", "zh_CN", "en_001", + "en_CZ", "cs_CZ", "en_CZ", + "en_JP", "ja_JP", "en_001", + "en_KR", "ko_KR", "en_001", + "en_TH", "th_TH", "en_001", + "en_TW", "zh_TW", "en_001", + + // locales that were okay except for currency-pattern issues + // (note that we have to specify the language locale as en, not en_150-- the en_150 currency format is wrong too) + "en_EE", "*et_EE", "en", + "en_LT", "*lt_LT", "en_LT", + "en_LV", "*lv_LV", "en", + "en_PT", "*pt_PT", "en", + "en_SK", "*sk_SK", "en_SK", + "en_FR", "*fr_FR", "en_FR", + + // locales we still have synthetic resources for that we had to modify to match the country-fallback results + "en_AL", "sq_AL", "en_150", + "en_AR", "es_AR", "en_AR", + "en_BD", "bn_BD@numbers=latn", "en_BD", + "en_BR", "pt_BR", "en_001", + "en_CL", "es_CL", "en_CL", + "en_CO", "es_CO", "en_CO", + "en_GR", "el_GR", "en_150", + "en_HU", "hu_HU", "en_150", + "en_ID", "id_ID", "en_001", + "en_MM", "my_MM@numbers=latn", "en_001", + "en_MV", "dv_MV", "en_001", + "en_MX", "es_MX", "en_001", + "en_RU", "ru_RU", "en_RU", + "en_TR", "tr_TR", "en_TR", + "en_UA", "uk_UA", "en_150", + "es_AG", "en_AG", "es_AG", + "es_BB", "en_BB", "es_BB", + "es_BM", "en_BM", "es_BM", + "es_BQ", "nl_BQ", "es_BQ", + "es_BS", "en_BS", "es_BS", + "es_CA", "en_CA", "es_CA", + "es_CW", "nl_CW", "es_CW", + "es_DM", "en_DM", "es_DM", + "es_GD", "en_GD", "es_GD", + "es_GY", "en_GY", "es_GY", + "es_HT", "fr_HT", "es_HT", + "es_KN", "en_KN", "es_KN", + "es_KY", "en_KY", "es_KY", + "es_LC", "en_LC", "es_LC", + "es_TC", "en_TC", "es_TC", + "es_TT", "en_TT", "es_TT", + "es_VC", "en_VC", "es_VC", + "es_VG", "en_VG", "es_VG", + "es_VI", "en_VI", "es_VI", + + // locales we used to have synthetic resources for but don't anymore + "en_AD", "ca_AD", "en_150", + "en_BA", "bs_BA", "en_150", + "en_ES", "es_ES", "en_150", + "en_HR", "hr_HR", "en_150", + "en_IS", "is_IS", "en_150", + "en_IT", "it_IT", "en_150", + "en_LU", "fr_LU", "en_150", + "en_ME", "sr_ME", "en_150", + "en_NO", "nb_NO", "en_NO", + "en_PL", "pl_PL", "en_150", + "en_RO", "ro_RO", "en_150", + "en_RS", "sr_RS", "en_150", + "en_SA", "ar_SA@numbers=latn", "en", + "es_AI", "en_AI", "es_419", + "es_AW", "nl_AW", "es_419", + "es_BL", "fr_BL", "es_419", + "es_FK", "en_FK", "es_419", + "es_GF", "fr_GF", "es_419", + "es_GL", "kl_GL", "es", + "es_GP", "fr_GP", "es_419", + "es_MF", "fr_MF", "es_419", + "es_MQ", "fr_MQ", "es_419", + "es_MS", "en_MS", "es_419", + "es_PM", "fr_PM", "es_419", + "es_SR", "nl_SR", "es_419", + "es_SX", "en_SX", "es_419", + + // locales we have synthetic resources for, but they come from open-source ICU + "en_DE", "de_DE", "en_DE", + "en_ER", "ti_ER", "en_001", + "en_GH", "ak_GH", "en_001", + "en_HK", "zh_HK", "en_001", + "en_ME", "sr_ME", "en_150", + "en_MO", "zh_MO", "en_001", + "en_MT", "mt_MT", "en_150", + "en_MY", "ms_MY", "en_001", + "en_NL", "nl_NL", "en_150", + "en_PH", "fil_PH", "en_001", + "en_ZW", "sn_ZW", "en_001", + "es_US", "en_US", "es_US", + + // locales where we're adding a NEW synthetic resource bundle, to PREVENT us from falling back by country + "en_BN", "en_001", "en_001", // rdar://69272236 + + // locales specifically mentioned in Radars + "fr_US", "en_US", "fr", // rdar://problem/54886964 +// "en_TH", "th_TH", "en", // rdar://problem/29299919 (listed above) +// "en_BG", "bg_BG", "en", // rdar://problem/29299919 (listed above) + "en_LI", "de_LI", "en", // rdar://problem/29299919 + "en_MC", "fr_MC", "en", // rdar://problem/29299919 + "en_MD", "ro_MD", "en", // rdar://problem/29299919 + "en_VA", "it_VA", "en", // rdar://problem/29299919 + "fr_GB", "en_GB", "fr", // rdar://problem/36020946 + "fr_CN", "zh_CN", "fr", // rdar://problem/50083902 + "es_IE", "en_IE", "es", // rdar://problem/58733843 + "en_LB", "ar_LB@numbers=latn", "en_001", // rdar://66609948 + + // tests for situations where the default number system is different depending on whether you + // fall back by language or by country: +// "en_SA", "ar_SA@numbers=latn", "en", // (listed above) + "ar_US", "en_US@numbers=arab", "ar", + "en_SA@numbers=arab", "ar_SA", "en@numbers=arab", + "ar_US@numbers=latn", "en_US", "ar@numbers=latn", + + // tests for situations where the original locale ID specifies a script: + "sr_Cyrl_SA", "ar_SA@numbers=latn", "sr_Cyrl", + "ru_Cyrl_BA", "bs_Cyrl_BA", "ru", + + // a few additional arbitrary combinations: + "ja_US", "en_US", "ja", + "fr_DE", "de_DE", "fr", + "de_FR", "fr_FR", "de", + "es_TW", "zh_TW", "es", + + // not in the resources, but to exercise the new ures_openWithCountryFallback() logic (AQ's default language is "und") + "fr_AQ", "en", "fr", + + // test to make sure that nothing goes wrong if language and country fallback both lead to the same resource + // (This won't happen for any "real" locales, because ICU has resources for all of them, but we can fake it with + // a nonexistent country code such as QQ.) + "en_QQ", "en", "en" + }; + + for (int32_t i = 0; i < (sizeof(testLocales) / sizeof(char*)); i += 3) { + const char* testLocale = testLocales[i]; + const char* fallbackLocale = testLocales[i + 1]; + const char* languageLocale = testLocales[i + 2]; + char errorMessage[200]; + UBool currencyFollowsLanguage = FALSE; + UErrorCode err = U_ZERO_ERROR; + + if (fallbackLocale[0] == '*') { + currencyFollowsLanguage = TRUE; + ++fallbackLocale; + } + + // Check that the decimal, percentage, currency, and scientific formatting patterns + // for the test locale are the same as those for the fallback locale. + for (UNumberFormatStyle style = UNUM_DECIMAL; style <= UNUM_SCIENTIFIC; ++style) { + err = U_ZERO_ERROR; + UNumberFormat* testFormatter = unum_open(style, NULL, -1, testLocale, NULL, &err); + UNumberFormat* fallbackFormatter = unum_open(style, NULL, -1, fallbackLocale, NULL, &err); + UNumberFormat* languageLocaleFormatter = unum_open(style, NULL, -1, languageLocale, NULL, &err); + + sprintf(errorMessage, "Error creating formatters for %s and %s", testLocale, fallbackLocale); + if (assertSuccess(errorMessage, &err)) { + UChar testPattern[100]; + UChar fallbackPattern[100]; + + unum_toPattern(testFormatter, FALSE, testPattern, 100, &err); + if (style == UNUM_PERCENT || (style == UNUM_CURRENCY && currencyFollowsLanguage)) { + unum_toPattern(languageLocaleFormatter, FALSE, fallbackPattern, 100, &err); + } else { + unum_toPattern(fallbackFormatter, FALSE, fallbackPattern, 100, &err); + } + + if (assertSuccess("Error getting number format patterns", &err)) { + sprintf(errorMessage, "In %s, formatting pattern for style %d doesn't match", testLocale, style); + assertUEquals(errorMessage, fallbackPattern, testPattern); + } + } + unum_close(testFormatter); + unum_close(fallbackFormatter); + unum_close(languageLocaleFormatter); + } + + // Check that all of the number formatting symbols for the test locale (except for the + // currency, exponential, infinity, and NaN symbols) are the same as those for the fallback locale. + UNumberFormat* testFormatter = unum_open(UNUM_DECIMAL, NULL, -1, testLocale, NULL, &err); + UNumberFormat* fallbackFormatter = unum_open(UNUM_DECIMAL, NULL, -1, fallbackLocale, NULL, &err); + UNumberFormat* languageLocaleFormatter = unum_open(UNUM_DECIMAL, NULL, -1, languageLocale, NULL, &err); + if (assertSuccess("Error creating formatters", &err)) { + for (UNumberFormatSymbol symbol = UNUM_DECIMAL_SEPARATOR_SYMBOL; symbol < UNUM_FORMAT_SYMBOL_COUNT; ++symbol) { + UBool compareToFallbackLocale = TRUE; + switch (symbol) { + case UNUM_CURRENCY_SYMBOL: + case UNUM_INTL_CURRENCY_SYMBOL: + case UNUM_MONETARY_SEPARATOR_SYMBOL: + case UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL: + // we don't do anything special with currency here + continue; + case UNUM_PLUS_SIGN_SYMBOL: + case UNUM_MINUS_SIGN_SYMBOL: + case UNUM_PERCENT_SYMBOL: + case UNUM_EXPONENTIAL_SYMBOL: + case UNUM_INFINITY_SYMBOL: + case UNUM_NAN_SYMBOL: + // unlike most number symbols, these should follow the language + compareToFallbackLocale = FALSE; + break; + default: + // everything else follows the country + compareToFallbackLocale = TRUE; + break; + } + + UChar testSymbol[50]; + UChar fallbackSymbol[50]; + + err = U_ZERO_ERROR; + unum_getSymbol(testFormatter, symbol, testSymbol, 50, &err); + if (compareToFallbackLocale) { + unum_getSymbol(fallbackFormatter, symbol, fallbackSymbol, 50, &err); + } else { + unum_getSymbol(languageLocaleFormatter, symbol, fallbackSymbol, 50, &err); + } + + if (assertSuccess("Error getting number format symbol", &err)) { + sprintf(errorMessage, "In %s, formatting symbol #%d doesn't match the fallback", testLocale, symbol); + assertUEquals(errorMessage, fallbackSymbol, testSymbol); + } + } + } + unum_close(testFormatter); + unum_close(fallbackFormatter); + unum_close(languageLocaleFormatter); + } +} + +#endif /* APPLE_ADDITIONS */ + #endif /* #if !UCONFIG_NO_FORMATTING */