| Index: source/test/intltest/tsmthred.cpp
|
| diff --git a/source/test/intltest/tsmthred.cpp b/source/test/intltest/tsmthred.cpp
|
| deleted file mode 100644
|
| index fd89af1ee83971ff230c79879dcede663c724f2c..0000000000000000000000000000000000000000
|
| --- a/source/test/intltest/tsmthred.cpp
|
| +++ /dev/null
|
| @@ -1,1572 +0,0 @@
|
| -/********************************************************************
|
| - * COPYRIGHT:
|
| - * Copyright (c) 1999-2015, International Business Machines Corporation and
|
| - * others. All Rights Reserved.
|
| - ********************************************************************/
|
| -
|
| -#include "simplethread.h"
|
| -
|
| -#include "unicode/utypes.h"
|
| -#include "unicode/ustring.h"
|
| -#include "umutex.h"
|
| -#include "cmemory.h"
|
| -#include "cstring.h"
|
| -#include "uparse.h"
|
| -#include "unicode/localpointer.h"
|
| -#include "unicode/resbund.h"
|
| -#include "unicode/udata.h"
|
| -#include "unicode/uloc.h"
|
| -#include "unicode/locid.h"
|
| -#include "putilimp.h"
|
| -#include "intltest.h"
|
| -#include "tsmthred.h"
|
| -#include "unicode/ushape.h"
|
| -#include "unicode/translit.h"
|
| -#include "sharedobject.h"
|
| -#include "unifiedcache.h"
|
| -#include "uassert.h"
|
| -
|
| -
|
| -#define TSMTHREAD_FAIL(msg) errln("%s at file %s, line %d", msg, __FILE__, __LINE__)
|
| -#define TSMTHREAD_ASSERT(expr) {if (!(expr)) {TSMTHREAD_FAIL("Fail");}}
|
| -#define TSMTHREAD_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
|
| - errln("file: %s:%d status = %s\n", __FILE__, __LINE__, u_errorName(status));}}
|
| -
|
| -MultithreadTest::MultithreadTest()
|
| -{
|
| -}
|
| -
|
| -MultithreadTest::~MultithreadTest()
|
| -{
|
| -}
|
| -
|
| -#include <stdio.h>
|
| -#include <string.h>
|
| -#include <ctype.h> // tolower, toupper
|
| -
|
| -#include "unicode/putil.h"
|
| -
|
| -// for mthreadtest
|
| -#include "unicode/numfmt.h"
|
| -#include "unicode/choicfmt.h"
|
| -#include "unicode/msgfmt.h"
|
| -#include "unicode/locid.h"
|
| -#include "unicode/coll.h"
|
| -#include "unicode/calendar.h"
|
| -#include "ucaconf.h"
|
| -
|
| -
|
| -void MultithreadTest::runIndexedTest( int32_t index, UBool exec,
|
| - const char* &name, char* /*par*/ ) {
|
| - if (exec)
|
| - logln("TestSuite MultithreadTest: ");
|
| - switch (index) {
|
| - case 0:
|
| - name = "TestThreads";
|
| - if (exec)
|
| - TestThreads();
|
| - break;
|
| -
|
| - case 1:
|
| - name = "TestMutex";
|
| - if (exec)
|
| - TestMutex();
|
| - break;
|
| -
|
| - case 2:
|
| - name = "TestThreadedIntl";
|
| -#if !UCONFIG_NO_FORMATTING
|
| - if (exec) {
|
| - TestThreadedIntl();
|
| - }
|
| -#endif
|
| - break;
|
| -
|
| - case 3:
|
| - name = "TestCollators";
|
| -#if !UCONFIG_NO_COLLATION
|
| - if (exec) {
|
| - TestCollators();
|
| - }
|
| -#endif /* #if !UCONFIG_NO_COLLATION */
|
| - break;
|
| -
|
| - case 4:
|
| - name = "TestString";
|
| - if (exec) {
|
| - TestString();
|
| - }
|
| - break;
|
| -
|
| - case 5:
|
| - name = "TestArabicShapingThreads";
|
| - if (exec) {
|
| - TestArabicShapingThreads();
|
| - }
|
| - break;
|
| -
|
| - case 6:
|
| - name = "TestAnyTranslit";
|
| - if (exec) {
|
| - TestAnyTranslit();
|
| - }
|
| - break;
|
| -
|
| - case 7:
|
| - name = "TestConditionVariables";
|
| - if (exec) {
|
| - TestConditionVariables();
|
| - }
|
| - break;
|
| - case 8:
|
| - name = "TestUnifiedCache";
|
| - if (exec) {
|
| - TestUnifiedCache();
|
| - }
|
| - break;
|
| -#if !UCONFIG_NO_TRANSLITERATION
|
| - case 9:
|
| - name = "TestBreakTranslit";
|
| - if (exec) {
|
| - TestBreakTranslit();
|
| - }
|
| - break;
|
| -#endif
|
| - default:
|
| - name = "";
|
| - break; //needed to end loop
|
| - }
|
| -}
|
| -
|
| -
|
| -//-----------------------------------------------------------------------------------
|
| -//
|
| -// TestThreads -- see if threads really work at all.
|
| -//
|
| -// Set up N threads pointing at N chars. When they are started, they will
|
| -// set their chars. At the end we make sure they are all set.
|
| -//
|
| -//-----------------------------------------------------------------------------------
|
| -
|
| -class TestThreadsThread : public SimpleThread
|
| -{
|
| -public:
|
| - TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }
|
| - virtual void run() { Mutex m;
|
| - *fWhatToChange = '*';
|
| - }
|
| -private:
|
| - char *fWhatToChange;
|
| -};
|
| -
|
| -
|
| -void MultithreadTest::TestThreads()
|
| -{
|
| - static const int32_t THREADTEST_NRTHREADS = 8;
|
| - char threadTestChars[THREADTEST_NRTHREADS + 1];
|
| - SimpleThread *threads[THREADTEST_NRTHREADS];
|
| - int32_t numThreadsStarted = 0;
|
| -
|
| - int32_t i;
|
| - for(i=0;i<THREADTEST_NRTHREADS;i++)
|
| - {
|
| - threadTestChars[i] = ' ';
|
| - threads[i] = new TestThreadsThread(&threadTestChars[i]);
|
| - }
|
| - threadTestChars[THREADTEST_NRTHREADS] = '\0';
|
| -
|
| - logln("->" + UnicodeString(threadTestChars) + "<- Firing off threads.. ");
|
| - for(i=0;i<THREADTEST_NRTHREADS;i++)
|
| - {
|
| - if (threads[i]->start() != 0) {
|
| - errln("Error starting thread %d", i);
|
| - }
|
| - else {
|
| - numThreadsStarted++;
|
| - }
|
| - logln(" Subthread started.");
|
| - }
|
| -
|
| - if (numThreadsStarted != THREADTEST_NRTHREADS) {
|
| - errln("Not all threads could be started for testing!");
|
| - return;
|
| - }
|
| -
|
| - logln("Waiting for threads to be set..");
|
| - for(i=0; i<THREADTEST_NRTHREADS; i++) {
|
| - threads[i]->join();
|
| - if (threadTestChars[i] != '*') {
|
| - errln("%s:%d Thread %d failed.", __FILE__, __LINE__, i);
|
| - }
|
| - delete threads[i];
|
| - }
|
| -}
|
| -
|
| -
|
| -//-----------------------------------------------------------------------------------
|
| -//
|
| -// TestArabicShapeThreads -- see if calls to u_shapeArabic in many threads works successfully
|
| -//
|
| -// Set up N threads pointing at N chars. When they are started, they will make calls to doTailTest which tests
|
| -// u_shapeArabic, if the calls are successful it will the set * chars.
|
| -// At the end we make sure all threads managed to run u_shapeArabic successfully.
|
| -// This is a unit test for ticket 9473
|
| -//
|
| -//-----------------------------------------------------------------------------------
|
| -
|
| -class TestArabicShapeThreads : public SimpleThread
|
| -{
|
| -public:
|
| - TestArabicShapeThreads() {};
|
| - virtual void run() { doTailTest(); };
|
| -private:
|
| - void doTailTest();
|
| -};
|
| -
|
| -
|
| -void TestArabicShapeThreads::doTailTest(void) {
|
| - static const UChar src[] = { 0x0020, 0x0633, 0 };
|
| - static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
|
| - static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
|
| - UChar dst[3] = { 0x0000, 0x0000,0 };
|
| - int32_t length;
|
| - UErrorCode status;
|
| -
|
| - for (int32_t loopCount = 0; loopCount < 100; loopCount++) {
|
| - status = U_ZERO_ERROR;
|
| - length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
|
| - U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
|
| - if(U_FAILURE(status)) {
|
| - IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
|
| - return;
|
| - } else if(length!=2) {
|
| - IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
|
| - return;
|
| - } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
|
| - IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
|
| - dst[0],dst[1],dst_old[0],dst_old[1]);
|
| - return;
|
| - }
|
| -
|
| -
|
| - //"Trying new tail
|
| - status = U_ZERO_ERROR;
|
| - length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
|
| - U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
|
| - if(U_FAILURE(status)) {
|
| - IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
|
| - return;
|
| - } else if(length!=2) {
|
| - IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
|
| - return;
|
| - } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
|
| - IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
|
| - dst[0],dst[1],dst_new[0],dst_new[1]);
|
| - return;
|
| - }
|
| - }
|
| - return;
|
| -}
|
| -
|
| -
|
| -void MultithreadTest::TestArabicShapingThreads()
|
| -{
|
| - TestArabicShapeThreads threads[30];
|
| -
|
| - int32_t i;
|
| -
|
| - logln("-> do TestArabicShapingThreads <- Firing off threads.. ");
|
| - for(i=0; i < UPRV_LENGTHOF(threads); i++) {
|
| - if (threads[i].start() != 0) {
|
| - errln("Error starting thread %d", i);
|
| - }
|
| - }
|
| -
|
| - for(i=0; i < UPRV_LENGTHOF(threads); i++) {
|
| - threads[i].join();
|
| - }
|
| - logln("->TestArabicShapingThreads <- Got all threads! cya");
|
| -}
|
| -
|
| -
|
| -//-----------------------------------------------------------------------
|
| -//
|
| -// TestMutex - a simple (non-stress) test to verify that ICU mutexes
|
| -// and condition variables are functioning. Does not test the use of
|
| -// mutexes within ICU services, but rather that the
|
| -// platform's mutex support is at least superficially there.
|
| -//
|
| -//----------------------------------------------------------------------
|
| -static UMutex gTestMutexA = U_MUTEX_INITIALIZER;
|
| -static UConditionVar gThreadsCountChanged = U_CONDITION_INITIALIZER;
|
| -
|
| -static int gThreadsStarted = 0;
|
| -static int gThreadsInMiddle = 0;
|
| -static int gThreadsDone = 0;
|
| -
|
| -static const int TESTMUTEX_THREAD_COUNT = 40;
|
| -
|
| -class TestMutexThread : public SimpleThread
|
| -{
|
| -public:
|
| - virtual void run() {
|
| - // This is the code that each of the spawned threads runs.
|
| - // All threads move together throught the started - middle - done sequence together,
|
| - // waiting for all other threads to reach each point before advancing.
|
| - umtx_lock(&gTestMutexA);
|
| - gThreadsStarted += 1;
|
| - umtx_condBroadcast(&gThreadsCountChanged);
|
| - while (gThreadsStarted < TESTMUTEX_THREAD_COUNT) {
|
| - if (gThreadsInMiddle != 0) {
|
| - IntlTest::gTest->errln(
|
| - "%s:%d gThreadsInMiddle = %d. Expected 0.", __FILE__, __LINE__, gThreadsInMiddle);
|
| - return;
|
| - }
|
| - umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
|
| - }
|
| -
|
| - gThreadsInMiddle += 1;
|
| - umtx_condBroadcast(&gThreadsCountChanged);
|
| - while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
|
| - if (gThreadsDone != 0) {
|
| - IntlTest::gTest->errln(
|
| - "%s:%d gThreadsDone = %d. Expected 0.", __FILE__, __LINE__, gThreadsDone);
|
| - return;
|
| - }
|
| - umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
|
| - }
|
| -
|
| - gThreadsDone += 1;
|
| - umtx_condBroadcast(&gThreadsCountChanged);
|
| - while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
|
| - umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
|
| - }
|
| - umtx_unlock(&gTestMutexA);
|
| - }
|
| -};
|
| -
|
| -void MultithreadTest::TestMutex()
|
| -{
|
| - gThreadsStarted = 0;
|
| - gThreadsInMiddle = 0;
|
| - gThreadsDone = 0;
|
| - int32_t i = 0;
|
| - TestMutexThread threads[TESTMUTEX_THREAD_COUNT];
|
| - umtx_lock(&gTestMutexA);
|
| - for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
|
| - if (threads[i].start() != 0) {
|
| - errln("%s:%d Error starting thread %d", __FILE__, __LINE__, i);
|
| - return;
|
| - }
|
| - }
|
| -
|
| - // Because we are holding gTestMutexA, all of the threads should be blocked
|
| - // at the start of their run() function.
|
| - if (gThreadsStarted != 0) {
|
| - errln("%s:%d gThreadsStarted=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
|
| - return;
|
| - }
|
| -
|
| - while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
|
| - if (gThreadsDone != 0) {
|
| - errln("%s:%d gThreadsDone=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
|
| - return;
|
| - }
|
| - umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
|
| - }
|
| -
|
| - while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
|
| - umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
|
| - }
|
| - umtx_unlock(&gTestMutexA);
|
| -
|
| - for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
|
| - threads[i].join();
|
| - }
|
| -}
|
| -
|
| -
|
| -//-------------------------------------------------------------------------------------------
|
| -//
|
| -// TestMultithreadedIntl. Test ICU Formatting in a multi-threaded environment
|
| -//
|
| -//-------------------------------------------------------------------------------------------
|
| -
|
| -
|
| -// * Show exactly where the string's differences lie.
|
| -UnicodeString showDifference(const UnicodeString& expected, const UnicodeString& result)
|
| -{
|
| - UnicodeString res;
|
| - res = expected + "<Expected\n";
|
| - if(expected.length() != result.length())
|
| - res += " [ Different lengths ] \n";
|
| - else
|
| - {
|
| - for(int32_t i=0;i<expected.length();i++)
|
| - {
|
| - if(expected[i] == result[i])
|
| - {
|
| - res += " ";
|
| - }
|
| - else
|
| - {
|
| - res += "|";
|
| - }
|
| - }
|
| - res += "<Differences";
|
| - res += "\n";
|
| - }
|
| - res += result + "<Result\n";
|
| -
|
| - return res;
|
| -}
|
| -
|
| -
|
| -//-------------------------------------------------------------------------------------------
|
| -//
|
| -// FormatThreadTest - a thread that tests performing a number of numberformats.
|
| -//
|
| -//-------------------------------------------------------------------------------------------
|
| -
|
| -const int kFormatThreadIterations = 100; // # of iterations per thread
|
| -const int kFormatThreadThreads = 10; // # of threads to spawn
|
| -
|
| -#if !UCONFIG_NO_FORMATTING
|
| -
|
| -
|
| -
|
| -struct FormatThreadTestData
|
| -{
|
| - double number;
|
| - UnicodeString string;
|
| - FormatThreadTestData(double a, const UnicodeString& b) : number(a),string(b) {}
|
| -} ;
|
| -
|
| -
|
| -// "Someone from {2} is receiving a #{0} error - {1}. Their telephone call is costing {3 number,currency}."
|
| -
|
| -static void formatErrorMessage(UErrorCode &realStatus, const UnicodeString& pattern, const Locale& theLocale,
|
| - UErrorCode inStatus0, /* statusString 1 */ const Locale &inCountry2, double currency3, // these numbers are the message arguments.
|
| - UnicodeString &result)
|
| -{
|
| - if(U_FAILURE(realStatus))
|
| - return; // you messed up
|
| -
|
| - UnicodeString errString1(u_errorName(inStatus0));
|
| -
|
| - UnicodeString countryName2;
|
| - inCountry2.getDisplayCountry(theLocale,countryName2);
|
| -
|
| - Formattable myArgs[] = {
|
| - Formattable((int32_t)inStatus0), // inStatus0 {0}
|
| - Formattable(errString1), // statusString1 {1}
|
| - Formattable(countryName2), // inCountry2 {2}
|
| - Formattable(currency3)// currency3 {3,number,currency}
|
| - };
|
| -
|
| - MessageFormat *fmt = new MessageFormat("MessageFormat's API is broken!!!!!!!!!!!",realStatus);
|
| - fmt->setLocale(theLocale);
|
| - fmt->applyPattern(pattern, realStatus);
|
| -
|
| - if (U_FAILURE(realStatus)) {
|
| - delete fmt;
|
| - return;
|
| - }
|
| -
|
| - FieldPosition ignore = 0;
|
| - fmt->format(myArgs,4,result,ignore,realStatus);
|
| -
|
| - delete fmt;
|
| -}
|
| -
|
| -/**
|
| - * Shared formatters & data used by instances of ThreadSafeFormat.
|
| - * Exactly one instance of this class is created, and it is then shared concurrently
|
| - * by the multiple instances of ThreadSafeFormat.
|
| - */
|
| -class ThreadSafeFormatSharedData {
|
| - public:
|
| - ThreadSafeFormatSharedData(UErrorCode &status);
|
| - ~ThreadSafeFormatSharedData();
|
| - LocalPointer<NumberFormat> fFormat;
|
| - Formattable fYDDThing;
|
| - Formattable fBBDThing;
|
| - UnicodeString fYDDStr;
|
| - UnicodeString fBBDStr;
|
| -};
|
| -
|
| -const ThreadSafeFormatSharedData *gSharedData = NULL;
|
| -
|
| -ThreadSafeFormatSharedData::ThreadSafeFormatSharedData(UErrorCode &status) {
|
| - fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
|
| - static const UChar kYDD[] = { 0x59, 0x44, 0x44, 0x00 };
|
| - static const UChar kBBD[] = { 0x42, 0x42, 0x44, 0x00 };
|
| - fYDDThing.adoptObject(new CurrencyAmount(123.456, kYDD, status));
|
| - fBBDThing.adoptObject(new CurrencyAmount(987.654, kBBD, status));
|
| - if (U_FAILURE(status)) {
|
| - return;
|
| - }
|
| - fFormat->format(fYDDThing, fYDDStr, NULL, status);
|
| - fFormat->format(fBBDThing, fBBDStr, NULL, status);
|
| - gSharedData = this;
|
| -}
|
| -
|
| -ThreadSafeFormatSharedData::~ThreadSafeFormatSharedData() {
|
| - gSharedData = NULL;
|
| -}
|
| -
|
| -/**
|
| - * Class for thread-safe testing of format.
|
| - * Instances of this class appear as members of class FormatThreadTest.
|
| - * Multiple instances of FormatThreadTest coexist.
|
| - * ThreadSafeFormat::doStuff() is called concurrently to test the thread safety of
|
| - * various shared format operations.
|
| - */
|
| -class ThreadSafeFormat {
|
| -public:
|
| - /* give a unique offset to each thread */
|
| - ThreadSafeFormat(UErrorCode &status);
|
| - UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const;
|
| -private:
|
| - LocalPointer<NumberFormat> fFormat; // formatter - en_US constructed currency
|
| -};
|
| -
|
| -
|
| -ThreadSafeFormat::ThreadSafeFormat(UErrorCode &status) {
|
| - fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
|
| -}
|
| -
|
| -static const UChar kUSD[] = { 0x55, 0x53, 0x44, 0x00 };
|
| -
|
| -UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const {
|
| - UBool okay = TRUE;
|
| -
|
| - if(u_strcmp(fFormat->getCurrency(), kUSD)) {
|
| - appendErr.append("fFormat currency != ")
|
| - .append(kUSD)
|
| - .append(", =")
|
| - .append(fFormat->getCurrency())
|
| - .append("! ");
|
| - okay = FALSE;
|
| - }
|
| -
|
| - if(u_strcmp(gSharedData->fFormat->getCurrency(), kUSD)) {
|
| - appendErr.append("gFormat currency != ")
|
| - .append(kUSD)
|
| - .append(", =")
|
| - .append(gSharedData->fFormat->getCurrency())
|
| - .append("! ");
|
| - okay = FALSE;
|
| - }
|
| - UnicodeString str;
|
| - const UnicodeString *o=NULL;
|
| - Formattable f;
|
| - const NumberFormat *nf = NULL; // only operate on it as const.
|
| - switch(offset%4) {
|
| - case 0: f = gSharedData->fYDDThing; o = &gSharedData->fYDDStr; nf = gSharedData->fFormat.getAlias(); break;
|
| - case 1: f = gSharedData->fBBDThing; o = &gSharedData->fBBDStr; nf = gSharedData->fFormat.getAlias(); break;
|
| - case 2: f = gSharedData->fYDDThing; o = &gSharedData->fYDDStr; nf = fFormat.getAlias(); break;
|
| - case 3: f = gSharedData->fBBDThing; o = &gSharedData->fBBDStr; nf = fFormat.getAlias(); break;
|
| - }
|
| - nf->format(f, str, NULL, status);
|
| -
|
| - if(*o != str) {
|
| - appendErr.append(showDifference(*o, str));
|
| - okay = FALSE;
|
| - }
|
| - return okay;
|
| -}
|
| -
|
| -UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInfo *) {
|
| - return TRUE;
|
| -}
|
| -
|
| -//static UMTX debugMutex = NULL;
|
| -//static UMTX gDebugMutex;
|
| -
|
| -
|
| -class FormatThreadTest : public SimpleThread
|
| -{
|
| -public:
|
| - int fNum;
|
| - int fTraceInfo;
|
| -
|
| - LocalPointer<ThreadSafeFormat> fTSF;
|
| -
|
| - FormatThreadTest() // constructor is NOT multithread safe.
|
| - : SimpleThread(),
|
| - fNum(0),
|
| - fTraceInfo(0),
|
| - fTSF(NULL),
|
| - fOffset(0)
|
| - // the locale to use
|
| - {
|
| - UErrorCode status = U_ZERO_ERROR; // TODO: rearrange code to allow checking of status.
|
| - fTSF.adoptInstead(new ThreadSafeFormat(status));
|
| - static int32_t fgOffset = 0;
|
| - fgOffset += 3;
|
| - fOffset = fgOffset;
|
| - }
|
| -
|
| -
|
| - virtual void run()
|
| - {
|
| - fTraceInfo = 1;
|
| - LocalPointer<NumberFormat> percentFormatter;
|
| - UErrorCode status = U_ZERO_ERROR;
|
| -
|
| -#if 0
|
| - // debugging code,
|
| - for (int i=0; i<4000; i++) {
|
| - status = U_ZERO_ERROR;
|
| - UDataMemory *data1 = udata_openChoice(0, "res", "en_US", isAcceptable, 0, &status);
|
| - UDataMemory *data2 = udata_openChoice(0, "res", "fr", isAcceptable, 0, &status);
|
| - udata_close(data1);
|
| - udata_close(data2);
|
| - if (U_FAILURE(status)) {
|
| - error("udata_openChoice failed.\n");
|
| - break;
|
| - }
|
| - }
|
| - return;
|
| -#endif
|
| -
|
| -#if 0
|
| - // debugging code,
|
| - int m;
|
| - for (m=0; m<4000; m++) {
|
| - status = U_ZERO_ERROR;
|
| - UResourceBundle *res = NULL;
|
| - const char *localeName = NULL;
|
| -
|
| - Locale loc = Locale::getEnglish();
|
| -
|
| - localeName = loc.getName();
|
| - // localeName = "en";
|
| -
|
| - // ResourceBundle bund = ResourceBundle(0, loc, status);
|
| - //umtx_lock(&gDebugMutex);
|
| - res = ures_open(NULL, localeName, &status);
|
| - //umtx_unlock(&gDebugMutex);
|
| -
|
| - //umtx_lock(&gDebugMutex);
|
| - ures_close(res);
|
| - //umtx_unlock(&gDebugMutex);
|
| -
|
| - if (U_FAILURE(status)) {
|
| - error("Resource bundle construction failed.\n");
|
| - break;
|
| - }
|
| - }
|
| - return;
|
| -#endif
|
| -
|
| - // Keep this data here to avoid static initialization.
|
| - FormatThreadTestData kNumberFormatTestData[] =
|
| - {
|
| - FormatThreadTestData((double)5.0, UnicodeString("5", "")),
|
| - FormatThreadTestData( 6.0, UnicodeString("6", "")),
|
| - FormatThreadTestData( 20.0, UnicodeString("20", "")),
|
| - FormatThreadTestData( 8.0, UnicodeString("8", "")),
|
| - FormatThreadTestData( 8.3, UnicodeString("8.3", "")),
|
| - FormatThreadTestData( 12345, UnicodeString("12,345", "")),
|
| - FormatThreadTestData( 81890.23, UnicodeString("81,890.23", "")),
|
| - };
|
| - int32_t kNumberFormatTestDataLength = UPRV_LENGTHOF(kNumberFormatTestData);
|
| -
|
| - // Keep this data here to avoid static initialization.
|
| - FormatThreadTestData kPercentFormatTestData[] =
|
| - {
|
| - FormatThreadTestData((double)5.0, CharsToUnicodeString("500\\u00a0%")),
|
| - FormatThreadTestData( 1.0, CharsToUnicodeString("100\\u00a0%")),
|
| - FormatThreadTestData( 0.26, CharsToUnicodeString("26\\u00a0%")),
|
| - FormatThreadTestData(
|
| - 16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499\\u00a0%")), // U+00a0 = NBSP
|
| - FormatThreadTestData(
|
| - 81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023\\u00a0%")),
|
| - };
|
| - int32_t kPercentFormatTestDataLength = UPRV_LENGTHOF(kPercentFormatTestData);
|
| - int32_t iteration;
|
| -
|
| - status = U_ZERO_ERROR;
|
| - LocalPointer<NumberFormat> formatter(NumberFormat::createInstance(Locale::getEnglish(),status));
|
| - if(U_FAILURE(status)) {
|
| - IntlTest::gTest->dataerrln("%s:%d Error %s on NumberFormat::createInstance().",
|
| - __FILE__, __LINE__, u_errorName(status));
|
| - goto cleanupAndReturn;
|
| - }
|
| -
|
| - percentFormatter.adoptInstead(NumberFormat::createPercentInstance(Locale::getFrench(),status));
|
| - if(U_FAILURE(status)) {
|
| - IntlTest::gTest->errln("%s:%d Error %s on NumberFormat::createPercentInstance().",
|
| - __FILE__, __LINE__, u_errorName(status));
|
| - goto cleanupAndReturn;
|
| - }
|
| -
|
| - for(iteration = 0;!IntlTest::gTest->getErrors() && iteration<kFormatThreadIterations;iteration++)
|
| - {
|
| -
|
| - int32_t whichLine = (iteration + fOffset)%kNumberFormatTestDataLength;
|
| -
|
| - UnicodeString output;
|
| -
|
| - formatter->format(kNumberFormatTestData[whichLine].number, output);
|
| -
|
| - if(0 != output.compare(kNumberFormatTestData[whichLine].string)) {
|
| - IntlTest::gTest->errln("format().. expected " + kNumberFormatTestData[whichLine].string
|
| - + " got " + output);
|
| - goto cleanupAndReturn;
|
| - }
|
| -
|
| - // Now check percent.
|
| - output.remove();
|
| - whichLine = (iteration + fOffset)%kPercentFormatTestDataLength;
|
| -
|
| - percentFormatter->format(kPercentFormatTestData[whichLine].number, output);
|
| - if(0 != output.compare(kPercentFormatTestData[whichLine].string))
|
| - {
|
| - IntlTest::gTest->errln("percent format().. \n" +
|
| - showDifference(kPercentFormatTestData[whichLine].string,output));
|
| - goto cleanupAndReturn;
|
| - }
|
| -
|
| - // Test message error
|
| - const int kNumberOfMessageTests = 3;
|
| - UErrorCode statusToCheck;
|
| - UnicodeString patternToCheck;
|
| - Locale messageLocale;
|
| - Locale countryToCheck;
|
| - double currencyToCheck;
|
| -
|
| - UnicodeString expected;
|
| -
|
| - // load the cases.
|
| - switch((iteration+fOffset) % kNumberOfMessageTests)
|
| - {
|
| - default:
|
| - case 0:
|
| - statusToCheck= U_FILE_ACCESS_ERROR;
|
| - patternToCheck= "0:Someone from {2} is receiving a #{0}"
|
| - " error - {1}. Their telephone call is costing "
|
| - "{3,number,currency}."; // number,currency
|
| - messageLocale= Locale("en","US");
|
| - countryToCheck= Locale("","HR");
|
| - currencyToCheck= 8192.77;
|
| - expected= "0:Someone from Croatia is receiving a #4 error - "
|
| - "U_FILE_ACCESS_ERROR. Their telephone call is costing $8,192.77.";
|
| - break;
|
| - case 1:
|
| - statusToCheck= U_INDEX_OUTOFBOUNDS_ERROR;
|
| - patternToCheck= "1:A customer in {2} is receiving a #{0} error - {1}. "
|
| - "Their telephone call is costing {3,number,currency}."; // number,currency
|
| - messageLocale= Locale("de","DE@currency=DEM");
|
| - countryToCheck= Locale("","BF");
|
| - currencyToCheck= 2.32;
|
| - expected= CharsToUnicodeString(
|
| - "1:A customer in Burkina Faso is receiving a #8 error - U_INDEX_OUTOFBOUNDS_ERROR. "
|
| - "Their telephone call is costing 2,32\\u00A0DM.");
|
| - break;
|
| - case 2:
|
| - statusToCheck= U_MEMORY_ALLOCATION_ERROR;
|
| - patternToCheck= "2:user in {2} is receiving a #{0} error - {1}. "
|
| - "They insist they just spent {3,number,currency} "
|
| - "on memory."; // number,currency
|
| - messageLocale= Locale("de","AT@currency=ATS"); // Austrian German
|
| - countryToCheck= Locale("","US"); // hmm
|
| - currencyToCheck= 40193.12;
|
| - expected= CharsToUnicodeString(
|
| - "2:user in Vereinigte Staaten is receiving a #7 error"
|
| - " - U_MEMORY_ALLOCATION_ERROR. They insist they just spent"
|
| - " \\u00f6S\\u00A040\\u00A0193,12 on memory.");
|
| - break;
|
| - }
|
| -
|
| - UnicodeString result;
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - formatErrorMessage(status,patternToCheck,messageLocale,statusToCheck,
|
| - countryToCheck,currencyToCheck,result);
|
| - if(U_FAILURE(status))
|
| - {
|
| - UnicodeString tmp(u_errorName(status));
|
| - IntlTest::gTest->errln("Failure on message format, pattern=" + patternToCheck +
|
| - ", error = " + tmp);
|
| - goto cleanupAndReturn;
|
| - }
|
| -
|
| - if(result != expected)
|
| - {
|
| - IntlTest::gTest->errln("PatternFormat: \n" + showDifference(expected,result));
|
| - goto cleanupAndReturn;
|
| - }
|
| - // test the Thread Safe Format
|
| - UnicodeString appendErr;
|
| - if(!fTSF->doStuff(fNum, appendErr, status)) {
|
| - IntlTest::gTest->errln(appendErr);
|
| - goto cleanupAndReturn;
|
| - }
|
| - } /* end of for loop */
|
| -
|
| -
|
| -
|
| -cleanupAndReturn:
|
| - fTraceInfo = 2;
|
| - }
|
| -
|
| -private:
|
| - int32_t fOffset; // where we are testing from.
|
| -};
|
| -
|
| -// ** The actual test function.
|
| -
|
| -void MultithreadTest::TestThreadedIntl()
|
| -{
|
| - UnicodeString theErr;
|
| -
|
| - UErrorCode threadSafeErr = U_ZERO_ERROR;
|
| -
|
| - ThreadSafeFormatSharedData sharedData(threadSafeErr);
|
| - assertSuccess("initializing ThreadSafeFormat", threadSafeErr, TRUE);
|
| -
|
| - //
|
| - // Create and start the test threads
|
| - //
|
| - logln("Spawning: %d threads * %d iterations each.",
|
| - kFormatThreadThreads, kFormatThreadIterations);
|
| - FormatThreadTest tests[kFormatThreadThreads];
|
| - int32_t j;
|
| - for(j = 0; j < UPRV_LENGTHOF(tests); j++) {
|
| - tests[j].fNum = j;
|
| - int32_t threadStatus = tests[j].start();
|
| - if (threadStatus != 0) {
|
| - errln("%s:%d System Error %d starting thread number %d.",
|
| - __FILE__, __LINE__, threadStatus, j);
|
| - return;
|
| - }
|
| - }
|
| -
|
| -
|
| - for (j=0; j<UPRV_LENGTHOF(tests); j++) {
|
| - tests[j].join();
|
| - logln("Thread # %d is complete..", j);
|
| - }
|
| -}
|
| -#endif /* #if !UCONFIG_NO_FORMATTING */
|
| -
|
| -
|
| -
|
| -
|
| -
|
| -//-------------------------------------------------------------------------------------------
|
| -//
|
| -// Collation threading test
|
| -//
|
| -//-------------------------------------------------------------------------------------------
|
| -#if !UCONFIG_NO_COLLATION
|
| -
|
| -#define kCollatorThreadThreads 10 // # of threads to spawn
|
| -#define kCollatorThreadPatience kCollatorThreadThreads*30
|
| -
|
| -struct Line {
|
| - UChar buff[25];
|
| - int32_t buflen;
|
| -} ;
|
| -
|
| -static UBool
|
| -skipLineBecauseOfBug(const UChar *s, int32_t length) {
|
| - // TODO: Fix ICU ticket #8052
|
| - if(length >= 3 &&
|
| - (s[0] == 0xfb2 || s[0] == 0xfb3) &&
|
| - s[1] == 0x334 &&
|
| - (s[2] == 0xf73 || s[2] == 0xf75 || s[2] == 0xf81)) {
|
| - return TRUE;
|
| - }
|
| - return FALSE;
|
| -}
|
| -
|
| -static UCollationResult
|
| -normalizeResult(int32_t result) {
|
| - return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;
|
| -}
|
| -
|
| -class CollatorThreadTest : public SimpleThread
|
| -{
|
| -private:
|
| - const Collator *coll;
|
| - const Line *lines;
|
| - int32_t noLines;
|
| - UBool isAtLeastUCA62;
|
| -public:
|
| - CollatorThreadTest() : SimpleThread(),
|
| - coll(NULL),
|
| - lines(NULL),
|
| - noLines(0),
|
| - isAtLeastUCA62(TRUE)
|
| - {
|
| - };
|
| - void setCollator(Collator *c, Line *l, int32_t nl, UBool atLeastUCA62)
|
| - {
|
| - coll = c;
|
| - lines = l;
|
| - noLines = nl;
|
| - isAtLeastUCA62 = atLeastUCA62;
|
| - }
|
| - virtual void run() {
|
| - uint8_t sk1[1024], sk2[1024];
|
| - uint8_t *oldSk = NULL, *newSk = sk1;
|
| - int32_t oldLen = 0;
|
| - int32_t prev = 0;
|
| - int32_t i = 0;
|
| -
|
| - for(i = 0; i < noLines; i++) {
|
| - if(lines[i].buflen == 0) { continue; }
|
| -
|
| - if(skipLineBecauseOfBug(lines[i].buff, lines[i].buflen)) { continue; }
|
| -
|
| - int32_t resLen = coll->getSortKey(lines[i].buff, lines[i].buflen, newSk, 1024);
|
| -
|
| - if(oldSk != NULL) {
|
| - int32_t skres = strcmp((char *)oldSk, (char *)newSk);
|
| - int32_t cmpres = coll->compare(lines[prev].buff, lines[prev].buflen, lines[i].buff, lines[i].buflen);
|
| - int32_t cmpres2 = coll->compare(lines[i].buff, lines[i].buflen, lines[prev].buff, lines[prev].buflen);
|
| -
|
| - if(cmpres != -cmpres2) {
|
| - IntlTest::gTest->errln(UnicodeString("Compare result not symmetrical on line ") + (i + 1));
|
| - break;
|
| - }
|
| -
|
| - if(cmpres != normalizeResult(skres)) {
|
| - IntlTest::gTest->errln(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));
|
| - break;
|
| - }
|
| -
|
| - int32_t res = cmpres;
|
| - if(res == 0 && !isAtLeastUCA62) {
|
| - // Up to UCA 6.1, the collation test files use a custom tie-breaker,
|
| - // comparing the raw input strings.
|
| - res = u_strcmpCodePointOrder(lines[prev].buff, lines[i].buff);
|
| - // Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
|
| - // comparing the NFD versions of the input strings,
|
| - // which we do via setting strength=identical.
|
| - }
|
| - if(res > 0) {
|
| - IntlTest::gTest->errln(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));
|
| - break;
|
| - }
|
| - }
|
| -
|
| - oldSk = newSk;
|
| - oldLen = resLen;
|
| - (void)oldLen; // Suppress set but not used warning.
|
| - prev = i;
|
| -
|
| - newSk = (newSk == sk1)?sk2:sk1;
|
| - }
|
| - }
|
| -};
|
| -
|
| -void MultithreadTest::TestCollators()
|
| -{
|
| -
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - FILE *testFile = NULL;
|
| - char testDataPath[1024];
|
| - strcpy(testDataPath, IntlTest::getSourceTestData(status));
|
| - if (U_FAILURE(status)) {
|
| - errln("ERROR: could not open test data %s", u_errorName(status));
|
| - return;
|
| - }
|
| - strcat(testDataPath, "CollationTest_");
|
| -
|
| - const char* type = "NON_IGNORABLE";
|
| -
|
| - const char *ext = ".txt";
|
| - if(testFile) {
|
| - fclose(testFile);
|
| - }
|
| - char buffer[1024];
|
| - strcpy(buffer, testDataPath);
|
| - strcat(buffer, type);
|
| - size_t bufLen = strlen(buffer);
|
| -
|
| - // we try to open 3 files:
|
| - // path/CollationTest_type.txt
|
| - // path/CollationTest_type_SHORT.txt
|
| - // path/CollationTest_type_STUB.txt
|
| - // we are going to test with the first one that we manage to open.
|
| -
|
| - strcpy(buffer+bufLen, ext);
|
| -
|
| - testFile = fopen(buffer, "rb");
|
| -
|
| - if(testFile == 0) {
|
| - strcpy(buffer+bufLen, "_SHORT");
|
| - strcat(buffer, ext);
|
| - testFile = fopen(buffer, "rb");
|
| -
|
| - if(testFile == 0) {
|
| - strcpy(buffer+bufLen, "_STUB");
|
| - strcat(buffer, ext);
|
| - testFile = fopen(buffer, "rb");
|
| -
|
| - if (testFile == 0) {
|
| - *(buffer+bufLen) = 0;
|
| - dataerrln("could not open any of the conformance test files, tried opening base %s", buffer);
|
| - return;
|
| - } else {
|
| - infoln(
|
| - "INFO: Working with the stub file.\n"
|
| - "If you need the full conformance test, please\n"
|
| - "download the appropriate data files from:\n"
|
| - "http://source.icu-project.org/repos/icu/tools/trunk/unicodetools/com/ibm/text/data/");
|
| - }
|
| - }
|
| - }
|
| -
|
| - LocalArray<Line> lines(new Line[200000]);
|
| - memset(lines.getAlias(), 0, sizeof(Line)*200000);
|
| - int32_t lineNum = 0;
|
| -
|
| - UChar bufferU[1024];
|
| - uint32_t first = 0;
|
| -
|
| - while (fgets(buffer, 1024, testFile) != NULL) {
|
| - if(*buffer == 0 || buffer[0] == '#') {
|
| - // Store empty and comment lines so that errors are reported
|
| - // for the real test file lines.
|
| - lines[lineNum].buflen = 0;
|
| - lines[lineNum].buff[0] = 0;
|
| - } else {
|
| - int32_t buflen = u_parseString(buffer, bufferU, 1024, &first, &status);
|
| - lines[lineNum].buflen = buflen;
|
| - u_memcpy(lines[lineNum].buff, bufferU, buflen);
|
| - lines[lineNum].buff[buflen] = 0;
|
| - }
|
| - lineNum++;
|
| - }
|
| - fclose(testFile);
|
| - if(U_FAILURE(status)) {
|
| - dataerrln("Couldn't read the test file!");
|
| - return;
|
| - }
|
| -
|
| - UVersionInfo uniVersion;
|
| - static const UVersionInfo v62 = { 6, 2, 0, 0 };
|
| - u_getUnicodeVersion(uniVersion);
|
| - UBool isAtLeastUCA62 = uprv_memcmp(uniVersion, v62, 4) >= 0;
|
| -
|
| - LocalPointer<Collator> coll(Collator::createInstance(Locale::getRoot(), status));
|
| - if(U_FAILURE(status)) {
|
| - errcheckln(status, "Couldn't open UCA collator");
|
| - return;
|
| - }
|
| - coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
|
| - coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
|
| - coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
|
| - coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);
|
| - coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, status);
|
| -
|
| - int32_t spawnResult = 0;
|
| - LocalArray<CollatorThreadTest> tests(new CollatorThreadTest[kCollatorThreadThreads]);
|
| -
|
| - logln(UnicodeString("Spawning: ") + kCollatorThreadThreads + " threads * " + kFormatThreadIterations + " iterations each.");
|
| - int32_t j = 0;
|
| - for(j = 0; j < kCollatorThreadThreads; j++) {
|
| - //logln("Setting collator %i", j);
|
| - tests[j].setCollator(coll.getAlias(), lines.getAlias(), lineNum, isAtLeastUCA62);
|
| - }
|
| - for(j = 0; j < kCollatorThreadThreads; j++) {
|
| - log("%i ", j);
|
| - spawnResult = tests[j].start();
|
| - if(spawnResult != 0) {
|
| - errln("%s:%d THREAD INFO: thread %d failed to start with status %d", __FILE__, __LINE__, j, spawnResult);
|
| - return;
|
| - }
|
| - }
|
| - logln("Spawned all");
|
| -
|
| - for(int32_t i=0;i<kCollatorThreadThreads;i++) {
|
| - tests[i].join();
|
| - //logln(UnicodeString("Test #") + i + " is complete.. ");
|
| - }
|
| -}
|
| -
|
| -#endif /* #if !UCONFIG_NO_COLLATION */
|
| -
|
| -
|
| -
|
| -
|
| -//-------------------------------------------------------------------------------------------
|
| -//
|
| -// StringThreadTest2
|
| -//
|
| -//-------------------------------------------------------------------------------------------
|
| -
|
| -const int kStringThreadIterations = 2500;// # of iterations per thread
|
| -const int kStringThreadThreads = 10; // # of threads to spawn
|
| -
|
| -
|
| -class StringThreadTest2 : public SimpleThread
|
| -{
|
| -public:
|
| - int fNum;
|
| - int fTraceInfo;
|
| - static const UnicodeString *gSharedString;
|
| -
|
| - StringThreadTest2() // constructor is NOT multithread safe.
|
| - : SimpleThread(),
|
| - fTraceInfo(0)
|
| - {
|
| - };
|
| -
|
| -
|
| - virtual void run()
|
| - {
|
| - fTraceInfo = 1;
|
| - int loopCount = 0;
|
| -
|
| - for (loopCount = 0; loopCount < kStringThreadIterations; loopCount++) {
|
| - if (*gSharedString != "This is the original test string.") {
|
| - IntlTest::gTest->errln("%s:%d Original string is corrupt.", __FILE__, __LINE__);
|
| - break;
|
| - }
|
| - UnicodeString s1 = *gSharedString;
|
| - s1 += "cat this";
|
| - UnicodeString s2(s1);
|
| - UnicodeString s3 = *gSharedString;
|
| - s2 = s3;
|
| - s3.truncate(12);
|
| - s2.truncate(0);
|
| - }
|
| -
|
| - fTraceInfo = 2;
|
| - }
|
| -
|
| -};
|
| -
|
| -const UnicodeString *StringThreadTest2::gSharedString = NULL;
|
| -
|
| -// ** The actual test function.
|
| -
|
| -
|
| -void MultithreadTest::TestString()
|
| -{
|
| - int j;
|
| - StringThreadTest2::gSharedString = new UnicodeString("This is the original test string.");
|
| - StringThreadTest2 tests[kStringThreadThreads];
|
| -
|
| - logln(UnicodeString("Spawning: ") + kStringThreadThreads + " threads * " + kStringThreadIterations + " iterations each.");
|
| - for(j = 0; j < kStringThreadThreads; j++) {
|
| - int32_t threadStatus = tests[j].start();
|
| - if (threadStatus != 0) {
|
| - errln("%s:%d System Error %d starting thread number %d.", __FILE__, __LINE__, threadStatus, j);
|
| - }
|
| - }
|
| -
|
| - // Force a failure, to verify test is functioning and can report errors.
|
| - // const_cast<UnicodeString *>(StringThreadTest2::gSharedString)->setCharAt(5, 'x');
|
| -
|
| - for(j=0; j<kStringThreadThreads; j++) {
|
| - tests[j].join();
|
| - logln(UnicodeString("Test #") + j + " is complete.. ");
|
| - }
|
| -
|
| - delete StringThreadTest2::gSharedString;
|
| - StringThreadTest2::gSharedString = NULL;
|
| -}
|
| -
|
| -
|
| -//
|
| -// Test for ticket #10673, race in cache code in AnyTransliterator.
|
| -// It's difficult to make the original unsafe code actually fail, but
|
| -// this test will fairly reliably take the code path for races in
|
| -// populating the cache.
|
| -//
|
| -
|
| -#if !UCONFIG_NO_TRANSLITERATION
|
| -Transliterator *gSharedTranslit = NULL;
|
| -class TxThread: public SimpleThread {
|
| - public:
|
| - TxThread() {};
|
| - ~TxThread();
|
| - void run();
|
| -};
|
| -
|
| -TxThread::~TxThread() {}
|
| -void TxThread::run() {
|
| - UnicodeString greekString("\\u03B4\\u03B9\\u03B1\\u03C6\\u03BF\\u03C1\\u03B5\\u03C4\\u03B9\\u03BA\\u03BF\\u03CD\\u03C2");
|
| - greekString = greekString.unescape();
|
| - gSharedTranslit->transliterate(greekString);
|
| - if (greekString[0] != 0x64) // 'd'. The whole transliterated string is "diaphoretikous" (accented u).
|
| - {
|
| - IntlTest::gTest->errln("%s:%d Transliteration failed.", __FILE__, __LINE__);
|
| - }
|
| -}
|
| -#endif
|
| -
|
| -
|
| -void MultithreadTest::TestAnyTranslit() {
|
| -#if !UCONFIG_NO_TRANSLITERATION
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - LocalPointer<Transliterator> tx(Transliterator::createInstance("Any-Latin", UTRANS_FORWARD, status));
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("File %s, Line %d: Error, status = %s", __FILE__, __LINE__, u_errorName(status));
|
| - return;
|
| - }
|
| - gSharedTranslit = tx.getAlias();
|
| - TxThread threads[4];
|
| - int32_t i;
|
| - for (i=0; i<UPRV_LENGTHOF(threads); i++) {
|
| - threads[i].start();
|
| - }
|
| -
|
| - for (i=0; i<UPRV_LENGTHOF(threads); i++) {
|
| - threads[i].join();
|
| - }
|
| - gSharedTranslit = NULL;
|
| -#endif // !UCONFIG_NO_TRANSLITERATION
|
| -}
|
| -
|
| -
|
| -//
|
| -// Condition Variables Test
|
| -// Create a swarm of threads.
|
| -// Using a mutex and a condition variables each thread
|
| -// Increments a global count of started threads.
|
| -// Broadcasts that it has started.
|
| -// Waits on the condition that all threads have started.
|
| -// Increments a global count of finished threads.
|
| -// Waits on the condition that all threads have finished.
|
| -// Exits.
|
| -//
|
| -
|
| -class CondThread: public SimpleThread {
|
| - public:
|
| - CondThread() :fFinished(false) {};
|
| - ~CondThread() {};
|
| - void run();
|
| - bool fFinished;
|
| -};
|
| -
|
| -static UMutex gCTMutex = U_MUTEX_INITIALIZER;
|
| -static UConditionVar gCTConditionVar = U_CONDITION_INITIALIZER;
|
| -int gConditionTestOne = 1; // Value one. Non-const, extern linkage to inhibit
|
| - // compiler assuming a known value.
|
| -int gStartedThreads;
|
| -int gFinishedThreads;
|
| -static const int NUMTHREADS = 10;
|
| -
|
| -
|
| -// Worker thread function.
|
| -void CondThread::run() {
|
| - umtx_lock(&gCTMutex);
|
| - gStartedThreads += gConditionTestOne;
|
| - umtx_condBroadcast(&gCTConditionVar);
|
| -
|
| - while (gStartedThreads < NUMTHREADS) {
|
| - if (gFinishedThreads != 0) {
|
| - IntlTest::gTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d",
|
| - __FILE__, __LINE__, gStartedThreads, gFinishedThreads);
|
| - }
|
| - umtx_condWait(&gCTConditionVar, &gCTMutex);
|
| - }
|
| -
|
| - gFinishedThreads += gConditionTestOne;
|
| - fFinished = true;
|
| - umtx_condBroadcast(&gCTConditionVar);
|
| -
|
| - while (gFinishedThreads < NUMTHREADS) {
|
| - umtx_condWait(&gCTConditionVar, &gCTMutex);
|
| - }
|
| - umtx_unlock(&gCTMutex);
|
| -}
|
| -
|
| -void MultithreadTest::TestConditionVariables() {
|
| - gStartedThreads = 0;
|
| - gFinishedThreads = 0;
|
| - int i;
|
| -
|
| - umtx_lock(&gCTMutex);
|
| - CondThread *threads[NUMTHREADS];
|
| - for (i=0; i<NUMTHREADS; ++i) {
|
| - threads[i] = new CondThread;
|
| - threads[i]->start();
|
| - }
|
| -
|
| - while (gStartedThreads < NUMTHREADS) {
|
| - umtx_condWait(&gCTConditionVar, &gCTMutex);
|
| - }
|
| -
|
| - while (gFinishedThreads < NUMTHREADS) {
|
| - umtx_condWait(&gCTConditionVar, &gCTMutex);
|
| - }
|
| -
|
| - umtx_unlock(&gCTMutex);
|
| -
|
| - for (i=0; i<NUMTHREADS; ++i) {
|
| - if (!threads[i]->fFinished) {
|
| - errln("File %s, Line %d: Error, threads[%d]->fFinished == false", __FILE__, __LINE__, i);
|
| - }
|
| - }
|
| -
|
| - for (i=0; i<NUMTHREADS; ++i) {
|
| - threads[i]->join();
|
| - delete threads[i];
|
| - }
|
| -}
|
| -
|
| -
|
| -//
|
| -// Unified Cache Test
|
| -//
|
| -
|
| -// Each thread fetches a pair of objects. There are 8 distinct pairs:
|
| -// ("en_US", "bs"), ("en_GB", "ca"), ("fr_FR", "ca_AD") etc.
|
| -// These pairs represent 8 distinct languages
|
| -
|
| -// Note that only one value per language gets created in the cache.
|
| -// In particular each cached value can have multiple keys.
|
| -static const char *gCacheLocales[] = {
|
| - "en_US", "en_GB", "fr_FR", "fr",
|
| - "de", "sr_ME", "sr_BA", "sr_CS"};
|
| -static const char *gCacheLocales2[] = {
|
| - "bs", "ca", "ca_AD", "ca_ES",
|
| - "en_US", "fi", "ff_CM", "ff_GN"};
|
| -
|
| -static int32_t gObjectsCreated = 0; // protected by gCTMutex
|
| -static const int32_t CACHE_LOAD = 3;
|
| -
|
| -class UCTMultiThreadItem : public SharedObject {
|
| - public:
|
| - char *value;
|
| - UCTMultiThreadItem(const char *x) : value(NULL) {
|
| - value = uprv_strdup(x);
|
| - }
|
| - virtual ~UCTMultiThreadItem() {
|
| - uprv_free(value);
|
| - }
|
| -};
|
| -
|
| -U_NAMESPACE_BEGIN
|
| -
|
| -template<> U_EXPORT
|
| -const UCTMultiThreadItem *LocaleCacheKey<UCTMultiThreadItem>::createObject(
|
| - const void *context, UErrorCode &status) const {
|
| - const UnifiedCache *cacheContext = (const UnifiedCache *) context;
|
| -
|
| - if (uprv_strcmp(fLoc.getLanguage(), fLoc.getName()) != 0) {
|
| - const UCTMultiThreadItem *result = NULL;
|
| - if (cacheContext == NULL) {
|
| - UnifiedCache::getByLocale(fLoc.getLanguage(), result, status);
|
| - return result;
|
| - }
|
| - cacheContext->get(LocaleCacheKey<UCTMultiThreadItem>(fLoc.getLanguage()), result, status);
|
| - return result;
|
| - }
|
| -
|
| - umtx_lock(&gCTMutex);
|
| - bool firstObject = (gObjectsCreated == 0);
|
| - if (firstObject) {
|
| - // Force the first object creation that comes through to wait
|
| - // until other have completed. Verifies that cache doesn't
|
| - // deadlock when a creation is slow.
|
| -
|
| - // Note that gObjectsCreated needs to be incremeneted from 0 to 1
|
| - // early, to keep subsequent threads from entering this path.
|
| - gObjectsCreated = 1;
|
| - while (gObjectsCreated < 3) {
|
| - umtx_condWait(&gCTConditionVar, &gCTMutex);
|
| - }
|
| - }
|
| - umtx_unlock(&gCTMutex);
|
| -
|
| - const UCTMultiThreadItem *result =
|
| - new UCTMultiThreadItem(fLoc.getLanguage());
|
| - if (result == NULL) {
|
| - status = U_MEMORY_ALLOCATION_ERROR;
|
| - } else {
|
| - result->addRef();
|
| - }
|
| -
|
| - // Log that we created an object. The first object was already counted,
|
| - // don't do it again.
|
| - umtx_lock(&gCTMutex);
|
| - if (!firstObject) {
|
| - gObjectsCreated += 1;
|
| - }
|
| - umtx_condBroadcast(&gCTConditionVar);
|
| - umtx_unlock(&gCTMutex);
|
| -
|
| - return result;
|
| -}
|
| -
|
| -U_NAMESPACE_END
|
| -
|
| -class UnifiedCacheThread: public SimpleThread {
|
| - public:
|
| - UnifiedCacheThread(
|
| - const UnifiedCache *cache,
|
| - const char *loc,
|
| - const char *loc2) : fCache(cache), fLoc(loc), fLoc2(loc2) {};
|
| - ~UnifiedCacheThread() {};
|
| - void run();
|
| - void exerciseByLocale(const Locale &);
|
| - const UnifiedCache *fCache;
|
| - Locale fLoc;
|
| - Locale fLoc2;
|
| -};
|
| -
|
| -void UnifiedCacheThread::exerciseByLocale(const Locale &locale) {
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - const UCTMultiThreadItem *origItem = NULL;
|
| - fCache->get(
|
| - LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, origItem, status);
|
| - U_ASSERT(U_SUCCESS(status));
|
| - if (uprv_strcmp(locale.getLanguage(), origItem->value)) {
|
| - IntlTest::gTest->errln(
|
| - "%s:%d Expected %s, got %s", __FILE__, __LINE__,
|
| - locale.getLanguage(),
|
| - origItem->value);
|
| - }
|
| -
|
| - // Fetch the same item again many times. We should always get the same
|
| - // pointer since this client is already holding onto it
|
| - for (int32_t i = 0; i < 1000; ++i) {
|
| - const UCTMultiThreadItem *item = NULL;
|
| - fCache->get(
|
| - LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, item, status);
|
| - if (item != origItem) {
|
| - IntlTest::gTest->errln(
|
| - "%s:%d Expected to get the same pointer",
|
| - __FILE__,
|
| - __LINE__);
|
| - }
|
| - if (item != NULL) {
|
| - item->removeRef();
|
| - }
|
| - }
|
| - origItem->removeRef();
|
| -}
|
| -
|
| -void UnifiedCacheThread::run() {
|
| - // Run the exercise with 2 different locales so that we can exercise
|
| - // eviction more. If each thread exerices just one locale, then
|
| - // eviction can't start until the threads end.
|
| - exerciseByLocale(fLoc);
|
| - exerciseByLocale(fLoc2);
|
| -}
|
| -
|
| -void MultithreadTest::TestUnifiedCache() {
|
| -
|
| - // Start with our own local cache so that we have complete control
|
| - // and set the eviction policy to evict starting with 2 unused
|
| - // values
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - UnifiedCache::getInstance(status);
|
| - UnifiedCache cache(status);
|
| - cache.setEvictionPolicy(2, 0, status);
|
| - U_ASSERT(U_SUCCESS(status));
|
| -
|
| - gFinishedThreads = 0;
|
| - gObjectsCreated = 0;
|
| -
|
| - UnifiedCacheThread *threads[CACHE_LOAD][UPRV_LENGTHOF(gCacheLocales)];
|
| - for (int32_t i=0; i<CACHE_LOAD; ++i) {
|
| - for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
|
| - // Each thread works with a pair of locales.
|
| - threads[i][j] = new UnifiedCacheThread(
|
| - &cache, gCacheLocales[j], gCacheLocales2[j]);
|
| - threads[i][j]->start();
|
| - }
|
| - }
|
| -
|
| - for (int32_t i=0; i<CACHE_LOAD; ++i) {
|
| - for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
|
| - threads[i][j]->join();
|
| - }
|
| - }
|
| - // Because of cache eviction, we can't assert exactly how many
|
| - // distinct objects get created over the course of this run.
|
| - // However we know that at least 8 objects get created because that
|
| - // is how many distinct languages we have in our test.
|
| - if (gObjectsCreated < 8) {
|
| - errln("%s:%d Too few objects created.", __FILE__, __LINE__);
|
| - }
|
| - // We know that each thread cannot create more than 2 objects in
|
| - // the cache, and there are UPRV_LENGTHOF(gCacheLocales) pairs of
|
| - // objects fetched from the cache. If the threads run in series because
|
| - // of eviction, at worst case each thread creates two objects.
|
| - if (gObjectsCreated > 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales)) {
|
| - errln("%s:%d Too many objects created, got %d, expected %d", __FILE__, __LINE__, gObjectsCreated, 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales));
|
| -
|
| - }
|
| -
|
| - assertEquals("unused values", 2, cache.unusedCount());
|
| -
|
| - // clean up threads
|
| - for (int32_t i=0; i<CACHE_LOAD; ++i) {
|
| - for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
|
| - delete threads[i][j];
|
| - }
|
| - }
|
| -}
|
| -
|
| -#if !UCONFIG_NO_TRANSLITERATION
|
| -//
|
| -// BreakTransliterator Threading Test
|
| -// This is a test for bug #11603. Test verified to fail prior to fix.
|
| -//
|
| -
|
| -static const Transliterator *gSharedTransliterator;
|
| -static const UnicodeString *gTranslitInput;
|
| -static const UnicodeString *gTranslitExpected;
|
| -
|
| -class BreakTranslitThread: public SimpleThread {
|
| - public:
|
| - BreakTranslitThread() {};
|
| - ~BreakTranslitThread() {};
|
| - void run();
|
| -};
|
| -
|
| -void BreakTranslitThread::run() {
|
| - for (int i=0; i<10; i++) {
|
| - icu::UnicodeString s(*gTranslitInput);
|
| - gSharedTransliterator->transliterate(s);
|
| - if (*gTranslitExpected != s) {
|
| - IntlTest::gTest->errln("%s:%d Transliteration threading failure.", __FILE__, __LINE__);
|
| - break;
|
| - }
|
| - }
|
| -}
|
| -
|
| -void MultithreadTest::TestBreakTranslit() {
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - UnicodeString input(
|
| - "\\u0E42\\u0E14\\u0E22\\u0E1E\\u0E37\\u0E49\\u0E19\\u0E10\\u0E32\\u0E19\\u0E41\\u0E25\\u0E49\\u0E27,");
|
| - input = input.unescape();
|
| - gTranslitInput = &input;
|
| -
|
| - gSharedTransliterator = Transliterator::createInstance(
|
| - UNICODE_STRING_SIMPLE("Any-Latin; Lower; NFD; [:Diacritic:]Remove; NFC; Latin-ASCII;"), UTRANS_FORWARD, status);
|
| - if (!gSharedTransliterator) {
|
| - return;
|
| - }
|
| - TSMTHREAD_ASSERT_SUCCESS(status);
|
| -
|
| - UnicodeString expected(*gTranslitInput);
|
| - gSharedTransliterator->transliterate(expected);
|
| - gTranslitExpected = &expected;
|
| -
|
| - BreakTranslitThread threads[4];
|
| - for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
|
| - threads[i].start();
|
| - }
|
| - for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
|
| - threads[i].join();
|
| - }
|
| -
|
| - delete gSharedTransliterator;
|
| - gTranslitInput = NULL;
|
| - gTranslitExpected = NULL;
|
| -}
|
| -
|
| -#endif /* !UCONFIG_NO_TRANSLITERATION */
|
|
|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
