1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 2009-2015, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6 /********************************************************************************
7 *
8 * File spooftest.c
9 *
10 *********************************************************************************/
11 /*C API TEST for the uspoof Unicode Indentifier Spoofing and Security API */
12 /**
13 * This is an API test for ICU spoof detection in plain C. It doesn't test very many cases, and doesn't
14 * try to test the full functionality. It just calls each function and verifies that it
15 * works on a basic level.
16 *
17 * More complete testing of spoof detection functionality is done with the C++ tests.
18 **/
19
20 #include "unicode/utypes.h"
21 #if !UCONFIG_NO_REGULAR_EXPRESSIONS && !UCONFIG_NO_NORMALIZATION
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include "unicode/uspoof.h"
27 #include "unicode/ustring.h"
28 #include "unicode/uset.h"
29 #include "cintltst.h"
30
31 #define TEST_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
32 log_err_status(status, "Failure at file %s, line %d, error = %s\n", __FILE__, __LINE__, u_errorName(status));}}
33
34 #define TEST_ASSERT(expr) {if ((expr)==FALSE) { \
35 log_err("Test Failure at file %s, line %d: \"%s\" is false.\n", __FILE__, __LINE__, #expr);};}
36
37 #define TEST_ASSERT_EQ(a, b) { if ((a) != (b)) { \
38 log_err("Test Failure at file %s, line %d: \"%s\" (%d) != \"%s\" (%d) \n", \
39 __FILE__, __LINE__, #a, (a), #b, (b)); }}
40
41 #define TEST_ASSERT_NE(a, b) { if ((a) == (b)) { \
42 log_err("Test Failure at file %s, line %d: \"%s\" (%d) == \"%s\" (%d) \n", \
43 __FILE__, __LINE__, #a, (a), #b, (b)); }}
44
45
46 /*
47 * TEST_SETUP and TEST_TEARDOWN
48 * macros to handle the boilerplate around setting up test case.
49 * Put arbitrary test code between SETUP and TEARDOWN.
50 * "sc" is the ready-to-go SpoofChecker for use in the tests.
51 */
52 #define TEST_SETUP { \
53 UErrorCode status = U_ZERO_ERROR; \
54 USpoofChecker *sc; \
55 sc = uspoof_open(&status); \
56 TEST_ASSERT_SUCCESS(status); \
57 if (U_SUCCESS(status)){
58
59 #define TEST_TEARDOWN \
60 } \
61 TEST_ASSERT_SUCCESS(status); \
62 uspoof_close(sc); \
63 }
64
65 static void TestOpenFromSource(void);
66 static void TestUSpoofCAPI(void);
67
68 void addUSpoofTest(TestNode** root);
69
addUSpoofTest(TestNode ** root)70 void addUSpoofTest(TestNode** root)
71 {
72 #if !UCONFIG_NO_FILE_IO
73 addTest(root, &TestOpenFromSource, "uspoof/TestOpenFromSource");
74 #endif
75 addTest(root, &TestUSpoofCAPI, "uspoof/TestUSpoofCAPI");
76 }
77
78 /*
79 * Identifiers for verifying that spoof checking is minimally alive and working.
80 */
81 const UChar goodLatin[] = {(UChar)0x75, (UChar)0x7a, 0}; /* "uz", all ASCII */
82 /* (not confusable) */
83 const UChar scMixed[] = {(UChar)0x73, (UChar)0x0441, 0}; /* "sc", with Cyrillic 'c' */
84 /* (mixed script, confusable */
85
86 const UChar scLatin[] = {(UChar)0x73, (UChar)0x63, 0}; /* "sc", plain ascii. */
87 const UChar goodCyrl[] = {(UChar)0x438, (UChar)0x43B, 0}; /* Plain lower case Cyrillic letters,
88 no latin confusables */
89
90 const UChar goodGreek[] = {(UChar)0x3c0, (UChar)0x3c6, 0}; /* Plain lower case Greek letters */
91
92 const UChar lll_Latin_a[] = {(UChar)0x6c, (UChar)0x49, (UChar)0x31, 0}; /* lI1, all ASCII */
93
94 /* Full-width I, Small Roman Numeral fifty, Latin Cap Letter IOTA*/
95 const UChar lll_Latin_b[] = {(UChar)0xff29, (UChar)0x217c, (UChar)0x196, 0};
96
97 const UChar lll_Cyrl[] = {(UChar)0x0406, (UChar)0x04C0, (UChar)0x31, 0};
98
99 /* The skeleton transform for all of thes 'lll' lookalikes is all lower case l. */
100 const UChar lll_Skel[] = {(UChar)0x6c, (UChar)0x6c, (UChar)0x6c, 0};
101
102 const UChar han_Hiragana[] = {(UChar)0x3086, (UChar)0x308A, (UChar)0x0020, (UChar)0x77F3, (UChar)0x7530, 0};
103
104 /* Provide better code coverage */
105 const char goodLatinUTF8[] = {0x75, 0x77, 0};
106
107 // Test open from source rules.
108 // Run this in isolation to verify initialization.
TestOpenFromSource()109 static void TestOpenFromSource() {
110 // No TEST_SETUP because that calls uspoof_open().
111 UErrorCode status = U_ZERO_ERROR;
112 const char *dataSrcDir;
113 char *fileName;
114 char *confusables;
115 int confusablesLength = 0;
116 char *confusablesWholeScript;
117 int confusablesWholeScriptLength = 0;
118 FILE *f;
119 UParseError pe;
120 int32_t errType;
121 int32_t checkResults;
122 USpoofChecker *rsc;
123
124 dataSrcDir = ctest_dataSrcDir();
125 fileName = malloc(strlen(dataSrcDir) + 100);
126 strcpy(fileName, dataSrcDir);
127 strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusables.txt");
128 f = fopen(fileName, "rb");
129 TEST_ASSERT_NE(f, NULL);
130 confusables = malloc(3000000);
131 if (f != NULL) {
132 confusablesLength = fread(confusables, 1, 3000000, f);
133 fclose(f);
134 }
135
136 strcpy(fileName, dataSrcDir);
137 strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusablesWholeScript.txt");
138 f = fopen(fileName, "rb");
139 TEST_ASSERT_NE(f, NULL);
140 confusablesWholeScript = malloc(1000000);
141 if (f != NULL) {
142 confusablesWholeScriptLength = fread(confusablesWholeScript, 1, 1000000, f);
143 fclose(f);
144 }
145
146 rsc = uspoof_openFromSource(confusables, confusablesLength,
147 confusablesWholeScript, confusablesWholeScriptLength,
148 &errType, &pe, &status);
149 TEST_ASSERT_SUCCESS(status);
150
151 // Ticket #11860: uspoof_openFromSource() did not initialize for use.
152 // Verify that the spoof checker does not crash.
153 checkResults = uspoof_check(rsc, goodLatin, -1, NULL, &status);
154 TEST_ASSERT_SUCCESS(status);
155 TEST_ASSERT_EQ(0, checkResults);
156
157 free(confusablesWholeScript);
158 free(confusables);
159 free(fileName);
160 uspoof_close(rsc);
161 /* printf("ParseError Line is %d\n", pe.line); */
162 }
163
164 /*
165 * Spoof Detection C API Tests
166 */
TestUSpoofCAPI(void)167 static void TestUSpoofCAPI(void) {
168
169 /*
170 * basic uspoof_open().
171 */
172 {
173 USpoofChecker *sc;
174 UErrorCode status = U_ZERO_ERROR;
175 sc = uspoof_open(&status);
176 TEST_ASSERT_SUCCESS(status);
177 if (U_FAILURE(status)) {
178 /* If things are so broken that we can't even open a default spoof checker, */
179 /* don't even try the rest of the tests. They would all fail. */
180 return;
181 }
182 uspoof_close(sc);
183 }
184
185 /*
186 * openFromSerialized and serialize
187 */
188 TEST_SETUP
189 int32_t serializedSize = 0;
190 int32_t actualLength = 0;
191 char *buf;
192 USpoofChecker *sc2;
193 int32_t checkResults;
194
195
196 serializedSize = uspoof_serialize(sc, NULL, 0, &status);
197 TEST_ASSERT_EQ(status, U_BUFFER_OVERFLOW_ERROR);
198 TEST_ASSERT(serializedSize > 0);
199
200 /* Serialize the default spoof checker */
201 status = U_ZERO_ERROR;
202 buf = (char *)malloc(serializedSize + 10);
203 TEST_ASSERT(buf != NULL);
204 buf[serializedSize] = 42;
205 uspoof_serialize(sc, buf, serializedSize, &status);
206 TEST_ASSERT_SUCCESS(status);
207 TEST_ASSERT_EQ(42, buf[serializedSize]);
208
209 /* Create a new spoof checker from the freshly serialized data */
210 sc2 = uspoof_openFromSerialized(buf, serializedSize+10, &actualLength, &status);
211 TEST_ASSERT_SUCCESS(status);
212 TEST_ASSERT_NE(NULL, sc2);
213 TEST_ASSERT_EQ(serializedSize, actualLength);
214
215 /* Verify that the new spoof checker at least wiggles */
216 checkResults = uspoof_check(sc2, goodLatin, -1, NULL, &status);
217 TEST_ASSERT_SUCCESS(status);
218 TEST_ASSERT_EQ(0, checkResults);
219
220 checkResults = uspoof_check(sc2, scMixed, -1, NULL, &status);
221 TEST_ASSERT_SUCCESS(status);
222 TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults);
223
224 uspoof_close(sc2);
225 free(buf);
226 TEST_TEARDOWN;
227
228
229
230 /*
231 * Set & Get Check Flags
232 */
233 TEST_SETUP
234 int32_t t;
235 uspoof_setChecks(sc, USPOOF_ALL_CHECKS, &status);
236 TEST_ASSERT_SUCCESS(status);
237 t = uspoof_getChecks(sc, &status);
238 TEST_ASSERT_EQ(t, USPOOF_ALL_CHECKS);
239
240 uspoof_setChecks(sc, 0, &status);
241 TEST_ASSERT_SUCCESS(status);
242 t = uspoof_getChecks(sc, &status);
243 TEST_ASSERT_EQ(0, t);
244
245 uspoof_setChecks(sc,
246 USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_ANY_CASE,
247 &status);
248 TEST_ASSERT_SUCCESS(status);
249 t = uspoof_getChecks(sc, &status);
250 TEST_ASSERT_SUCCESS(status);
251 TEST_ASSERT_EQ(USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_ANY_CASE, t);
252 TEST_TEARDOWN;
253
254 /*
255 * get & setAllowedChars
256 */
257 TEST_SETUP
258 USet *us;
259 const USet *uset;
260
261 uset = uspoof_getAllowedChars(sc, &status);
262 TEST_ASSERT_SUCCESS(status);
263 TEST_ASSERT(uset_isFrozen(uset));
264 us = uset_open((UChar32)0x41, (UChar32)0x5A); /* [A-Z] */
265 uspoof_setAllowedChars(sc, us, &status);
266 TEST_ASSERT_SUCCESS(status);
267 TEST_ASSERT_NE(us, uspoof_getAllowedChars(sc, &status));
268 TEST_ASSERT(uset_equals(us, uspoof_getAllowedChars(sc, &status)));
269 TEST_ASSERT_SUCCESS(status);
270 uset_close(us);
271 TEST_TEARDOWN;
272
273 /*
274 * clone()
275 */
276
277 TEST_SETUP
278 USpoofChecker *clone1 = NULL;
279 USpoofChecker *clone2 = NULL;
280 int32_t checkResults = 0;
281
282 clone1 = uspoof_clone(sc, &status);
283 TEST_ASSERT_SUCCESS(status);
284 TEST_ASSERT_NE(clone1, sc);
285
286 clone2 = uspoof_clone(clone1, &status);
287 TEST_ASSERT_SUCCESS(status);
288 TEST_ASSERT_NE(clone2, clone1);
289
290 uspoof_close(clone1);
291
292 /* Verify that the cloned spoof checker is alive */
293 checkResults = uspoof_check(clone2, goodLatin, -1, NULL, &status);
294 TEST_ASSERT_SUCCESS(status);
295 TEST_ASSERT_EQ(0, checkResults);
296
297 checkResults = uspoof_check(clone2, scMixed, -1, NULL, &status);
298 TEST_ASSERT_SUCCESS(status);
299 TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults);
300 uspoof_close(clone2);
301 TEST_TEARDOWN;
302
303 /*
304 * basic uspoof_check()
305 */
306 TEST_SETUP
307 int32_t result;
308 result = uspoof_check(sc, goodLatin, -1, NULL, &status);
309 TEST_ASSERT_SUCCESS(status);
310 TEST_ASSERT_EQ(0, result);
311
312 result = uspoof_check(sc, han_Hiragana, -1, NULL, &status);
313 TEST_ASSERT_SUCCESS(status);
314 TEST_ASSERT_EQ(0, result);
315
316 result = uspoof_check(sc, scMixed, -1, NULL, &status);
317 TEST_ASSERT_SUCCESS(status);
318 TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE, result);
319 TEST_TEARDOWN
320
321
322 /*
323 * get & set Checks
324 */
325 TEST_SETUP
326 int32_t checks;
327 int32_t checks2;
328 int32_t checkResults;
329
330 checks = uspoof_getChecks(sc, &status);
331 TEST_ASSERT_SUCCESS(status);
332 TEST_ASSERT_EQ(USPOOF_ALL_CHECKS, checks);
333
334 checks &= ~(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE);
335 uspoof_setChecks(sc, checks, &status);
336 TEST_ASSERT_SUCCESS(status);
337 checks2 = uspoof_getChecks(sc, &status);
338 TEST_ASSERT_EQ(checks, checks2);
339
340 /* The checks that were disabled just above are the same ones that the "scMixed" test fails.
341 So with those tests gone checking that Identifier should now succeed */
342 checkResults = uspoof_check(sc, scMixed, -1, NULL, &status);
343 TEST_ASSERT_SUCCESS(status);
344 TEST_ASSERT_EQ(0, checkResults);
345 TEST_TEARDOWN;
346
347 /*
348 * AllowedLoacles
349 */
350
351 TEST_SETUP
352 const char *allowedLocales;
353 int32_t checkResults;
354
355 /* Default allowed locales list should be empty */
356 allowedLocales = uspoof_getAllowedLocales(sc, &status);
357 TEST_ASSERT_SUCCESS(status);
358 TEST_ASSERT(strcmp("", allowedLocales) == 0)
359
360 /* Allow en and ru, which should enable Latin and Cyrillic only to pass */
361 uspoof_setAllowedLocales(sc, "en, ru_RU", &status);
362 TEST_ASSERT_SUCCESS(status);
363 allowedLocales = uspoof_getAllowedLocales(sc, &status);
364 TEST_ASSERT_SUCCESS(status);
365 TEST_ASSERT(strstr(allowedLocales, "en") != NULL);
366 TEST_ASSERT(strstr(allowedLocales, "ru") != NULL);
367
368 /* Limit checks to USPOOF_CHAR_LIMIT. Some of the test data has whole script confusables also,
369 * which we don't want to see in this test. */
370 uspoof_setChecks(sc, USPOOF_CHAR_LIMIT, &status);
371 TEST_ASSERT_SUCCESS(status);
372
373 checkResults = uspoof_check(sc, goodLatin, -1, NULL, &status);
374 TEST_ASSERT_SUCCESS(status);
375 TEST_ASSERT_EQ(0, checkResults);
376
377 checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status);
378 TEST_ASSERT_SUCCESS(status);
379 TEST_ASSERT_EQ(USPOOF_CHAR_LIMIT, checkResults);
380
381 checkResults = uspoof_check(sc, goodCyrl, -1, NULL, &status);
382 TEST_ASSERT_SUCCESS(status);
383 TEST_ASSERT_EQ(0, checkResults);
384
385 /* Reset with an empty locale list, which should allow all characters to pass */
386 uspoof_setAllowedLocales(sc, " ", &status);
387 TEST_ASSERT_SUCCESS(status);
388
389 checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status);
390 TEST_ASSERT_SUCCESS(status);
391 TEST_ASSERT_EQ(0, checkResults);
392 TEST_TEARDOWN;
393
394 /*
395 * AllowedChars set/get the USet of allowed characters.
396 */
397 TEST_SETUP
398 const USet *set;
399 USet *tmpSet;
400 int32_t checkResults;
401
402 /* By default, we should see no restriction; the USet should allow all characters. */
403 set = uspoof_getAllowedChars(sc, &status);
404 TEST_ASSERT_SUCCESS(status);
405 tmpSet = uset_open(0, 0x10ffff);
406 TEST_ASSERT(uset_equals(tmpSet, set));
407
408 /* Setting the allowed chars should enable the check. */
409 uspoof_setChecks(sc, USPOOF_ALL_CHECKS & ~USPOOF_CHAR_LIMIT, &status);
410 TEST_ASSERT_SUCCESS(status);
411
412 /* Remove a character that is in our good Latin test identifier from the allowed chars set. */
413 uset_remove(tmpSet, goodLatin[1]);
414 uspoof_setAllowedChars(sc, tmpSet, &status);
415 TEST_ASSERT_SUCCESS(status);
416 uset_close(tmpSet);
417
418 /* Latin Identifier should now fail; other non-latin test cases should still be OK
419 * Note: fail of CHAR_LIMIT also causes the restriction level to be USPOOF_UNRESTRICTIVE
420 * which will give us a USPOOF_RESTRICTION_LEVEL failure.
421 */
422 checkResults = uspoof_check(sc, goodLatin, -1, NULL, &status);
423 TEST_ASSERT_SUCCESS(status);
424 TEST_ASSERT_EQ(USPOOF_CHAR_LIMIT | USPOOF_RESTRICTION_LEVEL, checkResults);
425
426 checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status);
427 TEST_ASSERT_SUCCESS(status);
428 TEST_ASSERT_EQ(USPOOF_WHOLE_SCRIPT_CONFUSABLE, checkResults);
429 TEST_TEARDOWN;
430
431 /*
432 * check UTF-8
433 */
434 TEST_SETUP
435 char utf8buf[200];
436 int32_t checkResults;
437 int32_t position;
438
439 u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, goodLatin, -1, &status);
440 TEST_ASSERT_SUCCESS(status);
441 position = 666;
442 checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status);
443 TEST_ASSERT_SUCCESS(status);
444 TEST_ASSERT_EQ(0, checkResults);
445 TEST_ASSERT_EQ(0, position);
446
447 u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, goodCyrl, -1, &status);
448 TEST_ASSERT_SUCCESS(status);
449 checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status);
450 TEST_ASSERT_SUCCESS(status);
451 TEST_ASSERT_EQ(0, checkResults);
452
453 u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, scMixed, -1, &status);
454 TEST_ASSERT_SUCCESS(status);
455 position = 666;
456 checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status);
457 TEST_ASSERT_SUCCESS(status);
458 TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_SINGLE_SCRIPT , checkResults);
459 TEST_ASSERT_EQ(0, position);
460
461 TEST_TEARDOWN;
462
463 /*
464 * uspoof_areConfusable()
465 */
466 TEST_SETUP
467 int32_t checkResults;
468
469 checkResults = uspoof_areConfusable(sc, scLatin, -1, scMixed, -1, &status);
470 TEST_ASSERT_SUCCESS(status);
471 TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults);
472
473 checkResults = uspoof_areConfusable(sc, goodGreek, -1, scLatin, -1, &status);
474 TEST_ASSERT_SUCCESS(status);
475 TEST_ASSERT_EQ(0, checkResults);
476
477 checkResults = uspoof_areConfusable(sc, lll_Latin_a, -1, lll_Latin_b, -1, &status);
478 TEST_ASSERT_SUCCESS(status);
479 TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT_CONFUSABLE, checkResults);
480
481 TEST_TEARDOWN;
482
483 /*
484 * areConfusableUTF8
485 */
486 TEST_SETUP
487 int32_t checkResults;
488 char s1[200];
489 char s2[200];
490
491
492 u_strToUTF8(s1, sizeof(s1), NULL, scLatin, -1, &status);
493 u_strToUTF8(s2, sizeof(s2), NULL, scMixed, -1, &status);
494 TEST_ASSERT_SUCCESS(status);
495 checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status);
496 TEST_ASSERT_SUCCESS(status);
497 TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults);
498
499 u_strToUTF8(s1, sizeof(s1), NULL, goodGreek, -1, &status);
500 u_strToUTF8(s2, sizeof(s2), NULL, scLatin, -1, &status);
501 TEST_ASSERT_SUCCESS(status);
502 checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status);
503 TEST_ASSERT_SUCCESS(status);
504 TEST_ASSERT_EQ(0, checkResults);
505
506 u_strToUTF8(s1, sizeof(s1), NULL, lll_Latin_a, -1, &status);
507 u_strToUTF8(s2, sizeof(s2), NULL, lll_Latin_b, -1, &status);
508 TEST_ASSERT_SUCCESS(status);
509 checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status);
510 TEST_ASSERT_SUCCESS(status);
511 TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT_CONFUSABLE, checkResults);
512
513 TEST_TEARDOWN;
514
515
516 /*
517 * getSkeleton
518 */
519
520 TEST_SETUP
521 UChar dest[100];
522 int32_t skelLength;
523
524 skelLength = uspoof_getSkeleton(sc, USPOOF_ANY_CASE, lll_Latin_a, -1, dest, sizeof(dest)/sizeof(UChar), &status);
525 TEST_ASSERT_SUCCESS(status);
526 TEST_ASSERT_EQ(0, u_strcmp(lll_Skel, dest));
527 TEST_ASSERT_EQ(u_strlen(lll_Skel), skelLength);
528
529 skelLength = uspoof_getSkeletonUTF8(sc, USPOOF_ANY_CASE, goodLatinUTF8, -1, (char*)dest,
530 sizeof(dest)/sizeof(UChar), &status);
531 TEST_ASSERT_SUCCESS(status);
532
533 skelLength = uspoof_getSkeleton(sc, USPOOF_ANY_CASE, lll_Latin_a, -1, NULL, 0, &status);
534 TEST_ASSERT_EQ(U_BUFFER_OVERFLOW_ERROR, status);
535 TEST_ASSERT_EQ(3, skelLength);
536 status = U_ZERO_ERROR;
537
538 TEST_TEARDOWN;
539
540 /*
541 * get Inclusion and Recommended sets
542 */
543 TEST_SETUP
544 const USet *inclusions = NULL;
545 const USet *recommended = NULL;
546
547 inclusions = uspoof_getInclusionSet(&status);
548 TEST_ASSERT_SUCCESS(status);
549 TEST_ASSERT_EQ(TRUE, uset_isFrozen(inclusions));
550
551 status = U_ZERO_ERROR;
552 recommended = uspoof_getRecommendedSet(&status);
553 TEST_ASSERT_SUCCESS(status);
554 TEST_ASSERT_EQ(TRUE, uset_isFrozen(recommended));
555 TEST_TEARDOWN;
556
557 }
558
559 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
560