Display filename encoding test names respectively to know what encoding test

was successful, failed or skipped.

diff --git a/libarchive/test/test_gnutar_filename_encoding.c b/libarchive/test/test_gnutar_filename_encoding.c
index b22ea407374a7c6d599272122efc5d3b9f846a62..3ec4f61290f8ce62ae03096335fe539e962a5f11 100644 (file)
--- a/libarchive/test/test_gnutar_filename_encoding.c
+++ b/libarchive/test/test_gnutar_filename_encoding.c
@@ -27,8 +27,7 @@ __FBSDID("$FreeBSD$");
 
 #include <locale.h>
 
-static void
-test_gnutar_filename_encoding_UTF8_CP866(void)
+DEFINE_TEST(test_gnutar_filename_encoding_UTF8_CP866)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -69,8 +68,7 @@ test_gnutar_filename_encoding_UTF8_CP866(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_gnutar_filename_encoding_KOI8R_UTF8(void)
+DEFINE_TEST(test_gnutar_filename_encoding_KOI8R_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -111,8 +109,7 @@ test_gnutar_filename_encoding_KOI8R_UTF8(void)
        assertEqualMem(buff, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
 }
 
-static void
-test_gnutar_filename_encoding_KOI8R_CP866(void)
+DEFINE_TEST(test_gnutar_filename_encoding_KOI8R_CP866)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -153,8 +150,7 @@ test_gnutar_filename_encoding_KOI8R_CP866(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_gnutar_filename_encoding_CP1251_UTF8(void)
+DEFINE_TEST(test_gnutar_filename_encoding_CP1251_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -199,8 +195,7 @@ test_gnutar_filename_encoding_CP1251_UTF8(void)
 /*
  * Do not translate CP1251 into CP866 if non Windows platform.
  */
-static void
-test_gnutar_filename_encoding_ru_RU_CP1251(void)
+DEFINE_TEST(test_gnutar_filename_encoding_ru_RU_CP1251)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -240,8 +235,7 @@ test_gnutar_filename_encoding_ru_RU_CP1251(void)
  * into CP866 filenames and store it in the gnutar file.
  * Test above behavior works well.
  */
-static void
-test_gnutar_filename_encoding_Russian_Russia(void)
+DEFINE_TEST(test_gnutar_filename_encoding_Russian_Russia)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -276,8 +270,7 @@ test_gnutar_filename_encoding_Russian_Russia(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_gnutar_filename_encoding_EUCJP_UTF8(void)
+DEFINE_TEST(test_gnutar_filename_encoding_EUCJP_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -317,8 +310,7 @@ test_gnutar_filename_encoding_EUCJP_UTF8(void)
        assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
 }
 
-static void
-test_gnutar_filename_encoding_EUCJP_CP932(void)
+DEFINE_TEST(test_gnutar_filename_encoding_EUCJP_CP932)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -358,8 +350,7 @@ test_gnutar_filename_encoding_EUCJP_CP932(void)
        assertEqualMem(buff, "\x95\x5C.txt", 6);
 }
 
-static void
-test_gnutar_filename_encoding_CP932_UTF8(void)
+DEFINE_TEST(test_gnutar_filename_encoding_CP932_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -400,15 +391,3 @@ test_gnutar_filename_encoding_CP932_UTF8(void)
        assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
 }
 
-DEFINE_TEST(test_gnutar_filename_encoding)
-{
-       test_gnutar_filename_encoding_UTF8_CP866();
-       test_gnutar_filename_encoding_KOI8R_UTF8();
-       test_gnutar_filename_encoding_KOI8R_CP866();
-       test_gnutar_filename_encoding_CP1251_UTF8();
-       test_gnutar_filename_encoding_ru_RU_CP1251();
-       test_gnutar_filename_encoding_Russian_Russia();
-       test_gnutar_filename_encoding_EUCJP_UTF8();
-       test_gnutar_filename_encoding_EUCJP_CP932();
-       test_gnutar_filename_encoding_CP932_UTF8();
-}

diff --git a/libarchive/test/test_pax_filename_encoding.c b/libarchive/test/test_pax_filename_encoding.c
index e03276e411f0e9793ff7f41ea77fac589e96f26c..2d4515e1b3c4b979c4c76aef16771682892832d8 100644 (file)
--- a/libarchive/test/test_pax_filename_encoding.c
+++ b/libarchive/test/test_pax_filename_encoding.c
@@ -335,8 +335,7 @@ test_pax_filename_encoding_3(void)
 /*
  * Verify that KOI8-R filenames are correctly translated to Unicode and UTF-8.
  */
-static void
-test_pax_filename_encoding_KOI8R(void)
+DEFINE_TEST(test_pax_filename_encoding_KOI8R)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -382,8 +381,7 @@ test_pax_filename_encoding_KOI8R(void)
 /*
  * Verify that CP1251 filenames are correctly translated to Unicode and UTF-8.
  */
-static void
-test_pax_filename_encoding_CP1251(void)
+DEFINE_TEST(test_pax_filename_encoding_CP1251)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -430,8 +428,7 @@ test_pax_filename_encoding_CP1251(void)
 /*
  * Verify that EUC-JP filenames are correctly translated to Unicode and UTF-8.
  */
-static void
-test_pax_filename_encoding_EUCJP(void)
+DEFINE_TEST(test_pax_filename_encoding_EUCJP)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -478,8 +475,7 @@ test_pax_filename_encoding_EUCJP(void)
 /*
  * Verify that CP932/SJIS filenames are correctly translated to Unicode and UTF-8.
  */
-static void
-test_pax_filename_encoding_CP932(void)
+DEFINE_TEST(test_pax_filename_encoding_CP932)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -528,8 +524,7 @@ test_pax_filename_encoding_CP932(void)
  * Verify that KOI8-R filenames are not translated to Unicode and UTF-8
  * when using hdrcharset=BINARY option.
  */
-static void
-test_pax_filename_encoding_KOI8R_BINARY(void)
+DEFINE_TEST(test_pax_filename_encoding_KOI8R_BINARY)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -568,8 +563,7 @@ test_pax_filename_encoding_KOI8R_BINARY(void)
  * Pax format writer only accepts both BINARY and UTF-8.
  * If other character-set name is specified, you will get ARCHIVE_FAILED.
  */
-static void
-test_pax_filename_encoding_KOI8R_CP1251(void)
+DEFINE_TEST(test_pax_filename_encoding_KOI8R_CP1251)
 {
        struct archive *a;
 
@@ -592,10 +586,4 @@ DEFINE_TEST(test_pax_filename_encoding)
        test_pax_filename_encoding_1();
        test_pax_filename_encoding_2();
        test_pax_filename_encoding_3();
-       test_pax_filename_encoding_KOI8R();
-       test_pax_filename_encoding_CP1251();
-       test_pax_filename_encoding_EUCJP();
-       test_pax_filename_encoding_CP932();
-       test_pax_filename_encoding_KOI8R_BINARY();
-       test_pax_filename_encoding_KOI8R_CP1251();
 }

diff --git a/libarchive/test/test_read_format_cpio_filename.c b/libarchive/test/test_read_format_cpio_filename.c
index cc2367be823f2ee565ec18417a762334ff927814..cf4f5ac266b37b7c6182661c8a7ba97857a87bd7 100644 (file)
--- a/libarchive/test/test_read_format_cpio_filename.c
+++ b/libarchive/test/test_read_format_cpio_filename.c
@@ -27,9 +27,9 @@ __FBSDID("$FreeBSD");
 
 #include <locale.h>
 
-static void
-test_read_format_cpio_filename_eucJP_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_eucJP_UTF8)
 {
+       const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -40,6 +40,7 @@ test_read_format_cpio_filename_eucJP_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));
@@ -81,9 +82,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_eucJP(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_eucJP)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -94,6 +95,8 @@ test_read_format_cpio_filename_UTF8_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));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
@@ -132,9 +135,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_UTF8_jp(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_jp)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -145,6 +148,7 @@ test_read_format_cpio_filename_UTF8_UTF8_jp(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));
@@ -178,9 +182,9 @@ test_read_format_cpio_filename_UTF8_UTF8_jp(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_CP866_KOI8R(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_CP866_KOI8R)
 {
+       const char *refname = "test_read_format_cpio_filename_cp866.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -192,6 +196,7 @@ test_read_format_cpio_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));
@@ -230,9 +235,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_CP866_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_CP866_UTF8)
 {
+       const char *refname = "test_read_format_cpio_filename_cp866.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -243,6 +248,7 @@ test_read_format_cpio_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));
@@ -281,9 +287,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_KOI8R_CP866(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP866)
 {
+       const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -295,6 +301,7 @@ test_read_format_cpio_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));
@@ -333,9 +340,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_KOI8R_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_KOI8R_UTF8)
 {
+       const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -346,6 +353,7 @@ test_read_format_cpio_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));
@@ -384,9 +392,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_KOI8R(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_KOI8R)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -398,6 +406,7 @@ test_read_format_cpio_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_filter_all(a));
@@ -436,9 +445,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_CP866(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP866)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -450,6 +459,7 @@ test_read_format_cpio_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));
@@ -488,9 +498,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_UTF8_ru(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_ru)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -501,6 +511,7 @@ test_read_format_cpio_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));
@@ -533,9 +544,9 @@ test_read_format_cpio_filename_UTF8_UTF8_ru(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_eucJP_CP932(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_eucJP_CP932)
 {
+       const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -547,6 +558,7 @@ test_read_format_cpio_filename_eucJP_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));
@@ -583,9 +595,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_CP932(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP932)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -597,6 +609,7 @@ test_read_format_cpio_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_filter_all(a));
@@ -634,9 +647,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_CP866_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251)
 {
+       const char *refname = "test_read_format_cpio_filename_cp866.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -648,6 +661,7 @@ test_read_format_cpio_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));
@@ -692,9 +706,9 @@ cleanup:
  * filenames and store it in the cpio file and so we should read
  * it by default on Windows.
  */
-static void
-test_read_format_cpio_filename_CP866_CP1251_win(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251_win)
 {
+       const char *refname = "test_read_format_cpio_filename_cp866.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -705,6 +719,7 @@ test_read_format_cpio_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));
@@ -737,9 +752,9 @@ test_read_format_cpio_filename_CP866_CP1251_win(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_KOI8R_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP1251)
 {
+       const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -751,6 +766,7 @@ test_read_format_cpio_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));
@@ -789,9 +805,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_cpio_filename_UTF8_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP1251)
 {
+       const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -803,6 +819,7 @@ test_read_format_cpio_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_filter_all(a));
@@ -841,38 +858,3 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-
-DEFINE_TEST(test_read_format_cpio_filename)
-{
-       const char *refname1 = "test_read_format_cpio_filename_eucjp.cpio";
-       const char *refname2 = "test_read_format_cpio_filename_utf8_jp.cpio";
-       const char *refname3 = "test_read_format_cpio_filename_cp866.cpio";
-       const char *refname4 = "test_read_format_cpio_filename_koi8r.cpio";
-       const char *refname5 = "test_read_format_cpio_filename_utf8_ru.cpio";
-
-       extract_reference_file(refname1);
-       test_read_format_cpio_filename_eucJP_UTF8(refname1);
-       test_read_format_cpio_filename_eucJP_CP932(refname1);
-
-       extract_reference_file(refname2);
-       test_read_format_cpio_filename_UTF8_eucJP(refname2);
-       test_read_format_cpio_filename_UTF8_UTF8_jp(refname2);
-       test_read_format_cpio_filename_UTF8_CP932(refname2);
-
-       extract_reference_file(refname3);
-       test_read_format_cpio_filename_CP866_KOI8R(refname3);
-       test_read_format_cpio_filename_CP866_UTF8(refname3);
-       test_read_format_cpio_filename_CP866_CP1251(refname3);
-       test_read_format_cpio_filename_CP866_CP1251_win(refname3);
-
-       extract_reference_file(refname4);
-       test_read_format_cpio_filename_KOI8R_CP866(refname4);
-       test_read_format_cpio_filename_KOI8R_UTF8(refname4);
-       test_read_format_cpio_filename_KOI8R_CP1251(refname4);
-
-       extract_reference_file(refname5);
-       test_read_format_cpio_filename_UTF8_KOI8R(refname5);
-       test_read_format_cpio_filename_UTF8_CP866(refname5);
-       test_read_format_cpio_filename_UTF8_UTF8_ru(refname5);
-       test_read_format_cpio_filename_UTF8_CP1251(refname5);
-}

