[apple/icu.git] / icuSources / test / cintltst / currtest.c

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 2005-2016, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/
#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING
#include "unicode/unum.h"
#include "unicode/ucurr.h"
#include "unicode/ustring.h"
#include "cintltst.h"
#include "cmemory.h"
#include "cstring.h"

static void expectInList(const char *isoCurrency, uint32_t currencyType, UBool isExpected) {
    UErrorCode status = U_ZERO_ERROR;
    const char *foundCurrency = NULL;
    const char *currentCurrency;
    UEnumeration *en = ucurr_openISOCurrencies(currencyType, &status);
    if (U_FAILURE(status)) {
       log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(status));
       return;
    }

    while ((currentCurrency = uenum_next(en, NULL, &status)) != NULL) {
        if (strcmp(isoCurrency, currentCurrency) == 0) {
            foundCurrency = currentCurrency;
            break;
        }
    }

    if ((foundCurrency != NULL) != isExpected) {
       log_err("Error: could not find %s as expected. isExpected = %s type=0x%X\n",
           isoCurrency, isExpected ? "TRUE" : "FALSE", currencyType);
    }
    uenum_close(en);
}

static void TestEnumList(void) {
    expectInList("ADP", UCURR_ALL, TRUE); /* First in list */
    expectInList("ZWD", UCURR_ALL, TRUE); /* Last in list */

    expectInList("USD", UCURR_ALL, TRUE);
    expectInList("USD", UCURR_COMMON, TRUE);
    expectInList("USD", UCURR_UNCOMMON, FALSE);
    expectInList("USD", UCURR_DEPRECATED, FALSE);
    expectInList("USD", UCURR_NON_DEPRECATED, TRUE);
    expectInList("USD", UCURR_COMMON|UCURR_DEPRECATED, FALSE);
    expectInList("USD", UCURR_COMMON|UCURR_NON_DEPRECATED, TRUE);
    expectInList("USD", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE);
    expectInList("USD", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE);

    expectInList("USN", UCURR_ALL, TRUE);
    expectInList("USN", UCURR_COMMON, FALSE);
    expectInList("USN", UCURR_UNCOMMON, TRUE);
    expectInList("USN", UCURR_DEPRECATED, FALSE);
    expectInList("USN", UCURR_NON_DEPRECATED, TRUE);
    expectInList("USN", UCURR_COMMON|UCURR_DEPRECATED, FALSE);
    expectInList("USN", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE);
    expectInList("USN", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE);
    expectInList("USN", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, TRUE);

    expectInList("DEM", UCURR_ALL, TRUE);
    expectInList("DEM", UCURR_COMMON, TRUE);
    expectInList("DEM", UCURR_UNCOMMON, FALSE);
    expectInList("DEM", UCURR_DEPRECATED, TRUE);
    expectInList("DEM", UCURR_NON_DEPRECATED, FALSE);
    expectInList("DEM", UCURR_COMMON|UCURR_DEPRECATED, TRUE);
    expectInList("DEM", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE);
    expectInList("DEM", UCURR_UNCOMMON|UCURR_DEPRECATED, FALSE);
    expectInList("DEM", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE);

    expectInList("XEU", UCURR_ALL, TRUE);
    expectInList("XEU", UCURR_COMMON, FALSE);
    expectInList("XEU", UCURR_UNCOMMON, TRUE);
    expectInList("XEU", UCURR_DEPRECATED, TRUE);
    expectInList("XEU", UCURR_NON_DEPRECATED, FALSE);
    expectInList("XEU", UCURR_COMMON|UCURR_DEPRECATED, FALSE);
    expectInList("XEU", UCURR_COMMON|UCURR_NON_DEPRECATED, FALSE);
    expectInList("XEU", UCURR_UNCOMMON|UCURR_DEPRECATED, TRUE);
    expectInList("XEU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED, FALSE);

}

static void TestEnumListReset(void) {
    UErrorCode status = U_ZERO_ERROR;
    const char *currency1;
    const char *currency2;
    UEnumeration *en = ucurr_openISOCurrencies(UCURR_ALL, &status);
    if (U_FAILURE(status)) {
       log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(status));
       return;
    }

    currency1 = uenum_next(en, NULL, &status);
    uenum_reset(en, &status);
    currency2 = uenum_next(en, NULL, &status);
    if (U_FAILURE(status)) {
       log_err("Error: uenum_next or uenum_reset returned %s\n", myErrorName(status));
       return;
    }
    /* The first item's pointer in the list should be the same between resets. */
    if (currency1 != currency2) {
       log_err("Error: reset doesn't work %s != %s\n", currency1, currency2);
    }
    uenum_close(en);
}

