Check in the pristine copy of ICU 4.6...

icu46/source/test/intltest/tsmthred.cpp

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