/*- * Copyright (c) 2003-2007 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test.h" __FBSDID("$FreeBSD$"); #include /* * Most of these tests are system-independent, though a few depend on * features of the local system. Such tests are conditionalized on * the platform name. On unsupported platforms, only the * system-independent features will be tested. * * No, I don't want to use config.h in the test files because I want * the tests to also serve as a check on the correctness of config.h. * A mis-configured library build should cause tests to fail. */ DEFINE_TEST(test_entry) { char buff[128]; wchar_t wbuff[128]; struct stat st; struct archive_entry *e, *e2; const struct stat *pst; unsigned long set, clear; /* For fflag testing. */ int type, permset, tag, qual; /* For ACL testing. */ const char *name; /* For ACL testing. */ const char *xname; /* For xattr tests. */ const void *xval; /* For xattr tests. */ size_t xsize; /* For xattr tests. */ int c; wchar_t wc; long l; assert((e = archive_entry_new()) != NULL); /* * Basic set/read tests for all fields. * We should be able to set any field and read * back the same value. * * For methods that "copy" a string, we should be able * to overwrite the original passed-in string without * changing the value in the entry. * * The following tests are ordered alphabetically by the * name of the field. */ /* atime */ archive_entry_set_atime(e, 13579, 24680); assertEqualInt(archive_entry_atime(e), 13579); assertEqualInt(archive_entry_atime_nsec(e), 24680); archive_entry_unset_atime(e); assertEqualInt(archive_entry_atime(e), 0); assertEqualInt(archive_entry_atime_nsec(e), 0); assert(!archive_entry_atime_is_set(e)); /* birthtime */ archive_entry_set_birthtime(e, 17579, 24990); assertEqualInt(archive_entry_birthtime(e), 17579); assertEqualInt(archive_entry_birthtime_nsec(e), 24990); archive_entry_unset_birthtime(e); assertEqualInt(archive_entry_birthtime(e), 0); assertEqualInt(archive_entry_birthtime_nsec(e), 0); assert(!archive_entry_birthtime_is_set(e)); /* ctime */ archive_entry_set_ctime(e, 13580, 24681); assertEqualInt(archive_entry_ctime(e), 13580); assertEqualInt(archive_entry_ctime_nsec(e), 24681); archive_entry_unset_ctime(e); assertEqualInt(archive_entry_ctime(e), 0); assertEqualInt(archive_entry_ctime_nsec(e), 0); assert(!archive_entry_ctime_is_set(e)); #if ARCHIVE_VERSION_NUMBER >= 1009000 /* dev */ archive_entry_set_dev(e, 235); assertEqualInt(archive_entry_dev(e), 235); #else skipping("archive_entry_dev()"); #endif /* devmajor/devminor are tested specially below. */ #if ARCHIVE_VERSION_NUMBER >= 1009000 /* filetype */ archive_entry_set_filetype(e, AE_IFREG); assertEqualInt(archive_entry_filetype(e), AE_IFREG); #else skipping("archive_entry_filetype()"); #endif /* fflags are tested specially below */ /* gid */ archive_entry_set_gid(e, 204); assertEqualInt(archive_entry_gid(e), 204); /* gname */ archive_entry_set_gname(e, "group"); assertEqualString(archive_entry_gname(e), "group"); wcscpy(wbuff, L"wgroup"); archive_entry_copy_gname_w(e, wbuff); assertEqualWString(archive_entry_gname_w(e), L"wgroup"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_gname_w(e), L"wgroup"); /* hardlink */ archive_entry_set_hardlink(e, "hardlinkname"); assertEqualString(archive_entry_hardlink(e), "hardlinkname"); strcpy(buff, "hardlinkname2"); archive_entry_copy_hardlink(e, buff); assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); wcscpy(wbuff, L"whardlink"); archive_entry_copy_hardlink_w(e, wbuff); assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); #if ARCHIVE_VERSION_NUMBER >= 1009000 /* ino */ archive_entry_set_ino(e, 8593); assertEqualInt(archive_entry_ino(e), 8593); #else skipping("archive_entry_ino()"); #endif /* link */ archive_entry_set_hardlink(e, "hardlinkname"); archive_entry_set_symlink(e, NULL); archive_entry_set_link(e, "link"); assertEqualString(archive_entry_hardlink(e), "link"); assertEqualString(archive_entry_symlink(e), NULL); archive_entry_copy_link(e, "link2"); assertEqualString(archive_entry_hardlink(e), "link2"); assertEqualString(archive_entry_symlink(e), NULL); archive_entry_copy_link_w(e, L"link3"); assertEqualString(archive_entry_hardlink(e), "link3"); assertEqualString(archive_entry_symlink(e), NULL); archive_entry_set_hardlink(e, NULL); archive_entry_set_symlink(e, "symlink"); archive_entry_set_link(e, "link"); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualString(archive_entry_symlink(e), "link"); archive_entry_copy_link(e, "link2"); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualString(archive_entry_symlink(e), "link2"); archive_entry_copy_link_w(e, L"link3"); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualString(archive_entry_symlink(e), "link3"); /* Arbitrarily override symlink if both hardlink and symlink set. */ archive_entry_set_hardlink(e, "hardlink"); archive_entry_set_symlink(e, "symlink"); archive_entry_set_link(e, "link"); assertEqualString(archive_entry_hardlink(e), "hardlink"); assertEqualString(archive_entry_symlink(e), "link"); /* mode */ archive_entry_set_mode(e, 0123456); assertEqualInt(archive_entry_mode(e), 0123456); /* mtime */ archive_entry_set_mtime(e, 13581, 24682); assertEqualInt(archive_entry_mtime(e), 13581); assertEqualInt(archive_entry_mtime_nsec(e), 24682); archive_entry_unset_mtime(e); assertEqualInt(archive_entry_mtime(e), 0); assertEqualInt(archive_entry_mtime_nsec(e), 0); assert(!archive_entry_mtime_is_set(e)); #if ARCHIVE_VERSION_NUMBER >= 1009000 /* nlink */ archive_entry_set_nlink(e, 736); assertEqualInt(archive_entry_nlink(e), 736); #else skipping("archive_entry_nlink()"); #endif /* pathname */ archive_entry_set_pathname(e, "path"); assertEqualString(archive_entry_pathname(e), "path"); archive_entry_set_pathname(e, "path"); assertEqualString(archive_entry_pathname(e), "path"); strcpy(buff, "path2"); archive_entry_copy_pathname(e, buff); assertEqualString(archive_entry_pathname(e), "path2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_pathname(e), "path2"); wcscpy(wbuff, L"wpath"); archive_entry_copy_pathname_w(e, wbuff); assertEqualWString(archive_entry_pathname_w(e), L"wpath"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_pathname_w(e), L"wpath"); #if ARCHIVE_VERSION_NUMBER >= 1009000 /* rdev */ archive_entry_set_rdev(e, 532); assertEqualInt(archive_entry_rdev(e), 532); #else skipping("archive_entry_rdev()"); #endif /* rdevmajor/rdevminor are tested specially below. */ /* size */ archive_entry_set_size(e, 987654321); assertEqualInt(archive_entry_size(e), 987654321); archive_entry_unset_size(e); assertEqualInt(archive_entry_size(e), 0); assert(!archive_entry_size_is_set(e)); /* symlink */ archive_entry_set_symlink(e, "symlinkname"); assertEqualString(archive_entry_symlink(e), "symlinkname"); #if ARCHIVE_VERSION_NUMBER >= 1009000 strcpy(buff, "symlinkname2"); archive_entry_copy_symlink(e, buff); assertEqualString(archive_entry_symlink(e), "symlinkname2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_symlink(e), "symlinkname2"); #endif archive_entry_copy_symlink_w(e, L"wsymlink"); assertEqualWString(archive_entry_symlink_w(e), L"wsymlink"); /* uid */ archive_entry_set_uid(e, 83); assertEqualInt(archive_entry_uid(e), 83); /* uname */ archive_entry_set_uname(e, "user"); assertEqualString(archive_entry_uname(e), "user"); wcscpy(wbuff, L"wuser"); archive_entry_copy_gname_w(e, wbuff); assertEqualWString(archive_entry_gname_w(e), L"wuser"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_gname_w(e), L"wuser"); /* Test fflags interface. */ archive_entry_set_fflags(e, 0x55, 0xAA); archive_entry_fflags(e, &set, &clear); failure("Testing set/get of fflags data."); assertEqualInt(set, 0x55); failure("Testing set/get of fflags data."); assertEqualInt(clear, 0xAA); #ifdef __FreeBSD__ /* Converting fflags bitmap to string is currently system-dependent. */ /* TODO: Make this system-independent. */ assertEqualString(archive_entry_fflags_text(e), "uappnd,nouchg,nodump,noopaque,uunlnk"); /* TODO: Test archive_entry_copy_fflags_text_w() */ /* Test archive_entry_copy_fflags_text() */ archive_entry_copy_fflags_text(e, "nouappnd, nouchg, dump,uunlnk"); archive_entry_fflags(e, &set, &clear); assertEqualInt(16, set); assertEqualInt(7, clear); #endif /* See test_acl_basic.c for tests of ACL set/get consistency. */ /* Test xattrs set/get consistency. */ archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12); assertEqualInt(1, archive_entry_xattr_reset(e)); assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualString(xname, "xattr1"); assertEqualString(xval, "xattrvalue1"); assertEqualInt((int)xsize, 12); assertEqualInt(1, archive_entry_xattr_count(e)); assertEqualInt(ARCHIVE_WARN, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualString(xname, NULL); assertEqualString(xval, NULL); assertEqualInt((int)xsize, 0); archive_entry_xattr_clear(e); assertEqualInt(0, archive_entry_xattr_reset(e)); assertEqualInt(ARCHIVE_WARN, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualString(xname, NULL); assertEqualString(xval, NULL); assertEqualInt((int)xsize, 0); archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12); assertEqualInt(1, archive_entry_xattr_reset(e)); archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12); assertEqualInt(2, archive_entry_xattr_reset(e)); assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualInt(ARCHIVE_WARN, archive_entry_xattr_next(e, &xname, &xval, &xsize)); assertEqualString(xname, NULL); assertEqualString(xval, NULL); assertEqualInt((int)xsize, 0); /* * Test clone() implementation. */ /* Set values in 'e' */ archive_entry_clear(e); archive_entry_set_atime(e, 13579, 24680); archive_entry_set_birthtime(e, 13779, 24990); archive_entry_set_ctime(e, 13580, 24681); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_dev(e, 235); #endif archive_entry_set_fflags(e, 0x55, 0xAA); archive_entry_set_gid(e, 204); archive_entry_set_gname(e, "group"); archive_entry_set_hardlink(e, "hardlinkname"); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_ino(e, 8593); #endif archive_entry_set_mode(e, 0123456); archive_entry_set_mtime(e, 13581, 24682); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_nlink(e, 736); #endif archive_entry_set_pathname(e, "path"); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_rdev(e, 532); #endif archive_entry_set_size(e, 987654321); archive_entry_set_symlink(e, "symlinkname"); archive_entry_set_uid(e, 83); archive_entry_set_uname(e, "user"); /* Add an ACL entry. */ archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77"); /* Add an extended attribute. */ archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11); /* Make a clone. */ e2 = archive_entry_clone(e); /* Clone should have same contents. */ assertEqualInt(archive_entry_atime(e2), 13579); assertEqualInt(archive_entry_atime_nsec(e2), 24680); assertEqualInt(archive_entry_birthtime(e2), 13779); assertEqualInt(archive_entry_birthtime_nsec(e2), 24990); assertEqualInt(archive_entry_ctime(e2), 13580); assertEqualInt(archive_entry_ctime_nsec(e2), 24681); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_dev(e2), 235); #endif archive_entry_fflags(e, &set, &clear); assertEqualInt(clear, 0xAA); assertEqualInt(set, 0x55); assertEqualInt(archive_entry_gid(e2), 204); assertEqualString(archive_entry_gname(e2), "group"); assertEqualString(archive_entry_hardlink(e2), "hardlinkname"); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_ino(e2), 8593); #endif assertEqualInt(archive_entry_mode(e2), 0123456); assertEqualInt(archive_entry_mtime(e2), 13581); assertEqualInt(archive_entry_mtime_nsec(e2), 24682); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_nlink(e2), 736); #endif assertEqualString(archive_entry_pathname(e2), "path"); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_rdev(e2), 532); #endif assertEqualInt(archive_entry_size(e2), 987654321); assertEqualString(archive_entry_symlink(e2), "symlinkname"); assertEqualInt(archive_entry_uid(e2), 83); assertEqualString(archive_entry_uname(e2), "user"); #if ARCHIVE_VERSION_NUMBER < 1009000 skipping("ACL preserved by archive_entry_clone()"); #else /* Verify ACL was copied. */ assertEqualInt(4, c = archive_entry_acl_reset(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); /* First three are standard permission bits. */ assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 4); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ); assertEqualInt(qual, -1); assertEqualString(name, NULL); assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 5); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ); assertEqualInt(qual, -1); assertEqualString(name, NULL); assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 6); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER); assertEqualInt(qual, -1); assertEqualString(name, NULL); /* Fourth is custom one. */ assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER); assertEqualInt(qual, 77); assertEqualString(name, "user77"); #endif #if ARCHIVE_VERSION_NUMBER < 1009000 skipping("xattr data preserved by archive_entry_clone"); #else /* Verify xattr was copied. */ assertEqualInt(1, c = archive_entry_xattr_reset(e2)); assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize)); assertEqualString(xname, "xattr1"); assertEqualString(xval, "xattrvalue"); assertEqualInt((int)xsize, 11); assertEqualInt(ARCHIVE_WARN, archive_entry_xattr_next(e2, &xname, &xval, &xsize)); assertEqualString(xname, NULL); assertEqualString(xval, NULL); assertEqualInt((int)xsize, 0); #endif /* Change the original */ archive_entry_set_atime(e, 13580, 24690); archive_entry_set_birthtime(e, 13980, 24999); archive_entry_set_ctime(e, 13590, 24691); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_dev(e, 245); #endif archive_entry_set_fflags(e, 0x85, 0xDA); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_filetype(e, AE_IFLNK); #endif archive_entry_set_gid(e, 214); archive_entry_set_gname(e, "grouper"); archive_entry_set_hardlink(e, "hardlinkpath"); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_ino(e, 8763); #endif archive_entry_set_mode(e, 0123654); archive_entry_set_mtime(e, 18351, 28642); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_nlink(e, 73); #endif archive_entry_set_pathname(e, "pathest"); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_rdev(e, 132); #endif archive_entry_set_size(e, 987456321); archive_entry_set_symlink(e, "symlinkpath"); archive_entry_set_uid(e, 93); archive_entry_set_uname(e, "username"); archive_entry_acl_clear(e); archive_entry_xattr_clear(e); /* Clone should still have same contents. */ assertEqualInt(archive_entry_atime(e2), 13579); assertEqualInt(archive_entry_atime_nsec(e2), 24680); assertEqualInt(archive_entry_birthtime(e2), 13779); assertEqualInt(archive_entry_birthtime_nsec(e2), 24990); assertEqualInt(archive_entry_ctime(e2), 13580); assertEqualInt(archive_entry_ctime_nsec(e2), 24681); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_dev(e2), 235); #endif archive_entry_fflags(e2, &set, &clear); assertEqualInt(clear, 0xAA); assertEqualInt(set, 0x55); assertEqualInt(archive_entry_gid(e2), 204); assertEqualString(archive_entry_gname(e2), "group"); assertEqualString(archive_entry_hardlink(e2), "hardlinkname"); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_ino(e2), 8593); #endif assertEqualInt(archive_entry_mode(e2), 0123456); assertEqualInt(archive_entry_mtime(e2), 13581); assertEqualInt(archive_entry_mtime_nsec(e2), 24682); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_nlink(e2), 736); #endif assertEqualString(archive_entry_pathname(e2), "path"); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_rdev(e2), 532); #endif assertEqualInt(archive_entry_size(e2), 987654321); assertEqualString(archive_entry_symlink(e2), "symlinkname"); assertEqualInt(archive_entry_uid(e2), 83); assertEqualString(archive_entry_uname(e2), "user"); #if ARCHIVE_VERSION_NUMBER < 1009000 skipping("ACL held by clone of archive_entry"); #else /* Verify ACL was unchanged. */ assertEqualInt(4, c = archive_entry_acl_reset(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); /* First three are standard permission bits. */ assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 4); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ); assertEqualInt(qual, -1); assertEqualString(name, NULL); assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 5); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ); assertEqualInt(qual, -1); assertEqualString(name, NULL); assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, 6); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER); assertEqualInt(qual, -1); assertEqualString(name, NULL); /* Fourth is custom one. */ assertEqualInt(0, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ); assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER); assertEqualInt(qual, 77); assertEqualString(name, "user77"); assertEqualInt(1, archive_entry_acl_next(e2, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, &type, &permset, &tag, &qual, &name)); assertEqualInt(type, 0); assertEqualInt(permset, 0); assertEqualInt(tag, 0); assertEqualInt(qual, -1); assertEqualString(name, NULL); #endif #if ARCHIVE_VERSION_NUMBER < 1009000 skipping("xattr preserved in archive_entry copy"); #else /* Verify xattr was unchanged. */ assertEqualInt(1, archive_entry_xattr_reset(e2)); #endif /* Release clone. */ archive_entry_free(e2); /* * Test clear() implementation. */ archive_entry_clear(e); assertEqualInt(archive_entry_atime(e), 0); assertEqualInt(archive_entry_atime_nsec(e), 0); assertEqualInt(archive_entry_birthtime(e), 0); assertEqualInt(archive_entry_birthtime_nsec(e), 0); assertEqualInt(archive_entry_ctime(e), 0); assertEqualInt(archive_entry_ctime_nsec(e), 0); assertEqualInt(archive_entry_dev(e), 0); archive_entry_fflags(e, &set, &clear); assertEqualInt(clear, 0); assertEqualInt(set, 0); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_filetype(e), 0); #endif assertEqualInt(archive_entry_gid(e), 0); assertEqualString(archive_entry_gname(e), NULL); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualInt(archive_entry_ino(e), 0); assertEqualInt(archive_entry_mode(e), 0); assertEqualInt(archive_entry_mtime(e), 0); assertEqualInt(archive_entry_mtime_nsec(e), 0); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_nlink(e), 0); #endif assertEqualString(archive_entry_pathname(e), NULL); assertEqualInt(archive_entry_rdev(e), 0); assertEqualInt(archive_entry_size(e), 0); assertEqualString(archive_entry_symlink(e), NULL); assertEqualInt(archive_entry_uid(e), 0); assertEqualString(archive_entry_uname(e), NULL); /* ACLs should be cleared. */ assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0); assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0); /* Extended attributes should be cleared. */ assertEqualInt(archive_entry_xattr_count(e), 0); /* * Test archive_entry_copy_stat(). */ memset(&st, 0, sizeof(st)); /* Set all of the standard 'struct stat' fields. */ st.st_atime = 456789; st.st_ctime = 345678; st.st_dev = 123; st.st_gid = 34; st.st_ino = 234; st.st_mode = 077777; st.st_mtime = 234567; st.st_nlink = 345; st.st_size = 123456789; st.st_uid = 23; #ifdef __FreeBSD__ /* On FreeBSD, high-res timestamp data should come through. */ st.st_atimespec.tv_nsec = 6543210; st.st_ctimespec.tv_nsec = 5432109; st.st_mtimespec.tv_nsec = 3210987; st.st_birthtimespec.tv_nsec = 7459386; #endif /* Copy them into the entry. */ archive_entry_copy_stat(e, &st); /* Read each one back separately and compare. */ assertEqualInt(archive_entry_atime(e), 456789); assertEqualInt(archive_entry_ctime(e), 345678); assertEqualInt(archive_entry_dev(e), 123); assertEqualInt(archive_entry_gid(e), 34); assertEqualInt(archive_entry_ino(e), 234); assertEqualInt(archive_entry_mode(e), 077777); assertEqualInt(archive_entry_mtime(e), 234567); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(archive_entry_nlink(e), 345); #endif assertEqualInt(archive_entry_size(e), 123456789); assertEqualInt(archive_entry_uid(e), 23); #if __FreeBSD__ /* On FreeBSD, high-res timestamp data should come through. */ assertEqualInt(archive_entry_atime_nsec(e), 6543210); assertEqualInt(archive_entry_ctime_nsec(e), 5432109); assertEqualInt(archive_entry_mtime_nsec(e), 3210987); assertEqualInt(archive_entry_birthtime_nsec(e), 7459386); #endif /* * Test archive_entry_stat(). */ /* First, clear out any existing stat data. */ memset(&st, 0, sizeof(st)); archive_entry_copy_stat(e, &st); /* Set a bunch of fields individually. */ archive_entry_set_atime(e, 456789, 321); archive_entry_set_ctime(e, 345678, 432); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_dev(e, 123); #endif archive_entry_set_gid(e, 34); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_ino(e, 234); #endif archive_entry_set_mode(e, 012345); archive_entry_set_mode(e, 012345); archive_entry_set_mtime(e, 234567, 543); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_nlink(e, 345); #endif archive_entry_set_size(e, 123456789); archive_entry_set_uid(e, 23); /* Retrieve a stat structure. */ assert((pst = archive_entry_stat(e)) != NULL); /* Check that the values match. */ assertEqualInt(pst->st_atime, 456789); assertEqualInt(pst->st_ctime, 345678); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(pst->st_dev, 123); #endif assertEqualInt(pst->st_gid, 34); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(pst->st_ino, 234); #endif assertEqualInt(pst->st_mode, 012345); assertEqualInt(pst->st_mtime, 234567); #if ARCHIVE_VERSION_NUMBER >= 1009000 assertEqualInt(pst->st_nlink, 345); #endif assertEqualInt(pst->st_size, 123456789); assertEqualInt(pst->st_uid, 23); #ifdef __FreeBSD__ /* On FreeBSD, high-res timestamp data should come through. */ assertEqualInt(pst->st_atimespec.tv_nsec, 321); assertEqualInt(pst->st_ctimespec.tv_nsec, 432); assertEqualInt(pst->st_mtimespec.tv_nsec, 543); #endif /* Changing any one value should update struct stat. */ archive_entry_set_atime(e, 456788, 0); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_atime, 456788); archive_entry_set_ctime(e, 345677, 431); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_ctime, 345677); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_dev(e, 122); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_dev, 122); #endif archive_entry_set_gid(e, 33); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_gid, 33); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_ino(e, 233); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_ino, 233); #endif archive_entry_set_mode(e, 012344); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_mode, 012344); archive_entry_set_mtime(e, 234566, 542); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_mtime, 234566); #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_nlink(e, 344); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_nlink, 344); #endif archive_entry_set_size(e, 123456788); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_size, 123456788); archive_entry_set_uid(e, 22); assert((pst = archive_entry_stat(e)) != NULL); assertEqualInt(pst->st_uid, 22); /* We don't need to check high-res fields here. */ /* * Test dev/major/minor interfaces. Setting 'dev' or 'rdev' * should change the corresponding major/minor values, and * vice versa. * * The test here is system-specific because it assumes that * makedev(), major(), and minor() are defined in sys/stat.h. * I'm not too worried about it, though, because the code is * simple. If it works on FreeBSD, it's unlikely to be broken * anywhere else. Note: The functionality is present on every * platform even if these tests only run some places; * libarchive's more extensive configuration logic should find * the necessary definitions on every platform. */ #if __FreeBSD__ #if ARCHIVE_VERSION_NUMBER >= 1009000 archive_entry_set_dev(e, 0x12345678); assertEqualInt(archive_entry_devmajor(e), major(0x12345678)); assertEqualInt(archive_entry_devminor(e), minor(0x12345678)); assertEqualInt(archive_entry_dev(e), 0x12345678); archive_entry_set_devmajor(e, 0xfe); archive_entry_set_devminor(e, 0xdcba98); assertEqualInt(archive_entry_devmajor(e), 0xfe); assertEqualInt(archive_entry_devminor(e), 0xdcba98); assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98)); archive_entry_set_rdev(e, 0x12345678); assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678)); assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678)); assertEqualInt(archive_entry_rdev(e), 0x12345678); archive_entry_set_rdevmajor(e, 0xfe); archive_entry_set_rdevminor(e, 0xdcba98); assertEqualInt(archive_entry_rdevmajor(e), 0xfe); assertEqualInt(archive_entry_rdevminor(e), 0xdcba98); assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98)); #endif #endif /* * Exercise the character-conversion logic, if we can. */ if (NULL == setlocale(LC_ALL, LOCALE_DE)) { skipping("Can't exercise charset-conversion logic without" " a suitable locale."); } else { /* A filename that cannot be converted to wide characters. */ archive_entry_copy_pathname(e, "abc\314\214mno\374xyz"); failure("Converting invalid chars to Unicode should fail."); assert(NULL == archive_entry_pathname_w(e)); //failure("Converting invalid chars to UTF-8 should fail."); //assert(NULL == archive_entry_pathname_utf8(e)); /* A group name that cannot be converted. */ archive_entry_copy_gname(e, "abc\314\214mno\374xyz"); failure("Converting invalid chars to Unicode should fail."); assert(NULL == archive_entry_gname_w(e)); /* A user name that cannot be converted. */ archive_entry_copy_uname(e, "abc\314\214mno\374xyz"); failure("Converting invalid chars to Unicode should fail."); assert(NULL == archive_entry_uname_w(e)); /* A hardlink target that cannot be converted. */ archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz"); failure("Converting invalid chars to Unicode should fail."); assert(NULL == archive_entry_hardlink_w(e)); /* A symlink target that cannot be converted. */ archive_entry_copy_symlink(e, "abc\314\214mno\374xyz"); failure("Converting invalid chars to Unicode should fail."); assert(NULL == archive_entry_symlink_w(e)); } l = 0x12345678L; wc = (wchar_t)l; /* Wide character too big for UTF-8. */ if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) { skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale."); } else { /* * Build the string L"xxx\U12345678yyy\u5678zzz" without * using C99 \u#### syntax, which isn't uniformly * supported. (GCC 3.4.6, for instance, defaults to * "c89 plus GNU extensions.") */ wcscpy(wbuff, L"xxxAyyyBzzz"); wbuff[3] = (wchar_t)0x12345678; wbuff[7] = (wchar_t)0x5678; /* A wide filename that cannot be converted to narrow. */ archive_entry_copy_pathname_w(e, wbuff); failure("Converting wide characters from Unicode should fail."); assertEqualString(NULL, archive_entry_pathname(e)); } /* Release the experimental entry. */ archive_entry_free(e); }