Split test_read_format_zip_filename to know what filename conversion

is tested or skipped.

diff --git a/libarchive/test/test_read_format_zip_filename.c b/libarchive/test/test_read_format_zip_filename.c
index 4b9730f977d0477713d589ab4d64684be37cbf3a..93ba09b3ebbb996aedfec3c2006b511f529b0e89 100644 (file)
--- a/libarchive/test/test_read_format_zip_filename.c
+++ b/libarchive/test/test_read_format_zip_filename.c
@@ -27,9 +27,9 @@ __FBSDID("$FreeBSD");
 
 #include <locale.h>
 
-static void
-test_read_format_zip_filename_CP932_eucJP(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP932_eucJP)
 {
+       const char *refname = "test_read_format_zip_filename_cp932.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -40,6 +40,7 @@ test_read_format_zip_filename_CP932_eucJP(const char *refname)
                skipping("ja_JP.eucJP locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -86,9 +87,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_CP932_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP932_UTF8)
 {
+       const char *refname = "test_read_format_zip_filename_cp932.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -99,6 +100,7 @@ test_read_format_zip_filename_CP932_UTF8(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -163,9 +165,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_eucJP(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_eucJP)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -175,9 +177,11 @@ test_read_format_zip_filename_UTF8_eucJP(const char *refname)
         * Bit 11 of its general purpose bit flag is set.
         */
        if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
-               skipping("ja_JP.eucJP locale not availablefilename_ on this system.");
+               skipping("ja_JP.eucJP locale not availablefilename_ on "
+                        "this system.");
                return;
        }
+       extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
        if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
@@ -236,9 +240,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -251,6 +255,7 @@ test_read_format_zip_filename_UTF8_UTF8(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -329,9 +334,9 @@ test_read_format_zip_filename_UTF8_UTF8(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_CP866_KOI8R(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP866_KOI8R)
 {
+       const char *refname = "test_read_format_zip_filename_cp866.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -343,6 +348,7 @@ test_read_format_zip_filename_CP866_KOI8R(const char *refname)
                skipping("ru_RU.KOI8-R locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -385,9 +391,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_CP866_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP866_UTF8)
 {
+       const char *refname = "test_read_format_zip_filename_cp866.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -398,6 +404,7 @@ test_read_format_zip_filename_CP866_UTF8(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -440,9 +447,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_KOI8R_CP866(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP866)
 {
+       const char *refname = "test_read_format_zip_filename_koi8r.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -454,6 +461,7 @@ test_read_format_zip_filename_KOI8R_CP866(const char *refname)
                skipping("ru_RU.CP866 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -496,9 +504,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_KOI8R_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8)
 {
+       const char *refname = "test_read_format_zip_filename_koi8r.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -509,6 +517,7 @@ test_read_format_zip_filename_KOI8R_UTF8(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -551,9 +560,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_KOI8R(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_KOI8R)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -565,6 +574,7 @@ test_read_format_zip_filename_UTF8_KOI8R(const char *refname)
                skipping("ru_RU.KOI8-R locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
@@ -612,9 +622,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_CP866(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_CP866)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -628,6 +638,7 @@ test_read_format_zip_filename_UTF8_CP866(const char *refname)
                skipping("ru_RU.CP866 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -676,9 +687,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_UTF8_ru(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8_ru)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -691,6 +702,7 @@ test_read_format_zip_filename_UTF8_UTF8_ru(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -727,9 +739,9 @@ test_read_format_zip_filename_UTF8_UTF8_ru(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_CP932_CP932(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP932_CP932)
 {
+       const char *refname = "test_read_format_zip_filename_cp932.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -741,6 +753,7 @@ test_read_format_zip_filename_CP932_CP932(const char *refname)
                skipping("CP932 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -785,9 +798,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_CP932(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_CP932)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -801,6 +814,7 @@ test_read_format_zip_filename_UTF8_CP932(const char *refname)
                skipping("CP932 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
@@ -861,9 +875,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_CP866_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251)
 {
+       const char *refname = "test_read_format_zip_filename_cp866.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -875,6 +889,7 @@ test_read_format_zip_filename_CP866_CP1251(const char *refname)
                skipping("CP1251 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -923,9 +938,9 @@ cleanup:
  * filenames and store it in the zip file and so we should read
  * it by default on Windows.
  */
-static void
-test_read_format_zip_filename_CP866_CP1251_win(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251_win)
 {
+       const char *refname = "test_read_format_zip_filename_cp866.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -936,6 +951,7 @@ test_read_format_zip_filename_CP866_CP1251_win(const char *refname)
                skipping("Russian_Russia locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -972,9 +988,9 @@ test_read_format_zip_filename_CP866_CP1251_win(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_KOI8R_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP1251)
 {
+       const char *refname = "test_read_format_zip_filename_koi8r.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -986,6 +1002,7 @@ test_read_format_zip_filename_KOI8R_CP1251(const char *refname)
                skipping("CP1251 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -1028,9 +1045,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_zip_filename_UTF8_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_UTF8_CP1251)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -1044,6 +1061,7 @@ test_read_format_zip_filename_UTF8_CP1251(const char *refname)
                skipping("CP1251 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
@@ -1101,9 +1119,9 @@ cleanup:
  * filename of sencod file, which is stored in UTF-8.
  */
 
-static void
-test_read_format_zip_filename_KOI8R_UTF8_2(const char *refname)
+DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8_2)
 {
+       const char *refname = "test_read_format_zip_filename_utf8_ru2.zip";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -1114,6 +1132,7 @@ test_read_format_zip_filename_KOI8R_UTF8_2(const char *refname)
                skipping("en_US.UTF-8 locale not available on this system.");
                return;
        }
+       extract_reference_file(refname);
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
@@ -1203,44 +1222,3 @@ next_test:
        assertEqualInt(ARCHIVE_OK, archive_read_close(a));
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
-
-DEFINE_TEST(test_read_format_zip_filename)
-{
-       const char *refname1 = "test_read_format_zip_filename_cp932.zip";
-       const char *refname2 = "test_read_format_zip_filename_utf8_jp.zip";
-       const char *refname3 = "test_read_format_zip_filename_cp866.zip";
-       const char *refname4 = "test_read_format_zip_filename_koi8r.zip";
-       const char *refname5 = "test_read_format_zip_filename_utf8_ru.zip";
-       const char *refname6 = "test_read_format_zip_filename_utf8_ru2.zip";
-
-       extract_reference_file(refname1);
-       test_read_format_zip_filename_CP932_eucJP(refname1);
-       test_read_format_zip_filename_CP932_UTF8(refname1);
-       test_read_format_zip_filename_CP932_CP932(refname1);
-
-       extract_reference_file(refname2);
-       test_read_format_zip_filename_UTF8_eucJP(refname2);
-       test_read_format_zip_filename_UTF8_UTF8(refname2);
-       test_read_format_zip_filename_UTF8_CP932(refname2);
-
-       extract_reference_file(refname3);
-       test_read_format_zip_filename_CP866_KOI8R(refname3);
-       test_read_format_zip_filename_CP866_UTF8(refname3);
-       test_read_format_zip_filename_CP866_CP1251(refname3);
-       test_read_format_zip_filename_CP866_CP1251_win(refname3);
-
-       extract_reference_file(refname4);
-       test_read_format_zip_filename_KOI8R_CP866(refname4);
-       test_read_format_zip_filename_KOI8R_UTF8(refname4);
-       test_read_format_zip_filename_KOI8R_CP1251(refname4);
-
-       extract_reference_file(refname5);
-       test_read_format_zip_filename_UTF8_KOI8R(refname5);
-       test_read_format_zip_filename_UTF8_CP866(refname5);
-       test_read_format_zip_filename_UTF8_UTF8_ru(refname5);
-       test_read_format_zip_filename_UTF8_CP1251(refname5);
-
-       /* The filenames contained in refname6 are different charset. */
-       extract_reference_file(refname6);
-       test_read_format_zip_filename_KOI8R_UTF8_2(refname6);
-}