Update ICU to 54.1 step 1

source/test/intltest/citrtest.cpp

 /****************************************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2012, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  * Modification History:
  *
  *   Date          Name        Description
  *   05/22/2000    Madhu       Added tests for testing new API for utf16 support and more
  ****************************************************************************************/
 
 #include <string.h>
 #include "utypeinfo.h"  // for 'typeid' to work
 
 #include "unicode/chariter.h"
 #include "unicode/ustring.h"
 #include "unicode/unistr.h"
 #include "unicode/schriter.h"
 #include "unicode/uchriter.h"
 #include "unicode/uiter.h"
 #include "unicode/putil.h"
 #include "unicode/utf16.h"
 #include "citrtest.h"
+#include "cmemory.h"
 
 
 class  SCharacterIterator : public CharacterIterator {
 public:
     SCharacterIterator(const UnicodeString& textStr){
         text = textStr;
         pos=0;
         textLength = textStr.length();
         begin = 0;
         end=textLength;
@@ skipping 99 matching lines @@
      return *this;
   }
 
 
 private:
     UnicodeString text;
     static const char fgClassID;
 };
 const char SCharacterIterator::fgClassID=0;
 
-#define LENGTHOF(array) ((int32_t)(sizeof(array)/sizeof((array)[0])))
-
 CharIterTest::CharIterTest()
 {
 }
 void CharIterTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
 {
     if (exec) logln("TestSuite CharIterTest: ");
     switch (index) {
         case 0: name = "TestConstructionAndEquality"; if (exec) TestConstructionAndEquality(); break;
         case 1: name = "TestConstructionAndEqualityUChariter"; if (exec) TestConstructionAndEqualityUChariter(); break;
         case 2: name = "TestIteration"; if (exec) TestIteration(); break;
@@ skipping 806 matching lines @@
         errln("error: uiter_getState did not return UITER_NO_STATE on bad input");
     }
 }
 
 // subclass test, and completing API coverage -------------------------------
 
 class SubCharIter : public CharacterIterator {
 public:
     // public default constructor, to get coverage of CharacterIterator()
     SubCharIter() : CharacterIterator() {
-        textLength=end=LENGTHOF(s);
+        textLength=end=UPRV_LENGTHOF(s);
         s[0]=0x61;      // 'a'
         s[1]=0xd900;    // U+50400
         s[2]=0xdd00;
         s[3]=0x2029;    // PS
     }
 
     // useful stuff, mostly dummy but testing coverage and subclassability
     virtual UChar nextPostInc() {
-        if(pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s)) {
             return s[pos++];
         } else {
             return DONE;
         }
     }
 
     virtual UChar32 next32PostInc() {
-        if(pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s)) {
             UChar32 c;
-            U16_NEXT(s, pos, LENGTHOF(s), c);
+            U16_NEXT(s, pos, UPRV_LENGTHOF(s), c);
             return c;
         } else {
             return DONE;
         }
     }
 
     virtual UBool hasNext() {
-        return pos<LENGTHOF(s);
+        return pos<UPRV_LENGTHOF(s);
     }
 
     virtual UChar first() {
         pos=0;
         return s[0];
     }
 
     virtual UChar32 first32() {
         UChar32 c;
         pos=0;
-        U16_NEXT(s, pos, LENGTHOF(s), c);
+        U16_NEXT(s, pos, UPRV_LENGTHOF(s), c);
         pos=0;
         return c;
     }
 
     virtual UChar setIndex(int32_t position) {
-        if(0<=position && position<=LENGTHOF(s)) {
+        if(0<=position && position<=UPRV_LENGTHOF(s)) {
             pos=position;
-            if(pos<LENGTHOF(s)) {
+            if(pos<UPRV_LENGTHOF(s)) {
                 return s[pos];
             }
         }
         return DONE;
     }
 
     virtual UChar32 setIndex32(int32_t position) {
-        if(0<=position && position<=LENGTHOF(s)) {
+        if(0<=position && position<=UPRV_LENGTHOF(s)) {
             pos=position;
-            if(pos<LENGTHOF(s)) {
+            if(pos<UPRV_LENGTHOF(s)) {
                 UChar32 c;
-                U16_GET(s, 0, pos, LENGTHOF(s), c);
+                U16_GET(s, 0, pos, UPRV_LENGTHOF(s), c);
                 return c;
             }
         }
         return DONE;
     }
 
     virtual UChar current() const {
-        if(pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s)) {
             return s[pos];
         } else {
             return DONE;
         }
     }
 
     virtual UChar32 current32() const {
-        if(pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s)) {
             UChar32 c;
-            U16_GET(s, 0, pos, LENGTHOF(s), c);
+            U16_GET(s, 0, pos, UPRV_LENGTHOF(s), c);
             return c;
         } else {
             return DONE;
         }
     }
 
     virtual UChar next() {
-        if(pos<LENGTHOF(s) && ++pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s) && ++pos<UPRV_LENGTHOF(s)) {
             return s[pos];
         } else {
             return DONE;
         }
     }
 
     virtual UChar32 next32() {
-        if(pos<LENGTHOF(s)) {
-            U16_FWD_1(s, pos, LENGTHOF(s));
+        if(pos<UPRV_LENGTHOF(s)) {
+            U16_FWD_1(s, pos, UPRV_LENGTHOF(s));
         }
-        if(pos<LENGTHOF(s)) {
+        if(pos<UPRV_LENGTHOF(s)) {
             UChar32 c;
             int32_t i=pos;
-            U16_NEXT(s, i, LENGTHOF(s), c);
+            U16_NEXT(s, i, UPRV_LENGTHOF(s), c);
             return c;
         } else {
             return DONE;
         }
     }
 
     virtual UBool hasPrevious() {
         return pos>0;
     }
 
     virtual void getText(UnicodeString &result) {
-        result.setTo(s, LENGTHOF(s));
+        result.setTo(s, UPRV_LENGTHOF(s));
     }
 
     // dummy implementations of other pure virtual base class functions
     virtual UBool operator==(const ForwardCharacterIterator &that) const {
         return
             this==&that ||
             (typeid(*this)==typeid(that) && pos==((SubCharIter &)that).pos);
     }
 
     virtual int32_t hashCode() const {
@@ skipping 88 matching lines @@
     if(sci.firstPostInc()!=0x61) {
         errln("SubStringCharIter.firstPostInc() failed\n");
     }
 
     // coverage: UCharCharacterIterator default constructor
     SubUCharCharIter uci;
     if(uci.firstPostInc()!=0x61) {
         errln("SubUCharCharIter.firstPostInc() failed\n");
     }
 }