icuSources/test/perf/collperf2/collperf2.cpp

   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_STRINGS_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 && numTestStringsI < 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 && numTestStringsJ < 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* target, 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_uchar* 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), tgtLen);
 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 permuting 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 useLen)
 182     :   coll(coll),
 183         source(source),
 184         useLen(useLen)
 185 {
 186     maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_STRINGS_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->count && 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 < source->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->dataOf(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* target, 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 useLen)
 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_nextSortKeyPart 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 bufSize, 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 && (maxIteration < 0 || n < maxIteration); n++) {
 377             partLen = ucol_nextSortKeyPart(coll, &iter, state, part, bufSize, status);
 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_nextSortKeyPart 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 bufSize, 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* source, 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 && (maxIteration < 0 || n < maxIteration); n++) {
 444             partLen = ucol_nextSortKeyPart(coll, &iter, state, part, bufSize, status);
 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 permuting 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 useLen)
 482     :   coll(coll),
 483         source(source),
 484         useLen(useLen)
 485 {
 486     maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_STRINGS_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 && numTestStringsI < 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 && numTestStringsJ < 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), tgtLen);
 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* target, 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 CA_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 permuting 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, UBool useLen)
 592     :   coll(coll),
 593         source(source),
 594         useLen(useLen)
 595 {
 596     maxTestStrings = source->count > MAX_TEST_STRINGS_FOR_PERMUTING ? MAX_TEST_STRINGS_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->count && 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 < source->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 strings 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 useLen);
 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* source, 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, *status);
 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* right) {
 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 CA_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* data16)
 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, const 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_char* 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 pointers.
 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 &status) :
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 = "en_US";   // set default locale
1147     }
1148
1149     //  Set up an ICU collator
1150     coll = ucol_open(locale, &status);
1151     collObj = Collator::createInstance(locale, status);
1152
1153     // Keyword support should be actually a part of ICU collator, see ICU ticket #8260.
1154     char keyBuffer[256];
1155     UColAttributeValue val;
1156     if (uloc_getKeywordValue(locale, "strength", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1157         if (strcmp(keyBuffer, "primary") == 0) {
1158             val = UCOL_PRIMARY;
1159         } else if (strcmp(keyBuffer, "secondary") == 0) {
1160             val = UCOL_SECONDARY;
1161         } else if (strcmp(keyBuffer, "tertiary") == 0) {
1162             val = UCOL_TERTIARY;
1163         } else if (strcmp(keyBuffer, "quaternary") == 0) {
1164             val = UCOL_QUATERNARY;
1165         } else if (strcmp(keyBuffer, "identical") == 0) {
1166             val = UCOL_IDENTICAL;
1167         } else {
1168             status = U_ILLEGAL_ARGUMENT_ERROR;
1169         }
1170         if (U_SUCCESS(status)) {
1171             ucol_setAttribute(coll, UCOL_STRENGTH, val, &status);
1172             collObj->setAttribute(UCOL_STRENGTH, val, status);
1173         }
1174     }
1175     if (uloc_getKeywordValue(locale, "alternate", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1176         if (strcmp(keyBuffer, "non-ignorable") == 0) {
1177             val = UCOL_NON_IGNORABLE;
1178         } else if (strcmp(keyBuffer, "shifted") == 0) {
1179             val = UCOL_SHIFTED;
1180         } else {
1181             status = U_ILLEGAL_ARGUMENT_ERROR;
1182         }
1183         if (U_SUCCESS(status)) {
1184             ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, val, &status);
1185             collObj->setAttribute(UCOL_ALTERNATE_HANDLING, val, status);
1186         }
1187     }
1188     if (uloc_getKeywordValue(locale, "backwards", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1189         if (strcmp(keyBuffer, "on") == 0) {
1190             val = UCOL_ON;
1191         } else if (strcmp(keyBuffer, "off") == 0) {
1192             val = UCOL_OFF;
1193         } else {
1194             status = U_ILLEGAL_ARGUMENT_ERROR;
1195         }
1196         if (U_SUCCESS(status)) {
1197             ucol_setAttribute(coll, UCOL_FRENCH_COLLATION, val, &status);
1198             collObj->setAttribute(UCOL_FRENCH_COLLATION, val, status);
1199         }
1200     }
1201     if (uloc_getKeywordValue(locale, "normalization", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1202         if (strcmp(keyBuffer, "on") == 0) {
1203             val = UCOL_ON;
1204         } else if (strcmp(keyBuffer, "off") == 0) {
1205             val = UCOL_OFF;
1206         } else {
1207             status = U_ILLEGAL_ARGUMENT_ERROR;
1208         }
1209         if (U_SUCCESS(status)) {
1210             ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, val, &status);
1211             collObj->setAttribute(UCOL_NORMALIZATION_MODE, val, status);
1212         }
1213     }
1214     if (uloc_getKeywordValue(locale, "caseLevel", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1215         if (strcmp(keyBuffer, "on") == 0) {
1216             val = UCOL_ON;
1217         } else if (strcmp(keyBuffer, "off") == 0) {
1218             val = UCOL_OFF;
1219         } else {
1220             status = U_ILLEGAL_ARGUMENT_ERROR;
1221         }
1222         if (U_SUCCESS(status)) {
1223             ucol_setAttribute(coll, UCOL_CASE_LEVEL, val, &status);
1224             collObj->setAttribute(UCOL_CASE_LEVEL, val, status);
1225         }
1226     }
1227     if (uloc_getKeywordValue(locale, "caseFirst", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1228         if (strcmp(keyBuffer, "upper") == 0) {
1229             val = UCOL_UPPER_FIRST;
1230         } else if (strcmp(keyBuffer, "lower") == 0) {
1231             val = UCOL_LOWER_FIRST;
1232         } else if (strcmp(keyBuffer, "off") == 0) {
1233             val = UCOL_OFF;
1234         } else {
1235             status = U_ILLEGAL_ARGUMENT_ERROR;
1236         }
1237         if (U_SUCCESS(status)) {
1238             ucol_setAttribute(coll, UCOL_CASE_FIRST, val, &status);
1239             collObj->setAttribute(UCOL_CASE_FIRST, val, status);
1240         }
1241     }
1242     if (uloc_getKeywordValue(locale, "hiraganaQuaternary", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1243         if (strcmp(keyBuffer, "on") == 0) {
1244             val = UCOL_ON;
1245         } else if (strcmp(keyBuffer, "off") == 0) {
1246             val = UCOL_OFF;
1247         } else {
1248             status = U_ILLEGAL_ARGUMENT_ERROR;
1249         }
1250         if (U_SUCCESS(status)) {
1251             ucol_setAttribute(coll, UCOL_HIRAGANA_QUATERNARY_MODE, val, &status);
1252             collObj->setAttribute(UCOL_HIRAGANA_QUATERNARY_MODE, val, status);
1253         }
1254     }
1255     if (uloc_getKeywordValue(locale, "numeric", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1256         if (strcmp(keyBuffer, "on") == 0) {
1257             val = UCOL_ON;
1258         } else if (strcmp(keyBuffer, "off") == 0) {
1259             val = UCOL_OFF;
1260         } else {
1261             status = U_ILLEGAL_ARGUMENT_ERROR;
1262         }
1263         if (U_SUCCESS(status)) {
1264             ucol_setAttribute(coll, UCOL_NUMERIC_COLLATION, val, &status);
1265             collObj->setAttribute(UCOL_NUMERIC_COLLATION, val, status);
1266         }
1267     }
1268     if (uloc_getKeywordValue(locale, "variableTop", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1269         // no support for now
1270         status = U_UNSUPPORTED_ERROR;
1271     }
1272     if (uloc_getKeywordValue(locale, "reorder", keyBuffer, sizeof(keyBuffer)/sizeof(keyBuffer[0]), &status)) {
1273         // no support for now
1274         status = U_UNSUPPORTED_ERROR;
1275     }
1276 }
1277
1278 CollPerf2Test::~CollPerf2Test()
1279 {
1280     ucol_close(coll);
1281     delete collObj;
1282
1283     delete data16;
1284     delete data8;
1285     delete modData16;
1286     delete modData8;
1287     delete sortedData16;
1288     delete sortedData8;
1289     delete randomData16;
1290     delete randomData8;
1291 }
1292
1293 #define MAX_NUM_DATA 10000
1294
1295 const CA_uchar* CollPerf2Test::getData16(UErrorCode &status)
1296 {
1297     if (U_FAILURE(status)) return NULL;
1298     if (data16) return data16;
1299
1300     CA_uchar* d16 = new CA_uchar();
1301     const UChar *line = NULL;
1302     int32_t len = 0;
1303     int32_t numData = 0;
1304
1305     for (;;) {
1306         line = ucbuf_readline(ucharBuf, &len, &status);
1307         if (line == NULL || U_FAILURE(status)) break;
1308
1309         // Refer to the source code of ucbuf_readline()
1310         // 1. 'len' includes the line terminal symbols
1311         // 2. The length of the line terminal symbols is only one character
1312         // 3. The Windows CR LF line terminal symbols will be converted to CR
1313
1314         if (len == 1 || line[0] == 0x23 /* '#' */) {
1315             continue; // skip empty/comment line
1316         } else {
1317             d16->append_one(len);
1318             u_memcpy(d16->last(), line, len);
1319
1320             numData++;
1321             if (numData >= MAX_NUM_DATA) break;
1322         }
1323     }
1324
1325     if (U_SUCCESS(status)) {
1326         data16 = d16;
1327     } else {
1328         delete d16;
1329     }
1330
1331     return data16;
1332 }
1333
1334 const CA_char* CollPerf2Test::getData8(UErrorCode &status)
1335 {
1336     if (U_FAILURE(status)) return NULL;
1337     if (data8) return data8;
1338     return data8 = getData8FromData16(getData16(status), status);
1339 }
1340
1341 const CA_uchar* CollPerf2Test::getModData16(UErrorCode &status)
1342 {
1343     if (U_FAILURE(status)) return NULL;
1344     if (modData16) return modData16;
1345
1346     const CA_uchar* d16 = getData16(status);
1347     if (U_FAILURE(status)) return NULL;
1348
1349     CA_uchar* modData16 = new CA_uchar();
1350
1351     for (int32_t i = 0; i < d16->count; i++) {
1352         const UChar *s = d16->dataOf(i);
1353         int32_t len = d16->lengthOf(i) + 1; // including NULL terminator
1354
1355         modData16->append_one(len);
1356         u_memcpy(modData16->last(), s, len);
1357
1358         // replacing the last character with a different character
1359         UChar *lastChar = &modData16->last()[len -2];
1360         for (int32_t j = i + 1; j != i; j++) {
1361             if (j >= d16->count) {
1362                 j = 0;
1363             }
1364             const UChar *s1 = d16->dataOf(j);
1365             UChar lastChar1 = s1[d16->lengthOf(j) - 1];
1366             if (*lastChar != lastChar1) {
1367                 *lastChar = lastChar1;
1368                 break;
1369             }
1370         }
1371     }
1372
1373     return modData16;
1374 }
1375
1376 const CA_char* CollPerf2Test::getModData8(UErrorCode &status)
1377 {
1378     if (U_FAILURE(status)) return NULL;
1379     if (modData8) return modData8;
1380     return modData8 = getData8FromData16(getModData16(status), status);
1381 }
1382
1383 namespace {
1384
1385 struct ArrayAndColl {
1386     ArrayAndColl(const CA_uchar* a, const Collator& c) : d16(a), coll(c) {}
1387     const CA_uchar* d16;
1388     const Collator& coll;
1389 };
1390
1391 int32_t U_CALLCONV
1392 U16CollatorComparator(const void* context, const void* left, const void* right) {
1393     const ArrayAndColl& ac = *(const ArrayAndColl*)context;
1394     const CA_uchar* d16 = ac.d16;
1395     int32_t leftIndex = *(const int32_t*)left;
1396     int32_t rightIndex = *(const int32_t*)right;
1397     UErrorCode errorCode = U_ZERO_ERROR;
1398     return ac.coll.compare(d16->dataOf(leftIndex), d16->lengthOf(leftIndex),
1399                            d16->dataOf(rightIndex), d16->lengthOf(rightIndex),
1400                            errorCode);
1401 }
1402
1403 int32_t U_CALLCONV
1404 U16HashComparator(const void* context, const void* left, const void* right) {
1405     const CA_uchar* d16 = (const CA_uchar*)context;
1406     int32_t leftIndex = *(const int32_t*)left;
1407     int32_t rightIndex = *(const int32_t*)right;
1408     int32_t leftHash = ustr_hashUCharsN(d16->dataOf(leftIndex), d16->lengthOf(leftIndex));
1409     int32_t rightHash = ustr_hashUCharsN(d16->dataOf(rightIndex), d16->lengthOf(rightIndex));
1410     return leftHash < rightHash ? -1 : leftHash == rightHash ? 0 : 1;
1411 }
1412
1413 }  // namespace
1414
1415 const CA_uchar* CollPerf2Test::getSortedData16(UErrorCode &status) {
1416     if (U_FAILURE(status)) return NULL;
1417     if (sortedData16) return sortedData16;
1418
1419     ArrayAndColl ac(getData16(status), *collObj);
1420     return sortedData16 = sortData16(ac.d16, U16CollatorComparator, &ac, status);
1421 }
1422
1423 const CA_char* CollPerf2Test::getSortedData8(UErrorCode &status) {
1424     if (U_FAILURE(status)) return NULL;
1425     if (sortedData8) return sortedData8;
1426     return sortedData8 = getData8FromData16(getSortedData16(status), status);
1427 }
1428
1429 const CA_uchar* CollPerf2Test::getRandomData16(UErrorCode &status) {
1430     if (U_FAILURE(status)) return NULL;
1431     if (randomData16) return randomData16;
1432
1433     // Sort the strings by their hash codes, which should be a reasonably pseudo-random order.
1434     const CA_uchar* d16 = getData16(status);
1435     return randomData16 = sortData16(d16, U16HashComparator, d16, status);
1436 }
1437
1438 const CA_char* CollPerf2Test::getRandomData8(UErrorCode &status) {
1439     if (U_FAILURE(status)) return NULL;
1440     if (randomData8) return randomData8;
1441     return randomData8 = getData8FromData16(getRandomData16(status), status);
1442 }
1443
1444 CA_uchar* CollPerf2Test::sortData16(const CA_uchar* d16,
1445                                     UComparator *cmp, const void *context,
1446                                     UErrorCode &status) {
1447     if (U_FAILURE(status)) return NULL;
1448
1449     LocalArray<int32_t> indexes(new int32_t[d16->count]);
1450     for (int32_t i = 0; i < d16->count; ++i) {
1451         indexes[i] = i;
1452     }
1453     uprv_sortArray(indexes.getAlias(), d16->count, 4, cmp, context, TRUE, &status);
1454     if (U_FAILURE(status)) return NULL;
1455
1456     // Copy the strings in sorted order into a new array.
1457     LocalPointer<CA_uchar> newD16(new CA_uchar());
1458     for (int32_t i = 0; i < d16->count; i++) {
1459         const UChar* s = d16->dataOf(i);
1460         int32_t len = d16->lengthOf(i);
1461         int32_t capacity = len + 1;  // including NULL terminator
1462         newD16->append_one(capacity);
1463         u_memcpy(newD16->last(), s, capacity);
1464     }
1465
1466     if (U_SUCCESS(status)) {
1467         return newD16.orphan();
1468     } else {
1469         return NULL;
1470     }
1471 }
1472
1473 CA_char* CollPerf2Test::getData8FromData16(const CA_uchar* d16, UErrorCode &status) {
1474     if (U_FAILURE(status)) return NULL;
1475
1476     // UTF-16 -> UTF-8 conversion
1477     LocalPointer<CA_char> d8(new CA_char());
1478     for (int32_t i = 0; i < d16->count; i++) {
1479         const UChar *s16 = d16->dataOf(i);
1480         int32_t length16 = d16->lengthOf(i);
1481
1482         // get length in UTF-8
1483         int32_t length8;
1484         u_strToUTF8(NULL, 0, &length8, s16, length16, &status);
1485         if (status == U_BUFFER_OVERFLOW_ERROR || status == U_ZERO_ERROR){
1486             status = U_ZERO_ERROR;
1487         } else {
1488             break;
1489         }
1490         int32_t capacity8 = length8 + 1;  // plus terminal NULL
1491         d8->append_one(capacity8);
1492
1493         // convert to UTF-8
1494         u_strToUTF8(d8->last(), capacity8, NULL, s16, length16, &status);
1495         if (U_FAILURE(status)) break;
1496     }
1497
1498     if (U_SUCCESS(status)) {
1499         return d8.orphan();
1500     } else {
1501         return NULL;
1502     }
1503 }
1504
1505 UPerfFunction*
1506 CollPerf2Test::runIndexedTest(int32_t index, UBool exec, const char *&name, char *par /*= NULL*/)
1507 {
1508     (void)par;
1509     TESTCASE_AUTO_BEGIN;
1510
1511     TESTCASE_AUTO(TestStrcoll);
1512     TESTCASE_AUTO(TestStrcollNull);
1513     TESTCASE_AUTO(TestStrcollSimilar);
1514
1515     TESTCASE_AUTO(TestStrcollUTF8);
1516     TESTCASE_AUTO(TestStrcollUTF8Null);
1517     TESTCASE_AUTO(TestStrcollUTF8Similar);
1518
1519     TESTCASE_AUTO(TestGetSortKey);
1520     TESTCASE_AUTO(TestGetSortKeyNull);
1521
1522     TESTCASE_AUTO(TestNextSortKeyPart_4All);
1523     TESTCASE_AUTO(TestNextSortKeyPart_4x4);
1524     TESTCASE_AUTO(TestNextSortKeyPart_4x8);
1525     TESTCASE_AUTO(TestNextSortKeyPart_32All);
1526     TESTCASE_AUTO(TestNextSortKeyPart_32x2);
1527
1528     TESTCASE_AUTO(TestNextSortKeyPartUTF8_4All);
1529     TESTCASE_AUTO(TestNextSortKeyPartUTF8_4x4);
1530     TESTCASE_AUTO(TestNextSortKeyPartUTF8_4x8);
1531     TESTCASE_AUTO(TestNextSortKeyPartUTF8_32All);
1532     TESTCASE_AUTO(TestNextSortKeyPartUTF8_32x2);
1533
1534     TESTCASE_AUTO(TestCppCompare);
1535     TESTCASE_AUTO(TestCppCompareNull);
1536     TESTCASE_AUTO(TestCppCompareSimilar);
1537
1538     TESTCASE_AUTO(TestCppCompareUTF8);
1539     TESTCASE_AUTO(TestCppCompareUTF8Null);
1540     TESTCASE_AUTO(TestCppCompareUTF8Similar);
1541
1542     TESTCASE_AUTO(TestCppGetCollationKey);
1543     TESTCASE_AUTO(TestCppGetCollationKeyNull);
1544
1545     TESTCASE_AUTO(TestUniStrSort);
1546     TESTCASE_AUTO(TestStringPieceSortCpp);
1547     TESTCASE_AUTO(TestStringPieceSortC);
1548
1549     TESTCASE_AUTO(TestUniStrBinSearch);
1550     TESTCASE_AUTO(TestStringPieceBinSearchCpp);
1551     TESTCASE_AUTO(TestStringPieceBinSearchC);
1552
1553     TESTCASE_AUTO_END;
1554     return NULL;
1555 }
1556
1557
1558
1559 UPerfFunction* CollPerf2Test::TestStrcoll()
1560 {
1561     UErrorCode status = U_ZERO_ERROR;
1562     Strcoll *testCase = new Strcoll(coll, getData16(status), TRUE /* useLen */);
1563     if (U_FAILURE(status)) {
1564         delete testCase;
1565         return NULL;
1566     }
1567     return testCase;
1568 }
1569
1570 UPerfFunction* CollPerf2Test::TestStrcollNull()
1571 {
1572     UErrorCode status = U_ZERO_ERROR;
1573     Strcoll *testCase = new Strcoll(coll, getData16(status), FALSE /* useLen */);
1574     if (U_FAILURE(status)) {
1575         delete testCase;
1576         return NULL;
1577     }
1578     return testCase;
1579 }
1580
1581 UPerfFunction* CollPerf2Test::TestStrcollSimilar()
1582 {
1583     UErrorCode status = U_ZERO_ERROR;
1584     Strcoll_2 *testCase = new Strcoll_2(coll, getData16(status), getModData16(status), TRUE /* useLen */);
1585     if (U_FAILURE(status)) {
1586         delete testCase;
1587         return NULL;
1588     }
1589     return testCase;
1590 }
1591
1592 UPerfFunction* CollPerf2Test::TestStrcollUTF8()
1593 {
1594     UErrorCode status = U_ZERO_ERROR;
1595     StrcollUTF8 *testCase = new StrcollUTF8(coll, getData8(status), TRUE /* useLen */);
1596     if (U_FAILURE(status)) {
1597         delete testCase;
1598         return NULL;
1599     }
1600     return testCase;
1601 }
1602
1603 UPerfFunction* CollPerf2Test::TestStrcollUTF8Null()
1604 {
1605     UErrorCode status = U_ZERO_ERROR;
1606     StrcollUTF8 *testCase = new StrcollUTF8(coll, getData8(status),FALSE /* useLen */);
1607     if (U_FAILURE(status)) {
1608         delete testCase;
1609         return NULL;
1610     }
1611     return testCase;
1612 }
1613
1614 UPerfFunction* CollPerf2Test::TestStrcollUTF8Similar()
1615 {
1616     UErrorCode status = U_ZERO_ERROR;
1617     StrcollUTF8_2 *testCase = new StrcollUTF8_2(coll, getData8(status), getModData8(status), TRUE /* useLen */);
1618     if (U_FAILURE(status)) {
1619         delete testCase;
1620         return NULL;
1621     }
1622     return testCase;
1623 }
1624
1625 UPerfFunction* CollPerf2Test::TestGetSortKey()
1626 {
1627     UErrorCode status = U_ZERO_ERROR;
1628     GetSortKey *testCase = new GetSortKey(coll, getData16(status), TRUE /* useLen */);
1629     if (U_FAILURE(status)) {
1630         delete testCase;
1631         return NULL;
1632     }
1633     return testCase;
1634 }
1635
1636 UPerfFunction* CollPerf2Test::TestGetSortKeyNull()
1637 {
1638     UErrorCode status = U_ZERO_ERROR;
1639     GetSortKey *testCase = new GetSortKey(coll, getData16(status), FALSE /* useLen */);
1640     if (U_FAILURE(status)) {
1641         delete testCase;
1642         return NULL;
1643     }
1644     return testCase;
1645 }
1646
1647 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4All()
1648 {
1649     UErrorCode status = U_ZERO_ERROR;
1650     NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /* bufSize */);
1651     if (U_FAILURE(status)) {
1652         delete testCase;
1653         return NULL;
1654     }
1655     return testCase;
1656 }
1657
1658 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4x4()
1659 {
1660     UErrorCode status = U_ZERO_ERROR;
1661     NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /* bufSize */, 4 /* maxIteration */);
1662     if (U_FAILURE(status)) {
1663         delete testCase;
1664         return NULL;
1665     }
1666     return testCase;
1667 }
1668
1669 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_4x8()
1670 {
1671     UErrorCode status = U_ZERO_ERROR;
1672     NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 4 /* bufSize */, 8 /* maxIteration */);
1673     if (U_FAILURE(status)) {
1674         delete testCase;
1675         return NULL;
1676     }
1677     return testCase;
1678 }
1679
1680 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_32All()
1681 {
1682     UErrorCode status = U_ZERO_ERROR;
1683     NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 32 /* bufSize */);
1684     if (U_FAILURE(status)) {
1685         delete testCase;
1686         return NULL;
1687     }
1688     return testCase;
1689 }
1690
1691 UPerfFunction* CollPerf2Test::TestNextSortKeyPart_32x2()
1692 {
1693     UErrorCode status = U_ZERO_ERROR;
1694     NextSortKeyPart *testCase = new NextSortKeyPart(coll, getData16(status), 32 /* bufSize */, 2 /* maxIteration */);
1695     if (U_FAILURE(status)) {
1696         delete testCase;
1697         return NULL;
1698     }
1699     return testCase;
1700 }
1701
1702 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4All()
1703 {
1704     UErrorCode status = U_ZERO_ERROR;
1705     NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(status), 4 /* bufSize */);
1706     if (U_FAILURE(status)) {
1707         delete testCase;
1708         return NULL;
1709     }
1710     return testCase;
1711 }
1712
1713 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4x4()
1714 {
1715     UErrorCode status = U_ZERO_ERROR;
1716     NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(status), 4 /* bufSize */, 4 /* maxIteration */);
1717     if (U_FAILURE(status)) {
1718         delete testCase;
1719         return NULL;
1720     }
1721     return testCase;
1722 }
1723
1724 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_4x8()
1725 {
1726     UErrorCode status = U_ZERO_ERROR;
1727     NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(status), 4 /* bufSize */, 8 /* maxIteration */);
1728     if (U_FAILURE(status)) {
1729         delete testCase;
1730         return NULL;
1731     }
1732     return testCase;
1733 }
1734
1735 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_32All()
1736 {
1737     UErrorCode status = U_ZERO_ERROR;
1738     NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(status), 32 /* bufSize */);
1739     if (U_FAILURE(status)) {
1740         delete testCase;
1741         return NULL;
1742     }
1743     return testCase;
1744 }
1745
1746 UPerfFunction* CollPerf2Test::TestNextSortKeyPartUTF8_32x2()
1747 {
1748     UErrorCode status = U_ZERO_ERROR;
1749     NextSortKeyPartUTF8 *testCase = new NextSortKeyPartUTF8(coll, getData8(status), 32 /* bufSize */, 2 /* maxIteration */);
1750     if (U_FAILURE(status)) {
1751         delete testCase;
1752         return NULL;
1753     }
1754     return testCase;
1755 }
1756
1757 UPerfFunction* CollPerf2Test::TestCppCompare()
1758 {
1759     UErrorCode status = U_ZERO_ERROR;
1760     CppCompare *testCase = new CppCompare(collObj, getData16(status), TRUE /* useLen */);
1761     if (U_FAILURE(status)) {
1762         delete testCase;
1763         return NULL;
1764     }
1765     return testCase;
1766 }
1767
1768 UPerfFunction* CollPerf2Test::TestCppCompareNull()
1769 {
1770     UErrorCode status = U_ZERO_ERROR;
1771     CppCompare *testCase = new CppCompare(collObj, getData16(status), FALSE /* useLen */);
1772     if (U_FAILURE(status)) {
1773         delete testCase;
1774         return NULL;
1775     }
1776     return testCase;
1777 }
1778
1779 UPerfFunction* CollPerf2Test::TestCppCompareSimilar()
1780 {
1781     UErrorCode status = U_ZERO_ERROR;
1782     CppCompare_2 *testCase = new CppCompare_2(collObj, getData16(status), getModData16(status), TRUE /* useLen */);
1783     if (U_FAILURE(status)) {
1784         delete testCase;
1785         return NULL;
1786     }
1787     return testCase;
1788 }
1789
1790 UPerfFunction* CollPerf2Test::TestCppCompareUTF8()
1791 {
1792     UErrorCode status = U_ZERO_ERROR;
1793     CppCompareUTF8 *testCase = new CppCompareUTF8(collObj, getData8(status), TRUE /* useLen */);
1794     if (U_FAILURE(status)) {
1795         delete testCase;
1796         return NULL;
1797     }
1798     return testCase;
1799 }
1800
1801 UPerfFunction* CollPerf2Test::TestCppCompareUTF8Null()
1802 {
1803     UErrorCode status = U_ZERO_ERROR;
1804     CppCompareUTF8 *testCase = new CppCompareUTF8(collObj, getData8(status), FALSE /* useLen */);
1805     if (U_FAILURE(status)) {
1806         delete testCase;
1807         return NULL;
1808     }
1809     return testCase;
1810 }
1811
1812 UPerfFunction* CollPerf2Test::TestCppCompareUTF8Similar()
1813 {
1814     UErrorCode status = U_ZERO_ERROR;
1815     CppCompareUTF8_2 *testCase = new CppCompareUTF8_2(collObj, getData8(status), getModData8(status), TRUE /* useLen */);
1816     if (U_FAILURE(status)) {
1817         delete testCase;
1818         return NULL;
1819     }
1820     return testCase;
1821 }
1822
1823 UPerfFunction* CollPerf2Test::TestCppGetCollationKey()
1824 {
1825     UErrorCode status = U_ZERO_ERROR;
1826     CppGetCollationKey *testCase = new CppGetCollationKey(collObj, getData16(status), TRUE /* useLen */);
1827     if (U_FAILURE(status)) {
1828         delete testCase;
1829         return NULL;
1830     }
1831     return testCase;
1832 }
1833
1834 UPerfFunction* CollPerf2Test::TestCppGetCollationKeyNull()
1835 {
1836     UErrorCode status = U_ZERO_ERROR;
1837     CppGetCollationKey *testCase = new CppGetCollationKey(collObj, getData16(status), FALSE /* useLen */);
1838     if (U_FAILURE(status)) {
1839         delete testCase;
1840         return NULL;
1841     }
1842     return testCase;
1843 }
1844
1845 UPerfFunction* CollPerf2Test::TestUniStrSort() {
1846     UErrorCode status = U_ZERO_ERROR;
1847     UPerfFunction *testCase = new UniStrSort(*collObj, coll, getRandomData16(status));
1848     if (U_FAILURE(status)) {
1849         delete testCase;
1850         return NULL;
1851     }
1852     return testCase;
1853 }
1854
1855 UPerfFunction* CollPerf2Test::TestStringPieceSortCpp() {
1856     UErrorCode status = U_ZERO_ERROR;
1857     UPerfFunction *testCase = new StringPieceSortCpp(*collObj, coll, getRandomData8(status));
1858     if (U_FAILURE(status)) {
1859         delete testCase;
1860         return NULL;
1861     }
1862     return testCase;
1863 }
1864
1865 UPerfFunction* CollPerf2Test::TestStringPieceSortC() {
1866     UErrorCode status = U_ZERO_ERROR;
1867     UPerfFunction *testCase = new StringPieceSortC(*collObj, coll, getRandomData8(status));
1868     if (U_FAILURE(status)) {
1869         delete testCase;
1870         return NULL;
1871     }
1872     return testCase;
1873 }
1874
1875 UPerfFunction* CollPerf2Test::TestUniStrBinSearch() {
1876     UErrorCode status = U_ZERO_ERROR;
1877     UPerfFunction *testCase = new UniStrBinSearch(*collObj, coll, getSortedData16(status));
1878     if (U_FAILURE(status)) {
1879         delete testCase;
1880         return NULL;
1881     }
1882     return testCase;
1883 }
1884
1885 UPerfFunction* CollPerf2Test::TestStringPieceBinSearchCpp() {
1886     UErrorCode status = U_ZERO_ERROR;
1887     UPerfFunction *testCase = new StringPieceBinSearchCpp(*collObj, coll, getSortedData8(status));
1888     if (U_FAILURE(status)) {
1889         delete testCase;
1890         return NULL;
1891     }
1892     return testCase;
1893 }
1894
1895 UPerfFunction* CollPerf2Test::TestStringPieceBinSearchC() {
1896     UErrorCode status = U_ZERO_ERROR;
1897     UPerfFunction *testCase = new StringPieceBinSearchC(*collObj, coll, getSortedData8(status));
1898     if (U_FAILURE(status)) {
1899         delete testCase;
1900         return NULL;
1901     }
1902     return testCase;
1903 }
1904
1905
1906 int main(int argc, const char *argv[])
1907 {
1908     UErrorCode status = U_ZERO_ERROR;
1909     CollPerf2Test test(argc, argv, status);
1910
1911     if (U_FAILURE(status)){
1912         printf("The error is %s\n", u_errorName(status));
1913         //TODO: print usage here
1914         return status;
1915     }
1916
1917     if (test.run() == FALSE){
1918         fprintf(stderr, "FAILED: Tests could not be run please check the arguments.\n");
1919         return -1;
1920     }
1921     return 0;
1922 }