Switch to using libarchive from libtar for cpack and cmake -E tar

This allows for a built in bzip and zip capability, so external tools
will not be needed for these packagers.  The cmake -E tar xf should be
able to handle all compression types now as well.

44 files changed, 5575 insertions, 0 deletions

diff --git a/Utilities/cmlibarchive/cpio/test/CMakeLists.txt b/Utilities/cmlibarchive/cpio/test/CMakeLists.txt
new file mode 100644
index 0000000..4e1c98f
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/CMakeLists.txt
@@ -0,0 +1,75 @@
+############################################
+#
+# How to build bsdcpio_test
+#
+############################################
+IF(ENABLE_CPIO AND ENABLE_TEST)
+  SET(bsdcpio_test_SOURCES
+    ../cmdline.c
+    ../../libarchive_fe/err.c
+    ../../libarchive_fe/pathmatch.c
+    main.c
+    test.h
+    test_0.c
+    test_basic.c
+    test_cmdline.c
+    test_format_newc.c
+    test_gcpio_compat.c
+    test_option_B_upper.c
+    test_option_C_upper.c
+    test_option_J_upper.c
+    test_option_L_upper.c
+    test_option_Z_upper.c
+    test_option_a.c
+    test_option_c.c
+    test_option_d.c
+    test_option_f.c
+    test_option_help.c
+    test_option_l.c
+    test_option_lzma.c
+    test_option_m.c
+    test_option_t.c
+    test_option_u.c
+    test_option_version.c
+    test_option_y.c
+    test_option_z.c
+    test_owner_parse.c
+    test_passthrough_dotdot.c
+    test_passthrough_reverse.c
+    test_pathmatch.c
+  )
+  IF(WIN32 AND NOT CYGWIN)
+    LIST(APPEND bsdcpio_test_SOURCES ../cpio_windows.h)
+  ENDIF(WIN32 AND NOT CYGWIN)
+
+  #
+  # Generate the list.h
+  #
+  GENERATE_LIST_H(${CMAKE_CURRENT_BINARY_DIR}/list.h
+    ${CMAKE_CURRENT_LIST_FILE} ${bsdcpio_test_SOURCES})
+  SET_PROPERTY(DIRECTORY APPEND PROPERTY INCLUDE_DIRECTORIES
+    ${CMAKE_CURRENT_BINARY_DIR})
+  #
+  # Register target
+  #
+  ADD_EXECUTABLE(bsdcpio_test ${bsdcpio_test_SOURCES})
+  SET_PROPERTY(TARGET bsdcpio_test PROPERTY COMPILE_DEFINITIONS LIST_H)
+
+  # ADD_TEST() for each separate test
+  SET(num 0)
+  FOREACH(test ${bsdcpio_test_SOURCES})
+    IF(test MATCHES "^test_[^/]+[.]c$")
+      STRING(REGEX REPLACE "^(test_[^/]+)[.]c$" "\\1" testname ${test})
+      ADD_TEST("bsdcpio_${testname}" bsdcpio_test
+        -v -p ${BSDCPIO} -r ${CMAKE_CURRENT_SOURCE_DIR} ${num})
+      MATH(EXPR num "${num} + 1")
+    ENDIF(test MATCHES "^test_[^/]+[.]c$")
+  ENDFOREACH(test)
+
+  # Experimental new test handling
+  ADD_CUSTOM_TARGET(run_bsdcpio_test
+    COMMAND bsdcpio_test -p ${BSDCPIO} -r ${CMAKE_CURRENT_SOURCE_DIR})
+  ADD_DEPENDENCIES(run_bsdcpio_test bsdcpio)
+  ADD_DEPENDENCIES(run_all_tests run_bsdcpio_test)
+ENDIF(ENABLE_CPIO AND ENABLE_TEST)
+
diff --git a/Utilities/cmlibarchive/cpio/test/Makefile b/Utilities/cmlibarchive/cpio/test/Makefile
new file mode 100644
index 0000000..ab4247c
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/Makefile
@@ -0,0 +1,75 @@
+# $FreeBSD: src/usr.bin/cpio/test/Makefile,v 1.4 2008/08/24 05:49:36 kientzle Exp $
+
+# Where to find the cpio sources (for the internal unit tests)
+CPIO_SRCDIR=${.CURDIR}/..
+.PATH: ${CPIO_SRCDIR} ${CPIO_SRCDIR}/../libarchive_fe
+
+# Some cpio sources are pulled in for white-box tests
+CPIO_SRCS= cmdline.c err.c pathmatch.c
+
+TESTS=  \
+    test_0.c                \
+    test_basic.c                \
+    test_cmdline.c              \
+    test_format_newc.c          \
+    test_gcpio_compat.c         \
+    test_option_B_upper.c           \
+    test_option_C_upper.c           \
+    test_option_J_upper.c           \
+    test_option_L_upper.c           \
+    test_option_Z_upper.c           \
+    test_option_a.c             \
+    test_option_c.c             \
+    test_option_d.c             \
+    test_option_f.c             \
+    test_option_help.c          \
+    test_option_l.c             \
+    test_option_lzma.c          \
+    test_option_m.c             \
+    test_option_t.c             \
+    test_option_u.c             \
+    test_option_version.c           \
+    test_option_y.c             \
+    test_option_z.c             \
+    test_owner_parse.c          \
+    test_passthrough_dotdot.c       \
+    test_passthrough_reverse.c      \
+    test_pathmatch.c
+
+# Build the test program
+SRCS= list.h                    \
+    ${CPIO_SRCS}                \
+    ${TESTS}                \
+    main.c
+
+CLEANFILES+= list.h bsdcpio_test
+
+NO_MAN=yes
+
+PROG=bsdcpio_test
+DPADD=${LIBARCHIVE} ${LIBBZ2} ${LIBZ}
+CFLAGS+=    -DPLATFORM_CONFIG_H=\"config_freebsd.h\"
+CFLAGS+=    -I.. -I../../libarchive_fe
+LDADD= -larchive -lz -lbz2
+CFLAGS+= -static -g -O2 -Wall
+CFLAGS+= -I${.OBJDIR}
+CFLAGS+= -I${CPIO_SRCDIR}
+
+# Uncomment to link against dmalloc
+#LDADD+= -L/usr/local/lib -ldmalloc
+#CFLAGS+= -I/usr/local/include -DUSE_DMALLOC
+WARNS=6
+
+check test: bsdcpio_test
+    ${.OBJDIR}/bsdcpio_test -p ${.OBJDIR}/../bsdcpio -r ${.CURDIR}
+
+${.OBJDIR}/list.h list.h: ${TESTS} Makefile
+    (cd ${.CURDIR}; cat ${TESTS}) | grep DEFINE_TEST > list.h
+
+clean:
+    rm -f ${CLEANFILES}
+    rm -f *~
+    -chmod -R +w /tmp/bsdcpio_test.*
+    rm -rf /tmp/bsdcpio_test.*
+
+.include <bsd.prog.mk>
diff --git a/Utilities/cmlibarchive/cpio/test/main.c b/Utilities/cmlibarchive/cpio/test/main.c
new file mode 100644
index 0000000..2740134
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/main.c
@@ -0,0 +1,2059 @@
+/*
+ * 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 <errno.h>
+#include <locale.h>
+#include <stdarg.h>
+#include <time.h>
+#include "test.h"
+
+/*
+ * This same file is used pretty much verbatim for all test harnesses.
+ *
+ * The next few lines are the only differences.
+ * TODO: Move this into a separate configuration header, have all test
+ * suites share one copy of this file.
+ */
+__FBSDID("$FreeBSD: src/usr.bin/cpio/test/main.c,v 1.3 2008/08/24 04:58:22 kientzle Exp $");
+#define KNOWNREF    "test_option_f.cpio.uu"
+#define ENVBASE "BSDCPIO" /* Prefix for environment variables. */
+#define PROGRAM "bsdcpio" /* Name of program being tested. */
+#undef LIBRARY        /* Not testing a library. */
+#undef  EXTRA_DUMP       /* How to dump extra data */
+/* How to generate extra version info. */
+#define EXTRA_VERSION    (systemf("%s --version", testprog) ? "" : "")
+
+/*
+ *
+ * Windows support routines
+ *
+ * Note: Configuration is a tricky issue.  Using HAVE_* feature macros
+ * in the test harness is dangerous because they cover up
+ * configuration errors.  The classic example of this is omitting a
+ * configure check.  If libarchive and libarchive_test both look for
+ * the same feature macro, such errors are hard to detect.  Platform
+ * macros (e.g., _WIN32 or __GNUC__) are a little better, but can
+ * easily lead to very messy code.  It's best to limit yourself
+ * to only the most generic programming techniques in the test harness
+ * and thus avoid conditionals altogether.  Where that's not possible,
+ * try to minimize conditionals by grouping platform-specific tests in
+ * one place (e.g., test_acl_freebsd) or by adding new assert()
+ * functions (e.g., assertMakeHardlink()) to cover up platform
+ * differences.  Platform-specific coding in libarchive_test is often
+ * a symptom that some capability is missing from libarchive itself.
+ */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#if !defined(__GNUC__)
+#include <crtdbg.h>
+#endif
+#include <io.h>
+#include <windows.h>
+#ifndef F_OK
+#define F_OK (0)
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(m)  ((m) & _S_IFDIR)
+#endif
+#ifndef S_ISREG
+#define S_ISREG(m)  ((m) & _S_IFREG)
+#endif
+#define access _access
+#define chdir _chdir
+#ifndef fileno
+#define fileno _fileno
+#endif
+/*#define fstat _fstat64*/
+#define getcwd _getcwd
+#define lstat stat
+/*#define lstat _stat64*/
+/*#define stat _stat64*/
+#define rmdir _rmdir
+#define strdup _strdup
+#define umask _umask
+#define int64_t __int64
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+void *GetFunctionKernel32(const char *name)
+{
+    static HINSTANCE lib;
+    static int set;
+    if (!set) {
+        set = 1;
+        lib = LoadLibrary("kernel32.dll");
+    }
+    if (lib == NULL) {
+        fprintf(stderr, "Can't load kernel32.dll?!\n");
+        exit(1);
+    }
+    return (void *)GetProcAddress(lib, name);
+}
+
+static int
+my_CreateSymbolicLinkA(const char *linkname, const char *target, int flags)
+{
+    static BOOLEAN (WINAPI *f)(LPCSTR, LPCSTR, DWORD);
+    static int set;
+    if (!set) {
+        set = 1;
+        f = GetFunctionKernel32("CreateSymbolicLinkA");
+    }
+    return f == NULL ? 0 : (*f)(linkname, target, flags);
+}
+
+static int
+my_CreateHardLinkA(const char *linkname, const char *target)
+{
+    static BOOLEAN (WINAPI *f)(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
+    static int set;
+    if (!set) {
+        set = 1;
+        f = GetFunctionKernel32("CreateHardLinkA");
+    }
+    return f == NULL ? 0 : (*f)(linkname, target, NULL);
+}
+
+int
+my_GetFileInformationByName(const char *path, BY_HANDLE_FILE_INFORMATION *bhfi)
+{
+    HANDLE h;
+    int r;
+
+    memset(bhfi, 0, sizeof(*bhfi));
+    h = CreateFile(path, FILE_READ_ATTRIBUTES, 0, NULL,
+        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (h == INVALID_HANDLE_VALUE)
+        return (0);
+    r = GetFileInformationByHandle(h, bhfi);
+    CloseHandle(h);
+    return (r);
+}
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__GNUC__)
+static void
+invalid_parameter_handler(const wchar_t * expression,
+    const wchar_t * function, const wchar_t * file,
+    unsigned int line, uintptr_t pReserved)
+{
+    /* nop */
+}
+#endif
+
+/*
+ *
+ * OPTIONS FLAGS
+ *
+ */
+
+/* Enable core dump on failure. */
+static int dump_on_failure = 0;
+/* Default is to remove temp dirs and log data for successful tests. */
+static int keep_temp_files = 0;
+/* Default is to just report pass/fail for each test. */
+static int verbosity = 0;
+#define VERBOSITY_SUMMARY_ONLY -1 /* -q */
+#define VERBOSITY_PASSFAIL 0   /* Default */
+#define VERBOSITY_LIGHT_REPORT 1 /* -v */
+#define VERBOSITY_FULL 2 /* -vv */
+/* A few places generate even more output for verbosity > VERBOSITY_FULL,
+ * mostly for debugging the test harness itself. */
+/* Cumulative count of assertion failures. */
+static int failures = 0;
+/* Cumulative count of reported skips. */
+static int skips = 0;
+/* Cumulative count of assertions checked. */
+static int assertions = 0;
+
+/* Directory where uuencoded reference files can be found. */
+static const char *refdir;
+
+/*
+ * Report log information selectively to console and/or disk log.
+ */
+static int log_console = 0;
+static FILE *logfile;
+static void
+vlogprintf(const char *fmt, va_list ap)
+{
+    if (log_console)
+        vfprintf(stdout, fmt, ap);
+    if (logfile != NULL)
+        vfprintf(logfile, fmt, ap);
+}
+
+static void
+logprintf(const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    vlogprintf(fmt, ap);
+    va_end(ap);
+}
+
+/* Set up a message to display only if next assertion fails. */
+static char msgbuff[4096];
+static const char *msg, *nextmsg;
+void
+failure(const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    vsprintf(msgbuff, fmt, ap);
+    va_end(ap);
+    nextmsg = msgbuff;
+}
+
+/*
+ * Copy arguments into file-local variables.
+ * This was added to permit vararg assert() functions without needing
+ * variadic wrapper macros.  Turns out that the vararg capability is almost
+ * never used, so almost all of the vararg assertions can be simplified
+ * by removing the vararg capability and reworking the wrapper macro to
+ * pass __FILE__, __LINE__ directly into the function instead of using
+ * this hook.  I suspect this machinery is used so rarely that we
+ * would be better off just removing it entirely.  That would simplify
+ * the code here noticably.
+ */
+static const char *test_filename;
+static int test_line;
+static void *test_extra;
+void assertion_setup(const char *filename, int line)
+{
+    test_filename = filename;
+    test_line = line;
+}
+
+/* Called at the beginning of each assert() function. */
+static void
+assertion_count(const char *file, int line)
+{
+    (void)file; /* UNUSED */
+    (void)line; /* UNUSED */
+    ++assertions;
+    /* Proper handling of "failure()" message. */
+    msg = nextmsg;
+    nextmsg = NULL;
+    /* Uncomment to print file:line after every assertion.
+     * Verbose, but occasionally useful in tracking down crashes. */
+    /* printf("Checked %s:%d\n", file, line); */
+}
+
+/*
+ * For each test source file, we remember how many times each
+ * assertion was reported.  Cleared before each new test,
+ * used by test_summarize().
+ */
+static struct line {
+    int count;
+    int skip;
+}  failed_lines[10000];
+
+/* Count this failure, setup up log destination and handle initial report. */
+static void
+failure_start(const char *filename, int line, const char *fmt, ...)
+{
+    va_list ap;
+
+    /* Record another failure for this line. */
+    ++failures;
+    test_filename = filename;
+    failed_lines[line].count++;
+
+    /* Determine whether to log header to console. */
+    switch (verbosity) {
+    case VERBOSITY_FULL:
+        log_console = 1;
+        break;
+    case VERBOSITY_LIGHT_REPORT:
+        log_console = (failed_lines[line].count < 2);
+        break;
+    default:
+        log_console = 0;
+    }
+
+    /* Log file:line header for this failure */
+    va_start(ap, fmt);
+#if _MSC_VER
+    logprintf("%s(%d): ", filename, line);
+#else
+    logprintf("%s:%d: ", filename, line);
+#endif
+    vlogprintf(fmt, ap);
+    va_end(ap);
+    logprintf("\n");
+
+    if (msg != NULL && msg[0] != '\0') {
+        logprintf("   Description: %s\n", msg);
+        msg = NULL;
+    }
+
+    /* Determine whether to log details to console. */
+    if (verbosity == VERBOSITY_LIGHT_REPORT)
+        log_console = 0;
+}
+
+/* Complete reporting of failed tests. */
+/*
+ * The 'extra' hook here is used by libarchive to include libarchive
+ * error messages with assertion failures.  It could also be used
+ * to add strerror() output, for example.  Just define the EXTRA_DUMP()
+ * macro appropriately.
+ */
+static void
+failure_finish(void *extra)
+{
+    (void)extra; /* UNUSED (maybe) */
+#ifdef EXTRA_DUMP
+    if (extra != NULL)
+        logprintf("   detail: %s\n", EXTRA_DUMP(extra));
+#endif
+
+    if (dump_on_failure) {
+        fprintf(stderr,
+            " *** forcing core dump so failure can be debugged ***\n");
+        *(char *)(NULL) = 0;
+        exit(1);
+    }
+}
+
+/* Inform user that we're skipping some checks. */
+void
+test_skipping(const char *fmt, ...)
+{
+    char buff[1024];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buff, fmt, ap);
+    va_end(ap);
+    /* failure_start() isn't quite right, but is awfully convenient. */
+    failure_start(test_filename, test_line, "SKIPPING: %s", buff);
+    --failures; /* Undo failures++ in failure_start() */
+    /* Don't failure_finish() here. */
+    /* Mark as skip, so doesn't count as failed test. */
+    failed_lines[test_line].skip = 1;
+    ++skips;
+}
+
+/*
+ *
+ * ASSERTIONS
+ *
+ */
+
+/* Generic assert() just displays the failed condition. */
+int
+assertion_assert(const char *file, int line, int value,
+    const char *condition, void *extra)
+{
+    assertion_count(file, line);
+    if (!value) {
+        failure_start(file, line, "Assertion failed: %s", condition);
+        failure_finish(extra);
+    }
+    return (value);
+}
+
+/* chdir() and report any errors */
+int
+assertion_chdir(const char *file, int line, const char *pathname)
+{
+    assertion_count(file, line);
+    if (chdir(pathname) == 0)
+        return (1);
+    failure_start(file, line, "chdir(\"%s\")", pathname);
+    failure_finish(NULL);
+    return (0);
+
+}
+
+/* Verify two integers are equal. */
+int
+assertion_equal_int(const char *file, int line,
+    long long v1, const char *e1, long long v2, const char *e2, void *extra)
+{
+    assertion_count(file, line);
+    if (v1 == v2)
+        return (1);
+    failure_start(file, line, "%s != %s", e1, e2);
+    logprintf("      %s=%lld (0x%llx, 0%llo)\n", e1, v1, v1, v1);
+    logprintf("      %s=%lld (0x%llx, 0%llo)\n", e2, v2, v2, v2);
+    failure_finish(extra);
+    return (0);
+}
+
+static void strdump(const char *e, const char *p)
+{
+    logprintf("      %s = ", e);
+    if (p == NULL) {
+        logprintf("(null)");
+        return;
+    }
+    logprintf("\"");
+    while (*p != '\0') {
+        unsigned int c = 0xff & *p++;
+        switch (c) {
+        case '\a': printf("\a"); break;
+        case '\b': printf("\b"); break;
+        case '\n': printf("\n"); break;
+        case '\r': printf("\r"); break;
+        default:
+            if (c >= 32 && c < 127)
+                logprintf("%c", c);
+            else
+                logprintf("\\x%02X", c);
+        }
+    }
+    logprintf("\"");
+    logprintf(" (length %d)\n", p == NULL ? 0 : (int)strlen(p));
+}
+
+/* Verify two strings are equal, dump them if not. */
+int
+assertion_equal_string(const char *file, int line,
+    const char *v1, const char *e1,
+    const char *v2, const char *e2,
+    void *extra)
+{
+    assertion_count(file, line);
+    if (v1 == v2 || strcmp(v1, v2) == 0)
+        return (1);
+    failure_start(file, line, "%s != %s", e1, e2);
+    strdump(e1, v1);
+    strdump(e2, v2);
+    failure_finish(extra);
+    return (0);
+}
+
+static void
+wcsdump(const char *e, const wchar_t *w)
+{
+    logprintf("      %s = ", e);
+    if (w == NULL) {
+        logprintf("(null)");
+        return;
+    }
+    logprintf("\"");
+    while (*w != L'\0') {
+        unsigned int c = *w++;
+        if (c >= 32 && c < 127)
+            logprintf("%c", c);
+        else if (c < 256)
+            logprintf("\\x%02X", c);
+        else if (c < 0x10000)
+            logprintf("\\u%04X", c);
+        else
+            logprintf("\\U%08X", c);
+    }
+    logprintf("\"\n");
+}
+
+/* Verify that two wide strings are equal, dump them if not. */
+int
+assertion_equal_wstring(const char *file, int line,
+    const wchar_t *v1, const char *e1,
+    const wchar_t *v2, const char *e2,
+    void *extra)
+{
+    assertion_count(file, line);
+    if (v1 == v2 || wcscmp(v1, v2) == 0)
+        return (1);
+    failure_start(file, line, "%s != %s", e1, e2);
+    wcsdump(e1, v1);
+    wcsdump(e2, v2);
+    failure_finish(extra);
+    return (0);
+}
+
+/*
+ * Pretty standard hexdump routine.  As a bonus, if ref != NULL, then
+ * any bytes in p that differ from ref will be highlighted with '_'
+ * before and after the hex value.
+ */
+static void
+hexdump(const char *p, const char *ref, size_t l, size_t offset)
+{
+    size_t i, j;
+    char sep;
+
+    for(i=0; i < l; i+=16) {
+        logprintf("%04x", (unsigned)(i + offset));
+        sep = ' ';
+        for (j = 0; j < 16 && i + j < l; j++) {
+            if (ref != NULL && p[i + j] != ref[i + j])
+                sep = '_';
+            logprintf("%c%02x", sep, 0xff & (int)p[i+j]);
+            if (ref != NULL && p[i + j] == ref[i + j])
+                sep = ' ';
+        }
+        for (; j < 16; j++) {
+            logprintf("%c  ", sep);
+            sep = ' ';
+        }
+        logprintf("%c", sep);
+        for (j=0; j < 16 && i + j < l; j++) {
+            int c = p[i + j];
+            if (c >= ' ' && c <= 126)
+                logprintf("%c", c);
+            else
+                logprintf(".");
+        }
+        logprintf("\n");
+    }
+}
+
+/* Verify that two blocks of memory are the same, display the first
+ * block of differences if they're not. */
+int
+assertion_equal_mem(const char *file, int line,
+    const void *_v1, const char *e1,
+    const void *_v2, const char *e2,
+    size_t l, const char *ld, void *extra)
+{
+    const char *v1 = (const char *)_v1;
+    const char *v2 = (const char *)_v2;
+    size_t offset;
+
+    assertion_count(file, line);
+    if (v1 == v2 || memcmp(v1, v2, l) == 0)
+        return (1);
+
+    failure_start(file, line, "%s != %s", e1, e2);
+    logprintf("      size %s = %d\n", ld, (int)l);
+    /* Dump 48 bytes (3 lines) so that the first difference is
+     * in the second line. */
+    offset = 0;
+    while (l > 64 && memcmp(v1, v2, 32) == 0) {
+        /* Two lines agree, so step forward one line. */
+        v1 += 16;
+        v2 += 16;
+        l -= 16;
+        offset += 16;
+    }
+    logprintf("      Dump of %s\n", e1);
+    hexdump(v1, v2, l < 64 ? l : 64, offset);
+    logprintf("      Dump of %s\n", e2);
+    hexdump(v2, v1, l < 64 ? l : 64, offset);
+    logprintf("\n");
+    failure_finish(extra);
+    return (0);
+}
+
+/* Verify that the named file exists and is empty. */
+int
+assertion_empty_file(const char *f1fmt, ...)
+{
+    char buff[1024];
+    char f1[1024];
+    struct stat st;
+    va_list ap;
+    ssize_t s;
+    FILE *f;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, f1fmt);
+    vsprintf(f1, f1fmt, ap);
+    va_end(ap);
+
+    if (stat(f1, &st) != 0) {
+        failure_start(test_filename, test_line, "Stat failed: %s", f1);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (st.st_size == 0)
+        return (1);
+
+    failure_start(test_filename, test_line, "File should be empty: %s", f1);
+    logprintf("    File size: %d\n", (int)st.st_size);
+    logprintf("    Contents:\n");
+    f = fopen(f1, "rb");
+    if (f == NULL) {
+        logprintf("    Unable to open %s\n", f1);
+    } else {
+        s = ((off_t)sizeof(buff) < st.st_size) ?
+            (ssize_t)sizeof(buff) : (ssize_t)st.st_size;
+        s = fread(buff, 1, s, f);
+        hexdump(buff, NULL, s, 0);
+        fclose(f);
+    }
+    failure_finish(NULL);
+    return (0);
+}
+
+/* Verify that the named file exists and is not empty. */
+int
+assertion_non_empty_file(const char *f1fmt, ...)
+{
+    char f1[1024];
+    struct stat st;
+    va_list ap;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, f1fmt);
+    vsprintf(f1, f1fmt, ap);
+    va_end(ap);
+
+    if (stat(f1, &st) != 0) {
+        failure_start(test_filename, test_line, "Stat failed: %s", f1);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (st.st_size == 0) {
+        failure_start(test_filename, test_line, "File empty: %s", f1);
+        failure_finish(NULL);
+        return (0);
+    }
+    return (1);
+}
+
+/* Verify that two files have the same contents. */
+/* TODO: hexdump the first bytes that actually differ. */
+int
+assertion_equal_file(const char *fn1, const char *f2pattern, ...)
+{
+    char fn2[1024];
+    va_list ap;
+    char buff1[1024];
+    char buff2[1024];
+    FILE *f1, *f2;
+    int n1, n2;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, f2pattern);
+    vsprintf(fn2, f2pattern, ap);
+    va_end(ap);
+
+    f1 = fopen(fn1, "rb");
+    f2 = fopen(fn2, "rb");
+    for (;;) {
+        n1 = fread(buff1, 1, sizeof(buff1), f1);
+        n2 = fread(buff2, 1, sizeof(buff2), f2);
+        if (n1 != n2)
+            break;
+        if (n1 == 0 && n2 == 0) {
+            fclose(f1);
+            fclose(f2);
+            return (1);
+        }
+        if (memcmp(buff1, buff2, n1) != 0)
+            break;
+    }
+    fclose(f1);
+    fclose(f2);
+    failure_start(test_filename, test_line, "Files not identical");
+    logprintf("  file1=\"%s\"\n", fn1);
+    logprintf("  file2=\"%s\"\n", fn2);
+    failure_finish(test_extra);
+    return (0);
+}
+
+/* Verify that the named file does exist. */
+int
+assertion_file_exists(const char *fpattern, ...)
+{
+    char f[1024];
+    va_list ap;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, fpattern);
+    vsprintf(f, fpattern, ap);
+    va_end(ap);
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    if (!_access(f, 0))
+        return (1);
+#else
+    if (!access(f, F_OK))
+        return (1);
+#endif
+    failure_start(test_filename, test_line, "File should exist: %s", f);
+    failure_finish(test_extra);
+    return (0);
+}
+
+/* Verify that the named file doesn't exist. */
+int
+assertion_file_not_exists(const char *fpattern, ...)
+{
+    char f[1024];
+    va_list ap;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, fpattern);
+    vsprintf(f, fpattern, ap);
+    va_end(ap);
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    if (_access(f, 0))
+        return (1);
+#else
+    if (access(f, F_OK))
+        return (1);
+#endif
+    failure_start(test_filename, test_line, "File should not exist: %s", f);
+    failure_finish(test_extra);
+    return (0);
+}
+
+/* Compare the contents of a file to a block of memory. */
+int
+assertion_file_contents(const void *buff, int s, const char *fpattern, ...)
+{
+    char fn[1024];
+    va_list ap;
+    char *contents;
+    FILE *f;
+    int n;
+
+    assertion_count(test_filename, test_line);
+    va_start(ap, fpattern);
+    vsprintf(fn, fpattern, ap);
+    va_end(ap);
+
+    f = fopen(fn, "rb");
+    if (f == NULL) {
+        failure_start(test_filename, test_line,
+            "File should exist: %s", fn);
+        failure_finish(test_extra);
+        return (0);
+    }
+    contents = malloc(s * 2);
+    n = fread(contents, 1, s * 2, f);
+    fclose(f);
+    if (n == s && memcmp(buff, contents, s) == 0) {
+        free(contents);
+        return (1);
+    }
+    failure_start(test_filename, test_line, "File contents don't match");
+    logprintf("  file=\"%s\"\n", fn);
+    if (n > 0)
+        hexdump(contents, buff, n > 512 ? 512 : 0, 0);
+    else {
+        logprintf("  File empty, contents should be:\n");
+        hexdump(buff, NULL, s > 512 ? 512 : 0, 0);
+    }
+    failure_finish(test_extra);
+    free(contents);
+    return (0);
+}
+
+/* Check the contents of a text file, being tolerant of line endings. */
+int
+assertion_text_file_contents(const char *buff, const char *fn)
+{
+    char *contents;
+    const char *btxt, *ftxt;
+    FILE *f;
+    int n, s;
+
+    assertion_count(test_filename, test_line);
+    f = fopen(fn, "r");
+    s = strlen(buff);
+    contents = malloc(s * 2 + 128);
+    n = fread(contents, 1, s * 2 + 128 - 1, f);
+    if (n >= 0)
+        contents[n] = '\0';
+    fclose(f);
+    /* Compare texts. */
+    btxt = buff;
+    ftxt = (const char *)contents;
+    while (*btxt != '\0' && *ftxt != '\0') {
+        if (*btxt == *ftxt) {
+            ++btxt;
+            ++ftxt;
+            continue;
+        }
+        if (btxt[0] == '\n' && ftxt[0] == '\r' && ftxt[1] == '\n') {
+            /* Pass over different new line characters. */
+            ++btxt;
+            ftxt += 2;
+            continue;
+        }
+        break;
+    }
+    if (*btxt == '\0' && *ftxt == '\0') {
+        free(contents);
+        return (1);
+    }
+    failure_start(test_filename, test_line, "Contents don't match");
+    logprintf("  file=\"%s\"\n", fn);
+    if (n > 0)
+        hexdump(contents, buff, n, 0);
+    else {
+        logprintf("  File empty, contents should be:\n");
+        hexdump(buff, NULL, s, 0);
+    }
+    failure_finish(test_extra);
+    free(contents);
+    return (0);
+}
+
+/* Test that two paths point to the same file. */
+/* As a side-effect, asserts that both files exist. */
+static int
+is_hardlink(const char *file, int line,
+    const char *path1, const char *path2)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    BY_HANDLE_FILE_INFORMATION bhfi1, bhfi2;
+    int r;
+
+    assertion_count(file, line);
+    r = my_GetFileInformationByName(path1, &bhfi1);
+    if (r == 0) {
+        failure_start(file, line, "File %s can't be inspected?", path1);
+        failure_finish(NULL);
+        return (0);
+    }
+    r = my_GetFileInformationByName(path2, &bhfi2);
+    if (r == 0) {
+        failure_start(file, line, "File %s can't be inspected?", path2);
+        failure_finish(NULL);
+        return (0);
+    }
+    return (bhfi1.dwVolumeSerialNumber == bhfi2.dwVolumeSerialNumber
+        && bhfi1.nFileIndexHigh == bhfi2.nFileIndexHigh
+        && bhfi1.nFileIndexLow == bhfi2.nFileIndexLow);
+#else
+    struct stat st1, st2;
+    int r;
+
+    assertion_count(file, line);
+    r = lstat(path1, &st1);
+    if (r != 0) {
+        failure_start(file, line, "File should exist: %s", path1);
+        failure_finish(NULL);
+        return (0);
+    }
+    r = lstat(path2, &st2);
+    if (r != 0) {
+        failure_start(file, line, "File should exist: %s", path2);
+        failure_finish(NULL);
+        return (0);
+    }
+    return (st1.st_ino == st2.st_ino && st1.st_dev == st2.st_dev);
+#endif
+}
+
+int
+assertion_is_hardlink(const char *file, int line,
+    const char *path1, const char *path2)
+{
+    if (is_hardlink(file, line, path1, path2))
+        return (1);
+    failure_start(file, line,
+        "Files %s and %s are not hardlinked", path1, path2);
+    failure_finish(NULL);
+    return (0);
+}
+
+int
+assertion_is_not_hardlink(const char *file, int line,
+    const char *path1, const char *path2)
+{
+    if (!is_hardlink(file, line, path1, path2))
+        return (1);
+    failure_start(file, line,
+        "Files %s and %s should not be hardlinked", path1, path2);
+    failure_finish(NULL);
+    return (0);
+}
+
+/* Verify a/b/mtime of 'pathname'. */
+/* If 'recent', verify that it's within last 10 seconds. */
+static int
+assertion_file_time(const char *file, int line,
+    const char *pathname, long t, long nsec, char type, int recent)
+{
+    long long filet, filet_nsec;
+    int r;
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#define EPOC_TIME   (116444736000000000ULL)
+    FILETIME ftime, fbirthtime, fatime, fmtime;
+    ULARGE_INTEGER wintm;
+    HANDLE h;
+    ftime.dwLowDateTime = 0;
+    ftime.dwHighDateTime = 0;
+
+    assertion_count(file, line);
+    h = CreateFile(pathname, FILE_READ_ATTRIBUTES, 0, NULL,
+        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (h == INVALID_HANDLE_VALUE) {
+        failure_start(file, line, "Can't access %s\n", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    r = GetFileTime(h, &fbirthtime, &fatime, &fmtime);
+    switch (type) {
+    case 'a': ftime = fatime; break;
+    case 'b': ftime = fbirthtime; break;
+    case 'm': ftime = fmtime; break;
+    }
+    CloseHandle(h);
+    if (r == 0) {
+        failure_start(file, line, "Can't GetFileTime %s\n", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    wintm.LowPart = ftime.dwLowDateTime;
+    wintm.HighPart = ftime.dwHighDateTime;
+    filet = (wintm.QuadPart - EPOC_TIME) / 10000000;
+    filet_nsec = ((wintm.QuadPart - EPOC_TIME) % 10000000) * 100;
+    nsec = (nsec / 100) * 100; /* Round the request */
+#else
+    struct stat st;
+
+    assertion_count(file, line);
+    r = lstat(pathname, &st);
+    if (r != 0) {
+        failure_start(file, line, "Can't stat %s\n", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    switch (type) {
+    case 'a': filet = st.st_atime; break;
+    case 'm': filet = st.st_mtime; break;
+    case 'b': filet = 0; break;
+    default: fprintf(stderr, "INTERNAL: Bad type %c for file time", type);
+        exit(1);
+    }
+#if defined(__FreeBSD__)
+    switch (type) {
+    case 'a': filet_nsec = st.st_atimespec.tv_nsec; break;
+    case 'b': filet = st.st_birthtime;
+        filet_nsec = st.st_birthtimespec.tv_nsec; break;
+    case 'm': filet_nsec = st.st_mtimespec.tv_nsec; break;
+    default: fprintf(stderr, "INTERNAL: Bad type %c for file time", type);
+        exit(1);
+    }
+    /* FreeBSD generally only stores to microsecond res, so round. */
+    filet_nsec = (filet_nsec / 1000) * 1000;
+    nsec = (nsec / 1000) * 1000;
+#else
+    filet_nsec = nsec = 0;  /* Generic POSIX only has whole seconds. */
+    if (type == 'b') return (1); /* Generic POSIX doesn't have birthtime */
+#endif
+#endif
+    if (recent) {
+        /* Check that requested time is up-to-date. */
+        time_t now = time(NULL);
+        if (filet < now - 10 || filet > now + 1) {
+            failure_start(file, line,
+                "File %s has %ctime %ld, %ld seconds ago\n",
+                pathname, type, filet, now - filet);
+            failure_finish(NULL);
+            return (0);
+        }
+    } else if (filet != t || filet_nsec != nsec) {
+        failure_start(file, line,
+            "File %s has %ctime %ld.%09ld, expected %ld.%09ld",
+            pathname, type, filet, filet_nsec, t, nsec);
+        failure_finish(NULL);
+        return (0);
+    }
+    return (1);
+}
+
+/* Verify atime of 'pathname'. */
+int
+assertion_file_atime(const char *file, int line,
+    const char *pathname, long t, long nsec)
+{
+    return assertion_file_time(file, line, pathname, t, nsec, 'a', 0);
+}
+
+/* Verify atime of 'pathname' is up-to-date. */
+int
+assertion_file_atime_recent(const char *file, int line, const char *pathname)
+{
+    return assertion_file_time(file, line, pathname, 0, 0, 'a', 1);
+}
+
+/* Verify birthtime of 'pathname'. */
+int
+assertion_file_birthtime(const char *file, int line,
+    const char *pathname, long t, long nsec)
+{
+    return assertion_file_time(file, line, pathname, t, nsec, 'b', 0);
+}
+
+/* Verify birthtime of 'pathname' is up-to-date. */
+int
+assertion_file_birthtime_recent(const char *file, int line,
+    const char *pathname)
+{
+    return assertion_file_time(file, line, pathname, 0, 0, 'b', 1);
+}
+
+/* Verify mtime of 'pathname'. */
+int
+assertion_file_mtime(const char *file, int line,
+    const char *pathname, long t, long nsec)
+{
+    return assertion_file_time(file, line, pathname, t, nsec, 'm', 0);
+}
+
+/* Verify mtime of 'pathname' is up-to-date. */
+int
+assertion_file_mtime_recent(const char *file, int line, const char *pathname)
+{
+    return assertion_file_time(file, line, pathname, 0, 0, 'm', 1);
+}
+
+/* Verify number of links to 'pathname'. */
+int
+assertion_file_nlinks(const char *file, int line,
+    const char *pathname, int nlinks)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    BY_HANDLE_FILE_INFORMATION bhfi;
+    int r;
+
+    assertion_count(file, line);
+    r = my_GetFileInformationByName(pathname, &bhfi);
+    if (r != 0 && bhfi.nNumberOfLinks == nlinks)
+        return (1);
+    failure_start(file, line, "File %s has %d links, expected %d",
+        pathname, bhfi.nNumberOfLinks, nlinks);
+    failure_finish(NULL);
+    return (0);
+#else
+    struct stat st;
+    int r;
+
+    assertion_count(file, line);
+    r = lstat(pathname, &st);
+    if (r == 0 && st.st_nlink == nlinks)
+            return (1);
+    failure_start(file, line, "File %s has %d links, expected %d",
+        pathname, st.st_nlink, nlinks);
+    failure_finish(NULL);
+    return (0);
+#endif
+}
+
+/* Verify size of 'pathname'. */
+int
+assertion_file_size(const char *file, int line, const char *pathname, long size)
+{
+    int64_t filesize;
+    int r;
+
+    assertion_count(file, line);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    {
+        BY_HANDLE_FILE_INFORMATION bhfi;
+        r = !my_GetFileInformationByName(pathname, &bhfi);
+        filesize = ((int64_t)bhfi.nFileSizeHigh << 32) + bhfi.nFileSizeLow;
+    }
+#else
+    {
+        struct stat st;
+        r = lstat(pathname, &st);
+        filesize = st.st_size;
+    }
+#endif
+    if (r == 0 && filesize == size)
+            return (1);
+    failure_start(file, line, "File %s has size %ld, expected %ld",
+        pathname, (long)filesize, (long)size);
+    failure_finish(NULL);
+    return (0);
+}
+
+/* Assert that 'pathname' is a dir.  If mode >= 0, verify that too. */
+int
+assertion_is_dir(const char *file, int line, const char *pathname, int mode)
+{
+    struct stat st;
+    int r;
+
+    assertion_count(file, line);
+    r = lstat(pathname, &st);
+    if (r != 0) {
+        failure_start(file, line, "Dir should exist: %s", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (!S_ISDIR(st.st_mode)) {
+        failure_start(file, line, "%s is not a dir", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+#if !defined(_WIN32) || defined(__CYGWIN__)
+    /* Windows doesn't handle permissions the same way as POSIX,
+     * so just ignore the mode tests. */
+    /* TODO: Can we do better here? */
+    if (mode >= 0 && mode != (st.st_mode & 07777)) {
+        failure_start(file, line, "Dir %s has wrong mode", pathname);
+        logprintf("  Expected: 0%3o\n", mode);
+        logprintf("  Found: 0%3o\n", st.st_mode & 07777);
+        failure_finish(NULL);
+        return (0);
+    }
+#endif
+    return (1);
+}
+
+/* Verify that 'pathname' is a regular file.  If 'mode' is >= 0,
+ * verify that too. */
+int
+assertion_is_reg(const char *file, int line, const char *pathname, int mode)
+{
+    struct stat st;
+    int r;
+
+    assertion_count(file, line);
+    r = lstat(pathname, &st);
+    if (r != 0 || !S_ISREG(st.st_mode)) {
+        failure_start(file, line, "File should exist: %s", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+#if !defined(_WIN32) || defined(__CYGWIN__)
+    /* Windows doesn't handle permissions the same way as POSIX,
+     * so just ignore the mode tests. */
+    /* TODO: Can we do better here? */
+    if (mode >= 0 && mode != (st.st_mode & 07777)) {
+        failure_start(file, line, "File %s has wrong mode", pathname);
+        logprintf("  Expected: 0%3o\n", mode);
+        logprintf("  Found: 0%3o\n", st.st_mode & 07777);
+        failure_finish(NULL);
+        return (0);
+    }
+#endif
+    return (1);
+}
+
+/* Check whether 'pathname' is a symbolic link.  If 'contents' is
+ * non-NULL, verify that the symlink has those contents. */
+static int
+is_symlink(const char *file, int line,
+    const char *pathname, const char *contents)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    assertion_count(file, line);
+    return (0);
+#else
+    char buff[300];
+    struct stat st;
+    ssize_t linklen;
+    int r;
+
+    assertion_count(file, line);
+    r = lstat(pathname, &st);
+    if (r != 0) {
+        failure_start(file, line,
+            "Symlink should exist: %s", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (!S_ISLNK(st.st_mode))
+        return (0);
+    if (contents == NULL)
+        return (1);
+    linklen = readlink(pathname, buff, sizeof(buff));
+    if (linklen < 0) {
+        failure_start(file, line, "Can't read symlink %s", pathname);
+        failure_finish(NULL);
+        return (0);
+    }
+    buff[linklen] = '\0';
+    if (strcmp(buff, contents) != 0)
+        return (0);
+    return (1);
+#endif
+}
+
+/* Assert that path is a symlink that (optionally) contains contents. */
+int
+assertion_is_symlink(const char *file, int line,
+    const char *path, const char *contents)
+{
+    if (is_symlink(file, line, path, contents))
+        return (1);
+    if (contents)
+        failure_start(file, line, "File %s is not a symlink to %s",
+            path, contents);
+    else
+        failure_start(file, line, "File %s is not a symlink", path);
+    failure_finish(NULL);
+    return (0);
+}
+
+
+/* Create a directory and report any errors. */
+int
+assertion_make_dir(const char *file, int line, const char *dirname, int mode)
+{
+    assertion_count(file, line);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    if (0 == _mkdir(dirname))
+        return (1);
+#else
+    if (0 == mkdir(dirname, mode))
+        return (1);
+#endif
+    failure_start(file, line, "Could not create directory %s", dirname);
+    failure_finish(NULL);
+    return(0);
+}
+
+/* Create a file with the specified contents and report any failures. */
+int
+assertion_make_file(const char *file, int line,
+    const char *path, int mode, const char *contents)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* TODO: Rework this to set file mode as well. */
+    FILE *f;
+    assertion_count(file, line);
+    f = fopen(path, "wb");
+    if (f == NULL) {
+        failure_start(file, line, "Could not create file %s", path);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (contents != NULL) {
+        if (strlen(contents)
+            != fwrite(contents, 1, strlen(contents), f)) {
+            fclose(f);
+            failure_start(file, line,
+                "Could not write file %s", path);
+            failure_finish(NULL);
+            return (0);
+        }
+    }
+    fclose(f);
+    return (1);
+#else
+    int fd;
+    assertion_count(file, line);
+    fd = open(path, O_CREAT | O_WRONLY, mode >= 0 ? mode : 0644);
+    if (fd < 0) {
+        failure_start(file, line, "Could not create %s", path);
+        failure_finish(NULL);
+        return (0);
+    }
+    if (contents != NULL) {
+        if ((ssize_t)strlen(contents)
+            != write(fd, contents, strlen(contents))) {
+            close(fd);
+            failure_start(file, line, "Could not write to %s", path);
+            failure_finish(NULL);
+            return (0);
+        }
+    }
+    close(fd);
+    return (1);
+#endif
+}
+
+/* Create a hardlink and report any failures. */
+int
+assertion_make_hardlink(const char *file, int line,
+    const char *newpath, const char *linkto)
+{
+    int succeeded;
+
+    assertion_count(file, line);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    succeeded = my_CreateHardLinkA(newpath, linkto);
+#elif HAVE_LINK
+    succeeded = !link(linkto, newpath);
+#else
+    succeeded = 0;
+#endif
+    if (succeeded)
+        return (1);
+    failure_start(file, line, "Could not create hardlink");
+    logprintf("   New link: %s\n", newpath);
+    logprintf("   Old name: %s\n", linkto);
+    failure_finish(NULL);
+    return(0);
+}
+
+/* Create a symlink and report any failures. */
+int
+assertion_make_symlink(const char *file, int line,
+    const char *newpath, const char *linkto)
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    int targetIsDir = 0;  /* TODO: Fix this */
+    assertion_count(file, line);
+    if (my_CreateSymbolicLinkA(newpath, linkto, targetIsDir))
+        return (1);
+#elif HAVE_SYMLINK
+    assertion_count(file, line);
+    if (0 == symlink(linkto, newpath))
+        return (1);
+#endif
+    failure_start(file, line, "Could not create symlink");
+    logprintf("   New link: %s\n", newpath);
+    logprintf("   Old name: %s\n", linkto);
+    failure_finish(NULL);
+    return(0);
+}
+
+/* Set umask, report failures. */
+int
+assertion_umask(const char *file, int line, int mask)
+{
+    assertion_count(file, line);
+    (void)file; /* UNUSED */
+    (void)line; /* UNUSED */
+    umask(mask);
+    return (1);
+}
+
+/*
+ *
+ *  UTILITIES for use by tests.
+ *
+ */
+
+/*
+ * Check whether platform supports symlinks.  This is intended
+ * for tests to use in deciding whether to bother testing symlink
+ * support; if the platform doesn't support symlinks, there's no point
+ * in checking whether the program being tested can create them.
+ */
+int
+canSymlink(void)
+{
+    /* Remember the test result */
+    static int value = 0, tested = 0;
+    if (tested)
+        return (value);
+
+    ++tested;
+    assertion_make_file(__FILE__, __LINE__, "canSymlink.0", 0644, "a");
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    value = my_CreateSymbolicLinkA("canSymlink.1", "canSymlink.0", 0)
+        && is_symlink(__FILE__, __LINE__, "canSymlink.1", "canSymlink.0");
+#elif HAVE_SYMLINK
+    value = (0 == symlink("canSymlink.0", "canSymlink.1"))
+        && is_symlink(__FILE__, __LINE__, "canSymlink.1","canSymlink.0");
+#endif
+    return (value);
+}
+
+/*
+ * Can this platform run the gzip program?
+ */
+/* Platform-dependent options for hiding the output of a subcommand. */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+static const char *redirectArgs = ">NUL 2>NUL"; /* Win32 cmd.exe */
+#else
+static const char *redirectArgs = ">/dev/null 2>/dev/null"; /* POSIX 'sh' */
+#endif
+int
+canGzip(void)
+{
+    static int tested = 0, value = 0;
+    if (!tested) {
+        tested = 1;
+        if (systemf("gzip -V %s", redirectArgs) == 0)
+            value = 1;
+    }
+    return (value);
+}
+
+/*
+ * Can this platform run the gunzip program?
+ */
+int
+canGunzip(void)
+{
+    static int tested = 0, value = 0;
+    if (!tested) {
+        tested = 1;
+        if (systemf("gunzip -V %s", redirectArgs) == 0)
+            value = 1;
+    }
+    return (value);
+}
+
+/*
+ * Sleep as needed; useful for verifying disk timestamp changes by
+ * ensuring that the wall-clock time has actually changed before we
+ * go back to re-read something from disk.
+ */
+void
+sleepUntilAfter(time_t t)
+{
+    while (t >= time(NULL))
+#if defined(_WIN32) && !defined(__CYGWIN__)
+        Sleep(500);
+#else
+        sleep(1);
+#endif
+}
+
+/*
+ * Call standard system() call, but build up the command line using
+ * sprintf() conventions.
+ */
+int
+systemf(const char *fmt, ...)
+{
+    char buff[8192];
+    va_list ap;
+    int r;
+
+    va_start(ap, fmt);
+    vsprintf(buff, fmt, ap);
+    if (verbosity > VERBOSITY_FULL)
+        logprintf("Cmd: %s\n", buff);
+    r = system(buff);
+    va_end(ap);
+    return (r);
+}
+
+/*
+ * Slurp a file into memory for ease of comparison and testing.
+ * Returns size of file in 'sizep' if non-NULL, null-terminates
+ * data in memory for ease of use.
+ */
+char *
+slurpfile(size_t * sizep, const char *fmt, ...)
+{
+    char filename[8192];
+    struct stat st;
+    va_list ap;
+    char *p;
+    ssize_t bytes_read;
+    FILE *f;
+    int r;
+
+    va_start(ap, fmt);
+    vsprintf(filename, fmt, ap);
+    va_end(ap);
+
+    f = fopen(filename, "rb");
+    if (f == NULL) {
+        /* Note: No error; non-existent file is okay here. */
+        return (NULL);
+    }
+    r = fstat(fileno(f), &st);
+    if (r != 0) {
+        logprintf("Can't stat file %s\n", filename);
+        fclose(f);
+        return (NULL);
+    }
+    p = malloc((size_t)st.st_size + 1);
+    if (p == NULL) {
+        logprintf("Can't allocate %ld bytes of memory to read file %s\n",
+            (long int)st.st_size, filename);
+        fclose(f);
+        return (NULL);
+    }
+    bytes_read = fread(p, 1, (size_t)st.st_size, f);
+    if (bytes_read < st.st_size) {
+        logprintf("Can't read file %s\n", filename);
+        fclose(f);
+        free(p);
+        return (NULL);
+    }
+    p[st.st_size] = '\0';
+    if (sizep != NULL)
+        *sizep = (size_t)st.st_size;
+    fclose(f);
+    return (p);
+}
+
+/* Read a uuencoded file from the reference directory, decode, and
+ * write the result into the current directory. */
+#define UUDECODE(c) (((c) - 0x20) & 0x3f)
+void
+extract_reference_file(const char *name)
+{
+    char buff[1024];
+    FILE *in, *out;
+
+    sprintf(buff, "%s/%s.uu", refdir, name);
+    in = fopen(buff, "r");
+    failure("Couldn't open reference file %s", buff);
+    assert(in != NULL);
+    if (in == NULL)
+        return;
+    /* Read up to and including the 'begin' line. */
+    for (;;) {
+        if (fgets(buff, sizeof(buff), in) == NULL) {
+            /* TODO: This is a failure. */
+            return;
+        }
+        if (memcmp(buff, "begin ", 6) == 0)
+            break;
+    }
+    /* Now, decode the rest and write it. */
+    /* Not a lot of error checking here; the input better be right. */
+    out = fopen(name, "wb");
+    while (fgets(buff, sizeof(buff), in) != NULL) {
+        char *p = buff;
+        int bytes;
+
+        if (memcmp(buff, "end", 3) == 0)
+            break;
+
+        bytes = UUDECODE(*p++);
+        while (bytes > 0) {
+            int n = 0;
+            /* Write out 1-3 bytes from that. */
+            if (bytes > 0) {
+                n = UUDECODE(*p++) << 18;
+                n |= UUDECODE(*p++) << 12;
+                fputc(n >> 16, out);
+                --bytes;
+            }
+            if (bytes > 0) {
+                n |= UUDECODE(*p++) << 6;
+                fputc((n >> 8) & 0xFF, out);
+                --bytes;
+            }
+            if (bytes > 0) {
+                n |= UUDECODE(*p++);
+                fputc(n & 0xFF, out);
+                --bytes;
+            }
+        }
+    }
+    fclose(out);
+    fclose(in);
+}
+
+/*
+ *
+ * TEST management
+ *
+ */
+
+/*
+ * "list.h" is simply created by "grep DEFINE_TEST test_*.c"; it has
+ * a line like
+ *      DEFINE_TEST(test_function)
+ * for each test.
+ */
+
+/* Use "list.h" to declare all of the test functions. */
+#undef DEFINE_TEST
+#define DEFINE_TEST(name) void name(void);
+#include "list.h"
+
+/* Use "list.h" to create a list of all tests (functions and names). */
+#undef DEFINE_TEST
+#define DEFINE_TEST(n) { n, #n, 0 },
+struct { void (*func)(void); const char *name; int failures; } tests[] = {
+    #include "list.h"
+};
+
+/*
+ * Summarize repeated failures in the just-completed test.
+ */
+static void
+test_summarize(const char *filename, int failed)
+{
+    unsigned int i;
+
+    switch (verbosity) {
+    case VERBOSITY_SUMMARY_ONLY:
+        printf(failed ? "E" : ".");
+        fflush(stdout);
+        break;
+    case VERBOSITY_PASSFAIL:
+        printf(failed ? "FAIL\n" : "ok\n");
+        break;
+    }
+
+    log_console = (verbosity == VERBOSITY_LIGHT_REPORT);
+
+    for (i = 0; i < sizeof(failed_lines)/sizeof(failed_lines[0]); i++) {
+        if (failed_lines[i].count > 1 && !failed_lines[i].skip)
+            logprintf("%s:%d: Summary: Failed %d times\n",
+                filename, i, failed_lines[i].count);
+    }
+    /* Clear the failure history for the next file. */
+    memset(failed_lines, 0, sizeof(failed_lines));
+}
+
+/*
+ * Actually run a single test, with appropriate setup and cleanup.
+ */
+static int
+test_run(int i, const char *tmpdir)
+{
+    char logfilename[64];
+    int failures_before = failures;
+    int oldumask;
+
+    switch (verbosity) {
+    case VERBOSITY_SUMMARY_ONLY: /* No per-test reports at all */
+        break;
+    case VERBOSITY_PASSFAIL: /* rest of line will include ok/FAIL marker */
+        printf("%3d: %-50s", i, tests[i].name);
+        fflush(stdout);
+        break;
+    default: /* Title of test, details will follow */
+        printf("%3d: %s\n", i, tests[i].name);
+    }
+
+    /* Chdir to the top-level work directory. */
+    if (!assertChdir(tmpdir)) {
+        fprintf(stderr,
+            "ERROR: Can't chdir to top work dir %s\n", tmpdir);
+        exit(1);
+    }
+    /* Create a log file for this test. */
+    sprintf(logfilename, "%s.log", tests[i].name);
+    logfile = fopen(logfilename, "w");
+    fprintf(logfile, "%s\n\n", tests[i].name);
+    /* Chdir() to a work dir for this specific test. */
+    if (!assertMakeDir(tests[i].name, 0755)
+        || !assertChdir(tests[i].name)) {
+        fprintf(stderr,
+            "ERROR: Can't chdir to work dir %s/%s\n",
+            tmpdir, tests[i].name);
+        exit(1);
+    }
+    /* Explicitly reset the locale before each test. */
+    setlocale(LC_ALL, "C");
+    /* Record the umask before we run the test. */
+    umask(oldumask = umask(0));
+    /*
+     * Run the actual test.
+     */
+    (*tests[i].func)();
+    /*
+     * Clean up and report afterwards.
+     */
+    /* Restore umask */
+    umask(oldumask);
+    /* Reset locale. */
+    setlocale(LC_ALL, "C");
+    /* Reset directory. */
+    if (!assertChdir(tmpdir)) {
+        fprintf(stderr, "ERROR: Couldn't chdir to temp dir %s\n",
+            tmpdir);
+        exit(1);
+    }
+    /* Report per-test summaries. */
+    tests[i].failures = failures - failures_before;
+    test_summarize(test_filename, tests[i].failures);
+    /* Close the per-test log file. */
+    fclose(logfile);
+    logfile = NULL;
+    /* If there were no failures, we can remove the work dir and logfile. */
+    if (tests[i].failures == 0) {
+        if (!keep_temp_files && assertChdir(tmpdir)) {
+#if defined(_WIN32) && !defined(__CYGWIN__)
+            systemf("rmdir /S /Q %s", tests[i].name);
+            systemf("del %s", logfilename);
+#else
+            systemf("rm -rf %s", tests[i].name);
+            systemf("rm %s", logfilename);
+#endif
+        }
+    }
+    /* Return appropriate status. */
+    return (tests[i].failures);
+}
+
+/*
+ *
+ *
+ * MAIN and support routines.
+ *
+ *
+ */
+
+static void
+usage(const char *program)
+{
+    static const int limit = sizeof(tests) / sizeof(tests[0]);
+    int i;
+
+    printf("Usage: %s [options] <test> <test> ...\n", program);
+    printf("Default is to run all tests.\n");
+    printf("Otherwise, specify the numbers of the tests you wish to run.\n");
+    printf("Options:\n");
+    printf("  -d  Dump core after any failure, for debugging.\n");
+    printf("  -k  Keep all temp files.\n");
+    printf("      Default: temp files for successful tests deleted.\n");
+#ifdef PROGRAM
+    printf("  -p <path>  Path to executable to be tested.\n");
+    printf("      Default: path taken from " ENVBASE " environment variable.\n");
+#endif
+    printf("  -q  Quiet.\n");
+    printf("  -r <dir>   Path to dir containing reference files.\n");
+    printf("      Default: Current directory.\n");
+    printf("  -v  Verbose.\n");
+    printf("Available tests:\n");
+    for (i = 0; i < limit; i++)
+        printf("  %d: %s\n", i, tests[i].name);
+    exit(1);
+}
+
+static char *
+get_refdir(const char *d)
+{
+    char tried[512] = { '\0' };
+    char buff[128];
+    char *pwd, *p;
+
+    /* If a dir was specified, try that */
+    if (d != NULL) {
+        pwd = NULL;
+        snprintf(buff, sizeof(buff), "%s", d);
+        p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+        if (p != NULL) goto success;
+        strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+        strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+        goto failure;
+    }
+
+    /* Get the current dir. */
+    pwd = getcwd(NULL, 0);
+    while (pwd[strlen(pwd) - 1] == '\n')
+        pwd[strlen(pwd) - 1] = '\0';
+
+    /* Look for a known file. */
+    snprintf(buff, sizeof(buff), "%s", pwd);
+    p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+    if (p != NULL) goto success;
+    strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+    strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+
+    snprintf(buff, sizeof(buff), "%s/test", pwd);
+    p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+    if (p != NULL) goto success;
+    strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+    strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+
+#if defined(LIBRARY)
+    snprintf(buff, sizeof(buff), "%s/%s/test", pwd, LIBRARY);
+#else
+    snprintf(buff, sizeof(buff), "%s/%s/test", pwd, PROGRAM);
+#endif
+    p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+    if (p != NULL) goto success;
+    strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+    strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+
+    if (memcmp(pwd, "/usr/obj", 8) == 0) {
+        snprintf(buff, sizeof(buff), "%s", pwd + 8);
+        p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+        if (p != NULL) goto success;
+        strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+        strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+
+        snprintf(buff, sizeof(buff), "%s/test", pwd + 8);
+        p = slurpfile(NULL, "%s/%s", buff, KNOWNREF);
+        if (p != NULL) goto success;
+        strncat(tried, buff, sizeof(tried) - strlen(tried) - 1);
+        strncat(tried, "\n", sizeof(tried) - strlen(tried) - 1);
+    }
+
+failure:
+    printf("Unable to locate known reference file %s\n", KNOWNREF);
+    printf("  Checked following directories:\n%s\n", tried);
+#if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
+    DebugBreak();
+#endif
+    exit(1);
+
+success:
+    free(p);
+    free(pwd);
+    return strdup(buff);
+}
+
+int
+main(int argc, char **argv)
+{
+    static const int limit = sizeof(tests) / sizeof(tests[0]);
+    int i, tests_run = 0, tests_failed = 0, option;
+    time_t now;
+    char *refdir_alloc = NULL;
+    const char *progname;
+    const char *tmp, *option_arg, *p;
+    char tmpdir[256];
+    char tmpdir_timestamp[256];
+
+    (void)argc; /* UNUSED */
+
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__GNUC__)
+    /* To stop to run the default invalid parameter handler. */
+    _set_invalid_parameter_handler(invalid_parameter_handler);
+    /* Disable annoying assertion message box. */
+    _CrtSetReportMode(_CRT_ASSERT, 0);
+#endif
+
+    /*
+     * Name of this program, used to build root of our temp directory
+     * tree.
+     */
+    progname = p = argv[0];
+    while (*p != '\0') {
+        /* Support \ or / dir separators for Windows compat. */
+        if (*p == '/' || *p == '\\')
+            progname = p + 1;
+        ++p;
+    }
+
+#ifdef PROGRAM
+    /* Get the target program from environment, if available. */
+    testprogfile = getenv(ENVBASE);
+#endif
+
+    if (getenv("TMPDIR") != NULL)
+        tmp = getenv("TMPDIR");
+    else if (getenv("TMP") != NULL)
+        tmp = getenv("TMP");
+    else if (getenv("TEMP") != NULL)
+        tmp = getenv("TEMP");
+    else if (getenv("TEMPDIR") != NULL)
+        tmp = getenv("TEMPDIR");
+    else
+        tmp = "/tmp";
+
+    /* Allow -d to be controlled through the environment. */
+    if (getenv(ENVBASE "_DEBUG") != NULL)
+        dump_on_failure = 1;
+
+    /* Get the directory holding test files from environment. */
+    refdir = getenv(ENVBASE "_TEST_FILES");
+
+    /*
+     * Parse options, without using getopt(), which isn't available
+     * on all platforms.
+     */
+    ++argv; /* Skip program name */
+    while (*argv != NULL) {
+        if (**argv != '-')
+            break;
+        p = *argv++;
+        ++p; /* Skip '-' */
+        while (*p != '\0') {
+            option = *p++;
+            option_arg = NULL;
+            /* If 'opt' takes an argument, parse that. */
+            if (option == 'p' || option == 'r') {
+                if (*p != '\0')
+                    option_arg = p;
+                else if (*argv == NULL) {
+                    fprintf(stderr,
+                        "Option -%c requires argument.\n",
+                        option);
+                    usage(progname);
+                } else
+                    option_arg = *argv++;
+                p = ""; /* End of this option word. */
+            }
+
+            /* Now, handle the option. */
+            switch (option) {
+            case 'd':
+                dump_on_failure = 1;
+                break;
+            case 'k':
+                keep_temp_files = 1;
+                break;
+            case 'p':
+#ifdef PROGRAM
+                testprogfile = option_arg;
+#else
+                usage(progname);
+#endif
+                break;
+            case 'q':
+                verbosity--;
+                break;
+            case 'r':
+                refdir = option_arg;
+                break;
+            case 'v':
+                verbosity++;
+                break;
+            default:
+                usage(progname);
+            }
+        }
+    }
+
+    /*
+     * Sanity-check that our options make sense.
+     */
+#ifdef PROGRAM
+    if (testprogfile == NULL)
+        usage(progname);
+    {
+        char *testprg;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+        /* Command.com sometimes rejects '/' separators. */
+        testprg = strdup(testprogfile);
+        for (i = 0; testprg[i] != '\0'; i++) {
+            if (testprg[i] == '/')
+                testprg[i] = '\\';
+        }
+        testprogfile = testprg;
+#endif
+        /* Quote the name that gets put into shell command lines. */
+        testprg = malloc(strlen(testprogfile) + 3);
+        strcpy(testprg, "\"");
+        strcat(testprg, testprogfile);
+        strcat(testprg, "\"");
+        testprog = testprg;
+    }
+#endif
+
+    /*
+     * Create a temp directory for the following tests.
+     * Include the time the tests started as part of the name,
+     * to make it easier to track the results of multiple tests.
+     */
+    now = time(NULL);
+    for (i = 0; ; i++) {
+        strftime(tmpdir_timestamp, sizeof(tmpdir_timestamp),
+            "%Y-%m-%dT%H.%M.%S",
+            localtime(&now));
+        sprintf(tmpdir, "%s/%s.%s-%03d", tmp, progname,
+            tmpdir_timestamp, i);
+        if (assertMakeDir(tmpdir,0755))
+            break;
+        if (i >= 999) {
+            fprintf(stderr,
+                "ERROR: Unable to create temp directory %s\n",
+                tmpdir);
+            exit(1);
+        }
+    }
+
+    /*
+     * If the user didn't specify a directory for locating
+     * reference files, try to find the reference files in
+     * the "usual places."
+     */
+    refdir = refdir_alloc = get_refdir(refdir);
+
+    /*
+     * Banner with basic information.
+     */
+    printf("\n");
+    printf("If tests fail or crash, details will be in:\n");
+    printf("   %s\n", tmpdir);
+    printf("\n");
+    if (verbosity > VERBOSITY_SUMMARY_ONLY) {
+        printf("Reference files will be read from: %s\n", refdir);
+#ifdef PROGRAM
+        printf("Running tests on: %s\n", testprog);
+#endif
+        printf("Exercising: ");
+        fflush(stdout);
+        printf("%s\n", EXTRA_VERSION);
+    } else {
+        printf("Running ");
+        fflush(stdout);
+    }
+
+    /*
+     * Run some or all of the individual tests.
+     */
+    if (*argv == NULL) {
+        /* Default: Run all tests. */
+        for (i = 0; i < limit; i++) {
+            if (test_run(i, tmpdir))
+                tests_failed++;
+            tests_run++;
+        }
+    } else {
+        while (*(argv) != NULL) {
+            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 {
+                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++;
+        }
+    }
+
+    /*
+     * Report summary statistics.
+     */
+    if (verbosity > VERBOSITY_SUMMARY_ONLY) {
+        printf("\n");
+        printf("Totals:\n");
+        printf("  Tests run:         %8d\n", tests_run);
+        printf("  Tests failed:      %8d\n", tests_failed);
+        printf("  Assertions checked:%8d\n", assertions);
+        printf("  Assertions failed: %8d\n", failures);
+        printf("  Skips reported:    %8d\n", skips);
+    }
+    if (failures) {
+        printf("\n");
+        printf("Failing tests:\n");
+        for (i = 0; i < limit; ++i) {
+            if (tests[i].failures)
+                printf("  %d: %s (%d failures)\n", i,
+                    tests[i].name, tests[i].failures);
+        }
+        printf("\n");
+        printf("Details for failing tests: %s\n", tmpdir);
+        printf("\n");
+    } else {
+        if (verbosity == VERBOSITY_SUMMARY_ONLY)
+            printf("\n");
+        printf("%d tests passed, no failures\n", tests_run);
+    }
+
+    free(refdir_alloc);
+
+    /* If the final tmpdir is empty, we can remove it. */
+    /* This should be the usual case when all tests succeed. */
+    assertChdir("..");
+    rmdir(tmpdir);
+
+    return (tests_failed ? 1 : 0);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test.h b/Utilities/cmlibarchive/cpio/test/test.h
new file mode 100644
index 0000000..99010c8
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test.h
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2003-2006 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.
+ *
+ * $FreeBSD: src/usr.bin/cpio/test/test.h,v 1.2 2008/06/21 02:17:18 kientzle Exp $
+ */
+
+/* Every test program should #include "test.h" as the first thing. */
+
+/*
+ * The goal of this file (and the matching test.c) is to
+ * simplify the very repetitive test-*.c test programs.
+ */
+#if defined(HAVE_CONFIG_H)
+/* Most POSIX platforms use the 'configure' script to build config.h */
+#include "config.h"
+#elif defined(__FreeBSD__)
+/* Building as part of FreeBSD system requires a pre-built config.h. */
+#include "config_freebsd.h"
+#elif defined(_WIN32) && !defined(__CYGWIN__)
+/* Win32 can't run the 'configure' script. */
+#include "config_windows.h"
+#else
+/* Warn if the library hasn't been (automatically or manually) configured. */
+#error Oops: No config.h and no pre-built configuration in test.h.
+#endif
+
+#include <sys/types.h>  /* Windows requires this before sys/stat.h */
+#include <sys/stat.h>
+
+#ifdef USE_DMALLOC
+#include <dmalloc.h>
+#endif
+#if HAVE_DIRENT_H
+#include <dirent.h>
+#else
+#include <direct.h>
+#define dirent direct
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <wchar.h>
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+/*
+ * System-specific tweaks.  We really want to minimize these
+ * as much as possible, since they make it harder to understand
+ * the mainline code.
+ */
+
+/* Windows (including Visual Studio and MinGW but not Cygwin) */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include "../cpio_windows.h"
+#define strdup _strdup
+#define LOCALE_DE   "deu"
+#else
+#define LOCALE_DE   "de_DE.UTF-8"
+#endif
+
+/* Visual Studio */
+#ifdef _MSC_VER
+#define snprintf    sprintf_s
+#endif
+
+/* Cygwin */
+#if defined(__CYGWIN__)
+/* Cygwin-1.7.x is lazy about populating nlinks, so don't
+ * expect it to be accurate. */
+# define NLINKS_INACCURATE_FOR_DIRS
+#endif
+
+/* FreeBSD */
+#ifdef __FreeBSD__
+#include <sys/cdefs.h>  /* For __FBSDID */
+#else
+/* Surprisingly, some non-FreeBSD platforms define __FBSDID. */
+#ifndef __FBSDID
+#define __FBSDID(a)     struct _undefined_hack
+#endif
+#endif
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+/*
+ * Redefine DEFINE_TEST for use in defining the test functions.
+ */
+#undef DEFINE_TEST
+#define DEFINE_TEST(name) void name(void); void name(void)
+
+/* An implementation of the standard assert() macro */
+#define assert(e)   assertion_assert(__FILE__, __LINE__, (e), #e, NULL)
+/* chdir() and error if it fails */
+#define assertChdir(path)  \
+  assertion_chdir(__FILE__, __LINE__, path)
+/* Assert two integers are the same.  Reports value of each one if not. */
+#define assertEqualInt(v1,v2) \
+  assertion_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
+/* Assert two strings are the same.  Reports value of each one if not. */
+#define assertEqualString(v1,v2)   \
+  assertion_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
+/* As above, but v1 and v2 are wchar_t * */
+#define assertEqualWString(v1,v2)   \
+  assertion_equal_wstring(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
+/* As above, but raw blocks of bytes. */
+#define assertEqualMem(v1, v2, l)   \
+  assertion_equal_mem(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (l), #l, NULL)
+/* Assert two files are the same; allow printf-style expansion of second name.
+ * See below for comments about variable arguments here...
+ */
+#define assertEqualFile     \
+  assertion_setup(__FILE__, __LINE__);assertion_equal_file
+/* Assert that a file is empty; supports printf-style arguments. */
+#define assertEmptyFile     \
+  assertion_setup(__FILE__, __LINE__);assertion_empty_file
+/* Assert that a file is not empty; supports printf-style arguments. */
+#define assertNonEmptyFile      \
+  assertion_setup(__FILE__, __LINE__);assertion_non_empty_file
+#define assertFileAtime(pathname, sec, nsec)    \
+  assertion_file_atime(__FILE__, __LINE__, pathname, sec, nsec)
+#define assertFileAtimeRecent(pathname) \
+  assertion_file_atime_recent(__FILE__, __LINE__, pathname)
+#define assertFileBirthtime(pathname, sec, nsec)    \
+  assertion_file_birthtime(__FILE__, __LINE__, pathname, sec, nsec)
+#define assertFileBirthtimeRecent(pathname) \
+  assertion_file_birthtime_recent(__FILE__, __LINE__, pathname)
+/* Assert that a file exists; supports printf-style arguments. */
+#define assertFileExists        \
+  assertion_setup(__FILE__, __LINE__);assertion_file_exists
+/* Assert that a file exists; supports printf-style arguments. */
+#define assertFileNotExists     \
+  assertion_setup(__FILE__, __LINE__);assertion_file_not_exists
+/* Assert that file contents match a string; supports printf-style arguments. */
+#define assertFileContents             \
+  assertion_setup(__FILE__, __LINE__);assertion_file_contents
+#define assertFileMtime(pathname, sec, nsec)    \
+  assertion_file_mtime(__FILE__, __LINE__, pathname, sec, nsec)
+#define assertFileMtimeRecent(pathname) \
+  assertion_file_mtime_recent(__FILE__, __LINE__, pathname)
+#define assertFileNLinks(pathname, nlinks)  \
+  assertion_file_nlinks(__FILE__, __LINE__, pathname, nlinks)
+#define assertFileSize(pathname, size)  \
+  assertion_file_size(__FILE__, __LINE__, pathname, size)
+#define assertTextFileContents         \
+  assertion_setup(__FILE__, __LINE__);assertion_text_file_contents
+#define assertIsDir(pathname, mode)     \
+  assertion_is_dir(__FILE__, __LINE__, pathname, mode)
+#define assertIsHardlink(path1, path2)  \
+  assertion_is_hardlink(__FILE__, __LINE__, path1, path2)
+#define assertIsNotHardlink(path1, path2)   \
+  assertion_is_not_hardlink(__FILE__, __LINE__, path1, path2)
+#define assertIsReg(pathname, mode)     \
+  assertion_is_reg(__FILE__, __LINE__, pathname, mode)
+#define assertIsSymlink(pathname, contents) \
+  assertion_is_symlink(__FILE__, __LINE__, pathname, contents)
+/* Create a directory, report error if it fails. */
+#define assertMakeDir(dirname, mode)    \
+  assertion_make_dir(__FILE__, __LINE__, dirname, mode)
+#define assertMakeFile(path, mode, contents) \
+  assertion_make_file(__FILE__, __LINE__, path, mode, contents)
+#define assertMakeHardlink(newfile, oldfile)    \
+  assertion_make_hardlink(__FILE__, __LINE__, newfile, oldfile)
+#define assertMakeSymlink(newfile, linkto)  \
+  assertion_make_symlink(__FILE__, __LINE__, newfile, linkto)
+#define assertUmask(mask)   \
+  assertion_umask(__FILE__, __LINE__, mask)
+
+/*
+ * This would be simple with C99 variadic macros, but I don't want to
+ * require that.  Instead, I insert a function call before each
+ * skipping() call to pass the file and line information down.  Crude,
+ * but effective.
+ */
+#define skipping    \
+  assertion_setup(__FILE__, __LINE__);test_skipping
+
+/* Function declarations.  These are defined in test_utility.c. */
+void failure(const char *fmt, ...);
+int assertion_assert(const char *, int, int, const char *, void *);
+int assertion_chdir(const char *, int, const char *);
+int assertion_empty_file(const char *, ...);
+int assertion_equal_file(const char *, const char *, ...);
+int assertion_equal_int(const char *, int, long long, const char *, long long, const char *, void *);
+int assertion_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
+int assertion_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
+int assertion_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
+int assertion_file_atime(const char *, int, const char *, long, long);
+int assertion_file_atime_recent(const char *, int, const char *);
+int assertion_file_birthtime(const char *, int, const char *, long, long);
+int assertion_file_birthtime_recent(const char *, int, const char *);
+int assertion_file_contents(const void *, int, const char *, ...);
+int assertion_file_exists(const char *, ...);
+int assertion_file_mtime(const char *, int, const char *, long, long);
+int assertion_file_mtime_recent(const char *, int, const char *);
+int assertion_file_nlinks(const char *, int, const char *, int);
+int assertion_file_not_exists(const char *, ...);
+int assertion_file_size(const char *, int, const char *, long);
+int assertion_is_dir(const char *, int, const char *, int);
+int assertion_is_hardlink(const char *, int, const char *, const char *);
+int assertion_is_not_hardlink(const char *, int, const char *, const char *);
+int assertion_is_reg(const char *, int, const char *, int);
+int assertion_is_symlink(const char *, int, const char *, const char *);
+int assertion_make_dir(const char *, int, const char *, int);
+int assertion_make_file(const char *, int, const char *, int, const char *);
+int assertion_make_hardlink(const char *, int, const char *newpath, const char *);
+int assertion_make_symlink(const char *, int, const char *newpath, const char *);
+int assertion_non_empty_file(const char *, ...);
+int assertion_text_file_contents(const char *buff, const char *f);
+int assertion_umask(const char *, int, int);
+void assertion_setup(const char *, int);
+
+void test_skipping(const char *fmt, ...);
+
+/* Like sprintf, then system() */
+int systemf(const char * fmt, ...);
+
+/* Delay until time() returns a value after this. */
+void sleepUntilAfter(time_t);
+
+/* Return true if this platform can create symlinks. */
+int canSymlink(void);
+
+/* Return true if this platform can run the "gzip" program. */
+int canGzip(void);
+
+/* Return true if this platform can run the "gunzip" program. */
+int canGunzip(void);
+
+/* Suck file into string allocated via malloc(). Call free() when done. */
+/* Supports printf-style args: slurpfile(NULL, "%s/myfile", refdir); */
+char *slurpfile(size_t *, const char *fmt, ...);
+
+/* Extracts named reference file to the current directory. */
+void extract_reference_file(const char *);
+
+/*
+ * Special interfaces for program test harness.
+ */
+
+/* Pathname of exe to be tested. */
+const char *testprogfile;
+/* Name of exe to use in printf-formatted command strings. */
+/* On Windows, this includes leading/trailing quotes. */
+const char *testprog;
diff --git a/Utilities/cmlibarchive/cpio/test/test_0.c b/Utilities/cmlibarchive/cpio/test/test_0.c
new file mode 100644
index 0000000..e5d3bd2
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_0.c
@@ -0,0 +1,67 @@
+/*-
+ * 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$");
+
+/*
+ * This first test does basic sanity checks on the environment.  For
+ * most of these, we just exit on failure.
+ */
+#if !defined(_WIN32) || defined(__CYGWIN__)
+#define DEV_NULL "/dev/null"
+#else
+#define DEV_NULL "NUL"
+#endif
+
+DEFINE_TEST(test_0)
+{
+    struct stat st;
+
+    failure("File %s does not exist?!", testprogfile);
+    if (!assertEqualInt(0, stat(testprogfile, &st)))
+        exit(1);
+
+    failure("%s is not executable?!", testprogfile);
+    if (!assert((st.st_mode & 0111) != 0))
+        exit(1);
+
+    /*
+     * Try to succesfully run the program; this requires that
+     * we know some option that will succeed.
+     */
+    if (0 == systemf("%s --version >" DEV_NULL, testprog)) {
+        /* This worked. */
+    } else if (0 == systemf("%s -W version >" DEV_NULL, testprog)) {
+        /* This worked. */
+    } else {
+        failure("Unable to successfully run any of the following:\n"
+            "  * %s --version\n"
+            "  * %s -W version\n",
+            testprog, testprog);
+        assert(0);
+    }
+
+    /* TODO: Ensure that our reference files are available. */
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_basic.c b/Utilities/cmlibarchive/cpio/test/test_basic.c
new file mode 100644
index 0000000..a2c0b70
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_basic.c
@@ -0,0 +1,173 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_basic.c,v 1.4 2008/08/25 06:39:29 kientzle Exp $");
+
+static void
+verify_files(const char *msg)
+{
+    /*
+     * Verify unpacked files.
+     */
+
+    /* Regular file with 2 links. */
+    assertIsReg("file", 0644);
+    failure(msg);
+    assertFileSize("file", 10);
+    assertFileNLinks("file", 2);
+
+    /* Another name for the same file. */
+    assertIsHardlink("linkfile", "file");
+
+    /* Symlink */
+    if (canSymlink())
+        assertIsSymlink("symlink", "file");
+
+    /* Another file with 1 link and different permissions. */
+    assertIsReg("file2", 0777);
+    assertFileSize("file2", 10);
+    assertFileNLinks("file2", 1);
+
+    /* dir */
+    assertIsDir("dir", 0775);
+}
+
+static void
+basic_cpio(const char *target,
+    const char *pack_options,
+    const char *unpack_options,
+    const char *se)
+{
+    int r;
+
+    if (!assertMakeDir(target, 0775))
+        return;
+
+    /* Use the cpio program to create an archive. */
+    r = systemf("%s -o %s < filelist >%s/archive 2>%s/pack.err",
+        testprog, pack_options, target, target);
+    failure("Error invoking %s -o %s", testprog, pack_options);
+    assertEqualInt(r, 0);
+
+    assertChdir(target);
+
+    /* Verify stderr. */
+    failure("Expected: %s, options=%s", se, pack_options);
+    assertTextFileContents(se, "pack.err");
+
+    /*
+     * Use cpio to unpack the archive into another directory.
+     */
+    r = systemf("%s -i %s< archive >unpack.out 2>unpack.err",
+        testprog, unpack_options);
+    failure("Error invoking %s -i %s", testprog, unpack_options);
+    assertEqualInt(r, 0);
+
+    /* Verify stderr. */
+    failure("Error invoking %s -i %s in dir %s", testprog, unpack_options, target);
+    assertTextFileContents(se, "unpack.err");
+
+    verify_files(pack_options);
+
+    assertChdir("..");
+}
+
+static void
+passthrough(const char *target)
+{
+    int r;
+
+    if (!assertMakeDir(target, 0775))
+        return;
+
+    /*
+     * Use cpio passthrough mode to copy files to another directory.
+     */
+    r = systemf("%s -p %s <filelist >%s/stdout 2>%s/stderr",
+        testprog, target, target, target);
+    failure("Error invoking %s -p", testprog);
+    assertEqualInt(r, 0);
+
+    assertChdir(target);
+
+    /* Verify stderr. */
+    failure("Error invoking %s -p in dir %s",
+        testprog, target);
+    assertTextFileContents("1 block\n", "stderr");
+
+    verify_files("passthrough");
+    assertChdir("..");
+}
+
+DEFINE_TEST(test_basic)
+{
+    FILE *filelist;
+    const char *msg;
+
+    assertUmask(0);
+
+    /*
+     * Create an assortment of files on disk.
+     */
+    filelist = fopen("filelist", "w");
+
+    /* File with 10 bytes content. */
+    assertMakeFile("file", 0644, "1234567890");
+    fprintf(filelist, "file\n");
+
+    /* hardlink to above file. */
+    assertMakeHardlink("linkfile", "file");
+    fprintf(filelist, "linkfile\n");
+
+    /* Symlink to above file. */
+    if (canSymlink()) {
+        assertMakeSymlink("symlink", "file");
+        fprintf(filelist, "symlink\n");
+    }
+
+    /* Another file with different permissions. */
+    assertMakeFile("file2", 0777, "1234567890");
+    fprintf(filelist, "file2\n");
+
+    /* Directory. */
+    assertMakeDir("dir", 0775);
+    fprintf(filelist, "dir\n");
+    /* All done. */
+    fclose(filelist);
+
+    assertUmask(022);
+
+    /* Archive/dearchive with a variety of options. */
+    msg = canSymlink() ? "2 blocks\n" : "1 block\n";
+    basic_cpio("copy", "", "", msg);
+    basic_cpio("copy_odc", "--format=odc", "", msg);
+    basic_cpio("copy_newc", "-H newc", "", "2 blocks\n");
+    basic_cpio("copy_cpio", "-H odc", "", msg);
+    msg = canSymlink() ? "9 blocks\n" : "8 blocks\n";
+    basic_cpio("copy_ustar", "-H ustar", "", msg);
+
+    /* Copy in one step using -p */
+    passthrough("passthrough");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_cmdline.c b/Utilities/cmlibarchive/cpio/test/test_cmdline.c
new file mode 100644
index 0000000..c8cd84e
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_cmdline.c
@@ -0,0 +1,107 @@
+/*-
+ * 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$");
+
+/*
+ * Test the command-line parsing.
+ */
+
+DEFINE_TEST(test_cmdline)
+{
+    FILE *f;
+
+    /* Create an empty file. */
+    f = fopen("empty", "wb");
+    assert(f != NULL);
+    fclose(f);
+
+    failure("-Q is an invalid option on every cpio program I know of");
+    assert(0 != systemf("%s -i -Q <empty >1.out 2>1.err", testprog));
+    assertEmptyFile("1.out");
+
+    failure("-f requires an argument");
+    assert(0 != systemf("%s -if <empty >2.out 2>2.err", testprog));
+    assertEmptyFile("2.out");
+
+    failure("-f requires an argument");
+    assert(0 != systemf("%s -i -f <empty >3.out 2>3.err", testprog));
+    assertEmptyFile("3.out");
+
+    failure("--format requires an argument");
+    assert(0 != systemf("%s -i --format <empty >4.out 2>4.err", testprog));
+    assertEmptyFile("4.out");
+
+    failure("--badopt is an invalid option");
+    assert(0 != systemf("%s -i --badop <empty >5.out 2>5.err", testprog));
+    assertEmptyFile("5.out");
+
+    failure("--badopt is an invalid option");
+    assert(0 != systemf("%s -i --badopt <empty >6.out 2>6.err", testprog));
+    assertEmptyFile("6.out");
+
+    failure("--n is ambiguous");
+    assert(0 != systemf("%s -i --n <empty >7.out 2>7.err", testprog));
+    assertEmptyFile("7.out");
+
+    failure("--create forbids an argument");
+    assert(0 != systemf("%s --create=arg <empty >8.out 2>8.err", testprog));
+    assertEmptyFile("8.out");
+
+    failure("-i with empty input should succeed");
+    assert(0 == systemf("%s -i <empty >9.out 2>9.err", testprog));
+    assertEmptyFile("9.out");
+
+    failure("-o with empty input should succeed");
+    assert(0 == systemf("%s -o <empty >10.out 2>10.err", testprog));
+
+    failure("-i -p is nonsense");
+    assert(0 != systemf("%s -i -p <empty >11.out 2>11.err", testprog));
+    assertEmptyFile("11.out");
+
+    failure("-p -i is nonsense");
+    assert(0 != systemf("%s -p -i <empty >12.out 2>12.err", testprog));
+    assertEmptyFile("12.out");
+
+    failure("-i -o is nonsense");
+    assert(0 != systemf("%s -i -o <empty >13.out 2>13.err", testprog));
+    assertEmptyFile("13.out");
+
+    failure("-o -i is nonsense");
+    assert(0 != systemf("%s -o -i <empty >14.out 2>14.err", testprog));
+    assertEmptyFile("14.out");
+
+    failure("-o -p is nonsense");
+    assert(0 != systemf("%s -o -p <empty >15.out 2>15.err", testprog));
+    assertEmptyFile("15.out");
+
+    failure("-p -o is nonsense");
+    assert(0 != systemf("%s -p -o <empty >16.out 2>16.err", testprog));
+    assertEmptyFile("16.out");
+
+    failure("-p with empty input should fail");
+    assert(0 != systemf("%s -p <empty >17.out 2>17.err", testprog));
+    assertEmptyFile("17.out");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_format_newc.c b/Utilities/cmlibarchive/cpio/test/test_format_newc.c
new file mode 100644
index 0000000..133f753
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_format_newc.c
@@ -0,0 +1,294 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_format_newc.c,v 1.2 2008/08/22 02:09:10 kientzle Exp $");
+
+/* Number of bytes needed to pad 'n' to multiple of 'block', assuming
+ * that 'block' is a power of two. This trick can be more easily
+ * remembered as -n & (block - 1), but many compilers quite reasonably
+ * warn about "-n" when n is an unsigned value.  (~(n) + 1) is the
+ * same thing, but written in a way that won't offend anyone. */
+#define PAD(n, block)  ((~(n) + 1) & ((block) - 1))
+
+static int
+is_hex(const char *p, size_t l)
+{
+    while (l > 0) {
+        if ((*p >= '0' && *p <= '9')
+            || (*p >= 'a' && *p <= 'f')
+            || (*p >= 'A' && *p <= 'F'))
+        {
+            --l;
+            ++p;
+        } else
+            return (0);
+
+    }
+    return (1);
+}
+
+static int
+from_hex(const char *p, size_t l)
+{
+    int r = 0;
+
+    while (l > 0) {
+        r *= 16;
+        if (*p >= 'a' && *p <= 'f')
+            r += *p + 10 - 'a';
+        else if (*p >= 'A' && *p <= 'F')
+            r += *p + 10 - 'A';
+        else
+            r += *p - '0';
+        --l;
+        ++p;
+    }
+    return (r);
+}
+
+DEFINE_TEST(test_format_newc)
+{
+    FILE *list;
+    int r;
+    int devmajor, devminor, ino, gid;
+    int uid = -1;
+    time_t t, t2, now;
+    char *p, *e;
+    size_t s, fs, ns;
+
+    assertUmask(0);
+
+#if !defined(_WIN32)
+    uid = getuid();
+#endif
+
+    /*
+     * Create an assortment of files.
+     * TODO: Extend this to cover more filetypes.
+     */
+    list = fopen("list", "w");
+
+    /* "file1" */
+    assertMakeFile("file1", 0644, "1234567890");
+    fprintf(list, "file1\n");
+
+    /* "hardlink" */
+    assertMakeHardlink("hardlink", "file1");
+    fprintf(list, "hardlink\n");
+
+    /* Another hardlink, but this one won't be archived. */
+    assertMakeHardlink("hardlink2", "file1");
+
+    /* "symlink" */
+    if (canSymlink()) {
+        assertMakeSymlink("symlink", "file1");
+        fprintf(list, "symlink\n");
+    }
+
+    /* "dir" */
+    assertMakeDir("dir", 0775);
+    fprintf(list, "dir\n");
+
+    /* Record some facts about what we just created: */
+    now = time(NULL); /* They were all created w/in last two seconds. */
+
+    /* Use the cpio program to create an archive. */
+    fclose(list);
+    r = systemf("%s -o --format=newc <list >newc.out 2>newc.err",
+        testprog);
+    if (!assertEqualInt(r, 0))
+        return;
+
+    /* Verify that nothing went to stderr. */
+    if (canSymlink()) {
+        assertTextFileContents("2 blocks\n", "newc.err");
+    } else {
+        assertTextFileContents("1 block\n", "newc.err");
+    }
+
+    /* Verify that stdout is a well-formed cpio file in "newc" format. */
+    p = slurpfile(&s, "newc.out");
+    assertEqualInt(s, canSymlink() ? 1024 : 512);
+    e = p;
+
+    /*
+     * Some of these assertions could be stronger, but it's
+     * a little tricky because they depend on the local environment.
+     */
+
+    /* First entry is "file1" */
+    assert(is_hex(e, 110)); /* Entire header is octal digits. */
+    assertEqualMem(e + 0, "070701", 6); /* Magic */
+    ino = from_hex(e + 6, 8); /* ino */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Group members bits and others bits do not work. */ 
+    assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
+#else
+    assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
+#endif  
+    if (uid < 0)
+        uid = from_hex(e + 22, 8);
+    assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
+    gid = from_hex(e + 30, 8); /* gid */
+    assertEqualMem(e + 38, "00000003", 8); /* nlink */
+    t = from_hex(e + 46, 8); /* mtime */
+    failure("t=0x%08x now=0x%08x=%d", t, now, now);
+    assert(t <= now); /* File wasn't created in future. */
+    failure("t=0x%08x now - 2=0x%08x = %d", t, now - 2, now - 2);
+    assert(t >= now - 2); /* File was created w/in last 2 secs. */
+    failure("newc format stores body only with last appearance of a link\n"
+        "       first appearance should be empty, so this file size\n"
+        "       field should be zero");
+    assertEqualInt(0, from_hex(e + 54, 8)); /* File size */
+    fs = from_hex(e + 54, 8);
+    fs += PAD(fs, 4);
+    devmajor = from_hex(e + 62, 8); /* devmajor */
+    devminor = from_hex(e + 70, 8); /* devminor */
+    assert(is_hex(e + 78, 8)); /* rdevmajor */
+    assert(is_hex(e + 86, 8)); /* rdevminor */
+    assertEqualMem(e + 94, "00000006", 8); /* Name size */
+    ns = from_hex(e + 94, 8);
+    ns += PAD(ns + 2, 4);
+    assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
+    assertEqualMem(e + 110, "file1\0", 6); /* Name contents */
+    /* Since there's another link, no file contents here. */
+    /* But add in file size so that an error here doesn't cascade. */
+    e += 110 + fs + ns;
+
+    if (canSymlink()) {
+        /* "symlink" pointing to "file1" */
+        assert(is_hex(e, 110));
+        assertEqualMem(e + 0, "070701", 6); /* Magic */
+        assert(is_hex(e + 6, 8)); /* ino */
+        assertEqualInt(0xa1ff, from_hex(e + 14, 8)); /* Mode */
+        assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
+        assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
+        assertEqualMem(e + 38, "00000001", 8); /* nlink */
+        t2 = from_hex(e + 46, 8); /* mtime */
+        failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
+        assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
+        assertEqualMem(e + 54, "00000005", 8); /* File size */
+        fs = from_hex(e + 54, 8);
+        fs += PAD(fs, 4);
+        assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
+        assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
+        assert(is_hex(e + 78, 8)); /* rdevmajor */
+        assert(is_hex(e + 86, 8)); /* rdevminor */
+        assertEqualMem(e + 94, "00000008", 8); /* Name size */
+        ns = from_hex(e + 94, 8);
+        ns += PAD(ns + 2, 4);
+        assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
+        assertEqualMem(e + 110, "symlink\0\0\0", 10); /* Name contents */
+        assertEqualMem(e + 110 + ns, "file1\0\0\0", 8); /* symlink target */
+        e += 110 + fs + ns;
+    }
+
+    /* "dir" */
+    assert(is_hex(e, 110));
+    assertEqualMem(e + 0, "070701", 6); /* Magic */
+    assert(is_hex(e + 6, 8)); /* ino */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Group members bits and others bits do not work. */
+    assertEqualInt(0x41c0, from_hex(e + 14, 8) & 0xffc0); /* Mode */
+#else
+    /* Mode: sgid bit sometimes propagates from parent dirs, ignore it. */
+    assertEqualInt(040775, from_hex(e + 14, 8) & ~02000);
+#endif
+    assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
+    assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
+#ifndef NLINKS_INACCURATE_FOR_DIRS
+    assertEqualMem(e + 38, "00000002", 8); /* nlink */
+#endif
+    t2 = from_hex(e + 46, 8); /* mtime */
+    failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
+    assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
+    assertEqualMem(e + 54, "00000000", 8); /* File size */
+    fs = from_hex(e + 54, 8);
+    fs += PAD(fs, 4);
+    assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
+    assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
+    assert(is_hex(e + 78, 8)); /* rdevmajor */
+    assert(is_hex(e + 86, 8)); /* rdevminor */
+    assertEqualMem(e + 94, "00000004", 8); /* Name size */
+    ns = from_hex(e + 94, 8);
+    ns += PAD(ns + 2, 4);
+    assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
+    assertEqualMem(e + 110, "dir\0\0\0", 6); /* Name contents */
+    e += 110 + fs + ns;
+
+    /* Hardlink identical to "file1" */
+    /* Since we only wrote two of the three links to this
+     * file, this link should get deferred by the hardlink logic. */
+    assert(is_hex(e, 110));
+    assertEqualMem(e + 0, "070701", 6); /* Magic */
+    failure("If these aren't the same, then the hardlink detection failed to match them.");
+    assertEqualInt(ino, from_hex(e + 6, 8)); /* ino */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Group members bits and others bits do not work. */ 
+    assertEqualInt(0x8180, from_hex(e + 14, 8) & 0xffc0); /* Mode */
+#else
+    assertEqualInt(0x81a4, from_hex(e + 14, 8)); /* Mode */
+#endif
+    assertEqualInt(from_hex(e + 22, 8), uid); /* uid */
+    assertEqualInt(gid, from_hex(e + 30, 8)); /* gid */
+    assertEqualMem(e + 38, "00000003", 8); /* nlink */
+    t2 = from_hex(e + 46, 8); /* mtime */
+    failure("First entry created at t=0x%08x this entry created at t2=0x%08x", t, t2);
+    assert(t2 == t || t2 == t + 1); /* Almost same as first entry. */
+    assertEqualInt(10, from_hex(e + 54, 8)); /* File size */
+    fs = from_hex(e + 54, 8);
+    fs += PAD(fs, 4);
+    assertEqualInt(devmajor, from_hex(e + 62, 8)); /* devmajor */
+    assertEqualInt(devminor, from_hex(e + 70, 8)); /* devminor */
+    assert(is_hex(e + 78, 8)); /* rdevmajor */
+    assert(is_hex(e + 86, 8)); /* rdevminor */
+    assertEqualMem(e + 94, "00000009", 8); /* Name size */
+    ns = from_hex(e + 94, 8);
+    ns += PAD(ns + 2, 4);
+    assertEqualInt(0, from_hex(e + 102, 8)); /* check field */
+    assertEqualMem(e + 110, "hardlink\0\0", 10); /* Name contents */
+    assertEqualMem(e + 110 + ns, "1234567890\0\0", 12); /* File contents */
+    e += 110 + ns + fs;
+
+    /* Last entry is end-of-archive marker. */
+    assert(is_hex(e, 110));
+    assertEqualMem(e + 0, "070701", 6); /* Magic */
+    assertEqualMem(e + 8, "00000000", 8); /* ino */
+    assertEqualMem(e + 14, "00000000", 8); /* mode */
+    assertEqualMem(e + 22, "00000000", 8); /* uid */
+    assertEqualMem(e + 30, "00000000", 8); /* gid */
+    assertEqualMem(e + 38, "00000001", 8); /* nlink */
+    assertEqualMem(e + 46, "00000000", 8); /* mtime */
+    assertEqualMem(e + 54, "00000000", 8); /* size */
+    assertEqualMem(e + 62, "00000000", 8); /* devmajor */
+    assertEqualMem(e + 70, "00000000", 8); /* devminor */
+    assertEqualMem(e + 78, "00000000", 8); /* rdevmajor */
+    assertEqualMem(e + 86, "00000000", 8); /* rdevminor */
+    assertEqualInt(11, from_hex(e + 94, 8)); /* name size */
+    assertEqualMem(e + 102, "00000000", 8); /* check field */
+    assertEqualMem(e + 110, "TRAILER!!!\0\0", 12); /* Name */
+
+    free(p);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat.c b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat.c
new file mode 100644
index 0000000..2d49523
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat.c
@@ -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: src/usr.bin/cpio/test/test_gcpio_compat.c,v 1.2 2008/08/22 02:27:06 kientzle Exp $");
+
+static void
+unpack_test(const char *from, const char *options, const char *se)
+{
+    int r;
+
+    /* Create a work dir named after the file we're unpacking. */
+    assertMakeDir(from, 0775);
+    assertChdir(from);
+
+    /*
+     * Use cpio to unpack the sample archive
+     */
+    extract_reference_file(from);
+    r = systemf("%s -i %s < %s >unpack.out 2>unpack.err",
+        testprog, options, from);
+    failure("Error invoking %s -i %s < %s",
+        testprog, options, from);
+    assertEqualInt(r, 0);
+
+    /* Verify that nothing went to stderr. */
+    if (canSymlink()) {
+        failure("Error invoking %s -i %s < %s",
+            testprog, options, from);
+        assertTextFileContents(se, "unpack.err");
+    }
+
+    /*
+     * Verify unpacked files.
+     */
+
+    /* Regular file with 2 links. */
+    assertIsReg("file", 0644);
+    failure("%s", from);
+    assertFileSize("file", 10);
+    assertFileSize("linkfile", 10);
+    failure("%s", from);
+    assertFileNLinks("file", 2);
+
+    /* Another name for the same file. */
+    failure("%s", from);
+    assertIsHardlink("linkfile", "file");
+    assertFileSize("file", 10);
+    assertFileSize("linkfile", 10);
+
+    /* Symlink */
+    if (canSymlink())
+        assertIsSymlink("symlink", "file");
+
+    /* dir */
+    assertIsDir("dir", 0775);
+
+    assertChdir("..");
+}
+
+DEFINE_TEST(test_gcpio_compat)
+{
+    assertUmask(0);
+
+    /* Dearchive sample files with a variety of options. */
+    if (canSymlink()) {
+        unpack_test("test_gcpio_compat_ref.bin",
+            "--no-preserve-owner", "1 block\n");
+        unpack_test("test_gcpio_compat_ref.crc",
+            "--no-preserve-owner", "2 blocks\n");
+        unpack_test("test_gcpio_compat_ref.newc",
+            "--no-preserve-owner", "2 blocks\n");
+        /* gcpio-2.9 only reads 6 blocks here */
+        unpack_test("test_gcpio_compat_ref.ustar",
+            "--no-preserve-owner", "7 blocks\n");
+    } else {
+        unpack_test("test_gcpio_compat_ref_nosym.bin",
+            "--no-preserve-owner", "1 block\n");
+        unpack_test("test_gcpio_compat_ref_nosym.crc",
+            "--no-preserve-owner", "2 blocks\n");
+        unpack_test("test_gcpio_compat_ref_nosym.newc",
+            "--no-preserve-owner", "2 blocks\n");
+        /* gcpio-2.9 only reads 6 blocks here */
+        unpack_test("test_gcpio_compat_ref_nosym.ustar",
+            "--no-preserve-owner", "7 blocks\n");
+    }
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.bin.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.bin.uu
new file mode 100644
index 0000000..745d8ab
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.bin.uu
@@ -0,0 +1,16 @@
+$FreeBSD$
+begin 644 test_gcpio_compat_ref.bin
+MQW%9`*IWI('H`^@#`@````U'=YD%````"@!F:6QE```Q,C,T-38W.#D*QW%9
+M`*IWI('H`^@#`@````U'=YD)````"@!L:6YK9FEL90``,3(S-#4V-S@Y"L=Q
+M60"K=^VAZ`/H`P$````-1X29"`````0`<WEM;&EN:P!F:6QEQW%9`*YW_4'H
+M`^@#`@````U'A9D$``````!D:7(`QW$``````````````0`````````+````
+M``!44D%)3$52(2$A````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.crc.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.crc.uu
new file mode 100644
index 0000000..df8dde0
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.crc.uu
@@ -0,0 +1,27 @@
+$FreeBSD$
+begin 644 test_gcpio_compat_ref.crc
+M,#<P-S`R,#`S,S<W86$P,#`P.#%A-#`P,#`P,V4X,#`P,#`S93@P,#`P,#`P
+M,C0W,&0Y.3<W,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4Y,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`U,#`P,#`P,#!F:6QE```P-S`W,#(P,#,S-S=A83`P,#`X
+M,6$T,#`P,#`S93@P,#`P,#-E.#`P,#`P,#`R-#<P9#DY-S<P,#`P,#`P83`P
+M,#`P,#`P,#`P,#`P-3DP,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#DP,#`P,#%E
+M-VQI;FMF:6QE```Q,C,T-38W.#D*```P-S`W,#(P,#,S-S=A8C`P,#!A,65D
+M,#`P,#`S93@P,#`P,#-E.#`P,#`P,#`Q-#<P9#DY.#0P,#`P,#`P-#`P,#`P
+M,#`P,#`P,#`P-3DP,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#@P,#`P,#`P,'-Y
+M;6QI;FL```!F:6QE,#<P-S`R,#`S,S<W864P,#`P-#%F9#`P,#`P,V4X,#`P
+M,#`S93@P,#`P,#`P,C0W,&0Y.3@U,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4Y
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`T,#`P,#`P,#!D:7(````P-S`W,#(P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`Q,#`P,#`P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,&(P,#`P,#`P,%1204E,15(A(2$`````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+B````````````````````````````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.newc.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.newc.uu
new file mode 100644
index 0000000..1e29ba9
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.newc.uu
@@ -0,0 +1,27 @@
+$FreeBSD$
+begin 644 test_gcpio_compat_ref.newc
+M,#<P-S`Q,#`S,S<W86$P,#`P.#%A-#`P,#`P,V4X,#`P,#`S93@P,#`P,#`P
+M,C0W,&0Y.3<W,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4Y,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`U,#`P,#`P,#!F:6QE```P-S`W,#$P,#,S-S=A83`P,#`X
+M,6$T,#`P,#`S93@P,#`P,#-E.#`P,#`P,#`R-#<P9#DY-S<P,#`P,#`P83`P
+M,#`P,#`P,#`P,#`P-3DP,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#DP,#`P,#`P
+M,&QI;FMF:6QE```Q,C,T-38W.#D*```P-S`W,#$P,#,S-S=A8C`P,#!A,65D
+M,#`P,#`S93@P,#`P,#-E.#`P,#`P,#`Q-#<P9#DY.#0P,#`P,#`P-#`P,#`P
+M,#`P,#`P,#`P-3DP,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#@P,#`P,#`P,'-Y
+M;6QI;FL```!F:6QE,#<P-S`Q,#`S,S<W864P,#`P-#%F9#`P,#`P,V4X,#`P
+M,#`S93@P,#`P,#`P,C0W,&0Y.3@U,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4Y
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`T,#`P,#`P,#!D:7(````P-S`W,#$P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`Q,#`P,#`P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,&(P,#`P,#`P,%1204E,15(A(2$`````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+B````````````````````````````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.ustar.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.ustar.uu
new file mode 100644
index 0000000..77989f4
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref.ustar.uu
@@ -0,0 +1,84 @@
+$FreeBSD$
+begin 644 test_gcpio_compat_ref.ustar
+M9FEL90``````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````#`P,#`V-#0`,#`P,3<U,``P,#`Q-S4P`#`P,#`P,#`P,#$R
+M`#$P-S`S,S$T-38W`#`P,3$S-C,`,```````````````````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````````````````````````!U<W1A<@`P,'1I;0``
+M````````````````````````````````````=&EM````````````````````
+M```````````````````P,#`P,#`P`#`P,#`P,#``````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M```````````````````````Q,C,T-38W.#D*````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````````````````````````````````````&QI;FMF:6QE````
+M````````````````````````````````````````````````````````````
+M```````````````````````````````````````````````````````````P
+M,#`P-C0T`#`P,#$W-3``,#`P,3<U,``P,#`P,#`P,#`P,``Q,#<P,S,Q-#4V
+M-P`P,#$S,#<W`#%F:6QE````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````=7-T87(`,#!T:6T`````````````````
+M`````````````````````'1I;0``````````````````````````````````
+M````,#`P,#`P,``P,#`P,#`P````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````<WEM;&EN:P``````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````````````#`P,#`W-34`,#`P,3<U,``P,#`Q-S4P`#`P,#`P
+M,#`P,#`P`#$P-S`S,S$T-C`T`#`P,3(W-C0`,F9I;&4`````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````````````````````````````````!U<W1A<@`P
+M,'1I;0``````````````````````````````````````=&EM````````````
+M```````````````````````````P,#`P,#`P`#`P,#`P,#``````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````````````!D:7(O````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````,#`P,#<W-0`P,#`Q
+M-S4P`#`P,#$W-3``,#`P,#`P,#`P,#``,3`W,#,S,30V,#4`,#`Q,3,P,0`U
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````'5S=&%R`#`P=&EM````````````````````````````````
+M``````!T:6T``````````````````````````````````````#`P,#`P,#``
+M,#`P,#`P,```````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+=````````````````````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.bin.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.bin.uu
new file mode 100644
index 0000000..a3e87a7
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.bin.uu
@@ -0,0 +1,15 @@
+begin 644 test_gcpio_compat_ref_nosym.bin
+MQW%4`-[Z_4'H`^@#`@`VNZU*NQX$``````!D:7(`QW%4`-SZI('H`^@#`@`G
+MNZU*NQX%````"@!F:6QE```Q,C,T-38W.#D*QW%4`-SZI('H`^@#`@`GNZU*
+MNQX)````"@!L:6YK9FEL90``,3(S-#4V-S@Y"L=Q``````````````$`````
+M````"P``````5%)!24Q%4B$A(0``````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.crc.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.crc.uu
new file mode 100644
index 0000000..38ba9fe
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.crc.uu
@@ -0,0 +1,15 @@
+begin 644 test_gcpio_compat_ref_nosym.crc
+M,#<P-S`R,#`U-D9!1$4P,#`P-#%&1#`P,#`P,T4X,#`P,#`S13@P,#`P,#`P
+M,C1!040Q14)",#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4T,#`P,#`P0D(P,35"
+M,#`S-C`P,#`P,#`T,#`P,#`P,#!D:7(````P-S`W,#(P,#4V1D%$0S`P,#`X
+M,4$T,#`P,#`S13@P,#`P,#-%.#`P,#`P,#`R-$%!1#%%0D(P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`P-30P,#`P,#!"0C`Q-4(P,#(W,#`P,#`P,#4P,#`P,#`P
+M,&9I;&4``#`W,#<P,C`P-39&041#,#`P,#@Q030P,#`P,#-%.#`P,#`P,T4X
+M,#`P,#`P,#(T04%$,45"0C`P,#`P,#!!,#`P,#`P,#`P,#`P,#`U-#`P,#`P
+M,$)",#$U0C`P,C<P,#`P,#`P.3`P,#`P,44W;&EN:V9I;&4``#$R,S0U-C<X
+M.0H``#`W,#<P,C`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,#$P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`P,#`P0C`P,#`P,#`P5%)!24Q%4B$A(0``````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.newc.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.newc.uu
new file mode 100644
index 0000000..2404964
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.newc.uu
@@ -0,0 +1,15 @@
+begin 644 test_gcpio_compat_ref_nosym.newc
+M,#<P-S`Q,#`U-D9!1$4P,#`P-#%&1#`P,#`P,T4X,#`P,#`S13@P,#`P,#`P
+M,C1!040Q14)",#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4T,#`P,#`P0D(P,35"
+M,#`S-C`P,#`P,#`T,#`P,#`P,#!D:7(````P-S`W,#$P,#4V1D%$0S`P,#`X
+M,4$T,#`P,#`S13@P,#`P,#-%.#`P,#`P,#`R-$%!1#%%0D(P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`P-30P,#`P,#!"0C`Q-4(P,#(W,#`P,#`P,#4P,#`P,#`P
+M,&9I;&4``#`W,#<P,3`P-39&041#,#`P,#@Q030P,#`P,#-%.#`P,#`P,T4X
+M,#`P,#`P,#(T04%$,45"0C`P,#`P,#!!,#`P,#`P,#`P,#`P,#`U-#`P,#`P
+M,$)",#$U0C`P,C<P,#`P,#`P.3`P,#`P,#`P;&EN:V9I;&4``#$R,S0U-C<X
+M.0H``#`W,#<P,3`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,#$P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,#`P,#`P0C`P,#`P,#`P5%)!24Q%4B$A(0``````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.ustar.uu b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.ustar.uu
new file mode 100644
index 0000000..5f9fcbe
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_gcpio_compat_ref_nosym.ustar.uu
@@ -0,0 +1,72 @@
+begin 644 test_gcpio_compat_ref_nosym.ustar
+M9&ER+P``````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````#`P,#`W-S4`,#`P,3<U,``P,#`Q-S4P`#`P,#`P,#`P,#`P
+M`#$Q,C4S,C$W,C<S`#`P,3$S-3$`-0``````````````````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````````````````````````!U<W1A<@`P,'1I;0``
+M````````````````````````````````````=&EM````````````````````
+M```````````````````P,#`P,C<S`#8V,#`P-C8`````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````!F:6QE````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````,#`P,#8T-``P,#`Q-S4P`#`P
+M,#$W-3``,#`P,#`P,#`P,3(`,3$R-3,R,3<R-S,`,#`Q,30R,P`P````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````'5S=&%R`#`P=&EM``````````````````````````````````````!T
+M:6T``````````````````````````````````````#`P,#`R-S,`-C8P,#`T
+M-P``````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````````````````````````````````````#$R,S0U-C<X.0H`
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````;&EN:V9I;&4`````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M`````````````````````#`P,#`V-#0`,#`P,3<U,``P,#`Q-S4P`#`P,#`P
+M,#`P,#`P`#$Q,C4S,C$W,C<S`#`P,3,Q,S<`,69I;&4`````````````````
+M````````````````````````````````````````````````````````````
+M``````````````````````````````````````````````````!U<W1A<@`P
+M,'1I;0``````````````````````````````````````=&EM````````````
+M```````````````````````````P,#`P,C<S`#8V,#`P-#<`````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+,````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_B_upper.c b/Utilities/cmlibarchive/cpio/test/test_option_B_upper.c
new file mode 100644
index 0000000..a99b12b
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_B_upper.c
@@ -0,0 +1,52 @@
+/*-
+ * 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_option_B_upper)
+{
+    struct stat st;
+    int r;
+
+    /*
+     * Create a file on disk.
+     */
+    assertMakeFile("file", 0644, NULL);
+
+    /* Create an archive without -B; this should be 512 bytes. */
+    r = systemf("echo file | %s -o > small.cpio 2>small.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "small.err");
+    assertEqualInt(0, stat("small.cpio", &st));
+    assertEqualInt(512, st.st_size);
+
+    /* Create an archive with -B; this should be 5120 bytes. */
+    r = systemf("echo file | %s -oB > large.cpio 2>large.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "large.err");
+    assertEqualInt(0, stat("large.cpio", &st));
+    assertEqualInt(5120, st.st_size);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_C_upper.c b/Utilities/cmlibarchive/cpio/test/test_option_C_upper.c
new file mode 100644
index 0000000..afc319f
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_C_upper.c
@@ -0,0 +1,62 @@
+/*-
+ * 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_option_C_upper)
+{
+    int r;
+
+    /*
+     * Create a file on disk.
+     */
+    assertMakeFile("file", 0644, NULL);
+
+    /* Create an archive without -C; this should be 512 bytes. */
+    r = systemf("echo file | %s -o > small.cpio 2>small.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "small.err");
+    assertFileSize("small.cpio", 512);
+
+    /* Create an archive with -C 513; this should be 513 bytes. */
+    r = systemf("echo file | %s -o -C 513 > 513.cpio 2>513.err",
+            testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "513.err");
+    assertFileSize("513.cpio", 513);
+
+    /* Create an archive with -C 12345; this should be 12345 bytes. */
+    r = systemf("echo file | %s -o -C12345 > 12345.cpio 2>12345.err",
+            testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "12345.err");
+    assertFileSize("12345.cpio", 12345);
+
+    /* Create an archive with invalid -C request */
+    assert(0 != systemf("echo file | %s -o -C > bad.cpio 2>bad.err",
+                testprog));
+    assertEmptyFile("bad.cpio");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_J_upper.c b/Utilities/cmlibarchive/cpio/test/test_option_J_upper.c
new file mode 100644
index 0000000..554f64a
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_J_upper.c
@@ -0,0 +1,56 @@
+/*-
+ * 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$");
+
+DEFINE_TEST(test_option_J_upper)
+{
+    char *p;
+    int r;
+    size_t s;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Archive it with xz compression. */
+    r = systemf("echo f | %s -o -J >archive.out 2>archive.err",
+        testprog);
+    p = slurpfile(&s, "archive.err");
+    p[s] = '\0';
+    if (r != 0) {
+        if (strstr(p, "compression not available") != NULL) {
+            skipping("This version of bsdcpio was compiled "
+                "without xz support");
+            return;
+        }
+        failure("-J option is broken");
+        assertEqualInt(r, 0);
+        return;
+    }
+    /* Check that the archive file has an xz signature. */
+    p = slurpfile(&s, "archive.out");
+    assert(s > 2);
+    assertEqualMem(p, "\3757zXZ", 5);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_L_upper.c b/Utilities/cmlibarchive/cpio/test/test_option_L_upper.c
new file mode 100644
index 0000000..396752f
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_L_upper.c
@@ -0,0 +1,96 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_option_L.c,v 1.2 2008/08/24 06:21:00 kientzle Exp $");
+
+/* This is a little pointless, as Windows doesn't support symlinks
+ * (except for the seriously crippled CreateSymbolicLink API) so these
+ * tests won't run on Windows. */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#define CAT "type"
+#else
+#define CAT "cat"
+#endif
+
+DEFINE_TEST(test_option_L_upper)
+{
+    FILE *filelist;
+    int r;
+
+    if (!canSymlink()) {
+        skipping("Symlink tests");
+        return;
+    }
+
+    filelist = fopen("filelist", "w");
+
+    /* Create a file and a symlink to the file. */
+    assertMakeFile("file", 0644, "1234567890");
+    fprintf(filelist, "file\n");
+
+    /* Symlink to above file. */
+    assertMakeSymlink("symlink", "file");
+    fprintf(filelist, "symlink\n");
+
+    fclose(filelist);
+
+    r = systemf(CAT " filelist | %s -pd copy >copy.out 2>copy.err", testprog);
+    assertEqualInt(r, 0);
+
+    failure("Regular -p without -L should preserve symlinks.");
+    assertIsSymlink("copy/symlink", NULL);
+
+    r = systemf(CAT " filelist | %s -pd -L copy-L >copy-L.out 2>copy-L.err", testprog);
+    assertEqualInt(r, 0);
+    assertEmptyFile("copy-L.out");
+    assertTextFileContents("1 block\n", "copy-L.err");
+    failure("-pdL should dereference symlinks and turn them into files.");
+    assertIsReg("copy-L/symlink", -1);
+
+    r = systemf(CAT " filelist | %s -o >archive.out 2>archive.err", testprog);
+    failure("Error invoking %s -o ", testprog);
+    assertEqualInt(r, 0);
+
+    assertMakeDir("unpack", 0755);
+    assertChdir("unpack");
+    r = systemf(CAT " ../archive.out | %s -i >unpack.out 2>unpack.err", testprog);
+    assertChdir("..");
+    failure("Error invoking %s -i", testprog);
+    assertEqualInt(r, 0);
+
+    assertIsSymlink("unpack/symlink", NULL);
+
+    r = systemf(CAT " filelist | %s -oL >archive-L.out 2>archive-L.err", testprog);
+    failure("Error invoking %s -oL", testprog);
+    assertEqualInt(r, 0);
+
+    assertMakeDir("unpack-L", 0755);
+    assertChdir("unpack-L");
+    r = systemf(CAT " ../archive-L.out | %s -i >unpack-L.out 2>unpack-L.err", testprog);
+    assertChdir("..");
+    failure("Error invoking %s -i < archive-L.out", testprog);
+    assertEqualInt(r, 0);
+    assertIsReg("unpack-L/symlink", -1);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_Z_upper.c b/Utilities/cmlibarchive/cpio/test/test_option_Z_upper.c
new file mode 100644
index 0000000..6810ec6
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_Z_upper.c
@@ -0,0 +1,56 @@
+/*-
+ * 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$");
+
+DEFINE_TEST(test_option_Z_upper)
+{
+    char *p;
+    int r;
+    size_t s;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Archive it with compress compression. */
+    r = systemf("echo f | %s -oZ >archive.out 2>archive.err",
+        testprog);
+    p = slurpfile(&s, "archive.err");
+    p[s] = '\0';
+    if (r != 0) {
+        if (strstr(p, "compression not available") != NULL) {
+            skipping("This version of bsdcpio was compiled "
+                "without compress support");
+            return;
+        }
+        failure("-Z option is broken");
+        assertEqualInt(r, 0);
+        return;
+    }
+    /* Check that the archive file has a compress signature. */
+    p = slurpfile(&s, "archive.out");
+    assert(s > 2);
+    assertEqualMem(p, "\x1f\x9d", 2);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_a.c b/Utilities/cmlibarchive/cpio/test/test_option_a.c
new file mode 100644
index 0000000..c39e553
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_a.c
@@ -0,0 +1,154 @@
+/*-
+ * 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"
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <sys/utime.h>
+#else
+#include <utime.h>
+#endif
+__FBSDID("$FreeBSD: src/usr.bin/cpio/test/test_option_a.c,v 1.3 2008/08/24 06:21:00 kientzle Exp $");
+
+static struct {
+    const char *name;
+    time_t atime_sec;
+} files[] = {
+    { "f0", 0 },
+    { "f1", 0 },
+    { "f2", 0 },
+    { "f3", 0 },
+    { "f4", 0 },
+    { "f5", 0 }
+};
+
+/*
+ * Create a bunch of test files and record their atimes.
+ * For the atime preserve/change tests, the files must have
+ * atimes in the past.  We can accomplish this by explicitly invoking
+ * utime() on platforms that support it or by simply sleeping
+ * for a second after creating the files.  (Creating all of the files
+ * at once means we only need to sleep once.)
+ */
+static void
+test_create(void)
+{
+    struct stat st;
+    struct utimbuf times;
+    static const int numfiles = sizeof(files) / sizeof(files[0]);
+    int i;
+
+    for (i = 0; i < numfiles; ++i) {
+        /*
+         * Note: Have to write at least one byte to the file.
+         * cpio doesn't bother reading the file if it's zero length,
+         * so the atime never gets changed in that case, which
+         * makes the tests below rather pointless.
+         */
+        assertMakeFile(files[i].name, 0644, "a");
+
+        /* If utime() isn't supported on your platform, just
+         * #ifdef this section out.  Most of the test below is
+         * still valid. */
+        memset(&times, 0, sizeof(times));
+        times.actime = 1;
+        times.modtime = 3;
+        assertEqualInt(0, utime(files[i].name, &times));
+
+        /* Record whatever atime the file ended up with. */
+        /* If utime() is available, this should be 1, but there's
+         * no harm in being careful. */
+        assertEqualInt(0, stat(files[i].name, &st));
+        files[i].atime_sec = st.st_atime;
+    }
+
+    /* Wait until the atime on the last file is actually in the past. */
+    sleepUntilAfter(files[numfiles - 1].atime_sec);
+}
+
+DEFINE_TEST(test_option_a)
+{
+    struct stat st;
+    int r;
+    char *p;
+
+    /* Create all of the test files. */
+    test_create();
+
+    /* Sanity check; verify that atimes really do get modified. */
+    assert((p = slurpfile(NULL, "f0")) != NULL);
+    free(p);
+    assertEqualInt(0, stat("f0", &st));
+    if (st.st_atime == files[0].atime_sec) {
+        skipping("Cannot verify -a option\n"
+            "      Your system appears to not support atime.");
+    }
+    else
+    {
+        /*
+         * If this disk is mounted noatime, then we can't
+         * verify correct operation without -a.
+         */
+
+        /* Copy the file without -a; should change the atime. */
+        r = systemf("echo %s | %s -pd copy-no-a > copy-no-a.out 2>copy-no-a.err", files[1].name, testprog);
+        assertEqualInt(r, 0);
+        assertTextFileContents("1 block\n", "copy-no-a.err");
+        assertEmptyFile("copy-no-a.out");
+        assertEqualInt(0, stat(files[1].name, &st));
+        failure("Copying file without -a should have changed atime.");
+        assert(st.st_atime != files[1].atime_sec);
+
+        /* Archive the file without -a; should change the atime. */
+        r = systemf("echo %s | %s -o > archive-no-a.out 2>archive-no-a.err", files[2].name, testprog);
+        assertEqualInt(r, 0);
+        assertTextFileContents("1 block\n", "copy-no-a.err");
+        assertEqualInt(0, stat(files[2].name, &st));
+        failure("Archiving file without -a should have changed atime.");
+        assert(st.st_atime != files[2].atime_sec);
+    }
+
+    /*
+     * We can, of course, still verify that the atime is unchanged
+     * when using the -a option.
+     */
+
+    /* Copy the file with -a; should not change the atime. */
+    r = systemf("echo %s | %s -pad copy-a > copy-a.out 2>copy-a.err",
+        files[3].name, testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "copy-a.err");
+    assertEmptyFile("copy-a.out");
+    assertEqualInt(0, stat(files[3].name, &st));
+    failure("Copying file with -a should not have changed atime.");
+    assertEqualInt(st.st_atime, files[3].atime_sec);
+
+    /* Archive the file with -a; should not change the atime. */
+    r = systemf("echo %s | %s -oa > archive-a.out 2>archive-a.err",
+        files[4].name, testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "copy-a.err");
+    assertEqualInt(0, stat(files[4].name, &st));
+    failure("Archiving file with -a should not have changed atime.");
+    assertEqualInt(st.st_atime, files[4].atime_sec);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_c.c b/Utilities/cmlibarchive/cpio/test/test_option_c.c
new file mode 100644
index 0000000..a28a2ff
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_c.c
@@ -0,0 +1,221 @@
+/*-
+ * 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 int
+is_octal(const char *p, size_t l)
+{
+    while (l > 0) {
+        if (*p < '0' || *p > '7')
+            return (0);
+        --l;
+        ++p;
+    }
+    return (1);
+}
+
+static int
+from_octal(const char *p, size_t l)
+{
+    int r = 0;
+
+    while (l > 0) {
+        r *= 8;
+        r += *p - '0';
+        --l;
+        ++p;
+    }
+    return (r);
+}
+
+DEFINE_TEST(test_option_c)
+{
+    FILE *filelist;
+    int r;
+    int uid = -1;
+    int dev, ino, gid;
+    time_t t, now;
+    char *p, *e;
+    size_t s;
+
+    assertUmask(0);
+
+#if !defined(_WIN32)
+    uid = getuid();
+#endif
+
+    /*
+     * Create an assortment of files.
+     * TODO: Extend this to cover more filetypes.
+     */
+    filelist = fopen("filelist", "w");
+
+    /* "file" */
+    assertMakeFile("file", 0644, "1234567890");
+    fprintf(filelist, "file\n");
+
+    /* "symlink" */
+    if (canSymlink()) {
+        assertMakeSymlink("symlink", "file");
+        fprintf(filelist, "symlink\n");
+    }
+
+    /* "dir" */
+    assertMakeDir("dir", 0775);
+    /* Record some facts about what we just created: */
+    now = time(NULL); /* They were all created w/in last two seconds. */
+    fprintf(filelist, "dir\n");
+
+    /* Use the cpio program to create an archive. */
+    fclose(filelist);
+    r = systemf("%s -oc <filelist >basic.out 2>basic.err", testprog);
+    /* Verify that nothing went to stderr. */
+    assertTextFileContents("1 block\n", "basic.err");
+
+    /* Assert that the program finished. */
+    failure("%s -oc crashed", testprog);
+    if (!assertEqualInt(r, 0))
+        return;
+
+    /* Verify that stdout is a well-formed cpio file in "odc" format. */
+    p = slurpfile(&s, "basic.out");
+    assertEqualInt(s, 512);
+    e = p;
+
+    /*
+     * Some of these assertions could be stronger, but it's
+     * a little tricky because they depend on the local environment.
+     */
+
+    /* First entry is "file" */
+    assert(is_octal(e, 76)); /* Entire header is octal digits. */
+    assertEqualMem(e + 0, "070707", 6); /* Magic */
+    assert(is_octal(e + 6, 6)); /* dev */
+    dev = from_octal(e + 6, 6);
+    assert(is_octal(e + 12, 6)); /* ino */
+    ino = from_octal(e + 12, 6);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Group members bits and others bits do not work. */
+    assertEqualMem(e + 18, "100666", 6); /* Mode */
+#else
+    assertEqualMem(e + 18, "100644", 6); /* Mode */
+#endif
+    if (uid < 0)
+        uid = from_octal(e + 24, 6);
+    assertEqualInt(from_octal(e + 24, 6), uid); /* uid */
+    assert(is_octal(e + 30, 6)); /* gid */
+    gid = from_octal(e + 30, 6);
+    assertEqualMem(e + 36, "000001", 6); /* nlink */
+    failure("file entries should not have rdev set (dev field was 0%o)",
+        dev);
+    assertEqualMem(e + 42, "000000", 6); /* rdev */
+    t = from_octal(e + 48, 11); /* mtime */
+    assert(t <= now); /* File wasn't created in future. */
+    assert(t >= now - 2); /* File was created w/in last 2 secs. */
+    assertEqualMem(e + 59, "000005", 6); /* Name size */
+    assertEqualMem(e + 65, "00000000012", 11); /* File size */
+    assertEqualMem(e + 76, "file\0", 5); /* Name contents */
+    assertEqualMem(e + 81, "1234567890", 10); /* File contents */
+    e += 91;
+
+    /* "symlink" pointing to "file" */
+    if (canSymlink()) {
+        assert(is_octal(e, 76)); /* Entire header is octal digits. */
+        assertEqualMem(e + 0, "070707", 6); /* Magic */
+        assertEqualInt(dev, from_octal(e + 6, 6)); /* dev */
+        assert(dev != from_octal(e + 12, 6)); /* ino */
+#if !defined(_WIN32) || defined(__CYGWIN__)
+        /* On Windows, symbolic link and group members bits and
+         * others bits do not work. */
+        assertEqualMem(e + 18, "120777", 6); /* Mode */
+#endif
+        assertEqualInt(from_octal(e + 24, 6), uid); /* uid */
+        assertEqualInt(gid, from_octal(e + 30, 6)); /* gid */
+        assertEqualMem(e + 36, "000001", 6); /* nlink */
+        failure("file entries should have rdev == 0 (dev was 0%o)",
+            from_octal(e + 6, 6));
+        assertEqualMem(e + 42, "000000", 6); /* rdev */
+        t = from_octal(e + 48, 11); /* mtime */
+        assert(t <= now); /* File wasn't created in future. */
+        assert(t >= now - 2); /* File was created w/in last 2 secs. */
+        assertEqualMem(e + 59, "000010", 6); /* Name size */
+        assertEqualMem(e + 65, "00000000004", 11); /* File size */
+        assertEqualMem(e + 76, "symlink\0", 8); /* Name contents */
+        assertEqualMem(e + 84, "file", 4); /* Symlink target. */
+        e += 88;
+    }
+
+    /* "dir" */
+    assert(is_octal(e, 76));
+    assertEqualMem(e + 0, "070707", 6); /* Magic */
+    /* Dev should be same as first entry. */
+    assert(is_octal(e + 6, 6)); /* dev */
+    assertEqualInt(dev, from_octal(e + 6, 6));
+    /* Ino must be different from first entry. */
+    assert(is_octal(e + 12, 6)); /* ino */
+    assert(dev != from_octal(e + 12, 6));
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Group members bits and others bits do not work. */
+    assertEqualMem(e + 18, "040777", 6); /* Mode */
+#else
+    /* Accept 042775 to accomodate systems where sgid bit propagates. */
+    if (memcmp(e + 18, "042775", 6) != 0)
+        assertEqualMem(e + 18, "040775", 6); /* Mode */
+#endif
+    assertEqualInt(from_octal(e + 24, 6), uid); /* uid */
+    /* Gid should be same as first entry. */
+    assert(is_octal(e + 30, 6)); /* gid */
+    assertEqualInt(gid, from_octal(e + 30, 6));
+#ifndef NLINKS_INACCURATE_FOR_DIRS
+    assertEqualMem(e + 36, "000002", 6); /* Nlink */
+#endif
+    t = from_octal(e + 48, 11); /* mtime */
+    assert(t <= now); /* File wasn't created in future. */
+    assert(t >= now - 2); /* File was created w/in last 2 secs. */
+    assertEqualMem(e + 59, "000004", 6); /* Name size */
+    assertEqualMem(e + 65, "00000000000", 11); /* File size */
+    assertEqualMem(e + 76, "dir\0", 4); /* name */
+    e += 80;
+
+    /* TODO: Verify other types of entries. */
+
+    /* Last entry is end-of-archive marker. */
+    assert(is_octal(e, 76));
+    assertEqualMem(e + 0, "070707", 6); /* Magic */
+    assertEqualMem(e + 6, "000000", 6); /* dev */
+    assertEqualMem(e + 12, "000000", 6); /* ino */
+    assertEqualMem(e + 18, "000000", 6); /* Mode */
+    assertEqualMem(e + 24, "000000", 6); /* uid */
+    assertEqualMem(e + 30, "000000", 6); /* gid */
+    assertEqualMem(e + 36, "000001", 6); /* Nlink */
+    assertEqualMem(e + 42, "000000", 6); /* rdev */
+    assertEqualMem(e + 48, "00000000000", 11); /* mtime */
+    assertEqualMem(e + 59, "000013", 6); /* Name size */
+    assertEqualMem(e + 65, "00000000000", 11); /* File size */
+    assertEqualMem(e + 76, "TRAILER!!!\0", 11); /* Name */
+
+    free(p);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_d.c b/Utilities/cmlibarchive/cpio/test/test_option_d.c
new file mode 100644
index 0000000..48e7085
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_d.c
@@ -0,0 +1,64 @@
+/*-
+ * 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_option_d)
+{
+    int r;
+
+    /*
+     * Create a file in a directory.
+     */
+    assertMakeDir("dir", 0755);
+    assertMakeFile("dir/file", 0644, NULL);
+
+    /* Create an archive. */
+    r = systemf("echo dir/file | %s -o > archive.cpio 2>archive.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "archive.err");
+    assertFileSize("archive.cpio", 512);
+
+    /* Dearchive without -d, this should fail. */
+    assertMakeDir("without-d", 0755);
+    assertChdir("without-d");
+    r = systemf("%s -i < ../archive.cpio >out 2>err", testprog);
+    assertEqualInt(r, 0);
+    assertEmptyFile("out");
+    /* And the file should not be restored. */
+    assertFileNotExists("dir/file");
+
+    /* Dearchive with -d, this should succeed. */
+    assertChdir("..");
+    assertMakeDir("with-d", 0755);
+    assertChdir("with-d");
+    r = systemf("%s -id < ../archive.cpio >out 2>err", testprog);
+    assertEqualInt(r, 0);
+    assertEmptyFile("out");
+    assertTextFileContents("1 block\n", "err");
+    /* And the file should be restored. */
+    assertFileExists("dir/file");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_f.c b/Utilities/cmlibarchive/cpio/test/test_option_f.c
new file mode 100644
index 0000000..fa09e85
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_f.c
@@ -0,0 +1,76 @@
+/*-
+ * 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$");
+
+/*
+ * Unpack the archive in a new dir.
+ */
+static void
+unpack(const char *dirname, const char *option)
+{
+    int r;
+
+    assertMakeDir(dirname, 0755);
+    assertChdir(dirname);
+    extract_reference_file("test_option_f.cpio");
+    r = systemf("%s -i %s < test_option_f.cpio > copy-no-a.out 2>copy-no-a.err", testprog, option);
+    assertEqualInt(0, r);
+    assertChdir("..");
+}
+
+DEFINE_TEST(test_option_f)
+{
+    /* Calibrate:  No -f option, so everything should be extracted. */
+    unpack("t0", "--no-preserve-owner");
+    assertFileExists("t0/a123");
+    assertFileExists("t0/a234");
+    assertFileExists("t0/b123");
+    assertFileExists("t0/b234");
+
+    /* Don't extract 'a*' files. */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Single quotes isn't used by command.exe. */
+    unpack("t1", "--no-preserve-owner -f a*");
+#else
+    unpack("t1", "--no-preserve-owner -f 'a*'");
+#endif
+    assertFileNotExists("t1/a123");
+    assertFileNotExists("t1/a234");
+    assertFileExists("t1/b123");
+    assertFileExists("t1/b234");
+
+    /* Don't extract 'b*' files. */
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    /* Single quotes isn't used by command.exe. */
+    unpack("t2", "--no-preserve-owner -f b*");
+#else
+    unpack("t2", "--no-preserve-owner -f 'b*'");
+#endif
+    assertFileExists("t2/a123");
+    assertFileExists("t2/a234");
+    assertFileNotExists("t2/b123");
+    assertFileNotExists("t2/b234");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_f.cpio.uu b/Utilities/cmlibarchive/cpio/test/test_option_f.cpio.uu
new file mode 100644
index 0000000..42c63c3
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_f.cpio.uu
@@ -0,0 +1,16 @@
+$FreeBSD$
+begin 644 test_option_f.cpio
+M,#<P-S`W,#`P,3,Q-C(Q-38Q,3`P-C0T,#`Q-S4P,#`Q-S4P,#`P,#`Q,#`P
+M,#`P,3`W,S4Q,3(U,C8P,#`P,#4P,#`P,#`P,#`P,&$Q,C,`,#<P-S`W,#`P
+M,3,Q-C(Q-38S,3`P-C0T,#`Q-S4P,#`Q-S4P,#`P,#`Q,#`P,#`P,3`W,S4Q
+M,3(U-#`P,#`P,#4P,#`P,#`P,#`P,&$R,S0`,#<P-S`W,#`P,3,Q-C(Q-38R
+M,3`P-C0T,#`Q-S4P,#`Q-S4P,#`P,#`Q,#`P,#`P,3`W,S4Q,3(U,S0P,#`P
+M,#4P,#`P,#`P,#`P,&(Q,C,`,#<P-S`W,#`P,3,Q-C(Q-38T,3`P-C0T,#`Q
+M-S4P,#`Q-S4P,#`P,#`Q,#`P,#`P,3`W,S4Q,3(U-#,P,#`P,#4P,#`P,#`P
+M,#`P,&(R,S0`,#<P-S`W,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P
+M,#`P,#`Q,#`P,#`P,#`P,#`P,#`P,#`P,#`P,3,P,#`P,#`P,#`P,%1204E,
+M15(A(2$`````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_help.c b/Utilities/cmlibarchive/cpio/test/test_option_help.c
new file mode 100644
index 0000000..1b31a5c
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_help.c
@@ -0,0 +1,81 @@
+/*-
+ * 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$");
+
+/*
+ * Test that "--help", "-h", and "-W help" options all work and
+ * generate reasonable output.
+ */
+
+static int
+in_first_line(const char *p, const char *substring)
+{
+    size_t l = strlen(substring);
+
+    while (*p != '\0' && *p != '\n') {
+        if (memcmp(p, substring, l) == 0)
+            return (1);
+        ++p;
+    }
+    return (0);
+}
+
+DEFINE_TEST(test_option_help)
+{
+    int r;
+    char *p;
+    size_t plen;
+
+    /* Exercise --help option. */
+    r = systemf("%s --help >help.stdout 2>help.stderr", testprog);
+    failure("--help should generate nothing to stderr.");
+    assertEmptyFile("help.stderr");
+    /* Help message should start with name of program. */
+    p = slurpfile(&plen, "help.stdout");
+    failure("Help output should be long enough.");
+    assert(plen >= 7);
+    failure("First line of help output should contain string 'bsdcpio'");
+    assert(in_first_line(p, "bsdcpio"));
+    /*
+     * TODO: Extend this check to further verify that --help output
+     * looks approximately right.
+     */
+    free(p);
+
+    /* -h option should generate the same output. */
+    r = systemf("%s -h >h.stdout 2>h.stderr", testprog);
+    failure("-h should generate nothing to stderr.");
+    assertEmptyFile("h.stderr");
+    failure("stdout should be same for -h and --help");
+    assertEqualFile("h.stdout", "help.stdout");
+
+    /* -W help should be another synonym. */
+    r = systemf("%s -W help >Whelp.stdout 2>Whelp.stderr", testprog);
+    failure("-W help should generate nothing to stderr.");
+    assertEmptyFile("Whelp.stderr");
+    failure("stdout should be same for -W help and --help");
+    assertEqualFile("Whelp.stdout", "help.stdout");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_l.c b/Utilities/cmlibarchive/cpio/test/test_option_l.c
new file mode 100644
index 0000000..899478c
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_l.c
@@ -0,0 +1,50 @@
+/*-
+ * 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_option_l)
+{
+    int r;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Copy the file to the "copy" dir. */
+    r = systemf("echo f | %s -pd copy >copy.out 2>copy.err",
+        testprog);
+    assertEqualInt(r, 0);
+
+    /* Check that the copy is a true copy and not a link. */
+    assertIsNotHardlink("f", "copy/f");
+
+    /* Copy the file to the "link" dir with the -l option. */
+    r = systemf("echo f | %s -pld link >link.out 2>link.err",
+        testprog);
+    assertEqualInt(r, 0);
+
+    /* Check that this is a link and not a copy. */
+    assertIsHardlink("f", "link/f");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_lzma.c b/Utilities/cmlibarchive/cpio/test/test_option_lzma.c
new file mode 100644
index 0000000..dc780f1
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_lzma.c
@@ -0,0 +1,56 @@
+/*-
+ * 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_option_lzma)
+{
+    char *p;
+    int r;
+    size_t s;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Archive it with lzma compression. */
+    r = systemf("echo f | %s -o --lzma >archive.out 2>archive.err",
+        testprog);
+    p = slurpfile(&s, "archive.err");
+    p[s] = '\0';
+    if (r != 0) {
+        if (strstr(p, "compression not available") != NULL) {
+            skipping("This version of bsdcpio was compiled "
+                "without lzma support");
+            return;
+        }
+        failure("--lzma option is broken");
+        assertEqualInt(r, 0);
+        return;
+    }
+    /* Check that the archive file has an lzma signature. */
+    p = slurpfile(&s, "archive.out");
+    assert(s > 2);
+    assertEqualMem(p, "\x5d\00\00", 3);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_m.c b/Utilities/cmlibarchive/cpio/test/test_option_m.c
new file mode 100644
index 0000000..870a894
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_m.c
@@ -0,0 +1,63 @@
+/*-
+ * 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_option_m)
+{
+    int r;
+
+    /*
+     * The reference archive has one file with an mtime in 1970, 1
+     * second after the start of the epoch.
+     */
+
+    /* Restored without -m, the result should have a current mtime. */
+    assertMakeDir("without-m", 0755);
+    assertChdir("without-m");
+    extract_reference_file("test_option_m.cpio");
+    r = systemf("%s --no-preserve-owner -i < test_option_m.cpio >out 2>err", testprog);
+    assertEqualInt(r, 0);
+    assertEmptyFile("out");
+    assertTextFileContents("1 block\n", "err");
+    /* Should have been created within the last few seconds. */
+    assertFileMtimeRecent("file");
+
+    /* With -m, it should have an mtime in 1970. */
+    assertChdir("..");
+    assertMakeDir("with-m", 0755);
+    assertChdir("with-m");
+    extract_reference_file("test_option_m.cpio");
+    r = systemf("%s --no-preserve-owner -im < test_option_m.cpio >out 2>err", testprog);
+    assertEqualInt(r, 0);
+    assertEmptyFile("out");
+    assertTextFileContents("1 block\n", "err");
+    /*
+     * mtime in reference archive is '1' == 1 second after
+     * midnight Jan 1, 1970 UTC.
+     */
+    assertFileMtime("file", 1, 0);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_m.cpio.uu b/Utilities/cmlibarchive/cpio/test/test_option_m.cpio.uu
new file mode 100644
index 0000000..3d20023
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_m.cpio.uu
@@ -0,0 +1,16 @@
+$FreeBSD$
+begin 644 test_option_m.cpio
+M,#<P-S`W,#`P,3,Q-#4P,#8T,3`P-C0T,#`Q-S4P,#`Q-S4P,#`P,#`Q,#`P
+M,#`P,#`P,#`P,#`P,#$P,#`P,#4P,#`P,#`P,#`P,&9I;&4`,#<P-S`W,#`P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`Q,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,3,P,#`P,#`P,#`P,%1204E,15(A(2$`````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_t.c b/Utilities/cmlibarchive/cpio/test/test_option_t.c
new file mode 100644
index 0000000..f5e149e
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_t.c
@@ -0,0 +1,95 @@
+/*-
+ * 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_option_t)
+{
+    char *p;
+    int r;
+
+    /* List reference archive, make sure the TOC is correct. */
+    extract_reference_file("test_option_t.cpio");
+    r = systemf("%s -it < test_option_t.cpio >it.out 2>it.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "it.err");
+    extract_reference_file("test_option_t.stdout");
+    p = slurpfile(NULL, "test_option_t.stdout");
+    assertTextFileContents(p, "it.out");
+    free(p);
+
+    /* We accept plain "-t" as a synonym for "-it" */
+    r = systemf("%s -t < test_option_t.cpio >t.out 2>t.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "t.err");
+    extract_reference_file("test_option_t.stdout");
+    p = slurpfile(NULL, "test_option_t.stdout");
+    assertTextFileContents(p, "t.out");
+    free(p);
+
+    /* But "-ot" is an error. */
+    assert(0 != systemf("%s -ot < test_option_t.cpio >ot.out 2>ot.err",
+                testprog));
+    assertEmptyFile("ot.out");
+
+    /* List reference archive verbosely, make sure the TOC is correct. */
+    r = systemf("%s -itv < test_option_t.cpio >tv.out 2>tv.err", testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "tv.err");
+    extract_reference_file("test_option_tv.stdout");
+
+    /* This doesn't work because the usernames on different systems
+     * are different and cpio now looks up numeric UIDs on
+     * the local system. */
+    /* assertEqualFile("tv.out", "test_option_tv.stdout"); */
+
+    /* List reference archive with numeric IDs, verify TOC is correct. */
+    r = systemf("%s -itnv < test_option_t.cpio >itnv.out 2>itnv.err",
+            testprog);
+    assertEqualInt(r, 0);
+    assertTextFileContents("1 block\n", "itnv.err");
+    p = slurpfile(NULL, "itnv.out");
+    /* Since -n uses numeric UID/GID, this part should be the
+     * same on every system. */
+    assertEqualMem(p, "-rw-r--r--   1 1000     1000            0 ",42);
+    /* Date varies depending on local timezone. */
+    if (memcmp(p + 42, "Dec 31  1969", 12) == 0) {
+        /* East of Greenwich we get Dec 31, 1969. */
+    } else {
+        /* West of Greenwich get Jan 1, 1970 */
+        assertEqualMem(p + 42, "Jan ", 4);
+        /* Some systems format "Jan 01", some "Jan  1" */
+        assert(p[46] == ' ' || p[46] == '0');
+        assertEqualMem(p + 47, "1  1970 ", 8);
+    }
+    assertEqualMem(p + 54, " file", 5);
+    free(p);
+
+    /* But "-n" without "-t" is an error. */
+    assert(0 != systemf("%s -in < test_option_t.cpio >in.out 2>in.err",
+                testprog));
+    assertEmptyFile("in.out");
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_t.cpio.uu b/Utilities/cmlibarchive/cpio/test/test_option_t.cpio.uu
new file mode 100644
index 0000000..055fe74
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_t.cpio.uu
@@ -0,0 +1,16 @@
+$FreeBSD$
+begin 644 test_option_t.cpio
+M,#<P-S`W,#`P,3,Q-#4P,#8T,3`P-C0T,#`Q-S4P,#`Q-S4P,#`P,#`Q,#`P
+M,#`P,#`P,#`P,#`P,#$P,#`P,#4P,#`P,#`P,#`P,&9I;&4`,#<P-S`W,#`P
+M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`Q,#`P,#`P,#`P,#`P
+M,#`P,#`P,#`P,3,P,#`P,#`P,#`P,%1204E,15(A(2$`````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+M````````````````````````````````````````````````````````````
+1````````````````````````
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_t.stdout.uu b/Utilities/cmlibarchive/cpio/test/test_option_t.stdout.uu
new file mode 100644
index 0000000..2457706
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_t.stdout.uu
@@ -0,0 +1,5 @@
+$FreeBSD$
+begin 644 test_option_t.stdout
+%9FEL90H`
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_tv.stdout.uu b/Utilities/cmlibarchive/cpio/test/test_option_tv.stdout.uu
new file mode 100644
index 0000000..e28888a
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_tv.stdout.uu
@@ -0,0 +1,6 @@
+$FreeBSD: src/usr.bin/cpio/test/test_option_tv.stdout.uu,v 1.2 2008/11/29 20:22:02 kientzle Exp $
+begin 644 test_option_tv.stdout
+M+7)W+7(M+7(M+2`@(#$@=&EM("`@("`@=&EM("`@("`@("`@("`@(#`@1&5C
+/(#,Q("`Q.38Y(&9I;&4*
+`
+end
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_u.c b/Utilities/cmlibarchive/cpio/test/test_option_u.c
new file mode 100644
index 0000000..f515c9a
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_u.c
@@ -0,0 +1,81 @@
+/*-
+ * 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"
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <sys/utime.h>
+#else
+#include <utime.h>
+#endif
+__FBSDID("$FreeBSD$");
+
+DEFINE_TEST(test_option_u)
+{
+    struct utimbuf times;
+    char *p;
+    size_t s;
+    int r;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Copy the file to the "copy" dir. */
+    r = systemf("echo f | %s -pd copy >copy.out 2>copy.err",
+        testprog);
+    assertEqualInt(r, 0);
+
+    /* Check that the file contains only a single "a" */
+    p = slurpfile(&s, "copy/f");
+    assertEqualInt(s, 1);
+    assertEqualMem(p, "a", 1);
+
+    /* Recreate the file with a single "b" */
+    assertMakeFile("f", 0644, "b");
+
+    /* Set the mtime to the distant past. */
+    memset(&times, 0, sizeof(times));
+    times.actime = 1;
+    times.modtime = 3;
+    assertEqualInt(0, utime("f", &times));
+
+    /* Copy the file to the "copy" dir. */
+    r = systemf("echo f | %s -pd copy >copy.out 2>copy.err",
+        testprog);
+    assertEqualInt(r, 0);
+
+    /* Verify that the file hasn't changed (it wasn't overwritten) */
+    p = slurpfile(&s, "copy/f");
+    assertEqualInt(s, 1);
+    assertEqualMem(p, "a", 1);
+
+    /* Copy the file to the "copy" dir with -u (force) */
+    r = systemf("echo f | %s -pud copy >copy.out 2>copy.err",
+        testprog);
+    assertEqualInt(r, 0);
+
+    /* Verify that the file has changed (it was overwritten) */
+    p = slurpfile(&s, "copy/f");
+    assertEqualInt(s, 1);
+    assertEqualMem(p, "b", 1);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_version.c b/Utilities/cmlibarchive/cpio/test/test_option_version.c
new file mode 100644
index 0000000..f0dc88a
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_version.c
@@ -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$");
+
+/*
+ * Test that --version option works and generates reasonable output.
+ */
+
+static void
+verify(const char *p, size_t s)
+{
+    const char *q = p;
+
+    /* Version message should start with name of program, then space. */
+    failure("version message too short:", p);
+    if (!assert(s > 6))
+        return;
+    failure("Version message should begin with 'bsdcpio': %s", p);
+    if (!assertEqualMem(q, "bsdcpio ", 8))
+        /* If we're not testing bsdcpio, don't keep going. */
+        return;
+    q += 8; s -= 8;
+    /* Version number is a series of digits and periods. */
+    while (s > 0 && (*q == '.' || (*q >= '0' && *q <= '9'))) {
+        ++q;
+        --s;
+    }
+    /* Version number terminated by space. */
+    failure("Version: %s", p);
+    assert(s > 1);
+    /* Skip a single trailing a,b,c, or d. */
+    if (*q == 'a' || *q == 'b' || *q == 'c' || *q == 'd')
+        ++q;
+    failure("Version: %s", p);
+    assert(*q == ' ');
+    ++q; --s;
+    /* Separator. */
+    failure("Version: %s", p);
+    assertEqualMem(q, "-- ", 3);
+    q += 3; s -= 3;
+    /* libarchive name and version number */
+    assert(s > 11);
+    failure("Version: %s", p);
+    assertEqualMem(q, "libarchive ", 11);
+    q += 11; s -= 11;
+    /* Version number is a series of digits and periods. */
+    while (s > 0 && (*q == '.' || (*q >= '0' && *q <= '9'))) {
+        ++q;
+        --s;
+    }
+    /* Skip a single trailing a,b,c, or d. */
+    if (*q == 'a' || *q == 'b' || *q == 'c' || *q == 'd')
+        ++q;
+    /* All terminated by a newline. */
+    assert(s >= 1);
+    failure("Version: %s", p);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    assertEqualMem(q, "\r\n", 2);
+#else
+    assertEqualMem(q, "\n", 1);
+#endif
+}
+
+
+DEFINE_TEST(test_option_version)
+{
+    int r;
+    char *p;
+    size_t s;
+
+    r = systemf("%s --version >version.stdout 2>version.stderr", testprog);
+    if (r != 0)
+        r = systemf("%s -W version >version.stdout 2>version.stderr",
+            testprog);
+    failure("Unable to run either %s --version or %s -W version",
+        testprog, testprog);
+    if (!assert(r == 0))
+        return;
+
+    /* --version should generate nothing to stderr. */
+    assertEmptyFile("version.stderr");
+    /* Verify format of version message. */
+    p = slurpfile(&s, "version.stdout");
+    verify(p, s);
+    free(p);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_y.c b/Utilities/cmlibarchive/cpio/test/test_option_y.c
new file mode 100644
index 0000000..934cd90
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_y.c
@@ -0,0 +1,57 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_option_y.c,v 1.2 2008/08/24 06:21:00 kientzle Exp $");
+
+DEFINE_TEST(test_option_y)
+{
+    char *p;
+    int r;
+    size_t s;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Archive it with bzip2 compression. */
+    r = systemf("echo f | %s -oy >archive.out 2>archive.err",
+        testprog);
+    p = slurpfile(&s, "archive.err");
+    p[s] = '\0';
+    if (r != 0) {
+        if (strstr(p, "compression not available") != NULL) {
+            skipping("This version of bsdcpio was compiled "
+                "without bzip2 support");
+            return;
+        }
+        failure("-y option is broken");
+        assertEqualInt(r, 0);
+        return;
+    }
+    assertTextFileContents("1 block\n", "archive.err");
+    /* Check that the archive file has a bzip2 signature. */
+    p = slurpfile(&s, "archive.out");
+    assert(s > 2);
+    assertEqualMem(p, "BZh9", 4);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_option_z.c b/Utilities/cmlibarchive/cpio/test/test_option_z.c
new file mode 100644
index 0000000..0d7c148
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_option_z.c
@@ -0,0 +1,56 @@
+/*-
+ * 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_option_z)
+{
+    char *p;
+    int r;
+    size_t s;
+
+    /* Create a file. */
+    assertMakeFile("f", 0644, "a");
+
+    /* Archive it with gzip compression. */
+    r = systemf("echo f | %s -oz >archive.out 2>archive.err",
+        testprog);
+    p = slurpfile(&s, "archive.err");
+    p[s] = '\0';
+    if (r != 0) {
+        if (strstr(p, "compression not available") != NULL) {
+            skipping("This version of bsdcpio was compiled "
+                "without gzip support");
+            return;
+        }
+        failure("-z option is broken");
+        assertEqualInt(r, 0);
+        return;
+    }
+    /* Check that the archive file has a gzip signature. */
+    p = slurpfile(&s, "archive.out");
+    assert(s > 4);
+    assertEqualMem(p, "\x1f\x8b\x08\x00", 4);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_owner_parse.c b/Utilities/cmlibarchive/cpio/test/test_owner_parse.c
new file mode 100644
index 0000000..9bdb4d9
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_owner_parse.c
@@ -0,0 +1,121 @@
+/*-
+ * 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$");
+
+#include "../cpio.h"
+#include "err.h"
+
+#if !defined(_WIN32)
+#define ROOT "root"
+static int root_uids[] = { 0 };
+static int root_gids[] = { 0 };
+#elif defined(__CYGWIN__)
+/* On cygwin, the Administrator user most likely exists (unless
+ * it has been renamed or is in a non-English localization), but
+ * its primary group membership depends on how the user set up
+ * their /etc/passwd. Likely values are 513 (None), 545 (Users),
+ * or 544 (Administrators). Just check for one of those...
+ * TODO: Handle non-English localizations...e.g. French 'Administrateur'
+ *       Use CreateWellKnownSID() and LookupAccountName()?
+ */
+#define ROOT "Administrator"
+static int root_uids[] = { 500 };
+static int root_gids[] = { 513, 545, 544 };
+#endif
+
+#if defined(ROOT)
+static int
+int_in_list(int i, int *l, size_t n)
+{
+    while (n-- > 0)
+        if (*l++ == i)
+            return (1);
+    failure("%d", i);
+    return (0);
+}
+#endif
+
+DEFINE_TEST(test_owner_parse)
+{
+#if !defined(ROOT)
+    skipping("No uid/gid configuration for this OS");
+#else
+    int uid, gid;
+
+    assert(NULL == owner_parse(ROOT, &uid, &gid));
+    assert(int_in_list(uid, root_uids,
+        sizeof(root_uids)/sizeof(root_uids[0])));
+    assertEqualInt(-1, gid);
+
+
+    assert(NULL == owner_parse(ROOT ":", &uid, &gid));
+    assert(int_in_list(uid, root_uids,
+        sizeof(root_uids)/sizeof(root_uids[0])));
+    assert(int_in_list(gid, root_gids,
+        sizeof(root_gids)/sizeof(root_gids[0])));
+
+    assert(NULL == owner_parse(ROOT ".", &uid, &gid));
+    assert(int_in_list(uid, root_uids,
+        sizeof(root_uids)/sizeof(root_uids[0])));
+    assert(int_in_list(gid, root_gids,
+        sizeof(root_gids)/sizeof(root_gids[0])));
+
+    assert(NULL == owner_parse("111", &uid, &gid));
+    assertEqualInt(111, uid);
+    assertEqualInt(-1, gid);
+
+    assert(NULL == owner_parse("112:", &uid, &gid));
+    assertEqualInt(112, uid);
+    /* Can't assert gid, since we don't know gid for user #112. */
+
+    assert(NULL == owner_parse("113.", &uid, &gid));
+    assertEqualInt(113, uid);
+    /* Can't assert gid, since we don't know gid for user #113. */
+
+    assert(NULL == owner_parse(":114", &uid, &gid));
+    assertEqualInt(-1, uid);
+    assertEqualInt(114, gid);
+
+    assert(NULL == owner_parse(".115", &uid, &gid));
+    assertEqualInt(-1, uid);
+    assertEqualInt(115, gid);
+
+    assert(NULL == owner_parse("116:117", &uid, &gid));
+    assertEqualInt(116, uid);
+    assertEqualInt(117, gid);
+
+    /*
+     * TODO: Lookup current user/group name, build strings and
+     * use those to verify username/groupname lookups for ordinary
+     * users.
+     */
+
+    assert(NULL != owner_parse(":nonexistentgroup", &uid, &gid));
+    assert(NULL != owner_parse(ROOT ":nonexistentgroup", &uid, &gid));
+    assert(NULL !=
+        owner_parse("nonexistentuser:nonexistentgroup", &uid, &gid));
+#endif
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_passthrough_dotdot.c b/Utilities/cmlibarchive/cpio/test/test_passthrough_dotdot.c
new file mode 100644
index 0000000..a81e148
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_passthrough_dotdot.c
@@ -0,0 +1,76 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_passthrough_dotdot.c,v 1.4 2008/08/24 06:21:00 kientzle Exp $");
+
+/*
+ * Verify that "cpio -p .." works.
+ */
+
+DEFINE_TEST(test_passthrough_dotdot)
+{
+    int r;
+    FILE *filelist;
+
+    assertUmask(0);
+
+    /*
+     * Create an assortment of files on disk.
+     */
+    filelist = fopen("filelist", "w");
+
+    /* Directory. */
+    assertMakeDir("dir", 0755);
+    assertChdir("dir");
+
+    fprintf(filelist, ".\n");
+
+    /* File with 10 bytes content. */
+    assertMakeFile("file", 0642, "1234567890");
+    fprintf(filelist, "file\n");
+
+    /* All done. */
+    fclose(filelist);
+
+
+    /*
+     * Use cpio passthrough mode to copy files to another directory.
+     */
+    r = systemf("%s -pdvm .. <../filelist >../stdout 2>../stderr",
+        testprog);
+    failure("Error invoking %s -pd ..", testprog);
+    assertEqualInt(r, 0);
+
+    assertChdir("..");
+
+    /* Verify stderr and stdout. */
+    assertTextFileContents("../.\n../file\n1 block\n", "stderr");
+    assertEmptyFile("stdout");
+
+    /* Regular file. */
+    assertIsReg("file", 0642);
+    assertFileSize("file", 10);
+    assertFileNLinks("file", 1);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_passthrough_reverse.c b/Utilities/cmlibarchive/cpio/test/test_passthrough_reverse.c
new file mode 100644
index 0000000..86d70a6
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_passthrough_reverse.c
@@ -0,0 +1,85 @@
+/*-
+ * 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: src/usr.bin/cpio/test/test_passthrough_reverse.c,v 1.2 2008/08/24 06:21:00 kientzle Exp $");
+
+/*
+ * As reported by Bernd Walter:  Some people are in the habit of
+ * using "find -d" to generate a list for cpio -p because that
+ * copies the top-level dir last, which preserves owner and mode
+ * information.  That's not necessary for bsdcpio (libarchive defers
+ * restoring directory information), but bsdcpio should still generate
+ * the correct results with this usage.
+ */
+
+DEFINE_TEST(test_passthrough_reverse)
+{
+    int r;
+    FILE *filelist;
+
+    assertUmask(0);
+
+    /*
+     * Create an assortment of files on disk.
+     */
+    filelist = fopen("filelist", "w");
+
+    /* Directory. */
+    assertMakeDir("dir", 0743);
+
+    /* File with 10 bytes content. */
+    assertMakeFile("dir/file", 0644, "1234567890");
+    fprintf(filelist, "dir/file\n");
+
+    /* Write dir last. */
+    fprintf(filelist, "dir\n");
+
+    /* All done. */
+    fclose(filelist);
+
+
+    /*
+     * Use cpio passthrough mode to copy files to another directory.
+     */
+    r = systemf("%s -pdvm out <filelist >stdout 2>stderr", testprog);
+    failure("Error invoking %s -pd out", testprog);
+    assertEqualInt(r, 0);
+
+    assertChdir("out");
+
+    /* Verify stderr and stdout. */
+    assertTextFileContents("out/dir/file\nout/dir\n1 block\n",
+        "../stderr");
+    assertEmptyFile("../stdout");
+
+    /* dir */
+    assertIsDir("dir", 0743);
+
+
+    /* Regular file. */
+    assertIsReg("dir/file", 0644);
+    assertFileSize("dir/file", 10);
+    assertFileNLinks("dir/file", 1);
+}
diff --git a/Utilities/cmlibarchive/cpio/test/test_pathmatch.c b/Utilities/cmlibarchive/cpio/test/test_pathmatch.c
new file mode 100644
index 0000000..12b8886
--- /dev/null
+++ b/Utilities/cmlibarchive/cpio/test/test_pathmatch.c
@@ -0,0 +1,243 @@
+/*-
+ * Copyright (c) 2003-2007 Tim Kientzle
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "test.h"
+__FBSDID("$FreeBSD$");
+
+#include "pathmatch.h"
+
+/*
+ * Verify that the pattern matcher implements the wildcard logic specified
+ * in SUSv2 for the cpio command.  This is essentially the
+ * shell glob syntax:
+ *   * - matches any sequence of chars, including '/'
+ *   ? - matches any single char, including '/'
+ *   [...] - matches any of a set of chars, '-' specifies a range,
+ *        initial '!' is undefined
+ *
+ * The specification in SUSv2 is a bit incomplete, I assume the following:
+ *   Trailing '-' in [...] is not special.
+ *
+ * TODO: Figure out if there's a good way to extend this to handle
+ * Windows paths that use '\' as a path separator.  <sigh>
+ */
+
+DEFINE_TEST(test_pathmatch)
+{
+    assertEqualInt(1, lafe_pathmatch("a/b/c", "a/b/c", 0));
+    assertEqualInt(0, lafe_pathmatch("a/b/", "a/b/c", 0));
+    assertEqualInt(0, lafe_pathmatch("a/b", "a/b/c", 0));
+    assertEqualInt(0, lafe_pathmatch("a/b/c", "a/b/", 0));
+    assertEqualInt(0, lafe_pathmatch("a/b/c", "a/b", 0));
+
+    /* Empty pattern only matches empty string. */
+    assertEqualInt(1, lafe_pathmatch("","", 0));
+    assertEqualInt(0, lafe_pathmatch("","a", 0));
+    assertEqualInt(1, lafe_pathmatch("*","", 0));
+    assertEqualInt(1, lafe_pathmatch("*","a", 0));
+    assertEqualInt(1, lafe_pathmatch("*","abcd", 0));
+    /* SUSv2: * matches / */
+    assertEqualInt(1, lafe_pathmatch("*","abcd/efgh/ijkl", 0));
+    assertEqualInt(1, lafe_pathmatch("abcd*efgh/ijkl","abcd/efgh/ijkl", 0));
+    assertEqualInt(1, lafe_pathmatch("abcd***efgh/ijkl","abcd/efgh/ijkl", 0));
+    assertEqualInt(1, lafe_pathmatch("abcd***/efgh/ijkl","abcd/efgh/ijkl", 0));
+    assertEqualInt(0, lafe_pathmatch("?", "", 0));
+    assertEqualInt(0, lafe_pathmatch("?", "\0", 0));
+    assertEqualInt(1, lafe_pathmatch("?", "a", 0));
+    assertEqualInt(0, lafe_pathmatch("?", "ab", 0));
+    assertEqualInt(1, lafe_pathmatch("?", ".", 0));
+    assertEqualInt(1, lafe_pathmatch("?", "?", 0));
+    assertEqualInt(1, lafe_pathmatch("a", "a", 0));
+    assertEqualInt(0, lafe_pathmatch("a", "ab", 0));
+    assertEqualInt(0, lafe_pathmatch("a", "ab", 0));
+    assertEqualInt(1, lafe_pathmatch("a?c", "abc", 0));
+    /* SUSv2: ? matches / */
+    assertEqualInt(1, lafe_pathmatch("a?c", "a/c", 0));
+    assertEqualInt(1, lafe_pathmatch("a?*c*", "a/c", 0));
+    assertEqualInt(1, lafe_pathmatch("*a*", "a/c", 0));
+    assertEqualInt(1, lafe_pathmatch("*a*", "/a/c", 0));
+    assertEqualInt(1, lafe_pathmatch("*a*", "defaaaaaaa", 0));
+    assertEqualInt(0, lafe_pathmatch("a*", "defghi", 0));
+    assertEqualInt(0, lafe_pathmatch("*a*", "defghi", 0));
+
+    /* Character classes */
+    assertEqualInt(1, lafe_pathmatch("abc[def", "abc[def", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[def]", "abc[def", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[def", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[def]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[def]", "abce", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[def]", "abcf", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[def]", "abcg", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d*f]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d*f]", "abc*", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d*f]", "abcdefghi", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d*", "abcdefghi", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d*", "abc[defghi", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-f]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-f]", "abce", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-f]", "abcf", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d-f]", "abcg", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d-fh-k]", "abca", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abce", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abcf", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d-fh-k]", "abcg", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abch", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abci", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abcj", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-k]", "abck", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d-fh-k]", "abcl", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d-fh-k]", "abc-", 0));
+
+    /* [] matches nothing, [!] is the same as ? */
+    assertEqualInt(0, lafe_pathmatch("abc[]efg", "abcdefg", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[]efg", "abcqefg", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[]efg", "abcefg", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!]efg", "abcdefg", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!]efg", "abcqefg", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[!]efg", "abcefg", 0));
+
+    /* I assume: Trailing '-' is non-special. */
+    assertEqualInt(0, lafe_pathmatch("abc[d-fh-]", "abcl", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-]", "abch", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-]", "abc-", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-fh-]", "abc-", 0));
+
+    /* ']' can be backslash-quoted within a character class. */
+    assertEqualInt(1, lafe_pathmatch("abc[\\]]", "abc]", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[\\]d]", "abc]", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[\\]d]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d\\]]", "abc]", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d\\]]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d]e]", "abcde]", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d\\]e]", "abc]", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d\\]e]", "abcd]e", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[d]e]", "abc]", 0));
+
+    /* backslash-quoted chars can appear as either end of a range. */
+    assertEqualInt(1, lafe_pathmatch("abc[\\d-f]gh", "abcegh", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[\\d-f]gh", "abcggh", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[\\d-f]gh", "abc\\gh", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d-\\f]gh", "abcegh", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[\\d-\\f]gh", "abcegh", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[\\d-\\f]gh", "abcegh", 0));
+    /* backslash-quoted '-' isn't special. */
+    assertEqualInt(0, lafe_pathmatch("abc[d\\-f]gh", "abcegh", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[d\\-f]gh", "abc-gh", 0));
+
+    /* Leading '!' negates a character class. */
+    assertEqualInt(0, lafe_pathmatch("abc[!d]", "abcd", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!d]", "abce", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!d]", "abcc", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[!d-z]", "abcq", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!d-gi-z]", "abch", 0));
+    assertEqualInt(1, lafe_pathmatch("abc[!fgijkl]", "abch", 0));
+    assertEqualInt(0, lafe_pathmatch("abc[!fghijkl]", "abch", 0));
+
+    /* Backslash quotes next character. */
+    assertEqualInt(0, lafe_pathmatch("abc\\[def]", "abc\\d", 0));
+    assertEqualInt(1, lafe_pathmatch("abc\\[def]", "abc[def]", 0));
+    assertEqualInt(0, lafe_pathmatch("abc\\\\[def]", "abc[def]", 0));
+    assertEqualInt(0, lafe_pathmatch("abc\\\\[def]", "abc\\[def]", 0));
+    assertEqualInt(1, lafe_pathmatch("abc\\\\[def]", "abc\\d", 0));
+    assertEqualInt(1, lafe_pathmatch("abcd\\", "abcd\\", 0));
+    assertEqualInt(0, lafe_pathmatch("abcd\\", "abcd\\[", 0));
+    assertEqualInt(0, lafe_pathmatch("abcd\\", "abcde", 0));
+    assertEqualInt(0, lafe_pathmatch("abcd\\[", "abcd\\", 0));
+
+    /*
+     * Because '.' and '/' have special meanings, we can
+     * identify many equivalent paths even if they're expressed
+     * differently.  (But quoting a character with '\\' suppresses
+     * special meanings!)
+     */
+    assertEqualInt(0, lafe_pathmatch("a/b/", "a/bc", 0));
+    assertEqualInt(1, lafe_pathmatch("a/./b", "a/b", 0));
+    assertEqualInt(0, lafe_pathmatch("a\\/./b", "a/b", 0));
+    assertEqualInt(0, lafe_pathmatch("a/\\./b", "a/b", 0));
+    assertEqualInt(0, lafe_pathmatch("a/.\\/b", "a/b", 0));
+    assertEqualInt(0, lafe_pathmatch("a\\/\\.\\/b", "a/b", 0));
+    assertEqualInt(1, lafe_pathmatch("./abc/./def/", "abc/def/", 0));
+    assertEqualInt(1, lafe_pathmatch("abc/def", "./././abc/./def", 0));
+    assertEqualInt(1, lafe_pathmatch("abc/def/././//", "./././abc/./def/", 0));
+    assertEqualInt(1, lafe_pathmatch(".////abc/.//def", "./././abc/./def", 0));
+    assertEqualInt(1, lafe_pathmatch("./abc?def/", "abc/def/", 0));
+    failure("\"?./\" is not the same as \"/./\"");
+    assertEqualInt(0, lafe_pathmatch("./abc?./def/", "abc/def/", 0));
+    failure("Trailing '/' should match no trailing '/'");
+    assertEqualInt(1, lafe_pathmatch("./abc/./def/", "abc/def", 0));
+    failure("Trailing '/./' is still the same directory.");
+    assertEqualInt(1, lafe_pathmatch("./abc/./def/./", "abc/def", 0));
+    failure("Trailing '/.' is still the same directory.");
+    assertEqualInt(1, lafe_pathmatch("./abc/./def/.", "abc/def", 0));
+    assertEqualInt(1, lafe_pathmatch("./abc/./def", "abc/def/", 0));
+    failure("Trailing '/./' is still the same directory.");
+    assertEqualInt(1, lafe_pathmatch("./abc/./def", "abc/def/./", 0));
+    failure("Trailing '/.' is still the same directory.");
+    assertEqualInt(1, lafe_pathmatch("./abc*/./def", "abc/def/.", 0));
+
+    /* Matches not anchored at beginning. */
+    assertEqualInt(0,
+        lafe_pathmatch("bcd", "abcd", PATHMATCH_NO_ANCHOR_START));
+    assertEqualInt(1,
+        lafe_pathmatch("abcd", "abcd", PATHMATCH_NO_ANCHOR_START));
+    assertEqualInt(0,
+        lafe_pathmatch("^bcd", "abcd", PATHMATCH_NO_ANCHOR_START));
+    assertEqualInt(1,
+        lafe_pathmatch("b/c/d", "a/b/c/d", PATHMATCH_NO_ANCHOR_START));
+    assertEqualInt(0,
+        lafe_pathmatch("b/c", "a/b/c/d", PATHMATCH_NO_ANCHOR_START));
+    assertEqualInt(0,
+        lafe_pathmatch("^b/c", "a/b/c/d", PATHMATCH_NO_ANCHOR_START));
+
+    /* Matches not anchored at end. */
+    assertEqualInt(0,
+        lafe_pathmatch("bcd", "abcd", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("abcd", "abcd", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("abcd", "abcd/", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("abcd", "abcd/.", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(0,
+        lafe_pathmatch("abc", "abcd", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c", "a/b/c/d", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(0,
+        lafe_pathmatch("a/b/c$", "a/b/c/d", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c$", "a/b/c", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c$", "a/b/c/", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c/", "a/b/c/d", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(0,
+        lafe_pathmatch("a/b/c/$", "a/b/c/d", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c/$", "a/b/c/", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(1,
+        lafe_pathmatch("a/b/c/$", "a/b/c", PATHMATCH_NO_ANCHOR_END));
+    assertEqualInt(0,
+        lafe_pathmatch("b/c", "a/b/c/d", PATHMATCH_NO_ANCHOR_END));
+}