Catcrafts/Crafter.Build
2
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

test: migrate cross-arch tests to declarative test.toml; add WindowsViaWine

Browse source 
Collapses three outer-driver tests into declarative top-level fixtures:

  - CrossArchAarch64: outer + inner pair becomes main.cpp + test.toml. The
    'is this really an ARM aarch64 ELF?' artifact-introspection check is
    dropped — qemu-aarch64 refuses to run wrong-arch ELFs anyway, so a
    silent host-arch fallback would still fail the run.
  - Wasi: outer + inner pair becomes main.cpp + test.toml. The WASM
    magic-byte check is dropped on the same logic (wasmtime refuses
    non-WASM input).
  - Defines: simple defines-propagation smoke test becomes test.toml with
    [defines] CRAFTER_TEST_FOO = "42".

Adds WindowsViaWine to replace the (forthcoming-deletion) WindowsViaSsh:
declarative target=x86_64-w64-mingw32 + requires=[tool:wine,
tool:x86_64-w64-mingw32-g++]. Exercises the new Wine runner and the
ForTarget derivation end-to-end.

Diamond and CrossProjectModule had speculative --target= reading that
made them attempt cross-compilation under the multi-target sweep. They
have no sysroot/toolchain plumbing, so those cross-builds always fail.
Hardcoded them to HostTarget(); cross-arch tests live in their own
test.toml from now on.

Refs issue #8.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jorijn van der Graaf 2026-05-27 18:01:49 +02:00
commit 406a406420
16 changed files with 50 additions and 238 deletions
Download patch file Download diff file Expand all files Collapse all files

78
tests/CrossArchAarch64/CrossArchAarch64.cpp
View file

@ -1,78 +0,0 @@
/*
Crafter® Build
Copyright (C) 2026 Catcrafts®
Catcrafts.net
LGPL-3.0-only.
End-to-end cross-arch build through the V2 pipeline:
the inner project.cpp targets aarch64-linux-gnu with cfg.sysroot pointing at
the Arch Linux ARM rootfs at /opt/aarch64-rootfs. crafter.build-lib
cross-compiles the C++ source (with the libc++ std module from the sysroot),
produces a real aarch64 ELF, and qemu-aarch64 (with QEMU_LD_PREFIX pointing at
the sysroot so it can find ld-linux-aarch64.so.1) executes it.
*/
import std;
import Crafter.Build;
#include "../_shared/TestUtil.h"
namespace fs = std::filesystem;
using namespace TestUtil;
using namespace Crafter;
namespace {
bool ToolPresent(std::string_view name) {
return std::system(std::format("which {} > /dev/null 2>&1", name).c_str()) == 0;
}
}
int main() {
try {
const fs::path sysroot = "/opt/aarch64-rootfs";
if (!fs::exists(sysroot / "usr/share/libc++/v1/std.cppm")) {
Skip(std::format("aarch64 sysroot missing at {} — see README", sysroot.string()));
}
if (!ToolPresent("qemu-aarch64")) Skip("qemu-aarch64 not on PATH");
fs::path src = fs::current_path() / "tests" / "CrossArchAarch64" / "inner";
Configuration cfg = LoadFixture("CrossArchAarch64", src);
fs::path work = fs::current_path();
auto br = BuildOnce(cfg);
if (!br.result.empty()) {
std::println(std::cerr, "build failed:\n{}", br.result);
return 1;
}
fs::path artifact = cfg.BinDir() / "aarch-hello";
if (!fs::exists(artifact)) {
std::println(std::cerr, "expected artifact missing at {}", artifact.string());
return 1;
}
// Defend against silent host-arch fallback.
auto probe = RunInDir(work, std::format("file '{}'", artifact.string()));
if (probe.output.find("ARM aarch64") == std::string::npos) {
std::println(std::cerr, "artifact is not ARM aarch64 ELF:\n{}", probe.output);
return 1;
}
// Run via qemu-aarch64. QEMU_LD_PREFIX tells qemu where the target's
// dynamic linker (ld-linux-aarch64.so.1) and shared libs live.
auto run = RunInDir(work, std::format(
"QEMU_LD_PREFIX={} qemu-aarch64 '{}'",
sysroot.string(), artifact.string()));
if (run.exitCode != 0) {
std::println(std::cerr, "qemu-aarch64 run failed (rc={}):\n{}", run.exitCode, run.output);
return 1;
}
if (run.output != "hi from 64-bit aarch64\n") {
std::println(std::cerr, "output mismatch:\n expected: \"hi from 64-bit aarch64\\n\"\n got: {:?}", run.output);
return 1;
}
return 0;
} catch (const std::exception& e) {
std::println(std::cerr, "test exception: {}", e.what());
return 1;
}
}

23
tests/CrossArchAarch64/inner/project.cpp
View file

@ -1,23 +0,0 @@
import std;
import Crafter.Build;
namespace fs = std::filesystem;
using namespace Crafter;
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view>) {
Configuration cfg;
cfg.path = "./";
cfg.name = "aarch-hello";
cfg.outputName = "aarch-hello";
cfg.target = "aarch64-linux-gnu";
cfg.march = "armv8-a";
cfg.mtune = "generic";
cfg.sysroot = "/opt/aarch64-rootfs";
cfg.type = ConfigurationType::Executable;
std::array<fs::path, 0> ifaces = {};
std::array<fs::path, 1> impls = { "main" };
cfg.GetInterfacesAndImplementations(ifaces, impls);
return cfg;
}

0
tests/CrossArchAarch64/inner/main.cpp → tests/CrossArchAarch64/main.cpp
View file

20
tests/CrossArchAarch64/project.cpp
View file

@ -1,20 +0,0 @@
import std;
import Crafter.Build;
namespace fs = std::filesystem;
using namespace Crafter;
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view>) {
Configuration cfg;
cfg.path = "tests/CrossArchAarch64/";
cfg.name = "CrossArchAarch64";
cfg.outputName = "CrossArchAarch64";
cfg.target = "x86_64-pc-linux-gnu";
cfg.type = ConfigurationType::Executable;
cfg.dependencies = { ParentLib("crafter.build-lib") };
cfg.linkFlags.push_back("-Wl,--export-dynamic");
cfg.linkFlags.push_back("-ldl");
std::array<fs::path, 0> ifaces = {};
std::array<fs::path, 1> impls = { "CrossArchAarch64" };
cfg.GetInterfacesAndImplementations(ifaces, impls);
return cfg;
}

13
tests/CrossArchAarch64/test.toml Normal file
View file

@ -0,0 +1,13 @@
# End-to-end cross-arch build:
# crafter-build cross-compiles main.cpp for aarch64-linux-gnu using the
# Arch Linux ARM sysroot, and the runner derivation (TestRunner::ForTarget)
# wraps the produced ELF in `qemu-aarch64`. cfg.sysroot is forwarded to
# QEMU_LD_PREFIX automatically so the target's dynamic linker is reachable.
target = "aarch64-linux-gnu"
march = "armv8-a"
mtune = "generic"
sysroot = "/opt/aarch64-rootfs"
requires = [
"tool:qemu-aarch64",
"file:/opt/aarch64-rootfs/usr/share/libc++/v1/std.cppm",
]