Commit 0a38f61d58

@@ -8,5 +8,5 @@ fn getA() A {
 
 test "bug 1025" {
     const a = getA();
-    @import("std").testing.expect(a.B == u8);
+    try @import("std").testing.expect(a.B == u8);
 }

@@ -3,21 +3,21 @@ const mem = std.mem;
 const expect = std.testing.expect;
 
 test "comptime code should not modify constant data" {
-    testCastPtrOfArrayToSliceAndPtr();
-    comptime testCastPtrOfArrayToSliceAndPtr();
+    try testCastPtrOfArrayToSliceAndPtr();
+    comptime try testCastPtrOfArrayToSliceAndPtr();
 }
 
-fn testCastPtrOfArrayToSliceAndPtr() void {
+fn testCastPtrOfArrayToSliceAndPtr() !void {
     {
         var array = "aoeu".*;
         const x: [*]u8 = &array;
         x[0] += 1;
-        expect(mem.eql(u8, array[0..], "boeu"));
+        try expect(mem.eql(u8, array[0..], "boeu"));
     }
     {
         var array: [4]u8 = "aoeu".*;
         const x: [*]u8 = &array;
         x[0] += 1;
-        expect(mem.eql(u8, array[0..], "boeu"));
+        try expect(mem.eql(u8, array[0..], "boeu"));
     }
 }

@@ -19,5 +19,5 @@ test "bug 1120" {
         1 => &b.a,
         else => unreachable,
     };
-    expect(ptr.* == 2);
+    try expect(ptr.* == 2);
 }

@@ -11,5 +11,5 @@ fn f() i32 {
 }
 
 test "don't emit an LLVM global for a const function when it's in an optional in a struct" {
-    std.testing.expect(s.f.?() == 1234);
+    try std.testing.expect(s.f.?() == 1234);
 }

@@ -20,5 +20,5 @@ fn agent_callback(_vm: [*]VM, options: [*]u8) callconv(.C) i32 {
 }
 
 test "fixed" {
-    expect(agent_callback(undefined, undefined) == 11);
+    try expect(agent_callback(undefined, undefined) == 11);
 }

@@ -13,7 +13,7 @@ const C = struct {};
 
 test "tagged union with all void fields but a meaningful tag" {
     var a: A = A{ .b = B{ .c = C{} } };
-    std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).c);
+    try std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).c);
     a = A{ .b = B.None };
-    std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).None);
+    try std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).None);
 }

@@ -17,5 +17,5 @@ test "union that needs padding bytes inside an array" {
     };
 
     const a = as[0].B;
-    std.testing.expect(a.D == 1);
+    try std.testing.expect(a.D == 1);
 }

@@ -10,5 +10,5 @@ const S = struct {
 
 test "functions with return type required to be comptime are generic" {
     const ti = S.method();
-    expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct);
+    try expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct);
 }

@@ -7,5 +7,5 @@ const Union = union(enum) {
 
 test "const error union field alignment" {
     var union_or_err: anyerror!Union = Union{ .Color = 1234 };
-    std.testing.expect((union_or_err catch unreachable).Color == 1234);
+    try std.testing.expect((union_or_err catch unreachable).Color == 1234);
 }

@@ -5,6 +5,6 @@ var global: u64 = 123;
 
 test "constant pointer to global variable causes runtime load" {
     global = 1234;
-    expect(&global == ptr);
-    expect(ptr.* == 1234);
+    try expect(&global == ptr);
+    try expect(ptr.* == 1234);
 }

@@ -3,13 +3,13 @@ const testing = std.testing;
 
 const a = [_]u8{ 1, 2, 3 };
 
-fn checkAddress(s: []const u8) void {
+fn checkAddress(s: []const u8) !void {
     for (s) |*i, j| {
-        testing.expect(i == &a[j]);
+        try testing.expect(i == &a[j]);
     }
 }
 
 test "slices pointing at the same address as global array." {
-    checkAddress(&a);
-    comptime checkAddress(&a);
+    try checkAddress(&a);
+    comptime try checkAddress(&a);
 }

@@ -42,5 +42,5 @@ const a = struct {
 
 test "intialization" {
     var t = a.init();
-    std.testing.expect(t.foo.len == 0);
+    try std.testing.expect(t.foo.len == 0);
 }

@@ -2,5 +2,5 @@ const std = @import("std");
 
 test "fixed" {
     const x: f32 align(128) = 12.34;
-    std.testing.expect(@ptrToInt(&x) % 128 == 0);
+    try std.testing.expect(@ptrToInt(&x) % 128 == 0);
 }

@@ -2,25 +2,25 @@ const std = @import("std");
 const expect = std.testing.expect;
 
 test "allocation and looping over 3-byte integer" {
-    expect(@sizeOf(u24) == 4);
-    expect(@sizeOf([1]u24) == 4);
-    expect(@alignOf(u24) == 4);
-    expect(@alignOf([1]u24) == 4);
+    try expect(@sizeOf(u24) == 4);
+    try expect(@sizeOf([1]u24) == 4);
+    try expect(@alignOf(u24) == 4);
+    try expect(@alignOf([1]u24) == 4);
 
     var x = try std.testing.allocator.alloc(u24, 2);
     defer std.testing.allocator.free(x);
-    expect(x.len == 2);
+    try expect(x.len == 2);
     x[0] = 0xFFFFFF;
     x[1] = 0xFFFFFF;
 
     const bytes = std.mem.sliceAsBytes(x);
-    expect(@TypeOf(bytes) == []align(4) u8);
-    expect(bytes.len == 8);
+    try expect(@TypeOf(bytes) == []align(4) u8);
+    try expect(bytes.len == 8);
 
     for (bytes) |*b| {
         b.* = 0x00;
     }
 
-    expect(x[0] == 0x00);
-    expect(x[1] == 0x00);
+    try expect(x[0] == 0x00);
+    try expect(x[1] == 0x00);
 }

@@ -7,6 +7,6 @@ const S = struct {
 test "bug 2006" {
     var a: S = undefined;
     a = S{ .p = undefined };
-    expect(@sizeOf(S) != 0);
-    expect(@sizeOf(*void) == 0);
+    try expect(@sizeOf(S) != 0);
+    try expect(@sizeOf(*void) == 0);
 }

@@ -7,13 +7,13 @@ fn ctz(x: anytype) usize {
 }
 
 test "fixed" {
-    testClz();
-    comptime testClz();
+    try testClz();
+    comptime try testClz();
 }
 
-fn testClz() void {
-    expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126);
-    expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));
-    expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127);
-    expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);
+fn testClz() !void {
+    try expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126);
+    try expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));
+    try expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127);
+    try expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);
 }

@@ -27,5 +27,5 @@ fn parseNote() ?i32 {
 
 test "fixed" {
     const result = parseNote();
-    std.testing.expect(result.? == 9);
+    try std.testing.expect(result.? == 9);
 }

@@ -19,5 +19,5 @@ fn get_foo() Foo.FooError!*Foo {
 
 test "fixed" {
     default_foo = get_foo() catch null; // This Line
-    std.testing.expect(!default_foo.?.free);
+    try std.testing.expect(!default_foo.?.free);
 }

@@ -15,5 +15,5 @@ test "fixed" {
     some_struct = SomeStruct{
         .field = couldFail() catch |_| @as(i32, 0),
     };
-    expect(some_struct.field == 1);
+    try expect(some_struct.field == 1);
 }

@@ -7,7 +7,7 @@ const State = struct {
 };
 
 fn prev(p: ?State) void {
-    expect(p == null);
+    expect(p == null) catch @panic("test failure");
 }
 
 test "zig test crash" {

@@ -2,10 +2,10 @@ const std = @import("std");
 const expect = std.testing.expect;
 
 test "resolve array slice using builtin" {
-    expect(@hasDecl(@This(), "std") == true);
-    expect(@hasDecl(@This(), "std"[0..0]) == false);
-    expect(@hasDecl(@This(), "std"[0..1]) == false);
-    expect(@hasDecl(@This(), "std"[0..2]) == false);
-    expect(@hasDecl(@This(), "std"[0..3]) == true);
-    expect(@hasDecl(@This(), "std"[0..]) == true);
+    try expect(@hasDecl(@This(), "std") == true);
+    try expect(@hasDecl(@This(), "std"[0..0]) == false);
+    try expect(@hasDecl(@This(), "std"[0..1]) == false);
+    try expect(@hasDecl(@This(), "std"[0..2]) == false);
+    try expect(@hasDecl(@This(), "std"[0..3]) == true);
+    try expect(@hasDecl(@This(), "std"[0..]) == true);
 }

@@ -14,5 +14,5 @@ test "bug 394 fixed" {
         .x = 3,
         .y = E{ .B = 1 },
     };
-    expect(x.x == 3);
+    try expect(x.x == 3);
 }

@@ -1,12 +1,12 @@
 const expect = @import("std").testing.expect;
 
 test "bitCast to array" {
-    comptime testBitCastArray();
-    testBitCastArray();
+    comptime try testBitCastArray();
+    try testBitCastArray();
 }
 
-fn testBitCastArray() void {
-    expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef);
+fn testBitCastArray() !void {
+    try expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef);
 }
 
 fn extractOne64(a: u128) u64 {

@@ -25,14 +25,14 @@ test "Extern function calls in @TypeOf" {
             return 1;
         }
 
-        fn doTheTest() void {
-            expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));
-            expectEqual(c_short, @TypeOf(test_fn_2(0)));
+        fn doTheTest() !void {
+            try expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));
+            try expectEqual(c_short, @TypeOf(test_fn_2(0)));
         }
     };
 
