icuSources/test/intltest/tsmthred.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1999-2015, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7 #include "simplethread.h"
   8
   9 #include "unicode/utypes.h"
  10 #include "unicode/ustring.h"
  11 #include "umutex.h"
  12 #include "cmemory.h"
  13 #include "cstring.h"
  14 #include "uparse.h"
  15 #include "unicode/localpointer.h"
  16 #include "unicode/resbund.h"
  17 #include "unicode/udata.h"
  18 #include "unicode/uloc.h"
  19 #include "unicode/locid.h"
  20 #include "putilimp.h"
  21 #include "intltest.h"
  22 #include "tsmthred.h"
  23 #include "unicode/ushape.h"
  24 #include "unicode/translit.h"
  25 #include "sharedobject.h"
  26 #include "unifiedcache.h"
  27 #include "uassert.h"
  28
  29
  30 #define TSMTHREAD_FAIL(msg) errln("%s at file %s, line %d", msg, __FILE__, __LINE__)
  31 #define TSMTHREAD_ASSERT(expr) {if (!(expr)) {TSMTHREAD_FAIL("Fail");}}
  32 #define TSMTHREAD_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
  33                   errln("file: %s:%d status = %s\n", __FILE__, __LINE__, u_errorName(status));}}
  34
  35 MultithreadTest::MultithreadTest()
  36 {
  37 }
  38
  39 MultithreadTest::~MultithreadTest()
  40 {
  41 }
  42
  43 #include <stdio.h>
  44 #include <string.h>
  45 #include <ctype.h>    // tolower, toupper
  46
  47 #include "unicode/putil.h"
  48
  49 // for mthreadtest
  50 #include "unicode/numfmt.h"
  51 #include "unicode/choicfmt.h"
  52 #include "unicode/msgfmt.h"
  53 #include "unicode/locid.h"
  54 #include "unicode/coll.h"
  55 #include "unicode/calendar.h"
  56 #include "ucaconf.h"
  57
  58
  59 void MultithreadTest::runIndexedTest( int32_t index, UBool exec,
  60                 const char* &name, char* /*par*/ ) {
  61     if (exec)
  62         logln("TestSuite MultithreadTest: ");
  63     switch (index) {
  64     case 0:
  65         name = "TestThreads";
  66         if (exec)
  67             TestThreads();
  68         break;
  69
  70     case 1:
  71         name = "TestMutex";
  72         if (exec)
  73             TestMutex();
  74         break;
  75
  76     case 2:
  77         name = "TestThreadedIntl";
  78 #if !UCONFIG_NO_FORMATTING
  79         if (exec) {
  80             TestThreadedIntl();
  81         }
  82 #endif
  83         break;
  84
  85     case 3:
  86       name = "TestCollators";
  87 #if !UCONFIG_NO_COLLATION
  88       if (exec) {
  89             TestCollators();
  90       }
  91 #endif /* #if !UCONFIG_NO_COLLATION */
  92       break;
  93
  94     case 4:
  95         name = "TestString";
  96         if (exec) {
  97             TestString();
  98         }
  99         break;
 100
 101     case 5:
 102         name = "TestArabicShapingThreads";
 103         if (exec) {
 104             TestArabicShapingThreads();
 105         }
 106         break;
 107
 108     case 6:
 109         name = "TestAnyTranslit";
 110         if (exec) {
 111             TestAnyTranslit();
 112         }
 113         break;
 114
 115     case 7:
 116         name = "TestConditionVariables";
 117         if (exec) {
 118             TestConditionVariables();
 119         }
 120         break;
 121     case 8:
 122         name = "TestUnifiedCache";
 123         if (exec) {
 124             TestUnifiedCache();
 125         }
 126         break;
 127 #if !UCONFIG_NO_TRANSLITERATION
 128     case 9:
 129         name = "TestBreakTranslit";
 130         if (exec) {
 131             TestBreakTranslit();
 132         }
 133         break;
 134 #endif
 135     default:
 136         name = "";
 137         break; //needed to end loop
 138     }
 139 }
 140
 141
 142 //-----------------------------------------------------------------------------------
 143 //
 144 //   TestThreads -- see if threads really work at all.
 145 //
 146 //   Set up N threads pointing at N chars. When they are started, they will
 147 //   set their chars. At the end we make sure they are all set.
 148 //
 149 //-----------------------------------------------------------------------------------
 150
 151 class TestThreadsThread : public SimpleThread
 152 {
 153 public:
 154     TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }
 155     virtual void run() { Mutex m;
 156                          *fWhatToChange = '*';
 157     }
 158 private:
 159     char *fWhatToChange;
 160 };
 161
 162
 163 void MultithreadTest::TestThreads()
 164 {
 165     static const int32_t THREADTEST_NRTHREADS = 8;
 166     char threadTestChars[THREADTEST_NRTHREADS + 1];
 167     SimpleThread *threads[THREADTEST_NRTHREADS];
 168     int32_t numThreadsStarted = 0;
 169
 170     int32_t i;
 171     for(i=0;i<THREADTEST_NRTHREADS;i++)
 172     {
 173         threadTestChars[i] = ' ';
 174         threads[i] = new TestThreadsThread(&threadTestChars[i]);
 175     }
 176     threadTestChars[THREADTEST_NRTHREADS] = '\0';
 177
 178     logln("->" + UnicodeString(threadTestChars) + "<- Firing off threads.. ");
 179     for(i=0;i<THREADTEST_NRTHREADS;i++)
 180     {
 181         if (threads[i]->start() != 0) {
 182             errln("Error starting thread %d", i);
 183         }
 184         else {
 185             numThreadsStarted++;
 186         }
 187         logln(" Subthread started.");
 188     }
 189
 190     if (numThreadsStarted != THREADTEST_NRTHREADS) {
 191         errln("Not all threads could be started for testing!");
 192         return;
 193     }
 194
 195     logln("Waiting for threads to be set..");
 196     for(i=0; i<THREADTEST_NRTHREADS; i++) {
 197         threads[i]->join();
 198         if (threadTestChars[i] != '*') {
 199             errln("%s:%d Thread %d failed.", __FILE__, __LINE__, i);
 200         }
 201         delete threads[i];
 202     }
 203 }
 204
 205
 206 //-----------------------------------------------------------------------------------
 207 //
 208 //   TestArabicShapeThreads -- see if calls to u_shapeArabic in many threads works successfully
 209 //
 210 //   Set up N threads pointing at N chars. When they are started, they will make calls to doTailTest which tests
 211 //   u_shapeArabic, if the calls are successful it will the set * chars.
 212 //   At the end we make sure all threads managed to run u_shapeArabic successfully.
 213 //   This is a unit test for ticket 9473
 214 //
 215 //-----------------------------------------------------------------------------------
 216
 217 class TestArabicShapeThreads : public SimpleThread
 218 {
 219 public:
 220     TestArabicShapeThreads() {};
 221     virtual void run() { doTailTest(); };
 222 private:
 223         void doTailTest();
 224 };
 225
 226
 227 void TestArabicShapeThreads::doTailTest(void) {
 228     static const UChar src[] = { 0x0020, 0x0633, 0 };
 229     static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
 230     static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
 231     UChar dst[3] = { 0x0000, 0x0000,0 };
 232     int32_t length;
 233     UErrorCode status;
 234
 235     for (int32_t loopCount = 0; loopCount < 100; loopCount++) {
 236         status = U_ZERO_ERROR;
 237         length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
 238                 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
 239         if(U_FAILURE(status)) {
 240             IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
 241             return;
 242         } else if(length!=2) {
 243             IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
 244             return;
 245         } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
 246             IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
 247                     dst[0],dst[1],dst_old[0],dst_old[1]);
 248             return;
 249         }
 250
 251
 252         //"Trying new tail
 253         status = U_ZERO_ERROR;
 254         length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
 255                 U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
 256         if(U_FAILURE(status)) {
 257             IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
 258             return;
 259         } else if(length!=2) {
 260             IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
 261             return;
 262         } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
 263             IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
 264                     dst[0],dst[1],dst_new[0],dst_new[1]);
 265             return;
 266         }
 267     }
 268     return;
 269 }
 270
 271
 272 void MultithreadTest::TestArabicShapingThreads()
 273 {
 274     TestArabicShapeThreads threads[30];
 275
 276     int32_t i;
 277
 278     logln("-> do TestArabicShapingThreads <- Firing off threads.. ");
 279     for(i=0; i < UPRV_LENGTHOF(threads); i++) {
 280         if (threads[i].start() != 0) {
 281             errln("Error starting thread %d", i);
 282         }
 283     }
 284
 285     for(i=0; i < UPRV_LENGTHOF(threads); i++) {
 286         threads[i].join();
 287     }
 288     logln("->TestArabicShapingThreads <- Got all threads! cya");
 289 }
 290
 291
 292 //-----------------------------------------------------------------------
 293 //
 294 //  TestMutex  - a simple (non-stress) test to verify that ICU mutexes
 295 //               and condition variables are functioning.  Does not test the use of
 296 //               mutexes within ICU services, but rather that the
 297 //               platform's mutex support is at least superficially there.
 298 //
 299 //----------------------------------------------------------------------
 300 static UMutex         gTestMutexA          = U_MUTEX_INITIALIZER;
 301 static UConditionVar  gThreadsCountChanged = U_CONDITION_INITIALIZER;
 302
 303 static int     gThreadsStarted = 0;
 304 static int     gThreadsInMiddle = 0;
 305 static int     gThreadsDone = 0;
 306
 307 static const int TESTMUTEX_THREAD_COUNT = 40;
 308
 309 class TestMutexThread : public SimpleThread
 310 {
 311 public:
 312     virtual void run() {
 313         // This is the code that each of the spawned threads runs.
 314         // All threads move together throught the started - middle - done sequence together,
 315         // waiting for all other threads to reach each point before advancing.
 316         umtx_lock(&gTestMutexA);
 317         gThreadsStarted += 1;
 318         umtx_condBroadcast(&gThreadsCountChanged);
 319         while (gThreadsStarted < TESTMUTEX_THREAD_COUNT) {
 320             if (gThreadsInMiddle != 0) {
 321                 IntlTest::gTest->errln(
 322                     "%s:%d gThreadsInMiddle = %d. Expected 0.", __FILE__, __LINE__, gThreadsInMiddle);
 323                 return;
 324             }
 325             umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
 326         }
 327
 328         gThreadsInMiddle += 1;
 329         umtx_condBroadcast(&gThreadsCountChanged);
 330         while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
 331             if (gThreadsDone != 0) {
 332                 IntlTest::gTest->errln(
 333                     "%s:%d gThreadsDone = %d. Expected 0.", __FILE__, __LINE__, gThreadsDone);
 334                 return;
 335             }
 336             umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
 337         }
 338
 339         gThreadsDone += 1;
 340         umtx_condBroadcast(&gThreadsCountChanged);
 341         while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
 342             umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
 343         }
 344         umtx_unlock(&gTestMutexA);
 345     }
 346 };
 347
 348 void MultithreadTest::TestMutex()
 349 {
 350     gThreadsStarted = 0;
 351     gThreadsInMiddle = 0;
 352     gThreadsDone = 0;
 353     int32_t i = 0;
 354     TestMutexThread  threads[TESTMUTEX_THREAD_COUNT];
 355     umtx_lock(&gTestMutexA);
 356     for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
 357         if (threads[i].start() != 0) {
 358             errln("%s:%d Error starting thread %d", __FILE__, __LINE__, i);
 359             return;
 360         }
 361     }
 362
 363     // Because we are holding gTestMutexA, all of the threads should be blocked
 364     // at the start of their run() function.
 365     if (gThreadsStarted != 0) {
 366         errln("%s:%d gThreadsStarted=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
 367         return;
 368     }
 369
 370     while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
 371         if (gThreadsDone != 0) {
 372             errln("%s:%d gThreadsDone=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
 373             return;
 374         }
 375         umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
 376     }
 377
 378     while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
 379         umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
 380     }
 381     umtx_unlock(&gTestMutexA);
 382
 383     for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
 384         threads[i].join();
 385     }
 386 }
 387
 388
 389 //-------------------------------------------------------------------------------------------
 390 //
 391 //   TestMultithreadedIntl.  Test ICU Formatting in a multi-threaded environment
 392 //
 393 //-------------------------------------------------------------------------------------------
 394
 395
 396 // * Show exactly where the string's differences lie.
 397 UnicodeString showDifference(const UnicodeString& expected, const UnicodeString& result)
 398 {
 399     UnicodeString res;
 400     res = expected + "<Expected\n";
 401     if(expected.length() != result.length())
 402         res += " [ Different lengths ] \n";
 403     else
 404     {
 405         for(int32_t i=0;i<expected.length();i++)
 406         {
 407             if(expected[i] == result[i])
 408             {
 409                 res += " ";
 410             }
 411             else
 412             {
 413                 res += "|";
 414             }
 415         }
 416         res += "<Differences";
 417         res += "\n";
 418     }
 419     res += result + "<Result\n";
 420
 421     return res;
 422 }
 423
 424
 425 //-------------------------------------------------------------------------------------------
 426 //
 427 //   FormatThreadTest - a thread that tests performing a number of numberformats.
 428 //
 429 //-------------------------------------------------------------------------------------------
 430
 431 const int kFormatThreadIterations = 100;  // # of iterations per thread
 432 const int kFormatThreadThreads    = 10;  // # of threads to spawn
 433
 434 #if !UCONFIG_NO_FORMATTING
 435
 436
 437
 438 struct FormatThreadTestData
 439 {
 440     double number;
 441     UnicodeString string;
 442     FormatThreadTestData(double a, const UnicodeString& b) : number(a),string(b) {}
 443 } ;
 444
 445
 446 // "Someone from {2} is receiving a #{0} error - {1}. Their telephone call is costing {3 number,currency}."
 447
 448 static void formatErrorMessage(UErrorCode &realStatus, const UnicodeString& pattern, const Locale& theLocale,
 449                      UErrorCode inStatus0, /* statusString 1 */ const Locale &inCountry2, double currency3, // these numbers are the message arguments.
 450                      UnicodeString &result)
 451 {
 452     if(U_FAILURE(realStatus))
 453         return; // you messed up
 454
 455     UnicodeString errString1(u_errorName(inStatus0));
 456
 457     UnicodeString countryName2;
 458     inCountry2.getDisplayCountry(theLocale,countryName2);
 459
 460     Formattable myArgs[] = {
 461         Formattable((int32_t)inStatus0),   // inStatus0      {0}
 462         Formattable(errString1), // statusString1 {1}
 463         Formattable(countryName2),  // inCountry2 {2}
 464         Formattable(currency3)// currency3  {3,number,currency}
 465     };
 466
 467     MessageFormat *fmt = new MessageFormat("MessageFormat's API is broken!!!!!!!!!!!",realStatus);
 468     fmt->setLocale(theLocale);
 469     fmt->applyPattern(pattern, realStatus);
 470
 471     if (U_FAILURE(realStatus)) {
 472         delete fmt;
 473         return;
 474     }
 475
 476     FieldPosition ignore = 0;
 477     fmt->format(myArgs,4,result,ignore,realStatus);
 478
 479     delete fmt;
 480 }
 481
 482 /**
 483   * Shared formatters &  data used by instances of ThreadSafeFormat.
 484   * Exactly one instance of this class is created, and it is then shared concurrently
 485   * by the multiple instances of ThreadSafeFormat.
 486   */
 487 class ThreadSafeFormatSharedData {
 488   public:
 489     ThreadSafeFormatSharedData(UErrorCode &status);
 490     ~ThreadSafeFormatSharedData();
 491     LocalPointer<NumberFormat>  fFormat;
 492     Formattable    fYDDThing;
 493     Formattable    fBBDThing;
 494     UnicodeString  fYDDStr;
 495     UnicodeString  fBBDStr;
 496 };
 497
 498 const ThreadSafeFormatSharedData *gSharedData = NULL;
 499
 500 ThreadSafeFormatSharedData::ThreadSafeFormatSharedData(UErrorCode &status) {
 501     fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
 502     static const UChar kYDD[] = { 0x59, 0x44, 0x44, 0x00 };
 503     static const UChar kBBD[] = { 0x42, 0x42, 0x44, 0x00 };
 504     fYDDThing.adoptObject(new CurrencyAmount(123.456, kYDD, status));
 505     fBBDThing.adoptObject(new CurrencyAmount(987.654, kBBD, status));
 506     if (U_FAILURE(status)) {
 507         return;
 508     }
 509     fFormat->format(fYDDThing, fYDDStr, NULL, status);
 510     fFormat->format(fBBDThing, fBBDStr, NULL, status);
 511     gSharedData = this;
 512 }
 513
 514 ThreadSafeFormatSharedData::~ThreadSafeFormatSharedData() {
 515     gSharedData = NULL;
 516 }
 517
 518 /**
 519  * Class for thread-safe testing of format.
 520  *   Instances of this class appear as members of class FormatThreadTest.
 521  *   Multiple instances of FormatThreadTest coexist.
 522  *   ThreadSafeFormat::doStuff() is called concurrently to test the thread safety of
 523  *   various shared format operations.
 524  */
 525 class ThreadSafeFormat {
 526 public:
 527   /* give a unique offset to each thread */
 528   ThreadSafeFormat(UErrorCode &status);
 529   UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const;
 530 private:
 531   LocalPointer<NumberFormat> fFormat; // formatter - en_US constructed currency
 532 };
 533
 534
 535 ThreadSafeFormat::ThreadSafeFormat(UErrorCode &status) {
 536   fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
 537 }
 538
 539 static const UChar kUSD[] = { 0x55, 0x53, 0x44, 0x00 };
 540
 541 UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const {
 542   UBool okay = TRUE;
 543
 544   if(u_strcmp(fFormat->getCurrency(), kUSD)) {
 545     appendErr.append("fFormat currency != ")
 546       .append(kUSD)
 547       .append(", =")
 548       .append(fFormat->getCurrency())
 549       .append("! ");
 550     okay = FALSE;
 551   }
 552
 553   if(u_strcmp(gSharedData->fFormat->getCurrency(), kUSD)) {
 554     appendErr.append("gFormat currency != ")
 555       .append(kUSD)
 556       .append(", =")
 557       .append(gSharedData->fFormat->getCurrency())
 558       .append("! ");
 559     okay = FALSE;
 560   }
 561   UnicodeString str;
 562   const UnicodeString *o=NULL;
 563   Formattable f;
 564   const NumberFormat *nf = NULL; // only operate on it as const.
 565   switch(offset%4) {
 566   case 0:  f = gSharedData->fYDDThing;  o = &gSharedData->fYDDStr;  nf = gSharedData->fFormat.getAlias();  break;
 567   case 1:  f = gSharedData->fBBDThing;  o = &gSharedData->fBBDStr;  nf = gSharedData->fFormat.getAlias();  break;
 568   case 2:  f = gSharedData->fYDDThing;  o = &gSharedData->fYDDStr;  nf = fFormat.getAlias();  break;
 569   case 3:  f = gSharedData->fBBDThing;  o = &gSharedData->fBBDStr;  nf = fFormat.getAlias();  break;
 570   }
 571   nf->format(f, str, NULL, status);
 572
 573   if(*o != str) {
 574     appendErr.append(showDifference(*o, str));
 575     okay = FALSE;
 576   }
 577   return okay;
 578 }
 579
 580 UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInfo *) {
 581     return TRUE;
 582 }
 583
 584 //static UMTX debugMutex = NULL;
 585 //static UMTX gDebugMutex;
 586
 587
 588 class FormatThreadTest : public SimpleThread
 589 {
 590 public:
 591     int     fNum;
 592     int     fTraceInfo;
 593
 594     LocalPointer<ThreadSafeFormat> fTSF;
 595
 596     FormatThreadTest() // constructor is NOT multithread safe.
 597         : SimpleThread(),
 598         fNum(0),
 599         fTraceInfo(0),
 600         fTSF(NULL),
 601         fOffset(0)
 602         // the locale to use
 603     {
 604         UErrorCode status = U_ZERO_ERROR;      // TODO: rearrange code to allow checking of status.
 605         fTSF.adoptInstead(new ThreadSafeFormat(status));
 606         static int32_t fgOffset = 0;
 607         fgOffset += 3;
 608         fOffset = fgOffset;
 609     }
 610
 611
 612     virtual void run()
 613     {
 614         fTraceInfo                     = 1;
 615         LocalPointer<NumberFormat> percentFormatter;
 616         UErrorCode status = U_ZERO_ERROR;
 617
 618 #if 0
 619         // debugging code,
 620         for (int i=0; i<4000; i++) {
 621             status = U_ZERO_ERROR;
 622             UDataMemory *data1 = udata_openChoice(0, "res", "en_US", isAcceptable, 0, &status);
 623             UDataMemory *data2 = udata_openChoice(0, "res", "fr", isAcceptable, 0, &status);
 624             udata_close(data1);
 625             udata_close(data2);
 626             if (U_FAILURE(status)) {
 627                 error("udata_openChoice failed.\n");
 628                 break;
 629             }
 630         }
 631         return;
 632 #endif
 633
 634 #if 0
 635         // debugging code,
 636         int m;
 637         for (m=0; m<4000; m++) {
 638             status         = U_ZERO_ERROR;
 639             UResourceBundle *res   = NULL;
 640             const char *localeName = NULL;
 641
 642             Locale  loc = Locale::getEnglish();
 643
 644             localeName = loc.getName();
 645             // localeName = "en";
 646
 647             // ResourceBundle bund = ResourceBundle(0, loc, status);
 648             //umtx_lock(&gDebugMutex);
 649             res = ures_open(NULL, localeName, &status);
 650             //umtx_unlock(&gDebugMutex);
 651
 652             //umtx_lock(&gDebugMutex);
 653             ures_close(res);
 654             //umtx_unlock(&gDebugMutex);
 655
 656             if (U_FAILURE(status)) {
 657                 error("Resource bundle construction failed.\n");
 658                 break;
 659             }
 660         }
 661         return;
 662 #endif
 663
 664         // Keep this data here to avoid static initialization.
 665         FormatThreadTestData kNumberFormatTestData[] =
 666         {
 667             FormatThreadTestData((double)5.0, UnicodeString("5", "")),
 668                 FormatThreadTestData( 6.0, UnicodeString("6", "")),
 669                 FormatThreadTestData( 20.0, UnicodeString("20", "")),
 670                 FormatThreadTestData( 8.0, UnicodeString("8", "")),
 671                 FormatThreadTestData( 8.3, UnicodeString("8.3", "")),
 672                 FormatThreadTestData( 12345, UnicodeString("12,345", "")),
 673                 FormatThreadTestData( 81890.23, UnicodeString("81,890.23", "")),
 674         };
 675         int32_t kNumberFormatTestDataLength = UPRV_LENGTHOF(kNumberFormatTestData);
 676
 677         // Keep this data here to avoid static initialization.
 678         FormatThreadTestData kPercentFormatTestData[] =
 679         {
 680             FormatThreadTestData((double)5.0, CharsToUnicodeString("500\\u00a0%")),
 681                 FormatThreadTestData( 1.0, CharsToUnicodeString("100\\u00a0%")),
 682                 FormatThreadTestData( 0.26, CharsToUnicodeString("26\\u00a0%")),
 683                 FormatThreadTestData(
 684                    16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499\\u00a0%")), // U+00a0 = NBSP
 685                 FormatThreadTestData(
 686                     81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023\\u00a0%")),
 687         };
 688         int32_t kPercentFormatTestDataLength = UPRV_LENGTHOF(kPercentFormatTestData);
 689         int32_t iteration;
 690
 691         status = U_ZERO_ERROR;
 692         LocalPointer<NumberFormat> formatter(NumberFormat::createInstance(Locale::getEnglish(),status));
 693         if(U_FAILURE(status)) {
 694             IntlTest::gTest->dataerrln("%s:%d Error %s on NumberFormat::createInstance().",
 695                     __FILE__, __LINE__, u_errorName(status));
 696             goto cleanupAndReturn;
 697         }
 698
 699         percentFormatter.adoptInstead(NumberFormat::createPercentInstance(Locale::getFrench(),status));
 700         if(U_FAILURE(status))             {
 701             IntlTest::gTest->errln("%s:%d Error %s on NumberFormat::createPercentInstance().",
 702                     __FILE__, __LINE__, u_errorName(status));
 703             goto cleanupAndReturn;
 704         }
 705
 706         for(iteration = 0;!IntlTest::gTest->getErrors() && iteration<kFormatThreadIterations;iteration++)
 707         {
 708
 709             int32_t whichLine = (iteration + fOffset)%kNumberFormatTestDataLength;
 710
 711             UnicodeString  output;
 712
 713             formatter->format(kNumberFormatTestData[whichLine].number, output);
 714
 715             if(0 != output.compare(kNumberFormatTestData[whichLine].string)) {
 716                 IntlTest::gTest->errln("format().. expected " + kNumberFormatTestData[whichLine].string
 717                         + " got " + output);
 718                 goto cleanupAndReturn;
 719             }
 720
 721             // Now check percent.
 722             output.remove();
 723             whichLine = (iteration + fOffset)%kPercentFormatTestDataLength;
 724
 725             percentFormatter->format(kPercentFormatTestData[whichLine].number, output);
 726             if(0 != output.compare(kPercentFormatTestData[whichLine].string))
 727             {
 728                 IntlTest::gTest->errln("percent format().. \n" +
 729                         showDifference(kPercentFormatTestData[whichLine].string,output));
 730                 goto cleanupAndReturn;
 731             }
 732
 733             // Test message error
 734             const int       kNumberOfMessageTests = 3;
 735             UErrorCode      statusToCheck;
 736             UnicodeString   patternToCheck;
 737             Locale          messageLocale;
 738             Locale          countryToCheck;
 739             double          currencyToCheck;
 740
 741             UnicodeString   expected;
 742
 743             // load the cases.
 744             switch((iteration+fOffset) % kNumberOfMessageTests)
 745             {
 746             default:
 747             case 0:
 748                 statusToCheck=                      U_FILE_ACCESS_ERROR;
 749                 patternToCheck=        "0:Someone from {2} is receiving a #{0}"
 750                                        " error - {1}. Their telephone call is costing "
 751                                        "{3,number,currency}."; // number,currency
 752                 messageLocale=                      Locale("en","US");
 753                 countryToCheck=                     Locale("","HR");
 754                 currencyToCheck=                    8192.77;
 755                 expected=  "0:Someone from Croatia is receiving a #4 error - "
 756                             "U_FILE_ACCESS_ERROR. Their telephone call is costing $8,192.77.";
 757                 break;
 758             case 1:
 759                 statusToCheck=                      U_INDEX_OUTOFBOUNDS_ERROR;
 760                 patternToCheck=                     "1:A customer in {2} is receiving a #{0} error - {1}. "
 761                                                     "Their telephone call is costing {3,number,currency}."; // number,currency
 762                 messageLocale=                      Locale("de","DE@currency=DEM");
 763                 countryToCheck=                     Locale("","BF");
 764                 currencyToCheck=                    2.32;
 765                 expected=                           CharsToUnicodeString(
 766                                                     "1:A customer in Burkina Faso is receiving a #8 error - U_INDEX_OUTOFBOUNDS_ERROR. "
 767                                                     "Their telephone call is costing 2,32\\u00A0DM.");
 768                 break;
 769             case 2:
 770                 statusToCheck=                      U_MEMORY_ALLOCATION_ERROR;
 771                 patternToCheck=   "2:user in {2} is receiving a #{0} error - {1}. "
 772                                   "They insist they just spent {3,number,currency} "
 773                                   "on memory."; // number,currency
 774                 messageLocale=                      Locale("de","AT@currency=ATS"); // Austrian German
 775                 countryToCheck=                     Locale("","US"); // hmm
 776                 currencyToCheck=                    40193.12;
 777                 expected=       CharsToUnicodeString(
 778                             "2:user in Vereinigte Staaten is receiving a #7 error"
 779                             " - U_MEMORY_ALLOCATION_ERROR. They insist they just spent"
 780                             " \\u00f6S\\u00A040.193,12 on memory.");
 781                 break;
 782             }
 783
 784             UnicodeString result;
 785             UErrorCode status = U_ZERO_ERROR;
 786             formatErrorMessage(status,patternToCheck,messageLocale,statusToCheck,
 787                                 countryToCheck,currencyToCheck,result);
 788             if(U_FAILURE(status))
 789             {
 790                 UnicodeString tmp(u_errorName(status));
 791                 IntlTest::gTest->errln("Failure on message format, pattern=" + patternToCheck +
 792                         ", error = " + tmp);
 793                 goto cleanupAndReturn;
 794             }
 795
 796             if(result != expected)
 797             {
 798                 IntlTest::gTest->errln("PatternFormat: \n" + showDifference(expected,result));
 799                 goto cleanupAndReturn;
 800             }
 801             // test the Thread Safe Format
 802             UnicodeString appendErr;
 803             if(!fTSF->doStuff(fNum, appendErr, status)) {
 804               IntlTest::gTest->errln(appendErr);
 805               goto cleanupAndReturn;
 806             }
 807         }   /*  end of for loop */
 808
 809
 810
 811 cleanupAndReturn:
 812         fTraceInfo = 2;
 813     }
 814
 815 private:
 816     int32_t fOffset; // where we are testing from.
 817 };
 818
 819 // ** The actual test function.
 820
 821 void MultithreadTest::TestThreadedIntl()
 822 {
 823     UnicodeString theErr;
 824
 825     UErrorCode threadSafeErr = U_ZERO_ERROR;
 826
 827     ThreadSafeFormatSharedData sharedData(threadSafeErr);
 828     assertSuccess("initializing ThreadSafeFormat", threadSafeErr, TRUE);
 829
 830     //
 831     //  Create and start the test threads
 832     //
 833     logln("Spawning: %d threads * %d iterations each.",
 834                 kFormatThreadThreads, kFormatThreadIterations);
 835     FormatThreadTest tests[kFormatThreadThreads];
 836     int32_t j;
 837     for(j = 0; j < UPRV_LENGTHOF(tests); j++) {
 838         tests[j].fNum = j;
 839         int32_t threadStatus = tests[j].start();
 840         if (threadStatus != 0) {
 841             errln("%s:%d System Error %d starting thread number %d.",
 842                     __FILE__, __LINE__, threadStatus, j);
 843             return;
 844         }
 845     }
 846
 847
 848     for (j=0; j<UPRV_LENGTHOF(tests); j++) {
 849         tests[j].join();
 850         logln("Thread # %d is complete..", j);
 851     }
 852 }
 853 #endif /* #if !UCONFIG_NO_FORMATTING */
 854
 855
 856
 857
 858
 859 //-------------------------------------------------------------------------------------------
 860 //
 861 // Collation threading test
 862 //
 863 //-------------------------------------------------------------------------------------------
 864 #if !UCONFIG_NO_COLLATION
 865
 866 #define kCollatorThreadThreads   10  // # of threads to spawn
 867 #define kCollatorThreadPatience kCollatorThreadThreads*30
 868
 869 struct Line {
 870     UChar buff[25];
 871     int32_t buflen;
 872 } ;
 873
 874 static UBool
 875 skipLineBecauseOfBug(const UChar *s, int32_t length) {
 876     // TODO: Fix ICU ticket #8052
 877     if(length >= 3 &&
 878             (s[0] == 0xfb2 || s[0] == 0xfb3) &&
 879             s[1] == 0x334 &&
 880             (s[2] == 0xf73 || s[2] == 0xf75 || s[2] == 0xf81)) {
 881         return TRUE;
 882     }
 883     return FALSE;
 884 }
 885
 886 static UCollationResult
 887 normalizeResult(int32_t result) {
 888     return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;
 889 }
 890
 891 class CollatorThreadTest : public SimpleThread
 892 {
 893 private:
 894     const Collator *coll;
 895     const Line *lines;
 896     int32_t noLines;
 897     UBool isAtLeastUCA62;
 898 public:
 899     CollatorThreadTest()  : SimpleThread(),
 900         coll(NULL),
 901         lines(NULL),
 902         noLines(0),
 903         isAtLeastUCA62(TRUE)
 904     {
 905     };
 906     void setCollator(Collator *c, Line *l, int32_t nl, UBool atLeastUCA62)
 907     {
 908         coll = c;
 909         lines = l;
 910         noLines = nl;
 911         isAtLeastUCA62 = atLeastUCA62;
 912     }
 913     virtual void run() {
 914         uint8_t sk1[1024], sk2[1024];
 915         uint8_t *oldSk = NULL, *newSk = sk1;
 916         int32_t oldLen = 0;
 917         int32_t prev = 0;
 918         int32_t i = 0;
 919
 920         for(i = 0; i < noLines; i++) {
 921             if(lines[i].buflen == 0) { continue; }
 922
 923             if(skipLineBecauseOfBug(lines[i].buff, lines[i].buflen)) { continue; }
 924
 925             int32_t resLen = coll->getSortKey(lines[i].buff, lines[i].buflen, newSk, 1024);
 926
 927             if(oldSk != NULL) {
 928                 int32_t skres = strcmp((char *)oldSk, (char *)newSk);
 929                 int32_t cmpres = coll->compare(lines[prev].buff, lines[prev].buflen, lines[i].buff, lines[i].buflen);
 930                 int32_t cmpres2 = coll->compare(lines[i].buff, lines[i].buflen, lines[prev].buff, lines[prev].buflen);
 931
 932                 if(cmpres != -cmpres2) {
 933                     IntlTest::gTest->errln(UnicodeString("Compare result not symmetrical on line ") + (i + 1));
 934                     break;
 935                 }
 936
 937                 if(cmpres != normalizeResult(skres)) {
 938                     IntlTest::gTest->errln(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));
 939                     break;
 940                 }
 941
 942                 int32_t res = cmpres;
 943                 if(res == 0 && !isAtLeastUCA62) {
 944                     // Up to UCA 6.1, the collation test files use a custom tie-breaker,
 945                     // comparing the raw input strings.
 946                     res = u_strcmpCodePointOrder(lines[prev].buff, lines[i].buff);
 947                     // Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
 948                     // comparing the NFD versions of the input strings,
 949                     // which we do via setting strength=identical.
 950                 }
 951                 if(res > 0) {
 952                     IntlTest::gTest->errln(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));
 953                     break;
 954                 }
 955             }
 956
 957             oldSk = newSk;
 958             oldLen = resLen;
 959             (void)oldLen;   // Suppress set but not used warning.
 960             prev = i;
 961
 962             newSk = (newSk == sk1)?sk2:sk1;
 963         }
 964     }
 965 };
 966
 967 void MultithreadTest::TestCollators()
 968 {
 969
 970     UErrorCode status = U_ZERO_ERROR;
 971     FILE *testFile = NULL;
 972     char testDataPath[1024];
 973     strcpy(testDataPath, IntlTest::getSourceTestData(status));
 974     if (U_FAILURE(status)) {
 975         errln("ERROR: could not open test data %s", u_errorName(status));
 976         return;
 977     }
 978     strcat(testDataPath, "CollationTest_");
 979
 980     const char* type = "NON_IGNORABLE";
 981
 982     const char *ext = ".txt";
 983     if(testFile) {
 984         fclose(testFile);
 985     }
 986     char buffer[1024];
 987     strcpy(buffer, testDataPath);
 988     strcat(buffer, type);
 989     size_t bufLen = strlen(buffer);
 990
 991     // we try to open 3 files:
 992     // path/CollationTest_type.txt
 993     // path/CollationTest_type_SHORT.txt
 994     // path/CollationTest_type_STUB.txt
 995     // we are going to test with the first one that we manage to open.
 996
 997     strcpy(buffer+bufLen, ext);
 998
 999     testFile = fopen(buffer, "rb");
1000
1001     if(testFile == 0) {
1002         strcpy(buffer+bufLen, "_SHORT");
1003         strcat(buffer, ext);
1004         testFile = fopen(buffer, "rb");
1005
1006         if(testFile == 0) {
1007             strcpy(buffer+bufLen, "_STUB");
1008             strcat(buffer, ext);
1009             testFile = fopen(buffer, "rb");
1010
1011             if (testFile == 0) {
1012                 *(buffer+bufLen) = 0;
1013                 dataerrln("could not open any of the conformance test files, tried opening base %s", buffer);
1014                 return;
1015             } else {
1016                 infoln(
1017                     "INFO: Working with the stub file.\n"
1018                     "If you need the full conformance test, please\n"
1019                     "download the appropriate data files from:\n"
1020                     "http://source.icu-project.org/repos/icu/tools/trunk/unicodetools/com/ibm/text/data/");
1021             }
1022         }
1023     }
1024
1025     LocalArray<Line> lines(new Line[200000]);
1026     memset(lines.getAlias(), 0, sizeof(Line)*200000);
1027     int32_t lineNum = 0;
1028
1029     UChar bufferU[1024];
1030     uint32_t first = 0;
1031
1032     while (fgets(buffer, 1024, testFile) != NULL) {
1033         if(*buffer == 0 || buffer[0] == '#') {
1034             // Store empty and comment lines so that errors are reported
1035             // for the real test file lines.
1036             lines[lineNum].buflen = 0;
1037             lines[lineNum].buff[0] = 0;
1038         } else {
1039             int32_t buflen = u_parseString(buffer, bufferU, 1024, &first, &status);
1040             lines[lineNum].buflen = buflen;
1041             u_memcpy(lines[lineNum].buff, bufferU, buflen);
1042             lines[lineNum].buff[buflen] = 0;
1043         }
1044         lineNum++;
1045     }
1046     fclose(testFile);
1047     if(U_FAILURE(status)) {
1048       dataerrln("Couldn't read the test file!");
1049       return;
1050     }
1051
1052     UVersionInfo uniVersion;
1053     static const UVersionInfo v62 = { 6, 2, 0, 0 };
1054     u_getUnicodeVersion(uniVersion);
1055     UBool isAtLeastUCA62 = uprv_memcmp(uniVersion, v62, 4) >= 0;
1056
1057     LocalPointer<Collator> coll(Collator::createInstance(Locale::getRoot(), status));
1058     if(U_FAILURE(status)) {
1059         errcheckln(status, "Couldn't open UCA collator");
1060         return;
1061     }
1062     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
1063     coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
1064     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
1065     coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);
1066     coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, status);
1067
1068     int32_t spawnResult = 0;
1069     LocalArray<CollatorThreadTest> tests(new CollatorThreadTest[kCollatorThreadThreads]);
1070
1071     logln(UnicodeString("Spawning: ") + kCollatorThreadThreads + " threads * " + kFormatThreadIterations + " iterations each.");
1072     int32_t j = 0;
1073     for(j = 0; j < kCollatorThreadThreads; j++) {
1074         //logln("Setting collator %i", j);
1075         tests[j].setCollator(coll.getAlias(), lines.getAlias(), lineNum, isAtLeastUCA62);
1076     }
1077     for(j = 0; j < kCollatorThreadThreads; j++) {
1078         log("%i ", j);
1079         spawnResult = tests[j].start();
1080         if(spawnResult != 0) {
1081             errln("%s:%d THREAD INFO: thread %d failed to start with status %d", __FILE__, __LINE__, j, spawnResult);
1082             return;
1083         }
1084     }
1085     logln("Spawned all");
1086
1087     for(int32_t i=0;i<kCollatorThreadThreads;i++) {
1088         tests[i].join();
1089         //logln(UnicodeString("Test #") + i + " is complete.. ");
1090     }
1091 }
1092
1093 #endif /* #if !UCONFIG_NO_COLLATION */
1094
1095
1096
1097
1098 //-------------------------------------------------------------------------------------------
1099 //
1100 //   StringThreadTest2
1101 //
1102 //-------------------------------------------------------------------------------------------
1103
1104 const int kStringThreadIterations = 2500;// # of iterations per thread
1105 const int kStringThreadThreads    = 10;  // # of threads to spawn
1106
1107
1108 class StringThreadTest2 : public SimpleThread
1109 {
1110 public:
1111     int                 fNum;
1112     int                 fTraceInfo;
1113     static const UnicodeString *gSharedString;
1114
1115     StringThreadTest2() // constructor is NOT multithread safe.
1116         : SimpleThread(),
1117         fTraceInfo(0)
1118     {
1119     };
1120
1121
1122     virtual void run()
1123     {
1124         fTraceInfo    = 1;
1125         int loopCount = 0;
1126
1127         for (loopCount = 0; loopCount < kStringThreadIterations; loopCount++) {
1128             if (*gSharedString != "This is the original test string.") {
1129                 IntlTest::gTest->errln("%s:%d Original string is corrupt.", __FILE__, __LINE__);
1130                 break;
1131             }
1132             UnicodeString s1 = *gSharedString;
1133             s1 += "cat this";
1134             UnicodeString s2(s1);
1135             UnicodeString s3 = *gSharedString;
1136             s2 = s3;
1137             s3.truncate(12);
1138             s2.truncate(0);
1139         }
1140
1141         fTraceInfo = 2;
1142     }
1143
1144 };
1145
1146 const UnicodeString *StringThreadTest2::gSharedString = NULL;
1147
1148 // ** The actual test function.
1149
1150
1151 void MultithreadTest::TestString()
1152 {
1153     int     j;
1154     StringThreadTest2::gSharedString = new UnicodeString("This is the original test string.");
1155     StringThreadTest2  tests[kStringThreadThreads];
1156
1157     logln(UnicodeString("Spawning: ") + kStringThreadThreads + " threads * " + kStringThreadIterations + " iterations each.");
1158     for(j = 0; j < kStringThreadThreads; j++) {
1159         int32_t threadStatus = tests[j].start();
1160         if (threadStatus != 0) {
1161             errln("%s:%d System Error %d starting thread number %d.", __FILE__, __LINE__, threadStatus, j);
1162         }
1163     }
1164
1165     // Force a failure, to verify test is functioning and can report errors.
1166     // const_cast<UnicodeString *>(StringThreadTest2::gSharedString)->setCharAt(5, 'x');
1167
1168     for(j=0; j<kStringThreadThreads; j++) {
1169         tests[j].join();
1170         logln(UnicodeString("Test #") + j + " is complete.. ");
1171     }
1172
1173     delete StringThreadTest2::gSharedString;
1174     StringThreadTest2::gSharedString = NULL;
1175 }
1176
1177
1178 //
1179 // Test for ticket #10673, race in cache code in AnyTransliterator.
1180 // It's difficult to make the original unsafe code actually fail, but
1181 // this test will fairly reliably take the code path for races in
1182 // populating the cache.
1183 //
1184
1185 #if !UCONFIG_NO_TRANSLITERATION
1186 Transliterator *gSharedTranslit = NULL;
1187 class TxThread: public SimpleThread {
1188   public:
1189     TxThread() {};
1190     ~TxThread();
1191     void run();
1192 };
1193
1194 TxThread::~TxThread() {}
1195 void TxThread::run() {
1196     UnicodeString greekString("\\u03B4\\u03B9\\u03B1\\u03C6\\u03BF\\u03C1\\u03B5\\u03C4\\u03B9\\u03BA\\u03BF\\u03CD\\u03C2");
1197     greekString = greekString.unescape();
1198     gSharedTranslit->transliterate(greekString);
1199     if (greekString[0] != 0x64)      // 'd'. The whole transliterated string is "diaphoretikous" (accented u).
1200     {
1201         IntlTest::gTest->errln("%s:%d Transliteration failed.", __FILE__, __LINE__);
1202     }
1203 }
1204 #endif
1205
1206
1207 void MultithreadTest::TestAnyTranslit() {
1208 #if !UCONFIG_NO_TRANSLITERATION
1209     UErrorCode status = U_ZERO_ERROR;
1210     LocalPointer<Transliterator> tx(Transliterator::createInstance("Any-Latin", UTRANS_FORWARD, status));
1211     if (U_FAILURE(status)) {
1212         dataerrln("File %s, Line %d: Error, status = %s", __FILE__, __LINE__, u_errorName(status));
1213         return;
1214     }
1215     gSharedTranslit = tx.getAlias();
1216     TxThread  threads[4];
1217     int32_t i;
1218     for (i=0; i<UPRV_LENGTHOF(threads); i++) {
1219         threads[i].start();
1220     }
1221
1222     for (i=0; i<UPRV_LENGTHOF(threads); i++) {
1223         threads[i].join();
1224     }
1225     gSharedTranslit = NULL;
1226 #endif  // !UCONFIG_NO_TRANSLITERATION
1227 }
1228
1229
1230 //
1231 // Condition Variables Test
1232 //   Create a swarm of threads.
1233 //   Using a mutex and a condition variables each thread
1234 //     Increments a global count of started threads.
1235 //     Broadcasts that it has started.
1236 //     Waits on the condition that all threads have started.
1237 //     Increments a global count of finished threads.
1238 //     Waits on the condition that all threads have finished.
1239 //     Exits.
1240 //
1241
1242 class CondThread: public SimpleThread {
1243   public:
1244     CondThread() :fFinished(false)  {};
1245     ~CondThread() {};
1246     void run();
1247     bool  fFinished;
1248 };
1249
1250 static UMutex gCTMutex = U_MUTEX_INITIALIZER;
1251 static UConditionVar gCTConditionVar = U_CONDITION_INITIALIZER;
1252 int gConditionTestOne = 1;   // Value one. Non-const, extern linkage to inhibit
1253                              //   compiler assuming a known value.
1254 int gStartedThreads;
1255 int gFinishedThreads;
1256 static const int NUMTHREADS = 10;
1257
1258
1259 // Worker thread function.
1260 void CondThread::run() {
1261     umtx_lock(&gCTMutex);
1262     gStartedThreads += gConditionTestOne;
1263     umtx_condBroadcast(&gCTConditionVar);
1264
1265     while (gStartedThreads < NUMTHREADS) {
1266         if (gFinishedThreads != 0) {
1267             IntlTest::gTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d",
1268                              __FILE__, __LINE__, gStartedThreads, gFinishedThreads);
1269         }
1270         umtx_condWait(&gCTConditionVar, &gCTMutex);
1271     }
1272
1273     gFinishedThreads += gConditionTestOne;
1274     fFinished = true;
1275     umtx_condBroadcast(&gCTConditionVar);
1276
1277     while (gFinishedThreads < NUMTHREADS) {
1278         umtx_condWait(&gCTConditionVar, &gCTMutex);
1279     }
1280     umtx_unlock(&gCTMutex);
1281 }
1282
1283 void MultithreadTest::TestConditionVariables() {
1284     gStartedThreads = 0;
1285     gFinishedThreads = 0;
1286     int i;
1287
1288     umtx_lock(&gCTMutex);
1289     CondThread *threads[NUMTHREADS];
1290     for (i=0; i<NUMTHREADS; ++i) {
1291         threads[i] = new CondThread;
1292         threads[i]->start();
1293     }
1294
1295     while (gStartedThreads < NUMTHREADS) {
1296         umtx_condWait(&gCTConditionVar, &gCTMutex);
1297     }
1298
1299     while (gFinishedThreads < NUMTHREADS) {
1300         umtx_condWait(&gCTConditionVar, &gCTMutex);
1301     }
1302
1303     umtx_unlock(&gCTMutex);
1304
1305     for (i=0; i<NUMTHREADS; ++i) {
1306         if (!threads[i]->fFinished) {
1307             errln("File %s, Line %d: Error, threads[%d]->fFinished == false", __FILE__, __LINE__, i);
1308         }
1309     }
1310
1311     for (i=0; i<NUMTHREADS; ++i) {
1312         threads[i]->join();
1313         delete threads[i];
1314     }
1315 }
1316
1317
1318 //
1319 // Unified Cache Test
1320 //
1321
1322 // Each thread fetches a pair of objects. There are 8 distinct pairs:
1323 // ("en_US", "bs"), ("en_GB", "ca"), ("fr_FR", "ca_AD") etc.
1324 // These pairs represent 8 distinct languages
1325
1326 // Note that only one value per language gets created in the cache.
1327 // In particular each cached value can have multiple keys.
1328 static const char *gCacheLocales[] = {
1329     "en_US", "en_GB", "fr_FR", "fr",
1330     "de", "sr_ME", "sr_BA", "sr_CS"};
1331 static const char *gCacheLocales2[] = {
1332     "bs", "ca", "ca_AD", "ca_ES",
1333     "en_US", "fi", "ff_CM", "ff_GN"};
1334
1335 static int32_t gObjectsCreated = 0;  // protected by gCTMutex
1336 static const int32_t CACHE_LOAD = 3;
1337
1338 class UCTMultiThreadItem : public SharedObject {
1339   public:
1340     char *value;
1341     UCTMultiThreadItem(const char *x) : value(NULL) {
1342         value = uprv_strdup(x);
1343     }
1344     virtual ~UCTMultiThreadItem() {
1345         uprv_free(value);
1346     }
1347 };
1348
1349 U_NAMESPACE_BEGIN
1350
1351 template<> U_EXPORT
1352 const UCTMultiThreadItem *LocaleCacheKey<UCTMultiThreadItem>::createObject(
1353         const void *context, UErrorCode &status) const {
1354     const UnifiedCache *cacheContext = (const UnifiedCache *) context;
1355
1356     if (uprv_strcmp(fLoc.getLanguage(), fLoc.getName()) != 0) {
1357         const UCTMultiThreadItem *result = NULL;
1358         if (cacheContext == NULL) {
1359             UnifiedCache::getByLocale(fLoc.getLanguage(), result, status);
1360             return result;
1361         }
1362         cacheContext->get(LocaleCacheKey<UCTMultiThreadItem>(fLoc.getLanguage()), result, status);
1363         return result;
1364     }
1365
1366     umtx_lock(&gCTMutex);
1367     bool firstObject = (gObjectsCreated == 0);
1368     if (firstObject) {
1369         // Force the first object creation that comes through to wait
1370         // until other have completed. Verifies that cache doesn't
1371         // deadlock when a creation is slow.
1372
1373         // Note that gObjectsCreated needs to be incremeneted from 0 to 1
1374         // early, to keep subsequent threads from entering this path.
1375         gObjectsCreated = 1;
1376         while (gObjectsCreated < 3) {
1377             umtx_condWait(&gCTConditionVar, &gCTMutex);
1378         }
1379     }
1380     umtx_unlock(&gCTMutex);
1381
1382     const UCTMultiThreadItem *result =
1383         new UCTMultiThreadItem(fLoc.getLanguage());
1384     if (result == NULL) {
1385         status = U_MEMORY_ALLOCATION_ERROR;
1386     } else {
1387         result->addRef();
1388     }
1389
1390     // Log that we created an object. The first object was already counted,
1391     //    don't do it again.
1392     umtx_lock(&gCTMutex);
1393     if (!firstObject) {
1394         gObjectsCreated += 1;
1395     }
1396     umtx_condBroadcast(&gCTConditionVar);
1397     umtx_unlock(&gCTMutex);
1398
1399     return result;
1400 }
1401
1402 U_NAMESPACE_END
1403
1404 class UnifiedCacheThread: public SimpleThread {
1405   public:
1406     UnifiedCacheThread(
1407             const UnifiedCache *cache,
1408             const char *loc,
1409             const char *loc2) : fCache(cache), fLoc(loc), fLoc2(loc2) {};
1410     ~UnifiedCacheThread() {};
1411     void run();
1412     void exerciseByLocale(const Locale &);
1413     const UnifiedCache *fCache;
1414     Locale fLoc;
1415     Locale fLoc2;
1416 };
1417
1418 void UnifiedCacheThread::exerciseByLocale(const Locale &locale) {
1419     UErrorCode status = U_ZERO_ERROR;
1420     const UCTMultiThreadItem *origItem = NULL;
1421     fCache->get(
1422             LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, origItem, status);
1423     U_ASSERT(U_SUCCESS(status));
1424     if (uprv_strcmp(locale.getLanguage(), origItem->value)) {
1425       IntlTest::gTest->errln(
1426               "%s:%d Expected %s, got %s", __FILE__, __LINE__,
1427               locale.getLanguage(),
1428               origItem->value);
1429     }
1430
1431     // Fetch the same item again many times. We should always get the same
1432     // pointer since this client is already holding onto it
1433     for (int32_t i = 0; i < 1000; ++i) {
1434         const UCTMultiThreadItem *item = NULL;
1435         fCache->get(
1436                 LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, item, status);
1437         if (item != origItem) {
1438             IntlTest::gTest->errln(
1439                     "%s:%d Expected to get the same pointer",
1440                      __FILE__,
1441                      __LINE__);
1442         }
1443         if (item != NULL) {
1444             item->removeRef();
1445         }
1446     }
1447     origItem->removeRef();
1448 }
1449
1450 void UnifiedCacheThread::run() {
1451     // Run the exercise with 2 different locales so that we can exercise
1452     // eviction more. If each thread exerices just one locale, then
1453     // eviction can't start until the threads end.
1454     exerciseByLocale(fLoc);
1455     exerciseByLocale(fLoc2);
1456 }
1457
1458 void MultithreadTest::TestUnifiedCache() {
1459
1460     // Start with our own local cache so that we have complete control
1461     // and set the eviction policy to evict starting with 2 unused
1462     // values
1463     UErrorCode status = U_ZERO_ERROR;
1464     UnifiedCache::getInstance(status);
1465     UnifiedCache cache(status);
1466     cache.setEvictionPolicy(2, 0, status);
1467     U_ASSERT(U_SUCCESS(status));
1468
1469     gFinishedThreads = 0;
1470     gObjectsCreated = 0;
1471
1472     UnifiedCacheThread *threads[CACHE_LOAD][UPRV_LENGTHOF(gCacheLocales)];
1473     for (int32_t i=0; i<CACHE_LOAD; ++i) {
1474         for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
1475             // Each thread works with a pair of locales.
1476             threads[i][j] = new UnifiedCacheThread(
1477                     &cache, gCacheLocales[j], gCacheLocales2[j]);
1478             threads[i][j]->start();
1479         }
1480     }
1481
1482     for (int32_t i=0; i<CACHE_LOAD; ++i) {
1483         for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
1484             threads[i][j]->join();
1485         }
1486     }
1487     // Because of cache eviction, we can't assert exactly how many
1488     // distinct objects get created over the course of this run.
1489     // However we know that at least 8 objects get created because that
1490     // is how many distinct languages we have in our test.
1491     if (gObjectsCreated < 8) {
1492         errln("%s:%d Too few objects created.", __FILE__, __LINE__);
1493     }
1494     // We know that each thread cannot create more than 2 objects in
1495     // the cache, and there are UPRV_LENGTHOF(gCacheLocales) pairs of
1496     // objects fetched from the cache. If the threads run in series because
1497     // of eviction, at worst case each thread creates two objects.
1498     if (gObjectsCreated > 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales)) {
1499         errln("%s:%d Too many objects created, got %d, expected %d", __FILE__, __LINE__, gObjectsCreated, 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales));
1500
1501     }
1502
1503     assertEquals("unused values", 2, cache.unusedCount());
1504
1505     // clean up threads
1506     for (int32_t i=0; i<CACHE_LOAD; ++i) {
1507         for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
1508             delete threads[i][j];
1509         }
1510     }
1511 }
1512
1513 #if !UCONFIG_NO_TRANSLITERATION
1514 //
1515 //  BreakTransliterator Threading Test
1516 //     This is a test for bug #11603. Test verified to fail prior to fix.
1517 //
1518
1519 static const Transliterator *gSharedTransliterator;
1520 static const UnicodeString *gTranslitInput;
1521 static const UnicodeString *gTranslitExpected;
1522
1523 class BreakTranslitThread: public SimpleThread {
1524   public:
1525     BreakTranslitThread() {};
1526     ~BreakTranslitThread() {};
1527     void run();
1528 };
1529
1530 void BreakTranslitThread::run() {
1531     for (int i=0; i<10; i++) {
1532         icu::UnicodeString s(*gTranslitInput);
1533         gSharedTransliterator->transliterate(s);
1534         if (*gTranslitExpected != s) {
1535             IntlTest::gTest->errln("%s:%d Transliteration threading failure.", __FILE__, __LINE__);
1536             break;
1537         }
1538     }
1539 }
1540
1541 void MultithreadTest::TestBreakTranslit() {
1542     UErrorCode status = U_ZERO_ERROR;
1543     UnicodeString input(
1544         "\\u0E42\\u0E14\\u0E22\\u0E1E\\u0E37\\u0E49\\u0E19\\u0E10\\u0E32\\u0E19\\u0E41\\u0E25\\u0E49\\u0E27,");
1545     input = input.unescape();
1546     gTranslitInput = &input;
1547
1548     gSharedTransliterator = Transliterator::createInstance(
1549         UNICODE_STRING_SIMPLE("Any-Latin; Lower; NFD; [:Diacritic:]Remove; NFC; Latin-ASCII;"), UTRANS_FORWARD, status);
1550     if (!gSharedTransliterator) {
1551          return;
1552      }
1553     TSMTHREAD_ASSERT_SUCCESS(status);
1554
1555     UnicodeString expected(*gTranslitInput);
1556     gSharedTransliterator->transliterate(expected);
1557     gTranslitExpected = &expected;
1558
1559     BreakTranslitThread threads[4];
1560     for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
1561         threads[i].start();
1562     }
1563     for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
1564         threads[i].join();
1565     }
1566
1567     delete gSharedTransliterator;
1568     gTranslitInput = NULL;
1569     gTranslitExpected = NULL;
1570 }
1571
1572 #endif /* !UCONFIG_NO_TRANSLITERATION */