tests use archive_read_support_filter_*()

SVN-Revision: 3114

diff --git a/libarchive/test/test_acl_pax.c b/libarchive/test/test_acl_pax.c
index b73d04d9e040073506464357c6d199e6aaa6236d..6a7ee1516491f3de4dc6cb38266bd4f516db2156 100644 (file)
--- a/libarchive/test/test_acl_pax.c
+++ b/libarchive/test/test_acl_pax.c
@@ -240,7 +240,7 @@ DEFINE_TEST(test_acl_pax)
        /* Read back each entry and check that the ACL data is right. */
        assert(NULL != (a = archive_read_new()));
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, used));
 
        /* First item has no ACLs */

diff --git a/libarchive/test/test_archive_read_set_filter_option.c b/libarchive/test/test_archive_read_set_filter_option.c
index 0cb1adea3168d776b58cbf26a2afd004e5fd75f6..7ff3c267947d13fc668b09698a0acc3840045431 100644 (file)
--- a/libarchive/test/test_archive_read_set_filter_option.c
+++ b/libarchive/test/test_archive_read_set_filter_option.c
@@ -35,7 +35,7 @@ test(int pristine)
        struct archive* a = archive_read_new();
 
        if (!pristine)
-               archive_read_support_compression_all(a);
+               archive_read_support_filter_all(a);
 
        should(a, ARCHIVE_OK, NULL, NULL, NULL);
        should(a, ARCHIVE_OK, "", "", "");

diff --git a/libarchive/test/test_archive_read_set_option.c b/libarchive/test/test_archive_read_set_option.c
index 929a9a1bfa2b09f838ec119afdba65de168ab837..2ad5b0bda8e240716bba320541760299826c6bb7 100644 (file)
--- a/libarchive/test/test_archive_read_set_option.c
+++ b/libarchive/test/test_archive_read_set_option.c
@@ -36,7 +36,7 @@ test(int pristine)
        int known_option_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_OK;
 
        if (!pristine) {
-               archive_read_support_compression_all(a);
+               archive_read_support_filter_all(a);
                archive_read_support_format_all(a);
         }
 

diff --git a/libarchive/test/test_archive_read_set_options.c b/libarchive/test/test_archive_read_set_options.c
index c71b93f61d4c77e87b52cb88a8847bfba48bdcac..a199afe44524d2d82a2263a4db1cd867a2773b29 100644 (file)
--- a/libarchive/test/test_archive_read_set_options.c
+++ b/libarchive/test/test_archive_read_set_options.c
@@ -38,7 +38,7 @@ test(int pristine)
        int mixed_options_rv = pristine ? ARCHIVE_FAILED : ARCHIVE_WARN;
 
        if (!pristine) {
-               archive_read_support_compression_all(a);
+               archive_read_support_filter_all(a);
                archive_read_support_format_all(a);
         }
 

diff --git a/libarchive/test/test_bad_fd.c b/libarchive/test/test_bad_fd.c
index 34331b8b30fb7cfffdc4b6a61d2a2fc40433a524..f8144a3c39a45f56edeac24782d8a75d2d7b2f2a 100644 (file)
--- a/libarchive/test/test_bad_fd.c
+++ b/libarchive/test/test_bad_fd.c
@@ -30,7 +30,7 @@ DEFINE_TEST(test_bad_fd)
 {
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(ARCHIVE_FATAL == archive_read_open_fd(a, -1, 1024));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_compat_bzip2.c b/libarchive/test/test_compat_bzip2.c
index cdfbdd7a5ed05cde38639a455f3719f68ec022fc..d0726a1d36a0ff7ef7c3481d29f47dfceeec3c35 100644 (file)
--- a/libarchive/test/test_compat_bzip2.c
+++ b/libarchive/test/test_compat_bzip2.c
@@ -47,7 +47,7 @@ compat_bzip2(const char *name)
        int i;
 
        assert((a = archive_read_new()) != NULL);
-       if (ARCHIVE_OK != archive_read_support_compression_bzip2(a)) {
+       if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
                skipping("Unsupported bzip2");
                return;
        }

diff --git a/libarchive/test/test_compat_cpio.c b/libarchive/test/test_compat_cpio.c
index 19ce48d581434fee01256fdd9e1d5c87ab682ab5..e1e4e13997f63146cc4e103a66e46a1449c33d5a 100644 (file)
--- a/libarchive/test/test_compat_cpio.c
+++ b/libarchive/test/test_compat_cpio.c
@@ -48,7 +48,7 @@ test_compat_cpio_1(void)
        struct archive *a;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 17));

diff --git a/libarchive/test/test_compat_gtar.c b/libarchive/test/test_compat_gtar.c
index d3c32dbbe3e68fcfc1e21d29c24517a13b459ee1..f8f3ec06d280c045deb72dae525b48ee8d5c3ce8 100644 (file)
--- a/libarchive/test/test_compat_gtar.c
+++ b/libarchive/test/test_compat_gtar.c
@@ -46,7 +46,7 @@ test_compat_gtar_1(void)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

diff --git a/libarchive/test/test_compat_gzip.c b/libarchive/test/test_compat_gzip.c
index b323e694da656a1334145f4824febcd10509ee34..885c681415ec075c145e71c09e24957807055775 100644 (file)
--- a/libarchive/test/test_compat_gzip.c
+++ b/libarchive/test/test_compat_gzip.c
@@ -47,7 +47,7 @@ verify(const char *name)
        int i,r;
 
        assert((a = archive_read_new()) != NULL);
-       r = archive_read_support_compression_gzip(a);
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_compat_lzip.c b/libarchive/test/test_compat_lzip.c
index 0b414e09bcd4b68b6a43b69aece7f4aab6337c09..f474cd49e1d7a257909226cd7fda2812ec3d6782 100644 (file)
--- a/libarchive/test/test_compat_lzip.c
+++ b/libarchive/test/test_compat_lzip.c
@@ -98,8 +98,8 @@ compat_lzip(const char *name)
        int i, r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzip(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_compat_lzma.c b/libarchive/test/test_compat_lzma.c
index f35456338fb942381afd0720fe05a10af4ebfd52..8d37dd1879f693e77ae1fcec427f7a501468e2e9 100644 (file)
--- a/libarchive/test/test_compat_lzma.c
+++ b/libarchive/test/test_compat_lzma.c
@@ -107,8 +107,8 @@ compat_lzma(const char *name)
        int i, r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzma(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_compat_mac_gnutar.c b/libarchive/test/test_compat_mac_gnutar.c
index 5e6386c45deb931d9ab16e970b58484453adba73..b9aa1f711a7541bcdb3c13a502995a7c3ce07da4 100644 (file)
--- a/libarchive/test/test_compat_mac_gnutar.c
+++ b/libarchive/test/test_compat_mac_gnutar.c
@@ -48,7 +48,7 @@ DEFINE_TEST(test_compat_mac_gnutar)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

diff --git a/libarchive/test/test_compat_solaris_tar_acl.c b/libarchive/test/test_compat_solaris_tar_acl.c
index 0f2355c14c17b0cfc50eb12a33e0c83c068de769..a0cf9a8ad8ff668dffa1d0ac55f9a339eec55e67 100644 (file)
--- a/libarchive/test/test_compat_solaris_tar_acl.c
+++ b/libarchive/test/test_compat_solaris_tar_acl.c
@@ -45,7 +45,7 @@ DEFINE_TEST(test_compat_solaris_tar_acl)
        extract_reference_file(reference1);
        assert(NULL != (a = archive_read_new()));
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_filename(a, reference1, 512));
 
        /* Archive has 1 entry with some ACLs set on it. */

diff --git a/libarchive/test/test_compat_tar_hardlink.c b/libarchive/test/test_compat_tar_hardlink.c
index 4708cd3e8ec1fa49793938a2e3f931a8bc2fd872..21466d7c508d83ab25dcafc40dadbfa7e73d018e 100644 (file)
--- a/libarchive/test/test_compat_tar_hardlink.c
+++ b/libarchive/test/test_compat_tar_hardlink.c
@@ -51,7 +51,7 @@ test_compat_tar_hardlink_1(void)
        struct archive *a;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

diff --git a/libarchive/test/test_compat_xz.c b/libarchive/test/test_compat_xz.c
index e71c06667733932ecfbb16e3f1913939fa73f978..551edcc5733bd6c5eab979b54059154b5022e5db 100644 (file)
--- a/libarchive/test/test_compat_xz.c
+++ b/libarchive/test/test_compat_xz.c
@@ -46,8 +46,8 @@ compat_xz(const char *name)
        int i, r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_xz(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_compat_zip.c b/libarchive/test/test_compat_zip.c
index d7253eda705096f5204691b83d3183730b3dd932..8a3306af19ee92d39ddc29b978455dd9f35ee1b6 100644 (file)
--- a/libarchive/test/test_compat_zip.c
+++ b/libarchive/test/test_compat_zip.c
@@ -35,7 +35,7 @@ test_compat_zip_1(void)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));
@@ -81,7 +81,7 @@ test_compat_zip_2(void)
        struct archive *a;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

