new tests

interfaces/Crafter.Build-Clang.cppm

@@ -159,6 +159,24 @@ export namespace Crafter {
         std::vector<std::string> linkFlags;
         std::vector<Test> tests;
         CRAFTER_API void GetInterfacesAndImplementations(std::span<fs::path> interfaces, std::span<fs::path> implementations);
+        // Declare a test. Sources default to `tests/<name>/main.cpp` resolved
+        // against this Configuration's path; target/march/mtune/debug are
+        // inherited from this Configuration so cross-arch projects don't have
+        // to re-specify. Returns a builder for chaining defines, deps, etc.
+        // Defined in Crafter.Build:Test.
+        CRAFTER_API struct TestBuilder AddTest(std::string_view name);
+        // Same as AddTest, but compiles the parent's `interfaces` directly
+        // into this test's Configuration (rather than going through a dep).
+        // Use when the test must rebuild those interfaces with its own
+        // compile flags — typically per-march SIMD codegen.
+        CRAFTER_API struct TestBuilder AddTest(std::string_view name, std::span<fs::path> interfaces);
+        // Math-style fan-out: one Test per MarchTier, all sharing the same
+        // `tests/<name>/main.cpp` source and the same interface set, each
+        // compiled with the tier's `-march`/`-mtune`. Test names are
+        // `<name>-<march>`.
+        CRAFTER_API void AddMarchVariants(std::string_view name,
+                                          std::span<fs::path> interfaces,
+                                          std::span<const struct MarchTier> tiers);
         // Suffix that uniquely identifies this Configuration's compile state.
         // target+march+mtune are spelled out for readability; the rest
         // (type, debug, sysroot, defines, compileFlags) collapse into a short

interfaces/Crafter.Build-Test.cppm

@@ -24,6 +24,55 @@ import std;
 import :Clang;
 
 export namespace Crafter {
+    // One row in a SIMD-march fan-out: a single Test variant compiles the
+    // shared source with `-march=<march> -mtune=<mtune>`. Passed by span to
+    // Configuration::AddMarchVariants — see Crafter.Math/project.cpp.
+    struct MarchTier {
+        std::string march;
+        std::string mtune;
+    };
+
+    // Fluent helper returned by Configuration::AddTest. Holds a back-pointer
+    // to the parent Configuration and the index of the just-pushed Test, so
+    // mutations survive any vector reallocation that subsequent AddTest
+    // calls might trigger. Each setter returns `*this` to support chaining.
+    //
+    // Note: source files (interfaces + implementations) are fixed at
+    // AddTest-time — pass them via the AddTest overload that takes
+    // interfaces. The builder only mutates compile state, deps, runtime
+    // args, and requires; it deliberately does NOT expose Sources() to
+    // avoid the double-`GetInterfacesAndImplementations` footgun (calling
+    // it twice would re-parse the same .cppm files into duplicate Module
+    // entries).
+    struct CRAFTER_API TestBuilder {
+        Configuration* parent;
+        std::size_t index;
+
+        Test& test() const { return parent->tests[index]; }
+
+        // Override the path the test's sources resolve against. Defaults to
+        // "./" (project root, where tests/<name>/main.cpp lives). Override
+        // only when the test source layout sits under a subdir.
+        TestBuilder& Path(std::filesystem::path p);
+        TestBuilder& Target(std::string t);
+        TestBuilder& March(std::string m);
+        TestBuilder& Mtune(std::string m);
+        TestBuilder& Sysroot(std::filesystem::path s);
+        TestBuilder& Debug(bool d = true);
+        TestBuilder& Define(std::string name, std::string value = "");
+        TestBuilder& Timeout(std::chrono::seconds s);
+        // Replaces any previously-set args.
+        TestBuilder& Args(std::vector<std::string> a);
+        // Appends one require entry ("tool:foo" / "file:..." / "env:VAR").
+        TestBuilder& Requires(std::string r);
+        // Replaces the dependency list. Pointers must outlive the build.
+        TestBuilder& Dependencies(std::vector<Configuration*> deps);
+        // Append a single linker flag (-l..., -L..., etc.).
+        TestBuilder& LinkFlag(std::string f);
+        // Append a single compile flag.
+        TestBuilder& CompileFlag(std::string f);
+    };
+
     struct RunTestsOptions {
         std::vector<std::string> globs;
         int jobs = 0;