mirror of
https://github.com/Abdess/retroarch_system.git
synced 2026-10-20 10:23:16 -05:00
Abdessamad Derraz
ab1f5d7eb4
Two test docstrings named the maintainer's private notes file, and nothing stopped it. They now state the rule itself, and test_prose_style fails on any tracked file that names the private notes or the assistant tooling.
197 lines
8.6 KiB
Python
197 lines
8.6 KiB
Python
"""A hardware target names its artifacts by the name it is filed under.
|
|
|
|
`switch`, `nx` and `nintendo-switch` are one RetroArch target. The tag came
|
|
from the name as typed, so one target gave three pack and manifest names,
|
|
and `--verify-packs --target nx` looked for a pack nobody had built.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(REPO_ROOT / "scripts"))
|
|
|
|
from common import canonical_target_name # noqa: E402
|
|
|
|
|
|
class AliasesResolveToOneName(unittest.TestCase):
|
|
def test_retroarch_switch_aliases(self):
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
for typed in ("switch", "nx", "nintendo-switch"):
|
|
with self.subTest(typed=typed):
|
|
self.assertEqual(
|
|
canonical_target_name(["retroarch"], typed, platforms),
|
|
"nintendo-switch",
|
|
)
|
|
|
|
def test_raspberry_pi_models_reach_batocera_boards(self):
|
|
"""`--target rpi4`, the example every --help gives, was refused on
|
|
Batocera: its boards are named by SoC and no alias pointed there."""
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
for typed, board in (("rpi4", "bcm2711"), ("rpi5", "bcm2712"),
|
|
("rpi3", "bcm2837"), ("rpi-zero", "bcm2835")):
|
|
with self.subTest(typed=typed):
|
|
self.assertEqual(canonical_target_name(["batocera"], typed, platforms), board)
|
|
|
|
def test_linux_on_arm_and_32_bit_x86_is_a_target(self):
|
|
"""The buildbot's linux/aarch64 (232 cores) and linux/x86 builds were
|
|
not scraped: --target refused RetroArch on Raspberry Pi OS 64-bit."""
|
|
import yaml # noqa: PLC0415
|
|
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
targets = yaml.safe_load((REPO_ROOT / "platforms" / "targets" / "retroarch.yml")
|
|
.read_text())["targets"]
|
|
for typed, target in (("arm64", "linux-aarch64"), ("i686", "linux-x86")):
|
|
with self.subTest(typed=typed):
|
|
self.assertEqual(canonical_target_name(["retroarch"], typed, platforms), target)
|
|
self.assertGreater(len(targets[target]["cores"]), 100)
|
|
|
|
def test_an_unknown_name_is_left_for_the_target_check(self):
|
|
self.assertEqual(
|
|
canonical_target_name(["retroarch"], "bogus", str(REPO_ROOT / "platforms")),
|
|
"bogus",
|
|
)
|
|
|
|
|
|
class TheBuilderNamesByTheCanonicalTarget(unittest.TestCase):
|
|
def test_an_alias_writes_the_canonical_manifest(self):
|
|
if not (REPO_ROOT / "database.json").exists():
|
|
self.skipTest("database.json is not built")
|
|
(REPO_ROOT / "tmp").mkdir(exist_ok=True)
|
|
with tempfile.TemporaryDirectory(dir=REPO_ROOT / "tmp") as out:
|
|
proc = subprocess.run(
|
|
[sys.executable, "scripts/generate_pack.py", "--platform", "retroarch",
|
|
"--target", "nx", "--manifest", "--offline", "--output-dir", out],
|
|
cwd=REPO_ROOT, capture_output=True, text=True, timeout=600, check=False,
|
|
)
|
|
self.assertEqual(proc.returncode, 0, proc.stderr)
|
|
self.assertEqual(
|
|
sorted(p.name for p in Path(out).glob("*.json")),
|
|
["retroarch_nintendoswitch.json"],
|
|
)
|
|
|
|
|
|
|
|
class EachPlatformNamesTheTargetItsOwnWay(unittest.TestCase):
|
|
"""rpi4 is Batocera's bcm2711, Recalbox's rpi4_64 and RetroPie's rpi4.
|
|
Named once for the run, --all kept "rpi4" for all three while
|
|
--platform batocera named the same pack Bcm2711, so --verify-packs
|
|
answered SKIP for a pack the --all build had written."""
|
|
|
|
def test_the_all_run_and_the_platform_run_agree(self):
|
|
import contextlib # noqa: PLC0415
|
|
import io # noqa: PLC0415
|
|
|
|
import generate_pack # noqa: PLC0415
|
|
|
|
platforms_dir = str(REPO_ROOT / "platforms")
|
|
with contextlib.redirect_stdout(io.StringIO()):
|
|
expected = generate_pack._expected_pack_names(
|
|
["batocera", "recalbox"], platforms_dir, None, "rpi4"
|
|
)
|
|
self.assertTrue(any("_Bcm2711_" in name for name in expected["batocera"]))
|
|
self.assertTrue(any("_Rpi464_" in name for name in expected["recalbox"]))
|
|
for platform, tag in (("batocera", "bcm2711"), ("recalbox", "rpi4_64")):
|
|
self.assertEqual(
|
|
generate_pack._platform_target(platform, "rpi4", platforms_dir), tag
|
|
)
|
|
|
|
def test_no_naming_site_reads_the_typed_target(self):
|
|
source = (REPO_ROOT / "scripts" / "generate_pack.py").read_text()
|
|
self.assertNotIn("target_name=args.target,\n one_per_slot", source)
|
|
self.assertNotIn("args.target = canonical_target_name(", source)
|
|
|
|
|
|
class OneTruthModelPerTarget(unittest.TestCase):
|
|
"""generate_truth slugged the typed name: --target nx, switch and
|
|
nintendo-switch wrote three copies of one model, and the pipeline's diff
|
|
rebuilt the same slug by hand to find it."""
|
|
|
|
def test_aliases_share_a_directory(self):
|
|
from common import truth_target_dir # noqa: PLC0415
|
|
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
dirs = {
|
|
truth_target_dir("truth", ["retroarch"], alias, platforms)
|
|
for alias in ("nx", "switch", "nintendo-switch")
|
|
}
|
|
self.assertEqual(dirs, {str(Path("truth") / "nintendo-switch")})
|
|
# Lakka builds an image named switch: its own target, its own model.
|
|
self.assertEqual(
|
|
truth_target_dir("truth", ["lakka"], "switch", platforms),
|
|
str(Path("truth") / "switch"),
|
|
)
|
|
|
|
def test_writer_and_reader_call_one_function(self):
|
|
for module in ("generate_truth.py", "diff_truth.py"):
|
|
source = (REPO_ROOT / "scripts" / module).read_text()
|
|
with self.subTest(module=module):
|
|
self.assertIn("truth_target_dir(", source)
|
|
self.assertNotIn('re.sub(\n r"[^a-z0-9]+"', source)
|
|
pipeline = (REPO_ROOT / "scripts" / "pipeline.py").read_text()
|
|
self.assertIn('diff_cmd.extend(["--target", args.target])', pipeline)
|
|
|
|
|
|
class TheListingCountsWhatTheFilterUses(unittest.TestCase):
|
|
"""--list-targets showed Batocera x86_64 with 198 cores; --target x86_64
|
|
filters on 187 once _overrides.yml removes machine variants and launchers."""
|
|
|
|
def test_every_listed_count_is_the_filtered_set(self):
|
|
from common import list_available_targets, load_target_config # noqa: PLC0415
|
|
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
checked = 0
|
|
for target_file in sorted((REPO_ROOT / "platforms" / "targets").glob("[!_]*.yml")):
|
|
platform = target_file.stem
|
|
for row in list_available_targets(platform, platforms):
|
|
with self.subTest(platform=platform, target=row["name"]):
|
|
resolved = load_target_config(platform, row["name"], platforms)
|
|
self.assertEqual(row["core_count"],
|
|
None if resolved is None else len(resolved))
|
|
checked += 1
|
|
self.assertGreater(checked, 0)
|
|
|
|
|
|
class ASingleTargetFiltersNothing(unittest.TestCase):
|
|
"""The single-target rule, held on the real data: RetroBat, RetroDECK and RomM
|
|
have one target each, and hand-kept lists dropped 98, 300 and 132 cores
|
|
from a pack the user had only asked to name."""
|
|
|
|
def test_the_only_target_resolves_every_declared_core(self):
|
|
import glob # noqa: PLC0415
|
|
|
|
import yaml # noqa: PLC0415
|
|
|
|
from common import ( # noqa: PLC0415
|
|
load_emulator_profiles,
|
|
load_platform_config,
|
|
load_target_config,
|
|
resolve_platform_cores,
|
|
)
|
|
|
|
platforms = str(REPO_ROOT / "platforms")
|
|
profiles = load_emulator_profiles(str(REPO_ROOT / "emulators"))
|
|
checked = 0
|
|
for path in sorted(glob.glob(str(REPO_ROOT / "platforms" / "targets" / "*.yml"))):
|
|
name = Path(path).stem
|
|
if name.startswith("_"):
|
|
continue
|
|
targets = yaml.safe_load(Path(path).read_text())["targets"]
|
|
if len(targets) != 1:
|
|
continue
|
|
with self.subTest(platform=name):
|
|
config = load_platform_config(name, platforms)
|
|
only = load_target_config(name, next(iter(targets)), platforms)
|
|
self.assertEqual(resolve_platform_cores(config, profiles, target_cores=only),
|
|
resolve_platform_cores(config, profiles))
|
|
checked += 1
|
|
self.assertGreaterEqual(checked, 3)
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|