Improve verbosity of common functions for ACL tests

diff --git a/libarchive/test/test_acl_nfs4.c b/libarchive/test/test_acl_nfs4.c
index f4e66f52294e11e5e667448f1c427e848d5c9531..fdc0191516e1b596aaaa62ba7caa0a722934f6a9 100644 (file)
--- a/libarchive/test/test_acl_nfs4.c
+++ b/libarchive/test/test_acl_nfs4.c
@@ -159,7 +159,7 @@ DEFINE_TEST(test_acl_nfs4)
         archive_entry_set_mode(ae, S_IFREG | 0777);
 
        /* Store and read back some basic ACL entries. */
-       archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
+       assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
 
        /* Check that entry contains only NFSv4 types */
        assert((archive_entry_acl_types(ae) &
@@ -169,21 +169,21 @@ DEFINE_TEST(test_acl_nfs4)
 
        assertEqualInt(4,
            archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* A more extensive set of ACLs. */
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        assertEqualInt(32,
            archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
+       assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /*
         * Check that clearing ACLs gets rid of them all by repeating
         * the first test.
         */
-       archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
+       assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
        failure("Basic ACLs shouldn't be stored as extended ACLs");
        assertEqualInt(4,
            archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_NFS4));
@@ -192,7 +192,7 @@ DEFINE_TEST(test_acl_nfs4)
         * Different types of malformed ACL entries that should
         * fail when added to existing NFS4 ACLs.
         */
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        for (i = 0; i < (int)(sizeof(acls_bad)/sizeof(acls_bad[0])); ++i) {
                struct archive_test_acl_t *p = &acls_bad[i];
                failure("Malformed ACL test #%d", i);

diff --git a/libarchive/test/test_acl_pax.c b/libarchive/test/test_acl_pax.c
index 8dfa0e03131298906c9b3aaba8f97c704ceba79a..8566f55a51a48871084c136f5b534d72d3422f58 100644 (file)
--- a/libarchive/test/test_acl_pax.c
+++ b/libarchive/test/test_acl_pax.c
@@ -238,23 +238,22 @@ DEFINE_TEST(test_acl_pax_posix1e)
         archive_entry_set_mode(ae, S_IFREG | 0777);
 
        /* Basic owner/owning group should just update mode bits. */
-       archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
+       assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
        assertA(0 == archive_write_header(a, ae));
 
        /* With any extended ACL entry, we should read back a full set. */
-       archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
+       assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
        assertA(0 == archive_write_header(a, ae));
 
-
        /* A more extensive set of ACLs. */
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        assertA(0 == archive_write_header(a, ae));
 
        /*
         * Check that clearing ACLs gets rid of them all by repeating
         * the first test.
         */
-       archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
+       assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
        assertA(0 == archive_write_header(a, ae));
        archive_entry_free(ae);
 
@@ -296,7 +295,7 @@ DEFINE_TEST(test_acl_pax_posix1e)
        assertA(0 == archive_read_next_header(a, &ae));
        failure("One extended ACL should flag all ACLs to be returned.");
        assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142);
        failure("Basic ACLs should set mode to 0142, not %04o",
            archive_entry_mode(ae)&0777);
@@ -306,7 +305,7 @@ DEFINE_TEST(test_acl_pax_posix1e)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
+       assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543);
        failure("Basic ACLs should set mode to 0543, not %04o",
            archive_entry_mode(ae)&0777);
@@ -350,15 +349,15 @@ DEFINE_TEST(test_acl_pax_nfs4)
         archive_entry_set_mode(ae, S_IFREG | 0777);
 
        /* NFS4 ACLs mirroring 0754 file mode */
-       archive_test_set_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]));
+       assertEntrySetAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]));
        assertA(0 == archive_write_header(a, ae));
 
        /* A more extensive set of NFS4 ACLs. */
-       archive_test_set_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]));
+       assertEntrySetAcls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]));
        assertA(0 == archive_write_header(a, ae));
 
        /* Set with special (audit, alarm) NFS4 ACLs. */
-       archive_test_set_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]));
+       assertEntrySetAcls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]));
        assertA(0 == archive_write_header(a, ae));
 
        archive_entry_free(ae);
@@ -393,21 +392,21 @@ DEFINE_TEST(test_acl_pax_nfs4)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(3, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ALLOW));
-       archive_test_compare_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
+       assertEntryCompareAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ALLOW, 0);
 
        /* Second item has has more fine-grained NFS4 ACLs */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]),
