migrated build and test

build.zig

@@ -24,7 +24,7 @@ comptime {
             \\
             \\Ziglings requires development build
             \\
-            \\{}
+            \\{s}
             \\
             \\or higher.
             \\
@@ -34,7 +34,7 @@ comptime {
             \\
             \\
         ;
-        @compileError(std.fmt.comptimePrint(error_message, .{min_zig}));
+        @compileError(std.fmt.comptimePrint(error_message, .{required_zig}));
     }
 }
 
@@ -123,10 +123,12 @@ pub const logo =
 const progress_filename = ".progress.txt";
 
 pub fn build(b: *Build) !void {
+    const io = b.graph.io;
+    // const io = std.Options.debug_io;
     if (!validate_exercises()) std.process.exit(2);
 
     use_color_escapes = false;
-    if (std.fs.File.stderr().supportsAnsiEscapeCodes()) {
+    if (try std.Io.File.stderr().supportsAnsiEscapeCodes(io)) {
         use_color_escapes = true;
     } else if (builtin.os.tag == .windows) {
         const w32 = struct {
@@ -245,9 +247,9 @@ pub fn build(b: *Build) !void {
     }
 
     if (reset) |_| {
-        std.fs.cwd().deleteFile(progress_filename) catch |err| {
+        std.Io.Dir.cwd().deleteFile(io, progress_filename) catch |err| {
             switch (err) {
-                std.fs.Dir.DeleteFileError.FileNotFound => {},
+                std.Io.Dir.DeleteFileError.FileNotFound => {},
                 else => {
                     print("Unable to remove progress file, Error: {}\n", .{err});
                     return err;
@@ -268,17 +270,20 @@ pub fn build(b: *Build) !void {
 
     var starting_exercise: u32 = 0;
 
-    if (std.fs.cwd().openFile(progress_filename, .{})) |progress_file| {
+    if (std.Io.Dir.cwd().openFile(io, progress_filename, .{})) |progress_file| {
-        defer progress_file.close();
+        defer progress_file.close(io);
 
-        const progress_file_size = try progress_file.getEndPos();
+        const progress_file_size = try progress_file.length(io);
 
         var gpa = std.heap.GeneralPurposeAllocator(.{}){};
         defer _ = gpa.deinit();
         const allocator = gpa.allocator();
         const contents = try allocator.alloc(u8, progress_file_size);
         defer allocator.free(contents);
-        const bytes_read = try progress_file.read(contents);
+        var file_buffer: [1024]u8 = undefined;
+        var file_reader = progress_file.reader(io, &file_buffer);
+        // try file_reader.interface.readSliceAll(contents);
+        const bytes_read = try file_reader.interface.readSliceShort(contents);
         if (bytes_read != progress_file_size) {
             return error.UnexpectedEOF;
         }
@@ -286,7 +291,7 @@ pub fn build(b: *Build) !void {
         starting_exercise = try std.fmt.parseInt(u32, contents, 10);
     } else |err| {
         switch (err) {
-            std.fs.File.OpenError.FileNotFound => {
+            std.Io.File.OpenError.FileNotFound => {
                 // This is fine, may be the first time tests are run or progress have been reset
             },
             else => {
@@ -382,15 +387,16 @@ const ZiglingStep = struct {
 
     fn run(self: *ZiglingStep, exe_path: []const u8, _: std.Progress.Node) !void {
         resetLine();
-        print("Checking: {s}\n", .{self.exercise.main_file});
-
         const b = self.step.owner;
+        const io = b.graph.io;
+
+        print("Checking: {s}\n", .{self.exercise.main_file});
 
         // Allow up to 1 MB of stdout capture.
         const max_output_bytes = 1 * 1024 * 1024;
 
-        const result = Child.run(.{
+        const result = Child.run(b.allocator, io, .{
-            .allocator = b.allocator,
+            // .allocator = b.allocator,
             .argv = &.{exe_path},
             .cwd = b.build_root.path.?,
             .cwd_dir = b.build_root.handle,
@@ -409,6 +415,7 @@ const ZiglingStep = struct {
 
     fn check_output(self: *ZiglingStep, result: Child.RunResult) !void {
         const b = self.step.owner;
+        const io = b.graph.io;
 
         // Make sure it exited cleanly.
         switch (result.term) {
@@ -456,14 +463,15 @@ const ZiglingStep = struct {
         const progress = try std.fmt.allocPrint(b.allocator, "{d}", .{self.exercise.number()});
         defer b.allocator.free(progress);
 
-        const file = try std.fs.cwd().createFile(
+        const file = try std.Io.Dir.cwd().createFile(
+            io,
             progress_filename,
             .{ .read = true, .truncate = true },
         );
-        defer file.close();
+        defer file.close(io);
 
-        try file.writeAll(progress);
+        try file.writeStreamingAll(io, progress);
-        try file.sync();
+        try file.sync(io);
 
         print("{s}PASSED:\n{s}{s}\n\n", .{ green_text, output, reset_text });
     }
@@ -558,6 +566,8 @@ const ZiglingStep = struct {
 
     fn printErrors(self: *ZiglingStep) void {
         resetLine();
+        const b = self.step.owner;
+        const io = b.graph.io;
 
         // Display error/warning messages.
         if (self.step.result_error_msgs.items.len > 0) {
@@ -575,7 +585,10 @@ const ZiglingStep = struct {
         else
             .off;
         if (self.step.result_error_bundle.errorMessageCount() > 0) {
-            self.step.result_error_bundle.renderToStdErr(.{}, color);
+            self.step.result_error_bundle.renderToStderr(io, .{}, color) catch |err| {
+                print("{}\n", .{err});
+                return;
+            };
         }
     }
 };

exercises/026_hello2.zig

@@ -15,8 +15,12 @@ const std = @import("std");
 // https://ziglang.org/documentation/master/#Inferred-Error-Sets
 //
 pub fn main() !void {
+    // We need an io instance for I/O operations;
+    // we'll learn how to create them later.
+    const io = std.Options.debug_io;
+
     // We get a Writer for Standard Out so we can print() to it.
-    var stdout = std.fs.File.stdout().writer(&.{});
+    var stdout = std.Io.File.stdout().writer(io, &.{});
 
     // Unlike std.debug.print(), the Standard Out writer can fail
     // with an error. We don't care _what_ the error is, we want

patches/patches/026_hello2.patch

@@ -1,6 +1,6 @@
---- exercises/026_hello2.zig	2025-07-22 09:55:51.337832401 +0200
+--- exercises/026_hello2.zig	2025-12-27 21:15:21.403899392 +0100
-+++ answers/026_hello2.zig	2025-07-22 10:00:11.233348058 +0200
++++ answers/026_hello2.zig	2025-12-27 20:28:53.267236800 +0100
-@@ -23,5 +23,5 @@
+@@ -27,5 +27,5 @@
      // to be able to pass it up as a return value of main().
      //
      // We just learned of a single statement which can accomplish this.

test/tests.zig

@@ -3,14 +3,13 @@ const root = @import("../build.zig");
 
 const debug = std.debug;
 const fmt = std.fmt;
-const fs = std.fs;
 const mem = std.mem;
 
 const Allocator = std.mem.Allocator;
 const Child = std.process.Child;
 const Build = std.Build;
 const LazyPath = std.Build.LazyPath;
-const Reader = fs.File.Reader;
+// const Reader = fs.File.Reader;
 const RunStep = std.Build.RunStep;
 const Step = Build.Step;
 
@@ -152,17 +151,19 @@ const CheckNamedStep = struct {
 
     fn make(step: *Step, _: Step.MakeOptions) !void {
         const b = step.owner;
+        const io = b.graph.io;
         const self: *CheckNamedStep = @alignCast(@fieldParentPtr("step", step));
         const ex = self.exercise;
 
-        const stderr_file = try fs.cwd().openFile(
+        const stderr_file = try std.Io.Dir.cwd().openFile(
+            io,
             self.stderr.getPath(b),
             .{ .mode = .read_only },
         );
-        defer stderr_file.close();
+        defer stderr_file.close(io);
 
-        var threaded: std.Io.Threaded = .init_single_threaded;
+        // var threaded: std.Io.Threaded = .init_single_threaded;
-        const io = threaded.io();
+        // const io = threaded.io();
         var stderr = stderr_file.readerStreaming(io, &.{});
         {
             // Skip the logo.
@@ -206,17 +207,19 @@ const CheckStep = struct {
 
     fn make(step: *Step, _: Step.MakeOptions) !void {
         const b = step.owner;
+        const io = b.graph.io;
         const self: *CheckStep = @alignCast(@fieldParentPtr("step", step));
         const exercises = self.exercises;
 
-        const stderr_file = try fs.cwd().openFile(
+        const stderr_file = try std.Io.Dir.cwd().openFile(
+            io,
             self.stderr.getPath(b),
             .{ .mode = .read_only },
         );
-        defer stderr_file.close();
+        defer stderr_file.close(io);
 
-        var threaded: std.Io.Threaded = .init_single_threaded;
+        // var threaded: std.Io.Threaded = .init_single_threaded;
-        const io = threaded.io();
+        // const io = threaded.io();
         var stderr = stderr_file.readerStreaming(io, &.{});
         for (exercises) |ex| {
             if (ex.number() == 1) {
@@ -234,7 +237,7 @@ const CheckStep = struct {
     }
 };
 
-fn check_output(step: *Step, exercise: Exercise, reader: *Reader) !void {
+fn check_output(step: *Step, exercise: Exercise, reader: *std.Io.File.Reader) !void {
     const b = step.owner;
 
     var buf: [1024]u8 = undefined;
@@ -301,7 +304,7 @@ fn check(
     }
 }
 
-fn readLine(reader: *fs.File.Reader, buf: []u8) !?[]const u8 {
+fn readLine(reader: *std.Io.File.Reader, buf: []u8) !?[]const u8 {
     try reader.interface.readSliceAll(buf);
     return mem.trimEnd(u8, buf, " \r\n");
 }
@@ -379,8 +382,9 @@ const HealStep = struct {
 
 /// Heals all the exercises.
 fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void {
-    const sep = std.fs.path.sep_str;
+    const io = std.Options.debug_io;
-    const join = fs.path.join;
+    const sep = std.Io.Dir.path.sep_str;
+    const join = std.Io.Dir.path.join;
 
     const exercises_path = "exercises";
     const patches_path = "patches" ++ sep ++ "patches";
@@ -398,19 +402,17 @@ fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8
         const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file };
 
         var child = Child.init(argv, allocator);
-        _ = try child.spawnAndWait();
+        _ = try child.spawnAndWait(io);
     }
 }
 
 /// 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 io = b.graph.io;
     const rand_int = std.crypto.random.int(u64);
-    const rand_hex64 = std.fmt.hex(rand_int);
+    const tmp_dir_sub_path = "tmp" ++ std.Io.Dir.path.sep_str ++ std.fmt.hex(rand_int);
-    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ rand_hex64;
+    const result_path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch @panic("OOM");
-    const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch
+    try b.cache_root.handle.createDirPath(io, tmp_dir_sub_path);
-        @panic("OOM");
+    return result_path;
-    try b.cache_root.handle.makePath(tmp_dir_sub_path);
-
-    return path;
 }