| Index: icu46/source/test/intltest/tsmthred.cpp
|
| ===================================================================
|
| --- icu46/source/test/intltest/tsmthred.cpp (revision 0)
|
| +++ icu46/source/test/intltest/tsmthred.cpp (revision 0)
|
| @@ -0,0 +1,1240 @@
|
| +/********************************************************************
|
| + * COPYRIGHT:
|
| + * Copyright (c) 1999-2010, International Business Machines Corporation and
|
| + * others. All Rights Reserved.
|
| + ********************************************************************/
|
| +
|
| +#if defined(hpux)
|
| +# ifndef _INCLUDE_POSIX_SOURCE
|
| +# define _INCLUDE_POSIX_SOURCE
|
| +# endif
|
| +#endif
|
| +
|
| +#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"
|
| +#if !defined(U_WINDOWS) && !defined(XP_MAC) && !defined(U_RHAPSODY)
|
| +#define POSIX 1
|
| +#endif
|
| +
|
| +/* Needed by z/OS to get usleep */
|
| +#if defined(OS390)
|
| +#define __DOT1 1
|
| +#define __UU
|
| +#define _XOPEN_SOURCE_EXTENDED 1
|
| +#ifndef _XPG4_2
|
| +#define _XPG4_2
|
| +#endif
|
| +#include <unistd.h>
|
| +/*#include "platform_xopen_source_extended.h"*/
|
| +#endif
|
| +#if defined(POSIX) || defined(U_SOLARIS) || defined(U_AIX) || defined(U_HPUX)
|
| +
|
| +#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 defined(OS390)
|
| +#include <sys/types.h>
|
| +#endif
|
| +
|
| +#if !defined(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
|
| +
|
| +
|
| +
|
| +#include "tsmthred.h"
|
| +
|
| +#define TSMTHREAD_FAIL(msg) errln("%s at file %s, line %d", msg, __FILE__, __LINE__)
|
| +#define TSMTHREAD_ASSERT(expr) {if (!(expr)) {TSMTHREAD_FAIL("Fail");}}
|
| +
|
| +MultithreadTest::MultithreadTest()
|
| +{
|
| +}
|
| +
|
| +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
|
| +
|
| +#include "unicode/putil.h"
|
| +
|
| +// for mthreadtest
|
| +#include "unicode/numfmt.h"
|
| +#include "unicode/choicfmt.h"
|
| +#include "unicode/msgfmt.h"
|
| +#include "unicode/locid.h"
|
| +#include "unicode/ucol.h"
|
| +#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,
|
| + 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;
|
| +
|
| + 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
|
| +// each sleep 1 second and then set their chars. At the end we make sure they
|
| +// are all set.
|
| +//
|
| +//-----------------------------------------------------------------------------------
|
| +#define THREADTEST_NRTHREADS 8
|
| +
|
| +class TestThreadsThread : public SimpleThread
|
| +{
|
| +public:
|
| + TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }
|
| + virtual void run() { SimpleThread::sleep(1000);
|
| + Mutex m;
|
| + *fWhatToChange = '*';
|
| + }
|
| +private:
|
| + char *fWhatToChange;
|
| +};
|
| +
|
| +void MultithreadTest::TestThreads()
|
| +{
|
| + 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++;
|
| + }
|
| + SimpleThread::sleep(100);
|
| + logln(" Subthread started.");
|
| + }
|
| +
|
| + logln("Waiting for threads to be set..");
|
| + if (numThreadsStarted == 0) {
|
| + errln("No 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("->" + UnicodeString(threadTestChars) + "<- Waiting..");
|
| + SimpleThread::sleep(500);
|
| + }
|
| +
|
| + errln("->" + UnicodeString(threadTestChars) + "<- PATIENCE EXCEEDED!! Still missing some.");
|
| + for(i=0;i<THREADTEST_NRTHREADS;i++)
|
| + {
|
| + delete threads[i];
|
| + }
|
| +}
|
| +
|
| +
|
| +//-----------------------------------------------------------------------
|
| +//
|
| +// TestMutex - a simple (non-stress) test to verify that ICU mutexes
|
| +// are actually mutexing. Does not test the use of
|
| +// mutexes within ICU services, but rather that the
|
| +// platform's mutex support is at least superficially there.
|
| +//
|
| +//----------------------------------------------------------------------
|
| +static UMTX gTestMutexA = NULL;
|
| +static UMTX gTestMutexB = NULL;
|
| +
|
| +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;
|
| +}
|
| +
|
| +class TestMutexThread : public SimpleThread
|
| +{
|
| +public:
|
| + 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);
|
| + umtx_lock(&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;
|
| + 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");
|
| + 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);
|
| + }
|
| + 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");
|
| + return;
|
| + }
|
| + SimpleThread::sleep(500);
|
| + }
|
| +
|
| + // All threads made it by both mutexes.
|
| + // Destroy the test mutexes.
|
| + umtx_destroy(&gTestMutexA);
|
| + umtx_destroy(&gTestMutexB);
|
| + gTestMutexA=NULL;
|
| + gTestMutexB=NULL;
|
| +
|
| + for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
|
| + delete threads[i];
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +//-------------------------------------------------------------------------------------------
|
| +//
|
| +// 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
|
| +//
|
| +//-------------------------------------------------------------------------------------------
|
| +
|
| +
|
| +// * 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 = 20; // # of iterations per thread
|
| +const int kFormatThreadThreads = 10; // # of threads to spawn
|
| +const int kFormatThreadPatience = 60; // time in seconds to wait for all threads
|
| +
|
| +#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}."
|
| +
|
| +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;
|
| +}
|
| +
|
| +
|
| +UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInfo *) {
|
| + return TRUE;
|
| +}
|
| +
|
| +//static UMTX debugMutex = NULL;
|
| +//static UMTX gDebugMutex;
|
| +
|
| +
|
| +class FormatThreadTest : public ThreadWithStatus
|
| +{
|
| +public:
|
| + int fNum;
|
| + int fTraceInfo;
|
| +
|
| + FormatThreadTest() // constructor is NOT multithread safe.
|
| + : ThreadWithStatus(),
|
| + fNum(0),
|
| + fTraceInfo(0),
|
| + fOffset(0)
|
| + // the locale to use
|
| + {
|
| + 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 = (int32_t)(sizeof(kNumberFormatTestData) /
|
| + sizeof(kNumberFormatTestData[0]));
|
| +
|
| + // 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 =
|
| + (int32_t)(sizeof(kPercentFormatTestData) / sizeof(kPercentFormatTestData[0]));
|
| + 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
|
| + + " 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" +
|
| + 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.193,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));
|
| + error("Failure on message format, pattern=" + patternToCheck +
|
| + ", error = " + tmp);
|
| + goto cleanupAndReturn;
|
| + }
|
| +
|
| + if(result != expected)
|
| + {
|
| + error("PatternFormat: \n" + showDifference(expected,result));
|
| + goto cleanupAndReturn;
|
| + }
|
| + } /* end of for loop */
|
| +
|
| +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.
|
| +};
|
| +
|
| +// ** The actual test function.
|
| +
|
| +void MultithreadTest::TestThreadedIntl()
|
| +{
|
| + int i;
|
| + UnicodeString theErr;
|
| + UBool haveDisplayedInfo[kFormatThreadThreads];
|
| + static const int32_t PATIENCE_SECONDS = 45;
|
| +
|
| + //
|
| + // Create and start the test threads
|
| + //
|
| + logln("Spawning: %d threads * %d iterations each.",
|
| + kFormatThreadThreads, kFormatThreadIterations);
|
| + LocalArray<FormatThreadTest> tests(new FormatThreadTest[kFormatThreadThreads]);
|
| + for(int32_t j = 0; j < kFormatThreadThreads; 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();
|
| + return;
|
| + }
|
| + haveDisplayedInfo[j] = FALSE;
|
| + }
|
| +
|
| +
|
| + // Spin, waiting for the test threads to finish.
|
| + UBool stillRunning;
|
| + UDate startTime, endTime;
|
| + startTime = Calendar::getNow();
|
| + do {
|
| + /* Spin until the test threads complete. */
|
| + stillRunning = FALSE;
|
| + endTime = Calendar::getNow();
|
| + if (((int32_t)(endTime - startTime)/U_MILLIS_PER_SECOND) > PATIENCE_SECONDS) {
|
| + errln("Patience exceeded. Test is taking too long.");
|
| + return;
|
| + }
|
| + /*
|
| + 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.
|
| + //
|
| +}
|
| +#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;
|
| +} ;
|
| +
|
| +class CollatorThreadTest : public ThreadWithStatus
|
| +{
|
| +private:
|
| + const UCollator *coll;
|
| + const Line *lines;
|
| + int32_t noLines;
|
| +public:
|
| + CollatorThreadTest() : ThreadWithStatus(),
|
| + coll(NULL),
|
| + lines(NULL),
|
| + noLines(0)
|
| + {
|
| + };
|
| + void setCollator(UCollator *c, Line *l, int32_t nl)
|
| + {
|
| + coll = c;
|
| + lines = l;
|
| + noLines = nl;
|
| + }
|
| + virtual void run() {
|
| + //sleep(10000);
|
| + int32_t line = 0;
|
| +
|
| + uint8_t sk1[1024], sk2[1024];
|
| + uint8_t *oldSk = NULL, *newSk = sk1;
|
| + int32_t resLen = 0, oldLen = 0;
|
| + int32_t i = 0;
|
| +
|
| + for(i = 0; i < noLines; i++) {
|
| + resLen = ucol_getSortKey(coll, lines[i].buff, lines[i].buflen, newSk, 1024);
|
| +
|
| + int32_t res = 0, cmpres = 0, cmpres2 = 0;
|
| +
|
| + if(oldSk != NULL) {
|
| + res = strcmp((char *)oldSk, (char *)newSk);
|
| + cmpres = ucol_strcoll(coll, lines[i-1].buff, lines[i-1].buflen, lines[i].buff, lines[i].buflen);
|
| + cmpres2 = ucol_strcoll(coll, lines[i].buff, lines[i].buflen, lines[i-1].buff, lines[i-1].buflen);
|
| + //cmpres = res;
|
| + //cmpres2 = -cmpres;
|
| +
|
| + if(cmpres != -cmpres2) {
|
| + error("Compare result not symmetrical on line "+ line);
|
| + break;
|
| + }
|
| +
|
| + if(((res&0x80000000) != (cmpres&0x80000000)) || (res == 0 && cmpres != 0) || (res != 0 && cmpres == 0)) {
|
| + error(UnicodeString("Difference between ucol_strcoll and sortkey compare on line ")+ UnicodeString(line));
|
| + break;
|
| + }
|
| +
|
| + if(res > 0) {
|
| + error(UnicodeString("Line %i is not greater or equal than previous line ")+ UnicodeString(i));
|
| + break;
|
| + } else if(res == 0) { /* equal */
|
| + res = u_strcmpCodePointOrder(lines[i-1].buff, lines[i].buff);
|
| + if (res == 0) {
|
| + error(UnicodeString("Probable error in test file on line %i (comparing identical strings)")+ UnicodeString(i));
|
| + break;
|
| + }
|
| + /*
|
| + * UCA 6.0 test files can have lines that compare == if they are
|
| + * different strings but canonically equivalent.
|
| + else if (res > 0) {
|
| + error(UnicodeString("Sortkeys are identical, but code point compare gives >0 on line ")+ UnicodeString(i));
|
| + break;
|
| + }
|
| + */
|
| + }
|
| + }
|
| +
|
| + oldSk = newSk;
|
| + oldLen = resLen;
|
| +
|
| + 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/");
|
| + }
|
| + }
|
| + }
|
| +
|
| + Line *lines = new Line[200000];
|
| + memset(lines, 0, sizeof(Line)*200000);
|
| + int32_t lineNum = 0;
|
| +
|
| + UChar bufferU[1024];
|
| + int32_t buflen = 0;
|
| + uint32_t first = 0;
|
| + uint32_t offset = 0;
|
| +
|
| + while (fgets(buffer, 1024, testFile) != NULL) {
|
| + offset = 0;
|
| + if(*buffer == 0 || strlen(buffer) < 3 || buffer[0] == '#') {
|
| + continue;
|
| + }
|
| + offset = u_parseString(buffer, bufferU, 1024, &first, &status);
|
| + buflen = offset;
|
| + bufferU[offset++] = 0;
|
| + lines[lineNum].buflen = buflen;
|
| + //lines[lineNum].buff = new UChar[buflen+1];
|
| + u_memcpy(lines[lineNum].buff, bufferU, buflen);
|
| + lineNum++;
|
| + }
|
| + fclose(testFile);
|
| + if(U_FAILURE(status)) {
|
| + dataerrln("Couldn't read the test file!");
|
| + return;
|
| + }
|
| +
|
| + UCollator *coll = ucol_open("root", &status);
|
| + if(U_FAILURE(status)) {
|
| + errcheckln(status, "Couldn't open UCA collator");
|
| + return;
|
| + }
|
| + ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
|
| + ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
|
| + ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);
|
| + ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_TERTIARY, &status);
|
| + ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
|
| +
|
| + int32_t noSpawned = 0;
|
| + 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, lines, lineNum);
|
| + }
|
| + for(j = 0; j < kCollatorThreadThreads; j++) {
|
| + log("%i ", j);
|
| + spawnResult = tests[j].start();
|
| + if(spawnResult != 0) {
|
| + infoln("THREAD INFO: Couldn't spawn more than %i threads", noSpawned);
|
| + break;
|
| + }
|
| + 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();
|
| + }
|
| + ucol_close(coll);
|
| + //for(i = 0; i < lineNum; i++) {
|
| + //delete[] lines[i].buff;
|
| + //}
|
| + delete[] lines;
|
| +
|
| + return;
|
| + }
|
| +
|
| + SimpleThread::sleep(900);
|
| + }
|
| + errln("patience exceeded. ");
|
| + SimpleThread::errorFunc();
|
| + ucol_close(coll);
|
| +}
|
| +
|
| +#endif /* #if !UCONFIG_NO_COLLATION */
|
| +
|
| +
|
| +
|
| +
|
| +//-------------------------------------------------------------------------------------------
|
| +//
|
| +// 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
|
| +{
|
| +public:
|
| + int fNum;
|
| + int fTraceInfo;
|
| + const UnicodeString *fSharedString;
|
| +
|
| + StringThreadTest2(const UnicodeString *sharedString, int num) // constructor is NOT multithread safe.
|
| + : ThreadWithStatus(),
|
| + fNum(num),
|
| + fTraceInfo(0),
|
| + fSharedString(sharedString)
|
| + {
|
| + };
|
| +
|
| +
|
| + virtual void run()
|
| + {
|
| + fTraceInfo = 1;
|
| + int loopCount = 0;
|
| +
|
| + for (loopCount = 0; loopCount < kStringThreadIterations; loopCount++) {
|
| + if (*fSharedString != "This is the original test string.") {
|
| + error("Original string is corrupt.");
|
| + break;
|
| + }
|
| + UnicodeString s1 = *fSharedString;
|
| + s1 += "cat this";
|
| + UnicodeString s2(s1);
|
| + UnicodeString s3 = *fSharedString;
|
| + s2 = s3;
|
| + s3.truncate(12);
|
| + s2.truncate(0);
|
| + }
|
| +
|
| + // while (fNum == 4) {SimpleThread::sleep(10000);} // Force a failure by preventing thread from finishing
|
| + fTraceInfo = 2;
|
| + }
|
| +
|
| +};
|
| +
|
| +// ** The actual test function.
|
| +
|
| +void MultithreadTest::TestString()
|
| +{
|
| + int patience;
|
| + int terrs = 0;
|
| + int j;
|
| +
|
| + 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();
|
| + if (threadStatus != 0) {
|
| + errln("System Error %d starting thread number %d.", threadStatus, j);
|
| + SimpleThread::errorFunc();
|
| + goto cleanupAndReturn;
|
| + }
|
| + }
|
| +
|
| + for(patience = kStringThreadPatience;patience > 0; patience --)
|
| + {
|
| + logln("Waiting...");
|
| +
|
| + int32_t i;
|
| + terrs = 0;
|
| + int32_t completed =0;
|
| +
|
| + 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();
|
| + }
|
| +
|
| +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;
|
| + }
|
| +}
|
| +
|
| +#endif // ICU_USE_THREADS
|
|
|
| Property changes on: icu46/source/test/intltest/tsmthred.cpp
|
| ___________________________________________________________________
|
| Added: svn:eol-style
|
| + LF
|
|
|
|
|
Chromium Code Reviews
Issue 5516007:
Check in the pristine copy of ICU 4.6... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/