| OLD | NEW |
|---|
| (Empty) |
| 1 /******************************************************************** | |
| 2 * COPYRIGHT: | |
| 3 * Copyright (c) 1997-2014, International Business Machines Corporation | |
| 4 * and others. All Rights Reserved. | |
| 5 ********************************************************************/ | |
| 6 /******************************************************************************* | |
| 7 * | |
| 8 * File CNMDPTST.C | |
| 9 * | |
| 10 * Madhu Katragadda Creation | |
| 11 * Modification History: | |
| 12 * | |
| 13 * Date Name Description | |
| 14 * 06/24/99 helena Integrated Alan's NF enhancements and Java2 bug fixe
s | |
| 15 ******************************************************************************* | |
| 16 */ | |
| 17 | |
| 18 /* C DEPTH TEST FOR NUMBER FORMAT */ | |
| 19 | |
| 20 #include "unicode/utypes.h" | |
| 21 | |
| 22 #if !UCONFIG_NO_FORMATTING | |
| 23 | |
| 24 #include "unicode/ucurr.h" | |
| 25 #include "unicode/uloc.h" | |
| 26 #include "unicode/unum.h" | |
| 27 #include "unicode/ustring.h" | |
| 28 #include "cintltst.h" | |
| 29 #include "cnmdptst.h" | |
| 30 #include "cmemory.h" | |
| 31 #include "cstring.h" | |
| 32 #include "ulist.h" | |
| 33 | |
| 34 #define CHECK(status,str) if (U_FAILURE(status)) { log_err("FAIL: %s\n", str); r
eturn; } | |
| 35 | |
| 36 void addNumFrDepTest(TestNode** root); | |
| 37 static void TestCurrencyPreEuro(void); | |
| 38 static void TestCurrencyObject(void); | |
| 39 | |
| 40 void addNumFrDepTest(TestNode** root) | |
| 41 { | |
| 42 addTest(root, &TestPatterns, "tsformat/cnmdptst/TestPatterns"); | |
| 43 addTest(root, &TestQuotes, "tsformat/cnmdptst/TestQuotes"); | |
| 44 addTest(root, &TestExponential, "tsformat/cnmdptst/TestExponential"); | |
| 45 addTest(root, &TestCurrencySign, "tsformat/cnmdptst/TestCurrencySign"); | |
| 46 addTest(root, &TestCurrency, "tsformat/cnmdptst/TestCurrency"); | |
| 47 addTest(root, &TestCurrencyPreEuro, "tsformat/cnmdptst/TestCurrencyPreEuro"); | |
| 48 addTest(root, &TestCurrencyObject, "tsformat/cnmdptst/TestCurrencyObject"); | |
| 49 addTest(root, &TestRounding487, "tsformat/cnmdptst/TestRounding487"); | |
| 50 addTest(root, &TestDoubleAttribute, "tsformat/cnmdptst/TestDoubleAttribute"); | |
| 51 addTest(root, &TestSecondaryGrouping, "tsformat/cnmdptst/TestSecondaryGrouping
"); | |
| 52 addTest(root, &TestCurrencyKeywords, "tsformat/cnmdptst/TestCurrencyKeywords")
; | |
| 53 addTest(root, &TestRounding5350, "tsformat/cnmdptst/TestRounding5350"); | |
| 54 addTest(root, &TestGetKeywordValuesForLocale, "tsformat/cnmdptst/TestGetKeywor
dValuesForLocale"); | |
| 55 } | |
| 56 | |
| 57 /*Test Various format patterns*/ | |
| 58 static void TestPatterns(void) | |
| 59 { | |
| 60 int32_t pat_length, i, lneed; | |
| 61 UNumberFormat *fmt; | |
| 62 UChar upat[5]; | |
| 63 UChar unewpat[5]; | |
| 64 UChar unum[5]; | |
| 65 UChar *unewp=NULL; | |
| 66 UChar *str=NULL; | |
| 67 UErrorCode status = U_ZERO_ERROR; | |
| 68 const char* pat[] = { "#.#", "#.", ".#", "#" }; | |
| 69 const char* newpat[] = { "#0.#", "#0.", "#.0", "#" }; | |
| 70 const char* num[] = { "0", "0.", ".0", "0" }; | |
| 71 | |
| 72 log_verbose("\nTesting different format patterns\n"); | |
| 73 pat_length = sizeof(pat) / sizeof(pat[0]); | |
| 74 for (i=0; i < pat_length; ++i) | |
| 75 { | |
| 76 status = U_ZERO_ERROR; | |
| 77 u_uastrcpy(upat, pat[i]); | |
| 78 fmt= unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status); | |
| 79 if (U_FAILURE(status)) { | |
| 80 log_err_status(status, "FAIL: Number format constructor failed for p
attern %s -> %s\n", pat[i], u_errorName(status)); | |
| 81 continue; | |
| 82 } | |
| 83 lneed=0; | |
| 84 lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status); | |
| 85 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 86 status= U_ZERO_ERROR; | |
| 87 unewp=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 88 unum_toPattern(fmt, FALSE, unewp, lneed+1, &status); | |
| 89 } | |
| 90 if(U_FAILURE(status)){ | |
| 91 log_err("FAIL: Number format extracting the pattern failed for %s\n"
, pat[i]); | |
| 92 } | |
| 93 u_uastrcpy(unewpat, newpat[i]); | |
| 94 if(u_strcmp(unewp, unewpat) != 0) | |
| 95 log_err("FAIL: Pattern %s should be transmute to %s; %s seen instea
d\n", pat[i], newpat[i], austrdup(unewp) ); | |
| 96 | |
| 97 lneed=0; | |
| 98 lneed=unum_format(fmt, 0, NULL, lneed, NULL, &status); | |
| 99 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 100 status=U_ZERO_ERROR; | |
| 101 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 102 unum_format(fmt, 0, str, lneed+1, NULL, &status); | |
| 103 } | |
| 104 if(U_FAILURE(status)) { | |
| 105 log_err("Error in formatting using unum_format(.....): %s\n", myErro
rName(status) ); | |
| 106 } | |
| 107 u_uastrcpy(unum, num[i]); | |
| 108 if (u_strcmp(str, unum) != 0) | |
| 109 { | |
| 110 log_err("FAIL: Pattern %s should format zero as %s; %s Seen instead\
n", pat[i], num[i], austrdup(str) ); | |
| 111 | |
| 112 } | |
| 113 free(unewp); | |
| 114 free(str); | |
| 115 unum_close(fmt); | |
| 116 } | |
| 117 } | |
| 118 | |
| 119 /* Test the handling of quotes*/ | |
| 120 static void TestQuotes(void) | |
| 121 { | |
| 122 int32_t lneed; | |
| 123 UErrorCode status=U_ZERO_ERROR; | |
| 124 UChar pat[15]; | |
| 125 UChar res[15]; | |
| 126 UChar *str=NULL; | |
| 127 UNumberFormat *fmt; | |
| 128 char tempBuf[256]; | |
| 129 log_verbose("\nTestting the handling of quotes in number format\n"); | |
| 130 u_uastrcpy(pat, "a'fo''o'b#"); | |
| 131 fmt =unum_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status); | |
| 132 if(U_FAILURE(status)){ | |
| 133 log_err_status(status, "Error in number format costruction using pattern
\"a'fo''o'b#\" -> %s\n", u_errorName(status)); | |
| 134 } | |
| 135 lneed=0; | |
| 136 lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status); | |
| 137 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 138 status=U_ZERO_ERROR; | |
| 139 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 140 unum_format(fmt, 123, str, lneed+1, NULL, &status); | |
| 141 } | |
| 142 if(U_FAILURE(status) || !str) { | |
| 143 log_err_status(status, "Error in formatting using unum_format(.....): %s
\n", myErrorName(status) ); | |
| 144 return; | |
| 145 } | |
| 146 log_verbose("Pattern \"%s\" \n", u_austrcpy(tempBuf, pat) ); | |
| 147 log_verbose("Format 123 -> %s\n", u_austrcpy(tempBuf, str) ); | |
| 148 u_uastrcpy(res, "afo'ob123"); | |
| 149 if(u_strcmp(str, res) != 0) | |
| 150 log_err("FAIL: Expected afo'ob123"); | |
| 151 | |
| 152 free(str); | |
| 153 unum_close(fmt); | |
| 154 | |
| 155 | |
| 156 u_uastrcpy(pat, ""); | |
| 157 u_uastrcpy(pat, "a''b#"); | |
| 158 | |
| 159 | |
| 160 fmt =unum_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status); | |
| 161 if(U_FAILURE(status)){ | |
| 162 log_err("Error in number format costruction using pattern \"a''b#\"\n"); | |
| 163 } | |
| 164 lneed=0; | |
| 165 lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status); | |
| 166 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 167 status=U_ZERO_ERROR; | |
| 168 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 169 unum_format(fmt, 123, str, lneed+1, NULL, &status); | |
| 170 } | |
| 171 if(U_FAILURE(status)) { | |
| 172 log_err("Error in formatting using unum_format(.....): %s\n", myErrorNam
e(status) ); | |
| 173 } | |
| 174 log_verbose("Pattern \"%s\" \n", u_austrcpy(tempBuf, pat) ); | |
| 175 log_verbose("Format 123 -> %s\n", u_austrcpy(tempBuf, str) ); | |
| 176 u_uastrcpy(res, ""); | |
| 177 u_uastrcpy(res, "a'b123"); | |
| 178 if(u_strcmp(str, res) != 0) | |
| 179 log_err("FAIL: Expected a'b123\n"); | |
| 180 | |
| 181 free(str); | |
| 182 unum_close(fmt); | |
| 183 } | |
| 184 | |
| 185 /* Test exponential pattern*/ | |
| 186 static void TestExponential(void) | |
| 187 { | |
| 188 int32_t pat_length, val_length, lval_length; | |
| 189 int32_t ival, ilval, p, v, lneed; | |
| 190 UNumberFormat *fmt; | |
| 191 int32_t ppos; | |
| 192 UChar *upat; | |
| 193 UChar pattern[20]; | |
| 194 UChar *str=NULL; | |
| 195 UChar uvalfor[20], ulvalfor[20]; | |
| 196 char tempMsgBug[256]; | |
| 197 double a; | |
| 198 UErrorCode status = U_ZERO_ERROR; | |
| 199 #if U_PLATFORM == U_PF_OS390 | |
| 200 static const double val[] = { 0.01234, 123456789, 1.23e75, -3.141592653e-78
}; | |
| 201 #else | |
| 202 static const double val[] = { 0.01234, 123456789, 1.23e300, -3.141592653e-27
1 }; | |
| 203 #endif | |
| 204 static const char* pat[] = { "0.####E0", "00.000E00", "##0.######E000", "0.#
##E0;[0.###E0]" }; | |
| 205 static const int32_t lval[] = { 0, -1, 1, 123456789 }; | |
| 206 | |
| 207 static const char* valFormat[] = | |
| 208 { | |
| 209 "1.234E-2", "1.2346E8", "1.23E300", "-3.1416E-271", | |
| 210 "12.340E-03", "12.346E07", "12.300E299", "-31.416E-272", | |
| 211 "12.34E-003", "123.4568E006", "1.23E300", "-314.1593E-273", | |
| 212 "1.234E-2", "1.235E8", "1.23E300", "[3.142E-271]" | |
| 213 }; | |
| 214 static const char* lvalFormat[] = | |
| 215 { | |
| 216 "0E0", "-1E0", "1E0", "1.2346E8", | |
| 217 "00.000E00", "-10.000E-01", "10.000E-01", "12.346E07", | |
| 218 "0E000", "-1E000", "1E000", "123.4568E006", | |
| 219 "0E0", "[1E0]", "1E0", "1.235E8" | |
| 220 }; | |
| 221 static const double valParse[] = | |
| 222 { | |
| 223 #if U_PLATFORM == U_PF_OS390 | |
| 224 0.01234, 123460000, 1.23E75, -3.1416E-78, | |
| 225 0.01234, 123460000, 1.23E75, -3.1416E-78, | |
| 226 0.01234, 123456800, 1.23E75, -3.141593E-78, | |
| 227 0.01234, 123500000, 1.23E75, -3.142E-78 | |
| 228 #else | |
| 229 /* We define the whole IEEE 754 number in the 4th column because | |
| 230 Visual Age 7 has a bug in rounding numbers. */ | |
| 231 0.01234, 123460000, 1.23E300, -3.1415999999999999E-271, | |
| 232 0.01234, 123460000, 1.23E300, -3.1415999999999999E-271, | |
| 233 0.01234, 123456800, 1.23E300, -3.1415929999999999E-271, | |
| 234 0.01234, 123500000, 1.23E300, -3.1420000000000001E-271 | |
| 235 #endif | |
| 236 }; | |
| 237 static const int32_t lvalParse[] = | |
| 238 { | |
| 239 0, -1, 1, 123460000, | |
| 240 0, -1, 1, 123460000, | |
| 241 0, -1, 1, 123456800, | |
| 242 0, -1, 1, 123500000 | |
| 243 }; | |
| 244 | |
| 245 | |
| 246 pat_length = sizeof(pat) / sizeof(pat[0]); | |
| 247 val_length = sizeof(val) / sizeof(val[0]); | |
| 248 lval_length = sizeof(lval) / sizeof(lval[0]); | |
| 249 ival = 0; | |
| 250 ilval = 0; | |
| 251 for (p=0; p < pat_length; ++p) | |
| 252 { | |
| 253 upat=(UChar*)malloc(sizeof(UChar) * (strlen(pat[p])+1) ); | |
| 254 u_uastrcpy(upat, pat[p]); | |
| 255 fmt=unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status); | |
| 256 if (U_FAILURE(status)) { | |
| 257 log_err_status(status, "FAIL: Bad status returned by Number format c
onstruction with pattern %s -> %s\n", pat[p], u_errorName(status)); | |
| 258 continue; | |
| 259 } | |
| 260 lneed= u_strlen(upat) + 1; | |
| 261 unum_toPattern(fmt, FALSE, pattern, lneed, &status); | |
| 262 log_verbose("Pattern \" %s \" -toPattern-> \" %s \" \n", upat, u_austrcp
y(tempMsgBug, pattern) ); | |
| 263 for (v=0; v<val_length; ++v) | |
| 264 { | |
| 265 /*format*/ | |
| 266 lneed=0; | |
| 267 lneed=unum_formatDouble(fmt, val[v], NULL, lneed, NULL, &status); | |
| 268 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 269 status=U_ZERO_ERROR; | |
| 270 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 271 unum_formatDouble(fmt, val[v], str, lneed+1, NULL, &status); | |
| 272 } | |
| 273 if(U_FAILURE(status)) { | |
| 274 log_err("Error in formatting using unum_format(.....): %s\n", my
ErrorName(status) ); | |
| 275 } | |
| 276 | |
| 277 | |
| 278 | |
| 279 u_uastrcpy(uvalfor, valFormat[v+ival]); | |
| 280 if(u_strcmp(str, uvalfor) != 0) | |
| 281 log_verbose("FAIL: Expected %s ( %s )\n", valFormat[v+ival], u_a
ustrcpy(tempMsgBug, uvalfor) ); | |
| 282 | |
| 283 /*parsing*/ | |
| 284 ppos=0; | |
| 285 a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status); | |
| 286 if (ppos== u_strlen(str)) { | |
| 287 if (a != valParse[v+ival]) | |
| 288 log_err("FAIL: Expected: %e, Got: %g\n", valParse[v+ival], a
); | |
| 289 } | |
| 290 else | |
| 291 log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a
); | |
| 292 | |
| 293 free(str); | |
| 294 } | |
| 295 for (v=0; v<lval_length; ++v) | |
| 296 { | |
| 297 /*format*/ | |
| 298 lneed=0; | |
| 299 lneed=unum_formatDouble(fmt, lval[v], NULL, lneed, NULL, &status); | |
| 300 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 301 status=U_ZERO_ERROR; | |
| 302 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 303 unum_formatDouble(fmt, lval[v], str, lneed+1, NULL, &status); | |
| 304 } | |
| 305 if(U_FAILURE(status)) { | |
| 306 log_err("Error in formatting using unum_format(.....): %s\n", my
ErrorName(status) ); | |
| 307 } | |
| 308 /*printf(" Format %e -> %s\n", lval[v], austrdup(str) );*/ | |
| 309 u_uastrcpy(ulvalfor, lvalFormat[v+ilval]); | |
| 310 if(u_strcmp(str, ulvalfor) != 0) | |
| 311 log_err("FAIL: Expected %s ( %s )\n", valFormat[v+ilval], austrd
up(ulvalfor) ); | |
| 312 | |
| 313 /*parsing*/ | |
| 314 ppos=0; | |
| 315 a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status); | |
| 316 if (ppos== u_strlen(str)) { | |
| 317 /*printf(" Parse -> %e\n", a);*/ | |
| 318 if (a != lvalParse[v+ilval]) | |
| 319 log_err("FAIL: Expected : %e\n", valParse[v+ival]); | |
| 320 } | |
| 321 else | |
| 322 log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a
); | |
| 323 | |
| 324 free(str); | |
| 325 | |
| 326 } | |
| 327 ival += val_length; | |
| 328 ilval += lval_length; | |
| 329 unum_close(fmt); | |
| 330 free(upat); | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 /** | |
| 335 * Test the handling of the currency symbol in patterns. | |
| 336 */ | |
| 337 static void TestCurrencySign(void) | |
| 338 { | |
| 339 int32_t lneed; | |
| 340 UNumberFormat *fmt; | |
| 341 UChar *pattern=NULL; | |
| 342 UChar *str=NULL; | |
| 343 UChar *pat=NULL; | |
| 344 UChar *res=NULL; | |
| 345 UErrorCode status = U_ZERO_ERROR; | |
| 346 char tempBuf[256]; | |
| 347 | |
| 348 pattern=(UChar*)malloc(sizeof(UChar) * (strlen("*#,##0.00;-*#,##0.00") + 1)
); | |
| 349 u_uastrcpy(pattern, "*#,##0.00;-*#,##0.00"); | |
| 350 pattern[0]=pattern[11]=0xa4; /* insert latin-1 currency symbol */ | |
| 351 fmt = unum_open(UNUM_IGNORE,pattern, u_strlen(pattern), "en_US",NULL, &statu
s); | |
| 352 if(U_FAILURE(status)){ | |
| 353 log_err_status(status, "Error in number format construction with pattern
\"\\xA4#,##0.00;-\\xA4#,##0.00\\\" -> %s\n", u_errorName(status)); | |
| 354 } | |
| 355 lneed=0; | |
| 356 lneed=unum_formatDouble(fmt, 1234.56, NULL, lneed, NULL, &status); | |
| 357 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 358 status=U_ZERO_ERROR; | |
| 359 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 360 unum_formatDouble(fmt, 1234.56, str, lneed+1, NULL, &status); | |
| 361 } | |
| 362 if(U_FAILURE(status)) { | |
| 363 log_err_status(status, "Error in formatting using unum_format(.....): %s
\n", myErrorName(status) ); | |
| 364 } | |
| 365 lneed=0; | |
| 366 lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status); | |
| 367 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 368 status=U_ZERO_ERROR; | |
| 369 pat=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 370 unum_formatDouble(fmt, FALSE, pat, lneed+1, NULL, &status); | |
| 371 } | |
| 372 log_verbose("Pattern \" %s \" \n", u_austrcpy(tempBuf, pat)); | |
| 373 log_verbose("Format 1234.56 -> %s\n", u_austrcpy(tempBuf, str) ); | |
| 374 if(U_SUCCESS(status) && str) { | |
| 375 res=(UChar*)malloc(sizeof(UChar) * (strlen("$1,234.56")+1) ); | |
| 376 u_uastrcpy(res, "$1,234.56"); | |
| 377 if (u_strcmp(str, res) !=0) log_data_err("FAIL: Expected $1,234.56\n"); | |
| 378 } else { | |
| 379 log_err_status(status, "Error formatting -> %s\n", u_errorName(status)); | |
| 380 } | |
| 381 free(str); | |
| 382 free(res); | |
| 383 free(pat); | |
| 384 | |
| 385 lneed=0; | |
| 386 lneed=unum_formatDouble(fmt, -1234.56, NULL, lneed, NULL, &status); | |
| 387 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 388 status=U_ZERO_ERROR; | |
| 389 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 390 unum_formatDouble(fmt, -1234.56, str, lneed+1, NULL, &status); | |
| 391 } | |
| 392 if(U_FAILURE(status)) { | |
| 393 log_err_status(status, "Error in formatting using unum_format(.....): %s
\n", myErrorName(status) ); | |
| 394 } | |
| 395 if(str) { | |
| 396 res=(UChar*)malloc(sizeof(UChar) * (strlen("-$1,234.56")+1) ); | |
| 397 u_uastrcpy(res, "-$1,234.56"); | |
| 398 if (u_strcmp(str, res) != 0) log_data_err("FAIL: Expected -$1,234.56\n")
; | |
| 399 free(str); | |
| 400 free(res); | |
| 401 } | |
| 402 | |
| 403 unum_close(fmt); | |
| 404 free(pattern); | |
| 405 } | |
| 406 | |
| 407 /** | |
| 408 * Test localized currency patterns. | |
| 409 */ | |
| 410 static void TestCurrency(void) | |
| 411 { | |
| 412 UNumberFormat *currencyFmt; | |
| 413 UChar *str; | |
| 414 int32_t lneed, i; | |
| 415 UFieldPosition pos; | |
| 416 UChar res[100]; | |
| 417 UErrorCode status = U_ZERO_ERROR; | |
| 418 const char* locale[]={"fr_CA", "de_DE_PREEURO", "fr_FR_PREEURO"}; | |
| 419 const char* result[]={"1,50\\u00a0$", "1,50\\u00a0DM", "1,50\\u00a0F"}; | |
| 420 log_verbose("\nTesting the number format with different currency patterns\n"
); | |
| 421 for(i=0; i < 3; i++) | |
| 422 { | |
| 423 str=NULL; | |
| 424 currencyFmt = unum_open(UNUM_CURRENCY, NULL,0,locale[i],NULL, &status); | |
| 425 | |
| 426 if(U_FAILURE(status)){ | |
| 427 log_data_err("Error in the construction of number format with style
currency: %s (Are you missing data?)\n", | |
| 428 myErrorName(status)); | |
| 429 } else { | |
| 430 lneed=0; | |
| 431 lneed= unum_formatDouble(currencyFmt, 1.50, NULL, lneed, NULL, &stat
us); | |
| 432 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 433 status=U_ZERO_ERROR; | |
| 434 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 435 pos.field = 0; | |
| 436 unum_formatDouble(currencyFmt, 1.50, str, lneed+1, &pos, &status
); | |
| 437 } | |
| 438 | |
| 439 if(U_FAILURE(status)) { | |
| 440 log_err("Error in formatting using unum_formatDouble(.....): %s\
n", myErrorName(status) ); | |
| 441 } else { | |
| 442 u_unescape(result[i], res, (int32_t)strlen(result[i])+1); | |
| 443 | |
| 444 if (u_strcmp(str, res) != 0){ | |
| 445 log_err("FAIL: Expected %s Got: %s for locale: %s\n", result
[i], aescstrdup(str, -1), locale[i]); | |
| 446 } | |
| 447 } | |
| 448 } | |
| 449 | |
| 450 unum_close(currencyFmt); | |
| 451 free(str); | |
| 452 } | |
| 453 } | |
| 454 /** | |
| 455 * Test localized currency patterns for PREEURO variants. | |
| 456 */ | |
| 457 static void TestCurrencyPreEuro(void) | |
| 458 { | |
| 459 UNumberFormat *currencyFmt; | |
| 460 UChar *str=NULL, *res=NULL; | |
| 461 int32_t lneed, i; | |
| 462 UFieldPosition pos; | |
| 463 UErrorCode status = U_ZERO_ERROR; | |
| 464 | |
| 465 const char* locale[]={ | |
| 466 "ca_ES_PREEURO", "de_LU_PREEURO", "en_IE_PREEURO", "fi_FI
_PREEURO", "fr_LU_PREEURO", "it_IT_PREEURO", | |
| 467 "pt_PT_PREEURO", "de_AT_PREEURO", "el_GR_PREEURO", "es_ES
_PREEURO", "fr_BE_PREEURO", "ga_IE_PREEURO", | |
| 468 "nl_BE_PREEURO", "de_DE_PREEURO", "en_BE_PREEURO", "eu_ES
_PREEURO", "fr_FR_PREEURO", "gl_ES_PREEURO", | |
| 469 "nl_NL_PREEURO", | |
| 470 }; | |
| 471 | |
| 472 const char* result[]={ | |
| 473 "\\u20A7\\u00A02", "2\\u00A0F", "IEP1.50",
"1,50\\u00A0mk", "2\\u00A0F", "ITL\\u00A02", | |
| 474 "1$50\\u00A0\\u200B", "\\u00F6S\\u00A01,50", "1,50\\u00A0\\u0394\\u03C1
\\u03C7", "2\\u00A0\\u20A7", "1,50\\u00A0FB", "IEP1.50", | |
| 475 "1,50\\u00A0BEF", "1,50\\u00A0DM", "1,50\\u00A0BEF",
"\\u20A7\\u00A02", "1,50\\u00A0F", "2\\u00A0\\u20A7", | |
| 476 "NLG\\u00A01,50" | |
| 477 }; | |
| 478 | |
| 479 log_verbose("\nTesting the number format with different currency patterns\n"
); | |
| 480 for(i=0; i < 19; i++) | |
| 481 { | |
| 482 char curID[256] = {0}; | |
| 483 uloc_canonicalize(locale[i], curID, 256, &status); | |
| 484 if(U_FAILURE(status)){ | |
| 485 log_data_err("Could not canonicalize %s. Error: %s (Are you missing
data?)\n", locale[i], u_errorName(status)); | |
| 486 continue; | |
| 487 } | |
| 488 currencyFmt = unum_open(UNUM_CURRENCY, NULL,0,curID,NULL, &status); | |
| 489 | |
| 490 if(U_FAILURE(status)){ | |
| 491 log_data_err("Error in the construction of number format with style
currency: %s (Are you missing data?)\n", | |
| 492 myErrorName(status)); | |
| 493 } else { | |
| 494 lneed=0; | |
| 495 lneed= unum_formatDouble(currencyFmt, 1.50, NULL, lneed, NULL, &stat
us); | |
| 496 | |
| 497 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 498 status=U_ZERO_ERROR; | |
| 499 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 500 pos.field = 0; | |
| 501 unum_formatDouble(currencyFmt, 1.50, str, lneed+1, &pos, &status
); | |
| 502 } | |
| 503 | |
| 504 if(U_FAILURE(status)) { | |
| 505 log_err("Error in formatting using unum_formatDouble(.....): %s\
n", myErrorName(status) ); | |
| 506 } else { | |
| 507 res=(UChar*)malloc(sizeof(UChar) * (strlen(result[i])+1) ); | |
| 508 u_unescape(result[i],res,(int32_t)(strlen(result[i])+1)); | |
| 509 | |
| 510 if (u_strcmp(str, res) != 0){ | |
| 511 log_err("FAIL: Expected %s Got: %s for locale: %s\n", result
[i],aescstrdup(str, -1),locale[i]); | |
| 512 } | |
| 513 } | |
| 514 } | |
| 515 | |
| 516 unum_close(currencyFmt); | |
| 517 free(str); | |
| 518 free(res); | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 /** | |
| 523 * Test currency "object" (we use this name to match the other C++ | |
| 524 * test name and the Jave name). Actually, test ISO currency code | |
| 525 * support in the C API. | |
| 526 */ | |
| 527 static void TestCurrencyObject(void) | |
| 528 { | |
| 529 UNumberFormat *currencyFmt; | |
| 530 UChar *str=NULL, *res=NULL; | |
| 531 int32_t lneed, i; | |
| 532 UFieldPosition pos; | |
| 533 UErrorCode status = U_ZERO_ERROR; | |
| 534 | |
| 535 const char* locale[]={ | |
| 536 "fr_FR", | |
| 537 "fr_FR", | |
| 538 }; | |
| 539 | |
| 540 const char* currency[]={ | |
| 541 "", | |
| 542 "JPY", | |
| 543 }; | |
| 544 | |
| 545 const char* result[]={ | |
| 546 "1\\u00A0234,56\\u00A0\\u20AC", | |
| 547 "1\\u00A0235\\u00A0JPY", | |
| 548 }; | |
| 549 | |
| 550 log_verbose("\nTesting the number format with different currency codes\n"); | |
| 551 for(i=0; i < 2; i++) | |
| 552 { | |
| 553 char cStr[20]={0}; | |
| 554 UChar isoCode[16]={0}; | |
| 555 currencyFmt = unum_open(UNUM_CURRENCY, NULL,0,locale[i],NULL, &status); | |
| 556 if(U_FAILURE(status)){ | |
| 557 log_data_err("Error in the construction of number format with style
currency: %s (Are you missing data?)\n", | |
| 558 myErrorName(status)); | |
| 559 } else { | |
| 560 if (*currency[i]) { | |
| 561 u_uastrcpy(isoCode, currency[i]); | |
| 562 unum_setTextAttribute(currencyFmt, UNUM_CURRENCY_CODE, | |
| 563 isoCode, u_strlen(isoCode), &status); | |
| 564 | |
| 565 if(U_FAILURE(status)) { | |
| 566 log_err("FAIL: can't set currency code %s\n", myErrorName(st
atus) ); | |
| 567 } | |
| 568 } | |
| 569 | |
| 570 unum_getTextAttribute(currencyFmt, UNUM_CURRENCY_CODE, | |
| 571 isoCode, sizeof(isoCode), &status); | |
| 572 | |
| 573 if(U_FAILURE(status)) { | |
| 574 log_err("FAIL: can't get currency code %s\n", myErrorName(status
) ); | |
| 575 } | |
| 576 | |
| 577 u_UCharsToChars(isoCode,cStr,u_strlen(isoCode)); | |
| 578 log_verbose("ISO code %s\n", cStr); | |
| 579 if (*currency[i] && uprv_strcmp(cStr, currency[i])) { | |
| 580 log_err("FAIL: currency should be %s, but is %s\n", currency[i],
cStr); | |
| 581 } | |
| 582 | |
| 583 lneed=0; | |
| 584 lneed= unum_formatDouble(currencyFmt, 1234.56, NULL, lneed, NULL, &s
tatus); | |
| 585 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 586 status=U_ZERO_ERROR; | |
| 587 str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 588 pos.field = 0; | |
| 589 unum_formatDouble(currencyFmt, 1234.56, str, lneed+1, &pos, &sta
tus); | |
| 590 } | |
| 591 if(U_FAILURE(status)) { | |
| 592 log_err("Error in formatting using unum_formatDouble(.....): %s\
n", myErrorName(status) ); | |
| 593 } else { | |
| 594 res=(UChar*)malloc(sizeof(UChar) * (strlen(result[i])+1) ); | |
| 595 u_unescape(result[i],res, (int32_t)(strlen(result[i])+1)); | |
| 596 if (u_strcmp(str, res) != 0){ | |
| 597 log_err("FAIL: Expected %s Got: %s for locale: %s\n", result
[i],aescstrdup(str, -1),locale[i]); | |
| 598 } | |
| 599 } | |
| 600 } | |
| 601 | |
| 602 unum_close(currencyFmt); | |
| 603 free(str); | |
| 604 free(res); | |
| 605 } | |
| 606 } | |
| 607 | |
| 608 /** | |
| 609 * Test proper rounding by the format method. | |
| 610 */ | |
| 611 static void TestRounding487(void) | |
| 612 { | |
| 613 UNumberFormat *nnf; | |
| 614 UErrorCode status = U_ZERO_ERROR; | |
| 615 /* this is supposed to open default date format, but later on it treats it l
ike it is "en_US" | |
| 616 - very bad if you try to run the tests on machine where default locale is N
OT "en_US" */ | |
| 617 /* nnf = unum_open(UNUM_DEFAULT, NULL, &status); */ | |
| 618 nnf = unum_open(UNUM_DEFAULT, NULL,0,"en_US",NULL, &status); | |
| 619 | |
| 620 if(U_FAILURE(status)){ | |
| 621 log_data_err("FAIL: failure in the construction of number format: %s (Ar
e you missing data?)\n", myErrorName(status)); | |
| 622 } else { | |
| 623 roundingTest(nnf, 0.00159999, 4, "0.0016"); | |
| 624 roundingTest(nnf, 0.00995, 4, "0.01"); | |
| 625 | |
| 626 roundingTest(nnf, 12.3995, 3, "12.4"); | |
| 627 | |
| 628 roundingTest(nnf, 12.4999, 0, "12"); | |
| 629 roundingTest(nnf, - 19.5, 0, "-20"); | |
| 630 } | |
| 631 | |
| 632 unum_close(nnf); | |
| 633 } | |
| 634 | |
| 635 /*-------------------------------------*/ | |
| 636 | |
| 637 static void roundingTest(UNumberFormat* nf, double x, int32_t maxFractionDigits,
const char* expected) | |
| 638 { | |
| 639 UChar *out = NULL; | |
| 640 UChar *res; | |
| 641 UFieldPosition pos; | |
| 642 UErrorCode status; | |
| 643 int32_t lneed; | |
| 644 status=U_ZERO_ERROR; | |
| 645 unum_setAttribute(nf, UNUM_MAX_FRACTION_DIGITS, maxFractionDigits); | |
| 646 lneed=0; | |
| 647 lneed=unum_formatDouble(nf, x, NULL, lneed, NULL, &status); | |
| 648 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 649 status=U_ZERO_ERROR; | |
| 650 out=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 651 pos.field=0; | |
| 652 unum_formatDouble(nf, x, out, lneed+1, &pos, &status); | |
| 653 } | |
| 654 if(U_FAILURE(status)) { | |
| 655 log_err("Error in formatting using unum_formatDouble(.....): %s\n", myEr
rorName(status) ); | |
| 656 } | |
| 657 /*Need to use log_verbose here. Problem with the float*/ | |
| 658 /*printf("%f format with %d fraction digits to %s\n", x, maxFractionDigits,
austrdup(out) );*/ | |
| 659 res=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1) ); | |
| 660 u_uastrcpy(res, expected); | |
| 661 if (u_strcmp(out, res) != 0) | |
| 662 log_err("FAIL: Expected: %s or %s\n", expected, austrdup(res) ); | |
| 663 free(res); | |
| 664 if(out != NULL) { | |
| 665 free(out); | |
| 666 } | |
| 667 } | |
| 668 | |
| 669 /* | |
| 670 * Testing unum_getDoubleAttribute and unum_setDoubleAttribute() | |
| 671 */ | |
| 672 static void TestDoubleAttribute(void) | |
| 673 { | |
| 674 double mydata[] = { 1.11, 22.22, 333.33, 4444.44, 55555.55, 666666.66, 77777
77.77, 88888888.88, 999999999.99}; | |
| 675 double dvalue; | |
| 676 int i; | |
| 677 UErrorCode status=U_ZERO_ERROR; | |
| 678 UNumberFormatAttribute attr; | |
| 679 UNumberFormatStyle style= UNUM_DEFAULT; | |
| 680 UNumberFormat *def; | |
| 681 | |
| 682 log_verbose("\nTesting get and set DoubleAttributes\n"); | |
| 683 def=unum_open(style, NULL,0,NULL,NULL, &status); | |
| 684 | |
| 685 if (U_FAILURE(status)) { | |
| 686 log_data_err("Fail: error creating a default number formatter -> %s (Are
you missing data?)\n", u_errorName(status)); | |
| 687 } else { | |
| 688 attr=UNUM_ROUNDING_INCREMENT; | |
| 689 dvalue=unum_getDoubleAttribute(def, attr); | |
| 690 for (i = 0; i<9 ; i++) | |
| 691 { | |
| 692 dvalue = mydata[i]; | |
| 693 unum_setDoubleAttribute(def, attr, dvalue); | |
| 694 if(unum_getDoubleAttribute(def,attr)!=mydata[i]) | |
| 695 log_err("Fail: error in setting and getting double attributes fo
r UNUM_ROUNDING_INCREMENT\n"); | |
| 696 else | |
| 697 log_verbose("Pass: setting and getting double attributes for UNU
M_ROUNDING_INCREMENT works fine\n"); | |
| 698 } | |
| 699 } | |
| 700 | |
| 701 unum_close(def); | |
| 702 } | |
| 703 | |
| 704 /** | |
| 705 * Test the functioning of the secondary grouping value. | |
| 706 */ | |
| 707 static void TestSecondaryGrouping(void) { | |
| 708 UErrorCode status = U_ZERO_ERROR; | |
| 709 UNumberFormat *f = NULL, *g= NULL; | |
| 710 UNumberFormat *us = unum_open(UNUM_DECIMAL,NULL,0, "en_US", NULL,&status); | |
| 711 UFieldPosition pos; | |
| 712 UChar resultBuffer[512]; | |
| 713 int32_t l = 1876543210L; | |
| 714 UBool ok = TRUE; | |
| 715 UChar buffer[512]; | |
| 716 int32_t i; | |
| 717 UBool expectGroup = FALSE, isGroup = FALSE; | |
| 718 | |
| 719 u_uastrcpy(buffer, "#,##,###"); | |
| 720 f = unum_open(UNUM_IGNORE,buffer, -1, "en_US",NULL, &status); | |
| 721 if (U_FAILURE(status)) { | |
| 722 log_data_err("Error DecimalFormat ct -> %s (Are you missing data?)\n", u
_errorName(status)); | |
| 723 return; | |
| 724 } | |
| 725 | |
| 726 pos.field = 0; | |
| 727 unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status); | |
| 728 u_uastrcpy(buffer, "12,34,56,789"); | |
| 729 if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) | |
| 730 { | |
| 731 log_err("Fail: Formatting \"#,##,###\" pattern with 123456789 got %s, ex
pected %s\n", resultBuffer, "12,34,56,789"); | |
| 732 } | |
| 733 if (pos.beginIndex != 0 && pos.endIndex != 12) { | |
| 734 log_err("Fail: Formatting \"#,##,###\" pattern pos = (%d, %d) expected p
os = (0, 12)\n", pos.beginIndex, pos.endIndex); | |
| 735 } | |
| 736 memset(resultBuffer,0, sizeof(UChar)*512); | |
| 737 unum_toPattern(f, FALSE, resultBuffer, 512, &status); | |
| 738 u_uastrcpy(buffer, "#,##,###"); | |
| 739 if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) | |
| 740 { | |
| 741 log_err("Fail: toPattern() got %s, expected %s\n", resultBuffer, "#,##,#
##"); | |
| 742 } | |
| 743 memset(resultBuffer,0, sizeof(UChar)*512); | |
| 744 u_uastrcpy(buffer, "#,###"); | |
| 745 unum_applyPattern(f, FALSE, buffer, -1,NULL,NULL); | |
| 746 if (U_FAILURE(status)) | |
| 747 { | |
| 748 log_err("Fail: applyPattern call failed\n"); | |
| 749 } | |
| 750 unum_setAttribute(f, UNUM_SECONDARY_GROUPING_SIZE, 4); | |
| 751 unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status); | |
| 752 u_uastrcpy(buffer, "12,3456,789"); | |
| 753 if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) | |
| 754 { | |
| 755 log_err("Fail: Formatting \"#,###\" pattern with 123456789 got %s, expec
ted %s\n", resultBuffer, "12,3456,789"); | |
| 756 } | |
| 757 memset(resultBuffer,0, sizeof(UChar)*512); | |
| 758 unum_toPattern(f, FALSE, resultBuffer, 512, &status); | |
| 759 u_uastrcpy(buffer, "#,####,###"); | |
| 760 if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) | |
| 761 { | |
| 762 log_err("Fail: toPattern() got %s, expected %s\n", resultBuffer, "#,####
,###"); | |
| 763 } | |
| 764 memset(resultBuffer,0, sizeof(UChar)*512); | |
| 765 g = unum_open(UNUM_DECIMAL, NULL,0,"hi_IN",NULL, &status); | |
| 766 if (U_FAILURE(status)) | |
| 767 { | |
| 768 log_err("Fail: Cannot create UNumberFormat for \"hi_IN\" locale.\n"); | |
| 769 } | |
| 770 | |
| 771 unum_format(g, l, resultBuffer, 512, &pos, &status); | |
| 772 unum_close(g); | |
| 773 /* expect "1,87,65,43,210", but with Hindi digits */ | |
| 774 /* 01234567890123 */ | |
| 775 if (u_strlen(resultBuffer) != 14) { | |
| 776 ok = FALSE; | |
| 777 } else { | |
| 778 for (i=0; i<u_strlen(resultBuffer); ++i) { | |
| 779 expectGroup = FALSE; | |
| 780 switch (i) { | |
| 781 case 1: | |
| 782 case 4: | |
| 783 case 7: | |
| 784 case 10: | |
| 785 expectGroup = TRUE; | |
| 786 break; | |
| 787 } | |
| 788 /* Later -- fix this to get the actual grouping */ | |
| 789 /* character from the resource bundle. */ | |
| 790 isGroup = (UBool)(resultBuffer[i] == 0x002C); | |
| 791 if (isGroup != expectGroup) { | |
| 792 ok = FALSE; | |
| 793 break; | |
| 794 } | |
| 795 } | |
| 796 } | |
| 797 if (!ok) { | |
| 798 log_err("FAIL Expected %s x hi_IN -> \"1,87,65,43,210\" (with Hindi dig
its), got %s\n", "1876543210L", resultBuffer); | |
| 799 } | |
| 800 unum_close(f); | |
| 801 unum_close(us); | |
| 802 } | |
| 803 | |
| 804 static void TestCurrencyKeywords(void) | |
| 805 { | |
| 806 static const char * const currencies[] = { | |
| 807 "ADD", "ADP", "AED", "AFA", "AFN", "AIF", "ALK", "ALL", "ALV", "ALX", "A
MD", | |
| 808 "ANG", "AOA", "AOK", "AON", "AOR", "AOS", "ARA", "ARM", "ARP", "ARS", "A
TS", | |
| 809 "AUD", "AUP", "AWG", "AZM", "BAD", "BAM", "BAN", "BBD", "BDT", "BEC", "B
EF", | |
| 810 "BEL", "BGL", "BGM", "BGN", "BGO", "BGX", "BHD", "BIF", "BMD", "BMP", "B
ND", | |
| 811 "BOB", "BOL", "BOP", "BOV", "BRB", "BRC", "BRE", "BRL", "BRN", "BRR", "B
RZ", | |
| 812 "BSD", "BSP", "BTN", "BTR", "BUK", "BUR", "BWP", "BYB", "BYL", "BYR", "B
ZD", | |
| 813 "BZH", "CAD", "CDF", "CDG", "CDL", "CFF", "CHF", "CKD", "CLC", "CLE", "C
LF", | |
| 814 "CLP", "CMF", "CNP", "CNX", "CNY", "COB", "COF", "COP", "CRC", "CSC", "C
SK", | |
| 815 "CUP", "CUX", "CVE", "CWG", "CYP", "CZK", "DDM", "DEM", "DES", "DJF", "D
KK", | |
| 816 "DOP", "DZD", "DZF", "DZG", "ECS", "ECV", "EEK", "EGP", "ERN", "ESP", "E
TB", | |
| 817 "ETD", "EUR", "FIM", "FIN", "FJD", "FJP", "FKP", "FOK", "FRF", "FRG", "G
AF", | |
| 818 "GBP", "GEK", "GEL", "GHC", "GHO", "GHP", "GHR", "GIP", "GLK", "GMD", "G
MP", | |
| 819 "GNF", "GNI", "GNS", "GPF", "GQE", "GQF", "GQP", "GRD", "GRN", "GTQ", "G
UF", | |
| 820 "GWE", "GWM", "GWP", "GYD", "HKD", "HNL", "HRD", "HRK", "HTG", "HUF", "I
BP", | |
| 821 "IDG", "IDJ", "IDN", "IDR", "IEP", "ILL", "ILP", "ILS", "IMP", "INR", "I
QD", | |
| 822 "IRR", "ISK", "ITL", "JEP", "JMD", "JMP", "JOD", "JPY", "KES", "KGS", "K
HO", | |
| 823 "KHR", "KID", "KMF", "KPP", "KPW", "KRH", "KRO", "KRW", "KWD", "KYD", "K
ZR", | |
| 824 "KZT", "LAK", "LBP", "LIF", "LKR", "LNR", "LRD", "LSL", "LTL", "LTT", "L
UF", | |
| 825 "LVL", "LVR", "LYB", "LYD", "LYP", "MAD", "MAF", "MCF", "MCG", "MDC", "M
DL", | |
| 826 "MDR", "MGA", "MGF", "MHD", "MKD", "MKN", "MLF", "MMK", "MMX", "MNT", "M
OP", | |
| 827 "MQF", "MRO", "MTL", "MTP", "MUR", "MVP", "MVR", "MWK", "MWP", "MXN", "M
XP", | |
| 828 "MXV", "MYR", "MZE", "MZM", "NAD", "NCF", "NGN", "NGP", "NHF", "NIC", "N
IG", | |
| 829 "NIO", "NLG", "NOK", "NPR", "NZD", "NZP", "OMR", "OMS", "PAB", "PDK", "P
DN", | |
| 830 "PDR", "PEI", "PEN", "PES", "PGK", "PHP", "PKR", "PLN", "PLX", "PLZ", "P
SP", | |
| 831 "PTC", "PTE", "PYG", "QAR", "REF", "ROL", "RON", "RUB", "RUR", "RWF", "S
AR", | |
| 832 "SAS", "SBD", "SCR", "SDD", "SDP", "SEK", "SGD", "SHP", "SIB", "SIT", "S
KK", | |
| 833 "SLL", "SML", "SOS", "SQS", "SRG", "SSP", "STD", "STE", "SUN", "SUR", "S
VC", | |
| 834 "SYP", "SZL", "TCC", "TDF", "THB", "TJR", "TJS", "TMM", "TND", "TOP", "T
OS", | |
| 835 "TPE", "TPP", "TRL", "TTD", "TTO", "TVD", "TWD", "TZS", "UAH", "UAK", "U
GS", | |
| 836 "UGX", "USD", "USN", "USS", "UYF", "UYP", "UYU", "UZC", "UZS", "VAL", "V
DD", | |
| 837 "VDN", "VDP", "VEB", "VGD", "VND", "VNN", "VNR", "VNS", "VUV", "WSP", "W
ST", | |
| 838 "XAD", "XAF", "XAM", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XCF", "X
DR", | |
| 839 "XEF", "XEU", "XFO", "XFU", "XID", "XMF", "XNF", "XOF", "XPF", "XPS", "X
SS", | |
| 840 "XTR", "YDD", "YEI", "YER", "YUD", "YUF", "YUG", "YUM", "YUN", "YUO", "Y
UR", | |
| 841 "ZAL", "ZAP", "ZAR", "ZMK", "ZMP", "ZRN", "ZRZ", "ZWD" | |
| 842 }; | |
| 843 | |
| 844 UErrorCode status = U_ZERO_ERROR; | |
| 845 int32_t i = 0, j = 0; | |
| 846 int32_t noLocales = uloc_countAvailable(); | |
| 847 char locale[256]; | |
| 848 char currLoc[256]; | |
| 849 UChar result[4]; | |
| 850 UChar currBuffer[256]; | |
| 851 | |
| 852 | |
| 853 for(i = 0; i < noLocales; i++) { | |
| 854 strcpy(currLoc, uloc_getAvailable(i)); | |
| 855 for(j = 0; j < sizeof(currencies)/sizeof(currencies[0]); j++) { | |
| 856 strcpy(locale, currLoc); | |
| 857 strcat(locale, "@currency="); | |
| 858 strcat(locale, currencies[j]); | |
| 859 ucurr_forLocale(locale, result, 4, &status); | |
| 860 u_charsToUChars(currencies[j], currBuffer, 3); | |
| 861 currBuffer[3] = 0; | |
| 862 if(u_strcmp(currBuffer, result) != 0) { | |
| 863 log_err("Didn't get the right currency for %s\n", locale); | |
| 864 } | |
| 865 } | |
| 866 | |
| 867 } | |
| 868 } | |
| 869 | |
| 870 static void TestGetKeywordValuesForLocale(void) { | |
| 871 #define PREFERRED_SIZE 12 | |
| 872 #define MAX_NUMBER_OF_KEYWORDS 4 | |
| 873 const char *PREFERRED[PREFERRED_SIZE][MAX_NUMBER_OF_KEYWORDS] = { | |
| 874 { "root", "USD", "USN", NULL }, | |
| 875 { "und", "USD", "USN", NULL }, | |
| 876 /* { "und_ZZ", "USD", NULL, NULL }, -- temporarily remov
e as this locale now has 15 entries */ | |
| 877 { "en_US", "USD", "USN", NULL }, | |
| 878 { "en_029", "USD", "USN", NULL }, | |
| 879 { "en_TH", "THB", NULL, NULL }, | |
| 880 { "de", "EUR", NULL, NULL }, | |
| 881 { "de_DE", "EUR", NULL, NULL }, | |
| 882 { "ar", "EGP", NULL, NULL }, | |
| 883 { "ar_PS", "ILS", "JOD", NULL }, | |
| 884 { "en@currency=CAD", "USD", "USN", NULL }, | |
| 885 { "fr@currency=zzz", "EUR", NULL, NULL }, | |
| 886 { "de_DE@currency=DEM", "EUR", NULL, NULL }, | |
| 887 }; | |
| 888 const int32_t EXPECTED_SIZE[PREFERRED_SIZE] = { | |
| 889 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 1, 1 | |
| 890 }; | |
| 891 UErrorCode status = U_ZERO_ERROR; | |
| 892 int32_t i, j, size; | |
| 893 UEnumeration *pref, *all; | |
| 894 const char *loc = NULL; | |
| 895 UBool matchPref, matchAll; | |
| 896 const char *value = NULL; | |
| 897 int32_t valueLength = 0; | |
| 898 | |
| 899 UList *ALLList = NULL; | |
| 900 | |
| 901 UEnumeration *ALL = ucurr_getKeywordValuesForLocale("currency", uloc_getDefa
ult(), FALSE, &status); | |
| 902 if (ALL == NULL) { | |
| 903 log_err_status(status, "ERROR getting keyword value for default locale.
-> %s\n", u_errorName(status)); | |
| 904 return; | |
| 905 } | |
| 906 | |
| 907 for (i = 0; i < PREFERRED_SIZE; i++) { | |
| 908 pref = NULL; | |
| 909 all = NULL; | |
| 910 loc = PREFERRED[i][0]; | |
| 911 pref = ucurr_getKeywordValuesForLocale("currency", loc, TRUE, &status); | |
| 912 matchPref = FALSE; | |
| 913 matchAll = FALSE; | |
| 914 | |
| 915 size = uenum_count(pref, &status); | |
| 916 | |
| 917 if (size == EXPECTED_SIZE[i]) { | |
| 918 matchPref = TRUE; | |
| 919 for (j = 0; j < size; j++) { | |
| 920 if ((value = uenum_next(pref, &valueLength, &status)) != NULL &&
U_SUCCESS(status)) { | |
| 921 if (uprv_strcmp(value, PREFERRED[i][j+1]) != 0) { | |
| 922 log_err("ERROR: locale %s got keywords #%d %s expected %
s\n", loc, j, value, PREFERRED[i][j+1]); | |
| 923 | |
| 924 matchPref = FALSE; | |
| 925 break; | |
| 926 } | |
| 927 } else { | |
| 928 matchPref = FALSE; | |
| 929 log_err("ERROR getting keyword value for locale \"%s\"\n", l
oc); | |
| 930 break; | |
| 931 } | |
| 932 } | |
| 933 } else { | |
| 934 log_err("FAIL: size of locale \"%s\" %d does not match expected size
%d\n", loc, size, EXPECTED_SIZE[i]); | |
| 935 } | |
| 936 | |
| 937 if (!matchPref) { | |
| 938 log_err("FAIL: Preferred values for locale \"%s\" does not match exp
ected.\n", loc); | |
| 939 break; | |
| 940 } | |
| 941 uenum_close(pref); | |
| 942 | |
| 943 all = ucurr_getKeywordValuesForLocale("currency", loc, FALSE, &status); | |
| 944 | |
| 945 size = uenum_count(all, &status); | |
| 946 | |
| 947 if (U_SUCCESS(status) && size == uenum_count(ALL, &status)) { | |
| 948 matchAll = TRUE; | |
| 949 ALLList = ulist_getListFromEnum(ALL); | |
| 950 for (j = 0; j < size; j++) { | |
| 951 if ((value = uenum_next(all, &valueLength, &status)) != NULL &&
U_SUCCESS(status)) { | |
| 952 if (!ulist_containsString(ALLList, value, uprv_strlen(value)
)) { | |
| 953 log_err("Locale %s have %s not in ALL\n", loc, value); | |
| 954 matchAll = FALSE; | |
| 955 break; | |
| 956 } | |
| 957 } else { | |
| 958 matchAll = FALSE; | |
| 959 log_err("ERROR getting \"all\" keyword value for locale \"%s
\"\n", loc); | |
| 960 break; | |
| 961 } | |
| 962 } | |
| 963 if (!matchAll) { | |
| 964 log_err("FAIL: All values for locale \"%s\" does not match expected.
\n", loc); | |
| 965 } | |
| 966 } else { | |
| 967 if(U_FAILURE(status)) { | |
| 968 log_err("ERROR: %s\n", u_errorName(status)); | |
| 969 } else if(size!=uenum_count(ALL, &status)) { | |
| 970 log_err("ERROR: got size of %d, wanted %d\n", size, uenum_count(A
LL, &status)); | |
| 971 } | |
| 972 } | |
| 973 | |
| 974 uenum_close(all); | |
| 975 } | |
| 976 | |
| 977 uenum_close(ALL); | |
| 978 | |
| 979 } | |
| 980 | |
| 981 /** | |
| 982 * Test proper handling of rounding modes. | |
| 983 */ | |
| 984 static void TestRounding5350(void) | |
| 985 { | |
| 986 UNumberFormat *nnf; | |
| 987 UErrorCode status = U_ZERO_ERROR; | |
| 988 /* this is supposed to open default date format, but later on it treats it l
ike it is "en_US" | |
| 989 - very bad if you try to run the tests on machine where default locale is N
OT "en_US" */ | |
| 990 /* nnf = unum_open(UNUM_DEFAULT, NULL, &status); */ | |
| 991 nnf = unum_open(UNUM_DEFAULT, NULL,0,"en_US",NULL, &status); | |
| 992 | |
| 993 if(U_FAILURE(status)){ | |
| 994 log_data_err("FAIL: failure in the construction of number format: %s (Ar
e you missing data?)\n", myErrorName(status)); | |
| 995 return; | |
| 996 } | |
| 997 | |
| 998 unum_setAttribute(nnf, UNUM_MAX_FRACTION_DIGITS, 2); | |
| 999 roundingTest2(nnf, -0.125, UNUM_ROUND_CEILING, "-0.12"); | |
| 1000 roundingTest2(nnf, -0.125, UNUM_ROUND_FLOOR, "-0.13"); | |
| 1001 roundingTest2(nnf, -0.125, UNUM_ROUND_DOWN, "-0.12"); | |
| 1002 roundingTest2(nnf, -0.125, UNUM_ROUND_UP, "-0.13"); | |
| 1003 roundingTest2(nnf, 0.125, UNUM_FOUND_HALFEVEN, "0.12"); | |
| 1004 roundingTest2(nnf, 0.135, UNUM_ROUND_HALFDOWN, "0.13"); | |
| 1005 roundingTest2(nnf, 0.125, UNUM_ROUND_HALFUP, "0.13"); | |
| 1006 roundingTest2(nnf, 0.135, UNUM_FOUND_HALFEVEN, "0.14"); | |
| 1007 /* The following are exactly represented, and shouldn't round */ | |
| 1008 roundingTest2(nnf, 1.00, UNUM_ROUND_UP, "1"); | |
| 1009 roundingTest2(nnf, 24.25, UNUM_ROUND_UP, "24.25"); | |
| 1010 roundingTest2(nnf, 24.25, UNUM_ROUND_CEILING, "24.25"); | |
| 1011 roundingTest2(nnf, -24.25, UNUM_ROUND_UP, "-24.25"); | |
| 1012 | |
| 1013 /* Differences pretty far out there */ | |
| 1014 roundingTest2(nnf, 1.0000001, UNUM_ROUND_CEILING, "1.01"); | |
| 1015 roundingTest2(nnf, 1.0000001, UNUM_ROUND_FLOOR, "1"); | |
| 1016 roundingTest2(nnf, 1.0000001, UNUM_ROUND_DOWN, "1"); | |
| 1017 roundingTest2(nnf, 1.0000001, UNUM_ROUND_UP, "1.01"); | |
| 1018 roundingTest2(nnf, 1.0000001, UNUM_FOUND_HALFEVEN, "1"); | |
| 1019 roundingTest2(nnf, 1.0000001, UNUM_ROUND_HALFDOWN, "1"); | |
| 1020 roundingTest2(nnf, 1.0000001, UNUM_ROUND_HALFUP, "1"); | |
| 1021 | |
| 1022 roundingTest2(nnf, -1.0000001, UNUM_ROUND_CEILING, "-1"); | |
| 1023 roundingTest2(nnf, -1.0000001, UNUM_ROUND_FLOOR, "-1.01"); | |
| 1024 roundingTest2(nnf, -1.0000001, UNUM_ROUND_DOWN, "-1"); | |
| 1025 roundingTest2(nnf, -1.0000001, UNUM_ROUND_UP, "-1.01"); | |
| 1026 roundingTest2(nnf, -1.0000001, UNUM_FOUND_HALFEVEN, "-1"); | |
| 1027 roundingTest2(nnf, -1.0000001, UNUM_ROUND_HALFDOWN, "-1"); | |
| 1028 roundingTest2(nnf, -1.0000001, UNUM_ROUND_HALFUP, "-1"); | |
| 1029 | |
| 1030 unum_close(nnf); | |
| 1031 } | |
| 1032 | |
| 1033 /*-------------------------------------*/ | |
| 1034 | |
| 1035 static void roundingTest2(UNumberFormat* nf, double x, int32_t roundingMode, con
st char* expected) | |
| 1036 { | |
| 1037 UChar *out = NULL; | |
| 1038 UChar *res; | |
| 1039 UFieldPosition pos; | |
| 1040 UErrorCode status; | |
| 1041 int32_t lneed; | |
| 1042 status=U_ZERO_ERROR; | |
| 1043 unum_setAttribute(nf, UNUM_ROUNDING_MODE, roundingMode); | |
| 1044 lneed=0; | |
| 1045 lneed=unum_formatDouble(nf, x, NULL, lneed, NULL, &status); | |
| 1046 if(status==U_BUFFER_OVERFLOW_ERROR){ | |
| 1047 status=U_ZERO_ERROR; | |
| 1048 out=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); | |
| 1049 pos.field=0; | |
| 1050 unum_formatDouble(nf, x, out, lneed+1, &pos, &status); | |
| 1051 } | |
| 1052 if(U_FAILURE(status)) { | |
| 1053 log_err("Error in formatting using unum_formatDouble(.....): %s\n", myEr
rorName(status) ); | |
| 1054 } | |
| 1055 /*Need to use log_verbose here. Problem with the float*/ | |
| 1056 /*printf("%f format with %d fraction digits to %s\n", x, maxFractionDigits,
austrdup(out) );*/ | |
| 1057 res=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1) ); | |
| 1058 u_uastrcpy(res, expected); | |
| 1059 if (u_strcmp(out, res) != 0) | |
| 1060 log_err("FAIL: Expected: \"%s\" Got: \"%s\"\n", expected, austrdup(out)
); | |
| 1061 free(res); | |
| 1062 if(out != NULL) { | |
| 1063 free(out); | |
| 1064 } | |
| 1065 } | |
| 1066 | |
| 1067 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