static int32_t checkItemCount(uint32_t currencyType) {
    UErrorCode status = U_ZERO_ERROR;
    int32_t originalCount, count;
    UEnumeration *en = ucurr_openISOCurrencies(currencyType, &status);
    int32_t expectedLen = 3, len;
    if (U_FAILURE(status)) {
       log_err("Error: ucurr_openISOCurrencies returned %s\n", myErrorName(status));
       return -1;
    }

    originalCount = uenum_count(en, &status);
    for (count=0;;count++) {
        const char *str = uenum_next(en, &len, &status);
        if (str == NULL || len != expectedLen || strlen(str) != expectedLen) {
            break;
        }
    }

    if (originalCount != count) {
        log_err("Error: uenum_count returned the wrong value (type = 0x%X). Got: %d Expected %d\n",
           currencyType, count, originalCount);
    }
    if (U_FAILURE(status)) {
        log_err("Error: uenum_next got an error: %s\n", u_errorName(status));
    }
    uenum_close(en);
    return count;
}

static void TestEnumListCount(void) {
    checkItemCount(UCURR_ALL);
    checkItemCount(UCURR_COMMON);
    checkItemCount(UCURR_UNCOMMON);
    checkItemCount(UCURR_DEPRECATED);
    checkItemCount(UCURR_NON_DEPRECATED);
    checkItemCount(UCURR_COMMON|UCURR_DEPRECATED);
    checkItemCount(UCURR_COMMON|UCURR_NON_DEPRECATED);
    checkItemCount(UCURR_UNCOMMON|UCURR_DEPRECATED);
    checkItemCount(UCURR_UNCOMMON|UCURR_NON_DEPRECATED);

    if (checkItemCount(UCURR_DEPRECATED|UCURR_NON_DEPRECATED) != 0) {
        log_err("Error: UCURR_DEPRECATED|UCURR_NON_DEPRECATED should return 0 items\n");
    }
    if (checkItemCount(UCURR_COMMON|UCURR_UNCOMMON) != 0) {
        log_err("Error: UCURR_DEPRECATED|UCURR_NON_DEPRECATED should return 0 items\n");
    }
}

static void TestFractionDigitOverride(void) {
    UErrorCode status = U_ZERO_ERROR;
    UNumberFormat *fmt = unum_open(UNUM_CURRENCY, NULL, 0, "hu_HU", NULL, &status);
    UChar buffer[256];
    UChar expectedBuf[256];
    const char expectedFirst[] = "123,46\\u00A0Ft"; /* changed to use 2 fraction digits */
    const char expectedSecond[] = "123,46\\u00A0Ft";
    const char expectedThird[] = "123,456\\u00A0Ft";
    if (U_FAILURE(status)) {
       log_data_err("Error: unum_open returned %s (Are you missing data?)\n", myErrorName(status));
       return;
    }
    /* Make sure that you can format normal fraction digits. */
    unum_formatDouble(fmt, 123.456, buffer, UPRV_LENGTHOF(buffer), NULL, &status);
    u_unescape(expectedFirst, expectedBuf, strlen(expectedFirst)+1);
    if (u_strcmp(buffer, expectedBuf) != 0) {
       log_err("Error: unum_formatDouble didn't return %s\n", expectedFirst);
    }
    /* Make sure that you can format 2 fraction digits. */
    unum_setAttribute(fmt, UNUM_FRACTION_DIGITS, 2);
    unum_formatDouble(fmt, 123.456, buffer, UPRV_LENGTHOF(buffer), NULL, &status);
    u_unescape(expectedSecond, expectedBuf, strlen(expectedSecond)+1);
    if (u_strcmp(buffer, expectedBuf) != 0) {
       log_err("Error: unum_formatDouble didn't return %s\n", expectedSecond);
    }
    /* Make sure that you can format more fraction digits. */
    unum_setAttribute(fmt, UNUM_FRACTION_DIGITS, 3);
    unum_formatDouble(fmt, 123.456, buffer, UPRV_LENGTHOF(buffer), NULL, &status);
    u_unescape(expectedThird, expectedBuf, strlen(expectedThird)+1);
    if (u_strcmp(buffer, expectedBuf) != 0) {
       log_err("Error: unum_formatDouble didn't return %s\n", expectedThird);
    }
    unum_close(fmt);
}

