mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 05:44:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

re-integrate stack trace tests with the new std.Build API

Browse source 
* RunStep: ability to set stdin
 * RunStep: ability to capture stdout and stderr as a FileSource
 * RunStep: add setName method
 * RunStep: hash the stdio checks
This commit is contained in:
Andrew Kelley 2023-03-06 19:10:37 -07:00
parent 7bad695865
commit a24af8e400
7 changed files with 637 additions and 727 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
build.zig
View file

@ -442,33 +442,33 @@ pub fn build(b: *std.Build) !void {
.skip_stage2 = true, // TODO get all these passing
}));
test_step.dependOn(tests.addCompareOutputTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addStandaloneTests(
b,
test_filter,
optimization_modes,
skip_non_native,
enable_macos_sdk,
target,
skip_stage2_tests,
b.enable_darling,
b.enable_qemu,
b.enable_rosetta,
b.enable_wasmtime,
b.enable_wine,
enable_symlinks_windows,
));
test_step.dependOn(tests.addCAbiTests(b, skip_non_native, skip_release));
test_step.dependOn(tests.addLinkTests(b, test_filter, optimization_modes, enable_macos_sdk, skip_stage2_tests, enable_symlinks_windows));
_ = enable_symlinks_windows;
_ = enable_macos_sdk;
//test_step.dependOn(tests.addCompareOutputTests(b, test_filter, optimization_modes));
//test_step.dependOn(tests.addStandaloneTests(
// b,
// test_filter,
// optimization_modes,
// skip_non_native,
// enable_macos_sdk,
// target,
// skip_stage2_tests,
// b.enable_darling,
// b.enable_qemu,
// b.enable_rosetta,
// b.enable_wasmtime,
// b.enable_wine,
// enable_symlinks_windows,
//));
//test_step.dependOn(tests.addCAbiTests(b, skip_non_native, skip_release));
//test_step.dependOn(tests.addLinkTests(b, test_filter, optimization_modes, enable_macos_sdk, skip_stage2_tests, enable_symlinks_windows));
test_step.dependOn(tests.addStackTraceTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addCliTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, optimization_modes));
//test_step.dependOn(tests.addCliTests(b, test_filter, optimization_modes));
//test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, optimization_modes));
test_step.dependOn(tests.addTranslateCTests(b, test_filter));
if (!skip_run_translated_c) {
test_step.dependOn(tests.addRunTranslatedCTests(b, test_filter, target));
}
// tests for this feature are disabled until we have the self-hosted compiler available
// test_step.dependOn(tests.addGenHTests(b, test_filter));
test_step.dependOn(tests.addModuleTests(b, .{
.test_filter = test_filter,

246
lib/std/Build/RunStep.zig
View file

@ -38,6 +38,8 @@ env_map: ?*EnvMap,
/// be skipped if all output files are up-to-date and input files are
/// unchanged.
stdio: StdIo = .infer_from_args,
/// This field must be `null` if stdio is `inherit`.
stdin: ?[]const u8 = null,
/// Additional file paths relative to build.zig that, when modified, indicate
/// that the RunStep should be re-executed.
@ -65,6 +67,9 @@ skip_foreign_checks: bool = false,
/// the step fails.
max_stdio_size: usize = 10 * 1024 * 1024,
captured_stdout: ?*Output = null,
captured_stderr: ?*Output = null,
pub const StdIo = union(enum) {
/// Whether the RunStep has side-effects will be determined by whether or not one
/// of the args is an output file (added with `addOutputFileArg`).
@ -99,12 +104,12 @@ pub const Arg = union(enum) {
artifact: *CompileStep,
file_source: std.Build.FileSource,
bytes: []u8,
output: Output,
output: *Output,
};
pub const Output = struct {
generated_file: *std.Build.GeneratedFile,
basename: []const u8,
};
pub const Output = struct {
generated_file: std.Build.GeneratedFile,
basename: []const u8,
};
pub fn create(owner: *std.Build, name: []const u8) *RunStep {
@ -119,12 +124,15 @@ pub fn create(owner: *std.Build, name: []const u8) *RunStep {
.argv = ArrayList(Arg).init(owner.allocator),
.cwd = null,
.env_map = null,
.rename_step_with_output_arg = true,
.max_stdio_size = 10 * 1024 * 1024,
};
return self;
}
pub fn setName(self: *RunStep, name: []const u8) void {
self.step.name = name;
self.rename_step_with_output_arg = false;
}
pub fn addArtifactArg(self: *RunStep, artifact: *CompileStep) void {
self.argv.append(Arg{ .artifact = artifact }) catch @panic("OOM");
self.step.dependOn(&artifact.step);
@ -135,19 +143,19 @@ pub fn addArtifactArg(self: *RunStep, artifact: *CompileStep) void {
/// throughout the build system.
pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource {
const b = rs.step.owner;
const generated_file = b.allocator.create(std.Build.GeneratedFile) catch @panic("OOM");
generated_file.* = .{ .step = &rs.step };
rs.argv.append(.{ .output = .{
.generated_file = generated_file,
.basename = b.dupe(basename),
} }) catch @panic("OOM");
const output = b.allocator.create(Output) catch @panic("OOM");
output.* = .{
.basename = basename,
.generated_file = .{ .step = &rs.step },
};
rs.argv.append(.{ .output = output }) catch @panic("OOM");
if (rs.rename_step_with_output_arg) {
rs.rename_step_with_output_arg = false;
rs.step.name = b.fmt("{s} ({s})", .{ rs.step.name, basename });
rs.setName(b.fmt("{s} ({s})", .{ rs.step.name, basename }));
}
return .{ .generated = generated_file };
return .{ .generated = &output.generated_file };
}
pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {
@ -259,6 +267,34 @@ pub fn addCheck(self: *RunStep, new_check: StdIo.Check) void {
}
}
pub fn captureStdErr(self: *RunStep) std.Build.FileSource {
assert(self.stdio != .inherit);
if (self.captured_stderr) |output| return .{ .generated = &output.generated_file };
const output = self.step.owner.allocator.create(Output) catch @panic("OOM");
output.* = .{
.basename = "stderr",
.generated_file = .{ .step = &self.step },
};
self.captured_stderr = output;
return .{ .generated = &output.generated_file };
}
pub fn captureStdOut(self: *RunStep) *std.Build.GeneratedFile {
assert(self.stdio != .inherit);
if (self.captured_stdout) |output| return .{ .generated = &output.generated_file };
const output = self.step.owner.allocator.create(Output) catch @panic("OOM");
output.* = .{
.basename = "stdout",
.generated_file = .{ .step = &self.step },
};
self.captured_stdout = output;
return .{ .generated = &output.generated_file };
}
/// Returns whether the RunStep has side effects *other than* updating the output arguments.
fn hasSideEffects(self: RunStep) bool {
return switch (self.stdio) {
@ -269,6 +305,8 @@ fn hasSideEffects(self: RunStep) bool {
}
fn hasAnyOutputArgs(self: RunStep) bool {
if (self.captured_stdout != null) return true;
if (self.captured_stderr != null) return true;
for (self.argv.items) |arg| switch (arg) {
.output => return true,
else => continue,
@ -318,7 +356,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
var argv_list = ArrayList([]const u8).init(arena);
var output_placeholders = ArrayList(struct {
index: usize,
output: Arg.Output,
output: *Output,
}).init(arena);
var man = b.cache.obtain();
@ -361,46 +399,68 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
}
}
if (!has_side_effects) {
for (self.extra_file_dependencies) |file_path| {
_ = try man.addFile(b.pathFromRoot(file_path), null);
}
if (self.captured_stdout) |output| {
man.hash.addBytes(output.basename);
}
if (try step.cacheHit(&man)) {
// cache hit, skip running command
const digest = man.final();
for (output_placeholders.items) |placeholder| {
placeholder.output.generated_file.path = try b.cache_root.join(
arena,
&.{ "o", &digest, placeholder.output.basename },
);
}
step.result_cached = true;
return;
}
if (self.captured_stderr) |output| {
man.hash.addBytes(output.basename);
}
hashStdIo(&man.hash, self.stdio);
if (has_side_effects) {
try runCommand(self, argv_list.items, has_side_effects, null);
return;
}
for (self.extra_file_dependencies) |file_path| {
_ = try man.addFile(b.pathFromRoot(file_path), null);
}
if (try step.cacheHit(&man)) {
// cache hit, skip running command
const digest = man.final();
for (output_placeholders.items) |placeholder| {
const output_components = .{ "o", &digest, placeholder.output.basename };
const output_sub_path = try fs.path.join(arena, &output_components);
const output_sub_dir_path = fs.path.dirname(output_sub_path).?;
b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {
return step.fail("unable to make path '{}{s}': {s}", .{
b.cache_root, output_sub_dir_path, @errorName(err),
});
};
const output_path = try b.cache_root.join(arena, &output_components);
placeholder.output.generated_file.path = output_path;
argv_list.items[placeholder.index] = output_path;
placeholder.output.generated_file.path = try b.cache_root.join(arena, &.{
"o", &digest, placeholder.output.basename,
});
}
if (self.captured_stdout) |output| {
output.generated_file.path = try b.cache_root.join(arena, &.{
"o", &digest, output.basename,
});
}
if (self.captured_stderr) |output| {
output.generated_file.path = try b.cache_root.join(arena, &.{
"o", &digest, output.basename,
});
}
step.result_cached = true;
return;
}
try runCommand(self, argv_list.items, has_side_effects);
const digest = man.final();
if (!has_side_effects) {
try man.writeManifest();
for (output_placeholders.items) |placeholder| {
const output_components = .{ "o", &digest, placeholder.output.basename };
const output_sub_path = try fs.path.join(arena, &output_components);
const output_sub_dir_path = fs.path.dirname(output_sub_path).?;
b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {
return step.fail("unable to make path '{}{s}': {s}", .{
b.cache_root, output_sub_dir_path, @errorName(err),
});
};
const output_path = try b.cache_root.join(arena, &output_components);
placeholder.output.generated_file.path = output_path;
argv_list.items[placeholder.index] = output_path;
}
try runCommand(self, argv_list.items, has_side_effects, &digest);
try man.writeManifest();
}
fn formatTerm(
@ -448,7 +508,12 @@ fn termMatches(expected: ?std.process.Child.Term, actual: std.process.Child.Term
};
}
fn runCommand(self: *RunStep, argv: []const []const u8, has_side_effects: bool) !void {
fn runCommand(
self: *RunStep,
argv: []const []const u8,
has_side_effects: bool,
digest: ?*const [std.Build.Cache.hex_digest_len]u8,
) !void {
const step = &self.step;
const b = step.owner;
const arena = b.allocator;
@ -584,6 +649,46 @@ fn runCommand(self: *RunStep, argv: []const []const u8, has_side_effects: bool)
step.result_duration_ns = result.elapsed_ns;
step.result_peak_rss = result.peak_rss;
// Capture stdout and stderr to GeneratedFile objects.
const Stream = struct {
captured: ?*Output,
is_null: bool,
bytes: []const u8,
};
for ([_]Stream{
.{
.captured = self.captured_stdout,
.is_null = result.stdout_null,
.bytes = result.stdout,
},
.{
.captured = self.captured_stderr,
.is_null = result.stderr_null,
.bytes = result.stderr,
},
}) |stream| {
if (stream.captured) |output| {
assert(!stream.is_null);
const output_components = .{ "o", digest.?, output.basename };
const output_path = try b.cache_root.join(arena, &output_components);
output.generated_file.path = output_path;
const sub_path = try fs.path.join(arena, &output_components);
const sub_path_dirname = fs.path.dirname(sub_path).?;
b.cache_root.handle.makePath(sub_path_dirname) catch |err| {
return step.fail("unable to make path '{}{s}': {s}", .{
b.cache_root, sub_path_dirname, @errorName(err),
});
};
b.cache_root.handle.writeFile(sub_path, stream.bytes) catch |err| {
return step.fail("unable to write file '{}{s}': {s}", .{
b.cache_root, sub_path, @errorName(err),
});
};
}
}
switch (self.stdio) {
.check => |checks| for (checks.items) |check| switch (check) {
.expect_stderr_exact => |expected_bytes| {
@ -705,7 +810,7 @@ fn spawnChildAndCollect(
child.request_resource_usage_statistics = true;
child.stdin_behavior = switch (self.stdio) {
.infer_from_args => if (has_side_effects) .Inherit else .Ignore,
.infer_from_args => if (has_side_effects) .Inherit else .Close,
.inherit => .Inherit,
.check => .Close,
};
@ -719,12 +824,26 @@ fn spawnChildAndCollect(
.inherit => .Inherit,
.check => .Pipe,
};
if (self.captured_stdout != null) child.stdout_behavior = .Pipe;
if (self.captured_stderr != null) child.stderr_behavior = .Pipe;
if (self.stdin != null) {
assert(child.stdin_behavior != .Inherit);
child.stdin_behavior = .Pipe;
}
child.spawn() catch |err| return self.step.fail("unable to spawn {s}: {s}", .{
argv[0], @errorName(err),
});
var timer = try std.time.Timer.start();
if (self.stdin) |stdin| {
child.stdin.?.writeAll(stdin) catch |err| {
return self.step.fail("unable to write stdin: {s}", .{@errorName(err)});
};
child.stdin.?.close();
child.stdin = null;
}
// These are not optionals, as a workaround for
// https://github.com/ziglang/zig/issues/14783
var stdout_bytes: []const u8 = undefined;
@ -761,7 +880,8 @@ fn spawnChildAndCollect(
}
if (!stderr_null and stderr_bytes.len > 0) {
const stderr_is_diagnostic = switch (self.stdio) {
// Treat stderr as an error message.
const stderr_is_diagnostic = self.captured_stderr == null and switch (self.stdio) {
.check => |checks| !checksContainStderr(checks.items),
else => true,
};
@ -829,3 +949,27 @@ fn failForeign(
},
}
}
fn hashStdIo(hh: *std.Build.Cache.HashHelper, stdio: StdIo) void {
switch (stdio) {
.infer_from_args, .inherit => {},
.check => |checks| for (checks.items) |check| {
hh.add(@as(std.meta.Tag(StdIo.Check), check));
switch (check) {
.expect_stderr_exact,
.expect_stderr_match,
.expect_stdout_exact,
.expect_stdout_match,
=> |s| hh.addBytes(s),
.expect_term => |term| {
hh.add(@as(std.meta.Tag(std.process.Child.Term), term));
switch (term) {
.Exited => |x| hh.add(x),
.Signal, .Stopped, .Unknown => |x| hh.add(x),
}
},
}
},
}
}

14
lib/std/Build/WriteFileStep.zig
View file

@ -189,10 +189,9 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
if (try step.cacheHit(&man)) {
const digest = man.final();
for (wf.files.items) |file| {
file.generated_file.path = try b.cache_root.join(
b.allocator,
&.{ "o", &digest, file.sub_path },
);
file.generated_file.path = try b.cache_root.join(b.allocator, &.{
"o", &digest, file.sub_path,
});
}
return;
}
@ -249,10 +248,9 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
},
}
file.generated_file.path = try b.cache_root.join(
b.allocator,
&.{ cache_path, file.sub_path },
);
file.generated_file.path = try b.cache_root.join(b.allocator, &.{
cache_path, file.sub_path,
});
}
try man.writeManifest();

105
test/src/StackTrace.zig Normal file
View file

@ -0,0 +1,105 @@
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
check_exe: *std.Build.CompileStep,
const Expect = [@typeInfo(OptimizeMode).Enum.fields.len][]const u8;
pub fn addCase(self: *StackTrace, config: anytype) void {
if (@hasField(@TypeOf(config), "exclude")) {
if (config.exclude.exclude()) return;
}
if (@hasField(@TypeOf(config), "exclude_arch")) {
const exclude_arch: []const std.Target.Cpu.Arch = &config.exclude_arch;
for (exclude_arch) |arch| if (arch == builtin.cpu.arch) return;
}
if (@hasField(@TypeOf(config), "exclude_os")) {
const exclude_os: []const std.Target.Os.Tag = &config.exclude_os;
for (exclude_os) |os| if (os == builtin.os.tag) return;
}
for (self.optimize_modes) |optimize_mode| {
switch (optimize_mode) {
.Debug => {
if (@hasField(@TypeOf(config), "Debug")) {
self.addExpect(config.name, config.source, optimize_mode, config.Debug);
}
},
.ReleaseSafe => {
if (@hasField(@TypeOf(config), "ReleaseSafe")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseSafe);
}
},
.ReleaseFast => {
if (@hasField(@TypeOf(config), "ReleaseFast")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseFast);
}
},
.ReleaseSmall => {
if (@hasField(@TypeOf(config), "ReleaseSmall")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseSmall);
}
},
}
}
}
fn addExpect(
self: *StackTrace,
name: []const u8,
source: []const u8,
optimize_mode: OptimizeMode,
mode_config: anytype,
) void {
if (@hasField(@TypeOf(mode_config), "exclude")) {
if (mode_config.exclude.exclude()) return;
}
if (@hasField(@TypeOf(mode_config), "exclude_arch")) {
const exclude_arch: []const std.Target.Cpu.Arch = &mode_config.exclude_arch;
for (exclude_arch) |arch| if (arch == builtin.cpu.arch) return;
}
if (@hasField(@TypeOf(mode_config), "exclude_os")) {
const exclude_os: []const std.Target.Os.Tag = &mode_config.exclude_os;
for (exclude_os) |os| if (os == builtin.os.tag) return;
}
const b = self.b;
const annotated_case_name = fmt.allocPrint(b.allocator, "check {s} ({s})", .{
name, @tagName(optimize_mode),
}) catch @panic("OOM");
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
}
const src_basename = "source.zig";
const write_src = b.addWriteFile(src_basename, source);
const exe = b.addExecutable(.{
.name = "test",
.root_source_file = write_src.getFileSource(src_basename).?,
.optimize = optimize_mode,
.target = .{},
});
const run = b.addRunArtifact(exe);
run.expectExitCode(1);
run.expectStdOutEqual("");
const check_run = b.addRunArtifact(self.check_exe);
check_run.setName(annotated_case_name);
check_run.addFileSourceArg(run.captureStdErr());
check_run.addArgs(&.{
@tagName(optimize_mode),
});
check_run.expectStdOutEqual(mode_config.expect);
self.step.dependOn(&check_run.step);
}
const StackTrace = @This();
const std = @import("std");
const builtin = @import("builtin");
const Step = std.Build.Step;
const OptimizeMode = std.builtin.OptimizeMode;
const fmt = std.fmt;
const mem = std.mem;

141
test/src/Standalone.zig Normal file
View file

@ -0,0 +1,141 @@
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
skip_non_native: bool,
enable_macos_sdk: bool,
target: std.zig.CrossTarget,
omit_stage2: bool,
enable_darling: bool = false,
enable_qemu: bool = false,
enable_rosetta: bool = false,
enable_wasmtime: bool = false,
enable_wine: bool = false,
enable_symlinks_windows: bool,
pub fn addC(self: *Standalone, root_src: []const u8) void {
self.addAllArgs(root_src, true);
}
pub fn add(self: *Standalone, root_src: []const u8) void {
self.addAllArgs(root_src, false);
}
pub fn addBuildFile(self: *Standalone, build_file: []const u8, features: struct {
build_modes: bool = false,
cross_targets: bool = false,
requires_macos_sdk: bool = false,
requires_stage2: bool = false,
use_emulation: bool = false,
requires_symlinks: bool = false,
extra_argv: []const []const u8 = &.{},
}) void {
const b = self.b;
if (features.requires_macos_sdk and !self.enable_macos_sdk) return;
if (features.requires_stage2 and self.omit_stage2) return;
if (features.requires_symlinks and !self.enable_symlinks_windows and builtin.os.tag == .windows) return;
const annotated_case_name = b.fmt("build {s}", .{build_file});
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
}
var zig_args = ArrayList([]const u8).init(b.allocator);
const rel_zig_exe = fs.path.relative(b.allocator, b.build_root.path orelse ".", b.zig_exe) catch unreachable;
zig_args.append(rel_zig_exe) catch unreachable;
zig_args.append("build") catch unreachable;
// TODO: fix the various non-concurrency-safe issues in zig's standalone tests,
// and then remove this!
zig_args.append("-j1") catch @panic("OOM");
zig_args.append("--build-file") catch unreachable;
zig_args.append(b.pathFromRoot(build_file)) catch unreachable;
zig_args.appendSlice(features.extra_argv) catch unreachable;
zig_args.append("test") catch unreachable;
if (b.verbose) {
zig_args.append("--verbose") catch unreachable;
}
if (features.cross_targets and !self.target.isNative()) {
const target_triple = self.target.zigTriple(b.allocator) catch unreachable;
const target_arg = fmt.allocPrint(b.allocator, "-Dtarget={s}", .{target_triple}) catch unreachable;
zig_args.append(target_arg) catch unreachable;
}
if (features.use_emulation) {
if (self.enable_darling) {
zig_args.append("-fdarling") catch unreachable;
}
if (self.enable_qemu) {
zig_args.append("-fqemu") catch unreachable;
}
if (self.enable_rosetta) {
zig_args.append("-frosetta") catch unreachable;
}
if (self.enable_wasmtime) {
zig_args.append("-fwasmtime") catch unreachable;
}
if (self.enable_wine) {
zig_args.append("-fwine") catch unreachable;
}
}
const optimize_modes = if (features.build_modes) self.optimize_modes else &[1]OptimizeMode{.Debug};
for (optimize_modes) |optimize_mode| {
const arg = switch (optimize_mode) {
.Debug => "",
.ReleaseFast => "-Doptimize=ReleaseFast",
.ReleaseSafe => "-Doptimize=ReleaseSafe",
.ReleaseSmall => "-Doptimize=ReleaseSmall",
};
const zig_args_base_len = zig_args.items.len;
if (arg.len > 0)
zig_args.append(arg) catch unreachable;
defer zig_args.resize(zig_args_base_len) catch unreachable;
const run_cmd = b.addSystemCommand(zig_args.items);
self.step.dependOn(&run_cmd.step);
}
}
pub fn addAllArgs(self: *Standalone, root_src: []const u8, link_libc: bool) void {
const b = self.b;
for (self.optimize_modes) |optimize| {
const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {s} ({s})", .{
root_src,
@tagName(optimize),
}) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
}
const exe = b.addExecutable(.{
.name = "test",
.root_source_file = .{ .path = root_src },
.optimize = optimize,
.target = .{},
});
if (link_libc) {
exe.linkSystemLibrary("c");
}
self.step.dependOn(&exe.step);
}
}
const Standalone = @This();
const std = @import("std");
const builtin = @import("builtin");
const Step = std.Build.Step;
const OptimizeMode = std.builtin.OptimizeMode;
const fmt = std.fmt;
const mem = std.mem;
const ArrayList = std.ArrayList;
const fs = std.fs;

79
test/src/check-stack-trace.zig Normal file
View file

@ -0,0 +1,79 @@
const builtin = @import("builtin");
const std = @import("std");
const mem = std.mem;
const fs = std.fs;
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
const args = try std.process.argsAlloc(arena);
const input_path = args[1];
const optimize_mode_text = args[2];
const input_bytes = try std.fs.cwd().readFileAlloc(arena, input_path, 5 * 1024 * 1024);
const optimize_mode = std.meta.stringToEnum(std.builtin.OptimizeMode, optimize_mode_text).?;
var stderr = input_bytes;
// process result
// - keep only basename of source file path
// - replace address with symbolic string
// - replace function name with symbolic string when optimize_mode != .Debug
// - skip empty lines
const got: []const u8 = got_result: {
var buf = std.ArrayList(u8).init(arena);
defer buf.deinit();
if (stderr.len != 0 and stderr[stderr.len - 1] == '\n') stderr = stderr[0 .. stderr.len - 1];
var it = mem.split(u8, stderr, "\n");
process_lines: while (it.next()) |line| {
if (line.len == 0) continue;
// offset search past `[drive]:` on windows
var pos: usize = if (builtin.os.tag == .windows) 2 else 0;
// locate delims/anchor
const delims = [_][]const u8{ ":", ":", ":", " in ", "(", ")" };
var marks = [_]usize{0} ** delims.len;
for (delims, 0..) |delim, i| {
marks[i] = mem.indexOfPos(u8, line, pos, delim) orelse {
// unexpected pattern: emit raw line and cont
try buf.appendSlice(line);
try buf.appendSlice("\n");
continue :process_lines;
};
pos = marks[i] + delim.len;
}
// locate source basename
pos = mem.lastIndexOfScalar(u8, line[0..marks[0]], fs.path.sep) orelse {
// unexpected pattern: emit raw line and cont
try buf.appendSlice(line);
try buf.appendSlice("\n");
continue :process_lines;
};
// end processing if source basename changes
if (!mem.eql(u8, "source.zig", line[pos + 1 .. marks[0]])) break;
// emit substituted line
try buf.appendSlice(line[pos + 1 .. marks[2] + delims[2].len]);
try buf.appendSlice(" [address]");
if (optimize_mode == .Debug) {
// On certain platforms (windows) or possibly depending on how we choose to link main
// the object file extension may be present so we simply strip any extension.
if (mem.indexOfScalar(u8, line[marks[4]..marks[5]], '.')) |idot| {
try buf.appendSlice(line[marks[3] .. marks[4] + idot]);
try buf.appendSlice(line[marks[5]..]);
} else {
try buf.appendSlice(line[marks[3]..]);
}
} else {
try buf.appendSlice(line[marks[3] .. marks[3] + delims[3].len]);
try buf.appendSlice("[function]");
}
try buf.appendSlice("\n");
}
break :got_result try buf.toOwnedSlice();
};
try std.io.getStdOut().writeAll(got);
}

735
test/tests.zig
View file

@ -20,13 +20,14 @@ const stack_traces = @import("stack_traces.zig");
const assemble_and_link = @import("assemble_and_link.zig");
const translate_c = @import("translate_c.zig");
const run_translated_c = @import("run_translated_c.zig");
const gen_h = @import("gen_h.zig");
const link = @import("link.zig");
// Implementations
pub const TranslateCContext = @import("src/translate_c.zig").TranslateCContext;
pub const RunTranslatedCContext = @import("src/run_translated_c.zig").RunTranslatedCContext;
pub const CompareOutputContext = @import("src/compare_output.zig").CompareOutputContext;
pub const StackTracesContext = @import("src/StackTrace.zig");
pub const StandaloneContext = @import("src/Standalone.zig");
const TestTarget = struct {
target: CrossTarget = @as(CrossTarget, .{}),
@ -460,10 +461,71 @@ const test_targets = blk: {
};
};
const max_stdout_size = 1 * 1024 * 1024; // 1 MB
const c_abi_targets = [_]CrossTarget{
.{},
.{
.cpu_arch = .x86_64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .x86,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .aarch64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .arm,
.os_tag = .linux,
.abi = .musleabihf,
},
.{
.cpu_arch = .mips,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .riscv64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .wasm32,
.os_tag = .wasi,
.abi = .musl,
},
.{
.cpu_arch = .powerpc,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .powerpc64le,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .x86,
.os_tag = .windows,
.abi = .gnu,
},
.{
.cpu_arch = .x86_64,
.os_tag = .windows,
.abi = .gnu,
},
};
pub fn addCompareOutputTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
pub fn addCompareOutputTests(
b: *std.Build,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
) *Step {
const cases = b.allocator.create(CompareOutputContext) catch @panic("OOM");
cases.* = CompareOutputContext{
.b = b,
.step = b.step("test-compare-output", "Run the compare output tests"),
@ -477,14 +539,26 @@ pub fn addCompareOutputTests(b: *std.Build, test_filter: ?[]const u8, optimize_m
return cases.step;
}
pub fn addStackTraceTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(StackTracesContext) catch unreachable;
cases.* = StackTracesContext{
pub fn addStackTraceTests(
b: *std.Build,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
) *Step {
const check_exe = b.addExecutable(.{
.name = "check-stack-trace",
.root_source_file = .{ .path = "test/src/check-stack-trace.zig" },
.target = .{},
.optimize = .Debug,
});
const cases = b.allocator.create(StackTracesContext) catch @panic("OOM");
cases.* = .{
.b = b,
.step = b.step("test-stack-traces", "Run the stack trace tests"),
.test_index = 0,
.test_filter = test_filter,
.optimize_modes = optimize_modes,
.check_exe = check_exe,
};
stack_traces.addCases(cases);
@ -507,7 +581,7 @@ pub fn addStandaloneTests(
enable_wine: bool,
enable_symlinks_windows: bool,
) *Step {
const cases = b.allocator.create(StandaloneContext) catch unreachable;
const cases = b.allocator.create(StandaloneContext) catch @panic("OOM");
cases.* = StandaloneContext{
.b = b,
.step = b.step("test-standalone", "Run the standalone tests"),
@ -539,7 +613,7 @@ pub fn addLinkTests(
omit_stage2: bool,
enable_symlinks_windows: bool,
) *Step {
const cases = b.allocator.create(StandaloneContext) catch unreachable;
const cases = b.allocator.create(StandaloneContext) catch @panic("OOM");
cases.* = StandaloneContext{
.b = b,
.step = b.step("test-link", "Run the linker tests"),
@ -569,7 +643,7 @@ pub fn addCliTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []co
});
const run_cmd = exe.run();
run_cmd.addArgs(&[_][]const u8{
fs.realpathAlloc(b.allocator, b.zig_exe) catch unreachable,
fs.realpathAlloc(b.allocator, b.zig_exe) catch @panic("OOM"),
b.pathFromRoot(b.cache_root.path orelse "."),
});
@ -578,7 +652,7 @@ pub fn addCliTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []co
}
pub fn addAssembleAndLinkTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
const cases = b.allocator.create(CompareOutputContext) catch unreachable;
const cases = b.allocator.create(CompareOutputContext) catch @panic("OOM");
cases.* = CompareOutputContext{
.b = b,
.step = b.step("test-asm-link", "Run the assemble and link tests"),
@ -593,7 +667,7 @@ pub fn addAssembleAndLinkTests(b: *std.Build, test_filter: ?[]const u8, optimize
}
pub fn addTranslateCTests(b: *std.Build, test_filter: ?[]const u8) *Step {
const cases = b.allocator.create(TranslateCContext) catch unreachable;
const cases = b.allocator.create(TranslateCContext) catch @panic("OOM");
cases.* = TranslateCContext{
.b = b,
.step = b.step("test-translate-c", "Run the C translation tests"),
@ -611,7 +685,7 @@ pub fn addRunTranslatedCTests(
test_filter: ?[]const u8,
target: std.zig.CrossTarget,
) *Step {
const cases = b.allocator.create(RunTranslatedCContext) catch unreachable;
const cases = b.allocator.create(RunTranslatedCContext) catch @panic("OOM");
cases.* = .{
.b = b,
.step = b.step("test-run-translated-c", "Run the Run-Translated-C tests"),
@ -625,20 +699,6 @@ pub fn addRunTranslatedCTests(
return cases.step;
}
pub fn addGenHTests(b: *std.Build, test_filter: ?[]const u8) *Step {
const cases = b.allocator.create(GenHContext) catch unreachable;
cases.* = GenHContext{
.b = b,
.step = b.step("test-gen-h", "Run the C header file generation tests"),
.test_index = 0,
.test_filter = test_filter,
};
gen_h.addCases(cases);
return cases.step;
}
const ModuleTestOptions = struct {
test_filter: ?[]const u8,
root_src: []const u8,
@ -696,7 +756,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
else
"bare";
const triple_prefix = test_target.target.zigTriple(b.allocator) catch unreachable;
const triple_prefix = test_target.target.zigTriple(b.allocator) catch @panic("OOM");
// wasm32-wasi builds need more RAM, idk why
const max_rss = if (test_target.target.getOs().tag == .wasi)
@ -750,623 +810,6 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
return step;
}
pub const StackTracesContext = struct {
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
const Expect = [@typeInfo(OptimizeMode).Enum.fields.len][]const u8;
pub fn addCase(self: *StackTracesContext, config: anytype) void {
if (@hasField(@TypeOf(config), "exclude")) {
if (config.exclude.exclude()) return;
}
if (@hasField(@TypeOf(config), "exclude_arch")) {
const exclude_arch: []const std.Target.Cpu.Arch = &config.exclude_arch;
for (exclude_arch) |arch| if (arch == builtin.cpu.arch) return;
}
if (@hasField(@TypeOf(config), "exclude_os")) {
const exclude_os: []const std.Target.Os.Tag = &config.exclude_os;
for (exclude_os) |os| if (os == builtin.os.tag) return;
}
for (self.optimize_modes) |optimize_mode| {
switch (optimize_mode) {
.Debug => {
if (@hasField(@TypeOf(config), "Debug")) {
self.addExpect(config.name, config.source, optimize_mode, config.Debug);
}
},
.ReleaseSafe => {
if (@hasField(@TypeOf(config), "ReleaseSafe")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseSafe);
}
},
.ReleaseFast => {
if (@hasField(@TypeOf(config), "ReleaseFast")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseFast);
}
},
.ReleaseSmall => {
if (@hasField(@TypeOf(config), "ReleaseSmall")) {
self.addExpect(config.name, config.source, optimize_mode, config.ReleaseSmall);
}
},
}
}
}
fn addExpect(
self: *StackTracesContext,
name: []const u8,
source: []const u8,
optimize_mode: OptimizeMode,
mode_config: anytype,
) void {
if (@hasField(@TypeOf(mode_config), "exclude")) {
if (mode_config.exclude.exclude()) return;
}
if (@hasField(@TypeOf(mode_config), "exclude_arch")) {
const exclude_arch: []const std.Target.Cpu.Arch = &mode_config.exclude_arch;
for (exclude_arch) |arch| if (arch == builtin.cpu.arch) return;
}
if (@hasField(@TypeOf(mode_config), "exclude_os")) {
const exclude_os: []const std.Target.Os.Tag = &mode_config.exclude_os;
for (exclude_os) |os| if (os == builtin.os.tag) return;
}
const annotated_case_name = fmt.allocPrint(self.b.allocator, "{s} {s} ({s})", .{
"stack-trace",
name,
@tagName(optimize_mode),
}) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
}
const b = self.b;
const src_basename = "source.zig";
const write_src = b.addWriteFile(src_basename, source);
const exe = b.addExecutable(.{
.name = "test",
.root_source_file = write_src.getFileSource(src_basename).?,
.optimize = optimize_mode,
.target = .{},
});
const run_and_compare = RunAndCompareStep.create(
self,
exe,
annotated_case_name,
optimize_mode,
mode_config.expect,
);
self.step.dependOn(&run_and_compare.step);
}
const RunAndCompareStep = struct {
pub const base_id = .custom;
step: Step,
context: *StackTracesContext,
exe: *CompileStep,
name: []const u8,
optimize_mode: OptimizeMode,
expect_output: []const u8,
test_index: usize,
pub fn create(
context: *StackTracesContext,
exe: *CompileStep,
name: []const u8,
optimize_mode: OptimizeMode,
expect_output: []const u8,
) *RunAndCompareStep {
const allocator = context.b.allocator;
const ptr = allocator.create(RunAndCompareStep) catch unreachable;
ptr.* = RunAndCompareStep{
.step = Step.init(.{
.id = .custom,
.name = "StackTraceCompareOutputStep",
.makeFn = make,
.owner = context.b,
}),
.context = context,
.exe = exe,
.name = name,
.optimize_mode = optimize_mode,
.expect_output = expect_output,
.test_index = context.test_index,
};
ptr.step.dependOn(&exe.step);
context.test_index += 1;
return ptr;
}
fn make(step: *Step, prog_node: *std.Progress.Node) !void {
_ = prog_node;
const self = @fieldParentPtr(RunAndCompareStep, "step", step);
const b = self.context.b;
const full_exe_path = self.exe.getOutputSource().getPath(b);
var args = ArrayList([]const u8).init(b.allocator);
defer args.deinit();
args.append(full_exe_path) catch unreachable;
std.debug.print("Test {d}/{d} {s}...", .{ self.test_index + 1, self.context.test_index, self.name });
if (!std.process.can_spawn) {
const cmd = try std.mem.join(b.allocator, " ", args.items);
std.debug.print("the following command cannot be executed ({s} does not support spawning a child process):\n{s}", .{ @tagName(builtin.os.tag), cmd });
b.allocator.free(cmd);
return ExecError.ExecNotSupported;
}
var child = std.ChildProcess.init(args.items, b.allocator);
child.stdin_behavior = .Ignore;
child.stdout_behavior = .Pipe;
child.stderr_behavior = .Pipe;
child.env_map = b.env_map;
if (b.verbose) {
printInvocation(args.items);
}
child.spawn() catch |err| debug.panic("Unable to spawn {s}: {s}\n", .{ full_exe_path, @errorName(err) });
const stdout = child.stdout.?.reader().readAllAlloc(b.allocator, max_stdout_size) catch unreachable;
defer b.allocator.free(stdout);
const stderrFull = child.stderr.?.reader().readAllAlloc(b.allocator, max_stdout_size) catch unreachable;
defer b.allocator.free(stderrFull);
var stderr = stderrFull;
const term = child.wait() catch |err| {
debug.panic("Unable to spawn {s}: {s}\n", .{ full_exe_path, @errorName(err) });
};
switch (term) {
.Exited => |code| {
const expect_code: u32 = 1;
if (code != expect_code) {
std.debug.print("Process {s} exited with error code {d} but expected code {d}\n", .{
full_exe_path,
code,
expect_code,
});
printInvocation(args.items);
return error.TestFailed;
}
},
.Signal => |signum| {
std.debug.print("Process {s} terminated on signal {d}\n", .{ full_exe_path, signum });
printInvocation(args.items);
return error.TestFailed;
},
.Stopped => |signum| {
std.debug.print("Process {s} stopped on signal {d}\n", .{ full_exe_path, signum });
printInvocation(args.items);
return error.TestFailed;
},
.Unknown => |code| {
std.debug.print("Process {s} terminated unexpectedly with error code {d}\n", .{ full_exe_path, code });
printInvocation(args.items);
return error.TestFailed;
},
}
// process result
// - keep only basename of source file path
// - replace address with symbolic string
// - replace function name with symbolic string when optimize_mode != .Debug
// - skip empty lines
const got: []const u8 = got_result: {
var buf = ArrayList(u8).init(b.allocator);
defer buf.deinit();
if (stderr.len != 0 and stderr[stderr.len - 1] == '\n') stderr = stderr[0 .. stderr.len - 1];
var it = mem.split(u8, stderr, "\n");
process_lines: while (it.next()) |line| {
if (line.len == 0) continue;
// offset search past `[drive]:` on windows
var pos: usize = if (builtin.os.tag == .windows) 2 else 0;
// locate delims/anchor
const delims = [_][]const u8{ ":", ":", ":", " in ", "(", ")" };
var marks = [_]usize{0} ** delims.len;
for (delims, 0..) |delim, i| {
marks[i] = mem.indexOfPos(u8, line, pos, delim) orelse {
// unexpected pattern: emit raw line and cont
try buf.appendSlice(line);
try buf.appendSlice("\n");
continue :process_lines;
};
pos = marks[i] + delim.len;
}
// locate source basename
pos = mem.lastIndexOfScalar(u8, line[0..marks[0]], fs.path.sep) orelse {
// unexpected pattern: emit raw line and cont
try buf.appendSlice(line);
try buf.appendSlice("\n");
continue :process_lines;
};
// end processing if source basename changes
if (!mem.eql(u8, "source.zig", line[pos + 1 .. marks[0]])) break;
// emit substituted line
try buf.appendSlice(line[pos + 1 .. marks[2] + delims[2].len]);
try buf.appendSlice(" [address]");
if (self.optimize_mode == .Debug) {
// On certain platforms (windows) or possibly depending on how we choose to link main
// the object file extension may be present so we simply strip any extension.
if (mem.indexOfScalar(u8, line[marks[4]..marks[5]], '.')) |idot| {
try buf.appendSlice(line[marks[3] .. marks[4] + idot]);
try buf.appendSlice(line[marks[5]..]);
} else {
try buf.appendSlice(line[marks[3]..]);
}
} else {
try buf.appendSlice(line[marks[3] .. marks[3] + delims[3].len]);
try buf.appendSlice("[function]");
}
try buf.appendSlice("\n");
}
break :got_result try buf.toOwnedSlice();
};
if (!mem.eql(u8, self.expect_output, got)) {
std.debug.print(
\\
\\========= Expected this output: =========
\\{s}
\\================================================
\\{s}
\\
, .{ self.expect_output, got });
return error.TestFailed;
}
std.debug.print("OK\n", .{});
}
};
};
pub const StandaloneContext = struct {
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
optimize_modes: []const OptimizeMode,
skip_non_native: bool,
enable_macos_sdk: bool,
target: std.zig.CrossTarget,
omit_stage2: bool,
enable_darling: bool = false,
enable_qemu: bool = false,
enable_rosetta: bool = false,
enable_wasmtime: bool = false,
enable_wine: bool = false,
enable_symlinks_windows: bool,
pub fn addC(self: *StandaloneContext, root_src: []const u8) void {
self.addAllArgs(root_src, true);
}
pub fn add(self: *StandaloneContext, root_src: []const u8) void {
self.addAllArgs(root_src, false);
}
pub fn addBuildFile(self: *StandaloneContext, build_file: []const u8, features: struct {
build_modes: bool = false,
cross_targets: bool = false,
requires_macos_sdk: bool = false,
requires_stage2: bool = false,
use_emulation: bool = false,
requires_symlinks: bool = false,
extra_argv: []const []const u8 = &.{},
}) void {
const b = self.b;
if (features.requires_macos_sdk and !self.enable_macos_sdk) return;
if (features.requires_stage2 and self.omit_stage2) return;
if (features.requires_symlinks and !self.enable_symlinks_windows and builtin.os.tag == .windows) return;
const annotated_case_name = b.fmt("build {s}", .{build_file});
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
}
var zig_args = ArrayList([]const u8).init(b.allocator);
const rel_zig_exe = fs.path.relative(b.allocator, b.build_root.path orelse ".", b.zig_exe) catch unreachable;
zig_args.append(rel_zig_exe) catch unreachable;
zig_args.append("build") catch unreachable;
// TODO: fix the various non-concurrency-safe issues in zig's standalone tests,
// and then remove this!
zig_args.append("-j1") catch @panic("OOM");
zig_args.append("--build-file") catch unreachable;
zig_args.append(b.pathFromRoot(build_file)) catch unreachable;
zig_args.appendSlice(features.extra_argv) catch unreachable;
zig_args.append("test") catch unreachable;
if (b.verbose) {
zig_args.append("--verbose") catch unreachable;
}
if (features.cross_targets and !self.target.isNative()) {
const target_triple = self.target.zigTriple(b.allocator) catch unreachable;
const target_arg = fmt.allocPrint(b.allocator, "-Dtarget={s}", .{target_triple}) catch unreachable;
zig_args.append(target_arg) catch unreachable;
}
if (features.use_emulation) {
if (self.enable_darling) {
zig_args.append("-fdarling") catch unreachable;
}
if (self.enable_qemu) {
zig_args.append("-fqemu") catch unreachable;
}
if (self.enable_rosetta) {
zig_args.append("-frosetta") catch unreachable;
}
if (self.enable_wasmtime) {
zig_args.append("-fwasmtime") catch unreachable;
}
if (self.enable_wine) {
zig_args.append("-fwine") catch unreachable;
}
}
const optimize_modes = if (features.build_modes) self.optimize_modes else &[1]OptimizeMode{.Debug};
for (optimize_modes) |optimize_mode| {
const arg = switch (optimize_mode) {
.Debug => "",
.ReleaseFast => "-Doptimize=ReleaseFast",
.ReleaseSafe => "-Doptimize=ReleaseSafe",
.ReleaseSmall => "-Doptimize=ReleaseSmall",
};
const zig_args_base_len = zig_args.items.len;
if (arg.len > 0)
zig_args.append(arg) catch unreachable;
defer zig_args.resize(zig_args_base_len) catch unreachable;
const run_cmd = b.addSystemCommand(zig_args.items);
self.step.dependOn(&run_cmd.step);
}
}
pub fn addAllArgs(self: *StandaloneContext, root_src: []const u8, link_libc: bool) void {
const b = self.b;
for (self.optimize_modes) |optimize| {
const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {s} ({s})", .{
root_src,
@tagName(optimize),
}) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) continue;
}
const exe = b.addExecutable(.{
.name = "test",
.root_source_file = .{ .path = root_src },
.optimize = optimize,
.target = .{},
});
if (link_libc) {
exe.linkSystemLibrary("c");
}
self.step.dependOn(&exe.step);
}
}
};
pub const GenHContext = struct {
b: *std.Build,
step: *Step,
test_index: usize,
test_filter: ?[]const u8,
const TestCase = struct {
name: []const u8,
sources: ArrayList(SourceFile),
expected_lines: ArrayList([]const u8),
const SourceFile = struct {
filename: []const u8,
source: []const u8,
};
pub fn addSourceFile(self: *TestCase, filename: []const u8, source: []const u8) void {
self.sources.append(SourceFile{
.filename = filename,
.source = source,
}) catch unreachable;
}
pub fn addExpectedLine(self: *TestCase, text: []const u8) void {
self.expected_lines.append(text) catch unreachable;
}
};
const GenHCmpOutputStep = struct {
step: Step,
context: *GenHContext,
obj: *CompileStep,
name: []const u8,
test_index: usize,
case: *const TestCase,
pub fn create(
context: *GenHContext,
obj: *CompileStep,
name: []const u8,
case: *const TestCase,
) *GenHCmpOutputStep {
const allocator = context.b.allocator;
const ptr = allocator.create(GenHCmpOutputStep) catch unreachable;
ptr.* = GenHCmpOutputStep{
.step = Step.init(.{
.id = .custom,
.name = "ParseCCmpOutput",
.owner = context.b,
.makeFn = make,
}),
.context = context,
.obj = obj,
.name = name,
.test_index = context.test_index,
.case = case,
};
ptr.step.dependOn(&obj.step);
context.test_index += 1;
return ptr;
}
fn make(step: *Step, prog_node: *std.Progress.Node) !void {
_ = prog_node;
const self = @fieldParentPtr(GenHCmpOutputStep, "step", step);
const b = self.context.b;
std.debug.print("Test {d}/{d} {s}...", .{ self.test_index + 1, self.context.test_index, self.name });
const full_h_path = self.obj.getOutputHPath();
const actual_h = try io.readFileAlloc(b.allocator, full_h_path);
for (self.case.expected_lines.items) |expected_line| {
if (mem.indexOf(u8, actual_h, expected_line) == null) {
std.debug.print(
\\
\\========= Expected this output: ================
\\{s}
\\========= But found: ===========================
\\{s}
\\
, .{ expected_line, actual_h });
return error.TestFailed;
}
}
std.debug.print("OK\n", .{});
}
};
pub fn create(
self: *GenHContext,
filename: []const u8,
name: []const u8,
source: []const u8,
expected_lines: []const []const u8,
) *TestCase {
const tc = self.b.allocator.create(TestCase) catch unreachable;
tc.* = TestCase{
.name = name,
.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
.expected_lines = ArrayList([]const u8).init(self.b.allocator),
};
tc.addSourceFile(filename, source);
var arg_i: usize = 0;
while (arg_i < expected_lines.len) : (arg_i += 1) {
tc.addExpectedLine(expected_lines[arg_i]);
}
return tc;
}
pub fn add(self: *GenHContext, name: []const u8, source: []const u8, expected_lines: []const []const u8) void {
const tc = self.create("test.zig", name, source, expected_lines);
self.addCase(tc);
}
pub fn addCase(self: *GenHContext, case: *const TestCase) void {
const b = self.b;
const optimize_mode = std.builtin.OptimizeMode.Debug;
const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {s} ({s})", .{ case.name, @tagName(optimize_mode) }) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
}
const write_src = b.addWriteFiles();
for (case.sources.items) |src_file| {
write_src.add(src_file.filename, src_file.source);
}
const obj = b.addObjectFromWriteFileStep("test", write_src, case.sources.items[0].filename);
obj.setBuildMode(optimize_mode);
const cmp_h = GenHCmpOutputStep.create(self, obj, annotated_case_name, case);
self.step.dependOn(&cmp_h.step);
}
};
fn printInvocation(args: []const []const u8) void {
for (args) |arg| {
std.debug.print("{s} ", .{arg});
}
std.debug.print("\n", .{});
}
const c_abi_targets = [_]CrossTarget{
.{},
.{
.cpu_arch = .x86_64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .x86,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .aarch64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .arm,
.os_tag = .linux,
.abi = .musleabihf,
},
.{
.cpu_arch = .mips,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .riscv64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .wasm32,
.os_tag = .wasi,
.abi = .musl,
},
.{
.cpu_arch = .powerpc,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .powerpc64le,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .x86,
.os_tag = .windows,
.abi = .gnu,
},
.{
.cpu_arch = .x86_64,
.os_tag = .windows,
.abi = .gnu,
},
};
pub fn addCAbiTests(b: *std.Build, skip_non_native: bool, skip_release: bool) *Step {
const step = b.step("test-c-abi", "Run the C ABI tests");
@ -1395,7 +838,7 @@ pub fn addCAbiTests(b: *std.Build, skip_non_native: bool, skip_release: bool) *S
test_step.want_lto = false;
}
const triple_prefix = c_abi_target.zigTriple(b.allocator) catch unreachable;
const triple_prefix = c_abi_target.zigTriple(b.allocator) catch @panic("OOM");
test_step.setNamePrefix(b.fmt("{s}-{s}-{s} ", .{
"test-c-abi",
triple_prefix,