system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-10-15 21:05:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge lots of test suite updates from libarchive.googlecode.com.

Browse source
This commit is contained in:
Tim Kientzle 2009-04-17 01:06:31 +00:00
parent 7523935ae4
commit 24a4c12895
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=191183
42 changed files with 2236 additions and 349 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
lib/libarchive/test/Makefile
View file

@ -17,6 +17,7 @@ TESTS= \
test_compat_gtar.c \
test_compat_gzip.c \
test_compat_tar_hardlink.c \
test_compat_xz.c \
test_compat_zip.c \
test_empty_write.c \
test_entry.c \
@ -24,10 +25,14 @@ TESTS= \
test_extattr_freebsd.c \
test_fuzz.c \
test_link_resolver.c \
test_open_fd.c \
test_open_file.c \
test_open_filename.c \
test_pax_filename_encoding.c \
test_read_compress_program.c \
test_read_data_large.c \
test_read_disk.c \
test_read_disk_entry_from_file.c \
test_read_extract.c \
test_read_file_nonexistent.c \
test_read_format_ar.c \
@ -35,13 +40,16 @@ TESTS= \
test_read_format_cpio_bin_Z.c \
test_read_format_cpio_bin_bz2.c \
test_read_format_cpio_bin_gz.c \
test_read_format_cpio_bin_xz.c \
test_read_format_cpio_odc.c \
test_read_format_cpio_svr4_gzip.c \
test_read_format_cpio_svr4c_Z.c \
test_read_format_empty.c \
test_read_format_gtar_gz.c \
test_read_format_gtar_lzma.c \
test_read_format_gtar_sparse.c \
test_read_format_iso_gz.c \
test_read_format_isojoliet_bz2.c \
test_read_format_isorr_bz2.c \
test_read_format_mtree.c \
test_read_format_pax_bz2.c \
@ -49,6 +57,7 @@ TESTS= \
test_read_format_tar_empty_filename.c \
test_read_format_tbz.c \
test_read_format_tgz.c \
test_read_format_txz.c \
test_read_format_tz.c \
test_read_format_zip.c \
test_read_large.c \
@ -59,7 +68,11 @@ TESTS= \
test_tar_large.c \
test_ustar_filenames.c \
test_write_compress.c \
test_write_compress_bzip2.c \
test_write_compress_gzip.c \
test_write_compress_lzma.c \
test_write_compress_program.c \
test_write_compress_xz.c \
test_write_disk.c \
test_write_disk_failures.c \
test_write_disk_hardlink.c \
@ -72,6 +85,7 @@ TESTS= \
test_write_format_cpio_empty.c \
test_write_format_cpio_newc.c \
test_write_format_cpio_odc.c \
test_write_format_mtree.c \
test_write_format_pax.c \
test_write_format_shar_empty.c \
test_write_format_tar.c \
@ -93,10 +107,18 @@ PROG=libarchive_test
INTERNALPROG=yes # Don't install this; it's just for testing
DPADD=${LIBBZ2} ${LIBZ}
CFLAGS+= -DPLATFORM_CONFIG_H=\"config_freebsd.h\"
LDADD= -lz -lbz2
CFLAGS+= -static -g
LDADD= -lz -lbz2 -lmd -lcrypto
CFLAGS+= -g
CFLAGS+= -I${LA_SRCDIR} -I.
# Uncomment to build and test lzma support via liblzmadec
#CFLAGS+= -I/usr/local/include -DHAVE_LIBLZMADEC=1 -DHAVE_LZMADEC_H=1
#LDADD+= -L/usr/local/lib -llzmadec
# Uncomment to build and test lzma and xz support via liblzma
CFLAGS+= -I/usr/local/include -DHAVE_LIBLZMA=1 -DHAVE_LZMA_H=1
LDADD+= -L/usr/local/lib -llzma
# Uncomment to link against dmalloc
#LDADD+= -L/usr/local/lib -ldmalloc
#CFLAGS+= -I/usr/local/include -DUSE_DMALLOC
@ -108,9 +130,10 @@ check test: libarchive_test
# list.h is just a list of all tests, as indicated by DEFINE_TEST macro lines
list.h: ${TESTS} Makefile
(cd ${.CURDIR}; cat ${TESTS}) | grep DEFINE_TEST > list.h
(cd ${.CURDIR}; cat test_*.c) | grep DEFINE_TEST > list.h
CLEANFILES += *.out *.o *.core *~ list.h
CLEANFILES += *.out *.o *.core *~ list.h .dirstamp .depend
CLEANDIRS += .deps .libs
cleantest:
-chmod -R +w /tmp/libarchive_test.*

146
lib/libarchive/test/main.c
View file