diff --git a/libarchive/test/test_filter_count.c b/libarchive/test/test_filter_count.c
index d4a5a727e73937487b5bae59056a81c1201c4a16..3f587e33852f43c3567d417ebc4d2aceccdcb1a7 100644 (file)
--- a/libarchive/test/test_filter_count.c
+++ b/libarchive/test/test_filter_count.c
@@ -29,7 +29,7 @@ void
 read_test(const char *name)
 {
        struct archive* a = archive_read_new();
-       if(ARCHIVE_OK != archive_read_support_compression_bzip2(a)) {
+       if(ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
                skipping("bzip2 unsupported");
                return;
        }

diff --git a/libarchive/test/test_fuzz.c b/libarchive/test/test_fuzz.c
index c89a3dd7276caadb4bfe9431cd4aaf343f9190e6..449d3cbf2ab994083ee86c72463c423d5a7e4e21 100644 (file)
--- a/libarchive/test/test_fuzz.c
+++ b/libarchive/test/test_fuzz.c
@@ -98,7 +98,7 @@ DEFINE_TEST(test_fuzz)
                        /* Use format_raw to decompress the data. */
                        assert((a = archive_read_new()) != NULL);
                        assertEqualIntA(a, ARCHIVE_OK,
-                           archive_read_support_compression_all(a));
+                           archive_read_support_filter_all(a));
                        assertEqualIntA(a, ARCHIVE_OK,
                            archive_read_support_format_raw(a));
                        r = archive_read_open_filename(a, filename, 16384);
@@ -162,7 +162,7 @@ DEFINE_TEST(test_fuzz)
 
                        assert((a = archive_read_new()) != NULL);
                        assertEqualIntA(a, ARCHIVE_OK,
-                           archive_read_support_compression_all(a));
+                           archive_read_support_filter_all(a));
                        assertEqualIntA(a, ARCHIVE_OK,
                            archive_read_support_format_all(a));
 

diff --git a/libarchive/test/test_open_failure.c b/libarchive/test/test_open_failure.c
index f3a65d5c33d1bc1542c210a76b30ff9043318c55..cfc3062c86bf66197fe23146b37a376a2c804ddd 100644 (file)
--- a/libarchive/test/test_open_failure.c
+++ b/libarchive/test/test_open_failure.c
@@ -132,7 +132,7 @@ DEFINE_TEST(test_open_failure)
        a = archive_read_new();
        assert(a != NULL);
        assertEqualInt(ARCHIVE_OK,
-           archive_read_support_compression_compress(a));
+           archive_read_support_filter_compress(a));
        assertEqualInt(ARCHIVE_OK, archive_read_support_format_tar(a));
        assertEqualInt(ARCHIVE_FATAL,
            archive_read_open(a, &private, my_open, my_read, my_close));

diff --git a/libarchive/test/test_open_fd.c b/libarchive/test/test_open_fd.c
index 3461535ad96cf0798828d387680e89f90061b1d7..52b34bd125f7e639367a7afd89b633291aed217d 100644 (file)
--- a/libarchive/test/test_open_fd.c
+++ b/libarchive/test/test_open_fd.c
@@ -87,7 +87,7 @@ DEFINE_TEST(test_open_fd)
        assert(lseek(fd, 0, SEEK_SET) == 0);
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_fd(a, fd, 512));
 
        assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
@@ -119,7 +119,7 @@ DEFINE_TEST(test_open_fd)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        /* FD 100 shouldn't be open. */
        assertEqualIntA(a, ARCHIVE_FATAL,
            archive_read_open_fd(a, 100, 512));

diff --git a/libarchive/test/test_open_file.c b/libarchive/test/test_open_file.c
index 5153f5a929ae298a7557897cc8caeb90ff415478..4308f024344b5cd7a60a78a6b886152178acccae 100644 (file)
--- a/libarchive/test/test_open_file.c
+++ b/libarchive/test/test_open_file.c
@@ -79,7 +79,7 @@ DEFINE_TEST(test_open_file)
                return;
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_FILE(a, f));
 
        assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_open_filename.c b/libarchive/test/test_open_filename.c
index e0c7852299bbd3cbc39c01a4938e3ceba5f46e48..ca3ac272383cf120c2f48041842c8941f162735e 100644 (file)
--- a/libarchive/test/test_open_filename.c
+++ b/libarchive/test/test_open_filename.c
@@ -69,7 +69,7 @@ DEFINE_TEST(test_open_filename)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_open_filename(a, "test.tar", 512));
 
@@ -100,7 +100,7 @@ DEFINE_TEST(test_open_filename)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_FATAL,
            archive_read_open_filename(a, "nonexistent.tar", 512));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));

diff --git a/libarchive/test/test_pax_filename_encoding.c b/libarchive/test/test_pax_filename_encoding.c
index 85cbc45ce46285384fdce8c057a8b7a8c38db5f2..56729a2ce020905d0f694493a74e61a0d79faeab 100644 (file)
--- a/libarchive/test/test_pax_filename_encoding.c
+++ b/libarchive/test/test_pax_filename_encoding.c
@@ -58,7 +58,7 @@ test_pax_filename_encoding_1(void)
        extract_reference_file(testname);
        a = archive_read_new();
        assertEqualInt(ARCHIVE_OK, archive_read_support_format_tar(a));
-       assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualInt(ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, testname, 10240));
        /*

diff --git a/libarchive/test/test_read_compress_program.c b/libarchive/test/test_read_compress_program.c
index 6ef7277aea07a264be9469aa87b7d969f9f3f1c1..751abd54fc91eb447838cb6f457724e1624f3de5 100644 (file)
--- a/libarchive/test/test_read_compress_program.c
+++ b/libarchive/test/test_read_compress_program.c
@@ -43,9 +43,9 @@ DEFINE_TEST(test_read_compress_program)
         * program is requested.
         */
        assert((a = archive_read_new()) != NULL);
-       r = archive_read_support_compression_program(a, "nonexistent");
+       r = archive_read_support_filter_program(a, "nonexistent");
        if (r == ARCHIVE_FATAL) {
-               skipping("archive_read_support_compression_program() "
+               skipping("archive_read_support_filter_program() "
                    "unsupported on this platform");
                return;
        }
@@ -66,9 +66,9 @@ DEFINE_TEST(test_read_compress_program)
        }
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_none(a));
+           archive_read_support_filter_none(a));
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_program(a, "gunzip"));
+           archive_read_support_filter_program(a, "gunzip"));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_read_data_large.c b/libarchive/test/test_read_data_large.c
index 5756d7bfc00043493e7e3a1f8f2568e425286c33..a35be8250c3eccbaa8628ebb0852372c1a0a817a 100644 (file)
--- a/libarchive/test/test_read_data_large.c
+++ b/libarchive/test/test_read_data_large.c
@@ -78,7 +78,7 @@ DEFINE_TEST(test_read_data_large)
        /* Check that archive_read_data can handle 10*10^6 at a pop. */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff1, sizeof(buff1)));
        assertA(0 == archive_read_next_header(a, &ae));
        failure("Wrote 10MB, but didn't read the same amount");
@@ -91,7 +91,7 @@ DEFINE_TEST(test_read_data_large)
        /* Check archive_read_data_into_fd */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff1, sizeof(buff1)));
        assertA(0 == archive_read_next_header(a, &ae));
 #if defined(__BORLANDC__)

