text: /********************************************************************
   * COPYRIGHT: 
   * Copyright (c) 1999-2009, 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;
                      } 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::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
  