@ -62,11 +62,7 @@ __FBSDID("$FreeBSD$");
*/
#undef DEFINE_TEST
#define DEFINE_TEST(name) void name(void);
#ifdef LIST_H
#include LIST_H
#else
#include "list.h"
#endif
/* Interix doesn't define these in a standard header. */
#if __INTERIX__
@ -128,13 +124,28 @@ static const char *failed_filename = NULL;
static struct line {
int line;
int count;
int critical;
} failed_lines[1000];
/*
* Called at the beginning of each assert() function.
*/
static void
count_assertion(const char *file, int line)
{
(void)file; /* UNUSED */
(void)line; /* UNUSED */
++assertions;
/* Uncomment to print file:line after every assertion.
* Verbose, but occasionally useful in tracking down crashes. */
/* printf("Checked %s:%d\n", file, line); */
}
/*
* Count this failure; return the number of previous failures.
*/
static int
previous_failures(const char *filename, int line)
previous_failures(const char *filename, int line, int critical)
{
unsigned int i;
int count;
@ -152,6 +163,7 @@ previous_failures(const char *filename, int line)
if (failed_lines[i].line == 0) {
failed_lines[i].line = line;
failed_lines[i].count = 1;
failed_lines[i].critical = critical;
return (0);
}
}
@ -178,7 +190,7 @@ test_skipping(const char *fmt, ...)
{
va_list ap;
if (previous_failures(test_filename, test_line))
if (previous_failures(test_filename, test_line, 0))
return;
va_start(ap, fmt);
@ -241,7 +253,7 @@ summarize(void)
for (i = 0; i < sizeof(failed_lines)/sizeof(failed_lines[0]); i++) {
if (failed_lines[i].line == 0)
break;
if (failed_lines[i].count > 1)
if (failed_lines[i].count > 1 && failed_lines[i].critical)
fprintf(stderr, "%s:%d: Failed %d times\n",
failed_filename, failed_lines[i].line,
failed_lines[i].count);
@ -264,13 +276,13 @@ failure(const char *fmt, ...)
int
test_assert(const char *file, int line, int value, const char *condition, void *extra)
{
++assertions;
count_assertion(file, line);
if (value) {
msg[0] = '\0';
return (value);
}
failures ++;
if (!verbose && previous_failures(file, line))
if (!verbose && previous_failures(file, line, 1))
return (value);
fprintf(stderr, "%s:%d: Assertion failed\n", file, line);
fprintf(stderr, " Condition: %s\n", condition);
@ -283,13 +295,13 @@ int
test_assert_equal_int(const char *file, int line,
int v1, const char *e1, int v2, const char *e2, void *extra)
{
++assertions;
count_assertion(file, line);
if (v1 == v2) {
msg[0] = '\0';
return (1);
}
failures ++;
if (!verbose && previous_failures(file, line))
if (!verbose && previous_failures(file, line, 1))
return (0);
fprintf(stderr, "%s:%d: Assertion failed: Ints not equal\n",
file, line);
@ -330,7 +342,7 @@ test_assert_equal_string(const char *file, int line,
const char *v2, const char *e2,
void *extra)
{
++assertions;
count_assertion(file, line);
if (v1 == NULL || v2 == NULL) {
if (v1 == v2) {
msg[0] = '\0';
@ -341,7 +353,7 @@ test_assert_equal_string(const char *file, int line,
return (1);
}
failures ++;
if (!verbose && previous_failures(file, line))
if (!verbose && previous_failures(file, line, 1))
return (0);
fprintf(stderr, "%s:%d: Assertion failed: Strings not equal\n",
file, line);
@ -383,7 +395,7 @@ test_assert_equal_wstring(const char *file, int line,
const wchar_t *v2, const char *e2,
void *extra)
{
++assertions;
count_assertion(file, line);
if (v1 == NULL) {
if (v2 == NULL) {
msg[0] = '\0';
@ -399,7 +411,7 @@ test_assert_equal_wstring(const char *file, int line,
return (1);
}
failures ++;
if (!verbose && previous_failures(file, line))
if (!verbose && previous_failures(file, line, 1))
return (0);
fprintf(stderr, "%s:%d: Assertion failed: Unicode strings not equal\n",
file, line);
@ -458,7 +470,7 @@ test_assert_equal_mem(const char *file, int line,
const char *v2, const char *e2,
size_t l, const char *ld, void *extra)
{
++assertions;
count_assertion(file, line);
if (v1 == NULL || v2 == NULL) {
if (v1 == v2) {
msg[0] = '\0';
@ -469,7 +481,7 @@ test_assert_equal_mem(const char *file, int line,
return (1);
}
failures ++;
if (!verbose && previous_failures(file, line))
if (!verbose && previous_failures(file, line, 1))
return (0);
fprintf(stderr, "%s:%d: Assertion failed: memory not equal\n",
file, line);
@ -507,7 +519,7 @@ test_assert_empty_file(const char *f1fmt, ...)
return (1);
failures ++;
if (!verbose && previous_failures(test_filename, test_line))
if (!verbose && previous_failures(test_filename, test_line, 1))
return (0);
fprintf(stderr, "%s:%d: File not empty: %s\n", test_filename, test_line, f1);
@ -554,7 +566,7 @@ test_assert_equal_file(const char *f1, const char *f2pattern, ...)
break;
}
failures ++;
if (!verbose && previous_failures(test_filename, test_line))
if (!verbose && previous_failures(test_filename, test_line, 1))
return (0);
fprintf(stderr, "%s:%d: Files are not identical\n",
test_filename, test_line);
@ -576,7 +588,7 @@ test_assert_file_exists(const char *fpattern, ...)
if (!access(f, F_OK))
return (1);
if (!previous_failures(test_filename, test_line)) {
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File doesn't exist\n",
test_filename, test_line);
fprintf(stderr, " file=\"%s\"\n", f);
@ -597,7 +609,7 @@ test_assert_file_not_exists(const char *fpattern, ...)
if (access(f, F_OK))
return (1);
if (!previous_failures(test_filename, test_line)) {
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File exists and shouldn't\n",
test_filename, test_line);
fprintf(stderr, " file=\"%s\"\n", f);
@ -628,7 +640,7 @@ test_assert_file_contents(const void *buff, int s, const char *fpattern, ...)
return (1);
}
failures ++;
if (!previous_failures(test_filename, test_line)) {
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File contents don't match\n",
test_filename, test_line);
fprintf(stderr, " file=\"%s\"\n", f);
@ -722,13 +734,19 @@ slurpfile(size_t * sizep, const char *fmt, ...)
#undef DEFINE_TEST
#define DEFINE_TEST(n) { n, #n },
struct { void (*func)(void); const char *name; } tests[] = {
#ifdef LIST_H
#include LIST_H
#else
#include "list.h"
#endif
};
/*
* This is well-intentioned, but sometimes the standard libraries
* leave open file descriptors and expect to be able to come back to
* them (e.g., for username lookups or logging). Closing these
* descriptors out from under those libraries creates havoc.
*
* Maybe there's some reasonably portable way to tell if a descriptor
* is open without using close()?
*/
#if 0
static void
close_descriptors(int warn)
{
@ -745,6 +763,7 @@ close_descriptors(int warn)
report_failure(NULL);
}
}
#endif
/*
* Each test is run in a private work dir. Those work dirs
@ -788,11 +807,12 @@ static int test_run(int i, const char *tmpdir)
/* Explicitly reset the locale before each test. */
setlocale(LC_ALL, "C");
/* Make sure there are no stray descriptors going into the test. */
close_descriptors(0);
/* TODO: Find a better way to identify file descriptor leaks. */
//close_descriptors(0);
/* Run the actual test. */
(*tests[i].func)();
/* Close stray descriptors, record as errors against this test. */
close_descriptors(1);
//close_descriptors(1);
/* Summarize the results of this test. */
summarize();
/* If there were no failures, we can remove the work dir. */
@ -894,30 +914,34 @@ extract_reference_file(const char *name)
fclose(in);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
#define DEV_NULL "NUL"
#else
#define DEV_NULL "/dev/null"
#endif
/* Since gzip is by far the most popular external compression program
* available, we try to use it in the read_program and write_program
* tests. But if it's not available, then we can't use it. This
* function just tries to run gzip/gunzip to see if they're available.
* If not, some of the external compression program tests will be
* skipped. */
const char *
external_gzip_program(int un)
{
const char *extprog;
static int tested = 0;
static const char *compress_prog = NULL;
static const char *decompress_prog = NULL;
/* Args vary depending on the command interpreter we're using. */
#if defined(_WIN32) && !defined(__CYGWIN__)
static const char *args = "-V >NUL 2>NUL"; /* Win32 cmd.exe */
#else
static const char *args = "-V >/dev/null 2>/dev/null"; /* POSIX 'sh' */
#endif
if (un) {
extprog = "gunzip";
if (systemf("%s -V >" DEV_NULL " 2>" DEV_NULL, extprog) == 0)
return (extprog);
extprog = "gzip -d";
if (systemf("%s -V >" DEV_NULL " 2>" DEV_NULL, extprog) == 0)
return (extprog);
} else {
extprog = "gzip";
if (systemf("%s -V >" DEV_NULL " 2>" DEV_NULL, extprog) == 0)
return (extprog);
if (!tested) {
if (systemf("gunzip %s", args) == 0)
decompress_prog = "gunzip";
if (systemf("gzip %s", args) == 0)
compress_prog = "gzip";
tested = 1;
}
return (NULL);
return (un ? decompress_prog : compress_prog);
}
static char *
@ -1144,16 +1168,30 @@ int main(int argc, char **argv)
}
} else {
while (*(argv) != NULL) {
i = atoi(*argv);
if (**argv < '0' || **argv > '9' || i < 0 || i >= limit) {
printf("*** INVALID Test %s\n", *argv);
free(refdir_alloc);
usage(progname);
if (**argv >= '0' && **argv <= '9') {
i = atoi(*argv);
if (i < 0 || i >= limit) {
printf("*** INVALID Test %s\n", *argv);
free(refdir_alloc);
usage(progname);
/* usage() never returns */
}
} else {
if (test_run(i, tmpdir))
tests_failed++;
tests_run++;
for (i = 0; i < limit; ++i) {
if (strcmp(*argv, tests[i].name) == 0)
break;
}
if (i >= limit) {
printf("*** INVALID Test ``%s''\n",
*argv);
free(refdir_alloc);
usage(progname);
/* usage() never returns */
}
}
if (test_run(i, tmpdir))
tests_failed++;
tests_run++;
argv++;
}
}

2
lib/libarchive/test/read_open_memory.c
View file

@ -96,7 +96,7 @@ read_open_memory_internal(struct archive *a, void *buff,
memory_read, memory_read_skip, memory_read_close));
else
return (archive_read_open2(a, mine, NULL,
memory_read, NULL, NULL));
memory_read, NULL, memory_read_close));
}
/*

21
lib/libarchive/test/test_compat_bzip2.c
View file

@ -44,7 +44,7 @@ compat_bzip2(const char *name)
const char *n[7] = { "f1", "f2", "f3", "d1/f1", "d1/f2", "d1/f3", NULL };
struct archive_entry *ae;
struct archive *a;
int i,r;
int i;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
@ -54,19 +54,9 @@ compat_bzip2(const char *name)
/* Read entries, match up names with list above. */
for (i = 0; i < 6; ++i) {
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping BZIP2 compression check: "
"This version of libarchive was compiled "
"without bzip2 support");
goto finish;
}
failure("Could not read file %d (%s) from %s", i, n[i], name);
assertEqualIntA(a, ARCHIVE_OK, r);
if (r != ARCHIVE_OK) {
archive_read_finish(a);
return;
}
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualString(n[i], archive_entry_pathname(ae));
}
@ -79,12 +69,7 @@ compat_bzip2(const char *name)
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
#endif
}

23
lib/libarchive/test/test_compat_gzip.c
View file

@ -47,22 +47,22 @@ verify(const char *name)
int i,r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
extract_reference_file(name);
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 200));
/* Read entries, match up names with list above. */
for (i = 0; i < 6; ++i) {
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
}
failure("Could not read file %d (%s) from %s", i, n[i], name);
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
if (r != ARCHIVE_OK) {
archive_read_finish(a);
return;
@ -79,12 +79,7 @@ verify(const char *name)
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
#endif
}

84
lib/libarchive/test/test_compat_xz.c Normal file
View file

@ -0,0 +1,84 @@
/*-
* Copyright (c) 2009 Michihiro NAKAJIMA
* Copyright (c) 2003-2008 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$");
/*
* Verify our ability to read sample files compatibly with unxz.
*
* In particular:
* * unxz will read multiple xz streams, concatenating the output
*/
/*
* All of the sample files have the same contents; they're just
* compressed in different ways.
*/
static void
compat_xz(const char *name)
{
const char *n[7] = { "f1", "f2", "f3", "d1/f1", "d1/f2", "d1/f3", NULL };
struct archive_entry *ae;
struct archive *a;
int i, r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
extract_reference_file(name);
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));
/* Read entries, match up names with list above. */
for (i = 0; i < 6; ++i) {
failure("Could not read file %d (%s) from %s", i, n[i], name);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualString(n[i], archive_entry_pathname(ae));
}
/* Verify the end-of-archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify that the format detection worked. */
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_XZ);
assertEqualString(archive_compression_name(a), "xz");
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}
DEFINE_TEST(test_compat_xz)
{
compat_xz("test_compat_xz_1.txz");
}

