diffoscope 331__tar.gz → 336__tar.gz

{diffoscope-331/diffoscope.egg-info → diffoscope-336}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffoscope
-Version: 331
+Version: 336
 Summary: in-depth comparison of files, archives, and directories
 Home-page: https://diffoscope.org/
 Author: Diffoscope developers
@@ -14,12 +14,9 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Utilities
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Requires-Dist: python-magic

{diffoscope-331 → diffoscope-336}/diffoscope/__init__.py

@@ -17,4 +17,4 @@
 # You should have received a copy of the GNU General Public License
 # along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
 
-VERSION = "331"
+VERSION = "336"

{diffoscope-331 → diffoscope-336}/diffoscope/comparators/apk.py

@@ -331,11 +331,17 @@ def get_v2_signing_keys(path):
     except Exception:
         return ""
 
+    try:
+        pairs = instance._v2_blocks.items()
+    except AttributeError:
+        # Androguard >= 4.1.4-1 (approx)
+        pairs = [(b.id, b.data) for b in instance._v2_blocks]
+
     def format_key(x):
         return "\n".join(textwrap.wrap(binascii.hexlify(x).decode("utf-8")))
 
     output = []
-    for k, v in sorted(instance._v2_blocks.items()):
+    for k, v in sorted(pairs):
         output.append("Key {}:\n{}\n".format(hex(k), format_key(v)))
 
     return "\n".join(output)

{diffoscope-331 → diffoscope-336}/diffoscope/comparators/nar.py

@@ -1,7 +1,7 @@
 #
 # diffoscope: in-depth comparison of files, archives, and directories
 #
-# Copyright © 2024 Chris Lamb <lamby@debian.org>
+# Copyright © 2024, 2026 Chris Lamb <lamby@debian.org>
 # Copyright © 2022 Christopher Baines <mail@cbaines.net>
 #
 # diffoscope is free software: you can redistribute it and/or modify

{diffoscope-331 → diffoscope-336}/diffoscope/comparators/pdf.py

@@ -2,7 +2,7 @@
 # diffoscope: in-depth comparison of files, archives, and directories
 #
 # Copyright © 2014-2015 Jérémy Bobbio <lunar@debian.org>
-# Copyright © 2015-2016, 2018-2024 Chris Lamb <lamby@debian.org>
+# Copyright © 2015-2016, 2018-2024, 2026 Chris Lamb <lamby@debian.org>
 # Copyright © 2023 Mattia Rizzolo <mattia@debian.org>
 #
 # diffoscope is free software: you can redistribute it and/or modify
@@ -23,6 +23,7 @@ import os
 import re
 
 from diffoscope.tools import (
+    find_executable,
     python_module_missing,
     tool_required,
     get_package_provider,
@@ -86,7 +87,7 @@ class Pdftotext(Command):
 class Dumppdf(Command):
     @tool_required("dumppdf")
     def cmdline(self):
-        return ["dumppdf", "-at", self.path]
+        return [find_executable("dumppdf"), "-at", self.path]
 
 
 class PdfFile(File):
@@ -105,7 +106,7 @@ class PdfFile(File):
                 Difference.from_operation(Dumppdf, self.path, other.path)
             )
 
-        # Always preppend metadata differences
+        # Always prepend metadata differences
         xs[:0] = self.gen_metadata_differences(other)
 
         return xs

diffoscope-336/diffoscope/comparators/tar.py

