testaferro 0.1.0.dev0__py3-none-any.whl

testaferro/qemu.py

@@ -0,0 +1,364 @@
+# SPDX-FileCopyrightText: 2026 Paul Galbraith
+# SPDX-License-Identifier: BSD-3-Clause
+"""The QEMU/DOS guest binding.
+
+`suite_backend()` guards the door with `binfmt.classify()`: a DOS
+program — plain MZ or a headerless/.com image — yields a
+QemuSuiteBackend; anything else is rejected before any guest work,
+with the format and architecture named. The framework adapter
+defaults to testaferro.cpputest.
+
+QemuSuiteBackend drives a reliquary machine on the caller's behalf.
+Each facade session gets a fresh, disposable reliquary home under
+testaferro's cache directory (LOCALAPPDATA or XDG_CACHE_HOME): the
+declaration is written there as a blueprint, reliquary creates and
+boots one machine from it, and every guest run is one `reliquary.exec`
+against that machine. The suite executable reaches the guest on a
+host-directory (hostdir) work drive testaferro adds to the blueprint and
+stages before boot. Zero configuration is seeded from the
+caller-supplied `boot_image` or a cached FreeDOS image.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import os
+import shutil
+import tempfile
+
+import reliquary
+
+from . import binfmt
+from . import cache
+from . import cpputest
+from .suite import SuiteBackend
+
+
+# The blueprint name testaferro writes into each session's private
+# asset root, and the machine created from it.
+_BLUEPRINT_NAME = "testaferro"
+# The host-directory drive carrying the suite executable to the guest.
+_WORK_MEDIA_NAME = "testaferro-work"
+_BOOT_MEDIA_NAME = "testaferro-boot"
+_DEFAULT_MEMORY = "32M"
+# Seconds one guest command may take before reliquary gives up.
+_DEFAULT_TIMEOUT = 120
+_HDD_SLOTS = 4
+
+# FreeDOS 1.4's FloppyEdition, from which x86BOOT.img (a ready-to-boot
+# 1.44M floppy image) is extracted; a reliquary media definition,
+# fetched and hash-verified through reliquary.fetch_media().
+_FREEDOS_FLOPPY_MEDIA_NAME = "freedos-boot-floppy"
+_FREEDOS_FLOPPY_MEDIA_DEFINITION = [
+    {
+        "type": "media",
+        "name": "freedos-floppy-edition",
+        "location": "https://download.freedos.org/1.4/FD14-FloppyEdition.zip",
+        "sha256": ("45b1fa7c52dd996c3bfa5e352ffcd410781b952a6ad629f"
+                  "15a4c9ec4bbaefc5a"),
+        "children": [
+            {
+                "type": "media",
+                "name": _FREEDOS_FLOPPY_MEDIA_NAME,
+                "path": "144m/x86BOOT.img",
+                "sha256": ("552f7cbb0625960c050a3e682a4d2121cc2ffdfa9dc9d59"
+                          "2ccd49edf179333dc"),
+            },
+        ],
+    },
+]
+
+
+def suite_backend(exe_path, framework=cpputest, enumerator=None,
+                  boot_image=None, machine_config=None):
+    """Interrogate the referenced suite executable and return the
+    backend matching its format — a QemuSuiteBackend for a DOS
+    program. Raises FileNotFoundError for a missing file and
+    ValueError for a provably non-DOS executable (e.g. the suite's
+    host build passed by mistake)."""
+    exe_path = os.fspath(exe_path)
+    fmt = binfmt.classify(exe_path)
+    if fmt.platform != "dos":
+        raise ValueError(
+            f"{os.path.basename(exe_path)} is {fmt.kind} executable; "
+            "only DOS guest suites are supported")
+    if machine_config is not None:
+        from .machines import _coerce_machine_config
+
+        machine_config = _coerce_machine_config(machine_config)
+        if machine_config.platform != "dos":
+            raise ValueError(
+                "the QEMU/DOS binding requires a DOS machine config, "
+                f"not {machine_config.platform!r}")
+    if boot_image is not None and machine_config is not None:
+        raise TypeError("boot_image and machine_config cannot be combined")
+    return QemuSuiteBackend(exe_path, framework=framework,
+                            enumerator=enumerator,
+                            boot_image=boot_image,
+                            machine_config=machine_config)
+
+
+# The active testaferro session opened by start(), or None: its
+# disposable directory (holding the staged boot image and every run
+# home) plus the recorded image choice, staged lazily on first use.
+_session = None
+
+# Backends holding a booted machine right now. A machine outlives the
+# call that started it, so an interpreter that goes down between
+# start_session() and stop_session() would otherwise leave the guest
+# running — and sweeping its home would pull the disk out from under
+# it. Every exit path stops machines before deleting anything.
+_running = set()
+_sweep_registered = False
+
+
+def _machine_started(backend):
+    """Record a backend whose machine is now running."""
+    global _sweep_registered
+    _running.add(backend)
+    if not _sweep_registered:
+        atexit.register(_stop_running_machines)
+        _sweep_registered = True
+
+
+def _stop_running_machines():
+    """Stop every machine still running, best effort.
+
+    Called before any sweep and again at interpreter exit. One
+    backend failing to stop must not strand the others, so failures
+    are swallowed here; the machine's own home is removed regardless.
+    """
+    for backend in list(_running):
+        try:
+            backend.stop_session()
+        except Exception:
+            _running.discard(backend)
+
+
+def start(boot_image=None):
+    """Open a testaferro session: one boot-image choice serving every
+    suite until stop(). The image itself — `boot_image` or the cached
+    default — is staged lazily on the first guest use, so calling
+    this from a conftest costs nothing when no guest test runs. An
+    atexit failsafe sweeps the session if stop() is never called."""
+    global _session
+    if _session is not None:
+        raise RuntimeError("a testaferro session is already active")
+    root = os.path.join(cache.cache_root(), "sessions")
+    os.makedirs(root, exist_ok=True)
+    _session = {
+        "dir": tempfile.mkdtemp(prefix="session-", dir=root),
+        "boot_image": (None if boot_image is None
+                       else os.fspath(boot_image)),
+    }
+    # failsafe: sweep at interpreter exit if the caller never calls
+    # stop(); an explicit stop() unregisters this again
+    atexit.register(stop)
+
+
+def stop(clear_downloads=False):
+    """Close the session opened by start(), sweeping its whole area —
+    staged image and every run home. Safe to call with no session
+    active. `clear_downloads=True` also removes the cached default
+    boot image, forcing a fresh download next time."""
+    global _session
+    atexit.unregister(stop)
+    # Machines first: the run homes about to be swept are the disks
+    # those guests are running from.
+    _stop_running_machines()
+    if _session is not None:
+        shutil.rmtree(_session["dir"], ignore_errors=True)
+        _session = None
+    if clear_downloads:
+        cached = os.path.join(cache.cache_root(), "boot.img")
+        for path in (cached, cached + ".part"):
+            if os.path.exists(path):
+                os.remove(path)
+
+
+def _session_image():
+    """The active session's staged boot image, staging it on first
+    use from the recorded choice or the cached default."""
+    image = os.path.join(_session["dir"], "boot.img")
+    if not os.path.exists(image):
+        shutil.copy(_session["boot_image"] or _cached_default_image(),
+                    image)
+    return image
+
+
+def _cached_default_image():
+    """testaferro's cached copy of the default boot image: FreeDOS
+    1.4's floppy-edition boot floppy, fetched and hash-verified
+    through reliquary.fetch_media() on first use."""
+    cached = os.path.join(cache.cache_root(), "boot.img")
+    if not os.path.exists(cached):
+        os.makedirs(cache.cache_root(), exist_ok=True)
+        with tempfile.TemporaryDirectory(
+                prefix="download-", dir=cache.cache_root()) as home:
+            assets = os.path.join(home, "assets")
+            os.makedirs(assets)
+            definition = os.path.join(assets, "freedos-floppy.rlqb")
+            with open(definition, "w", encoding="utf-8") as handle:
+                json.dump(_FREEDOS_FLOPPY_MEDIA_DEFINITION, handle)
+            payload = reliquary.fetch_media(
+                _FREEDOS_FLOPPY_MEDIA_NAME,
+                _context(home, assets))
+            shutil.copy(payload, cached + ".part")
+        os.replace(cached + ".part", cached)
+    return cached
+
+
+def _context(home, assets):
+    """A reliquary context pinned to one disposable testaferro home.
+
+    Dir-mode assets keep the resolution hermetic: only what testaferro
+    wrote for this run, never the user's own reliquary home or the
+    built-in codex.
+    """
+    return reliquary.Context(home=home,
+                             cache=os.path.join(home, "cache"),
+                             assets=assets)
+
+
+def _work_drive(drives):
+    """Place testaferro's work drive and name the letter DOS gives it.
+
+    reliquary assigns DOS letters from declared facts alone: floppies
+    take A:/B: by slot and hard disks C: onward in slot order. The
+    work drive takes the lowest free disk slot, so its letter is its
+    own position among the declared disks.
+    """
+    used = sorted({int(key[len("hdd"):] or 0)
+                   for key in drives if key.startswith("hdd")})
+    free = [slot for slot in range(_HDD_SLOTS) if slot not in used]
+    if not free:
+        raise ValueError(
+            "the machine declares every disk slot; testaferro needs one "
+            "free slot for the work drive that carries the suite "
+            "executable into the guest")
+    slot = free[0]
+    letter = chr(ord("C") + sorted(used + [slot]).index(slot))
+    return f"hdd{slot}", letter
+
+
+class QemuSuiteBackend(SuiteBackend):
+    def __init__(self, exe_path, framework=cpputest, enumerator=None,
+                 boot_image=None, machine_config=None):
+        self._boot_image = (None if boot_image is None
+                            else os.fspath(boot_image))
+        self._home = None
+        self._ctx = None
+        self._machine = None
+        self._letter = None
+        self._machine_config = machine_config
+        self._timeout = (
+            _DEFAULT_TIMEOUT if machine_config is None
+            or machine_config.timeout is None else machine_config.timeout)
+        super().__init__(os.fspath(exe_path), run=self._run_in_guest,
+                         framework=framework, enumerator=enumerator)
+
+    def start_session(self):
+        area = _session["dir"] if _session else cache.cache_root()
+        runs = os.path.join(area, "runs")
+        os.makedirs(runs, exist_ok=True)
+        self._home = tempfile.mkdtemp(prefix="run-", dir=runs)
+        assets = os.path.join(self._home, "assets")
+        work = os.path.join(self._home, "work")
+        os.makedirs(assets)
+        os.makedirs(work)
+        # the backend snapshots the host directory when the drive is
+        # attached, so the executable is staged before the machine
+        # boots, not on the first run.
+        shutil.copy2(self._exe, os.path.join(work, self._program()))
+
+        document, self._letter = self._blueprint(work)
+        with open(os.path.join(assets, _BLUEPRINT_NAME + ".rlqb"),
+                  "w", encoding="utf-8") as handle:
+            json.dump(document, handle)
+        self._ctx = _context(self._home, assets)
+        try:
+            self._machine = reliquary.create_machine(
+                _BLUEPRINT_NAME, context=self._ctx)
+            _machine_started(self)
+            reliquary.start_machine(self._machine, context=self._ctx)
+        except BaseException:
+            self.stop_session()
+            raise
+
+    def stop_session(self):
+        if self._home is None:
+            return
+        _running.discard(self)
+        try:
+            if self._machine is not None:
+                reliquary.stop_machine(self._machine,
+                                       context=self._ctx)
+        finally:
+            # The machine's own cache lives under this home, so the
+            # sweep takes the whole run with it.
+            shutil.rmtree(self._home, ignore_errors=True)
+            self._home = None
+            self._ctx = None
+            self._machine = None
+            self._letter = None
+
+    def _program(self):
+        """The suite's guest-side command name."""
+        return os.path.basename(self._exe)
+
+    def _run_in_guest(self, exe_path, args):
+        if self._home is None:
+            raise RuntimeError("no active session: guest runs happen "
+                               "between start_session and stop_session")
+        command = f"{self._letter}:\\{self._program()}"
+        if args:
+            command += " " + " ".join(args)
+        rows = reliquary.exec(command, machine=self._machine,
+                              context=self._ctx,
+                              timeout=self._timeout)
+        return "\n".join(rows) + "\n"
+
+    def _blueprint(self, work):
+        """The blueprint document for this backend session.
+
+        The declaration (or the zero-configuration default) plus
+        testaferro's own work drive, which is how the suite executable
+        reaches the guest. Every drive is authored JSON passed through
+        to reliquary, which owns materialization: a declaration stays
+        a template because reliquary materializes a fresh machine from
+        it each session.
+        """
+        spec = self._machine_config
+        fields = dict(spec.fields) if spec is not None else {}
+        fields.setdefault("platform", "dos")
+        fields.setdefault("memory", _DEFAULT_MEMORY)
+        drives = dict(fields.get("drives") or {})
+        if not drives:
+            drives["floppy0"] = {
+                "type": "media",
+                "name": _BOOT_MEDIA_NAME,
+                "location": {"local": self._boot_media_path()},
+                "materialize": "use",
+            }
+            fields.setdefault("boot", ["floppy0"])
+        key, letter = _work_drive(drives)
+        drives[key] = {
+            "type": "media",
+            "name": _WORK_MEDIA_NAME,
+            "location": {"local": work},
+            "materialize": "use",
+        }
+        fields["drives"] = drives
+        fields["type"] = "machine"
+        fields["name"] = _BLUEPRINT_NAME
+        media = list(spec.media) if spec is not None else []
+        return [fields, *media], letter
+
+    def _boot_media_path(self):
+        """The image the zero-configuration machine boots: this
+        backend's own choice, the session's staged image, or the
+        cached default."""
+        if self._boot_image is not None:
+            return self._boot_image
+        return _session_image() if _session else _cached_default_image()