13
lib/libarchive/test/test_compat_xz_1.txz.uu Normal file
View file

@ -0,0 +1,13 @@
$FreeBSD$
begin 644 test_compat_gzip_1.txz
M_3=Z6%H```3FUK1&`@`A`18```!T+^6CX`^?`(-=`#,,/!NGC#0&C6L"2_R2
M/O9*^(7KX=WM^(=KA(RH"\09$$)!Q_+JUHQ*`]R;ITL_F3/I6:^Q0550A&)B
MHS@=K]7@K1-9FOIP#PU!I<PUHW+W#<F(6FSL/<?5:4*>?E5&IHH&Q=N>_C&G
M-$G]+L[\,B<7%8&$NO5K31*Y>"D^*ZG,Z=H```"KU50H$1^1S``!GP&@'P``
MLZ042+'$9_L"``````196OTW>EA:```$YM:T1@(`(0$6````="_EH^`,7P!I
M70``;IBIKOMK%/A?-<U3^2)5\V,DQ(:ZUH:[B'3>TZV0266G?2,[/?\,JE6`
M__C/SA[W1?*2<Y3NQ'DCK4JEJYHQU`Q\N=H9LL3KRAH,VQQ2OD*@?1NLV]<E
MF&X."!L\R:Z]=*TJPT/BJ^``````R[PG*'(H!W,``84!X!@``/;+`G2QQ&?[
(`@`````$65H`
`
end

28
lib/libarchive/test/test_entry.c
View file

@ -137,11 +137,17 @@ DEFINE_TEST(test_entry)
assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
memset(buff, 0, sizeof(buff));
assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
archive_entry_copy_hardlink(e, NULL);
assertEqualString(archive_entry_hardlink(e), NULL);
assertEqualWString(archive_entry_hardlink_w(e), NULL);
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");
archive_entry_copy_hardlink_w(e, NULL);
assertEqualString(archive_entry_hardlink(e), NULL);
assertEqualWString(archive_entry_hardlink_w(e), NULL);
#if ARCHIVE_VERSION_NUMBER >= 1009000
/* ino */
archive_entry_set_ino(e, 8593);
@ -233,6 +239,10 @@ DEFINE_TEST(test_entry)
assertEqualInt(archive_entry_size(e), 0);
assert(!archive_entry_size_is_set(e));
/* sourcepath */
archive_entry_copy_sourcepath(e, "path1");
assertEqualString(archive_entry_sourcepath(e), "path1");
/* symlink */
archive_entry_set_symlink(e, "symlinkname");
assertEqualString(archive_entry_symlink(e), "symlinkname");
@ -243,8 +253,14 @@ DEFINE_TEST(test_entry)
memset(buff, 0, sizeof(buff));
assertEqualString(archive_entry_symlink(e), "symlinkname2");
#endif
archive_entry_copy_symlink_w(e, NULL);
assertEqualWString(archive_entry_symlink_w(e), NULL);
assertEqualString(archive_entry_symlink(e), NULL);
archive_entry_copy_symlink_w(e, L"wsymlink");
assertEqualWString(archive_entry_symlink_w(e), L"wsymlink");
archive_entry_copy_symlink(e, NULL);
assertEqualWString(archive_entry_symlink_w(e), NULL);
assertEqualString(archive_entry_symlink(e), NULL);
/* uid */
archive_entry_set_uid(e, 83);
@ -271,9 +287,13 @@ DEFINE_TEST(test_entry)
/* 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_w() */
archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,uunlnk");
archive_entry_fflags(e, &set, &clear);
assertEqualInt(16, set);
assertEqualInt(7, clear);
/* Test archive_entry_copy_fflags_text() */
archive_entry_copy_fflags_text(e, "nouappnd, nouchg, dump,uunlnk");
archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,uunlnk");
archive_entry_fflags(e, &set, &clear);
assertEqualInt(16, set);
assertEqualInt(7, clear);
@ -343,6 +363,7 @@ DEFINE_TEST(test_entry)
archive_entry_set_rdev(e, 532);
#endif
archive_entry_set_size(e, 987654321);
archive_entry_copy_sourcepath(e, "source");
archive_entry_set_symlink(e, "symlinkname");
archive_entry_set_uid(e, 83);
archive_entry_set_uname(e, "user");
@ -385,6 +406,7 @@ DEFINE_TEST(test_entry)
assertEqualInt(archive_entry_rdev(e2), 532);
#endif
assertEqualInt(archive_entry_size(e2), 987654321);
assertEqualString(archive_entry_sourcepath(e2), "source");
assertEqualString(archive_entry_symlink(e2), "symlinkname");
assertEqualInt(archive_entry_uid(e2), 83);
assertEqualString(archive_entry_uname(e2), "user");
@ -472,6 +494,7 @@ DEFINE_TEST(test_entry)
archive_entry_set_rdev(e, 132);
#endif
archive_entry_set_size(e, 987456321);
archive_entry_copy_sourcepath(e, "source2");
archive_entry_set_symlink(e, "symlinkpath");
archive_entry_set_uid(e, 93);
archive_entry_set_uname(e, "username");
@ -508,6 +531,7 @@ DEFINE_TEST(test_entry)
assertEqualInt(archive_entry_rdev(e2), 532);
#endif
assertEqualInt(archive_entry_size(e2), 987654321);
assertEqualString(archive_entry_sourcepath(e2), "source");
assertEqualString(archive_entry_symlink(e2), "symlinkname");
assertEqualInt(archive_entry_uid(e2), 83);
assertEqualString(archive_entry_uname(e2), "user");

23
lib/libarchive/test/test_entry_strmode.c
View file

@ -34,15 +34,38 @@ DEFINE_TEST(test_entry_strmode)
archive_entry_set_mode(entry, S_IFREG | 0642);
assertEqualString(archive_entry_strmode(entry), "-rw-r---w- ");
/* Regular file + hardlink still shows as regular file. */
archive_entry_set_mode(entry, S_IFREG | 0644);
archive_entry_set_hardlink(entry, "link");
assertEqualString(archive_entry_strmode(entry), "-rw-r--r-- ");
archive_entry_set_mode(entry, 0640);
archive_entry_set_hardlink(entry, "link");
assertEqualString(archive_entry_strmode(entry), "hrw-r----- ");
archive_entry_set_hardlink(entry, NULL);
archive_entry_set_mode(entry, S_IFDIR | 0777);
assertEqualString(archive_entry_strmode(entry), "drwxrwxrwx ");
archive_entry_set_mode(entry, S_IFBLK | 03642);
assertEqualString(archive_entry_strmode(entry), "brw-r-S-wT ");
archive_entry_set_mode(entry, S_IFCHR | 05777);
assertEqualString(archive_entry_strmode(entry), "crwsrwxrwt ");
archive_entry_set_mode(entry, S_IFSOCK | 0222);
assertEqualString(archive_entry_strmode(entry), "s-w--w--w- ");
archive_entry_set_mode(entry, S_IFIFO | 0444);
assertEqualString(archive_entry_strmode(entry), "pr--r--r-- ");
archive_entry_set_mode(entry, S_IFLNK | 04000);
assertEqualString(archive_entry_strmode(entry), "l--S------ ");
archive_entry_acl_add_entry(entry, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
0007, ARCHIVE_ENTRY_ACL_GROUP, 78, "group78");
assertEqualString(archive_entry_strmode(entry), "l--S------+");
/* Release the experimental entry. */
archive_entry_free(entry);
}

1
lib/libarchive/test/test_extattr_freebsd.c
View file

@ -169,5 +169,6 @@ DEFINE_TEST(test_extattr_freebsd)
assertEqualMem(xval, "12345", xsize);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
archive_entry_free(ae);
#endif
}

117
lib/libarchive/test/test_open_fd.c Normal file
View file

@ -0,0 +1,117 @@
/*-
* 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$");
DEFINE_TEST(test_open_fd)
{
char buff[64];
struct archive_entry *ae;
struct archive *a;
int fd;
fd = open("test.tar", O_RDWR | O_CREAT, 0777);
assert(fd >= 0);
if (fd < 0)
return;
/* Write an archive through this fd. */
assert((a = archive_write_new()) != NULL);
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_open_fd(a, fd));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 8, archive_write_data(a, "12345678", 9));
/*
* Write a second file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 819200);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Now, read the data back.
*/
assert(lseek(fd, 0, SEEK_SET) == 0);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_fd(a, fd, 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(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));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8, archive_read_data(a, buff, 10));
assertEqualMem(buff, "12345678", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(819200, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_data_skip(a));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
close(fd);
/*
* Verify some of the error handling.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
/* FD 100 shouldn't be open. */
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_fd(a, 100, 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

108
lib/libarchive/test/test_open_file.c Normal file
View file

@ -0,0 +1,108 @@
/*-
* 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$");
DEFINE_TEST(test_open_file)
{
char buff[64];
struct archive_entry *ae;
struct archive *a;
FILE *f;
f = fopen("test.tar", "w");
assert(f != NULL);
if (f == NULL)
return;
/* Write an archive through this FILE *. */
assert((a = archive_write_new()) != NULL);
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_open_FILE(a, f));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 8, archive_write_data(a, "12345678", 9));
/*
* Write a second file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 819200);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
fclose(f);
/*
* Now, read the data back.
*/
f = fopen("test.tar", "r");
assert(f != NULL);
if (f == NULL)
return;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_FILE(a, f));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(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));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8, archive_read_data(a, buff, 10));
assertEqualMem(buff, "12345678", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(819200, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_data_skip(a));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
fclose(f);
}