@@ -0,0 +1,232 @@
+#
+# diffoscope: in-depth comparison of files, archives, and directories
+#
+# Copyright © 2014-2015 Jérémy Bobbio <lunar@debian.org>
+# Copyright © 2015-2016, 2018-2020, 2026 Chris Lamb <lamby@debian.org>
+#
+# diffoscope is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# diffoscope is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
+
+import datetime
+import re
+import struct
+import tarfile
+
+from diffoscope.difference import Difference
+
+from .utils.file import File
+from .utils.libarchive import LibarchiveContainer, list_libarchive
+
+
+class TarContainer(LibarchiveContainer):
+    pass
+
+
+class TarFile(File):
+    DESCRIPTION = "tape archives (.tar)"
+    CONTAINER_CLASSES = [TarContainer]
+    FILE_TYPE_RE = re.compile(r"\btar archive\b")
+
+    def compare_details(self, other, source=None):
+        libarchive_result = Difference.from_text_readers(
+            list_libarchive(self.path),
+            list_libarchive(other.path),
+            self.path,
+            other.path,
+            source="file list",
+        )
+        if libarchive_result is not None:
+            return [libarchive_result]
+
+        # The libarchive based reader is not able to spot differences in
+        # POSIX.1-2001 PAX headers. libarchive itself is capable of reading
+        # this information (the archive_entry_xattr_* functions) but it
+        # doesn't seem to expose the relevant functions via libarchive.ffi.
+        #
+        # The PAX header stores information like
+        #  * very long filenames and linknames
+        #  * extended attributes
+        #  * POSIX ACLs
+        #  * atime and ctime with sub-second resolution
+        #  * GNU/Hurd translators
+        #  * sparse files
+        #  * files larger than 8 GiB
+        #  * device major and minor numbers with more than 21 bits
+        #  * uid/gid with more than 21 bits
+        #
+        # If libarchive is unable to see a difference between the tarballs
+        # we fall back to the Python tarfile module and try to print more
+        # information.
+        return [
+            Difference.from_text_readers(
+                list_pytarfile(self.path),
+                list_pytarfile(other.path),
+                self.path,
+                other.path,
+                source="file list",
+            ),
+        ]
+
+
+def timestamp2str(ts):
+    try:
+        return str(datetime.datetime.fromtimestamp(float(ts), datetime.UTC))
+    except ValueError:
+        return f"Unable to parse: {ts}"
+
+
+def read_number(v):
+    try:
+        return int(v)
+    except ValueError:
+        return f"Unable to parse: {v}"
+
+
+# from https://salsa.debian.org/josch/seedfiles-integration-tests/-/blob/main/test.py
+def parse_xattr(acl):
+    # see uapi/linux/posix_acl.h
+    POSIX_ACL_XATTR_VERSION = 0x0002
+    assert (POSIX_ACL_XATTR_VERSION,) == struct.unpack("<I", acl[:4])
+    acl = acl[4:]
+    assert (1,) == struct.unpack("<H", acl[:2])  # a_refcount
+    (count,) = struct.unpack("<H", acl[2:4])
+    assert b"\xff\xff\xff\xff" == acl[4:8]  # filler?
+    # make sure that the acl minus the header is a multiple of 8
+    assert len(acl) % 8 == 0
+    assert count >= len(acl) / 8
+    count = len(acl) / 8
+    result = ""
+    # see linux/posix_acl.h
+    while acl:
+        e_tag, e_perm, e_id = struct.unpack("<hHI", acl[:8])
+        match e_tag:
+            case 0x01:
+                e_tag = "ACL_USER_OBJ"
+            case 0x02:
+                e_tag = "ACL_USER"
+            case 0x04:
+                e_tag = "ACL_GROUP_OBJ"
+            case 0x08:
+                e_tag = "ACL_GROUP"
+            case 0x10:
+                e_tag = "ACL_MASK"
+            case 0x20:
+                e_tag = "ACL_OTHER"
+            case _:
+                e_tag = f"Unknown e_tag: {e_tag}"
+        e_perm_str = ""
+        if e_perm & 0x04:
+            e_perm_str += "r"
+        if e_perm & 0x02:
+            e_perm_str += "w"
+        if e_perm & 0x01:
+            e_perm_str += "x"
+        if e_id + 1 == 2**32:
+            e_id = "2^32-1"
+        result += f"\n  {e_tag:>13} {e_perm_str:<3} {e_id}"
+        acl = acl[8:]
+    return result
+
+
+def list_pytarfile(path):
+    with tarfile.open(path) as tar:
+        for member in tar:
+            if not member.pax_headers:
+                continue
+            for k, v in sorted(member.pax_headers.items()):
+                p = f"{member.name} PAX header {k}"
+                match k:
+                    case "GNU.sparse.numblocks":
+                        yield f"{p} raw value: {v}\n"
+                    case "GNU.sparse.offset":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "GNU.sparse.numbytes":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "GNU.sparse.size":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "GNU.sparse.map":
+                        yield f"{p} raw value: {v}\n"
+                    case "GNU.sparse.major":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "GNU.sparse.minor":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "GNU.sparse.name":
+                        yield f"{p}: {v}\n"
+                    case "GNU.sparse.realsize":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "LIBARCHIVE.creationtime":
+                        yield f"{p}: {timestamp2str(v)}\n"
+                    case "LIBARCHIVE.symlinktype":
+                        match v:
+                            case "file" | "dir":
+                                yield f"{p}: {v}\n"
+                            case _:
+                                yield f"{p}: Unknown value: {v}"
+                    case "LIBARCHIVE.xattr":
+                        yield f"{p} raw value: {v}\n"
+                    case "RHT.security.selinux":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.acl.access":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.acl.default":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.acl.ace":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.devmajor":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.devminor":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.fflags":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.dev":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.ino":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.nlink":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.realsize":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "SCHILY.xattr.gnu.translator":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.xattr.system.posix_acl_default":
+                        yield f"{p}: {parse_xattr(v.encode(errors='surrogateescape'))}\n"
+                    case "SCHILY.xattr.user":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.xattr.trusted":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.xattr.security":
+                        yield f"{p} raw value: {v}\n"
+                    case "SCHILY.xattr.gnu.author":
+                        yield f"{p} raw value: {v}\n"
+                    case "SUN.holesdata":
+                        yield f"{p} raw value: {v}\n"
+                    case "atime" | "ctime" | "mtime":
+                        yield f"{p}: {timestamp2str(v)}\n"
+                    case "gid" | "uid":
+                        yield f"{p}: {read_number(v)}\n"
+                    case "gname" | "uname":
+                        yield f"{p}: {v}\n"
+                    case "hdrcharset":
+                        match v:
+                            case "BINARY":
+                                yield "{p}: BINARY\n"
+                            case "ISO-IR 10646 2000 UTF-8":
+                                yield "{p}: UTF-8\n"
+                            case _:
+                                yield f"{p}: Unknown value: {v}"
+                    case "linkpath":
+                        yield f"{p}: {v}\n"
+                    case "path":
+                        yield f"{p}: {v}\n"
+                    case "size":
+                        yield f"{p}: {read_number(v)}\n"