diff --git a/libarchive/test/test_read_extract.c b/libarchive/test/test_read_extract.c
index bf84055a78720c53292ed039e2e2d015cadb9f32..d7de26b6ee6188822d16e1aad9c35a62f97baa49 100644 (file)
--- a/libarchive/test/test_read_extract.c
+++ b/libarchive/test/test_read_extract.c
@@ -117,7 +117,7 @@ DEFINE_TEST(test_read_extract)
        /* Extract the entries to disk. */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, BUFF_SIZE));
        /* Restore first entry with _EXTRACT_PERM. */
        failure("Error reading first entry", i);

diff --git a/libarchive/test/test_read_format_ar.c b/libarchive/test/test_read_format_ar.c
index 9094d106a97f074ccc649664df9e713b776298af..c4694378d8d415da53d8af26baf40170360c2933 100644 (file)
--- a/libarchive/test/test_read_format_ar.c
+++ b/libarchive/test/test_read_format_ar.c
@@ -38,7 +38,7 @@ DEFINE_TEST(test_read_format_ar)
 
        extract_reference_file(reffile);
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_file(a, reffile, 7));
 

diff --git a/libarchive/test/test_read_format_cab.c b/libarchive/test/test_read_format_cab.c
index 453f23d9a7bb4ba273a47b0e88af18d05e1565bd..c1e6f7401092e8138f697acc70c4ee164f9a26f0 100644 (file)
--- a/libarchive/test/test_read_format_cab.c
+++ b/libarchive/test/test_read_format_cab.c
@@ -186,7 +186,7 @@ verify(const char *refname, enum comp_type comp)
        memset(zero, 0, sizeof(zero));
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));

diff --git a/libarchive/test/test_read_format_cab_filename.c b/libarchive/test/test_read_format_cab_filename.c
index 862cb88b9d5a59e0bc47034898b82e84e308a93d..f3cf1089c658f9784585200525a5619026385d27 100644 (file)
--- a/libarchive/test/test_read_format_cab_filename.c
+++ b/libarchive/test/test_read_format_cab_filename.c
@@ -42,7 +42,7 @@ test_read_format_cab_filename_CP932_eucJP(const char *refname)
        }
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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, "charset=CP932")) {
                skipping("This system cannot convert character-set"
@@ -95,7 +95,7 @@ test_read_format_cab_filename_CP932_UTF8(const char *refname)
        }
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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, "charset=CP932")) {
                skipping("This system cannot convert character-set"

diff --git a/libarchive/test/test_read_format_cpio_afio.c b/libarchive/test/test_read_format_cpio_afio.c
index 229758ed60e0a507b2c1b6f90db04ef2a9157a39..7aec833c2302985df61ed40f535af3cee1d2b2dc 100644 (file)
--- a/libarchive/test/test_read_format_cpio_afio.c
+++ b/libarchive/test/test_read_format_cpio_afio.c
@@ -89,7 +89,7 @@ DEFINE_TEST(test_read_format_cpio_afio)
        memset(p, 0, size);
        memcpy(p, archive, sizeof(archive));
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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_memory(a, p, size));
        /*

diff --git a/libarchive/test/test_read_format_cpio_bin.c b/libarchive/test/test_read_format_cpio_bin.c
index 78146ba19a3470eba2a111eb9e8a76aac9a695bd..9b0a19a2731467c6ee8406d3faa328571577d4cb 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin.c
+++ b/libarchive/test/test_read_format_cpio_bin.c
@@ -47,7 +47,7 @@ DEFINE_TEST(test_read_format_cpio_bin)
        struct archive_entry *ae;
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_memory(a, archive, sizeof(archive)));
        assertA(0 == archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_read_format_cpio_bin_Z.c b/libarchive/test/test_read_format_cpio_bin_Z.c
index 5c0765aa947950bca140bb23b3750988ea503f85..99cb26203c503f815375c2c85ea7b580842096b8 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_Z.c
+++ b/libarchive/test/test_read_format_cpio_bin_Z.c
@@ -37,7 +37,7 @@ DEFINE_TEST(test_read_format_cpio_bin_Z)
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_read_format_cpio_bin_be.c b/libarchive/test/test_read_format_cpio_bin_be.c
index 11f8295649623c2aca491ddfbbaba8abd28e7f9f..534471a1ca8a44ce83f8d0f5c6d3f40e999bb935 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_be.c
+++ b/libarchive/test/test_read_format_cpio_bin_be.c
@@ -33,7 +33,7 @@ DEFINE_TEST(test_read_format_cpio_bin_be)
 
        extract_reference_file(reference);
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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, reference, 10));

diff --git a/libarchive/test/test_read_format_cpio_bin_bz2.c b/libarchive/test/test_read_format_cpio_bin_bz2.c
index a526ed10a2e18ab48db85e4e00c647074e722fd3..c19efed88db24a7fdbda36d1643cdaedda49de4c 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_bz2.c
+++ b/libarchive/test/test_read_format_cpio_bin_bz2.c
@@ -39,7 +39,7 @@ DEFINE_TEST(test_read_format_cpio_bin_bz2)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       r = archive_read_support_compression_bzip2(a);
+       r = archive_read_support_filter_bzip2(a);
        if (r != ARCHIVE_OK) {
                skipping("bzip2 support unavailable");
                archive_read_close(a);

diff --git a/libarchive/test/test_read_format_cpio_bin_gz.c b/libarchive/test/test_read_format_cpio_bin_gz.c
index ecb6bf1205d9d0201f0a2b92a15df9dbf65f4c75..a807b5b190ae7c23e5b2423e601b663e935c9ec6 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_gz.c
+++ b/libarchive/test/test_read_format_cpio_bin_gz.c
@@ -38,14 +38,14 @@ DEFINE_TEST(test_read_format_cpio_bin_gz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualInt(ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));
                return;
        }
-       failure("archive_read_support_compression_gzip");
+       failure("archive_read_support_filter_gzip");
        assertEqualInt(ARCHIVE_OK, r);
        assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,

diff --git a/libarchive/test/test_read_format_cpio_bin_lzip.c b/libarchive/test/test_read_format_cpio_bin_lzip.c
index bb92f18ece632e591f08d673378847ecd9dc0d40..16effb91652b0218062cda8aa5067b2505619c4c 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_lzip.c
+++ b/libarchive/test/test_read_format_cpio_bin_lzip.c
@@ -42,8 +42,8 @@ DEFINE_TEST(test_read_format_cpio_bin_lzip)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzip(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_cpio_bin_lzma.c b/libarchive/test/test_read_format_cpio_bin_lzma.c
index 0c15de99c0b0e3ff4f49a90eb78d38316250ca19..e168e2f9c55ad4293eee1180e4ca2ee5ed7b42bb 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_lzma.c
+++ b/libarchive/test/test_read_format_cpio_bin_lzma.c
@@ -41,8 +41,8 @@ DEFINE_TEST(test_read_format_cpio_bin_lzma)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzma(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_cpio_bin_xz.c b/libarchive/test/test_read_format_cpio_bin_xz.c
index 4383e7f512924dc957976900058014c171e76be8..7c65da67751dbcc3483931a374510f4b7c25634f 100644 (file)
--- a/libarchive/test/test_read_format_cpio_bin_xz.c
+++ b/libarchive/test/test_read_format_cpio_bin_xz.c
@@ -51,8 +51,8 @@ DEFINE_TEST(test_read_format_cpio_bin_xz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_xz(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_cpio_odc.c b/libarchive/test/test_read_format_cpio_odc.c
index 4d42e1729e60c5756727d6dcfda8ab0377ada679..cdcf0b5aff31e87d803791fd1b5c6c21ca1b3dc7 100644 (file)
--- a/libarchive/test/test_read_format_cpio_odc.c
+++ b/libarchive/test/test_read_format_cpio_odc.c
@@ -51,7 +51,7 @@ DEFINE_TEST(test_read_format_cpio_odc)
        struct archive_entry *ae;
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_memory(a, archive, sizeof(archive)));
        assertEqualIntA(a, 0, archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c b/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c
index 9c0b92e00f036609a10aafc647da18b9fcd629d7..f0d27a3d0c0f4caa5e75490850f3420ad5e5dcc0 100644 (file)
--- a/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c
+++ b/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c
@@ -90,7 +90,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_bzip2_rpm)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-        r = archive_read_support_compression_bzip2(a);
+        r = archive_read_support_filter_bzip2(a);
        if (r == ARCHIVE_WARN) {
                skipping("bzip2 reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));
@@ -98,7 +98,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_bzip2_rpm)
         }
        assertEqualIntA(a, ARCHIVE_OK, r);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_rpm(a));
+           archive_read_support_filter_rpm(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));

diff --git a/libarchive/test/test_read_format_cpio_svr4_gzip.c b/libarchive/test/test_read_format_cpio_svr4_gzip.c
index c81b2e59337020093d0feb38a9fe3d019c201476..88d54d172c18701105b8cf3a11eb890c38f86518 100644 (file)
--- a/libarchive/test/test_read_format_cpio_svr4_gzip.c
+++ b/libarchive/test/test_read_format_cpio_svr4_gzip.c
@@ -39,8 +39,8 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualInt(ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c b/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c
index 1be66670bbf067fd9145a4d1e6ed4cd2f9f6b169..338a088a6135c8ad3fa4f05cc3c331987049552b 100644 (file)
--- a/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c
+++ b/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c
@@ -90,7 +90,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip_rpm)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-        r = archive_read_support_compression_gzip(a);
+        r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));
@@ -98,7 +98,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip_rpm)
         }
        assertEqualIntA(a, ARCHIVE_OK, r);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_rpm(a));
+           archive_read_support_filter_rpm(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));

diff --git a/libarchive/test/test_read_format_cpio_svr4c_Z.c b/libarchive/test/test_read_format_cpio_svr4c_Z.c
index 912824c49d72ff376ce4e8481a76cf01825804c8..ca3d5ce076683412779f1e9d5a3123e8ab279f0a 100644 (file)
--- a/libarchive/test/test_read_format_cpio_svr4c_Z.c
+++ b/libarchive/test/test_read_format_cpio_svr4c_Z.c
@@ -40,7 +40,7 @@ DEFINE_TEST(test_read_format_cpio_svr4c_Z)
 /*     printf("Archive address: start=%X, end=%X\n", archive, archive+sizeof(archive)); */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_read_format_empty.c b/libarchive/test/test_read_format_empty.c
index c16b6bb9fbe3727a1ccc8776fd647ebbffd42303..0dafe9f6c958eb9314e3f85cdf5e05fac9a8c6ed 100644 (file)
--- a/libarchive/test/test_read_format_empty.c
+++ b/libarchive/test/test_read_format_empty.c
@@ -32,7 +32,7 @@ DEFINE_TEST(test_read_format_empty)
        struct archive_entry *ae;
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_memory(a, archive, 0));
        assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_read_format_gtar_gz.c b/libarchive/test/test_read_format_gtar_gz.c