static void TestPrefixSuffix(void) {
    int32_t	pos;
    UErrorCode status;
    double result1 = 0.0, result2 = 0.0;
    UNumberFormat* parser;
    UChar buffer[4];
    static const UChar TEST_NUMBER[] = {0x0024,0x0031,0x0032,0x002E,0x0030,0x0030,0}; /* $12.00 */
    static const UChar NEG_PREFIX[] = {0x005B,0}; /* "[" */
    static const UChar NEG_SUFFIX[] = {0x005D,0}; /* "]" */


	status = U_ZERO_ERROR;
	parser = unum_open(UNUM_CURRENCY, NULL, -1, "en_US", NULL, &status);
    if (U_FAILURE(status)) {
       log_data_err("Error: unum_open returned %s (Are you missing data?)\n", u_errorName(status));
       return;
    }

	pos = 0;
	status = U_ZERO_ERROR;
	result1 = unum_parseDoubleCurrency(parser, TEST_NUMBER, -1, &pos, buffer, &status);

	unum_setTextAttribute(parser, UNUM_NEGATIVE_SUFFIX, NEG_SUFFIX, -1, &status);
	unum_setTextAttribute(parser, UNUM_NEGATIVE_PREFIX, NEG_PREFIX, -1, &status);
    if (U_FAILURE(status)) {
       log_err("Error: unum_setTextAttribute returned %s\n", u_errorName(status));
       return;
    }

	pos = 0;
	result2 = unum_parseDoubleCurrency(parser, TEST_NUMBER, -1, &pos, buffer, &status);
    if (result1 != result2 || U_FAILURE(status)) {
       log_err("Error: unum_parseDoubleCurrency didn't return the same value for same string %f %f %s\n",
           result1, result2, u_errorName(status));
    }
    unum_close(parser);
}

typedef struct {
    const char* alphaCode;
    int32_t     numericCode;
} NumCodeTestEntry;

static const NumCodeTestEntry NUMCODE_TESTDATA[] = {
    {"USD", 840},
    {"Usd", 840},   /* mixed casing */
    {"EUR", 978},
    {"JPY", 392},
    {"XFU", 0},     /* XFU: no numeric code  */
    {"ZZZ", 0},     /* ZZZ: undefined ISO currency code */
    {"bogus", 0},   /* bogus code */
    {0, 0},
};

static void TestNumericCode(void) {
    UChar code[8];  // at least one longer than the longest alphaCode
    int32_t i;
    int32_t numCode;

    for (i = 0; NUMCODE_TESTDATA[i].alphaCode; i++) {
        int32_t length = uprv_strlen(NUMCODE_TESTDATA[i].alphaCode);
        u_charsToUChars(NUMCODE_TESTDATA[i].alphaCode, code, length + 1);  // +1 includes the NUL
        numCode = ucurr_getNumericCode(code);
        if (numCode != NUMCODE_TESTDATA[i].numericCode) {
            log_data_err("Error: ucurr_getNumericCode returned %d for currency %s, expected - %d\n",
                numCode, NUMCODE_TESTDATA[i].alphaCode, NUMCODE_TESTDATA[i].numericCode);
        }
    }
}

void addCurrencyTest(TestNode** root);

#define TESTCASE(x) addTest(root, &x, "tsformat/currtest/" #x)

void addCurrencyTest(TestNode** root)
{
    TESTCASE(TestEnumList);
    TESTCASE(TestEnumListReset);
    TESTCASE(TestEnumListCount);
    TESTCASE(TestFractionDigitOverride);
    TESTCASE(TestPrefixSuffix);
    TESTCASE(TestNumericCode);
}

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