update usage of std.testing in stage2

3 files changed, 29 insertions, 29 deletions

diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index ef0fc6c3e2..d0dd47be92 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -182,7 +182,7 @@ test "CodeSignature header" {
     try code_sig.writeHeader(stream.writer());
 
     const expected = &[_]u8{ 0xfa, 0xde, 0x0c, 0xc0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0 };
-    testing.expect(mem.eql(u8, expected, &buffer));
+    try testing.expect(mem.eql(u8, expected, &buffer));
 }
 
 pub fn calcCodeSignaturePaddingSize(id: []const u8, file_size: u64, page_size: u16) u32 {
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index f7d54cf578..379b10e2d8 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -404,15 +404,15 @@ test "Trie node count" {
     var trie = Trie.init(gpa);
     defer trie.deinit();
 
-    testing.expectEqual(trie.node_count, 0);
-    testing.expect(trie.root == null);
+    try testing.expectEqual(trie.node_count, 0);
+    try testing.expect(trie.root == null);
 
     try trie.put(.{
         .name = "_main",
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
-    testing.expectEqual(trie.node_count, 2);
+    try testing.expectEqual(trie.node_count, 2);
 
     // Inserting the same node shouldn't update the trie.
     try trie.put(.{
@@ -420,14 +420,14 @@ test "Trie node count" {
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
-    testing.expectEqual(trie.node_count, 2);
+    try testing.expectEqual(trie.node_count, 2);
 
     try trie.put(.{
         .name = "__mh_execute_header",
         .vmaddr_offset = 0x1000,
         .export_flags = 0,
     });
-    testing.expectEqual(trie.node_count, 4);
+    try testing.expectEqual(trie.node_count, 4);
 
     // Inserting the same node shouldn't update the trie.
     try trie.put(.{
@@ -435,13 +435,13 @@ test "Trie node count" {
         .vmaddr_offset = 0x1000,
         .export_flags = 0,
     });
-    testing.expectEqual(trie.node_count, 4);
+    try testing.expectEqual(trie.node_count, 4);
     try trie.put(.{
         .name = "_main",
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
-    testing.expectEqual(trie.node_count, 4);
+    try testing.expectEqual(trie.node_count, 4);
 }
 
 test "Trie basic" {
@@ -455,8 +455,8 @@ test "Trie basic" {
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
-    testing.expect(trie.root.?.edges.items.len == 1);
-    testing.expect(mem.eql(u8, trie.root.?.edges.items[0].label, "_st"));
+    try testing.expect(trie.root.?.edges.items.len == 1);
+    try testing.expect(mem.eql(u8, trie.root.?.edges.items[0].label, "_st"));
 
     {
         // root --- _st ---> node --- art ---> node
@@ -465,12 +465,12 @@ test "Trie basic" {
             .vmaddr_offset = 0,
             .export_flags = 0,
         });
-        testing.expect(trie.root.?.edges.items.len == 1);
+        try testing.expect(trie.root.?.edges.items.len == 1);
 
         const nextEdge = &trie.root.?.edges.items[0];
-        testing.expect(mem.eql(u8, nextEdge.label, "_st"));
-        testing.expect(nextEdge.to.edges.items.len == 1);
-        testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "art"));
+        try testing.expect(mem.eql(u8, nextEdge.label, "_st"));
+        try testing.expect(nextEdge.to.edges.items.len == 1);
+        try testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "art"));
     }
     {
         // root --- _ ---> node --- st ---> node --- art ---> node
@@ -481,16 +481,16 @@ test "Trie basic" {
             .vmaddr_offset = 0,
             .export_flags = 0,
         });
-        testing.expect(trie.root.?.edges.items.len == 1);
+        try testing.expect(trie.root.?.edges.items.len == 1);
 
         const nextEdge = &trie.root.?.edges.items[0];
-        testing.expect(mem.eql(u8, nextEdge.label, "_"));
-        testing.expect(nextEdge.to.edges.items.len == 2);
-        testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "st"));
-        testing.expect(mem.eql(u8, nextEdge.to.edges.items[1].label, "main"));
+        try testing.expect(mem.eql(u8, nextEdge.label, "_"));
+        try testing.expect(nextEdge.to.edges.items.len == 2);
+        try testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "st"));
+        try testing.expect(mem.eql(u8, nextEdge.to.edges.items[1].label, "main"));
 
         const nextNextEdge = &nextEdge.to.edges.items[0];
-        testing.expect(mem.eql(u8, nextNextEdge.to.edges.items[0].label, "art"));
+        try testing.expect(mem.eql(u8, nextNextEdge.to.edges.items[0].label, "art"));
     }
 }
 
@@ -529,15 +529,15 @@ test "write Trie to a byte stream" {
     var stream = std.io.fixedBufferStream(buffer);
     {
         const nwritten = try trie.write(stream.writer());
-        testing.expect(nwritten == trie.size);
-        testing.expect(mem.eql(u8, buffer, &exp_buffer));
+        try testing.expect(nwritten == trie.size);
+        try testing.expect(mem.eql(u8, buffer, &exp_buffer));
     }
     {
         // Writing finalized trie again should yield the same result.
         try stream.seekTo(0);
         const nwritten = try trie.write(stream.writer());
-        testing.expect(nwritten == trie.size);
-        testing.expect(mem.eql(u8, buffer, &exp_buffer));
+        try testing.expect(nwritten == trie.size);
+        try testing.expect(mem.eql(u8, buffer, &exp_buffer));
     }
 }
 
@@ -560,7 +560,7 @@ test "parse Trie from byte stream" {
     defer trie.deinit();
     const nread = try trie.read(in_stream.reader());
 
-    testing.expect(nread == in_buffer.len);
+    try testing.expect(nread == in_buffer.len);
 
     try trie.finalize();
 
@@ -569,6 +569,6 @@ test "parse Trie from byte stream" {
     var out_stream = std.io.fixedBufferStream(out_buffer);
     const nwritten = try trie.write(out_stream.writer());
 
-    testing.expect(nwritten == trie.size);
-    testing.expect(mem.eql(u8, &in_buffer, out_buffer));
+    try testing.expect(nwritten == trie.size);
+    try testing.expect(mem.eql(u8, &in_buffer, out_buffer));
 }
diff --git a/src/link/MachO/commands.zig b/src/link/MachO/commands.zig
index 67b808d856..f81e5c757d 100644
--- a/src/link/MachO/commands.zig
+++ b/src/link/MachO/commands.zig
@@ -286,13 +286,13 @@ fn testRead(allocator: *Allocator, buffer: []const u8, expected: anytype) !void
     var stream = io.fixedBufferStream(buffer);
     var given = try LoadCommand.read(allocator, stream.reader());
     defer given.deinit(allocator);
-    testing.expect(expected.eql(given));
+    try testing.expect(expected.eql(given));
 }
 
 fn testWrite(buffer: []u8, cmd: LoadCommand, expected: []const u8) !void {
     var stream = io.fixedBufferStream(buffer);
     try cmd.write(stream.writer());
-    testing.expect(mem.eql(u8, expected, buffer[0..expected.len]));
+    try testing.expect(mem.eql(u8, expected, buffer[0..expected.len]));
 }
 
 test "read-write segment command" {