ICU 56 update step 1

source/test/cintltst/spooftest.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 2009-2013, International Business Machines Corporation and
+ * Copyright (c) 2009-2015, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /********************************************************************************
 *
 * File spooftest.c
 *
 *********************************************************************************/
 /*C API TEST for the uspoof Unicode Indentifier Spoofing and Security API */
 /**
 *   This is an API test for ICU spoof detection in plain C.  It doesn't test very many cases, and doesn't
@@ skipping 41 matching lines @@
     sc = uspoof_open(&status);  \
     TEST_ASSERT_SUCCESS(status);   \
     if (U_SUCCESS(status)){
 
 #define TEST_TEARDOWN  \
     }  \
     TEST_ASSERT_SUCCESS(status);  \
     uspoof_close(sc);  \
 }
 
-
+static void TestOpenFromSource(void);
 static void TestUSpoofCAPI(void);
 
 void addUSpoofTest(TestNode** root);
 
 void addUSpoofTest(TestNode** root)
 {
 #if !UCONFIG_NO_FILE_IO
+    addTest(root, &TestOpenFromSource, "uspoof/TestOpenFromSource");
+#endif
     addTest(root, &TestUSpoofCAPI, "uspoof/TestUSpoofCAPI");
-#endif
 }
 
 /*
  *  Identifiers for verifying that spoof checking is minimally alive and working.
  */
 const UChar goodLatin[] = {(UChar)0x75, (UChar)0x7a, 0};    /* "uz", all ASCII             */
                                                             /*   (not confusable)          */
 const UChar scMixed[]  = {(UChar)0x73, (UChar)0x0441, 0};   /* "sc", with Cyrillic 'c'     */
                                                             /*   (mixed script, confusable */
 
@@ skipping 10 matching lines @@
 
 const UChar lll_Cyrl[]    = {(UChar)0x0406, (UChar)0x04C0, (UChar)0x31, 0};
 
 /* The skeleton transform for all of thes 'lll' lookalikes is all lower case l. */
 const UChar lll_Skel[]    = {(UChar)0x6c, (UChar)0x6c, (UChar)0x6c, 0};  
 
 const UChar han_Hiragana[] = {(UChar)0x3086, (UChar)0x308A, (UChar)0x0020, (UChar)0x77F3, (UChar)0x7530, 0};
 
 /* Provide better code coverage */
 const char goodLatinUTF8[]    = {0x75, 0x77, 0};