-    Test.doTheTest();
-    comptime Test.doTheTest();
+    try Test.doTheTest();
+    comptime try Test.doTheTest();
 }
 
 test "Peer resolution of extern function calls in @TypeOf" {
@@ -41,13 +41,13 @@ test "Peer resolution of extern function calls in @TypeOf" {
             return 0;
         }
 
-        fn doTheTest() void {
-            expectEqual(c_long, @TypeOf(test_fn()));
+        fn doTheTest() !void {
+            try expectEqual(c_long, @TypeOf(test_fn()));
         }
     };
 
-    Test.doTheTest();
-    comptime Test.doTheTest();
+    try Test.doTheTest();
+    comptime try Test.doTheTest();
 }
 
 test "Extern function calls, dereferences and field access in @TypeOf" {
@@ -60,12 +60,12 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
             return 255;
         }
 
-        fn doTheTest() void {
-            expectEqual(FILE, @TypeOf(test_fn_1(0)));
-            expectEqual(u8, @TypeOf(test_fn_2(0)));
+        fn doTheTest() !void {
+            try expectEqual(FILE, @TypeOf(test_fn_1(0)));
+            try expectEqual(u8, @TypeOf(test_fn_2(0)));
         }
     };
 
-    Test.doTheTest();
-    comptime Test.doTheTest();
+    try Test.doTheTest();
+    comptime try Test.doTheTest();
 }

@@ -8,9 +8,9 @@ test "fixed" {
             .max_distance_from_start_index = 456,
         },
     };
-    std.testing.expect(s.a == 1);
-    std.testing.expect(s.b.size == 123);
-    std.testing.expect(s.b.max_distance_from_start_index == 456);
+    try std.testing.expect(s.a == 1);
+    try std.testing.expect(s.b.size == 123);
+    try std.testing.expect(s.b.max_distance_from_start_index == 456);
 }
 
 const S = struct {

@@ -1,1 +1,1 @@
-//
\ No newline at end of file
+//

@@ -1,1 +1,1 @@
-//!
\ No newline at end of file
+//!

@@ -25,7 +25,7 @@ test "assignment of field with padding" {
             .emits_shadows = false,
         },
     };
-    testing.expectEqual(false, renderable.material.transparent);
-    testing.expectEqual(false, renderable.material.emits_shadows);
-    testing.expectEqual(true, renderable.material.render_color);
+    try testing.expectEqual(false, renderable.material.transparent);
+    try testing.expectEqual(false, renderable.material.emits_shadows);
+    try testing.expectEqual(true, renderable.material.render_color);
 }

@@ -1,6 +1,6 @@
 const expect = @import("std").testing.expect;
 
 test "Peer type resolution with string literals and unknown length u8 pointers" {
-    expect(@TypeOf("", "a", @as([*:0]const u8, "")) == [*:0]const u8);
-    expect(@TypeOf(@as([*:0]const u8, "baz"), "foo", "bar") == [*:0]const u8);
+    try expect(@TypeOf("", "a", @as([*:0]const u8, "")) == [*:0]const u8);
+    try expect(@TypeOf(@as([*:0]const u8, "baz"), "foo", "bar") == [*:0]const u8);
 }

@@ -25,33 +25,33 @@ const Box2 = struct {
     };
 };
 
-fn doTest() void {
+fn doTest() !void {
     // var
     {
         var box0: Box0 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == false);
+        try std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == false);
 
         var box1: Box1 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == false);
+        try std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == false);
 
         var box2: Box2 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == false);
+        try std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == false);
     }
 
     // const
     {
         const box0: Box0 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == true);
+        try std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == true);
 
         const box1: Box1 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == true);
+        try std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == true);
 
         const box2: Box2 = .{ .items = undefined };
-        std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == true);
+        try std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == true);
     }
 }
 
 test "pointer-to-array constness for zero-size elements" {
-    doTest();
-    comptime doTest();
+    try doTest();
+    comptime try doTest();
 }

@@ -19,5 +19,5 @@ fn MemoryPool(comptime T: type) type {
 
 test "foo" {
     var allocator = ContextAllocator{ .n = 10 };
-    expect(allocator.n == 10);
+    try expect(allocator.n == 10);
 }

@@ -35,9 +35,9 @@ test "issue 6456" {
         });
 
         const gen_fields = @typeInfo(T).Struct.fields;
-        testing.expectEqual(3, gen_fields.len);
-        testing.expectEqualStrings("f1", gen_fields[0].name);
-        testing.expectEqualStrings("f2", gen_fields[1].name);
-        testing.expectEqualStrings("f3", gen_fields[2].name);
+        try testing.expectEqual(3, gen_fields.len);
+        try testing.expectEqualStrings("f1", gen_fields[0].name);
+        try testing.expectEqualStrings("f2", gen_fields[1].name);
+        try testing.expectEqualStrings("f3", gen_fields[2].name);
     }
 }

@@ -3,10 +3,10 @@ const other_file = @import("655_other_file.zig");
 
 test "function with *const parameter with type dereferenced by namespace" {
     const x: other_file.Integer = 1234;
-    comptime std.testing.expect(@TypeOf(&x) == *const other_file.Integer);
-    foo(&x);
+    comptime try std.testing.expect(@TypeOf(&x) == *const other_file.Integer);
+    try foo(&x);
 }
 
-fn foo(x: *const other_file.Integer) void {
-    std.testing.expect(x.* == 1234);
+fn foo(x: *const other_file.Integer) !void {
+    try std.testing.expect(x.* == 1234);
 }

@@ -10,10 +10,10 @@ const Value = struct {
 };
 
 test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
-    foo(false, true);
+    try foo(false, true);
 }
 
