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 
expectInList(const char * isoCurrency,uint32_t currencyType,UBool isExpected)15 static void expectInList(const char *isoCurrency, uint32_t currencyType, UBool isExpected) {
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(status));
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 
TestEnumList(void)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 
TestEnumListReset(void)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(status));
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(status));
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 
checkItemCount(uint32_t currencyType)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(status));
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 
TestEnumListCount(void)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 items\n");
151     }
152     if (checkItemCount(UCURR_COMMON|UCURR_UNCOMMON) != 0) {
153         log_err("Error: UCURR_DEPRECATED|UCURR_NON_DEPRECATED should return 0 items\n");
154     }
155 }
156 
TestFractionDigitOverride(void)157 static void TestFractionDigitOverride(void) {
158     UErrorCode status = U_ZERO_ERROR;
159     UNumberFormat *fmt = unum_open(UNUM_CURRENCY, NULL, 0, "hu_HU", NULL, &status);
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", myErrorName(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]), NULL, &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]), NULL, &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]), NULL, &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 
TestPrefixSuffix(void)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,0x0030,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, &status);
215 	unum_setTextAttribute(parser, UNUM_NEGATIVE_PREFIX, NEG_PREFIX, -1, &status);
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 
TestNumericCode(void)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].numericCode);
258         }
259     }
260 }
261 
262 void addCurrencyTest(TestNode** root);
263 
264 #define TESTCASE(x) addTest(root, &x, "tsformat/currtest/" #x)
265 
addCurrencyTest(TestNode ** root)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 */
277