index 4140a8a8781694f581bf13d9aa8db77738a013cb..cc95c1aed40ec98df246876e2e10dd4b5014f58f 100644 (file)
--- a/libarchive/test/test_read_format_gtar_gz.c
+++ b/libarchive/test/test_read_format_gtar_gz.c
@@ -39,8 +39,8 @@ DEFINE_TEST(test_read_format_gtar_gz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualInt(ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_gtar_lzma.c b/libarchive/test/test_read_format_gtar_lzma.c
index 9e57771737e0916eb920ffd62bb7a12921611a30..29ffae12fcf792173f892328b0842cfea5728b84 100644 (file)
--- a/libarchive/test/test_read_format_gtar_lzma.c
+++ b/libarchive/test/test_read_format_gtar_lzma.c
@@ -45,8 +45,8 @@ DEFINE_TEST(test_read_format_gtar_lzma)
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzma(a);
+           archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_gtar_sparse.c b/libarchive/test/test_read_format_gtar_sparse.c
index 003771dfff4465004c40caeb2324f869b0715caa..10e7898417e05c61b477d588ad759b71f30b6560 100644 (file)
--- a/libarchive/test/test_read_format_gtar_sparse.c
+++ b/libarchive/test/test_read_format_gtar_sparse.c
@@ -190,7 +190,7 @@ verify_archive_file(const char *name, struct archive_contents *ac)
        extract_reference_file(name);
 
        assert((a = archive_read_new()) != NULL);
-       assert(0 == archive_read_support_compression_all(a));
+       assert(0 == archive_read_support_filter_all(a));
        assert(0 == archive_read_support_format_tar(a));
        failure("Can't open %s", name);
        assert(0 == archive_read_open_filename(a, name, 3));

diff --git a/libarchive/test/test_read_format_iso_gz.c b/libarchive/test/test_read_format_iso_gz.c
index 4b7712d8ce933a8f1ba562ada1ec61f81145f9ff..b30320b2038ac971fd8e37420a1f817c072d120a 100644 (file)
--- a/libarchive/test/test_read_format_iso_gz.c
+++ b/libarchive/test/test_read_format_iso_gz.c
@@ -35,7 +35,7 @@ DEFINE_TEST(test_read_format_iso_gz)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_read_format_iso_multi_extent.c b/libarchive/test/test_read_format_iso_multi_extent.c
index a55527f8b145b55c436b2e94627681fb761ec007..3df52baaa870f932b964467a351acb12bf20ef5f 100644 (file)
--- a/libarchive/test/test_read_format_iso_multi_extent.c
+++ b/libarchive/test/test_read_format_iso_multi_extent.c
@@ -42,7 +42,7 @@ DEFINE_TEST(test_read_format_iso_multi_extent)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_iso_xorriso.c b/libarchive/test/test_read_format_iso_xorriso.c
index ff32624117478d13621a74b0af24c7eaa878c610..b4bbfed66a9d2d280317a5af970b6fdd66f0f7bc 100644 (file)
--- a/libarchive/test/test_read_format_iso_xorriso.c
+++ b/libarchive/test/test_read_format_iso_xorriso.c
@@ -80,7 +80,7 @@ DEFINE_TEST(test_read_format_iso_xorriso)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isojoliet_bz2.c b/libarchive/test/test_read_format_isojoliet_bz2.c
index a1417479e71153e85f4f18ab9c4a437d4576efd1..7f723b828dcc7199fde42b9c652f255dc075391a 100644 (file)
--- a/libarchive/test/test_read_format_isojoliet_bz2.c
+++ b/libarchive/test/test_read_format_isojoliet_bz2.c
@@ -67,7 +67,7 @@ DEFINE_TEST(test_read_format_isojoliet_bz2)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_set_option(a, "iso9660", "rockridge", NULL));

diff --git a/libarchive/test/test_read_format_isojoliet_long.c b/libarchive/test/test_read_format_isojoliet_long.c
index 3fc83d3299ef4935f98e9cf6c388d3748462ef29..0a84744a03164526a005a4d447b794acb963f048 100644 (file)
--- a/libarchive/test/test_read_format_isojoliet_long.c
+++ b/libarchive/test/test_read_format_isojoliet_long.c
@@ -75,7 +75,7 @@ DEFINE_TEST(test_read_format_isojoliet_long)
                pathname[i] = '0' + ((i+1) % 10); 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_set_options(a, "iso9660:!rockridge"));

diff --git a/libarchive/test/test_read_format_isojoliet_rr.c b/libarchive/test/test_read_format_isojoliet_rr.c
index 9f55751aad644a43079454012a51dcda4db0bb58..d1afdb5f1bbc857522e33538a8c9fb6046b5e816 100644 (file)
--- a/libarchive/test/test_read_format_isojoliet_rr.c
+++ b/libarchive/test/test_read_format_isojoliet_rr.c
@@ -70,7 +70,7 @@ DEFINE_TEST(test_read_format_isojoliet_rr)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isojoliet_versioned.c b/libarchive/test/test_read_format_isojoliet_versioned.c
index 6d29685b04399dffb61b85da927bf3fa68077045..82c5ab1f3b7bd4ce76695ce471cb2ec2fa31beb7 100644 (file)
--- a/libarchive/test/test_read_format_isojoliet_versioned.c
+++ b/libarchive/test/test_read_format_isojoliet_versioned.c
@@ -42,7 +42,7 @@ DEFINE_TEST(test_read_format_isojoliet_versioned)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_set_option(a, "iso9660", "rockridge", NULL));

diff --git a/libarchive/test/test_read_format_isorr_bz2.c b/libarchive/test/test_read_format_isorr_bz2.c
index 8e83736aa3a86ad5af77f485ed766435d93cc56a..7b7f7df9cf0fe828a030606a90388973b9a0c7c7 100644 (file)
--- a/libarchive/test/test_read_format_isorr_bz2.c
+++ b/libarchive/test/test_read_format_isorr_bz2.c
@@ -68,7 +68,7 @@ DEFINE_TEST(test_read_format_isorr_bz2)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isorr_ce.c b/libarchive/test/test_read_format_isorr_ce.c
index c20febdd3815a76c9ee5effc26d238eb0bb184a9..dc6648378ebf7c18210958ad33c360a53822f4fd 100644 (file)
--- a/libarchive/test/test_read_format_isorr_ce.c
+++ b/libarchive/test/test_read_format_isorr_ce.c
@@ -104,7 +104,7 @@ DEFINE_TEST(test_read_format_isorr_ce)
        mkpath(path3, 153);
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isorr_new_bz2.c b/libarchive/test/test_read_format_isorr_new_bz2.c
index b8cc2c148f925111c377094af80dfe91b64a4774..d71d4d23156dcb8e04c7b01569fce3963112cf35 100644 (file)
--- a/libarchive/test/test_read_format_isorr_new_bz2.c
+++ b/libarchive/test/test_read_format_isorr_new_bz2.c
@@ -69,7 +69,7 @@ DEFINE_TEST(test_read_format_isorr_new_bz2)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isorr_rr_moved.c b/libarchive/test/test_read_format_isorr_rr_moved.c
index 5a64f46f98f15f0f512a07db978ea6175faa6acf..a90677f2d960056142bbbefda2431da5394f79a5 100644 (file)
--- a/libarchive/test/test_read_format_isorr_rr_moved.c
+++ b/libarchive/test/test_read_format_isorr_rr_moved.c
@@ -74,7 +74,7 @@ DEFINE_TEST(test_read_format_isorr_rr_moved)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_isozisofs_bz2.c b/libarchive/test/test_read_format_isozisofs_bz2.c
index a7c68e04607d908f28fc15a0034e6f996056b848..c3705bb8eae9353e9e8c1f1364edce7c7684f877 100644 (file)
--- a/libarchive/test/test_read_format_isozisofs_bz2.c
+++ b/libarchive/test/test_read_format_isozisofs_bz2.c
@@ -67,7 +67,7 @@ DEFINE_TEST(test_read_format_isozisofs_bz2)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(0, archive_read_support_compression_all(a));
+       assertEqualInt(0, archive_read_support_filter_all(a));
        assertEqualInt(0, archive_read_support_format_all(a));
        assertEqualInt(ARCHIVE_OK,
            archive_read_open_filename(a, refname, 10240));

diff --git a/libarchive/test/test_read_format_lha.c b/libarchive/test/test_read_format_lha.c
index b31e245cb9a5316ccc40a5c3918f06b8cb21edd5..f295c090bb7859d1cc4b8f7ba0c7d47a233ad152 100644 (file)
--- a/libarchive/test/test_read_format_lha.c
+++ b/libarchive/test/test_read_format_lha.c
@@ -150,7 +150,7 @@ verify(const char *refname, int posix)
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));

diff --git a/libarchive/test/test_read_format_lha_filename.c b/libarchive/test/test_read_format_lha_filename.c
index 214089a223a86cb74ce2f02ae89d22cad0dc4c1b..6028bc2f50e8713fcc67e7ed484a4356bdb4486b 100644 (file)
--- a/libarchive/test/test_read_format_lha_filename.c
+++ b/libarchive/test/test_read_format_lha_filename.c
@@ -58,7 +58,7 @@ test_read_format_lha_filename_CP932_eucJP(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));
@@ -117,7 +117,7 @@ test_read_format_lha_filename_CP932_UTF8(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));
@@ -172,7 +172,7 @@ test_read_format_lha_filename_CP932_Windows(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));

diff --git a/libarchive/test/test_read_format_mtree.c b/libarchive/test/test_read_format_mtree.c
index 02c4be36e4906422f9991160437306311f8b22f5..b23d43c39acf17f9a647852271f740e32059625e 100644 (file)
--- a/libarchive/test/test_read_format_mtree.c
+++ b/libarchive/test/test_read_format_mtree.c
@@ -47,7 +47,7 @@ test_read_format_mtree1(void)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_file(a, reffile, 11));
@@ -120,7 +120,7 @@ test_read_format_mtree2(void)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
@@ -154,7 +154,7 @@ test_read_format_mtree3(void)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
@@ -193,7 +193,7 @@ test_read_format_mtree4(void)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_file(a, reffile, 11));

diff --git a/libarchive/test/test_read_format_pax_bz2.c b/libarchive/test/test_read_format_pax_bz2.c
index 54f6fcd0926a4964e7feb1011ff1ee3d3485e3f6..7217082c6887bcf3e7c1fd75a77cd6337c3e9337 100644 (file)
--- a/libarchive/test/test_read_format_pax_bz2.c
+++ b/libarchive/test/test_read_format_pax_bz2.c
@@ -47,7 +47,7 @@ DEFINE_TEST(test_read_format_pax_bz2)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       r = archive_read_support_compression_bzip2(a);
+       r = archive_read_support_filter_bzip2(a);
        if (r != ARCHIVE_OK) {
                archive_read_close(a);
                skipping("Bzip2 unavailable");

diff --git a/libarchive/test/test_read_format_raw.c b/libarchive/test/test_read_format_raw.c
index 6bc8347ddc94f3c8f8e25525263bf01243c3aab2..a23b9c55a74923299ee1410512e86e9d306c68c1 100644 (file)
--- a/libarchive/test/test_read_format_raw.c
+++ b/libarchive/test/test_read_format_raw.c
@@ -39,7 +39,7 @@ DEFINE_TEST(test_read_format_raw)
        /* First, try pulling data out of an uninterpretable file. */
        extract_reference_file(reffile1);
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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_support_format_raw(a));
        assertEqualIntA(a, ARCHIVE_OK,
@@ -65,7 +65,7 @@ DEFINE_TEST(test_read_format_raw)
        /* Second, try the same with a compressed file. */
        extract_reference_file(reffile2);
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_raw(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_read_format_tar.c b/libarchive/test/test_read_format_tar.c
index a820092755e75d54d19c4d46d3e1709a799745a6..31e6ae303daeae83c90ed69386315cf7c24653d4 100644 (file)
--- a/libarchive/test/test_read_format_tar.c
+++ b/libarchive/test/test_read_format_tar.c
@@ -66,7 +66,7 @@ static void verifyEmpty(void)
        struct archive *a;
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_memory(a, archiveEmpty, 512));
        assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
@@ -433,7 +433,7 @@ static void verify(unsigned char *d, size_t s,
        memset(buff + s, 0, 2048);
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_memory(a, buff, s + 1024));
        assertA(0 == archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_read_format_tar_empty_filename.c b/libarchive/test/test_read_format_tar_empty_filename.c
index 5832fc8bfab726033f0e3bbbf95c8004acaae99e..b83226ba3d80068aafeef4219c57930b5ea62149 100644 (file)
--- a/libarchive/test/test_read_format_tar_empty_filename.c
+++ b/libarchive/test/test_read_format_tar_empty_filename.c
@@ -35,7 +35,7 @@ DEFINE_TEST(test_read_format_tar_empty_filename)
        struct archive *a;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        extract_reference_file(name);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 10240));

diff --git a/libarchive/test/test_read_format_tbz.c b/libarchive/test/test_read_format_tbz.c
index f64aa7c452915eac797e0a47bb449531e5628640..dcd73cf9a97bab8870122e967cb5c4c41508baf6 100644 (file)
--- a/libarchive/test/test_read_format_tbz.c
+++ b/libarchive/test/test_read_format_tbz.c
@@ -40,7 +40,7 @@ DEFINE_TEST(test_read_format_tbz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       r = archive_read_support_compression_bzip2(a);
+       r = archive_read_support_filter_bzip2(a);
        if (r != ARCHIVE_OK) {
                skipping("Bzip2 support");
                archive_read_free(a);

diff --git a/libarchive/test/test_read_format_tgz.c b/libarchive/test/test_read_format_tgz.c
index e19853664388a232d00300ed43091960fb49f806..3193d978ccc377c160995524111893f0d56e2d5b 100644 (file)
--- a/libarchive/test/test_read_format_tgz.c
+++ b/libarchive/test/test_read_format_tgz.c
@@ -39,8 +39,8 @@ DEFINE_TEST(test_read_format_tgz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualInt(ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_tlz.c b/libarchive/test/test_read_format_tlz.c
index ef1c0ab3c1c87811a66ec0f30f908557899cff81..18660be698c22c86ea9b444b7e463e29c8533f56 100644 (file)
--- a/libarchive/test/test_read_format_tlz.c
+++ b/libarchive/test/test_read_format_tlz.c
@@ -42,8 +42,8 @@ DEFINE_TEST(test_read_format_tlz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzma(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_txz.c b/libarchive/test/test_read_format_txz.c
index 29fdd88c4bed50091051ceec55b3e9b4c2a986c8..3230083b430cde66bb07af538d277e234513065c 100644 (file)
--- a/libarchive/test/test_read_format_txz.c
+++ b/libarchive/test/test_read_format_txz.c
@@ -45,8 +45,8 @@ DEFINE_TEST(test_read_format_txz)
        int r;
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_xz(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));

diff --git a/libarchive/test/test_read_format_tz.c b/libarchive/test/test_read_format_tz.c
index b6a7bc1409aa9e3b57eb64ae2114cac283733561..905b8ffa95b4dcd167108d47b48b6f52a1aa8d19 100644 (file)
--- a/libarchive/test/test_read_format_tz.c
+++ b/libarchive/test/test_read_format_tz.c
@@ -40,7 +40,7 @@ DEFINE_TEST(test_read_format_tz)
        struct archive *a;
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_open_memory(a, archive, sizeof(archive)));

diff --git a/libarchive/test/test_read_format_xar.c b/libarchive/test/test_read_format_xar.c
index 009b5ecbe1e20893010105211cf3910eb251b039..dbc8a618331d80c01c6e1e7a138159ec2f2acb0b 100644 (file)
--- a/libarchive/test/test_read_format_xar.c
+++ b/libarchive/test/test_read_format_xar.c
@@ -638,7 +638,7 @@ static void verify(unsigned char *d, size_t s,
        case BZIP2:
                /* This is only check whether bzip is supported or not.
                 * This filter won't be used this test.  */
-               if (ARCHIVE_OK != archive_read_support_compression_bzip2(a)) {
+               if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
                        skipping("Unsupported bzip2");
                        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
                        return;
@@ -649,7 +649,7 @@ static void verify(unsigned char *d, size_t s,
                 * will return a warning if gzip is unsupported. */
                break;
        }
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        r = archive_read_support_format_xar(a);
        if (r == ARCHIVE_WARN) {
                skipping("xar reading not fully supported on this platform");

diff --git a/libarchive/test/test_read_format_zip.c b/libarchive/test/test_read_format_zip.c
index 7c8a42f9067aa615722458d76adf87c6082f8eb6..c1da4015250e6293073904ca0745970e37f61015 100644 (file)
--- a/libarchive/test/test_read_format_zip.c
+++ b/libarchive/test/test_read_format_zip.c
@@ -50,7 +50,7 @@ test_basic()
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_filename(a, refname, 10240));
        assertA(0 == archive_read_next_header(a, &ae));
@@ -106,7 +106,7 @@ test_info_zip_ux()
 
        extract_reference_file(refname);
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_support_format_all(a));
        assertA(0 == archive_read_open_filename(a, refname, 10240));
 

diff --git a/libarchive/test/test_read_format_zip_filename.c b/libarchive/test/test_read_format_zip_filename.c
index 36d08c7f445e0195ecd36882e0fda806959a1622..f51ae279aa1ce7dcacb927bb2dd916506c110ffb 100644 (file)
--- a/libarchive/test/test_read_format_zip_filename.c
+++ b/libarchive/test/test_read_format_zip_filename.c
@@ -42,7 +42,7 @@ test_read_format_zip_filename_CP932_eucJP(const char *refname)
        }
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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, "charset=CP932")) {
                skipping("This system cannot convert character-set"
@@ -95,7 +95,7 @@ test_read_format_zip_filename_CP932_UTF8(const char *refname)
        }
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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, "charset=CP932")) {
                skipping("This system cannot convert character-set"
@@ -158,7 +158,7 @@ test_read_format_zip_filename_UTF8_eucJP(const char *refname)
        assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));
@@ -217,7 +217,7 @@ test_read_format_zip_filename_UTF8_UTF8(const char *refname)
        }
 
        assert((a = archive_read_new()) != NULL);
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       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));

diff --git a/libarchive/test/test_read_large.c b/libarchive/test/test_read_large.c
index 342876fd2c8184428e41295560cd1e375072b5c9..e9b1a817ee49f7a0f6835995ae47a89cd70ba0da 100644 (file)
--- a/libarchive/test/test_read_large.c
+++ b/libarchive/test/test_read_large.c
@@ -62,7 +62,7 @@ DEFINE_TEST(test_read_large)
 
        assert(NULL != (a = archive_read_new()));
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, sizeof(buff)));
        assertA(0 == archive_read_next_header(a, &entry));
        assertA(0 == archive_read_data_into_buffer(a, testdatacopy, sizeof(testdatacopy)));
@@ -72,7 +72,7 @@ DEFINE_TEST(test_read_large)
 
        assert(NULL != (a = archive_read_new()));
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, sizeof(buff)));
        assertA(0 == archive_read_next_header(a, &entry));
 #if defined(__BORLANDC__)

diff --git a/libarchive/test/test_read_pax_truncated.c b/libarchive/test/test_read_pax_truncated.c
index 076a7f02d27c43d68d985ce3f316f38cd3c662a1..7350c58a185c16d87e4416708fc208d75dfb065e 100644 (file)
--- a/libarchive/test/test_read_pax_truncated.c
+++ b/libarchive/test/test_read_pax_truncated.c
@@ -68,7 +68,7 @@ DEFINE_TEST(test_read_pax_truncated)
        for (i = 1; i < used + 100; i += 100) {
                assert((a = archive_read_new()) != NULL);
                assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
                /* If it's truncated very early, the file type detection should fail. */
                if (i < 512) {
                        assertEqualIntA(a, ARCHIVE_FATAL, read_open_memory2(a, buff, i, 13));
@@ -122,7 +122,7 @@ DEFINE_TEST(test_read_pax_truncated)
        for (i = 1; i < used + 100; i += 100) {
                assert((a = archive_read_new()) != NULL);
                assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
                /* If it's truncated very early, file type detection should fail. */
                if (i < 512) {
                        assertEqualIntA(a, ARCHIVE_FATAL, read_open_memory(a, buff, i, 7));
@@ -172,7 +172,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[514] = 'A'; /* Non-digit in size. */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -183,7 +183,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[512] = 'A'; /* First character not a digit. */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -196,7 +196,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[i] = ' ';
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -210,7 +210,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[515] = ' ';
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -222,7 +222,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[513] = ' ';
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -233,7 +233,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[512] = ' '; /* No size given. */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
@@ -244,7 +244,7 @@ DEFINE_TEST(test_read_pax_truncated)
        buff2[1024]++; /* Break the checksum. */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff2, used));
        assertEqualIntA(a, ARCHIVE_FATAL, archive_read_next_header(a, &ae));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));

diff --git a/libarchive/test/test_read_truncated.c b/libarchive/test/test_read_truncated.c
index e254ba5890e2d2b320a412054c44f9779e8f8de8..306834127972f56189c3aefa621c39c35b669e0f 100644 (file)
--- a/libarchive/test/test_read_truncated.c
+++ b/libarchive/test/test_read_truncated.c
@@ -63,7 +63,7 @@ DEFINE_TEST(test_read_truncated)
        for (i = 1; i < used + 100; i += 100) {
                assert((a = archive_read_new()) != NULL);
                assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
                if (i < 512) {
                        assertEqualIntA(a, ARCHIVE_FATAL, archive_read_open_memory(a, buff, i));
                        goto wrap_up;
@@ -101,7 +101,7 @@ DEFINE_TEST(test_read_truncated)
        for (i = 1; i < used + 100; i += 100) {
                assert((a = archive_read_new()) != NULL);
                assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+               assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
                if (i < 512) {
                        assertEqualIntA(a, ARCHIVE_FATAL, archive_read_open_memory(a, buff, i));
                        goto wrap_up2;

diff --git a/libarchive/test/test_read_truncated_filter.c b/libarchive/test/test_read_truncated_filter.c
index f72eaba86be4f71828095e59c211bc9d2a8f7b79..582f7bae4ae340b8b9ed6bc0b31be18ba77ff9c3 100644 (file)
--- a/libarchive/test/test_read_truncated_filter.c
+++ b/libarchive/test/test_read_truncated_filter.c
@@ -95,7 +95,7 @@ test_truncation(const char *compression, int (*set_compression)(struct archive *
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used1 - used1/64));
        for (i = 0; i < 100; i++) {

diff --git a/libarchive/test/test_read_uu.c b/libarchive/test/test_read_uu.c
index a0979a81041f6fa7191c78e1cca624613bb5498d..ac8cf1604b82258b3739b6ed0ae5e32ae8eaa97f 100644 (file)
--- a/libarchive/test/test_read_uu.c
+++ b/libarchive/test/test_read_uu.c
@@ -104,7 +104,7 @@ test_read_uu_sub(const char *uudata, size_t uusize)
 
                assert((a = archive_read_new()) != NULL);
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_support_format_all(a));
                assertEqualIntA(a, ARCHIVE_OK,

diff --git a/libarchive/test/test_tar_filenames.c b/libarchive/test/test_tar_filenames.c
index aead684c4955b13e65163d79aeea87d0b893a248..de423bbe9787c731b174ec665fcfe5f6d39bf5dc 100644 (file)
--- a/libarchive/test/test_tar_filenames.c
+++ b/libarchive/test/test_tar_filenames.c
@@ -108,7 +108,7 @@ test_filename(const char *prefix, int dlen, int flen)
         */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, used));
 
        /* Read the file and check the filename. */

diff --git a/libarchive/test/test_ustar_filenames.c b/libarchive/test/test_ustar_filenames.c
index ffd263c03a7f086151caf3e57c75bf6dfb2de015..55665bb610a48109811f0077ce5960dbb75bd294 100644 (file)
--- a/libarchive/test/test_ustar_filenames.c
+++ b/libarchive/test/test_ustar_filenames.c
@@ -118,7 +118,7 @@ test_filename(const char *prefix, int dlen, int flen)
         */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, used));
 
        if (flen <= 100) {

diff --git a/libarchive/test/test_write_compress.c b/libarchive/test/test_write_compress.c
index b9c266408734e4cb572e2bc20df83332fd95b9eb..bb81c4f311bf8d367196ca3fcbca830096350e85 100644 (file)
--- a/libarchive/test/test_write_compress.c
+++ b/libarchive/test/test_write_compress.c
@@ -78,7 +78,7 @@ DEFINE_TEST(test_write_compress)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 
 

diff --git a/libarchive/test/test_write_compress_bzip2.c b/libarchive/test/test_write_compress_bzip2.c
index 54deef56c58b327156ca80657e253fec6c63019f..b9e92369a9c2d06ab5fa3e3e5c14d47507f4d06d 100644 (file)
--- a/libarchive/test/test_write_compress_bzip2.c
+++ b/libarchive/test/test_write_compress_bzip2.c
@@ -84,7 +84,7 @@ DEFINE_TEST(test_write_compress_bzip2)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used1));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
@@ -137,7 +137,7 @@ DEFINE_TEST(test_write_compress_bzip2)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
@@ -182,7 +182,7 @@ DEFINE_TEST(test_write_compress_bzip2)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);

diff --git a/libarchive/test/test_write_compress_gzip.c b/libarchive/test/test_write_compress_gzip.c
index 265c5724ed31ed39a851c3c8742148d8b9c355dc..c8281e7b6f23bd011288fd003e99095dc06b3c75 100644 (file)
--- a/libarchive/test/test_write_compress_gzip.c
+++ b/libarchive/test/test_write_compress_gzip.c
@@ -86,7 +86,7 @@ DEFINE_TEST(test_write_compress_gzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_gzip(a);
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify gzip writing by reading back;"
                    " gzip reading not fully supported on this platform");
@@ -150,12 +150,12 @@ DEFINE_TEST(test_write_compress_gzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_gzip(a);
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used2));
                for (i = 0; i < 100; i++) {
@@ -203,8 +203,8 @@ DEFINE_TEST(test_write_compress_gzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
        } else {

diff --git a/libarchive/test/test_write_compress_lzip.c b/libarchive/test/test_write_compress_lzip.c
index e07533dd832027b7fa1e8de9714977c3929e50ff..7dd8bcf24a2566026209579b46ddc4862719ba1e 100644 (file)
--- a/libarchive/test/test_write_compress_lzip.c
+++ b/libarchive/test/test_write_compress_lzip.c
@@ -85,13 +85,13 @@ DEFINE_TEST(test_write_compress_lzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_lzip(a);
+       r = archive_read_support_filter_lzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify lzip writing by reading back;"
                    " lzip reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used1));
                for (i = 0; i < 100; i++) {
@@ -140,12 +140,12 @@ DEFINE_TEST(test_write_compress_lzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_lzip(a);
+       r = archive_read_support_filter_lzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzip reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used2));
                for (i = 0; i < 100; i++) {
@@ -194,8 +194,8 @@ DEFINE_TEST(test_write_compress_lzip)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzip(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzip reading not fully supported on this platform");
        } else {

diff --git a/libarchive/test/test_write_compress_lzma.c b/libarchive/test/test_write_compress_lzma.c
index b9653d3692e6dac7b4d7c899a587073239663de9..f3b9de369f2b05f5b4efa87d593affd23f856f14 100644 (file)
--- a/libarchive/test/test_write_compress_lzma.c
+++ b/libarchive/test/test_write_compress_lzma.c
@@ -84,13 +84,13 @@ DEFINE_TEST(test_write_compress_lzma)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_lzma(a);
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify lzma writing by reading back;"
                    " lzma reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used1));
                for (i = 0; i < 100; i++) {
@@ -139,12 +139,12 @@ DEFINE_TEST(test_write_compress_lzma)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_lzma(a);
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used2));
                for (i = 0; i < 100; i++) {
@@ -198,8 +198,8 @@ DEFINE_TEST(test_write_compress_lzma)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_lzma(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
        } else {

diff --git a/libarchive/test/test_write_compress_program.c b/libarchive/test/test_write_compress_program.c
index 304f4051f3546d2380582e52653a5191712b3315..ba005a68fe4f331217b0d515e744d8c605a18711 100644 (file)
--- a/libarchive/test/test_write_compress_program.c
+++ b/libarchive/test/test_write_compress_program.c
@@ -80,8 +80,8 @@ DEFINE_TEST(test_write_compress_program)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_gzip(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_gzip(a);
        /* The compression_gzip() handler will fall back to gunzip
         * automatically, but if we know gunzip isn't available, then
         * skip the rest. */

diff --git a/libarchive/test/test_write_compress_xz.c b/libarchive/test/test_write_compress_xz.c
index 32c81a010dffd3ceb4c2b85b746d99a2fdd8710b..281dbcf55752fc2c8e256a5a0d2ace18c283103f 100644 (file)
--- a/libarchive/test/test_write_compress_xz.c
+++ b/libarchive/test/test_write_compress_xz.c
@@ -84,13 +84,13 @@ DEFINE_TEST(test_write_compress_xz)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_xz(a);
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify xz writing by reading back;"
                    " xz reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used1));
                for (i = 0; i < 100; i++) {
@@ -146,12 +146,12 @@ DEFINE_TEST(test_write_compress_xz)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       r = archive_read_support_compression_xz(a);
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
        } else {
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used2));
                for (i = 0; i < 100; i++) {
@@ -204,8 +204,8 @@ DEFINE_TEST(test_write_compress_xz)
 
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
-       r = archive_read_support_compression_xz(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
+       r = archive_read_support_filter_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
        } else {

diff --git a/libarchive/test/test_write_format_ar.c b/libarchive/test/test_write_format_ar.c
index 6bdbfb2aee4372fb0649b1ba81cbb75f1f3478b0..1c1b2a718b078e751b4306bfd2f1e7c8f9cf0449 100644 (file)
--- a/libarchive/test/test_write_format_ar.c
+++ b/libarchive/test/test_write_format_ar.c
@@ -108,7 +108,7 @@ DEFINE_TEST(test_write_format_ar)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 
        assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
@@ -170,7 +170,7 @@ DEFINE_TEST(test_write_format_ar)
        /* Now, Read the data back */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 
        assertEqualIntA(a, 0, archive_read_next_header(a, &ae));

diff --git a/libarchive/test/test_write_format_cpio.c b/libarchive/test/test_write_format_cpio.c
index 31b57cb5f447f6684f8c0a083e0d79601ca9d567..b8c1d648408e3358292a4ddb826c0e402adf3ce6 100644 (file)
--- a/libarchive/test/test_write_format_cpio.c
+++ b/libarchive/test/test_write_format_cpio.c
@@ -169,7 +169,7 @@ test_format(int     (*set_format)(struct archive *))
         */
        assert((a = archive_read_new()) != NULL);
        assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       assertA(0 == archive_read_support_filter_all(a));
        assertA(0 == archive_read_open_memory(a, buff, used));
 
        if (!assertEqualIntA(a, 0, archive_read_next_header(a, &ae))) {

diff --git a/libarchive/test/test_write_format_gnutar.c b/libarchive/test/test_write_format_gnutar.c
index ecae367b870bf07648c2db66c4d3274d914e45bd..42063e9cfa363499120fde1977a11004260d4173 100644 (file)
--- a/libarchive/test/test_write_format_gnutar.c
+++ b/libarchive/test/test_write_format_gnutar.c
@@ -182,7 +182,7 @@ DEFINE_TEST(test_write_format_gnutar)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_iso9660.c b/libarchive/test/test_write_format_iso9660.c
index 2be9ed76ffbd85cf66f0f01f0d815c5442baafff..02c35c536641f558230d284aa393980c54bb0279 100644 (file)
--- a/libarchive/test/test_write_format_iso9660.c
+++ b/libarchive/test/test_write_format_iso9660.c
@@ -192,7 +192,7 @@ DEFINE_TEST(test_write_format_iso9660)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*
@@ -446,7 +446,7 @@ DEFINE_TEST(test_write_format_iso9660)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        /* Disable Rockridge extensions support. */
         assertEqualInt(ARCHIVE_OK,
             archive_read_set_option(a, NULL, "rockridge", NULL));
@@ -683,7 +683,7 @@ DEFINE_TEST(test_write_format_iso9660)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        /* Disable Rockridge and Joliet extensions support. */
         assertEqualInt(ARCHIVE_OK,
             archive_read_set_option(a, NULL, "rockridge", NULL));

diff --git a/libarchive/test/test_write_format_iso9660_boot.c b/libarchive/test/test_write_format_iso9660_boot.c
index 8c738f3a81402d39b9992a15fc6b5e60614d852c..d3f8ab0e9349f6a778ed402d250172006d2f19d5 100644 (file)
--- a/libarchive/test/test_write_format_iso9660_boot.c
+++ b/libarchive/test/test_write_format_iso9660_boot.c
@@ -208,7 +208,7 @@ _test_write_format_iso9660_boot(int write_info_tbl)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_iso9660_empty.c b/libarchive/test/test_write_format_iso9660_empty.c
index 06e9264013dda99920c362c4f120805c97e44f72..c302c555936bad9fb756daf59c4e848cbb729389 100644 (file)
--- a/libarchive/test/test_write_format_iso9660_empty.c
+++ b/libarchive/test/test_write_format_iso9660_empty.c
@@ -117,7 +117,7 @@ DEFINE_TEST(test_write_format_iso9660_empty)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_iso9660_filename.c b/libarchive/test/test_write_format_iso9660_filename.c
index 9f1338e95f69ae261cd8cb0a27edb3d82a46cac2..337233e56179a8372c1ee5640289f66187e29735 100644 (file)
--- a/libarchive/test/test_write_format_iso9660_filename.c
+++ b/libarchive/test/test_write_format_iso9660_filename.c
@@ -149,7 +149,7 @@ verify(unsigned char *buff, size_t used, enum vtype type, struct fns *fns)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        if (type >= 1)
                assertA(0 == archive_read_set_option(a, NULL, "rockridge",
                    NULL));

diff --git a/libarchive/test/test_write_format_iso9660_zisofs.c b/libarchive/test/test_write_format_iso9660_zisofs.c
index dd1e86a96c96bfc832dfa8a3fad46d486ed474a7..5ab23bbf1646037ff96b8862bc64a301f6bf2ab8 100644 (file)
--- a/libarchive/test/test_write_format_iso9660_zisofs.c
+++ b/libarchive/test/test_write_format_iso9660_zisofs.c
@@ -200,7 +200,7 @@ DEFINE_TEST(test_write_format_iso9660_zisofs)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_mtree.c b/libarchive/test/test_write_format_mtree.c
index 57159dc0f0376436d21e8b0a28e9ec380168c6cb..ee436d08d5bf0b88bcdd8f7e619f165e91d72991 100644 (file)
--- a/libarchive/test/test_write_format_mtree.c
+++ b/libarchive/test/test_write_format_mtree.c
@@ -116,7 +116,7 @@ test_write_format_mtree_sub(int use_set, int dironly)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 
        /* Read entries */

diff --git a/libarchive/test/test_write_format_mtree_fflags.c b/libarchive/test/test_write_format_mtree_fflags.c
index 2998a9bc11ece7282d90134d9f02d2730f6657fc..18689fe855def20f81b5f09ccd7c50d92a58a106 100644 (file)
--- a/libarchive/test/test_write_format_mtree_fflags.c
+++ b/libarchive/test/test_write_format_mtree_fflags.c
@@ -102,7 +102,7 @@ test_write_format_mtree_sub(int use_set)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
-       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 
        /* Read entries */

diff --git a/libarchive/test/test_write_format_pax.c b/libarchive/test/test_write_format_pax.c
index 78c27ccfd6891ca7aa9d98a5586623c30d81c9fe..21517188e1da3a0002c5c804b719cd4da1eba514 100644 (file)
--- a/libarchive/test/test_write_format_pax.c
+++ b/libarchive/test/test_write_format_pax.c
@@ -115,7 +115,7 @@ DEFINE_TEST(test_write_format_pax)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_tar.c b/libarchive/test/test_write_format_tar.c
index 57fee78fcdfb6dc442659ebedea7f6ded40b7eaa..81aeab64b334985619f4535177e25011a7df3376 100644 (file)
--- a/libarchive/test/test_write_format_tar.c
+++ b/libarchive/test/test_write_format_tar.c
@@ -91,7 +91,7 @@ DEFINE_TEST(test_write_format_tar)
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_support_format_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
-                   archive_read_support_compression_all(a));
+                   archive_read_support_filter_all(a));
                assertEqualIntA(a, ARCHIVE_OK,
                    archive_read_open_memory(a, buff, used));
 

diff --git a/libarchive/test/test_write_format_xar.c b/libarchive/test/test_write_format_xar.c
index ff58beaca56825cbd8c1a3dc1ada7e92711f68ce..d1dd8e310847ccd9e97f3c080ee1a599a877d7da 100644 (file)
--- a/libarchive/test/test_write_format_xar.c
+++ b/libarchive/test/test_write_format_xar.c
@@ -165,7 +165,7 @@ test_xar(const char *option)
         */
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, 0, archive_read_support_format_all(a));
-       assertEqualIntA(a, 0, archive_read_support_compression_all(a));
+       assertEqualIntA(a, 0, archive_read_support_filter_all(a));
        assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
 
        /*

diff --git a/libarchive/test/test_write_format_zip.c b/libarchive/test/test_write_format_zip.c
index ba45a42d603f80a134b0615f040f4f3ac8f50d2d..e4a54003047d30f6ffbc7f5a2ef693a0e87042f8 100644 (file)
--- a/libarchive/test/test_write_format_zip.c
+++ b/libarchive/test/test_write_format_zip.c
@@ -120,7 +120,7 @@ DEFINE_TEST(test_write_format_zip)
        assert((a = archive_read_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
-           archive_read_support_compression_all(a));
+           archive_read_support_filter_all(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_read_open_memory(a, buff, used));