{diffoscope-331 → diffoscope-336/diffoscope.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffoscope
-Version: 331
+Version: 336
 Summary: in-depth comparison of files, archives, and directories
 Home-page: https://diffoscope.org/
 Author: Diffoscope developers
@@ -14,12 +14,9 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Utilities
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Requires-Dist: python-magic

{diffoscope-331 → diffoscope-336}/diffoscope.egg-info/SOURCES.txt

@@ -445,7 +445,10 @@ tests/data/squashfs_root_expected_diff
 tests/data/squashfs_superblock_expected_diff
 tests/data/symlink_expected_destination_diff
 tests/data/symlink_expected_diff
+tests/data/tar_acl_diff
+tests/data/tar_atime_diff
 tests/data/tar_listing_expected_diff
+tests/data/tar_translator_diff
 tests/data/test1-le64.cache-4
 tests/data/test1.a
 tests/data/test1.apk

{diffoscope-331 → diffoscope-336}/setup.py

@@ -6,8 +6,8 @@ import sys
 
 from setuptools import setup, find_packages
 
-if sys.version_info < (3, 7):
-    print("diffoscope requires at least python 3.7", file=sys.stderr)
+if sys.version_info < (3, 10):
+    print("diffoscope requires at least python 3.10", file=sys.stderr)
     sys.exit(1)
 
 
@@ -36,7 +36,7 @@ setup(
         "libarchive-c",
     ],
     extras_require=extras_require,
-    python_requires=">=3.7",
+    python_requires=">=3.10",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
@@ -44,9 +44,6 @@ setup(
         "Operating System :: POSIX",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Topic :: Utilities",
     ],

{diffoscope-331 → diffoscope-336}/tests/comparators/test_nar.py

@@ -1,7 +1,7 @@
 #
 # diffoscope: in-depth comparison of files, archives, and directories
 #
-# Copyright © 2024 Chris Lamb <lamby@debian.org>
+# Copyright © 2024, 2026 Chris Lamb <lamby@debian.org>
 # Copyright © 2022 Christopher Baines <mail@cbaines.net>
 #
 # diffoscope is free software: you can redistribute it and/or modify

diffoscope-336/tests/comparators/test_tar.py

@@ -0,0 +1,275 @@
+#
+# diffoscope: in-depth comparison of files, archives, and directories
+#
+# Copyright © 2015 Jérémy Bobbio <lunar@debian.org>
+# Copyright © 2015-2017, 2020, 2026 Chris Lamb <lamby@debian.org>
+#
+# diffoscope is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# diffoscope is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with diffoscope.  If not, see <https://www.gnu.org/licenses/>.
+
+import gzip
+import os.path
+import pytest
+import struct
+
+from diffoscope.config import Config
+from diffoscope.comparators.tar import TarFile
+from diffoscope.comparators.missing_file import MissingFile
+from diffoscope.comparators.utils.specialize import specialize
+from diffoscope.comparators.binary import FilesystemFile
+
+from ..utils.data import load_fixture, get_data, assert_diff
+from ..utils.nonexisting import assert_non_existing
+
+tar1 = load_fixture("test1.tar")
+tar2 = load_fixture("test2.tar")
+
+
+def test_identification(tar1):
+    assert isinstance(tar1, TarFile)
+
+
+def test_no_differences(tar1):
+    difference = tar1.compare(tar1)
+    assert difference is None
+
+
+@pytest.fixture
+def differences(tar1, tar2):
+    return tar1.compare(tar2).details
+
+
+def test_listing(differences):
+    expected_diff = get_data("tar_listing_expected_diff")
+    assert differences[0].unified_diff == expected_diff
+
+
+def test_symlinks(differences):
+    assert differences[2].source1 == "dir/link"
+    assert differences[2].source2 == "dir/link"
+    assert differences[2].comment == "symlink"
+    expected_diff = get_data("symlink_expected_diff")
+    assert differences[2].unified_diff == expected_diff
+
+
+def test_text_file(differences):
+    assert differences[1].source1 == "dir/text"
+    assert differences[1].source2 == "dir/text"
+    expected_diff = get_data("text_ascii_expected_diff")
+    assert differences[1].unified_diff == expected_diff
+
+
+def test_compare_non_existing(monkeypatch, tar1):
+    assert_non_existing(monkeypatch, tar1)
+
+
+no_permissions_tar = load_fixture("no-perms.tar")
+
+# Reported as Debian #797164. This is a good way to notice if we unpack directories
+# as we won't be able to remove files in one if we don't have write permissions.
+
+
+def test_no_permissions_dir_in_tarball(monkeypatch, no_permissions_tar):
+    # We want to make sure OSError is not raised.
+    # Comparing with non-existing file makes it easy to make sure all files are unpacked
+    monkeypatch.setattr(Config(), "new_file", True)
+    no_permissions_tar.compare(MissingFile("/nonexistent", no_permissions_tar))
+
+
+# The result of
+#    $ tar --format=pax --no-recursion -C /var/log -cf journal.tar ./journal
+# once with and once without the --xattrs option
+tar_acl_bytes = bytes.fromhex(
+    "1f8b080085ad436a02ffedd44f4bc3301806f02813a5273f42bf8069fef6ad87"
+    "9dbc4cf02078f224a1ad30e9ac3419d44faf2fdb4419a2286e179f1f94276d42"
+    "d2439fcae23a8cb33634ed108b877e393c864efc31c54ae756c9b6535947423b"
+    "6b4a22e734afd39ab411f928f660195318f855c4ff64551ed27cd14e35558648"
+    "3932d2581e91b72ee3d97a3d5b92f59a942269cfb5afac336556f9fce6627679"
+    "752bc790d220e3734ced423ef5713ede85bae3ab6e639c1ef23907e258bcb089"
+    "385ae509e7849f9f6eeef34d6655f9cda64d7b1f965dfad9ae023e27df4a5fec"
+    "ee0caeb821ef3ff65e13775ebddbeabf2d9d16b9df67ff87be4f5fad5b7f87cd"
+    "d98efe910000000000000000000000000000000000bff10adb0252ab00280000"
+)
+
+
+tar_noacl_bytes = bytes.fromhex(
+    "1f8b0800b4ad436a02ffedd43d6a0331108661d53ec55ec0bbfa19699cc2bdcb"
+    "5c41c45bc4c459d85d83737b0f0e263f458a101b82dfa719a11990407c6abbc7"
+    "7adcf475db8f53b71b0ee36b7d717fcc9b2272aee67bf55ec50549b1a88a049b"
+    "0b41bdbae6e86ee030cd75b4abb8fb947c53e7e77dbf0eba8aaa5e34b631d94a"
+    "739285759fdebb4553b657f1daa687905749625938fc7bed25f4ddf5ceb08447"
+    "cdf973ee838a7ee4dff6bee63f1509aec9b7ccff380cf34f73d3db34f7fbedf2"
+    "4a7f24000000000000000000000000f01b278df8083500280000"
+)
+
+# We run tar with --clamp-mtime --mtime=0 but the ctime and atime
+# will still be stored in pax headers. Re-create like this:
+#    $ tar --clamp-mtime --mtime=0 --format=pax --no-recursion -cf bin1.tar ./bin
+#    $ touch ./bin
+#    $ tar --clamp-mtime --mtime=0 --format=pax --no-recursion -cf bin2.tar ./bin
+
+tar_before_bytes = bytes.fromhex(
+    "1f8b0800000000000003edd3cd0a8240148661d75d8557a067fe6dd1be65b760"
+    "256450411a74f94d861006b508b3c5fb6c0ecc37301f0c27cb57e5755995dbea"
+    "dce4ebfa988c40226f6d37a3e1140936514e6b71de191bcf95846092f43a4699"
+    "a14bd396e758e5176ffd212369d9d6876aa142a10be38cf299b7f107bcf6c52c"
+    "a69b97d4e898cadccea6ee8eef65f7a5cfc77da35bf1e0ee530527cfb337d87f"
+    "25da25a91bb7d643bffffb53b3d9bdb9f7290700000000000000000000000026"
+    "7003acf6139900280000"
+)
+
+tar_after_bytes = bytes.fromhex(
+    "1f8b0800000000000003edd3cd0a8240148661d75d8557a0f3e39971d3be65b7"
+    "60266450811678f98d861042b508b3c5fb6c3e983370cee64bd26dd16daa625f"
+    "356dbaabcfd10c54e0b26cc8609a4af92cd2628c1227360bef5a796fa3b89be3"
+    "98a95b7b2d9a70ca2f76fd21abe2e25a9faab5f6b9c9ad5897275a7b63c439b7"
+    "0ad3f2f574e9dbf1bda42f7d3aef8ea1e25efad45ed4738e26fdd7ca4814cbbc"
+    "673d8cfd3f5edaf2f0e6dfa739000000000000000000000000b0803be9796d3f"
+    "00280000"
+)
+
+
+# Generates a PAX format tarball with a single entry which has the GNU/Hurd
+# translator given in the content argument attached to it in a PAX header
+def generate_pax(
+    name, mode, type, linktarget=None, major=None, minor=None, content=None
+):
+    entries = []
+    if content is not None:
+        content = "SCHILY.xattr.gnu.translator=" + content
+        # In the beginning the decimal length of the field is recorded.
+        # But the length includes the length of the number itself.
+        # Luckily we only need to support decimal numbers with two digits.
+        assert 9 < len(content) + 4 < 100
+        dirname, basename = os.path.split(name)
+        paxname = dirname + "/PaxHeaders/" + basename
+        content = f"{len(content) +4} {content}\n"
+        entries.append((paxname, 0, "x", None, None, None, content))
+    entries.append((name, mode, type, linktarget, major, minor, None))
+
+    mtime = int(1612543740)  # an arbitrary reproducible date
+    devtar = b""
+    for file in entries:
+        fname, mode, type, linktarget, major, minor, content = file
+        assert len(fname) <= 100
+        buf = struct.pack(
+            "@100s8s8s8s12s12s8s1s100s6s2s32s32s8s8s155s12s",
+            fname.encode(),
+            f"{mode:07o}".encode(),
+            b"0" * 7,
+            b"0" * 7,
+            f"{len(content) if content is not None else 0:011o}".encode(),
+            f"{0 if type == 'x' else mtime:011o}".encode(),
+            b" " * 8,
+            type.encode(),
+            linktarget.encode() if linktarget is not None else b"",
+            b"ustar",
+            b"00",
+            b"",
+            b"",
+            (f"{major:07o}" if major is not None else "").encode(),
+            (f"{minor:07o}" if minor is not None else "").encode(),
+            b"",
+            b"",
+        )
+        chksum = 256 + sum(struct.unpack_from("148B8x356B", buf))
+        buf = buf[:-364] + f"{chksum:06o}\0".encode() + buf[-357:]
+        devtar += buf
+        if content is not None:
+            devtar += struct.pack("@512s", content.encode())
+    return struct.pack("@10240s", devtar)
+
+
+def tar_fixture(content, prefix):
+    @pytest.fixture
+    def pax_tar(tmp_path, tar1, tar2):
+        match prefix:
+            case "test1":
+                tar = tar1
+            case "test2":
+                tar = tar2
+            case _:
+                raise Exception(f"Invalid prefix: {prefix}")
+        tar_path = tmp_path / f"{prefix}.tar"
+        with open(tar_path, "wb") as t_fp:
+            t_fp.write(content)
+            with open(tar.path, "rb") as r_fp:
+                t_fp.write(bytes(r_fp.read()))
+        return specialize(FilesystemFile(str(tar_path)))
+
+    return pax_tar
+
+
+tar_acl = tar_fixture(gzip.decompress(tar_acl_bytes), "test1")
+tar_noacl = tar_fixture(gzip.decompress(tar_noacl_bytes), "test2")
+
+tar_before = tar_fixture(gzip.decompress(tar_before_bytes), "test1")
+tar_after = tar_fixture(gzip.decompress(tar_after_bytes), "test2")
+
+
+# The translator of tar_fd1_translator is wrong -- don't do this at home, kids!
+tar_fd0_translator = tar_fixture(
+    generate_pax(
+        name="./dev/fd0", mode=0o640, type="0", content="/hurd/storeio\0fd0\0"
+    ),
+    "test1",
+)
+tar_fd1_translator = tar_fixture(
+    generate_pax(
+        name="./dev/fd0", mode=0o640, type="0", content="/hurd/storeio\0fd1\0"
+    ),
+    "test2",
+)
+
+
+def test_identification(
+    tar_acl,
+    tar_noacl,
+    tar_before,
+    tar_after,
+    tar_fd0_translator,
+    tar_fd1_translator,
+):
+    assert isinstance(tar_acl, TarFile)
+    assert isinstance(tar_noacl, TarFile)
+    assert isinstance(tar_before, TarFile)
+    assert isinstance(tar_after, TarFile)
+    assert isinstance(tar_fd0_translator, TarFile)
+    assert isinstance(tar_fd1_translator, TarFile)
+
+
+@pytest.fixture
+def differences_acl(tar_acl, tar_noacl):
+    return tar_acl.compare(tar_noacl).details
+
+
+def test_listing_acl(differences_acl):
+    assert_diff(differences_acl[0], "tar_acl_diff")
+
+
+@pytest.fixture
+def differences_atime(tar_before, tar_after):
+    return tar_before.compare(tar_after).details
+
+
+def test_listing_atime(differences_atime):
+    assert_diff(differences_atime[0], "tar_atime_diff")
+
+
+@pytest.fixture
+def differences_translator(tar_fd0_translator, tar_fd1_translator):
+    return tar_fd0_translator.compare(tar_fd1_translator).details
+
+
+def test_listing_translator(differences_translator):
+    assert_diff(differences_translator[0], "tar_translator_diff")

{diffoscope-331 → diffoscope-336}/tests/data/elf_obj_radare2_expected_diff

@@ -8,3 +8,4 @@
          rbp = pop ()  // rsp // rsp
          return
  }
+