cedar: 4.3.0 -> 4.3.1 (#379286)

[NixPkgs.git] / pkgs / by-name / xa / xar / patches / 0001-Update-tests-for-Python-3-and-Nix-sandbox.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Ivan Trubach <mr.trubach@icloud.com>
Date: Sat, 27 Jul 2024 12:53:54 +0300
Subject: [PATCH 01/19] Update tests for Python 3 and Nix sandbox

This change updates integration tests for Python 3 and fixes some
assumptions to work under Nix sandbox (in particular, extended
attributes are not allowed).

Also updates xar/test/validate.c for modern OpenSSL versions.
---
 xar/test/attr.py        | 54 +++++++++++++++++++-------
 xar/test/buffer.c       |  3 +-
 xar/test/checksums.py   | 75 +++++++++++++++++++-----------------
 xar/test/compression.py | 27 ++++++++-----
 xar/test/data.py        | 19 +++++----
 xar/test/hardlink.py    | 12 ++++--
 xar/test/heap.py        | 27 +++++++------
 xar/test/integrity.py   | 45 ++++++++++++----------
 xar/test/run-all.py     | 25 ++++++++++++
 xar/test/util.py        | 85 ++++++++++++++++++++++++++++++++++++-----
 xar/test/validate.c     | 32 +++++++++-------
 11 files changed, 282 insertions(+), 122 deletions(-)
 create mode 100755 xar/test/run-all.py

diff --git a/xar/test/attr.py b/xar/test/attr.py
index adc2c56..c28a4e6 100755
--- a/xar/test/attr.py
+++ b/xar/test/attr.py
@@ -6,6 +6,7 @@ import os
 import os.path
 import shutil
 import subprocess
+import sys
 import xattr
 
 import util
@@ -26,20 +27,27 @@ import util
 class MissingExtendedAttributeError(AssertionError):
        pass
 
-def _random_big_data(bytes=65536, path="/dev/random"):
+def _random_big_data(bytes=65536):
        """
        Returns a random string with the number of bytes requested. Due to xar
        implementation details, this should be greater than 4096 (32768 for
        compressed heap testing).
        
        """
-       with open(path, "r") as f:
-               return f.read(bytes)
+       return os.urandom(bytes)
+
+def _to_bytes(s):
+       if isinstance(s, str):
+               return s.encode("utf-8")
+       return s
 
 def _test_xattr_on_file_with_contents(filename, file_contents, xattrs=[], xar_create_flags=[], xar_extract_flags=[]):
+       file_contents = _to_bytes(file_contents)
+       xattr_prefix = "user." if sys.platform != "darwin" else ""
+       xattrs = [(xattr_prefix + k, _to_bytes(v)) for k, v in xattrs]
        try:
                # Write file out
-               with open(filename, "w") as f:
+               with open(filename, "wb") as f:
                        f.write(file_contents)
                        for (key, value) in xattrs:
                                xattr.setxattr(f, key, value)
@@ -51,14 +59,16 @@ def _test_xattr_on_file_with_contents(filename, file_contents, xattrs=[], xar_cr
                        with util.directory_created("extracted") as directory:
                                # Validate resulting xattrs
                                subprocess.check_call(["xar", "-x", "-C", directory, "-f", path] + xar_extract_flags)
+                               extracted_filename = os.path.join(directory, filename)
+                               expected_set = {key for key, _ in xattrs}
+                               actual_set = set(xattr.listxattr(os.path.join(directory, filename)))
+                               for key in expected_set - actual_set:
+                                       raise MissingExtendedAttributeError("extended attribute \"{n}\" missing after extraction".format(n=key))
                                for (key, value) in xattrs:
-                                       try:
-                                               assert xattr.getxattr(os.path.join(directory, filename), key) == value, "extended attribute \"{n}\" has incorrect contents after extraction".format(n=key)
-                                       except KeyError:
-                                               raise MissingExtendedAttributeError("extended attribute \"{n}\" missing after extraction".format(n=key))
+                                       assert xattr.getxattr(extracted_filename, key) == value, "extended attribute \"{n}\" has incorrect contents after extraction".format(n=key)
                                
                                # Validate file contents
-                               with open(os.path.join(directory, filename), "r") as f:
+                               with open(os.path.join(directory, filename), "rb") as f:
                                        if f.read() != file_contents:
                                                raise MissingExtendedAttributeError("archived file \"{f}\" has has incorrect contents after extraction".format(f=filename))
        finally:
@@ -73,36 +83,47 @@ def _test_xattr_on_file_with_contents(filename, file_contents, xattrs=[], xar_cr
 #       tests are commented out awaiting a day when this might be different.
 
 # def empty_xattr_empty_file(filename):
+#      util.skip_if_no_xattrs_support()
 #      _test_xattr_on_file_with_contents(filename, "", xattrs=[("foo", "")])
 
 def small_xattr_empty_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, "", xattrs=[("foo", "1234")])
 
 def large_xattr_empty_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, "", xattrs=[("foo", _random_big_data(5000))])
 
 # def empty_xattr_small_file(filename):
+#      util.skip_if_no_xattrs_support()
 #      _test_xattr_on_file_with_contents(filename, "small.file.contents", xattrs=[("foo", "")])
 
 def small_xattr_small_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, "small.file.contents", xattrs=[("foo", "1234")])
 
 def large_xattr_small_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, "small.file.contents", xattrs=[("foo", _random_big_data(4567))])
 
 # def empty_xattr_large_file(filename):
