/********************************************************************
- * COPYRIGHT:
+ * COPYRIGHT:
* Copyright (c) 1999-2014, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include "tsmthred.h"
#include "unicode/ushape.h"
#include "unicode/translit.h"
+#include "sharedobject.h"
+#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
#endif
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
/* Needed by z/OS to get usleep */
#if U_PLATFORM == U_PF_OS390
#define __DOT1 1
/* Define __USE_XOPEN_EXTENDED for Linux and glibc. */
#ifndef __USE_XOPEN_EXTENDED
-#define __USE_XOPEN_EXTENDED
+#define __USE_XOPEN_EXTENDED
#endif
/* Define _INCLUDE_XOPEN_SOURCE_EXTENDED for HP/UX (11?). */
#if (ICU_USE_THREADS==0)
-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: ");
// *(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: ");
break;
case 4:
- name = "TestString";
+ name = "TestString";
if (exec) {
TestString();
}
break;
case 5:
- name = "TestArabicShapingThreads";
+ name = "TestArabicShapingThreads";
if (exec) {
TestArabicShapingThreads();
}
TestAnyTranslit();
}
break;
-
+
+ case 7:
+ name = "TestConditionVariables";
+ if (exec) {
+ TestConditionVariables();
+ }
+ break;
+ case 8:
+ name = "TestUnifiedCache";
+ if (exec) {
+ TestUnifiedCache();
+ }
+ break;
default:
name = "";
break; //needed to end loop
{
public:
TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }
- virtual void run() { SimpleThread::sleep(1000);
+ virtual void run() { SimpleThread::sleep(1000);
Mutex m;
- *fWhatToChange = '*';
+ *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.
+// 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
+class TestArabicShapeThreads : public SimpleThread
{
public:
TestArabicShapeThreads(char* whatToChange) { fWhatToChange = whatToChange;}
- virtual void run() {
+ virtual void run() {
if(doTailTest()==TRUE)
- *fWhatToChange = '*';
+ *fWhatToChange = '*';
}
private:
char *fWhatToChange;
int32_t length;
UErrorCode status;
IntlTest inteltst = IntlTest();
-
+
status = U_ZERO_ERROR;
- length = u_shapeArabic(src, -1, dst, LENGTHOF(dst),
+ 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));
+ 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,LENGTHOF(dst))) {
+ } 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, LENGTHOF(dst),
+ 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));
+ 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,LENGTHOF(dst))) {
+ } 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;
-
+
}
}
}
umtx_unlock(NULL);
-
+
if(count == THREADTEST_NRTHREADS)
{
logln("->" + UnicodeString(threadTestChars) + "<- Got all threads! cya");
int32_t numThreadsStarted = 0;
int32_t i;
-
+
for(i=0;i<ARABICSHAPE_THREADTEST;i++)
{
threadTestChars[i] = ' ';
}
}
umtx_unlock(NULL);
-
+
if(count == ARABICSHAPE_THREADTEST)
{
logln("->TestArabicShapingThreads <- Got all threads! cya");
}
-
+
//-----------------------------------------------------------------------
//
// TestMutex - a simple (non-stress) test to verify that ICU mutexes
static UMutex gTestMutexA = U_MUTEX_INITIALIZER;
static UMutex gTestMutexB = U_MUTEX_INITIALIZER;
-static int gThreadsStarted = 0;
+static int gThreadsStarted = 0;
static int gThreadsInMiddle = 0;
static int gThreadsDone = 0;
// All test threads made it to the second mutex.
// Now let them proceed from there. They will all terminate.
- umtx_unlock(&gTestMutexB);
+ umtx_unlock(&gTestMutexB);
patience = 0;
while (safeIncr(gThreadsDone, 0) != TESTMUTEX_THREAD_COUNT) {
if (patience++ > 24) {
class ThreadWithStatus : public SimpleThread
{
public:
- UBool getError() { return (fErrors > 0); }
- UBool getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }
+ 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(const UnicodeString &error) {
+ fErrors++; fErrorString = error;
+ SimpleThread::errorFunc();
}
void error() { error("An error occured."); }
private:
//-------------------------------------------------------------------------------------------
//
-// TestMultithreadedIntl. Test ICU Formatting n a multi-threaded environment
+// TestMultithreadedIntl. Test ICU Formatting n a multi-threaded environment
//
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
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
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 != ")
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;
}
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);
int fNum;
int fTraceInfo;
- ThreadSafeFormat fTSF;
+ LocalPointer<ThreadSafeFormat> fTSF;
FormatThreadTest() // constructor is NOT multithread safe.
: ThreadWithStatus(),
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;
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);
#endif
#if 0
- // debugging code,
+ // debugging code,
int m;
for (m=0; m<4000; m++) {
status = U_ZERO_ERROR;
#endif
// Keep this data here to avoid static initialization.
- FormatThreadTestData kNumberFormatTestData[] =
+ FormatThreadTestData kNumberFormatTestData[] =
{
FormatThreadTestData((double)5.0, UnicodeString("5", "")),
FormatThreadTestData( 6.0, UnicodeString("6", "")),
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().");
goto cleanupAndReturn;
}
-
+
percentFormatter.adoptInstead(NumberFormat::createPercentInstance(Locale::getFrench(),status));
if(U_FAILURE(status)) {
error("Error on NumberFormat::createPercentInstance().");
goto cleanupAndReturn;
}
-
+
for(iteration = 0;!getError() && 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
+ error("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" +
+ error("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)
{
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\\u00A0DEM.");
+ "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;
" \\u00f6S\\u00A040.193,12 on memory.");
break;
}
-
+
UnicodeString result;
UErrorCode status = U_ZERO_ERROR;
formatErrorMessage(status,patternToCheck,messageLocale,statusToCheck,
", error = " + tmp);
goto cleanupAndReturn;
}
-
+
if(result != expected)
{
error("PatternFormat: \n" + showDifference(expected,result));
}
// test the Thread Safe Format
UnicodeString appendErr;
- if(!fTSF.doStuff(fNum, appendErr, status)) {
+ if(!fTSF->doStuff(fNum, appendErr, status)) {
error(appendErr);
goto 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.
};
UErrorCode threadSafeErr = U_ZERO_ERROR;
- ThreadSafeFormat::init(threadSafeErr);
+ ThreadSafeFormatSharedData sharedData(threadSafeErr);
assertSuccess("initializing ThreadSafeFormat", threadSafeErr, TRUE);
//
//
// All threads have finished.
//
- ThreadSafeFormat::fini(threadSafeErr);
assertSuccess("finalizing ThreadSafeFormat", threadSafeErr, TRUE);
}
#endif /* #if !UCONFIG_NO_FORMATTING */
class CollatorThreadTest : public ThreadWithStatus
{
-private:
+private:
const Collator *coll;
const Line *lines;
int32_t noLines;
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"
//-------------------------------------------------------------------------------------------
//
-// StringThreadTest2
+// StringThreadTest2
//
//-------------------------------------------------------------------------------------------
// while (fNum == 4) {SimpleThread::sleep(10000);} // Force a failure by preventing thread from finishing
fTraceInfo = 2;
}
-
+
};
// ** The actual test function.
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();
if (threadStatus != 0) {
errln("System Error %d starting thread number %d.", threadStatus, j);
- SimpleThread::errorFunc();
+ SimpleThread::errorFunc();
goto cleanupAndReturn;
}
}
if (tests[i]->isRunning() == FALSE)
{
completed++;
-
+
logln(UnicodeString("Test #") + i + " is complete.. ");
-
+
UnicodeString theErr;
if(tests[i]->getError(theErr))
{
// print out the error, too, if any.
}
}
-
+
if(completed == kStringThreadThreads)
{
logln("Done!");
}
if (terrs > 0) {
- SimpleThread::errorFunc();
+ SimpleThread::errorFunc();
}
cleanupAndReturn:
// 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
fSuccess = greekString[0] == 0x64; // 'd'. The whole transliterated string is "diaphoretikous" (accented u).
}
#endif
-
+
void MultithreadTest::TestAnyTranslit() {
#if !UCONFIG_NO_TRANSLITERATION
if (success == FALSE) {
errln("File %s, Line %d: Error, transliteration result incorrect.", __FILE__, __LINE__);
}
-
+
for (i=0; i<4; i++) {
delete threads[i];
}
#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;
+
+static MultithreadTest *gThisTest = NULL; // Make test frame work functions available to
+ // non-member functions.
+
+// Worker thread function.
+void CondThread::run() {
+ 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",
+ __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() {
+ gThisTest = this;
+ 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);
+ }
+ delete threads[i];
+ }
+}
+
+static const char *gCacheLocales[] = {"en_US", "en_GB", "fr_FR", "fr"};
+static int32_t gObjectsCreated = 0;
+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 * /*unused*/, UErrorCode & /* status */) const {
+ // Since multiple threads are hitting the cache for the first time,
+ // no objects should be created yet.
+ umtx_lock(&gCTMutex);
+ if (gObjectsCreated != 0) {
+ gThisTest->errln("Expected no objects to be created yet.");
+ }
+ umtx_unlock(&gCTMutex);
+
+ // Big, expensive object that takes 1 second to create.
+ SimpleThread::sleep(1000);
+
+ // Log that we created an object.
+ umtx_lock(&gCTMutex);
+ ++gObjectsCreated;
+ umtx_unlock(&gCTMutex);
+ UCTMultiThreadItem *result = new UCTMultiThreadItem(fLoc.getName());
+ result->addRef();
+ return result;
+}
+
+U_NAMESPACE_END
+
+class UnifiedCacheThread: public SimpleThread {
+ public:
+ UnifiedCacheThread(const char *loc) : fLoc(loc) {};
+ ~UnifiedCacheThread() {};
+ void run();
+ const char *fLoc;
+};
+
+void UnifiedCacheThread::run() {
+ 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);
+ }
+ item->removeRef();
+
+ // Mark this thread as finished
+ umtx_lock(&gCTMutex);
+ ++gFinishedThreads;
+ umtx_condBroadcast(&gCTConditionVar);
+ umtx_unlock(&gCTMutex);
+}
+
+void MultithreadTest::TestUnifiedCache() {
+ UErrorCode status = U_ZERO_ERROR;
+ const UnifiedCache *cache = UnifiedCache::getInstance(status);
+ U_ASSERT(cache != NULL);
+ cache->flush();
+ gThisTest = this;
+ 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]);
+ 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);
+ }
+ assertEquals("Objects created", UPRV_LENGTHOF(gCacheLocales), gObjectsCreated);
+ umtx_unlock(&gCTMutex);
+
+ // 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];
+ }
+ }
+}
+
#endif // ICU_USE_THREADS
projects / apple / icu.git / blobdiff