| OLD | NEW |
|---|
| (Empty) |
| 1 /******************************************************************** | |
| 2 * COPYRIGHT: | |
| 3 * Copyright (c) 1998-2012, International Business Machines Corporation and | |
| 4 * others. All Rights Reserved. | |
| 5 ********************************************************************/ | |
| 6 /* | |
| 7 * File putiltst.c (Tests the API in putil) | |
| 8 * | |
| 9 * Modification History: | |
| 10 * | |
| 11 * Date Name Description | |
| 12 * 07/12/2000 Madhu Creation | |
| 13 ******************************************************************************* | |
| 14 */ | |
| 15 | |
| 16 #include "unicode/utypes.h" | |
| 17 #include "cintltst.h" | |
| 18 #include "cmemory.h" | |
| 19 #include "unicode/putil.h" | |
| 20 #include "unicode/ustring.h" | |
| 21 #include "unicode/icudataver.h" | |
| 22 #include "cstring.h" | |
| 23 #include "putilimp.h" | |
| 24 #include "toolutil.h" | |
| 25 #include "uinvchar.h" | |
| 26 #include <stdio.h> | |
| 27 | |
| 28 /* See the comments on U_SIGNED_RIGHT_SHIFT_IS_ARITHMETIC. */ | |
| 29 static void TestSignedRightShiftIsArithmetic(void) { | |
| 30 int32_t x=0xfff5fff3; | |
| 31 int32_t m=-1; | |
| 32 int32_t x4=x>>4; | |
| 33 int32_t m1=m>>1; | |
| 34 UBool signedRightShiftIsArithmetic= x4==0xffff5fff && m1==-1; | |
| 35 if(signedRightShiftIsArithmetic==U_SIGNED_RIGHT_SHIFT_IS_ARITHMETIC) { | |
| 36 log_info("signed right shift is Arithmetic Shift Right: %d\n", | |
| 37 signedRightShiftIsArithmetic); | |
| 38 } else { | |
| 39 log_err("error: unexpected signed right shift is Arithmetic Shift Right:
%d\n" | |
| 40 " You need to change the value of U_SIGNED_RIGHT_SHIFT_IS_
ARITHMETIC " | |
| 41 "for your platform.\n", | |
| 42 signedRightShiftIsArithmetic); | |
| 43 } | |
| 44 } | |
| 45 | |
| 46 static UBool compareWithNAN(double x, double y); | |
| 47 static void doAssert(double expect, double got, const char *message); | |
| 48 | |
| 49 static void TestPUtilAPI(void){ | |
| 50 | |
| 51 double n1=0.0, y1=0.0, expn1, expy1; | |
| 52 double value1 = 0.021; | |
| 53 char *str=0; | |
| 54 UBool isTrue=FALSE; | |
| 55 | |
| 56 log_verbose("Testing the API uprv_modf()\n"); | |
| 57 y1 = uprv_modf(value1, &n1); | |
| 58 expn1=0; | |
| 59 expy1=0.021; | |
| 60 if(y1 != expy1 || n1 != expn1){ | |
| 61 log_err("Error in uprv_modf. Expected IntegralValue=%f, Got=%f, \n Expe
cted FractionalValue=%f, Got=%f\n", | |
| 62 expn1, n1, expy1, y1); | |
| 63 } | |
| 64 if(getTestOption(VERBOSITY_OPTION)){ | |
| 65 log_verbose("[float] x = %f n = %f y = %f\n", value1, n1, y1); | |
| 66 } | |
| 67 log_verbose("Testing the API uprv_fmod()\n"); | |
| 68 expn1=uprv_fmod(30.50, 15.00); | |
| 69 doAssert(expn1, 0.5, "uprv_fmod(30.50, 15.00) failed."); | |
| 70 | |
| 71 log_verbose("Testing the API uprv_ceil()\n"); | |
| 72 expn1=uprv_ceil(value1); | |
| 73 doAssert(expn1, 1, "uprv_ceil(0.021) failed."); | |
| 74 | |
| 75 log_verbose("Testing the API uprv_floor()\n"); | |
| 76 expn1=uprv_floor(value1); | |
| 77 doAssert(expn1, 0, "uprv_floor(0.021) failed."); | |
| 78 | |
| 79 log_verbose("Testing the API uprv_fabs()\n"); | |
| 80 expn1=uprv_fabs((2.02-1.345)); | |
| 81 doAssert(expn1, 0.675, "uprv_fabs(2.02-1.345) failed."); | |
| 82 | |
| 83 log_verbose("Testing the API uprv_fmax()\n"); | |
| 84 doAssert(uprv_fmax(2.4, 1.2), 2.4, "uprv_fmax(2.4, 1.2) failed."); | |
| 85 | |
| 86 log_verbose("Testing the API uprv_fmax() with x value= NaN\n"); | |
| 87 expn1=uprv_fmax(uprv_getNaN(), 1.2); | |
| 88 doAssert(expn1, uprv_getNaN(), "uprv_fmax(uprv_getNaN(), 1.2) failed. when o
ne parameter is NaN"); | |
| 89 | |
| 90 log_verbose("Testing the API uprv_fmin()\n"); | |
| 91 doAssert(uprv_fmin(2.4, 1.2), 1.2, "uprv_fmin(2.4, 1.2) failed."); | |
| 92 | |
| 93 log_verbose("Testing the API uprv_fmin() with x value= NaN\n"); | |
| 94 expn1=uprv_fmin(uprv_getNaN(), 1.2); | |
| 95 doAssert(expn1, uprv_getNaN(), "uprv_fmin(uprv_getNaN(), 1.2) failed. when o
ne parameter is NaN"); | |
| 96 | |
| 97 log_verbose("Testing the API uprv_max()\n"); | |
| 98 doAssert(uprv_max(4, 2), 4, "uprv_max(4, 2) failed."); | |
| 99 | |
| 100 log_verbose("Testing the API uprv_min()\n"); | |
| 101 doAssert(uprv_min(-4, 2), -4, "uprv_min(-4, 2) failed."); | |
| 102 | |
| 103 log_verbose("Testing the API uprv_trunc()\n"); | |
| 104 doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed."); | |
| 105 doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed."); | |
| 106 doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()
) failed. with parameter=NaN"); | |
| 107 doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(upr
v_getInfinity()) failed. with parameter=Infinity"); | |
| 108 | |
| 109 | |
| 110 log_verbose("Testing the API uprv_pow10()\n"); | |
| 111 doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed."); | |
| 112 | |
| 113 log_verbose("Testing the API uprv_isNegativeInfinity()\n"); | |
| 114 isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1); | |
| 115 if(isTrue != TRUE){ | |
| 116 log_err("ERROR: uprv_isNegativeInfinity failed.\n"); | |
| 117 } | |
| 118 log_verbose("Testing the API uprv_isPositiveInfinity()\n"); | |
| 119 isTrue=uprv_isPositiveInfinity(uprv_getInfinity()); | |
| 120 if(isTrue != TRUE){ | |
| 121 log_err("ERROR: uprv_isPositiveInfinity failed.\n"); | |
| 122 } | |
| 123 log_verbose("Testing the API uprv_isInfinite()\n"); | |
| 124 isTrue=uprv_isInfinite(uprv_getInfinity()); | |
| 125 if(isTrue != TRUE){ | |
| 126 log_err("ERROR: uprv_isInfinite failed.\n"); | |
| 127 } | |
| 128 | |
| 129 #if 0 | |
| 130 log_verbose("Testing the API uprv_digitsAfterDecimal()....\n"); | |
| 131 doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() fail
ed."); | |
| 132 doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.23
45E2) failed."); | |
| 133 doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2
345E-2) failed."); | |
| 134 doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.23
45E2) failed."); | |
| 135 doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(
1.2345E-20) failed."); | |
| 136 doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2
345E20) failed."); | |
| 137 doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021
) failed."); | |
| 138 doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) fa
iled."); | |
| 139 doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecima
l(0.022223333321) failed."); | |
| 140 #endif | |
| 141 | |
| 142 log_verbose("Testing the API u_errorName()...\n"); | |
| 143 str=(char*)u_errorName((UErrorCode)0); | |
| 144 if(strcmp(str, "U_ZERO_ERROR") != 0){ | |
| 145 log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s\n",
str); | |
| 146 } | |
| 147 log_verbose("Testing the API u_errorName()...\n"); | |
| 148 str=(char*)u_errorName((UErrorCode)-127); | |
| 149 if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){ | |
| 150 log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING
Got=%s\n", str); | |
| 151 } | |
| 152 log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE...\n"); | |
| 153 str=(char*)u_errorName((UErrorCode)200); | |
| 154 if(strcmp(str, "[BOGUS UErrorCode]") != 0){ | |
| 155 log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=
%s\n", str); | |
| 156 } | |
| 157 | |
| 158 { | |
| 159 const char* dataDirectory; | |
| 160 int32_t dataDirectoryLen; | |
| 161 UChar *udataDir=0; | |
| 162 UChar temp[100]; | |
| 163 char *charvalue=0; | |
| 164 log_verbose("Testing chars to UChars\n"); | |
| 165 | |
| 166 /* This cannot really work on a japanese system. u_uastrcpy will have d
ifferent results than */ | |
| 167 /* u_charsToUChars when there is a backslash in the string! */ | |
| 168 /*dataDirectory=u_getDataDirectory();*/ | |
| 169 | |
| 170 dataDirectory="directory1"; /*no backslashes*/ | |
| 171 dataDirectoryLen=(int32_t)strlen(dataDirectory); | |
| 172 udataDir=(UChar*)malloc(sizeof(UChar) * (dataDirectoryLen + 1)); | |
| 173 u_charsToUChars(dataDirectory, udataDir, (dataDirectoryLen + 1)); | |
| 174 u_uastrcpy(temp, dataDirectory); | |
| 175 | |
| 176 if(u_strcmp(temp, udataDir) != 0){ | |
| 177 log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s\n", aust
rdup(temp), austrdup(udataDir)); | |
| 178 } | |
| 179 log_verbose("Testing UChars to chars\n"); | |
| 180 charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1)); | |
| 181 | |
| 182 u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1)); | |
| 183 if(strcmp(charvalue, dataDirectory) != 0){ | |
| 184 log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s\n", char
value, dataDirectory); | |
| 185 } | |
| 186 free(charvalue); | |
| 187 free(udataDir); | |
| 188 } | |
| 189 | |
| 190 log_verbose("Testing uprv_timezone()....\n"); | |
| 191 { | |
| 192 int32_t tzoffset = uprv_timezone(); | |
| 193 log_verbose("Value returned from uprv_timezone = %d\n", tzoffset); | |
| 194 if (tzoffset != 28800) { | |
| 195 log_verbose("***** WARNING: If testing in the PST timezone, t_timezo
ne should return 28800! *****"); | |
| 196 } | |
| 197 if ((tzoffset % 1800 != 0)) { | |
| 198 log_info("Note: t_timezone offset of %ld (for %s : %s) is not a mult
iple of 30min.", tzoffset, uprv_tzname(0), uprv_tzname(1)); | |
| 199 } | |
| 200 /*tzoffset=uprv_getUTCtime();*/ | |
| 201 | |
| 202 } | |
| 203 } | |
| 204 | |
| 205 static void TestVersion(void) | |
| 206 { | |
| 207 UVersionInfo versionArray = {0x01, 0x00, 0x02, 0x02}; | |
| 208 UVersionInfo versionArray2 = {0x01, 0x00, 0x02, 0x02}; | |
| 209 char versionString[17]; /* xxx.xxx.xxx.xxx\0 */ | |
| 210 UChar versionUString[] = { 0x0031, 0x002E, 0x0030, 0x002E, | |
| 211 0x0032, 0x002E, 0x0038, 0x0000 }; /* 1.0.2.8 */ | |
| 212 UVersionInfo version; | |
| 213 UErrorCode status = U_ZERO_ERROR; | |
| 214 | |
| 215 log_verbose("Testing the API u_versionToString().....\n"); | |
| 216 u_versionToString(versionArray, versionString); | |
| 217 if(strcmp(versionString, "1.0.2.2") != 0){ | |
| 218 log_err("ERROR: u_versionToString() failed. Expected: 1.0.2.2, Got=%s\n"
, versionString); | |
| 219 } | |
| 220 log_verbose("Testing the API u_versionToString().....with versionArray=NULL\
n"); | |
| 221 u_versionToString(NULL, versionString); | |
| 222 if(strcmp(versionString, "") != 0){ | |
| 223 log_err("ERROR: u_versionToString() failed. with versionArray=NULL. It s
hould just return\n"); | |
| 224 } | |
| 225 log_verbose("Testing the API u_versionToString().....with versionArray=NULL\
n"); | |
| 226 u_versionToString(NULL, versionString); | |
| 227 if(strcmp(versionString, "") != 0){ | |
| 228 log_err("ERROR: u_versionToString() failed . It should just return\n"); | |
| 229 } | |
| 230 log_verbose("Testing the API u_versionToString().....with versionString=NULL
\n"); | |
| 231 u_versionToString(versionArray, NULL); | |
| 232 if(strcmp(versionString, "") != 0){ | |
| 233 log_err("ERROR: u_versionToString() failed. with versionArray=NULL It s
hould just return\n"); | |
| 234 } | |
| 235 versionArray[0] = 0x0a; | |
| 236 log_verbose("Testing the API u_versionToString().....\n"); | |
| 237 u_versionToString(versionArray, versionString); | |
| 238 if(strcmp(versionString, "10.0.2.2") != 0){ | |
| 239 log_err("ERROR: u_versionToString() failed. Expected: 10.0.2.2, Got=%s\n
", versionString); | |
| 240 } | |
| 241 versionArray[0] = 0xa0; | |
| 242 u_versionToString(versionArray, versionString); | |
| 243 if(strcmp(versionString, "160.0.2.2") != 0){ | |
| 244 log_err("ERROR: u_versionToString() failed. Expected: 160.0.2.2, Got=%s\
n", versionString); | |
| 245 } | |
| 246 versionArray[0] = 0xa0; | |
| 247 versionArray[1] = 0xa0; | |
| 248 u_versionToString(versionArray, versionString); | |
| 249 if(strcmp(versionString, "160.160.2.2") != 0){ | |
| 250 log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%
s\n", versionString); | |
| 251 } | |
| 252 versionArray[0] = 0x01; | |
| 253 versionArray[1] = 0x0a; | |
| 254 u_versionToString(versionArray, versionString); | |
| 255 if(strcmp(versionString, "1.10.2.2") != 0){ | |
| 256 log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%
s\n", versionString); | |
| 257 } | |
| 258 | |
| 259 log_verbose("Testing the API u_versionFromString() ....\n"); | |
| 260 u_versionFromString(versionArray, "1.3.5.6"); | |
| 261 u_versionToString(versionArray, versionString); | |
| 262 if(strcmp(versionString, "1.3.5.6") != 0){ | |
| 263 log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", ve
rsionString); | |
| 264 } | |
| 265 log_verbose("Testing the API u_versionFromString() where versionArray=NULL..
..\n"); | |
| 266 u_versionFromString(NULL, "1.3.5.6"); | |
| 267 u_versionToString(versionArray, versionString); | |
| 268 if(strcmp(versionString, "1.3.5.6") != 0){ | |
| 269 log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", ve
rsionString); | |
| 270 } | |
| 271 | |
| 272 log_verbose("Testing the API u_getVersion().....\n"); | |
| 273 u_getVersion(versionArray); | |
| 274 u_versionToString(versionArray, versionString); | |
| 275 if(strcmp(versionString, U_ICU_VERSION) != 0){ | |
| 276 log_err("ERROR: u_getVersion() failed. Got=%s, expected %s\n", versionS
tring, U_ICU_VERSION); | |
| 277 } | |
| 278 /* test unicode */ | |
| 279 log_verbose("Testing u_versionFromUString...\n"); | |
| 280 u_versionFromString(versionArray,"1.0.2.8"); | |
| 281 u_versionFromUString(versionArray2, versionUString); | |
| 282 u_versionToString(versionArray2, versionString); | |
| 283 if(memcmp(versionArray, versionArray2, sizeof(UVersionInfo))) { | |
| 284 log_err("FAIL: u_versionFromUString produced a different result - not 1.0
.2.8 but %s [%x.%x.%x.%x]\n", | |
| 285 versionString, | |
| 286 (int)versionArray2[0], | |
| 287 (int)versionArray2[1], | |
| 288 (int)versionArray2[2], | |
| 289 (int)versionArray2[3]); | |
| 290 } | |
| 291 else { | |
| 292 log_verbose(" from UString: %s\n", versionString); | |
| 293 } | |
| 294 | |
| 295 /* Test the data version API for better code coverage */ | |
| 296 u_getDataVersion(version, &status); | |
| 297 if (U_FAILURE(status)) { | |
| 298 log_data_err("ERROR: Unable to get data version. %s\n", u_errorName(stat
us)); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 static void TestCompareVersions(void) | |
| 303 { | |
| 304 /* use a 1d array to be palatable to java */ | |
| 305 const char *testCases[] = { | |
| 306 /* v1 <|=|> v2 */ | |
| 307 "0.0.0.0", "=", "0.0.0.0", | |
| 308 "3.1.2.0", ">", "3.0.9.0", | |
| 309 "3.2.8.6", "<", "3.4", | |
| 310 "4.0", ">", "3.2", | |
| 311 NULL, NULL, NULL | |
| 312 }; | |
| 313 const char *v1str; | |
| 314 const char *opstr; | |
| 315 const char *v2str; | |
| 316 int32_t op, invop, got, invgot; | |
| 317 UVersionInfo v1, v2; | |
| 318 int32_t j; | |
| 319 log_verbose("Testing memcmp()\n"); | |
| 320 for(j=0;testCases[j]!=NULL;j+=3) { | |
| 321 v1str = testCases[j+0]; | |
| 322 opstr = testCases[j+1]; | |
| 323 v2str = testCases[j+2]; | |
| 324 switch(opstr[0]) { | |
| 325 case '-': | |
| 326 case '<': op = -1; break; | |
| 327 case '0': | |
| 328 case '=': op = 0; break; | |
| 329 case '+': | |
| 330 case '>': op = 1; break; | |
| 331 default: log_err("Bad operator at j/3=%d\n", (j/3)); return; | |
| 332 } | |
| 333 invop = 0-op; /* inverse operation: with v1 and v2 switched */ | |
| 334 u_versionFromString(v1, v1str); | |
| 335 u_versionFromString(v2, v2str); | |
| 336 got = memcmp(v1, v2, sizeof(UVersionInfo)); | |
| 337 invgot = memcmp(v2, v1, sizeof(UVersionInfo)); /* Opposite */ | |
| 338 if((got <= 0 && op <= 0) || (got >= 0 && op >= 0)) { | |
| 339 log_verbose("%d: %s %s %s, OK\n", (j/3), v1str, opstr, v2str); | |
| 340 } else { | |
| 341 log_err("%d: %s %s %s: wanted values of the same sign, %d got %d\n", (j/
3), v1str, opstr, v2str, op, got); | |
| 342 } | |
| 343 if((invgot >= 0 && invop >= 0) || (invgot <= 0 && invop <= 0)) { | |
| 344 log_verbose("%d: %s (%d) %s, OK (inverse)\n", (j/3), v2str, invop, v1str
); | |
| 345 } else { | |
| 346 log_err("%d: %s (%d) %s: wanted values of the same sign, %d got %d\n", (
j/3), v2str, invop, v1str, invop, invgot); | |
| 347 } | |
| 348 } | |
| 349 } | |
| 350 | |
| 351 | |
| 352 | |
| 353 #if 0 | |
| 354 static void testIEEEremainder() | |
| 355 { | |
| 356 double pinf = uprv_getInfinity(); | |
| 357 double ninf = -uprv_getInfinity(); | |
| 358 double nan = uprv_getNaN(); | |
| 359 /* double pzero = 0.0;*/ | |
| 360 /* double nzero = 0.0; | |
| 361 nzero *= -1;*/ | |
| 362 | |
| 363 /* simple remainder checks*/ | |
| 364 remainderTest(7.0, 2.5, -0.5); | |
| 365 remainderTest(7.0, -2.5, -0.5); | |
| 366 /* this should work | |
| 367 remainderTest(43.7, 2.5, 1.2); | |
| 368 */ | |
| 369 | |
| 370 /* infinity and real*/ | |
| 371 remainderTest(1.0, pinf, 1.0); | |
| 372 remainderTest(1.0, ninf, 1.0); | |
| 373 | |
| 374 /*test infinity and real*/ | |
| 375 remainderTest(nan, 1.0, nan); | |
| 376 remainderTest(1.0, nan, nan); | |
| 377 /*test infinity and nan*/ | |
| 378 remainderTest(ninf, nan, nan); | |
| 379 remainderTest(pinf, nan, nan); | |
| 380 | |
| 381 /* test infinity and zero */ | |
| 382 /* remainderTest(pinf, pzero, 1.25); | |
| 383 remainderTest(pinf, nzero, 1.25); | |
| 384 remainderTest(ninf, pzero, 1.25); | |
| 385 remainderTest(ninf, nzero, 1.25); */ | |
| 386 } | |
| 387 | |
| 388 static void remainderTest(double x, double y, double exp) | |
| 389 { | |
| 390 double result = uprv_IEEEremainder(x,y); | |
| 391 | |
| 392 if( uprv_isNaN(result) && | |
| 393 ! ( uprv_isNaN(x) || uprv_isNaN(y))) { | |
| 394 log_err("FAIL: got NaN as result without NaN as argument"); | |
| 395 log_err(" IEEEremainder(%f, %f) is %f, expected %f\n", x, y, result
, exp); | |
| 396 } | |
| 397 else if(!compareWithNAN(result, exp)) { | |
| 398 log_err("FAIL: IEEEremainder(%f, %f) is %f, expected %f\n", x, y, resul
t, exp); | |
| 399 } else{ | |
| 400 log_verbose("OK: IEEEremainder(%f, %f) is %f\n", x, y, result); | |
| 401 } | |
| 402 | |
| 403 } | |
| 404 #endif | |
| 405 | |
| 406 static UBool compareWithNAN(double x, double y) | |
| 407 { | |
| 408 if( uprv_isNaN(x) || uprv_isNaN(y) ) { | |
| 409 if(!uprv_isNaN(x) || !uprv_isNaN(y) ) { | |
| 410 return FALSE; | |
| 411 } | |
| 412 } | |
| 413 else if (y != x) { /* no NaN's involved */ | |
| 414 return FALSE; | |
| 415 } | |
| 416 | |
| 417 return TRUE; | |
| 418 } | |
| 419 | |
| 420 static void doAssert(double got, double expect, const char *message) | |
| 421 { | |
| 422 if(! compareWithNAN(expect, got) ) { | |
| 423 log_err("ERROR : %s. Expected : %lf, Got: %lf\n", message, expect, got); | |
| 424 } | |
| 425 } | |
| 426 | |
| 427 | |
| 428 #define _CODE_ARR_LEN 8 | |
| 429 static const UErrorCode errorCode[_CODE_ARR_LEN] = { | |
| 430 U_USING_FALLBACK_WARNING, | |
| 431 U_STRING_NOT_TERMINATED_WARNING, | |
| 432 U_ILLEGAL_ARGUMENT_ERROR, | |
| 433 U_STATE_TOO_OLD_ERROR, | |
| 434 U_BAD_VARIABLE_DEFINITION, | |
| 435 U_RULE_MASK_ERROR, | |
| 436 U_UNEXPECTED_TOKEN, | |
| 437 U_UNSUPPORTED_ATTRIBUTE | |
| 438 }; | |
| 439 | |
| 440 static const char* str[] = { | |
| 441 "U_USING_FALLBACK_WARNING", | |
| 442 "U_STRING_NOT_TERMINATED_WARNING", | |
| 443 "U_ILLEGAL_ARGUMENT_ERROR", | |
| 444 "U_STATE_TOO_OLD_ERROR", | |
| 445 "U_BAD_VARIABLE_DEFINITION", | |
| 446 "U_RULE_MASK_ERROR", | |
| 447 "U_UNEXPECTED_TOKEN", | |
| 448 "U_UNSUPPORTED_ATTRIBUTE" | |
| 449 }; | |
| 450 | |
| 451 static void TestErrorName(void){ | |
| 452 int32_t code=0; | |
| 453 const char* errorName ; | |
| 454 for(;code<U_ERROR_LIMIT;code++){ | |
| 455 errorName = u_errorName((UErrorCode)code); | |
| 456 if(!errorName || errorName[0] == 0) { | |
| 457 log_err("Error: u_errorName(0x%X) failed.\n",code); | |
| 458 } | |
| 459 } | |
| 460 | |
| 461 for(code=0;code<_CODE_ARR_LEN; code++){ | |
| 462 errorName = u_errorName(errorCode[code]); | |
| 463 if(uprv_strcmp(str[code],errorName )!=0){ | |
| 464 log_err("Error : u_errorName failed. Expected: %s Got: %s \n",str[co
de],errorName); | |
| 465 } | |
| 466 } | |
| 467 } | |
| 468 | |
| 469 #define AESTRNCPY_SIZE 13 | |
| 470 | |
| 471 static const char * dump_binline(uint8_t *bytes) { | |
| 472 static char buf[512]; | |
| 473 int32_t i; | |
| 474 for(i=0;i<13;i++) { | |
| 475 sprintf(buf+(i*3), "%02x ", bytes[i]); | |
| 476 } | |
| 477 return buf; | |
| 478 } | |
| 479 | |
| 480 static void Test_aestrncpy(int32_t line, const uint8_t *expect, const uint8_t *s
rc, int32_t len) | |
| 481 { | |
| 482 uint8_t str_buf[AESTRNCPY_SIZE] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | |
| 483 uint8_t *ret; | |
| 484 | |
| 485 log_verbose("\n%s:%d: Beginning test of uprv_aestrncpy(dst, src, %d)\n", __FIL
E__, line, len); | |
| 486 ret = uprv_aestrncpy(str_buf, src, len); | |
| 487 if(ret != str_buf) { | |
| 488 log_err("\n%s:%d: FAIL: uprv_aestrncpy returned %p expected %p\n", __FILE__,
line, (void*)ret, (void*)str_buf); | |
| 489 } | |
| 490 if(!uprv_memcmp(str_buf, expect, AESTRNCPY_SIZE)) { | |
| 491 log_verbose("\n%s:%d: OK - compared OK.", __FILE__, line); | |
| 492 log_verbose("\n%s:%d: expected: %s", __FILE__, line, dump_binline((u
int8_t *)expect)); | |
| 493 log_verbose("\n%s:%d: got : %s\n", __FILE__, line, dump_binline(
str_buf)); | |
| 494 } else { | |
| 495 log_err ("\n%s:%d: FAIL: uprv_aestrncpy output differs", __FILE__, line); | |
| 496 log_err ("\n%s:%d: expected: %s", __FILE__, line, dump_binline((u
int8_t *)expect)); | |
| 497 log_err ("\n%s:%d: got : %s\n", __FILE__, line, dump_binline(
str_buf)); | |
| 498 } | |
| 499 } | |
| 500 | |
| 501 static void TestString(void) | |
| 502 { | |
| 503 | |
| 504 uint8_t str_tst[AESTRNCPY_SIZE] = { 0x81, 0x4b, 0x5c, 0x82, 0x25, 0x00, 0x7f,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f }; | |
| 505 | |
| 506 uint8_t str_exp1[AESTRNCPY_SIZE] = { 0x61, 0x2e, 0x2a, 0x62, 0x0a, 0x00, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | |
| 507 uint8_t str_exp2[AESTRNCPY_SIZE] = { 0x61, 0x2e, 0x2a, 0x62, 0x0a, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | |
| 508 uint8_t str_exp3[AESTRNCPY_SIZE] = { 0x61, 0x2e, 0x2a, 0x62, 0x0a, 0x00, 0x00,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff }; | |
| 509 | |
| 510 | |
| 511 | |
| 512 /* test #1- copy with -1 length */ | |
| 513 Test_aestrncpy(__LINE__, str_exp1, str_tst, -1); | |
| 514 Test_aestrncpy(__LINE__, str_exp1, str_tst, 6); | |
| 515 Test_aestrncpy(__LINE__, str_exp2, str_tst, 5); | |
| 516 Test_aestrncpy(__LINE__, str_exp3, str_tst, 8); | |
| 517 } | |
| 518 | |
| 519 void addPUtilTest(TestNode** root); | |
| 520 | |
| 521 static void addToolUtilTests(TestNode** root); | |
| 522 | |
| 523 void | |
| 524 addPUtilTest(TestNode** root) | |
| 525 { | |
| 526 addTest(root, &TestVersion, "putiltst/TestVersion"); | |
| 527 addTest(root, &TestCompareVersions, "putiltst/TestCompareVersions"); | |
| 528 /* addTest(root, &testIEEEremainder, "putiltst/testIEEEremainder"); */ | |
| 529 addTest(root, &TestErrorName, "putiltst/TestErrorName"); | |
| 530 addTest(root, &TestPUtilAPI, "putiltst/TestPUtilAPI"); | |
| 531 addTest(root, &TestString, "putiltst/TestString"); | |
| 532 addToolUtilTests(root); | |
| 533 } | |
| 534 | |
| 535 /* Tool Util Tests ================ */ | |
| 536 #define TOOLUTIL_TESTBUF_SIZE 2048 | |
| 537 static char toolutil_testBuf[TOOLUTIL_TESTBUF_SIZE]; | |
| 538 static const char *NULLSTR="NULL"; | |
| 539 | |
| 540 /** | |
| 541 * Normalize NULL to 'NULL' for testing | |
| 542 */ | |
| 543 #define STRNULL(x) ((x)?(x):NULLSTR) | |
| 544 | |
| 545 static void toolutil_findBasename(void) | |
| 546 { | |
| 547 struct { | |
| 548 const char *inBuf; | |
| 549 const char *expectResult; | |
| 550 } testCases[] = { | |
| 551 { | |
| 552 U_FILE_SEP_STRING "usr" U_FILE_SEP_STRING "bin" U_FILE_SEP_STRING "pkgdata
", | |
| 553 "pkgdata" | |
| 554 }, | |
| 555 { | |
| 556 U_FILE_SEP_STRING "usr" U_FILE_SEP_STRING "bin" U_FILE_SEP_STRING, | |
| 557 "" | |
| 558 }, | |
| 559 { | |
| 560 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_ALT_SEP_STR
ING "pkgdata", | |
| 561 "pkgdata" | |
| 562 }, | |
| 563 { | |
| 564 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_ALT_SEP_STR
ING, | |
| 565 "" | |
| 566 }, | |
| 567 }; | |
| 568 int32_t count=(sizeof(testCases)/sizeof(testCases[0])); | |
| 569 int32_t i; | |
| 570 | |
| 571 | |
| 572 log_verbose("Testing findBaseName()\n"); | |
| 573 for(i=0;i<count;i++) { | |
| 574 const char *result; | |
| 575 const char *input = STRNULL(testCases[i].inBuf); | |
| 576 const char *expect = STRNULL(testCases[i].expectResult); | |
| 577 log_verbose("Test case [%d/%d]: %s\n", i, count-1, input); | |
| 578 result = STRNULL(findBasename(testCases[i].inBuf)); | |
| 579 if(result==expect||!strcmp(result,expect)) { | |
| 580 log_verbose(" -> %s PASS\n", result); | |
| 581 } else { | |
| 582 log_err("FAIL: Test case [%d/%d]: %s -> %s but expected %s\n", i, count-1,
input, result, expect); | |
| 583 } | |
| 584 } | |
| 585 } | |
| 586 | |
| 587 | |
| 588 static void toolutil_findDirname(void) | |
| 589 { | |
| 590 int i; | |
| 591 struct { | |
| 592 const char *inBuf; | |
| 593 int32_t outBufLen; | |
| 594 UErrorCode expectStatus; | |
| 595 const char *expectResult; | |
| 596 } testCases[] = { | |
| 597 { | |
| 598 U_FILE_SEP_STRING "usr" U_FILE_SEP_STRING "bin" U_FILE_SEP_STRING "pkgdata
", | |
| 599 200, | |
| 600 U_ZERO_ERROR, | |
| 601 U_FILE_SEP_STRING "usr" U_FILE_SEP_STRING "bin", | |
| 602 }, | |
| 603 { | |
| 604 U_FILE_SEP_STRING "usr" U_FILE_SEP_STRING "bin" U_FILE_SEP_STRING "pkgdata
", | |
| 605 2, | |
| 606 U_BUFFER_OVERFLOW_ERROR, | |
| 607 NULL | |
| 608 }, | |
| 609 { | |
| 610 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_ALT_SEP_STR
ING "pkgdata", | |
| 611 200, | |
| 612 U_ZERO_ERROR, | |
| 613 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" | |
| 614 }, | |
| 615 { | |
| 616 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_ALT_SEP_STR
ING "pkgdata", | |
| 617 2, | |
| 618 U_BUFFER_OVERFLOW_ERROR, | |
| 619 NULL | |
| 620 }, | |
| 621 { | |
| 622 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_SEP_STRING
"pkgdata", | |
| 623 200, | |
| 624 U_ZERO_ERROR, | |
| 625 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" | |
| 626 }, | |
| 627 { | |
| 628 U_FILE_ALT_SEP_STRING "usr" U_FILE_SEP_STRING "bin" U_FILE_ALT_SEP_STRING
"pkgdata", | |
| 629 200, | |
| 630 U_ZERO_ERROR, | |
| 631 U_FILE_ALT_SEP_STRING "usr" U_FILE_SEP_STRING "bin" | |
| 632 }, | |
| 633 { | |
| 634 U_FILE_ALT_SEP_STRING "usr" U_FILE_ALT_SEP_STRING "bin" U_FILE_ALT_SEP_STR
ING "pkgdata", | |
| 635 2, | |
| 636 U_BUFFER_OVERFLOW_ERROR, | |
| 637 NULL | |
| 638 }, | |
| 639 { | |
| 640 U_FILE_ALT_SEP_STRING "vmlinuz", | |
| 641 200, | |
| 642 U_ZERO_ERROR, | |
| 643 U_FILE_ALT_SEP_STRING | |
| 644 }, | |
| 645 { | |
| 646 U_FILE_SEP_STRING "vmlinux", | |
| 647 200, | |
| 648 U_ZERO_ERROR, | |
| 649 U_FILE_SEP_STRING | |
| 650 }, | |
| 651 { | |
| 652 "pkgdata", | |
| 653 0, | |
| 654 U_BUFFER_OVERFLOW_ERROR, | |
| 655 NULL | |
| 656 }, | |
| 657 { | |
| 658 "pkgdata", | |
| 659 2, | |
| 660 U_ZERO_ERROR, | |
| 661 "" | |
| 662 } | |
| 663 }; | |
| 664 int32_t count=(sizeof(testCases)/sizeof(testCases[0])); | |
| 665 | |
| 666 log_verbose("Testing findDirname()\n"); | |
| 667 for(i=0;i<count;i++) { | |
| 668 const char *result; | |
| 669 const char *input = STRNULL(testCases[i].inBuf); | |
| 670 const char *expect = STRNULL(testCases[i].expectResult); | |
| 671 UErrorCode status = U_ZERO_ERROR; | |
| 672 uprv_memset(toolutil_testBuf, 0x55, TOOLUTIL_TESTBUF_SIZE); | |
| 673 | |
| 674 log_verbose("Test case [%d/%d]: %s\n", i, count-1, input); | |
| 675 result = STRNULL(findDirname(testCases[i].inBuf, toolutil_testBuf, testCases
[i].outBufLen, &status)); | |
| 676 log_verbose(" -> %s, \n", u_errorName(status)); | |
| 677 if(status != testCases[i].expectStatus) { | |
| 678 log_verbose("FAIL: Test case [%d/%d]: %s got error code %s but expected %s
\n", i, count-1, input, u_errorName(status), u_errorName(testCases[i].expectStat
us)); | |
| 679 } | |
| 680 if(result==expect||!strcmp(result,expect)) { | |
| 681 log_verbose(" = -> %s \n", result); | |
| 682 } else { | |
| 683 log_err("FAIL: Test case [%d/%d]: %s -> %s but expected %s\n", i, count-1,
input, result, expect); | |
| 684 } | |
| 685 } | |
| 686 } | |
| 687 | |
| 688 | |
| 689 | |
| 690 static void addToolUtilTests(TestNode** root) { | |
| 691 addTest(root, &toolutil_findBasename, "putiltst/toolutil/findBasename"
); | |
| 692 addTest(root, &toolutil_findDirname, "putiltst/toolutil/findDirname"); | |
| 693 addTest(root, &TestSignedRightShiftIsArithmetic, "putiltst/toolutil/TestSign
edRightShiftIsArithmetic"); | |
| 694 /* | |
| 695 Not yet tested: | |
| 696 | |
| 697 addTest(root, &toolutil_getLongPathname, "putiltst/toolutil/getLongPat
hname"); | |
| 698 addTest(root, &toolutil_getCurrentYear, "putiltst/toolutil/getCurrentY
ear"); | |
| 699 addTest(root, &toolutil_UToolMemory, "putiltst/toolutil/UToolMemory"); | |
| 700 */ | |
| 701 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