testaferro/suite.py

@@ -0,0 +1,51 @@
+# SPDX-FileCopyrightText: 2026 Paul Galbraith
+# SPDX-License-Identifier: BSD-3-Clause
+"""SuiteBackend: internal execution × framework composition.
+
+The reliquary-backed platform binding supplies the execution callable;
+the framework adapter exposes list_argv/run_all_argv/run_one_argv and
+parse_list/parse_run (e.g. testaferro.cpputest). Neither aspect knows
+the other exists. The callable remains an internal testing and
+composition seam, not a public runner contract.
+
+    backend = SuiteBackend("VRING16.EXE",
+                           run=run_guest_program,
+                           framework=cpputest)
+
+The optional `enumerator` replaces guest enumeration with a faster
+source of the same list — e.g. a host-built twin executable — without
+changing where the tests actually run.
+"""
+
+from __future__ import annotations
+
+from .backend import Backend, TestId, TestOutcome
+
+
+class SuiteBackend(Backend):
+    def __init__(self, exe_path, run, framework, enumerator=None):
+        self._exe = exe_path
+        self._run = run
+        self._framework = framework
+        self._enumerator = enumerator
+
+    def list_tests(self) -> "list[TestId]":
+        if self._enumerator is not None:
+            return self._enumerator()
+        return self._framework.parse_list(
+            self._run(self._exe, self._framework.list_argv()))
+
+    def run_test(self, group, name) -> TestOutcome:
+        outcomes = self._framework.parse_run(
+            self._run(self._exe,
+                      self._framework.run_one_argv(group, name)))
+        for outcome in outcomes:
+            if (outcome.group, outcome.name) == (group, name):
+                return outcome
+        raise LookupError(
+            f"target did not run test {group}.{name} "
+            "(host and target test lists out of sync?)")
+
+    def run_all(self) -> "list[TestOutcome]":
+        return self._framework.parse_run(
+            self._run(self._exe, self._framework.run_all_argv()))

