diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ab821c6..d071d8f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -27,21 +27,21 @@ jobs: - name: Check compatibility with old Zig compilers run: ci/compat.sh -# test: -# name: Unit Tests -# strategy: -# matrix: -# os: [ubuntu-latest, windows-latest, macos-latest] -# runs-on: ${{ matrix.os }} -# timeout-minutes: 30 -# steps: -# - name: Checkout -# uses: actions/checkout@v3 -# -# - name: Setup Zig -# uses: goto-bus-stop/setup-zig@v2 -# with: -# version: master -# -# - name: Run unit tests -# run: zig build test + test: + name: Unit Tests + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + runs-on: ${{ matrix.os }} + timeout-minutes: 30 + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Setup Zig + uses: goto-bus-stop/setup-zig@v2 + with: + version: master + + - name: Run unit tests + run: zig build test diff --git a/build.zig b/build.zig index 1b4855d..64968b9 100644 --- a/build.zig +++ b/build.zig @@ -210,9 +210,8 @@ pub fn build(b: *Build) !void { } ziglings_step.dependOn(prev_step); - // Disabled, see issue 272 - // const test_step = b.step("test", "Run all the tests"); - // // test_step.dependOn(tests.addCliTests(b, &exercises)); + const test_step = b.step("test", "Run all the tests"); + test_step.dependOn(tests.addCliTests(b, &exercises)); } var use_color_escapes = false; @@ -224,181 +223,199 @@ var reset_text: []const u8 = ""; const ZiglingStep = struct { step: Step, exercise: Exercise, - builder: *Build, work_path: []const u8, result_messages: []const u8 = "", result_error_bundle: std.zig.ErrorBundle = std.zig.ErrorBundle.empty, - pub fn create(builder: *Build, exercise: Exercise, work_path: []const u8) *@This() { - const self = builder.allocator.create(@This()) catch unreachable; + pub fn create(b: *Build, exercise: Exercise, work_path: []const u8) *ZiglingStep { + const self = b.allocator.create(ZiglingStep) catch @panic("OOM"); self.* = .{ - .step = Step.init(Step.Options{ .id = .custom, .name = exercise.main_file, .owner = builder, .makeFn = make }), + .step = Step.init(.{ + .id = .custom, + .name = exercise.main_file, + .owner = b, + .makeFn = make, + }), .exercise = exercise, - .builder = builder, .work_path = work_path, }; return self; } - fn make(step: *Step, prog_node: *std.Progress.Node) anyerror!void { - const self = @fieldParentPtr(@This(), "step", step); + fn make(step: *Step, prog_node: *std.Progress.Node) !void { + const self = @fieldParentPtr(ZiglingStep, "step", step); if (self.exercise.skip) { print("Skipping {s}\n\n", .{self.exercise.main_file}); return; } - self.makeInternal(prog_node) catch { + + const exe_path = self.compile(prog_node) catch { if (self.exercise.hint.len > 0) { - print("\n{s}HINT: {s}{s}", .{ bold_text, self.exercise.hint, reset_text }); + print("\n{s}HINT: {s}{s}", .{ + bold_text, self.exercise.hint, reset_text, + }); } - print("\n{s}Edit exercises/{s} and run this again.{s}", .{ red_text, self.exercise.main_file, reset_text }); - print("\n{s}To continue from this zigling, use this command:{s}\n {s}zig build -Dn={s}{s}\n", .{ red_text, reset_text, bold_text, self.exercise.key(), reset_text }); + self.help(); std.os.exit(1); }; - } - fn makeInternal(self: *@This(), prog_node: *std.Progress.Node) !void { - print("Compiling {s}...\n", .{self.exercise.main_file}); + self.run(exe_path, prog_node) catch { + if (self.exercise.hint.len > 0) { + print("\n{s}HINT: {s}{s}", .{ + bold_text, self.exercise.hint, reset_text, + }); + } - const exe_file = try self.doCompile(prog_node); + self.help(); + std.os.exit(1); + }; + } + fn run(self: *ZiglingStep, exe_path: []const u8, _: *std.Progress.Node) !void { resetLine(); print("Checking {s}...\n", .{self.exercise.main_file}); - const cwd = self.builder.build_root.path.?; - - const argv = [_][]const u8{exe_file}; - - var child = std.ChildProcess.init(&argv, self.builder.allocator); - - child.cwd = cwd; - child.env_map = self.builder.env_map; - - child.stdin_behavior = .Inherit; - if (self.exercise.check_stdout) { - child.stdout_behavior = .Pipe; - child.stderr_behavior = .Inherit; - } else { - child.stdout_behavior = .Inherit; - child.stderr_behavior = .Pipe; - } + const b = self.step.owner; - child.spawn() catch |err| { - print("{s}Unable to spawn {s}: {s}{s}\n", .{ red_text, argv[0], @errorName(err), reset_text }); + // Allow up to 1 MB of stdout capture. + const max_output_bytes = 1 * 1024 * 1024; + + var result = Child.exec(.{ + .allocator = b.allocator, + .argv = &.{exe_path}, + .cwd = b.build_root.path.?, + .cwd_dir = b.build_root.handle, + .max_output_bytes = max_output_bytes, + }) catch |err| { + print("{s}Unable to spawn {s}: {s}{s}\n", .{ + red_text, exe_path, @errorName(err), reset_text, + }); return err; }; - // Allow up to 1 MB of stdout capture. - const max_output_len = 1 * 1024 * 1024; - const output = if (self.exercise.check_stdout) - try child.stdout.?.reader().readAllAlloc(self.builder.allocator, max_output_len) + const raw_output = if (self.exercise.check_stdout) + result.stdout else - try child.stderr.?.reader().readAllAlloc(self.builder.allocator, max_output_len); - - // At this point stdout is closed, wait for the process to terminate. - const term = child.wait() catch |err| { - print("{s}Unable to spawn {s}: {s}{s}\n", .{ red_text, argv[0], @errorName(err), reset_text }); - return err; - }; + result.stderr; // Make sure it exited cleanly. - switch (term) { + switch (result.term) { .Exited => |code| { if (code != 0) { - print("{s}{s} exited with error code {d} (expected {d}){s}\n", .{ red_text, self.exercise.main_file, code, 0, reset_text }); + print("{s}{s} exited with error code {d} (expected {d}){s}\n", .{ + red_text, self.exercise.main_file, code, 0, reset_text, + }); return error.BadExitCode; } }, else => { - print("{s}{s} terminated unexpectedly{s}\n", .{ red_text, self.exercise.main_file, reset_text }); + print("{s}{s} terminated unexpectedly{s}\n", .{ + red_text, self.exercise.main_file, reset_text, + }); return error.UnexpectedTermination; }, } // Validate the output. - const trimOutput = std.mem.trimRight(u8, output, " \r\n"); - const trimExerciseOutput = std.mem.trimRight(u8, self.exercise.output, " \r\n"); - if (!std.mem.eql(u8, trimOutput, trimExerciseOutput)) { + const output = std.mem.trimRight(u8, raw_output, " \r\n"); + const exercise_output = std.mem.trimRight(u8, self.exercise.output, " \r\n"); + if (!std.mem.eql(u8, output, exercise_output)) { + const red = red_text; + const reset = reset_text; + print( \\ - \\{s}----------- Expected this output -----------{s} - \\"{s}" - \\{s}----------- but found -----------{s} - \\"{s}" - \\{s}-----------{s} + \\{s}========= expected this output: =========={s} + \\{s} + \\{s}========= but found: ====================={s} + \\{s} + \\{s}=========================================={s} \\ - , .{ red_text, reset_text, trimExerciseOutput, red_text, reset_text, trimOutput, red_text, reset_text }); + , .{ red, reset, exercise_output, red, reset, output, red, reset }); return error.InvalidOutput; } - print("{s}PASSED:\n{s}{s}\n\n", .{ green_text, trimOutput, reset_text }); + print("{s}PASSED:\n{s}{s}\n\n", .{ green_text, output, reset_text }); } - // The normal compile step calls os.exit, so we can't use it as a library :( - // This is a stripped down copy of std.build.LibExeObjStep.make. - fn doCompile(self: *@This(), prog_node: *std.Progress.Node) ![]const u8 { - const builder = self.builder; + fn compile(self: *ZiglingStep, prog_node: *std.Progress.Node) ![]const u8 { + print("Compiling {s}...\n", .{self.exercise.main_file}); - var zig_args = std.ArrayList([]const u8).init(builder.allocator); + const b = self.step.owner; + const exercise_path = self.exercise.main_file; + const path = join(b.allocator, &.{ self.work_path, exercise_path }) catch + @panic("OOM"); + + var zig_args = std.ArrayList([]const u8).init(b.allocator); defer zig_args.deinit(); - zig_args.append(builder.zig_exe) catch unreachable; - zig_args.append("build-exe") catch unreachable; + zig_args.append(b.zig_exe) catch @panic("OOM"); + zig_args.append("build-exe") catch @panic("OOM"); - // Enable C support for exercises that use C functions + // Enable C support for exercises that use C functions. if (self.exercise.link_libc) { - zig_args.append("-lc") catch unreachable; + zig_args.append("-lc") catch @panic("OOM"); } - const zig_file = join(builder.allocator, &.{ self.work_path, self.exercise.main_file }) catch unreachable; - zig_args.append(builder.pathFromRoot(zig_file)) catch unreachable; + zig_args.append(b.pathFromRoot(path)) catch @panic("OOM"); - zig_args.append("--cache-dir") catch unreachable; - zig_args.append(builder.pathFromRoot(builder.cache_root.path.?)) catch unreachable; + zig_args.append("--cache-dir") catch @panic("OOM"); + zig_args.append(b.pathFromRoot(b.cache_root.path.?)) catch @panic("OOM"); - zig_args.append("--listen=-") catch unreachable; + zig_args.append("--listen=-") catch @panic("OOM"); const argv = zig_args.items; var code: u8 = undefined; - const file_name = self.eval(argv, &code, prog_node) catch |err| { + const exe_path = self.eval(argv, &code, prog_node) catch |err| { self.printErrors(); switch (err) { error.FileNotFound => { - print("{s}{s}: Unable to spawn the following command: file not found{s}\n", .{ red_text, self.exercise.main_file, reset_text }); + print("{s}{s}: Unable to spawn the following command: file not found{s}\n", .{ + red_text, self.exercise.main_file, reset_text, + }); for (argv) |v| print("{s} ", .{v}); print("\n", .{}); }, error.ExitCodeFailure => { - print("{s}{s}: The following command exited with error code {}:{s}\n", .{ red_text, self.exercise.main_file, code, reset_text }); + print("{s}{s}: The following command exited with error code {}:{s}\n", .{ + red_text, self.exercise.main_file, code, reset_text, + }); for (argv) |v| print("{s} ", .{v}); print("\n", .{}); }, error.ProcessTerminated => { - print("{s}{s}: The following command terminated unexpectedly:{s}\n", .{ red_text, self.exercise.main_file, reset_text }); + print("{s}{s}: The following command terminated unexpectedly:{s}\n", .{ + red_text, self.exercise.main_file, reset_text, + }); for (argv) |v| print("{s} ", .{v}); print("\n", .{}); }, error.ZigIPCError => { print("{s}{s}: The following command failed to communicate the compilation result:{s}\n", .{ - red_text, - self.exercise.main_file, - reset_text, + red_text, self.exercise.main_file, reset_text, + }); + for (argv) |v| print("{s} ", .{v}); + print("\n", .{}); + }, + else => { + print("{s}{s}: Unexpected error: {s}{s}\n", .{ + red_text, self.exercise.main_file, @errorName(err), reset_text, }); for (argv) |v| print("{s} ", .{v}); print("\n", .{}); }, - else => {}, } return err; }; self.printErrors(); - return file_name; + return exe_path; } // Code adapted from `std.Build.execAllowFail and `std.Build.Step.evalZigProcess`. @@ -501,6 +518,23 @@ const ZiglingStep = struct { return result orelse return error.ZigIPCError; } + fn help(self: *ZiglingStep) void { + const path = self.exercise.main_file; + const key = self.exercise.key(); + + print("\n{s}Edit exercises/{s} and run this again.{s}", .{ + red_text, path, reset_text, + }); + + const format = + \\ + \\{s}To continue from this zigling, use this command:{s} + \\ {s}zig build -Dn={s}{s} + \\ + ; + print(format, .{ red_text, reset_text, bold_text, key, reset_text }); + } + fn printErrors(self: *ZiglingStep) void { resetLine(); diff --git a/exercises/047_methods.zig b/exercises/047_methods.zig index 96d4c8e..6b2dbef 100644 --- a/exercises/047_methods.zig +++ b/exercises/047_methods.zig @@ -2,9 +2,9 @@ // Help! Evil alien creatures have hidden eggs all over the Earth // and they're starting to hatch! // -// Before you jump into battle, you'll need to know four things: +// Before you jump into battle, you'll need to know three things: // -// 1. You can attach functions to structs: +// 1. You can attach functions to structs (and other "type definitions"): // // const Foo = struct{ // pub fn hello() void { @@ -12,31 +12,30 @@ // } // }; // -// 2. A function that is a member of a struct is a "method" and is -// called with the "dot syntax" like so: +// 2. A function that is a member of a struct is "namespaced" within +// that struct and is called by specifying the "namespace" and then +// using the "dot syntax": // // Foo.hello(); // -// 3. The NEAT feature of methods is the special parameter named -// "self" that takes an instance of that type of struct: +// 3. The NEAT feature of these functions is that if their first argument +// is an instance of the struct (or a pointer to one) then we can use +// the instance as the namespace instead of the type: // // const Bar = struct{ -// number: u32, -// -// pub fn printMe(self: Bar) void { -// std.debug.print("{}\n", .{self.number}); -// } +// pub fn a(self: Bar) void {} +// pub fn b(this: *Bar, other: u8) void {} +// pub fn c(bar: *const Bar) void {} // }; // -// (Actually, you can name the first parameter anything, but -// please follow convention and use "self".) -// -// 4. Now when you call the method on an INSTANCE of that struct -// with the "dot syntax", the instance will be automatically -// passed as the "self" parameter: +// var bar = Bar{}; +// bar.a() // is equivalent to Bar.a(bar) +// bar.b(3) // is equivalent to Bar.b(&bar, 3) +// bar.c() // is equivalent to Bar.c(&bar) // -// var my_bar = Bar{ .number = 2000 }; -// my_bar.printMe(); // prints "2000" +// Notice that the name of the parameter doesn't matter. Some use +// self, others use a lowercase version of the type name, but feel +// free to use whatever is most appropriate. // // Okay, you're armed. // diff --git a/exercises/060_floats.zig b/exercises/060_floats.zig index 8ba51db..1320171 100644 --- a/exercises/060_floats.zig +++ b/exercises/060_floats.zig @@ -1,10 +1,11 @@ // // Zig has support for IEEE-754 floating-point numbers in these // specific sizes: f16, f32, f64, f80, and f128. Floating point -// literals may be written in scientific notation: +// literals may be written in the same ways as integers but also +// in scientific notation: // -// const a1: f32 = 1200.0; // 1,200 -// const a2: f32 = 1.2e+3; // 1,200 +// const a1: f32 = 1200; // 1,200 +// const a2: f32 = 1.2e+3; // 1,200 // const b1: f32 = -500_000.0; // -500,000 // const b2: f32 = -5.0e+5; // -500,000 // @@ -22,12 +23,14 @@ // const pi: f16 = 3.1415926535; // rounds to 3.140625 // const av: f16 = 6.02214076e+23; // Avogadro's inf(inity)! // -// A float literal has a decimal point. When performing math -// operations with numeric literals, ensure the types match. Zig -// does not perform unsafe type coercions behind your back: +// When performing math operations with numeric literals, ensure +// the types match. Zig does not perform unsafe type coercions +// behind your back: // -// var foo: f16 = 13.5 * 5; // ERROR! -// var foo: f16 = 13.5 * 5.0; // No problem, both are floats +// var foo: f16 = 5; // NO ERROR +// +// var foo: u16 = 5; // A literal of a different type +// var bar: f16 = foo; // ERROR // // Please fix the two float problems with this program and // display the result as a whole number. diff --git a/test/tests.zig b/test/tests.zig index 8786d91..752ca50 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -20,15 +20,14 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { // We should use a temporary path, but it will make the implementation of // `build.zig` more complex. - const outdir = "patches/healed"; + const work_path = "patches/healed"; - fs.cwd().makePath(outdir) catch |err| { - return fail(step, "unable to make '{s}': {s}\n", .{ outdir, @errorName(err) }); - }; - heal(b.allocator, exercises, outdir) catch |err| { - return fail(step, "unable to heal exercises: {s}\n", .{@errorName(err)}); + fs.cwd().makePath(work_path) catch |err| { + return fail(step, "unable to make '{s}': {s}\n", .{ work_path, @errorName(err) }); }; + const heal_step = HealStep.create(b, exercises, work_path); + { // Test that `zig build -Dhealed -Dn=n test` selects the nth exercise. const case_step = createCase(b, "case-1"); @@ -49,6 +48,8 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { else expectStdErrMatch(cmd, ex.output); + cmd.step.dependOn(&heal_step.step); + case_step.dependOn(&cmd.step); } @@ -72,6 +73,8 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { cmd.expectStdOutEqual(""); expectStdErrMatch(cmd, b.fmt("{s} skipped", .{ex.main_file})); + cmd.step.dependOn(&heal_step.step); + case_step.dependOn(&cmd.step); } @@ -86,6 +89,7 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { const cmd = b.addSystemCommand(&.{ b.zig_exe, "build", "-Dhealed" }); cmd.setName("zig build -Dhealed"); cmd.expectExitCode(0); + cmd.step.dependOn(&heal_step.step); const stderr = cmd.captureStdErr(); const verify = CheckStep.create(b, exercises, stderr, true); @@ -107,6 +111,7 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { ); cmd.setName("zig build -Dhealed -Dn=1 start"); cmd.expectExitCode(0); + cmd.step.dependOn(&heal_step.step); const stderr = cmd.captureStdErr(); const verify = CheckStep.create(b, exercises, stderr, false); @@ -126,14 +131,16 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { cmd.expectExitCode(1); expectStdErrMatch(cmd, exercises[0].hint); + cmd.step.dependOn(&heal_step.step); + case_step.dependOn(&cmd.step); step.dependOn(case_step); } - // Don't add the cleanup step, since it may delete outdir while a test case - // is running. - //const cleanup = b.addRemoveDirTree(outdir); + // Don't add the cleanup step, since it may delete work_path while a test + // case is running. + //const cleanup = b.addRemoveDirTree(work_path); //step.dependOn(&cleanup.step); return step; @@ -315,8 +322,38 @@ fn fail(step: *Step, comptime format: []const u8, args: anytype) *Step { return step; } +// A step that heals exercises. +const HealStep = struct { + step: Step, + exercises: []const Exercise, + work_path: []const u8, + + pub fn create(owner: *Build, exercises: []const Exercise, work_path: []const u8) *HealStep { + const self = owner.allocator.create(HealStep) catch @panic("OOM"); + self.* = .{ + .step = Step.init(.{ + .id = .custom, + .name = "heal", + .owner = owner, + .makeFn = make, + }), + .exercises = exercises, + .work_path = work_path, + }; + + return self; + } + + fn make(step: *Step, _: *std.Progress.Node) !void { + const b = step.owner; + const self = @fieldParentPtr(HealStep, "step", step); + + return heal(b.allocator, self.exercises, self.work_path); + } +}; + // Heals all the exercises. -fn heal(allocator: Allocator, exercises: []const Exercise, outdir: []const u8) !void { +fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void { const join = fs.path.join; const exercises_path = "exercises"; @@ -331,7 +368,7 @@ fn heal(allocator: Allocator, exercises: []const Exercise, outdir: []const u8) ! const patch_name = try fmt.allocPrint(allocator, "{s}.patch", .{name}); break :b try join(allocator, &.{ patches_path, patch_name }); }; - const output = try join(allocator, &.{ outdir, ex.main_file }); + const output = try join(allocator, &.{ work_path, ex.main_file }); const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file };