| OLD | NEW |
|---|
| (Empty) |
| 1 /******************************************************************** | |
| 2 * COPYRIGHT: | |
| 3 * Copyright (c) 2005-2015, International Business Machines Corporation and | |
| 4 * others. All Rights Reserved. | |
| 5 ********************************************************************/ | |
| 6 #include "unicode/utypes.h" | |
| 7 | |
| 8 #if !UCONFIG_NO_FORMATTING | |
| 9 #include "unicode/unum.h" | |
| 10 #include "unicode/ucurr.h" | |
| 11 #include "unicode/ustring.h" | |
| 12 #include "cintltst.h" | |
| 13 #include "cstring.h" | |
| 14 | |
| 15 static void expectInList(const char *isoCurrency, uint32_t currencyType, UBool i
sExpected) { | |
| 16 UErrorCode status = U_ZERO_ERROR; | |
| 17 const char *foundCurrency = NULL; | |
| 18 const char *currentCurrency; | |
| 19 UEnumeration *en = ucurr_openISOCurrencies(currencyType, &status); | |
| 20 if (U_FAILURE(status)) { | |
| 21 log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(statu
s)); | |
| 22 return; | |
| 23 } | |
| 24 | |
| 25 while ((currentCurrency = uenum_next(en, NULL, &status)) != NULL) { | |
| 26 if (strcmp(isoCurrency, currentCurrency) == 0) { | |
| 27 foundCurrency = currentCurrency; | |
| 28 break; | |
| 29 } | |
| 30 } | |
| 31 | |
| 32 if ((foundCurrency != NULL) != isExpected) { | |
| 33 log_err("Error: could not find %s as expected. isExpected = %s type=0x%X\
n", | |
| 34 isoCurrency, isExpected ? "TRUE" : "FALSE", currencyType); | |
| 35 } | |
| 36 uenum_close(en); | |
| 37 } | |
| 38 | |
| 39 static void TestEnumList(void) { | |
| 40 expectInList("ADP", UCURR_ALL, TRUE); /* First in list */ | |
| 41 expectInList("ZWD", UCURR_ALL, TRUE); /* Last in list */ | |
| 42 | |
| 43 expectInList("USD", UCURR_ALL, TRUE); | |
| 44 expectInList("USD", UCURR_COMMON, TRUE); | |
| 45 expectInList("USD", UCURR_UNCOMMON, FALSE); | |
| 46 expectInList("USD", UCURR_DEPRECATED, FALSE); | |
| 47 expectInList("USD", UCURR_NON_DEPRECATED, TRUE); | |
| 48 expectInList("USD", UCURR_COMMON|UCURR_DEPRECATED, FALSE); | |
| 49 expectInList("USD", UCURR_COMMON|UCURR_NON_DEPRECATED, TRUE); | |
| 50 expectInList("USD", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE); | |
| 51 expectInList("USD", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 52 | |
| 53 expectInList("USN", UCURR_ALL, TRUE); | |
| 54 expectInList("USN", UCURR_COMMON, FALSE); | |
| 55 expectInList("USN", UCURR_UNCOMMON, TRUE); | |
| 56 expectInList("USN", UCURR_DEPRECATED, FALSE); | |
| 57 expectInList("USN", UCURR_NON_DEPRECATED, TRUE); | |
| 58 expectInList("USN", UCURR_COMMON|UCURR_DEPRECATED, FALSE); | |
| 59 expectInList("USN", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 60 expectInList("USN", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE); | |
| 61 expectInList("USN", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, TRUE); | |
| 62 | |
| 63 expectInList("DEM", UCURR_ALL, TRUE); | |
| 64 expectInList("DEM", UCURR_COMMON, TRUE); | |
| 65 expectInList("DEM", UCURR_UNCOMMON, FALSE); | |
| 66 expectInList("DEM", UCURR_DEPRECATED, TRUE); | |
| 67 expectInList("DEM", UCURR_NON_DEPRECATED, FALSE); | |
| 68 expectInList("DEM", UCURR_COMMON|UCURR_DEPRECATED, TRUE); | |
| 69 expectInList("DEM", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 70 expectInList("DEM", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE); | |
| 71 expectInList("DEM", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 72 | |
| 73 expectInList("XEU", UCURR_ALL, TRUE); | |
| 74 expectInList("XEU", UCURR_COMMON, FALSE); | |
| 75 expectInList("XEU", UCURR_UNCOMMON, TRUE); | |
| 76 expectInList("XEU", UCURR_DEPRECATED, TRUE); | |
| 77 expectInList("XEU", UCURR_NON_DEPRECATED, FALSE); | |
| 78 expectInList("XEU", UCURR_COMMON|UCURR_DEPRECATED, FALSE); | |
| 79 expectInList("XEU", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 80 expectInList("XEU", UCURR_UNCOMMON|UCURR_DEPRECATED, TRUE); | |
| 81 expectInList("XEU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE); | |
| 82 | |
| 83 } | |
| 84 | |
| 85 static void TestEnumListReset(void) { | |
| 86 UErrorCode status = U_ZERO_ERROR; | |
| 87 const char *currency1; | |
| 88 const char *currency2; | |
| 89 UEnumeration *en = ucurr_openISOCurrencies(UCURR_ALL, &status); | |
| 90 if (U_FAILURE(status)) { | |
| 91 log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(statu
s)); | |
| 92 return; | |
| 93 } | |
| 94 | |
| 95 currency1 = uenum_next(en, NULL, &status); | |
| 96 uenum_reset(en, &status); | |
| 97 currency2 = uenum_next(en, NULL, &status); | |
| 98 if (U_FAILURE(status)) { | |
| 99 log_err("Error: uenum_next or uenum_reset returned %s\n", myErrorName(sta
tus)); | |
| 100 return; | |
| 101 } | |
| 102 /* The first item's pointer in the list should be the same between resets. *
/ | |
| 103 if (currency1 != currency2) { | |
| 104 log_err("Error: reset doesn't work %s != %s\n", currency1, currency2); | |
| 105 } | |
| 106 uenum_close(en); | |
| 107 } | |
| 108 | |
| 109 static int32_t checkItemCount(uint32_t currencyType) { | |
| 110 UErrorCode status = U_ZERO_ERROR; | |
| 111 int32_t originalCount, count; | |
| 112 UEnumeration *en = ucurr_openISOCurrencies(currencyType, &status); | |
| 113 int32_t expectedLen = 3, len; | |
| 114 if (U_FAILURE(status)) { | |
| 115 log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(statu
s)); | |
| 116 return -1; | |
| 117 } | |
| 118 | |
| 119 originalCount = uenum_count(en, &status); | |
| 120 for (count=0;;count++) { | |
| 121 const char *str = uenum_next(en, &len, &status); | |
| 122 if (str == NULL || len != expectedLen || strlen(str) != expectedLen) { | |
| 123 break; | |
| 124 } | |
| 125 } | |
| 126 | |
| 127 if (originalCount != count) { | |
| 128 log_err("Error: uenum_count returned the wrong value (type = 0x%X). Got:
%d Expected %d\n", | |
| 129 currencyType, count, originalCount); | |
| 130 } | |
| 131 if (U_FAILURE(status)) { | |
| 132 log_err("Error: uenum_next got an error: %s\n", u_errorName(status)); | |
| 133 } | |
| 134 uenum_close(en); | |
| 135 return count; | |
| 136 } | |
| 137 | |
| 138 static void TestEnumListCount(void) { | |
| 139 checkItemCount(UCURR_ALL); | |
| 140 checkItemCount(UCURR_COMMON); | |
| 141 checkItemCount(UCURR_UNCOMMON); | |
| 142 checkItemCount(UCURR_DEPRECATED); | |
| 143 checkItemCount(UCURR_NON_DEPRECATED); | |
| 144 checkItemCount(UCURR_COMMON|UCURR_DEPRECATED); | |
| 145 checkItemCount(UCURR_COMMON|UCURR_NON_DEPRECATED); | |
| 146 checkItemCount(UCURR_UNCOMMON|UCURR_DEPRECATED); | |
| 147 checkItemCount(UCURR_UNCOMMON|UCURR_NON_DEPRECATED); | |
| 148 | |
| 149 if (checkItemCount(UCURR_DEPRECATED|UCURR_NON_DEPRECATED) != 0) { | |
| 150 log_err("Error: UCURR_DEPRECATED|UCURR_NON_DEPRECATED should return 0 it
ems\n"); | |
| 151 } | |
| 152 if (checkItemCount(UCURR_COMMON|UCURR_UNCOMMON) != 0) { | |
| 153 log_err("Error: UCURR_DEPRECATED|UCURR_NON_DEPRECATED should return 0 it
ems\n"); | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 static void TestFractionDigitOverride(void) { | |
| 158 UErrorCode status = U_ZERO_ERROR; | |
| 159 UNumberFormat *fmt = unum_open(UNUM_CURRENCY, NULL, 0, "hu_HU", NULL, &statu
s); | |
| 160 UChar buffer[256]; | |
| 161 UChar expectedBuf[256]; | |
| 162 const char expectedFirst[] = "123,46\\u00A0Ft"; /* changed to use 2 fraction
digits */ | |
| 163 const char expectedSecond[] = "123,46\\u00A0Ft"; | |
| 164 const char expectedThird[] = "123,456\\u00A0Ft"; | |
| 165 if (U_FAILURE(status)) { | |
| 166 log_data_err("Error: unum_open returned %s (Are you missing data?)\n", my
ErrorName(status)); | |
| 167 return; | |
| 168 } | |
| 169 /* Make sure that you can format normal fraction digits. */ | |
| 170 unum_formatDouble(fmt, 123.456, buffer, sizeof(buffer)/sizeof(buffer[0]), NU
LL, &status); | |
| 171 u_unescape(expectedFirst, expectedBuf, strlen(expectedFirst)+1); | |
| 172 if (u_strcmp(buffer, expectedBuf) != 0) { | |
| 173 log_err("Error: unum_formatDouble didn't return %s\n", expectedFirst); | |
| 174 } | |
| 175 /* Make sure that you can format 2 fraction digits. */ | |
| 176 unum_setAttribute(fmt, UNUM_FRACTION_DIGITS, 2); | |
| 177 unum_formatDouble(fmt, 123.456, buffer, sizeof(buffer)/sizeof(buffer[0]), NU
LL, &status); | |
| 178 u_unescape(expectedSecond, expectedBuf, strlen(expectedSecond)+1); | |
| 179 if (u_strcmp(buffer, expectedBuf) != 0) { | |
| 180 log_err("Error: unum_formatDouble didn't return %s\n", expectedSecond); | |
| 181 } | |
| 182 /* Make sure that you can format more fraction digits. */ | |
| 183 unum_setAttribute(fmt, UNUM_FRACTION_DIGITS, 3); | |
| 184 unum_formatDouble(fmt, 123.456, buffer, sizeof(buffer)/sizeof(buffer[0]), NU
LL, &status); | |
| 185 u_unescape(expectedThird, expectedBuf, strlen(expectedThird)+1); | |
| 186 if (u_strcmp(buffer, expectedBuf) != 0) { | |
| 187 log_err("Error: unum_formatDouble didn't return %s\n", expectedThird); | |
| 188 } | |
| 189 unum_close(fmt); | |
| 190 } | |
| 191 | |
| 192 static void TestPrefixSuffix(void) { | |
| 193 int32_t pos; | |
| 194 UErrorCode status; | |
| 195 double result1 = 0.0, result2 = 0.0; | |
| 196 UNumberFormat* parser; | |
| 197 UChar buffer[4]; | |
| 198 static const UChar TEST_NUMBER[] = {0x0024,0x0031,0x0032,0x002E,0x0030,0x003
0,0}; /* $12.00 */ | |
| 199 static const UChar NEG_PREFIX[] = {0x005B,0}; /* "[" */ | |
| 200 static const UChar NEG_SUFFIX[] = {0x005D,0}; /* "]" */ | |
| 201 | |
| 202 | |
| 203 status = U_ZERO_ERROR; | |
| 204 parser = unum_open(UNUM_CURRENCY, NULL, -1, "en_US", NULL, &status); | |
| 205 if (U_FAILURE(status)) { | |
| 206 log_data_err("Error: unum_open returned %s (Are you missing data?)\n", u_
errorName(status)); | |
| 207 return; | |
| 208 } | |
| 209 | |
| 210 pos = 0; | |
| 211 status = U_ZERO_ERROR; | |
| 212 result1 = unum_parseDoubleCurrency(parser, TEST_NUMBER, -1, &pos, buffer
, &status); | |
| 213 | |
| 214 unum_setTextAttribute(parser, UNUM_NEGATIVE_SUFFIX, NEG_SUFFIX, -1, &sta
tus); | |
| 215 unum_setTextAttribute(parser, UNUM_NEGATIVE_PREFIX, NEG_PREFIX, -1, &sta
tus); | |
| 216 if (U_FAILURE(status)) { | |
| 217 log_err("Error: unum_setTextAttribute returned %s\n", u_errorName(status)
); | |
| 218 return; | |
| 219 } | |
| 220 | |
| 221 pos = 0; | |
| 222 result2 = unum_parseDoubleCurrency(parser, TEST_NUMBER, -1, &pos, buffer
, &status); | |
| 223 if (result1 != result2 || U_FAILURE(status)) { | |
| 224 log_err("Error: unum_parseDoubleCurrency didn't return the same value for
same string %f %f %s\n", | |
| 225 result1, result2, u_errorName(status)); | |
| 226 } | |
| 227 unum_close(parser); | |
| 228 } | |
| 229 | |
| 230 typedef struct { | |
| 231 const char* alphaCode; | |
| 232 int32_t numericCode; | |
| 233 } NumCodeTestEntry; | |
| 234 | |
| 235 static const NumCodeTestEntry NUMCODE_TESTDATA[] = { | |
| 236 {"USD", 840}, | |
| 237 {"Usd", 840}, /* mixed casing */ | |
| 238 {"EUR", 978}, | |
| 239 {"JPY", 392}, | |
| 240 {"XFU", 0}, /* XFU: no numeric code */ | |
| 241 {"ZZZ", 0}, /* ZZZ: undefined ISO currency code */ | |
| 242 {"bogus", 0}, /* bogus code */ | |
| 243 {0, 0}, | |
| 244 }; | |
| 245 | |
| 246 static void TestNumericCode(void) { | |
| 247 UChar code[8]; // at least one longer than the longest alphaCode | |
| 248 int32_t i; | |
| 249 int32_t numCode; | |
| 250 | |
| 251 for (i = 0; NUMCODE_TESTDATA[i].alphaCode; i++) { | |
| 252 int32_t length = uprv_strlen(NUMCODE_TESTDATA[i].alphaCode); | |
| 253 u_charsToUChars(NUMCODE_TESTDATA[i].alphaCode, code, length + 1); // +1
includes the NUL | |
| 254 numCode = ucurr_getNumericCode(code); | |
| 255 if (numCode != NUMCODE_TESTDATA[i].numericCode) { | |
| 256 log_data_err("Error: ucurr_getNumericCode returned %d for currency %
s, expected - %d\n", | |
| 257 numCode, NUMCODE_TESTDATA[i].alphaCode, NUMCODE_TESTDATA[i].nume
ricCode); | |
| 258 } | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 void addCurrencyTest(TestNode** root); | |
| 263 | |
| 264 #define TESTCASE(x) addTest(root, &x, "tsformat/currtest/" #x) | |
| 265 | |
| 266 void addCurrencyTest(TestNode** root) | |
| 267 { | |
| 268 TESTCASE(TestEnumList); | |
| 269 TESTCASE(TestEnumListReset); | |
| 270 TESTCASE(TestEnumListCount); | |
| 271 TESTCASE(TestFractionDigitOverride); | |
| 272 TESTCASE(TestPrefixSuffix); | |
| 273 TESTCASE(TestNumericCode); | |
| 274 } | |
| 275 | |
| 276 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
