update to zig 0.15.1

Author: leecannon

build.zig.zon

@@ -6,7 +6,7 @@
 
     .version = "0.3.0",
 
-    .minimum_zig_version = "0.15.0-dev.1149+4e6a04929",
+    .minimum_zig_version = "0.15.1",
 
     .paths = .{
         "build.zig",

src/Command.zig

@@ -192,9 +192,11 @@ pub fn testExecute(
 ) ExposedError!void {
     std.debug.assert(builtin.is_test);
 
+    const allocator = std.testing.allocator;
+
     const system: System = .{
         ._backend = System.TestBackend.create(
-            std.testing.allocator,
+            allocator,
             settings.system_description,
         ) catch |err| {
             std.debug.panic("unable to create system backend: {t}", .{err});
@@ -214,7 +216,7 @@ pub fn testExecute(
     };
 
     return command.execute(
-        std.testing.allocator,
+        allocator,
         io,
         &arg_iter,
         system,
@@ -240,69 +242,71 @@ pub fn testError(
     var settings_copy = settings;
     settings_copy.stderr = &stderr.writer;
 
-    try std.testing.expectError(error.AlreadyHandled, command.testExecute(
-        arguments,
-        settings_copy,
-    ));
+    try std.testing.expectError(
+        error.AlreadyHandled,
+        command.testExecute(arguments, settings_copy),
+    );
 
-    std.testing.expect(std.mem.indexOf(u8, stderr.getWritten(), expected_error) != null) catch |err| {
-        std.debug.print("\nEXPECTED: {s}\n\nACTUAL: {s}\n", .{ expected_error, stderr.getWritten() });
+    std.testing.expect(std.mem.indexOf(u8, stderr.written(), expected_error) != null) catch |err| {
+        std.debug.print("\nEXPECTED: {s}\n\nACTUAL: {s}\n", .{ expected_error, stderr.written() });
         return err;
     };
 }
 
 pub fn testHelp(command: Command, comptime include_shorthand: bool) !void {
     std.debug.assert(builtin.is_test);
 
+    const allocator = std.testing.allocator;
+
     const full_expected_help = blk: {
         var sb: std.ArrayListUnmanaged(u8) = .empty;
-        errdefer sb.deinit(std.testing.allocator);
+        errdefer sb.deinit(allocator);
 
         var iter: NameReplacementIterator = .{ .slice = command.short_help };
         while (iter.next()) |result| {
-            try sb.appendSlice(std.testing.allocator, result.slice);
+            try sb.appendSlice(allocator, result.slice);
             if (result.output_name) {
-                try sb.appendSlice(std.testing.allocator, command.name);
+                try sb.appendSlice(allocator, command.name);
             }
         }
 
         if (!std.mem.eql(u8, command.name, "template")) { // template has an extended help but it is empty
             if (command.extended_help) |extended_help| {
-                try sb.append(std.testing.allocator, '\n');
-                try sb.appendSlice(std.testing.allocator, extended_help);
+                try sb.append(allocator, '\n');
+                try sb.appendSlice(allocator, extended_help);
             }
         }
 
-        break :blk try sb.toOwnedSlice(std.testing.allocator);
+        break :blk try sb.toOwnedSlice(allocator);
     };
-    defer std.testing.allocator.free(full_expected_help);
+    defer allocator.free(full_expected_help);
 
-    var stdout: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    var stdout: std.Io.Writer.Allocating = .init(allocator);
     defer stdout.deinit();
 
     try command.testExecute(
         &.{"--help"},
         .{ .stdout = &stdout.writer },
     );
 
-    try std.testing.expectEqualStrings(full_expected_help, stdout.getWritten());
+    try std.testing.expectEqualStrings(full_expected_help, stdout.written());
 
     if (include_shorthand) {
         const short_expected_help = blk: {
             var sb: std.ArrayListUnmanaged(u8) = .empty;
-            errdefer sb.deinit(std.testing.allocator);
+            errdefer sb.deinit(allocator);
 
             var iter: NameReplacementIterator = .{ .slice = command.short_help };
             while (iter.next()) |result| {
-                try sb.appendSlice(std.testing.allocator, result.slice);
+                try sb.appendSlice(allocator, result.slice);
                 if (result.output_name) {
-                    try sb.appendSlice(std.testing.allocator, command.name);
+                    try sb.appendSlice(allocator, command.name);
                 }
             }
 
-            break :blk try sb.toOwnedSlice(std.testing.allocator);
+            break :blk try sb.toOwnedSlice(allocator);
         };
-        defer std.testing.allocator.free(short_expected_help);
+        defer allocator.free(short_expected_help);
 
         stdout.clearRetainingCapacity();
 
@@ -312,14 +316,16 @@ pub fn testHelp(command: Command, comptime include_shorthand: bool) !void {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings(short_expected_help, stdout.getWritten());
+        try std.testing.expectEqualStrings(short_expected_help, stdout.written());
     }
 }
 
 pub fn testVersion(command: Command) !void {
     std.debug.assert(builtin.is_test);
 
-    var stdout: std.Io.Writer.Allocating = .init(std.testing.allocator);
+    const allocator = std.testing.allocator;
+
+    var stdout: std.Io.Writer.Allocating = .init(allocator);
     defer stdout.deinit();
 
     try command.testExecute(
@@ -331,21 +337,21 @@ pub fn testVersion(command: Command) !void {
 
     const expected = blk: {
         var sb: std.ArrayListUnmanaged(u8) = .empty;
-        errdefer sb.deinit(std.testing.allocator);
+        errdefer sb.deinit(allocator);
 
         var iter: NameReplacementIterator = .{ .slice = shared.version_string };
         while (iter.next()) |result| {
-            try sb.appendSlice(std.testing.allocator, result.slice);
+            try sb.appendSlice(allocator, result.slice);
             if (result.output_name) {
-                try sb.appendSlice(std.testing.allocator, command.name);
+                try sb.appendSlice(allocator, command.name);
             }
         }
 
-        break :blk try sb.toOwnedSlice(std.testing.allocator);
+        break :blk try sb.toOwnedSlice(allocator);
     };
-    defer std.testing.allocator.free(expected);
+    defer allocator.free(expected);
 
-    try std.testing.expectEqualStrings(expected, stdout.getWritten());
+    try std.testing.expectEqualStrings(expected, stdout.written());
 }
 
 pub const TestFuzzOptions = struct {
@@ -368,24 +374,26 @@ pub fn testFuzz(command: Command, options: TestFuzzOptions) !void {
         options: TestFuzzOptions,
 
         fn testOne(context: @This(), input: []const u8) anyerror!void {
+            const allocator = std.testing.allocator;
+
             const arguments = blk: {
-                var arguments: std.ArrayList([]const u8) = .init(std.testing.allocator);
-                errdefer arguments.deinit();
+                var arguments: std.ArrayList([]const u8) = .empty;
+                errdefer arguments.deinit(allocator);
 
                 var iter = std.mem.splitScalar(u8, input, ' ');
 
                 while (iter.next()) |arg| {
-                    try arguments.append(arg);
+                    try arguments.append(allocator, arg);
                 }
 
-                break :blk try arguments.toOwnedSlice();
+                break :blk try arguments.toOwnedSlice(allocator);
             };
-            defer std.testing.allocator.free(arguments);
+            defer allocator.free(arguments);
 
-            var stdout: std.Io.Writer.Allocating = .init(std.testing.allocator);
+            var stdout: std.Io.Writer.Allocating = .init(allocator);
             defer stdout.deinit();
 
-            var stderr: std.Io.Writer.Allocating = .init(std.testing.allocator);
+            var stderr: std.Io.Writer.Allocating = .init(allocator);
             defer stderr.deinit();
 
             context.inner_command.testExecute(
@@ -401,15 +409,15 @@ pub fn testFuzz(command: Command, options: TestFuzzOptions) !void {
                         // this error is output by main and some output may or not have been written to stderr
                     },
                     error.AlreadyHandled => if (context.options.expect_stderr_output_on_failure) {
-                        try std.testing.expect(stderr.getWritten().len != 0);
+                        try std.testing.expect(stderr.written().len != 0);
                     },
                 }
                 return;
             };
 
-            try std.testing.expect(stderr.getWritten().len == 0);
+            try std.testing.expect(stderr.written().len == 0);
             if (context.options.expect_stdout_output_on_success) {
-                try std.testing.expect(stdout.getWritten().len != 0);
+                try std.testing.expect(stdout.written().len != 0);
             }
         }
     };

src/commands/basename.zig

@@ -317,7 +317,7 @@ const impl = struct {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings("world\n", stdout.getWritten());
+        try std.testing.expectEqualStrings("world\n", stdout.written());
     }
 
     test "basename multiple" {
@@ -339,7 +339,7 @@ const impl = struct {
             \\test
             \\d
             \\
-        , stdout.getWritten());
+        , stdout.written());
     }
 
     test "basename help" {

src/commands/clear.zig

@@ -150,7 +150,7 @@ const impl = struct {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings("\x1b[H\x1b[2J\x1b[3J", stdout.getWritten());
+        try std.testing.expectEqualStrings("\x1b[H\x1b[2J\x1b[3J", stdout.written());
     }
 
     test "clear - don't clear scrollback" {
@@ -162,7 +162,7 @@ const impl = struct {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings("\x1b[H\x1b[2J", stdout.getWritten());
+        try std.testing.expectEqualStrings("\x1b[H\x1b[2J", stdout.written());
     }
 
     test "clear help" {

src/commands/dirname.zig

@@ -191,7 +191,7 @@ const impl = struct {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings("hello\n", stdout.getWritten());
+        try std.testing.expectEqualStrings("hello\n", stdout.written());
     }
 
     test "dirname multiple" {
@@ -212,7 +212,7 @@ const impl = struct {
             \\this/is/a
             \\a/b/c
             \\
-        , stdout.getWritten());
+        , stdout.written());
     }
 
     test "dirname help" {

src/commands/false.zig

@@ -60,7 +60,7 @@ const impl = struct {
             ),
         );
 
-        try std.testing.expectEqualStrings("", stdout.getWritten());
+        try std.testing.expectEqualStrings("", stdout.written());
     }
 
     test "false help" {

src/commands/groups.zig

@@ -291,7 +291,7 @@ const impl = struct {
             },
         });
 
-        try std.testing.expectEqualStrings("sys user wheel\n", stdout.getWritten());
+        try std.testing.expectEqualStrings("sys user wheel\n", stdout.written());
     }
 };
 

src/commands/nproc.zig

@@ -127,7 +127,7 @@ const impl = struct {
             },
         });
 
-        try std.testing.expectEqualStrings("16\n", stdout.getWritten());
+        try std.testing.expectEqualStrings("16\n", stdout.written());
     }
 };
 

src/commands/true.zig

@@ -56,7 +56,7 @@ const impl = struct {
             .{ .stdout = &stdout.writer },
         );
 
-        try std.testing.expectEqualStrings("", stdout.getWritten());
+        try std.testing.expectEqualStrings("", stdout.written());
     }
 
     test "true help" {

src/commands/uname.zig

@@ -395,7 +395,7 @@ const impl = struct {
         else
             "sysname nodename release version machine sysname\n";
 
-        try std.testing.expectEqualStrings(expected, stdout.getWritten());
+        try std.testing.expectEqualStrings(expected, stdout.written());
     }
 };