Update ICU to 54.1 step 1

source/test/cintltst/utf8tst.c

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1998-2012, International Business Machines Corporation and
+ * Copyright (c) 1998-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*
 * File utf8tst.c
 *
 * Modification History:
 *
 *   Date          Name        Description
 *   07/24/2000    Madhu       Creation
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 #include "unicode/utf8.h"
 #include "cmemory.h"
 #include "cintltst.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 /* lenient UTF-8 ------------------------------------------------------------ */
 
 /*
  * Lenient UTF-8 differs from conformant UTF-8 in that it allows surrogate
  * code points with their "natural" encoding.
  * Effectively, this allows a mix of UTF-8 and CESU-8 as well as encodings of
  * single surrogates.
  *
  * This is not conformant with UTF-8.
  *
@@ skipping 61 matching lines @@
     addTest(root, &TestAppendChar,              "utf8tst/TestAppendChar");
     addTest(root, &TestAppend,                  "utf8tst/TestAppend");
     addTest(root, &TestSurrogates,              "utf8tst/TestSurrogates");
 }
 
 static void TestCodeUnitValues()
 {
     static const uint8_t codeunit[]={0x00, 0x65, 0x7e, 0x7f, 0xc0, 0xc4, 0xf0, 0xfd, 0x80, 0x81, 0xbc, 0xbe,};
 
     int16_t i;
-    for(i=0; i<LENGTHOF(codeunit); i++){
+    for(i=0; i<UPRV_LENGTHOF(codeunit); i++){
         uint8_t c=codeunit[i];
         log_verbose("Testing code unit value of %x\n", c);
         if(i<4){
             if(!UTF8_IS_SINGLE(c) || UTF8_IS_LEAD(c) || UTF8_IS_TRAIL(c) || !U8_IS_SINGLE(c) || U8_IS_LEAD(c) || U8_IS_TRAIL(c)){
                 log_err("ERROR: 0x%02x is a single byte but results in single: %c lead: %c trail: %c\n",
                     c, UTF8_IS_SINGLE(c) ? 'y' : 'n', UTF8_IS_LEAD(c) ? 'y' : 'n', UTF8_IS_TRAIL(c) ? 'y' : 'n');
             }
         } else if(i< 8){
             if(!UTF8_IS_LEAD(c) || UTF8_IS_SINGLE(c) || UTF8_IS_TRAIL(c) || !U8_IS_LEAD(c) || U8_IS_SINGLE(c) || U8_IS_TRAIL(c)){
                 log_err("ERROR: 0x%02x is a lead byte but results in single: %c lead: %c trail: %c\n",
@@ skipping 22 matching lines @@
         4, 0x24506,
         4, 0x20402,
         4, 0x10402,
         3, 0xd7ff,
         3, 0xe000,
 
     };
 
     int16_t i;
     UBool multiple;
-    for(i=0; i<LENGTHOF(codepoint); i=(int16_t)(i+2)){
+    for(i=0; i<UPRV_LENGTHOF(codepoint); i=(int16_t)(i+2)){
         UChar32 c=codepoint[i+1];
         if(UTF8_CHAR_LENGTH(c) != (uint16_t)codepoint[i] || U8_LENGTH(c) != (uint16_t)codepoint[i]){
               log_err("The no: of code units for %lx:- Expected: %d Got: %d\n", c, codepoint[i], UTF8_CHAR_LENGTH(c));
         }else{
               log_verbose("The no: of code units for %lx is %d\n",c, UTF8_CHAR_LENGTH(c));
         }
         multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE);
         if(UTF8_NEED_MULTIPLE_UCHAR(c) != multiple){
               log_err("ERROR: UTF8_NEED_MULTIPLE_UCHAR failed for %lx\n", c);
         }
@@ skipping 377 matching lines @@
         }
     }
     for(i=0, offset=0; offset<sizeof(input); ++i) {
         U8_NEXT_UNSAFE(input, offset, c);
         if(c != codePoints[i]){
             log_err("ERROR: U8_NEXT_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n",
                     offset, codePoints[i], c);
         }
     }
 
-    for(i=LENGTHOF(codePoints)-1, offset=sizeof(input); offset > 0; --i){
+    for(i=UPRV_LENGTHOF(codePoints)-1, offset=sizeof(input); offset > 0; --i){
          UTF8_PREV_CHAR_UNSAFE(input, offset, c);
          if(c != codePoints[i]){
              log_err("ERROR: UTF8_PREV_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n",
                      offset, codePoints[i], c);
          }
     }
-    for(i=LENGTHOF(codePoints)-1, offset=sizeof(input); offset > 0; --i){
+    for(i=UPRV_LENGTHOF(codePoints)-1, offset=sizeof(input); offset > 0; --i){
          U8_PREV_UNSAFE(input, offset, c);
          if(c != codePoints[i]){
              log_err("ERROR: U8_PREV_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n",
                      offset, codePoints[i], c);
          }
     }
 }
 
 static void TestFwdBack() {
     static const uint8_t input[]={0x61, 0xF0, 0x90, 0x90, 0x81, 0xff, 0x62, 0xc0, 0x80, 0x7f, 0x8f, 0xc0, 0x63, 0x81, 0x90, 0x90, 0xF0, 0x00};
@@ skipping 38 matching lines @@
     offsafe=sizeof(input);
     while(offsafe > 0){
         U8_BACK_1(input, 0,  offsafe);
         if(offsafe != back_safe[i]){
             log_err("ERROR: U8_BACK_1 offset expected:%d, Got:%d\n", back_safe[i], offsafe);
         }
         i++;
     }
 
     offsafe=0;
-    for(i=0; i<LENGTHOF(Nvalue); i++){
+    for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         UTF8_FWD_N_SAFE(input, offsafe, sizeof(input), Nvalue[i]);
         if(offsafe != fwd_N_safe[i]){
             log_err("ERROR: Forward_N_safe offset=%d expected:%d, Got:%d\n", i, fwd_N_safe[i], offsafe);
         }
 
     }
 
     offsafe=0;
-    for(i=0; i<LENGTHOF(Nvalue); i++){
+    for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         U8_FWD_N(input, offsafe, sizeof(input), Nvalue[i]);
         if(offsafe != fwd_N_safe[i]){
             log_err("ERROR: U8_FWD_N offset=%d expected:%d, Got:%d\n", i, fwd_N_safe[i], offsafe);
         }
 
     }
 
     offsafe=sizeof(input);
-    for(i=0; i<LENGTHOF(Nvalue); i++){
+    for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         UTF8_BACK_N_SAFE(input, 0, offsafe, Nvalue[i]);
         if(offsafe != back_N_safe[i]){
             log_err("ERROR: backward_N_safe offset=%d expected:%d, Got:%ld\n", i, back_N_safe[i], offsafe);
         }
     }
 
     offsafe=sizeof(input);
-    for(i=0; i<LENGTHOF(Nvalue); i++){
+    for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         U8_BACK_N(input, 0, offsafe, Nvalue[i]);
         if(offsafe != back_N_safe[i]){
             log_err("ERROR: U8_BACK_N offset=%d expected:%d, Got:%ld\n", i, back_N_safe[i], offsafe);
         }
     }
 }
 
 static void TestFwdBackUnsafe() {
     /*
      * Use a (mostly) well-formed UTF-8 string and test at code point boundaries.
      * The behavior of _UNSAFE macros for ill-formed strings is undefined.
      */
     static const uint8_t input[]={
         0x61,
         0xf0, 0x90, 0x90, 0x81,
         0xc0, 0x80,  /* non-shortest form */
         0xe2, 0x82, 0xac,
         0xc2, 0xa1,
         0xf4, 0x8f, 0xbf, 0xbf,
         0x00
     };
     static const int8_t boundaries[]={ 0, 1, 5, 7, 10, 12, 16, 17 };
 
     int32_t offset;
     int32_t i;