diff --git a/libarchive/test/test_read_format_gtar_filename.c b/libarchive/test/test_read_format_gtar_filename.c
index 41d4f8f1e4640538c152f1278801ecabb152d78c..f81796b786da5670a4c38f814db68dd1c87826ea 100644 (file)
--- a/libarchive/test/test_read_format_gtar_filename.c
+++ b/libarchive/test/test_read_format_gtar_filename.c
@@ -27,9 +27,9 @@ __FBSDID("$FreeBSD");
 
 #include <locale.h>
 
-static void
-test_read_format_gtar_filename_eucJP_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_eucJP_UTF8)
 {
+       const char *refname = "test_read_format_gtar_filename_eucjp.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -40,6 +40,7 @@ test_read_format_gtar_filename_eucJP_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));
@@ -79,9 +80,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_CP866_KOI8R(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_CP866_KOI8R)
 {
+       const char *refname = "test_read_format_gtar_filename_cp866.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -93,6 +94,7 @@ test_read_format_gtar_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));
@@ -131,9 +133,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_CP866_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_CP866_UTF8)
 {
+       const char *refname = "test_read_format_gtar_filename_cp866.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -144,6 +146,7 @@ test_read_format_gtar_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));
@@ -182,9 +185,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_KOI8R_CP866(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_KOI8R_CP866)
 {
+       const char *refname = "test_read_format_gtar_filename_koi8r.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -196,6 +199,7 @@ test_read_format_gtar_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));
@@ -234,9 +238,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_KOI8R_UTF8(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_KOI8R_UTF8)
 {
+       const char *refname = "test_read_format_gtar_filename_koi8r.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -247,6 +251,7 @@ test_read_format_gtar_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));
@@ -285,9 +290,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_eucJP_CP932(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_eucJP_CP932)
 {
+       const char *refname = "test_read_format_gtar_filename_eucjp.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -299,6 +304,7 @@ test_read_format_gtar_filename_eucJP_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));
@@ -335,9 +341,9 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_CP866_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_CP866_CP1251)
 {
+       const char *refname = "test_read_format_gtar_filename_cp866.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -349,6 +355,7 @@ test_read_format_gtar_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));
@@ -393,9 +400,9 @@ cleanup:
  * filenames and store it in the gtar file and so we should read
  * it by default on Windows.
  */
-static void
-test_read_format_gtar_filename_CP866_CP1251_win(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_CP866_CP1251_win)
 {
+       const char *refname = "test_read_format_gtar_filename_cp866.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -406,6 +413,7 @@ test_read_format_gtar_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));
@@ -438,9 +446,9 @@ test_read_format_gtar_filename_CP866_CP1251_win(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-static void
-test_read_format_gtar_filename_KOI8R_CP1251(const char *refname)
+DEFINE_TEST(test_read_format_gtar_filename_KOI8R_CP1251)
 {
+       const char *refname = "test_read_format_gtar_filename_koi8r.tar.Z";
        struct archive *a;
        struct archive_entry *ae;
 
@@ -452,6 +460,7 @@ test_read_format_gtar_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));
@@ -490,25 +499,3 @@ cleanup:
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 }
 
-
-DEFINE_TEST(test_read_format_gtar_filename)
-{
-       const char *refname1 = "test_read_format_gtar_filename_eucjp.tar.Z";
-       const char *refname2 = "test_read_format_gtar_filename_cp866.tar.Z";
-       const char *refname3 = "test_read_format_gtar_filename_koi8r.tar.Z";
-
-       extract_reference_file(refname1);
-       test_read_format_gtar_filename_eucJP_UTF8(refname1);
-       test_read_format_gtar_filename_eucJP_CP932(refname1);
-
-       extract_reference_file(refname2);
-       test_read_format_gtar_filename_CP866_KOI8R(refname2);
-       test_read_format_gtar_filename_CP866_UTF8(refname2);
-       test_read_format_gtar_filename_CP866_CP1251(refname2);
-       test_read_format_gtar_filename_CP866_CP1251_win(refname2);
-
-       extract_reference_file(refname3);
-       test_read_format_gtar_filename_KOI8R_CP866(refname3);
-       test_read_format_gtar_filename_KOI8R_UTF8(refname3);
-       test_read_format_gtar_filename_KOI8R_CP1251(refname3);
-}

diff --git a/libarchive/test/test_ustar_filename_encoding.c b/libarchive/test/test_ustar_filename_encoding.c
index 17b7e4a22764ec87b8f6b1a76b99a83d01f230d0..5e4fba716c13f5d429c88bdc94543df42b24eed2 100644 (file)
--- a/libarchive/test/test_ustar_filename_encoding.c
+++ b/libarchive/test/test_ustar_filename_encoding.c
@@ -27,8 +27,7 @@ __FBSDID("$FreeBSD$");
 
 #include <locale.h>
 
-static void
-test_ustar_filename_encoding_UTF8_CP866(void)
+DEFINE_TEST(test_ustar_filename_encoding_UTF8_CP866)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -69,8 +68,7 @@ test_ustar_filename_encoding_UTF8_CP866(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_ustar_filename_encoding_KOI8R_UTF8(void)
+DEFINE_TEST(test_ustar_filename_encoding_KOI8R_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -111,8 +109,7 @@ test_ustar_filename_encoding_KOI8R_UTF8(void)
        assertEqualMem(buff, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
 }
 
-static void
-test_ustar_filename_encoding_KOI8R_CP866(void)
+DEFINE_TEST(test_ustar_filename_encoding_KOI8R_CP866)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -153,8 +150,7 @@ test_ustar_filename_encoding_KOI8R_CP866(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_ustar_filename_encoding_CP1251_UTF8(void)
+DEFINE_TEST(test_ustar_filename_encoding_CP1251_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -199,8 +195,7 @@ test_ustar_filename_encoding_CP1251_UTF8(void)
 /*
  * Do not translate CP1251 into CP866 if non Windows platform.
  */
-static void
-test_ustar_filename_encoding_ru_RU_CP1251(void)
+DEFINE_TEST(test_ustar_filename_encoding_ru_RU_CP1251)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -240,8 +235,7 @@ test_ustar_filename_encoding_ru_RU_CP1251(void)
  * into CP866 filenames and store it in the ustar file.
  * Test above behavior works well.
  */
-static void
-test_ustar_filename_encoding_Russian_Russia(void)
+DEFINE_TEST(test_ustar_filename_encoding_Russian_Russia)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -276,8 +270,7 @@ test_ustar_filename_encoding_Russian_Russia(void)
        assertEqualMem(buff, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_ustar_filename_encoding_EUCJP_UTF8(void)
+DEFINE_TEST(test_ustar_filename_encoding_EUCJP_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -317,8 +310,7 @@ test_ustar_filename_encoding_EUCJP_UTF8(void)
        assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
 }
 
-static void
-test_ustar_filename_encoding_EUCJP_CP932(void)
+DEFINE_TEST(test_ustar_filename_encoding_EUCJP_CP932)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -358,8 +350,7 @@ test_ustar_filename_encoding_EUCJP_CP932(void)
        assertEqualMem(buff, "\x95\x5C.txt", 6);
 }
 
-static void
-test_ustar_filename_encoding_CP932_UTF8(void)
+DEFINE_TEST(test_ustar_filename_encoding_CP932_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -400,15 +391,3 @@ test_ustar_filename_encoding_CP932_UTF8(void)
        assertEqualMem(buff, "\xE8\xA1\xA8.txt", 7);
 }
 
-DEFINE_TEST(test_ustar_filename_encoding)
-{
-       test_ustar_filename_encoding_UTF8_CP866();
-       test_ustar_filename_encoding_KOI8R_UTF8();
-       test_ustar_filename_encoding_KOI8R_CP866();
-       test_ustar_filename_encoding_CP1251_UTF8();
-       test_ustar_filename_encoding_ru_RU_CP1251();
-       test_ustar_filename_encoding_Russian_Russia();
-       test_ustar_filename_encoding_EUCJP_UTF8();
-       test_ustar_filename_encoding_EUCJP_CP932();
-       test_ustar_filename_encoding_CP932_UTF8();
-}

diff --git a/libarchive/test/test_zip_filename_encoding.c b/libarchive/test/test_zip_filename_encoding.c
index 7ee17196f59d79ffe9ac8e5f046353d7aa011651..54cd00630b8e287894e68661234109065d616abc 100644 (file)
--- a/libarchive/test/test_zip_filename_encoding.c
+++ b/libarchive/test/test_zip_filename_encoding.c
@@ -27,8 +27,7 @@ __FBSDID("$FreeBSD$");
 
 #include <locale.h>
 
-static void
-test_zip_filename_encoding_UTF8(void)
+DEFINE_TEST(test_zip_filename_encoding_UTF8)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -116,8 +115,7 @@ test_zip_filename_encoding_UTF8(void)
        assertEqualMem(buff + 30, "abcABC", 6);
 }
 
-static void
-test_zip_filename_encoding_KOI8R(void)
+DEFINE_TEST(test_zip_filename_encoding_KOI8R)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -217,8 +215,7 @@ test_zip_filename_encoding_KOI8R(void)
 /*
  * Do not translate CP1251 into CP866 if non Windows platform.
  */
-static void
-test_zip_filename_encoding_ru_RU_CP1251(void)
+DEFINE_TEST(test_zip_filename_encoding_ru_RU_CP1251)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -261,8 +258,7 @@ test_zip_filename_encoding_ru_RU_CP1251(void)
  * into CP866 filenames and store it in the zip file.
  * Test above behavior works well.
  */
-static void
-test_zip_filename_encoding_Russian_Russia(void)
+DEFINE_TEST(test_zip_filename_encoding_Russian_Russia)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -331,8 +327,7 @@ test_zip_filename_encoding_Russian_Russia(void)
        assertEqualMem(buff + 30, "\xAF\xE0\xA8", 3);
 }
 
-static void
-test_zip_filename_encoding_EUCJP(void)
+DEFINE_TEST(test_zip_filename_encoding_EUCJP)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -431,8 +426,7 @@ test_zip_filename_encoding_EUCJP(void)
        assertEqualMem(buff + 30, "abcABC", 6);
 }
 
-static void
-test_zip_filename_encoding_CP932(void)
+DEFINE_TEST(test_zip_filename_encoding_CP932)
 {
        struct archive *a;
        struct archive_entry *entry;
@@ -531,13 +525,3 @@ test_zip_filename_encoding_CP932(void)
        assertEqualInt(0, buff[7]);
        assertEqualMem(buff + 30, "abcABC", 6);
 }
-
-DEFINE_TEST(test_zip_filename_encoding)
-{
-       test_zip_filename_encoding_UTF8();
-       test_zip_filename_encoding_KOI8R();
-       test_zip_filename_encoding_ru_RU_CP1251();
-       test_zip_filename_encoding_Russian_Russia();
-       test_zip_filename_encoding_EUCJP();
-       test_zip_filename_encoding_CP932();
-}