109
lib/libarchive/test/test_open_filename.c Normal file
View file

@ -0,0 +1,109 @@
/*-
* 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$");
DEFINE_TEST(test_open_filename)
{
char buff[64];
struct archive_entry *ae;
struct archive *a;
/* Write an archive through this FILE *. */
assert((a = archive_write_new()) != NULL);
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_open_filename(a, "test.tar"));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 8, archive_write_data(a, "12345678", 9));
/*
* Write a second file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 819200);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_filename(a, "test.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(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));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8, archive_read_data(a, buff, 10));
assertEqualMem(buff, "12345678", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(819200, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_data_skip(a));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Verify some of the error handling.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_filename(a, "nonexistent.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

2
lib/libarchive/test/test_pax_filename_encoding.c
View file

@ -57,7 +57,7 @@ DEFINE_TEST(test_pax_filename_encoding_1)
extract_reference_file(testname);
a = archive_read_new();
assertEqualInt(ARCHIVE_OK, archive_read_support_format_tar(a));
assertEqualInt(ARCHIVE_OK, archive_read_support_compression_gzip(a));
assertEqualInt(ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_filename(a, testname, 10240));
/*

1
lib/libarchive/test/test_pax_filename_encoding.tar.uu
View file

@ -1,5 +1,4 @@
$FreeBSD$
begin 644 test_pax_filename_encoding.tar
M4&%X2&5A9&5R+V%B8\R,;6YO6'AY>@``````````````````````````````
M````````````````````````````````````````````````````````````

2
lib/libarchive/test/test_read_compress_program.c
View file

@ -61,7 +61,7 @@ DEFINE_TEST(test_read_compress_program)
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* If we have "gunzip", try using that.
* If we have "gzip -d", try using that.
*/
if ((extprog = external_gzip_program(1)) == NULL) {
skipping("There is no gzip uncompression "

32
lib/libarchive/test/test_read_disk.c
View file

@ -124,21 +124,23 @@ DEFINE_TEST(test_read_disk)
/* Get the group name for group 0 and see if it makes sense. */
p = archive_read_disk_gname(a, 0);
i = 0;
while (i < sizeof(zero_groups)/sizeof(zero_groups[0])) {
if (strcmp(zero_groups[i], p) == 0)
break;
++i;
}
if (i == sizeof(zero_groups)/sizeof(zero_groups[0])) {
/* If you get a failure here, either
* archive_read_disk_gname() isn't working or
* your system uses a different name for group
* number zero. If the latter, please add a
* new entry to the zero_groups[] array above.
*/
failure("group 0 didn't have any of the expected names");
assertEqualString(p, zero_groups[0]);
if (assert(p != NULL)) {
i = 0;
while (i < sizeof(zero_groups)/sizeof(zero_groups[0])) {
if (strcmp(zero_groups[i], p) == 0)
break;
++i;
}
if (i == sizeof(zero_groups)/sizeof(zero_groups[0])) {
/* If you get a failure here, either
* archive_read_disk_gname() isn't working or
* your system uses a different name for group
* number zero. If the latter, please add a
* new entry to the zero_groups[] array above.
*/
failure("group 0 didn't have any of the expected names");
assertEqualString(p, zero_groups[0]);
}
}
#endif
}

80
lib/libarchive/test/test_read_disk_entry_from_file.c Normal file
View file

@ -0,0 +1,80 @@
/*-
* Copyright (c) 2003-2009 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$");
static const char *
gname_lookup(void *d, gid_t g)
{
(void)d; /* UNUSED */
(void)g; /* UNUSED */
return ("FOOGROUP");
}
static const char *
uname_lookup(void *d, uid_t u)
{
(void)d; /* UNUSED */
(void)u; /* UNUSED */
return ("FOO");
}
DEFINE_TEST(test_read_disk_entry_from_file)
{
struct archive *a;
struct archive_entry *entry;
int fd;
assert((a = archive_read_disk_new()) != NULL);
assertEqualInt(ARCHIVE_OK, archive_read_disk_set_uname_lookup(a,
NULL, &uname_lookup, NULL));
assertEqualInt(ARCHIVE_OK, archive_read_disk_set_gname_lookup(a,
NULL, &gname_lookup, NULL));
assertEqualString(archive_read_disk_uname(a, 0), "FOO");
assertEqualString(archive_read_disk_gname(a, 0), "FOOGROUP");
/* Create a file on disk. */
fd = open("foo", O_WRONLY | O_CREAT, 0777);
assert(fd >= 0);
assertEqualInt(4, write(fd, "1234", 4));
close(fd);
/* Use archive_read_disk_entry_from_file to get information about it. */
entry = archive_entry_new();
assert(entry != NULL);
archive_entry_copy_pathname(entry, "foo");
assertEqualInt(ARCHIVE_OK,
archive_read_disk_entry_from_file(a, entry, -1, NULL));
/* Verify the information we got back. */
assertEqualString(archive_entry_uname(entry), "FOO");
assertEqualString(archive_entry_gname(entry), "FOOGROUP");
assertEqualInt(archive_entry_size(entry), 4);
/* Destroy the archive. */
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

17
lib/libarchive/test/test_read_format_cpio_bin_bz2.c
View file

@ -36,7 +36,6 @@ DEFINE_TEST(test_read_format_cpio_bin_bz2)
{
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
@ -44,23 +43,11 @@ DEFINE_TEST(test_read_format_cpio_bin_bz2)
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping BZ2 compression check: "
"This version of libarchive was compiled "
"without bz2 support");
goto finish;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assert(archive_compression(a) == ARCHIVE_COMPRESSION_BZIP2);
assert(archive_format(a) == ARCHIVE_FORMAT_CPIO_BIN_LE);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

36
lib/libarchive/test/test_read_format_cpio_bin_gz.c
View file

@ -38,26 +38,24 @@ DEFINE_TEST(test_read_format_cpio_bin_gz)
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
assertEqualInt(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");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_GZIP);
assert(archive_format(a) == ARCHIVE_FORMAT_CPIO_BIN_LE);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
failure("archive_read_support_compression_gzip");
assertEqualInt(ARCHIVE_OK, r);
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualInt(ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a),
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

70
lib/libarchive/test/test_read_format_cpio_bin_xz.c Normal file
View file

@ -0,0 +1,70 @@
/*-
* Copyright (c) 2009 Michihiro NAKAJIMA
* 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$");
static unsigned char archive[] = {
0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x04,
0xe6, 0xd6, 0xb4, 0x46, 0x02, 0x00, 0x21, 0x01,
0x16, 0x00, 0x00, 0x00, 0x74, 0x2f, 0xe5, 0xa3,
0xe0, 0x01, 0xff, 0x00, 0x33, 0x5d, 0x00, 0x63,
0x9c, 0x3e, 0xa0, 0x43, 0x7c, 0xe6, 0x5d, 0xdc,
0xeb, 0x76, 0x1d, 0x4b, 0x1b, 0xe2, 0x9e, 0x43,
0x95, 0x97, 0x60, 0x16, 0x36, 0xc6, 0xd1, 0x3f,
0x68, 0xd1, 0x94, 0xf9, 0xee, 0x47, 0xbb, 0xc9,
0xf3, 0xa2, 0x01, 0x2a, 0x2f, 0x2b, 0xb2, 0x23,
0x5a, 0x06, 0x9c, 0xd0, 0x4a, 0x6b, 0x5b, 0x14,
0xb4, 0x00, 0x00, 0x00, 0x91, 0x62, 0x1e, 0x15,
0x04, 0x46, 0x6b, 0x4d, 0x00, 0x01, 0x4f, 0x80,
0x04, 0x00, 0x00, 0x00, 0xa1, 0x4b, 0xdf, 0x03,
0xb1, 0xc4, 0x67, 0xfb, 0x02, 0x00, 0x00, 0x00,
0x00, 0x04, 0x59, 0x5a
};
DEFINE_TEST(test_read_format_cpio_bin_xz)
{
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_XZ);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

35
lib/libarchive/test/test_read_format_cpio_svr4_gzip.c
View file

@ -39,26 +39,23 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip)
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
assertEqualInt(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");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_GZIP);
assert(archive_format(a) == ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualInt(ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a),
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a),
ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

34
lib/libarchive/test/test_read_format_gtar_gz.c
View file

@ -39,26 +39,22 @@ DEFINE_TEST(test_read_format_gtar_gz)
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
assertEqualInt(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");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_GZIP);
assert(archive_format(a) == ARCHIVE_FORMAT_TAR_GNUTAR);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualInt(ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a),
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_GNUTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

78
lib/libarchive/test/test_read_format_gtar_lzma.c Normal file
View file

@ -0,0 +1,78 @@
/*-
* Copyright (c) 2008 Miklos Vajna
* 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$");
static unsigned char archive[] = {
0x5d, 0x0, 0x0, 0x80, 0x0, 0x0, 0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x17, 0xb, 0xbc, 0x1c, 0x7d, 0x1, 0x95, 0xc0, 0x1d, 0x4a, 0x46, 0x9c,
0x1c, 0xc5, 0x8, 0x82, 0x10, 0xed, 0x84, 0xf6, 0xea, 0x7a, 0xfe, 0x63,
0x5a, 0x34, 0x5e, 0xf7, 0xc, 0x60, 0xd6, 0x8b, 0xc1, 0x47, 0xaf, 0x11,
0x6f, 0x18, 0x94, 0x81, 0x74, 0x8a, 0xf8, 0x47, 0xcc, 0xdd, 0xc0, 0xd9,
0x40, 0xa, 0xc3, 0xac, 0x43, 0x47, 0xb5, 0xac, 0x2b, 0x31, 0xd3, 0x6,
0xa4, 0x2c, 0x44, 0x80, 0x24, 0x4b, 0xfe, 0x43, 0x22, 0x4e, 0x14, 0x30,
0x7a, 0xef, 0x99, 0x6e, 0xf, 0x8b, 0xc1, 0x79, 0x93, 0x88, 0x54, 0x73,
0x59, 0x3f, 0xc, 0xfb, 0xee, 0x9c, 0x83, 0x49, 0x93, 0x33, 0xad, 0x44,
0xbe, 0x0};
DEFINE_TEST(test_read_format_gtar_lzma)
{
int r;
struct archive_entry *ae;
struct archive *a;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_all(a));
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
r = archive_read_open_memory2(a, archive, sizeof(archive), 3);
if (r != ARCHIVE_OK) {
skipping("Skipping LZMA compression check: %s",
archive_error_string(a));
goto finish;
}
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_LZMA);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_GNUTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
#endif
}

1
lib/libarchive/test/test_read_format_gtar_sparse_1_13.tar.uu
View file

@ -1,5 +1,4 @@
$FreeBSD$
begin 644 test_read_format_gtar_sparse_1_13.tar
M<W!A<G-E````````````````````````````````````````````````````
M````````````````````````````````````````````````````````````

55
lib/libarchive/test/test_read_format_iso_gz.c
View file

@ -25,62 +25,35 @@
#include "test.h"
__FBSDID("$FreeBSD$");
static unsigned char archive[] = {
31,139,8,8,201,'R','p','C',0,3,'t','e','s','t','-','r','e','a','d','_','f',
'o','r','m','a','t','.','i','s','o',0,237,219,223,'k',211,'@',28,0,240,212,
23,'K','}',20,169,143,135,15,162,224,218,180,']','W',186,183,173,'I',183,
206,254,144,'d',19,246,'$',5,';',24,'2',11,235,240,239,221,127,162,233,'f',
17,29,219,24,12,'\'',243,243,'!',185,187,220,']',146,';',8,9,223,131,'D',
17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'P',234,
'%','q',220,'(','E',253,211,217,'l',';','O',194,'u','z','I','6',25,']',219,
26,194,234,'z',241,'o',217,13,247,'-',182,229,30,149,203,'Q',229,178,170,
242,252,'W',243,139,'e',242,'*',170,'^',30,'U',163,242,'2','+','G',199,207,
158,'V','_',190,';',127,178,':',255,134,1,241,23,140,222,15,242,'I','?',15,
'E',26,186,27,27,'q','}',183,'8',232,15,134,'i','~',152,239,167,163,176,'}',
'0',24,'&','i',22,'^','/',159,159,180,'7',201,146,162,176,150,213,147,143,
'E','!','K',183,246,'\'','Y','x',211,'{',27,26,221,'n','+',164,181,195,201,
193,'x','\'',217,26,166,171,202,'N',216,171,'}','H',183,178,'|','2',174,239,
213,242,222,238,'`','8',28,140,'w',30,'j',186,205,'8','n','7',26,'q',167,
217,'j',174,183,';','q','|','~',165,'"',254,'C','t',165,'G',')','z',168,209,
243,'o',184,143,215,'6',220,139,239,'?',191,255,0,192,255,163,136,224,194,
'h',254,'5',140,231,223,'B',232,132,'f','k',179,185,190,217,238,'\\',132,
':',149,147,'/',199,139,249,209,'"','4','k','q',173,21,214,230,225,'l',182,
'8','[',';',157,'M','?',127,':',154,159,158,'L',207,'j','E','{',152,'>',244,
28,0,128,187,')',']',172,177,139,255,1,0,0,224,'1',187,136,252,171,22,0,0,
0,0,224,'1',187,253,31,187,'[','{','X',';',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,224,206,
'~',0,137,'#',195,182,0,128,1,0};
DEFINE_TEST(test_read_format_iso_gz)
{
struct archive_entry *ae;
struct archive *a;
int r;
const char *name = "test_read_format_iso_gz.iso.gz";
extract_reference_file(name);
assert((a = archive_read_new()) != NULL);
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");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_GZIP);
archive_read_open_filename(a, name, 512));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a),
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
#endif
}

16
lib/libarchive/test/test_read_format_iso_gz.iso.gz.uu Normal file
View file

@ -0,0 +1,16 @@
$FreeBSD$
begin 755 test_read_format_iso_gz.iso.gz
M'XL(",E2<$,``W1E<W0M<F5A9%]F;W)M870N:7-O`.W;WVO30!P`\-072WT4
MJ8^'#Z+@VK1=5[JWK4FWSOZ09!/V)`4[&#(+Z_#OW7^BZ681'=L8#"?S\R&Y
MN]Q=DCL("=^#1!$`````````````````````````````````````````4.HE
M<=PH1?W3V6P[3\)U>DDV&5W;&L+J>O%OV0WW+;;E'I7+4>6RJO+\5_.+9?(J
MJEX>5:/R,BM'Q\^>5E^^.W^R.O^&`?$7C-X/\DD_#T4:NAL;<7VW..@/AFE^
MF.^GH[!],!@F:19>+Y^?M#?)DJ*PEM63CT4A2[?V)UEXTWL;&MUN*Z2UP\G!
M>"?9&J:KRD[8JWU(M[)\,J[OU?+>[F`X'(QW'FJZS3AN-QIQI]EJKK<[<7Q^
MI2+^0W2E1REZJ-'S;[B/US;<B^\_O_\`P/^CB.#":/XUC.??0NB$9FNSN;[9
M[ER$.I63+\>+^=$B-&MQK176YN%LMCA;.YU-/W\ZFI^>3,]J17N8/O0<`("[
M*5VLL8O_`0``X#&[B/RK%@````#@,;O]'[M;>U@[````````````````````
M`````````````````````````````````````````````.#.?@")(\.V`(`!
!````
`
end

17
lib/libarchive/test/test_read_format_isojoliet_bz2.c
View file

@ -69,15 +69,16 @@ joliettest(int withrr)
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualInt(0, archive_read_support_compression_bzip2(a));
assertEqualInt(0, archive_read_support_format_all(a));
r = archive_read_open_filename(a, refname, 10240);
if (r == ARCHIVE_FATAL) {
skipping("Bzip2 decompression unsupported on this platform");
archive_read_finish(a);
r = archive_read_support_compression_bzip2(a);
if (r == ARCHIVE_WARN) {
skipping("bzip2 reading not fully supported on this platform");
assertEqualInt(0, archive_read_finish(a));
return;
}
assertEqualInt(0, r);
assertEqualInt(0, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_filename(a, refname, 10240));
/* First entry is '.' root directory. */
assertEqualInt(0, archive_read_next_header(a, &ae));
@ -169,11 +170,7 @@ joliettest(int withrr)
/* Close the archive. */
assertEqualInt(0, archive_read_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(0, archive_read_finish(a));
#endif
}

13
lib/libarchive/test/test_read_format_isorr_bz2.c
View file

@ -55,15 +55,16 @@ DEFINE_TEST(test_read_format_isorr_bz2)
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualInt(0, archive_read_support_compression_bzip2(a));
assertEqualInt(0, archive_read_support_format_all(a));
r = archive_read_open_filename(a, refname, 10240);
if (r == ARCHIVE_FATAL) {
skipping("Bzip2 decompression unsupported on this platform");
archive_read_finish(a);
r = archive_read_support_compression_bzip2(a);
if (r == ARCHIVE_WARN) {
skipping("bzip2 reading not fully supported on this platform");
assertEqualInt(0, archive_read_finish(a));
return;
}
assertEqualInt(0, r);
assertEqualInt(0, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_filename(a, refname, 10240));
/* First entry is '.' root directory. */
assertEqualInt(0, archive_read_next_header(a, &ae));

9
lib/libarchive/test/test_read_format_mtree.c
View file

@ -52,6 +52,15 @@ DEFINE_TEST(test_read_format_mtree)
struct archive_entry *ae;
struct archive *a;
/*
* An access error occurred on some platform when mtree
* format handling open a directory. It is for through
* the routine which open a directory that we create
* "dir" and "dir2" directories.
*/
assertEqualInt(0, mkdir("dir", 0775));
assertEqualInt(0, mkdir("dir2", 0775));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_all(a));

30
lib/libarchive/test/test_read_format_pax_bz2.c
View file

@ -44,29 +44,17 @@ DEFINE_TEST(test_read_format_pax_bz2)
{
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping BZIP2 compression check: "
"This version of libarchive was compiled "
"without bzip2 support");
goto finish;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_BZIP2);
assert(archive_format(a) == ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualIntA(a,ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a,ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a,ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a,ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE);
assertEqualIntA(a,ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

30
lib/libarchive/test/test_read_format_tbz.c
View file

@ -37,29 +37,17 @@ DEFINE_TEST(test_read_format_tbz)
{
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping BZIP2 compression check: "
"This version of libarchive was compiled "
"without bzip2 support");
goto finish;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_BZIP2);
assert(archive_format(a) == ARCHIVE_FORMAT_TAR_USTAR);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

34
lib/libarchive/test/test_read_format_tgz.c
View file

@ -39,26 +39,22 @@ DEFINE_TEST(test_read_format_tgz)
int r;
assert((a = archive_read_new()) != NULL);
assert(0 == archive_read_support_compression_all(a));
assert(0 == archive_read_support_format_all(a));
assert(0 == archive_read_open_memory(a, archive, sizeof(archive)));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("Skipping GZIP compression check: "
"This version of libarchive was compiled "
"without gzip support");
goto finish;
assertEqualInt(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");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assert(0 == r);
assert(archive_compression(a) == ARCHIVE_COMPRESSION_GZIP);
assert(archive_format(a) == ARCHIVE_FORMAT_TAR_USTAR);
assert(0 == archive_read_close(a));
finish:
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualInt(ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a),
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK,archive_read_finish(a));
}

63
lib/libarchive/test/test_read_format_txz.c Normal file
View file

@ -0,0 +1,63 @@
/*-
* Copyright (c) 2009 Michihiro NAKAJIMA
* 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$");
static unsigned char archive[] = {
253, 55,122, 88, 90, 0, 0, 4,230,214,180, 70, 2, 0, 33, 1,
22, 0, 0, 0,116, 47,229,163,224, 5,255, 0, 73, 93, 0, 23,
0, 51, 80, 24,164,204,238, 45, 77, 28,191, 13,144, 8, 10, 70,
5,173,215, 47,132,237,145,162, 96, 6,131,168,152, 8,135,161,
189, 73,110,132, 27,195, 52,109,203, 22, 17,168,211, 18,181, 76,
93,120, 88,154,155,244,141,193,206,170,224, 80,137,134, 67, 1,
9,123,121,188,247, 28,139, 0, 0, 0, 0, 0,112,184, 17, 5,
103, 16, 8, 73, 0, 1,101,128, 12, 0, 0, 0, 30, 69, 92, 96,
177,196,103,251, 2, 0, 0, 0, 0, 4, 89, 90
};
DEFINE_TEST(test_read_format_txz)
{
struct archive_entry *ae;
struct archive *a;
int r;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_XZ);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
}

228
lib/libarchive/test/test_write_compress_bzip2.c Normal file
View file

@ -0,0 +1,228 @@
/*-
* Copyright (c) 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
* in this position and unchanged.
* 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$");
/*
* A basic exercise of bzip2 reading and writing.
*
* TODO: Add a reference file and make sure we can decompress that.
*/
DEFINE_TEST(test_write_compress_bzip2)
{
struct archive_entry *ae;
struct archive* a;
char *buff, *data;
size_t buffsize, datasize;
char path[16];
size_t used1, used2;
int i, r;
buffsize = 2000000;
assert(NULL != (buff = (char *)malloc(buffsize)));
datasize = 10000;
assert(NULL != (data = (char *)malloc(datasize)));
memset(data, 0, datasize);
/*
* Write a 100 files and read them all back.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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");
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
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));
assertEqualInt(ARCHIVE_COMPRESSION_BZIP2, archive_compression(a));
assertEqualString("bzip2", archive_compression_name(a));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_filetype(ae, AE_IFREG);
archive_entry_set_size(ae, datasize);
for (i = 0; i < 999; i++) {
sprintf(path, "file%03d", i);
archive_entry_copy_pathname(ae, path);
assertA(0 == archive_write_header(a, ae));
assertA(datasize
== (size_t)archive_write_data(a, data, datasize));
}
archive_entry_free(ae);
archive_write_close(a);
assert(0 == 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));
for (i = 0; i < 999; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assert(0 == archive_read_close(a));
assert(0 == archive_read_finish(a));
/*
* Repeat the cycle again, this time setting some compression
* options.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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_WARN,
archive_write_set_compressor_options(a, "nonexistent-option=0"));
assertEqualIntA(a, ARCHIVE_WARN,
archive_write_set_compressor_options(a, "compression-level=abc"));
assertEqualIntA(a, ARCHIVE_WARN,
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));
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));
assertA(datasize == (size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
/*
failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
(int)used2, (int)used1);
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));
for (i = 0; i < 999; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assert(0 == archive_read_close(a));
assert(0 == archive_read_finish(a));
/*
* 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_bytes_per_block(a, 10));
assertA(0 == 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));
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));
failure("Writing file %s", path);
assertEqualIntA(a, datasize,
(size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
(int)used2, (int)used1);
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));
for (i = 0; i < 999; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(0, archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assert(0 == archive_read_close(a));
assert(0 == archive_read_finish(a));
/*
* Test various premature shutdown scenarios to make sure we
* don't crash or leak memory.
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Clean up.
*/
free(data);
free(buff);
}

252
lib/libarchive/test/test_write_compress_gzip.c Normal file
View file

@ -0,0 +1,252 @@
/*-
* Copyright (c) 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
* in this position and unchanged.
* 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$");
/*
* A basic exercise of gzip reading and writing.
*
* TODO: Add a reference file and make sure we can decompress that.
*/
DEFINE_TEST(test_write_compress_gzip)
{
struct archive_entry *ae;
struct archive* a;
char *buff, *data;
size_t buffsize, datasize;
char path[16];
size_t used1, used2;
int i, r;
buffsize = 2000000;
assert(NULL != (buff = (char *)malloc(buffsize)));
datasize = 10000;
assert(NULL != (data = (char *)malloc(datasize)));
memset(data, 0, datasize);
/*
* Write a 100 files and read them all back.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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");
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
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));
assertEqualInt(ARCHIVE_COMPRESSION_GZIP, archive_compression(a));
assertEqualString("gzip", archive_compression_name(a));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_filetype(ae, AE_IFREG);
archive_entry_set_size(ae, datasize);
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
archive_entry_copy_pathname(ae, path);
assertA(0 == archive_write_header(a, ae));
assertA(datasize
== (size_t)archive_write_data(a, data, datasize));
}
archive_entry_free(ae);
archive_write_close(a);
assert(0 == archive_write_finish(a));
assert((a = archive_read_new()) != NULL);
assertA(0 == 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;"
" gzip reading not fully supported on this platform");
} else {
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 < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Repeat the cycle again, this time setting some compression
* options.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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_WARN,
archive_write_set_compressor_options(a, "nonexistent-option=0"));
assertEqualIntA(a, ARCHIVE_WARN,
archive_write_set_compressor_options(a, "compression-level=abc"));
assertEqualIntA(a, ARCHIVE_WARN,
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));
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));
assertA(datasize == (size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
/*
failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
(int)used2, (int)used1);
assert(used2 < used1);
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* 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_bytes_per_block(a, 10));
assertA(0 == 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));
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));
failure("Writing file %s", path);
assertEqualIntA(a, datasize,
(size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
(int)used2, (int)used1);
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));
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Test various premature shutdown scenarios to make sure we
* don't crash or leak memory.
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Clean up.
*/
free(data);
free(buff);
}

245
lib/libarchive/test/test_write_compress_lzma.c Normal file
View file

@ -0,0 +1,245 @@
/*-
* Copyright (c) 2007-2009 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
* in this position and unchanged.
* 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$");
/*
* A basic exercise of lzma reading and writing.
*
*/
DEFINE_TEST(test_write_compress_lzma)
{
struct archive_entry *ae;
struct archive* a;
char *buff, *data;
size_t buffsize, datasize;
char path[16];
size_t used1, used2;
int i, r;
buffsize = 2000000;
assert(NULL != (buff = (char *)malloc(buffsize)));
datasize = 10000;
assert(NULL != (data = (char *)malloc(datasize)));
memset(data, 0, datasize);
/*
* Write a 100 files and read them all back.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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");
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
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));
assertEqualInt(ARCHIVE_COMPRESSION_LZMA, archive_compression(a));
assertEqualString("lzma", archive_compression_name(a));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_filetype(ae, AE_IFREG);
archive_entry_set_size(ae, datasize);
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
archive_entry_copy_pathname(ae, path);
assertA(0 == archive_write_header(a, ae));
assertA(datasize
== (size_t)archive_write_data(a, data, datasize));
}
archive_entry_free(ae);
archive_write_close(a);
assert(0 == archive_write_finish(a));
assert((a = archive_read_new()) != NULL);
assertA(0 == 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;"
" lzma reading not fully supported on this platform");
} else {
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 < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Repeat the cycle again, this time setting some compression
* options.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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_WARN,
archive_write_set_compressor_options(a, "nonexistent-option=0"));
assertEqualIntA(a, ARCHIVE_WARN,
archive_write_set_compressor_options(a, "compression-level=abc"));
assertEqualIntA(a, ARCHIVE_WARN,
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));
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));
assertA(datasize == (size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
failure("Trying to read %s", path);
if (!assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* 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_bytes_per_block(a, 10));
assertA(0 == 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));
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));
failure("Writing file %s", path);
assertEqualIntA(a, datasize,
(size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
(int)used2, (int)used1);
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));
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Test various premature shutdown scenarios to make sure we
* don't crash or leak memory.
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Clean up.
*/
free(data);
free(buff);
}

79
lib/libarchive/test/test_write_compress_program.c
View file

@ -38,18 +38,20 @@ DEFINE_TEST(test_write_compress_program)
size_t used;
int blocksize = 1024;
int r;
const char *extprog;
const char *compprog, *decompprog;
if ((extprog = external_gzip_program(0)) == NULL) {
decompprog = external_gzip_program(1);
if ((compprog = external_gzip_program(0)) == NULL) {
skipping("There is no gzip compression "
"program in this platform");
return;
}
/* Create a new archive in memory. */
/* Write it through an external "gzip" program. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_ustar(a));
r = archive_write_set_compression_program(a, extprog);
r = archive_write_set_compression_program(a, compprog);
if (r == ARCHIVE_FATAL) {
skipping("Write compression via external "
"program unsupported on this platform");
@ -77,60 +79,43 @@ DEFINE_TEST(test_write_compress_program)
/* Close out the archive. */
assertA(0 == archive_write_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(a);
#else
assertA(0 == archive_write_finish(a));
#endif
/*
* Now, read the data back through the built-in gzip support.
*/
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));
r = archive_read_next_header(a, &ae);
if (UnsupportedCompress(r, a)) {
skipping("This version of libarchive was compiled "
"without gzip support");
assert(0 == archive_read_finish(a));
/*
* Try using an external "gunzip","gzip -d" program
*/
if ((extprog = external_gzip_program(1)) == NULL) {
skipping("There is no gzip uncompression "
"program in this platform");
return;
}
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_program(a, extprog));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
r = archive_read_next_header(a, &ae);
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);
/* The compression_gzip() handler will fall back to gunzip
* automatically, but if we know gunzip isn't available, then
* skip the rest. */
if (r != ARCHIVE_OK && decompprog == NULL) {
skipping("No gzip decompression is available; "
"unable to verify gzip compression");
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
return;
}
assertA(0 == r);
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
assert(1 == archive_entry_mtime(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
if (!assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae))) {
archive_read_finish(a);
return;
}
assertEqualInt(1, archive_entry_mtime(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((S_IFREG | 0755), archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 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));
assert(0 == archive_read_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
#endif
}

253
lib/libarchive/test/test_write_compress_xz.c Normal file
View file

@ -0,0 +1,253 @@
/*-
* Copyright (c) 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
* in this position and unchanged.
* 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$");
/*
* A basic exercise of xz reading and writing.
*
* TODO: Add a reference file and make sure we can decompress that.
*/
DEFINE_TEST(test_write_compress_xz)
{
struct archive_entry *ae;
struct archive* a;
char *buff, *data;
size_t buffsize, datasize;
char path[16];
size_t used1, used2;
int i, r;
buffsize = 2000000;
assert(NULL != (buff = (char *)malloc(buffsize)));
datasize = 10000;
assert(NULL != (data = (char *)malloc(datasize)));
memset(data, 0, datasize);
/*
* Write a 100 files and read them all back.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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");
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
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));
assertEqualInt(ARCHIVE_COMPRESSION_XZ, archive_compression(a));
assertEqualString("xz", archive_compression_name(a));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_filetype(ae, AE_IFREG);
archive_entry_set_size(ae, datasize);
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
archive_entry_copy_pathname(ae, path);
assertA(0 == archive_write_header(a, ae));
assertA(datasize
== (size_t)archive_write_data(a, data, datasize));
}
archive_entry_free(ae);
archive_write_close(a);
assert(0 == archive_write_finish(a));
assert((a = archive_read_new()) != NULL);
assertA(0 == 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;"
" xz reading not fully supported on this platform");
} else {
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 < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Repeat the cycle again, this time setting some compression
* options.
*/
assert((a = archive_write_new()) != NULL);
assertA(0 == 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_WARN,
archive_write_set_compressor_options(a, "nonexistent-option=0"));
assertEqualIntA(a, ARCHIVE_WARN,
archive_write_set_compressor_options(a, "compression-level=abc"));
assertEqualIntA(a, ARCHIVE_WARN,
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));
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));
assertA(datasize == (size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
/*
failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
(int)used2, (int)used1);
assert(used2 < used1);
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
failure("Trying to read %s", path);
if (!assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* 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_bytes_per_block(a, 10));
assertA(0 == 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));
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));
failure("Writing file %s", path);
assertEqualIntA(a, datasize,
(size_t)archive_write_data(a, data, datasize));
archive_entry_free(ae);
}
archive_write_close(a);
assert(0 == archive_write_finish(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
(int)used2, (int)used1);
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));
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used2));
for (i = 0; i < 100; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
/*
* Test various premature shutdown scenarios to make sure we
* don't crash or leak memory.
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
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));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
/*
* Clean up.
*/
free(data);
free(buff);
}

10
lib/libarchive/test/test_write_disk_failures.c
View file

@ -39,6 +39,7 @@ DEFINE_TEST(test_write_disk_failures)
#else
struct archive_entry *ae;
struct archive *a;
int fd;
/* Force the umask to something predictable. */
umask(UMASK);
@ -46,6 +47,15 @@ DEFINE_TEST(test_write_disk_failures)
/* A directory that we can't write to. */
assertEqualInt(0, mkdir("dir", 0555));
/* Can we? */
fd = open("dir/testfile", O_WRONLY | O_CREAT, 0777);
if (fd >= 0) {
/* Apparently, we can, so the test below won't work. */
close(fd);
skipping("Can't test writing to non-writable directory");
return;
}
/* Try to extract a regular file into the directory above. */
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "dir/file");

