| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ********************************************************************** | |
| 3 * Copyright (c) 2013-2014, International Business Machines | |
| 4 * Corporation and others. All Rights Reserved. | |
| 5 ********************************************************************** | |
| 6 */ | |
| 7 | |
| 8 #include <string.h> | |
| 9 #include "unicode/localpointer.h" | |
| 10 #include "unicode/uperf.h" | |
| 11 #include "unicode/ucol.h" | |
| 12 #include "unicode/coll.h" | |
| 13 #include "unicode/uiter.h" | |
| 14 #include "unicode/ustring.h" | |
| 15 #include "unicode/sortkey.h" | |
| 16 #include "uarrsort.h" | |
| 17 #include "uoptions.h" | |
| 18 #include "ustr_imp.h" | |
| 19 | |
| 20 #define COMPACT_ARRAY(CompactArrays, UNIT) \ | |
| 21 struct CompactArrays{\ | |
| 22 CompactArrays(const CompactArrays & );\ | |
| 23 CompactArrays & operator=(const CompactArrays & );\ | |
| 24 int32_t count;/*total number of the strings*/ \ | |
| 25 int32_t * index;/*relative offset in data*/ \ | |
| 26 UNIT * data; /*the real space to hold strings*/ \ | |
| 27 \ | |
| 28 ~CompactArrays(){free(index);free(data);} \ | |
| 29 CompactArrays() : count(0), index(NULL), data(NULL) { \ | |
| 30 index = (int32_t *) realloc(index, sizeof(int32_t)); \ | |
| 31 index[0] = 0; \ | |
| 32 } \ | |
| 33 void append_one(int32_t theLen){ /*include terminal NULL*/ \ | |
| 34 count++; \ | |
| 35 index = (int32_t *) realloc(index, sizeof(int32_t) * (count + 1)); \ | |
| 36 index[count] = index[count - 1] + theLen; \ | |
| 37 data = (UNIT *) realloc(data, sizeof(UNIT) * index[count]); \ | |
| 38 } \ | |
| 39 UNIT * last(){return data + index[count - 1];} \ | |
| 40 const UNIT * dataOf(int32_t i) const {return data + index[i];} \ | |
| 41 int32_t lengthOf(int i) const {return index[i+1] - index[i] - 1; } /*exclude
terminating NULL*/ \ | |
| 42 }; | |
| 43 | |
| 44 COMPACT_ARRAY(CA_uchar, UChar) | |
| 45 COMPACT_ARRAY(CA_char, char) | |
| 46 | |
| 47 #define MAX_TEST_STRINGS_FOR_PERMUTING 1000 | |
| 48 | |
| 49 // C API test cases | |
| 50 | |
| 51 // | |
| 52 // Test case taking a single test data array, calling ucol_strcoll by permuting
the test data | |
| 53 // | |
| 54 class Strcoll : public UPerfFunction | |
| 55 { | |
| 56 public: | |
| 57 Strcoll(const UCollator* coll, const CA_uchar* source, UBool useLen); | |
| 58 ~Strcoll(); | |
| 59 virtual void call(UErrorCode* status); | |
| 60 virtual long getOperationsPerIteration(); | |
| 61 | |
| 62 private: | |
| 63 const UCollator *coll; | |
| 64 const CA_uchar *source; | |
| 65 UBool useLen; | |
| 66 int32_t maxTestStrings; | |
| 67 }; | |
| 68 | |
| 69 Strcoll::Strcoll(const UCollator* coll, const CA_uchar* source, UBool useLen) | |
| 70 : coll(coll), | |
| 71 source(source), | |
| 72 useLen(useLen) | |
| 73 { | |
| 74 maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_S
TRINGS_FOR_PERMUTING : source->count; | |
| 75 } | |
| 76 | |
| 77 Strcoll::~Strcoll() | |
| 78 { | |
| 79 } | |
| 80 | |
| 81 void Strcoll::call(UErrorCode* status) | |
| 82 { | |
| 83 if (U_FAILURE(*status)) return; | |
| 84 | |
| 85 // call strcoll for permutation | |
| 86 int32_t divisor = source->count / maxTestStrings; | |
| 87 int32_t srcLen, tgtLen; | |
| 88 int32_t cmp = 0; | |
| 89 for (int32_t i = 0, numTestStringsI = 0; i < source->count && numTestStrings
I < maxTestStrings; i++) { | |
| 90 if (i % divisor) continue; | |
| 91 numTestStringsI++; | |
| 92 srcLen = useLen ? source->lengthOf(i) : -1; | |
| 93 for (int32_t j = 0, numTestStringsJ = 0; j < source->count && numTestStr
ingsJ < maxTestStrings; j++) { | |
| 94 if (j % divisor) continue; | |
| 95 numTestStringsJ++; | |
| 96 tgtLen = useLen ? source->lengthOf(j) : -1; | |
| 97 cmp += ucol_strcoll(coll, source->dataOf(i), srcLen, source->dataOf(
j), tgtLen); | |
| 98 } | |
| 99 } | |
| 100 // At the end, cmp must be 0 | |
| 101 if (cmp != 0) { | |
| 102 *status = U_INTERNAL_PROGRAM_ERROR; | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 long Strcoll::getOperationsPerIteration() | |
| 107 { | |
| 108 return maxTestStrings * maxTestStrings; | |
| 109 } | |
| 110 | |
| 111 // | |
| 112 // Test case taking two test data arrays, calling ucol_strcoll for strings at a
same index | |
| 113 // | |
| 114 class Strcoll_2 : public UPerfFunction | |
| 115 { | |
| 116 public: | |
| 117 Strcoll_2(const UCollator* coll, const CA_uchar* source, const CA_uchar* tar
get, UBool useLen); | |
| 118 ~Strcoll_2(); | |
| 119 virtual void call(UErrorCode* status); | |
| 120 virtual long getOperationsPerIteration(); | |
| 121 | |
| 122 private: | |
| 123 const UCollator *coll; | |
| 124 const CA_uchar *source; | |
| 125 const CA_uchar *target; | |
| 126 UBool useLen; | |
| 127 }; | |
| 128 | |
| 129 Strcoll_2::Strcoll_2(const UCollator* coll, const CA_uchar* source, const CA_uch
ar* target, UBool useLen) | |
| 130 : coll(coll), | |
| 131 source(source), | |
| 132 target(target), | |
| 133 useLen(useLen) | |
| 134 { | |
| 135 } | |
| 136 | |
| 137 Strcoll_2::~Strcoll_2() | |
| 138 { | |
| 139 } | |
| 140 | |
| 141 void Strcoll_2::call(UErrorCode* status) | |
| 142 { | |
| 143 if (U_FAILURE(*status)) return; | |
| 144 | |
| 145 // call strcoll for two strings at the same index | |
| 146 if (source->count < target->count) { | |
| 147 *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| 148 } else { | |
| 149 for (int32_t i = 0; i < source->count; i++) { | |
| 150 int32_t srcLen = useLen ? source->lengthOf(i) : -1; | |
| 151 int32_t tgtLen = useLen ? target->lengthOf(i) : -1; | |
| 152 ucol_strcoll(coll, source->dataOf(i), srcLen, target->dataOf(i), tgt
Len); | |
| 153 } | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 long Strcoll_2::getOperationsPerIteration() | |
| 158 { | |
| 159 return source->count; | |
| 160 } | |
| 161 | |
| 162 | |
| 163 // | |
| 164 // Test case taking a single test data array, calling ucol_strcollUTF8 by permut
ing the test data | |
| 165 // | |
| 166 class StrcollUTF8 : public UPerfFunction | |
| 167 { | |
| 168 public: | |
| 169 StrcollUTF8(const UCollator* coll, const CA_char* source, UBool useLen); | |
| 170 ~StrcollUTF8(); | |
| 171 virtual void call(UErrorCode* status); | |
| 172 virtual long getOperationsPerIteration(); | |
| 173 | |
| 174 private: | |
| 175 const UCollator *coll; | |
| 176 const CA_char *source; | |
| 177 UBool useLen; | |
| 178 int32_t maxTestStrings; | |
| 179 }; | |
| 180 | |
| 181 StrcollUTF8::StrcollUTF8(const UCollator* coll, const CA_char* source, UBool use
Len) | |
| 182 : coll(coll), | |
| 183 source(source), | |
| 184 useLen(useLen) | |
| 185 { | |
| 186 maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_S
TRINGS_FOR_PERMUTING : source->count; | |
| 187 } | |
| 188 | |
| 189 StrcollUTF8::~StrcollUTF8() | |
| 190 { | |
| 191 } | |
| 192 | |
| 193 void StrcollUTF8::call(UErrorCode* status) | |
| 194 { | |
| 195 if (U_FAILURE(*status)) return; | |
| 196 | |
| 197 // call strcollUTF8 for permutation | |
| 198 int32_t divisor = source->count / maxTestStrings; | |
| 199 int32_t srcLen, tgtLen; | |
| 200 int32_t cmp = 0; | |
| 201 for (int32_t i = 0, numTestStringsI = 0; U_SUCCESS(*status) && i < source->c
ount && numTestStringsI < maxTestStrings; i++) { | |
| 202 if (i % divisor) continue; | |
| 203 numTestStringsI++; | |
| 204 srcLen = useLen ? source->lengthOf(i) : -1; | |
| 205 for (int32_t j = 0, numTestStringsJ = 0; U_SUCCESS(*status) && j < sourc
e->count && numTestStringsJ < maxTestStrings; j++) { | |
| 206 if (j % divisor) continue; | |
| 207 numTestStringsJ++; | |
| 208 tgtLen = useLen ? source->lengthOf(j) : -1; | |
| 209 cmp += ucol_strcollUTF8(coll, source->dataOf(i), srcLen, source->dat
aOf(j), tgtLen, status); | |
| 210 } | |
| 211 } | |
| 212 // At the end, cmp must be 0 | |
| 213 if (cmp != 0) { | |
| 214 *status = U_INTERNAL_PROGRAM_ERROR; | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 long StrcollUTF8::getOperationsPerIteration() | |
| 219 { | |
| 220 return maxTestStrings * maxTestStrings; | |
| 221 } | |
| 222 | |
| 223 // | |
| 224 // Test case taking two test data arrays, calling ucol_strcoll for strings at a
same index | |
| 225 // | |
| 226 class StrcollUTF8_2 : public UPerfFunction | |
| 227 { | |
| 228 public: | |
| 229 StrcollUTF8_2(const UCollator* coll, const CA_char* source, const CA_char* t
arget, UBool useLen); | |
| 230 ~StrcollUTF8_2(); | |
| 231 virtual void call(UErrorCode* status); | |
| 232 virtual long getOperationsPerIteration(); | |
| 233 | |
| 234 private: | |
| 235 const UCollator *coll; | |
| 236 const CA_char *source; | |
| 237 const CA_char *target; | |
| 238 UBool useLen; | |
| 239 }; | |
| 240 | |
| 241 StrcollUTF8_2::StrcollUTF8_2(const UCollator* coll, const CA_char* source, const
CA_char* target, UBool useLen) | |
| 242 : coll(coll), | |
| 243 source(source), | |
| 244 target(target), | |
| 245 useLen(useLen) | |
| 246 { | |
| 247 } | |
| 248 | |
| 249 StrcollUTF8_2::~StrcollUTF8_2() | |
| 250 { | |
| 251 } | |
| 252 | |
| 253 void StrcollUTF8_2::call(UErrorCode* status) | |
| 254 { | |
| 255 if (U_FAILURE(*status)) return; | |
| 256 | |
| 257 // call strcoll for two strings at the same index | |
| 258 if (source->count < target->count) { | |
| 259 *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| 260 } else { | |
| 261 for (int32_t i = 0; U_SUCCESS(*status) && i < source->count; i++) { | |
| 262 int32_t srcLen = useLen ? source->lengthOf(i) : -1; | |
| 263 int32_t tgtLen = useLen ? target->lengthOf(i) : -1; | |
| 264 ucol_strcollUTF8(coll, source->dataOf(i), srcLen, target->dataOf(i),
tgtLen, status); | |
| 265 } | |
| 266 } | |
| 267 } | |
| 268 | |
| 269 long StrcollUTF8_2::getOperationsPerIteration() | |
| 270 { | |
| 271 return source->count; | |
| 272 } | |
| 273 | |
| 274 // | |
| 275 // Test case taking a single test data array, calling ucol_getSortKey for each | |
| 276 // | |
| 277 class GetSortKey : public UPerfFunction | |
| 278 { | |
| 279 public: | |
| 280 GetSortKey(const UCollator* coll, const CA_uchar* source, UBool useLen); | |
| 281 ~GetSortKey(); | |
| 282 virtual void call(UErrorCode* status); | |
| 283 virtual long getOperationsPerIteration(); | |
| 284 | |
| 285 private: | |
| 286 const UCollator *coll; | |
| 287 const CA_uchar *source; | |
| 288 UBool useLen; | |
| 289 }; | |
| 290 | |
| 291 GetSortKey::GetSortKey(const UCollator* coll, const CA_uchar* source, UBool useL
en) | |
| 292 : coll(coll), | |
| 293 source(source), | |
| 294 useLen(useLen) | |
| 295 { | |
| 296 } | |
| 297 | |
| 298 GetSortKey::~GetSortKey() | |
| 299 { | |
| 300 } | |
| 301 | |
| 302 #define KEY_BUF_SIZE 512 | |
| 303 | |
| 304 void GetSortKey::call(UErrorCode* status) | |
| 305 { | |
| 306 if (U_FAILURE(*status)) return; | |
| 307 | |
| 308 uint8_t key[KEY_BUF_SIZE]; | |
| 309 int32_t len; | |
| 310 | |
| 311 if (useLen) { | |
| 312 for (int32_t i = 0; i < source->count; i++) { | |
| 313 len = ucol_getSortKey(coll, source->dataOf(i), source->lengthOf(i),
key, KEY_BUF_SIZE); | |
| 314 } | |
| 315 } else { | |
| 316 for (int32_t i = 0; i < source->count; i++) { | |
| 317 len = ucol_getSortKey(coll, source->dataOf(i), -1, key, KEY_BUF_SIZE
); | |
| 318 } | |
| 319 } | |
| 320 } | |
| 321 | |
| 322 long GetSortKey::getOperationsPerIteration() | |
| 323 { | |
| 324 return source->count; | |
| 325 } | |
| 326 | |
| 327 // | |
| 328 // Test case taking a single test data array in UTF-16, calling ucol_nextSortKey
Part for each for the | |
| 329 // given buffer size | |
| 330 // | |
| 331 class NextSortKeyPart : public UPerfFunction | |
| 332 { | |
| 333 public: | |
| 334 NextSortKeyPart(const UCollator* coll, const CA_uchar* source, int32_t bufSi
ze, int32_t maxIteration = -1); | |
| 335 ~NextSortKeyPart(); | |
| 336 virtual void call(UErrorCode* status); | |
| 337 virtual long getOperationsPerIteration(); | |
| 338 virtual long getEventsPerIteration(); | |
| 339 | |
| 340 private: | |
| 341 const UCollator *coll; | |
| 342 const CA_uchar *source; | |
| 343 int32_t bufSize; | |
| 344 int32_t maxIteration; | |
| 345 long events; | |
| 346 }; | |
| 347 | |
| 348 // Note: maxIteration = -1 -> repeat until the end of collation key | |
| 349 NextSortKeyPart::NextSortKeyPart(const UCollator* coll, const CA_uchar* source,
int32_t bufSize, int32_t maxIteration /* = -1 */) | |
| 350 : coll(coll), | |
| 351 source(source), | |
| 352 bufSize(bufSize), | |
| 353 maxIteration(maxIteration), | |
| 354 events(0) | |
| 355 { | |
| 356 } | |
| 357 | |
| 358 NextSortKeyPart::~NextSortKeyPart() | |
| 359 { | |
| 360 } | |
| 361 | |
| 362 void NextSortKeyPart::call(UErrorCode* status) | |
| 363 { | |
| 364 if (U_FAILURE(*status)) return; | |
| 365 | |
| 366 uint8_t *part = (uint8_t *)malloc(bufSize); | |
| 367 uint32_t state[2]; | |
| 368 UCharIterator iter; | |
| 369 | |
| 370 events = 0; | |
| 371 for (int i = 0; i < source->count && U_SUCCESS(*status); i++) { | |
| 372 uiter_setString(&iter, source->dataOf(i), source->lengthOf(i)); | |
| 373 state[0] = 0; | |
| 374 state[1] = 0; | |
| 375 int32_t partLen = bufSize; | |
| 376 for (int32_t n = 0; U_SUCCESS(*status) && partLen == bufSize && (maxIter
ation < 0 || n < maxIteration); n++) { | |
| 377 partLen = ucol_nextSortKeyPart(coll, &iter, state, part, bufSize, st
atus); | |
| 378 events++; | |
| 379 } | |
| 380 } | |
| 381 free(part); | |
| 382 } | |
| 383 | |
| 384 long NextSortKeyPart::getOperationsPerIteration() | |
| 385 { | |
| 386 return source->count; | |
| 387 } | |
| 388 | |
| 389 long NextSortKeyPart::getEventsPerIteration() | |
| 390 { | |
| 391 return events; | |
| 392 } | |
| 393 | |
| 394 // | |
| 395 // Test case taking a single test data array in UTF-8, calling ucol_nextSortKeyP
art for each for the | |
| 396 // given buffer size | |
| 397 // | |
| 398 class NextSortKeyPartUTF8 : public UPerfFunction | |
| 399 { | |
| 400 public: | |
| 401 NextSortKeyPartUTF8(const UCollator* coll, const CA_char* source, int32_t bu
fSize, int32_t maxIteration = -1); | |
| 402 ~NextSortKeyPartUTF8(); | |
| 403 virtual void call(UErrorCode* status); | |
| 404 virtual long getOperationsPerIteration(); | |
| 405 virtual long getEventsPerIteration(); | |
| 406 | |
| 407 private: | |
| 408 const UCollator *coll; | |
| 409 const CA_char *source; | |
| 410 int32_t bufSize; | |
| 411 int32_t maxIteration; | |
| 412 long events; | |
| 413 }; | |
| 414 | |
| 415 // Note: maxIteration = -1 -> repeat until the end of collation key | |
| 416 NextSortKeyPartUTF8::NextSortKeyPartUTF8(const UCollator* coll, const CA_char* s
ource, int32_t bufSize, int32_t maxIteration /* = -1 */) | |
| 417 : coll(coll), | |
| 418 source(source), | |
| 419 bufSize(bufSize), | |
| 420 maxIteration(maxIteration), | |
| 421 events(0) | |
| 422 { | |
| 423 } | |
| 424 | |
| 425 NextSortKeyPartUTF8::~NextSortKeyPartUTF8() | |
| 426 { | |
| 427 } | |
| 428 | |
| 429 void NextSortKeyPartUTF8::call(UErrorCode* status) | |
| 430 { | |
| 431 if (U_FAILURE(*status)) return; | |
| 432 | |
| 433 uint8_t *part = (uint8_t *)malloc(bufSize); | |
| 434 uint32_t state[2]; | |
| 435 UCharIterator iter; | |
| 436 | |
| 437 events = 0; | |
| 438 for (int i = 0; i < source->count && U_SUCCESS(*status); i++) { | |
| 439 uiter_setUTF8(&iter, source->dataOf(i), source->lengthOf(i)); | |
| 440 state[0] = 0; | |
| 441 state[1] = 0; | |
| 442 int32_t partLen = bufSize; | |
| 443 for (int32_t n = 0; U_SUCCESS(*status) && partLen == bufSize && (maxIter
ation < 0 || n < maxIteration); n++) { | |
| 444 partLen = ucol_nextSortKeyPart(coll, &iter, state, part, bufSize, st
atus); | |
| 445 events++; | |
| 446 } | |
| 447 } | |
| 448 free(part); | |
| 449 } | |
| 450 | |
| 451 long NextSortKeyPartUTF8::getOperationsPerIteration() | |
| 452 { | |
| 453 return source->count; | |
| 454 } | |
| 455 | |
| 456 long NextSortKeyPartUTF8::getEventsPerIteration() | |
| 457 { | |
| 458 return events; | |
| 459 } | |
| 460 | |
| 461 // CPP API test cases | |
| 462 | |
| 463 // | |
| 464 // Test case taking a single test data array, calling Collator::compare by permu
ting the test data | |
| 465 // | |
| 466 class CppCompare : public UPerfFunction | |
| 467 { | |
| 468 public: | |
| 469 CppCompare(const Collator* coll, const CA_uchar* source, UBool useLen); | |
| 470 ~CppCompare(); | |
| 471 virtual void call(UErrorCode* status); | |
| 472 virtual long getOperationsPerIteration(); | |
| 473 | |
| 474 private: | |
| 475 const Collator *coll; | |
| 476 const CA_uchar *source; | |
| 477 UBool useLen; | |
| 478 int32_t maxTestStrings; | |
| 479 }; | |
| 480 | |
| 481 CppCompare::CppCompare(const Collator* coll, const CA_uchar* source, UBool useLe
n) | |
| 482 : coll(coll), | |
| 483 source(source), | |
| 484 useLen(useLen) | |
| 485 { | |
| 486 maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_S
TRINGS_FOR_PERMUTING : source->count; | |
| 487 } | |
| 488 | |
| 489 CppCompare::~CppCompare() | |
| 490 { | |
| 491 } | |
| 492 | |
| 493 void CppCompare::call(UErrorCode* status) { | |
| 494 if (U_FAILURE(*status)) return; | |
| 495 | |
| 496 // call compare for permutation of test data | |
| 497 int32_t divisor = source->count / maxTestStrings; | |
| 498 int32_t srcLen, tgtLen; | |
| 499 int32_t cmp = 0; | |
| 500 for (int32_t i = 0, numTestStringsI = 0; i < source->count && numTestStrings
I < maxTestStrings; i++) { | |
| 501 if (i % divisor) continue; | |
| 502 numTestStringsI++; | |
| 503 srcLen = useLen ? source->lengthOf(i) : -1; | |
| 504 for (int32_t j = 0, numTestStringsJ = 0; j < source->count && numTestStr
ingsJ < maxTestStrings; j++) { | |
| 505 if (j % divisor) continue; | |
| 506 numTestStringsJ++; | |
| 507 tgtLen = useLen ? source->lengthOf(j) : -1; | |
| 508 cmp += coll->compare(source->dataOf(i), srcLen, source->dataOf(j), t
gtLen); | |
| 509 } | |
| 510 } | |
| 511 // At the end, cmp must be 0 | |
| 512 if (cmp != 0) { | |
| 513 *status = U_INTERNAL_PROGRAM_ERROR; | |
| 514 } | |
| 515 } | |
| 516 | |
| 517 long CppCompare::getOperationsPerIteration() | |
| 518 { | |
| 519 return maxTestStrings * maxTestStrings; | |
| 520 } | |
| 521 | |
| 522 // | |
| 523 // Test case taking two test data arrays, calling Collator::compare for strings
at a same index | |
| 524 // | |
| 525 class CppCompare_2 : public UPerfFunction | |
| 526 { | |
| 527 public: | |
| 528 CppCompare_2(const Collator* coll, const CA_uchar* source, const CA_uchar* t
arget, UBool useLen); | |
| 529 ~CppCompare_2(); | |
| 530 virtual void call(UErrorCode* status); | |
| 531 virtual long getOperationsPerIteration(); | |
| 532 | |
| 533 private: | |
| 534 const Collator *coll; | |
| 535 const CA_uchar *source; | |
| 536 const CA_uchar *target; | |
| 537 UBool useLen; | |
| 538 }; | |
| 539 | |
| 540 CppCompare_2::CppCompare_2(const Collator* coll, const CA_uchar* source, const C
A_uchar* target, UBool useLen) | |
| 541 : coll(coll), | |
| 542 source(source), | |
| 543 target(target), | |
| 544 useLen(useLen) | |
| 545 { | |
| 546 } | |
| 547 | |
| 548 CppCompare_2::~CppCompare_2() | |
| 549 { | |
| 550 } | |
| 551 | |
| 552 void CppCompare_2::call(UErrorCode* status) { | |
| 553 if (U_FAILURE(*status)) return; | |
| 554 | |
| 555 // call strcoll for two strings at the same index | |
| 556 if (source->count < target->count) { | |
| 557 *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| 558 } else { | |
| 559 for (int32_t i = 0; i < source->count; i++) { | |
| 560 int32_t srcLen = useLen ? source->lengthOf(i) : -1; | |
| 561 int32_t tgtLen = useLen ? target->lengthOf(i) : -1; | |
| 562 coll->compare(source->dataOf(i), srcLen, target->dataOf(i), tgtLen); | |
| 563 } | |
| 564 } | |
| 565 } | |
| 566 | |
| 567 long CppCompare_2::getOperationsPerIteration() | |
| 568 { | |
| 569 return source->count; | |
| 570 } | |
| 571 | |
| 572 | |
| 573 // | |
| 574 // Test case taking a single test data array, calling Collator::compareUTF8 by p
ermuting the test data | |
| 575 // | |
| 576 class CppCompareUTF8 : public UPerfFunction | |
| 577 { | |
| 578 public: | |
| 579 CppCompareUTF8(const Collator* coll, const CA_char* source, UBool useLen); | |
| 580 ~CppCompareUTF8(); | |
| 581 virtual void call(UErrorCode* status); | |
| 582 virtual long getOperationsPerIteration(); | |
| 583 | |
| 584 private: | |
| 585 const Collator *coll; | |
| 586 const CA_char *source; | |
| 587 UBool useLen; | |
| 588 int32_t maxTestStrings; | |
| 589 }; | |
| 590 | |
| 591 CppCompareUTF8::CppCompareUTF8(const Collator* coll, const CA_char* source, UBoo
l useLen) | |
| 592 : coll(coll), | |
| 593 source(source), | |
| 594 useLen(useLen) | |
| 595 { | |
| 596 maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_S
TRINGS_FOR_PERMUTING : source->count; | |
| 597 } | |
| 598 | |
| 599 CppCompareUTF8::~CppCompareUTF8() | |
| 600 { | |
| 601 } | |
| 602 | |
| 603 void CppCompareUTF8::call(UErrorCode* status) { | |
| 604 if (U_FAILURE(*status)) return; | |
| 605 | |
| 606 // call compareUTF8 for all permutations | |
| 607 int32_t divisor = source->count / maxTestStrings; | |
| 608 StringPiece src, tgt; | |
| 609 int32_t cmp = 0; | |
| 610 for (int32_t i = 0, numTestStringsI = 0; U_SUCCESS(*status) && i < source->c
ount && numTestStringsI < maxTestStrings; i++) { | |
| 611 if (i % divisor) continue; | |
| 612 numTestStringsI++; | |
| 613 | |
| 614 if (useLen) { | |
| 615 src.set(source->dataOf(i), source->lengthOf(i)); | |
| 616 } else { | |
| 617 src.set(source->dataOf(i)); | |
| 618 } | |
| 619 for (int32_t j = 0, numTestStringsJ = 0; U_SUCCESS(*status) && j < sourc
e->count && numTestStringsJ < maxTestStrings; j++) { | |
| 620 if (j % divisor) continue; | |
| 621 numTestStringsJ++; | |
| 622 | |
| 623 if (useLen) { | |
| 624 tgt.set(source->dataOf(i), source->lengthOf(i)); | |
| 625 } else { | |
| 626 tgt.set(source->dataOf(i)); | |
| 627 } | |
| 628 cmp += coll->compareUTF8(src, tgt, *status); | |
| 629 } | |
| 630 } | |
| 631 // At the end, cmp must be 0 | |
| 632 if (cmp != 0) { | |
| 633 *status = U_INTERNAL_PROGRAM_ERROR; | |
| 634 } | |
| 635 } | |
| 636 | |
| 637 long CppCompareUTF8::getOperationsPerIteration() | |
| 638 { | |
| 639 return maxTestStrings * maxTestStrings; | |
| 640 } | |
| 641 | |
| 642 | |
| 643 // | |
| 644 // Test case taking two test data arrays, calling Collator::compareUTF8 for stri
ngs at a same index | |
| 645 // | |
| 646 class CppCompareUTF8_2 : public UPerfFunction | |
| 647 { | |
| 648 public: | |
| 649 CppCompareUTF8_2(const Collator* coll, const CA_char* source, const CA_char*
target, UBool useLen); | |
| 650 ~CppCompareUTF8_2(); | |
| 651 virtual void call(UErrorCode* status); | |
| 652 virtual long getOperationsPerIteration(); | |
| 653 | |
| 654 private: | |
| 655 const Collator *coll; | |
| 656 const CA_char *source; | |
| 657 const CA_char *target; | |
| 658 UBool useLen; | |
| 659 }; | |
| 660 | |
| 661 CppCompareUTF8_2::CppCompareUTF8_2(const Collator* coll, const CA_char* source,
const CA_char* target, UBool useLen) | |
| 662 : coll(coll), | |
| 663 source(source), | |
| 664 target(target), | |
| 665 useLen(useLen) | |
| 666 { | |
| 667 } | |
| 668 | |
| 669 CppCompareUTF8_2::~CppCompareUTF8_2() | |
| 670 { | |
| 671 } | |
| 672 | |
| 673 void CppCompareUTF8_2::call(UErrorCode* status) { | |
| 674 if (U_FAILURE(*status)) return; | |
| 675 | |
| 676 // call strcoll for two strings at the same index | |
| 677 StringPiece src, tgt; | |
| 678 if (source->count < target->count) { | |
| 679 *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| 680 } else { | |
| 681 for (int32_t i = 0; U_SUCCESS(*status) && i < source->count; i++) { | |
| 682 if (useLen) { | |
| 683 src.set(source->dataOf(i), source->lengthOf(i)); | |
| 684 tgt.set(target->dataOf(i), target->lengthOf(i)); | |
| 685 } else { | |
| 686 src.set(source->dataOf(i)); | |
| 687 tgt.set(target->dataOf(i)); | |
| 688 } | |
| 689 coll->compareUTF8(src, tgt, *status); | |
| 690 } | |
| 691 } | |
| 692 } | |
| 693 | |
| 694 long CppCompareUTF8_2::getOperationsPerIteration() | |
| 695 { | |
| 696 return source->count; | |
| 697 } | |
| 698 | |
| 699 | |
| 700 // | |
| 701 // Test case taking a single test data array, calling Collator::getCollationKey
for each | |
| 702 // | |
| 703 class CppGetCollationKey : public UPerfFunction | |
| 704 { | |
| 705 public: | |
| 706 CppGetCollationKey(const Collator* coll, const CA_uchar* source, UBool useLe
n); | |
| 707 ~CppGetCollationKey(); | |
| 708 virtual void call(UErrorCode* status); | |
| 709 virtual long getOperationsPerIteration(); | |
| 710 | |
| 711 private: | |
| 712 const Collator *coll; | |
| 713 const CA_uchar *source; | |
| 714 UBool useLen; | |
| 715 }; | |
| 716 | |
| 717 CppGetCollationKey::CppGetCollationKey(const Collator* coll, const CA_uchar* sou
rce, UBool useLen) | |
| 718 : coll(coll), | |
| 719 source(source), | |
| 720 useLen(useLen) | |
| 721 { | |
| 722 } | |
| 723 | |
| 724 CppGetCollationKey::~CppGetCollationKey() | |
| 725 { | |
| 726 } | |
| 727 | |
| 728 void CppGetCollationKey::call(UErrorCode* status) | |
| 729 { | |
| 730 if (U_FAILURE(*status)) return; | |
| 731 | |
| 732 CollationKey key; | |
| 733 for (int32_t i = 0; U_SUCCESS(*status) && i < source->count; i++) { | |
| 734 coll->getCollationKey(source->dataOf(i), source->lengthOf(i), key, *stat
us); | |
| 735 } | |
| 736 } | |
| 737 | |
| 738 long CppGetCollationKey::getOperationsPerIteration() { | |
| 739 return source->count; | |
| 740 } | |
| 741 | |
| 742 namespace { | |
| 743 | |
| 744 struct CollatorAndCounter { | |
| 745 CollatorAndCounter(const Collator& coll) : coll(coll), ucoll(NULL), counter(
0) {} | |
| 746 CollatorAndCounter(const Collator& coll, const UCollator *ucoll) | |
| 747 : coll(coll), ucoll(ucoll), counter(0) {} | |
| 748 const Collator& coll; | |
| 749 const UCollator *ucoll; | |
| 750 int32_t counter; | |
| 751 }; | |
| 752 | |
| 753 int32_t U_CALLCONV | |
| 754 UniStrCollatorComparator(const void* context, const void* left, const void* righ
t) { | |
| 755 CollatorAndCounter& cc = *(CollatorAndCounter*)context; | |
| 756 const UnicodeString& leftString = **(const UnicodeString**)left; | |
| 757 const UnicodeString& rightString = **(const UnicodeString**)right; | |
| 758 UErrorCode errorCode = U_ZERO_ERROR; | |
| 759 ++cc.counter; | |
| 760 return cc.coll.compare(leftString, rightString, errorCode); | |
| 761 } | |
| 762 | |
| 763 } // namespace | |
| 764 | |
| 765 class CollPerfFunction : public UPerfFunction { | |
| 766 public: | |
| 767 CollPerfFunction(const Collator& coll, const UCollator *ucoll) | |
| 768 : coll(coll), ucoll(ucoll), ops(0) {} | |
| 769 virtual ~CollPerfFunction(); | |
| 770 /** Calls call() to set the ops field, and returns that. */ | |
| 771 virtual long getOperationsPerIteration(); | |
| 772 | |
| 773 protected: | |
| 774 const Collator& coll; | |
| 775 const UCollator *ucoll; | |
| 776 int32_t ops; | |
| 777 }; | |
| 778 | |
| 779 CollPerfFunction::~CollPerfFunction() {} | |
| 780 | |
| 781 long CollPerfFunction::getOperationsPerIteration() { | |
| 782 UErrorCode errorCode = U_ZERO_ERROR; | |
| 783 call(&errorCode); | |
| 784 return U_SUCCESS(errorCode) ? ops : 0; | |
| 785 } | |
| 786 | |
| 787 class UniStrCollPerfFunction : public CollPerfFunction { | |
| 788 public: | |
| 789 UniStrCollPerfFunction(const Collator& coll, const UCollator *ucoll, const C
A_uchar* data16) | |
| 790 : CollPerfFunction(coll, ucoll), d16(data16), | |
| 791 source(new UnicodeString*[d16->count]) { | |
| 792 for (int32_t i = 0; i < d16->count; ++i) { | |
| 793 source[i] = new UnicodeString(TRUE, d16->dataOf(i), d16->lengthOf(i)
); | |
| 794 } | |
| 795 } | |
| 796 virtual ~UniStrCollPerfFunction(); | |
| 797 | |
| 798 protected: | |
| 799 const CA_uchar* d16; | |
| 800 UnicodeString** source; | |
| 801 }; | |
| 802 | |
| 803 UniStrCollPerfFunction::~UniStrCollPerfFunction() { | |
| 804 for (int32_t i = 0; i < d16->count; ++i) { | |
| 805 delete source[i]; | |
| 806 } | |
| 807 delete[] source; | |
| 808 } | |
| 809 | |
| 810 // | |
| 811 // Test case sorting an array of UnicodeString pointers. | |
| 812 // | |
| 813 class UniStrSort : public UniStrCollPerfFunction { | |
| 814 public: | |
| 815 UniStrSort(const Collator& coll, const UCollator *ucoll, const CA_uchar* dat
a16) | |
| 816 : UniStrCollPerfFunction(coll, ucoll, data16), | |
| 817 dest(new UnicodeString*[d16->count]) {} | |
| 818 virtual ~UniStrSort(); | |
| 819 virtual void call(UErrorCode* status); | |
| 820 | |
| 821 private: | |
| 822 UnicodeString** dest; // aliases only | |
| 823 }; | |
| 824 | |
| 825 UniStrSort::~UniStrSort() { | |
| 826 delete[] dest; | |
| 827 } | |
| 828 | |
| 829 void UniStrSort::call(UErrorCode* status) { | |
| 830 if (U_FAILURE(*status)) return; | |
| 831 | |
| 832 CollatorAndCounter cc(coll); | |
| 833 int32_t count = d16->count; | |
| 834 memcpy(dest, source, count * sizeof(UnicodeString *)); | |
| 835 uprv_sortArray(dest, count, (int32_t)sizeof(UnicodeString *), | |
| 836 UniStrCollatorComparator, &cc, TRUE, status); | |
| 837 ops = cc.counter; | |
| 838 } | |
| 839 | |
| 840 namespace { | |
| 841 | |
| 842 int32_t U_CALLCONV | |
| 843 StringPieceCollatorComparator(const void* context, const void* left, const void*
right) { | |
| 844 CollatorAndCounter& cc = *(CollatorAndCounter*)context; | |
| 845 const StringPiece& leftString = *(const StringPiece*)left; | |
| 846 const StringPiece& rightString = *(const StringPiece*)right; | |
| 847 UErrorCode errorCode = U_ZERO_ERROR; | |
| 848 ++cc.counter; | |
| 849 return cc.coll.compareUTF8(leftString, rightString, errorCode); | |
| 850 } | |
| 851 | |
| 852 int32_t U_CALLCONV | |
| 853 StringPieceUCollatorComparator(const void* context, const void* left, const void
* right) { | |
| 854 CollatorAndCounter& cc = *(CollatorAndCounter*)context; | |
| 855 const StringPiece& leftString = *(const StringPiece*)left; | |
| 856 const StringPiece& rightString = *(const StringPiece*)right; | |
| 857 UErrorCode errorCode = U_ZERO_ERROR; | |
| 858 ++cc.counter; | |
| 859 return ucol_strcollUTF8(cc.ucoll, | |
| 860 leftString.data(), leftString.length(), | |
| 861 rightString.data(), rightString.length(), &errorCode
); | |
| 862 } | |
| 863 | |
| 864 } // namespace | |
| 865 | |
| 866 class StringPieceCollPerfFunction : public CollPerfFunction { | |
| 867 public: | |
| 868 StringPieceCollPerfFunction(const Collator& coll, const UCollator *ucoll, co
nst CA_char* data8) | |
| 869 : CollPerfFunction(coll, ucoll), d8(data8), | |
| 870 source(new StringPiece[d8->count]) { | |
| 871 for (int32_t i = 0; i < d8->count; ++i) { | |
| 872 source[i].set(d8->dataOf(i), d8->lengthOf(i)); | |
| 873 } | |
| 874 } | |
| 875 virtual ~StringPieceCollPerfFunction(); | |
| 876 | |
| 877 protected: | |
| 878 const CA_char* d8; | |
| 879 StringPiece* source; | |
| 880 }; | |
| 881 | |
| 882 StringPieceCollPerfFunction::~StringPieceCollPerfFunction() { | |
| 883 delete[] source; | |
| 884 } | |
| 885 | |
| 886 class StringPieceSort : public StringPieceCollPerfFunction { | |
| 887 public: | |
| 888 StringPieceSort(const Collator& coll, const UCollator *ucoll, const CA_char*
data8) | |
| 889 : StringPieceCollPerfFunction(coll, ucoll, data8), | |
| 890 dest(new StringPiece[d8->count]) {} | |
| 891 virtual ~StringPieceSort(); | |
| 892 | |
| 893 protected: | |
| 894 StringPiece* dest; | |
| 895 }; | |
| 896 | |
| 897 StringPieceSort::~StringPieceSort() { | |
| 898 delete[] dest; | |
| 899 } | |
| 900 | |
| 901 // | |
| 902 // Test case sorting an array of UTF-8 StringPiece's with Collator::compareUTF8(
). | |
| 903 // | |
| 904 class StringPieceSortCpp : public StringPieceSort { | |
| 905 public: | |
| 906 StringPieceSortCpp(const Collator& coll, const UCollator *ucoll, const CA_ch
ar* data8) | |
| 907 : StringPieceSort(coll, ucoll, data8) {} | |
| 908 virtual ~StringPieceSortCpp(); | |
| 909 virtual void call(UErrorCode* status); | |
| 910 }; | |
| 911 | |
| 912 StringPieceSortCpp::~StringPieceSortCpp() {} | |
| 913 | |
| 914 void StringPieceSortCpp::call(UErrorCode* status) { | |
| 915 if (U_FAILURE(*status)) return; | |
| 916 | |
| 917 CollatorAndCounter cc(coll); | |
| 918 int32_t count = d8->count; | |
| 919 memcpy(dest, source, count * sizeof(StringPiece)); | |
| 920 uprv_sortArray(dest, count, (int32_t)sizeof(StringPiece), | |
| 921 StringPieceCollatorComparator, &cc, TRUE, status); | |
| 922 ops = cc.counter; | |
| 923 } | |
| 924 | |
| 925 // | |
| 926 // Test case sorting an array of UTF-8 StringPiece's with ucol_strcollUTF8(). | |
| 927 // | |
| 928 class StringPieceSortC : public StringPieceSort { | |
| 929 public: | |
| 930 StringPieceSortC(const Collator& coll, const UCollator *ucoll, const CA_char
* data8) | |
| 931 : StringPieceSort(coll, ucoll, data8) {} | |
| 932 virtual ~StringPieceSortC(); | |
| 933 virtual void call(UErrorCode* status); | |
| 934 }; | |
| 935 | |
| 936 StringPieceSortC::~StringPieceSortC() {} | |
| 937 | |
| 938 void StringPieceSortC::call(UErrorCode* status) { | |
| 939 if (U_FAILURE(*status)) return; | |
| 940 | |
| 941 CollatorAndCounter cc(coll, ucoll); | |
| 942 int32_t count = d8->count; | |
| 943 memcpy(dest, source, count * sizeof(StringPiece)); | |
| 944 uprv_sortArray(dest, count, (int32_t)sizeof(StringPiece), | |
| 945 StringPieceUCollatorComparator, &cc, TRUE, status); | |
| 946 ops = cc.counter; | |
| 947 } | |
| 948 | |
| 949 // | |
| 950 // Test case performing binary searches in a sorted array of UnicodeString point
ers. | |
| 951 // | |
| 952 class UniStrBinSearch : public UniStrCollPerfFunction { | |
| 953 public: | |
| 954 UniStrBinSearch(const Collator& coll, const UCollator *ucoll, const CA_uchar
* data16) | |
| 955 : UniStrCollPerfFunction(coll, ucoll, data16) {} | |
| 956 virtual ~UniStrBinSearch(); | |
| 957 virtual void call(UErrorCode* status); | |
| 958 }; | |
| 959 | |
| 960 UniStrBinSearch::~UniStrBinSearch() {} | |
| 961 | |
| 962 void UniStrBinSearch::call(UErrorCode* status) { | |
| 963 if (U_FAILURE(*status)) return; | |
| 964 | |
| 965 CollatorAndCounter cc(coll); | |
| 966 int32_t count = d16->count; | |
| 967 for (int32_t i = 0; i < count; ++i) { | |
| 968 (void)uprv_stableBinarySearch((char *)source, count, | |
| 969 source + i, (int32_t)sizeof(UnicodeString
*), | |
| 970 UniStrCollatorComparator, &cc); | |
| 971 } | |
| 972 ops = cc.counter; | |
| 973 } | |
| 974 | |
| 975 class StringPieceBinSearch : public StringPieceCollPerfFunction { | |
| 976 public: | |
| 977 StringPieceBinSearch(const Collator& coll, const UCollator *ucoll, const CA_
char* data8) | |
| 978 : StringPieceCollPerfFunction(coll, ucoll, data8) {} | |
| 979 virtual ~StringPieceBinSearch(); | |
| 980 }; | |
| 981 | |
| 982 StringPieceBinSearch::~StringPieceBinSearch() {} | |
| 983 | |
| 984 // | |
| 985 // Test case performing binary searches in a sorted array of UTF-8 StringPiece's | |
| 986 // with Collator::compareUTF8(). | |
| 987 // | |
| 988 class StringPieceBinSearchCpp : public StringPieceBinSearch { | |
| 989 public: | |
| 990 StringPieceBinSearchCpp(const Collator& coll, const UCollator *ucoll, const
CA_char* data8) | |
| 991 : StringPieceBinSearch(coll, ucoll, data8) {} | |
| 992 virtual ~StringPieceBinSearchCpp(); | |
| 993 virtual void call(UErrorCode* status); | |
| 994 }; | |
| 995 | |
| 996 StringPieceBinSearchCpp::~StringPieceBinSearchCpp() {} | |
| 997 | |
| 998 void StringPieceBinSearchCpp::call(UErrorCode* status) { | |
| 999 if (U_FAILURE(*status)) return; | |
| 1000 | |
| 1001 CollatorAndCounter cc(coll); | |
| 1002 int32_t count = d8->count; | |
| 1003 for (int32_t i = 0; i < count; ++i) { | |
| 1004 (void)uprv_stableBinarySearch((char *)source, count, | |
| 1005 source + i, (int32_t)sizeof(StringPiece), | |
| 1006 StringPieceCollatorComparator, &cc); | |
| 1007 } | |
| 1008 ops = cc.counter; | |
| 1009 } | |
| 1010 | |
| 1011 // | |
| 1012 // Test case performing binary searches in a sorted array of UTF-8 StringPiece's | |
| 1013 // with ucol_strcollUTF8(). | |
| 1014 // | |
| 1015 class StringPieceBinSearchC : public StringPieceBinSearch { | |
| 1016 public: | |
| 1017 StringPieceBinSearchC(const Collator& coll, const UCollator *ucoll, const CA
_char* data8) | |
| 1018 : StringPieceBinSearch(coll, ucoll, data8) {} | |
| 1019 virtual ~StringPieceBinSearchC(); | |
| 1020 virtual void call(UErrorCode* status); | |
| 1021 }; | |
| 1022 | |
| 1023 StringPieceBinSearchC::~StringPieceBinSearchC() {} | |
| 1024 | |
| 1025 void StringPieceBinSearchC::call(UErrorCode* status) { | |
| 1026 if (U_FAILURE(*status)) return; | |
| 1027 | |
| 1028 CollatorAndCounter cc(coll, ucoll); | |
| 1029 int32_t count = d8->count; | |
| 1030 for (int32_t i = 0; i < count; ++i) { | |
| 1031 (void)uprv_stableBinarySearch((char *)source, count, | |
| 1032 source + i, (int32_t)sizeof(StringPiece), | |
| 1033 StringPieceUCollatorComparator, &cc); | |
| 1034 } | |
| 1035 ops = cc.counter; | |
| 1036 } | |
| 1037 | |
| 1038 | |
| 1039 class CollPerf2Test : public UPerfTest | |
| 1040 { | |
| 1041 public: | |
| 1042 CollPerf2Test(int32_t argc, const char *argv[], UErrorCode &status); | |
| 1043 ~CollPerf2Test(); | |
| 1044 virtual UPerfFunction* runIndexedTest( | |
| 1045 int32_t index, UBool exec, const char *&name, char *par = NULL); | |
| 1046 | |
| 1047 private: | |
| 1048 UCollator* coll; | |
| 1049 Collator* collObj; | |
| 1050 | |
| 1051 int32_t count; | |
| 1052 CA_uchar* data16; | |
| 1053 CA_char* data8; | |
| 1054 | |
| 1055 CA_uchar* modData16; | |
| 1056 CA_char* modData8; | |
| 1057 | |
| 1058 CA_uchar* sortedData16; | |
| 1059 CA_char* sortedData8; | |
| 1060 | |
| 1061 CA_uchar* randomData16; | |
| 1062 CA_char* randomData8; | |
| 1063 | |
| 1064 const CA_uchar* getData16(UErrorCode &status); | |
| 1065 const CA_char* getData8(UErrorCode &status); | |
| 1066 | |
| 1067 const CA_uchar* getModData16(UErrorCode &status); | |
| 1068 const CA_char* getModData8(UErrorCode &status); | |
| 1069 | |
| 1070 const CA_uchar* getSortedData16(UErrorCode &status); | |
| 1071 const CA_char* getSortedData8(UErrorCode &status); | |
| 1072 | |
| 1073 const CA_uchar* getRandomData16(UErrorCode &status); | |
| 1074 const CA_char* getRandomData8(UErrorCode &status); | |
| 1075 | |
| 1076 static CA_uchar* sortData16( | |
| 1077 const CA_uchar* d16, | |
| 1078 UComparator *cmp, const void *context, | |
| 1079 UErrorCode &status); | |
| 1080 static CA_char* getData8FromData16(const CA_uchar* d16, UErrorCode &status); | |
| 1081 | |
| 1082 UPerfFunction* TestStrcoll(); | |
| 1083 UPerfFunction* TestStrcollNull(); | |
| 1084 UPerfFunction* TestStrcollSimilar(); | |
| 1085 | |
| 1086 UPerfFunction* TestStrcollUTF8(); | |
| 1087 UPerfFunction* TestStrcollUTF8Null(); | |
| 1088 UPerfFunction* TestStrcollUTF8Similar(); | |
| 1089 | |
| 1090 UPerfFunction* TestGetSortKey(); | |
| 1091 UPerfFunction* TestGetSortKeyNull(); | |
| 1092 | |
| 1093 UPerfFunction* TestNextSortKeyPart_4All(); | |
| 1094 UPerfFunction* TestNextSortKeyPart_4x2(); | |
| 1095 UPerfFunction* TestNextSortKeyPart_4x4(); | |
| 1096 UPerfFunction* TestNextSortKeyPart_4x8(); | |
| 1097 UPerfFunction* TestNextSortKeyPart_32All(); | |
| 1098 UPerfFunction* TestNextSortKeyPart_32x2(); | |
| 1099 | |
| 1100 UPerfFunction* TestNextSortKeyPartUTF8_4All(); | |
| 1101 UPerfFunction* TestNextSortKeyPartUTF8_4x2(); | |
| 1102 UPerfFunction* TestNextSortKeyPartUTF8_4x4(); | |
| 1103 UPerfFunction* TestNextSortKeyPartUTF8_4x8(); | |
| 1104 UPerfFunction* TestNextSortKeyPartUTF8_32All(); | |
| 1105 UPerfFunction* TestNextSortKeyPartUTF8_32x2(); | |
| 1106 | |
| 1107 UPerfFunction* TestCppCompare(); | |
| 1108 UPerfFunction* TestCppCompareNull(); | |
| 1109 UPerfFunction* TestCppCompareSimilar(); | |
| 1110 | |
| 1111 UPerfFunction* TestCppCompareUTF8(); | |
| 1112 UPerfFunction* TestCppCompareUTF8Null(); | |
| 1113 UPerfFunction* TestCppCompareUTF8Similar(); | |
| 1114 | |
| 1115 UPerfFunction* TestCppGetCollationKey(); | |
| 1116 UPerfFunction* TestCppGetCollationKeyNull(); | |
| 1117 | |
| 1118 UPerfFunction* TestUniStrSort(); | |
| 1119 UPerfFunction* TestStringPieceSortCpp(); | |
| 1120 UPerfFunction* TestStringPieceSortC(); | |
| 1121 | |
| 1122 UPerfFunction* TestUniStrBinSearch(); | |
| 1123 UPerfFunction* TestStringPieceBinSearchCpp(); | |
| 1124 UPerfFunction* TestStringPieceBinSearchC(); | |
| 1125 }; | |
| 1126 | |
| 1127 CollPerf2Test::CollPerf2Test(int32_t argc, const char *argv[], UErrorCode &statu
s) : | |
| 1128 UPerfTest(argc, argv, status), | |
| 1129 coll(NULL), | |
| 1130 collObj(NULL), | |
| 1131 count(0), | |
| 1132 data16(NULL), | |
| 1133 data8(NULL), | |
| 1134 modData16(NULL), | |
| 1135 modData8(NULL), | |
| 1136 sortedData16(NULL), | |
| 1137 sortedData8(NULL), | |
| 1138 randomData16(NULL), | |
| 1139 randomData8(NULL) | |
| 1140 { | |
| 1141 if (U_FAILURE(status)) { | |
| 1142 return; | |
| 1143 } | |
| 1144 | |
| 1145 if (locale == NULL){ | |
| 1146 locale = "root"; | |
| 1147 } | |
| 1148 | |
| 1149 // Set up an ICU collator. | |
| 1150 // Starting with ICU 54 (ticket #8260), this supports standard collation loc
ale keywords. | |
| 1151 coll = ucol_open(locale, &status); | |
| 1152 collObj = Collator::createInstance(locale, status); | |
| 1153 } | |
| 1154 | |
| 1155 CollPerf2Test::~CollPerf2Test() | |
| 1156 { | |
| 1157 ucol_close(coll); | |
| 1158 delete collObj; | |
| 1159 | |
| 1160 delete data16; | |
| 1161 delete data8; | |
| 1162 delete modData16; | |
| 1163 delete modData8; | |
| 1164 delete sortedData16; | |
| 1165 delete sortedData8; | |
| 1166 delete randomData16; | |
| 1167 delete randomData8; | |
| 1168 } | |
| 1169 | |
| 1170 #define MAX_NUM_DATA 10000 | |
| 1171 | |
| 1172 const CA_uchar* CollPerf2Test::getData16(UErrorCode &status) | |
| 1173 { | |
| 1174 if (U_FAILURE(status)) return NULL; | |
| 1175 if (data16) return data16; | |
| 1176 | |
| 1177 CA_uchar* d16 = new CA_uchar(); | |
| 1178 const UChar *line = NULL; | |
| 1179 int32_t len = 0; | |
| 1180 int32_t numData = 0; | |
| 1181 | |
| 1182 for (;;) { | |
| 1183 line = ucbuf_readline(ucharBuf, &len, &status); | |
| 1184 if (line == NULL || U_FAILURE(status)) break; | |
| 1185 | |
| 1186 // Refer to the source code of ucbuf_readline() | |
| 1187 // 1. 'len' includes the line terminal symbols | |
| 1188 // 2. The length of the line terminal symbols is only one character | |
| 1189 // 3. The Windows CR LF line terminal symbols will be converted to CR | |
| 1190 | |
| 1191 if (len == 1 || line[0] == 0x23 /* '#' */) { | |
| 1192 continue; // skip empty/comment line | |
| 1193 } else { | |
| 1194 d16->append_one(len); | |
| 1195 UChar *p = d16->last(); | |
| 1196 u_memcpy(p, line, len - 1); // exclude the CR | |
| 1197 p[len - 1] = 0; // NUL-terminate | |
| 1198 | |
| 1199 numData++; | |
| 1200 if (numData >= MAX_NUM_DATA) break; | |
| 1201 } | |
| 1202 } | |
| 1203 | |
| 1204 if (U_SUCCESS(status)) { | |
| 1205 data16 = d16; | |
| 1206 } else { | |
| 1207 delete d16; | |
| 1208 } | |
| 1209 | |
| 1210 return data16; | |
| 1211 } | |
| 1212 | |
| 1213 const CA_char* CollPerf2Test::getData8(UErrorCode &status) | |
| 1214 { | |
| 1215 if (U_FAILURE(status)) return NULL; | |
| 1216 if (data8) return data8; | |
| 1217 return data8 = getData8FromData16(getData16(status), status); | |
| 1218 } | |
| 1219 | |
| 1220 const CA_uchar* CollPerf2Test::getModData16(UErrorCode &status) | |
| 1221 { | |
| 1222 if (U_FAILURE(status)) return NULL; | |
| 1223 if (modData16) return modData16; | |
| 1224 | |
| 1225 const CA_uchar* d16 = getData16(status); | |
| 1226 if (U_FAILURE(status)) return NULL; | |
| 1227 | |
| 1228 CA_uchar* modData16 = new CA_uchar(); | |
| 1229 | |
| 1230 for (int32_t i = 0; i < d16->count; i++) { | |
| 1231 const UChar *s = d16->dataOf(i); | |
| 1232 int32_t len = d16->lengthOf(i) + 1; // including NULL terminator | |
| 1233 | |
| 1234 modData16->append_one(len); | |
| 1235 u_memcpy(modData16->last(), s, len); | |
| 1236 | |
| 1237 // replacing the last character with a different character | |
| 1238 UChar *lastChar = &modData16->last()[len -2]; | |
| 1239 for (int32_t j = i + 1; j != i; j++) { | |
| 1240 if (j >= d16->count) { | |
| 1241 j = 0; | |
| 1242 } | |
| 1243 const UChar *s1 = d16->dataOf(j); | |
| 1244 UChar lastChar1 = s1[d16->lengthOf(j) - 1]; | |
| 1245 if (*lastChar != lastChar1) { | |
| 1246 *lastChar = lastChar1; | |
| 1247 break; | |
| 1248 } | |
| 1249 } | |
| 1250 } | |
| 1251 | |
| 1252 return modData16; | |
| 1253 } | |
| 1254 | |
| 1255 const CA_char* CollPerf2Test::getModData8(UErrorCode &status) | |
| 1256 { | |
| 1257 if (U_FAILURE(status)) return NULL; | |
| 1258 if (modData8) return modData8; | |
| 1259 return modData8 = getData8FromData16(getModData16(status), status); | |
| 1260 } | |
| 1261 | |
| 1262 namespace { | |
| 1263 | |
| 1264 struct ArrayAndColl { | |
| 1265 ArrayAndColl(const CA_uchar* a, const Collator& c) : d16(a), coll(c) {} | |
| 1266 const CA_uchar* d16; | |
| 1267 const Collator& coll; | |
| 1268 }; | |
| 1269 | |
| 1270 int32_t U_CALLCONV | |
| 1271 U16CollatorComparator(const void* context, const void* left, const void* right)
{ | |
| 1272 const ArrayAndColl& ac = *(const ArrayAndColl*)context; | |
| 1273 const CA_uchar* d16 = ac.d16; | |
| 1274 int32_t leftIndex = *(const int32_t*)left; | |
| 1275 int32_t rightIndex = *(const int32_t*)right; | |
| 1276 UErrorCode errorCode = U_ZERO_ERROR; | |
| 1277 return ac.coll.compare(d16->dataOf(leftIndex), d16->lengthOf(leftIndex), | |
| 1278 d16->dataOf(rightIndex), d16->lengthOf(rightIndex), | |
| 1279 errorCode); | |
| 1280 } | |
| 1281 | |
| 1282 int32_t U_CALLCONV | |
| 1283 U16HashComparator(const void* context, const void* left, const void* right) { | |
| 1284 const CA_uchar* d16 = (const CA_uchar*)context; | |
| 1285 int32_t leftIndex = *(const int32_t*)left; | |
| 1286 int32_t rightIndex = *(const int32_t*)right; | |
| 1287 int32_t leftHash = ustr_hashUCharsN(d16->dataOf(leftIndex), d16->lengthOf(le
ftIndex)); | |
| 1288 int32_t rightHash = ustr_hashUCharsN(d16->dataOf(rightIndex), d16->lengthOf(
rightIndex)); | |
| 1289 return leftHash < rightHash ? -1 : leftHash == rightHash ? 0 : 1; | |
| 1290 } | |
| 1291 | |
| 1292 } // namespace | |
| 1293 | |
| 1294 const CA_uchar* CollPerf2Test::getSortedData16(UErrorCode &status) { | |
| 1295 if (U_FAILURE(status)) return NULL; | |
| 1296 if (sortedData16) return sortedData16; | |
| 1297 | |
| 1298 ArrayAndColl ac(getData16(status), *collObj); | |
| 1299 return sortedData16 = sortData16(ac.d16, U16CollatorComparator, &ac, status)
; | |
| 1300 } | |
| 1301 | |
| 1302 const CA_char* CollPerf2Test::getSortedData8(UErrorCode &status) { | |
| 1303 if (U_FAILURE(status)) return NULL; | |
| 1304 if (sortedData8) return sortedData8; | |
| 1305 return sortedData8 = getData8FromData16(getSortedData16(status), status); | |
| 1306 } | |
| 1307 | |
| 1308 const CA_uchar* CollPerf2Test::getRandomData16(UErrorCode &status) { | |
| 1309 if (U_FAILURE(status)) return NULL; | |
| 1310 if (randomData16) return randomData16; | |
| 1311 | |
| 1312 // Sort the strings by their hash codes, which should be a reasonably pseudo
-random order. | |
| 1313 const CA_uchar* d16 = getData16(status); | |
| 1314 return randomData16 = sortData16(d16, U16HashComparator, d16, status); | |
| 1315 } | |
| 1316 | |
| 1317 const CA_char* CollPerf2Test::getRandomData8(UErrorCode &status) { | |
| 1318 if (U_FAILURE(status)) return NULL; | |
| 1319 if (randomData8) return randomData8; | |
| 1320 return randomData8 = getData8FromData16(getRandomData16(status), status); | |
| 1321 } | |
| 1322 | |
| 1323 CA_uchar* CollPerf2Test::sortData16(const CA_uchar* d16, | |
| 1324 UComparator *cmp, const void *context, | |
| 1325 UErrorCode &status) { | |
| 1326 if (U_FAILURE(status)) return NULL; | |
| 1327 | |
| 1328 LocalArray<int32_t> indexes(new int32_t[d16->count]); | |
| 1329 for (int32_t i = 0; i < d16->count; ++i) { | |
| 1330 indexes[i] = i; | |
| 1331 } | |
| 1332 uprv_sortArray(indexes.getAlias(), d16->count, 4, cmp, context, TRUE, &statu
s); | |
| 1333 if (U_FAILURE(status)) return NULL; | |
| 1334 | |
| 1335 // Copy the strings in sorted order into a new array. | |
| 1336 LocalPointer<CA_uchar> newD16(new CA_uchar()); | |
| 1337 for (int32_t i = 0; i < d16->count; i++) { | |
| 1338 int32_t j = indexes[i]; | |
| 1339 const UChar* s = d16->dataOf(j); | |
| 1340 int32_t len = d16->lengthOf(j); | |
| 1341 int32_t capacity = len + 1; // including NULL terminator | |
| 1342 newD16->append_one(capacity); | |
| 1343 u_memcpy(newD16->last(), s, capacity); | |
| 1344 } | |
| 1345 | |
| 1346 if (U_SUCCESS(status)) { | |
| 1347 return newD16.orphan(); | |
| 1348 } else { | |
| 1349 return NULL; | |
| 1350 } | |
| 1351 } | |
| 1352 | |
| 1353 CA_char* CollPerf2Test::getData8FromData16(const CA_uchar* d16, UErrorCode &stat
us) { | |
| 1354 if (U_FAILURE(status)) return NULL; | |
| 1355 | |
| 1356 // UTF-16 -> UTF-8 conversion | |
| 1357 LocalPointer<CA_char> d8(new CA_char()); | |
| 1358 for (int32_t i = 0; i < d16->count; i++) { | |
| 1359 const UChar *s16 = d16->dataOf(i); | |
| 1360 int32_t length16 = d16->lengthOf(i); | |
| 1361 | |
| 1362 // get length in UTF-8 | |
| 1363 int32_t length8; | |
| 1364 u_strToUTF8(NULL, 0, &length8, s16, length16, &status); | |
| 1365 if (status == U_BUFFER_OVERFLOW_ERROR || status == U_ZERO_ERROR){ | |
| 1366 status = U_ZERO_ERROR; | |
| 1367 } else { | |
| 1368 break; | |
| 1369 } | |
| 1370 int32_t capacity8 = length8 + 1; // plus terminal NULL | |
| 1371 d8->append_one(capacity8); | |
| 1372 | |
| 1373 // convert to UTF-8 | |
| 1374 u_strToUTF8(d8->last(), capacity8, NULL, s16, length16, &status); | |
| 1375 if (U_FAILURE(status)) break; | |
| 1376 } | |
| 1377 | |
| 1378 if (U_SUCCESS(status)) { | |
| 1379 return d8.orphan(); | |
| 1380 } else { | |
| 1381 return NULL; | |
| 1382 } | |
| 1383 } | |
| 1384 | |
| 1385 UPerfFunction* | |
| 1386 CollPerf2Test::runIndexedTest(int32_t index, UBool exec, const char *&name, char
*par /*= NULL*/) | |
| 1387 { | |
| 1388 (void)par; | |
| 1389 TESTCASE_AUTO_BEGIN; | |
| 1390 | |
| 1391 TESTCASE_AUTO(TestStrcoll); | |
| 1392 TESTCASE_AUTO(TestStrcollNull); | |
| 1393 TESTCASE_AUTO(TestStrcollSimilar); | |
| 1394 | |
| 1395 TESTCASE_AUTO(TestStrcollUTF8); | |
| 1396 TESTCASE_AUTO(TestStrcollUTF8Null); | |
| 1397 TESTCASE_AUTO(TestStrcollUTF8Similar); | |
| 1398 | |
| 1399 TESTCASE_AUTO(TestGetSortKey); | |
| 1400 TESTCASE_AUTO(TestGetSortKeyNull); | |
| 1401 | |
| 1402 TESTCASE_AUTO(TestNextSortKeyPart_4All); | |
| 1403 TESTCASE_AUTO(TestNextSortKeyPart_4x4); | |
| 1404 TESTCASE_AUTO(TestNextSortKeyPart_4x8); | |
| 1405 TESTCASE_AUTO(TestNextSortKeyPart_32All); | |
| 1406 TESTCASE_AUTO(TestNextSortKeyPart_32x2); | |
| 1407 | |
| 1408 TESTCASE_AUTO(TestNextSortKeyPartUTF8_4All); | |
| 1409 TESTCASE_AUTO(TestNextSortKeyPartUTF8_4x4); | |
| 1410 TESTCASE_AUTO(TestNextSortKeyPartUTF8_4x8); | |
| 1411 TESTCASE_AUTO(TestNextSortKeyPartUTF8_32All); | |
| 1412 TESTCASE_AUTO(TestNextSortKeyPartUTF8_32x2); | |
| 1413 | |
| 1414 TESTCASE_AUTO(TestCppCompare); | |
| 1415 TESTCASE_AUTO(TestCppCompareNull); | |
| 1416 TESTCASE_AUTO(TestCppCompareSimilar); | |
| 1417 | |
| 1418 TESTCASE_AUTO(TestCppCompareUTF8); | |
| 1419 TESTCASE_AUTO(TestCppCompareUTF8Null); | |
| 1420 TESTCASE_AUTO(TestCppCompareUTF8Similar); | |
| 1421 | |
| 1422 TESTCASE_AUTO(TestCppGetCollationKey); | |
| 1423 TESTCASE_AUTO(TestCppGetCollationKeyNull); | |
| 1424 | |
| 1425 TESTCASE_AUTO(TestUniStrSort); | |
| 1426 TESTCASE_AUTO(TestStringPieceSortCpp); | |
| 1427 TESTCASE_AUTO(TestStringPieceSortC); | |
| 1428 | |
| 1429 TESTCASE_AUTO(TestUniStrBinSearch); | |
| 1430 TESTCASE_AUTO(TestStringPieceBinSearchCpp); | |
| 1431 TESTCASE_AUTO(TestStringPieceBinSearchC); | |
| 1432 | |
| 1433 TESTCASE_AUTO_END; | |
| 1434 return NULL; | |
| 1435 } | |
| 1436 | |
| 1437 | |
| 1438 | |
| 1439 UPerfFunction* CollPerf2Test::TestStrcoll() | |
| 1440 { | |
| 1441 UErrorCode status = U_ZERO_ERROR; | |
| 1442 Strcoll *testCase = new Strcoll(coll, getData16(status), TRUE /* useLen */); | |
| 1443 if (U_FAILURE(status)) { | |
| 1444 delete testCase; | |
| 1445 return NULL; | |
| 1446 } | |
| 1447 return testCase; | |
| 1448 } | |
| 1449 | |
| 1450 UPerfFunction* CollPerf2Test::TestStrcollNull() | |
| 1451 { | |
| 1452 UErrorCode status = U_ZERO_ERROR; | |
| 1453 Strcoll *testCase = new Strcoll(coll, getData16(status), FALSE /* useLen */)
; | |
| 1454 if (U_FAILURE(status)) { | |
| 1455 delete testCase; | |
| 1456 return NULL; | |
| 1457 } | |
| 1458 return testCase; | |
| 1459 } | |
| 1460 | |
| 1461 UPerfFunction* CollPerf2Test::TestStrcollSimilar() | |
| 1462 { | |
| 1463 UErrorCode status = U_ZERO_ERROR; | |
| 1464 Strcoll_2 *testCase = new Strcoll_2(coll, getData16(status), getModData16(st
atus), TRUE /* useLen */); | |
| 1465 if (U_FAILURE(status)) { | |
| 1466 delete testCase; | |
| 1467 return NULL; | |
| 1468 } | |
| 1469 return testCase; | |
| 1470 } | |
| 1471 | |
| 1472 UPerfFunction* CollPerf2Test::TestStrcollUTF8() | |
| 1473 { | |
| 1474 UErrorCode status = U_ZERO_ERROR; | |
| 1475 StrcollUTF8 *testCase = new StrcollUTF8(coll, getData8(status), TRUE /* useL
en */); | |
| 1476 if (U_FAILURE(status)) { | |
| 1477 delete testCase; | |
| 1478 return NULL; | |
| 1479 } | |
| 1480 return testCase; | |
| 1481 } | |
| 1482 | |
| 1483 UPerfFunction* CollPerf2Test::TestStrcollUTF8Null() | |
| 1484 { | |
| 1485 UErrorCode status = U_ZERO_ERROR; | |
| 1486 StrcollUTF8 *testCase = new StrcollUTF8(coll, getData8(status),FALSE /* useL
en */); | |
| 1487 if (U_FAILURE(status)) { | |
| 1488 delete testCase; | |
| 1489 return NULL; | |
| 1490 } | |
| 1491 return testCase; | |
| 1492 } | |
| 1493 | |
| 1494 UPerfFunction* CollPerf2Test::TestStrcollUTF8Similar() | |
| 1495 { | |
| 1496 UErrorCode status = U_ZERO_ERROR; | |
| 1497 StrcollUTF8_2 *testCase = new StrcollUTF8_2(coll, getData8(status), getModDa
ta8(status), TRUE /* useLen */); | |
| 1498 if (U_FAILURE(status)) { | |
| 1499 delete testCase; | |
| 1500 return NULL; | |
| 1501 } | |
| 1502 return testCase; | |
| 1503 } | |
| 1504 | |
| 1505 UPerfFunction* CollPerf2Test::TestGetSortKey() | |
| 1506 { | |
| 1507 UErrorCode status = U_ZERO_ERROR; | |
| 1508 GetSortKey *testCase = new GetSortKey(coll, getData16(status), TRUE /* useLe
n */); | |
| 1509 if (U_FAILURE(status)) { | |
| 1510 delete testCase; | |
| 1511 return NULL; | |
| 1512 } | |
| 1513 return testCase; | |
| 1514 } | |
| 1515 | |
| 1516 UPerfFunction* CollPerf2Test::TestGetSortKeyNull() | |
| 1517 { | |
| 1518 UErrorCode status = U_ZERO_ERROR; | |
| 1519 GetSortKey *testCase = new GetSortKey(coll, getData16(status), FALSE /* useL
en */); | |
| 1520 if (U_FAILURE(status)) { | |
| 1521 delete testCase; | |
| 1522 return NULL; | |
| 1523 } | |
| 1524 return testCase; | |
| 1525 } | |
| 1526 | |
| 1527 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4All() | |
| 1528 { | |
| 1529 UErrorCode status = U_ZERO_ERROR; | |
| 1530 NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /
* bufSize */); | |
| 1531 if (U_FAILURE(status)) { | |
| 1532 delete testCase; | |
| 1533 return NULL; | |
| 1534 } | |
| 1535 return testCase; | |
| 1536 } | |
| 1537 | |
| 1538 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4x4() | |
| 1539 { | |
| 1540 UErrorCode status = U_ZERO_ERROR; | |
| 1541 NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /
* bufSize */, 4 /* maxIteration */); | |
| 1542 if (U_FAILURE(status)) { | |
| 1543 delete testCase; | |
| 1544 return NULL; | |
| 1545 } | |
| 1546 return testCase; | |
| 1547 } | |
| 1548 | |
| 1549 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4x8() | |
| 1550 { | |
| 1551 UErrorCode status = U_ZERO_ERROR; | |
| 1552 NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /
* bufSize */, 8 /* maxIteration */); | |
| 1553 if (U_FAILURE(status)) { | |
| 1554 delete testCase; | |
| 1555 return NULL; | |
| 1556 } | |
| 1557 return testCase; | |
| 1558 } | |
| 1559 | |
| 1560 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_32All() | |
| 1561 { | |
| 1562 UErrorCode status = U_ZERO_ERROR; | |
| 1563 NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 32
/* bufSize */); | |
| 1564 if (U_FAILURE(status)) { | |
| 1565 delete testCase; | |
| 1566 return NULL; | |
| 1567 } | |
| 1568 return testCase; | |
| 1569 } | |
| 1570 | |
| 1571 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_32x2() | |
| 1572 { | |
| 1573 UErrorCode status = U_ZERO_ERROR; | |
| 1574 NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 32
/* bufSize */, 2 /* maxIteration */); | |
| 1575 if (U_FAILURE(status)) { | |
| 1576 delete testCase; | |
| 1577 return NULL; | |
| 1578 } | |
| 1579 return testCase; | |
| 1580 } | |
| 1581 | |
| 1582 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4All() | |
| 1583 { | |
| 1584 UErrorCode status = U_ZERO_ERROR; | |
| 1585 NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(statu
s), 4 /* bufSize */); | |
| 1586 if (U_FAILURE(status)) { | |
| 1587 delete testCase; | |
| 1588 return NULL; | |
| 1589 } | |
| 1590 return testCase; | |
| 1591 } | |
| 1592 | |
| 1593 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4x4() | |
| 1594 { | |
| 1595 UErrorCode status = U_ZERO_ERROR; | |
| 1596 NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(statu
s), 4 /* bufSize */, 4 /* maxIteration */); | |
| 1597 if (U_FAILURE(status)) { | |
| 1598 delete testCase; | |
| 1599 return NULL; | |
| 1600 } | |
| 1601 return testCase; | |
| 1602 } | |
| 1603 | |
| 1604 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4x8() | |
| 1605 { | |
| 1606 UErrorCode status = U_ZERO_ERROR; | |
| 1607 NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(statu
s), 4 /* bufSize */, 8 /* maxIteration */); | |
| 1608 if (U_FAILURE(status)) { | |
| 1609 delete testCase; | |
| 1610 return NULL; | |
| 1611 } | |
| 1612 return testCase; | |
| 1613 } | |
| 1614 | |
| 1615 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_32All() | |
| 1616 { | |
| 1617 UErrorCode status = U_ZERO_ERROR; | |
| 1618 NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(statu
s), 32 /* bufSize */); | |
| 1619 if (U_FAILURE(status)) { | |
| 1620 delete testCase; | |
| 1621 return NULL; | |
| 1622 } | |
| 1623 return testCase; | |
| 1624 } | |
| 1625 | |
| 1626 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_32x2() | |
| 1627 { | |
| 1628 UErrorCode status = U_ZERO_ERROR; | |
| 1629 NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(statu
s), 32 /* bufSize */, 2 /* maxIteration */); | |
| 1630 if (U_FAILURE(status)) { | |
| 1631 delete testCase; | |
| 1632 return NULL; | |
| 1633 } | |
| 1634 return testCase; | |
| 1635 } | |
| 1636 | |
| 1637 UPerfFunction* CollPerf2Test::TestCppCompare() | |
| 1638 { | |
| 1639 UErrorCode status = U_ZERO_ERROR; | |
| 1640 CppCompare *testCase = new CppCompare(collObj, getData16(status), TRUE /* us
eLen */); | |
| 1641 if (U_FAILURE(status)) { | |
| 1642 delete testCase; | |
| 1643 return NULL; | |
| 1644 } | |
| 1645 return testCase; | |
| 1646 } | |
| 1647 | |
| 1648 UPerfFunction* CollPerf2Test::TestCppCompareNull() | |
| 1649 { | |
| 1650 UErrorCode status = U_ZERO_ERROR; | |
| 1651 CppCompare *testCase = new CppCompare(collObj, getData16(status), FALSE /* u
seLen */); | |
| 1652 if (U_FAILURE(status)) { | |
| 1653 delete testCase; | |
| 1654 return NULL; | |
| 1655 } | |
| 1656 return testCase; | |
| 1657 } | |
| 1658 | |
| 1659 UPerfFunction* CollPerf2Test::TestCppCompareSimilar() | |
| 1660 { | |
| 1661 UErrorCode status = U_ZERO_ERROR; | |
| 1662 CppCompare_2 *testCase = new CppCompare_2(collObj, getData16(status), getMod
Data16(status), TRUE /* useLen */); | |
| 1663 if (U_FAILURE(status)) { | |
| 1664 delete testCase; | |
| 1665 return NULL; | |
| 1666 } | |
| 1667 return testCase; | |
| 1668 } | |
| 1669 | |
| 1670 UPerfFunction* CollPerf2Test::TestCppCompareUTF8() | |
| 1671 { | |
| 1672 UErrorCode status = U_ZERO_ERROR; | |
| 1673 CppCompareUTF8 *testCase = new CppCompareUTF8(collObj, getData8(status), TRU
E /* useLen */); | |
| 1674 if (U_FAILURE(status)) { | |
| 1675 delete testCase; | |
| 1676 return NULL; | |
| 1677 } | |
| 1678 return testCase; | |
| 1679 } | |
| 1680 | |
| 1681 UPerfFunction* CollPerf2Test::TestCppCompareUTF8Null() | |
| 1682 { | |
| 1683 UErrorCode status = U_ZERO_ERROR; | |
| 1684 CppCompareUTF8 *testCase = new CppCompareUTF8(collObj, getData8(status), FAL
SE /* useLen */); | |
| 1685 if (U_FAILURE(status)) { | |
| 1686 delete testCase; | |
| 1687 return NULL; | |
| 1688 } | |
| 1689 return testCase; | |
| 1690 } | |
| 1691 | |
| 1692 UPerfFunction* CollPerf2Test::TestCppCompareUTF8Similar() | |
| 1693 { | |
| 1694 UErrorCode status = U_ZERO_ERROR; | |
| 1695 CppCompareUTF8_2 *testCase = new CppCompareUTF8_2(collObj, getData8(status),
getModData8(status), TRUE /* useLen */); | |
| 1696 if (U_FAILURE(status)) { | |
| 1697 delete testCase; | |
| 1698 return NULL; | |
| 1699 } | |
| 1700 return testCase; | |
| 1701 } | |
| 1702 | |
| 1703 UPerfFunction* CollPerf2Test::TestCppGetCollationKey() | |
| 1704 { | |
| 1705 UErrorCode status = U_ZERO_ERROR; | |
| 1706 CppGetCollationKey *testCase = new CppGetCollationKey(collObj, getData16(sta
tus), TRUE /* useLen */); | |
| 1707 if (U_FAILURE(status)) { | |
| 1708 delete testCase; | |
| 1709 return NULL; | |
| 1710 } | |
| 1711 return testCase; | |
| 1712 } | |
| 1713 | |
| 1714 UPerfFunction* CollPerf2Test::TestCppGetCollationKeyNull() | |
| 1715 { | |
| 1716 UErrorCode status = U_ZERO_ERROR; | |
| 1717 CppGetCollationKey *testCase = new CppGetCollationKey(collObj, getData16(sta
tus), FALSE /* useLen */); | |
| 1718 if (U_FAILURE(status)) { | |
| 1719 delete testCase; | |
| 1720 return NULL; | |
| 1721 } | |
| 1722 return testCase; | |
| 1723 } | |
| 1724 | |
| 1725 UPerfFunction* CollPerf2Test::TestUniStrSort() { | |
| 1726 UErrorCode status = U_ZERO_ERROR; | |
| 1727 UPerfFunction *testCase = new UniStrSort(*collObj, coll, getRandomData16(sta
tus)); | |
| 1728 if (U_FAILURE(status)) { | |
| 1729 delete testCase; | |
| 1730 return NULL; | |
| 1731 } | |
| 1732 return testCase; | |
| 1733 } | |
| 1734 | |
| 1735 UPerfFunction* CollPerf2Test::TestStringPieceSortCpp() { | |
| 1736 UErrorCode status = U_ZERO_ERROR; | |
| 1737 UPerfFunction *testCase = new StringPieceSortCpp(*collObj, coll, getRandomDa
ta8(status)); | |
| 1738 if (U_FAILURE(status)) { | |
| 1739 delete testCase; | |
| 1740 return NULL; | |
| 1741 } | |
| 1742 return testCase; | |
| 1743 } | |
| 1744 | |
| 1745 UPerfFunction* CollPerf2Test::TestStringPieceSortC() { | |
| 1746 UErrorCode status = U_ZERO_ERROR; | |
| 1747 UPerfFunction *testCase = new StringPieceSortC(*collObj, coll, getRandomData
8(status)); | |
| 1748 if (U_FAILURE(status)) { | |
| 1749 delete testCase; | |
| 1750 return NULL; | |
| 1751 } | |
| 1752 return testCase; | |
| 1753 } | |
| 1754 | |
| 1755 UPerfFunction* CollPerf2Test::TestUniStrBinSearch() { | |
| 1756 UErrorCode status = U_ZERO_ERROR; | |
| 1757 UPerfFunction *testCase = new UniStrBinSearch(*collObj, coll, getSortedData1
6(status)); | |
| 1758 if (U_FAILURE(status)) { | |
| 1759 delete testCase; | |
| 1760 return NULL; | |
| 1761 } | |
| 1762 return testCase; | |
| 1763 } | |
| 1764 | |
| 1765 UPerfFunction* CollPerf2Test::TestStringPieceBinSearchCpp() { | |
| 1766 UErrorCode status = U_ZERO_ERROR; | |
| 1767 UPerfFunction *testCase = new StringPieceBinSearchCpp(*collObj, coll, getSor
tedData8(status)); | |
| 1768 if (U_FAILURE(status)) { | |
| 1769 delete testCase; | |
| 1770 return NULL; | |
| 1771 } | |
| 1772 return testCase; | |
| 1773 } | |
| 1774 | |
| 1775 UPerfFunction* CollPerf2Test::TestStringPieceBinSearchC() { | |
| 1776 UErrorCode status = U_ZERO_ERROR; | |
| 1777 UPerfFunction *testCase = new StringPieceBinSearchC(*collObj, coll, getSorte
dData8(status)); | |
| 1778 if (U_FAILURE(status)) { | |
| 1779 delete testCase; | |
| 1780 return NULL; | |
| 1781 } | |
| 1782 return testCase; | |
| 1783 } | |
| 1784 | |
| 1785 | |
| 1786 int main(int argc, const char *argv[]) | |
| 1787 { | |
| 1788 UErrorCode status = U_ZERO_ERROR; | |
| 1789 CollPerf2Test test(argc, argv, status); | |
| 1790 | |
| 1791 if (U_FAILURE(status)){ | |
| 1792 printf("The error is %s\n", u_errorName(status)); | |
| 1793 //TODO: print usage here | |
| 1794 return status; | |
| 1795 } | |
| 1796 | |
| 1797 if (test.run() == FALSE){ | |
| 1798 fprintf(stderr, "FAILED: Tests could not be run please check the argumen
ts.\n"); | |
| 1799 return -1; | |
| 1800 } | |
| 1801 return 0; | |
| 1802 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
