source/test/intltest/tsmthred.cpp - Issue 1621843002: ICU 56 update step 1

Unified Diff: source/test/intltest/tsmthred.cpp

Issue 1621843002: ICU 56 update step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@561

Patch Set: Created 4 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: source/test/intltest/tsmthred.cpp

diff --git a/source/test/intltest/tsmthred.cpp b/source/test/intltest/tsmthred.cpp

index f63990118a1d5451c53f31f16e61146749ff085f..fd89af1ee83971ff230c79879dcede663c724f2c 100644

--- a/source/test/intltest/tsmthred.cpp

+++ b/source/test/intltest/tsmthred.cpp

@@ -1,15 +1,9 @@

/********************************************************************

- * COPYRIGHT:

+ * COPYRIGHT:

********************************************************************/

-#if defined(hpux)

-# ifndef _INCLUDE_POSIX_SOURCE

-# define _INCLUDE_POSIX_SOURCE

-# endif

-#endif

#include "simplethread.h"

#include "unicode/utypes.h"

@@ -32,76 +26,11 @@

#include "unifiedcache.h"

#include "uassert.h"

-#if U_PLATFORM_USES_ONLY_WIN32_API

- /* Prefer native Windows APIs even if POSIX is implemented (i.e., on Cygwin). */

-# undef POSIX

-#elif U_PLATFORM_IMPLEMENTS_POSIX

-# define POSIX

-#else

-# undef POSIX

-#endif

-/* Needed by z/OS to get usleep */

-#if U_PLATFORM == U_PF_OS390

-#define __DOT1 1

-#define __UU

-#ifndef _XPG4_2

-#define _XPG4_2

-#endif

-#include <unistd.h>

-#endif

-#if defined(POSIX)

-#define HAVE_IMP

-#if (ICU_USE_THREADS == 1)

-#include <pthread.h>

-#endif

-#if defined(__hpux) && defined(HPUX_CMA)

-# if defined(read) // read being defined as cma_read causes trouble with iostream::read

-# undef read

-# endif

-#endif

-/* Define __EXTENSIONS__ for Solaris and old friends in strict mode. */

-#ifndef __EXTENSIONS__

-#define __EXTENSIONS__

-#endif

-#if U_PLATFORM == U_PF_OS390

-#include <sys/types.h>

-#endif

-#if U_PLATFORM != U_PF_OS390

-#include <signal.h>

-#endif

-/* Define _XPG4_2 for Solaris and friends. */

-#ifndef _XPG4_2

-#define _XPG4_2

-#endif

-/* Define __USE_XOPEN_EXTENDED for Linux and glibc. */

-#ifndef __USE_XOPEN_EXTENDED

-#define __USE_XOPEN_EXTENDED

-#endif

-/* Define _INCLUDE_XOPEN_SOURCE_EXTENDED for HP/UX (11?). */

-#ifndef _INCLUDE_XOPEN_SOURCE_EXTENDED

-#define _INCLUDE_XOPEN_SOURCE_EXTENDED

-#endif

-#include <unistd.h>

-#endif

-/* HPUX */

-#ifdef sleep

-#undef sleep

-#endif

#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()

{

@@ -111,23 +40,6 @@ MultithreadTest::~MultithreadTest()

{

}

-#if (ICU_USE_THREADS==0)

-void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

- const char* &name, char* /*par*/ ) {

- if (exec) logln("TestSuite MultithreadTest: ");

- if(index == 0)

- name = "NO_THREADED_TESTS";

- else

- name = "";

- if(exec) { logln("MultithreadTest - test DISABLED. ICU_USE_THREADS set to 0, check your configuration if this is a problem..");

- }

-#else

#include <stdio.h>

#include <string.h>

#include <ctype.h> // tolower, toupper

@@ -143,11 +55,8 @@ void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

#include "unicode/calendar.h"

#include "ucaconf.h"

-void SimpleThread::errorFunc() {

- // *(char *)0 = 3; // Force entry into a debugger via a crash;

-void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

+void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

const char* &name, char* /*par*/ ) {

if (exec)

logln("TestSuite MultithreadTest: ");

@@ -183,14 +92,14 @@ void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

break;

case 4:

- name = "TestString";

+ name = "TestString";

if (exec) {

TestString();

}

break;

case 5:

- name = "TestArabicShapingThreads";

+ name = "TestArabicShapingThreads";

if (exec) {

TestArabicShapingThreads();

}

@@ -202,7 +111,7 @@ void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

TestAnyTranslit();

}

break;

case 7:

name = "TestConditionVariables";

if (exec) {

@@ -215,6 +124,14 @@ void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

TestUnifiedCache();

}

break;

+#if !UCONFIG_NO_TRANSLITERATION

+ case 9:

+ name = "TestBreakTranslit";

+ if (exec) {

+ TestBreakTranslit();

+ }

+ break;

+#endif

default:

name = "";

break; //needed to end loop

@@ -227,96 +144,25 @@ void MultithreadTest::runIndexedTest( int32_t index, UBool exec,

// TestThreads -- see if threads really work at all.

// Set up N threads pointing at N chars. When they are started, they will

-// each sleep 1 second and then set their chars. At the end we make sure they

-// are all set.

+// set their chars. At the end we make sure they are all set.

//-----------------------------------------------------------------------------------

-#define THREADTEST_NRTHREADS 8

-#define ARABICSHAPE_THREADTEST 30

class TestThreadsThread : public SimpleThread

{

public:

TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }

- virtual void run() { SimpleThread::sleep(1000);

- Mutex m;

- *fWhatToChange = '*';

+ virtual void run() { Mutex m;

+ *fWhatToChange = '*';

}

private:

char *fWhatToChange;

};

-//-----------------------------------------------------------------------------------

-//

-// 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(char* whatToChange) { fWhatToChange = whatToChange;}

- virtual void run() {

- if(doTailTest()==TRUE)

- *fWhatToChange = '*';

- }

-private:

- char *fWhatToChange;

- UBool 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;

- IntlTest inteltst = IntlTest();

- 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)) {

- inteltst.errln("Fail: status %s\n", u_errorName(status));

- return FALSE;

- } else if(length!=2) {

- inteltst.errln("Fail: len %d expected 3\n", length);

- return FALSE;

- } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {

- inteltst.errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",

- dst[0],dst[1],dst_old[0],dst_old[1]);

