ICU-461.12.tar.gz

[apple/icu.git] / icuSources / test / intltest / tscoll.cpp

diff --git a/icuSources/test/intltest/tscoll.cpp b/icuSources/test/intltest/tscoll.cpp
index eb7bb04fa7ab7e2f6870c0dc4ea22f5a1550d23b..3644e4a3a1eb7e4902781483109727dd2cdf777d 100644 (file)
--- a/icuSources/test/intltest/tscoll.cpp
+++ b/icuSources/test/intltest/tscoll.cpp
@@ -1,6 +1,6 @@
 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2005, International Business Machines Corporation and
+ * Copyright (c) 1997-2009, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
@@ -19,6 +19,7 @@
 
 #if !UCONFIG_NO_COLLATION
 
+#include "unicode/localpointer.h"
 #include "unicode/uchar.h"
 #include "unicode/ustring.h"
 
@@ -42,12 +43,16 @@
 #include "normconf.h"
 #include "thcoll.h"
 #include "srchtest.h"
+#include "ssearch.h"
 #include "cntabcol.h"
 #include "lcukocol.h"
 #include "ucaconf.h"
 #include "svccoll.h"
 #include "cmemory.h"
-#include "rndmcoll.h"
+//#include "rndmcoll.h"
+
+// Set to 1 to test offsets in backAndForth()
+#define TEST_OFFSETS 0
 
 #define TESTCLASS(n,classname)        \
     case n:                           \
@@ -84,11 +89,14 @@ void IntlTestCollator::runIndexedTest( int32_t index, UBool exec, const char* &n
       TESTCLASS(14, LotusCollationKoreanTest);
       TESTCLASS(15, StringSearchTest);
       TESTCLASS(16, ContractionTableTest);
+#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
       TESTCLASS(17, DataDrivenCollatorTest);
+#endif
       TESTCLASS(18, UCAConformanceTest);
       TESTCLASS(19, CollationServiceTest);
       TESTCLASS(20, CollationFinnishTest); // removed by weiv - we have changed Finnish collation
-      TESTCLASS(21, RandomCollatorTest);
+      //TESTCLASS(21, RandomCollatorTest); // See ticket 5747 about reenabling this test.
+      TESTCLASS(21, SSearchTest);
 
       default: name = ""; break;
     }
