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 fixes 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); return; } 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/TestGetKeywordValuesForLocale"); 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 pattern %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 instead\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", myErrorName(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", myErrorName(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-271 }; 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 construction 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_austrcpy(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", myErrorName(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_austrcpy(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", myErrorName(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], austrdup(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, &status); 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, &status); 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, &status); 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(status) ); 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, &status); 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, &status); 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 like it is "en_US" 616 - very bad if you try to run the tests on machine where default locale is NOT "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 (Are 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", myErrorName(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, 7777777.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 for UNUM_ROUNDING_INCREMENT\n"); 696 else 697 log_verbose("Pass: setting and getting double attributes for UNUM_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, expected %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 pos = (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, expected %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 digits), 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", "AMD", 808 "ANG", "AOA", "AOK", "AON", "AOR", "AOS", "ARA", "ARM", "ARP", "ARS", "ATS", 809 "AUD", "AUP", "AWG", "AZM", "BAD", "BAM", "BAN", "BBD", "BDT", "BEC", "BEF", 810 "BEL", "BGL", "BGM", "BGN", "BGO", "BGX", "BHD", "BIF", "BMD", "BMP", "BND", 811 "BOB", "BOL", "BOP", "BOV", "BRB", "BRC", "BRE", "BRL", "BRN", "BRR", "BRZ", 812 "BSD", "BSP", "BTN", "BTR", "BUK", "BUR", "BWP", "BYB", "BYL", "BYR", "BZD", 813 "BZH", "CAD", "CDF", "CDG", "CDL", "CFF", "CHF", "CKD", "CLC", "CLE", "CLF", 814 "CLP", "CMF", "CNP", "CNX", "CNY", "COB", "COF", "COP", "CRC", "CSC", "CSK", 815 "CUP", "CUX", "CVE", "CWG", "CYP", "CZK", "DDM", "DEM", "DES", "DJF", "DKK", 816 "DOP", "DZD", "DZF", "DZG", "ECS", "ECV", "EEK", "EGP", "ERN", "ESP", "ETB", 817 "ETD", "EUR", "FIM", "FIN", "FJD", "FJP", "FKP", "FOK", "FRF", "FRG", "GAF", 818 "GBP", "GEK", "GEL", "GHC", "GHO", "GHP", "GHR", "GIP", "GLK", "GMD", "GMP", 819 "GNF", "GNI", "GNS", "GPF", "GQE", "GQF", "GQP", "GRD", "GRN", "GTQ", "GUF", 820 "GWE", "GWM", "GWP", "GYD", "HKD", "HNL", "HRD", "HRK", "HTG", "HUF", "IBP", 821 "IDG", "IDJ", "IDN", "IDR", "IEP", "ILL", "ILP", "ILS", "IMP", "INR", "IQD", 822 "IRR", "ISK", "ITL", "JEP", "JMD", "JMP", "JOD", "JPY", "KES", "KGS", "KHO", 823 "KHR", "KID", "KMF", "KPP", "KPW", "KRH", "KRO", "KRW", "KWD", "KYD", "KZR", 824 "KZT", "LAK", "LBP", "LIF", "LKR", "LNR", "LRD", "LSL", "LTL", "LTT", "LUF", 825 "LVL", "LVR", "LYB", "LYD", "LYP", "MAD", "MAF", "MCF", "MCG", "MDC", "MDL", 826 "MDR", "MGA", "MGF", "MHD", "MKD", "MKN", "MLF", "MMK", "MMX", "MNT", "MOP", 827 "MQF", "MRO", "MTL", "MTP", "MUR", "MVP", "MVR", "MWK", "MWP", "MXN", "MXP", 828 "MXV", "MYR", "MZE", "MZM", "NAD", "NCF", "NGN", "NGP", "NHF", "NIC", "NIG", 829 "NIO", "NLG", "NOK", "NPR", "NZD", "NZP", "OMR", "OMS", "PAB", "PDK", "PDN", 830 "PDR", "PEI", "PEN", "PES", "PGK", "PHP", "PKR", "PLN", "PLX", "PLZ", "PSP", 831 "PTC", "PTE", "PYG", "QAR", "REF", "ROL", "RON", "RUB", "RUR", "RWF", "SAR", 832 "SAS", "SBD", "SCR", "SDD", "SDP", "SEK", "SGD", "SHP", "SIB", "SIT", "SKK", 833 "SLL", "SML", "SOS", "SQS", "SRG", "SSP", "STD", "STE", "SUN", "SUR", "SVC", 834 "SYP", "SZL", "TCC", "TDF", "THB", "TJR", "TJS", "TMM", "TND", "TOP", "TOS", 835 "TPE", "TPP", "TRL", "TTD", "TTO", "TVD", "TWD", "TZS", "UAH", "UAK", "UGS", 836 "UGX", "USD", "USN", "USS", "UYF", "UYP", "UYU", "UZC", "UZS", "VAL", "VDD", 837 "VDN", "VDP", "VEB", "VGD", "VND", "VNN", "VNR", "VNS", "VUV", "WSP", "WST", 838 "XAD", "XAF", "XAM", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XCF", "XDR", 839 "XEF", "XEU", "XFO", "XFU", "XID", "XMF", "XNF", "XOF", "XPF", "XPS", "XSS", 840 "XTR", "YDD", "YEI", "YER", "YUD", "YUF", "YUG", "YUM", "YUN", "YUO", "YUR", 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 remove 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_getDefault(), 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", loc); 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 expected.\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(ALL, &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 like it is "en_US" 989 - very bad if you try to run the tests on machine where default locale is NOT "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 (Are 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, const 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", myErrorName(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 */ 1068