-fn foo(a: bool, b: bool) void {
+fn foo(a: bool, b: bool) !void {
     var prefix_op = PrefixOp{
         .AddrOf = Value{ .align_expr = 1234 },
     };
@@ -22,7 +22,7 @@ fn foo(a: bool, b: bool) void {
             PrefixOp.AddrOf => |addr_of_info| {
                 if (b) {}
                 if (addr_of_info.align_expr) |align_expr| {
-                    expect(align_expr == 1234);
+                    try expect(align_expr == 1234);
                 }
             },
             PrefixOp.Return => {},

@@ -13,5 +13,5 @@ const Element = struct {
 test "false dependency loop in struct definition" {
     const listType = ElementList;
     var x: listType = 42;
-    expect(x == 42);
+    try expect(x == 42);
 }

@@ -4,7 +4,7 @@ test "lazy sizeof comparison with zero" {
     const Empty = struct {};
     const T = *Empty;
 
-    std.testing.expect(hasNoBits(T));
+    try std.testing.expect(hasNoBits(T));
 }
 
 fn hasNoBits(comptime T: type) bool {

@@ -15,8 +15,8 @@ fn S(comptime query: U) type {
 
 test "compiler doesn't consider equal unions with different 'type' payload" {
     const s1 = S(U{ .T = u32 }).tag();
-    std.testing.expectEqual(u32, s1);
+    try std.testing.expectEqual(u32, s1);
 
     const s2 = S(U{ .T = u64 }).tag();
-    std.testing.expectEqual(u64, s2);
+    try std.testing.expectEqual(u64, s2);
 }

@@ -10,8 +10,8 @@ const Keys = struct {
 var keys: Keys = undefined;
 test "zero keys with @memset" {
     @memset(@ptrCast([*]u8, &keys), 0, @sizeOf(@TypeOf(keys)));
-    expect(!keys.up);
-    expect(!keys.down);
-    expect(!keys.left);
-    expect(!keys.right);
+    try expect(!keys.up);
+    try expect(!keys.down);
+    try expect(!keys.left);
+    try expect(!keys.right);
 }

@@ -3,7 +3,7 @@ const expect = @import("std").testing.expect;
 test "@ptrCast from const to nullable" {
     const c: u8 = 4;
     var x: ?*const u8 = @ptrCast(?*const u8, &c);
-    expect(x.?.* == 4);
+    try expect(x.?.* == 4);
 }
 
 test "@ptrCast from var in empty struct to nullable" {
@@ -11,5 +11,5 @@ test "@ptrCast from var in empty struct to nullable" {
         var c: u8 = 4;
     };
     var x: ?*const u8 = @ptrCast(?*const u8, &container.c);
-    expect(x.?.* == 4);
+    try expect(x.?.* == 4);
 }

@@ -60,6 +60,6 @@ test "bug 920 fixed" {
     };
 
     for (NormalDist1.f) |_, i| {
-        std.testing.expectEqual(NormalDist1.f[i], NormalDist.f[i]);
+        try std.testing.expectEqual(NormalDist1.f[i], NormalDist.f[i]);
     }
 }

@@ -5,16 +5,16 @@ const builtin = @import("builtin");
 var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
-    comptime expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
-    comptime expect(@TypeOf(&foo) == *align(4) u8);
+    comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
+    comptime try expect(@TypeOf(&foo) == *align(4) u8);
     {
         const slice = @as(*[1]u8, &foo)[0..];
-        comptime expect(@TypeOf(slice) == *align(4) [1]u8);
+        comptime try expect(@TypeOf(slice) == *align(4) [1]u8);
     }
     {
         var runtime_zero: usize = 0;
         const slice = @as(*[1]u8, &foo)[runtime_zero..];
-        comptime expect(@TypeOf(slice) == []align(4) u8);
+        comptime try expect(@TypeOf(slice) == []align(4) u8);
     }
 }
 
@@ -28,9 +28,9 @@ test "function alignment" {
     // function alignment is a compile error on wasm32/wasm64
     if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
 
-    expect(derp() == 1234);
-    expect(@TypeOf(noop1) == fn () align(1) void);
-    expect(@TypeOf(noop4) == fn () align(4) void);
+    try expect(derp() == 1234);
+    try expect(@TypeOf(noop1) == fn () align(1) void);
+    try expect(@TypeOf(noop4) == fn () align(4) void);
     noop1();
     noop4();
 }
@@ -41,7 +41,7 @@ var baz: packed struct {
 } = undefined;
 
 test "packed struct alignment" {
-    expect(@TypeOf(&baz.b) == *align(1) u32);
+    try expect(@TypeOf(&baz.b) == *align(1) u32);
 }
 
 const blah: packed struct {
@@ -51,17 +51,17 @@ const blah: packed struct {
 } = undefined;
 
 test "bit field alignment" {
-    expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);
+    try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);
 }
 
 test "default alignment allows unspecified in type syntax" {
-    expect(*u32 == *align(@alignOf(u32)) u32);
+    try expect(*u32 == *align(@alignOf(u32)) u32);
 }
 
 test "implicitly decreasing pointer alignment" {
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
-    expect(addUnaligned(&a, &b) == 7);
+    try expect(addUnaligned(&a, &b) == 7);
 }
 
 fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
@@ -71,16 +71,16 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
 test "implicitly decreasing slice alignment" {
     const a: u32 align(4) = 3;
     const b: u32 align(8) = 4;
-    expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7);
+    try expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7);
 }
 fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
     return a[0] + b[0];
 }
 
 test "specifying alignment allows pointer cast" {
-    testBytesAlign(0x33);
+    try testBytesAlign(0x33);
 }
-fn testBytesAlign(b: u8) void {
+fn testBytesAlign(b: u8) !void {
     var bytes align(4) = [_]u8{
         b,
         b,
@@ -88,13 +88,13 @@ fn testBytesAlign(b: u8) void {
         b,
     };
     const ptr = @ptrCast(*u32, &bytes[0]);
-    expect(ptr.* == 0x33333333);
+    try expect(ptr.* == 0x33333333);
 }
 
 test "@alignCast pointers" {
     var x: u32 align(4) = 1;
     expectsOnly1(&x);
-    expect(x == 2);
+    try expect(x == 2);
 }
 fn expectsOnly1(x: *align(1) u32) void {
     expects4(@alignCast(4, x));
@@ -110,7 +110,7 @@ test "@alignCast slices" {
     };
     const slice = array[0..];
     sliceExpectsOnly1(slice);
-    expect(slice[0] == 2);
+    try expect(slice[0] == 2);
 }
 fn sliceExpectsOnly1(slice: []align(1) u32) void {
     sliceExpects4(@alignCast(4, slice));
@@ -123,12 +123,12 @@ test "implicitly decreasing fn alignment" {
     // function alignment is a compile error on wasm32/wasm64
     if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
 
-    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
-    testImplicitlyDecreaseFnAlign(alignedBig, 5678);
+    try testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
+    try testImplicitlyDecreaseFnAlign(alignedBig, 5678);
 }
 
-fn testImplicitlyDecreaseFnAlign(ptr: fn () align(1) i32, answer: i32) void {
-    expect(ptr() == answer);
+fn testImplicitlyDecreaseFnAlign(ptr: fn () align(1) i32, answer: i32) !void {
+    try expect(ptr() == answer);
 }
 
 fn alignedSmall() align(8) i32 {
@@ -143,7 +143,7 @@ test "@alignCast functions" {
     if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
     if (builtin.arch == .thumb) return error.SkipZigTest;
 
-    expect(fnExpectsOnly1(simple4) == 0x19);
+    try expect(fnExpectsOnly1(simple4) == 0x19);
 }
 fn fnExpectsOnly1(ptr: fn () align(1) i32) i32 {
     return fnExpects4(@alignCast(4, ptr));
@@ -160,9 +160,9 @@ test "generic function with align param" {
     if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
     if (builtin.arch == .thumb) return error.SkipZigTest;
 
-    expect(whyWouldYouEverDoThis(1) == 0x1);
-    expect(whyWouldYouEverDoThis(4) == 0x1);
-    expect(whyWouldYouEverDoThis(8) == 0x1);
+    try expect(whyWouldYouEverDoThis(1) == 0x1);
+    try expect(whyWouldYouEverDoThis(4) == 0x1);
+    try expect(whyWouldYouEverDoThis(8) == 0x1);
 }
 
 fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 {
@@ -172,49 +172,49 @@ fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 {
 test "@ptrCast preserves alignment of bigger source" {
     var x: u32 align(16) = 1234;
     const ptr = @ptrCast(*u8, &x);
-    expect(@TypeOf(ptr) == *align(16) u8);
+    try expect(@TypeOf(ptr) == *align(16) u8);
 }
 
 test "runtime known array index has best alignment possible" {
     // take full advantage of over-alignment
     var array align(4) = [_]u8{ 1, 2, 3, 4 };
-    expect(@TypeOf(&array[0]) == *align(4) u8);
-    expect(@TypeOf(&array[1]) == *u8);
-    expect(@TypeOf(&array[2]) == *align(2) u8);
-    expect(@TypeOf(&array[3]) == *u8);
+    try expect(@TypeOf(&array[0]) == *align(4) u8);
+    try expect(@TypeOf(&array[1]) == *u8);
+    try expect(@TypeOf(&array[2]) == *align(2) u8);
+    try expect(@TypeOf(&array[3]) == *u8);
 
     // because align is too small but we still figure out to use 2
     var bigger align(2) = [_]u64{ 1, 2, 3, 4 };
-    expect(@TypeOf(&bigger[0]) == *align(2) u64);
-    expect(@TypeOf(&bigger[1]) == *align(2) u64);
-    expect(@TypeOf(&bigger[2]) == *align(2) u64);
-    expect(@TypeOf(&bigger[3]) == *align(2) u64);
+    try expect(@TypeOf(&bigger[0]) == *align(2) u64);
+    try expect(@TypeOf(&bigger[1]) == *align(2) u64);
+    try expect(@TypeOf(&bigger[2]) == *align(2) u64);
+    try expect(@TypeOf(&bigger[3]) == *align(2) u64);
 
     // because pointer is align 2 and u32 align % 2 == 0 we can assume align 2
     var smaller align(2) = [_]u32{ 1, 2, 3, 4 };
     var runtime_zero: usize = 0;
-    comptime expect(@TypeOf(smaller[runtime_zero..]) == []align(2) u32);
-    comptime expect(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32);
-    testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32);
-    testIndex(smaller[runtime_zero..].ptr, 1, *align(2) u32);
-    testIndex(smaller[runtime_zero..].ptr, 2, *align(2) u32);
-    testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32);
+    comptime try expect(@TypeOf(smaller[runtime_zero..]) == []align(2) u32);
+    comptime try expect(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32);
+    try testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32);
+    try testIndex(smaller[runtime_zero..].ptr, 1, *align(2) u32);
+    try testIndex(smaller[runtime_zero..].ptr, 2, *align(2) u32);
+    try testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32);
 
     // has to use ABI alignment because index known at runtime only
-    testIndex2(array[runtime_zero..].ptr, 0, *u8);
-    testIndex2(array[runtime_zero..].ptr, 1, *u8);
-    testIndex2(array[runtime_zero..].ptr, 2, *u8);
-    testIndex2(array[runtime_zero..].ptr, 3, *u8);
+    try testIndex2(array[runtime_zero..].ptr, 0, *u8);
+    try testIndex2(array[runtime_zero..].ptr, 1, *u8);
+    try testIndex2(array[runtime_zero..].ptr, 2, *u8);
+    try testIndex2(array[runtime_zero..].ptr, 3, *u8);
 }
-fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) void {
-    comptime expect(@TypeOf(&smaller[index]) == T);
+fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void {
+    comptime try expect(@TypeOf(&smaller[index]) == T);
 }
-fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) void {
-    comptime expect(@TypeOf(&ptr[index]) == T);
+fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
+    comptime try expect(@TypeOf(&ptr[index]) == T);
 }
 
 test "alignstack" {
-    expect(fnWithAlignedStack() == 1234);
+    try expect(fnWithAlignedStack() == 1234);
 }
 
 fn fnWithAlignedStack() i32 {
@@ -223,7 +223,7 @@ fn fnWithAlignedStack() i32 {
 }
 
 test "alignment of structs" {
-    expect(@alignOf(struct {
+    try expect(@alignOf(struct {
         a: i32,
         b: *i32,
     }) == @alignOf(usize));
@@ -239,37 +239,37 @@ test "alignment of function with c calling convention" {
 fn nothing() callconv(.C) void {}
 
 test "return error union with 128-bit integer" {
-    expect(3 == try give());
+    try expect(3 == try give());
 }
 fn give() anyerror!u128 {
     return 3;
 }
 
 test "alignment of >= 128-bit integer type" {
-    expect(@alignOf(u128) == 16);
-    expect(@alignOf(u129) == 16);
+    try expect(@alignOf(u128) == 16);
+    try expect(@alignOf(u129) == 16);
 }
 
 test "alignment of struct with 128-bit field" {
-    expect(@alignOf(struct {
+    try expect(@alignOf(struct {
         x: u128,
     }) == 16);
 
     comptime {
-        expect(@alignOf(struct {
+        try expect(@alignOf(struct {
             x: u128,
         }) == 16);
     }
 }
 
 test "size of extern struct with 128-bit field" {
-    expect(@sizeOf(extern struct {
+    try expect(@sizeOf(extern struct {
         x: u128,
         y: u8,
     }) == 32);
 
     comptime {
-        expect(@sizeOf(extern struct {
+        try expect(@sizeOf(extern struct {
             x: u128,
             y: u8,
         }) == 32);
@@ -286,8 +286,8 @@ test "read 128-bit field from default aligned struct in stack memory" {
         .nevermind = 1,
         .badguy = 12,
     };
-    expect((@ptrToInt(&default_aligned.badguy) % 16) == 0);
-    expect(12 == default_aligned.badguy);
+    try expect((@ptrToInt(&default_aligned.badguy) % 16) == 0);
+    try expect(12 == default_aligned.badguy);
 }
 
 var default_aligned_global = DefaultAligned{
@@ -296,8 +296,8 @@ var default_aligned_global = DefaultAligned{
 };
 
 test "read 128-bit field from default aligned struct in global memory" {
-    expect((@ptrToInt(&default_aligned_global.badguy) % 16) == 0);
-    expect(12 == default_aligned_global.badguy);
+    try expect((@ptrToInt(&default_aligned_global.badguy) % 16) == 0);
+    try expect(12 == default_aligned_global.badguy);
 }
 
 test "struct field explicit alignment" {
@@ -310,9 +310,9 @@ test "struct field explicit alignment" {
 
     var node: S.Node = undefined;
     node.massive_byte = 100;
-    expect(node.massive_byte == 100);
-    comptime expect(@TypeOf(&node.massive_byte) == *align(64) u8);
-    expect(@ptrToInt(&node.massive_byte) % 64 == 0);
+    try expect(node.massive_byte == 100);
+    comptime try expect(@TypeOf(&node.massive_byte) == *align(64) u8);
+    try expect(@ptrToInt(&node.massive_byte) % 64 == 0);
 }
 
 test "align(@alignOf(T)) T does not force resolution of T" {
@@ -334,7 +334,7 @@ test "align(@alignOf(T)) T does not force resolution of T" {
         var ok = false;
     };
     _ = async S.doTheTest();
-    expect(S.ok);
+    try expect(S.ok);
 }
 
 test "align(N) on functions" {
@@ -342,7 +342,7 @@ test "align(N) on functions" {
     if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
     if (builtin.arch == .thumb) return error.SkipZigTest;
 
-    expect((@ptrToInt(overaligned_fn) & (0x1000 - 1)) == 0);
+    try expect((@ptrToInt(overaligned_fn) & (0x1000 - 1)) == 0);
 }
 fn overaligned_fn() align(0x1000) i32 {
     return 42;

@@ -10,29 +10,29 @@ const Foo = struct {
 };
 
 test "@alignOf(T) before referencing T" {
-    comptime expect(@alignOf(Foo) != maxInt(usize));
+    comptime try expect(@alignOf(Foo) != maxInt(usize));
     if (builtin.arch == builtin.Arch.x86_64) {
-        comptime expect(@alignOf(Foo) == 4);
+        comptime try expect(@alignOf(Foo) == 4);
     }
 }
 
 test "comparison of @alignOf(T) against zero" {
     {
         const T = struct { x: u32 };
-        expect(!(@alignOf(T) == 0));
-        expect(@alignOf(T) != 0);
-        expect(!(@alignOf(T) < 0));
-        expect(!(@alignOf(T) <= 0));
-        expect(@alignOf(T) > 0);
-        expect(@alignOf(T) >= 0);
+        try expect(!(@alignOf(T) == 0));
+        try expect(@alignOf(T) != 0);
+        try expect(!(@alignOf(T) < 0));
+        try expect(!(@alignOf(T) <= 0));
+        try expect(@alignOf(T) > 0);
+        try expect(@alignOf(T) >= 0);
     }
     {
         const T = struct {};
-        expect(@alignOf(T) == 0);
-        expect(!(@alignOf(T) != 0));
-        expect(!(@alignOf(T) < 0));
-        expect(@alignOf(T) <= 0);
-        expect(!(@alignOf(T) > 0));
-        expect(@alignOf(T) >= 0);
+        try expect(@alignOf(T) == 0);
+        try expect(!(@alignOf(T) != 0));
+        try expect(!(@alignOf(T) < 0));
+        try expect(@alignOf(T) <= 0);
+        try expect(!(@alignOf(T) > 0));
+        try expect(@alignOf(T) >= 0);
     }
 }

@@ -21,8 +21,8 @@ test "arrays" {
         i += 1;
     }
 
-    expect(accumulator == 15);
-    expect(getArrayLen(&array) == 5);
+    try expect(accumulator == 15);
+    try expect(getArrayLen(&array) == 5);
 }
 fn getArrayLen(a: []const u32) usize {
     return a.len;
@@ -30,37 +30,37 @@ fn getArrayLen(a: []const u32) usize {
 
 test "array with sentinels" {
     const S = struct {
-        fn doTheTest(is_ct: bool) void {
+        fn doTheTest(is_ct: bool) !void {
             if (is_ct) {
                 var zero_sized: [0:0xde]u8 = [_:0xde]u8{};
                 // Disabled at runtime because of
                 // https://github.com/ziglang/zig/issues/4372
-                expectEqual(@as(u8, 0xde), zero_sized[0]);
+                try expectEqual(@as(u8, 0xde), zero_sized[0]);
                 var reinterpreted = @ptrCast(*[1]u8, &zero_sized);
-                expectEqual(@as(u8, 0xde), reinterpreted[0]);
+                try expectEqual(@as(u8, 0xde), reinterpreted[0]);
             }
             var arr: [3:0x55]u8 = undefined;
             // Make sure the sentinel pointer is pointing after the last element
             if (!is_ct) {
                 const sentinel_ptr = @ptrToInt(&arr[3]);
                 const last_elem_ptr = @ptrToInt(&arr[2]);
-                expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr);
+                try expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr);
             }
             // Make sure the sentinel is writeable
             arr[3] = 0x55;
         }
     };
 
-    S.doTheTest(false);
-    comptime S.doTheTest(true);
+    try S.doTheTest(false);
+    comptime try S.doTheTest(true);
 }
 
 test "void arrays" {
     var array: [4]void = undefined;
     array[0] = void{};
     array[1] = array[2];
-    expect(@sizeOf(@TypeOf(array)) == 0);
-    expect(array.len == 4);
+    try expect(@sizeOf(@TypeOf(array)) == 0);
+    try expect(array.len == 4);
 }
 
 test "array literal" {
@@ -71,12 +71,12 @@ test "array literal" {
         1,
     };
 
-    expect(hex_mult.len == 4);
-    expect(hex_mult[1] == 256);
+    try expect(hex_mult.len == 4);
+    try expect(hex_mult[1] == 256);
 }
 
 test "array dot len const expr" {
-    expect(comptime x: {
+    try expect(comptime x: {
         break :x some_array.len == 4;
     });
 }
@@ -100,11 +100,11 @@ test "nested arrays" {
         "thing",
     };
     for (array_of_strings) |s, i| {
-        if (i == 0) expect(mem.eql(u8, s, "hello"));
-        if (i == 1) expect(mem.eql(u8, s, "this"));
-        if (i == 2) expect(mem.eql(u8, s, "is"));
-        if (i == 3) expect(mem.eql(u8, s, "my"));
-        if (i == 4) expect(mem.eql(u8, s, "thing"));
+        if (i == 0) try expect(mem.eql(u8, s, "hello"));
+        if (i == 1) try expect(mem.eql(u8, s, "this"));
+        if (i == 2) try expect(mem.eql(u8, s, "is"));
+        if (i == 3) try expect(mem.eql(u8, s, "my"));
+        if (i == 4) try expect(mem.eql(u8, s, "thing"));
     }
 }
 
@@ -122,9 +122,9 @@ test "set global var array via slice embedded in struct" {
     s.a[1].b = 2;
     s.a[2].b = 3;
 
-    expect(s_array[0].b == 1);
-    expect(s_array[1].b == 2);
-    expect(s_array[2].b == 3);
+    try expect(s_array[0].b == 1);
+    try expect(s_array[1].b == 2);
+    try expect(s_array[2].b == 3);
 }
 
 test "array literal with specified size" {
@@ -132,34 +132,34 @@ test "array literal with specified size" {
         1,
         2,
     };
-    expect(array[0] == 1);
-    expect(array[1] == 2);
+    try expect(array[0] == 1);
+    try expect(array[1] == 2);
 }
 
 test "array len field" {
     var arr = [4]u8{ 0, 0, 0, 0 };
     var ptr = &arr;
-    expect(arr.len == 4);
-    comptime expect(arr.len == 4);
-    expect(ptr.len == 4);
-    comptime expect(ptr.len == 4);
+    try expect(arr.len == 4);
+    comptime try expect(arr.len == 4);
+    try expect(ptr.len == 4);
+    comptime try expect(ptr.len == 4);
 }
 
 test "single-item pointer to array indexing and slicing" {
-    testSingleItemPtrArrayIndexSlice();
-    comptime testSingleItemPtrArrayIndexSlice();
+    try testSingleItemPtrArrayIndexSlice();
+    comptime try testSingleItemPtrArrayIndexSlice();
 }
 
-fn testSingleItemPtrArrayIndexSlice() void {
+fn testSingleItemPtrArrayIndexSlice() !void {
     {
         var array: [4]u8 = "aaaa".*;
         doSomeMangling(&array);
-        expect(mem.eql(u8, "azya", &array));
+        try expect(mem.eql(u8, "azya", &array));
     }
     {
         var array = "aaaa".*;
         doSomeMangling(&array);
-        expect(mem.eql(u8, "azya", &array));
+        try expect(mem.eql(u8, "azya", &array));
     }
 }
 
@@ -169,15 +169,15 @@ fn doSomeMangling(array: *[4]u8) void {
 }
 
 test "implicit cast single-item pointer" {
-    testImplicitCastSingleItemPtr();
-    comptime testImplicitCastSingleItemPtr();
+    try testImplicitCastSingleItemPtr();
+    comptime try testImplicitCastSingleItemPtr();
 }
 
-fn testImplicitCastSingleItemPtr() void {
+fn testImplicitCastSingleItemPtr() !void {
     var byte: u8 = 100;
     const slice = @as(*[1]u8, &byte)[0..];
     slice[0] += 1;
-    expect(byte == 101);
+    try expect(byte == 101);
 }
 
 fn testArrayByValAtComptime(b: [2]u8) u8 {
@@ -192,7 +192,7 @@ test "comptime evalutating function that takes array by value" {
 
 test "implicit comptime in array type size" {
     var arr: [plusOne(10)]bool = undefined;
-    expect(arr.len == 11);
+    try expect(arr.len == 11);
 }
 
 fn plusOne(x: u32) u32 {
@@ -202,52 +202,52 @@ fn plusOne(x: u32) u32 {
 test "runtime initialize array elem and then implicit cast to slice" {
     var two: i32 = 2;
     const x: []const i32 = &[_]i32{two};
-    expect(x[0] == 2);
+    try expect(x[0] == 2);
 }
 
 test "array literal as argument to function" {
     const S = struct {
-        fn entry(two: i32) void {
-            foo(&[_]i32{
+        fn entry(two: i32) !void {
+            try foo(&[_]i32{
                 1,
                 2,
                 3,
             });
-            foo(&[_]i32{
+            try foo(&[_]i32{
                 1,
                 two,
                 3,
             });
-            foo2(true, &[_]i32{
+            try foo2(true, &[_]i32{
                 1,
                 2,
                 3,
             });
-            foo2(true, &[_]i32{
+            try foo2(true, &[_]i32{
                 1,
                 two,
                 3,
             });
         }
-        fn foo(x: []const i32) void {
-            expect(x[0] == 1);
-            expect(x[1] == 2);
-            expect(x[2] == 3);
+        fn foo(x: []const i32) !void {
+            try expect(x[0] == 1);
+            try expect(x[1] == 2);
+            try expect(x[2] == 3);
         }
-        fn foo2(trash: bool, x: []const i32) void {
-            expect(trash);
-            expect(x[0] == 1);
-            expect(x[1] == 2);
-            expect(x[2] == 3);
+        fn foo2(trash: bool, x: []const i32) !void {
+            try expect(trash);
+            try expect(x[0] == 1);
+            try expect(x[1] == 2);
+            try expect(x[2] == 3);
         }
     };
-    S.entry(2);
-    comptime S.entry(2);
+    try S.entry(2);
+    comptime try S.entry(2);
 }
 
 test "double nested array to const slice cast in array literal" {
     const S = struct {
-        fn entry(two: i32) void {
+        fn entry(two: i32) !void {
             const cases = [_][]const []const i32{
                 &[_][]const i32{&[_]i32{1}},
                 &[_][]const i32{&[_]i32{ 2, 3 }},
@@ -256,18 +256,18 @@ test "double nested array to const slice cast in array literal" {
                     &[_]i32{ 5, 6, 7 },
                 },
             };
-            check(&cases);
+            try check(&cases);
 
             const cases2 = [_][]const i32{
                 &[_]i32{1},
                 &[_]i32{ two, 3 },
             };
-            expect(cases2.len == 2);
-            expect(cases2[0].len == 1);
-            expect(cases2[0][0] == 1);
-            expect(cases2[1].len == 2);
-            expect(cases2[1][0] == 2);
-            expect(cases2[1][1] == 3);
+            try expect(cases2.len == 2);
+            try expect(cases2[0].len == 1);
+            try expect(cases2[0][0] == 1);
+            try expect(cases2[1].len == 2);
+            try expect(cases2[1][0] == 2);
+            try expect(cases2[1][1] == 3);
 
             const cases3 = [_][]const []const i32{
                 &[_][]const i32{&[_]i32{1}},
@@ -277,37 +277,37 @@ test "double nested array to const slice cast in array literal" {
                     &[_]i32{ 5, 6, 7 },
                 },
             };
-            check(&cases3);
+            try check(&cases3);
         }
 
-        fn check(cases: []const []const []const i32) void {
-            expect(cases.len == 3);
-            expect(cases[0].len == 1);
-            expect(cases[0][0].len == 1);
-            expect(cases[0][0][0] == 1);
-            expect(cases[1].len == 1);
-            expect(cases[1][0].len == 2);
-            expect(cases[1][0][0] == 2);
-            expect(cases[1][0][1] == 3);
-            expect(cases[2].len == 2);
-            expect(cases[2][0].len == 1);
-            expect(cases[2][0][0] == 4);
-            expect(cases[2][1].len == 3);
-            expect(cases[2][1][0] == 5);
-            expect(cases[2][1][1] == 6);
-            expect(cases[2][1][2] == 7);
+        fn check(cases: []const []const []const i32) !void {
+            try expect(cases.len == 3);
+            try expect(cases[0].len == 1);
+            try expect(cases[0][0].len == 1);
+            try expect(cases[0][0][0] == 1);
+            try expect(cases[1].len == 1);
+            try expect(cases[1][0].len == 2);
+            try expect(cases[1][0][0] == 2);
+            try expect(cases[1][0][1] == 3);
+            try expect(cases[2].len == 2);
+            try expect(cases[2][0].len == 1);
+            try expect(cases[2][0][0] == 4);
+            try expect(cases[2][1].len == 3);
+            try expect(cases[2][1][0] == 5);
+            try expect(cases[2][1][1] == 6);
+            try expect(cases[2][1][2] == 7);
         }
     };
-    S.entry(2);
-    comptime S.entry(2);
+    try S.entry(2);
+    comptime try S.entry(2);
 }
 
 test "read/write through global variable array of struct fields initialized via array mult" {
     const S = struct {
-        fn doTheTest() void {
-            expect(storage[0].term == 1);
+        fn doTheTest() !void {
+            try expect(storage[0].term == 1);
             storage[0] = MyStruct{ .term = 123 };
-            expect(storage[0].term == 123);
+            try expect(storage[0].term == 123);
         }
 
         pub const MyStruct = struct {
@@ -316,34 +316,34 @@ test "read/write through global variable array of struct fields initialized via
 
         var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1;
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "implicit cast zero sized array ptr to slice" {
     {
         var b = "".*;
         const c: []const u8 = &b;
-        expect(c.len == 0);
+        try expect(c.len == 0);
     }
     {
         var b: [0]u8 = "".*;
         const c: []const u8 = &b;
-        expect(c.len == 0);
+        try expect(c.len == 0);
     }
 }
 
 test "anonymous list literal syntax" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var array: [4]u8 = .{ 1, 2, 3, 4 };
-            expect(array[0] == 1);
-            expect(array[1] == 2);
-            expect(array[2] == 3);
-            expect(array[3] == 4);
+            try expect(array[0] == 1);
+            try expect(array[1] == 2);
+            try expect(array[2] == 3);
+            try expect(array[3] == 4);
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "anonymous literal in array" {
@@ -352,51 +352,51 @@ test "anonymous literal in array" {
             a: usize = 2,
             b: usize = 4,
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var array: [2]Foo = .{
                 .{ .a = 3 },
                 .{ .b = 3 },
             };
-            expect(array[0].a == 3);
-            expect(array[0].b == 4);
-            expect(array[1].a == 2);
-            expect(array[1].b == 3);
+            try expect(array[0].a == 3);
+            try expect(array[0].b == 4);
+            try expect(array[1].a == 2);
+            try expect(array[1].b == 3);
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "access the null element of a null terminated array" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
-            expect(array[4] == 0);
+            try expect(array[4] == 0);
             var len: usize = 4;
-            expect(array[len] == 0);
+            try expect(array[len] == 0);
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "type deduction for array subscript expression" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var array = [_]u8{ 0x55, 0xAA };
             var v0 = true;
-            expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]);
+            try expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]);
             var v1 = false;
-            expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]);
+            try expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]);
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "sentinel element count towards the ABI size calculation" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             const T = packed struct {
                 fill_pre: u8 = 0x55,
                 data: [0:0]u8 = undefined,
@@ -404,14 +404,14 @@ test "sentinel element count towards the ABI size calculation" {
             };
             var x = T{};
             var as_slice = mem.asBytes(&x);
-            expectEqual(@as(usize, 3), as_slice.len);
-            expectEqual(@as(u8, 0x55), as_slice[0]);
-            expectEqual(@as(u8, 0xAA), as_slice[2]);
+            try expectEqual(@as(usize, 3), as_slice.len);
+            try expectEqual(@as(u8, 0x55), as_slice[0]);
+            try expectEqual(@as(u8, 0xAA), as_slice[2]);
         }
     };
 
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "zero-sized array with recursive type definition" {
@@ -429,61 +429,61 @@ test "zero-sized array with recursive type definition" {
     };
 
     var t: S = .{ .list = .{ .s = undefined } };
-    expectEqual(@as(usize, 0), t.list.x);
+    try expectEqual(@as(usize, 0), t.list.x);
 }
 
 test "type coercion of anon struct literal to array" {
     const S = struct {
-        const U = union{
+        const U = union {
             a: u32,
             b: bool,
             c: []const u8,
         };
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var x1: u8 = 42;
             const t1 = .{ x1, 56, 54 };
             var arr1: [3]u8 = t1;
-            expect(arr1[0] == 42);
-            expect(arr1[1] == 56);
-            expect(arr1[2] == 54);
-            
+            try expect(arr1[0] == 42);
+            try expect(arr1[1] == 56);
+            try expect(arr1[2] == 54);
+
             var x2: U = .{ .a = 42 };
             const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
             var arr2: [3]U = t2;
-            expect(arr2[0].a == 42);
-            expect(arr2[1].b == true);
-            expect(mem.eql(u8, arr2[2].c, "hello"));
+            try expect(arr2[0].a == 42);
+            try expect(arr2[1].b == true);
+            try expect(mem.eql(u8, arr2[2].c, "hello"));
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }
 
 test "type coercion of pointer to anon struct literal to pointer to array" {
     const S = struct {
-        const U = union{
+        const U = union {
             a: u32,
             b: bool,
             c: []const u8,
         };
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var x1: u8 = 42;
             const t1 = &.{ x1, 56, 54 };
-            var arr1: *const[3]u8 = t1;
-            expect(arr1[0] == 42);
-            expect(arr1[1] == 56);
-            expect(arr1[2] == 54);
-            
+            var arr1: *const [3]u8 = t1;
+            try expect(arr1[0] == 42);
+            try expect(arr1[1] == 56);
+            try expect(arr1[2] == 54);
+
             var x2: U = .{ .a = 42 };
             const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
             var arr2: *const [3]U = t2;
-            expect(arr2[0].a == 42);
-            expect(arr2[1].b == true);
-            expect(mem.eql(u8, arr2[2].c, "hello"));
+            try expect(arr2[0].a == 42);
+            try expect(arr2[1].b == true);
+            try expect(mem.eql(u8, arr2[2].c, "hello"));
         }
     };
-    S.doTheTest();
-    comptime S.doTheTest();
+    try S.doTheTest();
+    comptime try S.doTheTest();
 }

@@ -15,7 +15,7 @@ comptime {
 
 test "module level assembly" {
     if (is_x86_64_linux) {
-        expect(this_is_my_alias() == 1234);
+        try expect(this_is_my_alias() == 1234);
     }
 }
 

@@ -9,12 +9,12 @@ var global_x: i32 = 1;
 
 test "simple coroutine suspend and resume" {
     var frame = async simpleAsyncFn();
-    expect(global_x == 2);
+    try expect(global_x == 2);
     resume frame;
-    expect(global_x == 3);
+    try expect(global_x == 3);
     const af: anyframe->void = &frame;
     resume frame;
-    expect(global_x == 4);
+    try expect(global_x == 4);
 }
 fn simpleAsyncFn() void {
     global_x += 1;
@@ -28,9 +28,9 @@ var global_y: i32 = 1;
 
 test "pass parameter to coroutine" {
     var p = async simpleAsyncFnWithArg(2);
-    expect(global_y == 3);
+    try expect(global_y == 3);
     resume p;
-    expect(global_y == 5);
+    try expect(global_y == 5);
 }
 fn simpleAsyncFnWithArg(delta: i32) void {
     global_y += delta;
@@ -42,10 +42,10 @@ test "suspend at end of function" {
     const S = struct {
         var x: i32 = 1;
 
-        fn doTheTest() void {
-            expect(x == 1);
+        fn doTheTest() !void {
+            try expect(x == 1);
             const p = async suspendAtEnd();
-            expect(x == 2);
+            try expect(x == 2);
         }
 
         fn suspendAtEnd() void {
@@ -53,23 +53,23 @@ test "suspend at end of function" {
             suspend {}
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "local variable in async function" {
     const S = struct {
         var x: i32 = 0;
 
-        fn doTheTest() void {
-            expect(x == 0);
+        fn doTheTest() !void {
+            try expect(x == 0);
             var p = async add(1, 2);
-            expect(x == 0);
+            try expect(x == 0);
             resume p;
-            expect(x == 0);
+            try expect(x == 0);
             resume p;
-            expect(x == 0);
+            try expect(x == 0);
             resume p;
-            expect(x == 3);
+            try expect(x == 3);
         }
 
         fn add(a: i32, b: i32) void {
@@ -82,7 +82,7 @@ test "local variable in async function" {
             x = accum;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "calling an inferred async function" {
@@ -90,11 +90,11 @@ test "calling an inferred async function" {
         var x: i32 = 1;
         var other_frame: *@Frame(other) = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async first();
-            expect(x == 1);
+            try expect(x == 1);
             resume other_frame.*;
-            expect(x == 2);
+            try expect(x == 2);
         }
 
         fn first() void {
@@ -106,7 +106,7 @@ test "calling an inferred async function" {
             x += 1;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "@frameSize" {
@@ -114,16 +114,16 @@ test "@frameSize" {
         return error.SkipZigTest;
 
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             {
                 var ptr = @ptrCast(fn (i32) callconv(.Async) void, other);
                 const size = @frameSize(ptr);
-                expect(size == @sizeOf(@Frame(other)));
+                try expect(size == @sizeOf(@Frame(other)));
             }
             {
                 var ptr = @ptrCast(fn () callconv(.Async) void, first);
                 const size = @frameSize(ptr);
-                expect(size == @sizeOf(@Frame(first)));
+                try expect(size == @sizeOf(@Frame(first)));
             }
         }
 
@@ -135,20 +135,20 @@ test "@frameSize" {
             suspend {}
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "coroutine suspend, resume" {
     const S = struct {
         var frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async amain();
             seq('d');
             resume frame;
             seq('h');
 
-            expect(std.mem.eql(u8, &points, "abcdefgh"));
+            try expect(std.mem.eql(u8, &points, "abcdefgh"));
         }
 
         fn amain() void {
@@ -176,27 +176,27 @@ test "coroutine suspend, resume" {
             index += 1;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "coroutine suspend with block" {
     const p = async testSuspendBlock();
-    expect(!global_result);
+    try expect(!global_result);
     resume a_promise;
-    expect(global_result);
+    try expect(global_result);
 }
 
 var a_promise: anyframe = undefined;
 var global_result = false;
 fn testSuspendBlock() callconv(.Async) void {
     suspend {
-        comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock));
+        comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock)) catch unreachable;
         a_promise = @frame();
     }
 
     // Test to make sure that @frame() works as advertised (issue #1296)
     // var our_handle: anyframe = @frame();
-    expect(a_promise == @as(anyframe, @frame()));
+    expect(a_promise == @as(anyframe, @frame())) catch @panic("test failed");
 
     global_result = true;
 }
@@ -210,8 +210,8 @@ test "coroutine await" {
     await_seq('f');
     resume await_a_promise;
     await_seq('i');
-    expect(await_final_result == 1234);
-    expect(std.mem.eql(u8, &await_points, "abcdefghi"));
+    try expect(await_final_result == 1234);
+    try expect(std.mem.eql(u8, &await_points, "abcdefghi"));
 }
 fn await_amain() callconv(.Async) void {
     await_seq('b');
@@ -244,8 +244,8 @@ test "coroutine await early return" {
     early_seq('a');
     var p = async early_amain();
     early_seq('f');
-    expect(early_final_result == 1234);
-    expect(std.mem.eql(u8, &early_points, "abcdef"));
+    try expect(early_final_result == 1234);
+    try expect(std.mem.eql(u8, &early_points, "abcdef"));
 }
 fn early_amain() callconv(.Async) void {
     early_seq('b');
@@ -276,7 +276,7 @@ test "async function with dot syntax" {
         }
     };
     const p = async S.foo();
-    expect(S.y == 2);
+    try expect(S.y == 2);
 }
 
 test "async fn pointer in a struct field" {
@@ -287,12 +287,12 @@ test "async fn pointer in a struct field" {
     var foo = Foo{ .bar = simpleAsyncFn2 };
     var bytes: [64]u8 align(16) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
-    comptime expect(@TypeOf(f) == anyframe->void);
-    expect(data == 2);
+    comptime try expect(@TypeOf(f) == anyframe->void);
+    try expect(data == 2);
     resume f;
-    expect(data == 4);
+    try expect(data == 4);
     _ = async doTheAwait(f);
-    expect(data == 4);
+    try expect(data == 4);
 }
 
 fn doTheAwait(f: anyframe->void) void {
@@ -323,22 +323,22 @@ test "@asyncCall with return type" {
     var bytes: [150]u8 align(16) = undefined;
     var aresult: i32 = 0;
     _ = @asyncCall(&bytes, &aresult, foo.bar, .{});
-    expect(aresult == 0);
+    try expect(aresult == 0);
     resume Foo.global_frame;
-    expect(aresult == 1234);
+    try expect(aresult == 1234);
 }
 
 test "async fn with inferred error set" {
     const S = struct {
         var global_frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var frame: [1]@Frame(middle) = undefined;
             var fn_ptr = middle;
             var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
             _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
             resume global_frame;
-            std.testing.expectError(error.Fail, result);
+            try std.testing.expectError(error.Fail, result);
         }
         fn middle() callconv(.Async) !void {
             var f = async middle2();
@@ -355,7 +355,7 @@ test "async fn with inferred error set" {
             return error.Fail;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "error return trace across suspend points - early return" {
@@ -383,9 +383,9 @@ fn suspendThenFail() callconv(.Async) anyerror!void {
 }
 fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
     (await p) catch |e| {
-        std.testing.expect(e == error.Fail);
+        std.testing.expect(e == error.Fail) catch @panic("test failure");
         if (@errorReturnTrace()) |trace| {
-            expect(trace.index == 1);
+            expect(trace.index == 1) catch @panic("test failure");
         } else switch (builtin.mode) {
             .Debug, .ReleaseSafe => @panic("expected return trace"),
             .ReleaseFast, .ReleaseSmall => {},
@@ -396,7 +396,7 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
 test "break from suspend" {
     var my_result: i32 = 1;
     const p = async testBreakFromSuspend(&my_result);
-    std.testing.expect(my_result == 2);
+    try std.testing.expect(my_result == 2);
 }
 fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void {
     suspend {
@@ -415,11 +415,11 @@ test "heap allocated async function frame" {
             const frame = try std.testing.allocator.create(@Frame(someFunc));
             defer std.testing.allocator.destroy(frame);
 
-            expect(x == 42);
+            try expect(x == 42);
             frame.* = async someFunc();
-            expect(x == 43);
+            try expect(x == 43);
             resume frame;
-            expect(x == 44);
+            try expect(x == 44);
         }
 
         fn someFunc() void {
@@ -436,15 +436,15 @@ test "async function call return value" {
         var frame: anyframe = undefined;
         var pt = Point{ .x = 10, .y = 11 };
 
-        fn doTheTest() void {
-            expectEqual(pt.x, 10);
-            expectEqual(pt.y, 11);
+        fn doTheTest() !void {
+            try expectEqual(pt.x, 10);
+            try expectEqual(pt.y, 11);
             _ = async first();
-            expectEqual(pt.x, 10);
-            expectEqual(pt.y, 11);
+            try expectEqual(pt.x, 10);
+            try expectEqual(pt.y, 11);
             resume frame;
-            expectEqual(pt.x, 1);
-            expectEqual(pt.y, 2);
+            try expectEqual(pt.x, 1);
+            try expectEqual(pt.y, 2);
         }
 
         fn first() void {
@@ -469,23 +469,23 @@ test "async function call return value" {
             y: i32,
         };
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "suspension points inside branching control flow" {
     const S = struct {
         var result: i32 = 10;
 
-        fn doTheTest() void {
-            expect(10 == result);
+        fn doTheTest() !void {
+            try expect(10 == result);
             var frame = async func(true);
-            expect(10 == result);
+            try expect(10 == result);
             resume frame;
-            expect(11 == result);
+            try expect(11 == result);
             resume frame;
-            expect(12 == result);
+            try expect(12 == result);
             resume frame;
-            expect(13 == result);
+            try expect(13 == result);
         }
 
         fn func(b: bool) void {
@@ -495,7 +495,7 @@ test "suspension points inside branching control flow" {
             }
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "call async function which has struct return type" {
@@ -509,8 +509,8 @@ test "call async function which has struct return type" {
 
         fn atest() void {
             const result = func();
-            expect(result.x == 5);
-            expect(result.y == 6);
+            expect(result.x == 5) catch @panic("test failed");
+            expect(result.y == 6) catch @panic("test failed");
         }
 
         const Point = struct {
@@ -536,27 +536,27 @@ test "pass string literal to async function" {
         var frame: anyframe = undefined;
         var ok: bool = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async hello("hello");
             resume frame;
-            expect(ok);
+            try expect(ok);
         }
 
         fn hello(msg: []const u8) void {
             frame = @frame();
             suspend {}
-            expectEqualStrings("hello", msg);
+            expectEqualStrings("hello", msg) catch @panic("test failed");
             ok = true;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "await inside an errdefer" {
     const S = struct {
         var frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async amainWrap();
             resume frame;
         }
@@ -572,7 +572,7 @@ test "await inside an errdefer" {
             suspend {}
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "try in an async function with error union and non-zero-bit payload" {
@@ -580,14 +580,14 @@ test "try in an async function with error union and non-zero-bit payload" {
         var frame: anyframe = undefined;
         var ok = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async amain();
             resume frame;
-            expect(ok);
+            try expect(ok);
         }
 
         fn amain() void {
-            std.testing.expectError(error.Bad, theProblem());
+            std.testing.expectError(error.Bad, theProblem()) catch @panic("test failed");
             ok = true;
         }
 
@@ -602,7 +602,7 @@ test "try in an async function with error union and non-zero-bit payload" {
             return error.Bad;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "returning a const error from async function" {
@@ -610,10 +610,10 @@ test "returning a const error from async function" {
         var frame: anyframe = undefined;
         var ok = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async amain();
             resume frame;
-            expect(ok);
+            try expect(ok);
         }
 
         fn amain() !void {
@@ -630,7 +630,7 @@ test "returning a const error from async function" {
             return error.OutOfMemory;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "async/await typical usage" {
@@ -663,11 +663,11 @@ fn testAsyncAwaitTypicalUsage(
         }
         fn amainWrap() void {
             if (amain()) |_| {
-                expect(!simulate_fail_download);
-                expect(!simulate_fail_file);
+                expect(!simulate_fail_download) catch @panic("test failure");
+                expect(!simulate_fail_file) catch @panic("test failure");
             } else |e| switch (e) {
-                error.NoResponse => expect(simulate_fail_download),
-                error.FileNotFound => expect(simulate_fail_file),
+                error.NoResponse => expect(simulate_fail_download) catch @panic("test failure"),
+                error.FileNotFound => expect(simulate_fail_file) catch @panic("test failure"),
                 else => @panic("test failure"),
             }
         }
@@ -694,8 +694,8 @@ fn testAsyncAwaitTypicalUsage(
             const file_text = try await file_frame;
             defer allocator.free(file_text);
 
-            expect(std.mem.eql(u8, "expected download text", download_text));
-            expect(std.mem.eql(u8, "expected file text", file_text));
+            try expect(std.mem.eql(u8, "expected download text", download_text));
+            try expect(std.mem.eql(u8, "expected file text", file_text));
         }
 
         var global_download_frame: anyframe = undefined;
@@ -728,13 +728,13 @@ fn testAsyncAwaitTypicalUsage(
 
 test "alignment of local variables in async functions" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var y: u8 = 123;
             var x: u8 align(128) = 1;
-            expect(@ptrToInt(&x) % 128 == 0);
+            try expect(@ptrToInt(&x) % 128 == 0);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "no reason to resolve frame still works" {
@@ -746,10 +746,10 @@ fn simpleNothing() void {
 
 test "async call a generic function" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var f = async func(i32, 2);
             const result = await f;
-            expect(result == 3);
+            try expect(result == 3);
         }
 
         fn func(comptime T: type, inc: T) T {
@@ -766,8 +766,8 @@ test "async call a generic function" {
 
 test "return from suspend block" {
     const S = struct {
-        fn doTheTest() void {
-            expect(func() == 1234);
+        fn doTheTest() !void {
+            expect(func() == 1234) catch @panic("test failure");
         }
         fn func() i32 {
             suspend {
@@ -808,7 +808,7 @@ test "struct parameter to async function is copied to the frame" {
             var pt = Point{ .x = 1, .y = 2 };
             f.* = async foo(pt);
             var result = await f;
-            expect(result == 1);
+            expect(result == 1) catch @panic("test failure");
         }
 
         fn foo(point: Point) i32 {
@@ -833,7 +833,7 @@ test "cast fn to async fn when it is inferred to be async" {
             var result: i32 = undefined;
             const f = @asyncCall(&buf, &result, ptr, .{});
             _ = await f;
-            expect(result == 1234);
+            expect(result == 1234) catch @panic("test failure");
             ok = true;
         }
 
@@ -846,7 +846,7 @@ test "cast fn to async fn when it is inferred to be async" {
     };
     _ = async S.doTheTest();
     resume S.frame;
-    expect(S.ok);
+    try expect(S.ok);
 }
 
 test "cast fn to async fn when it is inferred to be async, awaited directly" {
@@ -860,7 +860,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
             var buf: [100]u8 align(16) = undefined;
             var result: i32 = undefined;
             _ = await @asyncCall(&buf, &result, ptr, .{});
-            expect(result == 1234);
+            expect(result == 1234) catch @panic("test failure");
             ok = true;
         }
 
@@ -873,7 +873,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
     };
     _ = async S.doTheTest();
     resume S.frame;
-    expect(S.ok);
+    try expect(S.ok);
 }
 
 test "await does not force async if callee is blocking" {
@@ -883,12 +883,12 @@ test "await does not force async if callee is blocking" {
         }
     };
     var x = async S.simple();
-    expect(await x == 1234);
+    try expect(await x == 1234);
 }
 
 test "recursive async function" {
-    expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
-    expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);
+    try expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
+    try expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);
 }
 
 fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
@@ -952,12 +952,12 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
     const S = struct {
         var global_frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var frame: [1]@Frame(middle) = undefined;
             var result: @typeInfo(@typeInfo(@TypeOf(middle)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
             _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{});
             resume global_frame;
-            std.testing.expectError(error.Fail, result);
+            try std.testing.expectError(error.Fail, result);
         }
         fn middle() callconv(.Async) !void {
             var f = async middle2();
@@ -974,7 +974,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
             return error.Fail;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "@asyncCall with actual frame instead of byte buffer" {
@@ -988,7 +988,7 @@ test "@asyncCall with actual frame instead of byte buffer" {
     var result: i32 = undefined;
     const ptr = @asyncCall(&frame, &result, S.func, .{});
     resume ptr;
-    expect(result == 1234);
+    try expect(result == 1234);
 }
 
 test "@asyncCall using the result location inside the frame" {
@@ -1010,19 +1010,19 @@ test "@asyncCall using the result location inside the frame" {
     var foo = Foo{ .bar = S.simple2 };
     var bytes: [64]u8 align(16) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
-    comptime expect(@TypeOf(f) == anyframe->i32);
-    expect(data == 2);
+    comptime try expect(@TypeOf(f) == anyframe->i32);
+    try expect(data == 2);
     resume f;
-    expect(data == 4);
+    try expect(data == 4);
     _ = async S.getAnswer(f, &data);
-    expect(data == 1234);
+    try expect(data == 1234);
 }
 
 test "@TypeOf an async function call of generic fn with error union type" {
     const S = struct {
         fn func(comptime x: anytype) anyerror!i32 {
             const T = @TypeOf(async func(x));
-            comptime expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child);
+            comptime try expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child);
             return undefined;
         }
     };
@@ -1051,7 +1051,7 @@ test "using @TypeOf on a generic function call" {
     };
     _ = async S.amain(@as(u32, 1));
     resume S.global_frame;
-    expect(S.global_ok);
+    try expect(S.global_ok);
 }
 
 test "recursive call of await @asyncCall with struct return type" {
@@ -1084,17 +1084,17 @@ test "recursive call of await @asyncCall with struct return type" {
     var frame: @TypeOf(async S.amain(@as(u32, 1))) = undefined;
     _ = @asyncCall(&frame, &res, S.amain, .{@as(u32, 1)});
     resume S.global_frame;
-    expect(S.global_ok);
-    expect(res.x == 1);
-    expect(res.y == 2);
-    expect(res.z == 3);
+    try expect(S.global_ok);
+    try expect(res.x == 1);
+    try expect(res.y == 2);
+    try expect(res.z == 3);
 }
 
 test "nosuspend function call" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             const result = nosuspend add(50, 100);
-            expect(result == 150);
+            try expect(result == 150);
         }
         fn add(a: i32, b: i32) i32 {
             if (a > 100) {
@@ -1103,7 +1103,7 @@ test "nosuspend function call" {
             return a + b;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "await used in expression and awaiting fn with no suspend but async calling convention" {
@@ -1113,7 +1113,7 @@ test "await used in expression and awaiting fn with no suspend but async calling
             var f2 = async add(3, 4);
 
             const sum = (await f1) + (await f2);
-            expect(sum == 10);
+            expect(sum == 10) catch @panic("test failure");
         }
         fn add(a: i32, b: i32) callconv(.Async) i32 {
             return a + b;
@@ -1128,7 +1128,7 @@ test "await used in expression after a fn call" {
             var f1 = async add(3, 4);
             var sum: i32 = 0;
             sum = foo() + await f1;
-            expect(sum == 8);
+            expect(sum == 8) catch @panic("test failure");
         }
         fn add(a: i32, b: i32) callconv(.Async) i32 {
             return a + b;
@@ -1145,7 +1145,7 @@ test "async fn call used in expression after a fn call" {
         fn atest() void {
             var sum: i32 = 0;
             sum = foo() + add(3, 4);
-            expect(sum == 8);
+            expect(sum == 8) catch @panic("test failure");
         }
         fn add(a: i32, b: i32) callconv(.Async) i32 {
             return a + b;
@@ -1167,7 +1167,7 @@ test "suspend in for loop" {
         }
 
         fn atest() void {
-            expect(func(&[_]u8{ 1, 2, 3 }) == 6);
+            expect(func(&[_]u8{ 1, 2, 3 }) == 6) catch @panic("test failure");
         }
         fn func(stuff: []const u8) u32 {
             global_frame = @frame();
@@ -1193,8 +1193,8 @@ test "suspend in while loop" {
         }
 
         fn atest() void {
-            expect(optional(6) == 6);
-            expect(errunion(6) == 6);
+            expect(optional(6) == 6) catch @panic("test failure");
+            expect(errunion(6) == 6) catch @panic("test failure");
         }
         fn optional(stuff: ?u32) u32 {
             global_frame = @frame();
@@ -1223,8 +1223,8 @@ test "correctly spill when returning the error union result of another async fn"
     const S = struct {
         var global_frame: anyframe = undefined;
 
-        fn doTheTest() void {
-            expect((atest() catch unreachable) == 1234);
+        fn doTheTest() !void {
+            expect((atest() catch unreachable) == 1234) catch @panic("test failure");
         }
 
         fn atest() !i32 {
@@ -1246,11 +1246,11 @@ test "spill target expr in a for loop" {
     const S = struct {
         var global_frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var foo = Foo{
                 .slice = &[_]i32{ 1, 2 },
             };
-            expect(atest(&foo) == 3);
+            expect(atest(&foo) == 3) catch @panic("test failure");
         }
 
         const Foo = struct {
@@ -1277,11 +1277,11 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
     const S = struct {
         var global_frame: anyframe = undefined;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var foo = Foo{
                 .slice = &[_]i32{ 1, 2 },
             };
-            expect(atest(&foo) == 3);
+            expect(atest(&foo) == 3) catch @panic("test failure");
         }
 
         const Foo = struct {
@@ -1319,7 +1319,7 @@ test "async call with @call" {
         fn atest() void {
             var frame = @call(.{ .modifier = .async_kw }, afoo, .{});
             const res = await frame;
-            expect(res == 42);
+            expect(res == 42) catch @panic("test failure");
         }
         fn afoo() i32 {
             suspend {
@@ -1348,7 +1348,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {
     };
     _ = async S.foo();
     resume S.global_frame;
-    expect(S.global_int == 1);
+    try expect(S.global_int == 1);
 }
 
 test "async function passed align(16) arg after align(8) arg" {
@@ -1362,7 +1362,7 @@ test "async function passed align(16) arg after align(8) arg" {
         }
 
         fn bar(x: u64, args: anytype) anyerror!void {
-            expect(x == 10);
+            try expect(x == 10);
             global_frame = @frame();
             suspend {}
             global_int = args[0];
@@ -1370,7 +1370,7 @@ test "async function passed align(16) arg after align(8) arg" {
     };
     _ = async S.foo();
     resume S.global_frame;
-    expect(S.global_int == 99);
+    try expect(S.global_int == 99);
 }
 
 test "async function call resolves target fn frame, comptime func" {
@@ -1392,7 +1392,7 @@ test "async function call resolves target fn frame, comptime func" {
     };
     _ = async S.foo();
     resume S.global_frame;
-    expect(S.global_int == 10);
+    try expect(S.global_int == 10);
 }
 
 test "async function call resolves target fn frame, runtime func" {
@@ -1415,7 +1415,7 @@ test "async function call resolves target fn frame, runtime func" {
     };
     _ = async S.foo();
     resume S.global_frame;
-    expect(S.global_int == 10);
+    try expect(S.global_int == 10);
 }
 
 test "properly spill optional payload capture value" {
@@ -1439,7 +1439,7 @@ test "properly spill optional payload capture value" {
     };
     _ = async S.foo();
     resume S.global_frame;
-    expect(S.global_int == 1237);
+    try expect(S.global_int == 1237);
 }
 
 test "handle defer interfering with return value spill" {
@@ -1449,16 +1449,16 @@ test "handle defer interfering with return value spill" {
         var finished = false;
         var baz_happened = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async testFoo();
             resume global_frame1;
             resume global_frame2;
-            expect(baz_happened);
-            expect(finished);
+            try expect(baz_happened);
+            try expect(finished);
         }
 
         fn testFoo() void {
-            expectError(error.Bad, foo());
+            expectError(error.Bad, foo()) catch @panic("test failure");
             finished = true;
         }
 
@@ -1479,7 +1479,7 @@ test "handle defer interfering with return value spill" {
             baz_happened = true;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "take address of temporary async frame" {
@@ -1487,14 +1487,14 @@ test "take address of temporary async frame" {
         var global_frame: anyframe = undefined;
         var finished = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             _ = async asyncDoTheTest();
             resume global_frame;
-            expect(finished);
+            try expect(finished);
         }
 
         fn asyncDoTheTest() void {
-            expect(finishIt(&async foo(10)) == 1245);
+            expect(finishIt(&async foo(10)) == 1245) catch @panic("test failure");
             finished = true;
         }
 
@@ -1508,16 +1508,16 @@ test "take address of temporary async frame" {
             return (await frame) + 1;
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 
 test "nosuspend await" {
     const S = struct {
         var finished = false;
 
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var frame = async foo(false);
-            expect(nosuspend await frame == 42);
+            try expect(nosuspend await frame == 42);
             finished = true;
         }
 
@@ -1528,8 +1528,8 @@ test "nosuspend await" {
             return 42;
         }
     };
-    S.doTheTest();
-    expect(S.finished);
+    try S.doTheTest();
+    try expect(S.finished);
 }
 
 test "nosuspend on function calls" {
@@ -1544,8 +1544,8 @@ test "nosuspend on function calls" {
             return S0{};
         }
     };
-    expectEqual(@as(i32, 42), nosuspend S1.c().b);
-    expectEqual(@as(i32, 42), (try nosuspend S1.d()).b);
+    try expectEqual(@as(i32, 42), nosuspend S1.c().b);
+    try expectEqual(@as(i32, 42), (try nosuspend S1.d()).b);
 }
 
 test "nosuspend on async function calls" {
@@ -1561,9 +1561,9 @@ test "nosuspend on async function calls" {
         }
     };
     var frame_c = nosuspend async S1.c();
-    expectEqual(@as(i32, 42), (await frame_c).b);
+    try expectEqual(@as(i32, 42), (await frame_c).b);
     var frame_d = nosuspend async S1.d();
-    expectEqual(@as(i32, 42), (try await frame_d).b);
+    try expectEqual(@as(i32, 42), (try await frame_d).b);
 }
 
 // test "resume nosuspend async function calls" {
@@ -1582,10 +1582,10 @@ test "nosuspend on async function calls" {
 //     };
 //     var frame_c = nosuspend async S1.c();
 //     resume frame_c;
-//     expectEqual(@as(i32, 42), (await frame_c).b);
+// try expectEqual(@as(i32, 42), (await frame_c).b);
 //     var frame_d = nosuspend async S1.d();
 //     resume frame_d;
-//     expectEqual(@as(i32, 42), (try await frame_d).b);
+// try expectEqual(@as(i32, 42), (try await frame_d).b);
 // }
 
 test "nosuspend resume async function calls" {
@@ -1604,10 +1604,10 @@ test "nosuspend resume async function calls" {
     };
     var frame_c = async S1.c();
     nosuspend resume frame_c;
-    expectEqual(@as(i32, 42), (await frame_c).b);
+    try expectEqual(@as(i32, 42), (await frame_c).b);
     var frame_d = async S1.d();
     nosuspend resume frame_d;
-    expectEqual(@as(i32, 42), (try await frame_d).b);
+    try expectEqual(@as(i32, 42), (try await frame_d).b);
 }
 
 test "avoid forcing frame alignment resolution implicit cast to *c_void" {
@@ -1623,7 +1623,7 @@ test "avoid forcing frame alignment resolution implicit cast to *c_void" {
     };
     var frame = async S.foo();
     resume @ptrCast(anyframe->bool, @alignCast(@alignOf(@Frame(S.foo)), S.x));
-    expect(nosuspend await frame);
+    try expect(nosuspend await frame);
 }
 
 test "@asyncCall with pass-by-value arguments" {
@@ -1638,9 +1638,9 @@ test "@asyncCall with pass-by-value arguments" {
         pub fn f(_fill0: u64, s: ST, _fill1: u64, a: AT, _fill2: u64) callconv(.Async) void {
             // Check that the array and struct arguments passed by value don't
             // end up overflowing the adjacent fields in the frame structure.
-            expectEqual(F0, _fill0);
-            expectEqual(F1, _fill1);
-            expectEqual(F2, _fill2);
+            expectEqual(F0, _fill0) catch @panic("test failure");
+            expectEqual(F1, _fill1) catch @panic("test failure");
+            expectEqual(F2, _fill2) catch @panic("test failure");
         }
     };
 
@@ -1664,8 +1664,8 @@ test "@asyncCall with arguments having non-standard alignment" {
         pub fn f(_fill0: u32, s: struct { x: u64 align(16) }, _fill1: u64) callconv(.Async) void {
             // The compiler inserts extra alignment for s, check that the
             // generated code picks the right slot for fill1.
-            expectEqual(F0, _fill0);
-            expectEqual(F1, _fill1);
+            expectEqual(F0, _fill0) catch @panic("test failure");
+            expectEqual(F1, _fill1) catch @panic("test failure");
         }
     };