ICU 56 update step 1

source/test/intltest/tsmthred.cpp

 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 1999-2014, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 1999-2015, 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"
 #include "intltest.h"
 #include "tsmthred.h"
 #include "unicode/ushape.h"
 #include "unicode/translit.h"
 #include "sharedobject.h"
 #include "unifiedcache.h"
 #include "uassert.h"
 
-#if U_PLATFORM_USES_ONLY_WIN32_API
-    /* Prefer native Windows APIs even if POSIX is implemented (i.e., on Cygwin). */
-#   undef POSIX
-#elif U_PLATFORM_IMPLEMENTS_POSIX
-#   define POSIX
-#else
-#   undef POSIX
-#endif
-
-/* Needed by z/OS to get usleep */
-#if U_PLATFORM == U_PF_OS390
-#define __DOT1 1
-#define __UU
-#ifndef _XPG4_2
-#define _XPG4_2
-#endif
-#include <unistd.h>
-#endif
-#if defined(POSIX)
-
-#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 U_PLATFORM == U_PF_OS390
-#include <sys/types.h>
-#endif
-
-#if U_PLATFORM != U_PF_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
 
 #define TSMTHREAD_FAIL(msg) errln("%s at file %s, line %d", msg, __FILE__, __LINE__)
 #define TSMTHREAD_ASSERT(expr) {if (!(expr)) {TSMTHREAD_FAIL("Fail");}}
+#define TSMTHREAD_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
+                  errln("file: %s:%d status = %s\n", __FILE__, __LINE__, u_errorName(status));}}
 
 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/coll.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, 
+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;
 
@@ skipping 15 matching lines @@
     case 3:
       name = "TestCollators";
 #if !UCONFIG_NO_COLLATION
       if (exec) {
             TestCollators();
       }
 #endif /* #if !UCONFIG_NO_COLLATION */
       break;
 
     case 4:
-        name = "TestString"; 
+        name = "TestString";
         if (exec) {
             TestString();
         }
         break;
 
     case 5:
-        name = "TestArabicShapingThreads"; 
+        name = "TestArabicShapingThreads";
         if (exec) {
             TestArabicShapingThreads();
         }
         break;
 
     case 6:
         name = "TestAnyTranslit";
         if (exec) {
             TestAnyTranslit();
         }
         break;
-     
+
     case 7:
         name = "TestConditionVariables";
         if (exec) {
             TestConditionVariables();
         }
         break;
     case 8:
         name = "TestUnifiedCache";
         if (exec) {
             TestUnifiedCache();
         }
         break;
+#if !UCONFIG_NO_TRANSLITERATION
+    case 9:
+        name = "TestBreakTranslit";
+        if (exec) {
+            TestBreakTranslit();
+        }
+        break;
+#endif
     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.
+//   set their chars. At the end we make sure they are all set.
 //
 //-----------------------------------------------------------------------------------
-#define THREADTEST_NRTHREADS 8
-#define ARABICSHAPE_THREADTEST 30
 
 class TestThreadsThread : public SimpleThread
 {
 public:
     TestThreadsThread(char* whatToChange) { fWhatToChange = whatToChange; }
-    virtual void run() { SimpleThread::sleep(1000); 
-                         Mutex m;
-                         *fWhatToChange = '*'; 
+    virtual void run() { Mutex m;
+                         *fWhatToChange = '*';
     }
 private:
     char *fWhatToChange;
 };
-//-----------------------------------------------------------------------------------
-//
-//   TestArabicShapeThreads -- see if calls to u_shapeArabic in many threads works successfully
-//
-//   Set up N threads pointing at N chars. When they are started, they will make calls to doTailTest which tests
-//   u_shapeArabic, if the calls are successful it will the set * chars. 
-//   At the end we make sure all threads managed to run u_shapeArabic successfully.
-//   This is a unit test for ticket 9473
-//
-//-----------------------------------------------------------------------------------
-class TestArabicShapeThreads : public SimpleThread 
-{
-public:
-    TestArabicShapeThreads(char* whatToChange) { fWhatToChange = whatToChange;}
-    virtual void run() { 
-            if(doTailTest()==TRUE)
-                        *fWhatToChange = '*';             
-    }
-private:
-    char *fWhatToChange;
-        
-        UBool doTailTest(void) {
-  static const UChar src[] = { 0x0020, 0x0633, 0 };
-  static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
-  static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
-  UChar dst[3] = { 0x0000, 0x0000,0 };
-  int32_t length;
-  UErrorCode status;
-  IntlTest inteltst =  IntlTest();
- 
-  status = U_ZERO_ERROR;
-  length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
-                         U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
-  if(U_FAILURE(status)) {
-           inteltst.errln("Fail: status %s\n", u_errorName(status)); 
-        return FALSE;
-  } else if(length!=2) {
-    inteltst.errln("Fail: len %d expected 3\n", length);
-        return FALSE;
-  } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
-    inteltst.errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
-            dst[0],dst[1],dst_old[0],dst_old[1]);
-        return FALSE;
-  }
 
 
-  //"Trying new tail
-  status = U_ZERO_ERROR;
-  length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
-                         U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
-  if(U_FAILURE(status)) {
-    inteltst.errln("Fail: status %s\n", u_errorName(status)); 
-        return FALSE;
-  } else if(length!=2) {
-    inteltst.errln("Fail: len %d expected 3\n", length);
-        return FALSE;
-  } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
-    inteltst.errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
-            dst[0],dst[1],dst_new[0],dst_new[1]);
-        return FALSE;
-  } 
-  
-  
-  return TRUE;
-  
-}
-        
-
-};
-
 void MultithreadTest::TestThreads()
 {
+    static const int32_t THREADTEST_NRTHREADS = 8;
     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.");
     }
 
+    if (numThreadsStarted != THREADTEST_NRTHREADS) {
+        errln("Not all threads could be started for testing!");
+        return;
+    }
+
     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++)
-    {
+    for(i=0; i<THREADTEST_NRTHREADS; i++) {
+        threads[i]->join();
+        if (threadTestChars[i] != '*') {
+            errln("%s:%d Thread %d failed.", __FILE__, __LINE__, i);
+        }
         delete threads[i];
     }
 }
 
 
