Update ICU to 54.1 step 1

source/test/intltest/itercoll.cpp

 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 1997-2009, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_COLLATION
 
 #include "unicode/coll.h"
 #include "unicode/tblcoll.h"
 #include "unicode/unistr.h"
@@ skipping 155 matching lines @@
 
 /**
  * Test for getOffset() and setOffset()
  */
 void CollationIteratorTest::TestOffset(/* char* par */)
 {
     CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
     UErrorCode status = U_ZERO_ERROR;
     // testing boundaries
     iter->setOffset(0, status);
-    if (U_FAILURE(status) || iter->previous(status) != UCOL_NULLORDER) {
+    if (U_FAILURE(status) || iter->previous(status) != CollationElementIterator::NULLORDER) {
         errln("Error: After setting offset to 0, we should be at the end "
                 "of the backwards iteration");
     }
     iter->setOffset(test1.length(), status);
-    if (U_FAILURE(status) || iter->next(status) != UCOL_NULLORDER) {
+    if (U_FAILURE(status) || iter->next(status) != CollationElementIterator::NULLORDER) {
         errln("Error: After setting offset to end of the string, we should "
                 "be at the end of the backwards iteration");
     }
 
     // Run all the way through the iterator, then get the offset
     int32_t orderLength = 0;
     Order *orders = getOrders(*iter, orderLength);
 
     int32_t offset = iter->getOffset();
 
@@ skipping 12 matching lines @@
 
     if (U_FAILURE(status))
     {
         errln("setOffset failed.");
     }
     else
     {
         assertEqual(*iter, *pristine);
     }
 
-    // TODO: try iterating halfway through a messy string.
-
     delete pristine;
     delete[] orders;
     delete iter;
+
+    // setting offset in the middle of a contraction
+    UnicodeString contraction = "change";
+    status = U_ZERO_ERROR;
+    RuleBasedCollator tailored("& a < ch", status);
+    if (U_FAILURE(status)) {
+        errln("Error: in creation of Spanish collator - %s", u_errorName(status));
+        return;
+    }
+    iter = tailored.createCollationElementIterator(contraction);
+    Order *order = getOrders(*iter, orderLength);
+    iter->setOffset(1, status); // sets offset in the middle of ch
+    int32_t order2Length = 0;
+    Order *order2 = getOrders(*iter, order2Length);
+    if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
+        errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
+    }
+    delete[] order;
+    delete[] order2;
+    delete iter;
+    contraction = "peache";
+    iter = tailored.createCollationElementIterator(contraction);
+    iter->setOffset(3, status);
+    order = getOrders(*iter, orderLength);
+    iter->setOffset(4, status); // sets offset in the middle of ch
+    order2 = getOrders(*iter, order2Length);
+    if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
+        errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
+    }
+    delete[] order;
+    delete[] order2;
+    delete iter;
+    // setting offset in the middle of a surrogate pair
+    UnicodeString surrogate = UNICODE_STRING_SIMPLE("\\ud800\\udc00str").unescape();
+    iter = tailored.createCollationElementIterator(surrogate);
+    order = getOrders(*iter, orderLength);
+    iter->setOffset(1, status); // sets offset in the middle of surrogate
+    order2 = getOrders(*iter, order2Length);
+    if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
+        errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
+    }
+    delete[] order;
+    delete[] order2;
+    delete iter;
+    surrogate = UNICODE_STRING_SIMPLE("simple\\ud800\\udc00str").unescape();
+    iter = tailored.createCollationElementIterator(surrogate);
+    iter->setOffset(6, status);
+    order = getOrders(*iter, orderLength);
+    iter->setOffset(7, status); // sets offset in the middle of surrogate
+    order2 = getOrders(*iter, order2Length);
+    if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
+        errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
+    }
+    delete[] order;
+    delete[] order2;
+    delete iter;
+    // TODO: try iterating halfway through a messy string.
 }
 
 /**
  * Test for setText()
  */
 void CollationIteratorTest::TestSetText(/* char* par */)
 {
     CollationElementIterator *iter1 = en_us->createCollationElementIterator(test1);
     CollationElementIterator *iter2 = en_us->createCollationElementIterator(test2);
     UErrorCode status = U_ZERO_ERROR;
@@ skipping 35 matching lines @@
     }
     else
     {
         assertEqual(*iter1, *iter2);
     }
    
     // test for an empty string
     UnicodeString empty("");
     iter1->setText(empty, status);
     if (U_FAILURE(status) 
-        || iter1->next(status) != (int32_t)UCOL_NULLORDER) {
+        || iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
         errln("Empty string should have no CEs.");
     }
     ((StringCharacterIterator *)chariter)->setText(empty);
     iter1->setText(*chariter, status);
     if (U_FAILURE(status) 
-        || iter1->next(status) != (int32_t)UCOL_NULLORDER) {
+        || iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
         errln("Empty string should have no CEs.");
     }
     delete chariter;
     delete iter2;
     delete iter1;
 }
 
 /** @bug 4108762
  * Test for getMaxExpansion()
  */
@@ skipping 13 matching lines @@
         ch ++;
         UnicodeString str(ch);
         iter->setText(str, status);
         order = iter->previous(status);
 
         /* thai management */
         if (CollationElementIterator::isIgnorable(order))
             order = iter->previous(status);
 
         while (U_SUCCESS(status)
-            && iter->previous(status) != (int32_t)UCOL_NULLORDER)
+            && iter->previous(status) != (int32_t)CollationElementIterator::NULLORDER)
         {
             count ++; 
         }
 
         if (U_FAILURE(status) && iter->getMaxExpansion(order) < count) {
             errln("Failure at codepoint %d, maximum expansion count < %d\n",
                 ch, count);
         }
     }
 
@@ skipping 186 matching lines @@
 
     // tests empty strings
     UnicodeString empty("");
     iter1 = coll->createCollationElementIterator(empty);
     chariter.setText(empty);
     iter2 = coll->createCollationElementIterator(chariter);
     if (*iter1 != *iter1 || *iter2 != *iter2 || *iter1 != *iter2 
         || *iter2 != *iter1) {
         errln("CollationElementIterators constructed with the same string data should be the same at the start");
     } 
-    if (iter1->next(status) != (int32_t)UCOL_NULLORDER) {
+    if (iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
         errln("Empty string should have no CEs.");
     }
-    if (iter2->next(status) != (int32_t)UCOL_NULLORDER) {
+    if (iter2->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
         errln("Empty string should have no CEs.");
     }
     delete iter1;
     delete iter2;
     delete coll;
 }
 
 /**
  * Testing the strength order
  */
@@ skipping 100 matching lines @@
           case  8: name = "TestStrengthOrder"; if (exec) TestStrengthOrder(/* par */); break;
           default: name = ""; break;
       }
     } else {
       dataerrln("Class iterator not instantiated");
       name = "";
     }
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */