source/test/cintltst/spooftest.c

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