Modernize this test.

SVN-Revision: 1899

diff --git a/libarchive/test/test_write_format_tar.c b/libarchive/test/test_write_format_tar.c
index a02570ca4d2dfe866e32ffc456fb683e78ec9c5d..fb40c6522be5a3eeadc053a3112a6880843b9cd4 100644 (file)
--- a/libarchive/test/test_write_format_tar.c
+++ b/libarchive/test/test_write_format_tar.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2003-2007 Tim Kientzle
+ * Copyright (c) 2003-2010 Tim Kientzle
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,35 +40,40 @@ DEFINE_TEST(test_write_format_tar)
        for (blocksize = 1; blocksize < 100000; blocksize += blocksize + 3) {
                /* Create a new archive in memory. */
                assert((a = archive_write_new()) != NULL);
-               assertA(0 == archive_write_set_format_ustar(a));
-               assertA(0 == archive_write_set_compression_none(a));
-               assertA(0 == archive_write_set_bytes_per_block(a, (int)blocksize));
-               assertA(0 == archive_write_set_bytes_in_last_block(a, (int)blocksize));
-               assertA(blocksize == (size_t)archive_write_get_bytes_in_last_block(a));
-               assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
-               assertA(blocksize == (size_t)archive_write_get_bytes_in_last_block(a));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_write_set_format_ustar(a));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_write_set_compression_none(a));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_write_set_bytes_per_block(a, (int)blocksize));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_write_set_bytes_in_last_block(a, (int)blocksize));
+               assertEqualIntA(a, blocksize,
+                   archive_write_get_bytes_in_last_block(a));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_write_open_memory(a, buff, sizeof(buff), &used));
+               assertEqualIntA(a, blocksize,
+                   (size_t)archive_write_get_bytes_in_last_block(a));
 
                /*
                 * Write a file to it.
                 */
                assert((ae = archive_entry_new()) != NULL);
                archive_entry_set_mtime(ae, 1, 10);
-               assert(1 == archive_entry_mtime(ae));
-#if !defined(__INTERIX)
-               assert(10 == archive_entry_mtime_nsec(ae));
-#endif
+               assertEqualInt(1, archive_entry_mtime(ae));
+               assertEqualInt(10, archive_entry_mtime_nsec(ae));
                p = strdup("file");
                archive_entry_copy_pathname(ae, p);
                strcpy(p, "XXXX");
                free(p);
                assertEqualString("file", archive_entry_pathname(ae));
                archive_entry_set_mode(ae, S_IFREG | 0755);
-               assert((S_IFREG | 0755) == archive_entry_mode(ae));
+               assertEqualInt(S_IFREG | 0755, archive_entry_mode(ae));
                archive_entry_set_size(ae, 8);
 
-               assertA(0 == archive_write_header(a, ae));
+               assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
                archive_entry_free(ae);
-               assertA(8 == archive_write_data(a, "12345678", 9));
+               assertEqualInt(8, archive_write_data(a, "12345678", 9));
 
                /* Close out the archive. */
                assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
@@ -76,31 +81,38 @@ DEFINE_TEST(test_write_format_tar)
 
                /* This calculation gives "the smallest multiple of
                 * the block size that is at least 2048 bytes". */
-               assert(((2048 - 1)/blocksize+1)*blocksize == used);
+               failure("blocksize=%d", blocksize);
+               assertEqualInt(((2048 - 1)/blocksize+1)*blocksize, used);
 
                /*
                 * Now, read the data back.
                 */
                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, used));
+               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, used));
 
-               assertA(0 == archive_read_next_header(a, &ae));
+               assertEqualIntA(a, ARCHIVE_OK,
+                   archive_read_next_header(a, &ae));
 
-               assert(1 == archive_entry_mtime(ae));
+               assertEqualInt(1, archive_entry_mtime(ae));
                /* Not the same as above: ustar doesn't store hi-res times. */
-               assert(0 == archive_entry_mtime_nsec(ae));
-               assert(0 == archive_entry_atime(ae));
-               assert(0 == archive_entry_ctime(ae));
+               assertEqualInt(0, archive_entry_mtime_nsec(ae));
+               assertEqualInt(0, archive_entry_atime(ae));
+               assertEqualInt(0, archive_entry_ctime(ae));
                assertEqualString("file", archive_entry_pathname(ae));
-               assert((S_IFREG | 0755) == archive_entry_mode(ae));
-               assert(8 == archive_entry_size(ae));
-               assertA(8 == archive_read_data(a, buff2, 10));
-               assert(0 == memcmp(buff2, "12345678", 8));
+               assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
+               assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
+               assertEqualInt(8, archive_entry_size(ae));
+               assertEqualInt(8, archive_read_data(a, buff2, 10));
+               assertEqualMem(buff2, "12345678", 8);
 
                /* Verify the end of the archive. */
-               assert(1 == archive_read_next_header(a, &ae));
+               assertEqualIntA(a, ARCHIVE_EOF,
+                   archive_read_next_header(a, &ae));
                assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
                assertEqualInt(ARCHIVE_OK, archive_read_free(a));
        }