- return FALSE;

- }

- //"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)) {

- inteltst.errln("Fail: status %s\n", u_errorName(status));

- return FALSE;

- } else if(length!=2) {

- inteltst.errln("Fail: len %d expected 3\n", length);

- return FALSE;

- } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {

- inteltst.errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",

- dst[0],dst[1],dst_new[0],dst_new[1]);

- return FALSE;

- }

- return TRUE;

-};

void MultithreadTest::TestThreads()

{

+ static const int32_t THREADTEST_NRTHREADS = 8;

char threadTestChars[THREADTEST_NRTHREADS + 1];

SimpleThread *threads[THREADTEST_NRTHREADS];

int32_t numThreadsStarted = 0;

@@ -338,273 +184,211 @@ void MultithreadTest::TestThreads()

else {

numThreadsStarted++;

}

- SimpleThread::sleep(100);

logln(" Subthread started.");

}

- logln("Waiting for threads to be set..");

- if (numThreadsStarted == 0) {

- errln("No threads could be started for testing!");

+ if (numThreadsStarted != THREADTEST_NRTHREADS) {

+ errln("Not all threads could be started for testing!");

return;

}

- int32_t patience = 40; // seconds to wait

- while(patience--)

- {

- int32_t count = 0;

- umtx_lock(NULL);

- for(i=0;i<THREADTEST_NRTHREADS;i++)

- {

- if(threadTestChars[i] == '*')

- {

- count++;

- }

- umtx_unlock(NULL);

- if(count == THREADTEST_NRTHREADS)

- {

- logln("->" + UnicodeString(threadTestChars) + "<- Got all threads! cya");

- for(i=0;i<THREADTEST_NRTHREADS;i++)

- {

- delete threads[i];

- }

- 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);

}

- logln("->" + UnicodeString(threadTestChars) + "<- Waiting..");

- SimpleThread::sleep(500);

- }

- errln("->" + UnicodeString(threadTestChars) + "<- PATIENCE EXCEEDED!! Still missing some.");

- for(i=0;i<THREADTEST_NRTHREADS;i++)

- {

delete threads[i];

}

-void MultithreadTest::TestArabicShapingThreads()

+//-----------------------------------------------------------------------------------

+//

+// 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

{

- char threadTestChars[ARABICSHAPE_THREADTEST + 1];

- SimpleThread *threads[ARABICSHAPE_THREADTEST];

- int32_t numThreadsStarted = 0;

+public:

+ TestArabicShapeThreads() {};

+ virtual void run() { doTailTest(); };

+private:

+ void doTailTest();

+};

- int32_t i;

- for(i=0;i<ARABICSHAPE_THREADTEST;i++)

- {

- threadTestChars[i] = ' ';

- threads[i] = new TestArabicShapeThreads(&threadTestChars[i]);

- }

- threadTestChars[ARABICSHAPE_THREADTEST] = '\0';

- logln("-> do TestArabicShapingThreads <- Firing off threads.. ");

- for(i=0;i<ARABICSHAPE_THREADTEST;i++)

- {

- if (threads[i]->start() != 0) {

- errln("Error starting thread %d", i);

+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;

}

- else {

- numThreadsStarted++;

+ //"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;

}

- //SimpleThread::sleep(100);

- logln(" Subthread started.");

}

+ return;

- logln("Waiting for threads to be set..");

- if (numThreadsStarted == 0) {

- errln("No threads could be started for testing!");

- return;

- }

+void MultithreadTest::TestArabicShapingThreads()

+ TestArabicShapeThreads threads[30];

- int32_t patience = 100; // seconds to wait

+ int32_t i;

- while(patience--)

- {

- int32_t count = 0;

- umtx_lock(NULL);

- for(i=0;i<ARABICSHAPE_THREADTEST;i++)

- {

- if(threadTestChars[i] == '*')

- {

- count++;

- }

- umtx_unlock(NULL);

- if(count == ARABICSHAPE_THREADTEST)

- {

- logln("->TestArabicShapingThreads <- Got all threads! cya");

- for(i=0;i<ARABICSHAPE_THREADTEST;i++)

- {

- delete threads[i];

- }

- return;

+ 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);

}

- logln("-> TestArabicShapingThreads <- Waiting..");

- SimpleThread::sleep(500);

}

- errln("-> TestArabicShapingThreads <- PATIENCE EXCEEDED!! Still missing some.");

- for(i=0;i<ARABICSHAPE_THREADTEST;i++)

- {

- delete threads[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

-// are actually mutexing. Does not test the use of

+// 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 UMutex gTestMutexB = U_MUTEX_INITIALIZER;

+static UMutex gTestMutexA = U_MUTEX_INITIALIZER;

+static UConditionVar gThreadsCountChanged = U_CONDITION_INITIALIZER;

-static int gThreadsStarted = 0;

+static int gThreadsStarted = 0;

static int gThreadsInMiddle = 0;

static int gThreadsDone = 0;

-static const int TESTMUTEX_THREAD_COUNT = 4;

-static int safeIncr(int &var, int amt) {

- // Thread safe (using global mutex) increment of a variable.

- // Return the updated value.

- // Can also be used as a safe load of a variable by incrementing it by 0.

- Mutex m;

- var += amt;

- return var;

+static const int TESTMUTEX_THREAD_COUNT = 40;

class TestMutexThread : public SimpleThread

{

public:

- virtual void run()

- {

+ virtual void run() {

// This is the code that each of the spawned threads runs.

- // All of the spawned threads bunch up together at each of the two mutexes

- // because the main holds the mutexes until they do.

- //

- safeIncr(gThreadsStarted, 1);

+ // 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);

- safeIncr(gThreadsInMiddle, 1);

- umtx_lock(&gTestMutexB);

- umtx_unlock(&gTestMutexB);

- safeIncr(gThreadsDone, 1);

}

};

void MultithreadTest::TestMutex()

{

- // Start up the test threads. They should all pile up waiting on

- // gTestMutexA, which we (the main thread) hold until the test threads

- // all get there.

gThreadsStarted = 0;

gThreadsInMiddle = 0;

gThreadsDone = 0;

+ int32_t i = 0;

+ TestMutexThread threads[TESTMUTEX_THREAD_COUNT];

umtx_lock(&gTestMutexA);

- TestMutexThread *threads[TESTMUTEX_THREAD_COUNT];

- int i;

- int32_t numThreadsStarted = 0;

for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {

- threads[i] = new TestMutexThread;

- if (threads[i]->start() != 0) {

- errln("Error starting thread %d", i);

- }

- else {

- numThreadsStarted++;

- }

- if (numThreadsStarted == 0) {

- errln("No threads could be started for testing!");

- return;

- }

- int patience = 0;

- while (safeIncr(gThreadsStarted, 0) != TESTMUTEX_THREAD_COUNT) {

- if (patience++ > 24) {

- TSMTHREAD_FAIL("Patience Exceeded");

+ if (threads[i].start() != 0) {

+ errln("%s:%d Error starting thread %d", __FILE__, __LINE__, i);

return;

}

- SimpleThread::sleep(500);

}

- // None of the test threads should have advanced past the first mutex.

- TSMTHREAD_ASSERT(gThreadsInMiddle==0);

- TSMTHREAD_ASSERT(gThreadsDone==0);

- // All of the test threads have made it to the first mutex.

- // We (the main thread) now let them advance to the second mutex,

- // where they should all pile up again.

- umtx_lock(&gTestMutexB);

- umtx_unlock(&gTestMutexA);

- patience = 0;

- while (safeIncr(gThreadsInMiddle, 0) != TESTMUTEX_THREAD_COUNT) {

- if (patience++ > 24) {

- TSMTHREAD_FAIL("Patience Exceeded");

- return;

- }

- SimpleThread::sleep(500);

+ // 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;

}

- TSMTHREAD_ASSERT(gThreadsDone==0);

- // All test threads made it to the second mutex.

- // Now let them proceed from there. They will all terminate.

- umtx_unlock(&gTestMutexB);

- patience = 0;

- while (safeIncr(gThreadsDone, 0) != TESTMUTEX_THREAD_COUNT) {

- if (patience++ > 24) {

- TSMTHREAD_FAIL("Patience Exceeded");

+ while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {

+ if (gThreadsDone != 0) {

+ errln("%s:%d gThreadsDone=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);

return;

}

- SimpleThread::sleep(500);

+ umtx_condWait(&gThreadsCountChanged, &gTestMutexA);

}

- // All threads made it by both mutexes.

+ while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {

+ umtx_condWait(&gThreadsCountChanged, &gTestMutexA);

+ }

+ umtx_unlock(&gTestMutexA);

for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {

- delete threads[i];

+ threads[i].join();

}

//-------------------------------------------------------------------------------------------

-// class ThreadWithStatus - a thread that we can check the status and error condition of

-//

-//-------------------------------------------------------------------------------------------

-class ThreadWithStatus : public SimpleThread

-public:

- UBool getError() { return (fErrors > 0); }

- UBool getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }

- virtual ~ThreadWithStatus(){}

-protected:

- ThreadWithStatus() : fErrors(0) {}

- void error(const UnicodeString &error) {

- fErrors++; fErrorString = error;

- SimpleThread::errorFunc();

- }

- void error() { error("An error occured."); }

-private:

- int32_t fErrors;

- UnicodeString fErrorString;

-};

-//-------------------------------------------------------------------------------------------

-//

-// TestMultithreadedIntl. Test ICU Formatting n a multi-threaded environment

+// TestMultithreadedIntl. Test ICU Formatting in a multi-threaded environment

//-------------------------------------------------------------------------------------------

@@ -638,8 +422,6 @@ UnicodeString showDifference(const UnicodeString& expected, const UnicodeString&

}

//-------------------------------------------------------------------------------------------

// FormatThreadTest - a thread that tests performing a number of numberformats.

@@ -647,7 +429,7 @@ UnicodeString showDifference(const UnicodeString& expected, const UnicodeString&

//-------------------------------------------------------------------------------------------

const int kFormatThreadIterations = 100; // # of iterations per thread

-const int kFormatThreadThreads = 10; // # of threads to spawn

+const int kFormatThreadThreads = 10; // # of threads to spawn

#if !UCONFIG_NO_FORMATTING

@@ -685,81 +467,79 @@ static void formatErrorMessage(UErrorCode &realStatus, const UnicodeString& patt

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;

+ FieldPosition ignore = 0;

fmt->format(myArgs,4,result,ignore,realStatus);

delete fmt;

}

/**

- * Class for thread-safe (theoretically) format.

- *

- * Its constructor, destructor, and init/fini are NOT thread safe.

+ * 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();

- UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status);

-private:

- LocalPointer<NumberFormat> fFormat; // formtter - default constructed currency

- Formattable fYDDThing; // Formattable currency - YDD

- Formattable fBBDThing; // Formattable currency - BBD

- // statics

+ ThreadSafeFormat(UErrorCode &status);

+ UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const;

private:

- static LocalPointer<NumberFormat> gFormat;

- static NumberFormat *createFormat(UErrorCode &status);

- static Formattable gYDDThing, gBBDThing;

-public:

- static void init(UErrorCode &status); // avoid static init.

- static void fini(UErrorCode &status); // avoid static fini

+ LocalPointer<NumberFormat> fFormat; // formatter - en_US constructed currency

};

-LocalPointer<NumberFormat> ThreadSafeFormat::gFormat;

-Formattable ThreadSafeFormat::gYDDThing;

-Formattable ThreadSafeFormat::gBBDThing;

-UnicodeString gYDDStr, gBBDStr;

-NumberFormat *ThreadSafeFormat::createFormat(UErrorCode &status) {

- LocalPointer<NumberFormat> fmt(NumberFormat::createCurrencyInstance(Locale::getUS(), status));

- return fmt.orphan();

-static const UChar kYDD[] = { 0x59, 0x44, 0x44, 0x00 };

-static const UChar kBBD[] = { 0x42, 0x42, 0x44, 0x00 };

-static const UChar kUSD[] = { 0x55, 0x53, 0x44, 0x00 };

-void ThreadSafeFormat::init(UErrorCode &status) {

- gFormat.adoptInstead(createFormat(status));

- gYDDThing.adoptObject(new CurrencyAmount(123.456, kYDD, status));

- gBBDThing.adoptObject(new CurrencyAmount(987.654, kBBD, status));

- if (U_FAILURE(status)) {

- return;

- }

- gFormat->format(gYDDThing, gYDDStr, NULL, status);

- gFormat->format(gBBDThing, gBBDStr, NULL, status);

-void ThreadSafeFormat::fini(UErrorCode &/*status*/) {

- gFormat.adoptInstead(NULL);

+ThreadSafeFormat::ThreadSafeFormat(UErrorCode &status) {

+ fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));

}

-ThreadSafeFormat::ThreadSafeFormat() {

+static const UChar kUSD[] = { 0x55, 0x53, 0x44, 0x00 };

-UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) {

+UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const {

UBool okay = TRUE;

- if(fFormat.isNull()) {

- fFormat.adoptInstead(createFormat(status));

- }

if(u_strcmp(fFormat->getCurrency(), kUSD)) {

appendErr.append("fFormat currency != ")

@@ -770,11 +550,11 @@ UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UError

okay = FALSE;

}

- if(u_strcmp(gFormat->getCurrency(), kUSD)) {

+ if(u_strcmp(gSharedData->fFormat->getCurrency(), kUSD)) {

appendErr.append("gFormat currency != ")

.append(kUSD)

.append(", =")

- .append(gFormat->getCurrency())

+ .append(gSharedData->fFormat->getCurrency())

.append("! ");

okay = FALSE;

}

@@ -783,10 +563,10 @@ UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UError

Formattable f;

const NumberFormat *nf = NULL; // only operate on it as const.

switch(offset%4) {

- case 0: f = gYDDThing; o = &gYDDStr; nf = gFormat.getAlias(); break;

- case 1: f = gBBDThing; o = &gBBDStr; nf = gFormat.getAlias(); break;

- case 2: f = gYDDThing; o = &gYDDStr; nf = fFormat.getAlias(); break;

- case 3: f = gBBDThing; o = &gBBDStr; nf = fFormat.getAlias(); break;

+ 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);

@@ -805,21 +585,24 @@ UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInf

//static UMTX gDebugMutex;

-class FormatThreadTest : public ThreadWithStatus

+class FormatThreadTest : public SimpleThread

{

public:

int fNum;

int fTraceInfo;

- ThreadSafeFormat fTSF;

+ LocalPointer<ThreadSafeFormat> fTSF;

FormatThreadTest() // constructor is NOT multithread safe.

- : ThreadWithStatus(),

+ : 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;

@@ -833,7 +616,7 @@ public:

UErrorCode status = U_ZERO_ERROR;

#if 0

- // debugging code,

+ // debugging code,

for (int i=0; i<4000; i++) {

status = U_ZERO_ERROR;

UDataMemory *data1 = udata_openChoice(0, "res", "en_US", isAcceptable, 0, &status);

@@ -849,7 +632,7 @@ public:

#endif

#if 0

- // debugging code,

+ // debugging code,

int m;

for (m=0; m<4000; m++) {

status = U_ZERO_ERROR;

@@ -879,7 +662,7 @@ public:

#endif

// Keep this data here to avoid static initialization.

- FormatThreadTestData kNumberFormatTestData[] =

+ FormatThreadTestData kNumberFormatTestData[] =

{

FormatThreadTestData((double)5.0, UnicodeString("5", "")),

FormatThreadTestData( 6.0, UnicodeString("6", "")),

@@ -889,74 +672,74 @@ public:

FormatThreadTestData( 12345, UnicodeString("12,345", "")),

FormatThreadTestData( 81890.23, UnicodeString("81,890.23", "")),

};

- int32_t kNumberFormatTestDataLength = (int32_t)(sizeof(kNumberFormatTestData) /

- sizeof(kNumberFormatTestData[0]));

+ int32_t kNumberFormatTestDataLength = UPRV_LENGTHOF(kNumberFormatTestData);

// Keep this data here to avoid static initialization.

- FormatThreadTestData kPercentFormatTestData[] =

+ FormatThreadTestData kPercentFormatTestData[] =

{

FormatThreadTestData((double)5.0, CharsToUnicodeString("500\\u00a0%")),

FormatThreadTestData( 1.0, CharsToUnicodeString("100\\u00a0%")),

FormatThreadTestData( 0.26, CharsToUnicodeString("26\\u00a0%")),

- FormatThreadTestData(

+ FormatThreadTestData(

16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499\\u00a0%")), // U+00a0 = NBSP

- FormatThreadTestData(

+ FormatThreadTestData(

81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023\\u00a0%")),

};

- int32_t kPercentFormatTestDataLength =

- (int32_t)(sizeof(kPercentFormatTestData) / sizeof(kPercentFormatTestData[0]));

+ 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)) {

- error("Error on NumberFormat::createInstance().");

+ 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)) {

- error("Error on NumberFormat::createPercentInstance().");

+ IntlTest::gTest->errln("%s:%d Error %s on NumberFormat::createPercentInstance().",

+ __FILE__, __LINE__, u_errorName(status));

goto cleanupAndReturn;

}

- for(iteration = 0;!getError() && iteration<kFormatThreadIterations;iteration++)

+ 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)) {

- error("format().. expected " + 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))

{

- error("percent format().. \n" +

+ IntlTest::gTest->errln("percent format().. \n" +

showDifference(kPercentFormatTestData[whichLine].string,output));

goto cleanupAndReturn;

}

- // Test message error

+ // 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)

{

@@ -974,12 +757,14 @@ public:

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

+ 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.");

+ "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;

@@ -992,10 +777,10 @@ public:

expected= CharsToUnicodeString(

"2:user in Vereinigte Staaten is receiving a #7 error"

" - U_MEMORY_ALLOCATION_ERROR. They insist they just spent"

- " \\u00f6S\\u00A040.193,12 on memory.");

+ " \\u00f6S\\u00A040\\u00A0193,12 on memory.");

break;

}

UnicodeString result;

UErrorCode status = U_ZERO_ERROR;

formatErrorMessage(status,patternToCheck,messageLocale,statusToCheck,

@@ -1003,20 +788,20 @@ public:

if(U_FAILURE(status))

{

UnicodeString tmp(u_errorName(status));

- error("Failure on message format, pattern=" + patternToCheck +

+ IntlTest::gTest->errln("Failure on message format, pattern=" + patternToCheck +

", error = " + tmp);

goto cleanupAndReturn;

}

if(result != expected)

{

- error("PatternFormat: \n" + showDifference(expected,result));

+ IntlTest::gTest->errln("PatternFormat: \n" + showDifference(expected,result));

goto cleanupAndReturn;

}

// test the Thread Safe Format

UnicodeString appendErr;

- if(!fTSF.doStuff(fNum, appendErr, status)) {

- error(appendErr);

+ if(!fTSF->doStuff(fNum, appendErr, status)) {

+ IntlTest::gTest->errln(appendErr);

goto cleanupAndReturn;

}

} /* end of for loop */

@@ -1024,10 +809,9 @@ public:

cleanupAndReturn:

- // while (fNum == 4) {SimpleThread::sleep(10000);} // Force a failure by preventing thread from finishing

fTraceInfo = 2;

}

private:

int32_t fOffset; // where we are testing from.

};

@@ -1036,14 +820,11 @@ private:

void MultithreadTest::TestThreadedIntl()

{

- int i;

UnicodeString theErr;

- UBool haveDisplayedInfo[kFormatThreadThreads];

- static const int32_t PATIENCE_SECONDS = 45;

UErrorCode threadSafeErr = U_ZERO_ERROR;

- ThreadSafeFormat::init(threadSafeErr);

+ ThreadSafeFormatSharedData sharedData(threadSafeErr);

assertSuccess("initializing ThreadSafeFormat", threadSafeErr, TRUE);

@@ -1051,61 +832,23 @@ void MultithreadTest::TestThreadedIntl()

logln("Spawning: %d threads * %d iterations each.",

kFormatThreadThreads, kFormatThreadIterations);

- LocalArray<FormatThreadTest> tests(new FormatThreadTest[kFormatThreadThreads]);

- for(int32_t j = 0; j < kFormatThreadThreads; j++) {

+ 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("System Error %d starting thread number %d.", threadStatus, j);

- SimpleThread::errorFunc();

+ errln("%s:%d System Error %d starting thread number %d.",

+ __FILE__, __LINE__, threadStatus, j);

return;

}

- haveDisplayedInfo[j] = FALSE;

- }

- // Spin, waiting for the test threads to finish.

- UBool stillRunning;

- UDate startTime, endTime;

- startTime = Calendar::getNow();

- double lastComplaint = 0;

- do {

- /* Spin until the test threads complete. */

- stillRunning = FALSE;

- endTime = Calendar::getNow();

- double elapsedSeconds = ((int32_t)(endTime - startTime)/U_MILLIS_PER_SECOND);

- if (elapsedSeconds > PATIENCE_SECONDS) {

- errln("Patience exceeded. Test is taking too long.");

- return;

- } else if((elapsedSeconds-lastComplaint) > 2.0) {

- infoln("%.1f seconds elapsed (still waiting..)", elapsedSeconds);

- lastComplaint = elapsedSeconds;

- }

- /*

- The following sleep must be here because the *BSD operating systems

- have a brain dead thread scheduler. They starve the child threads from

- CPU time.

- */

- SimpleThread::sleep(1); // yield

- for(i=0;i<kFormatThreadThreads;i++) {

- if (tests[i].isRunning()) {

- stillRunning = TRUE;

- } else if (haveDisplayedInfo[i] == FALSE) {

- logln("Thread # %d is complete..", i);

- if(tests[i].getError(theErr)) {

- dataerrln(UnicodeString("#") + i + ": " + theErr);

- SimpleThread::errorFunc();

- }

- haveDisplayedInfo[i] = TRUE;

- }

- } while (stillRunning);

+ }

- //

- // All threads have finished.

- //

- ThreadSafeFormat::fini(threadSafeErr);

- assertSuccess("finalizing ThreadSafeFormat", threadSafeErr, TRUE);

+ for (j=0; j<UPRV_LENGTHOF(tests); j++) {

+ tests[j].join();

+ logln("Thread # %d is complete..", j);

+ }

}

#endif /* #if !UCONFIG_NO_FORMATTING */

@@ -1145,15 +888,15 @@ normalizeResult(int32_t result) {

return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;

}

-class CollatorThreadTest : public ThreadWithStatus

+class CollatorThreadTest : public SimpleThread

{

-private:

+private:

const Collator *coll;

const Line *lines;

int32_t noLines;

UBool isAtLeastUCA62;

public:

- CollatorThreadTest() : ThreadWithStatus(),

+ CollatorThreadTest() : SimpleThread(),

coll(NULL),

lines(NULL),

noLines(0),

@@ -1187,12 +930,12 @@ public:

int32_t cmpres2 = coll->compare(lines[i].buff, lines[i].buflen, lines[prev].buff, lines[prev].buflen);

if(cmpres != -cmpres2) {

- error(UnicodeString("Compare result not symmetrical on line ") + (i + 1));

+ IntlTest::gTest->errln(UnicodeString("Compare result not symmetrical on line ") + (i + 1));

break;

}

if(cmpres != normalizeResult(skres)) {

- error(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));

+ IntlTest::gTest->errln(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));

break;

}

@@ -1206,7 +949,7 @@ public:

// which we do via setting strength=identical.

}

if(res > 0) {

- error(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));

+ IntlTest::gTest->errln(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));

break;

}

@@ -1268,7 +1011,7 @@ void MultithreadTest::TestCollators()

if (testFile == 0) {

*(buffer+bufLen) = 0;

dataerrln("could not open any of the conformance test files, tried opening base %s", buffer);

- return;

+ return;

} else {

infoln(

"INFO: Working with the stub file.\n"

@@ -1322,7 +1065,6 @@ void MultithreadTest::TestCollators()

coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);

coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, status);

- int32_t noSpawned = 0;

int32_t spawnResult = 0;

LocalArray<CollatorThreadTest> tests(new CollatorThreadTest[kCollatorThreadThreads]);

@@ -1336,60 +1078,16 @@ void MultithreadTest::TestCollators()

log("%i ", j);

spawnResult = tests[j].start();

if(spawnResult != 0) {

- infoln("THREAD INFO: Couldn't spawn more than %i threads", noSpawned);

- break;

+ errln("%s:%d THREAD INFO: thread %d failed to start with status %d", __FILE__, __LINE__, j, spawnResult);

+ return;

}

- noSpawned++;

}

logln("Spawned all");

- if (noSpawned == 0) {

- errln("No threads could be spawned.");

- return;

- }

- for(int32_t patience = kCollatorThreadPatience;patience > 0; patience --)

- {

- logln("Waiting...");

- int32_t i;

- int32_t terrs = 0;

- int32_t completed =0;

- for(i=0;i<kCollatorThreadThreads;i++)

- {

- if (tests[i].isRunning() == FALSE)

- {

- completed++;

- //logln(UnicodeString("Test #") + i + " is complete.. ");

- UnicodeString theErr;

- if(tests[i].getError(theErr))

- {

- terrs++;

- errln(UnicodeString("#") + i + ": " + theErr);

- }

- // print out the error, too, if any.

- }

- logln("Completed %i tests", completed);

- if(completed == noSpawned)

- {

- logln("Done! All %i tests are finished", noSpawned);

- if(terrs)

- {

- errln("There were errors.");

- SimpleThread::errorFunc();

- }

- return;

- }

- SimpleThread::sleep(900);

+ for(int32_t i=0;i<kCollatorThreadThreads;i++) {

+ tests[i].join();

+ //logln(UnicodeString("Test #") + i + " is complete.. ");

}

- errln("patience exceeded. ");

- SimpleThread::errorFunc();

}

#endif /* #if !UCONFIG_NO_COLLATION */

@@ -1399,27 +1097,24 @@ void MultithreadTest::TestCollators()

//-------------------------------------------------------------------------------------------

-// StringThreadTest2

+// StringThreadTest2

//-------------------------------------------------------------------------------------------

const int kStringThreadIterations = 2500;// # of iterations per thread

const int kStringThreadThreads = 10; // # of threads to spawn

-const int kStringThreadPatience = 120; // time in seconds to wait for all threads

-class StringThreadTest2 : public ThreadWithStatus

+class StringThreadTest2 : public SimpleThread

{

public:

int fNum;

int fTraceInfo;

- const UnicodeString *fSharedString;

+ static const UnicodeString *gSharedString;

- StringThreadTest2(const UnicodeString *sharedString, int num) // constructor is NOT multithread safe.

- : ThreadWithStatus(),

- fNum(num),

- fTraceInfo(0),

- fSharedString(sharedString)

+ StringThreadTest2() // constructor is NOT multithread safe.

+ : SimpleThread(),

+ fTraceInfo(0)

{

};

@@ -1430,128 +1125,68 @@ public:

int loopCount = 0;

for (loopCount = 0; loopCount < kStringThreadIterations; loopCount++) {

- if (*fSharedString != "This is the original test string.") {

- error("Original string is corrupt.");

+ if (*gSharedString != "This is the original test string.") {

+ IntlTest::gTest->errln("%s:%d Original string is corrupt.", __FILE__, __LINE__);

break;

}

- UnicodeString s1 = *fSharedString;

+ UnicodeString s1 = *gSharedString;

s1 += "cat this";

UnicodeString s2(s1);

- UnicodeString s3 = *fSharedString;

+ UnicodeString s3 = *gSharedString;

s2 = s3;

s3.truncate(12);

s2.truncate(0);

}

- // while (fNum == 4) {SimpleThread::sleep(10000);} // Force a failure by preventing thread from finishing

fTraceInfo = 2;

}

};

+const UnicodeString *StringThreadTest2::gSharedString = NULL;

// ** The actual test function.

void MultithreadTest::TestString()

{

- int patience;

- int terrs = 0;

int j;

+ StringThreadTest2::gSharedString = new UnicodeString("This is the original test string.");

+ StringThreadTest2 tests[kStringThreadThreads];

- UnicodeString *testString = new UnicodeString("This is the original test string.");

- // Not using LocalArray<StringThreadTest2> tests[kStringThreadThreads];

- // because we don't always want to delete them.

- // See the comments below the cleanupAndReturn label.

- StringThreadTest2 *tests[kStringThreadThreads];

- for(j = 0; j < kStringThreadThreads; j++) {

- tests[j] = new StringThreadTest2(testString, j);

- }

logln(UnicodeString("Spawning: ") + kStringThreadThreads + " threads * " + kStringThreadIterations + " iterations each.");

for(j = 0; j < kStringThreadThreads; j++) {

- int32_t threadStatus = tests[j]->start();

+ int32_t threadStatus = tests[j].start();

if (threadStatus != 0) {

- errln("System Error %d starting thread number %d.", threadStatus, j);

- SimpleThread::errorFunc();

- goto cleanupAndReturn;

+ errln("%s:%d System Error %d starting thread number %d.", __FILE__, __LINE__, threadStatus, j);

}

- for(patience = kStringThreadPatience;patience > 0; patience --)

- {

- logln("Waiting...");

- int32_t i;

- terrs = 0;

- int32_t completed =0;

+ // Force a failure, to verify test is functioning and can report errors.

+ // const_cast<UnicodeString *>(StringThreadTest2::gSharedString)->setCharAt(5, 'x');

- for(i=0;i<kStringThreadThreads;i++) {

- if (tests[i]->isRunning() == FALSE)

- {

- completed++;

- logln(UnicodeString("Test #") + i + " is complete.. ");

- UnicodeString theErr;

- if(tests[i]->getError(theErr))

- {

- terrs++;

- errln(UnicodeString("#") + i + ": " + theErr);

- }

- // print out the error, too, if any.

- }

- if(completed == kStringThreadThreads)

- {

- logln("Done!");

- if(terrs) {

- errln("There were errors.");

- }

- break;

- }

- SimpleThread::sleep(900);

- }

- if (patience <= 0) {

- errln("patience exceeded. ");

- // while (TRUE) {SimpleThread::sleep(10000);} // TODO: for debugging. Sleep forever on failure.

- terrs++;

- }

- if (terrs > 0) {

- SimpleThread::errorFunc();

+ for(j=0; j<kStringThreadThreads; j++) {

+ tests[j].join();

+ logln(UnicodeString("Test #") + j + " is complete.. ");

}

-cleanupAndReturn:

- if (terrs == 0) {

- /*

- Don't clean up if there are errors. This prevents crashes if the

- threads are still running and using this data. This will only happen

- if there is an error with the test, ICU, or the machine is too slow.

- It's better to leak than crash.

- */

- for(j = 0; j < kStringThreadThreads; j++) {

- delete tests[j];

- }

- delete testString;

- }

+ 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

+// 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 {

- private:

- Transliterator *fSharedTranslit;

public:

- UBool fSuccess;

- TxThread(Transliterator *tx) : fSharedTranslit(tx), fSuccess(FALSE) {};

+ TxThread() {};

~TxThread();

void run();

};

@@ -1560,11 +1195,14 @@ TxThread::~TxThread() {}

void TxThread::run() {

UnicodeString greekString("\\u03B4\\u03B9\\u03B1\\u03C6\\u03BF\\u03C1\\u03B5\\u03C4\\u03B9\\u03BA\\u03BF\\u03CD\\u03C2");

greekString = greekString.unescape();

- fSharedTranslit->transliterate(greekString);

- fSuccess = greekString[0] == 0x64; // 'd'. The whole transliterated string is "diaphoretikous" (accented u).

+ 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

@@ -1574,47 +1212,22 @@ void MultithreadTest::TestAnyTranslit() {

dataerrln("File %s, Line %d: Error, status = %s", __FILE__, __LINE__, u_errorName(status));

return;

}

- TxThread * threads[4];

+ gSharedTranslit = tx.getAlias();

+ TxThread threads[4];

int32_t i;

- for (i=0; i<4; i++) {

- threads[i] = new TxThread(tx.getAlias());

- }

- for (i=0; i<4; i++) {

- threads[i]->start();

+ for (i=0; i<UPRV_LENGTHOF(threads); i++) {

+ threads[i].start();

}

- int32_t patience = 100;

- UBool success;

- UBool someThreadRunning;

- do {

- someThreadRunning = FALSE;

- success = TRUE;

- for (i=0; i<4; i++) {

- if (threads[i]->isRunning()) {

- someThreadRunning = TRUE;

- SimpleThread::sleep(10);

- break;

- } else {

- if (threads[i]->fSuccess == FALSE) {

- success = FALSE;

- }

- } while (someThreadRunning && --patience > 0);

- if (patience <= 0) {

- errln("File %s, Line %d: Error, one or more threads did not complete.", __FILE__, __LINE__);

- }

- if (success == FALSE) {

- errln("File %s, Line %d: Error, transliteration result incorrect.", __FILE__, __LINE__);

- }

- for (i=0; i<4; i++) {

- delete threads[i];

+ 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

@@ -1624,6 +1237,7 @@ void MultithreadTest::TestAnyTranslit() {

// Increments a global count of finished threads.

// Waits on the condition that all threads have finished.

// Exits.

+//

class CondThread: public SimpleThread {

public:

@@ -1637,22 +1251,20 @@ 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 gStartedThreads;

int gFinishedThreads;

static const int NUMTHREADS = 10;

-static MultithreadTest *gThisTest = NULL; // Make test frame work functions available to

- // non-member functions.

// Worker thread function.

void CondThread::run() {

- umtx_lock(&gCTMutex);

+ umtx_lock(&gCTMutex);

gStartedThreads += gConditionTestOne;

umtx_condBroadcast(&gCTConditionVar);

while (gStartedThreads < NUMTHREADS) {

if (gFinishedThreads != 0) {

- gThisTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d",

+ IntlTest::gTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d",

__FILE__, __LINE__, gStartedThreads, gFinishedThreads);

}

umtx_condWait(&gCTConditionVar, &gCTMutex);

@@ -1669,7 +1281,6 @@ void CondThread::run() {

}

void MultithreadTest::TestConditionVariables() {

- gThisTest = this;

gStartedThreads = 0;

gFinishedThreads = 0;

int i;

@@ -1695,21 +1306,42 @@ void MultithreadTest::TestConditionVariables() {

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];

}

-static const char *gCacheLocales[] = {"en_US", "en_GB", "fr_FR", "fr"};

-static int32_t gObjectsCreated = 0;

+//

+// 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) {

+ UCTMultiThreadItem(const char *x) : value(NULL) {

value = uprv_strdup(x);

}

- virtual ~UCTMultiThreadItem() {

+ virtual ~UCTMultiThreadItem() {

uprv_free(value);

}

};

@@ -1718,24 +1350,52 @@ U_NAMESPACE_BEGIN

template<> U_EXPORT

const UCTMultiThreadItem *LocaleCacheKey<UCTMultiThreadItem>::createObject(

- const void * /*unused*/, UErrorCode & /* status */) const {

- // Since multiple threads are hitting the cache for the first time,

- // no objects should be created yet.

+ 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);

- if (gObjectsCreated != 0) {

- gThisTest->errln("Expected no objects to be created yet.");

+ 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);

- // Big, expensive object that takes 1 second to create.

- SimpleThread::sleep(1000);

- // Log that we created an object.

+ 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);

- ++gObjectsCreated;

+ if (!firstObject) {

+ gObjectsCreated += 1;

+ }

+ umtx_condBroadcast(&gCTConditionVar);

umtx_unlock(&gCTMutex);

- UCTMultiThreadItem *result = new UCTMultiThreadItem(fLoc.getName());

- result->addRef();

return result;

}

@@ -1743,55 +1403,104 @@ U_NAMESPACE_END

class UnifiedCacheThread: public SimpleThread {

public:

- UnifiedCacheThread(const char *loc) : fLoc(loc) {};

+ UnifiedCacheThread(

+ const UnifiedCache *cache,

+ const char *loc,

+ const char *loc2) : fCache(cache), fLoc(loc), fLoc2(loc2) {};

~UnifiedCacheThread() {};

void run();

- const char *fLoc;

+ void exerciseByLocale(const Locale &);

+ const UnifiedCache *fCache;

+ Locale fLoc;

+ Locale fLoc2;

};

-void UnifiedCacheThread::run() {

+void UnifiedCacheThread::exerciseByLocale(const Locale &locale) {

UErrorCode status = U_ZERO_ERROR;

- const UnifiedCache *cache = UnifiedCache::getInstance(status);

- U_ASSERT(status == U_ZERO_ERROR);

- const UCTMultiThreadItem *item = NULL;

- cache->get(LocaleCacheKey<UCTMultiThreadItem>(fLoc), item, status);

- U_ASSERT(item != NULL);

- if (uprv_strcmp(fLoc, item->value)) {

- gThisTest->errln("Expected %s, got %s", fLoc, item->value);

+ 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();

+ }

}

- item->removeRef();

+ origItem->removeRef();

- // Mark this thread as finished

- umtx_lock(&gCTMutex);

- ++gFinishedThreads;

- umtx_condBroadcast(&gCTConditionVar);

- umtx_unlock(&gCTMutex);

+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;

- const UnifiedCache *cache = UnifiedCache::getInstance(status);

- U_ASSERT(cache != NULL);

- cache->flush();

- gThisTest = this;

+ 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) {

- threads[i][j] = new UnifiedCacheThread(gCacheLocales[j]);

+ // Each thread works with a pair of locales.

+ threads[i][j] = new UnifiedCacheThread(

+ &cache, gCacheLocales[j], gCacheLocales2[j]);

threads[i][j]->start();

}

- // Wait on all the threads to complete verify that LENGTHOF(gCacheLocales)

- // objects were created.

- umtx_lock(&gCTMutex);

- while (gFinishedThreads < CACHE_LOAD*UPRV_LENGTHOF(gCacheLocales)) {

- umtx_condWait(&gCTConditionVar, &gCTMutex);

+ for (int32_t i=0; i<CACHE_LOAD; ++i) {

+ for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {

+ threads[i][j]->join();

+ }

}

- assertEquals("Objects created", UPRV_LENGTHOF(gCacheLocales), gObjectsCreated);

- umtx_unlock(&gCTMutex);

+ // 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) {

@@ -1801,4 +1510,63 @@ void MultithreadTest::TestUnifiedCache() {

}

-#endif // ICU_USE_THREADS

+#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 */

« no previous file with comments | « source/test/intltest/tsmthred.h ('k') | source/test/intltest/tufmtts.cpp » ('j') | no next file with comments »