+#      util.skip_if_no_xattrs_support()
 #      _test_xattr_on_file_with_contents(filename, _random_big_data(10000000), xattrs=[("foo", "")])
 
 def small_xattr_large_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, _random_big_data(5000000), xattrs=[("foo", "1234")])
 
 def large_xattr_large_file(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, _random_big_data(9876543), xattrs=[("foo", _random_big_data(6543))])
 
 def multiple_xattrs(filename):
+       util.skip_if_no_xattrs_support()
        _test_xattr_on_file_with_contents(filename, "", xattrs=[("foo", "bar"), ("baz", "1234"), ("quux", "more")]) # ("empty", "")
 
 def distribution_create(filename):
+       util.skip_if_no_xattrs_support()
        try:
                _test_xattr_on_file_with_contents(filename, "dummy", xattrs=[("foo", "bar")], xar_create_flags=["--distribution"])
        except MissingExtendedAttributeError:
@@ -114,6 +135,7 @@ def distribution_create(filename):
 #       when it can.
 
 # def distribution_extract(filename):
+#      util.skip_if_no_xattrs_support()
 #      try:
 #              _test_xattr_on_file_with_contents(filename, "dummy", xattrs=[("foo", "bar")], xar_extract_flags=["--distribution"])
 #      except MissingExtendedAttributeError:
@@ -128,12 +150,18 @@ TEST_CASES = (small_xattr_empty_file, large_xattr_empty_file,
               multiple_xattrs, distribution_create)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case(case.func_name)
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case(func_name)
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
+               except util.TestCaseSkipError as e:
+                       print("SKIPPED: {f}: {m}".format(f=func_name, m=e))
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/buffer.c b/xar/test/buffer.c
index a353cef..e4c5639 100644
--- a/xar/test/buffer.c
+++ b/xar/test/buffer.c
@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <sys/stat.h>
 #include <sys/fcntl.h>
 #include <string.h>
@@ -50,7 +51,7 @@ int main(int argc, char *argv[])
        if( red < sb.st_size )
                fprintf(stderr, "Incomplete read\n");
 