-    for(i=1, offset=0; offset<LENGTHOF(input); ++i) {
+    for(i=1, offset=0; offset<UPRV_LENGTHOF(input); ++i) {
         UTF8_FWD_1_UNSAFE(input, offset);
         if(offset != boundaries[i]){
             log_err("ERROR: UTF8_FWD_1_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
-    for(i=1, offset=0; offset<LENGTHOF(input); ++i) {
+    for(i=1, offset=0; offset<UPRV_LENGTHOF(input); ++i) {
         U8_FWD_1_UNSAFE(input, offset);
         if(offset != boundaries[i]){
             log_err("ERROR: U8_FWD_1_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
 
-    for(i=LENGTHOF(boundaries)-2, offset=LENGTHOF(input); offset>0; --i) {
+    for(i=UPRV_LENGTHOF(boundaries)-2, offset=UPRV_LENGTHOF(input); offset>0; --i) {
         UTF8_BACK_1_UNSAFE(input, offset);
         if(offset != boundaries[i]){
             log_err("ERROR: UTF8_BACK_1_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
-    for(i=LENGTHOF(boundaries)-2, offset=LENGTHOF(input); offset>0; --i) {
+    for(i=UPRV_LENGTHOF(boundaries)-2, offset=UPRV_LENGTHOF(input); offset>0; --i) {
         U8_BACK_1_UNSAFE(input, offset);
         if(offset != boundaries[i]){
             log_err("ERROR: U8_BACK_1_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
 
-    for(i=0; i<LENGTHOF(boundaries); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(boundaries); ++i) {
         offset=0;
         UTF8_FWD_N_UNSAFE(input, offset, i);
         if(offset != boundaries[i]) {
             log_err("ERROR: UTF8_FWD_N_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
-    for(i=0; i<LENGTHOF(boundaries); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(boundaries); ++i) {
         offset=0;
         U8_FWD_N_UNSAFE(input, offset, i);
         if(offset != boundaries[i]) {
             log_err("ERROR: U8_FWD_N_UNSAFE offset expected:%d, Got:%d\n", boundaries[i], offset);
         }
     }
 
-    for(i=0; i<LENGTHOF(boundaries); ++i) {
-        int32_t j=LENGTHOF(boundaries)-1-i;
-        offset=LENGTHOF(input);
+    for(i=0; i<UPRV_LENGTHOF(boundaries); ++i) {
+        int32_t j=UPRV_LENGTHOF(boundaries)-1-i;
+        offset=UPRV_LENGTHOF(input);
         UTF8_BACK_N_UNSAFE(input, offset, i);
         if(offset != boundaries[j]) {
             log_err("ERROR: UTF8_BACK_N_UNSAFE offset expected:%d, Got:%d\n", boundaries[j], offset);
         }
     }
-    for(i=0; i<LENGTHOF(boundaries); ++i) {
-        int32_t j=LENGTHOF(boundaries)-1-i;
-        offset=LENGTHOF(input);
+    for(i=0; i<UPRV_LENGTHOF(boundaries); ++i) {
+        int32_t j=UPRV_LENGTHOF(boundaries)-1-i;
+        offset=UPRV_LENGTHOF(input);
         U8_BACK_N_UNSAFE(input, offset, i);
         if(offset != boundaries[j]) {
             log_err("ERROR: U8_BACK_N_UNSAFE offset expected:%d, Got:%d\n", boundaries[j], offset);
         }
     }
 }
 
 static void TestSetChar() {
     static const uint8_t input[]
         = {0x61, 0xe4, 0xba, 0x8c, 0x7f, 0xfe, 0x62, 0xc5, 0x7f, 0x61, 0x80, 0x80, 0xe0, 0x00 };
     static const int16_t start_safe[]
         = {0,    1,    1,    1,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,  14 };
     static const int16_t limit_safe[]
         = {0,    1,    4,    4,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,  14 };
 
     uint32_t i=0;
     int32_t offset=0, setOffset=0;
-    for(offset=0; offset<=LENGTHOF(input); offset++){
-        if (offset<LENGTHOF(input)){
+    for(offset=0; offset<=UPRV_LENGTHOF(input); offset++){
+        if (offset<UPRV_LENGTHOF(input)){
             setOffset=offset;
             UTF8_SET_CHAR_START_SAFE(input, 0, setOffset);
             if(setOffset != start_safe[i]){
                 log_err("ERROR: UTF8_SET_CHAR_START_SAFE failed for offset=%ld. Expected:%ld Got:%ld\n", offset, start_safe[i], setOffset);
             }
 
             setOffset=offset;
             U8_SET_CP_START(input, 0, setOffset);
             if(setOffset != start_safe[i]){
                 log_err("ERROR: U8_SET_CP_START failed for offset=%ld. Expected:%ld Got:%ld\n", offset, start_safe[i], setOffset);
@@ skipping 19 matching lines @@
 static void TestSetCharUnsafe() {
     static const uint8_t input[]
         = {0x61, 0xe4, 0xba, 0x8c, 0x7f, 0x2e, 0x62, 0xc5, 0x7f, 0x61, 0x80, 0x80, 0xe0, 0x80, 0x80, 0x00 };
     static const int16_t start_unsafe[]
         = {0,    1,    1,    1,    4,    5,    6,    7,    8,    9,    9,    9,    12,   12,   12,   15 };
     static const int16_t limit_unsafe[]
         = {0,    1,    4,    4,    4,    5,    6,    7,    9,    9,    10,   10,   10,   15,   15,   15,   16 };
 
     uint32_t i=0;
     int32_t offset=0, setOffset=0;
-    for(offset=0; offset<=LENGTHOF(input); offset++){
-        if (offset<LENGTHOF(input)){
+    for(offset=0; offset<=UPRV_LENGTHOF(input); offset++){
+        if (offset<UPRV_LENGTHOF(input)){
             setOffset=offset;
             UTF8_SET_CHAR_START_UNSAFE(input, setOffset);
             if(setOffset != start_unsafe[i]){
                 log_err("ERROR: UTF8_SET_CHAR_START_UNSAFE failed for offset=%ld. Expected:%ld Got:%ld\n", offset, start_unsafe[i], setOffset);
             }
 
             setOffset=offset;
             U8_SET_CP_START_UNSAFE(input, setOffset);
             if(setOffset != start_unsafe[i]){
                 log_err("ERROR: U8_SET_CP_START_UNSAFE failed for offset=%ld. Expected:%ld Got:%ld\n", offset, start_unsafe[i], setOffset);
@@ skipping 119 matching lines @@
         {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0xc2, 0x81, 0x69, 0x6a, 0x00},
         {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0xc2, 0xbf, 0x69, 0x6a, 0x00},
 
         {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0xc3, 0xbe, 0x6a, 0x00},
 
     };
     uint16_t i, count=0;
     uint8_t str[12];
     uint32_t offset;
 /*    UChar32 c=0;*/
-    uint16_t size=LENGTHOF(s);
-    for(i=0; i<LENGTHOF(test); i=(uint16_t)(i+2)){
+    uint16_t size=UPRV_LENGTHOF(s);
+    for(i=0; i<UPRV_LENGTHOF(test); i=(uint16_t)(i+2)){
         uprv_memcpy(str, s, size);
         offset=test[i];
         if(count<13){
             UTF8_APPEND_CHAR_UNSAFE(str, offset, test[i+1]);
             if(offset != movedOffset[count]){
                 log_err("ERROR: UTF8_APPEND_CHAR_UNSAFE failed to move the offset correctly for count=%d.\nExpectedOffset=%d  currentOffset=%d\n",
                     count, movedOffset[count], offset);
 
             }
             if(uprv_memcmp(str, result[count], size) !=0){
@@ skipping 70 matching lines @@
         /* none from this line */
         0,  0xd0, 0x80
     };
 
     uint8_t buffer[100];
     UChar32 c;
     int32_t i, length;
     UBool isError, expectIsError, wrongIsError;
 
     length=0;
-    for(i=0; i<LENGTHOF(codePoints); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(codePoints); ++i) {
         c=codePoints[i];
         if(c<0 || 0x10ffff<c) {
             continue; /* skip non-code points for U8_APPEND_UNSAFE */
         }
 
         U8_APPEND_UNSAFE(buffer, length, c);
     }
-    if(length!=LENGTHOF(expectUnsafe) || 0!=memcmp(buffer, expectUnsafe, length)) {
+    if(length!=UPRV_LENGTHOF(expectUnsafe) || 0!=memcmp(buffer, expectUnsafe, length)) {
         log_err("U8_APPEND_UNSAFE did not generate the expected output\n");
     }
 
     length=0;
     wrongIsError=FALSE;
-    for(i=0; i<LENGTHOF(codePoints); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(codePoints); ++i) {
         c=codePoints[i];
         expectIsError= c<0 || 0x10ffff<c || U_IS_SURROGATE(c);
         isError=FALSE;
 
-        U8_APPEND(buffer, length, LENGTHOF(buffer), c, isError);
+        U8_APPEND(buffer, length, UPRV_LENGTHOF(buffer), c, isError);
         wrongIsError|= isError!=expectIsError;
     }
     if(wrongIsError) {
         log_err("U8_APPEND did not set isError correctly\n");
     }
-    if(length!=LENGTHOF(expectSafe) || 0!=memcmp(buffer, expectSafe, length)) {
+    if(length!=UPRV_LENGTHOF(expectSafe) || 0!=memcmp(buffer, expectSafe, length)) {
         log_err("U8_APPEND did not generate the expected output\n");
     }
 }
 
 static void
 TestSurrogates() {
     static const uint8_t b[]={
         0xc3, 0x9f,             /*  00DF */
         0xed, 0x9f, 0xbf,       /*  D7FF */
         0xed, 0xa0, 0x81,       /*  D801 */
         0xed, 0xbf, 0xbe,       /*  DFFE */
         0xee, 0x80, 0x80,       /*  E000 */
         0xf0, 0x97, 0xbf, 0xbe  /* 17FFE */
     };
     static const UChar32 cp[]={
         0xdf, 0xd7ff, 0xd801, 0xdffe, 0xe000, 0x17ffe
     };
 
     UChar32 cu, cs, cl;
     int32_t i, j, k, iu, is, il, length;
 
     k=0; /* index into cp[] */
-    length=LENGTHOF(b);
+    length=UPRV_LENGTHOF(b);
     for(i=0; i<length;) {
         j=i;
         U8_NEXT_UNSAFE(b, j, cu);
         iu=j;
 
         j=i;
         U8_NEXT(b, j, length, cs);
         is=j;
 
         j=i;
@@ skipping 58 matching lines @@
         i=iu;   /* go back by one UTF-8 sequence */
     }
 }
 
 static void printUChars(const uint8_t *uchars, int16_t len){
     int16_t i=0;
     for(i=0; i<len; i++){
         log_err("0x%02x ", *(uchars+i));
     }
 }