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