-/*
- *   Spoof Detction C API Tests
- */
-static void TestUSpoofCAPI(void) {
 
-    /*
-     *  basic uspoof_open().
-     */
-    {
-        USpoofChecker *sc;
-        UErrorCode  status = U_ZERO_ERROR;
-        sc = uspoof_open(&status);
-        TEST_ASSERT_SUCCESS(status);
-        if (U_FAILURE(status)) {
-            /* If things are so broken that we can't even open a default spoof checker,  */
-            /*   don't even try the rest of the tests.  They would all fail.             */
-            return;
-        }
-        uspoof_close(sc);
-    }
-
-    
-        
-    /*
-     *  Test Open from source rules.
-    */
-    TEST_SETUP
+// Test open from source rules.
+// Run this in isolation to verify initialization.
+static void TestOpenFromSource() {
+    // No TEST_SETUP because that calls uspoof_open().
+    UErrorCode status = U_ZERO_ERROR;
     const char *dataSrcDir;
     char       *fileName;
     char       *confusables;
     int         confusablesLength = 0;
     char       *confusablesWholeScript;
     int         confusablesWholeScriptLength = 0;
     FILE       *f;
     UParseError pe;
     int32_t     errType;
+    int32_t     checkResults;
     USpoofChecker *rsc;
-    
+
     dataSrcDir = ctest_dataSrcDir();
     fileName = malloc(strlen(dataSrcDir) + 100);
     strcpy(fileName, dataSrcDir);
     strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusables.txt");
     f = fopen(fileName, "rb");
     TEST_ASSERT_NE(f, NULL);
     confusables = malloc(3000000);
     if (f != NULL) {
         confusablesLength = fread(confusables, 1, 3000000, f);
         fclose(f);
     }
 
     strcpy(fileName, dataSrcDir);
     strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusablesWholeScript.txt");
     f = fopen(fileName, "rb");
     TEST_ASSERT_NE(f, NULL);
     confusablesWholeScript = malloc(1000000);
     if (f != NULL) {
         confusablesWholeScriptLength = fread(confusablesWholeScript, 1, 1000000, f);
         fclose(f);
     }
 
     rsc = uspoof_openFromSource(confusables, confusablesLength,
-                                              confusablesWholeScript, confusablesWholeScriptLength,
-                                              &errType, &pe, &status);
+                                confusablesWholeScript, confusablesWholeScriptLength,
+                                &errType, &pe, &status);
     TEST_ASSERT_SUCCESS(status);
 
+    // Ticket #11860: uspoof_openFromSource() did not initialize for use.
+    // Verify that the spoof checker does not crash.
+    checkResults = uspoof_check(rsc, goodLatin, -1, NULL, &status);
+    TEST_ASSERT_SUCCESS(status);
+    TEST_ASSERT_EQ(0, checkResults);
+
     free(confusablesWholeScript);
     free(confusables);
     free(fileName);
     uspoof_close(rsc);
     /*  printf("ParseError Line is %d\n", pe.line);  */
-    TEST_TEARDOWN;
+}
 
+/*
+ *   Spoof Detection C API Tests
+ */
+static void TestUSpoofCAPI(void) {
+
+    /*
+     *  basic uspoof_open().
+     */
+    {
+        USpoofChecker *sc;
+        UErrorCode  status = U_ZERO_ERROR;
+        sc = uspoof_open(&status);
+        TEST_ASSERT_SUCCESS(status);
+        if (U_FAILURE(status)) {
+            /* If things are so broken that we can't even open a default spoof checker,  */
+            /*   don't even try the rest of the tests.  They would all fail.             */
+            return;
+        }
+        uspoof_close(sc);
+    }
 
     /*
      * openFromSerialized and serialize
     */
     TEST_SETUP
         int32_t        serializedSize = 0;
         int32_t        actualLength = 0;
         char           *buf;
         USpoofChecker  *sc2;
         int32_t         checkResults;
@@ skipping 335 matching lines @@
         skelLength = uspoof_getSkeletonUTF8(sc, USPOOF_ANY_CASE, goodLatinUTF8, -1, (char*)dest, 
                                             sizeof(dest)/sizeof(UChar), &status);
         TEST_ASSERT_SUCCESS(status);
 
         skelLength = uspoof_getSkeleton(sc, USPOOF_ANY_CASE, lll_Latin_a, -1, NULL, 0, &status);
         TEST_ASSERT_EQ(U_BUFFER_OVERFLOW_ERROR, status);
         TEST_ASSERT_EQ(3, skelLength);
         status = U_ZERO_ERROR;
 
     TEST_TEARDOWN;
+
+    /*
+     * get Inclusion and Recommended sets
+     */
+    TEST_SETUP
+        const USet *inclusions = NULL;
+        const USet *recommended = NULL;
+
+        inclusions = uspoof_getInclusionSet(&status);
+        TEST_ASSERT_SUCCESS(status);
+        TEST_ASSERT_EQ(TRUE, uset_isFrozen(inclusions));
+
+        status = U_ZERO_ERROR;
+        recommended = uspoof_getRecommendedSet(&status);
+        TEST_ASSERT_SUCCESS(status);
+        TEST_ASSERT_EQ(TRUE, uset_isFrozen(recommended));
+    TEST_TEARDOWN;
+
 }
 
 #endif  /* UCONFIG_NO_REGULAR_EXPRESSIONS */