+       assertEntryCompareAcls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Third item has has audit and alarm NFS4 ACLs */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
+       assertEntryCompareAcls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Close the archive. */

diff --git a/libarchive/test/test_acl_platform_posix1e.c b/libarchive/test/test_acl_platform_posix1e.c
index 5d1732a510f7050cd8e30f4a9357c2efb2ea2829..b46f65815307809ddaedaccc336f8852c5fa0e94 100644 (file)
--- a/libarchive/test/test_acl_platform_posix1e.c
+++ b/libarchive/test/test_acl_platform_posix1e.c
@@ -393,7 +393,7 @@ DEFINE_TEST(test_acl_platform_posix1e_restore)
        archive_entry_set_pathname(ae, "test0");
        archive_entry_set_mtime(ae, 123456, 7890);
        archive_entry_set_size(ae, 0);
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
        archive_entry_free(ae);
 

diff --git a/libarchive/test/test_acl_posix1e.c b/libarchive/test/test_acl_posix1e.c
index 01167dae20b016e795d3abb847097a597d469f3c..fa2628dbe79432e7c33f0ccb33da281ddd9b1919 100644 (file)
--- a/libarchive/test/test_acl_posix1e.c
+++ b/libarchive/test/test_acl_posix1e.c
@@ -116,16 +116,15 @@ DEFINE_TEST(test_acl_posix1e)
         * triggering unnecessary extensions.  It's better to identify
         * trivial ACLs at the point they are being read from disk.
         */
-       archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
+       assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
        failure("Basic ACLs shouldn't be stored as extended ACLs");
        assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
        failure("Basic ACLs should set mode to 0142, not %04o",
            archive_entry_mode(ae)&0777);
        assert((archive_entry_mode(ae) & 0777) == 0142);
 
-
        /* With any extended ACL entry, we should read back a full set. */
-       archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
+       assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
        failure("One extended ACL should flag all ACLs to be returned.");
 
        /* Check that entry contains only POSIX.1e types */
@@ -135,7 +134,7 @@ DEFINE_TEST(test_acl_posix1e)
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0);
 
        assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142);
        failure("Basic ACLs should set mode to 0142, not %04o",
            archive_entry_mode(ae)&0777);
@@ -143,9 +142,9 @@ DEFINE_TEST(test_acl_posix1e)
 
 
        /* A more extensive set of ACLs. */
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        assertEqualInt(6, archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
+       assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543);
        failure("Basic ACLs should set mode to 0543, not %04o",
            archive_entry_mode(ae)&0777);
@@ -155,7 +154,7 @@ DEFINE_TEST(test_acl_posix1e)
         * Check that clearing ACLs gets rid of them all by repeating
         * the first test.
         */