+//-----------------------------------------------------------------------------------
+//
+//   TestArabicShapeThreads -- see if calls to u_shapeArabic in many threads works successfully
+//
+//   Set up N threads pointing at N chars. When they are started, they will make calls to doTailTest which tests
+//   u_shapeArabic, if the calls are successful it will the set * chars.
+//   At the end we make sure all threads managed to run u_shapeArabic successfully.
+//   This is a unit test for ticket 9473
+//
+//-----------------------------------------------------------------------------------
+
+class TestArabicShapeThreads : public SimpleThread
+{
+public:
+    TestArabicShapeThreads() {};
+    virtual void run() { doTailTest(); };
+private:
+        void doTailTest();
+};
+
+
+void TestArabicShapeThreads::doTailTest(void) {
+    static const UChar src[] = { 0x0020, 0x0633, 0 };
+    static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
+    static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
+    UChar dst[3] = { 0x0000, 0x0000,0 };
+    int32_t length;
+    UErrorCode status;
+
+    for (int32_t loopCount = 0; loopCount < 100; loopCount++) {
+        status = U_ZERO_ERROR;
+        length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
+                U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
+        if(U_FAILURE(status)) {
+            IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
+            return;
+        } else if(length!=2) {
+            IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
+            return;
+        } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
+            IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
+                    dst[0],dst[1],dst_old[0],dst_old[1]);
+            return;
+        }
+
+
+        //"Trying new tail
+        status = U_ZERO_ERROR;
+        length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
+                U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
+        if(U_FAILURE(status)) {
+            IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
+            return;
+        } else if(length!=2) {
+            IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
+            return;
+        } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
+            IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
+                    dst[0],dst[1],dst_new[0],dst_new[1]);
+            return;
+        }
+    }
+    return;
+}
+        
+
 void MultithreadTest::TestArabicShapingThreads()
 {
-    char threadTestChars[ARABICSHAPE_THREADTEST + 1];
-    SimpleThread *threads[ARABICSHAPE_THREADTEST];
-    int32_t numThreadsStarted = 0;
+    TestArabicShapeThreads threads[30];
 
     int32_t i;
-    
-    for(i=0;i<ARABICSHAPE_THREADTEST;i++)
-    {
-        threadTestChars[i] = ' ';
-        threads[i] = new TestArabicShapeThreads(&threadTestChars[i]);
-    }
-    threadTestChars[ARABICSHAPE_THREADTEST] = '\0';
 
     logln("-> do TestArabicShapingThreads <- Firing off threads.. ");
-    for(i=0;i<ARABICSHAPE_THREADTEST;i++)
-    {
-        if (threads[i]->start() != 0) {
+    for(i=0; i < UPRV_LENGTHOF(threads); 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 = 100; // seconds to wait
-
-    while(patience--)
-    {
-        int32_t count = 0;
-        umtx_lock(NULL);
-        for(i=0;i<ARABICSHAPE_THREADTEST;i++)
-        {
-            if(threadTestChars[i] == '*')
-            {
-                count++;
-            }
-        }
-        umtx_unlock(NULL);
-        
-        if(count == ARABICSHAPE_THREADTEST)
-        {
-            logln("->TestArabicShapingThreads <- Got all threads! cya");
-            for(i=0;i<ARABICSHAPE_THREADTEST;i++)
-            {
-                delete threads[i];
-            }
-            return;
-        }
-
-        logln("-> TestArabicShapingThreads <- Waiting..");
-        SimpleThread::sleep(500);
-    }
-
-    errln("-> TestArabicShapingThreads <- PATIENCE EXCEEDED!! Still missing some.");
-    for(i=0;i<ARABICSHAPE_THREADTEST;i++)
-    {
-        delete threads[i];
-    }
-        
-}
-
- 
+    }
+
+    for(i=0; i < UPRV_LENGTHOF(threads); i++) {
+        threads[i].join();
+    }
+    logln("->TestArabicShapingThreads <- Got all threads! cya");
+}
+
+
 //-----------------------------------------------------------------------
 //
 //  TestMutex  - a simple (non-stress) test to verify that ICU mutexes
-//               are actually mutexing.  Does not test the use of
+//               and condition variables are functioning.  Does not test the use of
 //               mutexes within ICU services, but rather that the
 //               platform's mutex support is at least superficially there.
 //
 //----------------------------------------------------------------------
-static UMutex    gTestMutexA = U_MUTEX_INITIALIZER;
-static UMutex    gTestMutexB = U_MUTEX_INITIALIZER;
-
-static int     gThreadsStarted = 0; 
+static UMutex         gTestMutexA          = U_MUTEX_INITIALIZER;
+static UConditionVar  gThreadsCountChanged = U_CONDITION_INITIALIZER;
+
+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;
-}
+static const int TESTMUTEX_THREAD_COUNT = 40;
 
 class TestMutexThread : public SimpleThread
 {
 public:
-    virtual void run()
-    {
+    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);
+        // All threads move together throught the started - middle - done sequence together,
+        // waiting for all other threads to reach each point before advancing.
         umtx_lock(&gTestMutexA);
+        gThreadsStarted += 1;
+        umtx_condBroadcast(&gThreadsCountChanged);
+        while (gThreadsStarted < TESTMUTEX_THREAD_COUNT) {
+            if (gThreadsInMiddle != 0) {
+                IntlTest::gTest->errln(
+                    "%s:%d gThreadsInMiddle = %d. Expected 0.", __FILE__, __LINE__, gThreadsInMiddle);
+                return;
+            }
+            umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
+        }
+
+        gThreadsInMiddle += 1;
+        umtx_condBroadcast(&gThreadsCountChanged);
+        while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
+            if (gThreadsDone != 0) {
+                IntlTest::gTest->errln(
+                    "%s:%d gThreadsDone = %d. Expected 0.", __FILE__, __LINE__, gThreadsDone);
+                return;
+            }
+            umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
+        }
+
+        gThreadsDone += 1;
+        umtx_condBroadcast(&gThreadsCountChanged);
+        while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
+            umtx_condWait(&gThreadsCountChanged, &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;
+    int32_t i = 0;
+    TestMutexThread  threads[TESTMUTEX_THREAD_COUNT];
     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!");
+        if (threads[i].start() != 0) {
+            errln("%s:%d Error starting thread %d", __FILE__, __LINE__, i);
+            return;
+        }
+    }
+
+    // Because we are holding gTestMutexA, all of the threads should be blocked
+    // at the start of their run() function.
+    if (gThreadsStarted != 0) {
+        errln("%s:%d gThreadsStarted=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
         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);
+    while (gThreadsInMiddle < TESTMUTEX_THREAD_COUNT) {
+        if (gThreadsDone != 0) {
+            errln("%s:%d gThreadsDone=%d. Expected 0.", __FILE__, __LINE__, gThreadsStarted);
+            return;
+        }
+        umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
+    }
+
+    while (gThreadsDone < TESTMUTEX_THREAD_COUNT) {
+        umtx_condWait(&gThreadsCountChanged, &gTestMutexA);
+    }
     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.
-
     for (i=0; i<TESTMUTEX_THREAD_COUNT; i++) {
-        delete threads[i];
-    }
-
+        threads[i].join();
+    }
 }
 
 
 //-------------------------------------------------------------------------------------------
 //