testaferro-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: testaferro
+Version: 0.1.0.dev0
+Summary: pytest facade for DOS-based CppUTest unit testing, run via QEMU
+Author-email: Paul Galbraith <paul@galbraiths.ca>
+License-Expression: BSD-3-Clause
+Keywords: pytest,cpputest,qemu,dos,testing,guest
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest
+Requires-Dist: reliquary==0.1.0.dev2
+Dynamic: license-file
+
+# testaferro
+
+testaferro is a pytest facade for DOS-based CppUTest unit testing: a CppUTest suite built for DOS runs inside a QEMU
+guest via reliquary, and its tests surface as pytest tests on the host — running, selecting, and
+reporting them feels like an ordinary local pytest run.
+
+DOS and CppUTest are what it supports today. Reliquary owns the guest-machine side; testaferro owns the pytest facade and
+its test-framework adapters. Other platforms and frameworks are not built; what has been argued for them, and what the
+project has decided so far, is in [planning/](planning/).
+
+## Status: alpha
+
+The architecture is built and works for its first target pair: a DOS-built CppUTest suite run inside a QEMU guest,
+surfacing as ordinary pytest items on the host. It was verified end to end before the move onto reliquary's blueprint
+model; since that move the unit suite passes but no guest has actually run, so treat a first run here as unproven
+ground and expect to report what you find. testaferro is pre-1.0 and makes no compatibility promise: interfaces change
+coherently and completely, without a bridge for the old shape.
+
+## Usage
+
+Hand the facade a reference to the suite executable in a normal pytest test module:
+
+```python
+from pathlib import Path
+
+import testaferro
+
+test_guest_case = testaferro.guest_suite(Path(__file__).parent / "TESTS.EXE")
+```
+
+testaferro interrogates the referenced file and selects the matching guest backend: a DOS executable runs inside a
+QEMU guest through reliquary (a dependency of testaferro), while a provably non-DOS binary — say, the host
+build of the suite passed by mistake — is rejected with a clear error before any guest boots, naming the format and
+architecture it found (Windows PE, Linux/BSD ELF, macOS Mach-O, 16-bit NE/LX/LE; x86 through ARM64). Headerless
+images (`.com`-style raw code) carry nothing to prove, so they pass through for the guest itself to judge. The framework adapter
+defaults to `testaferro.cpputest`; pass `framework=` to use a different one.
+
+The guest machine's working state is testaferro's business, not the consumer's: each run happens in a fresh, disposable
+reliquary home under testaferro's cache (`%LOCALAPPDATA%\testaferro` on Windows, `$XDG_CACHE_HOME/testaferro`
+elsewhere), and the machine is created there fresh for the session and swept away with it. Zero configuration boots a
+FreeDOS image that is downloaded once and cached; pass `boot_image=` to boot a caller-supplied DOS floppy image
+instead.
+
+The suite executable reaches the guest on a work drive testaferro adds to the machine: a host directory served into the
+guest as a FAT volume, with the executable staged into it before boot. The guest sees it as its first hard disk —
+normally `C:` — and testaferro runs it there by name. Nothing is written into your boot image.
+
+### Named test machines
+
+Declare a named machine once when several suites share it. A declaration is a reliquary **blueprint** — the machine's
+own description, in reliquary's vocabulary. `config()` accepts blueprint machine fields directly (`memory`, `drives`,
+`boot`, `backend_settings`, …), or a complete `machine_config=` template: a `MachineSpec`, a mapping, a whole blueprint
+document, or a path to a `.rlqb` file. The template supplies its platform when it declares one; `platform=` is optional
+and verifies an explicit choice.
+
+```python
+import testaferro
+
+testaferro.config("msdos", boot_image="images/msdos.img", memory=32)
+
+test_guest_case = testaferro.guest_suite(
+    "build/TESTS.EXE", machine="msdos")
+```
+
+The same declarations can live in an optional per-project `testaferro.ini` — one section per machine, the
+declarative twin of `config()`. `guest_suite()` searches upward from the calling test module and loads the file
+automatically, so the suite can name only the executable when a unique machine matches:
+
+```ini
+[msdos]
+boot_image = images/msdos.img
+memory = 32
+
+[custom]
+machine_config = machines/custom.rlqb
+```
+
+```python
+test_guest_case = testaferro.guest_suite("build/TESTS.EXE")
+```
+
+Relative `boot_image` / `machine_config` / `template` paths resolve from the ini file's directory. Structured blueprint
+fields (`drives`, `boot`, `scripts`, `backend_settings`, `control_planes`, `parameters`) accept JSON values; a bare
+integer stays an integer, so `memory = 32` and `memory = 32M` are both accepted. Call `testaferro.load_config(path)` to
+load an explicit file, or `load_config()` to search upward from the current directory.
+
+A declaration is a template, never a running machine: every backend session creates a fresh machine from it, so runs do
+not share guest state. What that costs per session is the blueprint's own business — reliquary's `materialize` mode on
+each drive decides whether media is attached in place, copied, or layered. Use `platform="dos"` or `machine="msdos"`
+when more than one configured DOS machine would otherwise match. With no declarations, DOS executables retain the
+implicit downloaded-FreeDOS machine.
+
+With several guest suites — or parallel pytest processes — open a *session*, so the image choice is made once and
+every run's state is swept together. From the consuming project's `conftest.py`:
+
+```python
+import testaferro
+
+testaferro.start()                  # or testaferro.start(boot_image=...)
+
+def pytest_unconfigure(config):
+    testaferro.stop()
+```
+
+`start()` costs nothing until a guest actually runs; `stop()` sweeps the session's staged image and every run home,
+keeping the once-downloaded FreeDOS image cached for the next session (`stop(clear_downloads=True)` scrubs that too).
+Forgetting `stop()` is not fatal — `start()` registers an `atexit` failsafe that sweeps the session at interpreter
+exit — but the explicit call is still preferred: it cleans up at a deterministic point and is where
+`clear_downloads=True` can be said.
+
+Because every run gets a private home and a private image copy, suites in separate pytest processes never share
+mutable guest state — safe to parallelize. With [pytest-xdist](https://pypi.org/project/pytest-xdist/), run
+`pytest -n auto --dist loadfile`: `loadfile` keeps each test file's items on one worker, so a whole guest suite stays
+together (preserving the one-boot `run_all()` batching) while *different* suites boot their guests concurrently on
+other workers. Plain `--dist load` would scatter a suite's items across workers and degrade it to one boot per test.
+
+Backend lifecycle hooks are automatic. Enumeration runs in a short collection session; selected tests then share one
+execution session, which is cleaned up by pytest even when a test fails.
+
+Every test in the guest suite becomes its own pytest item, so pytest's selection drives what actually runs remotely:
+
+- run everything (`pytest`) and the facade batches the whole suite into a single guest run — one execution boot for the
+  session;
+- narrow the selection (`pytest -k Wraps`, an explicit node id) and only the selected tests run in the guest,
+  individually.
+
+A failing guest test fails its pytest item with the guest side's original file, line, and assertion message — not a
+traceback into the facade. IDE test integrations work per item too: the generated test function reports the
+`guest_suite()` call site as its source, so run-this-test and jump-to-source in PyCharm-style test trees resolve to
+your module.
+
+Under the hood, reliquary owns the guest machine and a framework adapter knows the suite's argv and output grammar.
+`testaferro.suite.SuiteBackend` composes reliquary execution with the selected adapter; `guest_suite()` also accepts a
+prebuilt backend as the custom escape hatch.
+
+Enumeration can be delegated to a host-built twin of a guest suite through `enumerator=`, and for a suite of any size
+it should be. Guest output is captured by reading the guest's screen, so a command whose output scrolls past one
+screenful leaves only its tail there — which bites enumeration hardest, since `-ln` lists every test at once. A host
+twin built from the same sources both avoids that and keeps the two builds honest against each other: a test the guest
+build dropped shows up as one that did not run.
+
+The framework adapter remains usable directly where the facade is more than you need — it is just argv and grammar,
+independent of how you obtained the output:
+
+```python
+from testaferro import cpputest
+
+results = cpputest.parse(log)  # {"ran", "failed", "summary"}
+```
+
+## Tests
+
+```powershell
+python -m unittest discover -s tests -v
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, the required checks, and contribution licensing terms.
+
+## License
+
+BSD 3-Clause; see [LICENSE](LICENSE). The project follows REUSE conventions (SPDX headers
+plus [REUSE.toml](REUSE.toml)).

testaferro-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,14 @@
+testaferro/__init__.py,sha256=SndrEaMGYlN6l-yUC7e59gEufRuHjckHhN-zUzKmzZs,3038
+testaferro/backend.py,sha256=k9Zg4SL7SZWDhXWOOWEeG_QFAEa2x2C_9GJlmfe6Ccc,1861
+testaferro/binfmt.py,sha256=3npAcWwRxpn7OMF8M7okQIiWi1NhwS5mXwIpMdehgDs,4658
+testaferro/cache.py,sha256=h9a7uxbCOsW_1sFJ-98o5o8kHjAqXURjLza2xONHx58,789
+testaferro/cpputest.py,sha256=AUWTYBY7IAX14ckeORcEKa863AAofWrdbYdvy0i61nM,4639
+testaferro/facade.py,sha256=pL8NX762S2NMvIVrqyCuMczJq2SfGzq7JdIAfJ7fh8Q,9440
+testaferro/machines.py,sha256=7N6M_hpXCXKWlRqhrM018-KKJIX9ePXjc9I5dKwVgu8,15196
+testaferro/qemu.py,sha256=g0etBiGCQQrziwiWaiWGlpajmsCiVCmzbmE3is1G-qM,14895
+testaferro/suite.py,sha256=9KwDr71DgLuFBoExlDx8kB29iVOofF5phLuWPmLc24Y,1957
+testaferro-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=PQZNmWpJyQDBeiUj6i7KYIamCtH1SzVXSW4Q4sTfA9c,1501
+testaferro-0.1.0.dev0.dist-info/METADATA,sha256=zdkV3_3ZH4L7Nsd3HSBZRwGp_ARFVTgP3DVPXm8-Q7s,9602
+testaferro-0.1.0.dev0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+testaferro-0.1.0.dev0.dist-info/top_level.txt,sha256=tvsT9wvRXkh2cWG6ruTDM4xd0dsR5yzM2E0gHWF4pyc,11
+testaferro-0.1.0.dev0.dist-info/RECORD,,

testaferro-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

testaferro-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Paul Galbraith
+
+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.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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.

testaferro-0.1.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+testaferro