diff options
| -rw-r--r-- | build.zig | 9 | ||||
| -rw-r--r-- | exercises/001_hello.zig | 14 | ||||
| -rw-r--r-- | exercises/047_methods.zig | 37 | ||||
| -rw-r--r-- | exercises/060_floats.zig | 19 | ||||
| -rw-r--r-- | exercises/092_interfaces.zig | 2 | ||||
| -rw-r--r-- | exercises/101_for5.zig | 32 | ||||
| -rw-r--r-- | test/tests.zig | 156 |
7 files changed, 162 insertions, 107 deletions
@@ -122,11 +122,12 @@ pub fn build(b: *Build) !void { \\ ; - const use_healed = b.option(bool, "healed", "Run exercises from patches/healed") orelse false; + const healed = b.option(bool, "healed", "Run exercises from patches/healed") orelse false; + const override_healed_path = b.option([]const u8, "healed-path", "Override healed path"); const exno: ?usize = b.option(usize, "n", "Select exercise"); - const healed_path = "patches/healed"; - const work_path = if (use_healed) healed_path else "exercises"; + const healed_path = if (override_healed_path) |path| path else "patches/healed"; + const work_path = if (healed) healed_path else "exercises"; const header_step = PrintStep.create(b, logo); @@ -172,7 +173,7 @@ pub fn build(b: *Build) !void { start_step.dependOn(&prev_step.step); return; - } else if (use_healed and false) { + } else if (healed and false) { // Special case when healed by the eowyn script, where we can make the // code more efficient. // diff --git a/exercises/001_hello.zig b/exercises/001_hello.zig index d2093c7..9534b60 100644 --- a/exercises/001_hello.zig +++ b/exercises/001_hello.zig @@ -1,18 +1,18 @@ // -// Oh no! This program is supposed to print "Hello world!" but it needs -// your help! +// Oh no, this is supposed to print "Hello world!" but it needs +// your help. // +// Zig functions are private by default but the main() function +// should be public. // -// Zig functions are private by default but the main() function should -// be public. -// -// A function is declared public with the "pub" statement like so: +// A function is made public with the "pub" statement like so: // // pub fn foo() void { // ... // } // -// Try to fix the program and run `ziglings` to see if it works! +// Perhaps knowing this well help solve the errors we're getting +// with this little program? // const std = @import("std"); 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/exercises/092_interfaces.zig b/exercises/092_interfaces.zig index 5ac5768..8f0a937 100644 --- a/exercises/092_interfaces.zig +++ b/exercises/092_interfaces.zig @@ -40,7 +40,7 @@ // // switch (thing) { // .a => |a| special(a), -// inline else |t| => normal(t), +// inline else => |t| normal(t), // } // // We can have special handling of some cases and then Zig diff --git a/exercises/101_for5.zig b/exercises/101_for5.zig index 3861417..037989f 100644 --- a/exercises/101_for5.zig +++ b/exercises/101_for5.zig @@ -79,19 +79,19 @@ pub fn main() void { // all about: // // Let's say you've been tasked with grabbing three glass -// marbles, three spoons, and three feathers from a bucket. But -// you can't use your hands to grab them. Instead, you have a -// special marble scoop, spoon magnet, and feather tongs to grab +// marbles, three spoons, and three feathers from a magic bag. +// But you can't use your hands to grab them. Instead, you must +// use a marble scoop, spoon magnet, and feather tongs to grab // each type of object. // -// Now, would you rather have: +// Now, would you rather the magic bag: // -// A. The items layered so you have to pick up one marble, then -// one spoon, then one feather? +// A. Grouped the items in clusters so you have to pick up one +// marble, then one spoon, then one feather? // // OR // -// B. The items separated by type so you can pick up all of the +// B. Grouped the items by type so you can pick up all of the // marbles at once, then all the spoons, then all of the // feathers? // @@ -103,14 +103,16 @@ pub fn main() void { // efficient for modern CPUs. // // Decades of OOP practices have steered people towards grouping -// different data types together into "objects" with the hope -// that it would be friendlier to the human mind. But -// data-oriented design groups data in a way that is more -// efficient for the computer. -// -// In Zig terminology, the difference in groupings is sometimes -// known as "Array of Structs" (AoS) versus "Struct of Arrays" -// (SoA). +// different data types together into mixed-type "objects" with +// the intent that these are easier on the human mind. +// Data-oriented design groups data by type in a way that is +// easier on the computer. +// +// With clever language design, maybe we can have both. +// +// In the Zig community, you may see the difference in groupings +// presented with the terms "Array of Structs" (AoS) versus +// "Struct of Arrays" (SoA). // // To envision these two designs in action, imagine an array of // RPG character structs, each containing three different data diff --git a/test/tests.zig b/test/tests.zig index 752ca50..0fd3286 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -7,6 +7,7 @@ const fs = std.fs; const mem = std.mem; const Allocator = std.mem.Allocator; +const Child = std.process.Child; const Build = std.build; const FileSource = std.Build.FileSource; const Reader = fs.File.Reader; @@ -18,57 +19,73 @@ const Exercise = root.Exercise; pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { const step = b.step("test-cli", "Test the command line interface"); - // We should use a temporary path, but it will make the implementation of - // `build.zig` more complex. - const work_path = "patches/healed"; - - 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"); - var i: usize = 0; + const tmp_path = makeTempPath(b) catch |err| { + return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)}); + }; + + const heal_step = HealStep.create(b, exercises, tmp_path); + for (exercises[0 .. exercises.len - 1]) |ex| { - i += 1; + const n = ex.number(); if (ex.skip) continue; - const cmd = b.addSystemCommand( - &.{ b.zig_exe, "build", "-Dhealed", b.fmt("-Dn={}", .{i}), "test" }, - ); - cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{i})); + const cmd = b.addSystemCommand(&.{ + b.zig_exe, + "build", + "-Dhealed", + b.fmt("-Dhealed-path={s}", .{tmp_path}), + b.fmt("-Dn={}", .{n}), + "test", + }); + cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{n})); cmd.expectExitCode(0); - if (ex.check_stdout) - expectStdOutMatch(cmd, ex.output) - else + if (ex.check_stdout) { + expectStdOutMatch(cmd, ex.output); + cmd.expectStdErrEqual(""); + } else { expectStdErrMatch(cmd, ex.output); + cmd.expectStdOutEqual(""); + } cmd.step.dependOn(&heal_step.step); case_step.dependOn(&cmd.step); } - step.dependOn(case_step); + const cleanup = b.addRemoveDirTree(tmp_path); + cleanup.step.dependOn(case_step); + + step.dependOn(&cleanup.step); } { // Test that `zig build -Dhealed -Dn=n test` skips disabled esercises. const case_step = createCase(b, "case-2"); - var i: usize = 0; + const tmp_path = makeTempPath(b) catch |err| { + return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)}); + }; + + const heal_step = HealStep.create(b, exercises, tmp_path); + for (exercises[0 .. exercises.len - 1]) |ex| { - i += 1; + const n = ex.number(); if (!ex.skip) continue; - const cmd = b.addSystemCommand( - &.{ b.zig_exe, "build", "-Dhealed", b.fmt("-Dn={}", .{i}), "test" }, - ); - cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{i})); + const cmd = b.addSystemCommand(&.{ + b.zig_exe, + "build", + "-Dhealed", + b.fmt("-Dhealed-path={s}", .{tmp_path}), + b.fmt("-Dn={}", .{n}), + "test", + }); + cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{n})); cmd.expectExitCode(0); cmd.expectStdOutEqual(""); expectStdErrMatch(cmd, b.fmt("{s} skipped", .{ex.main_file})); @@ -78,15 +95,30 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { case_step.dependOn(&cmd.step); } - step.dependOn(case_step); + const cleanup = b.addRemoveDirTree(tmp_path); + cleanup.step.dependOn(case_step); + + step.dependOn(&cleanup.step); } { // Test that `zig build -Dhealed` process all the exercises in order. const case_step = createCase(b, "case-3"); + const tmp_path = makeTempPath(b) catch |err| { + return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)}); + }; + + const heal_step = HealStep.create(b, exercises, tmp_path); + heal_step.step.dependOn(case_step); + // TODO: when an exercise is modified, the cache is not invalidated. - const cmd = b.addSystemCommand(&.{ b.zig_exe, "build", "-Dhealed" }); + const cmd = b.addSystemCommand(&.{ + b.zig_exe, + "build", + "-Dhealed", + b.fmt("-Dhealed-path={s}", .{tmp_path}), + }); cmd.setName("zig build -Dhealed"); cmd.expectExitCode(0); cmd.step.dependOn(&heal_step.step); @@ -95,9 +127,10 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { const verify = CheckStep.create(b, exercises, stderr, true); verify.step.dependOn(&cmd.step); - case_step.dependOn(&verify.step); + const cleanup = b.addRemoveDirTree(tmp_path); + cleanup.step.dependOn(&verify.step); - step.dependOn(case_step); + step.dependOn(&cleanup.step); } { @@ -105,10 +138,22 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { // in order. const case_step = createCase(b, "case-4"); + const tmp_path = makeTempPath(b) catch |err| { + return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)}); + }; + + const heal_step = HealStep.create(b, exercises, tmp_path); + heal_step.step.dependOn(case_step); + // TODO: when an exercise is modified, the cache is not invalidated. - const cmd = b.addSystemCommand( - &.{ b.zig_exe, "build", "-Dhealed", "-Dn=1", "start" }, - ); + const cmd = b.addSystemCommand(&.{ + b.zig_exe, + "build", + "-Dhealed", + b.fmt("-Dhealed-path={s}", .{tmp_path}), + "-Dn=1", + "start", + }); cmd.setName("zig build -Dhealed -Dn=1 start"); cmd.expectExitCode(0); cmd.step.dependOn(&heal_step.step); @@ -117,9 +162,10 @@ pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step { const verify = CheckStep.create(b, exercises, stderr, false); verify.step.dependOn(&cmd.step); - case_step.dependOn(&verify.step); + const cleanup = b.addRemoveDirTree(tmp_path); + cleanup.step.dependOn(&verify.step); - step.dependOn(case_step); + step.dependOn(&cleanup.step); } { @@ -131,18 +177,11 @@ 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); + cmd.step.dependOn(case_step); - step.dependOn(case_step); + step.dependOn(&cmd.step); } - // 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; } @@ -157,7 +196,7 @@ fn createCase(b: *Build, name: []const u8) *Step { return case_step; } -// Check the output of `zig build` or `zig build -Dn=1 start`. +/// Checks the output of `zig build` or `zig build -Dn=1 start`. const CheckStep = struct { step: Step, exercises: []const Exercise, @@ -281,7 +320,7 @@ const CheckStep = struct { } }; -// A step that will fail. +/// Fails with a custom error message. const FailStep = struct { step: Step, error_msg: []const u8, @@ -310,9 +349,9 @@ const FailStep = struct { } }; -// A variant of `std.Build.Step.fail` that does not return an error so that it -// can be used in the configuration phase. It returns a FailStep, so that the -// error will be cleanly handled by the build runner. +/// A variant of `std.Build.Step.fail` that does not return an error so that it +/// can be used in the configuration phase. It returns a FailStep, so that the +/// error will be cleanly handled by the build runner. fn fail(step: *Step, comptime format: []const u8, args: anytype) *Step { const b = step.owner; @@ -322,7 +361,7 @@ fn fail(step: *Step, comptime format: []const u8, args: anytype) *Step { return step; } -// A step that heals exercises. +/// Heals the exercises. const HealStep = struct { step: Step, exercises: []const Exercise, @@ -352,7 +391,7 @@ const HealStep = struct { } }; -// Heals all the exercises. +/// Heals all the exercises. fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void { const join = fs.path.join; @@ -362,7 +401,6 @@ fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8 for (exercises) |ex| { const name = ex.name(); - // Use the POSIX patch variant. const file = try join(allocator, &.{ exercises_path, ex.main_file }); const patch = b: { const patch_name = try fmt.allocPrint(allocator, "{s}.patch", .{name}); @@ -372,11 +410,23 @@ fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8 const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file }; - var child = std.process.Child.init(argv, allocator); + var child = Child.init(argv, allocator); _ = try child.spawnAndWait(); } } +/// This function is the same as the one in std.Build.makeTempPath, with the +/// difference that returns an error when the temp path cannot be created. +pub fn makeTempPath(b: *Build) ![]const u8 { + const rand_int = std.crypto.random.int(u64); + const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ Build.hex64(rand_int); + const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch + @panic("OOM"); + try b.cache_root.handle.makePath(tmp_dir_sub_path); + + return path; +} + // // Missing functions from std.Build.RunStep // |