-// class ThreadWithStatus - a thread that we can check the status and error condition of
+//   TestMultithreadedIntl.  Test ICU Formatting in a multi-threaded environment
 //
 //-------------------------------------------------------------------------------------------
-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
     {
@@ skipping 10 matching lines @@
         }
         res += "<Differences";
         res += "\n";
     }
     res += result + "<Result\n";
 
     return res;
 }
 
 
-
-
 //-------------------------------------------------------------------------------------------
 //
 //   FormatThreadTest - a thread that tests performing a number of numberformats.
 //
 //-------------------------------------------------------------------------------------------
 
 const int kFormatThreadIterations = 100;  // # of iterations per thread
-const int kFormatThreadThreads    = 10;  // # of threads to spawn   
+const int kFormatThreadThreads    = 10;  // # of threads to spawn
 
 #if !UCONFIG_NO_FORMATTING
 
 
 
 struct FormatThreadTestData
 {
     double number;
     UnicodeString string;
     FormatThreadTestData(double a, const UnicodeString& b) : number(a),string(b) {}
@@ skipping 17 matching lines @@
     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;                      
+    FieldPosition ignore = 0;
     fmt->format(myArgs,4,result,ignore,realStatus);
 
     delete fmt;
 }
 
 /**
- * Class for thread-safe (theoretically) format.
- * 
- *
- * Its constructor, destructor, and init/fini are NOT thread safe.
+  * Shared formatters &  data used by instances of ThreadSafeFormat.
+  * Exactly one instance of this class is created, and it is then shared concurrently
+  * by the multiple instances of ThreadSafeFormat.
+  */
+class ThreadSafeFormatSharedData {
+  public:
+    ThreadSafeFormatSharedData(UErrorCode &status);
+    ~ThreadSafeFormatSharedData();
+    LocalPointer<NumberFormat>  fFormat;
+    Formattable    fYDDThing;
+    Formattable    fBBDThing;
+    UnicodeString  fYDDStr;
+    UnicodeString  fBBDStr;
+};
+
+const ThreadSafeFormatSharedData *gSharedData = NULL;
+
+ThreadSafeFormatSharedData::ThreadSafeFormatSharedData(UErrorCode &status) {
+    fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
+    static const UChar kYDD[] = { 0x59, 0x44, 0x44, 0x00 };
+    static const UChar kBBD[] = { 0x42, 0x42, 0x44, 0x00 };
+    fYDDThing.adoptObject(new CurrencyAmount(123.456, kYDD, status));
+    fBBDThing.adoptObject(new CurrencyAmount(987.654, kBBD, status));
+    if (U_FAILURE(status)) {
+        return;
+    }
+    fFormat->format(fYDDThing, fYDDStr, NULL, status);
+    fFormat->format(fBBDThing, fBBDStr, NULL, status);
+    gSharedData = this;
+}
+
+ThreadSafeFormatSharedData::~ThreadSafeFormatSharedData() {
+    gSharedData = NULL;
+}
+
+/**
+ * Class for thread-safe testing of format.
+ *   Instances of this class appear as members of class FormatThreadTest.
+ *   Multiple instances of FormatThreadTest coexist.
+ *   ThreadSafeFormat::doStuff() is called concurrently to test the thread safety of
+ *   various shared format operations.
  */
 class ThreadSafeFormat {
 public:
   /* give a unique offset to each thread */
-  ThreadSafeFormat();
-  UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status);
+  ThreadSafeFormat(UErrorCode &status);
+  UBool doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const;
 private:
-  LocalPointer<NumberFormat> fFormat; // formtter - default constructed currency
-  Formattable  fYDDThing;    // Formattable currency - YDD
-  Formattable  fBBDThing;   // Formattable currency - BBD
-
-  // statics
-private:
-  static LocalPointer<NumberFormat> gFormat;
-  static NumberFormat *createFormat(UErrorCode &status);
-  static Formattable gYDDThing, gBBDThing;
-public:
-  static void init(UErrorCode &status); // avoid static init.
-  static void fini(UErrorCode &status); // avoid static fini
+  LocalPointer<NumberFormat> fFormat; // formatter - en_US constructed currency
 };
 
