icuSources/test/cintltst/utexttst.c

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 2005-2013, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6 /*
   7 * File utexttst.c
   8 *
   9 * Modification History:
  10 *
  11 *   Date          Name               Description
  12 *   06/13/2005    Andy Heninger      Creation
  13 *******************************************************************************
  14 */
  15
  16 #include "unicode/utypes.h"
  17 #include "unicode/utext.h"
  18 #include "unicode/ustring.h"
  19 #include "cintltst.h"
  20 #include "memory.h"
  21 #include "string.h"
  22
  23
  24 static void TestAPI(void);
  25 void addUTextTest(TestNode** root);
  26
  27
  28 void
  29 addUTextTest(TestNode** root)
  30 {
  31   addTest(root, &TestAPI           ,    "tsutil/UTextTest/TestAPI");
  32 }
  33
  34
  35 #define TEST_ASSERT(x) \
  36    {if ((x)==FALSE) {log_err("Test failure in file %s at line %d\n", __FILE__, __LINE__);\
  37                      gFailed = TRUE;\
  38    }}
  39
  40
  41 #define TEST_SUCCESS(status) \
  42    {if (U_FAILURE(status)) {log_err("Test failure in file %s at line %d. Error = \"%s\"\n", \
  43        __FILE__, __LINE__, u_errorName(status)); \
  44        gFailed = TRUE;\
  45    }}
  46
  47
  48
  49 /*
  50  *  TestAPI   verify that the UText API is accessible from C programs.
  51  *            This is not intended to be a complete test of the API functionality.  That is
  52  *            in the C++ intltest program.
  53  *            This test is intended to check that everything can be accessed and built in
  54  *            a pure C enviornment.
  55  */
  56
  57
  58 static void TestAPI(void) {
  59     UErrorCode      status = U_ZERO_ERROR;
  60     UBool           gFailed = FALSE;
  61     (void)gFailed;   /* Suppress set but not used warning. */
  62
  63     /* Open    */
  64     {
  65         UText           utLoc = UTEXT_INITIALIZER;
  66         const char *    cString = "\x61\x62\x63\x64";
  67         UChar           uString[]  = {0x41, 0x42, 0x43, 0};
  68         UText          *uta;
  69         UText          *utb;
  70         UChar           c;
  71
  72         uta = utext_openUChars(NULL, uString, -1, &status);
  73         TEST_SUCCESS(status);
  74         c = utext_next32(uta);
  75         TEST_ASSERT(c == 0x41);
  76         utb = utext_close(uta);
  77         TEST_ASSERT(utb == NULL);
  78
  79         uta = utext_openUTF8(&utLoc, cString, -1, &status);
  80         TEST_SUCCESS(status);
  81         TEST_ASSERT(uta == &utLoc);
  82
  83         uta = utext_close(&utLoc);
  84         TEST_ASSERT(uta == &utLoc);
  85     }
  86
  87     /* utext_clone()  */
  88     {
  89         UChar   uString[]  = {0x41, 0x42, 0x43, 0};
  90         int64_t len;
  91         UText   *uta;
  92         UText   *utb;
  93
  94         status = U_ZERO_ERROR;
  95         uta = utext_openUChars(NULL, uString, -1, &status);
  96         TEST_SUCCESS(status);
  97         utb = utext_clone(NULL, uta, FALSE, FALSE, &status);
  98         TEST_SUCCESS(status);
  99         TEST_ASSERT(utb != NULL);
 100         TEST_ASSERT(utb != uta);
 101         len = utext_nativeLength(uta);
 102         TEST_ASSERT(len == u_strlen(uString));
 103         utext_close(uta);
 104         utext_close(utb);
 105     }
 106
 107     /* basic access functions  */
 108     {
 109         UChar     uString[]  = {0x41, 0x42, 0x43, 0};
 110         UText     *uta;
 111         UChar32   c;
 112         int64_t   len;
 113         UBool     b;
 114         int64_t   i;
 115
 116         status = U_ZERO_ERROR;
 117         uta = utext_openUChars(NULL, uString, -1, &status);
 118         TEST_ASSERT(uta!=NULL);
 119         TEST_SUCCESS(status);
 120         b = utext_isLengthExpensive(uta);
 121         TEST_ASSERT(b==TRUE);
 122         len = utext_nativeLength(uta);
 123         TEST_ASSERT(len == u_strlen(uString));
 124         b = utext_isLengthExpensive(uta);
 125         TEST_ASSERT(b==FALSE);
 126
 127         c = utext_char32At(uta, 0);
 128         TEST_ASSERT(c==uString[0]);
 129
 130         c = utext_current32(uta);
 131         TEST_ASSERT(c==uString[0]);
 132
 133         c = utext_next32(uta);
 134         TEST_ASSERT(c==uString[0]);
 135         c = utext_current32(uta);
 136         TEST_ASSERT(c==uString[1]);
 137
 138         c = utext_previous32(uta);
 139         TEST_ASSERT(c==uString[0]);
 140         c = utext_current32(uta);
 141         TEST_ASSERT(c==uString[0]);
 142
 143         c = utext_next32From(uta, 1);
 144         TEST_ASSERT(c==uString[1]);
 145         c = utext_next32From(uta, u_strlen(uString));
 146         TEST_ASSERT(c==U_SENTINEL);
 147
 148         c = utext_previous32From(uta, 2);
 149         TEST_ASSERT(c==uString[1]);
 150         i = utext_getNativeIndex(uta);
 151         TEST_ASSERT(i == 1);
 152
 153         utext_setNativeIndex(uta, 0);
 154         b = utext_moveIndex32(uta, 1);
 155         TEST_ASSERT(b==TRUE);
 156         i = utext_getNativeIndex(uta);
 157         TEST_ASSERT(i==1);
 158
 159         b = utext_moveIndex32(uta, u_strlen(uString)-1);
 160         TEST_ASSERT(b==TRUE);
 161         i = utext_getNativeIndex(uta);
 162         TEST_ASSERT(i==u_strlen(uString));
 163
 164         b = utext_moveIndex32(uta, 1);
 165         TEST_ASSERT(b==FALSE);
 166         i = utext_getNativeIndex(uta);
 167         TEST_ASSERT(i==u_strlen(uString));
 168
 169         utext_setNativeIndex(uta, 0);
 170         c = UTEXT_NEXT32(uta);
 171         TEST_ASSERT(c==uString[0]);
 172         c = utext_current32(uta);
 173         TEST_ASSERT(c==uString[1]);
 174
 175         c = UTEXT_PREVIOUS32(uta);
 176         TEST_ASSERT(c==uString[0]);
 177         c = UTEXT_PREVIOUS32(uta);
 178         TEST_ASSERT(c==U_SENTINEL);
 179
 180
 181         utext_close(uta);
 182     }
 183
 184     {
 185         /*
 186          * UText opened on a NULL string with zero length
 187          */
 188         UText    *uta;
 189         UChar32   c;
 190
 191         status = U_ZERO_ERROR;
 192         uta = utext_openUChars(NULL, NULL, 0, &status);
 193         TEST_SUCCESS(status);
 194         c = UTEXT_NEXT32(uta);
 195         TEST_ASSERT(c == U_SENTINEL);
 196         utext_close(uta);
 197
 198         uta = utext_openUTF8(NULL, NULL, 0, &status);
 199         TEST_SUCCESS(status);
 200         c = UTEXT_NEXT32(uta);
 201         TEST_ASSERT(c == U_SENTINEL);
 202         utext_close(uta);
 203     }
 204
 205
 206     {
 207         /*
 208          * extract
 209          */
 210         UText     *uta;
 211         UChar     uString[]  = {0x41, 0x42, 0x43, 0};
 212         UChar     buf[100];
 213         int32_t   i;
 214         /* Test pinning of input bounds */
 215         UChar     uString2[]  = {0x41, 0x42, 0x43, 0x44, 0x45,
 216                                  0x46, 0x47, 0x48, 0x49, 0x4A, 0};
 217         UChar *   uString2Ptr = uString2 + 5;
 218
 219         status = U_ZERO_ERROR;
 220         uta = utext_openUChars(NULL, uString, -1, &status);
 221         TEST_SUCCESS(status);
 222
 223         status = U_ZERO_ERROR;
 224         i = utext_extract(uta, 0, 100, NULL, 0, &status);
 225         TEST_ASSERT(status==U_BUFFER_OVERFLOW_ERROR);
 226         TEST_ASSERT(i == u_strlen(uString));
 227
 228         status = U_ZERO_ERROR;
 229         memset(buf, 0, sizeof(buf));
 230         i = utext_extract(uta, 0, 100, buf, 100, &status);
 231         TEST_SUCCESS(status);
 232         TEST_ASSERT(i == u_strlen(uString));
 233         i = u_strcmp(uString, buf);
 234         TEST_ASSERT(i == 0);
 235         utext_close(uta);
 236
 237         /* Test pinning of input bounds */
 238         status = U_ZERO_ERROR;
 239         uta = utext_openUChars(NULL, uString2Ptr, -1, &status);
 240         TEST_SUCCESS(status);
 241
 242         status = U_ZERO_ERROR;
 243         memset(buf, 0, sizeof(buf));
 244         i = utext_extract(uta, -3, 20, buf, 100, &status);
 245         TEST_SUCCESS(status);
 246         TEST_ASSERT(i == u_strlen(uString2Ptr));
 247         i = u_strcmp(uString2Ptr, buf);
 248         TEST_ASSERT(i == 0);
 249         utext_close(uta);
 250     }
 251
 252     {
 253         /*
 254          *  Copy, Replace, isWritable
 255          *    Can't create an editable UText from plain C, so all we
 256          *    can easily do is check that errors returned.
 257          */
 258         UText     *uta;
 259         UChar     uString[]  = {0x41, 0x42, 0x43, 0};
 260         UBool     b;
 261
 262         status = U_ZERO_ERROR;
 263         uta = utext_openUChars(NULL, uString, -1, &status);
 264         TEST_SUCCESS(status);
 265
 266         b = utext_isWritable(uta);
 267         TEST_ASSERT(b == FALSE);
 268
 269         b = utext_hasMetaData(uta);
 270         TEST_ASSERT(b == FALSE);
 271
 272         utext_replace(uta,
 273                       0, 1,     /* start, limit */
 274                       uString, -1,  /* replacement, replacement length */
 275                       &status);
 276         TEST_ASSERT(status == U_NO_WRITE_PERMISSION);
 277
 278
 279         utext_copy(uta,
 280                    0, 1,         /* start, limit      */
 281                    2,            /* destination index */
 282                    FALSE,        /* move flag         */
 283                    &status);
 284         TEST_ASSERT(status == U_NO_WRITE_PERMISSION);
 285
 286         utext_close(uta);
 287     }
 288
 289
 290 }
 291