1537 lines
45 KiB
C++
1537 lines
45 KiB
C++
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1999-2004, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
********************************************************************/
|
|
|
|
#if defined(hpux)
|
|
# ifndef _INCLUDE_POSIX_SOURCE
|
|
# define _INCLUDE_POSIX_SOURCE
|
|
# endif
|
|
#endif
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/ustring.h"
|
|
#include "umutex.h"
|
|
#include "cmemory.h"
|
|
#include "cstring.h"
|
|
#include "uparse.h"
|
|
#include "unicode/resbund.h"
|
|
#include "unicode/udata.h"
|
|
#include "unicode/uloc.h"
|
|
#include "unicode/locid.h"
|
|
|
|
#if !defined(WIN32) && !defined(XP_MAC) && !defined(U_RHAPSODY)
|
|
#define POSIX 1
|
|
#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
|
|
|
|
#include <signal.h>
|
|
|
|
/* 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"
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
// Note: A LOT OF THE FUNCTIONS IN THIS FILE SHOULD LIVE ELSEWHERE!!!!!
|
|
// Note: A LOT OF THE FUNCTIONS IN THIS FILE SHOULD LIVE ELSEWHERE!!!!!
|
|
// -srl
|
|
|
|
#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 "ucaconf.h"
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
// class SimpleThread Of course we need a thread class first..
|
|
// This wrapper has a ported implementation.
|
|
//
|
|
//-----------------------------------------------------------------------------------
|
|
class SimpleThread
|
|
{
|
|
public:
|
|
SimpleThread();
|
|
virtual ~SimpleThread();
|
|
int32_t start(void); // start the thread
|
|
UBool isRunning(); // return true if a started thread has exited.
|
|
|
|
virtual void run(void) = 0; // Override this to provide the code to run
|
|
// in the thread.
|
|
void *fImplementation;
|
|
|
|
public:
|
|
static void sleep(int32_t millis); // probably shouldn't go here but oh well.
|
|
static void errorFunc(); // Empty function, provides a single convenient place
|
|
// to break on errors.
|
|
};
|
|
|
|
void SimpleThread::errorFunc() {
|
|
// *(char *)0 = 3; // Force entry into a debugger via a crash;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
#define HAVE_IMP
|
|
|
|
# define VC_EXTRALEAN
|
|
# define WIN32_LEAN_AND_MEAN
|
|
# define NOGDI
|
|
# define NOUSER
|
|
# define NOSERVICE
|
|
# define NOIME
|
|
# define NOMCX
|
|
#include <windows.h>
|
|
#include <process.h>
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
// class SimpleThread Windows Implementation
|
|
//
|
|
//-----------------------------------------------------------------------------------
|
|
struct Win32ThreadImplementation
|
|
{
|
|
HANDLE fHandle;
|
|
unsigned int fThreadID;
|
|
};
|
|
|
|
|
|
extern "C" unsigned int __stdcall SimpleThreadProc(void *arg)
|
|
{
|
|
((SimpleThread*)arg)->run();
|
|
return 0;
|
|
}
|
|
|
|
SimpleThread::SimpleThread()
|
|
:fImplementation(0)
|
|
{
|
|
Win32ThreadImplementation *imp = new Win32ThreadImplementation;
|
|
imp->fHandle = 0;
|
|
fImplementation = imp;
|
|
}
|
|
|
|
SimpleThread::~SimpleThread()
|
|
{
|
|
// Destructor. Because we start the thread running with _beginthreadex(),
|
|
// we own the Windows HANDLE for the thread and must
|
|
// close it here.
|
|
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
|
|
if (imp != 0) {
|
|
if (imp->fHandle != 0) {
|
|
CloseHandle(imp->fHandle);
|
|
imp->fHandle = 0;
|
|
}
|
|
}
|
|
delete (Win32ThreadImplementation*)fImplementation;
|
|
}
|
|
|
|
int32_t SimpleThread::start()
|
|
{
|
|
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
|
|
if(imp->fHandle != NULL) {
|
|
// The thread appears to have already been started.
|
|
// This is probably an error on the part of our caller.
|
|
return -1;
|
|
}
|
|
|
|
imp->fHandle = (HANDLE) _beginthreadex(
|
|
NULL, // Security
|
|
0x20000, // Stack Size
|
|
SimpleThreadProc, // Function to Run
|
|
(void *)this, // Arg List
|
|
0, // initflag. Start running, not suspended
|
|
&imp->fThreadID // thraddr
|
|
);
|
|
|
|
if (imp->fHandle == 0) {
|
|
// An error occured
|
|
int err = errno;
|
|
if (err == 0) {
|
|
err = -1;
|
|
}
|
|
return err;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
UBool SimpleThread::isRunning() {
|
|
//
|
|
// Test whether the thread associated with the SimpleThread object is
|
|
// still actually running.
|
|
//
|
|
// NOTE: on Win64 on Itanium processors, a crashes
|
|
// occur if the main thread of a process exits concurrently with some
|
|
// other thread(s) exiting. To avoid the possibility, we wait until the
|
|
// OS indicates that all threads have terminated, rather than waiting
|
|
// only until the end of the user's Run function has been reached.
|
|
//
|
|
// I don't know whether the crashes represent a Windows bug, or whether
|
|
// main() programs are supposed to have to wait for their threads.
|
|
//
|
|
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
|
|
|
|
bool success;
|
|
DWORD threadExitCode;
|
|
|
|
if (imp->fHandle == 0) {
|
|
// No handle, thread must not be running.
|
|
return FALSE;
|
|
}
|
|
success = GetExitCodeThread(imp->fHandle, &threadExitCode) != 0;
|
|
if (! success) {
|
|
// Can't get status, thread must not be running.
|
|
return FALSE;
|
|
}
|
|
return (threadExitCode == STILL_ACTIVE);
|
|
}
|
|
|
|
|
|
void SimpleThread::sleep(int32_t millis)
|
|
{
|
|
::Sleep(millis);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
// class SimpleThread NULL Implementation
|
|
//
|
|
//-----------------------------------------------------------------------------------
|
|
#elif defined XP_MAC
|
|
|
|
// since the Mac has no preemptive threading (at least on MacOS 8), only
|
|
// cooperative threading, threads are a no-op. We have no yield() calls
|
|
// anywhere in the ICU, so we are guaranteed to be thread-safe.
|
|
|
|
#define HAVE_IMP
|
|
|
|
SimpleThread::SimpleThread()
|
|
{}
|
|
|
|
SimpleThread::~SimpleThread()
|
|
{}
|
|
|
|
int32_t
|
|
SimpleThread::start()
|
|
{ return 0; }
|
|
|
|
void
|
|
SimpleThread::run()
|
|
{}
|
|
|
|
void
|
|
SimpleThread::sleep(int32_t millis)
|
|
{}
|
|
|
|
UBool
|
|
SimpleThread::isRunning() {
|
|
return FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
//
|
|
// class SimpleThread POSIX implementation
|
|
//
|
|
// A note on the POSIX vs the Windows implementations of this class..
|
|
// On Windows, the main thread must verify that other threads have finished
|
|
// before exiting, or crashes occasionally occur. (Seen on Itanium Win64 only)
|
|
// The function SimpleThread::isRunning() is used for this purpose.
|
|
//
|
|
// On POSIX, there is NO reliable non-blocking mechanism to determine
|
|
// whether a thread has exited. pthread_kill(thread, 0) almost works,
|
|
// but the system can recycle thread ids immediately, so seeing that a
|
|
// thread exists with this call could mean that the original thread has
|
|
// finished and a new one started with the same ID. Useless.
|
|
//
|
|
// So we need to do the check with user code, by setting a flag just before
|
|
// the thread function returns. A technique that is guaranteed to fail
|
|
// on Windows, because it indicates that the thread is done before all
|
|
// system level cleanup has happened.
|
|
//
|
|
//-----------------------------------------------------------------------------------
|
|
#if defined(POSIX)||defined(U_SOLARIS)||defined(U_AIX)||defined(U_HPUX)
|
|
#define HAVE_IMP
|
|
|
|
struct PosixThreadImplementation
|
|
{
|
|
pthread_t fThread;
|
|
UBool fRunning;
|
|
UBool fRan; /* True if the thread was successfully started */
|
|
};
|
|
|
|
extern "C" void* SimpleThreadProc(void *arg)
|
|
{
|
|
// This is the code that is run in the new separate thread.
|
|
SimpleThread *This = (SimpleThread *)arg;
|
|
This->run(); // Run the user code.
|
|
|
|
// The user function has returned. Set the flag indicating that this thread
|
|
// is done. Need a mutex for memory barrier purposes only, so that other thread
|
|
// will reliably see that the flag has changed.
|
|
PosixThreadImplementation *imp = (PosixThreadImplementation*)This->fImplementation;
|
|
umtx_lock(NULL);
|
|
imp->fRunning = FALSE;
|
|
umtx_unlock(NULL);
|
|
return 0;
|
|
}
|
|
|
|
SimpleThread::SimpleThread()
|
|
{
|
|
PosixThreadImplementation *imp = new PosixThreadImplementation;
|
|
imp->fRunning = FALSE;
|
|
imp->fRan = FALSE;
|
|
fImplementation = imp;
|
|
}
|
|
|
|
SimpleThread::~SimpleThread()
|
|
{
|
|
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
|
|
if (imp->fRan) {
|
|
pthread_join(imp->fThread, NULL);
|
|
}
|
|
delete imp;
|
|
fImplementation = (void *)0xdeadbeef;
|
|
}
|
|
|
|
int32_t SimpleThread::start()
|
|
{
|
|
int32_t rc;
|
|
static pthread_attr_t attr;
|
|
static UBool attrIsInitialized = FALSE;
|
|
|
|
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
|
|
imp->fRunning = TRUE;
|
|
imp->fRan = TRUE;
|
|
|
|
#ifdef HPUX_CMA
|
|
if (attrIsInitialized == FALSE) {
|
|
rc = pthread_attr_create(&attr);
|
|
attrIsInitialized = TRUE;
|
|
}
|
|
rc = pthread_create(&(imp->fThread),attr,&SimpleThreadProc,(void*)this);
|
|
#else
|
|
if (attrIsInitialized == FALSE) {
|
|
rc = pthread_attr_init(&attr);
|
|
#if defined(OS390)
|
|
{
|
|
int detachstate = 0; /* jdc30: detach state of zero causes
|
|
threads created with this attr to be in
|
|
an undetached state. An undetached
|
|
thread will keep its resources after
|
|
termination. */
|
|
pthread_attr_setdetachstate(&attr, &detachstate);
|
|
}
|
|
#else
|
|
// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
|
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
|
|
#endif
|
|
attrIsInitialized = TRUE;
|
|
}
|
|
rc = pthread_create(&(imp->fThread),&attr,&SimpleThreadProc,(void*)this);
|
|
#endif
|
|
|
|
if (rc != 0) {
|
|
// some kind of error occured, the thread did not start.
|
|
imp->fRan = FALSE;
|
|
imp->fRunning = FALSE;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
UBool
|
|
SimpleThread::isRunning() {
|
|
// Note: Mutex functions are used here not for synchronization,
|
|
// but to force memory barriors to exist, to ensure that one thread
|
|
// can see changes made by another when running on processors
|
|
// with memory models having weak coherency.
|
|
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
|
|
umtx_lock(NULL);
|
|
UBool retVal = imp->fRunning;
|
|
umtx_unlock(NULL);
|
|
return retVal;
|
|
}
|
|
|
|
|
|
void SimpleThread::sleep(int32_t millis)
|
|
{
|
|
#ifdef U_SOLARIS
|
|
sigignore(SIGALRM);
|
|
#endif
|
|
|
|
#ifdef HPUX_CMA
|
|
cma_sleep(millis/100);
|
|
#elif defined(U_HPUX) || defined(OS390)
|
|
millis *= 1000;
|
|
while(millis >= 1000000) {
|
|
usleep(999999);
|
|
millis -= 1000000;
|
|
}
|
|
if(millis > 0) {
|
|
usleep(millis);
|
|
}
|
|
#else
|
|
usleep(millis * 1000);
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
// end POSIX
|
|
|
|
|
|
#ifndef HAVE_IMP
|
|
#error No implementation for threads! Cannot test.
|
|
0 = 216; //die
|
|
#endif
|
|
|
|
|
|
// *************** end fluff ******************
|
|
|
|
/* now begins the real test. */
|
|
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 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);
|
|
}
|
|
SimpleThread::sleep(200);
|
|
logln(" Subthread started.");
|
|
}
|
|
|
|
logln("Waiting for threads to be set..");
|
|
|
|
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];
|
|
}
|
|
}
|
|
|
|
|
|
class TestMutexThread1 : public SimpleThread
|
|
{
|
|
public:
|
|
TestMutexThread1() : fDone(FALSE) {}
|
|
virtual void run()
|
|
{
|
|
Mutex m; // grab the lock first thing
|
|
SimpleThread::sleep(900); // then wait
|
|
fDone = TRUE; // finally, set our flag
|
|
}
|
|
public:
|
|
UBool fDone;
|
|
};
|
|
|
|
class TestMutexThread2 : public SimpleThread
|
|
{
|
|
public:
|
|
TestMutexThread2(TestMutexThread1& r) : fOtherThread(r), fDone(FALSE), fErr(FALSE) {}
|
|
virtual void run()
|
|
{
|
|
SimpleThread::sleep(500); // wait, make sure they aquire the lock
|
|
fElapsed = uprv_getUTCtime();
|
|
{
|
|
Mutex m; // wait here
|
|
|
|
fElapsed = uprv_getUTCtime() - fElapsed;
|
|
|
|
if(fOtherThread.fDone == FALSE)
|
|
fErr = TRUE; // they didnt get to it yet
|
|
|
|
fDone = TRUE; // we're done.
|
|
}
|
|
}
|
|
public:
|
|
TestMutexThread1 & fOtherThread;
|
|
UBool fDone, fErr;
|
|
int32_t fElapsed;
|
|
private:
|
|
/**
|
|
* The assignment operator has no real implementation.
|
|
* It is provided to make the compiler happy. Do not call.
|
|
*/
|
|
TestMutexThread2& operator=(const TestMutexThread2&) { return *this; }
|
|
};
|
|
|
|
void MultithreadTest::TestMutex()
|
|
{
|
|
/* this test uses printf so that we don't hang by calling UnicodeString inside of a mutex. */
|
|
//logln("Bye.");
|
|
// printf("Warning: MultiThreadTest::Testmutex() disabled.\n");
|
|
// return;
|
|
|
|
if(verbose)
|
|
printf("Before mutex.\n");
|
|
{
|
|
Mutex m;
|
|
if(verbose)
|
|
printf(" Exited 2nd mutex\n");
|
|
}
|
|
if(verbose)
|
|
printf("exited 1st mutex. Now testing with threads:");
|
|
|
|
TestMutexThread1 thread1;
|
|
TestMutexThread2 thread2(thread1);
|
|
if (thread2.start() != 0 ||
|
|
thread1.start() != 0 ) {
|
|
errln("Error starting threads.");
|
|
}
|
|
|
|
for(int32_t patience = 12; patience > 0;patience--)
|
|
{
|
|
// TODO: Possible memory coherence issue in looking at fDone values
|
|
// that are set in another thread without the mutex here.
|
|
if(thread1.fDone && verbose)
|
|
printf("Thread1 done\n");
|
|
|
|
if(thread1.fDone && thread2.fDone)
|
|
{
|
|
if(thread2.fErr)
|
|
errln("Thread 2 says: thread1 didn't run before I aquired the mutex.");
|
|
logln("took %lu seconds for thread2 to aquire the mutex.", thread2.fElapsed);
|
|
return;
|
|
}
|
|
SimpleThread::sleep(1000);
|
|
}
|
|
if(verbose)
|
|
printf("patience exceeded. [WARNING mutex may still be acquired.] ");
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
//
|
|
// 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) {}
|
|
} ;
|
|
|
|
|
|
void errorToString(UErrorCode theStatus, UnicodeString &string)
|
|
{
|
|
string=u_errorName(theStatus);
|
|
}
|
|
|
|
// "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;
|
|
errorToString(inStatus0, errString1);
|
|
|
|
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;
|
|
NumberFormat *formatter = NULL;
|
|
NumberFormat *percentFormatter = NULL;
|
|
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 1
|
|
// 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, UnicodeString("500%", "")),
|
|
FormatThreadTestData( 1.0, UnicodeString("100%", "")),
|
|
FormatThreadTestData( 0.26, UnicodeString("26%", "")),
|
|
FormatThreadTestData(
|
|
16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499%") ), // U+00a0 = NBSP
|
|
FormatThreadTestData(
|
|
81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023%" )),
|
|
};
|
|
int32_t kPercentFormatTestDataLength =
|
|
(int32_t)(sizeof(kPercentFormatTestData) / sizeof(kPercentFormatTestData[0]));
|
|
int32_t iteration;
|
|
|
|
status = U_ZERO_ERROR;
|
|
formatter = NumberFormat::createInstance(Locale::getEnglish(),status);
|
|
if(U_FAILURE(status)) {
|
|
error("Error on NumberFormat::createInstance()");
|
|
goto cleanupAndReturn;
|
|
}
|
|
|
|
percentFormatter = 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_PREEURO");
|
|
countryToCheck= Locale("","BF");
|
|
currencyToCheck= 2.32;
|
|
expected= "1:A customer in Burkina Faso is receiving a #8 error - U_INDEX_OUTOFBOUNDS_ERROR. Their telephone call is costing 2,32 DM.";
|
|
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_PREEURO"); // 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 40.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;
|
|
errorToString(status,tmp);
|
|
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:
|
|
delete formatter;
|
|
delete percentFormatter;
|
|
|
|
// 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];
|
|
|
|
//
|
|
// Create and start the test threads
|
|
//
|
|
logln("Spawning: %d threads * %d iterations each.",
|
|
kFormatThreadThreads, kFormatThreadIterations);
|
|
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();
|
|
goto cleanupAndReturn;
|
|
}
|
|
haveDisplayedInfo[j] = FALSE;
|
|
}
|
|
|
|
|
|
// Spin, waiting for the test threads to finish.
|
|
// (An earlier version used a wait in this loop, but that seems to trigger
|
|
// a bug in some versions of AIX.)
|
|
UBool stillRunning;
|
|
do {
|
|
/* Spin until the test threads complete. */
|
|
stillRunning = FALSE;
|
|
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)) {
|
|
errln(UnicodeString("#") + i + ": " + theErr);
|
|
SimpleThread::errorFunc();
|
|
}
|
|
haveDisplayedInfo[i] = TRUE;
|
|
}
|
|
}
|
|
} while (stillRunning);
|
|
|
|
//
|
|
// All threads have finished.
|
|
//
|
|
cleanupAndReturn:
|
|
delete [] tests;
|
|
return;
|
|
|
|
}
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
//
|
|
// Collation threading test
|
|
//
|
|
//-------------------------------------------------------------------------------------------
|
|
#if !UCONFIG_NO_COLLATION
|
|
|
|
#define kCollatorThreadThreads 10 // # of threads to spawn
|
|
#define kCollatorThreadPatience kCollatorThreadThreads*100
|
|
|
|
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;
|
|
} else if (res > 0) {
|
|
error(UnicodeString("Sortkeys are identical, but code point comapare 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::loadTestData(status));
|
|
char* index = 0;
|
|
if (U_FAILURE(status)) {
|
|
errln("ERROR: could not open test data %s", u_errorName(status));
|
|
return;
|
|
}
|
|
index=strrchr(testDataPath,(char)U_FILE_SEP_CHAR);
|
|
|
|
if((unsigned int)(index-testDataPath) != (strlen(testDataPath)-1)){
|
|
*(index+1)=0;
|
|
}
|
|
strcat(testDataPath,".."U_FILE_SEP_STRING);
|
|
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;
|
|
errln("ERROR: 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://oss.software.ibm.com/cvs/icu4j/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 || 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);
|
|
|
|
|
|
|
|
UCollator *coll = ucol_open("root", &status);
|
|
if(U_FAILURE(status)) {
|
|
errln("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;
|
|
CollatorThreadTest *tests;
|
|
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");
|
|
|
|
//for(int32_t patience = kCollatorThreadPatience;patience > 0; patience --)
|
|
for(;;)
|
|
{
|
|
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);
|
|
delete[] tests;
|
|
//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 = 20; // # of iterations per thread
|
|
const int kStringThreadThreads = 10; // # of threads to spawn
|
|
const int kStringThreadPatience = 60; // 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 < 5000; 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.");
|
|
|
|
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
|
|
|