-LocalPointer<NumberFormat> ThreadSafeFormat::gFormat;
-Formattable ThreadSafeFormat::gYDDThing;
-Formattable ThreadSafeFormat::gBBDThing;
-UnicodeString gYDDStr, gBBDStr;
-NumberFormat *ThreadSafeFormat::createFormat(UErrorCode &status) {
-  LocalPointer<NumberFormat> fmt(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
-  return fmt.orphan();
+
+ThreadSafeFormat::ThreadSafeFormat(UErrorCode &status) {
+  fFormat.adoptInstead(NumberFormat::createCurrencyInstance(Locale::getUS(), status));
 }
 
-
-static const UChar kYDD[] = { 0x59, 0x44, 0x44, 0x00 };
-static const UChar kBBD[] = { 0x42, 0x42, 0x44, 0x00 };
 static const UChar kUSD[] = { 0x55, 0x53, 0x44, 0x00 };
 
-void ThreadSafeFormat::init(UErrorCode &status) {
-  gFormat.adoptInstead(createFormat(status));
-  gYDDThing.adoptObject(new CurrencyAmount(123.456, kYDD, status));
-  gBBDThing.adoptObject(new CurrencyAmount(987.654, kBBD, status));
-  if (U_FAILURE(status)) {
-      return;
-  }
-  gFormat->format(gYDDThing, gYDDStr, NULL, status);
-  gFormat->format(gBBDThing, gBBDStr, NULL, status);
-}
-
-void ThreadSafeFormat::fini(UErrorCode &/*status*/) {
-  gFormat.adoptInstead(NULL);
-}
-
-ThreadSafeFormat::ThreadSafeFormat() {
-}
-
-UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) {
+UBool ThreadSafeFormat::doStuff(int32_t offset, UnicodeString &appendErr, UErrorCode &status) const {
   UBool okay = TRUE;
-  if(fFormat.isNull()) {
-    fFormat.adoptInstead(createFormat(status));
-  }
 
   if(u_strcmp(fFormat->getCurrency(), kUSD)) {
     appendErr.append("fFormat currency != ")
       .append(kUSD)
       .append(", =")
       .append(fFormat->getCurrency())
       .append("! ");
     okay = FALSE;
   }
 
-  if(u_strcmp(gFormat->getCurrency(), kUSD)) {
+  if(u_strcmp(gSharedData->fFormat->getCurrency(), kUSD)) {
     appendErr.append("gFormat currency != ")
       .append(kUSD)
       .append(", =")
-      .append(gFormat->getCurrency())
+      .append(gSharedData->fFormat->getCurrency())
       .append("! ");
     okay = FALSE;
   }
   UnicodeString str;
   const UnicodeString *o=NULL;
   Formattable f;
   const NumberFormat *nf = NULL; // only operate on it as const.
   switch(offset%4) {
-  case 0:  f = gYDDThing;  o = &gYDDStr;  nf = gFormat.getAlias();  break;
-  case 1:  f = gBBDThing;  o = &gBBDStr;  nf = gFormat.getAlias();  break;
-  case 2:  f = gYDDThing;  o = &gYDDStr;  nf = fFormat.getAlias();  break;
-  case 3:  f = gBBDThing;  o = &gBBDStr;  nf = fFormat.getAlias();  break;
+  case 0:  f = gSharedData->fYDDThing;  o = &gSharedData->fYDDStr;  nf = gSharedData->fFormat.getAlias();  break;
+  case 1:  f = gSharedData->fBBDThing;  o = &gSharedData->fBBDStr;  nf = gSharedData->fFormat.getAlias();  break;
+  case 2:  f = gSharedData->fYDDThing;  o = &gSharedData->fYDDStr;  nf = fFormat.getAlias();  break;
+  case 3:  f = gSharedData->fBBDThing;  o = &gSharedData->fBBDStr;  nf = fFormat.getAlias();  break;
   }
   nf->format(f, str, NULL, status);
 
   if(*o != str) {
     appendErr.append(showDifference(*o, str));
     okay = FALSE;
   }
   return okay;
 }
 
 UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInfo *) {
     return TRUE;
 }
 
 //static UMTX debugMutex = NULL;
 //static UMTX gDebugMutex;
 
 
-class FormatThreadTest : public ThreadWithStatus
+class FormatThreadTest : public SimpleThread
 {
 public:
     int     fNum;
     int     fTraceInfo;
 
-    ThreadSafeFormat fTSF;
+    LocalPointer<ThreadSafeFormat> fTSF;
 
     FormatThreadTest() // constructor is NOT multithread safe.
-        : ThreadWithStatus(),
+        : SimpleThread(),
         fNum(0),
         fTraceInfo(0),
+        fTSF(NULL),
         fOffset(0)
         // the locale to use
     {
+        UErrorCode status = U_ZERO_ERROR;      // TODO: rearrange code to allow checking of status.
+        fTSF.adoptInstead(new ThreadSafeFormat(status));
         static int32_t fgOffset = 0;
         fgOffset += 3;
         fOffset = fgOffset;
     }
 
 
     virtual void run()
     {
         fTraceInfo                     = 1;
         LocalPointer<NumberFormat> percentFormatter;
         UErrorCode status = U_ZERO_ERROR;
 
 #if 0
-        // debugging code, 
+        // debugging code,
         for (int i=0; i<4000; i++) {
             status = U_ZERO_ERROR;
             UDataMemory *data1 = udata_openChoice(0, "res", "en_US", isAcceptable, 0, &status);
             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, 
+        // 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 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]));
-        
+        int32_t kNumberFormatTestDataLength = UPRV_LENGTHOF(kNumberFormatTestData);
+
         // Keep this data here to avoid static initialization.
-        FormatThreadTestData kPercentFormatTestData[] = 
+        FormatThreadTestData kPercentFormatTestData[] =
         {
             FormatThreadTestData((double)5.0, CharsToUnicodeString("500\\u00a0%")),
                 FormatThreadTestData( 1.0, CharsToUnicodeString("100\\u00a0%")),
                 FormatThreadTestData( 0.26, CharsToUnicodeString("26\\u00a0%")),
-                FormatThreadTestData( 
+                FormatThreadTestData(
                    16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499\\u00a0%")), // U+00a0 = NBSP
-                FormatThreadTestData( 
+                FormatThreadTestData(
                     81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023\\u00a0%")),
         };
-        int32_t kPercentFormatTestDataLength = 
-                (int32_t)(sizeof(kPercentFormatTestData) / sizeof(kPercentFormatTestData[0]));
+        int32_t kPercentFormatTestDataLength = UPRV_LENGTHOF(kPercentFormatTestData);
         int32_t iteration;
-        
+
         status = U_ZERO_ERROR;
         LocalPointer<NumberFormat> formatter(NumberFormat::createInstance(Locale::getEnglish(),status));
         if(U_FAILURE(status)) {
-            error("Error on NumberFormat::createInstance().");
+            IntlTest::gTest->dataerrln("%s:%d Error %s on NumberFormat::createInstance().",
+                    __FILE__, __LINE__, u_errorName(status));
             goto cleanupAndReturn;
         }
-        
+
         percentFormatter.adoptInstead(NumberFormat::createPercentInstance(Locale::getFrench(),status));
         if(U_FAILURE(status))             {
-            error("Error on NumberFormat::createPercentInstance().");
+            IntlTest::gTest->errln("%s:%d Error %s on NumberFormat::createPercentInstance().",
+                    __FILE__, __LINE__, u_errorName(status));
             goto cleanupAndReturn;
         }
-        
-        for(iteration = 0;!getError() && iteration<kFormatThreadIterations;iteration++)
+
+        for(iteration = 0;!IntlTest::gTest->getErrors() && 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 
+                IntlTest::gTest->errln("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" + 
+                IntlTest::gTest->errln("percent format().. \n" +
                         showDifference(kPercentFormatTestData[whichLine].string,output));
                 goto cleanupAndReturn;
             }
-            
-            // Test message error 
+
+            // Test message error
             const int       kNumberOfMessageTests = 3;
             UErrorCode      statusToCheck;
             UnicodeString   patternToCheck;
             Locale          messageLocale;
             Locale          countryToCheck;
             double          currencyToCheck;
-            
+
             UnicodeString   expected;
-            
+
             // load the cases.
             switch((iteration+fOffset) % kNumberOfMessageTests)
             {
             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
+                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.");
+                                                    "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.");
+                            " \\u00f6S\\u00A040\\u00A0193,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 +
+                IntlTest::gTest->errln("Failure on message format, pattern=" + patternToCheck +
                         ", error = " + tmp);
                 goto cleanupAndReturn;
             }
-            
+
             if(result != expected)
             {
-                error("PatternFormat: \n" + showDifference(expected,result));
+                IntlTest::gTest->errln("PatternFormat: \n" + showDifference(expected,result));
                 goto cleanupAndReturn;
             }
             // test the Thread Safe Format
             UnicodeString appendErr;
-            if(!fTSF.doStuff(fNum, appendErr, status)) {
-              error(appendErr);
+            if(!fTSF->doStuff(fNum, appendErr, status)) {
+              IntlTest::gTest->errln(appendErr);
               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;
 
     UErrorCode threadSafeErr = U_ZERO_ERROR;
 
-    ThreadSafeFormat::init(threadSafeErr);
+    ThreadSafeFormatSharedData sharedData(threadSafeErr);
     assertSuccess("initializing ThreadSafeFormat", threadSafeErr, TRUE);
 
     //
     //  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++) {
+    FormatThreadTest tests[kFormatThreadThreads];
+    int32_t j;
+    for(j = 0; j < UPRV_LENGTHOF(tests); 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();
+            errln("%s:%d System Error %d starting thread number %d.",
+                    __FILE__, __LINE__, threadStatus, j);
             return;
         }
-        haveDisplayedInfo[j] = FALSE;
     }
 
 
-    // Spin, waiting for the test threads to finish.
-    UBool   stillRunning;
-    UDate startTime, endTime;
-    startTime = Calendar::getNow();
-    double lastComplaint = 0;
-    do {
-        /*  Spin until the test threads  complete. */
-        stillRunning = FALSE;
-        endTime = Calendar::getNow();
-        double elapsedSeconds =  ((int32_t)(endTime - startTime)/U_MILLIS_PER_SECOND);
-        if (elapsedSeconds > PATIENCE_SECONDS) {
-            errln("Patience exceeded. Test is taking too long.");
-            return;
-        } else if((elapsedSeconds-lastComplaint) > 2.0) {
-            infoln("%.1f seconds elapsed (still waiting..)", elapsedSeconds);
-            lastComplaint = elapsedSeconds;
-        }
-        /*
-         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.
-    //
-    ThreadSafeFormat::fini(threadSafeErr);
-    assertSuccess("finalizing ThreadSafeFormat", threadSafeErr, TRUE);
+    for (j=0; j<UPRV_LENGTHOF(tests); j++) {
+        tests[j].join();
+        logln("Thread # %d is complete..", j);
+    }
 }
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 
 
 
 
 //-------------------------------------------------------------------------------------------
 //
 // Collation threading test
@@ skipping 19 matching lines @@
         return TRUE;
     }
     return FALSE;
 }
 
 static UCollationResult
 normalizeResult(int32_t result) {
     return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;
 }
 
-class CollatorThreadTest : public ThreadWithStatus
+class CollatorThreadTest : public SimpleThread
 {
-private: 
+private:
     const Collator *coll;
     const Line *lines;
     int32_t noLines;
     UBool isAtLeastUCA62;
 public:
-    CollatorThreadTest()  : ThreadWithStatus(),
+    CollatorThreadTest()  : SimpleThread(),
         coll(NULL),
         lines(NULL),
         noLines(0),
         isAtLeastUCA62(TRUE)
     {
     };
     void setCollator(Collator *c, Line *l, int32_t nl, UBool atLeastUCA62)
     {
         coll = c;
         lines = l;
@@ skipping 13 matching lines @@
             if(skipLineBecauseOfBug(lines[i].buff, lines[i].buflen)) { continue; }
 
             int32_t resLen = coll->getSortKey(lines[i].buff, lines[i].buflen, newSk, 1024);
 
             if(oldSk != NULL) {
                 int32_t skres = strcmp((char *)oldSk, (char *)newSk);
                 int32_t cmpres = coll->compare(lines[prev].buff, lines[prev].buflen, lines[i].buff, lines[i].buflen);
                 int32_t cmpres2 = coll->compare(lines[i].buff, lines[i].buflen, lines[prev].buff, lines[prev].buflen);
 
                 if(cmpres != -cmpres2) {
-                    error(UnicodeString("Compare result not symmetrical on line ") + (i + 1));
+                    IntlTest::gTest->errln(UnicodeString("Compare result not symmetrical on line ") + (i + 1));
                     break;
                 }
 
                 if(cmpres != normalizeResult(skres)) {
-                    error(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));
+                    IntlTest::gTest->errln(UnicodeString("Difference between coll->compare and sortkey compare on line ") + (i + 1));
                     break;
                 }
 
                 int32_t res = cmpres;
                 if(res == 0 && !isAtLeastUCA62) {
                     // Up to UCA 6.1, the collation test files use a custom tie-breaker,
                     // comparing the raw input strings.
                     res = u_strcmpCodePointOrder(lines[prev].buff, lines[i].buff);
                     // Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
                     // comparing the NFD versions of the input strings,
                     // which we do via setting strength=identical.
                 }
                 if(res > 0) {
-                    error(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));
+                    IntlTest::gTest->errln(UnicodeString("Line is not greater or equal than previous line, for line ") + (i + 1));
                     break;
                 }
             }
 
             oldSk = newSk;
             oldLen = resLen;
             (void)oldLen;   // Suppress set but not used warning.
             prev = i;
 
             newSk = (newSk == sk1)?sk2:sk1;
@@ skipping 41 matching lines @@
         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;        
+                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/");
             }
         }
     }
 
@@ skipping 33 matching lines @@
     if(U_FAILURE(status)) {
         errcheckln(status, "Couldn't open UCA collator");
         return;
     }
     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
     coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
     coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);
     coll->setAttribute(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.getAlias(), lines.getAlias(), lineNum, isAtLeastUCA62);
     }
     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;
+            errln("%s:%d THREAD INFO: thread %d failed to start with status %d", __FILE__, __LINE__, j, spawnResult);
+            return;
         }
-        noSpawned++;
     }
     logln("Spawned all");
-    if (noSpawned == 0) {
-        errln("No threads could be spawned.");
-        return;
+
+    for(int32_t i=0;i<kCollatorThreadThreads;i++) {
+        tests[i].join();
+        //logln(UnicodeString("Test #") + i + " is complete.. ");
     }
-
-    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();
-            }
-            return;
-        }
-
-        SimpleThread::sleep(900);
-    }
-    errln("patience exceeded. ");
-    SimpleThread::errorFunc();
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */
 
 
 
 
 //-------------------------------------------------------------------------------------------
 //
-//   StringThreadTest2 
+//   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
+class StringThreadTest2 : public SimpleThread
 {
 public:
     int                 fNum;
     int                 fTraceInfo;
-    const UnicodeString *fSharedString;
+    static const UnicodeString *gSharedString;
 
-    StringThreadTest2(const UnicodeString *sharedString, int num) // constructor is NOT multithread safe.
-        : ThreadWithStatus(),
-        fNum(num),
-        fTraceInfo(0),
-        fSharedString(sharedString)
+    StringThreadTest2() // constructor is NOT multithread safe.
+        : SimpleThread(),
+        fTraceInfo(0)
     {
     };
 
 
     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.");
+            if (*gSharedString != "This is the original test string.") {
+                IntlTest::gTest->errln("%s:%d Original string is corrupt.", __FILE__, __LINE__);
                 break;
             }
-            UnicodeString s1 = *fSharedString;
+            UnicodeString s1 = *gSharedString;
             s1 += "cat this";
             UnicodeString s2(s1);
-            UnicodeString s3 = *fSharedString;
+            UnicodeString s3 = *gSharedString;
             s2 = s3;
             s3.truncate(12);
             s2.truncate(0);
         }
 
-        //  while (fNum == 4) {SimpleThread::sleep(10000);}   // Force a failure by preventing thread from finishing
         fTraceInfo = 2;
     }
-    
+
 };
 
+const UnicodeString *StringThreadTest2::gSharedString = NULL;
+
 // ** The actual test function.
 
+
 void MultithreadTest::TestString()
 {
-    int     patience;
-    int     terrs = 0;
     int     j;
+    StringThreadTest2::gSharedString = new UnicodeString("This is the original test string.");
+    StringThreadTest2  tests[kStringThreadThreads];
 
-    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();
+        int32_t threadStatus = tests[j].start();
         if (threadStatus != 0) {
-            errln("System Error %d starting thread number %d.", threadStatus, j);
-            SimpleThread::errorFunc();  
-            goto cleanupAndReturn;
+            errln("%s:%d System Error %d starting thread number %d.", __FILE__, __LINE__, threadStatus, j);
         }
     }
 
-    for(patience = kStringThreadPatience;patience > 0; patience --)
-    {
-        logln("Waiting...");
+    // Force a failure, to verify test is functioning and can report errors.
+    // const_cast<UnicodeString *>(StringThreadTest2::gSharedString)->setCharAt(5, 'x');
 
-        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);
+    for(j=0; j<kStringThreadThreads; j++) {
+        tests[j].join();
+        logln(UnicodeString("Test #") + j + " is complete.. ");
     }
 
-    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;
-    }
+    delete StringThreadTest2::gSharedString;
+    StringThreadTest2::gSharedString = NULL;
 }
 
 
+//
 // Test for ticket #10673, race in cache code in AnyTransliterator.
 // It's difficult to make the original unsafe code actually fail, but
-// this test will fairly reliably take the code path for races in 
+// this test will fairly reliably take the code path for races in
 // populating the cache.
+//
 
 #if !UCONFIG_NO_TRANSLITERATION
+Transliterator *gSharedTranslit = NULL;
 class TxThread: public SimpleThread {
-  private:
-    Transliterator *fSharedTranslit;
   public:
-    UBool fSuccess;
-    TxThread(Transliterator *tx) : fSharedTranslit(tx), fSuccess(FALSE) {};
+    TxThread() {};
     ~TxThread();
     void run();
 };
 
 TxThread::~TxThread() {}
 void TxThread::run() {
     UnicodeString greekString("\\u03B4\\u03B9\\u03B1\\u03C6\\u03BF\\u03C1\\u03B5\\u03C4\\u03B9\\u03BA\\u03BF\\u03CD\\u03C2");
     greekString = greekString.unescape();
-    fSharedTranslit->transliterate(greekString);
-    fSuccess = greekString[0] == 0x64; // 'd'. The whole transliterated string is "diaphoretikous" (accented u).
+    gSharedTranslit->transliterate(greekString);
+    if (greekString[0] != 0x64)      // 'd'. The whole transliterated string is "diaphoretikous" (accented u).
+    {
+        IntlTest::gTest->errln("%s:%d Transliteration failed.", __FILE__, __LINE__);
+    }
 }
 #endif
-    
+
 
 void MultithreadTest::TestAnyTranslit() {
 #if !UCONFIG_NO_TRANSLITERATION
     UErrorCode status = U_ZERO_ERROR;
     LocalPointer<Transliterator> tx(Transliterator::createInstance("Any-Latin", UTRANS_FORWARD, status));
     if (U_FAILURE(status)) {
         dataerrln("File %s, Line %d: Error, status = %s", __FILE__, __LINE__, u_errorName(status));
         return;
     }
-    TxThread * threads[4];
+    gSharedTranslit = tx.getAlias();
+    TxThread  threads[4];
     int32_t i;
-    for (i=0; i<4; i++) {
-        threads[i] = new TxThread(tx.getAlias());
+    for (i=0; i<UPRV_LENGTHOF(threads); i++) {
+        threads[i].start();
     }
-    for (i=0; i<4; i++) {
-        threads[i]->start();
+
+    for (i=0; i<UPRV_LENGTHOF(threads); i++) {
+        threads[i].join();
     }
-    int32_t patience = 100;
-    UBool success;
-    UBool someThreadRunning;
-    do {
-        someThreadRunning = FALSE;
-        success = TRUE;
-        for (i=0; i<4; i++) {
-            if (threads[i]->isRunning()) {
-                someThreadRunning = TRUE;
-                SimpleThread::sleep(10);
-                break;
-            } else {
-                if (threads[i]->fSuccess == FALSE) {
-                    success = FALSE;
-                }
-            }
-        }
-    } while (someThreadRunning && --patience > 0);
-
-    if (patience <= 0) {
-        errln("File %s, Line %d: Error, one or more threads did not complete.", __FILE__, __LINE__);
-    }
-    if (success == FALSE) {
-        errln("File %s, Line %d: Error, transliteration result incorrect.", __FILE__, __LINE__);
-    }
-    
-    for (i=0; i<4; i++) {
-        delete threads[i];
-    }
+    gSharedTranslit = NULL;
 #endif  // !UCONFIG_NO_TRANSLITERATION
 }
 
 
+//
 // Condition Variables Test
 //   Create a swarm of threads.
 //   Using a mutex and a condition variables each thread
 //     Increments a global count of started threads.
 //     Broadcasts that it has started.
 //     Waits on the condition that all threads have started.
 //     Increments a global count of finished threads.
 //     Waits on the condition that all threads have finished.
 //     Exits.
+//
 
 class CondThread: public SimpleThread {
   public:
     CondThread() :fFinished(false)  {};
     ~CondThread() {};
     void run();
     bool  fFinished;
 };
 
 static UMutex gCTMutex = U_MUTEX_INITIALIZER;
 static UConditionVar gCTConditionVar = U_CONDITION_INITIALIZER;
 int gConditionTestOne = 1;   // Value one. Non-const, extern linkage to inhibit
                              //   compiler assuming a known value.
-int gStartedThreads;         
+int gStartedThreads;
 int gFinishedThreads;
 static const int NUMTHREADS = 10;
 
-static MultithreadTest *gThisTest = NULL; // Make test frame work functions available to
-                                          //   non-member functions.
 
 // Worker thread function.
 void CondThread::run() {
-    umtx_lock(&gCTMutex); 
+    umtx_lock(&gCTMutex);
     gStartedThreads += gConditionTestOne;
     umtx_condBroadcast(&gCTConditionVar);
-    
+
     while (gStartedThreads < NUMTHREADS) {
         if (gFinishedThreads != 0) {
-            gThisTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d", 
+            IntlTest::gTest->errln("File %s, Line %d: Error, gStartedThreads = %d, gFinishedThreads = %d",
                              __FILE__, __LINE__, gStartedThreads, gFinishedThreads);
         }
         umtx_condWait(&gCTConditionVar, &gCTMutex);
     }
 
     gFinishedThreads += gConditionTestOne;
     fFinished = true;
     umtx_condBroadcast(&gCTConditionVar);
 
     while (gFinishedThreads < NUMTHREADS) {
         umtx_condWait(&gCTConditionVar, &gCTMutex);
     }
     umtx_unlock(&gCTMutex);
 }
 
 void MultithreadTest::TestConditionVariables() {
-    gThisTest = this;
     gStartedThreads = 0;
     gFinishedThreads = 0;
     int i;
 
     umtx_lock(&gCTMutex);
     CondThread *threads[NUMTHREADS];
     for (i=0; i<NUMTHREADS; ++i) {
         threads[i] = new CondThread;
         threads[i]->start();
     }
 
     while (gStartedThreads < NUMTHREADS) {
         umtx_condWait(&gCTConditionVar, &gCTMutex);
     }
 
     while (gFinishedThreads < NUMTHREADS) {
         umtx_condWait(&gCTConditionVar, &gCTMutex);
     }
 
     umtx_unlock(&gCTMutex);
 
     for (i=0; i<NUMTHREADS; ++i) {
         if (!threads[i]->fFinished) {
             errln("File %s, Line %d: Error, threads[%d]->fFinished == false", __FILE__, __LINE__, i);
         }
+    }
+
+    for (i=0; i<NUMTHREADS; ++i) {
+        threads[i]->join();
         delete threads[i];
     }
 }
 
-static const char *gCacheLocales[] = {"en_US", "en_GB", "fr_FR", "fr"};
-static int32_t gObjectsCreated = 0;
+
+//
+// Unified Cache Test
+//
+
+// Each thread fetches a pair of objects. There are 8 distinct pairs:
+// ("en_US", "bs"), ("en_GB", "ca"), ("fr_FR", "ca_AD") etc.
+// These pairs represent 8 distinct languages
+
+// Note that only one value per language gets created in the cache.
+// In particular each cached value can have multiple keys.
+static const char *gCacheLocales[] = {
+    "en_US", "en_GB", "fr_FR", "fr",
+    "de", "sr_ME", "sr_BA", "sr_CS"};
+static const char *gCacheLocales2[] = {
+    "bs", "ca", "ca_AD", "ca_ES",
+    "en_US", "fi", "ff_CM", "ff_GN"};
+
+static int32_t gObjectsCreated = 0;  // protected by gCTMutex
 static const int32_t CACHE_LOAD = 3;
 
 class UCTMultiThreadItem : public SharedObject {
   public:
     char *value;
-    UCTMultiThreadItem(const char *x) : value(NULL) { 
+    UCTMultiThreadItem(const char *x) : value(NULL) {
         value = uprv_strdup(x);
     }
-    virtual ~UCTMultiThreadItem() { 
+    virtual ~UCTMultiThreadItem() {
         uprv_free(value);
     }
 };
 
 U_NAMESPACE_BEGIN
 
 template<> U_EXPORT
 const UCTMultiThreadItem *LocaleCacheKey<UCTMultiThreadItem>::createObject(
-        const void * /*unused*/, UErrorCode & /* status */) const {
-    // Since multiple threads are hitting the cache for the first time,
-    // no objects should be created yet.
+        const void *context, UErrorCode &status) const {
+    const UnifiedCache *cacheContext = (const UnifiedCache *) context;
+
+    if (uprv_strcmp(fLoc.getLanguage(), fLoc.getName()) != 0) {
+        const UCTMultiThreadItem *result = NULL;
+        if (cacheContext == NULL) {
+            UnifiedCache::getByLocale(fLoc.getLanguage(), result, status);
+            return result;
+        }
+        cacheContext->get(LocaleCacheKey<UCTMultiThreadItem>(fLoc.getLanguage()), result, status);
+        return result;
+    }
+
     umtx_lock(&gCTMutex);
-    if (gObjectsCreated != 0) {
-        gThisTest->errln("Expected no objects to be created yet.");
+    bool firstObject = (gObjectsCreated == 0);
+    if (firstObject) {
+        // Force the first object creation that comes through to wait
+        // until other have completed. Verifies that cache doesn't
+        // deadlock when a creation is slow.
+
+        // Note that gObjectsCreated needs to be incremeneted from 0 to 1
+        // early, to keep subsequent threads from entering this path.
+        gObjectsCreated = 1;
+        while (gObjectsCreated < 3) {
+            umtx_condWait(&gCTConditionVar, &gCTMutex);
+        }
     }
     umtx_unlock(&gCTMutex);
 
-    // Big, expensive object that takes 1 second to create.
-    SimpleThread::sleep(1000);
+    const UCTMultiThreadItem *result =
+        new UCTMultiThreadItem(fLoc.getLanguage());
+    if (result == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    } else {
+        result->addRef();
+    }
+    
+    // Log that we created an object. The first object was already counted,
+    //    don't do it again.
+    umtx_lock(&gCTMutex);
+    if (!firstObject) {
+        gObjectsCreated += 1;
+    }
+    umtx_condBroadcast(&gCTConditionVar);
+    umtx_unlock(&gCTMutex);
 
-    // Log that we created an object.
-    umtx_lock(&gCTMutex);
-    ++gObjectsCreated;
-    umtx_unlock(&gCTMutex);
-    UCTMultiThreadItem *result = new UCTMultiThreadItem(fLoc.getName());
-    result->addRef();
     return result;
 }
 
 U_NAMESPACE_END
 
 class UnifiedCacheThread: public SimpleThread {
   public:
-    UnifiedCacheThread(const char *loc) : fLoc(loc) {};
+    UnifiedCacheThread(
+            const UnifiedCache *cache,
+            const char *loc,
+            const char *loc2) : fCache(cache), fLoc(loc), fLoc2(loc2) {};
     ~UnifiedCacheThread() {};
     void run();
-    const char *fLoc;
+    void exerciseByLocale(const Locale &);
+    const UnifiedCache *fCache;
+    Locale fLoc;
+    Locale fLoc2;
 };
 
+void UnifiedCacheThread::exerciseByLocale(const Locale &locale) {
+    UErrorCode status = U_ZERO_ERROR;
+    const UCTMultiThreadItem *origItem = NULL;
+    fCache->get(
+            LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, origItem, status);
+    U_ASSERT(U_SUCCESS(status));
+    if (uprv_strcmp(locale.getLanguage(), origItem->value)) {
+      IntlTest::gTest->errln(
+              "%s:%d Expected %s, got %s", __FILE__, __LINE__,
+              locale.getLanguage(),
+              origItem->value);
+    }
+
+    // Fetch the same item again many times. We should always get the same
+    // pointer since this client is already holding onto it
+    for (int32_t i = 0; i < 1000; ++i) {
+        const UCTMultiThreadItem *item = NULL;
+        fCache->get(
+                LocaleCacheKey<UCTMultiThreadItem>(locale), fCache, item, status);
+        if (item != origItem) {
+            IntlTest::gTest->errln(
+                    "%s:%d Expected to get the same pointer",
+                     __FILE__,
+                     __LINE__);
+        }
+        if (item != NULL) {
+            item->removeRef();
+        }
+    }
+    origItem->removeRef();
+}
+
 void UnifiedCacheThread::run() {
-    UErrorCode status = U_ZERO_ERROR;
-    const UnifiedCache *cache = UnifiedCache::getInstance(status);
-    U_ASSERT(status == U_ZERO_ERROR);
-    const UCTMultiThreadItem *item = NULL;
-    cache->get(LocaleCacheKey<UCTMultiThreadItem>(fLoc), item, status);
-    U_ASSERT(item != NULL);
-    if (uprv_strcmp(fLoc, item->value)) {
-      gThisTest->errln("Expected %s, got %s", fLoc, item->value);
-    }
-    item->removeRef();
-
-    // Mark this thread as finished
-    umtx_lock(&gCTMutex);
-    ++gFinishedThreads;
-    umtx_condBroadcast(&gCTConditionVar);
-    umtx_unlock(&gCTMutex);
+    // Run the exercise with 2 different locales so that we can exercise
+    // eviction more. If each thread exerices just one locale, then
+    // eviction can't start until the threads end.
+    exerciseByLocale(fLoc);
+    exerciseByLocale(fLoc2);
 }
 
 void MultithreadTest::TestUnifiedCache() {
+
+    // Start with our own local cache so that we have complete control
+    // and set the eviction policy to evict starting with 2 unused
+    // values
     UErrorCode status = U_ZERO_ERROR;
-    const UnifiedCache *cache = UnifiedCache::getInstance(status);
-    U_ASSERT(cache != NULL);
-    cache->flush();
-    gThisTest = this;
+    UnifiedCache::getInstance(status);
+    UnifiedCache cache(status);
+    cache.setEvictionPolicy(2, 0, status);
+    U_ASSERT(U_SUCCESS(status));
+
     gFinishedThreads = 0;
     gObjectsCreated = 0;
 
     UnifiedCacheThread *threads[CACHE_LOAD][UPRV_LENGTHOF(gCacheLocales)];
     for (int32_t i=0; i<CACHE_LOAD; ++i) {
         for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
-            threads[i][j] = new UnifiedCacheThread(gCacheLocales[j]);
+            // Each thread works with a pair of locales.
+            threads[i][j] = new UnifiedCacheThread(
+                    &cache, gCacheLocales[j], gCacheLocales2[j]);
             threads[i][j]->start();
         }
     }
-    // Wait on all the threads to complete verify that LENGTHOF(gCacheLocales)
-    // objects were created.
-    umtx_lock(&gCTMutex);
-    while (gFinishedThreads < CACHE_LOAD*UPRV_LENGTHOF(gCacheLocales)) {
-        umtx_condWait(&gCTConditionVar, &gCTMutex);
+
+    for (int32_t i=0; i<CACHE_LOAD; ++i) {
+        for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
+            threads[i][j]->join();
+        }
     }
-    assertEquals("Objects created", UPRV_LENGTHOF(gCacheLocales), gObjectsCreated);
-    umtx_unlock(&gCTMutex);
+    // Because of cache eviction, we can't assert exactly how many
+    // distinct objects get created over the course of this run.
+    // However we know that at least 8 objects get created because that
+    // is how many distinct languages we have in our test.
+    if (gObjectsCreated < 8) {
+        errln("%s:%d Too few objects created.", __FILE__, __LINE__);
+    }
+    // We know that each thread cannot create more than 2 objects in
+    // the cache, and there are UPRV_LENGTHOF(gCacheLocales) pairs of
+    // objects fetched from the cache. If the threads run in series because
+    // of eviction, at worst case each thread creates two objects.
+    if (gObjectsCreated > 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales)) {
+        errln("%s:%d Too many objects created, got %d, expected %d", __FILE__, __LINE__, gObjectsCreated, 2 * CACHE_LOAD * UPRV_LENGTHOF(gCacheLocales));
+
+    }
+
+    assertEquals("unused values", 2, cache.unusedCount());
 
     // clean up threads
     for (int32_t i=0; i<CACHE_LOAD; ++i) {
         for (int32_t j=0; j<UPRV_LENGTHOF(gCacheLocales); ++j) {
             delete threads[i][j];
         }
     }
 }
 
-#endif // ICU_USE_THREADS
+#if !UCONFIG_NO_TRANSLITERATION
+//
+//  BreakTransliterator Threading Test
+//     This is a test for bug #11603. Test verified to fail prior to fix.
+//
+
+static const Transliterator *gSharedTransliterator;
+static const UnicodeString *gTranslitInput;
+static const UnicodeString *gTranslitExpected;
+
+class BreakTranslitThread: public SimpleThread {
+  public:
+    BreakTranslitThread() {};
+    ~BreakTranslitThread() {};
+    void run();
+};
+
+void BreakTranslitThread::run() {
+    for (int i=0; i<10; i++) {
+        icu::UnicodeString s(*gTranslitInput);
+        gSharedTransliterator->transliterate(s);
+        if (*gTranslitExpected != s) {
+            IntlTest::gTest->errln("%s:%d Transliteration threading failure.", __FILE__, __LINE__);
+            break;
+        }
+    }
+}
+
+void MultithreadTest::TestBreakTranslit() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString input(
+        "\\u0E42\\u0E14\\u0E22\\u0E1E\\u0E37\\u0E49\\u0E19\\u0E10\\u0E32\\u0E19\\u0E41\\u0E25\\u0E49\\u0E27,");
+    input = input.unescape();
+    gTranslitInput = &input;
+
+    gSharedTransliterator = Transliterator::createInstance(
+        UNICODE_STRING_SIMPLE("Any-Latin; Lower; NFD; [:Diacritic:]Remove; NFC; Latin-ASCII;"), UTRANS_FORWARD, status);
+    if (!gSharedTransliterator) {
+         return;
+     }
+    TSMTHREAD_ASSERT_SUCCESS(status); 
+
+    UnicodeString expected(*gTranslitInput);
+    gSharedTransliterator->transliterate(expected);
+    gTranslitExpected = &expected;
+
+    BreakTranslitThread threads[4];
+    for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
+        threads[i].start();
+    }
+    for (int i=0; i<UPRV_LENGTHOF(threads); ++i) {
+        threads[i].join();
+    }
+
+    delete gSharedTransliterator;
+    gTranslitInput = NULL;
+    gTranslitExpected = NULL;
+}
+
+#endif /* !UCONFIG_NO_TRANSLITERATION */