convert compare-output tests to use zig build system
Andrew Kelley
parent
237dfdbdc6
commit
37b9a2e6a4
|
|
@ -0,0 +1,36 @@
|
|||
const Builder = @import("std").build.Builder;
|
||||
const tests = @import("test/tests.zig");
|
||||
|
||||
pub fn build(b: &Builder) {
|
||||
const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match filter");
|
||||
const test_step = b.step("test", "Run all the tests");
|
||||
|
||||
const run_tests_exe = b.addExecutable("run_tests", "test/run_tests.zig");
|
||||
|
||||
const run_tests_cmd = b.addCommand(b.out_dir, b.env_map, "./run_tests", [][]const u8{});
|
||||
run_tests_cmd.step.dependOn(&run_tests_exe.step);
|
||||
|
||||
const self_hosted_tests_debug_nolibc = b.addTest("test/self_hosted.zig");
|
||||
|
||||
const self_hosted_tests_release_nolibc = b.addTest("test/self_hosted.zig");
|
||||
self_hosted_tests_release_nolibc.setRelease(true);
|
||||
|
||||
const self_hosted_tests_debug_libc = b.addTest("test/self_hosted.zig");
|
||||
self_hosted_tests_debug_libc.linkLibrary("c");
|
||||
|
||||
const self_hosted_tests_release_libc = b.addTest("test/self_hosted.zig");
|
||||
self_hosted_tests_release_libc.setRelease(true);
|
||||
self_hosted_tests_release_libc.linkLibrary("c");
|
||||
|
||||
const self_hosted_tests = b.step("test-self-hosted", "Run the self-hosted tests");
|
||||
self_hosted_tests.dependOn(&self_hosted_tests_debug_nolibc.step);
|
||||
self_hosted_tests.dependOn(&self_hosted_tests_release_nolibc.step);
|
||||
self_hosted_tests.dependOn(&self_hosted_tests_debug_libc.step);
|
||||
self_hosted_tests.dependOn(&self_hosted_tests_release_libc.step);
|
||||
|
||||
test_step.dependOn(self_hosted_tests);
|
||||
//test_step.dependOn(&run_tests_cmd.step);
|
||||
|
||||
test_step.dependOn(tests.addCompareOutputTests(b, test_filter));
|
||||
//test_step.dependOn(tests.addBuildExampleTests(b, test_filter));
|
||||
}
|
||||
|
|
@ -168,6 +168,7 @@ int main(int argc, char **argv) {
|
|||
|
||||
ZigList<const char *> args = {0};
|
||||
args.append(zig_exe_path);
|
||||
args.append(NULL); // placeholder
|
||||
for (int i = 2; i < argc; i += 1) {
|
||||
if (strcmp(argv[i], "--debug-build-verbose") == 0) {
|
||||
verbose = true;
|
||||
|
|
@ -202,6 +203,8 @@ int main(int argc, char **argv) {
|
|||
Buf build_file_dirname = BUF_INIT;
|
||||
os_path_split(&build_file_abs, &build_file_dirname, &build_file_basename);
|
||||
|
||||
args.items[1] = buf_ptr(&build_file_dirname);
|
||||
|
||||
bool build_file_exists;
|
||||
if ((err = os_file_exists(&build_file_abs, &build_file_exists))) {
|
||||
fprintf(stderr, "unable to open '%s': %s\n", buf_ptr(&build_file_abs), err_str(err));
|
||||
|
|
|
|||
253
std/build.zig
253
std/build.zig
|
|
@ -38,6 +38,7 @@ pub const Builder = struct {
|
|||
lib_dir: []const u8,
|
||||
out_dir: []u8,
|
||||
installed_files: List([]const u8),
|
||||
build_root: []const u8,
|
||||
|
||||
const UserInputOptionsMap = HashMap([]const u8, UserInputOption, mem.hash_slice_u8, mem.eql_slice_u8);
|
||||
const AvailableOptionsMap = HashMap([]const u8, AvailableOption, mem.hash_slice_u8, mem.eql_slice_u8);
|
||||
|
|
@ -73,8 +74,10 @@ pub const Builder = struct {
|
|||
description: []const u8,
|
||||
};
|
||||
|
||||
pub fn init(allocator: &Allocator) -> Builder {
|
||||
pub fn init(allocator: &Allocator, zig_exe: []const u8, build_root: []const u8) -> Builder {
|
||||
var self = Builder {
|
||||
.zig_exe = zig_exe,
|
||||
.build_root = build_root,
|
||||
.verbose = false,
|
||||
.invalid_user_input = false,
|
||||
.allocator = allocator,
|
||||
|
|
@ -85,7 +88,6 @@ pub const Builder = struct {
|
|||
.available_options_map = AvailableOptionsMap.init(allocator),
|
||||
.available_options_list = List(AvailableOption).init(allocator),
|
||||
.top_level_steps = List(&TopLevelStep).init(allocator),
|
||||
.zig_exe = undefined,
|
||||
.default_step = undefined,
|
||||
.env_map = %%os.getEnvMap(allocator),
|
||||
.prefix = undefined,
|
||||
|
|
@ -123,6 +125,12 @@ pub const Builder = struct {
|
|||
return exe;
|
||||
}
|
||||
|
||||
pub fn addTest(self: &Builder, root_src: []const u8) -> &TestStep {
|
||||
const test_step = %%self.allocator.create(TestStep);
|
||||
*test_step = TestStep.init(self, root_src);
|
||||
return test_step;
|
||||
}
|
||||
|
||||
pub fn addCStaticLibrary(self: &Builder, name: []const u8) -> &CLibrary {
|
||||
const lib = %%self.allocator.create(CLibrary);
|
||||
*lib = CLibrary.initStatic(self, name);
|
||||
|
|
@ -149,6 +157,19 @@ pub const Builder = struct {
|
|||
return cmd;
|
||||
}
|
||||
|
||||
pub fn addWriteFile(self: &Builder, file_path: []const u8, data: []const u8) -> &WriteFileStep {
|
||||
const write_file_step = %%self.allocator.create(WriteFileStep);
|
||||
*write_file_step = WriteFileStep.init(self, file_path, data);
|
||||
return write_file_step;
|
||||
}
|
||||
|
||||
pub fn addLog(self: &Builder, comptime format: []const u8, args: ...) -> &LogStep {
|
||||
const data = %%fmt.allocPrint(self.allocator, format, args);
|
||||
const log_step = %%self.allocator.create(LogStep);
|
||||
*log_step = LogStep.init(self, data);
|
||||
return log_step;
|
||||
}
|
||||
|
||||
pub fn version(self: &const Builder, major: u32, minor: u32, patch: u32) -> Version {
|
||||
Version {
|
||||
.major = major,
|
||||
|
|
@ -197,9 +218,8 @@ pub const Builder = struct {
|
|||
}
|
||||
|
||||
fn makeUninstall(uninstall_step: &Step) -> %void {
|
||||
// TODO
|
||||
// const self = @fieldParentPtr(Exe, "step", step);
|
||||
const self = @ptrcast(&Builder, uninstall_step);
|
||||
const uninstall_tls = @fieldParentPtr(TopLevelStep, "step", uninstall_step);
|
||||
const self = @fieldParentPtr(Builder, "uninstall_tls", uninstall_tls);
|
||||
|
||||
for (self.installed_files.toSliceConst()) |installed_file| {
|
||||
_ = os.deleteFile(self.allocator, installed_file);
|
||||
|
|
@ -278,7 +298,7 @@ pub const Builder = struct {
|
|||
}
|
||||
|
||||
pub fn option(self: &Builder, comptime T: type, name: []const u8, description: []const u8) -> ?T {
|
||||
const type_id = typeToEnum(T);
|
||||
const type_id = comptime typeToEnum(T);
|
||||
const available_option = AvailableOption {
|
||||
.name = name,
|
||||
.type_id = type_id,
|
||||
|
|
@ -313,7 +333,19 @@ pub const Builder = struct {
|
|||
},
|
||||
TypeId.Int => debug.panic("TODO integer options to build script"),
|
||||
TypeId.Float => debug.panic("TODO float options to build script"),
|
||||
TypeId.String => debug.panic("TODO string options to build script"),
|
||||
TypeId.String => switch (entry.value.value) {
|
||||
UserValue.Flag => {
|
||||
%%io.stderr.printf("Expected -D{} to be a string, but received a boolean.\n", name);
|
||||
self.markInvalidUserInput();
|
||||
return null;
|
||||
},
|
||||
UserValue.List => {
|
||||
%%io.stderr.printf("Expected -D{} to be a string, but received a list.\n", name);
|
||||
self.markInvalidUserInput();
|
||||
return null;
|
||||
},
|
||||
UserValue.Scalar => |s| return s,
|
||||
},
|
||||
TypeId.List => debug.panic("TODO list options to build script"),
|
||||
}
|
||||
}
|
||||
|
|
@ -482,6 +514,10 @@ pub const Builder = struct {
|
|||
debug.panic("Unable to copy {} to {}: {}", source_path, dest_path, @errorName(err));
|
||||
};
|
||||
}
|
||||
|
||||
fn pathFromRoot(self: &Builder, rel_path: []const u8) -> []u8 {
|
||||
return %%os.path.join(self.allocator, self.build_root, rel_path);
|
||||
}
|
||||
};
|
||||
|
||||
const Version = struct {
|
||||
|
|
@ -518,7 +554,7 @@ const LinkerScript = enum {
|
|||
Path: []const u8,
|
||||
};
|
||||
|
||||
const Exe = struct {
|
||||
pub const Exe = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
root_src: []const u8,
|
||||
|
|
@ -528,6 +564,7 @@ const Exe = struct {
|
|||
link_libs: BufSet,
|
||||
verbose: bool,
|
||||
release: bool,
|
||||
output_path: ?[]const u8,
|
||||
|
||||
pub fn init(builder: &Builder, name: []const u8, root_src: []const u8) -> Exe {
|
||||
Exe {
|
||||
|
|
@ -540,6 +577,7 @@ const Exe = struct {
|
|||
.linker_script = LinkerScript.None,
|
||||
.link_libs = BufSet.init(builder.allocator),
|
||||
.step = Step.init(name, builder.allocator, make),
|
||||
.output_path = null,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -579,6 +617,10 @@ const Exe = struct {
|
|||
self.release = value;
|
||||
}
|
||||
|
||||
pub fn setOutputPath(self: &Exe, value: []const u8) {
|
||||
self.output_path = value;
|
||||
}
|
||||
|
||||
fn make(step: &Step) -> %void {
|
||||
const exe = @fieldParentPtr(Exe, "step", step);
|
||||
const builder = exe.builder;
|
||||
|
|
@ -586,31 +628,36 @@ const Exe = struct {
|
|||
var zig_args = List([]const u8).init(builder.allocator);
|
||||
defer zig_args.deinit();
|
||||
|
||||
%return zig_args.append("build_exe");
|
||||
%return zig_args.append(exe.root_src);
|
||||
%%zig_args.append("build_exe");
|
||||
%%zig_args.append(builder.pathFromRoot(exe.root_src));
|
||||
|
||||
if (exe.verbose) {
|
||||
%return zig_args.append("--verbose");
|
||||
%%zig_args.append("--verbose");
|
||||
}
|
||||
|
||||
if (exe.release) {
|
||||
%return zig_args.append("--release");
|
||||
%%zig_args.append("--release");
|
||||
}
|
||||
|
||||
%return zig_args.append("--name");
|
||||
%return zig_args.append(exe.name);
|
||||
if (const output_path ?= exe.output_path) {
|
||||
%%zig_args.append("--output");
|
||||
%%zig_args.append(builder.pathFromRoot(output_path));
|
||||
}
|
||||
|
||||
%%zig_args.append("--name");
|
||||
%%zig_args.append(exe.name);
|
||||
|
||||
switch (exe.target) {
|
||||
Target.Native => {},
|
||||
Target.Cross => |cross_target| {
|
||||
%return zig_args.append("--target-arch");
|
||||
%return zig_args.append(@enumTagName(cross_target.arch));
|
||||
%%zig_args.append("--target-arch");
|
||||
%%zig_args.append(@enumTagName(cross_target.arch));
|
||||
|
||||
%return zig_args.append("--target-os");
|
||||
%return zig_args.append(@enumTagName(cross_target.os));
|
||||
%%zig_args.append("--target-os");
|
||||
%%zig_args.append(@enumTagName(cross_target.os));
|
||||
|
||||
%return zig_args.append("--target-environ");
|
||||
%return zig_args.append(@enumTagName(cross_target.environ));
|
||||
%%zig_args.append("--target-environ");
|
||||
%%zig_args.append(@enumTagName(cross_target.environ));
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -620,12 +667,12 @@ const Exe = struct {
|
|||
const tmp_file_name = "linker.ld.tmp"; // TODO issue #298
|
||||
io.writeFile(tmp_file_name, script, builder.allocator)
|
||||
%% |err| debug.panic("unable to write linker script: {}\n", @errorName(err));
|
||||
%return zig_args.append("--linker-script");
|
||||
%return zig_args.append(tmp_file_name);
|
||||
%%zig_args.append("--linker-script");
|
||||
%%zig_args.append(tmp_file_name);
|
||||
},
|
||||
LinkerScript.Path => |path| {
|
||||
%return zig_args.append("--linker-script");
|
||||
%return zig_args.append(path);
|
||||
%%zig_args.append("--linker-script");
|
||||
%%zig_args.append(path);
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -633,31 +680,109 @@ const Exe = struct {
|
|||
var it = exe.link_libs.iterator();
|
||||
while (true) {
|
||||
const entry = it.next() ?? break;
|
||||
%return zig_args.append("--library");
|
||||
%return zig_args.append(entry.key);
|
||||
%%zig_args.append("--library");
|
||||
%%zig_args.append(entry.key);
|
||||
}
|
||||
}
|
||||
|
||||
for (builder.include_paths.toSliceConst()) |include_path| {
|
||||
%return zig_args.append("-isystem");
|
||||
%return zig_args.append(include_path);
|
||||
%%zig_args.append("-isystem");
|
||||
%%zig_args.append(include_path);
|
||||
}
|
||||
|
||||
for (builder.rpaths.toSliceConst()) |rpath| {
|
||||
%return zig_args.append("-rpath");
|
||||
%return zig_args.append(rpath);
|
||||
%%zig_args.append("-rpath");
|
||||
%%zig_args.append(rpath);
|
||||
}
|
||||
|
||||
for (builder.lib_paths.toSliceConst()) |lib_path| {
|
||||
%return zig_args.append("--library-path");
|
||||
%return zig_args.append(lib_path);
|
||||
%%zig_args.append("--library-path");
|
||||
%%zig_args.append(lib_path);
|
||||
}
|
||||
|
||||
builder.spawnChild(builder.zig_exe, zig_args.toSliceConst());
|
||||
}
|
||||
};
|
||||
|
||||
const CLibrary = struct {
|
||||
pub const TestStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
root_src: []const u8,
|
||||
release: bool,
|
||||
verbose: bool,
|
||||
link_libs: BufSet,
|
||||
|
||||
pub fn init(builder: &Builder, root_src: []const u8) -> TestStep {
|
||||
const step_name = %%fmt.allocPrint(builder.allocator, "test {}", root_src);
|
||||
TestStep {
|
||||
.step = Step.init(step_name, builder.allocator, make),
|
||||
.builder = builder,
|
||||
.root_src = root_src,
|
||||
.release = false,
|
||||
.verbose = false,
|
||||
.link_libs = BufSet.init(builder.allocator),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn setVerbose(self: &TestStep, value: bool) {
|
||||
self.verbose = value;
|
||||
}
|
||||
|
||||
pub fn setRelease(self: &TestStep, value: bool) {
|
||||
self.release = value;
|
||||
}
|
||||
|
||||
pub fn linkLibrary(self: &TestStep, name: []const u8) {
|
||||
%%self.link_libs.put(name);
|
||||
}
|
||||
|
||||
fn make(step: &Step) -> %void {
|
||||
const self = @fieldParentPtr(TestStep, "step", step);
|
||||
const builder = self.builder;
|
||||
|
||||
var zig_args = List([]const u8).init(builder.allocator);
|
||||
defer zig_args.deinit();
|
||||
|
||||
%%zig_args.append("test");
|
||||
%%zig_args.append(builder.pathFromRoot(self.root_src));
|
||||
|
||||
if (self.verbose) {
|
||||
%%zig_args.append("--verbose");
|
||||
}
|
||||
|
||||
if (self.release) {
|
||||
%%zig_args.append("--release");
|
||||
}
|
||||
|
||||
{
|
||||
var it = self.link_libs.iterator();
|
||||
while (true) {
|
||||
const entry = it.next() ?? break;
|
||||
%%zig_args.append("--library");
|
||||
%%zig_args.append(entry.key);
|
||||
}
|
||||
}
|
||||
|
||||
for (builder.include_paths.toSliceConst()) |include_path| {
|
||||
%%zig_args.append("-isystem");
|
||||
%%zig_args.append(include_path);
|
||||
}
|
||||
|
||||
for (builder.rpaths.toSliceConst()) |rpath| {
|
||||
%%zig_args.append("-rpath");
|
||||
%%zig_args.append(rpath);
|
||||
}
|
||||
|
||||
for (builder.lib_paths.toSliceConst()) |lib_path| {
|
||||
%%zig_args.append("--library-path");
|
||||
%%zig_args.append(lib_path);
|
||||
}
|
||||
|
||||
builder.spawnChild(builder.zig_exe, zig_args.toSliceConst());
|
||||
}
|
||||
};
|
||||
|
||||
pub const CLibrary = struct {
|
||||
step: Step,
|
||||
name: []const u8,
|
||||
out_filename: []const u8,
|
||||
|
|
@ -829,7 +954,7 @@ const CLibrary = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const CExecutable = struct {
|
||||
pub const CExecutable = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
name: []const u8,
|
||||
|
|
@ -959,7 +1084,7 @@ const CExecutable = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const CommandStep = struct {
|
||||
pub const CommandStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
exe_path: []const u8,
|
||||
|
|
@ -988,7 +1113,7 @@ const CommandStep = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const InstallCLibraryStep = struct {
|
||||
pub const InstallCLibraryStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
lib: &CLibrary,
|
||||
|
|
@ -1023,7 +1148,7 @@ const InstallCLibraryStep = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const InstallFileStep = struct {
|
||||
pub const InstallFileStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
src_path: []const u8,
|
||||
|
|
@ -1047,7 +1172,59 @@ const InstallFileStep = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const Step = struct {
|
||||
pub const WriteFileStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
file_path: []const u8,
|
||||
data: []const u8,
|
||||
|
||||
pub fn init(builder: &Builder, file_path: []const u8, data: []const u8) -> WriteFileStep {
|
||||
return WriteFileStep {
|
||||
.builder = builder,
|
||||
.step = Step.init(
|
||||
%%fmt.allocPrint(builder.allocator, "writefile {}", file_path),
|
||||
builder.allocator, make),
|
||||
.file_path = file_path,
|
||||
.data = data,
|
||||
};
|
||||
}
|
||||
|
||||
fn make(step: &Step) -> %void {
|
||||
const self = @fieldParentPtr(WriteFileStep, "step", step);
|
||||
const full_path = self.builder.pathFromRoot(self.file_path);
|
||||
const full_path_dir = %%os.path.dirname(self.builder.allocator, full_path);
|
||||
os.makePath(self.builder.allocator, full_path_dir) %% |err| {
|
||||
debug.panic("unable to make path {}: {}\n", full_path_dir, @errorName(err));
|
||||
};
|
||||
io.writeFile(full_path, self.data, self.builder.allocator) %% |err| {
|
||||
debug.panic("unable to write {}: {}\n", full_path, @errorName(err));
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
pub const LogStep = struct {
|
||||
step: Step,
|
||||
builder: &Builder,
|
||||
data: []const u8,
|
||||
|
||||
pub fn init(builder: &Builder, data: []const u8) -> LogStep {
|
||||
return LogStep {
|
||||
.builder = builder,
|
||||
.step = Step.init(
|
||||
%%fmt.allocPrint(builder.allocator, "log {}", data),
|
||||
builder.allocator, make),
|
||||
.data = data,
|
||||
};
|
||||
}
|
||||
|
||||
fn make(step: &Step) -> %void {
|
||||
const self = @fieldParentPtr(LogStep, "step", step);
|
||||
%%io.stderr.write(self.data);
|
||||
%%io.stderr.flush();
|
||||
}
|
||||
};
|
||||
|
||||
pub const Step = struct {
|
||||
name: []const u8,
|
||||
makeFn: fn(self: &Step) -> %void,
|
||||
dependencies: List(&Step),
|
||||
|
|
|
|||
28
std/mem.zig
28
std/mem.zig
|
|
@ -134,6 +134,13 @@ pub fn eql(comptime T: type, a: []const T, b: []const T) -> bool {
|
|||
return true;
|
||||
}
|
||||
|
||||
/// Copies ::m to newly allocated memory. Caller is responsible to free it.
|
||||
pub fn dupe(allocator: &Allocator, comptime T: type, m: []const T) -> %[]T {
|
||||
const new_buf = %return allocator.alloc(T, m.len);
|
||||
copy(T, new_buf, m);
|
||||
return new_buf;
|
||||
}
|
||||
|
||||
/// Linear search for the index of a scalar value inside a slice.
|
||||
pub fn indexOfScalar(comptime T: type, slice: []const T, value: T) -> ?usize {
|
||||
for (slice) |item, i| {
|
||||
|
|
@ -144,6 +151,27 @@ pub fn indexOfScalar(comptime T: type, slice: []const T, value: T) -> ?usize {
|
|||
return null;
|
||||
}
|
||||
|
||||
// TODO boyer-moore algorithm
|
||||
pub fn indexOf(comptime T: type, haystack: []const T, needle: []const T) -> ?usize {
|
||||
if (needle.len > haystack.len)
|
||||
return null;
|
||||
|
||||
var i: usize = 0;
|
||||
const end = haystack.len - needle.len;
|
||||
while (i <= end; i += 1) {
|
||||
if (eql(T, haystack[i...i + needle.len], needle))
|
||||
return i;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
test "mem.indexOf" {
|
||||
assert(??indexOf(u8, "one two three four", "four") == 14);
|
||||
assert(indexOf(u8, "one two three four", "gour") == null);
|
||||
assert(??indexOf(u8, "foo", "foo") == 0);
|
||||
assert(indexOf(u8, "foo", "fool") == null);
|
||||
}
|
||||
|
||||
/// Reads an integer from memory with size equal to bytes.len.
|
||||
/// T specifies the return type, which must be large enough to store
|
||||
/// the result.
|
||||
|
|
|
|||
|
|
@ -12,6 +12,11 @@ pub const max_noalloc_path_len = 1024;
|
|||
pub const ChildProcess = @import("child_process.zig").ChildProcess;
|
||||
pub const path = @import("path.zig");
|
||||
|
||||
pub const line_sep = switch (@compileVar("os")) {
|
||||
Os.windows => "\r\n",
|
||||
else => "\n",
|
||||
};
|
||||
|
||||
const debug = @import("../debug.zig");
|
||||
const assert = debug.assert;
|
||||
|
||||
|
|
@ -319,7 +324,8 @@ fn posixExecveErrnoToErr(err: usize) -> error {
|
|||
errno.EINVAL, errno.ENOEXEC => error.InvalidExe,
|
||||
errno.EIO, errno.ELOOP => error.FileSystem,
|
||||
errno.EISDIR => error.IsDir,
|
||||
errno.ENOENT, errno.ENOTDIR => error.FileNotFound,
|
||||
errno.ENOENT => error.FileNotFound,
|
||||
errno.ENOTDIR => error.NotDir,
|
||||
errno.ETXTBSY => error.FileBusy,
|
||||
else => error.Unexpected,
|
||||
};
|
||||
|
|
@ -413,7 +419,8 @@ pub fn symLink(allocator: &Allocator, existing_path: []const u8, new_path: []con
|
|||
errno.EIO => error.FileSystem,
|
||||
errno.ELOOP => error.SymLinkLoop,
|
||||
errno.ENAMETOOLONG => error.NameTooLong,
|
||||
errno.ENOENT, errno.ENOTDIR => error.FileNotFound,
|
||||
errno.ENOENT => error.FileNotFound,
|
||||
errno.ENOTDIR => error.NotDir,
|
||||
errno.ENOMEM => error.SystemResources,
|
||||
errno.ENOSPC => error.NoSpaceLeft,
|
||||
errno.EROFS => error.ReadOnlyFileSystem,
|
||||
|
|
@ -471,7 +478,8 @@ pub fn deleteFile(allocator: &Allocator, file_path: []const u8) -> %void {
|
|||
errno.EISDIR => error.IsDir,
|
||||
errno.ELOOP => error.SymLinkLoop,
|
||||
errno.ENAMETOOLONG => error.NameTooLong,
|
||||
errno.ENOENT, errno.ENOTDIR => error.FileNotFound,
|
||||
errno.ENOENT => error.FileNotFound,
|
||||
errno.ENOTDIR => error.NotDir,
|
||||
errno.ENOMEM => error.SystemResources,
|
||||
errno.EROFS => error.ReadOnlyFileSystem,
|
||||
else => error.Unexpected,
|
||||
|
|
@ -518,7 +526,8 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
|
|||
errno.ELOOP => error.SymLinkLoop,
|
||||
errno.EMLINK => error.LinkQuotaExceeded,
|
||||
errno.ENAMETOOLONG => error.NameTooLong,
|
||||
errno.ENOENT, errno.ENOTDIR => error.FileNotFound,
|
||||
errno.ENOENT => error.FileNotFound,
|
||||
errno.ENOTDIR => error.NotDir,
|
||||
errno.ENOMEM => error.SystemResources,
|
||||
errno.ENOSPC => error.NoSpaceLeft,
|
||||
errno.EEXIST, errno.ENOTEMPTY => error.PathAlreadyExists,
|
||||
|
|
@ -528,3 +537,51 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
|
|||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub fn makeDir(allocator: &Allocator, dir_path: []const u8) -> %void {
|
||||
const path_buf = %return allocator.alloc(u8, dir_path.len + 1);
|
||||
defer allocator.free(path_buf);
|
||||
|
||||
mem.copy(u8, path_buf, dir_path);
|
||||
path_buf[dir_path.len] = 0;
|
||||
|
||||
const err = posix.getErrno(posix.mkdir(path_buf.ptr, 0o755));
|
||||
if (err > 0) {
|
||||
return switch (err) {
|
||||
errno.EACCES, errno.EPERM => error.AccessDenied,
|
||||
errno.EDQUOT => error.DiskQuota,
|
||||
errno.EEXIST => error.PathAlreadyExists,
|
||||
errno.EFAULT => unreachable,
|
||||
errno.ELOOP => error.SymLinkLoop,
|
||||
errno.EMLINK => error.LinkQuotaExceeded,
|
||||
errno.ENAMETOOLONG => error.NameTooLong,
|
||||
errno.ENOENT => error.FileNotFound,
|
||||
errno.ENOMEM => error.SystemResources,
|
||||
errno.ENOSPC => error.NoSpaceLeft,
|
||||
errno.ENOTDIR => error.NotDir,
|
||||
errno.EROFS => error.ReadOnlyFileSystem,
|
||||
else => error.Unexpected,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/// Calls makeDir recursively to make an entire path. Returns success if the path
|
||||
/// already exists and is a directory.
|
||||
pub fn makePath(allocator: &Allocator, full_path: []const u8) -> %void {
|
||||
const child_dir = %return path.dirname(allocator, full_path);
|
||||
defer allocator.free(child_dir);
|
||||
|
||||
if (mem.eql(u8, child_dir, full_path))
|
||||
return;
|
||||
|
||||
makePath(allocator, child_dir) %% |err| {
|
||||
if (err != error.PathAlreadyExists)
|
||||
return err;
|
||||
};
|
||||
|
||||
makeDir(allocator, full_path) %% |err| {
|
||||
if (err != error.PathAlreadyExists)
|
||||
return err;
|
||||
// TODO stat the file and return an error if it's not a directory
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -273,6 +273,10 @@ pub fn getcwd(buf: &u8, size: usize) -> usize {
|
|||
arch.syscall2(arch.SYS_getcwd, usize(buf), size)
|
||||
}
|
||||
|
||||
pub fn mkdir(path: &const u8, mode: usize) -> usize {
|
||||
arch.syscall2(arch.SYS_mkdir, usize(path), mode)
|
||||
}
|
||||
|
||||
pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: usize, fd: i32, offset: usize)
|
||||
-> usize
|
||||
{
|
||||
|
|
|
|||
|
|
@ -4,22 +4,61 @@ const mem = @import("../mem.zig");
|
|||
const Allocator = mem.Allocator;
|
||||
|
||||
/// Allocates memory for the result, which must be freed by the caller.
|
||||
pub fn join(allocator: &Allocator, dirname: []const u8, basename: []const u8) -> %[]const u8 {
|
||||
const buf = %return allocator.alloc(u8, dirname.len + basename.len + 1);
|
||||
pub fn join(allocator: &Allocator, paths: ...) -> %[]u8 {
|
||||
assert(paths.len >= 2);
|
||||
var total_paths_len: usize = paths.len; // 1 slash per path
|
||||
{
|
||||
comptime var path_i = 0;
|
||||
inline while (path_i < paths.len; path_i += 1) {
|
||||
const arg = ([]const u8)(paths[path_i]);
|
||||
total_paths_len += arg.len;
|
||||
}
|
||||
}
|
||||
|
||||
const buf = %return allocator.alloc(u8, total_paths_len);
|
||||
%defer allocator.free(buf);
|
||||
|
||||
mem.copy(u8, buf, dirname);
|
||||
if (dirname[dirname.len - 1] == '/') {
|
||||
mem.copy(u8, buf[dirname.len...], basename);
|
||||
return buf[0...buf.len - 1];
|
||||
} else {
|
||||
buf[dirname.len] = '/';
|
||||
mem.copy(u8, buf[dirname.len + 1 ...], basename);
|
||||
return buf;
|
||||
var buf_index: usize = 0;
|
||||
comptime var path_i = 0;
|
||||
inline while (true) {
|
||||
const arg = ([]const u8)(paths[path_i]);
|
||||
path_i += 1;
|
||||
mem.copy(u8, buf[buf_index...], arg);
|
||||
buf_index += arg.len;
|
||||
if (path_i >= paths.len) break;
|
||||
if (arg[arg.len - 1] != '/') {
|
||||
buf[buf_index] = '/';
|
||||
buf_index += 1;
|
||||
}
|
||||
}
|
||||
|
||||
return buf[0...buf_index];
|
||||
}
|
||||
|
||||
test "os.path.join" {
|
||||
assert(mem.eql(u8, %%join(&debug.global_allocator, "/a/b", "c"), "/a/b/c"));
|
||||
assert(mem.eql(u8, %%join(&debug.global_allocator, "/a/b/", "c"), "/a/b/c"));
|
||||
|
||||
assert(mem.eql(u8, %%join(&debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));
|
||||
assert(mem.eql(u8, %%join(&debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));
|
||||
}
|
||||
|
||||
pub fn dirname(allocator: &Allocator, path: []const u8) -> %[]u8 {
|
||||
if (path.len != 0) {
|
||||
var last_index: usize = path.len - 1;
|
||||
if (path[last_index] == '/')
|
||||
last_index -= 1;
|
||||
|
||||
var i: usize = last_index;
|
||||
while (true) {
|
||||
const c = path[i];
|
||||
if (c == '/')
|
||||
return mem.dupe(allocator, u8, path[0...i]);
|
||||
if (i == 0)
|
||||
break;
|
||||
i -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
return mem.dupe(allocator, u8, ".");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@ const Builder = @import("std").build.Builder;
|
|||
pub fn build(b: &Builder) {
|
||||
const release = b.option(bool, "release", "optimizations on and safety off") ?? false;
|
||||
|
||||
var exe = b.addExe("src/main.zig", "YOUR_NAME_HERE");
|
||||
const exe = b.addExecutable("YOUR_NAME_HERE", "src/main.zig");
|
||||
exe.setRelease(release);
|
||||
|
||||
b.default_step.dependOn(&exe.step);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,74 +10,85 @@ const List = std.list.List;
|
|||
error InvalidArgs;
|
||||
|
||||
pub fn main() -> %void {
|
||||
var arg_i: usize = 1;
|
||||
|
||||
const zig_exe = {
|
||||
if (arg_i >= os.args.count()) {
|
||||
%%io.stderr.printf("Expected first argument to be path to zig compiler\n");
|
||||
return error.InvalidArgs;
|
||||
}
|
||||
const result = os.args.at(arg_i);
|
||||
arg_i += 1;
|
||||
result
|
||||
};
|
||||
|
||||
const build_root = {
|
||||
if (arg_i >= os.args.count()) {
|
||||
%%io.stderr.printf("Expected second argument to be build root directory path\n");
|
||||
return error.InvalidArgs;
|
||||
}
|
||||
const result = os.args.at(arg_i);
|
||||
arg_i += 1;
|
||||
result
|
||||
};
|
||||
|
||||
// TODO use a more general purpose allocator here
|
||||
var inc_allocator = %%mem.IncrementingAllocator.init(10 * 1024 * 1024);
|
||||
defer inc_allocator.deinit();
|
||||
|
||||
const allocator = &inc_allocator.allocator;
|
||||
|
||||
var builder = Builder.init(allocator);
|
||||
var builder = Builder.init(allocator, zig_exe, build_root);
|
||||
defer builder.deinit();
|
||||
|
||||
var maybe_zig_exe: ?[]const u8 = null;
|
||||
var targets = List([]const u8).init(allocator);
|
||||
|
||||
var prefix: ?[]const u8 = null;
|
||||
|
||||
var arg_i: usize = 1;
|
||||
while (arg_i < os.args.count(); arg_i += 1) {
|
||||
const arg = os.args.at(arg_i);
|
||||
if (mem.startsWith(u8, arg, "-D")) {
|
||||
const option_contents = arg[2...];
|
||||
if (option_contents.len == 0) {
|
||||
%%io.stderr.printf("Expected option name after '-D'\n\n");
|
||||
return usage(&builder, maybe_zig_exe, false, &io.stderr);
|
||||
return usage(&builder, false, &io.stderr);
|
||||
}
|
||||
if (const name_end ?= mem.indexOfScalar(u8, option_contents, '=')) {
|
||||
const option_name = option_contents[0...name_end];
|
||||
const option_value = option_contents[name_end...];
|
||||
const option_value = option_contents[name_end + 1...];
|
||||
if (builder.addUserInputOption(option_name, option_value))
|
||||
return usage(&builder, maybe_zig_exe, false, &io.stderr);
|
||||
return usage(&builder, false, &io.stderr);
|
||||
} else {
|
||||
if (builder.addUserInputFlag(option_contents))
|
||||
return usage(&builder, maybe_zig_exe, false, &io.stderr);
|
||||
return usage(&builder, false, &io.stderr);
|
||||
}
|
||||
} else if (mem.startsWith(u8, arg, "-")) {
|
||||
if (mem.eql(u8, arg, "--verbose")) {
|
||||
builder.verbose = true;
|
||||
} else if (mem.eql(u8, arg, "--help")) {
|
||||
return usage(&builder, maybe_zig_exe, false, &io.stdout);
|
||||
return usage(&builder, false, &io.stdout);
|
||||
} else if (mem.eql(u8, arg, "--prefix") and arg_i + 1 < os.args.count()) {
|
||||
arg_i += 1;
|
||||
prefix = os.args.at(arg_i);
|
||||
} else {
|
||||
%%io.stderr.printf("Unrecognized argument: {}\n\n", arg);
|
||||
return usage(&builder, maybe_zig_exe, false, &io.stderr);
|
||||
return usage(&builder, false, &io.stderr);
|
||||
}
|
||||
} else if (maybe_zig_exe == null) {
|
||||
maybe_zig_exe = arg;
|
||||
} else {
|
||||
%%targets.append(arg);
|
||||
}
|
||||
}
|
||||
|
||||
builder.zig_exe = maybe_zig_exe ?? return usage(&builder, null, false, &io.stderr);
|
||||
builder.setInstallPrefix(prefix);
|
||||
|
||||
root.build(&builder);
|
||||
|
||||
if (builder.validateUserInputDidItFail())
|
||||
return usage(&builder, maybe_zig_exe, true, &io.stderr);
|
||||
return usage(&builder, true, &io.stderr);
|
||||
|
||||
%return builder.make(targets.toSliceConst());
|
||||
}
|
||||
|
||||
fn usage(builder: &Builder, maybe_zig_exe: ?[]const u8, already_ran_build: bool, out_stream: &io.OutStream) -> %void {
|
||||
const zig_exe = maybe_zig_exe ?? {
|
||||
%%out_stream.printf("Expected first argument to be path to zig compiler\n");
|
||||
return error.InvalidArgs;
|
||||
};
|
||||
|
||||
fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream) -> %void {
|
||||
// run the build script to collect the options
|
||||
if (!already_ran_build) {
|
||||
builder.setInstallPrefix(null);
|
||||
|
|
@ -90,7 +101,7 @@ fn usage(builder: &Builder, maybe_zig_exe: ?[]const u8, already_ran_build: bool,
|
|||
\\
|
||||
\\Steps:
|
||||
\\
|
||||
, zig_exe);
|
||||
, builder.zig_exe);
|
||||
|
||||
const allocator = builder.allocator;
|
||||
for (builder.top_level_steps.toSliceConst()) |top_level_step| {
|
||||
|
|
|
|||
|
|
@ -270,412 +270,6 @@ static TestCase *add_example_compile_libc(const char *root_source_file) {
|
|||
return add_example_compile_extra(root_source_file, true);
|
||||
}
|
||||
|
||||
static void add_compiling_test_cases(void) {
|
||||
add_simple_case_libc("hello world with libc", R"SOURCE(
|
||||
const c = @cImport(@cInclude("stdio.h"));
|
||||
export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
_ = c.puts(c"Hello, world!");
|
||||
return 0;
|
||||
}
|
||||
)SOURCE", "Hello, world!" NL);
|
||||
|
||||
{
|
||||
TestCase *tc = add_simple_case("multiple files with private function", R"SOURCE(
|
||||
use @import("std").io;
|
||||
use @import("foo.zig");
|
||||
|
||||
pub fn main() -> %void {
|
||||
privateFunction();
|
||||
%%stdout.printf("OK 2\n");
|
||||
}
|
||||
|
||||
fn privateFunction() {
|
||||
printText();
|
||||
}
|
||||
)SOURCE", "OK 1\nOK 2\n");
|
||||
|
||||
add_source_file(tc, "foo.zig", R"SOURCE(
|
||||
use @import("std").io;
|
||||
|
||||
// purposefully conflicting function with main.zig
|
||||
// but it's private so it should be OK
|
||||
fn privateFunction() {
|
||||
%%stdout.printf("OK 1\n");
|
||||
}
|
||||
|
||||
pub fn printText() {
|
||||
privateFunction();
|
||||
}
|
||||
)SOURCE");
|
||||
}
|
||||
|
||||
{
|
||||
TestCase *tc = add_simple_case("import segregation", R"SOURCE(
|
||||
use @import("foo.zig");
|
||||
use @import("bar.zig");
|
||||
|
||||
pub fn main() -> %void {
|
||||
foo_function();
|
||||
bar_function();
|
||||
}
|
||||
)SOURCE", "OK\nOK\n");
|
||||
|
||||
add_source_file(tc, "foo.zig", R"SOURCE(
|
||||
use @import("std").io;
|
||||
pub fn foo_function() {
|
||||
%%stdout.printf("OK\n");
|
||||
}
|
||||
)SOURCE");
|
||||
|
||||
add_source_file(tc, "bar.zig", R"SOURCE(
|
||||
use @import("other.zig");
|
||||
use @import("std").io;
|
||||
|
||||
pub fn bar_function() {
|
||||
if (foo_function()) {
|
||||
%%stdout.printf("OK\n");
|
||||
}
|
||||
}
|
||||
)SOURCE");
|
||||
|
||||
add_source_file(tc, "other.zig", R"SOURCE(
|
||||
pub fn foo_function() -> bool {
|
||||
// this one conflicts with the one from foo
|
||||
return true;
|
||||
}
|
||||
)SOURCE");
|
||||
}
|
||||
|
||||
{
|
||||
TestCase *tc = add_simple_case("two files use import each other", R"SOURCE(
|
||||
use @import("a.zig");
|
||||
|
||||
pub fn main() -> %void {
|
||||
ok();
|
||||
}
|
||||
)SOURCE", "OK\n");
|
||||
|
||||
add_source_file(tc, "a.zig", R"SOURCE(
|
||||
use @import("b.zig");
|
||||
const io = @import("std").io;
|
||||
|
||||
pub const a_text = "OK\n";
|
||||
|
||||
pub fn ok() {
|
||||
%%io.stdout.printf(b_text);
|
||||
}
|
||||
)SOURCE");
|
||||
|
||||
add_source_file(tc, "b.zig", R"SOURCE(
|
||||
use @import("a.zig");
|
||||
|
||||
pub const b_text = a_text;
|
||||
)SOURCE");
|
||||
}
|
||||
|
||||
|
||||
|
||||
add_simple_case("hello world without libc", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
|
||||
pub fn main() -> %void {
|
||||
%%io.stdout.printf("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a'));
|
||||
}
|
||||
)SOURCE", "Hello, world!\n0012 012 a\n");
|
||||
|
||||
|
||||
add_simple_case_libc("number literals", R"SOURCE(
|
||||
const c = @cImport(@cInclude("stdio.h"));
|
||||
|
||||
export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
_ = c.printf(c"\n");
|
||||
|
||||
_ = c.printf(c"0: %llu\n",
|
||||
u64(0));
|
||||
_ = c.printf(c"320402575052271: %llu\n",
|
||||
u64(320402575052271));
|
||||
_ = c.printf(c"0x01236789abcdef: %llu\n",
|
||||
u64(0x01236789abcdef));
|
||||
_ = c.printf(c"0xffffffffffffffff: %llu\n",
|
||||
u64(0xffffffffffffffff));
|
||||
_ = c.printf(c"0x000000ffffffffffffffff: %llu\n",
|
||||
u64(0x000000ffffffffffffffff));
|
||||
_ = c.printf(c"0o1777777777777777777777: %llu\n",
|
||||
u64(0o1777777777777777777777));
|
||||
_ = c.printf(c"0o0000001777777777777777777777: %llu\n",
|
||||
u64(0o0000001777777777777777777777));
|
||||
_ = c.printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
|
||||
u64(0b1111111111111111111111111111111111111111111111111111111111111111));
|
||||
_ = c.printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
|
||||
u64(0b0000001111111111111111111111111111111111111111111111111111111111111111));
|
||||
|
||||
_ = c.printf(c"\n");
|
||||
|
||||
_ = c.printf(c"0.0: %a\n",
|
||||
f64(0.0));
|
||||
_ = c.printf(c"0e0: %a\n",
|
||||
f64(0e0));
|
||||
_ = c.printf(c"0.0e0: %a\n",
|
||||
f64(0.0e0));
|
||||
_ = c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %a\n",
|
||||
f64(000000000000000000000000000000000000000000000000000000000.0e0));
|
||||
_ = c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %a\n",
|
||||
f64(0.000000000000000000000000000000000000000000000000000000000e0));
|
||||
_ = c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %a\n",
|
||||
f64(0.0e000000000000000000000000000000000000000000000000000000000));
|
||||
_ = c.printf(c"1.0: %a\n",
|
||||
f64(1.0));
|
||||
_ = c.printf(c"10.0: %a\n",
|
||||
f64(10.0));
|
||||
_ = c.printf(c"10.5: %a\n",
|
||||
f64(10.5));
|
||||
_ = c.printf(c"10.5e5: %a\n",
|
||||
f64(10.5e5));
|
||||
_ = c.printf(c"10.5e+5: %a\n",
|
||||
f64(10.5e+5));
|
||||
_ = c.printf(c"50.0e-2: %a\n",
|
||||
f64(50.0e-2));
|
||||
_ = c.printf(c"50e-2: %a\n",
|
||||
f64(50e-2));
|
||||
|
||||
_ = c.printf(c"\n");
|
||||
|
||||
_ = c.printf(c"0x1.0: %a\n",
|
||||
f64(0x1.0));
|
||||
_ = c.printf(c"0x10.0: %a\n",
|
||||
f64(0x10.0));
|
||||
_ = c.printf(c"0x100.0: %a\n",
|
||||
f64(0x100.0));
|
||||
_ = c.printf(c"0x103.0: %a\n",
|
||||
f64(0x103.0));
|
||||
_ = c.printf(c"0x103.7: %a\n",
|
||||
f64(0x103.7));
|
||||
_ = c.printf(c"0x103.70: %a\n",
|
||||
f64(0x103.70));
|
||||
_ = c.printf(c"0x103.70p4: %a\n",
|
||||
f64(0x103.70p4));
|
||||
_ = c.printf(c"0x103.70p5: %a\n",
|
||||
f64(0x103.70p5));
|
||||
_ = c.printf(c"0x103.70p+5: %a\n",
|
||||
f64(0x103.70p+5));
|
||||
_ = c.printf(c"0x103.70p-5: %a\n",
|
||||
f64(0x103.70p-5));
|
||||
|
||||
_ = c.printf(c"\n");
|
||||
|
||||
_ = c.printf(c"0b10100.00010e0: %a\n",
|
||||
f64(0b10100.00010e0));
|
||||
_ = c.printf(c"0o10700.00010e0: %a\n",
|
||||
f64(0o10700.00010e0));
|
||||
|
||||
return 0;
|
||||
}
|
||||
)SOURCE", R"OUTPUT(
|
||||
0: 0
|
||||
320402575052271: 320402575052271
|
||||
0x01236789abcdef: 320402575052271
|
||||
0xffffffffffffffff: 18446744073709551615
|
||||
0x000000ffffffffffffffff: 18446744073709551615
|
||||
0o1777777777777777777777: 18446744073709551615
|
||||
0o0000001777777777777777777777: 18446744073709551615
|
||||
0b1111111111111111111111111111111111111111111111111111111111111111: 18446744073709551615
|
||||
0b0000001111111111111111111111111111111111111111111111111111111111111111: 18446744073709551615
|
||||
|
||||
0.0: 0x0p+0
|
||||
0e0: 0x0p+0
|
||||
0.0e0: 0x0p+0
|
||||
000000000000000000000000000000000000000000000000000000000.0e0: 0x0p+0
|
||||
0.000000000000000000000000000000000000000000000000000000000e0: 0x0p+0
|
||||
0.0e000000000000000000000000000000000000000000000000000000000: 0x0p+0
|
||||
1.0: 0x1p+0
|
||||
10.0: 0x1.4p+3
|
||||
10.5: 0x1.5p+3
|
||||
10.5e5: 0x1.0059p+20
|
||||
10.5e+5: 0x1.0059p+20
|
||||
50.0e-2: 0x1p-1
|
||||
50e-2: 0x1p-1
|
||||
|
||||
0x1.0: 0x1p+0
|
||||
0x10.0: 0x1p+4
|
||||
0x100.0: 0x1p+8
|
||||
0x103.0: 0x1.03p+8
|
||||
0x103.7: 0x1.037p+8
|
||||
0x103.70: 0x1.037p+8
|
||||
0x103.70p4: 0x1.037p+12
|
||||
0x103.70p5: 0x1.037p+13
|
||||
0x103.70p+5: 0x1.037p+13
|
||||
0x103.70p-5: 0x1.037p+3
|
||||
|
||||
0b10100.00010e0: 0x1.41p+4
|
||||
0o10700.00010e0: 0x1.1c0001p+12
|
||||
)OUTPUT");
|
||||
|
||||
add_simple_case("order-independent declarations", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
const z = io.stdin_fileno;
|
||||
const x : @typeOf(y) = 1234;
|
||||
const y : u16 = 5678;
|
||||
pub fn main() -> %void {
|
||||
var x_local : i32 = print_ok(x);
|
||||
}
|
||||
fn print_ok(val: @typeOf(x)) -> @typeOf(foo) {
|
||||
%%io.stdout.printf("OK\n");
|
||||
return 0;
|
||||
}
|
||||
const foo : i32 = 0;
|
||||
)SOURCE", "OK\n");
|
||||
|
||||
add_simple_case_libc("expose function pointer to C land", R"SOURCE(
|
||||
const c = @cImport(@cInclude("stdlib.h"));
|
||||
|
||||
export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {
|
||||
const a_int = @ptrcast(&i32, a ?? unreachable);
|
||||
const b_int = @ptrcast(&i32, b ?? unreachable);
|
||||
if (*a_int < *b_int) {
|
||||
-1
|
||||
} else if (*a_int > *b_int) {
|
||||
1
|
||||
} else {
|
||||
c_int(0)
|
||||
}
|
||||
}
|
||||
|
||||
export fn main() -> c_int {
|
||||
var array = []u32 { 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };
|
||||
|
||||
c.qsort(@ptrcast(&c_void, &array[0]), c_ulong(array.len), @sizeOf(i32), compare_fn);
|
||||
|
||||
for (array) |item, i| {
|
||||
if (item != i) {
|
||||
c.abort();
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
)SOURCE", "");
|
||||
|
||||
|
||||
|
||||
add_simple_case_libc("casting between float and integer types", R"SOURCE(
|
||||
const c = @cImport(@cInclude("stdio.h"));
|
||||
export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
const small: f32 = 3.25;
|
||||
const x: f64 = small;
|
||||
const y = i32(x);
|
||||
const z = f64(y);
|
||||
_ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, f64(-0.4));
|
||||
return 0;
|
||||
}
|
||||
)SOURCE", "3.25\n3\n3.00\n-0.40\n");
|
||||
|
||||
|
||||
add_simple_case("same named methods in incomplete struct", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
|
||||
const Foo = struct {
|
||||
field1: Bar,
|
||||
|
||||
fn method(a: &const Foo) -> bool { true }
|
||||
};
|
||||
|
||||
const Bar = struct {
|
||||
field2: i32,
|
||||
|
||||
fn method(b: &const Bar) -> bool { true }
|
||||
};
|
||||
|
||||
pub fn main() -> %void {
|
||||
const bar = Bar {.field2 = 13,};
|
||||
const foo = Foo {.field1 = bar,};
|
||||
if (!foo.method()) {
|
||||
%%io.stdout.printf("BAD\n");
|
||||
}
|
||||
if (!bar.method()) {
|
||||
%%io.stdout.printf("BAD\n");
|
||||
}
|
||||
%%io.stdout.printf("OK\n");
|
||||
}
|
||||
)SOURCE", "OK\n");
|
||||
|
||||
|
||||
add_simple_case("defer with only fallthrough", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
pub fn main() -> %void {
|
||||
%%io.stdout.printf("before\n");
|
||||
defer %%io.stdout.printf("defer1\n");
|
||||
defer %%io.stdout.printf("defer2\n");
|
||||
defer %%io.stdout.printf("defer3\n");
|
||||
%%io.stdout.printf("after\n");
|
||||
}
|
||||
)SOURCE", "before\nafter\ndefer3\ndefer2\ndefer1\n");
|
||||
|
||||
|
||||
add_simple_case("defer with return", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
const os = @import("std").os;
|
||||
pub fn main() -> %void {
|
||||
%%io.stdout.printf("before\n");
|
||||
defer %%io.stdout.printf("defer1\n");
|
||||
defer %%io.stdout.printf("defer2\n");
|
||||
if (os.args.count() == 1) return;
|
||||
defer %%io.stdout.printf("defer3\n");
|
||||
%%io.stdout.printf("after\n");
|
||||
}
|
||||
)SOURCE", "before\ndefer2\ndefer1\n");
|
||||
|
||||
|
||||
add_simple_case("%defer and it fails", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
pub fn main() -> %void {
|
||||
do_test() %% return;
|
||||
}
|
||||
fn do_test() -> %void {
|
||||
%%io.stdout.printf("before\n");
|
||||
defer %%io.stdout.printf("defer1\n");
|
||||
%defer %%io.stdout.printf("deferErr\n");
|
||||
%return its_gonna_fail();
|
||||
defer %%io.stdout.printf("defer3\n");
|
||||
%%io.stdout.printf("after\n");
|
||||
}
|
||||
error IToldYouItWouldFail;
|
||||
fn its_gonna_fail() -> %void {
|
||||
return error.IToldYouItWouldFail;
|
||||
}
|
||||
)SOURCE", "before\ndeferErr\ndefer1\n");
|
||||
|
||||
|
||||
add_simple_case("%defer and it passes", R"SOURCE(
|
||||
const io = @import("std").io;
|
||||
pub fn main() -> %void {
|
||||
do_test() %% return;
|
||||
}
|
||||
fn do_test() -> %void {
|
||||
%%io.stdout.printf("before\n");
|
||||
defer %%io.stdout.printf("defer1\n");
|
||||
%defer %%io.stdout.printf("deferErr\n");
|
||||
%return its_gonna_pass();
|
||||
defer %%io.stdout.printf("defer3\n");
|
||||
%%io.stdout.printf("after\n");
|
||||
}
|
||||
fn its_gonna_pass() -> %void { }
|
||||
)SOURCE", "before\nafter\ndefer3\ndefer1\n");
|
||||
|
||||
|
||||
{
|
||||
TestCase *tc = add_simple_case("@embedFile", R"SOURCE(
|
||||
const foo_txt = @embedFile("foo.txt");
|
||||
const io = @import("std").io;
|
||||
|
||||
pub fn main() -> %void {
|
||||
%%io.stdout.printf(foo_txt);
|
||||
}
|
||||
)SOURCE", "1234\nabcd\n");
|
||||
|
||||
add_source_file(tc, "foo.txt", "1234\nabcd\n");
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void add_build_examples(void) {
|
||||
|
|
@ -3021,7 +2615,6 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
}
|
||||
}
|
||||
add_compiling_test_cases();
|
||||
add_build_examples();
|
||||
add_debug_safety_test_cases();
|
||||
add_compile_failure_test_cases();
|
||||
|
|
|
|||
|
|
@ -0,0 +1,5 @@
|
|||
const io = @import("std").io;
|
||||
|
||||
pub fn main() -> %void {
|
||||
%%io.stderr.printf("TODO run tests\n");
|
||||
}
|
||||
|
|
@ -0,0 +1,587 @@
|
|||
const std = @import("std");
|
||||
const debug = std.debug;
|
||||
const build = std.build;
|
||||
const os = std.os;
|
||||
const StdIo = os.ChildProcess.StdIo;
|
||||
const Term = os.ChildProcess.Term;
|
||||
const Buffer0 = std.cstr.Buffer0;
|
||||
const io = std.io;
|
||||
const mem = std.mem;
|
||||
const fmt = std.fmt;
|
||||
const List = std.list.List;
|
||||
|
||||
error TestFailed;
|
||||
|
||||
pub fn addCompareOutputTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
|
||||
const cases = %%b.allocator.create(CompareOutputContext);
|
||||
*cases = CompareOutputContext {
|
||||
.b = b,
|
||||
.compare_output_tests = b.step("test-compare-output", "Run the compare output tests"),
|
||||
.test_index = 0,
|
||||
.test_filter = test_filter,
|
||||
};
|
||||
|
||||
cases.addC("hello world with libc",
|
||||
\\const c = @cImport(@cInclude("stdio.h"));
|
||||
\\export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
\\ _ = c.puts(c"Hello, world!");
|
||||
\\ return 0;
|
||||
\\}
|
||||
, "Hello, world!" ++ os.line_sep);
|
||||
|
||||
cases.addCase({
|
||||
var tc = cases.create("multiple files with private function",
|
||||
\\use @import("std").io;
|
||||
\\use @import("foo.zig");
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ privateFunction();
|
||||
\\ %%stdout.printf("OK 2\n");
|
||||
\\}
|
||||
\\
|
||||
\\fn privateFunction() {
|
||||
\\ printText();
|
||||
\\}
|
||||
, "OK 1\nOK 2\n");
|
||||
|
||||
tc.addSourceFile("foo.zig",
|
||||
\\use @import("std").io;
|
||||
\\
|
||||
\\// purposefully conflicting function with main.zig
|
||||
\\// but it's private so it should be OK
|
||||
\\fn privateFunction() {
|
||||
\\ %%stdout.printf("OK 1\n");
|
||||
\\}
|
||||
\\
|
||||
\\pub fn printText() {
|
||||
\\ privateFunction();
|
||||
\\}
|
||||
);
|
||||
|
||||
tc
|
||||
});
|
||||
|
||||
cases.addCase({
|
||||
var tc = cases.create("import segregation",
|
||||
\\use @import("foo.zig");
|
||||
\\use @import("bar.zig");
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ foo_function();
|
||||
\\ bar_function();
|
||||
\\}
|
||||
, "OK\nOK\n");
|
||||
|
||||
tc.addSourceFile("foo.zig",
|
||||
\\use @import("std").io;
|
||||
\\pub fn foo_function() {
|
||||
\\ %%stdout.printf("OK\n");
|
||||
\\}
|
||||
);
|
||||
|
||||
tc.addSourceFile("bar.zig",
|
||||
\\use @import("other.zig");
|
||||
\\use @import("std").io;
|
||||
\\
|
||||
\\pub fn bar_function() {
|
||||
\\ if (foo_function()) {
|
||||
\\ %%stdout.printf("OK\n");
|
||||
\\ }
|
||||
\\}
|
||||
);
|
||||
|
||||
tc.addSourceFile("other.zig",
|
||||
\\pub fn foo_function() -> bool {
|
||||
\\ // this one conflicts with the one from foo
|
||||
\\ return true;
|
||||
\\}
|
||||
);
|
||||
|
||||
tc
|
||||
});
|
||||
|
||||
cases.addCase({
|
||||
var tc = cases.create("two files use import each other",
|
||||
\\use @import("a.zig");
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ ok();
|
||||
\\}
|
||||
, "OK\n");
|
||||
|
||||
tc.addSourceFile("a.zig",
|
||||
\\use @import("b.zig");
|
||||
\\const io = @import("std").io;
|
||||
\\
|
||||
\\pub const a_text = "OK\n";
|
||||
\\
|
||||
\\pub fn ok() {
|
||||
\\ %%io.stdout.printf(b_text);
|
||||
\\}
|
||||
);
|
||||
|
||||
tc.addSourceFile("b.zig",
|
||||
\\use @import("a.zig");
|
||||
\\
|
||||
\\pub const b_text = a_text;
|
||||
);
|
||||
|
||||
tc
|
||||
});
|
||||
|
||||
cases.add("hello world without libc",
|
||||
\\const io = @import("std").io;
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ %%io.stdout.printf("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a'));
|
||||
\\}
|
||||
, "Hello, world!\n0012 012 a\n");
|
||||
|
||||
cases.addC("number literals",
|
||||
\\const c = @cImport(@cInclude("stdio.h"));
|
||||
\\
|
||||
\\export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
\\ _ = c.printf(c"0: %llu\n",
|
||||
\\ u64(0));
|
||||
\\ _ = c.printf(c"320402575052271: %llu\n",
|
||||
\\ u64(320402575052271));
|
||||
\\ _ = c.printf(c"0x01236789abcdef: %llu\n",
|
||||
\\ u64(0x01236789abcdef));
|
||||
\\ _ = c.printf(c"0xffffffffffffffff: %llu\n",
|
||||
\\ u64(0xffffffffffffffff));
|
||||
\\ _ = c.printf(c"0x000000ffffffffffffffff: %llu\n",
|
||||
\\ u64(0x000000ffffffffffffffff));
|
||||
\\ _ = c.printf(c"0o1777777777777777777777: %llu\n",
|
||||
\\ u64(0o1777777777777777777777));
|
||||
\\ _ = c.printf(c"0o0000001777777777777777777777: %llu\n",
|
||||
\\ u64(0o0000001777777777777777777777));
|
||||
\\ _ = c.printf(c"0b1111111111111111111111111111111111111111111111111111111111111111: %llu\n",
|
||||
\\ u64(0b1111111111111111111111111111111111111111111111111111111111111111));
|
||||
\\ _ = c.printf(c"0b0000001111111111111111111111111111111111111111111111111111111111111111: %llu\n",
|
||||
\\ u64(0b0000001111111111111111111111111111111111111111111111111111111111111111));
|
||||
\\
|
||||
\\ _ = c.printf(c"\n");
|
||||
\\
|
||||
\\ _ = c.printf(c"0.0: %a\n",
|
||||
\\ f64(0.0));
|
||||
\\ _ = c.printf(c"0e0: %a\n",
|
||||
\\ f64(0e0));
|
||||
\\ _ = c.printf(c"0.0e0: %a\n",
|
||||
\\ f64(0.0e0));
|
||||
\\ _ = c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %a\n",
|
||||
\\ f64(000000000000000000000000000000000000000000000000000000000.0e0));
|
||||
\\ _ = c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %a\n",
|
||||
\\ f64(0.000000000000000000000000000000000000000000000000000000000e0));
|
||||
\\ _ = c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %a\n",
|
||||
\\ f64(0.0e000000000000000000000000000000000000000000000000000000000));
|
||||
\\ _ = c.printf(c"1.0: %a\n",
|
||||
\\ f64(1.0));
|
||||
\\ _ = c.printf(c"10.0: %a\n",
|
||||
\\ f64(10.0));
|
||||
\\ _ = c.printf(c"10.5: %a\n",
|
||||
\\ f64(10.5));
|
||||
\\ _ = c.printf(c"10.5e5: %a\n",
|
||||
\\ f64(10.5e5));
|
||||
\\ _ = c.printf(c"10.5e+5: %a\n",
|
||||
\\ f64(10.5e+5));
|
||||
\\ _ = c.printf(c"50.0e-2: %a\n",
|
||||
\\ f64(50.0e-2));
|
||||
\\ _ = c.printf(c"50e-2: %a\n",
|
||||
\\ f64(50e-2));
|
||||
\\
|
||||
\\ _ = c.printf(c"\n");
|
||||
\\
|
||||
\\ _ = c.printf(c"0x1.0: %a\n",
|
||||
\\ f64(0x1.0));
|
||||
\\ _ = c.printf(c"0x10.0: %a\n",
|
||||
\\ f64(0x10.0));
|
||||
\\ _ = c.printf(c"0x100.0: %a\n",
|
||||
\\ f64(0x100.0));
|
||||
\\ _ = c.printf(c"0x103.0: %a\n",
|
||||
\\ f64(0x103.0));
|
||||
\\ _ = c.printf(c"0x103.7: %a\n",
|
||||
\\ f64(0x103.7));
|
||||
\\ _ = c.printf(c"0x103.70: %a\n",
|
||||
\\ f64(0x103.70));
|
||||
\\ _ = c.printf(c"0x103.70p4: %a\n",
|
||||
\\ f64(0x103.70p4));
|
||||
\\ _ = c.printf(c"0x103.70p5: %a\n",
|
||||
\\ f64(0x103.70p5));
|
||||
\\ _ = c.printf(c"0x103.70p+5: %a\n",
|
||||
\\ f64(0x103.70p+5));
|
||||
\\ _ = c.printf(c"0x103.70p-5: %a\n",
|
||||
\\ f64(0x103.70p-5));
|
||||
\\
|
||||
\\ _ = c.printf(c"\n");
|
||||
\\
|
||||
\\ _ = c.printf(c"0b10100.00010e0: %a\n",
|
||||
\\ f64(0b10100.00010e0));
|
||||
\\ _ = c.printf(c"0o10700.00010e0: %a\n",
|
||||
\\ f64(0o10700.00010e0));
|
||||
\\
|
||||
\\ return 0;
|
||||
\\}
|
||||
,
|
||||
\\0: 0
|
||||
\\320402575052271: 320402575052271
|
||||
\\0x01236789abcdef: 320402575052271
|
||||
\\0xffffffffffffffff: 18446744073709551615
|
||||
\\0x000000ffffffffffffffff: 18446744073709551615
|
||||
\\0o1777777777777777777777: 18446744073709551615
|
||||
\\0o0000001777777777777777777777: 18446744073709551615
|
||||
\\0b1111111111111111111111111111111111111111111111111111111111111111: 18446744073709551615
|
||||
\\0b0000001111111111111111111111111111111111111111111111111111111111111111: 18446744073709551615
|
||||
\\
|
||||
\\0.0: 0x0p+0
|
||||
\\0e0: 0x0p+0
|
||||
\\0.0e0: 0x0p+0
|
||||
\\000000000000000000000000000000000000000000000000000000000.0e0: 0x0p+0
|
||||
\\0.000000000000000000000000000000000000000000000000000000000e0: 0x0p+0
|
||||
\\0.0e000000000000000000000000000000000000000000000000000000000: 0x0p+0
|
||||
\\1.0: 0x1p+0
|
||||
\\10.0: 0x1.4p+3
|
||||
\\10.5: 0x1.5p+3
|
||||
\\10.5e5: 0x1.0059p+20
|
||||
\\10.5e+5: 0x1.0059p+20
|
||||
\\50.0e-2: 0x1p-1
|
||||
\\50e-2: 0x1p-1
|
||||
\\
|
||||
\\0x1.0: 0x1p+0
|
||||
\\0x10.0: 0x1p+4
|
||||
\\0x100.0: 0x1p+8
|
||||
\\0x103.0: 0x1.03p+8
|
||||
\\0x103.7: 0x1.037p+8
|
||||
\\0x103.70: 0x1.037p+8
|
||||
\\0x103.70p4: 0x1.037p+12
|
||||
\\0x103.70p5: 0x1.037p+13
|
||||
\\0x103.70p+5: 0x1.037p+13
|
||||
\\0x103.70p-5: 0x1.037p+3
|
||||
\\
|
||||
\\0b10100.00010e0: 0x1.41p+4
|
||||
\\0o10700.00010e0: 0x1.1c0001p+12
|
||||
\\
|
||||
);
|
||||
|
||||
cases.add("order-independent declarations",
|
||||
\\const io = @import("std").io;
|
||||
\\const z = io.stdin_fileno;
|
||||
\\const x : @typeOf(y) = 1234;
|
||||
\\const y : u16 = 5678;
|
||||
\\pub fn main() -> %void {
|
||||
\\ var x_local : i32 = print_ok(x);
|
||||
\\}
|
||||
\\fn print_ok(val: @typeOf(x)) -> @typeOf(foo) {
|
||||
\\ %%io.stdout.printf("OK\n");
|
||||
\\ return 0;
|
||||
\\}
|
||||
\\const foo : i32 = 0;
|
||||
, "OK\n");
|
||||
|
||||
cases.addC("expose function pointer to C land",
|
||||
\\const c = @cImport(@cInclude("stdlib.h"));
|
||||
\\
|
||||
\\export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {
|
||||
\\ const a_int = @ptrcast(&i32, a ?? unreachable);
|
||||
\\ const b_int = @ptrcast(&i32, b ?? unreachable);
|
||||
\\ if (*a_int < *b_int) {
|
||||
\\ -1
|
||||
\\ } else if (*a_int > *b_int) {
|
||||
\\ 1
|
||||
\\ } else {
|
||||
\\ c_int(0)
|
||||
\\ }
|
||||
\\}
|
||||
\\
|
||||
\\export fn main() -> c_int {
|
||||
\\ var array = []u32 { 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };
|
||||
\\
|
||||
\\ c.qsort(@ptrcast(&c_void, &array[0]), c_ulong(array.len), @sizeOf(i32), compare_fn);
|
||||
\\
|
||||
\\ for (array) |item, i| {
|
||||
\\ if (item != i) {
|
||||
\\ c.abort();
|
||||
\\ }
|
||||
\\ }
|
||||
\\
|
||||
\\ return 0;
|
||||
\\}
|
||||
, "");
|
||||
|
||||
cases.addC("casting between float and integer types",
|
||||
\\const c = @cImport(@cInclude("stdio.h"));
|
||||
\\export fn main(argc: c_int, argv: &&u8) -> c_int {
|
||||
\\ const small: f32 = 3.25;
|
||||
\\ const x: f64 = small;
|
||||
\\ const y = i32(x);
|
||||
\\ const z = f64(y);
|
||||
\\ _ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, f64(-0.4));
|
||||
\\ return 0;
|
||||
\\}
|
||||
, "3.25\n3\n3.00\n-0.40\n");
|
||||
|
||||
cases.add("same named methods in incomplete struct",
|
||||
\\const io = @import("std").io;
|
||||
\\
|
||||
\\const Foo = struct {
|
||||
\\ field1: Bar,
|
||||
\\
|
||||
\\ fn method(a: &const Foo) -> bool { true }
|
||||
\\};
|
||||
\\
|
||||
\\const Bar = struct {
|
||||
\\ field2: i32,
|
||||
\\
|
||||
\\ fn method(b: &const Bar) -> bool { true }
|
||||
\\};
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ const bar = Bar {.field2 = 13,};
|
||||
\\ const foo = Foo {.field1 = bar,};
|
||||
\\ if (!foo.method()) {
|
||||
\\ %%io.stdout.printf("BAD\n");
|
||||
\\ }
|
||||
\\ if (!bar.method()) {
|
||||
\\ %%io.stdout.printf("BAD\n");
|
||||
\\ }
|
||||
\\ %%io.stdout.printf("OK\n");
|
||||
\\}
|
||||
, "OK\n");
|
||||
|
||||
cases.add("defer with only fallthrough",
|
||||
\\const io = @import("std").io;
|
||||
\\pub fn main() -> %void {
|
||||
\\ %%io.stdout.printf("before\n");
|
||||
\\ defer %%io.stdout.printf("defer1\n");
|
||||
\\ defer %%io.stdout.printf("defer2\n");
|
||||
\\ defer %%io.stdout.printf("defer3\n");
|
||||
\\ %%io.stdout.printf("after\n");
|
||||
\\}
|
||||
, "before\nafter\ndefer3\ndefer2\ndefer1\n");
|
||||
|
||||
cases.add("defer with return",
|
||||
\\const io = @import("std").io;
|
||||
\\const os = @import("std").os;
|
||||
\\pub fn main() -> %void {
|
||||
\\ %%io.stdout.printf("before\n");
|
||||
\\ defer %%io.stdout.printf("defer1\n");
|
||||
\\ defer %%io.stdout.printf("defer2\n");
|
||||
\\ if (os.args.count() == 1) return;
|
||||
\\ defer %%io.stdout.printf("defer3\n");
|
||||
\\ %%io.stdout.printf("after\n");
|
||||
\\}
|
||||
, "before\ndefer2\ndefer1\n");
|
||||
|
||||
cases.add("%defer and it fails",
|
||||
\\const io = @import("std").io;
|
||||
\\pub fn main() -> %void {
|
||||
\\ do_test() %% return;
|
||||
\\}
|
||||
\\fn do_test() -> %void {
|
||||
\\ %%io.stdout.printf("before\n");
|
||||
\\ defer %%io.stdout.printf("defer1\n");
|
||||
\\ %defer %%io.stdout.printf("deferErr\n");
|
||||
\\ %return its_gonna_fail();
|
||||
\\ defer %%io.stdout.printf("defer3\n");
|
||||
\\ %%io.stdout.printf("after\n");
|
||||
\\}
|
||||
\\error IToldYouItWouldFail;
|
||||
\\fn its_gonna_fail() -> %void {
|
||||
\\ return error.IToldYouItWouldFail;
|
||||
\\}
|
||||
, "before\ndeferErr\ndefer1\n");
|
||||
|
||||
cases.add("%defer and it passes",
|
||||
\\const io = @import("std").io;
|
||||
\\pub fn main() -> %void {
|
||||
\\ do_test() %% return;
|
||||
\\}
|
||||
\\fn do_test() -> %void {
|
||||
\\ %%io.stdout.printf("before\n");
|
||||
\\ defer %%io.stdout.printf("defer1\n");
|
||||
\\ %defer %%io.stdout.printf("deferErr\n");
|
||||
\\ %return its_gonna_pass();
|
||||
\\ defer %%io.stdout.printf("defer3\n");
|
||||
\\ %%io.stdout.printf("after\n");
|
||||
\\}
|
||||
\\fn its_gonna_pass() -> %void { }
|
||||
, "before\nafter\ndefer3\ndefer1\n");
|
||||
|
||||
cases.addCase({
|
||||
var tc = cases.create("@embedFile",
|
||||
\\const foo_txt = @embedFile("foo.txt");
|
||||
\\const io = @import("std").io;
|
||||
\\
|
||||
\\pub fn main() -> %void {
|
||||
\\ %%io.stdout.printf(foo_txt);
|
||||
\\}
|
||||
, "1234\nabcd\n");
|
||||
|
||||
tc.addSourceFile("foo.txt", "1234\nabcd\n");
|
||||
|
||||
tc
|
||||
});
|
||||
|
||||
return cases.compare_output_tests;
|
||||
}
|
||||
|
||||
const CompareOutputContext = struct {
|
||||
b: &build.Builder,
|
||||
compare_output_tests: &build.Step,
|
||||
test_index: usize,
|
||||
test_filter: ?[]const u8,
|
||||
|
||||
const TestCase = struct {
|
||||
name: []const u8,
|
||||
sources: List(SourceFile),
|
||||
expected_output: []const u8,
|
||||
link_libc: bool,
|
||||
|
||||
const SourceFile = struct {
|
||||
filename: []const u8,
|
||||
source: []const u8,
|
||||
};
|
||||
|
||||
pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) {
|
||||
%%self.sources.append(SourceFile {
|
||||
.filename = filename,
|
||||
.source = source,
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
pub fn create(self: &CompareOutputContext, name: []const u8, source: []const u8,
|
||||
expected_output: []const u8) -> TestCase
|
||||
{
|
||||
var tc = TestCase {
|
||||
.name = name,
|
||||
.sources = List(TestCase.SourceFile).init(self.b.allocator),
|
||||
.expected_output = expected_output,
|
||||
.link_libc = false,
|
||||
};
|
||||
tc.addSourceFile("source.zig", source);
|
||||
return tc;
|
||||
}
|
||||
|
||||
pub fn addC(self: &CompareOutputContext, name: []const u8, source: []const u8, expected_output: []const u8) {
|
||||
var tc = self.create(name, source, expected_output);
|
||||
tc.link_libc = true;
|
||||
self.addCase(tc);
|
||||
}
|
||||
|
||||
pub fn add(self: &CompareOutputContext, name: []const u8, source: []const u8, expected_output: []const u8) {
|
||||
const tc = self.create(name, source, expected_output);
|
||||
self.addCase(tc);
|
||||
}
|
||||
|
||||
pub fn addCase(self: &CompareOutputContext, case: &const TestCase) {
|
||||
const b = self.b;
|
||||
|
||||
const root_src = %%os.path.join(b.allocator, "test_artifacts", case.sources.items[0].filename);
|
||||
const exe_path = %%os.path.join(b.allocator, "test_artifacts", "test");
|
||||
|
||||
for ([]bool{false, true}) |release| {
|
||||
const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "{} ({})",
|
||||
case.name, if (release) "release" else "debug");
|
||||
if (const filter ?= self.test_filter) {
|
||||
if (mem.indexOf(u8, annotated_case_name, filter) == null)
|
||||
continue;
|
||||
}
|
||||
|
||||
const exe = b.addExecutable("test", root_src);
|
||||
exe.setOutputPath(exe_path);
|
||||
exe.setRelease(release);
|
||||
if (case.link_libc) {
|
||||
exe.linkLibrary("c");
|
||||
}
|
||||
|
||||
for (case.sources.toSliceConst()) |src_file| {
|
||||
const expanded_src_path = %%os.path.join(b.allocator, "test_artifacts", src_file.filename);
|
||||
const write_src = b.addWriteFile(expanded_src_path, src_file.source);
|
||||
exe.step.dependOn(&write_src.step);
|
||||
}
|
||||
|
||||
const run_and_cmp_output = RunCompareOutputStep.create(self, exe_path, annotated_case_name,
|
||||
case.expected_output);
|
||||
run_and_cmp_output.step.dependOn(&exe.step);
|
||||
|
||||
self.compare_output_tests.dependOn(&run_and_cmp_output.step);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const RunCompareOutputStep = struct {
|
||||
step: build.Step,
|
||||
context: &CompareOutputContext,
|
||||
exe_path: []const u8,
|
||||
name: []const u8,
|
||||
expected_output: []const u8,
|
||||
test_index: usize,
|
||||
|
||||
pub fn create(context: &CompareOutputContext, exe_path: []const u8,
|
||||
name: []const u8, expected_output: []const u8) -> &RunCompareOutputStep
|
||||
{
|
||||
const allocator = context.b.allocator;
|
||||
const ptr = %%allocator.create(RunCompareOutputStep);
|
||||
*ptr = RunCompareOutputStep {
|
||||
.context = context,
|
||||
.exe_path = exe_path,
|
||||
.name = name,
|
||||
.expected_output = expected_output,
|
||||
.test_index = context.test_index,
|
||||
.step = build.Step.init("RunCompareOutput", allocator, make),
|
||||
};
|
||||
context.test_index += 1;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
fn make(step: &build.Step) -> %void {
|
||||
const self = @fieldParentPtr(RunCompareOutputStep, "step", step);
|
||||
const b = self.context.b;
|
||||
|
||||
const full_exe_path = b.pathFromRoot(self.exe_path);
|
||||
|
||||
%%io.stderr.printf("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
|
||||
|
||||
var child = os.ChildProcess.spawn(full_exe_path, [][]u8{}, &b.env_map,
|
||||
StdIo.Ignore, StdIo.Pipe, StdIo.Pipe, b.allocator) %% |err|
|
||||
{
|
||||
debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
|
||||
};
|
||||
|
||||
const term = child.wait() %% |err| {
|
||||
debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
|
||||
};
|
||||
switch (term) {
|
||||
Term.Clean => |code| {
|
||||
if (code != 0) {
|
||||
%%io.stderr.printf("Process {} exited with error code {}\n", full_exe_path, code);
|
||||
return error.TestFailed;
|
||||
}
|
||||
},
|
||||
else => {
|
||||
%%io.stderr.printf("Process {} terminated unexpectedly\n", full_exe_path);
|
||||
return error.TestFailed;
|
||||
},
|
||||
};
|
||||
|
||||
var stdout = %%Buffer0.initEmpty(b.allocator);
|
||||
var stderr = %%Buffer0.initEmpty(b.allocator);
|
||||
|
||||
%%(??child.stdout).readAll(&stdout);
|
||||
%%(??child.stderr).readAll(&stderr);
|
||||
|
||||
if (!mem.eql(u8, self.expected_output, stdout.toSliceConst())) {
|
||||
%%io.stderr.printf(
|
||||
\\
|
||||
\\========= Expected this output: =========
|
||||
\\{}
|
||||
\\================================================
|
||||
\\{}
|
||||
\\
|
||||
, self.expected_output, stdout.toSliceConst());
|
||||
return error.TestFailed;
|
||||
}
|
||||
%%io.stderr.printf("OK\n");
|
||||
}
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue