More broad style cleanups of libarchive_test.

SVN-Revision: 1888

diff --git a/libarchive/test/test_write_compress_bzip2.c b/libarchive/test/test_write_compress_bzip2.c
index f92bd9885ebb05a0dc2a6e167ba2137b10b3c2c8..c0c249bce5fd7775db692bd5bb7b9ef650579b48 100644 (file)
--- a/libarchive/test/test_write_compress_bzip2.c
+++ b/libarchive/test/test_write_compress_bzip2.c
@@ -54,7 +54,7 @@ DEFINE_TEST(test_write_compress_bzip2)
         * Write a 100 files and read them all back.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        r = archive_write_set_compression_bzip2(a);
        if (r == ARCHIVE_FATAL) {
                skipping("bzip2 writing not supported on this platform");
@@ -65,7 +65,7 @@ DEFINE_TEST(test_write_compress_bzip2)
            archive_write_set_bytes_per_block(a, 10));
        assertEqualInt(ARCHIVE_COMPRESSION_BZIP2, archive_compression(a));
        assertEqualString("bzip2", archive_compression_name(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used1));
        assertEqualInt(ARCHIVE_COMPRESSION_BZIP2, archive_compression(a));
        assertEqualString("bzip2", archive_compression_name(a));
        assert((ae = archive_entry_new()) != NULL);
@@ -74,18 +74,18 @@ DEFINE_TEST(test_write_compress_bzip2)
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                archive_entry_copy_pathname(ae, path);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize
                    == (size_t)archive_write_data(a, data, datasize));
        }
        archive_entry_free(ae);
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        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_open_memory(a, buff, used1));
+       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_open_memory(a, buff, used1));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
@@ -101,10 +101,10 @@ DEFINE_TEST(test_write_compress_bzip2)
         * options.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_bzip2(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
        assertEqualIntA(a, ARCHIVE_WARN,
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
        assertEqualIntA(a, ARCHIVE_WARN,
@@ -113,18 +113,18 @@ DEFINE_TEST(test_write_compress_bzip2)
            archive_write_set_compressor_options(a, "compression-level=99"));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=9"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Curiously, this test fails; the test data above compresses
@@ -136,9 +136,9 @@ DEFINE_TEST(test_write_compress_bzip2)
        */
 
        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_open_memory(a, buff, used2));
+       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_open_memory(a, buff, used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
@@ -153,26 +153,26 @@ DEFINE_TEST(test_write_compress_bzip2)
         * Repeat again, with much lower compression.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_bzip2(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=1"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                failure("Writing file %s", path);
                assertEqualIntA(a, datasize,
                    (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Level 0 really does result in larger data. */
@@ -181,9 +181,9 @@ DEFINE_TEST(test_write_compress_bzip2)
        assert(used2 > used1);
 
        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_open_memory(a, buff, used2));
+       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_open_memory(a, buff, used2));
        for (i = 0; i < 999; i++) {
                sprintf(path, "file%03d", i);
                if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
@@ -216,7 +216,7 @@ DEFINE_TEST(test_write_compress_bzip2)
        assert((a = archive_write_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 

diff --git a/libarchive/test/test_write_compress_gzip.c b/libarchive/test/test_write_compress_gzip.c
index 920f405c20c5afc497fbe9a811f04cb816412dfb..1666472871c381bbc1d48a5ac1e88b71a6d39624 100644 (file)
--- a/libarchive/test/test_write_compress_gzip.c
+++ b/libarchive/test/test_write_compress_gzip.c
@@ -54,7 +54,7 @@ DEFINE_TEST(test_write_compress_gzip)
         * Write a 100 files and read them all back.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        r = archive_write_set_compression_gzip(a);
        if (r == ARCHIVE_FATAL) {
                skipping("gzip writing not supported on this platform");
@@ -65,7 +65,7 @@ DEFINE_TEST(test_write_compress_gzip)
            archive_write_set_bytes_per_block(a, 10));
        assertEqualInt(ARCHIVE_COMPRESSION_GZIP, archive_compression(a));
        assertEqualString("gzip", archive_compression_name(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used1));
        assertEqualInt(ARCHIVE_COMPRESSION_GZIP, archive_compression(a));
        assertEqualString("gzip", archive_compression_name(a));
        assert((ae = archive_entry_new()) != NULL);
@@ -74,16 +74,16 @@ DEFINE_TEST(test_write_compress_gzip)
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                archive_entry_copy_pathname(ae, path);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize
                    == (size_t)archive_write_data(a, data, datasize));
        }
        archive_entry_free(ae);
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        r = archive_read_support_compression_gzip(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify gzip writing by reading back;"
@@ -110,10 +110,10 @@ DEFINE_TEST(test_write_compress_gzip)
         * options.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_gzip(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
        assertEqualIntA(a, ARCHIVE_WARN,
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
        assertEqualIntA(a, ARCHIVE_WARN,
@@ -122,18 +122,18 @@ DEFINE_TEST(test_write_compress_gzip)
            archive_write_set_compressor_options(a, "compression-level=99"));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=9"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Curiously, this test fails; the test data above compresses
@@ -170,26 +170,26 @@ DEFINE_TEST(test_write_compress_gzip)
         * Repeat again, with much lower compression.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_gzip(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=0"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                failure("Writing file %s", path);
                assertEqualIntA(a, datasize,
                    (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Level 0 really does result in larger data. */
@@ -198,8 +198,8 @@ DEFINE_TEST(test_write_compress_gzip)
        assert(used2 > used1);
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       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);
        if (r == ARCHIVE_WARN) {
                skipping("gzip reading not fully supported on this platform");
@@ -240,7 +240,7 @@ DEFINE_TEST(test_write_compress_gzip)
        assert((a = archive_write_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 

diff --git a/libarchive/test/test_write_compress_lzma.c b/libarchive/test/test_write_compress_lzma.c
index 895fed8c6ff0657dc1ab7b1f65b73753c4e15da5..af172a8f3dc0db0120f1f812cf2a377052f91992 100644 (file)
--- a/libarchive/test/test_write_compress_lzma.c
+++ b/libarchive/test/test_write_compress_lzma.c
@@ -53,7 +53,7 @@ DEFINE_TEST(test_write_compress_lzma)
         * Write a 100 files and read them all back.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        r = archive_write_set_compression_lzma(a);
        if (r == ARCHIVE_FATAL) {
                skipping("lzma writing not supported on this platform");
@@ -64,7 +64,7 @@ DEFINE_TEST(test_write_compress_lzma)
            archive_write_set_bytes_per_block(a, 10));
        assertEqualInt(ARCHIVE_COMPRESSION_LZMA, archive_compression(a));
        assertEqualString("lzma", archive_compression_name(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used1));
        assertEqualInt(ARCHIVE_COMPRESSION_LZMA, archive_compression(a));
        assertEqualString("lzma", archive_compression_name(a));
        assert((ae = archive_entry_new()) != NULL);
@@ -73,16 +73,16 @@ DEFINE_TEST(test_write_compress_lzma)
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                archive_entry_copy_pathname(ae, path);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize
                    == (size_t)archive_write_data(a, data, datasize));
        }
        archive_entry_free(ae);
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        r = archive_read_support_compression_lzma(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify lzma writing by reading back;"
@@ -109,10 +109,10 @@ DEFINE_TEST(test_write_compress_lzma)
         * options.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_lzma(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
        assertEqualIntA(a, ARCHIVE_WARN,
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
        assertEqualIntA(a, ARCHIVE_WARN,
@@ -121,18 +121,18 @@ DEFINE_TEST(test_write_compress_lzma)
            archive_write_set_compressor_options(a, "compression-level=99"));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=9"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
 
@@ -163,26 +163,26 @@ DEFINE_TEST(test_write_compress_lzma)
         * Repeat again, with much lower compression.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_lzma(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=0"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                failure("Writing file %s", path);
                assertEqualIntA(a, datasize,
                    (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Level 0 really does result in larger data. */
@@ -191,8 +191,8 @@ DEFINE_TEST(test_write_compress_lzma)
        assert(used2 > used1);
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       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);
        if (r == ARCHIVE_WARN) {
                skipping("lzma reading not fully supported on this platform");
@@ -233,7 +233,7 @@ DEFINE_TEST(test_write_compress_lzma)
        assert((a = archive_write_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 

diff --git a/libarchive/test/test_write_compress_xz.c b/libarchive/test/test_write_compress_xz.c
index bd4d2bbb6d376d665b14a2d1606bd4c92e0c6345..caa52f98ccf983dddd54f86b4eda56a22da4643f 100644 (file)
--- a/libarchive/test/test_write_compress_xz.c
+++ b/libarchive/test/test_write_compress_xz.c
@@ -54,7 +54,7 @@ DEFINE_TEST(test_write_compress_xz)
         * Write a 100 files and read them all back.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        r = archive_write_set_compression_xz(a);
        if (r == ARCHIVE_FATAL) {
                skipping("xz writing not supported on this platform");
@@ -65,7 +65,7 @@ DEFINE_TEST(test_write_compress_xz)
            archive_write_set_bytes_per_block(a, 10));
        assertEqualInt(ARCHIVE_COMPRESSION_XZ, archive_compression(a));
        assertEqualString("xz", archive_compression_name(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used1));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used1));
        assertEqualInt(ARCHIVE_COMPRESSION_XZ, archive_compression(a));
        assertEqualString("xz", archive_compression_name(a));
        assert((ae = archive_entry_new()) != NULL);
@@ -74,16 +74,16 @@ DEFINE_TEST(test_write_compress_xz)
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                archive_entry_copy_pathname(ae, path);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize
                    == (size_t)archive_write_data(a, data, datasize));
        }
        archive_entry_free(ae);
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
        r = archive_read_support_compression_xz(a);
        if (r == ARCHIVE_WARN) {
                skipping("Can't verify xz writing by reading back;"
@@ -110,10 +110,10 @@ DEFINE_TEST(test_write_compress_xz)
         * options.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_xz(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
        assertEqualIntA(a, ARCHIVE_WARN,
            archive_write_set_compressor_options(a, "nonexistent-option=0"));
        assertEqualIntA(a, ARCHIVE_WARN,
@@ -122,18 +122,18 @@ DEFINE_TEST(test_write_compress_xz)
            archive_write_set_compressor_options(a, "compression-level=99"));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=9"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                assertA(datasize == (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Curiously, this test fails; the test data above compresses
@@ -171,26 +171,26 @@ DEFINE_TEST(test_write_compress_xz)
         * Repeat again, with much lower compression.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ustar(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_bytes_per_block(a, 10));
-       assertA(0 == archive_write_set_compression_xz(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
        assertEqualIntA(a, ARCHIVE_OK,
            archive_write_set_compressor_options(a, "compression-level=0"));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        for (i = 0; i < 100; i++) {
                sprintf(path, "file%03d", i);
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_copy_pathname(ae, path);
                archive_entry_set_size(ae, datasize);
                archive_entry_set_filetype(ae, AE_IFREG);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                failure("Writing file %s", path);
                assertEqualIntA(a, datasize,
                    (size_t)archive_write_data(a, data, datasize));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Level 0 really does result in larger data. */
@@ -199,8 +199,8 @@ DEFINE_TEST(test_write_compress_xz)
        assert(used2 > used1);
 
        assert((a = archive_read_new()) != NULL);
-       assertA(0 == archive_read_support_format_all(a));
-       assertA(0 == archive_read_support_compression_all(a));
+       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);
        if (r == ARCHIVE_WARN) {
                skipping("xz reading not fully supported on this platform");
@@ -241,7 +241,7 @@ DEFINE_TEST(test_write_compress_xz)
        assert((a = archive_write_new()) != NULL);
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
        assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
-       assertA(0 == archive_write_open_memory(a, buff, buffsize, &used2));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
        assertEqualInt(ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 

diff --git a/libarchive/test/test_write_format_ar.c b/libarchive/test/test_write_format_ar.c
index a2a4316b6fbe53306d33901393f31ee882d1a98c..def40a4446360943fcafc6436944d66fa16a5ac9 100644 (file)
--- a/libarchive/test/test_write_format_ar.c
+++ b/libarchive/test/test_write_format_ar.c
@@ -42,14 +42,14 @@ DEFINE_TEST(test_write_format_ar)
         * First we try to create a SVR4/GNU format archive.
         */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_ar_svr4(a));
-       assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ar_svr4(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff), &used));
 
        /* write the filename table */
        assert((ae = archive_entry_new()) != NULL);
        archive_entry_copy_pathname(ae, "//");
        archive_entry_set_size(ae, strlen(strtab));
-       assertA(0 == archive_write_header(a, ae));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
        assertA(strlen(strtab) == (size_t)archive_write_data(a, strtab, strlen(strtab)));
        archive_entry_free(ae);
 
@@ -61,7 +61,7 @@ DEFINE_TEST(test_write_format_ar)
        assert((S_IFREG | 0755) == archive_entry_mode(ae));
        archive_entry_copy_pathname(ae, "abcdefghijklmn.o");
        archive_entry_set_size(ae, 8);
-       assertA(0 == archive_write_header(a, ae));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
        assertA(8 == archive_write_data(a, "87654321", 15));
        archive_entry_free(ae);
 
@@ -97,7 +97,7 @@ DEFINE_TEST(test_write_format_ar)
        assertA(0 != archive_write_header(a, ae));
        archive_entry_free(ae);
 
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /*
@@ -161,7 +161,7 @@ DEFINE_TEST(test_write_format_ar)
        assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
        assertEqualIntA(a, 6, archive_write_data(a, "555555", 7));
        archive_entry_free(ae);
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
        assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        /* Now, Read the data back */

diff --git a/libarchive/test/test_write_format_mtree.c b/libarchive/test/test_write_format_mtree.c
index 38aaa14f364d12df66bbc02f36c1eafe5397102b..0c6fd1fd127156d1dd09bfef5d9d7dd35dac4911 100644 (file)
--- a/libarchive/test/test_write_format_mtree.c
+++ b/libarchive/test/test_write_format_mtree.c
@@ -59,12 +59,12 @@ test_write_format_mtree_sub(int use_set, int dironly)
 
        /* Create a mtree format archive. */
        assert((a = archive_write_new()) != NULL);
-       assertA(0 == archive_write_set_format_mtree(a));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
        if (use_set)
-               assertA(0 == archive_write_set_options(a, "use-set"));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "use-set"));
        if (dironly)
-               assertA(0 == archive_write_set_options(a, "dironly"));
-       assertA(0 == archive_write_open_memory(a, buff, sizeof(buff)-1, &used));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "dironly"));
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff)-1, &used));
 
        /* Write entries */
        for (i = 0; entries[i].path != NULL; i++) {
@@ -80,12 +80,13 @@ test_write_format_mtree_sub(int use_set, int dironly)
                archive_entry_copy_pathname(ae, entries[i].path);
                if ((entries[i].mode & AE_IFMT) != S_IFDIR)
                        archive_entry_set_size(ae, 8);
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                if ((entries[i].mode & AE_IFMT) != S_IFDIR)
-                       assertA(8 == archive_write_data(a, "Hello012", 15));
+                       assertEqualIntA(a, 8,
+                           archive_write_data(a, "Hello012", 15));
                archive_entry_free(ae);
        }
-       archive_write_close(a);
+       assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
         assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 
        if (use_set) {