247 lines
8.7 KiB
Zig
247 lines
8.7 KiB
Zig
const std = @import("std");
|
|
const io = std.io;
|
|
const builtin = @import("builtin");
|
|
|
|
pub const std_options = struct {
|
|
pub const io_mode: io.Mode = builtin.test_io_mode;
|
|
pub const logFn = log;
|
|
};
|
|
|
|
var log_err_count: usize = 0;
|
|
var cmdline_buffer: [4096]u8 = undefined;
|
|
var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer);
|
|
|
|
pub fn main() void {
|
|
if (builtin.zig_backend == .stage2_wasm or
|
|
builtin.zig_backend == .stage2_x86_64 or
|
|
builtin.zig_backend == .stage2_aarch64)
|
|
{
|
|
return mainSimple() catch @panic("test failure");
|
|
}
|
|
|
|
const args = std.process.argsAlloc(fba.allocator()) catch
|
|
@panic("unable to parse command line args");
|
|
|
|
var listen = false;
|
|
|
|
for (args[1..]) |arg| {
|
|
if (std.mem.eql(u8, arg, "--listen=-")) {
|
|
listen = true;
|
|
} else {
|
|
@panic("unrecognized command line argument");
|
|
}
|
|
}
|
|
|
|
if (listen) {
|
|
return mainServer() catch @panic("internal test runner failure");
|
|
} else {
|
|
return mainTerminal();
|
|
}
|
|
}
|
|
|
|
fn mainServer() !void {
|
|
var server = try std.zig.Server.init(.{
|
|
.gpa = fba.allocator(),
|
|
.in = std.io.getStdIn(),
|
|
.out = std.io.getStdOut(),
|
|
.zig_version = builtin.zig_version_string,
|
|
});
|
|
defer server.deinit();
|
|
|
|
while (true) {
|
|
const hdr = try server.receiveMessage();
|
|
switch (hdr.tag) {
|
|
.exit => {
|
|
return std.process.exit(0);
|
|
},
|
|
.query_test_metadata => {
|
|
std.testing.allocator_instance = .{};
|
|
defer if (std.testing.allocator_instance.deinit()) {
|
|
@panic("internal test runner memory leak");
|
|
};
|
|
|
|
var string_bytes: std.ArrayListUnmanaged(u8) = .{};
|
|
defer string_bytes.deinit(std.testing.allocator);
|
|
try string_bytes.append(std.testing.allocator, 0); // Reserve 0 for null.
|
|
|
|
const test_fns = builtin.test_functions;
|
|
const names = try std.testing.allocator.alloc(u32, test_fns.len);
|
|
defer std.testing.allocator.free(names);
|
|
const async_frame_sizes = try std.testing.allocator.alloc(u32, test_fns.len);
|
|
defer std.testing.allocator.free(async_frame_sizes);
|
|
const expected_panic_msgs = try std.testing.allocator.alloc(u32, test_fns.len);
|
|
defer std.testing.allocator.free(expected_panic_msgs);
|
|
|
|
for (test_fns, names, async_frame_sizes, expected_panic_msgs) |test_fn, *name, *async_frame_size, *expected_panic_msg| {
|
|
name.* = @intCast(u32, string_bytes.items.len);
|
|
try string_bytes.ensureUnusedCapacity(std.testing.allocator, test_fn.name.len + 1);
|
|
string_bytes.appendSliceAssumeCapacity(test_fn.name);
|
|
string_bytes.appendAssumeCapacity(0);
|
|
|
|
async_frame_size.* = @intCast(u32, test_fn.async_frame_size orelse 0);
|
|
expected_panic_msg.* = 0;
|
|
}
|
|
|
|
try server.serveTestMetadata(.{
|
|
.names = names,
|
|
.async_frame_sizes = async_frame_sizes,
|
|
.expected_panic_msgs = expected_panic_msgs,
|
|
.string_bytes = string_bytes.items,
|
|
});
|
|
},
|
|
|
|
.run_test => {
|
|
std.testing.allocator_instance = .{};
|
|
const index = try server.receiveBody_u32();
|
|
const test_fn = builtin.test_functions[index];
|
|
if (test_fn.async_frame_size != null)
|
|
@panic("TODO test runner implement async tests");
|
|
var fail = false;
|
|
var skip = false;
|
|
var leak = false;
|
|
test_fn.func() catch |err| switch (err) {
|
|
error.SkipZigTest => skip = true,
|
|
else => {
|
|
fail = true;
|
|
if (@errorReturnTrace()) |trace| {
|
|
std.debug.dumpStackTrace(trace.*);
|
|
}
|
|
},
|
|
};
|
|
leak = std.testing.allocator_instance.deinit();
|
|
try server.serveTestResults(.{
|
|
.index = index,
|
|
.flags = .{
|
|
.fail = fail,
|
|
.skip = skip,
|
|
.leak = leak,
|
|
},
|
|
});
|
|
},
|
|
|
|
else => {
|
|
std.debug.print("unsupported message: {x}", .{@enumToInt(hdr.tag)});
|
|
std.process.exit(1);
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
fn mainTerminal() void {
|
|
const test_fn_list = builtin.test_functions;
|
|
var ok_count: usize = 0;
|
|
var skip_count: usize = 0;
|
|
var fail_count: usize = 0;
|
|
var progress = std.Progress{
|
|
.dont_print_on_dumb = true,
|
|
};
|
|
const root_node = progress.start("Test", test_fn_list.len);
|
|
const have_tty = progress.terminal != null and
|
|
(progress.supports_ansi_escape_codes or progress.is_windows_terminal);
|
|
|
|
var async_frame_buffer: []align(std.Target.stack_align) u8 = undefined;
|
|
// TODO this is on the next line (using `undefined` above) because otherwise zig incorrectly
|
|
// ignores the alignment of the slice.
|
|
async_frame_buffer = &[_]u8{};
|
|
|
|
var leaks: usize = 0;
|
|
for (test_fn_list, 0..) |test_fn, i| {
|
|
std.testing.allocator_instance = .{};
|
|
defer {
|
|
if (std.testing.allocator_instance.deinit()) {
|
|
leaks += 1;
|
|
}
|
|
}
|
|
std.testing.log_level = .warn;
|
|
|
|
var test_node = root_node.start(test_fn.name, 0);
|
|
test_node.activate();
|
|
progress.refresh();
|
|
if (!have_tty) {
|
|
std.debug.print("{d}/{d} {s}... ", .{ i + 1, test_fn_list.len, test_fn.name });
|
|
}
|
|
const result = if (test_fn.async_frame_size) |size| switch (std.options.io_mode) {
|
|
.evented => blk: {
|
|
if (async_frame_buffer.len < size) {
|
|
std.heap.page_allocator.free(async_frame_buffer);
|
|
async_frame_buffer = std.heap.page_allocator.alignedAlloc(u8, std.Target.stack_align, size) catch @panic("out of memory");
|
|
}
|
|
const casted_fn = @ptrCast(fn () callconv(.Async) anyerror!void, test_fn.func);
|
|
break :blk await @asyncCall(async_frame_buffer, {}, casted_fn, .{});
|
|
},
|
|
.blocking => {
|
|
skip_count += 1;
|
|
test_node.end();
|
|
progress.log("SKIP (async test)\n", .{});
|
|
continue;
|
|
},
|
|
} else test_fn.func();
|
|
if (result) |_| {
|
|
ok_count += 1;
|
|
test_node.end();
|
|
if (!have_tty) std.debug.print("OK\n", .{});
|
|
} else |err| switch (err) {
|
|
error.SkipZigTest => {
|
|
skip_count += 1;
|
|
progress.log("SKIP\n", .{});
|
|
test_node.end();
|
|
},
|
|
else => {
|
|
fail_count += 1;
|
|
progress.log("FAIL ({s})\n", .{@errorName(err)});
|
|
if (@errorReturnTrace()) |trace| {
|
|
std.debug.dumpStackTrace(trace.*);
|
|
}
|
|
test_node.end();
|
|
},
|
|
}
|
|
}
|
|
root_node.end();
|
|
if (ok_count == test_fn_list.len) {
|
|
std.debug.print("All {d} tests passed.\n", .{ok_count});
|
|
} else {
|
|
std.debug.print("{d} passed; {d} skipped; {d} failed.\n", .{ ok_count, skip_count, fail_count });
|
|
}
|
|
if (log_err_count != 0) {
|
|
std.debug.print("{d} errors were logged.\n", .{log_err_count});
|
|
}
|
|
if (leaks != 0) {
|
|
std.debug.print("{d} tests leaked memory.\n", .{leaks});
|
|
}
|
|
if (leaks != 0 or log_err_count != 0 or fail_count != 0) {
|
|
std.process.exit(1);
|
|
}
|
|
}
|
|
|
|
pub fn log(
|
|
comptime message_level: std.log.Level,
|
|
comptime scope: @Type(.EnumLiteral),
|
|
comptime format: []const u8,
|
|
args: anytype,
|
|
) void {
|
|
if (@enumToInt(message_level) <= @enumToInt(std.log.Level.err)) {
|
|
log_err_count += 1;
|
|
}
|
|
if (@enumToInt(message_level) <= @enumToInt(std.testing.log_level)) {
|
|
std.debug.print(
|
|
"[" ++ @tagName(scope) ++ "] (" ++ @tagName(message_level) ++ "): " ++ format ++ "\n",
|
|
args,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Simpler main(), exercising fewer language features, so that
|
|
/// work-in-progress backends can handle it.
|
|
pub fn mainSimple() anyerror!void {
|
|
//const stderr = std.io.getStdErr();
|
|
for (builtin.test_functions) |test_fn| {
|
|
test_fn.func() catch |err| {
|
|
if (err != error.SkipZigTest) {
|
|
//stderr.writeAll(test_fn.name) catch {};
|
|
//stderr.writeAll("\n") catch {};
|
|
return err;
|
|
}
|
|
};
|
|
}
|
|
}
|