2
lib/libarchive/test/test_write_disk_sparse.c
View file

@ -116,6 +116,7 @@ verify_write_data(struct archive *a, int sparse)
/* XXX more XXX */
assertEqualInt(0, close(fd));
archive_entry_free(ae);
free(buff);
}
@ -249,6 +250,7 @@ verify_write_data_block(struct archive *a, int sparse)
assertEqualInt(0, close(fd));
free(buff);
archive_entry_free(ae);
}
DEFINE_TEST(test_write_disk_sparse)

155
lib/libarchive/test/test_write_format_mtree.c Normal file
View file

@ -0,0 +1,155 @@
/*-
* Copyright (c) 2009 Michihiro NAKAJIMA
* 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
* in this position and unchanged.
* 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$");
static char buff[4096];
static struct {
const char *path;
mode_t mode;
time_t mtime;
uid_t uid;
gid_t gid;
} entries[] = {
{ "./Makefile", S_IFREG | 0644, 1233041050, 1001, 1001 },
{ "./NEWS", S_IFREG | 0644, 1231975636, 1001, 1001 },
{ "./PROJECTS", S_IFREG | 0644, 1231975636, 1001, 1001 },
{ "./README", S_IFREG | 0644, 1231975636, 1001, 1001 },
{ "./COPYING", S_IFREG | 0644, 1231975636, 1001, 1001 },
{ "./subdir", S_IFDIR | 0755, 1233504586, 1001, 1001 },
{ "./subdir/README", S_IFREG | 0664, 1231975636, 1002, 1001 },
{ "./subdir/config", S_IFREG | 0664, 1232266273, 1003, 1003 },
{ "./subdir2", S_IFDIR | 0755, 1233504586, 1001, 1001 },
{ "./subdir3", S_IFDIR | 0755, 1233504586, 1001, 1001 },
{ "./subdir3/mtree", S_IFREG | 0664, 1232266273, 1003, 1003 },
{ NULL, 0, 0, 0, 0 }
};
static void
test_write_format_mtree_sub(int use_set, int dironly)
{
struct archive_entry *ae;
struct archive* a;
size_t used;
int i;
/* Create a mtree format archive. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_mtree(a));
if (use_set)
assertA(0 == 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));
/* Write entries */
for (i = 0; entries[i].path != NULL; i++) {
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, entries[i].mtime, 0);
assert(entries[i].mtime == archive_entry_mtime(ae));
archive_entry_set_mode(ae, entries[i].mode);
assert(entries[i].mode == archive_entry_mode(ae));
archive_entry_set_uid(ae, entries[i].uid);
assert(entries[i].uid == archive_entry_uid(ae));
archive_entry_set_gid(ae, entries[i].gid);
assert(entries[i].gid == archive_entry_gid(ae));
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));
if ((entries[i].mode & AE_IFMT) != S_IFDIR)
assertA(8 == archive_write_data(a, "Hello012", 15));
archive_entry_free(ae);
}
archive_write_close(a);
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(a);
#else
assertEqualInt(0, archive_write_finish(a));
#endif
if (use_set) {
const char *p;
buff[used] = '\0';
assert(NULL != (p = strstr(buff, "\n/set ")));
if (p != NULL) {
char *r;
const char *o;
p++;
r = strchr(p, '\n');
if (r != NULL)
*r = '\0';
if (dironly)
o = "/set type=dir uid=1001 gid=1001 mode=755";
else
o = "/set type=file uid=1001 gid=1001 mode=644";
assertEqualString(o, p);
if (r != NULL)
*r = '\n';
}
}
/*
* Read the data and check it.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
/* Read entries */
for (i = 0; entries[i].path != NULL; i++) {
if (dironly && (entries[i].mode & AE_IFMT) != S_IFDIR)
continue;
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(entries[i].mtime, archive_entry_mtime(ae));
assertEqualInt(entries[i].mode, archive_entry_mode(ae));
assertEqualInt(entries[i].uid, archive_entry_uid(ae));
assertEqualInt(entries[i].gid, archive_entry_gid(ae));
assertEqualString(entries[i].path, archive_entry_pathname(ae));
if ((entries[i].mode & AE_IFMT) != S_IFDIR)
assertEqualInt(8, archive_entry_size(ae));
}
assertEqualIntA(a, 0, archive_read_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assertEqualInt(0, archive_read_finish(a));
#endif
}
DEFINE_TEST(test_write_format_mtree)
{
/* Default setting */
test_write_format_mtree_sub(0, 0);
/* Directory only */
test_write_format_mtree_sub(0, 1);
/* Use /set keyword */
test_write_format_mtree_sub(1, 0);
/* Use /set keyword with directory only */
test_write_format_mtree_sub(1, 1);
}