Merge pull request #3 from allyourcodebase/tests

Replace Zig tests with upstream testing framework

Author: Parzival-3141

ClarTestStep.zig

@@ -0,0 +1,240 @@
+//! Runs a Clar test and lightly parses it's [TAP](https://testanything.org/) stream,
+//! reporting progress/errors to the build system.
+// Based on Step.Run
+
+step: Step,
+runner: *Step.Compile,
+args: std.ArrayListUnmanaged([]const u8),
+
+const ClarTestStep = @This();
+
+pub fn create(owner: *std.Build, name: []const u8, runner: *Step.Compile) *ClarTestStep {
+    const clar = owner.allocator.create(ClarTestStep) catch @panic("OOM");
+    clar.* = .{
+        .step = Step.init(.{
+            .id = .custom,
+            .name = name,
+            .owner = owner,
+            .makeFn = make,
+        }),
+        .runner = runner,
+        .args = .{},
+    };
+    runner.getEmittedBin().addStepDependencies(&clar.step);
+    return clar;
+}
+
+pub fn addArg(clar: *ClarTestStep, arg: []const u8) void {
+    const b = clar.step.owner;
+    clar.args.append(b.allocator, b.dupe(arg)) catch @panic("OOM");
+}
+
+pub fn addArgs(clar: *ClarTestStep, args: []const []const u8) void {
+    for (args) |arg| clar.addArg(arg);
+}
+
+fn make(step: *Step, options: Step.MakeOptions) !void {
+    const clar: *ClarTestStep = @fieldParentPtr("step", step);
+    const b = step.owner;
+    const arena = b.allocator;
+
+    var man = b.graph.cache.obtain();
+    defer man.deinit();
+
+    var argv_list: std.ArrayList([]const u8) = .init(arena);
+    {
+        const file_path = clar.runner.installed_path orelse clar.runner.generated_bin.?.path.?;
+        try argv_list.append(file_path);
+        _ = try man.addFile(file_path, null);
+    }
+    try argv_list.append("-t"); // force TAP output
+    for (clar.args.items) |arg| {
+        try argv_list.append(arg);
+        man.hash.addBytes(arg);
+    }
+
+    if (try step.cacheHitAndWatch(&man)) {
+        // cache hit, skip running command
+        step.result_cached = true;
+        return;
+    }
+
+    {
+        var child: std.process.Child = .init(argv_list.items, arena);
+        child.stdin_behavior = .Ignore;
+        child.stdout_behavior = .Pipe;
+        child.stderr_behavior = .Ignore;
+
+        try child.spawn();
+
+        var poller = std.io.poll(
+            b.allocator,
+            enum { stdout },
+            .{ .stdout = child.stdout.? },
+        );
+        defer poller.deinit();
+
+        const fifo = poller.fifo(.stdout);
+        const r = fifo.reader();
+
+        var buf: std.BoundedArray(u8, 1024) = .{};
+        const w = buf.writer();
+
+        var parser: TapParser = .default;
+        var node: ?std.Progress.Node = null;
+        defer if (node) |n| n.end();
+
+        while (true) {
+            r.streamUntilDelimiter(w, '\n', null) catch |err| switch (err) {
+                error.EndOfStream => if (try poller.poll()) continue else break,
+                else => return err,
+            };
+
+            const line = buf.constSlice();
+            defer buf.resize(0) catch unreachable;
+
+            switch (try parser.parseLine(arena, line)) {
+                .start_suite => |suite| {
+                    if (node) |n| n.end();
+                    node = options.progress_node.start(suite, 0);
+                },
+                .ok => {
+                    if (node) |n| n.completeOne();
+                },
+                .failure => |fail| {
+                    // @Cleanup print failures in a nicer way. Avoid redundant "error:" prefixes on newlines with minimal allocations.
+                    try step.result_error_msgs.append(arena, fail.description.items);
+                    try step.result_error_msgs.appendSlice(arena, fail.reasons.items);
+                    try step.result_error_msgs.append(arena, "\n");
+                    if (node) |n| n.completeOne();
+                    parser.reset();
+                },
+                .feed_line => {},
+            }
+        }
+
+        const term = try child.wait();
+        try step.handleChildProcessTerm(term, null, argv_list.items);
+    }
+
+    try step.writeManifestAndWatch(&man);
+}
+
+const TapParser = struct {
+    state: State,
+    wip_failure: Result.Failure,
+
+    const Result = union(enum) {
+        start_suite: []const u8,
+        ok,
+        failure: Failure,
+        feed_line,
+
+        const Failure = struct {
+            description: std.ArrayListUnmanaged(u8),
+            reasons: std.ArrayListUnmanaged([]const u8),
+        };
+    };
+
+    const keyword = struct {
+        const suite_start = "# start of suite ";
+        const ok = "ok ";
+        const not_ok = "not ok ";
+        const spacer1 = " - ";
+        const spacer2 = ": ";
+        const yaml_blk = " ---";
+        const pre_reason = "reason: |";
+        const at = "at:";
+        const file = "file: ";
+        const line = "line: ";
+    };
+
+    const State = enum {
+        start,
+        desc,
+        yaml_start,
+        pre_reason,
+        reason,
+        file,
+        line,
+    };
+
+    fn parseLine(p: *TapParser, step_arena: Allocator, line: []const u8) Allocator.Error!Result {
+        loop: switch (p.state) {
+            .start => {
+                if (mem.startsWith(u8, line, keyword.suite_start)) {
+                    const suite_start = skip(line, keyword.spacer2, keyword.suite_start.len) orelse @panic("expected suite number");
+                    return .{ .start_suite = line[suite_start..] };
+                } else if (mem.startsWith(u8, line, keyword.ok)) {
+                    return .ok;
+                } else if (mem.startsWith(u8, line, keyword.not_ok)) {
+                    p.state = .desc;
+                    continue :loop p.state;
+                }
+            },
+
+            // Failure parsing
+            .desc => {
+                const name_start = skip(line, keyword.spacer1, keyword.not_ok.len) orelse @panic("expected spacer");
+                const name = mem.trim(u8, line[name_start..], &std.ascii.whitespace);
+                try p.wip_failure.description.appendSlice(step_arena, name);
+                try p.wip_failure.description.appendSlice(step_arena, ": ");
+                p.state = .yaml_start;
+            },
+            .yaml_start => {
+                _ = mem.indexOf(u8, line, keyword.yaml_blk) orelse @panic("expected yaml_blk");
+                p.state = .pre_reason;
+            },
+            .pre_reason => {
+                _ = mem.indexOf(u8, line, keyword.pre_reason) orelse @panic("expected pre_reason");
+                p.state = .reason;
+            },
+            .reason => {
+                if (mem.indexOf(u8, line, keyword.at) != null) {
+                    p.state = .file;
+                } else {
+                    const ln = mem.trim(u8, line, &std.ascii.whitespace);
+                    try p.wip_failure.reasons.append(step_arena, try step_arena.dupe(u8, ln));
+                }
+            },
+            .file => {
+                const file_start = skip(line, keyword.file, 0) orelse @panic("expected file");
+                const file = mem.trim(u8, line[file_start..], std.ascii.whitespace ++ "'");
+                try p.wip_failure.description.appendSlice(step_arena, file);
+                try p.wip_failure.description.append(step_arena, ':');
+                p.state = .line;
+            },
+            .line => {
+                const line_start = skip(line, keyword.line, 0) orelse @panic("expected line");
+                const fail_line = mem.trim(u8, line[line_start..], &std.ascii.whitespace);
+                try p.wip_failure.description.appendSlice(step_arena, fail_line);
+                p.state = .start;
+                return .{ .failure = p.wip_failure };
+            },
+        }
+
+        return .feed_line;
+    }
+
+    fn skip(line: []const u8, to_skip: []const u8, start: usize) ?usize {
+        const index = mem.indexOfPos(u8, line, start, to_skip) orelse return null;
+        return to_skip.len + index;
+    }
+
+    const default: TapParser = .{
+        .state = .start,
+        .wip_failure = .{
+            .description = .empty,
+            .reasons = .empty,
+        },
+    };
+
+    fn reset(p: *TapParser) void {
+        p.* = default;
+    }
+};
+
+const std = @import("std");
+const mem = std.mem;
+const Step = std.Build.Step;
+const Allocator = mem.Allocator;