Add some test for zip reader.

 - read Russian filenames in KOI8-R.
 - read Russian filenames in CP866.
 - read Russian filenames in UTF-8.

SVN-Revision: 3176

diff --git a/Makefile.am b/Makefile.am
index 11cbc86f739d642516dcfcffa5755d72f5162e07..8632f0d924eb35c447b9f9d3885c1310c6cab44c 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -461,8 +461,11 @@ libarchive_test_EXTRA_DIST=\
        libarchive/test/test_read_format_raw.data.uu                    \
        libarchive/test/test_read_format_tar_empty_filename.tar.uu      \
        libarchive/test/test_read_format_zip.zip.uu                     \
+       libarchive/test/test_read_format_zip_cp866.zip.uu               \
        libarchive/test/test_read_format_zip_cp932.zip.uu               \
+       libarchive/test/test_read_format_zip_koi8r.zip.uu               \
        libarchive/test/test_read_format_zip_utf8.zip.uu                \
+       libarchive/test/test_read_format_zip_utf8_ru.zip.uu             \
        libarchive/test/CMakeLists.txt                                  \
        libarchive/test/README
 

diff --git a/libarchive/test/test_read_format_zip_cp866.zip.uu b/libarchive/test/test_read_format_zip_cp866.zip.uu
new file mode 100644 (file)
index 0000000..52c6770
--- /dev/null
+++ b/libarchive/test/test_read_format_zip_cp866.zip.uu
@@ -0,0 +1,10 @@
+begin 644 test_read_format_zip_cp866.zip
+M4$L#!`H``````%VEAS[,X8$4!@````8````&`!P`CY"(@H62550)``-!HYU-
+M0:.=375X"P`!!.D#```$Z0,``/#RZ??E]%!+`P0*``````!=I8<^S.&!%`8`
+M```&````!@`<`*_@J**EXE54"0`#0:.=34&CG4UU>`L``03I`P``!.D#``#P
+M\NGWY?102P$"'@,*``````!=I8<^S.&!%`8````&````!@`8```````!````
+M[8$`````CY"(@H62550%``-!HYU-=7@+``$$Z0,```3I`P``4$L!`AX#"@``
+M````7:6'/LSA@10&````!@````8`&````````0```.V!1@```*_@J**EXE54
+L!0`#0:.=375X"P`!!.D#```$Z0,``%!+!08``````@`"`)@```",````````
+`
+end

diff --git a/libarchive/test/test_read_format_zip_filename.c b/libarchive/test/test_read_format_zip_filename.c
index a45953a5ea0dc350989132dad63458cdffbe5fcf..aa476593d6b4bf29d364aeb94a3db499fa20331d 100644 (file)
--- a/libarchive/test/test_read_format_zip_filename.c
+++ b/libarchive/test/test_read_format_zip_filename.c
@@ -258,10 +258,379 @@ 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)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
+               skipping("ru_RU.KOI8-R locale not available on this system.");
+               return;
+       }
+
+       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));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
+               skipping("This system cannot convert character-set"
+                   " from CP866 to KOI8-R.");
+               goto cleanup;
+       }
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_CP866_UTF8(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.UTF-8 with "hdrcharset=CP866" option.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.UTF-8")) {
+               skipping("ru_RU.UTF-8 locale not available on this system.");
+               return;
+       }
+
+       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));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
+               skipping("This system cannot convert character-set"
+                   " from CP866 to UTF-8.");
+               goto cleanup;
+       }
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_KOI8R_CP866(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
+               skipping("ru_RU.CP866 locale not available on this system.");
+               return;
+       }
+
+       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));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
+               skipping("This system cannot convert character-set"
+                   " from KOI8-R to CP866.");
+               goto cleanup;
+       }
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\x8f\x90\x88\x82\x85\x92",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_KOI8R_UTF8(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.UTF-8 with "hdrcharset=KOI8-R" option.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.UTF-8")) {
+               skipping("ru_RU.UTF-8 locale not available on this system.");
+               return;
+       }
+
+       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));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
+               skipping("This system cannot convert character-set"
+                   " from KOI8-R to UTF-8.");
+               goto cleanup;
+       }
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_UTF8_KOI8R(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
+               skipping("ru_RU.KOI8-R locale not available on this system.");
+               return;
+       }
+
+       assert((a = archive_read_new()) != NULL);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
+               skipping("This system cannot convert character-set"
+                   " from UTF-8 to KOI8-R.");
+               goto cleanup;
+       }
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+
+       /* Re-create a read archive object. */
+       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));
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_UTF8_CP866(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.CP866 without charset option
+        * because the file name in the sample file is UTF-8 and
+        * Bit 11 of its general purpose bit flag is set.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
+               skipping("ru_RU.CP866 locale not available on this system.");
+               return;
+       }
+
+       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));
+       if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
+               skipping("This system cannot convert character-set"
+                   " from UTF-8 to CP866.");
+               goto cleanup;
+       }
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+
+       /* Re-create a read archive object. */
+       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));
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\x8f\x90\x88\x82\x85\x92",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+cleanup:
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
+static void
+test_read_format_zip_filename_UTF8_UTF8_ru(const char *refname)
+{
+       struct archive *a;
+       struct archive_entry *ae;
+
+       /*
+        * Read ZIP filename in ru_RU.UTF-8 without charset option
+        * because the file name in the sample file is UTF-8 and
+        * Bit 11 of its general purpose bit flag is set.
+        */
+       if (NULL == setlocale(LC_ALL, "ru_RU.UTF-8")) {
+               skipping("ru_RU.UTF-8 locale not available on this system.");
+               return;
+       }
+
+       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));
+       assertEqualIntA(a, ARCHIVE_OK,
+           archive_read_open_filename(a, refname, 10240));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+       /* Verify regular file. */
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
+       assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
+           archive_entry_pathname(ae));
+       assertEqualInt(6, archive_entry_size(ae));
+
+
+       /* End of archive. */
+       assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
+
+       /* Verify archive format. */
+       assertEqualIntA(a, ARCHIVE_COMPRESSION_NONE, archive_compression(a));
+       assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
+
+       /* Close the archive. */
+       assertEqualInt(ARCHIVE_OK, archive_read_close(a));
+       assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+}
+
 DEFINE_TEST(test_read_format_zip_filename)
 {
        const char *refname = "test_read_format_zip_cp932.zip";
        const char *refname2 = "test_read_format_zip_utf8.zip";
+       const char *refname3 = "test_read_format_zip_cp866.zip";
+       const char *refname4 = "test_read_format_zip_koi8r.zip";
+       const char *refname5 = "test_read_format_zip_utf8_ru.zip";
 
        extract_reference_file(refname);
        test_read_format_zip_filename_CP932_eucJP(refname);
@@ -269,4 +638,14 @@ DEFINE_TEST(test_read_format_zip_filename)
        extract_reference_file(refname2);
        test_read_format_zip_filename_UTF8_eucJP(refname2);
        test_read_format_zip_filename_UTF8_UTF8(refname2);
+       extract_reference_file(refname3);
+       test_read_format_zip_filename_CP866_KOI8R(refname3);
+       test_read_format_zip_filename_CP866_UTF8(refname3);
+       extract_reference_file(refname4);
+       test_read_format_zip_filename_KOI8R_CP866(refname4);
+       test_read_format_zip_filename_KOI8R_UTF8(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);
 }

diff --git a/libarchive/test/test_read_format_zip_koi8r.zip.uu b/libarchive/test/test_read_format_zip_koi8r.zip.uu
new file mode 100644 (file)
index 0000000..05c6695
--- /dev/null
+++ b/libarchive/test/test_read_format_zip_koi8r.zip.uu
@@ -0,0 +1,10 @@
+begin 644 test_read_format_zip_koi8r.zip
+M4$L#!`H``````+&CAS[,X8$4!@````8````&`!P`T-+)U\74550)``,>H)U-
+M'J"=375X"P`!!.D#```$Z0,``/#RZ??E]%!+`P0*``````"QHX<^S.&!%`8`
+M```&````!@`<`/#RZ??E]%54"0`#'J"=31Z@G4UU>`L``03I`P``!.D#``#P
+M\NGWY?102P$"'@,*``````"QHX<^S.&!%`8````&````!@`8```````!````
+M[8$`````T-+)U\74550%``,>H)U-=7@+``$$Z0,```3I`P``4$L!`AX#"@``
+M````L:.'/LSA@10&````!@````8`&````````0```.V!1@```/#RZ??E]%54
+L!0`#'J"=375X"P`!!.D#```$Z0,``%!+!08``````@`"`)@```",````````
+`
+end

diff --git a/libarchive/test/test_read_format_zip_utf8_ru.zip.uu b/libarchive/test/test_read_format_zip_utf8_ru.zip.uu
new file mode 100644 (file)
index 0000000..9241776
--- /dev/null
+++ b/libarchive/test/test_read_format_zip_utf8_ru.zip.uu
@@ -0,0 +1,11 @@
+begin 644 test_read_format_zip_utf8_ru.zip
+M4$L#!`H```@``,NC/S[,X8$4!@````8````,`!P`T)_0H-"8T)+0E="B550)
+M``-.G49-'J"=375X"P`!!.D#```$Z0,``/#RZ??E]%!+`P0*```(``!KI3\^
+MS.&!%`8````&````#``<`-"_T8#0N-"RT+71@E54"0`#6J!&31Z@G4UU>`L`
+M`03I`P``!.D#``#P\NGWY?102P$"'@,*```(``#+HS\^S.&!%`8````&````
+M#``8```````!````[8$`````T)_0H-"8T)+0E="B550%``-.G49-=7@+``$$
+MZ0,```3I`P``4$L!`AX#"@``"```:Z4_/LSA@10&````!@````P`&```````
+M`0```.V!3````-"_T8#0N-"RT+71@E54!0`#6J!&375X"P`!!.D#```$Z0,`
+7`%!+!08``````@`"`*0```"8````````
+`
+end