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