n
/
ziglings
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'main' of github.com:ratfactor/ziglings

Browse Source
pull/2/head
Dave Gauer 1 year ago
parent 8a3d722a33 7a44e4d342
commit f2b3e93402
5 changed files with 213 additions and 140 deletions
Show Stats Download Patch File Download Diff File

36
.github/workflows/ci.yml vendored
Unescape Escape View File

@ -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

202
build.zig
Unescape Escape View File

@ -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();

37
exercises/047_methods.zig
Unescape Escape View File

@ -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.
//

19
exercises/060_floats.zig
Unescape Escape View File

@ -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.

59
test/tests.zig
Unescape Escape View File

@ -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 };

Write Preview
Loading…
Cancel
Save