-       archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
+       assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
        failure("Basic ACLs shouldn't be stored as extended ACLs");
        assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
        failure("Basic ACLs should set mode to 0142, not %04o",
@@ -166,7 +165,7 @@ DEFINE_TEST(test_acl_posix1e)
         * Different types of malformed ACL entries that should
         * fail when added to existing POSIX.1e ACLs.
         */
-       archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
+       assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
        for (i = 0; i < (int)(sizeof(acls_nfs4)/sizeof(acls_nfs4[0])); ++i) {
                struct archive_test_acl_t *p = &acls_nfs4[i];
                failure("Malformed ACL test #%d", i);

diff --git a/libarchive/test/test_acl_text.c b/libarchive/test/test_acl_text.c
index f3d2b10edcfe1a1d6a03681490ac9ca656a8b8b1..80728932cb5412c74c0f87d52078a56c93e73bce 100644 (file)
--- a/libarchive/test/test_acl_text.c
+++ b/libarchive/test/test_acl_text.c
@@ -282,7 +282,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[5],
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
@@ -291,7 +291,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[7],
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -303,7 +303,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
@@ -314,7 +314,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -324,7 +324,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[7],
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);
        assertEqualInt(5, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
@@ -334,7 +334,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);
        assertEqualInt(5, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
@@ -344,7 +344,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[1],
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -355,7 +355,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -365,7 +365,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[2],
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -376,7 +376,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
        assertEqualInt(11, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
@@ -386,7 +386,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text(ae, acltext[10],
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
@@ -398,7 +398,7 @@ DEFINE_TEST(test_acl_from_text)
        assertEqualInt(ARCHIVE_OK,
            archive_entry_acl_from_text_w(ae, ws,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
@@ -416,7 +416,7 @@ DEFINE_TEST(test_acl_to_text)
        assert((ae = archive_entry_new()) != NULL);
 
        /* Write POSIX.1e ACLs  */
-       archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
+       assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 
        /* No flags should give output like getfacl(1) on linux */
        compare_acl_text(ae, 0, acltext[0]);
@@ -457,7 +457,7 @@ DEFINE_TEST(test_acl_to_text)
            ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT, acltext[8]);
 
        /* Write NFSv4 ACLs */
-       archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
+       assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
 
        /* NFSv4 ACLs like getfacl(1) on FreeBSD */
        compare_acl_text(ae, 0, acltext[9]);

diff --git a/libarchive/test/test_compat_solaris_tar_acl.c b/libarchive/test/test_compat_solaris_tar_acl.c
index 3d063c1db9e653ad89c45e01a16e460dda40f429..81597729067039b0792b11f242b073d5bb91d64d 100644 (file)
--- a/libarchive/test/test_compat_solaris_tar_acl.c
+++ b/libarchive/test/test_compat_solaris_tar_acl.c
@@ -227,7 +227,7 @@ DEFINE_TEST(test_compat_solaris_tar_acl)
        failure("One extended ACL should flag all ACLs to be returned.");
        assertEqualInt(7, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0644);
        failure("Basic ACLs should set mode to 0644, not %04o",
            archive_entry_mode(ae)&0777);
@@ -237,28 +237,28 @@ DEFINE_TEST(test_compat_solaris_tar_acl)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0750);
        failure("Basic ACLs should set mode to 0750, not %04o",
            archive_entry_mode(ae)&0777);
        assert((archive_entry_mode(ae) & 0777) == 0750);
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
+       assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0750);
 
        /* Third item has NFS4 ACLs */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
+       assertEntryCompareAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Fourth item has NFS4 ACLs and inheritance flags */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(5, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls4, sizeof(acls4)/sizeof(acls0[4]),
+       assertEntryCompareAcls(ae, acls4, sizeof(acls4)/sizeof(acls0[4]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Close the archive. */

diff --git a/libarchive/test/test_compat_star_acl.c b/libarchive/test/test_compat_star_acl.c
index f2a78b2d2ce4f01f3df449b0eac0ea6ede36acce..824710194c18bc2952cdb7e9544877c1e082058b 100644 (file)
--- a/libarchive/test/test_compat_star_acl.c
+++ b/libarchive/test/test_compat_star_acl.c
@@ -249,7 +249,7 @@ DEFINE_TEST(test_compat_star_acl_posix1e)
        failure("One extended ACL should flag all ACLs to be returned.");
        assertEqualInt(5, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
+       assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142);
        failure("Basic ACLs should set mode to 0142, not %04o",
            archive_entry_mode(ae)&0777);
@@ -259,7 +259,7 @@ DEFINE_TEST(test_compat_star_acl_posix1e)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(7, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-       archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
+       assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543);
        failure("Basic ACLs should set mode to 0543, not %04o",
            archive_entry_mode(ae)&0777);
@@ -269,7 +269,7 @@ DEFINE_TEST(test_compat_star_acl_posix1e)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
-       archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
+       assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
            ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0142);
        failure("Basic ACLs should set mode to 0142, not %04o",
            archive_entry_mode(ae)&0777);
@@ -298,21 +298,21 @@ DEFINE_TEST(test_compat_star_acl_nfs4)
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(3, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_ALLOW));
-       archive_test_compare_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
+       assertEntryCompareAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
            ARCHIVE_ENTRY_ACL_TYPE_ALLOW, 0);
 
        /* Second item has has fine-grained NFS4 ACLs */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(6, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls4, sizeof(acls4)/sizeof(acls0[4]),
+       assertEntryCompareAcls(ae, acls4, sizeof(acls4)/sizeof(acls0[4]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Third item has file and directory inheritance NFS4 ACLs */
        assertA(0 == archive_read_next_header(a, &ae));
        assertEqualInt(5, archive_entry_acl_reset(ae,
            ARCHIVE_ENTRY_ACL_TYPE_NFS4));
-       archive_test_compare_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
+       assertEntryCompareAcls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
            ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 
        /* Close the archive. */

diff --git a/test_utils/test_common.h b/test_utils/test_common.h
index 127027737f32abad0dbfd15700c4f59de5ca421c..82e8483f0134533846c78e06972a99ed548f2aa9 100644 (file)
--- a/test_utils/test_common.h
+++ b/test_utils/test_common.h
@@ -245,6 +245,12 @@
   assertion_umask(__FILE__, __LINE__, mask)
 #define assertUtimes(pathname, atime, atime_nsec, mtime, mtime_nsec)   \
   assertion_utimes(__FILE__, __LINE__, pathname, atime, atime_nsec, mtime, mtime_nsec)
+#ifndef PROGRAM
+#define assertEntrySetAcls(entry, acls, count) \
+  assertion_entry_set_acls(__FILE__, __LINE__, entry, acls, count)
+#define assertEntryCompareAcls(entry, acls, count, type, mode) \
+  assertion_entry_compare_acls(__FILE__, __LINE__, entry, acls, count, type, mode)
+#endif
 
 /*
  * This would be simple with C99 variadic macros, but I don't want to
@@ -385,11 +391,11 @@ struct archive_test_acl_t {
 };
 
 /* Set ACLs */
-void archive_test_set_acls(struct archive_entry *, struct archive_test_acl_t *,
-    int);
+int assertion_entry_set_acls(const char *, int, struct archive_entry *,
+    struct archive_test_acl_t *, int);
 
 /* Compare ACLs */
-void archive_test_compare_acls(struct archive_entry *,
+int assertion_entry_compare_acls(const char *, int, struct archive_entry *,
     struct archive_test_acl_t *, int, int, int);
 
 /* Special customized read-from-memory interface. */

diff --git a/test_utils/test_main.c b/test_utils/test_main.c
index 615e31b036c8c452b79dc348a8408c9e9b28ccb7..b0b6c2bd4d45de6a864c623552644de200c91614 100644 (file)
--- a/test_utils/test_main.c
+++ b/test_utils/test_main.c
@@ -2526,22 +2526,31 @@ extract_reference_files(const char **names)
 
 #ifndef PROGRAM
 /* Set ACLs */
-void
-archive_test_set_acls(struct archive_entry *ae,
+int
+assertion_entry_set_acls(const char *file, int line, struct archive_entry *ae,
     struct archive_test_acl_t *acls, int n)
 {
-       int i;
+       int i, r, ret;
 
+       assertion_count(file, line);
+
+       ret = 0;
        archive_entry_acl_clear(ae);
        for (i = 0; i < n; i++) {
-               failure("type=%#010x, permset=%#010x, tag=%d, qual=%d name=%s",
+               r = archive_entry_acl_add_entry(ae,
                    acls[i].type, acls[i].permset, acls[i].tag,
                    acls[i].qual, acls[i].name);
-               assertEqualInt(ARCHIVE_OK,
-                   archive_entry_acl_add_entry(ae,
-                       acls[i].type, acls[i].permset, acls[i].tag,
-                       acls[i].qual, acls[i].name));
+               if (r != 0) {
+                       ret = 1;
+                       failure_start(file, line, "type=%#010x, ",
+                           "permset=%#010x, tag=%d, qual=%d name=%s",
+                           acls[i].type, acls[i].permset, acls[i].tag,
+                           acls[i].qual, acls[i].name);
+                       failure_finish(NULL);
+               }
        }
+
+       return (ret);
 }
 
 static int
@@ -2578,16 +2587,20 @@ archive_test_acl_match(struct archive_test_acl_t *acl, int type, int permset,
 }
 
 /* Compare ACLs */
-void
-archive_test_compare_acls(struct archive_entry *ae,
-    struct archive_test_acl_t *acls, int cnt, int want_type, int mode)
+int
+assertion_entry_compare_acls(const char *file, int line,
+    struct archive_entry *ae, struct archive_test_acl_t *acls, int cnt,
+    int want_type, int mode)
 {
        int *marker;
-       int i, r, n;
+       int i, r, n, ret;
        int type, permset, tag, qual;
        int matched;
        const char *name;
 
+       assertion_count(file, line);
+
+       ret = 0;
        n = 0;
        marker = malloc(sizeof(marker[0]) * cnt);
 
@@ -2598,10 +2611,11 @@ archive_test_compare_acls(struct archive_entry *ae,
                }
        }
 
-       failure("No ACL's to compare, type mask: %d", want_type);
-       assert(n > 0);
-       if (n == 0)
-               return;
+       if (n == 0) {
+               failure_start(file, line, "No ACL's to compare, type mask: %d",
+                   want_type);
+               return (1);
+       }
 
        while (0 == (r = archive_entry_acl_next(ae, want_type,
                         &type, &permset, &tag, &qual, &name))) {
@@ -2616,39 +2630,81 @@ archive_test_compare_acls(struct archive_entry *ae,
                }
                if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
                    && tag == ARCHIVE_ENTRY_ACL_USER_OBJ) {
-                       if (!matched) printf("No match for user_obj perm\n");
-                       failure("USER_OBJ permset (%02o) != user mode (%02o)",
-                           permset, 07 & (mode >> 6));
-                       assert((permset << 6) == (mode & 0700));
+                       if (!matched) {
+                               failure_start(file, line, "No match for "
+                                   "user_obj perm");
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
+                       if ((permset << 6) != (mode & 0700)) {
+                               failure_start(file, line, "USER_OBJ permset "
+                                   "(%02o) != user mode (%02o)", permset,
+                                   07 & (mode >> 6));
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
                } else if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
                    && tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ) {
-                       if (!matched) printf("No match for group_obj perm\n");
-                       failure("GROUP_OBJ permset %02o != group mode %02o",
-                           permset, 07 & (mode >> 3));
-                       assert((permset << 3) == (mode & 0070));
+                       if (!matched) {
+                               failure_start(file, line, "No match for "
+                                   "group_obj perm");
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
+                       if ((permset << 3) != (mode & 0070)) {
+                               failure_start(file, line, "GROUP_OBJ permset "
+                                   "(%02o) != group mode (%02o)", permset,
+                                   07 & (mode >> 3));
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
                } else if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
                    && tag == ARCHIVE_ENTRY_ACL_OTHER) {
-                       if (!matched) printf("No match for other perm\n");
-                       failure("OTHER permset (%02o) != other mode (%02o)",
-                           permset, mode & 07);
-                       assert((permset << 0) == (mode & 0007));
-               } else {
-                       failure("Could not find match for ACL "
-                           "(type=%#010x,permset=%#010x,tag=%d,qual=%d,"
+                       if (!matched) {
+                               failure_start(file, line, "No match for "
+                                   "other perm");
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
+                       if ((permset << 0) != (mode & 0007)) {
+                               failure_start(file, line, "OTHER permset "
+                                   "(%02o) != other mode (%02o)", permset,
+                                   mode & 07);
+                               failure_finish(NULL);
+                               ret = 1;
+                       }
+               } else if (matched != 1) {
+                       failure_start(file, line, "Could not find match for "
+                           "ACL (type=%#010x,permset=%#010x,tag=%d,qual=%d,"
                            "name=``%s'')", type, permset, tag, qual, name);
-                       assert(matched == 1);
+                       failure_finish(NULL);
+                       ret = 1;
                }
        }
-       assertEqualInt(ARCHIVE_EOF, r);
-       if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
-               assert((mode_t)(mode & 0777) == (archive_entry_mode(ae)
-                   & 0777));
-       failure("Could not find match for ACL "
-           "(type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s'')",
-           acls[marker[0]].type, acls[marker[0]].permset,
-           acls[marker[0]].tag, acls[marker[0]].qual, acls[marker[0]].name);
-       assert(n == 0); /* Number of ACLs not matched should == 0 */
+       if (r != ARCHIVE_EOF) {
+               failure_start(file, line, "Should not exit before EOF");
+               failure_finish(NULL);
+               ret = 1;
+       }
+       if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0 &&
+           (mode_t)(mode & 0777) != (archive_entry_mode(ae) & 0777)) {
+               failure_start(file, line, "Mode (%02o) and entry mode (%02o) "
+                   "mismatch", mode, archive_entry_mode(ae));
+               failure_finish(NULL);
+               ret = 1;
+       }
+       if (n != 0) {
+               failure_start(file, line, "Could not find match for ACL "
+                   "(type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s'')",
+                   acls[marker[0]].type, acls[marker[0]].permset,
+                   acls[marker[0]].tag, acls[marker[0]].qual,
+                   acls[marker[0]].name);
+               failure_finish(NULL);
+               ret = 1;
+               /* Number of ACLs not matched should == 0 */
+       }
        free(marker);
+       return (ret);
 }
 #endif /* !defined(PROGRAM) */