wip add panic_runner to test panics

Panic handlers spawns itself as child process, such that child
communicates passed tests encoded into a message format.

Message format:
[term = process_return, was_panic, message_len, optional message]

This uses a non-standard stream=pipe to allow user logging.
Depends on ziglang#14152.
Closes ziglang#1356.

Author: matu3ba

lib/panic_runner.zig

@@ -0,0 +1,222 @@
+//! Panic test runner
+//! Test Control(TC) starts itself as Test Runner(TR) as childprocess as
+//! [test_runner_exe_path, msg_pipe handle, test_nr].
+//! TR writes [process return, panic?, message len, optional message] into
+//! msg_pipe to TC.
+//! TC spawns TR with the next test_nr, if TR errored or panicked with the
+//! expected message with optionally a predefined message len restriction.
+//! TODO: clarify, if a timeout should be offered as available opt-in functionality.
+
+const std = @import("std");
+const io = std.io;
+const builtin = @import("builtin");
+const os = std.os;
+const ChildProcess = std.ChildProcess;
+const child_process = std.child_process;
+const pipe_rd = child_process.pipe_rd;
+const pipe_wr = child_process.pipe_wr;
+
+// filled by runner
+const global = struct {
+    var msg_pipe: os.fd_t = undefined;
+    var is_runner_panic: bool = false;
+};
+
+// called by runner and control on panic
+// TODO: synchronization etc
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+    _ = stack_trace;
+    if (global.is_runner_panic) {
+        var msg_pipe_file = std.fs.File{
+            .handle = global.msg_pipe,
+        };
+        const msg_pipe_wr = msg_pipe_file.writer();
+        msg_pipe_wr.writeAll(message) catch |err| {
+            const stderr_wr = std.io.getStdErr().writer();
+            stderr_wr.print("could not write msg pipe due to {any}\n", .{err}) catch |err2| {
+                const stdout_wr = std.io.getStdOut().writer();
+                stdout_wr.print("could not write stderr due to {any}\n", .{err2}) catch {};
+            };
+            // TODO: close pipe: workaround process.exit
+            std.process.exit(1);
+        };
+        std.process.exit(0);
+    }
+    // TODO regular panic impl
+}
+
+const State = enum {
+    Control,
+    Worker,
+};
+
+const Cli = struct {
+    state: State,
+    test_nr: u64,
+    test_runner_exe_path: []u8,
+};
+
+/// Messages are either skip, failure, passed and can indicate run or panic.
+const CtrlMsg = struct {
+    //const Self = @This();
+    /// Exit status
+    exit: u8,
+    /// Worker tells in panic handler that it has panicked
+    panicked: bool,
+    /// length of data message for failures
+    /// A panic is not a failure, if it is expected by the Test Control.
+    len: u32,
+
+    // TODO finish this up for Linux
+
+    // const maxsize_testnr: u64 = maxAsciiDigits(std.meta.fieldInfo(CtrlMsg, .testnr).field_type);
+    // const maxsize_exit: u64 = maxAsciiDigits(Self.exit);
+    // const maxsize_len: u64 = maxAsciiDigits(Self.len);
+    // writes into padded msgbuf
+    //fn print(self: *CtrlMsg, msgbuf: []u8) !void {
+    //    // TODO write into buffer
+    //    _ = ctrlmsg;
+    //    _ = msgbuf;
+    //}
+    // reads from padded msgbuf
+    //fn parse(self: *CtrlMsg, msgbuf: []u8) !void {
+    //    _ = ctrlmsg;
+    //    _ = msgbuf;
+    //}
+};
+
+// path_to_testbinary, test number(u32), string(*anyopaque = 64bit)
+var buffer: [std.fs.MAX_PATH_BYTES + 30]u8 = undefined;
+var FixedBufferAlloc = std.heap.FixedBufferAllocator.init(buffer[0..]);
+var fixed_alloc = FixedBufferAlloc.allocator();
+
+fn processArgs(static_alloc: std.mem.Allocator) Cli {
+    const args = std.process.argsAlloc(static_alloc) catch {
+        @panic("Too many bytes passed over the CLI to Test Runner/Control.");
+    };
+    var cli = Cli{
+        .state = undefined,
+        .test_nr = undefined,
+        .test_runner_exe_path = undefined,
+    };
+
+    cli.test_runner_exe_path = args[0];
+    if (args.len == 1) {
+        std.debug.print("test control: {s}\n", .{args[0]});
+        cli.state = .Control;
+        cli.test_nr = 0;
+    } else {
+        std.debug.assert(args.len == 3);
+        std.debug.print("test worker (exe test_nr test_runner_exe_path: ", .{});
+        cli.state = .Worker;
+        std.debug.print("{s} {s} {s}\n", .{ args[0], args[1], args[2] });
+        cli.test_nr = std.fmt.parseUnsigned(u64, args[1], 10) catch unreachable;
+        global.isRunnerPanicy = true;
+        global.msg_pipe = std.fmt.parseUnsigned(u64, args[2], 10) catch unreachable;
+        global.is_runner_panic = true;
+    }
+    return cli;
+}
+
+fn maxAsciiDigits(comptime UT: type) u64 {
+    return std.fmt.count("{d}", .{std.math.maxInt(UT)});
+}
+
+// args: path_to_testbinary, [test_nr pipe_worker_to_ctrl]
+pub fn main() !void {
+    // TODO: use stack allocator per thread for better perf
+    var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
+    defer std.debug.assert(!general_purpose_allocator.deinit());
+    const gpa = general_purpose_allocator.allocator();
+
+    var cli = processArgs(fixed_alloc);
+    switch (cli.state) {
+        .Control => {
+            // pipe TW => TC
+            var buf_handle: [os.handleCharSize]u8 = comptime [_]u8{0} ** os.handleCharSize;
+            var buf_tests_done: [10]u8 = comptime [_]u8{0} ** 10;
+            var last_tests_done: u32 = 0;
+            var tests_done: u32 = 0;
+            const tests_todo = builtin.test_functions.len;
+
+            while (tests_done < tests_todo) {
+                var pipe = try child_process.portablePipe();
+                const s_handle = os.handleToString(pipe[pipe_wr], &buf_handle) catch unreachable;
+                const tests_done_s = std.fmt.bufPrint(&buf_tests_done, "{d}", .{tests_done}) catch unreachable;
+                var child_proc = ChildProcess.init(
+                    &.{ cli.test_runner_exe_path, tests_done_s, s_handle },
+                    gpa,
+                );
+
+                // multi-threading best practice: dont wait for the leak to happen.
+                {
+                    try os.enableInheritance(pipe[pipe_wr]);
+                    defer os.close(pipe[pipe_wr]);
+
+                    try child_proc.spawn();
+                }
+                const res = try child_proc.wait();
+                // TODO parse + compare messages to get amount of tests done
+
+                if (res.Exited != 0 or tests_done == last_tests_done) {
+                    // print both as status
+
+                }
+
+                last_tests_done = tests_done;
+            }
+        },
+        .Worker => {
+            // Continue with next test
+        },
+    }
+    //std.debug.assert(cli.state == .Control);
+
+    var skipped: usize = 0;
+    var failed: usize = 0;
+    for (builtin.test_functions) |test_fn| {
+        test_fn.func() catch |err| {
+            if (err != error.SkipZigTest) {
+                failed += 1;
+            } else {
+                skipped += 1;
+            }
+        };
+    }
+    if (builtin.cpu.arch == .wasm32 or
+        builtin.zig_backend == .stage1 or
+        builtin.zig_backend == .stage2_wasm or
+        builtin.zig_backend == .stage2_x86_64 or
+        builtin.zig_backend == .stage2_aarch64 or
+        builtin.zig_backend == .stage2_llvm or
+        builtin.zig_backend == .stage2_c)
+    {
+        const passed = builtin.test_functions.len - skipped - failed;
+        const stderr = std.io.getStdErr();
+        writeInt(stderr, passed) catch {};
+        stderr.writeAll(" passed; ") catch {};
+        writeInt(stderr, skipped) catch {};
+        stderr.writeAll(" skipped; ") catch {};
+        writeInt(stderr, failed) catch {};
+        stderr.writeAll(" failed.\n") catch {};
+    }
+    if (failed != 0) {
+        return error.TestsFailed;
+    }
+}
+
+fn writeInt(stderr: std.fs.File, int: usize) anyerror!void {
+    const base = 10;
+    var buf: [100]u8 = undefined;
+    var a: usize = int;
+    var index: usize = buf.len;
+    while (true) {
+        const digit = a % base;
+        index -= 1;
+        buf[index] = std.fmt.digitToChar(@intCast(u8, digit), .lower);
+        a /= base;
+        if (a == 0) break;
+    }
+    const slice = buf[index..];
+    try stderr.writeAll(slice);
+}