-       x = xar_open("/tmp/test.xar", WRITE);
+       x = xar_open("test.xar", WRITE);
        if( x == NULL ) {
                fprintf(stderr, "Error creating xarchive\n");
                exit(6);
diff --git a/xar/test/checksums.py b/xar/test/checksums.py
index 7080d7c..0f39e63 100755
--- a/xar/test/checksums.py
+++ b/xar/test/checksums.py
@@ -2,6 +2,7 @@
 
 from __future__ import print_function
 
+import contextlib
 import hashlib
 import os
 import os.path
@@ -9,6 +10,7 @@ import re
 import shutil
 import struct
 import subprocess
+import sys
 
 import util
 
@@ -17,15 +19,21 @@ import util
 # Utility Functions
 # 
 
+@contextlib.contextmanager
+def _test_archive_created(filename, directory, *args, **kwargs):
+       with util.test_directory_created(directory) as test_directory:
+               with util.archive_created(filename, test_directory, *args, **kwargs) as path:
+                       yield path
+
 def _get_numeric_value_from_header(archive_name, key):
        """
        Dumps the header of the specified xar archive and extracts the header
        size from the output, in bytes.
        
        """
-       header = subprocess.check_output(["xar", "--dump-header", "-f", archive_name])
+       header = subprocess.check_output(["xar", "--dump-header", "-f", archive_name], text=True)
        for line in header.splitlines():
-               matchdata = re.match("^(.+):\s+(.+)$", line) # magic: 0x78617221 (OK)
+               matchdata = re.match(r"^(.+):\s+(.+)$", line) # magic: 0x78617221 (OK)
                assert matchdata, "unexpected output from `xar --dump-header`:\n{h}".format(h=header)
                if matchdata.groups()[0] == key:
                        return int(matchdata.groups()[1])
@@ -38,17 +46,14 @@ def _get_toc_size(archive_name):
        return _get_numeric_value_from_header(archive_name, "Compressed TOC length")
 
 def _clobber_bytes_at(clobber_range, path):
-       with open(path, "r+") as f:
+       with open(path, "rb+") as f:
                f.seek(clobber_range[0])
-               with open("/dev/random", "r") as r:
-                       random_bytes = r.read(len(clobber_range))
-                       f.write(random_bytes)
+               f.write(os.urandom(len(clobber_range)))
 
 def _verify_extraction_failed(filename):
        with util.directory_created("extracted") as directory:
                try:
-                       with open("/dev/null", "w") as n:
-                               returncode = subprocess.call(["xar", "-x", "-C", directory, "-f", filename], stdout=n, stderr=n)
+                       returncode = subprocess.call(["xar", "-x", "-C", directory, "-f", filename], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                        assert returncode != 0, "xar reported success extracting an archive with a broken TOC"
                finally:
                        if os.path.exists(directory):
@@ -63,7 +68,7 @@ def _verify_header_checksum(filename, algorithm):
        header_size = _get_header_size(filename)
        toc_length = _get_toc_size(filename)
        
-       with open(filename, "r") as f:
+       with open(filename, "rb") as f:
                f.seek(header_size)
                h = hashlib.new(algorithm, f.read(toc_length))
                computed_digest = h.digest()
@@ -76,23 +81,23 @@ def _verify_header_checksum(filename, algorithm):
 # 
 
 def default_toc_checksum_validity(filename):
-       with util.archive_created(filename, "/bin") as path:
+       with _test_archive_created(filename, "testdir") as path:
                _verify_header_checksum(path, "sha1")
 
 def sha1_toc_checksum_validity(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha1") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha1") as path:
                _verify_header_checksum(path, "sha1")
 
 def sha256_toc_checksum_validity(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha256") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha256") as path:
                _verify_header_checksum(path, "sha256")
 
 def sha512_toc_checksum_validity(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha512") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha512") as path:
                _verify_header_checksum(path, "sha512")
 
 def broken_toc_default_checksum(filename):
-       with util.archive_created(filename, "/bin") as path:
+       with _test_archive_created(filename, "testdir") as path:
                # Mess up the archive
                toc_start = _get_header_size(path)
                _clobber_bytes_at(range(toc_start + 4, toc_start + 4 + 100), path) # Why did the original test specify 4? No idea.
@@ -101,7 +106,7 @@ def broken_toc_default_checksum(filename):
                _verify_extraction_failed(filename)
                
 def broken_toc_sha1_checksum(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha1") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha1") as path:
                # Mess up the archive
                toc_start = _get_header_size(path)
                _clobber_bytes_at(range(toc_start + 4, toc_start + 4 + 100), path) # Why did the original test specify 4? No idea.
@@ -110,7 +115,7 @@ def broken_toc_sha1_checksum(filename):
                _verify_extraction_failed(filename)
 
 def broken_toc_sha256_checksum(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha256") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha256") as path:
                # Mess up the archive
                toc_start = _get_header_size(path)
                _clobber_bytes_at(range(toc_start + 4, toc_start + 4 + 100), path) # Why did the original test specify 4? No idea.
@@ -119,7 +124,7 @@ def broken_toc_sha256_checksum(filename):
                _verify_extraction_failed(filename)
 
 def broken_toc_sha512_checksum(filename):
-       with util.archive_created(filename, "/bin", "--toc-cksum", "sha512") as path:
+       with _test_archive_created(filename, "testdir", "--toc-cksum", "sha512") as path:
                # Mess up the archive
                toc_start = _get_header_size(path)
                _clobber_bytes_at(range(toc_start + 4, toc_start + 4 + 100), path) # Why did the original test specify 4? No idea.
@@ -128,7 +133,7 @@ def broken_toc_sha512_checksum(filename):
                _verify_extraction_failed(filename)
 
 def broken_heap_default_checksum(filename):
-       with util.archive_created(filename, "/bin") as path:
+       with _test_archive_created(filename, "testdir") as path:
                # Mess up the archive
                toc_start = _get_header_size(path)
                toc_size = _get_toc_size(path)
@@ -139,11 +144,11 @@ def broken_heap_default_checksum(filename):
                _verify_extraction_failed(filename)
 
 def default_checksum_algorithm(filename):
-       with util.archive_created(filename, "/bin") as path:
-               header = subprocess.check_output(["xar", "--dump-header", "-f", path])
+       with _test_archive_created(filename, "testdir") as path:
+               header = subprocess.check_output(["xar", "--dump-header", "-f", path], text=True)
                found = False
                for line in header.splitlines():
-                       matchdata = re.match("^Checksum algorithm:\s+(\d+)\s+\\((\w+)\\)$", line)
+                       matchdata = re.match(r"^Checksum algorithm:\s+(\d+)\s+\((\w+)\)$", line)
                        if not matchdata:
                                continue
                        found = True
@@ -156,7 +161,7 @@ def default_checksum_algorithm(filename):
 # 
 # def invalid_checksum_algorithm(filename):
 #      try:
-#              with util.archive_created(filename, "/bin", "--toc-cksum", "invalid-algorithm") as path:
+#              with _test_archive_created(filename, "testdir", "--toc-cksum", "invalid-algorithm") as path:
 #                      raise AssertionError("xar succeeded when it should have failed")
 #      except subprocess.CalledProcessError:
 #              pass
@@ -164,17 +169,15 @@ def default_checksum_algorithm(filename):
 # It does fail for md5 explicitly, however
 def md5_toc_checksum_failure(filename):
        try:
-               with open("/dev/null", "a") as devnull:
-                       with util.archive_created(filename, "/bin", "--toc-cksum", "md5", stderr=devnull) as path:
-                               raise AssertionError("xar succeeded when it should have failed")
+               with _test_archive_created(filename, "testdir", "--toc-cksum", "md5", stderr=subprocess.DEVNULL) as path:
+                       raise AssertionError("xar succeeded when it should have failed")
        except subprocess.CalledProcessError:
                pass
 
 def md5_file_checksum_failure(filename):
        try:
-               with open("/dev/null", "a") as devnull:
-                       with util.archive_created(filename, "/bin", "--file-cksum", "md5", stderr=devnull) as path:
-                               raise AssertionError("xar succeeded when it should have failed")
+               with _test_archive_created(filename, "testdir", "--file-cksum", "md5", stderr=subprocess.DEVNULL) as path:
+                       raise AssertionError("xar succeeded when it should have failed")
        except subprocess.CalledProcessError:
                pass
 
@@ -185,8 +188,8 @@ def _verify_checksum_algorithm(filename, algorithm):
        else:
                algorithm = "sha1"
        
-       with util.archive_created(filename, "/bin", *additional_args) as path:
-               toc = subprocess.check_output(["xar", "--dump-toc=-", "-f", path])
+       with _test_archive_created(filename, "testdir", *additional_args) as path:
+               toc = subprocess.check_output(["xar", "--dump-toc=-", "-f", path], text=True)
                found = False
                for line in toc.splitlines():
                        if '<unarchived-checksum style="{a}">'.format(a=algorithm) in line or '<archived-checksum style="{a}">'.format(a=algorithm) in line:
@@ -214,12 +217,16 @@ TEST_CASES = (default_toc_checksum_validity, sha1_toc_checksum_validity, sha256_
               md5_toc_checksum_failure, md5_file_checksum_failure,)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/compression.py b/xar/test/compression.py
index 2b3b2ec..7ed30ca 100755
--- a/xar/test/compression.py
+++ b/xar/test/compression.py
@@ -2,10 +2,10 @@
 
 from __future__ import print_function
 
-import cStringIO
 import os
 import os.path
 import subprocess
+import sys
 import tempfile
 
 import util
@@ -16,10 +16,15 @@ import util
 # 
 
 def _check_compression(filename, *args, **kwargs):
-       with util.archive_created(filename, "/bin", *args, **kwargs) as path:
+       with (
+               util.directory_created("temp") as temp_directory,
+               util.chdir(temp_directory),
+               util.test_directory_created("testdir") as test_directory,
+               util.archive_created(filename, "testdir", *args, **kwargs) as path,
+       ):
                with util.directory_created("extracted") as directory:
                        subprocess.check_call(["xar", "-x", "-f", path, "-C", directory])
-                       util.assert_identical_directories("/bin", os.path.join(directory, "bin"))
+                       util.assert_identical_directories(test_directory, os.path.join(directory, "testdir"))
 
 
 # 
@@ -61,14 +66,18 @@ TEST_CASES = (no_compression, default_compression,
               gzip_compression_short, bzip2_compression_short, lzma_compression_short)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
-               except util.TestCaseSkipError, e:
-                       print("SKIPPED: {f}: {m}".format(f=case.func_name, m=e.message))
+               except util.TestCaseSkipError as e:
+                       print("SKIPPED: {f}: {m}".format(f=func_name, m=e))
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/data.py b/xar/test/data.py
index a9793f0..f902b78 100755
--- a/xar/test/data.py
+++ b/xar/test/data.py
@@ -6,6 +6,7 @@ import contextlib
 import os
 import os.path
 import subprocess
+import sys
 import util
 
 
@@ -28,7 +29,7 @@ def _process_toc(archive_path):
        subprocess.check_call(["xar", "-f", archive_path, "--dump-toc=data_toc.xml"])
        try:
                result = subprocess.check_output(["xsltproc", "-o", "-", os.path.realpath(os.path.join(__file__, "..", "data.xsl")), "data_toc.xml"])
-               assert result == "", "expected no data offset, but instead found:{o}".format(o=result)
+               assert result == b"", "expected no data offset, but instead found:{o}".format(o=result)
        finally:
                os.unlink("data_toc.xml")
 
@@ -90,14 +91,18 @@ TEST_CASES = (zero_length_default_compression, zero_length_no_compression,
               mixed_length_gzip_compression, mixed_length_bzip2_compression, mixed_length_lzma_compression)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
-               except util.TestCaseSkipError, e:
-                       print("SKIPPED: {f}: {m}".format(f=case.func_name, m=e.message))
+               except util.TestCaseSkipError as e:
+                       print("SKIPPED: {f}: {m}".format(f=func_name, m=e))
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/hardlink.py b/xar/test/hardlink.py
index 5145216..da409d6 100755
--- a/xar/test/hardlink.py
+++ b/xar/test/hardlink.py
@@ -5,6 +5,7 @@ from __future__ import print_function
 import os
 import os.path
 import subprocess
+import sys
 
 import util
 
@@ -58,12 +59,17 @@ def hard_link_identical_files(filename):
 TEST_CASES = (hard_link_in_directory, hard_link_in_cwd, hard_link_identical_files)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
+                       failed = True
                        import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/heap.py b/xar/test/heap.py
index f431c77..727412a 100755
--- a/xar/test/heap.py
+++ b/xar/test/heap.py
@@ -8,6 +8,7 @@ import os.path
 import re
 import shutil
 import subprocess
+import sys
 
 import util
 
@@ -19,8 +20,8 @@ import util
 def _file_offsets_for_archive(path, xsl_path):
        subprocess.check_call(["xar", "--dump-toc=heap_toc.xml", "-f", path])
        try:
-               offsets = subprocess.check_output(["xsltproc", xsl_path, "heap_toc.xml"])
-               matches = [re.match("^(.+)\s([^\s]+)$", offset) for offset in offsets.splitlines()]
+               offsets = subprocess.check_output(["xsltproc", xsl_path, "heap_toc.xml"], text=True)
+               matches = [re.match(r"^(.+)\s([^\s]+)$", offset) for offset in offsets.splitlines()]
                offsets = [(match.groups()[0], int(match.groups()[1])) for match in matches]
                return offsets
        finally:
@@ -33,9 +34,8 @@ def _file_offsets_for_archive(path, xsl_path):
 XSL_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "heap1.xsl")
 
 def normal_heap(filename):
-       with util.directory_created("scratch") as directory:
-               shutil.copy("/bin/ls", os.path.join(directory, "ls"))
-               shutil.copy(os.path.join(directory, "ls"), os.path.join(directory, "foo"))
+       with util.test_directory_created("scratch") as directory:
+               shutil.copy(os.path.join(directory, "script"), os.path.join(directory, "foo"))
                with util.chdir(directory):
                        with util.archive_created(os.path.join("..", "heap.xar"), ".") as path:
                                # Verify file offsets are as we expect
@@ -50,9 +50,8 @@ def normal_heap(filename):
                                        subprocess.check_call(["xar", "-x", "-f", path, "-C", extracted])
 
 def coalesce_heap(filename):
-       with util.directory_created("scratch") as directory:
-               shutil.copy("/bin/ls", os.path.join(directory, "ls"))
-               shutil.copy(os.path.join(directory, "ls"), os.path.join(directory, "foo"))
+       with util.test_directory_created("scratch") as directory:
+               shutil.copy(os.path.join(directory, "script"), os.path.join(directory, "foo"))
                with util.chdir(directory):
                        with util.archive_created(os.path.join("..", "heap.xar"), ".", "--coalesce-heap") as path:
                                # Verify file offsets are as we expect
@@ -67,12 +66,16 @@ def coalesce_heap(filename):
 TEST_CASES = (normal_heap, coalesce_heap)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/integrity.py b/xar/test/integrity.py
index c47ac6a..f4d2af7 100755
--- a/xar/test/integrity.py
+++ b/xar/test/integrity.py
@@ -5,6 +5,7 @@ from __future__ import print_function
 import os
 import os.path
 import subprocess
+import sys
 
 import util
 
@@ -12,9 +13,9 @@ import util
 # Utility Functions
 # 
 
-def _test_truncation(filename, path_to_be_archived, bytes_to_chop, *args):
-       with util.archive_created(filename, path_to_be_archived) as path:
-               with open("/dev/null", "w") as bitbucket:
+def _test_truncation(filename, bytes_to_chop, *args):
+       with util.test_directory_created("testdir") as test_directory:
+               with util.archive_created(filename, test_directory) as path:
                        size = os.stat(path).st_size
                        while size > 0:
                                last_size = size
@@ -23,7 +24,7 @@ def _test_truncation(filename, path_to_be_archived, bytes_to_chop, *args):
                                        f.truncate(size)
                        
                                with util.directory_created("scratch") as directory:
-                                       returncode = subprocess.call(["xar", "-x", "-f", path, "-C", directory], stderr=bitbucket)
+                                       returncode = subprocess.call(["xar", "-x", "-f", path, "-C", directory], stderr=subprocess.DEVNULL)
                                        assert returncode != 0, "xar claimed to succeed when extracting a truncated archive"
 
 # 
@@ -31,42 +32,42 @@ def _test_truncation(filename, path_to_be_archived, bytes_to_chop, *args):
 #
 
 def large_uncompressed(filename):
-       _test_truncation(filename, "/usr/share/man/man1", 1024 * 1024, "--compression=none")
+       _test_truncation(filename, 1024 * 1024, "--compression=none")
        
 def large_default_compression(filename):
-       _test_truncation(filename, "/usr/share/man/man1", 1024 * 1024)
+       _test_truncation(filename, 1024 * 1024)
 
 def large_gzip_compressed(filename):
        util.skip_if_no_compression_support("gzip")
-       _test_truncation(filename, "/usr/share/man/man1", 1024 * 1024, "--compression=gzip")
+       _test_truncation(filename, 1024 * 1024, "--compression=gzip")
 
 def large_bzip2_compressed(filename):
        util.skip_if_no_compression_support("bzip2")
-       _test_truncation(filename, "/usr/share/man/man1", 1024 * 1024, "--compression=bzip2")
+       _test_truncation(filename, 1024 * 1024, "--compression=bzip2")
 
 def large_lzma_compressed(filename):
        util.skip_if_no_compression_support("lzma")
-       _test_truncation(filename, "/usr/share/man/man1", 1024 * 1024, "--compression=lzma")
+       _test_truncation(filename, 1024 * 1024, "--compression=lzma")
 
 # "small" variants use a non-base-2 size to try to catch issues that occur on uneven boundaries
 
 def small_uncompressed(filename):
-       _test_truncation(filename, "/bin", 43651, "--compression=none")
+       _test_truncation(filename, 43651, "--compression=none")
 
 def small_default_compression(filename):
-       _test_truncation(filename, "/bin", 43651)
+       _test_truncation(filename, 43651)
 
 def small_gzip_compressed(filename):
        util.skip_if_no_compression_support("gzip")
-       _test_truncation(filename, "/bin", 43651, "--compression=gzip")
+       _test_truncation(filename, 43651, "--compression=gzip")
 
 def small_bzip2_compressed(filename):
        util.skip_if_no_compression_support("bzip2")
-       _test_truncation(filename, "/bin", 43651, "--compression=bzip2")
+       _test_truncation(filename, 43651, "--compression=bzip2")
 
 def small_lzma_compressed(filename):
        util.skip_if_no_compression_support("lzma")
-       _test_truncation(filename, "/bin", 43651, "--compression=lzma")
+       _test_truncation(filename, 43651, "--compression=lzma")
 
 
 TEST_CASES = (large_uncompressed, large_default_compression,
@@ -75,14 +76,18 @@ TEST_CASES = (large_uncompressed, large_default_compression,
               small_gzip_compressed, small_bzip2_compressed, small_lzma_compressed)
 
 if __name__ == "__main__":
+       failed = False
        for case in TEST_CASES:
+               func_name = case.__name__
                try:
-                       case("{f}.xar".format(f=case.func_name))
-                       print("PASSED: {f}".format(f=case.func_name))
+                       case("{f}.xar".format(f=func_name))
+                       print("PASSED: {f}".format(f=func_name))
                except (AssertionError, IOError, subprocess.CalledProcessError):
-                       import sys, os
-                       print("FAILED: {f}".format(f=case.func_name))
+                       failed = True
+                       print("FAILED: {f}".format(f=func_name))
                        sys.excepthook(*sys.exc_info())
                        print("")
-               except util.TestCaseSkipError, e:
-                       print("SKIPPED: {f}: {m}".format(f=case.func_name, m=e.message))
+               except util.TestCaseSkipError as e:
+                       print("SKIPPED: {f}: {m}".format(f=func_name, m=e))
+       if failed:
+               sys.exit(1)
diff --git a/xar/test/run-all.py b/xar/test/run-all.py
new file mode 100755
index 0000000..05e3054
--- /dev/null
+++ b/xar/test/run-all.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+
+import os.path
+import subprocess
+import sys
+
+test_suites = [
+       "attr.py",
+       "checksums.py",
+       "compression.py",
+       "data.py",
+       "hardlink.py",
+       "heap.py",
+       "integrity.py",
+]
+
+test_path = os.path.dirname(__file__)
+
+failed = False
+for suite in test_suites:
+       p = subprocess.run([sys.executable, "--", os.path.join(test_path, suite)])
+       if p.returncode:
+               failed = True
+if failed:
+       sys.exit(1)
diff --git a/xar/test/util.py b/xar/test/util.py
index da79925..423dd3c 100644
--- a/xar/test/util.py
+++ b/xar/test/util.py
@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 
 import contextlib
+import errno
+import functools
 import hashlib
 import os
 import os.path
@@ -13,16 +15,65 @@ import xattr
 class TestCaseSkipError(Exception):
        pass
 
+@functools.cache
+def _check_xattrs_supported():
+       """
+       Returns True if the filesystem supports extended attributes.
+       """
+       with directory_created("empty") as directory:
+               try:
+                       xattr.setxattr(directory, "user.xattrcheck", b"supported")
+                       return True
+               except OSError as e:
+                       if e.errno != errno.ENOTSUP:
+                               raise
+       return False
+
+def skip_if_no_xattrs_support():
+       """
+       Raises TestCaseSkipError if the the filesystem does not support extended
+       attributes.
+       """
+       if not _check_xattrs_supported():
+               raise TestCaseSkipError("filesystem does not support extended attributes")
+
+@functools.cache
+def _check_compression_supported(type):
+       """
+       Returns True if xar has support for the given compression type compiled
+       in. This function performs a runtime check that tries to compress data
+       with the given compression type and looks for a known error string. It
+       ignores all other errors.
+       """
+       supported = True
+       with directory_created("empty") as directory:
+               archive_path = f"{type}_compression_check.xar"
+               try:
+                       return f"{type} support not compiled in." not in subprocess.run(
+                               [
+                                       "xar",
+                                       "-c",
+                                       "-f",
+                                       archive_path,
+                                       "--compression=" + type,
+                                       directory,
+                               ],
+                               stdout=subprocess.PIPE,
+                               text=True,
+                       ).stdout
+               except:
+                       # Assume that this compression type is supported.
+                       pass
+               finally:
+                       if os.path.exists(archive_path):
+                               os.unlink(archive_path)
+       return supported
+
 def skip_if_no_compression_support(type):
        """
-       Raises TestCaseSkipError if the type is "lzma" and the test is running on
-       darwin (OS X). In the future, we should add a hidden debugging flag to xar
-       to determine valid compression types. This will skip incorrectly if a
-       custom xar is used on OS X, or if a custom xar on another platform is
-       built without bzip2 or lzma.
-       
+       Raises TestCaseSkipError if the compression type is not compiled in.
        """
-       if sys.platform == "darwin" and type == "lzma":
+       if not _check_compression_supported(type):
                raise TestCaseSkipError("{t} support not compiled in".format(t=type))
 
 @contextlib.contextmanager
@@ -43,6 +94,22 @@ def directory_created(directory_path):
                if os.path.exists(directory_path):
                        shutil.rmtree(directory_path)
 
+@contextlib.contextmanager
+def test_directory_created(directory_path):
+       """
+       Like directory_created, but populates the directory with test files.
+       """
+       with directory_created(directory_path) as directory:
+               with open(os.path.join(directory, "script"), "w+", opener=lambda path, flags: os.open(path, flags, 0o750)) as f:
+                       f.write("#!/bin/sh\necho hello world")
+               with open(os.path.join(directory, "random_1kb"), "wb+") as f:
+                       f.write(os.urandom(1000))
+               with open(os.path.join(directory, "random_4kib"), "wb+") as f:
+                       f.write(os.urandom(4096))
+               with open(os.path.join(directory, "random_1mb"), "wb+") as f:
+                       f.write(os.urandom(9999999))
+               yield directory
+
 @contextlib.contextmanager
 def archive_created(archive_path, content_path, *extra_args, **extra_kwargs):
        """
@@ -68,7 +135,7 @@ def archive_created(archive_path, content_path, *extra_args, **extra_kwargs):
 HASH_CHUNK_SIZE = 32768
 
 def _md5_path(path):
-       with open(path, "r") as f:
+       with open(path, "rb") as f:
                h = hashlib.md5()
                while True:
                        last = f.read(HASH_CHUNK_SIZE)
@@ -122,7 +189,7 @@ def assert_identical_directories(path1, path2):
                
                # Sizes and the like
                assert stat1.st_size == stat2.st_size, "size mismatch for \"{e1}\" ({s1}) and \"{e2}\" ({s2})".format(e1=entry1, s1=stat1.st_size, e2=entry2, s2=stat2.st_size)
-               assert stat1.st_mtime == stat2.st_mtime, "mtime mismatch for \"{e1}\" and \"{e2}\"".format(e1=entry1, e2=entry2)
+               assert int(stat1.st_mtime) == int(stat2.st_mtime), "mtime mismatch for \"{e1}\" and \"{e2}\"".format(e1=entry1, e2=entry2)
                assert _md5_path(entry1) == _md5_path(entry2), "md5 hash mismatch for \"{e1}\" and \"{e2}\"".format(e1=entry1, e2=entry2)
                if os.path.isdir(entry1):
                        assert_identical_directories(entry1, entry2)
diff --git a/xar/test/validate.c b/xar/test/validate.c
index dfe69eb..a5fbe37 100644
--- a/xar/test/validate.c
+++ b/xar/test/validate.c
@@ -16,37 +16,40 @@
 
 off_t HeapOff = 0;
 
-static char* xar_format_md5(const unsigned char* m) {
+static char* xar_format_sha1(const unsigned char* m) {
         char* result = NULL;
         asprintf(&result,
                 "%02x%02x%02x%02x"
                 "%02x%02x%02x%02x"
                 "%02x%02x%02x%02x"
+                "%02x%02x%02x%02x"
                 "%02x%02x%02x%02x",
                 m[0], m[1], m[2], m[3],
                 m[4], m[5], m[6], m[7],
                 m[8], m[9], m[10], m[11],
-                m[12], m[13], m[14], m[15]);
+                m[12], m[13], m[14], m[15],
+                m[16], m[17], m[18], m[19]);
         return result;
 }
 
 void heap_check(int fd, const char *name, const char *prop, off_t offset, off_t length, const char *csum) {
        char *buf;
-       EVP_MD_CTX ctx;
+       EVP_MD_CTX *ctx;
        const EVP_MD *md;
-       unsigned char md5str[EVP_MAX_MD_SIZE];
+       unsigned char sha1str[EVP_MAX_MD_SIZE];
        unsigned int len;
        ssize_t r;
-       char *formattedmd5;
+       char *formattedsha1;
 
        fprintf(stderr, "Heap checking %s %s at offset: %" PRIu64 "\n", name, prop, HeapOff+offset);
        OpenSSL_add_all_digests();
-       md = EVP_get_digestbyname("md5");
+       md = EVP_get_digestbyname("sha1");
        if( md == NULL ) {
-               fprintf(stderr, "No md5 digest in openssl\n");
+               fprintf(stderr, "No sha1 digest in openssl\n");
                exit(1);
        }
-       EVP_DigestInit(&ctx, md);
+       ctx = EVP_MD_CTX_create();
+       EVP_DigestInit(ctx, md);
 
        buf = malloc(length);
        if( !buf ) {
@@ -65,14 +68,15 @@ void heap_check(int fd, const char *name, const char *prop, off_t offset, off_t
                fprintf(stderr, "Error reading from the heap\n");
                exit(1);
        }
-       EVP_DigestUpdate(&ctx, buf, length);
-       EVP_DigestFinal(&ctx, md5str, &len);
+       EVP_DigestUpdate(ctx, buf, length);
+       EVP_DigestFinal(ctx, sha1str, &len);
+       EVP_MD_CTX_destroy(ctx);
 
-       formattedmd5 = xar_format_md5(md5str);
-       if( strcmp(formattedmd5, csum) != 0 ) {
-               fprintf(stderr, "%s %s checksum does not match\n", name, prop);
+       formattedsha1 = xar_format_sha1(sha1str);
+       if( strcmp(formattedsha1, csum) != 0 ) {
+               fprintf(stderr, "%s %s checksum does not match (got %s but expected %s)\n", name, prop, formattedsha1, csum);
        }
-       free(formattedmd5);
+       free(formattedsha1);
        free(buf);
 }
 
-- 
2.44.1