@@ -154,7 +162,7 @@ IntlTestCollator::doTestVariant(Collator* col, const UnicodeString &source, cons
     const UChar* trg = target.getBuffer();
     UCollationResult compareResultIter = (UCollationResult)result;
 
-    if(1) {
+    {
       UCharIterator sIter, tIter;
       uiter_setString(&sIter, src, sLen);
       uiter_setString(&tIter, trg, tLen);
@@ -202,7 +210,7 @@ IntlTestCollator::doTestVariant(Collator* col, const UnicodeString &source, cons
     }
 
     /* testing the partial sortkeys */
-    if(1) { /*!QUICK*/
+    { /*!QUICK*/
       int32_t partialSizes[] = { 3, 1, 2, 4, 8, 20, 80 }; /* just size 3 in the quick mode */
       int32_t partialSizesSize = 1;
       if(!quick) {
@@ -258,13 +266,12 @@ IntlTestCollator::doTest(Collator* col, const UnicodeString &source, const Unico
     }
 
     UErrorCode status = U_ZERO_ERROR;
-    CollationElementIterator* c = ((RuleBasedCollator *)col)->createCollationElementIterator( source );
+    LocalPointer<CollationElementIterator> c(((RuleBasedCollator *)col)->createCollationElementIterator(source));
     logln("Testing iterating source: "+source);
     backAndForth(*c);
     c->setText(target, status);
     logln("Testing iterating target: "+target);
     backAndForth(*c);
-    delete c;
   }
 }
 
@@ -379,8 +386,10 @@ UnicodeString &IntlTestCollator::prettify(const CollationKey &source, UnicodeStr
 
     for (i = 0; i < byteCount; i += 1)
     {
+        if (i != 0) {
+            target += " ";
+        }
         appendHex(bytes[i], 2, target);
-        target += " ";
     }
 
     target += "]";
@@ -392,7 +401,7 @@ void IntlTestCollator::backAndForth(CollationElementIterator &iter)
 {
     // Run through the iterator forwards and stick it into an array
     int32_t orderLength = 0;
-    int32_t *orders = getOrders(iter, orderLength);
+    LocalArray<Order> orders(getOrders(iter, orderLength));
     UErrorCode status = U_ZERO_ERROR;
 
     // Now go through it backwards and make sure we get the same values
@@ -404,6 +413,8 @@ void IntlTestCollator::backAndForth(CollationElementIterator &iter)
 
     while ((o = iter.previous(status)) != CollationElementIterator::NULLORDER)
     {
+        /*int32_t offset = */iter.getOffset();
+
         if (index == 0) {
           if(o == 0) {
             continue;
@@ -411,28 +422,39 @@ void IntlTestCollator::backAndForth(CollationElementIterator &iter)
             // going backwards
             errln("Backward iteration returned a non ignorable after orders are exhausted");
             break;
+          }
         }
-        }
-        if (o != orders[--index])
-        {
+
+        index -= 1;
+        if (o != orders[index].order) {
             if (o == 0)
-                index ++;
-            else
-            {
-                while (index > 0 && orders[--index] == 0)
-                {
+                index += 1;
+            else {
+                while (index > 0 && orders[--index].order == 0) {
+                  // nothing...
                 }
-                if (o != orders[index])
-                {
-            errln("Mismatch at index %d: 0x%X vs 0x%X", index,
-                  orders[index], o);
-                    break;
+
+                if (o != orders[index].order) {
+                    errln("Mismatched order at index %d: 0x%0:8X vs. 0x%0:8X", index,
+                    orders[index].order, o);
+                //break;
+                  return;
                 }
             }
         }
+
+#if TEST_OFFSETS
+        if (offset != orders[index].offset) {
+          errln("Mismatched offset at index %d: %d vs. %d", index,
+            orders[index].offset, offset);
+       //break;
+         return;
+        }
+#endif
+
     }
 
-    while (index != 0 && orders[index - 1] == 0)
+    while (index != 0 && orders[index - 1].order == 0)
     {
       index --;
     }
@@ -465,8 +487,6 @@ void IntlTestCollator::backAndForth(CollationElementIterator &iter)
         }
         errln("");
     }
-
-    delete[] orders;
 }
 
 
@@ -474,12 +494,13 @@ void IntlTestCollator::backAndForth(CollationElementIterator &iter)
  * Return an integer array containing all of the collation orders
  * returned by calls to next on the specified iterator
  */
-int32_t *IntlTestCollator::getOrders(CollationElementIterator &iter, int32_t &orderLength)
+IntlTestCollator::Order *IntlTestCollator::getOrders(CollationElementIterator &iter, int32_t &orderLength)
 {
     int32_t maxSize = 100;
     int32_t size = 0;
-    int32_t *orders = new int32_t[maxSize];
+    LocalArray<Order> orders(new Order[maxSize]);
     UErrorCode status = U_ZERO_ERROR;
+    int32_t offset = iter.getOffset();
 
     int32_t order;
     while ((order = iter.next(status)) != CollationElementIterator::NULLORDER)
@@ -487,27 +508,29 @@ int32_t *IntlTestCollator::getOrders(CollationElementIterator &iter, int32_t &or
         if (size == maxSize)
         {
             maxSize *= 2;
-            int32_t *temp = new int32_t[maxSize];
+            Order *temp = new Order[maxSize];
 
-            uprv_memcpy(temp, orders, size * sizeof(int32_t));
-            delete[] orders;
-            orders = temp;
+            uprv_memcpy(temp, orders.getAlias(), size * sizeof(Order));
+            orders.adoptInstead(temp);
         }
 
-        orders[size++] = order;
+        orders[size].order  = order;
+        orders[size].offset = offset;
+
+        offset = iter.getOffset();
+        size += 1;
     }
 
     if (maxSize > size)
     {
-        int32_t *temp = new int32_t[size];
+        Order *temp = new Order[size];
 
-        uprv_memcpy(temp, orders, size * sizeof(int32_t));
-        delete[] orders;
-        orders = temp;
+        uprv_memcpy(temp, orders.getAlias(), size * sizeof(Order));
+        orders.adoptInstead(temp);
     }
 
     orderLength = size;
-    return orders;
+    return orders.orphan();
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */