Commit 67154d233ef68d9fd63e673e63e7d66f149060a5 | zig

doc/langref.html.in+349-348

 @@ -358,7 +358,7 @@ test "comments" {
     //expect(false);
     const x = true;  // another comment
-    expect(x);
+    try expect(x);
 }
       {#code_end#}
       <p>
 @@ -718,15 +718,15 @@ const mem = @import("std").mem;
 test "string literals" {
     const bytes = "hello";
-    expect(@TypeOf(bytes) == *const [5:0]u8);
+    try expect(@TypeOf(bytes) == *const [5:0]u8);
-    expect(bytes.len == 5);
+    try expect(bytes.len == 5);
-    expect(bytes[1] == 'e');
+    try expect(bytes[1] == 'e');
-    expect(bytes[5] == 0);
+    try expect(bytes[5] == 0);
-    expect('e' == '\x65');
+    try expect('e' == '\x65');
-    expect('\u{1f4a9}' == 128169);
+    try expect('\u{1f4a9}' == 128169);
-    expect('💯' == 128175);
+    try expect('💯' == 128175);
-    expect(mem.eql(u8, "hello", "h\x65llo"));
+    try expect(mem.eql(u8, "hello", "h\x65llo"));
-    expect("\xff"[0] == 0xff); // non-UTF-8 strings are possible with \xNN notation.
+    try expect("\xff"[0] == 0xff); // non-UTF-8 strings are possible with \xNN notation.
 }
       {#code_end#}
       {#see_also|Arrays|Zig Test|Source Encoding#}
 @@ -826,7 +826,7 @@ test "var" {
     y += 1;
-    expect(y == 5679);
+    try expect(y == 5679);
 }
       {#code_end#}
       <p>Variables must be initialized:</p>
 @@ -845,7 +845,7 @@ const expect = @import("std").testing.expect;
 test "init with undefined" {
     var x: i32 = undefined;
     x = 1;
-    expect(x == 1);
+    try expect(x == 1);
 }
       {#code_end#}
       <p>
 @@ -887,8 +887,8 @@ var y: i32 = add(10, x);
 const x: i32 = add(12, 34);
 test "global variables" {
-    expect(x == 46);
+    try expect(x == 46);
-    expect(y == 56);
+    try expect(y == 56);
 }
 fn add(a: i32, b: i32) i32 {
 @@ -906,8 +906,8 @@ const std = @import("std");
 const expect = std.testing.expect;
 test "namespaced global variable" {
-    expect(foo() == 1235);
+    try expect(foo() == 1235);
-    expect(foo() == 1236);
+    try expect(foo() == 1236);
 }
 fn foo() i32 {
 @@ -985,8 +985,8 @@ test "comptime vars" {
     x += 1;
     y += 1;
-    expect(x == 2);
+    try expect(x == 2);
-    expect(y == 2);
+    try expect(y == 2);
     if (y != 2) {
         // This compile error never triggers because y is a comptime variable,
 @@ -1777,6 +1777,7 @@ orelse catch
       {#header_open|Arrays#}
       {#code_begin|test|arrays#}
 const expect = @import("std").testing.expect;
+const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
 // array literal
 @@ -1784,14 +1785,14 @@ const message = [_]u8{ 'h', 'e', 'l', 'l', 'o' };
 // get the size of an array
 comptime {
-    expect(message.len == 5);
+    assert(message.len == 5);
 }
 // A string literal is a single-item pointer to an array literal.
 const same_message = "hello";
 comptime {
-    expect(mem.eql(u8, &message, same_message));
+    assert(mem.eql(u8, &message, same_message));
 }
 test "iterate over an array" {
 @@ -1799,7 +1800,7 @@ test "iterate over an array" {
     for (message) |byte| {
         sum += byte;
     }
-    expect(sum == 'h' + 'e' + 'l' * 2 + 'o');
+    try expect(sum == 'h' + 'e' + 'l' * 2 + 'o');
 }
 // modifiable array
 @@ -1809,8 +1810,8 @@ test "modify an array" {
     for (some_integers) |*item, i| {
         item.* = @intCast(i32, i);
     }
-    expect(some_integers[10] == 10);
+    try expect(some_integers[10] == 10);
-    expect(some_integers[99] == 99);
+    try expect(some_integers[99] == 99);
 }
 // array concatenation works if the values are known
 @@ -1819,7 +1820,7 @@ const part_one = [_]i32{ 1, 2, 3, 4 };
 const part_two = [_]i32{ 5, 6, 7, 8 };
 const all_of_it = part_one ++ part_two;
 comptime {
-    expect(mem.eql(i32, &all_of_it, &[_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }));
+    assert(mem.eql(i32, &all_of_it, &[_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }));
 }
 // remember that string literals are arrays
 @@ -1827,21 +1828,21 @@ const hello = "hello";
 const world = "world";
 const hello_world = hello ++ " " ++ world;
 comptime {
-    expect(mem.eql(u8, hello_world, "hello world"));
+    assert(mem.eql(u8, hello_world, "hello world"));
 }
 // ** does repeating patterns
 const pattern = "ab" ** 3;
 comptime {
-    expect(mem.eql(u8, pattern, "ababab"));
+    assert(mem.eql(u8, pattern, "ababab"));
 }
 // initialize an array to zero
 const all_zero = [_]u16{0} ** 10;
 comptime {
-    expect(all_zero.len == 10);
+    assert(all_zero.len == 10);
-    expect(all_zero[5] == 0);
+    assert(all_zero[5] == 0);
 }
 // use compile-time code to initialize an array
 @@ -1861,8 +1862,8 @@ const Point = struct {
 };
 test "compile-time array initialization" {
-    expect(fancy_array[4].x == 4);
+    try expect(fancy_array[4].x == 4);
-    expect(fancy_array[4].y == 8);
+    try expect(fancy_array[4].y == 8);
 }
 // call a function to initialize an array
 @@ -1874,9 +1875,9 @@ fn makePoint(x: i32) Point {
     };
 }
 test "array initialization with function calls" {
-    expect(more_points[4].x == 3);
+    try expect(more_points[4].x == 3);
-    expect(more_points[4].y == 6);
+    try expect(more_points[4].y == 6);
-    expect(more_points.len == 10);
+    try expect(more_points.len == 10);
 }
       {#code_end#}
       {#see_also|for|Slices#}
 @@ -1890,10 +1891,10 @@ const expect = std.testing.expect;
 test "anonymous list literal syntax" {
     var array: [4]u8 = .{11, 22, 33, 44};
-    expect(array[0] == 11);
+    try expect(array[0] == 11);
-    expect(array[1] == 22);
+    try expect(array[1] == 22);
-    expect(array[2] == 33);
+    try expect(array[2] == 33);
-    expect(array[3] == 44);
+    try expect(array[3] == 44);
 }
       {#code_end#}
       <p>
 @@ -1905,15 +1906,15 @@ const std = @import("std");
 const expect = std.testing.expect;
 test "fully anonymous list literal" {
-    dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi"});
+    try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi"});
 }
-fn dump(args: anytype) void {
+fn dump(args: anytype) !void {
-    expect(args.@"0" == 1234);
+    try expect(args.@"0" == 1234);
-    expect(args.@"1" == 12.34);
+    try expect(args.@"1" == 12.34);
-    expect(args.@"2");
+    try expect(args.@"2");
-    expect(args.@"3"[0] == 'h');
+    try expect(args.@"3"[0] == 'h');
-    expect(args.@"3"[1] == 'i');
+    try expect(args.@"3"[1] == 'i');
 }
       {#code_end#}
       {#header_close#}
 @@ -1934,13 +1935,13 @@ const mat4x4 = [4][4]f32{
 };
 test "multidimensional arrays" {
     // Access the 2D array by indexing the outer array, and then the inner array.
-    expect(mat4x4[1][1] == 1.0);
+    try expect(mat4x4[1][1] == 1.0);
     // Here we iterate with for loops.
     for (mat4x4) |row, row_index| {
         for (row) |cell, column_index| {
             if (row_index == column_index) {
-                expect(cell == 1.0);
+                try expect(cell == 1.0);
             }
         }
     }
 @@ -1960,9 +1961,9 @@ const expect = std.testing.expect;
 test "null terminated array" {
     const array = [_:0]u8 {1, 2, 3, 4};
-    expect(@TypeOf(array) == [4:0]u8);
+    try expect(@TypeOf(array) == [4:0]u8);
-    expect(array.len == 4);
+    try expect(array.len == 4);
-    expect(array[4] == 0);
+    try expect(array[4] == 0);
 }
       {#code_end#}
       {#see_also|Sentinel-Terminated Pointers|Sentinel-Terminated Slices#}
 @@ -2040,17 +2041,17 @@ test "address of syntax" {
     const x_ptr = &x;
     // Dereference a pointer:
-    expect(x_ptr.* == 1234);
+    try expect(x_ptr.* == 1234);
     // When you get the address of a const variable, you get a const single-item pointer.
-    expect(@TypeOf(x_ptr) == *const i32);
+    try expect(@TypeOf(x_ptr) == *const i32);
     // If you want to mutate the value, you'd need an address of a mutable variable:
     var y: i32 = 5678;
     const y_ptr = &y;
-    expect(@TypeOf(y_ptr) == *i32);
+    try expect(@TypeOf(y_ptr) == *i32);
     y_ptr.* += 1;
-    expect(y_ptr.* == 5679);
+    try expect(y_ptr.* == 5679);
 }
 test "pointer array access" {
 @@ -2059,11 +2060,11 @@ test "pointer array access" {
     // does not support pointer arithmetic.
     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     const ptr = &array[2];
-    expect(@TypeOf(ptr) == *u8);
+    try expect(@TypeOf(ptr) == *u8);
-    expect(array[2] == 3);
+    try expect(array[2] == 3);
     ptr.* += 1;
-    expect(array[2] == 4);
+    try expect(array[2] == 4);
 }
       {#code_end#}
       <p>
 @@ -2081,11 +2082,11 @@ const expect = @import("std").testing.expect;
 test "pointer slicing" {
     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     const slice = array[2..4];
-    expect(slice.len == 2);
+    try expect(slice.len == 2);
-    expect(array[3] == 4);
+    try expect(array[3] == 4);
     slice[1] += 1;
-    expect(array[3] == 5);
+    try expect(array[3] == 5);
 }
       {#code_end#}
       <p>Pointers work at compile-time too, as long as the code does not depend on
 @@ -2099,7 +2100,7 @@ test "comptime pointers" {
         const ptr = &x;
         ptr.* += 1;
         x += 1;
-        expect(ptr.* == 3);
+        try expect(ptr.* == 3);
     }
 }
       {#code_end#}
 @@ -2111,8 +2112,8 @@ const expect = @import("std").testing.expect;
 test "@ptrToInt and @intToPtr" {
     const ptr = @intToPtr(*i32, 0xdeadbee0);
     const addr = @ptrToInt(ptr);
-    expect(@TypeOf(addr) == usize);
+    try expect(@TypeOf(addr) == usize);
-    expect(addr == 0xdeadbee0);
+    try expect(addr == 0xdeadbee0);
 }
       {#code_end#}
       <p>Zig is able to preserve memory addresses in comptime code, as long as
 @@ -2126,8 +2127,8 @@ test "comptime @intToPtr" {
         // ptr is never dereferenced.
         const ptr = @intToPtr(*i32, 0xdeadbee0);
         const addr = @ptrToInt(ptr);
-        expect(@TypeOf(addr) == usize);
+        try expect(@TypeOf(addr) == usize);
-        expect(addr == 0xdeadbee0);
+        try expect(addr == 0xdeadbee0);
     }
 }
       {#code_end#}
 @@ -2142,7 +2143,7 @@ const expect = @import("std").testing.expect;
 test "volatile" {
     const mmio_ptr = @intToPtr(*volatile u8, 0x12345678);
-    expect(@TypeOf(mmio_ptr) == *volatile u8);
+    try expect(@TypeOf(mmio_ptr) == *volatile u8);
 }
       {#code_end#}
       <p>
 @@ -2163,20 +2164,20 @@ const expect = std.testing.expect;
 test "pointer casting" {
     const bytes align(@alignOf(u32)) = [_]u8{ 0x12, 0x12, 0x12, 0x12 };
     const u32_ptr = @ptrCast(*const u32, &bytes);
-    expect(u32_ptr.* == 0x12121212);
+    try expect(u32_ptr.* == 0x12121212);
     // Even this example is contrived - there are better ways to do the above than
     // pointer casting. For example, using a slice narrowing cast:
     const u32_value = std.mem.bytesAsSlice(u32, bytes[0..])[0];
-    expect(u32_value == 0x12121212);
+    try expect(u32_value == 0x12121212);
     // And even another way, the most straightforward way to do it:
-    expect(@bitCast(u32, bytes) == 0x12121212);
+    try expect(@bitCast(u32, bytes) == 0x12121212);
 }
 test "pointer child type" {
     // pointer types have a `child` field which tells you the type they point to.
-    expect(@typeInfo(*u32).Pointer.child == u32);
+    try expect(@typeInfo(*u32).Pointer.child == u32);
 }
       {#code_end#}
       {#header_open|Alignment#}
 @@ -2201,10 +2202,10 @@ const expect = std.testing.expect;
 test "variable alignment" {
     var x: i32 = 1234;
     const align_of_i32 = @alignOf(@TypeOf(x));
-    expect(@TypeOf(&x) == *i32);
+    try expect(@TypeOf(&x) == *i32);
-    expect(*i32 == *align(align_of_i32) i32);
+    try expect(*i32 == *align(align_of_i32) i32);
     if (std.Target.current.cpu.arch == .x86_64) {
-        expect(@typeInfo(*i32).Pointer.alignment == 4);
+        try expect(@typeInfo(*i32).Pointer.alignment == 4);
     }
 }
       {#code_end#}
 @@ -2222,11 +2223,11 @@ const expect = @import("std").testing.expect;
 var foo: u8 align(4) = 100;
 test "global variable alignment" {
-    expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
+    try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
-    expect(@TypeOf(&foo) == *align(4) u8);
+    try expect(@TypeOf(&foo) == *align(4) u8);
     const as_pointer_to_array: *[1]u8 = &foo;
     const as_slice: []u8 = as_pointer_to_array;
-    expect(@TypeOf(as_slice) == []align(4) u8);
+    try expect(@TypeOf(as_slice) == []align(4) u8);
 }
 fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; }
 @@ -2234,9 +2235,9 @@ fn noop1() align(1) void {}
 fn noop4() align(4) void {}
 test "function alignment" {
-    expect(derp() == 1234);
+    try expect(derp() == 1234);
-    expect(@TypeOf(noop1) == fn() align(1) void);
+    try expect(@TypeOf(noop1) == fn() align(1) void);
-    expect(@TypeOf(noop4) == fn() align(4) void);
+    try expect(@TypeOf(noop4) == fn() align(4) void);
     noop1();
     noop4();
 }
 @@ -2253,7 +2254,7 @@ const std = @import("std");
 test "pointer alignment safety" {
     var array align(4) = [_]u32{ 0x11111111, 0x11111111 };
     const bytes = std.mem.sliceAsBytes(array[0..]);
-    std.testing.expect(foo(bytes) == 0x11111111);
+    try std.testing.expect(foo(bytes) == 0x11111111);
 }
 fn foo(bytes: []u8) u32 {
     const slice4 = bytes[1..5];
 @@ -2279,7 +2280,7 @@ const expect = std.testing.expect;
 test "allowzero" {
     var zero: usize = 0;
     var ptr = @intToPtr(*allowzero i32, zero);
-    expect(@ptrToInt(ptr) == 0);
+    try expect(@ptrToInt(ptr) == 0);
 }
       {#code_end#}
       {#header_close#}
 @@ -2321,14 +2322,14 @@ test "basic slices" {
     // Both can be accessed with the `len` field.
     var known_at_runtime_zero: usize = 0;
     const slice = array[known_at_runtime_zero..array.len];
-    expect(&slice[0] == &array[0]);
+    try expect(&slice[0] == &array[0]);
-    expect(slice.len == array.len);
+    try expect(slice.len == array.len);
     // Using the address-of operator on a slice gives a single-item pointer,
     // while using the `ptr` field gives a many-item pointer.
-    expect(@TypeOf(slice.ptr) == [*]i32);
+    try expect(@TypeOf(slice.ptr) == [*]i32);
-    expect(@TypeOf(&slice[0]) == *i32);
+    try expect(@TypeOf(&slice[0]) == *i32);
-    expect(@ptrToInt(slice.ptr) == @ptrToInt(&slice[0]));
+    try expect(@ptrToInt(slice.ptr) == @ptrToInt(&slice[0]));
     // Slices have array bounds checking. If you try to access something out
     // of bounds, you'll get a safety check failure:
 @@ -2362,7 +2363,7 @@ test "using slices for strings" {
     // Generally, you can use UTF-8 and not worry about whether something is a
     // string. If you don't need to deal with individual characters, no need
     // to decode.
-    expect(mem.eql(u8, hello_world, "hello 世界"));
+    try expect(mem.eql(u8, hello_world, "hello 世界"));
 }
 test "slice pointer" {
 @@ -2372,16 +2373,16 @@ test "slice pointer" {
     // You can use slicing syntax to convert a pointer into a slice:
     const slice = ptr[0..5];
     slice[2] = 3;
-    expect(slice[2] == 3);
+    try expect(slice[2] == 3);
     // The slice is mutable because we sliced a mutable pointer.
     // Furthermore, it is actually a pointer to an array, since the start
     // and end indexes were both comptime-known.
-    expect(@TypeOf(slice) == *[5]u8);
+    try expect(@TypeOf(slice) == *[5]u8);
     // You can also slice a slice:
     const slice2 = slice[2..3];
-    expect(slice2.len == 1);
+    try expect(slice2.len == 1);
-    expect(slice2[0] == 3);
+    try expect(slice2[0] == 3);
 }
       {#code_end#}
       {#see_also|Pointers|for|Arrays#}
 @@ -2400,8 +2401,8 @@ const expect = std.testing.expect;
 test "null terminated slice" {
     const slice: [:0]const u8 = "hello";
-    expect(slice.len == 5);
+    try expect(slice.len == 5);
-    expect(slice[5] == 0);
+    try expect(slice[5] == 0);
 }
       {#code_end#}
       {#see_also|Sentinel-Terminated Pointers|Sentinel-Terminated Arrays#}
 @@ -2463,12 +2464,12 @@ const expect = @import("std").testing.expect;
 test "dot product" {
     const v1 = Vec3.init(1.0, 0.0, 0.0);
     const v2 = Vec3.init(0.0, 1.0, 0.0);
-    expect(v1.dot(v2) == 0.0);
+    try expect(v1.dot(v2) == 0.0);
     // Other than being available to call with dot syntax, struct methods are
     // not special. You can reference them as any other declaration inside
     // the struct:
-    expect(Vec3.dot(v1, v2) == 0.0);
+    try expect(Vec3.dot(v1, v2) == 0.0);
 }
 // Structs can have global declarations.
 @@ -2477,8 +2478,8 @@ const Empty = struct {
     pub const PI = 3.14;
 };
 test "struct namespaced variable" {
-    expect(Empty.PI == 3.14);
+    try expect(Empty.PI == 3.14);
-    expect(@sizeOf(Empty) == 0);
+    try expect(@sizeOf(Empty) == 0);
     // you can still instantiate an empty struct
     const does_nothing = Empty {};
 @@ -2496,7 +2497,7 @@ test "field parent pointer" {
         .y = 0.5678,
     };
     setYBasedOnX(&point.x, 0.9);
-    expect(point.y == 0.9);
+    try expect(point.y == 0.9);
 }
 // You can return a struct from a function. This is how we do generics
 @@ -2518,19 +2519,19 @@ fn LinkedList(comptime T: type) type {
 test "linked list" {
     // Functions called at compile-time are memoized. This means you can
     // do this:
-    expect(LinkedList(i32) == LinkedList(i32));
+    try expect(LinkedList(i32) == LinkedList(i32));
     var list = LinkedList(i32) {
         .first = null,
         .last = null,
         .len = 0,
     };
-    expect(list.len == 0);
+    try expect(list.len == 0);
     // Since types are first class values you can instantiate the type
     // by assigning it to a variable:
     const ListOfInts = LinkedList(i32);
-    expect(ListOfInts == LinkedList(i32));
+    try expect(ListOfInts == LinkedList(i32));
     var node = ListOfInts.Node {
         .prev = null,
 @@ -2542,7 +2543,7 @@ test "linked list" {
         .last = &node,
         .len = 1,
     };
-    expect(list2.first.?.data == 1234);
+    try expect(list2.first.?.data == 1234);
 }
       {#code_end#}
 @@ -2615,25 +2616,25 @@ const Divided = packed struct {
 };
 test "@bitCast between packed structs" {
-    doTheTest();
+    try doTheTest();
-    comptime doTheTest();
+    comptime try doTheTest();
 }
-fn doTheTest() void {
+fn doTheTest() !void {
-    expect(@sizeOf(Full) == 2);
+    try expect(@sizeOf(Full) == 2);
-    expect(@sizeOf(Divided) == 2);
+    try expect(@sizeOf(Divided) == 2);
     var full = Full{ .number = 0x1234 };
     var divided = @bitCast(Divided, full);
     switch (builtin.endian) {
         .Big => {
-            expect(divided.half1 == 0x12);
+            try expect(divided.half1 == 0x12);
-            expect(divided.quarter3 == 0x3);
+            try expect(divided.quarter3 == 0x3);
-            expect(divided.quarter4 == 0x4);
+            try expect(divided.quarter4 == 0x4);
         },
         .Little => {
-            expect(divided.half1 == 0x34);
+            try expect(divided.half1 == 0x34);
-            expect(divided.quarter3 == 0x2);
+            try expect(divided.quarter3 == 0x2);
-            expect(divided.quarter4 == 0x1);
+            try expect(divided.quarter4 == 0x1);
         },
     }
 }
 @@ -2659,7 +2660,7 @@ var foo = BitField{
 test "pointer to non-byte-aligned field" {
     const ptr = &foo.b;
-    expect(ptr.* == 2);
+    try expect(ptr.* == 2);
 }
       {#code_end#}
       <p>
 @@ -2683,7 +2684,7 @@ var bit_field = BitField{
 };
 test "pointer to non-bit-aligned field" {
-    expect(bar(&bit_field.b) == 2);
+    try expect(bar(&bit_field.b) == 2);
 }
 fn bar(x: *const u3) u3 {
 @@ -2714,8 +2715,8 @@ var bit_field = BitField{
 };
 test "pointer to non-bit-aligned field" {
-    expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.b));
+    try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.b));
-    expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c));
+    try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c));
 }
       {#code_end#}
       <p>
 @@ -2733,13 +2734,13 @@ const BitField = packed struct {
 test "pointer to non-bit-aligned field" {
     comptime {
-        expect(@bitOffsetOf(BitField, "a") == 0);
+        try expect(@bitOffsetOf(BitField, "a") == 0);
-        expect(@bitOffsetOf(BitField, "b") == 3);
+        try expect(@bitOffsetOf(BitField, "b") == 3);
-        expect(@bitOffsetOf(BitField, "c") == 6);
+        try expect(@bitOffsetOf(BitField, "c") == 6);
-        expect(@byteOffsetOf(BitField, "a") == 0);
+        try expect(@byteOffsetOf(BitField, "a") == 0);
-        expect(@byteOffsetOf(BitField, "b") == 0);
+        try expect(@byteOffsetOf(BitField, "b") == 0);
-        expect(@byteOffsetOf(BitField, "c") == 0);
+        try expect(@byteOffsetOf(BitField, "c") == 0);
     }
 }
       {#code_end#}
 @@ -2776,9 +2777,9 @@ test "aligned struct fields" {
     };
     var foo = S{ .a = 1, .b = 2 };
-    expectEqual(64, @alignOf(S));
+    try expectEqual(64, @alignOf(S));
-    expectEqual(*align(2) u32, @TypeOf(&foo.a));
+    try expectEqual(*align(2) u32, @TypeOf(&foo.a));
-    expectEqual(*align(64) u32, @TypeOf(&foo.b));
+    try expectEqual(*align(64) u32, @TypeOf(&foo.b));
 }
       {#code_end#}
       <p>
 @@ -2834,8 +2835,8 @@ test "anonymous struct literal" {
         .x = 13,
         .y = 67,
     };
-    expect(pt.x == 13);
+    try expect(pt.x == 13);
-    expect(pt.y == 67);
+    try expect(pt.y == 67);
 }
       {#code_end#}
       <p>
 @@ -2847,7 +2848,7 @@ const std = @import("std");
 const expect = std.testing.expect;
 test "fully anonymous struct" {
-    dump(.{
+    try dump(.{
         .int = @as(u32, 1234),
         .float = @as(f64, 12.34),
         .b = true,
 @@ -2855,12 +2856,12 @@ test "fully anonymous struct" {
     });
 }
-fn dump(args: anytype) void {
+fn dump(args: anytype) !void {
-    expect(args.int == 1234);
+    try expect(args.int == 1234);
-    expect(args.float == 12.34);
+    try expect(args.float == 12.34);
-    expect(args.b);
+    try expect(args.b);
-    expect(args.s[0] == 'h');
+    try expect(args.s[0] == 'h');
-    expect(args.s[1] == 'i');
+    try expect(args.s[1] == 'i');
 }
       {#code_end#}
       <p>
 @@ -2884,14 +2885,14 @@ test "tuple" {
         true,
         "hi",
     } ++ .{false} ** 2;
-    expect(values[0] == 1234);
+    try expect(values[0] == 1234);
-    expect(values[4] == false);
+    try expect(values[4] == false);
     inline for (values) |v, i| {
         if (i != 2) continue;
-        expect(v);
+        try expect(v);
     }
-    expect(values.len == 6);
+    try expect(values.len == 6);
-    expect(values.@"3"[0] == 'h');
+    try expect(values.@"3"[0] == 'h');
 }
       {#code_end#}
       {#header_close#}
 @@ -2922,9 +2923,9 @@ const Value = enum(u2) {
 // Now you can cast between u2 and Value.
 // The ordinal value starts from 0, counting up for each member.
 test "enum ordinal value" {
-    expect(@enumToInt(Value.zero) == 0);
+    try expect(@enumToInt(Value.zero) == 0);
-    expect(@enumToInt(Value.one) == 1);
+    try expect(@enumToInt(Value.one) == 1);
-    expect(@enumToInt(Value.two) == 2);
+    try expect(@enumToInt(Value.two) == 2);
 }
 // You can override the ordinal value for an enum.
 @@ -2934,9 +2935,9 @@ const Value2 = enum(u32) {
     million = 1000000,
 };
 test "set enum ordinal value" {
-    expect(@enumToInt(Value2.hundred) == 100);
+    try expect(@enumToInt(Value2.hundred) == 100);
-    expect(@enumToInt(Value2.thousand) == 1000);
+    try expect(@enumToInt(Value2.thousand) == 1000);
-    expect(@enumToInt(Value2.million) == 1000000);
+    try expect(@enumToInt(Value2.million) == 1000000);
 }
 // Enums can have methods, the same as structs and unions.
 @@ -2954,7 +2955,7 @@ const Suit = enum {
 };
 test "enum method" {
     const p = Suit.spades;
-    expect(!p.isClubs());
+    try expect(!p.isClubs());
 }
 // An enum variant of different types can be switched upon.
 @@ -2970,7 +2971,7 @@ test "enum variant switch" {
         Foo.number => "this is a number",
         Foo.none => "this is a none",
     };
-    expect(mem.eql(u8, what_is_it, "this is a number"));
+    try expect(mem.eql(u8, what_is_it, "this is a number"));
 }
 // @typeInfo can be used to access the integer tag type of an enum.
 @@ -2981,18 +2982,18 @@ const Small = enum {
     four,
 };
 test "std.meta.Tag" {
-    expect(@typeInfo(Small).Enum.tag_type == u2);
+    try expect(@typeInfo(Small).Enum.tag_type == u2);
 }
 // @typeInfo tells us the field count and the fields names:
 test "@typeInfo" {
-    expect(@typeInfo(Small).Enum.fields.len == 4);
+    try expect(@typeInfo(Small).Enum.fields.len == 4);
-    expect(mem.eql(u8, @typeInfo(Small).Enum.fields[1].name, "two"));
+    try expect(mem.eql(u8, @typeInfo(Small).Enum.fields[1].name, "two"));
 }
 // @tagName gives a []const u8 representation of an enum value:
 test "@tagName" {
-    expect(mem.eql(u8, @tagName(Small.three), "three"));
+    try expect(mem.eql(u8, @tagName(Small.three), "three"));
 }
       {#code_end#}
       {#see_also|@typeInfo|@tagName|@sizeOf#}
 @@ -3027,7 +3028,7 @@ test "packed enum" {
         two,
         three,
     };
-    std.testing.expect(@sizeOf(Number) == @sizeOf(u8));
+    try std.testing.expect(@sizeOf(Number) == @sizeOf(u8));
 }
       {#code_end#}
       <p>This makes the enum eligible to be in a {#link|packed struct#}.</p>
 @@ -3050,7 +3051,7 @@ const Color = enum {
 test "enum literals" {
     const color1: Color = .auto;
     const color2 = Color.auto;
-    expect(color1 == color2);
+    try expect(color1 == color2);
 }
 test "switch using enum literals" {
 @@ -3060,7 +3061,7 @@ test "switch using enum literals" {
         .on => true,
         .off => false,
     };
-    expect(result);
+    try expect(result);
 }
       {#code_end#}
       {#header_close#}
 @@ -3096,12 +3097,12 @@ test "switch on non-exhaustive enum" {
         .three => false,
         _ => false,
     };
-    expect(result);
+    try expect(result);
     const is_one = switch (number) {
         .one => true,
         else => false,
     };
-    expect(is_one);
+    try expect(is_one);
 }
       {#code_end#}
       {#header_close#}
 @@ -3141,9 +3142,9 @@ const Payload = union {
 };
 test "simple union" {
     var payload = Payload{ .int = 1234 };
-    expect(payload.int == 1234);
+    try expect(payload.int == 1234);
     payload = Payload{ .float = 12.34 };
-    expect(payload.float == 12.34);
+    try expect(payload.float == 12.34);
 }
       {#code_end#}
       <p>
 @@ -3174,24 +3175,24 @@ const ComplexType = union(ComplexTypeTag) {
 test "switch on tagged union" {
     const c = ComplexType{ .ok = 42 };
-    expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
+    try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
     switch (c) {
-        ComplexTypeTag.ok => |value| expect(value == 42),
+        ComplexTypeTag.ok => |value| try expect(value == 42),
         ComplexTypeTag.not_ok => unreachable,
     }
 }
 test "get tag type" {
-    expect(std.meta.Tag(ComplexType) == ComplexTypeTag);
+    try expect(std.meta.Tag(ComplexType) == ComplexTypeTag);
 }
 test "coerce to enum" {
     const c1 = ComplexType{ .ok = 42 };
     const c2 = ComplexType.not_ok;
-    expect(c1 == .ok);
+    try expect(c1 == .ok);
-    expect(c2 == .not_ok);
+    try expect(c2 == .not_ok);
 }
       {#code_end#}
       <p>In order to modify the payload of a tagged union in a switch expression,
 @@ -3212,14 +3213,14 @@ const ComplexType = union(ComplexTypeTag) {
 test "modify tagged union in switch" {
     var c = ComplexType{ .ok = 42 };
-    expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
+    try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
     switch (c) {
         ComplexTypeTag.ok => |*value| value.* += 1,
         ComplexTypeTag.not_ok => unreachable,
     }
-    expect(c.ok == 43);
+    try expect(c.ok == 43);
 }
       {#code_end#}
       <p>
 @@ -3250,8 +3251,8 @@ test "union method" {
     var v1 = Variant{ .int = 1 };
     var v2 = Variant{ .boolean = false };
-    expect(v1.truthy());
+    try expect(v1.truthy());
-    expect(!v2.truthy());
+    try expect(!v2.truthy());
 }
       {#code_end#}
       <p>
 @@ -3268,7 +3269,7 @@ const Small2 = union(enum) {
     c: u8,
 };
 test "@tagName" {
-    expect(std.mem.eql(u8, @tagName(Small2.a), "a"));
+    try expect(std.mem.eql(u8, @tagName(Small2.a), "a"));
 }
       {#code_end#}
       {#header_close#}
 @@ -3301,8 +3302,8 @@ const Number = union {
 test "anonymous union literal syntax" {
     var i: Number = .{.int = 42};
     var f = makeNumber();
-    expect(i.int == 42);
+    try expect(i.int == 42);
-    expect(f.float == 12.34);
+    try expect(f.float == 12.34);
 }
 fn makeNumber() Number {
 @@ -3364,8 +3365,8 @@ test "labeled break from labeled block expression" {
         y += 1;
         break :blk y;
     };
-    expect(x == 124);
+    try expect(x == 124);
-    expect(y == 124);
+    try expect(y == 124);
 }
       {#code_end#}
       <p>Here, {#syntax#}blk{#endsyntax#} can be any name.</p>
 @@ -3443,7 +3444,7 @@ test "switch simple" {
         else => 9,
     };
-    expect(b == 1);
+    try expect(b == 1);
 }
 // Switch expressions can be used outside a function:
 @@ -3506,8 +3507,8 @@ test "switch on tagged union" {
         Item.d => 8,
     };
-    expect(b == 6);
+    try expect(b == 6);
-    expect(a.c.x == 2);
+    try expect(a.c.x == 2);
 }
       {#code_end#}
       {#see_also|comptime|enum|@compileError|Compile Variables#}
 @@ -3556,7 +3557,7 @@ test "enum literals with switch" {
         .on => false,
         .off => true,
     };
-    expect(result);
+    try expect(result);
 }
       {#code_end#}
       {#header_close#}
 @@ -3575,7 +3576,7 @@ test "while basic" {
     while (i < 10) {
         i += 1;
     }
-    expect(i == 10);
+    try expect(i == 10);
 }
       {#code_end#}
       <p>
 @@ -3591,7 +3592,7 @@ test "while break" {
             break;
         i += 1;
     }
-    expect(i == 10);
+    try expect(i == 10);
 }
       {#code_end#}
       <p>
 @@ -3608,7 +3609,7 @@ test "while continue" {
             continue;
         break;
     }
-    expect(i == 10);
+    try expect(i == 10);
 }
       {#code_end#}
       <p>
 @@ -3621,7 +3622,7 @@ const expect = @import("std").testing.expect;
 test "while loop continue expression" {
     var i: usize = 0;
     while (i < 10) : (i += 1) {}
-    expect(i == 10);
+    try expect(i == 10);
 }
 test "while loop continue expression, more complicated" {
 @@ -3629,7 +3630,7 @@ test "while loop continue expression, more complicated" {
     var j: usize = 1;
     while (i * j < 2000) : ({ i *= 2; j *= 3; }) {
         const my_ij = i * j;
-        expect(my_ij < 2000);
+        try expect(my_ij < 2000);
     }
 }
       {#code_end#}
 @@ -3648,8 +3649,8 @@ test "while loop continue expression, more complicated" {
 const expect = @import("std").testing.expect;
 test "while else" {
-    expect(rangeHasNumber(0, 10, 5));
+    try expect(rangeHasNumber(0, 10, 5));
-    expect(!rangeHasNumber(0, 10, 15));
+    try expect(!rangeHasNumber(0, 10, 15));
 }
 fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {
 @@ -3706,14 +3707,14 @@ test "while null capture" {
     while (eventuallyNullSequence()) |value| {
         sum1 += value;
     }
-    expect(sum1 == 3);
+    try expect(sum1 == 3);
     var sum2: u32 = 0;
     numbers_left = 3;
     while (eventuallyNullSequence()) |value| {
         sum2 += value;
     } else {
-        expect(sum2 == 3);
+        try expect(sum2 == 3);
     }
 }
 @@ -3748,7 +3749,7 @@ test "while error union capture" {
     while (eventuallyErrorSequence()) |value| {
         sum1 += value;
     } else |err| {
-        expect(err == error.ReachedZero);
+        try expect(err == error.ReachedZero);
     }
 }
 @@ -3784,7 +3785,7 @@ test "inline while loop" {
         };
         sum += typeNameLength(T);
     }
-    expect(sum == 9);
+    try expect(sum == 9);
 }
 fn typeNameLength(comptime T: type) usize {
 @@ -3819,22 +3820,22 @@ test "for basics" {
         }
         sum += value;
     }
-    expect(sum == 16);
+    try expect(sum == 16);
     // To iterate over a portion of a slice, reslice.
     for (items[0..1]) |value| {
         sum += value;
     }
-    expect(sum == 20);
+    try expect(sum == 20);
     // To access the index of iteration, specify a second capture value.
     // This is zero-indexed.
     var sum2: i32 = 0;
     for (items) |value, i| {
-        expect(@TypeOf(i) == usize);
+        try expect(@TypeOf(i) == usize);
         sum2 += @intCast(i32, i);
     }
-    expect(sum2 == 10);
+    try expect(sum2 == 10);
 }
 test "for reference" {
 @@ -3846,9 +3847,9 @@ test "for reference" {
         value.* += 1;
     }
-    expect(items[0] == 4);
+    try expect(items[0] == 4);
-    expect(items[1] == 5);
+    try expect(items[1] == 5);
-    expect(items[2] == 3);
+    try expect(items[2] == 3);
 }
 test "for else" {
 @@ -3863,10 +3864,10 @@ test "for else" {
             sum += value.?;
         }
     } else blk: {
-        expect(sum == 12);
+        try expect(sum == 12);
         break :blk sum;
     };
-    expect(result == 12);
+    try expect(result == 12);
 }
       {#code_end#}
       {#header_open|Labeled for#}
 @@ -3884,7 +3885,7 @@ test "nested break" {
             break :outer;
         }
     }
-    expect(count == 1);
+    try expect(count == 1);
 }
 test "nested continue" {
 @@ -3896,7 +3897,7 @@ test "nested continue" {
         }
     }
-    expect(count == 8);
+    try expect(count == 8);
 }
       {#code_end#}
       {#header_close#}
 @@ -3923,7 +3924,7 @@ test "inline for loop" {
         };
         sum += typeNameLength(T);
     }
-    expect(sum == 9);
+    try expect(sum == 9);
 }
 fn typeNameLength(comptime T: type) usize {
 @@ -3956,7 +3957,7 @@ test "if expression" {
     const a: u32 = 5;
     const b: u32 = 4;
     const result = if (a != b) 47 else 3089;
-    expect(result == 47);
+    try expect(result == 47);
 }
 test "if boolean" {
 @@ -3964,7 +3965,7 @@ test "if boolean" {
     const a: u32 = 5;
     const b: u32 = 4;
     if (a != b) {
-        expect(true);
+        try expect(true);
     } else if (a == 9) {
         unreachable;
     } else {
 @@ -3977,7 +3978,7 @@ test "if optional" {
     const a: ?u32 = 0;
     if (a) |value| {
-        expect(value == 0);
+        try expect(value == 0);
     } else {
         unreachable;
     }
 @@ -3986,17 +3987,17 @@ test "if optional" {
     if (b) |value| {
         unreachable;
     } else {
-        expect(true);
+        try expect(true);
     }
     // The else is not required.
     if (a) |value| {
-        expect(value == 0);
+        try expect(value == 0);
     }
     // To test against null only, use the binary equality operator.
     if (b == null) {
-        expect(true);
+        try expect(true);
     }
     // Access the value by reference using a pointer capture.
 @@ -4006,7 +4007,7 @@ test "if optional" {
     }
     if (c) |value| {
-        expect(value == 2);
+        try expect(value == 2);
     } else {
         unreachable;
     }
 @@ -4018,7 +4019,7 @@ test "if error union" {
     const a: anyerror!u32 = 0;
     if (a) |value| {
-        expect(value == 0);
+        try expect(value == 0);
     } else |err| {
         unreachable;
     }
 @@ -4027,17 +4028,17 @@ test "if error union" {
     if (b) |value| {
         unreachable;
     } else |err| {
-        expect(err == error.BadValue);
+        try expect(err == error.BadValue);
     }
     // The else and |err| capture is strictly required.
     if (a) |value| {
-        expect(value == 0);
+        try expect(value == 0);
     } else |_| {}
     // To check only the error value, use an empty block expression.
     if (b) |_| {} else |err| {
-        expect(err == error.BadValue);
+        try expect(err == error.BadValue);
     }
     // Access the value by reference using a pointer capture.
 @@ -4049,7 +4050,7 @@ test "if error union" {
     }
     if (c) |value| {
-        expect(value == 9);
+        try expect(value == 9);
     } else |err| {
         unreachable;
     }
 @@ -4061,14 +4062,14 @@ test "if error union with optional" {
     const a: anyerror!?u32 = 0;
     if (a) |optional_value| {
-        expect(optional_value.? == 0);
+        try expect(optional_value.? == 0);
     } else |err| {
         unreachable;
     }
     const b: anyerror!?u32 = null;
     if (b) |optional_value| {
-        expect(optional_value == null);
+        try expect(optional_value == null);
     } else |err| {
         unreachable;
     }
 @@ -4077,7 +4078,7 @@ test "if error union with optional" {
     if (c) |optional_value| {
         unreachable;
     } else |err| {
-        expect(err == error.BadValue);
+        try expect(err == error.BadValue);
     }
     // Access the value by reference by using a pointer capture each time.
 @@ -4091,7 +4092,7 @@ test "if error union with optional" {
     }
     if (d) |optional_value| {
-        expect(optional_value.? == 9);
+        try expect(optional_value.? == 9);
     } else |err| {
         unreachable;
     }
 @@ -4106,21 +4107,21 @@ const expect = std.testing.expect;
 const print = std.debug.print;
 // defer will execute an expression at the end of the current scope.
-fn deferExample() usize {
+fn deferExample() !usize {
     var a: usize = 1;
     {
         defer a = 2;
         a = 1;
     }
-    expect(a == 2);
+    try expect(a == 2);
     a = 5;
     return a;
 }
 test "defer basics" {
-    expect(deferExample() == 5);
+    try expect((try deferExample()) == 5);
 }
 // If multiple defer statements are specified, they will be executed in
 @@ -4258,7 +4259,7 @@ pub extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(if (@import("bu
 test "foo" {
     const value = bar() catch ExitProcess(1);
-    expect(value == 1234);
+    try expect(value == 1234);
 }
 fn bar() anyerror!u32 {
 @@ -4321,17 +4322,17 @@ fn do_op(fn_call: call2_op, op1: i8, op2: i8) i8 {
 }
 test "function" {
-    expect(do_op(add, 5, 6) == 11);
+    try expect(do_op(add, 5, 6) == 11);
-    expect(do_op(sub2, 5, 6) == -1);
+    try expect(do_op(sub2, 5, 6) == -1);
 }
       {#code_end#}
       <p>Function values are like pointers:</p>
       {#code_begin|obj#}
-const expect = @import("std").testing.expect;
+const assert = @import("std").debug.assert;
 comptime {
-    expect(@TypeOf(foo) == fn()void);
+    assert(@TypeOf(foo) == fn()void);
-    expect(@sizeOf(fn()void) == @sizeOf(?fn()void));
+    assert(@sizeOf(fn()void) == @sizeOf(?fn()void));
 }
 fn foo() void { }
 @@ -4366,7 +4367,7 @@ fn foo(point: Point) i32 {
 const expect = @import("std").testing.expect;
 test "pass struct to function" {
-    expect(foo(Point{ .x = 1, .y = 2 }) == 3);
+    try expect(foo(Point{ .x = 1, .y = 2 }) == 3);
 }
       {#code_end#}
       <p>
 @@ -4387,11 +4388,11 @@ fn addFortyTwo(x: anytype) @TypeOf(x) {
 }
 test "fn type inference" {
-    expect(addFortyTwo(1) == 43);
+    try expect(addFortyTwo(1) == 43);
-    expect(@TypeOf(addFortyTwo(1)) == comptime_int);
+    try expect(@TypeOf(addFortyTwo(1)) == comptime_int);
     var y: i64 = 2;
-    expect(addFortyTwo(y) == 44);
+    try expect(addFortyTwo(y) == 44);
-    expect(@TypeOf(addFortyTwo(y)) == i64);
+    try expect(@TypeOf(addFortyTwo(y)) == i64);
 }
       {#code_end#}
 @@ -4401,8 +4402,8 @@ test "fn type inference" {
 const expect = @import("std").testing.expect;
 test "fn reflection" {
-    expect(@typeInfo(@TypeOf(expect)).Fn.return_type.? == void);
+    try expect(@typeInfo(@TypeOf(expect)).Fn.args[0].arg_type.? == bool);
-    expect(@typeInfo(@TypeOf(expect)).Fn.is_var_args == false);
+    try expect(@typeInfo(@TypeOf(expect)).Fn.is_var_args == false);
 }
       {#code_end#}
       {#header_close#}
 @@ -4437,7 +4438,7 @@ const AllocationError = error {
 test "coerce subset to superset" {
     const err = foo(AllocationError.OutOfMemory);
-    std.testing.expect(err == FileOpenError.OutOfMemory);
+    try std.testing.expect(err == FileOpenError.OutOfMemory);
 }
 fn foo(err: AllocationError) FileOpenError {
 @@ -4545,7 +4546,7 @@ fn charToDigit(c: u8) u8 {
 test "parse u64" {
     const result = try parseU64("1234", 10);
-    std.testing.expect(result == 1234);
+    try std.testing.expect(result == 1234);
 }
       {#code_end#}
       <p>
 @@ -4702,10 +4703,10 @@ test "error union" {
     foo = error.SomeError;
     // Use compile-time reflection to access the payload type of an error union:
-    comptime expect(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32);
+    comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32);
     // Use compile-time reflection to access the error set type of an error union:
-    comptime expect(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror);
+    comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror);
 }
       {#code_end#}
       {#header_open|Merging Error Sets#}
 @@ -5082,7 +5083,7 @@ test "optional type" {
     foo = 1234;
     // Use compile-time reflection to access the child type of the optional:
-    comptime expect(@typeInfo(@TypeOf(foo)).Optional.child == i32);
+    comptime try expect(@typeInfo(@TypeOf(foo)).Optional.child == i32);
 }
       {#code_end#}
       {#header_close#}
 @@ -5109,11 +5110,11 @@ test "optional pointers" {
     var x: i32 = 1;
     ptr = &x;
-    expect(ptr.?.* == 1);
+    try expect(ptr.?.* == 1);
     // Optional pointers are the same size as normal pointers, because pointer
     // value 0 is used as the null value.
-    expect(@sizeOf(?*i32) == @sizeOf(*i32));
+    try expect(@sizeOf(?*i32) == @sizeOf(*i32));
 }
       {#code_end#}
       {#header_close#}
 @@ -5186,7 +5187,7 @@ const mem = std.mem;
 test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
     const window_name = [1][*]const u8{"window name"};
     const x: [*]const ?[*]const u8 = &window_name;
-    expect(mem.eql(u8, std.mem.spanZ(@ptrCast([*:0]const u8, x[0].?)), "window name"));
+    try expect(mem.eql(u8, std.mem.spanZ(@ptrCast([*:0]const u8, x[0].?)), "window name"));
 }
       {#code_end#}
       {#header_close#}
 @@ -5207,13 +5208,13 @@ test "integer widening" {
     var d: u64 = c;
     var e: u64 = d;
     var f: u128 = e;
-    expect(f == a);
+    try expect(f == a);
 }
 test "implicit unsigned integer to signed integer" {
     var a: u8 = 250;
     var b: i16 = a;
-    expect(b == 250);
+    try expect(b == 250);
 }
 test "float widening" {
 @@ -5225,7 +5226,7 @@ test "float widening" {
     var b: f32 = a;
     var c: f64 = b;
     var d: f128 = c;
-    expect(d == a);
+    try expect(d == a);
 }
       {#code_end#}
       {#header_close#}
 @@ -5257,48 +5258,48 @@ const expect = std.testing.expect;
 test "[N]T to []const T" {
     var x1: []const u8 = "hello";
     var x2: []const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    expect(std.mem.eql(u8, x1, x2));
+    try expect(std.mem.eql(u8, x1, x2));
     var y: []const f32 = &[2]f32{ 1.2, 3.4 };
-    expect(y[0] == 1.2);
+    try expect(y[0] == 1.2);
 }
 // Likewise, it works when the destination type is an error union.
 test "[N]T to E![]const T" {
     var x1: anyerror![]const u8 = "hello";
     var x2: anyerror![]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    expect(std.mem.eql(u8, try x1, try x2));
+    try expect(std.mem.eql(u8, try x1, try x2));
     var y: anyerror![]const f32 = &[2]f32{ 1.2, 3.4 };
-    expect((try y)[0] == 1.2);
+    try expect((try y)[0] == 1.2);
 }
 // Likewise, it works when the destination type is an optional.
 test "[N]T to ?[]const T" {
     var x1: ?[]const u8 = "hello";
     var x2: ?[]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
-    expect(std.mem.eql(u8, x1.?, x2.?));
+    try expect(std.mem.eql(u8, x1.?, x2.?));
     var y: ?[]const f32 = &[2]f32{ 1.2, 3.4 };
-    expect(y.?[0] == 1.2);
+    try expect(y.?[0] == 1.2);
 }
 // In this cast, the array length becomes the slice length.
 test "*[N]T to []T" {
     var buf: [5]u8 = "hello".*;
     const x: []u8 = &buf;
-    expect(std.mem.eql(u8, x, "hello"));
+    try expect(std.mem.eql(u8, x, "hello"));
     const buf2 = [2]f32{ 1.2, 3.4 };
     const x2: []const f32 = &buf2;
-    expect(std.mem.eql(f32, x2, &[2]f32{ 1.2, 3.4 }));
+    try expect(std.mem.eql(f32, x2, &[2]f32{ 1.2, 3.4 }));
 }
 // Single-item pointers to arrays can be coerced to many-item pointers.
 test "*[N]T to [*]T" {
     var buf: [5]u8 = "hello".*;
     const x: [*]u8 = &buf;
-    expect(x[4] == 'o');
+    try expect(x[4] == 'o');
     // x[5] would be an uncaught out of bounds pointer dereference!
 }
 @@ -5306,7 +5307,7 @@ test "*[N]T to [*]T" {
 test "*[N]T to ?[*]T" {
     var buf: [5]u8 = "hello".*;
     const x: ?[*]u8 = &buf;
-    expect(x.?[4] == 'o');
+    try expect(x.?[4] == 'o');
 }
 // Single-item pointers can be cast to len-1 single-item arrays.
 @@ -5314,7 +5315,7 @@ test "*T to *[1]T" {
     var x: i32 = 1234;
     const y: *[1]i32 = &x;
     const z: [*]i32 = y;
-    expect(z[0] == 1234);
+    try expect(z[0] == 1234);
 }
       {#code_end#}
       {#see_also|C Pointers#}
 @@ -5331,8 +5332,8 @@ test "coerce to optionals" {
     const x: ?i32 = 1234;
     const y: ?i32 = null;
-    expect(x.? == 1234);
+    try expect(x.? == 1234);
-    expect(y == null);
+    try expect(y == null);
 }
       {#code_end#}
       <p>It works nested inside the {#link|Error Union Type#}, too:</p>
 @@ -5344,8 +5345,8 @@ test "coerce to optionals wrapped in error union" {
     const x: anyerror!?i32 = 1234;
     const y: anyerror!?i32 = null;
-    expect((try x).? == 1234);
+    try expect((try x).? == 1234);
-    expect((try y) == null);
+    try expect((try y) == null);
 }
       {#code_end#}
       {#header_close#}
 @@ -5361,8 +5362,8 @@ test "coercion to error unions" {
     const x: anyerror!i32 = 1234;
     const y: anyerror!i32 = error.Failure;
-    expect((try x) == 1234);
+    try expect((try x) == 1234);
-    std.testing.expectError(error.Failure, y);
+    try std.testing.expectError(error.Failure, y);
 }
       {#code_end#}
       {#header_close#}
 @@ -5377,7 +5378,7 @@ const expect = std.testing.expect;
 test "coercing large integer type to smaller one when value is comptime known to fit" {
     const x: u64 = 255;
     const y: u8 = x;
-    expect(y == 255);
+    try expect(y == 255);
 }
       {#code_end#}
       {#header_close#}
 @@ -5405,11 +5406,11 @@ const U = union(E) {
 test "coercion between unions and enums" {
     var u = U{ .two = 12.34 };
     var e: E = u;
-    expect(e == E.two);
+    try expect(e == E.two);
     const three = E.three;
     var another_u: U = three;
-    expect(another_u == E.three);
+    try expect(another_u == E.three);
 }
       {#code_end#}
       {#see_also|union|enum#}
 @@ -5482,37 +5483,37 @@ test "peer resolve int widening" {
     var a: i8 = 12;
     var b: i16 = 34;
     var c = a + b;
-    expect(c == 46);
+    try expect(c == 46);
-    expect(@TypeOf(c) == i16);
+    try expect(@TypeOf(c) == i16);
 }
 test "peer resolve arrays of different size to const slice" {
-    expect(mem.eql(u8, boolToStr(true), "true"));
+    try expect(mem.eql(u8, boolToStr(true), "true"));
-    expect(mem.eql(u8, boolToStr(false), "false"));
+    try expect(mem.eql(u8, boolToStr(false), "false"));
-    comptime expect(mem.eql(u8, boolToStr(true), "true"));
+    comptime try expect(mem.eql(u8, boolToStr(true), "true"));
-    comptime expect(mem.eql(u8, boolToStr(false), "false"));
+    comptime try expect(mem.eql(u8, boolToStr(false), "false"));
 }
 fn boolToStr(b: bool) []const u8 {
     return if (b) "true" else "false";
 }
 test "peer resolve array and const slice" {
-    testPeerResolveArrayConstSlice(true);
+    try testPeerResolveArrayConstSlice(true);
-    comptime testPeerResolveArrayConstSlice(true);
+    comptime try testPeerResolveArrayConstSlice(true);
 }
-fn testPeerResolveArrayConstSlice(b: bool) void {
+fn testPeerResolveArrayConstSlice(b: bool) !void {
     const value1 = if (b) "aoeu" else @as([]const u8, "zz");
     const value2 = if (b) @as([]const u8, "zz") else "aoeu";
-    expect(mem.eql(u8, value1, "aoeu"));
+    try expect(mem.eql(u8, value1, "aoeu"));
-    expect(mem.eql(u8, value2, "zz"));
+    try expect(mem.eql(u8, value2, "zz"));
 }
 test "peer type resolution: ?T and T" {
-    expect(peerTypeTAndOptionalT(true, false).? == 0);
+    try expect(peerTypeTAndOptionalT(true, false).? == 0);
-    expect(peerTypeTAndOptionalT(false, false).? == 3);
+    try expect(peerTypeTAndOptionalT(false, false).? == 3);
     comptime {
-        expect(peerTypeTAndOptionalT(true, false).? == 0);
+        try expect(peerTypeTAndOptionalT(true, false).? == 0);
-        expect(peerTypeTAndOptionalT(false, false).? == 3);
+        try expect(peerTypeTAndOptionalT(false, false).? == 3);
     }
 }
 fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
 @@ -5524,11 +5525,11 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
 }
 test "peer type resolution: *[0]u8 and []const u8" {
-    expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
+    try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
-    expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
+    try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
     comptime {
-        expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
+        try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
-        expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
+        try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
     }
 }
 fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
 @@ -5542,14 +5543,14 @@ test "peer type resolution: *[0]u8, []const u8, and anyerror![]u8" {
     {
         var data = "hi".*;
         const slice = data[0..];
-        expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
+        try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+        try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
     }
     comptime {
         var data = "hi".*;
         const slice = data[0..];
-        expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
+        try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
-        expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
+        try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
     }
 }
 fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
 @@ -5563,8 +5564,8 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
 test "peer type resolution: *const T and ?*T" {
     const a = @intToPtr(*const usize, 0x123456780);
     const b = @intToPtr(?*usize, 0x123456780);
-    expect(a == b);
+    try expect(a == b);
-    expect(b == a);
+    try expect(b == a);
 }
       {#code_end#}
       {#header_close#}
 @@ -5620,11 +5621,11 @@ test "turn HashMap into a set with void" {
     try map.put(1, {});
     try map.put(2, {});
-    expect(map.contains(2));
+    try expect(map.contains(2));
-    expect(!map.contains(3));
+    try expect(!map.contains(3));
     _ = map.remove(2);
-    expect(!map.contains(2));
+    try expect(!map.contains(2));
 }
       {#code_end#}
       <p>Note that this is different from using a dummy value for the hash map value.
 @@ -5679,7 +5680,7 @@ test "pointer to empty struct" {
     var b = Empty{};
     var ptr_a = &a;
     var ptr_b = &b;
-    comptime expect(ptr_a == ptr_b);
+    comptime try expect(ptr_a == ptr_b);
 }
       {#code_end#}
       <p>The type being pointed to can only ever be one value; therefore loads and stores are
 @@ -5714,7 +5715,7 @@ test "@intToPtr for pointer to zero bit type" {
 usingnamespace @import("std");
 test "using std namespace" {
-    testing.expect(true);
+    try testing.expect(true);
 }
       {#code_end#}
       <p>
 @@ -5826,7 +5827,7 @@ fn max(comptime T: type, a: T, b: T) T {
     }
 }
 test "try to compare bools" {
-    @import("std").testing.expect(max(bool, false, true) == true);
+    try @import("std").testing.expect(max(bool, false, true) == true);
 }
       {#code_end#}
       <p>
 @@ -5894,9 +5895,9 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
 }
 test "perform fn" {
-    expect(performFn('t', 1) == 6);
+    try expect(performFn('t', 1) == 6);
-    expect(performFn('o', 0) == 1);
+    try expect(performFn('o', 0) == 1);
-    expect(performFn('w', 99) == 99);
+    try expect(performFn('w', 99) == 99);
 }
       {#code_end#}
       <p>
 @@ -5988,11 +5989,11 @@ fn fibonacci(index: u32) u32 {
 test "fibonacci" {
     // test fibonacci at run-time
-    expect(fibonacci(7) == 13);
+    try expect(fibonacci(7) == 13);
     // test fibonacci at compile-time
     comptime {
-        expect(fibonacci(7) == 13);
+        try expect(fibonacci(7) == 13);
     }
 }
       {#code_end#}
 @@ -6009,7 +6010,7 @@ fn fibonacci(index: u32) u32 {
 test "fibonacci" {
     comptime {
-        expect(fibonacci(7) == 13);
+        try expect(fibonacci(7) == 13);
     }
 }
       {#code_end#}
 @@ -6032,7 +6033,7 @@ fn fibonacci(index: i32) i32 {
 test "fibonacci" {
     comptime {
-        expect(fibonacci(7) == 13);
+        try expect(fibonacci(7) == 13);
     }
 }
       {#code_end#}
 @@ -6045,7 +6046,7 @@ test "fibonacci" {
       <p>
       What if we fix the base case, but put the wrong value in the {#syntax#}expect{#endsyntax#} line?
       </p>
-      {#code_begin|test_err|encountered @panic at compile-time#}
+      {#code_begin|test_err|test "fibonacci"... FAIL (TestUnexpectedResult)#}
 const expect = @import("std").testing.expect;
 fn fibonacci(index: i32) i32 {
 @@ -6055,7 +6056,7 @@ fn fibonacci(index: i32) i32 {
 test "fibonacci" {
     comptime {
-        expect(fibonacci(7) == 99999);
+        try expect(fibonacci(7) == 99999);
     }
 }
       {#code_end#}
 @@ -6105,7 +6106,7 @@ fn sum(numbers: []const i32) i32 {
 }
 test "variable values" {
-    @import("std").testing.expect(sum_of_first_25_primes == 1060);
+    try @import("std").testing.expect(sum_of_first_25_primes == 1060);
 }
       {#code_end#}
       <p>
 @@ -6513,7 +6514,7 @@ comptime {
 extern fn my_func(a: i32, b: i32) i32;
 test "global assembly" {
-    expect(my_func(12, 34) == 46);
+    try expect(my_func(12, 34) == 46);
 }
       {#code_end#}
       {#header_close#}
 @@ -6554,7 +6555,7 @@ var x: i32 = 1;
 test "suspend with no resume" {
     var frame = async func();
-    expect(x == 2);
+    try expect(x == 2);
 }
 fn func() void {
 @@ -6581,14 +6582,14 @@ var result = false;
 test "async function suspend with block" {
     _ = async testSuspendBlock();
-    expect(!result);
+    try expect(!result);
     resume the_frame;
-    expect(result);
+    try expect(result);
 }
 fn testSuspendBlock() void {
     suspend {
-        comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock));
+        comptime try expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock));
         the_frame = @frame();
     }
     result = true;
 @@ -6617,7 +6618,7 @@ const expect = std.testing.expect;
 test "resume from suspend" {
     var my_result: i32 = 1;
     _ = async testResumeFromSuspend(&my_result);
-    std.testing.expect(my_result == 2);
+    try std.testing.expect(my_result == 2);
 }
 fn testResumeFromSuspend(my_result: *i32) void {
     suspend {
 @@ -6653,7 +6654,7 @@ test "async and await" {
 fn amain() void {
     var frame = async func();
-    comptime expect(@TypeOf(frame) == @Frame(func));
+    comptime try expect(@TypeOf(frame) == @Frame(func));
     const ptr: anyframe->void = &frame;
     const any_ptr: anyframe = ptr;
 @@ -6694,8 +6695,8 @@ test "async function await" {
     seq('f');
     resume the_frame;
     seq('i');
-    expect(final_result == 1234);
+    try expect(final_result == 1234);
-    expect(std.mem.eql(u8, &seq_points, "abcdefghi"));
+    try expect(std.mem.eql(u8, &seq_points, "abcdefghi"));
 }
 fn amain() void {
     seq('b');
 @@ -6909,9 +6910,9 @@ fn readFile(allocator: *Allocator, filename: []const u8) ![]u8 {
       for the current target to match the C ABI. When the child type of a pointer has
       this alignment, the alignment can be omitted from the type.
       </p>
-      <pre>{#syntax#}const expect = @import("std").testing.expect;
+      <pre>{#syntax#}const expect = @import("std").debug.assert;
 comptime {
-    expect(*u32 == *align(@alignOf(u32)) u32);
+    assert(*u32 == *align(@alignOf(u32)) u32);
 }{#endsyntax#}</pre>
       <p>
       The result is a target-specific compile time constant. It is guaranteed to be
 @@ -6957,9 +6958,9 @@ test "async fn pointer in a struct field" {
     var foo = Foo{ .bar = func };
     var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
-    expect(data == 2);
+    try expect(data == 2);
     resume f;
-    expect(data == 4);
+    try expect(data == 4);
 }
 fn func(y: *i32) void {
 @@ -7146,7 +7147,7 @@ fn func(y: *i32) void {
 const expect = @import("std").testing.expect;
 test "noinline function call" {
-    expect(@call(.{}, add, .{3, 9}) == 12);
+    try expect(@call(.{}, add, .{3, 9}) == 12);
 }
 fn add(a: i32, b: i32) i32 {
 @@ -7621,17 +7622,17 @@ test "field access by string" {
     @field(p, "x") = 4;
     @field(p, "y") = @field(p, "x") + 1;
-    expect(@field(p, "x") == 4);
+    try expect(@field(p, "x") == 4);
-    expect(@field(p, "y") == 5);
+    try expect(@field(p, "y") == 5);
 }
 test "decl access by string" {
     const expect = std.testing.expect;
-    expect(@field(Point, "z") == 1);
+    try expect(@field(Point, "z") == 1);
     @field(Point, "z") = 2;
-    expect(@field(Point, "z") == 2);
+    try expect(@field(Point, "z") == 2);
 }
       {#code_end#}
 @@ -7747,16 +7748,16 @@ const Foo = struct {
 };
 test "@hasDecl" {
-    expect(@hasDecl(Foo, "blah"));
+    try expect(@hasDecl(Foo, "blah"));
     // Even though `hi` is private, @hasDecl returns true because this test is
     // in the same file scope as Foo. It would return false if Foo was declared
     // in a different file.
-    expect(@hasDecl(Foo, "hi"));
+    try expect(@hasDecl(Foo, "hi"));
     // @hasDecl is for declarations; not fields.
-    expect(!@hasDecl(Foo, "nope"));
+    try expect(!@hasDecl(Foo, "nope"));
-    expect(!@hasDecl(Foo, "nope1234"));
+    try expect(!@hasDecl(Foo, "nope1234"));
 }
       {#code_end#}
       {#see_also|@hasField#}
 @@ -7937,8 +7938,8 @@ test "@wasmMemoryGrow" {
     if (builtin.arch != .wasm32) return error.SkipZigTest;
     var prev = @wasmMemorySize(0);
-    expect(prev == @wasmMemoryGrow(0, 1));
+    try expect(prev == @wasmMemoryGrow(0, 1));
-    expect(prev + 1 == @wasmMemorySize(0));
+    try expect(prev + 1 == @wasmMemorySize(0));
 }
       {#code_end#}
       {#see_also|@wasmMemorySize#}
 @@ -8279,8 +8280,8 @@ const expect = std.testing.expect;
 test "vector @splat" {
     const scalar: u32 = 5;
     const result = @splat(4, scalar);
-    comptime expect(@TypeOf(result) == std.meta.Vector(4, u32));
+    comptime try expect(@TypeOf(result) == std.meta.Vector(4, u32));
-    expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
+    try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
 }
       {#code_end#}
       <p>
 @@ -8322,10 +8323,10 @@ test "vector @reduce" {
     const value: std.meta.Vector(4, i32) = [_]i32{ 1, -1, 1, -1 };
     const result = value > @splat(4, @as(i32, 0));
     // result is { true, false, true, false };
-    comptime expect(@TypeOf(result) == std.meta.Vector(4, bool));
+    comptime try expect(@TypeOf(result) == std.meta.Vector(4, bool));
     const is_all_true = @reduce(.And, result);
-    comptime expect(@TypeOf(is_all_true) == bool);
+    comptime try expect(@TypeOf(is_all_true) == bool);
-    expect(is_all_true == false);
+    try expect(is_all_true == false);
 }
       {#code_end#}
       {#see_also|Vectors|@setFloatMode#}
 @@ -8341,16 +8342,16 @@ const std = @import("std");
 const expect = std.testing.expect;
 test "@src" {
-    doTheTest();
+    try doTheTest();
 }
-fn doTheTest() void {
+fn doTheTest() !void {
     const src = @src();
-    expect(src.line == 9);
+    try expect(src.line == 9);
-    expect(src.column == 17);
+    try expect(src.column == 17);
-    expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
+    try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
-    expect(std.mem.endsWith(u8, src.file, "test.zig"));
+    try expect(std.mem.endsWith(u8, src.file, "test.zig"));
 }
       {#code_end#}
       {#header_close#}
 @@ -8527,7 +8528,7 @@ const expect = std.testing.expect;
 test "@This()" {
     var items = [_]i32{ 1, 2, 3, 4 };
     const list = List(i32){ .items = items[0..] };
-    expect(list.length() == 4);
+    try expect(list.length() == 4);
 }
 fn List(comptime T: type) type {
 @@ -8573,7 +8574,7 @@ const expect = std.testing.expect;
 test "integer truncation" {
     var a: u16 = 0xabcd;
     var b: u8 = @truncate(u8, a);
-    expect(b == 0xcd);
+    try expect(b == 0xcd);
 }
       {#code_end#}
       <p>
 @@ -8661,8 +8662,8 @@ const expect = std.testing.expect;
 test "no runtime side effects" {
     var data: i32 = 0;
     const T = @TypeOf(foo(i32, &data));
-    comptime expect(T == i32);
+    comptime try expect(T == i32);
-    expect(data == 0);
+    try expect(data == 0);
 }
 fn foo(comptime T: type, ptr: *T) T {
 @@ -8972,9 +8973,9 @@ const maxInt = std.math.maxInt;
 test "wraparound addition and subtraction" {
     const x: i32 = maxInt(i32);
     const min_val = x +% 1;
-    expect(min_val == minInt(i32));
+    try expect(min_val == minInt(i32));
     const max_val = min_val -% 1;
-    expect(max_val == maxInt(i32));
+    try expect(max_val == maxInt(i32));
 }
       {#code_end#}
       {#header_close#}
 @@ -9405,7 +9406,7 @@ test "using an allocator" {
     var buffer: [100]u8 = undefined;
     const allocator = &std.heap.FixedBufferAllocator.init(&buffer).allocator;
     const result = try concat(allocator, "foo", "bar");
-    expect(std.mem.eql(u8, "foobar", result));
+    try expect(std.mem.eql(u8, "foobar", result));
 }
 fn concat(allocator: *Allocator, a: []const u8, b: []const u8) ![]u8 {
 @@ -9675,7 +9676,7 @@ const builtin = std.builtin;
 const expect = std.testing.expect;
 test "builtin.is_test" {
-    expect(builtin.is_test);
+    try expect(builtin.is_test);
 }
       {#code_end#}
       <p>
 @@ -9720,13 +9721,13 @@ test "assert in release fast mode" {
       <p>
       Better practice for checking the output when testing is to use {#syntax#}std.testing.expect{#endsyntax#}:
       </p>
-      {#code_begin|test_err|test failure#}
+      {#code_begin|test_err|test "expect in release fast mode"... FAIL (TestUnexpectedResult)#}
       {#code_release_fast#}
 const std = @import("std");
 const expect = std.testing.expect;
 test "expect in release fast mode" {
-    expect(false);
+    try expect(false);
 }
       {#code_end#}
       <p>See the rest of the {#syntax#}std.testing{#endsyntax#} namespace for more available functions.</p>

lib/std/SemanticVersion.zig+13-13

lib/std/Thread/AutoResetEvent.zig+8-8

...	@@ -176,7 +176,7 @@ test "basic usage" {	...	@@ -176,7 +176,7 @@ test "basic usage" {
176	// test local code paths	176	// test local code paths
177	{	177	{
178	var event = AutoResetEvent{};	178	var event = AutoResetEvent{};
179	testing.expectError(error.TimedOut, event.timedWait(1));	179	try testing.expectError(error.TimedOut, event.timedWait(1));
180	event.set();	180	event.set();
181	event.wait();	181	event.wait();
182	}	182	}
...	@@ -192,28 +192,28 @@ test "basic usage" {	...	@@ -192,28 +192,28 @@ test "basic usage" {
192		192
193	const Self = @This();	193	const Self = @This();
194		194
195	fn sender(self: *Self) void {	195	fn sender(self: *Self) !void {
196	testing.expect(self.value == 0);	196	try testing.expect(self.value == 0);
197	self.value = 1;	197	self.value = 1;
198	self.out.set();	198	self.out.set();
199		199
200	self.in.wait();	200	self.in.wait();
201	testing.expect(self.value == 2);	201	try testing.expect(self.value == 2);
202	self.value = 3;	202	self.value = 3;
203	self.out.set();	203	self.out.set();
204		204
205	self.in.wait();	205	self.in.wait();
206	testing.expect(self.value == 4);	206	try testing.expect(self.value == 4);
207	}	207	}
208		208
209	fn receiver(self: *Self) void {	209	fn receiver(self: *Self) !void {
210	self.out.wait();	210	self.out.wait();
211	testing.expect(self.value == 1);	211	try testing.expect(self.value == 1);
212	self.value = 2;	212	self.value = 2;
213	self.in.set();	213	self.in.set();
214		214
215	self.out.wait();	215	self.out.wait();
216	testing.expect(self.value == 3);	216	try testing.expect(self.value == 3);
217	self.value = 4;	217	self.value = 4;
218	self.in.set();	218	self.in.set();
219	}	219	}

lib/std/Thread/Mutex.zig+2-2

...	@@ -294,7 +294,7 @@ test "basic usage" {	...	@@ -294,7 +294,7 @@ test "basic usage" {
294		294
295	if (builtin.single_threaded) {	295	if (builtin.single_threaded) {
296	worker(&context);	296	worker(&context);
297	testing.expect(context.data == TestContext.incr_count);	297	try testing.expect(context.data == TestContext.incr_count);
298	} else {	298	} else {
299	const thread_count = 10;	299	const thread_count = 10;
300	var threads: [thread_count]*std.Thread = undefined;	300	var threads: [thread_count]*std.Thread = undefined;
...	@@ -304,7 +304,7 @@ test "basic usage" {	...	@@ -304,7 +304,7 @@ test "basic usage" {
304	for (threads) \|t\|	304	for (threads) \|t\|
305	t.wait();	305	t.wait();
306		306
307	testing.expect(context.data == thread_count * TestContext.incr_count);	307	try testing.expect(context.data == thread_count * TestContext.incr_count);
308	}	308	}
309	}	309	}
310		310

lib/std/Thread/ResetEvent.zig+10-10

...	@@ -204,7 +204,7 @@ test "basic usage" {	...	@@ -204,7 +204,7 @@ test "basic usage" {
204	event.reset();	204	event.reset();
205		205
206	event.set();	206	event.set();
207	testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));	207	try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));
208		208
209	// test cross-thread signaling	209	// test cross-thread signaling
210	if (builtin.single_threaded)	210	if (builtin.single_threaded)
...	@@ -233,25 +233,25 @@ test "basic usage" {	...	@@ -233,25 +233,25 @@ test "basic usage" {
233	self.* = undefined;	233	self.* = undefined;
234	}	234	}
235		235
236	fn sender(self: *Self) void {	236	fn sender(self: *Self) !void {
237	// update value and signal input	237	// update value and signal input
238	testing.expect(self.value == 0);	238	try testing.expect(self.value == 0);
239	self.value = 1;	239	self.value = 1;
240	self.in.set();	240	self.in.set();
241		241
242	// wait for receiver to update value and signal output	242	// wait for receiver to update value and signal output
243	self.out.wait();	243	self.out.wait();
244	testing.expect(self.value == 2);	244	try testing.expect(self.value == 2);
245		245
246	// update value and signal final input	246	// update value and signal final input
247	self.value = 3;	247	self.value = 3;
248	self.in.set();	248	self.in.set();
249	}	249	}
250		250
251	fn receiver(self: *Self) void {	251	fn receiver(self: *Self) !void {
252	// wait for sender to update value and signal input	252	// wait for sender to update value and signal input
253	self.in.wait();	253	self.in.wait();
254	assert(self.value == 1);	254	try testing.expect(self.value == 1);
255		255
256	// update value and signal output	256	// update value and signal output
257	self.in.reset();	257	self.in.reset();
...	@@ -260,7 +260,7 @@ test "basic usage" {	...	@@ -260,7 +260,7 @@ test "basic usage" {
260		260
261	// wait for sender to update value and signal final input	261	// wait for sender to update value and signal final input
262	self.in.wait();	262	self.in.wait();
263	assert(self.value == 3);	263	try testing.expect(self.value == 3);
264	}	264	}
265		265
266	fn sleeper(self: *Self) void {	266	fn sleeper(self: *Self) void {
...	@@ -272,9 +272,9 @@ test "basic usage" {	...	@@ -272,9 +272,9 @@ test "basic usage" {
272		272
273	fn timedWaiter(self: *Self) !void {	273	fn timedWaiter(self: *Self) !void {
274	self.in.wait();	274	self.in.wait();
275	testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us));	275	try testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us));
276	try self.out.timedWait(time.ns_per_ms * 100);	276	try self.out.timedWait(time.ns_per_ms * 100);
277	testing.expect(self.value == 5);	277	try testing.expect(self.value == 5);
278	}	278	}
279	};	279	};
280		280
...	@@ -283,7 +283,7 @@ test "basic usage" {	...	@@ -283,7 +283,7 @@ test "basic usage" {
283	defer context.deinit();	283	defer context.deinit();
284	const receiver = try std.Thread.spawn(Context.receiver, &context);	284	const receiver = try std.Thread.spawn(Context.receiver, &context);
285	defer receiver.wait();	285	defer receiver.wait();
286	context.sender();	286	try context.sender();
287		287
288	if (false) {	288	if (false) {
289	// I have now observed this fail on macOS, Windows, and Linux.	289	// I have now observed this fail on macOS, Windows, and Linux.

lib/std/Thread/StaticResetEvent.zig+10-10

...	@@ -320,7 +320,7 @@ test "basic usage" {	...	@@ -320,7 +320,7 @@ test "basic usage" {
320	event.reset();	320	event.reset();
321		321
322	event.set();	322	event.set();
323	testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));	323	try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));
324		324
325	// test cross-thread signaling	325	// test cross-thread signaling
326	if (std.builtin.single_threaded)	326	if (std.builtin.single_threaded)
...	@@ -333,25 +333,25 @@ test "basic usage" {	...	@@ -333,25 +333,25 @@ test "basic usage" {
333	in: StaticResetEvent = .{},	333	in: StaticResetEvent = .{},
334	out: StaticResetEvent = .{},	334	out: StaticResetEvent = .{},
335		335
336	fn sender(self: *Self) void {	336	fn sender(self: *Self) !void {
337	// update value and signal input	337	// update value and signal input
338	testing.expect(self.value == 0);	338	try testing.expect(self.value == 0);
339	self.value = 1;	339	self.value = 1;
340	self.in.set();	340	self.in.set();
341		341
342	// wait for receiver to update value and signal output	342	// wait for receiver to update value and signal output
343	self.out.wait();	343	self.out.wait();
344	testing.expect(self.value == 2);	344	try testing.expect(self.value == 2);
345		345
346	// update value and signal final input	346	// update value and signal final input
347	self.value = 3;	347	self.value = 3;
348	self.in.set();	348	self.in.set();
349	}	349	}
350		350
351	fn receiver(self: *Self) void {	351	fn receiver(self: *Self) !void {
352	// wait for sender to update value and signal input	352	// wait for sender to update value and signal input
353	self.in.wait();	353	self.in.wait();
354	assert(self.value == 1);	354	try testing.expect(self.value == 1);
355		355
356	// update value and signal output	356	// update value and signal output
357	self.in.reset();	357	self.in.reset();
...	@@ -360,7 +360,7 @@ test "basic usage" {	...	@@ -360,7 +360,7 @@ test "basic usage" {
360		360
361	// wait for sender to update value and signal final input	361	// wait for sender to update value and signal final input
362	self.in.wait();	362	self.in.wait();
363	assert(self.value == 3);	363	try testing.expect(self.value == 3);
364	}	364	}
365		365
366	fn sleeper(self: *Self) void {	366	fn sleeper(self: *Self) void {
...	@@ -372,16 +372,16 @@ test "basic usage" {	...	@@ -372,16 +372,16 @@ test "basic usage" {
372		372
373	fn timedWaiter(self: *Self) !void {	373	fn timedWaiter(self: *Self) !void {
374	self.in.wait();	374	self.in.wait();
375	testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us));	375	try testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us));
376	try self.out.timedWait(time.ns_per_ms * 100);	376	try self.out.timedWait(time.ns_per_ms * 100);
377	testing.expect(self.value == 5);	377	try testing.expect(self.value == 5);
378	}	378	}
379	};	379	};
380		380
381	var context = Context{};	381	var context = Context{};
382	const receiver = try std.Thread.spawn(Context.receiver, &context);	382	const receiver = try std.Thread.spawn(Context.receiver, &context);
383	defer receiver.wait();	383	defer receiver.wait();
384	context.sender();	384	try context.sender();
385		385
386	if (false) {	386	if (false) {
387	// I have now observed this fail on macOS, Windows, and Linux.	387	// I have now observed this fail on macOS, Windows, and Linux.

lib/std/array_hash_map.zig+68-68

lib/std/array_list.zig+116-116

lib/std/ascii.zig+23-23

lib/std/atomic/bool.zig+4-4

...	@@ -47,9 +47,9 @@ pub const Bool = extern struct {	...	@@ -47,9 +47,9 @@ pub const Bool = extern struct {
47		47
48	test "std.atomic.Bool" {	48	test "std.atomic.Bool" {
49	var a = Bool.init(false);	49	var a = Bool.init(false);
50	testing.expectEqual(false, a.xchg(false, .SeqCst));	50	try testing.expectEqual(false, a.xchg(false, .SeqCst));
51	testing.expectEqual(false, a.load(.SeqCst));	51	try testing.expectEqual(false, a.load(.SeqCst));
52	a.store(true, .SeqCst);	52	a.store(true, .SeqCst);
53	testing.expectEqual(true, a.xchg(false, .SeqCst));	53	try testing.expectEqual(true, a.xchg(false, .SeqCst));
54	testing.expectEqual(false, a.load(.SeqCst));	54	try testing.expectEqual(false, a.load(.SeqCst));
55	}	55	}

lib/std/atomic/int.zig+6-6

...	@@ -81,12 +81,12 @@ pub fn Int(comptime T: type) type {	...	@@ -81,12 +81,12 @@ pub fn Int(comptime T: type) type {
81		81
82	test "std.atomic.Int" {	82	test "std.atomic.Int" {
83	var a = Int(u8).init(0);	83	var a = Int(u8).init(0);
84	testing.expectEqual(@as(u8, 0), a.incr());	84	try testing.expectEqual(@as(u8, 0), a.incr());
85	testing.expectEqual(@as(u8, 1), a.load(.SeqCst));	85	try testing.expectEqual(@as(u8, 1), a.load(.SeqCst));
86	a.store(42, .SeqCst);	86	a.store(42, .SeqCst);
87	testing.expectEqual(@as(u8, 42), a.decr());	87	try testing.expectEqual(@as(u8, 42), a.decr());
88	testing.expectEqual(@as(u8, 41), a.xchg(100));	88	try testing.expectEqual(@as(u8, 41), a.xchg(100));
89	testing.expectEqual(@as(u8, 100), a.fetchAdd(5));	89	try testing.expectEqual(@as(u8, 100), a.fetchAdd(5));
90	testing.expectEqual(@as(u8, 105), a.get());	90	try testing.expectEqual(@as(u8, 105), a.get());
91	a.set(200);	91	a.set(200);
92	}	92	}

lib/std/atomic/queue.zig+28-28

...	@@ -195,24 +195,24 @@ test "std.atomic.Queue" {	...	@@ -195,24 +195,24 @@ test "std.atomic.Queue" {
195	};	195	};
196		196
197	if (builtin.single_threaded) {	197	if (builtin.single_threaded) {
198	expect(context.queue.isEmpty());	198	try expect(context.queue.isEmpty());
199	{	199	{
200	var i: usize = 0;	200	var i: usize = 0;
201	while (i < put_thread_count) : (i += 1) {	201	while (i < put_thread_count) : (i += 1) {
202	expect(startPuts(&context) == 0);	202	try expect(startPuts(&context) == 0);
203	}	203	}
204	}	204	}
205	expect(!context.queue.isEmpty());	205	try expect(!context.queue.isEmpty());
206	context.puts_done = true;	206	context.puts_done = true;
207	{	207	{
208	var i: usize = 0;	208	var i: usize = 0;
209	while (i < put_thread_count) : (i += 1) {	209	while (i < put_thread_count) : (i += 1) {
210	expect(startGets(&context) == 0);	210	try expect(startGets(&context) == 0);
211	}	211	}
212	}	212	}
213	expect(context.queue.isEmpty());	213	try expect(context.queue.isEmpty());
214	} else {	214	} else {
215	expect(context.queue.isEmpty());	215	try expect(context.queue.isEmpty());
216		216
217	var putters: [put_thread_count]*std.Thread = undefined;	217	var putters: [put_thread_count]*std.Thread = undefined;
218	for (putters) \|*t\| {	218	for (putters) \|*t\| {
...	@@ -229,7 +229,7 @@ test "std.atomic.Queue" {	...	@@ -229,7 +229,7 @@ test "std.atomic.Queue" {
229	for (getters) \|t\|	229	for (getters) \|t\|
230	t.wait();	230	t.wait();
231		231
232	expect(context.queue.isEmpty());	232	try expect(context.queue.isEmpty());
233	}	233	}
234		234
235	if (context.put_sum != context.get_sum) {	235	if (context.put_sum != context.get_sum) {
...	@@ -279,7 +279,7 @@ fn startGets(ctx: *Context) u8 {	...	@@ -279,7 +279,7 @@ fn startGets(ctx: *Context) u8 {
279		279
280	test "std.atomic.Queue single-threaded" {	280	test "std.atomic.Queue single-threaded" {
281	var queue = Queue(i32).init();	281	var queue = Queue(i32).init();
282	expect(queue.isEmpty());	282	try expect(queue.isEmpty());
283		283
284	var node_0 = Queue(i32).Node{	284	var node_0 = Queue(i32).Node{
285	.data = 0,	285	.data = 0,
...	@@ -287,7 +287,7 @@ test "std.atomic.Queue single-threaded" {	...	@@ -287,7 +287,7 @@ test "std.atomic.Queue single-threaded" {
287	.prev = undefined,	287	.prev = undefined,
288	};	288	};
289	queue.put(&node_0);	289	queue.put(&node_0);
290	expect(!queue.isEmpty());	290	try expect(!queue.isEmpty());
291		291
292	var node_1 = Queue(i32).Node{	292	var node_1 = Queue(i32).Node{
293	.data = 1,	293	.data = 1,
...	@@ -295,10 +295,10 @@ test "std.atomic.Queue single-threaded" {	...	@@ -295,10 +295,10 @@ test "std.atomic.Queue single-threaded" {
295	.prev = undefined,	295	.prev = undefined,
296	};	296	};
297	queue.put(&node_1);	297	queue.put(&node_1);
298	expect(!queue.isEmpty());	298	try expect(!queue.isEmpty());
299		299
300	expect(queue.get().?.data == 0);	300	try expect(queue.get().?.data == 0);
301	expect(!queue.isEmpty());	301	try expect(!queue.isEmpty());
302		302
303	var node_2 = Queue(i32).Node{	303	var node_2 = Queue(i32).Node{
304	.data = 2,	304	.data = 2,
...	@@ -306,7 +306,7 @@ test "std.atomic.Queue single-threaded" {	...	@@ -306,7 +306,7 @@ test "std.atomic.Queue single-threaded" {
306	.prev = undefined,	306	.prev = undefined,
307	};	307	};
308	queue.put(&node_2);	308	queue.put(&node_2);
309	expect(!queue.isEmpty());	309	try expect(!queue.isEmpty());
310		310
311	var node_3 = Queue(i32).Node{	311	var node_3 = Queue(i32).Node{
312	.data = 3,	312	.data = 3,
...	@@ -314,13 +314,13 @@ test "std.atomic.Queue single-threaded" {	...	@@ -314,13 +314,13 @@ test "std.atomic.Queue single-threaded" {
314	.prev = undefined,	314	.prev = undefined,
315	};	315	};
316	queue.put(&node_3);	316	queue.put(&node_3);
317	expect(!queue.isEmpty());	317	try expect(!queue.isEmpty());
318		318
319	expect(queue.get().?.data == 1);	319	try expect(queue.get().?.data == 1);
320	expect(!queue.isEmpty());	320	try expect(!queue.isEmpty());
321		321
322	expect(queue.get().?.data == 2);	322	try expect(queue.get().?.data == 2);
323	expect(!queue.isEmpty());	323	try expect(!queue.isEmpty());
324		324
325	var node_4 = Queue(i32).Node{	325	var node_4 = Queue(i32).Node{
326	.data = 4,	326	.data = 4,
...	@@ -328,17 +328,17 @@ test "std.atomic.Queue single-threaded" {	...	@@ -328,17 +328,17 @@ test "std.atomic.Queue single-threaded" {
328	.prev = undefined,	328	.prev = undefined,
329	};	329	};
330	queue.put(&node_4);	330	queue.put(&node_4);
331	expect(!queue.isEmpty());	331	try expect(!queue.isEmpty());
332		332
333	expect(queue.get().?.data == 3);	333	try expect(queue.get().?.data == 3);
334	node_3.next = null;	334	node_3.next = null;
335	expect(!queue.isEmpty());	335	try expect(!queue.isEmpty());
336		336
337	expect(queue.get().?.data == 4);	337	try expect(queue.get().?.data == 4);
338	expect(queue.isEmpty());	338	try expect(queue.isEmpty());
339		339
340	expect(queue.get() == null);	340	try expect(queue.get() == null);
341	expect(queue.isEmpty());	341	try expect(queue.isEmpty());
342	}	342	}
343		343
344	test "std.atomic.Queue dump" {	344	test "std.atomic.Queue dump" {
...	@@ -352,7 +352,7 @@ test "std.atomic.Queue dump" {	...	@@ -352,7 +352,7 @@ test "std.atomic.Queue dump" {
352	// Test empty stream	352	// Test empty stream
353	fbs.reset();	353	fbs.reset();
354	try queue.dumpToStream(fbs.writer());	354	try queue.dumpToStream(fbs.writer());
355	expect(mem.eql(u8, buffer[0..fbs.pos],	355	try expect(mem.eql(u8, buffer[0..fbs.pos],
356	\\head: (null)	356	\\head: (null)
357	\\tail: (null)	357	\\tail: (null)
358	\\	358	\\
...	@@ -376,7 +376,7 @@ test "std.atomic.Queue dump" {	...	@@ -376,7 +376,7 @@ test "std.atomic.Queue dump" {
376	\\ (null)	376	\\ (null)
377	\\	377	\\
378	, .{ @ptrToInt(queue.head), @ptrToInt(queue.tail) });	378	, .{ @ptrToInt(queue.head), @ptrToInt(queue.tail) });
379	expect(mem.eql(u8, buffer[0..fbs.pos], expected));	379	try expect(mem.eql(u8, buffer[0..fbs.pos], expected));
380		380
381	// Test a stream with two elements	381	// Test a stream with two elements
382	var node_1 = Queue(i32).Node{	382	var node_1 = Queue(i32).Node{
...	@@ -397,5 +397,5 @@ test "std.atomic.Queue dump" {	...	@@ -397,5 +397,5 @@ test "std.atomic.Queue dump" {
397	\\ (null)	397	\\ (null)
398	\\	398	\\
399	, .{ @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail) });	399	, .{ @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail) });
400	expect(mem.eql(u8, buffer[0..fbs.pos], expected));	400	try expect(mem.eql(u8, buffer[0..fbs.pos], expected));
401	}	401	}

lib/std/atomic/stack.zig+2-2

...	@@ -110,14 +110,14 @@ test "std.atomic.stack" {	...	@@ -110,14 +110,14 @@ test "std.atomic.stack" {
110	{	110	{
111	var i: usize = 0;	111	var i: usize = 0;
112	while (i < put_thread_count) : (i += 1) {	112	while (i < put_thread_count) : (i += 1) {
113	expect(startPuts(&context) == 0);	113	try expect(startPuts(&context) == 0);
114	}	114	}
115	}	115	}
116	context.puts_done = true;	116	context.puts_done = true;
117	{	117	{
118	var i: usize = 0;	118	var i: usize = 0;
119	while (i < put_thread_count) : (i += 1) {	119	while (i < put_thread_count) : (i += 1) {
120	expect(startGets(&context) == 0);	120	try expect(startGets(&context) == 0);
121	}	121	}
122	}	122	}
123	} else {	123	} else {

lib/std/base64.zig+9-9

lib/std/bit_set.zig+89-89

lib/std/buf_map.zig+7-7

lib/std/buf_set.zig+2-2

...	@@ -73,9 +73,9 @@ test "BufSet" {	...	@@ -73,9 +73,9 @@ test "BufSet" {
73	defer bufset.deinit();	73	defer bufset.deinit();
74		74
75	try bufset.put("x");	75	try bufset.put("x");
76	testing.expect(bufset.count() == 1);	76	try testing.expect(bufset.count() == 1);
77	bufset.delete("x");	77	bufset.delete("x");
78	testing.expect(bufset.count() == 0);	78	try testing.expect(bufset.count() == 0);
79		79
80	try bufset.put("x");	80	try bufset.put("x");
81	try bufset.put("y");	81	try bufset.put("y");

lib/std/build.zig+11-11

lib/std/builtin.zig+1-1

...	@@ -546,7 +546,7 @@ pub fn testVersionParse() !void {	...	@@ -546,7 +546,7 @@ pub fn testVersionParse() !void {
546	const f = struct {	546	const f = struct {
547	fn eql(text: []const u8, v1: u32, v2: u32, v3: u32) !void {	547	fn eql(text: []const u8, v1: u32, v2: u32, v3: u32) !void {
548	const v = try Version.parse(text);	548	const v = try Version.parse(text);
549	std.testing.expect(v.major == v1 and v.minor == v2 and v.patch == v3);	549	try std.testing.expect(v.major == v1 and v.minor == v2 and v.patch == v3);
550	}	550	}
551		551
552	fn err(text: []const u8, expected_err: anyerror) !void {	552	fn err(text: []const u8, expected_err: anyerror) !void {

lib/std/c/tokenizer.zig+8-8

...	@@ -1310,7 +1310,7 @@ pub const Tokenizer = struct {	...	@@ -1310,7 +1310,7 @@ pub const Tokenizer = struct {
1310	};	1310	};
1311		1311
1312	test "operators" {	1312	test "operators" {
1313	expectTokens(	1313	try expectTokens(
1314	\\ ! != \| \|\| \|= = ==	1314	\\ ! != \| \|\| \|= = ==
1315	\\ ( ) { } [ ] . .. ...	1315	\\ ( ) { } [ ] . .. ...
1316	\\ ^ ^= + ++ += - -- -=	1316	\\ ^ ^= + ++ += - -- -=
...	@@ -1379,7 +1379,7 @@ test "operators" {	...	@@ -1379,7 +1379,7 @@ test "operators" {
1379	}	1379	}
1380		1380
1381	test "keywords" {	1381	test "keywords" {
1382	expectTokens(	1382	try expectTokens(
1383	\\auto break case char const continue default do	1383	\\auto break case char const continue default do
1384	\\double else enum extern float for goto if int	1384	\\double else enum extern float for goto if int
1385	\\long register return short signed sizeof static	1385	\\long register return short signed sizeof static
...	@@ -1442,7 +1442,7 @@ test "keywords" {	...	@@ -1442,7 +1442,7 @@ test "keywords" {
1442	}	1442	}
1443		1443
1444	test "preprocessor keywords" {	1444	test "preprocessor keywords" {
1445	expectTokens(	1445	try expectTokens(
1446	\\#include <test>	1446	\\#include <test>
1447	\\#define #include <1	1447	\\#define #include <1
1448	\\#ifdef	1448	\\#ifdef
...	@@ -1478,7 +1478,7 @@ test "preprocessor keywords" {	...	@@ -1478,7 +1478,7 @@ test "preprocessor keywords" {
1478	}	1478	}
1479		1479
1480	test "line continuation" {	1480	test "line continuation" {
1481	expectTokens(	1481	try expectTokens(
1482	\\#define foo \	1482	\\#define foo \
1483	\\ bar	1483	\\ bar
1484	\\"foo\	1484	\\"foo\
...	@@ -1509,7 +1509,7 @@ test "line continuation" {	...	@@ -1509,7 +1509,7 @@ test "line continuation" {
1509	}	1509	}
1510		1510
1511	test "string prefix" {	1511	test "string prefix" {
1512	expectTokens(	1512	try expectTokens(
1513	\\"foo"	1513	\\"foo"
1514	\\u"foo"	1514	\\u"foo"
1515	\\u8"foo"	1515	\\u8"foo"
...	@@ -1543,7 +1543,7 @@ test "string prefix" {	...	@@ -1543,7 +1543,7 @@ test "string prefix" {
1543	}	1543	}
1544		1544
1545	test "num suffixes" {	1545	test "num suffixes" {
1546	expectTokens(	1546	try expectTokens(
1547	\\ 1.0f 1.0L 1.0 .0 1.	1547	\\ 1.0f 1.0L 1.0 .0 1.
1548	\\ 0l 0lu 0ll 0llu 0	1548	\\ 0l 0lu 0ll 0llu 0
1549	\\ 1u 1ul 1ull 1	1549	\\ 1u 1ul 1ull 1
...	@@ -1573,7 +1573,7 @@ test "num suffixes" {	...	@@ -1573,7 +1573,7 @@ test "num suffixes" {
1573	});	1573	});
1574	}	1574	}
1575		1575
1576	fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) void {	1576	fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) !void {
1577	var tokenizer = Tokenizer{	1577	var tokenizer = Tokenizer{
1578	.buffer = source,	1578	.buffer = source,
1579	};	1579	};
...	@@ -1584,5 +1584,5 @@ fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) void {	...	@@ -1584,5 +1584,5 @@ fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) void {
1584	}	1584	}
1585	}	1585	}
1586	const last_token = tokenizer.next();	1586	const last_token = tokenizer.next();
1587	std.testing.expect(last_token.id == .Eof);	1587	try std.testing.expect(last_token.id == .Eof);
1588	}	1588	}

lib/std/child_process.zig+2-2

...	@@ -1005,7 +1005,7 @@ test "createNullDelimitedEnvMap" {	...	@@ -1005,7 +1005,7 @@ test "createNullDelimitedEnvMap" {
1005	defer arena.deinit();	1005	defer arena.deinit();
1006	const environ = try createNullDelimitedEnvMap(&arena.allocator, &envmap);	1006	const environ = try createNullDelimitedEnvMap(&arena.allocator, &envmap);
1007		1007
1008	testing.expectEqual(@as(usize, 5), environ.len);	1008	try testing.expectEqual(@as(usize, 5), environ.len);
1009		1009
1010	inline for (.{	1010	inline for (.{
1011	"HOME=/home/ifreund",	1011	"HOME=/home/ifreund",
...	@@ -1017,7 +1017,7 @@ test "createNullDelimitedEnvMap" {	...	@@ -1017,7 +1017,7 @@ test "createNullDelimitedEnvMap" {
1017	for (environ) \|variable\| {	1017	for (environ) \|variable\| {
1018	if (mem.eql(u8, mem.span(variable orelse continue), target)) break;	1018	if (mem.eql(u8, mem.span(variable orelse continue), target)) break;
1019	} else {	1019	} else {
1020	testing.expect(false); // Environment variable not found	1020	try testing.expect(false); // Environment variable not found
1021	}	1021	}
1022	}	1022	}
1023	}	1023	}

lib/std/compress/deflate.zig+1-1

...	@@ -669,5 +669,5 @@ test "lengths overflow" {	...	@@ -669,5 +669,5 @@ test "lengths overflow" {
669	var inflate = inflateStream(reader, &window);	669	var inflate = inflateStream(reader, &window);
670		670
671	var buf: [1]u8 = undefined;	671	var buf: [1]u8 = undefined;
672	std.testing.expectError(error.InvalidLength, inflate.read(&buf));	672	try std.testing.expectError(error.InvalidLength, inflate.read(&buf));
673	}	673	}

lib/std/compress/gzip.zig+9-9

...	@@ -172,17 +172,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {	...	@@ -172,17 +172,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
172	var hash: [32]u8 = undefined;	172	var hash: [32]u8 = undefined;
173	std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{});	173	std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{});
174		174
175	assertEqual(expected, &hash);	175	try assertEqual(expected, &hash);
176	}	176	}
177		177
178	// Assert `expected` == `input` where `input` is a bytestring.	178	// Assert `expected` == `input` where `input` is a bytestring.
179	pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {	179	pub fn assertEqual(comptime expected: []const u8, input: []const u8) !void {
180	var expected_bytes: [expected.len / 2]u8 = undefined;	180	var expected_bytes: [expected.len / 2]u8 = undefined;
181	for (expected_bytes) \|*r, i\| {	181	for (expected_bytes) \|*r, i\| {
182	r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;	182	r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;
183	}	183	}
184		184
185	testing.expectEqualSlices(u8, &expected_bytes, input);	185	try testing.expectEqualSlices(u8, &expected_bytes, input);
186	}	186	}
187		187
188	// All the test cases are obtained by compressing the RFC1952 text	188	// All the test cases are obtained by compressing the RFC1952 text
...	@@ -198,12 +198,12 @@ test "compressed data" {	...	@@ -198,12 +198,12 @@ test "compressed data" {
198		198
199	test "sanity checks" {	199	test "sanity checks" {
200	// Truncated header	200	// Truncated header
201	testing.expectError(	201	try testing.expectError(
202	error.EndOfStream,	202	error.EndOfStream,
203	testReader(&[_]u8{ 0x1f, 0x8B }, ""),	203	testReader(&[_]u8{ 0x1f, 0x8B }, ""),
204	);	204	);
205	// Wrong CM	205	// Wrong CM
206	testing.expectError(	206	try testing.expectError(
207	error.InvalidCompression,	207	error.InvalidCompression,
208	testReader(&[_]u8{	208	testReader(&[_]u8{
209	0x1f, 0x8b, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,	209	0x1f, 0x8b, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
...	@@ -211,7 +211,7 @@ test "sanity checks" {	...	@@ -211,7 +211,7 @@ test "sanity checks" {
211	}, ""),	211	}, ""),
212	);	212	);
213	// Wrong checksum	213	// Wrong checksum
214	testing.expectError(	214	try testing.expectError(
215	error.WrongChecksum,	215	error.WrongChecksum,
216	testReader(&[_]u8{	216	testReader(&[_]u8{
217	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,	217	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
...	@@ -220,7 +220,7 @@ test "sanity checks" {	...	@@ -220,7 +220,7 @@ test "sanity checks" {
220	}, ""),	220	}, ""),
221	);	221	);
222	// Truncated checksum	222	// Truncated checksum
223	testing.expectError(	223	try testing.expectError(
224	error.EndOfStream,	224	error.EndOfStream,
225	testReader(&[_]u8{	225	testReader(&[_]u8{
226	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,	226	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
...	@@ -228,7 +228,7 @@ test "sanity checks" {	...	@@ -228,7 +228,7 @@ test "sanity checks" {
228	}, ""),	228	}, ""),
229	);	229	);
230	// Wrong initial size	230	// Wrong initial size
231	testing.expectError(	231	try testing.expectError(
232	error.CorruptedData,	232	error.CorruptedData,
233	testReader(&[_]u8{	233	testReader(&[_]u8{
234	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,	234	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
...	@@ -237,7 +237,7 @@ test "sanity checks" {	...	@@ -237,7 +237,7 @@ test "sanity checks" {
237	}, ""),	237	}, ""),
238	);	238	);
239	// Truncated initial size field	239	// Truncated initial size field
240	testing.expectError(	240	try testing.expectError(
241	error.EndOfStream,	241	error.EndOfStream,
242	testReader(&[_]u8{	242	testReader(&[_]u8{
243	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,	243	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,

lib/std/compress/zlib.zig+9-9

...	@@ -109,17 +109,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {	...	@@ -109,17 +109,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
109	var hash: [32]u8 = undefined;	109	var hash: [32]u8 = undefined;
110	std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{});	110	std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{});
111		111
112	assertEqual(expected, &hash);	112	try assertEqual(expected, &hash);
113	}	113	}
114		114
115	// Assert `expected` == `input` where `input` is a bytestring.	115	// Assert `expected` == `input` where `input` is a bytestring.
116	pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {	116	pub fn assertEqual(comptime expected: []const u8, input: []const u8) !void {
117	var expected_bytes: [expected.len / 2]u8 = undefined;	117	var expected_bytes: [expected.len / 2]u8 = undefined;
118	for (expected_bytes) \|*r, i\| {	118	for (expected_bytes) \|*r, i\| {
119	r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;	119	r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;
120	}	120	}
121		121
122	testing.expectEqualSlices(u8, &expected_bytes, input);	122	try testing.expectEqualSlices(u8, &expected_bytes, input);
123	}	123	}
124		124
125	// All the test cases are obtained by compressing the RFC1950 text	125	// All the test cases are obtained by compressing the RFC1950 text
...	@@ -159,32 +159,32 @@ test "don't read past deflate stream's end" {	...	@@ -159,32 +159,32 @@ test "don't read past deflate stream's end" {
159		159
160	test "sanity checks" {	160	test "sanity checks" {
161	// Truncated header	161	// Truncated header
162	testing.expectError(	162	try testing.expectError(
163	error.EndOfStream,	163	error.EndOfStream,
164	testReader(&[_]u8{0x78}, ""),	164	testReader(&[_]u8{0x78}, ""),
165	);	165	);
166	// Failed FCHECK check	166	// Failed FCHECK check
167	testing.expectError(	167	try testing.expectError(
168	error.BadHeader,	168	error.BadHeader,
169	testReader(&[_]u8{ 0x78, 0x9D }, ""),	169	testReader(&[_]u8{ 0x78, 0x9D }, ""),
170	);	170	);
171	// Wrong CM	171	// Wrong CM
172	testing.expectError(	172	try testing.expectError(
173	error.InvalidCompression,	173	error.InvalidCompression,
174	testReader(&[_]u8{ 0x79, 0x94 }, ""),	174	testReader(&[_]u8{ 0x79, 0x94 }, ""),
175	);	175	);
176	// Wrong CINFO	176	// Wrong CINFO
177	testing.expectError(	177	try testing.expectError(
178	error.InvalidWindowSize,	178	error.InvalidWindowSize,
179	testReader(&[_]u8{ 0x88, 0x98 }, ""),	179	testReader(&[_]u8{ 0x88, 0x98 }, ""),
180	);	180	);
181	// Wrong checksum	181	// Wrong checksum
182	testing.expectError(	182	try testing.expectError(
183	error.WrongChecksum,	183	error.WrongChecksum,
184	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, ""),	184	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, ""),
185	);	185	);
186	// Truncated checksum	186	// Truncated checksum
187	testing.expectError(	187	try testing.expectError(
188	error.EndOfStream,	188	error.EndOfStream,
189	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00 }, ""),	189	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00 }, ""),
190	);	190	);

lib/std/comptime_string_map.zig+21-21

lib/std/crypto.zig+2-2

...	@@ -188,7 +188,7 @@ test "CSPRNG" {	...	@@ -188,7 +188,7 @@ test "CSPRNG" {
188	const a = random.int(u64);	188	const a = random.int(u64);
189	const b = random.int(u64);	189	const b = random.int(u64);
190	const c = random.int(u64);	190	const c = random.int(u64);
191	std.testing.expect(a ^ b ^ c != 0);	191	try std.testing.expect(a ^ b ^ c != 0);
192	}	192	}
193		193
194	test "issue #4532: no index out of bounds" {	194	test "issue #4532: no index out of bounds" {
...	@@ -226,6 +226,6 @@ test "issue #4532: no index out of bounds" {	...	@@ -226,6 +226,6 @@ test "issue #4532: no index out of bounds" {
226	h.update(block[1..]);	226	h.update(block[1..]);
227	h.final(&out2);	227	h.final(&out2);
228		228
229	std.testing.expectEqual(out1, out2);	229	try std.testing.expectEqual(out1, out2);
230	}	230	}
231	}	231	}

lib/std/crypto/25519/curve25519.zig+6-6

lib/std/crypto/25519/ed25519.zig+6-6

lib/std/crypto/25519/edwards25519.zig+9-9

lib/std/crypto/25519/ristretto255.zig+5-5

lib/std/crypto/25519/scalar.zig+4-4

lib/std/crypto/25519/x25519.zig+8-8

lib/std/crypto/aegis.zig+20-20

lib/std/crypto/aes.zig+9-9

lib/std/crypto/aes_gcm.zig+8-8

lib/std/crypto/bcrypt.zig+2-2

...	@@ -281,13 +281,13 @@ test "bcrypt codec" {	...	@@ -281,13 +281,13 @@ test "bcrypt codec" {
281	Codec.encode(salt_str[0..], salt[0..]);	281	Codec.encode(salt_str[0..], salt[0..]);
282	var salt2: [salt_length]u8 = undefined;	282	var salt2: [salt_length]u8 = undefined;
283	try Codec.decode(salt2[0..], salt_str[0..]);	283	try Codec.decode(salt2[0..], salt_str[0..]);
284	testing.expectEqualSlices(u8, salt[0..], salt2[0..]);	284	try testing.expectEqualSlices(u8, salt[0..], salt2[0..]);
285	}	285	}
286		286
287	test "bcrypt" {	287	test "bcrypt" {
288	const s = try strHash("password", 5);	288	const s = try strHash("password", 5);
289	try strVerify(s, "password");	289	try strVerify(s, "password");
290	testing.expectError(error.PasswordVerificationFailed, strVerify(s, "invalid password"));	290	try testing.expectError(error.PasswordVerificationFailed, strVerify(s, "invalid password"));
291		291
292	const long_s = try strHash("password" ** 100, 5);	292	const long_s = try strHash("password" ** 100, 5);
293	try strVerify(long_s, "password" ** 100);	293	try strVerify(long_s, "password" ** 100);

lib/std/crypto/blake2.zig+82-82

...	@@ -194,16 +194,16 @@ pub fn Blake2s(comptime out_bits: usize) type {	...	@@ -194,16 +194,16 @@ pub fn Blake2s(comptime out_bits: usize) type {
194		194
195	test "blake2s160 single" {	195	test "blake2s160 single" {
196	const h1 = "354c9c33f735962418bdacb9479873429c34916f";	196	const h1 = "354c9c33f735962418bdacb9479873429c34916f";
197	htest.assertEqualHash(Blake2s160, h1, "");	197	try htest.assertEqualHash(Blake2s160, h1, "");
198		198
199	const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17";	199	const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17";
200	htest.assertEqualHash(Blake2s160, h2, "abc");	200	try htest.assertEqualHash(Blake2s160, h2, "abc");
201		201
202	const h3 = "5a604fec9713c369e84b0ed68daed7d7504ef240";	202	const h3 = "5a604fec9713c369e84b0ed68daed7d7504ef240";
203	htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog");	203	try htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog");
204		204
205	const h4 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";	205	const h4 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
206	htest.assertEqualHash(Blake2s160, h4, "a" 32 ++ "b" 32);	206	try htest.assertEqualHash(Blake2s160, h4, "a" 32 ++ "b" 32);
207	}	207	}
208		208
209	test "blake2s160 streaming" {	209	test "blake2s160 streaming" {
...	@@ -213,21 +213,21 @@ test "blake2s160 streaming" {	...	@@ -213,21 +213,21 @@ test "blake2s160 streaming" {
213	const h1 = "354c9c33f735962418bdacb9479873429c34916f";	213	const h1 = "354c9c33f735962418bdacb9479873429c34916f";
214		214
215	h.final(out[0..]);	215	h.final(out[0..]);
216	htest.assertEqual(h1, out[0..]);	216	try htest.assertEqual(h1, out[0..]);
217		217
218	const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17";	218	const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17";
219		219
220	h = Blake2s160.init(.{});	220	h = Blake2s160.init(.{});
221	h.update("abc");	221	h.update("abc");
222	h.final(out[0..]);	222	h.final(out[0..]);
223	htest.assertEqual(h2, out[0..]);	223	try htest.assertEqual(h2, out[0..]);
224		224
225	h = Blake2s160.init(.{});	225	h = Blake2s160.init(.{});
226	h.update("a");	226	h.update("a");
227	h.update("b");	227	h.update("b");
228	h.update("c");	228	h.update("c");
229	h.final(out[0..]);	229	h.final(out[0..]);
230	htest.assertEqual(h2, out[0..]);	230	try htest.assertEqual(h2, out[0..]);
231		231
232	const h3 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";	232	const h3 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
233		233
...	@@ -235,12 +235,12 @@ test "blake2s160 streaming" {	...	@@ -235,12 +235,12 @@ test "blake2s160 streaming" {
235	h.update("a" ** 32);	235	h.update("a" ** 32);
236	h.update("b" ** 32);	236	h.update("b" ** 32);
237	h.final(out[0..]);	237	h.final(out[0..]);
238	htest.assertEqual(h3, out[0..]);	238	try htest.assertEqual(h3, out[0..]);
239		239
240	h = Blake2s160.init(.{});	240	h = Blake2s160.init(.{});
241	h.update("a" 32 ++ "b" 32);	241	h.update("a" 32 ++ "b" 32);
242	h.final(out[0..]);	242	h.final(out[0..]);
243	htest.assertEqual(h3, out[0..]);	243	try htest.assertEqual(h3, out[0..]);
244		244
245	const h4 = "4667fd60791a7fe41f939bca646b4529e296bd68";	245	const h4 = "4667fd60791a7fe41f939bca646b4529e296bd68";
246		246
...	@@ -248,12 +248,12 @@ test "blake2s160 streaming" {	...	@@ -248,12 +248,12 @@ test "blake2s160 streaming" {
248	h.update("a" ** 32);	248	h.update("a" ** 32);
249	h.update("b" ** 32);	249	h.update("b" ** 32);
250	h.final(out[0..]);	250	h.final(out[0..]);
251	htest.assertEqual(h4, out[0..]);	251	try htest.assertEqual(h4, out[0..]);
252		252
253	h = Blake2s160.init(.{ .context = [_]u8{0x69} 8, .salt = [_]u8{0x42} 8 });	253	h = Blake2s160.init(.{ .context = [_]u8{0x69} 8, .salt = [_]u8{0x42} 8 });
254	h.update("a" 32 ++ "b" 32);	254	h.update("a" 32 ++ "b" 32);
255	h.final(out[0..]);	255	h.final(out[0..]);
256	htest.assertEqual(h4, out[0..]);	256	try htest.assertEqual(h4, out[0..]);
257	}	257	}
258		258
259	test "comptime blake2s160" {	259	test "comptime blake2s160" {
...	@@ -265,28 +265,28 @@ test "comptime blake2s160" {	...	@@ -265,28 +265,28 @@ test "comptime blake2s160" {
265		265
266	const h1 = "2c56ad9d0b2c8b474aafa93ab307db2f0940105f";	266	const h1 = "2c56ad9d0b2c8b474aafa93ab307db2f0940105f";
267		267
268	htest.assertEqualHash(Blake2s160, h1, block[0..]);	268	try htest.assertEqualHash(Blake2s160, h1, block[0..]);
269		269
270	var h = Blake2s160.init(.{});	270	var h = Blake2s160.init(.{});
271	h.update(&block);	271	h.update(&block);
272	h.final(out[0..]);	272	h.final(out[0..]);
273		273
274	htest.assertEqual(h1, out[0..]);	274	try htest.assertEqual(h1, out[0..]);
275	}	275	}
276	}	276	}
277		277
278	test "blake2s224 single" {	278	test "blake2s224 single" {
279	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";	279	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";
280	htest.assertEqualHash(Blake2s224, h1, "");	280	try htest.assertEqualHash(Blake2s224, h1, "");
281		281
282	const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55";	282	const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55";
283	htest.assertEqualHash(Blake2s224, h2, "abc");	283	try htest.assertEqualHash(Blake2s224, h2, "abc");
284		284
285	const h3 = "e4e5cb6c7cae41982b397bf7b7d2d9d1949823ae78435326e8db4912";	285	const h3 = "e4e5cb6c7cae41982b397bf7b7d2d9d1949823ae78435326e8db4912";
286	htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog");	286	try htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog");
287		287
288	const h4 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";	288	const h4 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
289	htest.assertEqualHash(Blake2s224, h4, "a" 32 ++ "b" 32);	289	try htest.assertEqualHash(Blake2s224, h4, "a" 32 ++ "b" 32);
290	}	290	}
291		291
292	test "blake2s224 streaming" {	292	test "blake2s224 streaming" {
...	@@ -296,21 +296,21 @@ test "blake2s224 streaming" {	...	@@ -296,21 +296,21 @@ test "blake2s224 streaming" {
296	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";	296	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";
297		297
298	h.final(out[0..]);	298	h.final(out[0..]);
299	htest.assertEqual(h1, out[0..]);	299	try htest.assertEqual(h1, out[0..]);
300		300
301	const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55";	301	const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55";
302		302
303	h = Blake2s224.init(.{});	303	h = Blake2s224.init(.{});
304	h.update("abc");	304	h.update("abc");
305	h.final(out[0..]);	305	h.final(out[0..]);
306	htest.assertEqual(h2, out[0..]);	306	try htest.assertEqual(h2, out[0..]);
307		307
308	h = Blake2s224.init(.{});	308	h = Blake2s224.init(.{});
309	h.update("a");	309	h.update("a");
310	h.update("b");	310	h.update("b");
311	h.update("c");	311	h.update("c");
312	h.final(out[0..]);	312	h.final(out[0..]);
313	htest.assertEqual(h2, out[0..]);	313	try htest.assertEqual(h2, out[0..]);
314		314
315	const h3 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";	315	const h3 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
316		316
...	@@ -318,12 +318,12 @@ test "blake2s224 streaming" {	...	@@ -318,12 +318,12 @@ test "blake2s224 streaming" {
318	h.update("a" ** 32);	318	h.update("a" ** 32);
319	h.update("b" ** 32);	319	h.update("b" ** 32);
320	h.final(out[0..]);	320	h.final(out[0..]);
321	htest.assertEqual(h3, out[0..]);	321	try htest.assertEqual(h3, out[0..]);
322		322
323	h = Blake2s224.init(.{});	323	h = Blake2s224.init(.{});
324	h.update("a" 32 ++ "b" 32);	324	h.update("a" 32 ++ "b" 32);
325	h.final(out[0..]);	325	h.final(out[0..]);
326	htest.assertEqual(h3, out[0..]);	326	try htest.assertEqual(h3, out[0..]);
327		327
328	const h4 = "a4d6a9d253441b80e5dfd60a04db169ffab77aec56a2855c402828c3";	328	const h4 = "a4d6a9d253441b80e5dfd60a04db169ffab77aec56a2855c402828c3";
329		329
...	@@ -331,12 +331,12 @@ test "blake2s224 streaming" {	...	@@ -331,12 +331,12 @@ test "blake2s224 streaming" {
331	h.update("a" ** 32);	331	h.update("a" ** 32);
332	h.update("b" ** 32);	332	h.update("b" ** 32);
333	h.final(out[0..]);	333	h.final(out[0..]);
334	htest.assertEqual(h4, out[0..]);	334	try htest.assertEqual(h4, out[0..]);
335		335
336	h = Blake2s224.init(.{ .context = [_]u8{0x69} 8, .salt = [_]u8{0x42} 8 });	336	h = Blake2s224.init(.{ .context = [_]u8{0x69} 8, .salt = [_]u8{0x42} 8 });
337	h.update("a" 32 ++ "b" 32);	337	h.update("a" 32 ++ "b" 32);
338	h.final(out[0..]);	338	h.final(out[0..]);
339	htest.assertEqual(h4, out[0..]);	339	try htest.assertEqual(h4, out[0..]);
340	}	340	}
341		341
342	test "comptime blake2s224" {	342	test "comptime blake2s224" {
...	@@ -347,28 +347,28 @@ test "comptime blake2s224" {	...	@@ -347,28 +347,28 @@ test "comptime blake2s224" {
347		347
348	const h1 = "86b7611563293f8c73627df7a6d6ba25ca0548c2a6481f7d116ee576";	348	const h1 = "86b7611563293f8c73627df7a6d6ba25ca0548c2a6481f7d116ee576";
349		349
350	htest.assertEqualHash(Blake2s224, h1, block[0..]);	350	try htest.assertEqualHash(Blake2s224, h1, block[0..]);
351		351
352	var h = Blake2s224.init(.{});	352	var h = Blake2s224.init(.{});
353	h.update(&block);	353	h.update(&block);
354	h.final(out[0..]);	354	h.final(out[0..]);
355		355
356	htest.assertEqual(h1, out[0..]);	356	try htest.assertEqual(h1, out[0..]);
357	}	357	}
358	}	358	}
359		359
360	test "blake2s256 single" {	360	test "blake2s256 single" {
361	const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9";	361	const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9";
362	htest.assertEqualHash(Blake2s256, h1, "");	362	try htest.assertEqualHash(Blake2s256, h1, "");
363		363
364	const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982";	364	const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982";
365	htest.assertEqualHash(Blake2s256, h2, "abc");	365	try htest.assertEqualHash(Blake2s256, h2, "abc");
366		366
367	const h3 = "606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812";	367	const h3 = "606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812";
368	htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog");	368	try htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog");
369		369
370	const h4 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";	370	const h4 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
371	htest.assertEqualHash(Blake2s256, h4, "a" 32 ++ "b" 32);	371	try htest.assertEqualHash(Blake2s256, h4, "a" 32 ++ "b" 32);
372	}	372	}
373		373
374	test "blake2s256 streaming" {	374	test "blake2s256 streaming" {
...	@@ -378,21 +378,21 @@ test "blake2s256 streaming" {	...	@@ -378,21 +378,21 @@ test "blake2s256 streaming" {
378	const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9";	378	const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9";
379		379
380	h.final(out[0..]);	380	h.final(out[0..]);
381	htest.assertEqual(h1, out[0..]);	381	try htest.assertEqual(h1, out[0..]);
382		382
383	const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982";	383	const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982";
384		384
385	h = Blake2s256.init(.{});	385	h = Blake2s256.init(.{});
386	h.update("abc");	386	h.update("abc");
387	h.final(out[0..]);	387	h.final(out[0..]);
388	htest.assertEqual(h2, out[0..]);	388	try htest.assertEqual(h2, out[0..]);
389		389
390	h = Blake2s256.init(.{});	390	h = Blake2s256.init(.{});
391	h.update("a");	391	h.update("a");
392	h.update("b");	392	h.update("b");
393	h.update("c");	393	h.update("c");
394	h.final(out[0..]);	394	h.final(out[0..]);
395	htest.assertEqual(h2, out[0..]);	395	try htest.assertEqual(h2, out[0..]);
396		396
397	const h3 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";	397	const h3 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
398		398
...	@@ -400,12 +400,12 @@ test "blake2s256 streaming" {	...	@@ -400,12 +400,12 @@ test "blake2s256 streaming" {
400	h.update("a" ** 32);	400	h.update("a" ** 32);
401	h.update("b" ** 32);	401	h.update("b" ** 32);
402	h.final(out[0..]);	402	h.final(out[0..]);
403	htest.assertEqual(h3, out[0..]);	403	try htest.assertEqual(h3, out[0..]);
404		404
405	h = Blake2s256.init(.{});	405	h = Blake2s256.init(.{});
406	h.update("a" 32 ++ "b" 32);	406	h.update("a" 32 ++ "b" 32);
407	h.final(out[0..]);	407	h.final(out[0..]);
408	htest.assertEqual(h3, out[0..]);	408	try htest.assertEqual(h3, out[0..]);
409	}	409	}
410		410
411	test "blake2s256 keyed" {	411	test "blake2s256 keyed" {
...	@@ -415,20 +415,20 @@ test "blake2s256 keyed" {	...	@@ -415,20 +415,20 @@ test "blake2s256 keyed" {
415	const key = "secret_key";	415	const key = "secret_key";
416		416
417	Blake2s256.hash("a" 64 ++ "b" 64, &out, .{ .key = key });	417	Blake2s256.hash("a" 64 ++ "b" 64, &out, .{ .key = key });
418	htest.assertEqual(h1, out[0..]);	418	try htest.assertEqual(h1, out[0..]);
419		419
420	var h = Blake2s256.init(.{ .key = key });	420	var h = Blake2s256.init(.{ .key = key });
421	h.update("a" 64 ++ "b" 64);	421	h.update("a" 64 ++ "b" 64);
422	h.final(out[0..]);	422	h.final(out[0..]);
423		423
424	htest.assertEqual(h1, out[0..]);	424	try htest.assertEqual(h1, out[0..]);
425		425
426	h = Blake2s256.init(.{ .key = key });	426	h = Blake2s256.init(.{ .key = key });
427	h.update("a" ** 64);	427	h.update("a" ** 64);
428	h.update("b" ** 64);	428	h.update("b" ** 64);
429	h.final(out[0..]);	429	h.final(out[0..]);
430		430
431	htest.assertEqual(h1, out[0..]);	431	try htest.assertEqual(h1, out[0..]);
432	}	432	}
433		433
434	test "comptime blake2s256" {	434	test "comptime blake2s256" {
...	@@ -439,13 +439,13 @@ test "comptime blake2s256" {	...	@@ -439,13 +439,13 @@ test "comptime blake2s256" {
439		439
440	const h1 = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3";	440	const h1 = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3";
441		441
442	htest.assertEqualHash(Blake2s256, h1, block[0..]);	442	try htest.assertEqualHash(Blake2s256, h1, block[0..]);
443		443
444	var h = Blake2s256.init(.{});	444	var h = Blake2s256.init(.{});
445	h.update(&block);	445	h.update(&block);
446	h.final(out[0..]);	446	h.final(out[0..]);
447		447
448	htest.assertEqual(h1, out[0..]);	448	try htest.assertEqual(h1, out[0..]);
449	}	449	}
450	}	450	}
451		451
...	@@ -617,16 +617,16 @@ pub fn Blake2b(comptime out_bits: usize) type {	...	@@ -617,16 +617,16 @@ pub fn Blake2b(comptime out_bits: usize) type {
617		617
618	test "blake2b160 single" {	618	test "blake2b160 single" {
619	const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2";	619	const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2";
620	htest.assertEqualHash(Blake2b160, h1, "");	620	try htest.assertEqualHash(Blake2b160, h1, "");
621		621
622	const h2 = "384264f676f39536840523f284921cdc68b6846b";	622	const h2 = "384264f676f39536840523f284921cdc68b6846b";
623	htest.assertEqualHash(Blake2b160, h2, "abc");	623	try htest.assertEqualHash(Blake2b160, h2, "abc");
624		624
625	const h3 = "3c523ed102ab45a37d54f5610d5a983162fde84f";	625	const h3 = "3c523ed102ab45a37d54f5610d5a983162fde84f";
626	htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog");	626	try htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog");
627		627
628	const h4 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";	628	const h4 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
629	htest.assertEqualHash(Blake2b160, h4, "a" 64 ++ "b" 64);	629	try htest.assertEqualHash(Blake2b160, h4, "a" 64 ++ "b" 64);
630	}	630	}
631		631
632	test "blake2b160 streaming" {	632	test "blake2b160 streaming" {
...	@@ -636,40 +636,40 @@ test "blake2b160 streaming" {	...	@@ -636,40 +636,40 @@ test "blake2b160 streaming" {
636	const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2";	636	const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2";
637		637
638	h.final(out[0..]);	638	h.final(out[0..]);
639	htest.assertEqual(h1, out[0..]);	639	try htest.assertEqual(h1, out[0..]);
640		640
641	const h2 = "384264f676f39536840523f284921cdc68b6846b";	641	const h2 = "384264f676f39536840523f284921cdc68b6846b";
642		642
643	h = Blake2b160.init(.{});	643	h = Blake2b160.init(.{});
644	h.update("abc");	644	h.update("abc");
645	h.final(out[0..]);	645	h.final(out[0..]);
646	htest.assertEqual(h2, out[0..]);	646	try htest.assertEqual(h2, out[0..]);
647		647
648	h = Blake2b160.init(.{});	648	h = Blake2b160.init(.{});
649	h.update("a");	649	h.update("a");
650	h.update("b");	650	h.update("b");
651	h.update("c");	651	h.update("c");
652	h.final(out[0..]);	652	h.final(out[0..]);
653	htest.assertEqual(h2, out[0..]);	653	try htest.assertEqual(h2, out[0..]);
654		654
655	const h3 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";	655	const h3 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
656		656
657	h = Blake2b160.init(.{});	657	h = Blake2b160.init(.{});
658	h.update("a" 64 ++ "b" 64);	658	h.update("a" 64 ++ "b" 64);
659	h.final(out[0..]);	659	h.final(out[0..]);
660	htest.assertEqual(h3, out[0..]);	660	try htest.assertEqual(h3, out[0..]);
661		661
662	h = Blake2b160.init(.{});	662	h = Blake2b160.init(.{});
663	h.update("a" ** 64);	663	h.update("a" ** 64);
664	h.update("b" ** 64);	664	h.update("b" ** 64);
665	h.final(out[0..]);	665	h.final(out[0..]);
666	htest.assertEqual(h3, out[0..]);	666	try htest.assertEqual(h3, out[0..]);
667		667
668	h = Blake2b160.init(.{});	668	h = Blake2b160.init(.{});
669	h.update("a" ** 64);	669	h.update("a" ** 64);
670	h.update("b" ** 64);	670	h.update("b" ** 64);
671	h.final(out[0..]);	671	h.final(out[0..]);
672	htest.assertEqual(h3, out[0..]);	672	try htest.assertEqual(h3, out[0..]);
673		673
674	const h4 = "72328f8a8200663752fc302d372b5dd9b49dd8dc";	674	const h4 = "72328f8a8200663752fc302d372b5dd9b49dd8dc";
675		675
...	@@ -677,13 +677,13 @@ test "blake2b160 streaming" {	...	@@ -677,13 +677,13 @@ test "blake2b160 streaming" {
677	h.update("a" ** 64);	677	h.update("a" ** 64);
678	h.update("b" ** 64);	678	h.update("b" ** 64);
679	h.final(out[0..]);	679	h.final(out[0..]);
680	htest.assertEqual(h4, out[0..]);	680	try htest.assertEqual(h4, out[0..]);
681		681
682	h = Blake2b160.init(.{ .context = [_]u8{0x69} 16, .salt = [_]u8{0x42} 16 });	682	h = Blake2b160.init(.{ .context = [_]u8{0x69} 16, .salt = [_]u8{0x42} 16 });
683	h.update("a" ** 64);	683	h.update("a" ** 64);
684	h.update("b" ** 64);	684	h.update("b" ** 64);
685	h.final(out[0..]);	685	h.final(out[0..]);
686	htest.assertEqual(h4, out[0..]);	686	try htest.assertEqual(h4, out[0..]);
687	}	687	}
688		688
689	test "comptime blake2b160" {	689	test "comptime blake2b160" {
...	@@ -694,28 +694,28 @@ test "comptime blake2b160" {	...	@@ -694,28 +694,28 @@ test "comptime blake2b160" {
694		694
695	const h1 = "8d26f158f564e3293b42f5e3d34263cb173aa9c9";	695	const h1 = "8d26f158f564e3293b42f5e3d34263cb173aa9c9";
696		696
697	htest.assertEqualHash(Blake2b160, h1, block[0..]);	697	try htest.assertEqualHash(Blake2b160, h1, block[0..]);
698		698
699	var h = Blake2b160.init(.{});	699	var h = Blake2b160.init(.{});
700	h.update(&block);	700	h.update(&block);
701	h.final(out[0..]);	701	h.final(out[0..]);
702		702
703	htest.assertEqual(h1, out[0..]);	703	try htest.assertEqual(h1, out[0..]);
704	}	704	}
705	}	705	}
706		706
707	test "blake2b384 single" {	707	test "blake2b384 single" {
708	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";	708	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";
709	htest.assertEqualHash(Blake2b384, h1, "");	709	try htest.assertEqualHash(Blake2b384, h1, "");
710		710
711	const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4";	711	const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4";
712	htest.assertEqualHash(Blake2b384, h2, "abc");	712	try htest.assertEqualHash(Blake2b384, h2, "abc");
713		713
714	const h3 = "b7c81b228b6bd912930e8f0b5387989691c1cee1e65aade4da3b86a3c9f678fc8018f6ed9e2906720c8d2a3aeda9c03d";	714	const h3 = "b7c81b228b6bd912930e8f0b5387989691c1cee1e65aade4da3b86a3c9f678fc8018f6ed9e2906720c8d2a3aeda9c03d";
715	htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog");	715	try htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog");
716		716
717	const h4 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";	717	const h4 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
718	htest.assertEqualHash(Blake2b384, h4, "a" 64 ++ "b" 64);	718	try htest.assertEqualHash(Blake2b384, h4, "a" 64 ++ "b" 64);
719	}	719	}
720		720
721	test "blake2b384 streaming" {	721	test "blake2b384 streaming" {
...	@@ -725,40 +725,40 @@ test "blake2b384 streaming" {	...	@@ -725,40 +725,40 @@ test "blake2b384 streaming" {
725	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";	725	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";
726		726
727	h.final(out[0..]);	727	h.final(out[0..]);
728	htest.assertEqual(h1, out[0..]);	728	try htest.assertEqual(h1, out[0..]);
729		729
730	const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4";	730	const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4";
731		731
732	h = Blake2b384.init(.{});	732	h = Blake2b384.init(.{});
733	h.update("abc");	733	h.update("abc");
734	h.final(out[0..]);	734	h.final(out[0..]);
735	htest.assertEqual(h2, out[0..]);	735	try htest.assertEqual(h2, out[0..]);
736		736
737	h = Blake2b384.init(.{});	737	h = Blake2b384.init(.{});
738	h.update("a");	738	h.update("a");
739	h.update("b");	739	h.update("b");
740	h.update("c");	740	h.update("c");
741	h.final(out[0..]);	741	h.final(out[0..]);
742	htest.assertEqual(h2, out[0..]);	742	try htest.assertEqual(h2, out[0..]);
743		743
744	const h3 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";	744	const h3 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
745		745
746	h = Blake2b384.init(.{});	746	h = Blake2b384.init(.{});
747	h.update("a" 64 ++ "b" 64);	747	h.update("a" 64 ++ "b" 64);
748	h.final(out[0..]);	748	h.final(out[0..]);
749	htest.assertEqual(h3, out[0..]);	749	try htest.assertEqual(h3, out[0..]);
750		750
751	h = Blake2b384.init(.{});	751	h = Blake2b384.init(.{});
752	h.update("a" ** 64);	752	h.update("a" ** 64);
753	h.update("b" ** 64);	753	h.update("b" ** 64);
754	h.final(out[0..]);	754	h.final(out[0..]);
755	htest.assertEqual(h3, out[0..]);	755	try htest.assertEqual(h3, out[0..]);
756		756
757	h = Blake2b384.init(.{});	757	h = Blake2b384.init(.{});
758	h.update("a" ** 64);	758	h.update("a" ** 64);
759	h.update("b" ** 64);	759	h.update("b" ** 64);
760	h.final(out[0..]);	760	h.final(out[0..]);
761	htest.assertEqual(h3, out[0..]);	761	try htest.assertEqual(h3, out[0..]);
762		762
763	const h4 = "934c48fcb197031c71f583d92f98703510805e72142e0b46f5752d1e971bc86c355d556035613ff7a4154b4de09dac5c";	763	const h4 = "934c48fcb197031c71f583d92f98703510805e72142e0b46f5752d1e971bc86c355d556035613ff7a4154b4de09dac5c";
764		764
...	@@ -766,13 +766,13 @@ test "blake2b384 streaming" {	...	@@ -766,13 +766,13 @@ test "blake2b384 streaming" {
766	h.update("a" ** 64);	766	h.update("a" ** 64);
767	h.update("b" ** 64);	767	h.update("b" ** 64);
768	h.final(out[0..]);	768	h.final(out[0..]);
769	htest.assertEqual(h4, out[0..]);	769	try htest.assertEqual(h4, out[0..]);
770		770
771	h = Blake2b384.init(.{ .context = [_]u8{0x69} 16, .salt = [_]u8{0x42} 16 });	771	h = Blake2b384.init(.{ .context = [_]u8{0x69} 16, .salt = [_]u8{0x42} 16 });
772	h.update("a" ** 64);	772	h.update("a" ** 64);
773	h.update("b" ** 64);	773	h.update("b" ** 64);
774	h.final(out[0..]);	774	h.final(out[0..]);
775	htest.assertEqual(h4, out[0..]);	775	try htest.assertEqual(h4, out[0..]);
776	}	776	}
777		777
778	test "comptime blake2b384" {	778	test "comptime blake2b384" {
...	@@ -783,28 +783,28 @@ test "comptime blake2b384" {	...	@@ -783,28 +783,28 @@ test "comptime blake2b384" {
783		783
784	const h1 = "e8aa1931ea0422e4446fecdd25c16cf35c240b10cb4659dd5c776eddcaa4d922397a589404b46eb2e53d78132d05fd7d";	784	const h1 = "e8aa1931ea0422e4446fecdd25c16cf35c240b10cb4659dd5c776eddcaa4d922397a589404b46eb2e53d78132d05fd7d";
785		785
786	htest.assertEqualHash(Blake2b384, h1, block[0..]);	786	try htest.assertEqualHash(Blake2b384, h1, block[0..]);
787		787
788	var h = Blake2b384.init(.{});	788	var h = Blake2b384.init(.{});
789	h.update(&block);	789	h.update(&block);
790	h.final(out[0..]);	790	h.final(out[0..]);
791		791
792	htest.assertEqual(h1, out[0..]);	792	try htest.assertEqual(h1, out[0..]);
793	}	793	}
794	}	794	}
795		795
796	test "blake2b512 single" {	796	test "blake2b512 single" {
797	const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce";	797	const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce";
798	htest.assertEqualHash(Blake2b512, h1, "");	798	try htest.assertEqualHash(Blake2b512, h1, "");
799		799
800	const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923";	800	const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923";
801	htest.assertEqualHash(Blake2b512, h2, "abc");	801	try htest.assertEqualHash(Blake2b512, h2, "abc");
802		802
803	const h3 = "a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918";	803	const h3 = "a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918";
804	htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog");	804	try htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog");
805		805
806	const h4 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";	806	const h4 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
807	htest.assertEqualHash(Blake2b512, h4, "a" 64 ++ "b" 64);	807	try htest.assertEqualHash(Blake2b512, h4, "a" 64 ++ "b" 64);
808	}	808	}
809		809
810	test "blake2b512 streaming" {	810	test "blake2b512 streaming" {
...	@@ -814,34 +814,34 @@ test "blake2b512 streaming" {	...	@@ -814,34 +814,34 @@ test "blake2b512 streaming" {
814	const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce";	814	const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce";
815		815
816	h.final(out[0..]);	816	h.final(out[0..]);
817	htest.assertEqual(h1, out[0..]);	817	try htest.assertEqual(h1, out[0..]);
818		818
819	const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923";	819	const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923";
820		820
821	h = Blake2b512.init(.{});	821	h = Blake2b512.init(.{});
822	h.update("abc");	822	h.update("abc");
823	h.final(out[0..]);	823	h.final(out[0..]);
824	htest.assertEqual(h2, out[0..]);	824	try htest.assertEqual(h2, out[0..]);
825		825
826	h = Blake2b512.init(.{});	826	h = Blake2b512.init(.{});
827	h.update("a");	827	h.update("a");
828	h.update("b");	828	h.update("b");
829	h.update("c");	829	h.update("c");
830	h.final(out[0..]);	830	h.final(out[0..]);
831	htest.assertEqual(h2, out[0..]);	831	try htest.assertEqual(h2, out[0..]);
832		832
833	const h3 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";	833	const h3 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
834		834
835	h = Blake2b512.init(.{});	835	h = Blake2b512.init(.{});
836	h.update("a" 64 ++ "b" 64);	836	h.update("a" 64 ++ "b" 64);
837	h.final(out[0..]);	837	h.final(out[0..]);
838	htest.assertEqual(h3, out[0..]);	838	try htest.assertEqual(h3, out[0..]);
839		839
840	h = Blake2b512.init(.{});	840	h = Blake2b512.init(.{});
841	h.update("a" ** 64);	841	h.update("a" ** 64);
842	h.update("b" ** 64);	842	h.update("b" ** 64);
843	h.final(out[0..]);	843	h.final(out[0..]);
844	htest.assertEqual(h3, out[0..]);	844	try htest.assertEqual(h3, out[0..]);
845	}	845	}
846		846
847	test "blake2b512 keyed" {	847	test "blake2b512 keyed" {
...	@@ -851,20 +851,20 @@ test "blake2b512 keyed" {	...	@@ -851,20 +851,20 @@ test "blake2b512 keyed" {
851	const key = "secret_key";	851	const key = "secret_key";
852		852
853	Blake2b512.hash("a" 64 ++ "b" 64, &out, .{ .key = key });	853	Blake2b512.hash("a" 64 ++ "b" 64, &out, .{ .key = key });
854	htest.assertEqual(h1, out[0..]);	854	try htest.assertEqual(h1, out[0..]);
855		855
856	var h = Blake2b512.init(.{ .key = key });	856	var h = Blake2b512.init(.{ .key = key });
857	h.update("a" 64 ++ "b" 64);	857	h.update("a" 64 ++ "b" 64);
858	h.final(out[0..]);	858	h.final(out[0..]);
859		859
860	htest.assertEqual(h1, out[0..]);	860	try htest.assertEqual(h1, out[0..]);
861		861
862	h = Blake2b512.init(.{ .key = key });	862	h = Blake2b512.init(.{ .key = key });
863	h.update("a" ** 64);	863	h.update("a" ** 64);
864	h.update("b" ** 64);	864	h.update("b" ** 64);
865	h.final(out[0..]);	865	h.final(out[0..]);
866		866
867	htest.assertEqual(h1, out[0..]);	867	try htest.assertEqual(h1, out[0..]);
868	}	868	}
869		869
870	test "comptime blake2b512" {	870	test "comptime blake2b512" {
...	@@ -875,12 +875,12 @@ test "comptime blake2b512" {	...	@@ -875,12 +875,12 @@ test "comptime blake2b512" {
875		875
876	const h1 = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf798e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41";	876	const h1 = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf798e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41";
877		877
878	htest.assertEqualHash(Blake2b512, h1, block[0..]);	878	try htest.assertEqualHash(Blake2b512, h1, block[0..]);
879		879
880	var h = Blake2b512.init(.{});	880	var h = Blake2b512.init(.{});
881	h.update(&block);	881	h.update(&block);
882	h.final(out[0..]);	882	h.final(out[0..]);
883		883
884	htest.assertEqual(h1, out[0..]);	884	try htest.assertEqual(h1, out[0..]);
885	}	885	}
886	}	886	}

lib/std/crypto/blake3.zig+5-5

lib/std/crypto/chacha20.zig+21-21

lib/std/crypto/ghash.zig+2-2

...	@@ -326,11 +326,11 @@ test "ghash" {	...	@@ -326,11 +326,11 @@ test "ghash" {
326	st.update(&m);	326	st.update(&m);
327	var out: [16]u8 = undefined;	327	var out: [16]u8 = undefined;
328	st.final(&out);	328	st.final(&out);
329	htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out);	329	try htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out);
330		330
331	st = Ghash.init(&key);	331	st = Ghash.init(&key);
332	st.update(m[0..100]);	332	st.update(m[0..100]);
333	st.update(m[100..]);	333	st.update(m[100..]);
334	st.final(&out);	334	st.final(&out);
335	htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out);	335	try htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out);
336	}	336	}

lib/std/crypto/gimli.zig+19-19

lib/std/crypto/hkdf.zig+2-2

...	@@ -65,8 +65,8 @@ test "Hkdf" {	...	@@ -65,8 +65,8 @@ test "Hkdf" {
65	const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };	65	const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
66	const kdf = HkdfSha256;	66	const kdf = HkdfSha256;
67	const prk = kdf.extract(&salt, &ikm);	67	const prk = kdf.extract(&salt, &ikm);
68	htest.assertEqual("077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5", &prk);	68	try htest.assertEqual("077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5", &prk);
69	var out: [42]u8 = undefined;	69	var out: [42]u8 = undefined;
70	kdf.expand(&out, &context, prk);	70	kdf.expand(&out, &context, prk);
71	htest.assertEqual("3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865", &out);	71	try htest.assertEqual("3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865", &out);
72	}	72	}

lib/std/crypto/hmac.zig+6-6

lib/std/crypto/isap.zig+3-3

...	@@ -240,8 +240,8 @@ test "ISAP" {	...	@@ -240,8 +240,8 @@ test "ISAP" {
240	var msg = "test";	240	var msg = "test";
241	var c: [msg.len]u8 = undefined;	241	var c: [msg.len]u8 = undefined;
242	IsapA128A.encrypt(c[0..], &tag, msg[0..], ad, n, k);	242	IsapA128A.encrypt(c[0..], &tag, msg[0..], ad, n, k);
243	testing.expect(mem.eql(u8, &[_]u8{ 0x8f, 0x68, 0x03, 0x8d }, c[0..]));	243	try testing.expect(mem.eql(u8, &[_]u8{ 0x8f, 0x68, 0x03, 0x8d }, c[0..]));
244	testing.expect(mem.eql(u8, &[_]u8{ 0x6c, 0x25, 0xe8, 0xe2, 0xe1, 0x1f, 0x38, 0xe9, 0x80, 0x75, 0xde, 0xd5, 0x2d, 0xb2, 0x31, 0x82 }, tag[0..]));	244	try testing.expect(mem.eql(u8, &[_]u8{ 0x6c, 0x25, 0xe8, 0xe2, 0xe1, 0x1f, 0x38, 0xe9, 0x80, 0x75, 0xde, 0xd5, 0x2d, 0xb2, 0x31, 0x82 }, tag[0..]));
245	try IsapA128A.decrypt(c[0..], c[0..], tag, ad, n, k);	245	try IsapA128A.decrypt(c[0..], c[0..], tag, ad, n, k);
246	testing.expect(mem.eql(u8, msg, c[0..]));	246	try testing.expect(mem.eql(u8, msg, c[0..]));
247	}	247	}

lib/std/crypto/md5.zig+10-10

...	@@ -241,13 +241,13 @@ pub const Md5 = struct {	...	@@ -241,13 +241,13 @@ pub const Md5 = struct {
241	const htest = @import("test.zig");	241	const htest = @import("test.zig");
242		242
243	test "md5 single" {	243	test "md5 single" {
244	htest.assertEqualHash(Md5, "d41d8cd98f00b204e9800998ecf8427e", "");	244	try htest.assertEqualHash(Md5, "d41d8cd98f00b204e9800998ecf8427e", "");
245	htest.assertEqualHash(Md5, "0cc175b9c0f1b6a831c399e269772661", "a");	245	try htest.assertEqualHash(Md5, "0cc175b9c0f1b6a831c399e269772661", "a");
246	htest.assertEqualHash(Md5, "900150983cd24fb0d6963f7d28e17f72", "abc");	246	try htest.assertEqualHash(Md5, "900150983cd24fb0d6963f7d28e17f72", "abc");
247	htest.assertEqualHash(Md5, "f96b697d7cb7938d525a2f31aaf161d0", "message digest");	247	try htest.assertEqualHash(Md5, "f96b697d7cb7938d525a2f31aaf161d0", "message digest");
248	htest.assertEqualHash(Md5, "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz");	248	try htest.assertEqualHash(Md5, "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz");
249	htest.assertEqualHash(Md5, "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");	249	try htest.assertEqualHash(Md5, "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
250	htest.assertEqualHash(Md5, "57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890");	250	try htest.assertEqualHash(Md5, "57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890");
251	}	251	}
252		252
253	test "md5 streaming" {	253	test "md5 streaming" {
...	@@ -255,12 +255,12 @@ test "md5 streaming" {	...	@@ -255,12 +255,12 @@ test "md5 streaming" {
255	var out: [16]u8 = undefined;	255	var out: [16]u8 = undefined;
256		256
257	h.final(out[0..]);	257	h.final(out[0..]);
258	htest.assertEqual("d41d8cd98f00b204e9800998ecf8427e", out[0..]);	258	try htest.assertEqual("d41d8cd98f00b204e9800998ecf8427e", out[0..]);
259		259
260	h = Md5.init(.{});	260	h = Md5.init(.{});
261	h.update("abc");	261	h.update("abc");
262	h.final(out[0..]);	262	h.final(out[0..]);
263	htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]);	263	try htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]);
264		264
265	h = Md5.init(.{});	265	h = Md5.init(.{});
266	h.update("a");	266	h.update("a");
...	@@ -268,7 +268,7 @@ test "md5 streaming" {	...	@@ -268,7 +268,7 @@ test "md5 streaming" {
268	h.update("c");	268	h.update("c");
269	h.final(out[0..]);	269	h.final(out[0..]);
270		270
271	htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]);	271	try htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]);
272	}	272	}
273		273
274	test "md5 aligned final" {	274	test "md5 aligned final" {

lib/std/crypto/pbkdf2.zig+6-6

lib/std/crypto/pcurves/tests.zig+9-9

lib/std/crypto/poly1305.zig+1-1

...	@@ -216,5 +216,5 @@ test "poly1305 rfc7439 vector1" {	...	@@ -216,5 +216,5 @@ test "poly1305 rfc7439 vector1" {
216	var mac: [16]u8 = undefined;	216	var mac: [16]u8 = undefined;
217	Poly1305.create(mac[0..], msg, key);	217	Poly1305.create(mac[0..], msg, key);
218		218
219	std.testing.expectEqualSlices(u8, expected_mac, &mac);	219	try std.testing.expectEqualSlices(u8, expected_mac, &mac);
220	}	220	}

lib/std/crypto/salsa20.zig+3-3

...	@@ -561,11 +561,11 @@ test "(x)salsa20" {	...	@@ -561,11 +561,11 @@ test "(x)salsa20" {
561	var c: [msg.len]u8 = undefined;	561	var c: [msg.len]u8 = undefined;
562		562
563	Salsa20.xor(&c, msg[0..], 0, key, nonce);	563	Salsa20.xor(&c, msg[0..], 0, key, nonce);
564	htest.assertEqual("30ff9933aa6534ff5207142593cd1fca4b23bdd8", c[0..]);	564	try htest.assertEqual("30ff9933aa6534ff5207142593cd1fca4b23bdd8", c[0..]);
565		565
566	const extended_nonce = [_]u8{0x42} ** 24;	566	const extended_nonce = [_]u8{0x42} ** 24;
567	XSalsa20.xor(&c, msg[0..], 0, key, extended_nonce);	567	XSalsa20.xor(&c, msg[0..], 0, key, extended_nonce);
568	htest.assertEqual("b4ab7d82e750ec07644fa3281bce6cd91d4243f9", c[0..]);	568	try htest.assertEqual("b4ab7d82e750ec07644fa3281bce6cd91d4243f9", c[0..]);
569	}	569	}
570		570
571	test "xsalsa20poly1305" {	571	test "xsalsa20poly1305" {
...	@@ -628,5 +628,5 @@ test "secretbox twoblocks" {	...	@@ -628,5 +628,5 @@ test "secretbox twoblocks" {
628	const msg = [_]u8{'a'} ** 97;	628	const msg = [_]u8{'a'} ** 97;
629	var ciphertext: [msg.len + SecretBox.tag_length]u8 = undefined;	629	var ciphertext: [msg.len + SecretBox.tag_length]u8 = undefined;
630	SecretBox.seal(&ciphertext, &msg, nonce, key);	630	SecretBox.seal(&ciphertext, &msg, nonce, key);
631	htest.assertEqual("b05760e217288ba079caa2fd57fd3701784974ffcfda20fe523b89211ad8af065a6eb37cdb29d51aca5bd75dafdd21d18b044c54bb7c526cf576c94ee8900f911ceab0147e82b667a28c52d58ceb29554ff45471224d37b03256b01c119b89ff6d36855de8138d103386dbc9d971f52261", &ciphertext);	631	try htest.assertEqual("b05760e217288ba079caa2fd57fd3701784974ffcfda20fe523b89211ad8af065a6eb37cdb29d51aca5bd75dafdd21d18b044c54bb7c526cf576c94ee8900f911ceab0147e82b667a28c52d58ceb29554ff45471224d37b03256b01c119b89ff6d36855de8138d103386dbc9d971f52261", &ciphertext);
632	}	632	}

lib/std/crypto/sha1.zig+6-6

...	@@ -265,9 +265,9 @@ pub const Sha1 = struct {	...	@@ -265,9 +265,9 @@ pub const Sha1 = struct {
265	const htest = @import("test.zig");	265	const htest = @import("test.zig");
266		266
267	test "sha1 single" {	267	test "sha1 single" {
268	htest.assertEqualHash(Sha1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", "");	268	try htest.assertEqualHash(Sha1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", "");
269	htest.assertEqualHash(Sha1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc");	269	try htest.assertEqualHash(Sha1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc");
270	htest.assertEqualHash(Sha1, "a49b2446a02c645bf419f995b67091253a04a259", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	270	try htest.assertEqualHash(Sha1, "a49b2446a02c645bf419f995b67091253a04a259", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
271	}	271	}
272		272
273	test "sha1 streaming" {	273	test "sha1 streaming" {
...	@@ -275,19 +275,19 @@ test "sha1 streaming" {	...	@@ -275,19 +275,19 @@ test "sha1 streaming" {
275	var out: [20]u8 = undefined;	275	var out: [20]u8 = undefined;
276		276
277	h.final(&out);	277	h.final(&out);
278	htest.assertEqual("da39a3ee5e6b4b0d3255bfef95601890afd80709", out[0..]);	278	try htest.assertEqual("da39a3ee5e6b4b0d3255bfef95601890afd80709", out[0..]);
279		279
280	h = Sha1.init(.{});	280	h = Sha1.init(.{});
281	h.update("abc");	281	h.update("abc");
282	h.final(&out);	282	h.final(&out);
283	htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]);	283	try htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]);
284		284
285	h = Sha1.init(.{});	285	h = Sha1.init(.{});
286	h.update("a");	286	h.update("a");
287	h.update("b");	287	h.update("b");
288	h.update("c");	288	h.update("c");
289	h.final(&out);	289	h.final(&out);
290	htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]);	290	try htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]);
291	}	291	}
292		292
293	test "sha1 aligned final" {	293	test "sha1 aligned final" {

lib/std/crypto/sha2.zig+24-24

...	@@ -285,9 +285,9 @@ fn Sha2x32(comptime params: Sha2Params32) type {	...	@@ -285,9 +285,9 @@ fn Sha2x32(comptime params: Sha2Params32) type {
285	}	285	}
286		286
287	test "sha224 single" {	287	test "sha224 single" {
288	htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");	288	try htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");
289	htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc");	289	try htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc");
290	htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	290	try htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
291	}	291	}
292		292
293	test "sha224 streaming" {	293	test "sha224 streaming" {
...	@@ -295,25 +295,25 @@ test "sha224 streaming" {	...	@@ -295,25 +295,25 @@ test "sha224 streaming" {
295	var out: [28]u8 = undefined;	295	var out: [28]u8 = undefined;
296		296
297	h.final(out[0..]);	297	h.final(out[0..]);
298	htest.assertEqual("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", out[0..]);	298	try htest.assertEqual("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", out[0..]);
299		299
300	h = Sha224.init(.{});	300	h = Sha224.init(.{});
301	h.update("abc");	301	h.update("abc");
302	h.final(out[0..]);	302	h.final(out[0..]);
303	htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]);	303	try htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]);
304		304
305	h = Sha224.init(.{});	305	h = Sha224.init(.{});
306	h.update("a");	306	h.update("a");
307	h.update("b");	307	h.update("b");
308	h.update("c");	308	h.update("c");
309	h.final(out[0..]);	309	h.final(out[0..]);
310	htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]);	310	try htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]);
311	}	311	}
312		312
313	test "sha256 single" {	313	test "sha256 single" {
314	htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "");	314	try htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "");
315	htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc");	315	try htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc");
316	htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	316	try htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
317	}	317	}
318		318
319	test "sha256 streaming" {	319	test "sha256 streaming" {
...	@@ -321,19 +321,19 @@ test "sha256 streaming" {	...	@@ -321,19 +321,19 @@ test "sha256 streaming" {
321	var out: [32]u8 = undefined;	321	var out: [32]u8 = undefined;
322		322
323	h.final(out[0..]);	323	h.final(out[0..]);
324	htest.assertEqual("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", out[0..]);	324	try htest.assertEqual("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", out[0..]);
325		325
326	h = Sha256.init(.{});	326	h = Sha256.init(.{});
327	h.update("abc");	327	h.update("abc");
328	h.final(out[0..]);	328	h.final(out[0..]);
329	htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]);	329	try htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]);
330		330
331	h = Sha256.init(.{});	331	h = Sha256.init(.{});
332	h.update("a");	332	h.update("a");
333	h.update("b");	333	h.update("b");
334	h.update("c");	334	h.update("c");
335	h.final(out[0..]);	335	h.final(out[0..]);
336	htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]);	336	try htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]);
337	}	337	}
338		338
339	test "sha256 aligned final" {	339	test "sha256 aligned final" {
...	@@ -675,13 +675,13 @@ fn Sha2x64(comptime params: Sha2Params64) type {	...	@@ -675,13 +675,13 @@ fn Sha2x64(comptime params: Sha2Params64) type {
675		675
676	test "sha384 single" {	676	test "sha384 single" {
677	const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";	677	const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";
678	htest.assertEqualHash(Sha384, h1, "");	678	try htest.assertEqualHash(Sha384, h1, "");
679		679
680	const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7";	680	const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7";
681	htest.assertEqualHash(Sha384, h2, "abc");	681	try htest.assertEqualHash(Sha384, h2, "abc");
682		682
683	const h3 = "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039";	683	const h3 = "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039";
684	htest.assertEqualHash(Sha384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	684	try htest.assertEqualHash(Sha384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
685	}	685	}
686		686
687	test "sha384 streaming" {	687	test "sha384 streaming" {
...	@@ -690,32 +690,32 @@ test "sha384 streaming" {	...	@@ -690,32 +690,32 @@ test "sha384 streaming" {
690		690
691	const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";	691	const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";
692	h.final(out[0..]);	692	h.final(out[0..]);
693	htest.assertEqual(h1, out[0..]);	693	try htest.assertEqual(h1, out[0..]);
694		694
695	const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7";	695	const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7";
696		696
697	h = Sha384.init(.{});	697	h = Sha384.init(.{});
698	h.update("abc");	698	h.update("abc");
699	h.final(out[0..]);	699	h.final(out[0..]);
700	htest.assertEqual(h2, out[0..]);	700	try htest.assertEqual(h2, out[0..]);
701		701
702	h = Sha384.init(.{});	702	h = Sha384.init(.{});
703	h.update("a");	703	h.update("a");
704	h.update("b");	704	h.update("b");
705	h.update("c");	705	h.update("c");
706	h.final(out[0..]);	706	h.final(out[0..]);
707	htest.assertEqual(h2, out[0..]);	707	try htest.assertEqual(h2, out[0..]);
708	}	708	}
709		709
710	test "sha512 single" {	710	test "sha512 single" {
711	const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e";	711	const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e";
712	htest.assertEqualHash(Sha512, h1, "");	712	try htest.assertEqualHash(Sha512, h1, "");
713		713
714	const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";	714	const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";
715	htest.assertEqualHash(Sha512, h2, "abc");	715	try htest.assertEqualHash(Sha512, h2, "abc");
716		716
717	const h3 = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909";	717	const h3 = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909";
718	htest.assertEqualHash(Sha512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	718	try htest.assertEqualHash(Sha512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
719	}	719	}
720		720
721	test "sha512 streaming" {	721	test "sha512 streaming" {
...	@@ -724,21 +724,21 @@ test "sha512 streaming" {	...	@@ -724,21 +724,21 @@ test "sha512 streaming" {
724		724
725	const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e";	725	const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e";
726	h.final(out[0..]);	726	h.final(out[0..]);
727	htest.assertEqual(h1, out[0..]);	727	try htest.assertEqual(h1, out[0..]);
728		728
729	const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";	729	const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";
730		730
731	h = Sha512.init(.{});	731	h = Sha512.init(.{});
732	h.update("abc");	732	h.update("abc");
733	h.final(out[0..]);	733	h.final(out[0..]);
734	htest.assertEqual(h2, out[0..]);	734	try htest.assertEqual(h2, out[0..]);
735		735
736	h = Sha512.init(.{});	736	h = Sha512.init(.{});
737	h.update("a");	737	h.update("a");
738	h.update("b");	738	h.update("b");
739	h.update("c");	739	h.update("c");
740	h.final(out[0..]);	740	h.final(out[0..]);
741	htest.assertEqual(h2, out[0..]);	741	try htest.assertEqual(h2, out[0..]);
742	}	742	}
743		743
744	test "sha512 aligned final" {	744	test "sha512 aligned final" {

lib/std/crypto/sha3.zig+30-30

...	@@ -169,9 +169,9 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {	...	@@ -169,9 +169,9 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {
169	}	169	}
170		170
171	test "sha3-224 single" {	171	test "sha3-224 single" {
172	htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", "");	172	try htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", "");
173	htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc");	173	try htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc");
174	htest.assertEqualHash(Sha3_224, "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	174	try htest.assertEqualHash(Sha3_224, "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
175	}	175	}
176		176
177	test "sha3-224 streaming" {	177	test "sha3-224 streaming" {
...	@@ -179,25 +179,25 @@ test "sha3-224 streaming" {	...	@@ -179,25 +179,25 @@ test "sha3-224 streaming" {
179	var out: [28]u8 = undefined;	179	var out: [28]u8 = undefined;
180		180
181	h.final(out[0..]);	181	h.final(out[0..]);
182	htest.assertEqual("6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", out[0..]);	182	try htest.assertEqual("6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", out[0..]);
183		183
184	h = Sha3_224.init(.{});	184	h = Sha3_224.init(.{});
185	h.update("abc");	185	h.update("abc");
186	h.final(out[0..]);	186	h.final(out[0..]);
187	htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);	187	try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);
188		188
189	h = Sha3_224.init(.{});	189	h = Sha3_224.init(.{});
190	h.update("a");	190	h.update("a");
191	h.update("b");	191	h.update("b");
192	h.update("c");	192	h.update("c");
193	h.final(out[0..]);	193	h.final(out[0..]);
194	htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);	194	try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]);
195	}	195	}
196		196
197	test "sha3-256 single" {	197	test "sha3-256 single" {
198	htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", "");	198	try htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", "");
199	htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc");	199	try htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc");
200	htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	200	try htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
201	}	201	}
202		202
203	test "sha3-256 streaming" {	203	test "sha3-256 streaming" {
...	@@ -205,19 +205,19 @@ test "sha3-256 streaming" {	...	@@ -205,19 +205,19 @@ test "sha3-256 streaming" {
205	var out: [32]u8 = undefined;	205	var out: [32]u8 = undefined;
206		206
207	h.final(out[0..]);	207	h.final(out[0..]);
208	htest.assertEqual("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", out[0..]);	208	try htest.assertEqual("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", out[0..]);
209		209
210	h = Sha3_256.init(.{});	210	h = Sha3_256.init(.{});
211	h.update("abc");	211	h.update("abc");
212	h.final(out[0..]);	212	h.final(out[0..]);
213	htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);	213	try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);
214		214
215	h = Sha3_256.init(.{});	215	h = Sha3_256.init(.{});
216	h.update("a");	216	h.update("a");
217	h.update("b");	217	h.update("b");
218	h.update("c");	218	h.update("c");
219	h.final(out[0..]);	219	h.final(out[0..]);
220	htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);	220	try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]);
221	}	221	}
222		222
223	test "sha3-256 aligned final" {	223	test "sha3-256 aligned final" {
...	@@ -231,11 +231,11 @@ test "sha3-256 aligned final" {	...	@@ -231,11 +231,11 @@ test "sha3-256 aligned final" {
231		231
232	test "sha3-384 single" {	232	test "sha3-384 single" {
233	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";	233	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
234	htest.assertEqualHash(Sha3_384, h1, "");	234	try htest.assertEqualHash(Sha3_384, h1, "");
235	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";	235	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";
236	htest.assertEqualHash(Sha3_384, h2, "abc");	236	try htest.assertEqualHash(Sha3_384, h2, "abc");
237	const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7";	237	const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7";
238	htest.assertEqualHash(Sha3_384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	238	try htest.assertEqualHash(Sha3_384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
239	}	239	}
240		240
241	test "sha3-384 streaming" {	241	test "sha3-384 streaming" {
...	@@ -244,29 +244,29 @@ test "sha3-384 streaming" {	...	@@ -244,29 +244,29 @@ test "sha3-384 streaming" {
244		244
245	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";	245	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
246	h.final(out[0..]);	246	h.final(out[0..]);
247	htest.assertEqual(h1, out[0..]);	247	try htest.assertEqual(h1, out[0..]);
248		248
249	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";	249	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";
250	h = Sha3_384.init(.{});	250	h = Sha3_384.init(.{});
251	h.update("abc");	251	h.update("abc");
252	h.final(out[0..]);	252	h.final(out[0..]);
253	htest.assertEqual(h2, out[0..]);	253	try htest.assertEqual(h2, out[0..]);
254		254
255	h = Sha3_384.init(.{});	255	h = Sha3_384.init(.{});
256	h.update("a");	256	h.update("a");
257	h.update("b");	257	h.update("b");
258	h.update("c");	258	h.update("c");
259	h.final(out[0..]);	259	h.final(out[0..]);
260	htest.assertEqual(h2, out[0..]);	260	try htest.assertEqual(h2, out[0..]);
261	}	261	}
262		262
263	test "sha3-512 single" {	263	test "sha3-512 single" {
264	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";	264	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
265	htest.assertEqualHash(Sha3_512, h1, "");	265	try htest.assertEqualHash(Sha3_512, h1, "");
266	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";	266	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";
267	htest.assertEqualHash(Sha3_512, h2, "abc");	267	try htest.assertEqualHash(Sha3_512, h2, "abc");
268	const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185";	268	const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185";
269	htest.assertEqualHash(Sha3_512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	269	try htest.assertEqualHash(Sha3_512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
270	}	270	}
271		271
272	test "sha3-512 streaming" {	272	test "sha3-512 streaming" {
...	@@ -275,20 +275,20 @@ test "sha3-512 streaming" {	...	@@ -275,20 +275,20 @@ test "sha3-512 streaming" {
275		275
276	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";	276	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
277	h.final(out[0..]);	277	h.final(out[0..]);
278	htest.assertEqual(h1, out[0..]);	278	try htest.assertEqual(h1, out[0..]);
279		279
280	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";	280	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";
281	h = Sha3_512.init(.{});	281	h = Sha3_512.init(.{});
282	h.update("abc");	282	h.update("abc");
283	h.final(out[0..]);	283	h.final(out[0..]);
284	htest.assertEqual(h2, out[0..]);	284	try htest.assertEqual(h2, out[0..]);
285		285
286	h = Sha3_512.init(.{});	286	h = Sha3_512.init(.{});
287	h.update("a");	287	h.update("a");
288	h.update("b");	288	h.update("b");
289	h.update("c");	289	h.update("c");
290	h.final(out[0..]);	290	h.final(out[0..]);
291	htest.assertEqual(h2, out[0..]);	291	try htest.assertEqual(h2, out[0..]);
292	}	292	}
293		293
294	test "sha3-512 aligned final" {	294	test "sha3-512 aligned final" {
...	@@ -301,13 +301,13 @@ test "sha3-512 aligned final" {	...	@@ -301,13 +301,13 @@ test "sha3-512 aligned final" {
301	}	301	}
302		302
303	test "keccak-256 single" {	303	test "keccak-256 single" {
304	htest.assertEqualHash(Keccak_256, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "");	304	try htest.assertEqualHash(Keccak_256, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "");
305	htest.assertEqualHash(Keccak_256, "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", "abc");	305	try htest.assertEqualHash(Keccak_256, "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", "abc");
306	htest.assertEqualHash(Keccak_256, "f519747ed599024f3882238e5ab43960132572b7345fbeb9a90769dafd21ad67", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	306	try htest.assertEqualHash(Keccak_256, "f519747ed599024f3882238e5ab43960132572b7345fbeb9a90769dafd21ad67", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
307	}	307	}
308		308
309	test "keccak-512 single" {	309	test "keccak-512 single" {
310	htest.assertEqualHash(Keccak_512, "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", "");	310	try htest.assertEqualHash(Keccak_512, "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", "");
311	htest.assertEqualHash(Keccak_512, "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc");	311	try htest.assertEqualHash(Keccak_512, "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc");
312	htest.assertEqualHash(Keccak_512, "ac2fb35251825d3aa48468a9948c0a91b8256f6d97d8fa4160faff2dd9dfcc24f3f1db7a983dad13d53439ccac0b37e24037e7b95f80f59f37a2f683c4ba4682", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	312	try htest.assertEqualHash(Keccak_512, "ac2fb35251825d3aa48468a9948c0a91b8256f6d97d8fa4160faff2dd9dfcc24f3f1db7a983dad13d53439ccac0b37e24037e7b95f80f59f37a2f683c4ba4682", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
313	}	313	}

lib/std/crypto/siphash.zig+3-3

...	@@ -319,7 +319,7 @@ test "siphash64-2-4 sanity" {	...	@@ -319,7 +319,7 @@ test "siphash64-2-4 sanity" {
319		319
320	var out: [siphash.mac_length]u8 = undefined;	320	var out: [siphash.mac_length]u8 = undefined;
321	siphash.create(&out, buffer[0..i], test_key);	321	siphash.create(&out, buffer[0..i], test_key);
322	testing.expectEqual(out, vector);	322	try testing.expectEqual(out, vector);
323	}	323	}
324	}	324	}
325		325
...	@@ -399,7 +399,7 @@ test "siphash128-2-4 sanity" {	...	@@ -399,7 +399,7 @@ test "siphash128-2-4 sanity" {
399		399
400	var out: [siphash.mac_length]u8 = undefined;	400	var out: [siphash.mac_length]u8 = undefined;
401	siphash.create(&out, buffer[0..i], test_key[0..]);	401	siphash.create(&out, buffer[0..i], test_key[0..]);
402	testing.expectEqual(out, vector);	402	try testing.expectEqual(out, vector);
403	}	403	}
404	}	404	}
405		405
...	@@ -423,6 +423,6 @@ test "iterative non-divisible update" {	...	@@ -423,6 +423,6 @@ test "iterative non-divisible update" {
423	}	423	}
424	const iterative_hash = siphash.finalInt();	424	const iterative_hash = siphash.finalInt();
425		425
426	std.testing.expectEqual(iterative_hash, non_iterative_hash);	426	try std.testing.expectEqual(iterative_hash, non_iterative_hash);
427	}	427	}
428	}	428	}

lib/std/crypto/test.zig+4-4

...	@@ -8,19 +8,19 @@ const testing = std.testing;	...	@@ -8,19 +8,19 @@ const testing = std.testing;
8	const fmt = std.fmt;	8	const fmt = std.fmt;
9		9
10	// Hash using the specified hasher `H` asserting `expected == H(input)`.	10	// Hash using the specified hasher `H` asserting `expected == H(input)`.
11	pub fn assertEqualHash(comptime Hasher: anytype, comptime expected_hex: const [Hasher.digest_length 2:0]u8, input: []const u8) void {	11	pub fn assertEqualHash(comptime Hasher: anytype, comptime expected_hex: const [Hasher.digest_length 2:0]u8, input: []const u8) !void {
12	var h: [Hasher.digest_length]u8 = undefined;	12	var h: [Hasher.digest_length]u8 = undefined;
13	Hasher.hash(input, &h, .{});	13	Hasher.hash(input, &h, .{});
14		14
15	assertEqual(expected_hex, &h);	15	try assertEqual(expected_hex, &h);
16	}	16	}
17		17
18	// Assert `expected` == hex(`input`) where `input` is a bytestring	18	// Assert `expected` == hex(`input`) where `input` is a bytestring
19	pub fn assertEqual(comptime expected_hex: [:0]const u8, input: []const u8) void {	19	pub fn assertEqual(comptime expected_hex: [:0]const u8, input: []const u8) !void {
20	var expected_bytes: [expected_hex.len / 2]u8 = undefined;	20	var expected_bytes: [expected_hex.len / 2]u8 = undefined;
21	for (expected_bytes) \|*r, i\| {	21	for (expected_bytes) \|*r, i\| {
22	r.* = fmt.parseInt(u8, expected_hex[2 * i .. 2 * i + 2], 16) catch unreachable;	22	r.* = fmt.parseInt(u8, expected_hex[2 * i .. 2 * i + 2], 16) catch unreachable;
23	}	23	}
24		24
25	testing.expectEqualSlices(u8, &expected_bytes, input);	25	try testing.expectEqualSlices(u8, &expected_bytes, input);
26	}	26	}

lib/std/crypto/utils.zig+11-11

lib/std/cstr.zig+7-7

lib/std/dynamic_library.zig+1-1

...	@@ -408,7 +408,7 @@ test "dynamic_library" {	...	@@ -408,7 +408,7 @@ test "dynamic_library" {
408	};	408	};
409		409
410	const dynlib = DynLib.open(libname) catch \|err\| {	410	const dynlib = DynLib.open(libname) catch \|err\| {
411	testing.expect(err == error.FileNotFound);	411	try testing.expect(err == error.FileNotFound);
412	return;	412	return;
413	};	413	};
414	}	414	}

lib/std/elf.zig+1-1

...	@@ -565,7 +565,7 @@ test "bswapAllFields" {	...	@@ -565,7 +565,7 @@ test "bswapAllFields" {
565	.ch_addralign = 0x12124242,	565	.ch_addralign = 0x12124242,
566	};	566	};
567	bswapAllFields(Elf32_Chdr, &s);	567	bswapAllFields(Elf32_Chdr, &s);
568	std.testing.expectEqual(Elf32_Chdr{	568	try std.testing.expectEqual(Elf32_Chdr{
569	.ch_type = 0x34123412,	569	.ch_type = 0x34123412,
570	.ch_size = 0x78567856,	570	.ch_size = 0x78567856,
571	.ch_addralign = 0x42421212,	571	.ch_addralign = 0x42421212,

lib/std/enums.zig+275-275

lib/std/event/batch.zig+2-2

...	@@ -119,12 +119,12 @@ test "std.event.Batch" {	...	@@ -119,12 +119,12 @@ test "std.event.Batch" {
119	batch.add(&async sleepALittle(&count));	119	batch.add(&async sleepALittle(&count));
120	batch.add(&async increaseByTen(&count));	120	batch.add(&async increaseByTen(&count));
121	batch.wait();	121	batch.wait();
122	testing.expect(count == 11);	122	try testing.expect(count == 11);
123		123
124	var another = Batch(anyerror!void, 2, .auto_async).init();	124	var another = Batch(anyerror!void, 2, .auto_async).init();
125	another.add(&async somethingElse());	125	another.add(&async somethingElse());
126	another.add(&async doSomethingThatFails());	126	another.add(&async doSomethingThatFails());
127	testing.expectError(error.ItBroke, another.wait());	127	try testing.expectError(error.ItBroke, another.wait());
128	}	128	}
129		129
130	fn sleepALittle(count: *usize) void {	130	fn sleepALittle(count: *usize) void {

lib/std/event/channel.zig+7-7

lib/std/event/future.zig+1-1

...	@@ -107,7 +107,7 @@ fn testFuture() void {	...	@@ -107,7 +107,7 @@ fn testFuture() void {
107		107
108	const result = (await a) + (await b);	108	const result = (await a) + (await b);
109		109
110	testing.expect(result == 12);	110	try testing.expect(result == 12);
111	}	111	}
112		112
113	fn waitOnFuture(future: *Future(i32)) i32 {	113	fn waitOnFuture(future: *Future(i32)) i32 {

lib/std/event/group.zig+2-2

...	@@ -140,14 +140,14 @@ fn testGroup(allocator: *Allocator) callconv(.Async) void {	...	@@ -140,14 +140,14 @@ fn testGroup(allocator: *Allocator) callconv(.Async) void {
140	var increase_by_ten_frame = async increaseByTen(&count);	140	var increase_by_ten_frame = async increaseByTen(&count);
141	group.add(&increase_by_ten_frame) catch @panic("memory");	141	group.add(&increase_by_ten_frame) catch @panic("memory");
142	group.wait();	142	group.wait();
143	testing.expect(count == 11);	143	try testing.expect(count == 11);
144		144
145	var another = Group(anyerror!void).init(allocator);	145	var another = Group(anyerror!void).init(allocator);
146	var something_else_frame = async somethingElse();	146	var something_else_frame = async somethingElse();
147	another.add(&something_else_frame) catch @panic("memory");	147	another.add(&something_else_frame) catch @panic("memory");
148	var something_that_fails_frame = async doSomethingThatFails();	148	var something_that_fails_frame = async doSomethingThatFails();
149	another.add(&something_that_fails_frame) catch @panic("memory");	149	another.add(&something_that_fails_frame) catch @panic("memory");
150	testing.expectError(error.ItBroke, another.wait());	150	try testing.expectError(error.ItBroke, another.wait());
151	}	151	}
152	fn sleepALittle(count: *usize) callconv(.Async) void {	152	fn sleepALittle(count: *usize) callconv(.Async) void {
153	std.time.sleep(1 * std.time.ns_per_ms);	153	std.time.sleep(1 * std.time.ns_per_ms);

lib/std/event/lock.zig+1-1

...	@@ -136,7 +136,7 @@ test "std.event.Lock" {	...	@@ -136,7 +136,7 @@ test "std.event.Lock" {
136	testLock(&lock);	136	testLock(&lock);
137		137
138	const expected_result = [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;	138	const expected_result = [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;
139	testing.expectEqualSlices(i32, &expected_result, &shared_test_data);	139	try testing.expectEqualSlices(i32, &expected_result, &shared_test_data);
140	}	140	}
141	fn testLock(lock: *Lock) void {	141	fn testLock(lock: *Lock) void {
142	var handle1 = async lockRunner(lock);	142	var handle1 = async lockRunner(lock);

lib/std/event/loop.zig+3-3

lib/std/event/rwlock.zig+3-3

...	@@ -228,7 +228,7 @@ test "std.event.RwLock" {	...	@@ -228,7 +228,7 @@ test "std.event.RwLock" {
228	const handle = testLock(std.heap.page_allocator, &lock);	228	const handle = testLock(std.heap.page_allocator, &lock);
229		229
230	const expected_result = [1]i32{shared_it_count * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;	230	const expected_result = [1]i32{shared_it_count * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;
231	testing.expectEqualSlices(i32, expected_result, shared_test_data);	231	try testing.expectEqualSlices(i32, expected_result, shared_test_data);
232	}	232	}
233	fn testLock(allocator: Allocator, lock: RwLock) callconv(.Async) void {	233	fn testLock(allocator: Allocator, lock: RwLock) callconv(.Async) void {
234	var read_nodes: [100]Loop.NextTickNode = undefined;	234	var read_nodes: [100]Loop.NextTickNode = undefined;
...	@@ -290,7 +290,7 @@ fn readRunner(lock: *RwLock) callconv(.Async) void {	...	@@ -290,7 +290,7 @@ fn readRunner(lock: *RwLock) callconv(.Async) void {
290	const handle = await lock_promise;	290	const handle = await lock_promise;
291	defer handle.release();	291	defer handle.release();
292		292
293	testing.expect(shared_test_index == 0);	293	try testing.expect(shared_test_index == 0);
294	testing.expect(shared_test_data[i] == @intCast(i32, shared_count));	294	try testing.expect(shared_test_data[i] == @intCast(i32, shared_count));
295	}	295	}
296	}	296	}

lib/std/fifo.zig+38-38

lib/std/fmt.zig+77-77

lib/std/fmt/parse_float.zig+29-29

lib/std/fmt/parse_hex_float.zig+13-13

lib/std/fs/path.zig+205-205

lib/std/fs/test.zig+52-52

lib/std/fs/wasi.zig+3-3

...	@@ -174,8 +174,8 @@ test "extracting WASI preopens" {	...	@@ -174,8 +174,8 @@ test "extracting WASI preopens" {
174		174
175	try preopens.populate();	175	try preopens.populate();
176		176
177	std.testing.expectEqual(@as(usize, 1), preopens.asSlice().len);	177	try std.testing.expectEqual(@as(usize, 1), preopens.asSlice().len);
178	const preopen = preopens.find(PreopenType{ .Dir = "." }) orelse unreachable;	178	const preopen = preopens.find(PreopenType{ .Dir = "." }) orelse unreachable;
179	std.testing.expect(preopen.@"type".eql(PreopenType{ .Dir = "." }));	179	try std.testing.expect(preopen.@"type".eql(PreopenType{ .Dir = "." }));
180	std.testing.expectEqual(@as(usize, 3), preopen.fd);	180	try std.testing.expectEqual(@as(usize, 3), preopen.fd);
181	}	181	}

lib/std/fs/watch.zig+3-3

...	@@ -662,13 +662,13 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void {	...	@@ -662,13 +662,13 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void {
662		662
663	const read_contents = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);	663	const read_contents = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);
664	defer allocator.free(read_contents);	664	defer allocator.free(read_contents);
665	testing.expectEqualSlices(u8, contents, read_contents);	665	try testing.expectEqualSlices(u8, contents, read_contents);
666		666
667	// now watch the file	667	// now watch the file
668	var watch = try Watch(void).init(allocator, 0);	668	var watch = try Watch(void).init(allocator, 0);
669	defer watch.deinit();	669	defer watch.deinit();
670		670
671	testing.expect((try watch.addFile(file_path, {})) == null);	671	try testing.expect((try watch.addFile(file_path, {})) == null);
672		672
673	var ev = async watch.channel.get();	673	var ev = async watch.channel.get();
674	var ev_consumed = false;	674	var ev_consumed = false;
...	@@ -698,7 +698,7 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void {	...	@@ -698,7 +698,7 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void {
698	const contents_updated = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);	698	const contents_updated = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);
699	defer allocator.free(contents_updated);	699	defer allocator.free(contents_updated);
700		700
701	testing.expectEqualSlices(u8,	701	try testing.expectEqualSlices(u8,
702	\\line 1	702	\\line 1
703	\\lorem ipsum	703	\\lorem ipsum
704	, contents_updated);	704	, contents_updated);

lib/std/hash/adler.zig+6-6

lib/std/hash/auto_hash.zig+46-46

lib/std/hash/cityhash.zig+7-7

...	@@ -381,14 +381,14 @@ fn CityHash32hashIgnoreSeed(str: []const u8, seed: u32) u32 {	...	@@ -381,14 +381,14 @@ fn CityHash32hashIgnoreSeed(str: []const u8, seed: u32) u32 {
381		381
382	test "cityhash32" {	382	test "cityhash32" {
383	const Test = struct {	383	const Test = struct {
384	fn doTest() void {	384	fn doTest() !void {
385	// Note: SMHasher doesn't provide a 32bit version of the algorithm.	385	// Note: SMHasher doesn't provide a 32bit version of the algorithm.
386	// Note: The implementation was verified against the Google Abseil version.	386	// Note: The implementation was verified against the Google Abseil version.
387	std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81);	387	try std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81);
388	std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81);	388	try std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81);
389	}	389	}
390	};	390	};
391	Test.doTest();	391	try Test.doTest();
392	// TODO This is uncommented to prevent OOM on the CI server. Re-enable this test	392	// TODO This is uncommented to prevent OOM on the CI server. Re-enable this test
393	// case once we ship stage2.	393	// case once we ship stage2.
394	//@setEvalBranchQuota(50000);	394	//@setEvalBranchQuota(50000);
...	@@ -397,13 +397,13 @@ test "cityhash32" {	...	@@ -397,13 +397,13 @@ test "cityhash32" {
397		397
398	test "cityhash64" {	398	test "cityhash64" {
399	const Test = struct {	399	const Test = struct {
400	fn doTest() void {	400	fn doTest() !void {
401	// Note: This is not compliant with the SMHasher implementation of CityHash64!	401	// Note: This is not compliant with the SMHasher implementation of CityHash64!
402	// Note: The implementation was verified against the Google Abseil version.	402	// Note: The implementation was verified against the Google Abseil version.
403	std.testing.expectEqual(SMHasherTest(CityHash64.hashWithSeed), 0x5FABC5C5);	403	try std.testing.expectEqual(SMHasherTest(CityHash64.hashWithSeed), 0x5FABC5C5);
404	}	404	}
405	};	405	};
406	Test.doTest();	406	try Test.doTest();
407	// TODO This is uncommented to prevent OOM on the CI server. Re-enable this test	407	// TODO This is uncommented to prevent OOM on the CI server. Re-enable this test
408	// case once we ship stage2.	408	// case once we ship stage2.
409	//@setEvalBranchQuota(50000);	409	//@setEvalBranchQuota(50000);

lib/std/hash/crc.zig+12-12

lib/std/hash/fnv.zig+8-8

...	@@ -46,18 +46,18 @@ fn Fnv1a(comptime T: type, comptime prime: T, comptime offset: T) type {	...	@@ -46,18 +46,18 @@ fn Fnv1a(comptime T: type, comptime prime: T, comptime offset: T) type {
46	}	46	}
47		47
48	test "fnv1a-32" {	48	test "fnv1a-32" {
49	testing.expect(Fnv1a_32.hash("") == 0x811c9dc5);	49	try testing.expect(Fnv1a_32.hash("") == 0x811c9dc5);
50	testing.expect(Fnv1a_32.hash("a") == 0xe40c292c);	50	try testing.expect(Fnv1a_32.hash("a") == 0xe40c292c);
51	testing.expect(Fnv1a_32.hash("foobar") == 0xbf9cf968);	51	try testing.expect(Fnv1a_32.hash("foobar") == 0xbf9cf968);
52	}	52	}
53		53
54	test "fnv1a-64" {	54	test "fnv1a-64" {
55	testing.expect(Fnv1a_64.hash("") == 0xcbf29ce484222325);	55	try testing.expect(Fnv1a_64.hash("") == 0xcbf29ce484222325);
56	testing.expect(Fnv1a_64.hash("a") == 0xaf63dc4c8601ec8c);	56	try testing.expect(Fnv1a_64.hash("a") == 0xaf63dc4c8601ec8c);
57	testing.expect(Fnv1a_64.hash("foobar") == 0x85944171f73967e8);	57	try testing.expect(Fnv1a_64.hash("foobar") == 0x85944171f73967e8);
58	}	58	}
59		59
60	test "fnv1a-128" {	60	test "fnv1a-128" {
61	testing.expect(Fnv1a_128.hash("") == 0x6c62272e07bb014262b821756295c58d);	61	try testing.expect(Fnv1a_128.hash("") == 0x6c62272e07bb014262b821756295c58d);
62	testing.expect(Fnv1a_128.hash("a") == 0xd228cb696f1a8caf78912b704e4a8964);	62	try testing.expect(Fnv1a_128.hash("a") == 0xd228cb696f1a8caf78912b704e4a8964);
63	}	63	}

lib/std/hash/murmur.zig+9-9

...	@@ -308,7 +308,7 @@ fn SMHasherTest(comptime hash_fn: anytype, comptime hashbits: u32) u32 {	...	@@ -308,7 +308,7 @@ fn SMHasherTest(comptime hash_fn: anytype, comptime hashbits: u32) u32 {
308	}	308	}
309		309
310	test "murmur2_32" {	310	test "murmur2_32" {
311	testing.expectEqual(SMHasherTest(Murmur2_32.hashWithSeed, 32), 0x27864C1E);	311	try testing.expectEqual(SMHasherTest(Murmur2_32.hashWithSeed, 32), 0x27864C1E);
312	var v0: u32 = 0x12345678;	312	var v0: u32 = 0x12345678;
313	var v1: u64 = 0x1234567812345678;	313	var v1: u64 = 0x1234567812345678;
314	var v0le: u32 = v0;	314	var v0le: u32 = v0;
...	@@ -317,12 +317,12 @@ test "murmur2_32" {	...	@@ -317,12 +317,12 @@ test "murmur2_32" {
317	v0le = @byteSwap(u32, v0le);	317	v0le = @byteSwap(u32, v0le);
318	v1le = @byteSwap(u64, v1le);	318	v1le = @byteSwap(u64, v1le);
319	}	319	}
320	testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_32.hashUint32(v0));	320	try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_32.hashUint32(v0));
321	testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_32.hashUint64(v1));	321	try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_32.hashUint64(v1));
322	}	322	}
323		323
324	test "murmur2_64" {	324	test "murmur2_64" {
325	std.testing.expectEqual(SMHasherTest(Murmur2_64.hashWithSeed, 64), 0x1F0D3804);	325	try std.testing.expectEqual(SMHasherTest(Murmur2_64.hashWithSeed, 64), 0x1F0D3804);
326	var v0: u32 = 0x12345678;	326	var v0: u32 = 0x12345678;
327	var v1: u64 = 0x1234567812345678;	327	var v1: u64 = 0x1234567812345678;
328	var v0le: u32 = v0;	328	var v0le: u32 = v0;
...	@@ -331,12 +331,12 @@ test "murmur2_64" {	...	@@ -331,12 +331,12 @@ test "murmur2_64" {
331	v0le = @byteSwap(u32, v0le);	331	v0le = @byteSwap(u32, v0le);
332	v1le = @byteSwap(u64, v1le);	332	v1le = @byteSwap(u64, v1le);
333	}	333	}
334	testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_64.hashUint32(v0));	334	try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_64.hashUint32(v0));
335	testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_64.hashUint64(v1));	335	try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_64.hashUint64(v1));
336	}	336	}
337		337
338	test "murmur3_32" {	338	test "murmur3_32" {
339	std.testing.expectEqual(SMHasherTest(Murmur3_32.hashWithSeed, 32), 0xB0F57EE3);	339	try std.testing.expectEqual(SMHasherTest(Murmur3_32.hashWithSeed, 32), 0xB0F57EE3);
340	var v0: u32 = 0x12345678;	340	var v0: u32 = 0x12345678;
341	var v1: u64 = 0x1234567812345678;	341	var v1: u64 = 0x1234567812345678;
342	var v0le: u32 = v0;	342	var v0le: u32 = v0;
...	@@ -345,6 +345,6 @@ test "murmur3_32" {	...	@@ -345,6 +345,6 @@ test "murmur3_32" {
345	v0le = @byteSwap(u32, v0le);	345	v0le = @byteSwap(u32, v0le);
346	v1le = @byteSwap(u64, v1le);	346	v1le = @byteSwap(u64, v1le);
347	}	347	}
348	testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur3_32.hashUint32(v0));	348	try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur3_32.hashUint32(v0));
349	testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur3_32.hashUint64(v1));	349	try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur3_32.hashUint64(v1));
350	}	350	}

lib/std/hash/wyhash.zig+11-11

lib/std/hash_map.zig+72-72

...	@@ -824,15 +824,15 @@ test "std.hash_map basic usage" {	...	@@ -824,15 +824,15 @@ test "std.hash_map basic usage" {
824	while (it.next()) \|kv\| {	824	while (it.next()) \|kv\| {
825	sum += kv.key;	825	sum += kv.key;
826	}	826	}
827	expect(sum == total);	827	try expect(sum == total);
828		828
829	i = 0;	829	i = 0;
830	sum = 0;	830	sum = 0;
831	while (i < count) : (i += 1) {	831	while (i < count) : (i += 1) {
832	expectEqual(map.get(i).?, i);	832	try expectEqual(map.get(i).?, i);
833	sum += map.get(i).?;	833	sum += map.get(i).?;
834	}	834	}
835	expectEqual(total, sum);	835	try expectEqual(total, sum);
836	}	836	}
837		837
838	test "std.hash_map ensureCapacity" {	838	test "std.hash_map ensureCapacity" {
...	@@ -841,13 +841,13 @@ test "std.hash_map ensureCapacity" {	...	@@ -841,13 +841,13 @@ test "std.hash_map ensureCapacity" {
841		841
842	try map.ensureCapacity(20);	842	try map.ensureCapacity(20);
843	const initial_capacity = map.capacity();	843	const initial_capacity = map.capacity();
844	testing.expect(initial_capacity >= 20);	844	try testing.expect(initial_capacity >= 20);
845	var i: i32 = 0;	845	var i: i32 = 0;
846	while (i < 20) : (i += 1) {	846	while (i < 20) : (i += 1) {
847	testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null);	847	try testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null);
848	}	848	}
849	// shouldn't resize from putAssumeCapacity	849	// shouldn't resize from putAssumeCapacity
850	testing.expect(initial_capacity == map.capacity());	850	try testing.expect(initial_capacity == map.capacity());
851	}	851	}
852		852
853	test "std.hash_map ensureCapacity with tombstones" {	853	test "std.hash_map ensureCapacity with tombstones" {
...	@@ -870,22 +870,22 @@ test "std.hash_map clearRetainingCapacity" {	...	@@ -870,22 +870,22 @@ test "std.hash_map clearRetainingCapacity" {
870	map.clearRetainingCapacity();	870	map.clearRetainingCapacity();
871		871
872	try map.put(1, 1);	872	try map.put(1, 1);
873	expectEqual(map.get(1).?, 1);	873	try expectEqual(map.get(1).?, 1);
874	expectEqual(map.count(), 1);	874	try expectEqual(map.count(), 1);
875		875
876	map.clearRetainingCapacity();	876	map.clearRetainingCapacity();
877	map.putAssumeCapacity(1, 1);	877	map.putAssumeCapacity(1, 1);
878	expectEqual(map.get(1).?, 1);	878	try expectEqual(map.get(1).?, 1);
879	expectEqual(map.count(), 1);	879	try expectEqual(map.count(), 1);
880		880
881	const cap = map.capacity();	881	const cap = map.capacity();
882	expect(cap > 0);	882	try expect(cap > 0);
883		883
884	map.clearRetainingCapacity();	884	map.clearRetainingCapacity();
885	map.clearRetainingCapacity();	885	map.clearRetainingCapacity();
886	expectEqual(map.count(), 0);	886	try expectEqual(map.count(), 0);
887	expectEqual(map.capacity(), cap);	887	try expectEqual(map.capacity(), cap);
888	expect(!map.contains(1));	888	try expect(!map.contains(1));
889	}	889	}
890		890
891	test "std.hash_map grow" {	891	test "std.hash_map grow" {
...	@@ -898,19 +898,19 @@ test "std.hash_map grow" {	...	@@ -898,19 +898,19 @@ test "std.hash_map grow" {
898	while (i < growTo) : (i += 1) {	898	while (i < growTo) : (i += 1) {
899	try map.put(i, i);	899	try map.put(i, i);
900	}	900	}
901	expectEqual(map.count(), growTo);	901	try expectEqual(map.count(), growTo);
902		902
903	i = 0;	903	i = 0;
904	var it = map.iterator();	904	var it = map.iterator();
905	while (it.next()) \|kv\| {	905	while (it.next()) \|kv\| {
906	expectEqual(kv.key, kv.value);	906	try expectEqual(kv.key, kv.value);
907	i += 1;	907	i += 1;
908	}	908	}
909	expectEqual(i, growTo);	909	try expectEqual(i, growTo);
910		910
911	i = 0;	911	i = 0;
912	while (i < growTo) : (i += 1) {	912	while (i < growTo) : (i += 1) {
913	expectEqual(map.get(i).?, i);	913	try expectEqual(map.get(i).?, i);
914	}	914	}
915	}	915	}
916		916
...	@@ -921,7 +921,7 @@ test "std.hash_map clone" {	...	@@ -921,7 +921,7 @@ test "std.hash_map clone" {
921	var a = try map.clone();	921	var a = try map.clone();
922	defer a.deinit();	922	defer a.deinit();
923		923
924	expectEqual(a.count(), 0);	924	try expectEqual(a.count(), 0);
925		925
926	try a.put(1, 1);	926	try a.put(1, 1);
927	try a.put(2, 2);	927	try a.put(2, 2);
...	@@ -930,10 +930,10 @@ test "std.hash_map clone" {	...	@@ -930,10 +930,10 @@ test "std.hash_map clone" {
930	var b = try a.clone();	930	var b = try a.clone();
931	defer b.deinit();	931	defer b.deinit();
932		932
933	expectEqual(b.count(), 3);	933	try expectEqual(b.count(), 3);
934	expectEqual(b.get(1), 1);	934	try expectEqual(b.get(1), 1);
935	expectEqual(b.get(2), 2);	935	try expectEqual(b.get(2), 2);
936	expectEqual(b.get(3), 3);	936	try expectEqual(b.get(3), 3);
937	}	937	}
938		938
939	test "std.hash_map ensureCapacity with existing elements" {	939	test "std.hash_map ensureCapacity with existing elements" {
...	@@ -941,12 +941,12 @@ test "std.hash_map ensureCapacity with existing elements" {	...	@@ -941,12 +941,12 @@ test "std.hash_map ensureCapacity with existing elements" {
941	defer map.deinit();	941	defer map.deinit();
942		942
943	try map.put(0, 0);	943	try map.put(0, 0);
944	expectEqual(map.count(), 1);	944	try expectEqual(map.count(), 1);
945	expectEqual(map.capacity(), @TypeOf(map).Unmanaged.minimal_capacity);	945	try expectEqual(map.capacity(), @TypeOf(map).Unmanaged.minimal_capacity);
946		946
947	try map.ensureCapacity(65);	947	try map.ensureCapacity(65);
948	expectEqual(map.count(), 1);	948	try expectEqual(map.count(), 1);
949	expectEqual(map.capacity(), 128);	949	try expectEqual(map.capacity(), 128);
950	}	950	}
951		951
952	test "std.hash_map ensureCapacity satisfies max load factor" {	952	test "std.hash_map ensureCapacity satisfies max load factor" {
...	@@ -954,7 +954,7 @@ test "std.hash_map ensureCapacity satisfies max load factor" {	...	@@ -954,7 +954,7 @@ test "std.hash_map ensureCapacity satisfies max load factor" {
954	defer map.deinit();	954	defer map.deinit();
955		955
956	try map.ensureCapacity(127);	956	try map.ensureCapacity(127);
957	expectEqual(map.capacity(), 256);	957	try expectEqual(map.capacity(), 256);
958	}	958	}
959		959
960	test "std.hash_map remove" {	960	test "std.hash_map remove" {
...	@@ -972,19 +972,19 @@ test "std.hash_map remove" {	...	@@ -972,19 +972,19 @@ test "std.hash_map remove" {
972	_ = map.remove(i);	972	_ = map.remove(i);
973	}	973	}
974	}	974	}
975	expectEqual(map.count(), 10);	975	try expectEqual(map.count(), 10);
976	var it = map.iterator();	976	var it = map.iterator();
977	while (it.next()) \|kv\| {	977	while (it.next()) \|kv\| {
978	expectEqual(kv.key, kv.value);	978	try expectEqual(kv.key, kv.value);
979	expect(kv.key % 3 != 0);	979	try expect(kv.key % 3 != 0);
980	}	980	}
981		981
982	i = 0;	982	i = 0;
983	while (i < 16) : (i += 1) {	983	while (i < 16) : (i += 1) {
984	if (i % 3 == 0) {	984	if (i % 3 == 0) {
985	expect(!map.contains(i));	985	try expect(!map.contains(i));
986	} else {	986	} else {
987	expectEqual(map.get(i).?, i);	987	try expectEqual(map.get(i).?, i);
988	}	988	}
989	}	989	}
990	}	990	}
...	@@ -1001,14 +1001,14 @@ test "std.hash_map reverse removes" {	...	@@ -1001,14 +1001,14 @@ test "std.hash_map reverse removes" {
1001	i = 16;	1001	i = 16;
1002	while (i > 0) : (i -= 1) {	1002	while (i > 0) : (i -= 1) {
1003	_ = map.remove(i - 1);	1003	_ = map.remove(i - 1);
1004	expect(!map.contains(i - 1));	1004	try expect(!map.contains(i - 1));
1005	var j: u32 = 0;	1005	var j: u32 = 0;
1006	while (j < i - 1) : (j += 1) {	1006	while (j < i - 1) : (j += 1) {
1007	expectEqual(map.get(j).?, j);	1007	try expectEqual(map.get(j).?, j);
1008	}	1008	}
1009	}	1009	}
1010		1010
1011	expectEqual(map.count(), 0);	1011	try expectEqual(map.count(), 0);
1012	}	1012	}
1013		1013
1014	test "std.hash_map multiple removes on same metadata" {	1014	test "std.hash_map multiple removes on same metadata" {
...	@@ -1024,17 +1024,17 @@ test "std.hash_map multiple removes on same metadata" {	...	@@ -1024,17 +1024,17 @@ test "std.hash_map multiple removes on same metadata" {
1024	_ = map.remove(15);	1024	_ = map.remove(15);
1025	_ = map.remove(14);	1025	_ = map.remove(14);
1026	_ = map.remove(13);	1026	_ = map.remove(13);
1027	expect(!map.contains(7));	1027	try expect(!map.contains(7));
1028	expect(!map.contains(15));	1028	try expect(!map.contains(15));
1029	expect(!map.contains(14));	1029	try expect(!map.contains(14));
1030	expect(!map.contains(13));	1030	try expect(!map.contains(13));
1031		1031
1032	i = 0;	1032	i = 0;
1033	while (i < 13) : (i += 1) {	1033	while (i < 13) : (i += 1) {
1034	if (i == 7) {	1034	if (i == 7) {
1035	expect(!map.contains(i));	1035	try expect(!map.contains(i));
1036	} else {	1036	} else {
1037	expectEqual(map.get(i).?, i);	1037	try expectEqual(map.get(i).?, i);
1038	}	1038	}
1039	}	1039	}
1040		1040
...	@@ -1044,7 +1044,7 @@ test "std.hash_map multiple removes on same metadata" {	...	@@ -1044,7 +1044,7 @@ test "std.hash_map multiple removes on same metadata" {
1044	try map.put(7, 7);	1044	try map.put(7, 7);
1045	i = 0;	1045	i = 0;
1046	while (i < 16) : (i += 1) {	1046	while (i < 16) : (i += 1) {
1047	expectEqual(map.get(i).?, i);	1047	try expectEqual(map.get(i).?, i);
1048	}	1048	}
1049	}	1049	}
1050		1050
...	@@ -1070,12 +1070,12 @@ test "std.hash_map put and remove loop in random order" {	...	@@ -1070,12 +1070,12 @@ test "std.hash_map put and remove loop in random order" {
1070	for (keys.items) \|key\| {	1070	for (keys.items) \|key\| {
1071	try map.put(key, key);	1071	try map.put(key, key);
1072	}	1072	}
1073	expectEqual(map.count(), size);	1073	try expectEqual(map.count(), size);
1074		1074
1075	for (keys.items) \|key\| {	1075	for (keys.items) \|key\| {
1076	_ = map.remove(key);	1076	_ = map.remove(key);
1077	}	1077	}
1078	expectEqual(map.count(), 0);	1078	try expectEqual(map.count(), 0);
1079	}	1079	}
1080	}	1080	}
1081		1081
...	@@ -1119,7 +1119,7 @@ test "std.hash_map put" {	...	@@ -1119,7 +1119,7 @@ test "std.hash_map put" {
1119		1119
1120	i = 0;	1120	i = 0;
1121	while (i < 16) : (i += 1) {	1121	while (i < 16) : (i += 1) {
1122	expectEqual(map.get(i).?, i);	1122	try expectEqual(map.get(i).?, i);
1123	}	1123	}
1124		1124
1125	i = 0;	1125	i = 0;
...	@@ -1129,7 +1129,7 @@ test "std.hash_map put" {	...	@@ -1129,7 +1129,7 @@ test "std.hash_map put" {
1129		1129
1130	i = 0;	1130	i = 0;
1131	while (i < 16) : (i += 1) {	1131	while (i < 16) : (i += 1) {
1132	expectEqual(map.get(i).?, i * 16 + 1);	1132	try expectEqual(map.get(i).?, i * 16 + 1);
1133	}	1133	}
1134	}	1134	}
1135		1135
...	@@ -1148,7 +1148,7 @@ test "std.hash_map putAssumeCapacity" {	...	@@ -1148,7 +1148,7 @@ test "std.hash_map putAssumeCapacity" {
1148	while (i < 20) : (i += 1) {	1148	while (i < 20) : (i += 1) {
1149	sum += map.get(i).?;	1149	sum += map.get(i).?;
1150	}	1150	}
1151	expectEqual(sum, 190);	1151	try expectEqual(sum, 190);
1152		1152
1153	i = 0;	1153	i = 0;
1154	while (i < 20) : (i += 1) {	1154	while (i < 20) : (i += 1) {
...	@@ -1160,7 +1160,7 @@ test "std.hash_map putAssumeCapacity" {	...	@@ -1160,7 +1160,7 @@ test "std.hash_map putAssumeCapacity" {
1160	while (i < 20) : (i += 1) {	1160	while (i < 20) : (i += 1) {
1161	sum += map.get(i).?;	1161	sum += map.get(i).?;
1162	}	1162	}
1163	expectEqual(sum, 20);	1163	try expectEqual(sum, 20);
1164	}	1164	}
1165		1165
1166	test "std.hash_map getOrPut" {	1166	test "std.hash_map getOrPut" {
...	@@ -1183,49 +1183,49 @@ test "std.hash_map getOrPut" {	...	@@ -1183,49 +1183,49 @@ test "std.hash_map getOrPut" {
1183	sum += map.get(i).?;	1183	sum += map.get(i).?;
1184	}	1184	}
1185		1185
1186	expectEqual(sum, 30);	1186	try expectEqual(sum, 30);
1187	}	1187	}
1188		1188
1189	test "std.hash_map basic hash map usage" {	1189	test "std.hash_map basic hash map usage" {
1190	var map = AutoHashMap(i32, i32).init(std.testing.allocator);	1190	var map = AutoHashMap(i32, i32).init(std.testing.allocator);
1191	defer map.deinit();	1191	defer map.deinit();
1192		1192
1193	testing.expect((try map.fetchPut(1, 11)) == null);	1193	try testing.expect((try map.fetchPut(1, 11)) == null);
1194	testing.expect((try map.fetchPut(2, 22)) == null);	1194	try testing.expect((try map.fetchPut(2, 22)) == null);
1195	testing.expect((try map.fetchPut(3, 33)) == null);	1195	try testing.expect((try map.fetchPut(3, 33)) == null);
1196	testing.expect((try map.fetchPut(4, 44)) == null);	1196	try testing.expect((try map.fetchPut(4, 44)) == null);
1197		1197
1198	try map.putNoClobber(5, 55);	1198	try map.putNoClobber(5, 55);
1199	testing.expect((try map.fetchPut(5, 66)).?.value == 55);	1199	try testing.expect((try map.fetchPut(5, 66)).?.value == 55);
1200	testing.expect((try map.fetchPut(5, 55)).?.value == 66);	1200	try testing.expect((try map.fetchPut(5, 55)).?.value == 66);
1201		1201
1202	const gop1 = try map.getOrPut(5);	1202	const gop1 = try map.getOrPut(5);
1203	testing.expect(gop1.found_existing == true);	1203	try testing.expect(gop1.found_existing == true);
1204	testing.expect(gop1.entry.value == 55);	1204	try testing.expect(gop1.entry.value == 55);
1205	gop1.entry.value = 77;	1205	gop1.entry.value = 77;
1206	testing.expect(map.getEntry(5).?.value == 77);	1206	try testing.expect(map.getEntry(5).?.value == 77);
1207		1207
1208	const gop2 = try map.getOrPut(99);	1208	const gop2 = try map.getOrPut(99);
1209	testing.expect(gop2.found_existing == false);	1209	try testing.expect(gop2.found_existing == false);
1210	gop2.entry.value = 42;	1210	gop2.entry.value = 42;
1211	testing.expect(map.getEntry(99).?.value == 42);	1211	try testing.expect(map.getEntry(99).?.value == 42);
1212		1212
1213	const gop3 = try map.getOrPutValue(5, 5);	1213	const gop3 = try map.getOrPutValue(5, 5);
1214	testing.expect(gop3.value == 77);	1214	try testing.expect(gop3.value == 77);
1215		1215
1216	const gop4 = try map.getOrPutValue(100, 41);	1216	const gop4 = try map.getOrPutValue(100, 41);
1217	testing.expect(gop4.value == 41);	1217	try testing.expect(gop4.value == 41);
1218		1218
1219	testing.expect(map.contains(2));	1219	try testing.expect(map.contains(2));
1220	testing.expect(map.getEntry(2).?.value == 22);	1220	try testing.expect(map.getEntry(2).?.value == 22);
1221	testing.expect(map.get(2).? == 22);	1221	try testing.expect(map.get(2).? == 22);
1222		1222
1223	const rmv1 = map.remove(2);	1223	const rmv1 = map.remove(2);
1224	testing.expect(rmv1.?.key == 2);	1224	try testing.expect(rmv1.?.key == 2);
1225	testing.expect(rmv1.?.value == 22);	1225	try testing.expect(rmv1.?.value == 22);
1226	testing.expect(map.remove(2) == null);	1226	try testing.expect(map.remove(2) == null);
1227	testing.expect(map.getEntry(2) == null);	1227	try testing.expect(map.getEntry(2) == null);
1228	testing.expect(map.get(2) == null);	1228	try testing.expect(map.get(2) == null);
1229		1229
1230	map.removeAssertDiscard(3);	1230	map.removeAssertDiscard(3);
1231	}	1231	}
...	@@ -1244,6 +1244,6 @@ test "std.hash_map clone" {	...	@@ -1244,6 +1244,6 @@ test "std.hash_map clone" {
1244		1244
1245	i = 0;	1245	i = 0;
1246	while (i < 10) : (i += 1) {	1246	while (i < 10) : (i += 1) {
1247	testing.expect(copy.get(i).? == i * 10);	1247	try testing.expect(copy.get(i).? == i * 10);
1248	}	1248	}
1249	}	1249	}

lib/std/heap.zig+43-43

lib/std/heap/general_purpose_allocator.zig+50-50

lib/std/heap/logging_allocator.zig+3-3

...	@@ -93,11 +93,11 @@ test "LoggingAllocator" {	...	@@ -93,11 +93,11 @@ test "LoggingAllocator" {
93		93
94	var a = try allocator.alloc(u8, 10);	94	var a = try allocator.alloc(u8, 10);
95	a = allocator.shrink(a, 5);	95	a = allocator.shrink(a, 5);
96	std.testing.expect(a.len == 5);	96	try std.testing.expect(a.len == 5);
97	std.testing.expectError(error.OutOfMemory, allocator.resize(a, 20));	97	try std.testing.expectError(error.OutOfMemory, allocator.resize(a, 20));
98	allocator.free(a);	98	allocator.free(a);
99		99
100	std.testing.expectEqualSlices(u8,	100	try std.testing.expectEqualSlices(u8,
101	\\alloc : 10 success!	101	\\alloc : 10 success!
102	\\shrink: 10 to 5	102	\\shrink: 10 to 5
103	\\expand: 5 to 20 failure!	103	\\expand: 5 to 20 failure!

lib/std/io/bit_reader.zig+38-38

...	@@ -185,64 +185,64 @@ test "api coverage" {	...	@@ -185,64 +185,64 @@ test "api coverage" {
185	const expect = testing.expect;	185	const expect = testing.expect;
186	const expectError = testing.expectError;	186	const expectError = testing.expectError;
187		187
188	expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits));	188	try expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits));
189	expect(out_bits == 1);	189	try expect(out_bits == 1);
190	expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits));	190	try expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits));
191	expect(out_bits == 2);	191	try expect(out_bits == 2);
192	expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits));	192	try expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits));
193	expect(out_bits == 3);	193	try expect(out_bits == 3);
194	expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits));	194	try expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits));
195	expect(out_bits == 4);	195	try expect(out_bits == 4);
196	expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits));	196	try expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits));
197	expect(out_bits == 5);	197	try expect(out_bits == 5);
198	expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits));	198	try expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits));
199	expect(out_bits == 1);	199	try expect(out_bits == 1);
200		200
201	mem_in_be.pos = 0;	201	mem_in_be.pos = 0;
202	bit_stream_be.bit_count = 0;	202	bit_stream_be.bit_count = 0;
203	expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits));	203	try expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits));
204	expect(out_bits == 15);	204	try expect(out_bits == 15);
205		205
206	mem_in_be.pos = 0;	206	mem_in_be.pos = 0;
207	bit_stream_be.bit_count = 0;	207	bit_stream_be.bit_count = 0;
208	expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits));	208	try expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits));
209	expect(out_bits == 16);	209	try expect(out_bits == 16);
210		210
211	_ = try bit_stream_be.readBits(u0, 0, &out_bits);	211	_ = try bit_stream_be.readBits(u0, 0, &out_bits);
212		212
213	expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits));	213	try expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits));
214	expect(out_bits == 0);	214	try expect(out_bits == 0);
215	expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));	215	try expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));
216		216
217	var mem_in_le = io.fixedBufferStream(&mem_le);	217	var mem_in_le = io.fixedBufferStream(&mem_le);
218	var bit_stream_le = bitReader(.Little, mem_in_le.reader());	218	var bit_stream_le = bitReader(.Little, mem_in_le.reader());
219		219
220	expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));	220	try expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));
221	expect(out_bits == 1);	221	try expect(out_bits == 1);
222	expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits));	222	try expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits));
223	expect(out_bits == 2);	223	try expect(out_bits == 2);
224	expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits));	224	try expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits));
225	expect(out_bits == 3);	225	try expect(out_bits == 3);
226	expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits));	226	try expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits));
227	expect(out_bits == 4);	227	try expect(out_bits == 4);
228	expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits));	228	try expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits));
229	expect(out_bits == 5);	229	try expect(out_bits == 5);
230	expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits));	230	try expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits));
231	expect(out_bits == 1);	231	try expect(out_bits == 1);
232		232
233	mem_in_le.pos = 0;	233	mem_in_le.pos = 0;
234	bit_stream_le.bit_count = 0;	234	bit_stream_le.bit_count = 0;
235	expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits));	235	try expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits));
236	expect(out_bits == 15);	236	try expect(out_bits == 15);
237		237
238	mem_in_le.pos = 0;	238	mem_in_le.pos = 0;
239	bit_stream_le.bit_count = 0;	239	bit_stream_le.bit_count = 0;
240	expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits));	240	try expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits));
241	expect(out_bits == 16);	241	try expect(out_bits == 16);
242		242
243	_ = try bit_stream_le.readBits(u0, 0, &out_bits);	243	_ = try bit_stream_le.readBits(u0, 0, &out_bits);
244		244
245	expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits));	245	try expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits));
246	expect(out_bits == 0);	246	try expect(out_bits == 0);
247	expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1));	247	try expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1));
248	}	248	}

lib/std/io/bit_writer.zig+6-6

lib/std/io/buffered_reader.zig+1-1

...	@@ -87,5 +87,5 @@ test "io.BufferedReader" {	...	@@ -87,5 +87,5 @@ test "io.BufferedReader" {
87		87
88	const res = try stream.readAllAlloc(testing.allocator, str.len + 1);	88	const res = try stream.readAllAlloc(testing.allocator, str.len + 1);
89	defer testing.allocator.free(res);	89	defer testing.allocator.free(res);
90	testing.expectEqualSlices(u8, str, res);	90	try testing.expectEqualSlices(u8, str, res);
91	}	91	}

lib/std/io/counting_reader.zig+2-2

...	@@ -41,8 +41,8 @@ test "io.CountingReader" {	...	@@ -41,8 +41,8 @@ test "io.CountingReader" {
41		41
42	//read and discard all bytes	42	//read and discard all bytes
43	while (stream.readByte()) \|_\| {} else \|err\| {	43	while (stream.readByte()) \|_\| {} else \|err\| {
44	testing.expect(err == error.EndOfStream);	44	try testing.expect(err == error.EndOfStream);
45	}	45	}
46		46
47	testing.expect(counting_stream.bytes_read == bytes.len);	47	try testing.expect(counting_stream.bytes_read == bytes.len);
48	}	48	}

lib/std/io/counting_writer.zig+1-1

...	@@ -40,5 +40,5 @@ test "io.CountingWriter" {	...	@@ -40,5 +40,5 @@ test "io.CountingWriter" {
40		40
41	const bytes = "yay" ** 100;	41	const bytes = "yay" ** 100;
42	stream.writeAll(bytes) catch unreachable;	42	stream.writeAll(bytes) catch unreachable;
43	testing.expect(counting_stream.bytes_written == bytes.len);	43	try testing.expect(counting_stream.bytes_written == bytes.len);
44	}	44	}

lib/std/io/fixed_buffer_stream.zig+13-13

lib/std/io/limited_reader.zig+4-4

...	@@ -43,8 +43,8 @@ test "basic usage" {	...	@@ -43,8 +43,8 @@ test "basic usage" {
43	var early_stream = limitedReader(fbs.reader(), 3);	43	var early_stream = limitedReader(fbs.reader(), 3);
44		44
45	var buf: [5]u8 = undefined;	45	var buf: [5]u8 = undefined;
46	testing.expectEqual(@as(usize, 3), try early_stream.reader().read(&buf));	46	try testing.expectEqual(@as(usize, 3), try early_stream.reader().read(&buf));
47	testing.expectEqualSlices(u8, data[0..3], buf[0..3]);	47	try testing.expectEqualSlices(u8, data[0..3], buf[0..3]);
48	testing.expectEqual(@as(usize, 0), try early_stream.reader().read(&buf));	48	try testing.expectEqual(@as(usize, 0), try early_stream.reader().read(&buf));
49	testing.expectError(error.EndOfStream, early_stream.reader().skipBytes(10, .{}));	49	try testing.expectError(error.EndOfStream, early_stream.reader().skipBytes(10, .{}));
50	}	50	}

lib/std/io/multi_writer.zig+2-2

...	@@ -52,6 +52,6 @@ test "MultiWriter" {	...	@@ -52,6 +52,6 @@ test "MultiWriter" {
52	var fbs2 = io.fixedBufferStream(&buf2);	52	var fbs2 = io.fixedBufferStream(&buf2);
53	var stream = multiWriter(.{ fbs1.writer(), fbs2.writer() });	53	var stream = multiWriter(.{ fbs1.writer(), fbs2.writer() });
54	try stream.writer().print("HI", .{});	54	try stream.writer().print("HI", .{});
55	testing.expectEqualSlices(u8, "HI", fbs1.getWritten());	55	try testing.expectEqualSlices(u8, "HI", fbs1.getWritten());
56	testing.expectEqualSlices(u8, "HI", fbs2.getWritten());	56	try testing.expectEqualSlices(u8, "HI", fbs2.getWritten());
57	}	57	}

lib/std/io/peek_stream.zig+11-11

...	@@ -94,24 +94,24 @@ test "PeekStream" {	...	@@ -94,24 +94,24 @@ test "PeekStream" {
94	try ps.putBackByte(10);	94	try ps.putBackByte(10);
95		95
96	var read = try ps.reader().read(dest[0..4]);	96	var read = try ps.reader().read(dest[0..4]);
97	testing.expect(read == 4);	97	try testing.expect(read == 4);
98	testing.expect(dest[0] == 10);	98	try testing.expect(dest[0] == 10);
99	testing.expect(dest[1] == 9);	99	try testing.expect(dest[1] == 9);
100	testing.expect(mem.eql(u8, dest[2..4], bytes[0..2]));	100	try testing.expect(mem.eql(u8, dest[2..4], bytes[0..2]));
101		101
102	read = try ps.reader().read(dest[0..4]);	102	read = try ps.reader().read(dest[0..4]);
103	testing.expect(read == 4);	103	try testing.expect(read == 4);
104	testing.expect(mem.eql(u8, dest[0..4], bytes[2..6]));	104	try testing.expect(mem.eql(u8, dest[0..4], bytes[2..6]));
105		105
106	read = try ps.reader().read(dest[0..4]);	106	read = try ps.reader().read(dest[0..4]);
107	testing.expect(read == 2);	107	try testing.expect(read == 2);
108	testing.expect(mem.eql(u8, dest[0..2], bytes[6..8]));	108	try testing.expect(mem.eql(u8, dest[0..2], bytes[6..8]));
109		109
110	try ps.putBackByte(11);	110	try ps.putBackByte(11);
111	try ps.putBackByte(12);	111	try ps.putBackByte(12);
112		112
113	read = try ps.reader().read(dest[0..4]);	113	read = try ps.reader().read(dest[0..4]);
114	testing.expect(read == 2);	114	try testing.expect(read == 2);
115	testing.expect(dest[0] == 12);	115	try testing.expect(dest[0] == 12);
116	testing.expect(dest[1] == 11);	116	try testing.expect(dest[1] == 11);
117	}	117	}

lib/std/io/reader.zig+7-7

...	@@ -329,26 +329,26 @@ pub fn Reader(	...	@@ -329,26 +329,26 @@ pub fn Reader(
329	test "Reader" {	329	test "Reader" {
330	var buf = "a\x02".*;	330	var buf = "a\x02".*;
331	const reader = std.io.fixedBufferStream(&buf).reader();	331	const reader = std.io.fixedBufferStream(&buf).reader();
332	testing.expect((try reader.readByte()) == 'a');	332	try testing.expect((try reader.readByte()) == 'a');
333	testing.expect((try reader.readEnum(enum(u8) {	333	try testing.expect((try reader.readEnum(enum(u8) {
334	a = 0,	334	a = 0,
335	b = 99,	335	b = 99,
336	c = 2,	336	c = 2,
337	d = 3,	337	d = 3,
338	}, undefined)) == .c);	338	}, undefined)) == .c);
339	testing.expectError(error.EndOfStream, reader.readByte());	339	try testing.expectError(error.EndOfStream, reader.readByte());
340	}	340	}
341		341
342	test "Reader.isBytes" {	342	test "Reader.isBytes" {
343	const reader = std.io.fixedBufferStream("foobar").reader();	343	const reader = std.io.fixedBufferStream("foobar").reader();
344	testing.expectEqual(true, try reader.isBytes("foo"));	344	try testing.expectEqual(true, try reader.isBytes("foo"));
345	testing.expectEqual(false, try reader.isBytes("qux"));	345	try testing.expectEqual(false, try reader.isBytes("qux"));
346	}	346	}
347		347
348	test "Reader.skipBytes" {	348	test "Reader.skipBytes" {
349	const reader = std.io.fixedBufferStream("foobar").reader();	349	const reader = std.io.fixedBufferStream("foobar").reader();
350	try reader.skipBytes(3, .{});	350	try reader.skipBytes(3, .{});
351	testing.expect(try reader.isBytes("bar"));	351	try testing.expect(try reader.isBytes("bar"));
352	try reader.skipBytes(0, .{});	352	try reader.skipBytes(0, .{});
353	testing.expectError(error.EndOfStream, reader.skipBytes(1, .{}));	353	try testing.expectError(error.EndOfStream, reader.skipBytes(1, .{}));
354	}	354	}

lib/std/io/test.zig+33-33

lib/std/json.zig+139-139

lib/std/json/test.zig+275-275

...	@@ -21,37 +21,37 @@ fn testNonStreaming(s: []const u8) !void {	...	@@ -21,37 +21,37 @@ fn testNonStreaming(s: []const u8) !void {
21	}	21	}
22		22
23	fn ok(s: []const u8) !void {	23	fn ok(s: []const u8) !void {
24	testing.expect(json.validate(s));	24	try testing.expect(json.validate(s));
25		25
26	try testNonStreaming(s);	26	try testNonStreaming(s);
27	}	27	}
28		28
29	fn err(s: []const u8) void {	29	fn err(s: []const u8) !void {
30	testing.expect(!json.validate(s));	30	try testing.expect(!json.validate(s));
31		31
32	testing.expect(std.meta.isError(testNonStreaming(s)));	32	try testing.expect(std.meta.isError(testNonStreaming(s)));
33	}	33	}
34		34
35	fn utf8Error(s: []const u8) void {	35	fn utf8Error(s: []const u8) !void {
36	testing.expect(!json.validate(s));	36	try testing.expect(!json.validate(s));
37		37
38	testing.expectError(error.InvalidUtf8Byte, testNonStreaming(s));	38	try testing.expectError(error.InvalidUtf8Byte, testNonStreaming(s));
39	}	39	}
40		40
41	fn any(s: []const u8) void {	41	fn any(s: []const u8) !void {
42	_ = json.validate(s);	42	_ = json.validate(s);
43		43
44	testNonStreaming(s) catch {};	44	testNonStreaming(s) catch {};
45	}	45	}
46		46
47	fn anyStreamingErrNonStreaming(s: []const u8) void {	47	fn anyStreamingErrNonStreaming(s: []const u8) !void {
48	_ = json.validate(s);	48	_ = json.validate(s);
49		49
50	testing.expect(std.meta.isError(testNonStreaming(s)));	50	try testing.expect(std.meta.isError(testNonStreaming(s)));
51	}	51	}
52		52
53	fn roundTrip(s: []const u8) !void {	53	fn roundTrip(s: []const u8) !void {
54	testing.expect(json.validate(s));	54	try testing.expect(json.validate(s));
55		55
56	var p = json.Parser.init(testing.allocator, false);	56	var p = json.Parser.init(testing.allocator, false);
57	defer p.deinit();	57	defer p.deinit();
...	@@ -63,7 +63,7 @@ fn roundTrip(s: []const u8) !void {	...	@@ -63,7 +63,7 @@ fn roundTrip(s: []const u8) !void {
63	var fbs = std.io.fixedBufferStream(&buf);	63	var fbs = std.io.fixedBufferStream(&buf);
64	try tree.root.jsonStringify(.{}, fbs.writer());	64	try tree.root.jsonStringify(.{}, fbs.writer());
65		65
66	testing.expectEqualStrings(s, fbs.getWritten());	66	try testing.expectEqualStrings(s, fbs.getWritten());
67	}	67	}
68		68
69	////////////////////////////////////////////////////////////////////////////////////////////////////	69	////////////////////////////////////////////////////////////////////////////////////////////////////
...	@@ -642,109 +642,109 @@ test "y_structure_whitespace_array" {	...	@@ -642,109 +642,109 @@ test "y_structure_whitespace_array" {
642	////////////////////////////////////////////////////////////////////////////////////////////////////	642	////////////////////////////////////////////////////////////////////////////////////////////////////
643		643
644	test "n_array_1_true_without_comma" {	644	test "n_array_1_true_without_comma" {
645	err(	645	try err(
646	\\[1 true]	646	\\[1 true]
647	);	647	);
648	}	648	}
649		649
650	test "n_array_a_invalid_utf8" {	650	test "n_array_a_invalid_utf8" {
651	err(	651	try err(
652	\\[aå]	652	\\[aå]
653	);	653	);
654	}	654	}
655		655
656	test "n_array_colon_instead_of_comma" {	656	test "n_array_colon_instead_of_comma" {
657	err(	657	try err(
658	\\["": 1]	658	\\["": 1]
659	);	659	);
660	}	660	}
661		661
662	test "n_array_comma_after_close" {	662	test "n_array_comma_after_close" {
663	err(	663	try err(
664	\\[""],	664	\\[""],
665	);	665	);
666	}	666	}
667		667
668	test "n_array_comma_and_number" {	668	test "n_array_comma_and_number" {
669	err(	669	try err(
670	\\[,1]	670	\\[,1]
671	);	671	);
672	}	672	}
673		673
674	test "n_array_double_comma" {	674	test "n_array_double_comma" {
675	err(	675	try err(
676	\\[1,,2]	676	\\[1,,2]
677	);	677	);
678	}	678	}
679		679
680	test "n_array_double_extra_comma" {	680	test "n_array_double_extra_comma" {
681	err(	681	try err(
682	\\["x",,]	682	\\["x",,]
683	);	683	);
684	}	684	}
685		685
686	test "n_array_extra_close" {	686	test "n_array_extra_close" {
687	err(	687	try err(
688	\\["x"]]	688	\\["x"]]
689	);	689	);
690	}	690	}
691		691
692	test "n_array_extra_comma" {	692	test "n_array_extra_comma" {
693	err(	693	try err(
694	\\["",]	694	\\["",]
695	);	695	);
696	}	696	}
697		697
698	test "n_array_incomplete_invalid_value" {	698	test "n_array_incomplete_invalid_value" {
699	err(	699	try err(
700	\\[x	700	\\[x
701	);	701	);
702	}	702	}
703		703
704	test "n_array_incomplete" {	704	test "n_array_incomplete" {
705	err(	705	try err(
706	\\["x"	706	\\["x"
707	);	707	);
708	}	708	}
709		709
710	test "n_array_inner_array_no_comma" {	710	test "n_array_inner_array_no_comma" {
711	err(	711	try err(
712	\\[3[4]]	712	\\[3[4]]
713	);	713	);
714	}	714	}
715		715
716	test "n_array_invalid_utf8" {	716	test "n_array_invalid_utf8" {
717	err(	717	try err(
718	\\[ÿ]	718	\\[ÿ]
719	);	719	);
720	}	720	}
721		721
722	test "n_array_items_separated_by_semicolon" {	722	test "n_array_items_separated_by_semicolon" {
723	err(	723	try err(
724	\\[1:2]	724	\\[1:2]
725	);	725	);
726	}	726	}
727		727
728	test "n_array_just_comma" {	728	test "n_array_just_comma" {
729	err(	729	try err(
730	\\[,]	730	\\[,]
731	);	731	);
732	}	732	}
733		733
734	test "n_array_just_minus" {	734	test "n_array_just_minus" {
735	err(	735	try err(
736	\\[-]	736	\\[-]
737	);	737	);
738	}	738	}
739		739
740	test "n_array_missing_value" {	740	test "n_array_missing_value" {
741	err(	741	try err(
742	\\[ , ""]	742	\\[ , ""]
743	);	743	);
744	}	744	}
745		745
746	test "n_array_newlines_unclosed" {	746	test "n_array_newlines_unclosed" {
747	err(	747	try err(
748	\\["a",	748	\\["a",
749	\\4	749	\\4
750	\\,1,	750	\\,1,
...	@@ -752,41 +752,41 @@ test "n_array_newlines_unclosed" {	...	@@ -752,41 +752,41 @@ test "n_array_newlines_unclosed" {
752	}	752	}
753		753
754	test "n_array_number_and_comma" {	754	test "n_array_number_and_comma" {
755	err(	755	try err(
756	\\[1,]	756	\\[1,]
757	);	757	);
758	}	758	}
759		759
760	test "n_array_number_and_several_commas" {	760	test "n_array_number_and_several_commas" {
761	err(	761	try err(
762	\\[1,,]	762	\\[1,,]
763	);	763	);
764	}	764	}
765		765
766	test "n_array_spaces_vertical_tab_formfeed" {	766	test "n_array_spaces_vertical_tab_formfeed" {
767	err("[\"\x0aa\"\\f]");	767	try err("[\"\x0aa\"\\f]");
768	}	768	}
769		769
770	test "n_array_star_inside" {	770	test "n_array_star_inside" {
771	err(	771	try err(
772	\\[*]	772	\\[*]
773	);	773	);
774	}	774	}
775		775
776	test "n_array_unclosed" {	776	test "n_array_unclosed" {
777	err(	777	try err(
778	\\[""	778	\\[""
779	);	779	);
780	}	780	}
781		781
782	test "n_array_unclosed_trailing_comma" {	782	test "n_array_unclosed_trailing_comma" {
783	err(	783	try err(
784	\\[1,	784	\\[1,
785	);	785	);
786	}	786	}
787		787
788	test "n_array_unclosed_with_new_lines" {	788	test "n_array_unclosed_with_new_lines" {
789	err(	789	try err(
790	\\[1,	790	\\[1,
791	\\1	791	\\1
792	\\,1	792	\\,1
...	@@ -794,956 +794,956 @@ test "n_array_unclosed_with_new_lines" {	...	@@ -794,956 +794,956 @@ test "n_array_unclosed_with_new_lines" {
794	}	794	}
795		795
796	test "n_array_unclosed_with_object_inside" {	796	test "n_array_unclosed_with_object_inside" {
797	err(	797	try err(
798	\\[{}	798	\\[{}
799	);	799	);
800	}	800	}
801		801
802	test "n_incomplete_false" {	802	test "n_incomplete_false" {
803	err(	803	try err(
804	\\[fals]	804	\\[fals]
805	);	805	);
806	}	806	}
807		807
808	test "n_incomplete_null" {	808	test "n_incomplete_null" {
809	err(	809	try err(
810	\\[nul]	810	\\[nul]
811	);	811	);
812	}	812	}
813		813
814	test "n_incomplete_true" {	814	test "n_incomplete_true" {
815	err(	815	try err(
816	\\[tru]	816	\\[tru]
817	);	817	);
818	}	818	}
819		819
820	test "n_multidigit_number_then_00" {	820	test "n_multidigit_number_then_00" {
821	err("123\x00");	821	try err("123\x00");
822	}	822	}
823		823
824	test "n_number_0.1.2" {	824	test "n_number_0.1.2" {
825	err(	825	try err(
826	\\[0.1.2]	826	\\[0.1.2]
827	);	827	);
828	}	828	}
829		829
830	test "n_number_-01" {	830	test "n_number_-01" {
831	err(	831	try err(
832	\\[-01]	832	\\[-01]
833	);	833	);
834	}	834	}
835		835
836	test "n_number_0.3e" {	836	test "n_number_0.3e" {
837	err(	837	try err(
838	\\[0.3e]	838	\\[0.3e]
839	);	839	);
840	}	840	}
841		841
842	test "n_number_0.3e+" {	842	test "n_number_0.3e+" {
843	err(	843	try err(
844	\\[0.3e+]	844	\\[0.3e+]
845	);	845	);
846	}	846	}
847		847
848	test "n_number_0_capital_E" {	848	test "n_number_0_capital_E" {
849	err(	849	try err(
850	\\[0E]	850	\\[0E]
851	);	851	);
852	}	852	}
853		853
854	test "n_number_0_capital_E+" {	854	test "n_number_0_capital_E+" {
855	err(	855	try err(
856	\\[0E+]	856	\\[0E+]
857	);	857	);
858	}	858	}
859		859
860	test "n_number_0.e1" {	860	test "n_number_0.e1" {
861	err(	861	try err(
862	\\[0.e1]	862	\\[0.e1]
863	);	863	);
864	}	864	}
865		865
866	test "n_number_0e" {	866	test "n_number_0e" {
867	err(	867	try err(
868	\\[0e]	868	\\[0e]
869	);	869	);
870	}	870	}
871		871
872	test "n_number_0e+" {	872	test "n_number_0e+" {
873	err(	873	try err(
874	\\[0e+]	874	\\[0e+]
875	);	875	);
876	}	876	}
877		877
878	test "n_number_1_000" {	878	test "n_number_1_000" {
879	err(	879	try err(
880	\\[1 000.0]	880	\\[1 000.0]
881	);	881	);
882	}	882	}
883		883
884	test "n_number_1.0e-" {	884	test "n_number_1.0e-" {
885	err(	885	try err(
886	\\[1.0e-]	886	\\[1.0e-]
887	);	887	);
888	}	888	}
889		889
890	test "n_number_1.0e" {	890	test "n_number_1.0e" {
891	err(	891	try err(
892	\\[1.0e]	892	\\[1.0e]
893	);	893	);
894	}	894	}
895		895
896	test "n_number_1.0e+" {	896	test "n_number_1.0e+" {
897	err(	897	try err(
898	\\[1.0e+]	898	\\[1.0e+]
899	);	899	);
900	}	900	}
901		901
902	test "n_number_-1.0." {	902	test "n_number_-1.0." {
903	err(	903	try err(
904	\\[-1.0.]	904	\\[-1.0.]
905	);	905	);
906	}	906	}
907		907
908	test "n_number_1eE2" {	908	test "n_number_1eE2" {
909	err(	909	try err(
910	\\[1eE2]	910	\\[1eE2]
911	);	911	);
912	}	912	}
913		913
914	test "n_number_.-1" {	914	test "n_number_.-1" {
915	err(	915	try err(
916	\\[.-1]	916	\\[.-1]
917	);	917	);
918	}	918	}
919		919
920	test "n_number_+1" {	920	test "n_number_+1" {
921	err(	921	try err(
922	\\[+1]	922	\\[+1]
923	);	923	);
924	}	924	}
925		925
926	test "n_number_.2e-3" {	926	test "n_number_.2e-3" {
927	err(	927	try err(
928	\\[.2e-3]	928	\\[.2e-3]
929	);	929	);
930	}	930	}
931		931
932	test "n_number_2.e-3" {	932	test "n_number_2.e-3" {
933	err(	933	try err(
934	\\[2.e-3]	934	\\[2.e-3]
935	);	935	);
936	}	936	}
937		937
938	test "n_number_2.e+3" {	938	test "n_number_2.e+3" {
939	err(	939	try err(
940	\\[2.e+3]	940	\\[2.e+3]
941	);	941	);
942	}	942	}
943		943
944	test "n_number_2.e3" {	944	test "n_number_2.e3" {
945	err(	945	try err(
946	\\[2.e3]	946	\\[2.e3]
947	);	947	);
948	}	948	}
949		949
950	test "n_number_-2." {	950	test "n_number_-2." {
951	err(	951	try err(
952	\\[-2.]	952	\\[-2.]
953	);	953	);
954	}	954	}
955		955
956	test "n_number_9.e+" {	956	test "n_number_9.e+" {
957	err(	957	try err(
958	\\[9.e+]	958	\\[9.e+]
959	);	959	);
960	}	960	}
961		961
962	test "n_number_expression" {	962	test "n_number_expression" {
963	err(	963	try err(
964	\\[1+2]	964	\\[1+2]
965	);	965	);
966	}	966	}
967		967
968	test "n_number_hex_1_digit" {	968	test "n_number_hex_1_digit" {
969	err(	969	try err(
970	\\[0x1]	970	\\[0x1]
971	);	971	);
972	}	972	}
973		973
974	test "n_number_hex_2_digits" {	974	test "n_number_hex_2_digits" {
975	err(	975	try err(
976	\\[0x42]	976	\\[0x42]
977	);	977	);
978	}	978	}
979		979
980	test "n_number_infinity" {	980	test "n_number_infinity" {
981	err(	981	try err(
982	\\[Infinity]	982	\\[Infinity]
983	);	983	);
984	}	984	}
985		985
986	test "n_number_+Inf" {	986	test "n_number_+Inf" {
987	err(	987	try err(
988	\\[+Inf]	988	\\[+Inf]
989	);	989	);
990	}	990	}
991		991
992	test "n_number_Inf" {	992	test "n_number_Inf" {
993	err(	993	try err(
994	\\[Inf]	994	\\[Inf]
995	);	995	);
996	}	996	}
997		997
998	test "n_number_invalid+-" {	998	test "n_number_invalid+-" {
999	err(	999	try err(
1000	\\[0e+-1]	1000	\\[0e+-1]
1001	);	1001	);
1002	}	1002	}
1003		1003
1004	test "n_number_invalid-negative-real" {	1004	test "n_number_invalid-negative-real" {
1005	err(	1005	try err(
1006	\\[-123.123foo]	1006	\\[-123.123foo]
1007	);	1007	);
1008	}	1008	}
1009		1009
1010	test "n_number_invalid-utf-8-in-bigger-int" {	1010	test "n_number_invalid-utf-8-in-bigger-int" {
1011	err(	1011	try err(
1012	\\[123å]	1012	\\[123å]
1013	);	1013	);
1014	}	1014	}
1015		1015
1016	test "n_number_invalid-utf-8-in-exponent" {	1016	test "n_number_invalid-utf-8-in-exponent" {
1017	err(	1017	try err(
1018	\\[1e1å]	1018	\\[1e1å]
1019	);	1019	);
1020	}	1020	}
1021		1021
1022	test "n_number_invalid-utf-8-in-int" {	1022	test "n_number_invalid-utf-8-in-int" {
1023	err(	1023	try err(
1024	\\[0å]	1024	\\[0å]
1025	);	1025	);
1026	}	1026	}
1027		1027
1028	test "n_number_++" {	1028	test "n_number_++" {
1029	err(	1029	try err(
1030	\\[++1234]	1030	\\[++1234]
1031	);	1031	);
1032	}	1032	}
1033		1033
1034	test "n_number_minus_infinity" {	1034	test "n_number_minus_infinity" {
1035	err(	1035	try err(
1036	\\[-Infinity]	1036	\\[-Infinity]
1037	);	1037	);
1038	}	1038	}
1039		1039
1040	test "n_number_minus_sign_with_trailing_garbage" {	1040	test "n_number_minus_sign_with_trailing_garbage" {
1041	err(	1041	try err(
1042	\\[-foo]	1042	\\[-foo]
1043	);	1043	);
1044	}	1044	}
1045		1045
1046	test "n_number_minus_space_1" {	1046	test "n_number_minus_space_1" {
1047	err(	1047	try err(
1048	\\[- 1]	1048	\\[- 1]
1049	);	1049	);
1050	}	1050	}
1051		1051
1052	test "n_number_-NaN" {	1052	test "n_number_-NaN" {
1053	err(	1053	try err(
1054	\\[-NaN]	1054	\\[-NaN]
1055	);	1055	);
1056	}	1056	}
1057		1057
1058	test "n_number_NaN" {	1058	test "n_number_NaN" {
1059	err(	1059	try err(
1060	\\[NaN]	1060	\\[NaN]
1061	);	1061	);
1062	}	1062	}
1063		1063
1064	test "n_number_neg_int_starting_with_zero" {	1064	test "n_number_neg_int_starting_with_zero" {
1065	err(	1065	try err(
1066	\\[-012]	1066	\\[-012]
1067	);	1067	);
1068	}	1068	}
1069		1069
1070	test "n_number_neg_real_without_int_part" {	1070	test "n_number_neg_real_without_int_part" {
1071	err(	1071	try err(
1072	\\[-.123]	1072	\\[-.123]
1073	);	1073	);
1074	}	1074	}
1075		1075
1076	test "n_number_neg_with_garbage_at_end" {	1076	test "n_number_neg_with_garbage_at_end" {
1077	err(	1077	try err(
1078	\\[-1x]	1078	\\[-1x]
1079	);	1079	);
1080	}	1080	}
1081		1081
1082	test "n_number_real_garbage_after_e" {	1082	test "n_number_real_garbage_after_e" {
1083	err(	1083	try err(
1084	\\[1ea]	1084	\\[1ea]
1085	);	1085	);
1086	}	1086	}
1087		1087
1088	test "n_number_real_with_invalid_utf8_after_e" {	1088	test "n_number_real_with_invalid_utf8_after_e" {
1089	err(	1089	try err(
1090	\\[1eå]	1090	\\[1eå]
1091	);	1091	);
1092	}	1092	}
1093		1093
1094	test "n_number_real_without_fractional_part" {	1094	test "n_number_real_without_fractional_part" {
1095	err(	1095	try err(
1096	\\[1.]	1096	\\[1.]
1097	);	1097	);
1098	}	1098	}
1099		1099
1100	test "n_number_starting_with_dot" {	1100	test "n_number_starting_with_dot" {
1101	err(	1101	try err(
1102	\\[.123]	1102	\\[.123]
1103	);	1103	);
1104	}	1104	}
1105		1105
1106	test "n_number_U+FF11_fullwidth_digit_one" {	1106	test "n_number_U+FF11_fullwidth_digit_one" {
1107	err(	1107	try err(
1108	\\[ï¼]	1108	\\[ï¼]
1109	);	1109	);
1110	}	1110	}
1111		1111
1112	test "n_number_with_alpha_char" {	1112	test "n_number_with_alpha_char" {
1113	err(	1113	try err(
1114	\\[1.8011670033376514H-308]	1114	\\[1.8011670033376514H-308]
1115	);	1115	);
1116	}	1116	}
1117		1117
1118	test "n_number_with_alpha" {	1118	test "n_number_with_alpha" {
1119	err(	1119	try err(
1120	\\[1.2a-3]	1120	\\[1.2a-3]
1121	);	1121	);
1122	}	1122	}
1123		1123
1124	test "n_number_with_leading_zero" {	1124	test "n_number_with_leading_zero" {
1125	err(	1125	try err(
1126	\\[012]	1126	\\[012]
1127	);	1127	);
1128	}	1128	}
1129		1129
1130	test "n_object_bad_value" {	1130	test "n_object_bad_value" {
1131	err(	1131	try err(
1132	\\["x", truth]	1132	\\["x", truth]
1133	);	1133	);
1134	}	1134	}
1135		1135
1136	test "n_object_bracket_key" {	1136	test "n_object_bracket_key" {
1137	err(	1137	try err(
1138	\\{[: "x"}	1138	\\{[: "x"}
1139	);	1139	);
1140	}	1140	}
1141		1141
1142	test "n_object_comma_instead_of_colon" {	1142	test "n_object_comma_instead_of_colon" {
1143	err(	1143	try err(
1144	\\{"x", null}	1144	\\{"x", null}
1145	);	1145	);
1146	}	1146	}
1147		1147
1148	test "n_object_double_colon" {	1148	test "n_object_double_colon" {
1149	err(	1149	try err(
1150	\\{"x"::"b"}	1150	\\{"x"::"b"}
1151	);	1151	);
1152	}	1152	}
1153		1153
1154	test "n_object_emoji" {	1154	test "n_object_emoji" {
1155	err(	1155	try err(
1156	\\{ð¨ð}	1156	\\{ð¨ð}
1157	);	1157	);
1158	}	1158	}
1159		1159
1160	test "n_object_garbage_at_end" {	1160	test "n_object_garbage_at_end" {
1161	err(	1161	try err(
1162	\\{"a":"a" 123}	1162	\\{"a":"a" 123}
1163	);	1163	);
1164	}	1164	}
1165		1165
1166	test "n_object_key_with_single_quotes" {	1166	test "n_object_key_with_single_quotes" {
1167	err(	1167	try err(
1168	\\{key: 'value'}	1168	\\{key: 'value'}
1169	);	1169	);
1170	}	1170	}
1171		1171
1172	test "n_object_lone_continuation_byte_in_key_and_trailing_comma" {	1172	test "n_object_lone_continuation_byte_in_key_and_trailing_comma" {
1173	err(	1173	try err(
1174	\\{"¹":"0",}	1174	\\{"¹":"0",}
1175	);	1175	);
1176	}	1176	}
1177		1177
1178	test "n_object_missing_colon" {	1178	test "n_object_missing_colon" {
1179	err(	1179	try err(
1180	\\{"a" b}	1180	\\{"a" b}
1181	);	1181	);
1182	}	1182	}
1183		1183
1184	test "n_object_missing_key" {	1184	test "n_object_missing_key" {
1185	err(	1185	try err(
1186	\\{:"b"}	1186	\\{:"b"}
1187	);	1187	);
1188	}	1188	}
1189		1189
1190	test "n_object_missing_semicolon" {	1190	test "n_object_missing_semicolon" {
1191	err(	1191	try err(
1192	\\{"a" "b"}	1192	\\{"a" "b"}
1193	);	1193	);
1194	}	1194	}
1195		1195
1196	test "n_object_missing_value" {	1196	test "n_object_missing_value" {
1197	err(	1197	try err(
1198	\\{"a":	1198	\\{"a":
1199	);	1199	);
1200	}	1200	}
1201		1201
1202	test "n_object_no-colon" {	1202	test "n_object_no-colon" {
1203	err(	1203	try err(
1204	\\{"a"	1204	\\{"a"
1205	);	1205	);
1206	}	1206	}
1207		1207
1208	test "n_object_non_string_key_but_huge_number_instead" {	1208	test "n_object_non_string_key_but_huge_number_instead" {
1209	err(	1209	try err(
1210	\\{9999E9999:1}	1210	\\{9999E9999:1}
1211	);	1211	);
1212	}	1212	}
1213		1213
1214	test "n_object_non_string_key" {	1214	test "n_object_non_string_key" {
1215	err(	1215	try err(
1216	\\{1:1}	1216	\\{1:1}
1217	);	1217	);
1218	}	1218	}
1219		1219
1220	test "n_object_repeated_null_null" {	1220	test "n_object_repeated_null_null" {
1221	err(	1221	try err(
1222	\\{null:null,null:null}	1222	\\{null:null,null:null}
1223	);	1223	);
1224	}	1224	}
1225		1225
1226	test "n_object_several_trailing_commas" {	1226	test "n_object_several_trailing_commas" {
1227	err(	1227	try err(
1228	\\{"id":0,,,,,}	1228	\\{"id":0,,,,,}
1229	);	1229	);
1230	}	1230	}
1231		1231
1232	test "n_object_single_quote" {	1232	test "n_object_single_quote" {
1233	err(	1233	try err(
1234	\\{'a':0}	1234	\\{'a':0}
1235	);	1235	);
1236	}	1236	}
1237		1237
1238	test "n_object_trailing_comma" {	1238	test "n_object_trailing_comma" {
1239	err(	1239	try err(
1240	\\{"id":0,}	1240	\\{"id":0,}
1241	);	1241	);
1242	}	1242	}
1243		1243
1244	test "n_object_trailing_comment" {	1244	test "n_object_trailing_comment" {
1245	err(	1245	try err(
1246	\\{"a":"b"}/**/	1246	\\{"a":"b"}/**/
1247	);	1247	);
1248	}	1248	}
1249		1249
1250	test "n_object_trailing_comment_open" {	1250	test "n_object_trailing_comment_open" {
1251	err(	1251	try err(
1252	\\{"a":"b"}/**//	1252	\\{"a":"b"}/**//
1253	);	1253	);
1254	}	1254	}
1255		1255
1256	test "n_object_trailing_comment_slash_open_incomplete" {	1256	test "n_object_trailing_comment_slash_open_incomplete" {
1257	err(	1257	try err(
1258	\\{"a":"b"}/	1258	\\{"a":"b"}/
1259	);	1259	);
1260	}	1260	}
1261		1261
1262	test "n_object_trailing_comment_slash_open" {	1262	test "n_object_trailing_comment_slash_open" {
1263	err(	1263	try err(
1264	\\{"a":"b"}//	1264	\\{"a":"b"}//
1265	);	1265	);
1266	}	1266	}
1267		1267
1268	test "n_object_two_commas_in_a_row" {	1268	test "n_object_two_commas_in_a_row" {
1269	err(	1269	try err(
1270	\\{"a":"b",,"c":"d"}	1270	\\{"a":"b",,"c":"d"}
1271	);	1271	);
1272	}	1272	}
1273		1273
1274	test "n_object_unquoted_key" {	1274	test "n_object_unquoted_key" {
1275	err(	1275	try err(
1276	\\{a: "b"}	1276	\\{a: "b"}
1277	);	1277	);
1278	}	1278	}
1279		1279
1280	test "n_object_unterminated-value" {	1280	test "n_object_unterminated-value" {
1281	err(	1281	try err(
1282	\\{"a":"a	1282	\\{"a":"a
1283	);	1283	);
1284	}	1284	}
1285		1285
1286	test "n_object_with_single_string" {	1286	test "n_object_with_single_string" {
1287	err(	1287	try err(
1288	\\{ "foo" : "bar", "a" }	1288	\\{ "foo" : "bar", "a" }
1289	);	1289	);
1290	}	1290	}
1291		1291
1292	test "n_object_with_trailing_garbage" {	1292	test "n_object_with_trailing_garbage" {
1293	err(	1293	try err(
1294	\\{"a":"b"}#	1294	\\{"a":"b"}#
1295	);	1295	);
1296	}	1296	}
1297		1297
1298	test "n_single_space" {	1298	test "n_single_space" {
1299	err(" ");	1299	try err(" ");
1300	}	1300	}
1301		1301
1302	test "n_string_1_surrogate_then_escape" {	1302	test "n_string_1_surrogate_then_escape" {
1303	err(	1303	try err(
1304	\\["\uD800\"]	1304	\\["\uD800\"]
1305	);	1305	);
1306	}	1306	}
1307		1307
1308	test "n_string_1_surrogate_then_escape_u1" {	1308	test "n_string_1_surrogate_then_escape_u1" {
1309	err(	1309	try err(
1310	\\["\uD800\u1"]	1310	\\["\uD800\u1"]
1311	);	1311	);
1312	}	1312	}
1313		1313
1314	test "n_string_1_surrogate_then_escape_u1x" {	1314	test "n_string_1_surrogate_then_escape_u1x" {
1315	err(	1315	try err(
1316	\\["\uD800\u1x"]	1316	\\["\uD800\u1x"]
1317	);	1317	);
1318	}	1318	}
1319		1319
1320	test "n_string_1_surrogate_then_escape_u" {	1320	test "n_string_1_surrogate_then_escape_u" {
1321	err(	1321	try err(
1322	\\["\uD800\u"]	1322	\\["\uD800\u"]
1323	);	1323	);
1324	}	1324	}
1325		1325
1326	test "n_string_accentuated_char_no_quotes" {	1326	test "n_string_accentuated_char_no_quotes" {
1327	err(	1327	try err(
1328	\\[Ã©]	1328	\\[Ã©]
1329	);	1329	);
1330	}	1330	}
1331		1331
1332	test "n_string_backslash_00" {	1332	test "n_string_backslash_00" {
1333	err("[\"\x00\"]");	1333	try err("[\"\x00\"]");
1334	}	1334	}
1335		1335
1336	test "n_string_escaped_backslash_bad" {	1336	test "n_string_escaped_backslash_bad" {
1337	err(	1337	try err(
1338	\\["\\\"]	1338	\\["\\\"]
1339	);	1339	);
1340	}	1340	}
1341		1341
1342	test "n_string_escaped_ctrl_char_tab" {	1342	test "n_string_escaped_ctrl_char_tab" {
1343	err("\x5b\x22\x5c\x09\x22\x5d");	1343	try err("\x5b\x22\x5c\x09\x22\x5d");
1344	}	1344	}
1345		1345
1346	test "n_string_escaped_emoji" {	1346	test "n_string_escaped_emoji" {
1347	err("[\"\x5c\xc3\xb0\xc2\x9f\xc2\x8c\xc2\x80\"]");	1347	try err("[\"\x5c\xc3\xb0\xc2\x9f\xc2\x8c\xc2\x80\"]");
1348	}	1348	}
1349		1349
1350	test "n_string_escape_x" {	1350	test "n_string_escape_x" {
1351	err(	1351	try err(
1352	\\["\x00"]	1352	\\["\x00"]
1353	);	1353	);
1354	}	1354	}
1355		1355
1356	test "n_string_incomplete_escaped_character" {	1356	test "n_string_incomplete_escaped_character" {
1357	err(	1357	try err(
1358	\\["\u00A"]	1358	\\["\u00A"]
1359	);	1359	);
1360	}	1360	}
1361		1361
1362	test "n_string_incomplete_escape" {	1362	test "n_string_incomplete_escape" {
1363	err(	1363	try err(
1364	\\["\"]	1364	\\["\"]
1365	);	1365	);
1366	}	1366	}
1367		1367
1368	test "n_string_incomplete_surrogate_escape_invalid" {	1368	test "n_string_incomplete_surrogate_escape_invalid" {
1369	err(	1369	try err(
1370	\\["\uD800\uD800\x"]	1370	\\["\uD800\uD800\x"]
1371	);	1371	);
1372	}	1372	}
1373		1373
1374	test "n_string_incomplete_surrogate" {	1374	test "n_string_incomplete_surrogate" {
1375	err(	1375	try err(
1376	\\["\uD834\uDd"]	1376	\\["\uD834\uDd"]
1377	);	1377	);
1378	}	1378	}
1379		1379
1380	test "n_string_invalid_backslash_esc" {	1380	test "n_string_invalid_backslash_esc" {
1381	err(	1381	try err(
1382	\\["\a"]	1382	\\["\a"]
1383	);	1383	);
1384	}	1384	}
1385		1385
1386	test "n_string_invalid_unicode_escape" {	1386	test "n_string_invalid_unicode_escape" {
1387	err(	1387	try err(
1388	\\["\uqqqq"]	1388	\\["\uqqqq"]
1389	);	1389	);
1390	}	1390	}
1391		1391
1392	test "n_string_invalid_utf8_after_escape" {	1392	test "n_string_invalid_utf8_after_escape" {
1393	err("[\"\\\x75\xc3\xa5\"]");	1393	try err("[\"\\\x75\xc3\xa5\"]");
1394	}	1394	}
1395		1395
1396	test "n_string_invalid-utf-8-in-escape" {	1396	test "n_string_invalid-utf-8-in-escape" {
1397	err(	1397	try err(
1398	\\["\uå"]	1398	\\["\uå"]
1399	);	1399	);
1400	}	1400	}
1401		1401
1402	test "n_string_leading_uescaped_thinspace" {	1402	test "n_string_leading_uescaped_thinspace" {
1403	err(	1403	try err(
1404	\\[\u0020"asd"]	1404	\\[\u0020"asd"]
1405	);	1405	);
1406	}	1406	}
1407		1407
1408	test "n_string_no_quotes_with_bad_escape" {	1408	test "n_string_no_quotes_with_bad_escape" {
1409	err(	1409	try err(
1410	\\[\n]	1410	\\[\n]
1411	);	1411	);
1412	}	1412	}
1413		1413
1414	test "n_string_single_doublequote" {	1414	test "n_string_single_doublequote" {
1415	err(	1415	try err(
1416	\\"	1416	\\"
1417	);	1417	);
1418	}	1418	}
1419		1419
1420	test "n_string_single_quote" {	1420	test "n_string_single_quote" {
1421	err(	1421	try err(
1422	\\['single quote']	1422	\\['single quote']
1423	);	1423	);
1424	}	1424	}
1425		1425
1426	test "n_string_single_string_no_double_quotes" {	1426	test "n_string_single_string_no_double_quotes" {
1427	err(	1427	try err(
1428	\\abc	1428	\\abc
1429	);	1429	);
1430	}	1430	}
1431		1431
1432	test "n_string_start_escape_unclosed" {	1432	test "n_string_start_escape_unclosed" {
1433	err(	1433	try err(
1434	\\["\	1434	\\["\
1435	);	1435	);
1436	}	1436	}
1437		1437
1438	test "n_string_unescaped_crtl_char" {	1438	test "n_string_unescaped_crtl_char" {
1439	err("[\"a\x00a\"]");	1439	try err("[\"a\x00a\"]");
1440	}	1440	}
1441		1441
1442	test "n_string_unescaped_newline" {	1442	test "n_string_unescaped_newline" {
1443	err(	1443	try err(
1444	\\["new	1444	\\["new
1445	\\line"]	1445	\\line"]
1446	);	1446	);
1447	}	1447	}
1448		1448
1449	test "n_string_unescaped_tab" {	1449	test "n_string_unescaped_tab" {
1450	err("[\"\t\"]");	1450	try err("[\"\t\"]");
1451	}	1451	}
1452		1452
1453	test "n_string_unicode_CapitalU" {	1453	test "n_string_unicode_CapitalU" {
1454	err(	1454	try err(
1455	\\"\UA66D"	1455	\\"\UA66D"
1456	);	1456	);
1457	}	1457	}
1458		1458
1459	test "n_string_with_trailing_garbage" {	1459	test "n_string_with_trailing_garbage" {
1460	err(	1460	try err(
1461	\\""x	1461	\\""x
1462	);	1462	);
1463	}	1463	}
1464		1464
1465	test "n_structure_100000_opening_arrays" {	1465	test "n_structure_100000_opening_arrays" {
1466	err("[" ** 100000);	1466	try err("[" ** 100000);
1467	}	1467	}
1468		1468
1469	test "n_structure_angle_bracket_." {	1469	test "n_structure_angle_bracket_." {
1470	err(	1470	try err(
1471	\\<.>	1471	\\<.>
1472	);	1472	);
1473	}	1473	}
1474		1474
1475	test "n_structure_angle_bracket_null" {	1475	test "n_structure_angle_bracket_null" {
1476	err(	1476	try err(
1477	\\[<null>]	1477	\\[<null>]
1478	);	1478	);
1479	}	1479	}
1480		1480
1481	test "n_structure_array_trailing_garbage" {	1481	test "n_structure_array_trailing_garbage" {
1482	err(	1482	try err(
1483	\\[1]x	1483	\\[1]x
1484	);	1484	);
1485	}	1485	}
1486		1486
1487	test "n_structure_array_with_extra_array_close" {	1487	test "n_structure_array_with_extra_array_close" {
1488	err(	1488	try err(
1489	\\[1]]	1489	\\[1]]
1490	);	1490	);
1491	}	1491	}
1492		1492
1493	test "n_structure_array_with_unclosed_string" {	1493	test "n_structure_array_with_unclosed_string" {
1494	err(	1494	try err(
1495	\\["asd]	1495	\\["asd]
1496	);	1496	);
1497	}	1497	}
1498		1498
1499	test "n_structure_ascii-unicode-identifier" {	1499	test "n_structure_ascii-unicode-identifier" {
1500	err(	1500	try err(
1501	\\aÃ¥	1501	\\aÃ¥
1502	);	1502	);
1503	}	1503	}
1504		1504
1505	test "n_structure_capitalized_True" {	1505	test "n_structure_capitalized_True" {
1506	err(	1506	try err(
1507	\\[True]	1507	\\[True]
1508	);	1508	);
1509	}	1509	}
1510		1510
1511	test "n_structure_close_unopened_array" {	1511	test "n_structure_close_unopened_array" {
1512	err(	1512	try err(
1513	\\1]	1513	\\1]
1514	);	1514	);
1515	}	1515	}
1516		1516
1517	test "n_structure_comma_instead_of_closing_brace" {	1517	test "n_structure_comma_instead_of_closing_brace" {
1518	err(	1518	try err(
1519	\\{"x": true,	1519	\\{"x": true,
1520	);	1520	);
1521	}	1521	}
1522		1522
1523	test "n_structure_double_array" {	1523	test "n_structure_double_array" {
1524	err(	1524	try err(
1525	\\[][]	1525	\\[][]
1526	);	1526	);
1527	}	1527	}
1528		1528
1529	test "n_structure_end_array" {	1529	test "n_structure_end_array" {
1530	err(	1530	try err(
1531	\\]	1531	\\]
1532	);	1532	);
1533	}	1533	}
1534		1534
1535	test "n_structure_incomplete_UTF8_BOM" {	1535	test "n_structure_incomplete_UTF8_BOM" {
1536	err(	1536	try err(
1537	\\ï»{}	1537	\\ï»{}
1538	);	1538	);
1539	}	1539	}
1540		1540
1541	test "n_structure_lone-invalid-utf-8" {	1541	test "n_structure_lone-invalid-utf-8" {
1542	err(	1542	try err(
1543	\\å	1543	\\å
1544	);	1544	);
1545	}	1545	}
1546		1546
1547	test "n_structure_lone-open-bracket" {	1547	test "n_structure_lone-open-bracket" {
1548	err(	1548	try err(
1549	\\[	1549	\\[
1550	);	1550	);
1551	}	1551	}
1552		1552
1553	test "n_structure_no_data" {	1553	test "n_structure_no_data" {
1554	err(	1554	try err(
1555	\\	1555	\\
1556	);	1556	);
1557	}	1557	}
1558		1558
1559	test "n_structure_null-byte-outside-string" {	1559	test "n_structure_null-byte-outside-string" {
1560	err("[\x00]");	1560	try err("[\x00]");
1561	}	1561	}
1562		1562
1563	test "n_structure_number_with_trailing_garbage" {	1563	test "n_structure_number_with_trailing_garbage" {
1564	err(	1564	try err(
1565	\\2@	1565	\\2@
1566	);	1566	);
1567	}	1567	}
1568		1568
1569	test "n_structure_object_followed_by_closing_object" {	1569	test "n_structure_object_followed_by_closing_object" {
1570	err(	1570	try err(
1571	\\{}}	1571	\\{}}
1572	);	1572	);
1573	}	1573	}
1574		1574
1575	test "n_structure_object_unclosed_no_value" {	1575	test "n_structure_object_unclosed_no_value" {
1576	err(	1576	try err(
1577	\\{"":	1577	\\{"":
1578	);	1578	);
1579	}	1579	}
1580		1580
1581	test "n_structure_object_with_comment" {	1581	test "n_structure_object_with_comment" {
1582	err(	1582	try err(
1583	\\{"a":/comment/"b"}	1583	\\{"a":/comment/"b"}
1584	);	1584	);
1585	}	1585	}
1586		1586
1587	test "n_structure_object_with_trailing_garbage" {	1587	test "n_structure_object_with_trailing_garbage" {
1588	err(	1588	try err(
1589	\\{"a": true} "x"	1589	\\{"a": true} "x"
1590	);	1590	);
1591	}	1591	}
1592		1592
1593	test "n_structure_open_array_apostrophe" {	1593	test "n_structure_open_array_apostrophe" {
1594	err(	1594	try err(
1595	\\['	1595	\\['
1596	);	1596	);
1597	}	1597	}
1598		1598
1599	test "n_structure_open_array_comma" {	1599	test "n_structure_open_array_comma" {
1600	err(	1600	try err(
1601	\\[,	1601	\\[,
1602	);	1602	);
1603	}	1603	}
1604		1604
1605	test "n_structure_open_array_object" {	1605	test "n_structure_open_array_object" {
1606	err("[{\"\":" ** 50000);	1606	try err("[{\"\":" ** 50000);
1607	}	1607	}
1608		1608
1609	test "n_structure_open_array_open_object" {	1609	test "n_structure_open_array_open_object" {
1610	err(	1610	try err(
1611	\\[{	1611	\\[{
1612	);	1612	);
1613	}	1613	}
1614		1614
1615	test "n_structure_open_array_open_string" {	1615	test "n_structure_open_array_open_string" {
1616	err(	1616	try err(
1617	\\["a	1617	\\["a
1618	);	1618	);
1619	}	1619	}
1620		1620
1621	test "n_structure_open_array_string" {	1621	test "n_structure_open_array_string" {
1622	err(	1622	try err(
1623	\\["a"	1623	\\["a"
1624	);	1624	);
1625	}	1625	}
1626		1626
1627	test "n_structure_open_object_close_array" {	1627	test "n_structure_open_object_close_array" {
1628	err(	1628	try err(
1629	\\{]	1629	\\{]
1630	);	1630	);
1631	}	1631	}
1632		1632
1633	test "n_structure_open_object_comma" {	1633	test "n_structure_open_object_comma" {
1634	err(	1634	try err(
1635	\\{,	1635	\\{,
1636	);	1636	);
1637	}	1637	}
1638		1638
1639	test "n_structure_open_object" {	1639	test "n_structure_open_object" {
1640	err(	1640	try err(
1641	\\{	1641	\\{
1642	);	1642	);
1643	}	1643	}
1644		1644
1645	test "n_structure_open_object_open_array" {	1645	test "n_structure_open_object_open_array" {
1646	err(	1646	try err(
1647	\\{[	1647	\\{[
1648	);	1648	);
1649	}	1649	}
1650		1650
1651	test "n_structure_open_object_open_string" {	1651	test "n_structure_open_object_open_string" {
1652	err(	1652	try err(
1653	\\{"a	1653	\\{"a
1654	);	1654	);
1655	}	1655	}
1656		1656
1657	test "n_structure_open_object_string_with_apostrophes" {	1657	test "n_structure_open_object_string_with_apostrophes" {
1658	err(	1658	try err(
1659	\\{'a'	1659	\\{'a'
1660	);	1660	);
1661	}	1661	}
1662		1662
1663	test "n_structure_open_open" {	1663	test "n_structure_open_open" {
1664	err(	1664	try err(
1665	\\["\{["\{["\{["\{	1665	\\["\{["\{["\{["\{
1666	);	1666	);
1667	}	1667	}
1668		1668
1669	test "n_structure_single_eacute" {	1669	test "n_structure_single_eacute" {
1670	err(	1670	try err(
1671	\\é	1671	\\é
1672	);	1672	);
1673	}	1673	}
1674		1674
1675	test "n_structure_single_star" {	1675	test "n_structure_single_star" {
1676	err(	1676	try err(
1677	\\*	1677	\\*
1678	);	1678	);
1679	}	1679	}
1680		1680
1681	test "n_structure_trailing_#" {	1681	test "n_structure_trailing_#" {
1682	err(	1682	try err(
1683	\\{"a":"b"}#{}	1683	\\{"a":"b"}#{}
1684	);	1684	);
1685	}	1685	}
1686		1686
1687	test "n_structure_U+2060_word_joined" {	1687	test "n_structure_U+2060_word_joined" {
1688	err(	1688	try err(
1689	\\[â ]	1689	\\[â ]
1690	);	1690	);
1691	}	1691	}
1692		1692
1693	test "n_structure_uescaped_LF_before_string" {	1693	test "n_structure_uescaped_LF_before_string" {
1694	err(	1694	try err(
1695	\\[\u000A""]	1695	\\[\u000A""]
1696	);	1696	);
1697	}	1697	}
1698		1698
1699	test "n_structure_unclosed_array" {	1699	test "n_structure_unclosed_array" {
1700	err(	1700	try err(
1701	\\[1	1701	\\[1
1702	);	1702	);
1703	}	1703	}
1704		1704
1705	test "n_structure_unclosed_array_partial_null" {	1705	test "n_structure_unclosed_array_partial_null" {
1706	err(	1706	try err(
1707	\\[ false, nul	1707	\\[ false, nul
1708	);	1708	);
1709	}	1709	}
1710		1710
1711	test "n_structure_unclosed_array_unfinished_false" {	1711	test "n_structure_unclosed_array_unfinished_false" {
1712	err(	1712	try err(
1713	\\[ true, fals	1713	\\[ true, fals
1714	);	1714	);
1715	}	1715	}
1716		1716
1717	test "n_structure_unclosed_array_unfinished_true" {	1717	test "n_structure_unclosed_array_unfinished_true" {
1718	err(	1718	try err(
1719	\\[ false, tru	1719	\\[ false, tru
1720	);	1720	);
1721	}	1721	}
1722		1722
1723	test "n_structure_unclosed_object" {	1723	test "n_structure_unclosed_object" {
1724	err(	1724	try err(
1725	\\{"asd":"asd"	1725	\\{"asd":"asd"
1726	);	1726	);
1727	}	1727	}
1728		1728
1729	test "n_structure_unicode-identifier" {	1729	test "n_structure_unicode-identifier" {
1730	err(	1730	try err(
1731	\\Ã¥	1731	\\Ã¥
1732	);	1732	);
1733	}	1733	}
1734		1734
1735	test "n_structure_UTF8_BOM_no_data" {	1735	test "n_structure_UTF8_BOM_no_data" {
1736	err(	1736	try err(
1737	\\ï»¿	1737	\\ï»¿
1738	);	1738	);
1739	}	1739	}
1740		1740
1741	test "n_structure_whitespace_formfeed" {	1741	test "n_structure_whitespace_formfeed" {
1742	err("[\x0c]");	1742	try err("[\x0c]");
1743	}	1743	}
1744		1744
1745	test "n_structure_whitespace_U+2060_word_joiner" {	1745	test "n_structure_whitespace_U+2060_word_joiner" {
1746	err(	1746	try err(
1747	\\[â ]	1747	\\[â ]
1748	);	1748	);
1749	}	1749	}
...	@@ -1751,255 +1751,255 @@ test "n_structure_whitespace_U+2060_word_joiner" {	...	@@ -1751,255 +1751,255 @@ test "n_structure_whitespace_U+2060_word_joiner" {
1751	////////////////////////////////////////////////////////////////////////////////////////////////////	1751	////////////////////////////////////////////////////////////////////////////////////////////////////
1752		1752
1753	test "i_number_double_huge_neg_exp" {	1753	test "i_number_double_huge_neg_exp" {
1754	any(	1754	try any(
1755	\\[123.456e-789]	1755	\\[123.456e-789]
1756	);	1756	);
1757	}	1757	}
1758		1758
1759	test "i_number_huge_exp" {	1759	test "i_number_huge_exp" {
1760	any(	1760	try any(
1761	\\[0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006]	1761	\\[0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006]
1762	);	1762	);
1763	}	1763	}
1764		1764
1765	test "i_number_neg_int_huge_exp" {	1765	test "i_number_neg_int_huge_exp" {
1766	any(	1766	try any(
1767	\\[-1e+9999]	1767	\\[-1e+9999]
1768	);	1768	);
1769	}	1769	}
1770		1770
1771	test "i_number_pos_double_huge_exp" {	1771	test "i_number_pos_double_huge_exp" {
1772	any(	1772	try any(
1773	\\[1.5e+9999]	1773	\\[1.5e+9999]
1774	);	1774	);
1775	}	1775	}
1776		1776
1777	test "i_number_real_neg_overflow" {	1777	test "i_number_real_neg_overflow" {
1778	any(	1778	try any(
1779	\\[-123123e100000]	1779	\\[-123123e100000]
1780	);	1780	);
1781	}	1781	}
1782		1782
1783	test "i_number_real_pos_overflow" {	1783	test "i_number_real_pos_overflow" {
1784	any(	1784	try any(
1785	\\[123123e100000]	1785	\\[123123e100000]
1786	);	1786	);
1787	}	1787	}
1788		1788
1789	test "i_number_real_underflow" {	1789	test "i_number_real_underflow" {
1790	any(	1790	try any(
1791	\\[123e-10000000]	1791	\\[123e-10000000]
1792	);	1792	);
1793	}	1793	}
1794		1794
1795	test "i_number_too_big_neg_int" {	1795	test "i_number_too_big_neg_int" {
1796	any(	1796	try any(
1797	\\[-123123123123123123123123123123]	1797	\\[-123123123123123123123123123123]
1798	);	1798	);
1799	}	1799	}
1800		1800
1801	test "i_number_too_big_pos_int" {	1801	test "i_number_too_big_pos_int" {
1802	any(	1802	try any(
1803	\\[100000000000000000000]	1803	\\[100000000000000000000]
1804	);	1804	);
1805	}	1805	}
1806		1806
1807	test "i_number_very_big_negative_int" {	1807	test "i_number_very_big_negative_int" {
1808	any(	1808	try any(
1809	\\[-237462374673276894279832749832423479823246327846]	1809	\\[-237462374673276894279832749832423479823246327846]
1810	);	1810	);
1811	}	1811	}
1812		1812
1813	test "i_object_key_lone_2nd_surrogate" {	1813	test "i_object_key_lone_2nd_surrogate" {
1814	anyStreamingErrNonStreaming(	1814	try anyStreamingErrNonStreaming(
1815	\\{"\uDFAA":0}	1815	\\{"\uDFAA":0}
1816	);	1816	);
1817	}	1817	}
1818		1818
1819	test "i_string_1st_surrogate_but_2nd_missing" {	1819	test "i_string_1st_surrogate_but_2nd_missing" {
1820	anyStreamingErrNonStreaming(	1820	try anyStreamingErrNonStreaming(
1821	\\["\uDADA"]	1821	\\["\uDADA"]
1822	);	1822	);
1823	}	1823	}
1824		1824
1825	test "i_string_1st_valid_surrogate_2nd_invalid" {	1825	test "i_string_1st_valid_surrogate_2nd_invalid" {
1826	anyStreamingErrNonStreaming(	1826	try anyStreamingErrNonStreaming(
1827	\\["\uD888\u1234"]	1827	\\["\uD888\u1234"]
1828	);	1828	);
1829	}	1829	}
1830		1830
1831	test "i_string_incomplete_surrogate_and_escape_valid" {	1831	test "i_string_incomplete_surrogate_and_escape_valid" {
1832	anyStreamingErrNonStreaming(	1832	try anyStreamingErrNonStreaming(
1833	\\["\uD800\n"]	1833	\\["\uD800\n"]
1834	);	1834	);
1835	}	1835	}
1836		1836
1837	test "i_string_incomplete_surrogate_pair" {	1837	test "i_string_incomplete_surrogate_pair" {
1838	anyStreamingErrNonStreaming(	1838	try anyStreamingErrNonStreaming(
1839	\\["\uDd1ea"]	1839	\\["\uDd1ea"]
1840	);	1840	);
1841	}	1841	}
1842		1842
1843	test "i_string_incomplete_surrogates_escape_valid" {	1843	test "i_string_incomplete_surrogates_escape_valid" {
1844	anyStreamingErrNonStreaming(	1844	try anyStreamingErrNonStreaming(
1845	\\["\uD800\uD800\n"]	1845	\\["\uD800\uD800\n"]
1846	);	1846	);
1847	}	1847	}
1848		1848
1849	test "i_string_invalid_lonely_surrogate" {	1849	test "i_string_invalid_lonely_surrogate" {
1850	anyStreamingErrNonStreaming(	1850	try anyStreamingErrNonStreaming(
1851	\\["\ud800"]	1851	\\["\ud800"]
1852	);	1852	);
1853	}	1853	}
1854		1854
1855	test "i_string_invalid_surrogate" {	1855	test "i_string_invalid_surrogate" {
1856	anyStreamingErrNonStreaming(	1856	try anyStreamingErrNonStreaming(
1857	\\["\ud800abc"]	1857	\\["\ud800abc"]
1858	);	1858	);
1859	}	1859	}
1860		1860
1861	test "i_string_invalid_utf-8" {	1861	test "i_string_invalid_utf-8" {
1862	any(	1862	try any(
1863	\\["ÿ"]	1863	\\["ÿ"]
1864	);	1864	);
1865	}	1865	}
1866		1866
1867	test "i_string_inverted_surrogates_U+1D11E" {	1867	test "i_string_inverted_surrogates_U+1D11E" {
1868	anyStreamingErrNonStreaming(	1868	try anyStreamingErrNonStreaming(
1869	\\["\uDd1e\uD834"]	1869	\\["\uDd1e\uD834"]
1870	);	1870	);
1871	}	1871	}
1872		1872
1873	test "i_string_iso_latin_1" {	1873	test "i_string_iso_latin_1" {
1874	any(	1874	try any(
1875	\\["é"]	1875	\\["é"]
1876	);	1876	);
1877	}	1877	}
1878		1878
1879	test "i_string_lone_second_surrogate" {	1879	test "i_string_lone_second_surrogate" {
1880	anyStreamingErrNonStreaming(	1880	try anyStreamingErrNonStreaming(
1881	\\["\uDFAA"]	1881	\\["\uDFAA"]
1882	);	1882	);
1883	}	1883	}
1884		1884
1885	test "i_string_lone_utf8_continuation_byte" {	1885	test "i_string_lone_utf8_continuation_byte" {
1886	any(	1886	try any(
1887	\\[""]	1887	\\[""]
1888	);	1888	);
1889	}	1889	}
1890		1890
1891	test "i_string_not_in_unicode_range" {	1891	test "i_string_not_in_unicode_range" {
1892	any(	1892	try any(
1893	\\["ô¿¿¿"]	1893	\\["ô¿¿¿"]
1894	);	1894	);
1895	}	1895	}
1896		1896
1897	test "i_string_overlong_sequence_2_bytes" {	1897	test "i_string_overlong_sequence_2_bytes" {
1898	any(	1898	try any(
1899	\\["À¯"]	1899	\\["À¯"]
1900	);	1900	);
1901	}	1901	}
1902		1902
1903	test "i_string_overlong_sequence_6_bytes" {	1903	test "i_string_overlong_sequence_6_bytes" {
1904	any(	1904	try any(
1905	\\["ü¿¿¿¿"]	1905	\\["ü¿¿¿¿"]
1906	);	1906	);
1907	}	1907	}
1908		1908
1909	test "i_string_overlong_sequence_6_bytes_null" {	1909	test "i_string_overlong_sequence_6_bytes_null" {
1910	any(	1910	try any(
1911	\\["ü"]	1911	\\["ü"]
1912	);	1912	);
1913	}	1913	}
1914		1914
1915	test "i_string_truncated-utf-8" {	1915	test "i_string_truncated-utf-8" {
1916	any(	1916	try any(
1917	\\["àÿ"]	1917	\\["àÿ"]
1918	);	1918	);
1919	}	1919	}
1920		1920
1921	test "i_string_utf16BE_no_BOM" {	1921	test "i_string_utf16BE_no_BOM" {
1922	any("\x00\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d");	1922	try any("\x00\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d");
1923	}	1923	}
1924		1924
1925	test "i_string_utf16LE_no_BOM" {	1925	test "i_string_utf16LE_no_BOM" {
1926	any("\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00");	1926	try any("\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00");
1927	}	1927	}
1928		1928
1929	test "i_string_UTF-16LE_with_BOM" {	1929	test "i_string_UTF-16LE_with_BOM" {
1930	any("\xc3\xbf\xc3\xbe\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00");	1930	try any("\xc3\xbf\xc3\xbe\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00");
1931	}	1931	}
1932		1932
1933	test "i_string_UTF-8_invalid_sequence" {	1933	test "i_string_UTF-8_invalid_sequence" {
1934	any(	1934	try any(
1935	\\["æ¥Ñú"]	1935	\\["æ¥Ñú"]
1936	);	1936	);
1937	}	1937	}
1938		1938
1939	test "i_string_UTF8_surrogate_U+D800" {	1939	test "i_string_UTF8_surrogate_U+D800" {
1940	any(	1940	try any(
1941	\\["í "]	1941	\\["í "]
1942	);	1942	);
1943	}	1943	}
1944		1944
1945	test "i_structure_500_nested_arrays" {	1945	test "i_structure_500_nested_arrays" {
1946	any(("[" 500) ++ ("]" 500));	1946	try any(("[" 500) ++ ("]" 500));
1947	}	1947	}
1948		1948
1949	test "i_structure_UTF-8_BOM_empty_object" {	1949	test "i_structure_UTF-8_BOM_empty_object" {
1950	any(	1950	try any(
1951	\\ï»¿{}	1951	\\ï»¿{}
1952	);	1952	);
1953	}	1953	}
1954		1954
1955	test "truncated UTF-8 sequence" {	1955	test "truncated UTF-8 sequence" {
1956	utf8Error("\"\xc2\"");	1956	try utf8Error("\"\xc2\"");
1957	utf8Error("\"\xdf\"");	1957	try utf8Error("\"\xdf\"");
1958	utf8Error("\"\xed\xa0\"");	1958	try utf8Error("\"\xed\xa0\"");
1959	utf8Error("\"\xf0\x80\"");	1959	try utf8Error("\"\xf0\x80\"");
1960	utf8Error("\"\xf0\x80\x80\"");	1960	try utf8Error("\"\xf0\x80\x80\"");
1961	}	1961	}
1962		1962
1963	test "invalid continuation byte" {	1963	test "invalid continuation byte" {
1964	utf8Error("\"\xc2\x00\"");	1964	try utf8Error("\"\xc2\x00\"");
1965	utf8Error("\"\xc2\x7f\"");	1965	try utf8Error("\"\xc2\x7f\"");
1966	utf8Error("\"\xc2\xc0\"");	1966	try utf8Error("\"\xc2\xc0\"");
1967	utf8Error("\"\xc3\xc1\"");	1967	try utf8Error("\"\xc3\xc1\"");
1968	utf8Error("\"\xc4\xf5\"");	1968	try utf8Error("\"\xc4\xf5\"");
1969	utf8Error("\"\xc5\xff\"");	1969	try utf8Error("\"\xc5\xff\"");
1970	utf8Error("\"\xe4\x80\x00\"");	1970	try utf8Error("\"\xe4\x80\x00\"");
1971	utf8Error("\"\xe5\x80\x10\"");	1971	try utf8Error("\"\xe5\x80\x10\"");
1972	utf8Error("\"\xe6\x80\xc0\"");	1972	try utf8Error("\"\xe6\x80\xc0\"");
1973	utf8Error("\"\xe7\x80\xf5\"");	1973	try utf8Error("\"\xe7\x80\xf5\"");
1974	utf8Error("\"\xe8\x00\x80\"");	1974	try utf8Error("\"\xe8\x00\x80\"");
1975	utf8Error("\"\xf2\x00\x80\x80\"");	1975	try utf8Error("\"\xf2\x00\x80\x80\"");
1976	utf8Error("\"\xf0\x80\x00\x80\"");	1976	try utf8Error("\"\xf0\x80\x00\x80\"");
1977	utf8Error("\"\xf1\x80\xc0\x80\"");	1977	try utf8Error("\"\xf1\x80\xc0\x80\"");
1978	utf8Error("\"\xf2\x80\x80\x00\"");	1978	try utf8Error("\"\xf2\x80\x80\x00\"");
1979	utf8Error("\"\xf3\x80\x80\xc0\"");	1979	try utf8Error("\"\xf3\x80\x80\xc0\"");
1980	utf8Error("\"\xf4\x80\x80\xf5\"");	1980	try utf8Error("\"\xf4\x80\x80\xf5\"");
1981	}	1981	}
1982		1982
1983	test "disallowed overlong form" {	1983	test "disallowed overlong form" {
1984	utf8Error("\"\xc0\x80\"");	1984	try utf8Error("\"\xc0\x80\"");
1985	utf8Error("\"\xc0\x90\"");	1985	try utf8Error("\"\xc0\x90\"");
1986	utf8Error("\"\xc1\x80\"");	1986	try utf8Error("\"\xc1\x80\"");
1987	utf8Error("\"\xc1\x90\"");	1987	try utf8Error("\"\xc1\x90\"");
1988	utf8Error("\"\xe0\x80\x80\"");	1988	try utf8Error("\"\xe0\x80\x80\"");
1989	utf8Error("\"\xf0\x80\x80\x80\"");	1989	try utf8Error("\"\xf0\x80\x80\x80\"");
1990	}	1990	}
1991		1991
1992	test "out of UTF-16 range" {	1992	test "out of UTF-16 range" {
1993	utf8Error("\"\xf4\x90\x80\x80\"");	1993	try utf8Error("\"\xf4\x90\x80\x80\"");
1994	utf8Error("\"\xf5\x80\x80\x80\"");	1994	try utf8Error("\"\xf5\x80\x80\x80\"");
1995	utf8Error("\"\xf6\x80\x80\x80\"");	1995	try utf8Error("\"\xf6\x80\x80\x80\"");
1996	utf8Error("\"\xf7\x80\x80\x80\"");	1996	try utf8Error("\"\xf7\x80\x80\x80\"");
1997	utf8Error("\"\xf8\x80\x80\x80\"");	1997	try utf8Error("\"\xf8\x80\x80\x80\"");
1998	utf8Error("\"\xf9\x80\x80\x80\"");	1998	try utf8Error("\"\xf9\x80\x80\x80\"");
1999	utf8Error("\"\xfa\x80\x80\x80\"");	1999	try utf8Error("\"\xfa\x80\x80\x80\"");
2000	utf8Error("\"\xfb\x80\x80\x80\"");	2000	try utf8Error("\"\xfb\x80\x80\x80\"");
2001	utf8Error("\"\xfc\x80\x80\x80\"");	2001	try utf8Error("\"\xfc\x80\x80\x80\"");
2002	utf8Error("\"\xfd\x80\x80\x80\"");	2002	try utf8Error("\"\xfd\x80\x80\x80\"");
2003	utf8Error("\"\xfe\x80\x80\x80\"");	2003	try utf8Error("\"\xfe\x80\x80\x80\"");
2004	utf8Error("\"\xff\x80\x80\x80\"");	2004	try utf8Error("\"\xff\x80\x80\x80\"");
2005	}	2005	}

lib/std/json/write_stream.zig+1-1

...	@@ -288,7 +288,7 @@ test "json write stream" {	...	@@ -288,7 +288,7 @@ test "json write stream" {
288	\\ "float": 3.5e+00	288	\\ "float": 3.5e+00
289	\\}	289	\\}
290	;	290	;
291	std.testing.expect(std.mem.eql(u8, expected, result));	291	try std.testing.expect(std.mem.eql(u8, expected, result));
292	}	292	}
293		293
294	fn getJsonObject(allocator: *std.mem.Allocator) !std.json.Value {	294	fn getJsonObject(allocator: *std.mem.Allocator) !std.json.Value {

lib/std/leb128.zig+68-68

lib/std/linked_list.zig+20-20

lib/std/math.zig+353-353

lib/std/math/acos.zig+18-18

lib/std/math/acosh.zig+14-14

lib/std/math/asin.zig+22-22

lib/std/math/asinh.zig+26-26

lib/std/math/atan.zig+20-20

...	@@ -217,44 +217,44 @@ fn atan64(x_: f64) f64 {	...	@@ -217,44 +217,44 @@ fn atan64(x_: f64) f64 {
217	}	217	}
218		218
219	test "math.atan" {	219	test "math.atan" {
220	expect(@bitCast(u32, atan(@as(f32, 0.2))) == @bitCast(u32, atan32(0.2)));	220	try expect(@bitCast(u32, atan(@as(f32, 0.2))) == @bitCast(u32, atan32(0.2)));
221	expect(atan(@as(f64, 0.2)) == atan64(0.2));	221	try expect(atan(@as(f64, 0.2)) == atan64(0.2));
222	}	222	}
223		223
224	test "math.atan32" {	224	test "math.atan32" {
225	const epsilon = 0.000001;	225	const epsilon = 0.000001;
226		226
227	expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));	227	try expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon));
228	expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));	228	try expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon));
229	expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));	229	try expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon));
230	expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));	230	try expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon));
231	expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));	231	try expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon));
232	}	232	}
233		233
234	test "math.atan64" {	234	test "math.atan64" {
235	const epsilon = 0.000001;	235	const epsilon = 0.000001;
236		236
237	expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));	237	try expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon));
238	expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));	238	try expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon));
239	expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));	239	try expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon));
240	expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));	240	try expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon));
241	expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));	241	try expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon));
242	}	242	}
243		243
244	test "math.atan32.special" {	244	test "math.atan32.special" {
245	const epsilon = 0.000001;	245	const epsilon = 0.000001;
246		246
247	expect(atan32(0.0) == 0.0);	247	try expect(atan32(0.0) == 0.0);
248	expect(atan32(-0.0) == -0.0);	248	try expect(atan32(-0.0) == -0.0);
249	expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));	249	try expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon));
250	expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));	250	try expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon));
251	}	251	}
252		252
253	test "math.atan64.special" {	253	test "math.atan64.special" {
254	const epsilon = 0.000001;	254	const epsilon = 0.000001;
255		255
256	expect(atan64(0.0) == 0.0);	256	try expect(atan64(0.0) == 0.0);
257	expect(atan64(-0.0) == -0.0);	257	try expect(atan64(-0.0) == -0.0);
258	expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));	258	try expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon));
259	expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));	259	try expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon));
260	}	260	}

lib/std/math/atan2.zig+52-52

lib/std/math/atanh.zig+18-18

lib/std/math/big/int_test.zig+211-211

lib/std/math/big/rational.zig+67-67

lib/std/math/cbrt.zig+24-24

...	@@ -125,44 +125,44 @@ fn cbrt64(x: f64) f64 {	...	@@ -125,44 +125,44 @@ fn cbrt64(x: f64) f64 {
125	}	125	}
126		126
127	test "math.cbrt" {	127	test "math.cbrt" {
128	expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0));	128	try expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0));
129	expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0));	129	try expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0));
130	}	130	}
131		131
132	test "math.cbrt32" {	132	test "math.cbrt32" {
133	const epsilon = 0.000001;	133	const epsilon = 0.000001;
134		134
135	expect(cbrt32(0.0) == 0.0);	135	try expect(cbrt32(0.0) == 0.0);
136	expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon));	136	try expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon));
137	expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon));	137	try expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon));
138	expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon));	138	try expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon));
139	expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon));	139	try expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon));
140	expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon));	140	try expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon));
141	}	141	}
142		142
143	test "math.cbrt64" {	143	test "math.cbrt64" {
144	const epsilon = 0.000001;	144	const epsilon = 0.000001;
145		145
146	expect(cbrt64(0.0) == 0.0);	146	try expect(cbrt64(0.0) == 0.0);
147	expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon));	147	try expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon));
148	expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon));	148	try expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon));
149	expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon));	149	try expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon));
150	expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon));	150	try expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon));
151	expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon));	151	try expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon));
152	}	152	}
153		153
154	test "math.cbrt.special" {	154	test "math.cbrt.special" {
155	expect(cbrt32(0.0) == 0.0);	155	try expect(cbrt32(0.0) == 0.0);
156	expect(cbrt32(-0.0) == -0.0);	156	try expect(cbrt32(-0.0) == -0.0);
157	expect(math.isPositiveInf(cbrt32(math.inf(f32))));	157	try expect(math.isPositiveInf(cbrt32(math.inf(f32))));
158	expect(math.isNegativeInf(cbrt32(-math.inf(f32))));	158	try expect(math.isNegativeInf(cbrt32(-math.inf(f32))));
159	expect(math.isNan(cbrt32(math.nan(f32))));	159	try expect(math.isNan(cbrt32(math.nan(f32))));
160	}	160	}
161		161
162	test "math.cbrt64.special" {	162	test "math.cbrt64.special" {
163	expect(cbrt64(0.0) == 0.0);	163	try expect(cbrt64(0.0) == 0.0);
164	expect(cbrt64(-0.0) == -0.0);	164	try expect(cbrt64(-0.0) == -0.0);
165	expect(math.isPositiveInf(cbrt64(math.inf(f64))));	165	try expect(math.isPositiveInf(cbrt64(math.inf(f64))));
166	expect(math.isNegativeInf(cbrt64(-math.inf(f64))));	166	try expect(math.isNegativeInf(cbrt64(-math.inf(f64))));
167	expect(math.isNan(cbrt64(math.nan(f64))));	167	try expect(math.isNan(cbrt64(math.nan(f64))));
168	}	168	}

lib/std/math/ceil.zig+27-27

...	@@ -120,49 +120,49 @@ fn ceil128(x: f128) f128 {	...	@@ -120,49 +120,49 @@ fn ceil128(x: f128) f128 {
120	}	120	}
121		121
122	test "math.ceil" {	122	test "math.ceil" {
123	expect(ceil(@as(f32, 0.0)) == ceil32(0.0));	123	try expect(ceil(@as(f32, 0.0)) == ceil32(0.0));
124	expect(ceil(@as(f64, 0.0)) == ceil64(0.0));	124	try expect(ceil(@as(f64, 0.0)) == ceil64(0.0));
125	expect(ceil(@as(f128, 0.0)) == ceil128(0.0));	125	try expect(ceil(@as(f128, 0.0)) == ceil128(0.0));
126	}	126	}
127		127
128	test "math.ceil32" {	128	test "math.ceil32" {
129	expect(ceil32(1.3) == 2.0);	129	try expect(ceil32(1.3) == 2.0);
130	expect(ceil32(-1.3) == -1.0);	130	try expect(ceil32(-1.3) == -1.0);
131	expect(ceil32(0.2) == 1.0);	131	try expect(ceil32(0.2) == 1.0);
132	}	132	}
133		133
134	test "math.ceil64" {	134	test "math.ceil64" {
135	expect(ceil64(1.3) == 2.0);	135	try expect(ceil64(1.3) == 2.0);
136	expect(ceil64(-1.3) == -1.0);	136	try expect(ceil64(-1.3) == -1.0);
137	expect(ceil64(0.2) == 1.0);	137	try expect(ceil64(0.2) == 1.0);
138	}	138	}
139		139
140	test "math.ceil128" {	140	test "math.ceil128" {
141	expect(ceil128(1.3) == 2.0);	141	try expect(ceil128(1.3) == 2.0);
142	expect(ceil128(-1.3) == -1.0);	142	try expect(ceil128(-1.3) == -1.0);
143	expect(ceil128(0.2) == 1.0);	143	try expect(ceil128(0.2) == 1.0);
144	}	144	}
145		145
146	test "math.ceil32.special" {	146	test "math.ceil32.special" {
147	expect(ceil32(0.0) == 0.0);	147	try expect(ceil32(0.0) == 0.0);
148	expect(ceil32(-0.0) == -0.0);	148	try expect(ceil32(-0.0) == -0.0);
149	expect(math.isPositiveInf(ceil32(math.inf(f32))));	149	try expect(math.isPositiveInf(ceil32(math.inf(f32))));
150	expect(math.isNegativeInf(ceil32(-math.inf(f32))));	150	try expect(math.isNegativeInf(ceil32(-math.inf(f32))));
151	expect(math.isNan(ceil32(math.nan(f32))));	151	try expect(math.isNan(ceil32(math.nan(f32))));
152	}	152	}
153		153
154	test "math.ceil64.special" {	154	test "math.ceil64.special" {
155	expect(ceil64(0.0) == 0.0);	155	try expect(ceil64(0.0) == 0.0);
156	expect(ceil64(-0.0) == -0.0);	156	try expect(ceil64(-0.0) == -0.0);
157	expect(math.isPositiveInf(ceil64(math.inf(f64))));	157	try expect(math.isPositiveInf(ceil64(math.inf(f64))));
158	expect(math.isNegativeInf(ceil64(-math.inf(f64))));	158	try expect(math.isNegativeInf(ceil64(-math.inf(f64))));
159	expect(math.isNan(ceil64(math.nan(f64))));	159	try expect(math.isNan(ceil64(math.nan(f64))));
160	}	160	}
161		161
162	test "math.ceil128.special" {	162	test "math.ceil128.special" {
163	expect(ceil128(0.0) == 0.0);	163	try expect(ceil128(0.0) == 0.0);
164	expect(ceil128(-0.0) == -0.0);	164	try expect(ceil128(-0.0) == -0.0);
165	expect(math.isPositiveInf(ceil128(math.inf(f128))));	165	try expect(math.isPositiveInf(ceil128(math.inf(f128))));
166	expect(math.isNegativeInf(ceil128(-math.inf(f128))));	166	try expect(math.isNegativeInf(ceil128(-math.inf(f128))));
167	expect(math.isNan(ceil128(math.nan(f128))));	167	try expect(math.isNan(ceil128(math.nan(f128))));
168	}	168	}

lib/std/math/complex.zig+7-7

lib/std/math/complex/abs.zig+1-1

...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;	...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;
20	test "complex.cabs" {	20	test "complex.cabs" {
21	const a = Complex(f32).new(5, 3);	21	const a = Complex(f32).new(5, 3);
22	const c = abs(a);	22	const c = abs(a);
23	testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));	23	try testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
24	}	24	}

lib/std/math/complex/acos.zig+2-2

...	@@ -22,6 +22,6 @@ test "complex.cacos" {	...	@@ -22,6 +22,6 @@ test "complex.cacos" {
22	const a = Complex(f32).new(5, 3);	22	const a = Complex(f32).new(5, 3);
23	const c = acos(a);	23	const c = acos(a);
24		24
25	testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon));	25	try testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon));
26	testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon));
27	}	27	}

lib/std/math/complex/acosh.zig+2-2

...	@@ -22,6 +22,6 @@ test "complex.cacosh" {	...	@@ -22,6 +22,6 @@ test "complex.cacosh" {
22	const a = Complex(f32).new(5, 3);	22	const a = Complex(f32).new(5, 3);
23	const c = acosh(a);	23	const c = acosh(a);
24		24
25	testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon));	25	try testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon));
26	testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon));
27	}	27	}

lib/std/math/complex/arg.zig+1-1

...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;	...	@@ -20,5 +20,5 @@ const epsilon = 0.0001;
20	test "complex.carg" {	20	test "complex.carg" {
21	const a = Complex(f32).new(5, 3);	21	const a = Complex(f32).new(5, 3);
22	const c = arg(a);	22	const c = arg(a);
23	testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon));	23	try testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon));
24	}	24	}

lib/std/math/complex/asin.zig+2-2

...	@@ -28,6 +28,6 @@ test "complex.casin" {	...	@@ -28,6 +28,6 @@ test "complex.casin" {
28	const a = Complex(f32).new(5, 3);	28	const a = Complex(f32).new(5, 3);
29	const c = asin(a);	29	const c = asin(a);
30		30
31	testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon));	31	try testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon));
32	testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon));	32	try testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon));
33	}	33	}

lib/std/math/complex/asinh.zig+2-2

...	@@ -23,6 +23,6 @@ test "complex.casinh" {	...	@@ -23,6 +23,6 @@ test "complex.casinh" {
23	const a = Complex(f32).new(5, 3);	23	const a = Complex(f32).new(5, 3);
24	const c = asinh(a);	24	const c = asinh(a);
25		25
26	testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon));
27	testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon));
28	}	28	}

lib/std/math/complex/atan.zig+4-4

...	@@ -130,14 +130,14 @@ test "complex.catan32" {	...	@@ -130,14 +130,14 @@ test "complex.catan32" {
130	const a = Complex(f32).new(5, 3);	130	const a = Complex(f32).new(5, 3);
131	const c = atan(a);	131	const c = atan(a);
132		132
133	testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon));	133	try testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon));
134	testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));	134	try testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon));
135	}	135	}
136		136
137	test "complex.catan64" {	137	test "complex.catan64" {
138	const a = Complex(f64).new(5, 3);	138	const a = Complex(f64).new(5, 3);
139	const c = atan(a);	139	const c = atan(a);
140		140
141	testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon));	141	try testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon));
142	testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon));	142	try testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon));
143	}	143	}

lib/std/math/complex/atanh.zig+2-2

...	@@ -23,6 +23,6 @@ test "complex.catanh" {	...	@@ -23,6 +23,6 @@ test "complex.catanh" {
23	const a = Complex(f32).new(5, 3);	23	const a = Complex(f32).new(5, 3);
24	const c = atanh(a);	24	const c = atanh(a);
25		25
26	testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon));
27	testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon));
28	}	28	}

lib/std/math/complex/conj.zig+1-1

...	@@ -19,5 +19,5 @@ test "complex.conj" {	...	@@ -19,5 +19,5 @@ test "complex.conj" {
19	const a = Complex(f32).new(5, 3);	19	const a = Complex(f32).new(5, 3);
20	const c = a.conjugate();	20	const c = a.conjugate();
21		21
22	testing.expect(c.re == 5 and c.im == -3);	22	try testing.expect(c.re == 5 and c.im == -3);
23	}	23	}

lib/std/math/complex/cos.zig+2-2

...	@@ -22,6 +22,6 @@ test "complex.ccos" {	...	@@ -22,6 +22,6 @@ test "complex.ccos" {
22	const a = Complex(f32).new(5, 3);	22	const a = Complex(f32).new(5, 3);
23	const c = cos(a);	23	const c = cos(a);
24		24
25	testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon));	25	try testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon));
26	testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon));
27	}	27	}

lib/std/math/complex/cosh.zig+4-4

...	@@ -165,14 +165,14 @@ test "complex.ccosh32" {	...	@@ -165,14 +165,14 @@ test "complex.ccosh32" {
165	const a = Complex(f32).new(5, 3);	165	const a = Complex(f32).new(5, 3);
166	const c = cosh(a);	166	const c = cosh(a);
167		167
168	testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon));	168	try testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon));
169	testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));	169	try testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon));
170	}	170	}
171		171
172	test "complex.ccosh64" {	172	test "complex.ccosh64" {
173	const a = Complex(f64).new(5, 3);	173	const a = Complex(f64).new(5, 3);
174	const c = cosh(a);	174	const c = cosh(a);
175		175
176	testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon));	176	try testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon));
177	testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon));	177	try testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon));
178	}	178	}

lib/std/math/complex/exp.zig+4-4

...	@@ -131,14 +131,14 @@ test "complex.cexp32" {	...	@@ -131,14 +131,14 @@ test "complex.cexp32" {
131	const a = Complex(f32).new(5, 3);	131	const a = Complex(f32).new(5, 3);
132	const c = exp(a);	132	const c = exp(a);
133		133
134	testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon));	134	try testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon));
135	testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon));	135	try testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon));
136	}	136	}
137		137
138	test "complex.cexp64" {	138	test "complex.cexp64" {
139	const a = Complex(f64).new(5, 3);	139	const a = Complex(f64).new(5, 3);
140	const c = exp(a);	140	const c = exp(a);
141		141
142	testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon));	142	try testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon));
143	testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon));	143	try testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon));
144	}	144	}

lib/std/math/complex/log.zig+2-2

...	@@ -24,6 +24,6 @@ test "complex.clog" {	...	@@ -24,6 +24,6 @@ test "complex.clog" {
24	const a = Complex(f32).new(5, 3);	24	const a = Complex(f32).new(5, 3);
25	const c = log(a);	25	const c = log(a);
26		26
27	testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon));
28	testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon));	28	try testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon));
29	}	29	}

lib/std/math/complex/pow.zig+2-2

...	@@ -23,6 +23,6 @@ test "complex.cpow" {	...	@@ -23,6 +23,6 @@ test "complex.cpow" {
23	const b = Complex(f32).new(2.3, -1.3);	23	const b = Complex(f32).new(2.3, -1.3);
24	const c = pow(Complex(f32), a, b);	24	const c = pow(Complex(f32), a, b);
25		25
26	testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon));
27	testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon));
28	}	28	}

lib/std/math/complex/proj.zig+1-1

...	@@ -26,5 +26,5 @@ test "complex.cproj" {	...	@@ -26,5 +26,5 @@ test "complex.cproj" {
26	const a = Complex(f32).new(5, 3);	26	const a = Complex(f32).new(5, 3);
27	const c = proj(a);	27	const c = proj(a);
28		28
29	testing.expect(c.re == 5 and c.im == 3);	29	try testing.expect(c.re == 5 and c.im == 3);
30	}	30	}

lib/std/math/complex/sin.zig+2-2

...	@@ -23,6 +23,6 @@ test "complex.csin" {	...	@@ -23,6 +23,6 @@ test "complex.csin" {
23	const a = Complex(f32).new(5, 3);	23	const a = Complex(f32).new(5, 3);
24	const c = sin(a);	24	const c = sin(a);
25		25
26	testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon));
27	testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon));
28	}	28	}

lib/std/math/complex/sinh.zig+4-4

...	@@ -164,14 +164,14 @@ test "complex.csinh32" {	...	@@ -164,14 +164,14 @@ test "complex.csinh32" {
164	const a = Complex(f32).new(5, 3);	164	const a = Complex(f32).new(5, 3);
165	const c = sinh(a);	165	const c = sinh(a);
166		166
167	testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon));	167	try testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon));
168	testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));	168	try testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon));
169	}	169	}
170		170
171	test "complex.csinh64" {	171	test "complex.csinh64" {
172	const a = Complex(f64).new(5, 3);	172	const a = Complex(f64).new(5, 3);
173	const c = sinh(a);	173	const c = sinh(a);
174		174
175	testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon));	175	try testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon));
176	testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon));	176	try testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon));
177	}	177	}

lib/std/math/complex/sqrt.zig+4-4

...	@@ -138,14 +138,14 @@ test "complex.csqrt32" {	...	@@ -138,14 +138,14 @@ test "complex.csqrt32" {
138	const a = Complex(f32).new(5, 3);	138	const a = Complex(f32).new(5, 3);
139	const c = sqrt(a);	139	const c = sqrt(a);
140		140
141	testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon));	141	try testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon));
142	testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));	142	try testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon));
143	}	143	}
144		144
145	test "complex.csqrt64" {	145	test "complex.csqrt64" {
146	const a = Complex(f64).new(5, 3);	146	const a = Complex(f64).new(5, 3);
147	const c = sqrt(a);	147	const c = sqrt(a);
148		148
149	testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon));	149	try testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon));
150	testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon));	150	try testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon));
151	}	151	}

lib/std/math/complex/tan.zig+2-2

...	@@ -23,6 +23,6 @@ test "complex.ctan" {	...	@@ -23,6 +23,6 @@ test "complex.ctan" {
23	const a = Complex(f32).new(5, 3);	23	const a = Complex(f32).new(5, 3);
24	const c = tan(a);	24	const c = tan(a);
25		25
26	testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon));	26	try testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon));
27	testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon));	27	try testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon));
28	}	28	}

lib/std/math/complex/tanh.zig+4-4

...	@@ -113,14 +113,14 @@ test "complex.ctanh32" {	...	@@ -113,14 +113,14 @@ test "complex.ctanh32" {
113	const a = Complex(f32).new(5, 3);	113	const a = Complex(f32).new(5, 3);
114	const c = tanh(a);	114	const c = tanh(a);
115		115
116	testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon));	116	try testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon));
117	testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));	117	try testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon));
118	}	118	}
119		119
120	test "complex.ctanh64" {	120	test "complex.ctanh64" {
121	const a = Complex(f64).new(5, 3);	121	const a = Complex(f64).new(5, 3);
122	const c = tanh(a);	122	const c = tanh(a);
123		123
124	testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon));	124	try testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon));
125	testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon));	125	try testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon));
126	}	126	}

lib/std/math/copysign.zig+20-20

lib/std/math/cos.zig+22-22

lib/std/math/cosh.zig+28-28

lib/std/math/exp.zig+16-16

lib/std/math/exp2.zig+15-15

lib/std/math/expm1.zig+18-18

lib/std/math/fabs.zig+24-24

...	@@ -55,52 +55,52 @@ fn fabs128(x: f128) f128 {	...	@@ -55,52 +55,52 @@ fn fabs128(x: f128) f128 {
55	}	55	}
56		56
57	test "math.fabs" {	57	test "math.fabs" {
58	expect(fabs(@as(f16, 1.0)) == fabs16(1.0));	58	try expect(fabs(@as(f16, 1.0)) == fabs16(1.0));
59	expect(fabs(@as(f32, 1.0)) == fabs32(1.0));	59	try expect(fabs(@as(f32, 1.0)) == fabs32(1.0));
60	expect(fabs(@as(f64, 1.0)) == fabs64(1.0));	60	try expect(fabs(@as(f64, 1.0)) == fabs64(1.0));
61	expect(fabs(@as(f128, 1.0)) == fabs128(1.0));	61	try expect(fabs(@as(f128, 1.0)) == fabs128(1.0));
62	}	62	}
63		63
64	test "math.fabs16" {	64	test "math.fabs16" {
65	expect(fabs16(1.0) == 1.0);	65	try expect(fabs16(1.0) == 1.0);
66	expect(fabs16(-1.0) == 1.0);	66	try expect(fabs16(-1.0) == 1.0);
67	}	67	}
68		68
69	test "math.fabs32" {	69	test "math.fabs32" {
70	expect(fabs32(1.0) == 1.0);	70	try expect(fabs32(1.0) == 1.0);
71	expect(fabs32(-1.0) == 1.0);	71	try expect(fabs32(-1.0) == 1.0);
72	}	72	}
73		73
74	test "math.fabs64" {	74	test "math.fabs64" {
75	expect(fabs64(1.0) == 1.0);	75	try expect(fabs64(1.0) == 1.0);
76	expect(fabs64(-1.0) == 1.0);	76	try expect(fabs64(-1.0) == 1.0);
77	}	77	}
78		78
79	test "math.fabs128" {	79	test "math.fabs128" {
80	expect(fabs128(1.0) == 1.0);	80	try expect(fabs128(1.0) == 1.0);
81	expect(fabs128(-1.0) == 1.0);	81	try expect(fabs128(-1.0) == 1.0);
82	}	82	}
83		83
84	test "math.fabs16.special" {	84	test "math.fabs16.special" {
85	expect(math.isPositiveInf(fabs(math.inf(f16))));	85	try expect(math.isPositiveInf(fabs(math.inf(f16))));
86	expect(math.isPositiveInf(fabs(-math.inf(f16))));	86	try expect(math.isPositiveInf(fabs(-math.inf(f16))));
87	expect(math.isNan(fabs(math.nan(f16))));	87	try expect(math.isNan(fabs(math.nan(f16))));
88	}	88	}
89		89
90	test "math.fabs32.special" {	90	test "math.fabs32.special" {
91	expect(math.isPositiveInf(fabs(math.inf(f32))));	91	try expect(math.isPositiveInf(fabs(math.inf(f32))));
92	expect(math.isPositiveInf(fabs(-math.inf(f32))));	92	try expect(math.isPositiveInf(fabs(-math.inf(f32))));
93	expect(math.isNan(fabs(math.nan(f32))));	93	try expect(math.isNan(fabs(math.nan(f32))));
94	}	94	}
95		95
96	test "math.fabs64.special" {	96	test "math.fabs64.special" {
97	expect(math.isPositiveInf(fabs(math.inf(f64))));	97	try expect(math.isPositiveInf(fabs(math.inf(f64))));
98	expect(math.isPositiveInf(fabs(-math.inf(f64))));	98	try expect(math.isPositiveInf(fabs(-math.inf(f64))));
99	expect(math.isNan(fabs(math.nan(f64))));	99	try expect(math.isNan(fabs(math.nan(f64))));
100	}	100	}
101		101
102	test "math.fabs128.special" {	102	test "math.fabs128.special" {
103	expect(math.isPositiveInf(fabs(math.inf(f128))));	103	try expect(math.isPositiveInf(fabs(math.inf(f128))));
104	expect(math.isPositiveInf(fabs(-math.inf(f128))));	104	try expect(math.isPositiveInf(fabs(-math.inf(f128))));
105	expect(math.isNan(fabs(math.nan(f128))));	105	try expect(math.isNan(fabs(math.nan(f128))));
106	}	106	}

lib/std/math/floor.zig+36-36

...	@@ -156,64 +156,64 @@ fn floor128(x: f128) f128 {	...	@@ -156,64 +156,64 @@ fn floor128(x: f128) f128 {
156	}	156	}
157		157
158	test "math.floor" {	158	test "math.floor" {
159	expect(floor(@as(f16, 1.3)) == floor16(1.3));	159	try expect(floor(@as(f16, 1.3)) == floor16(1.3));
160	expect(floor(@as(f32, 1.3)) == floor32(1.3));	160	try expect(floor(@as(f32, 1.3)) == floor32(1.3));
161	expect(floor(@as(f64, 1.3)) == floor64(1.3));	161	try expect(floor(@as(f64, 1.3)) == floor64(1.3));
162	expect(floor(@as(f128, 1.3)) == floor128(1.3));	162	try expect(floor(@as(f128, 1.3)) == floor128(1.3));
163	}	163	}
164		164
165	test "math.floor16" {	165	test "math.floor16" {
166	expect(floor16(1.3) == 1.0);	166	try expect(floor16(1.3) == 1.0);
167	expect(floor16(-1.3) == -2.0);	167	try expect(floor16(-1.3) == -2.0);
168	expect(floor16(0.2) == 0.0);	168	try expect(floor16(0.2) == 0.0);
169	}	169	}
170		170
171	test "math.floor32" {	171	test "math.floor32" {
172	expect(floor32(1.3) == 1.0);	172	try expect(floor32(1.3) == 1.0);
173	expect(floor32(-1.3) == -2.0);	173	try expect(floor32(-1.3) == -2.0);
174	expect(floor32(0.2) == 0.0);	174	try expect(floor32(0.2) == 0.0);
175	}	175	}
176		176
177	test "math.floor64" {	177	test "math.floor64" {
178	expect(floor64(1.3) == 1.0);	178	try expect(floor64(1.3) == 1.0);
179	expect(floor64(-1.3) == -2.0);	179	try expect(floor64(-1.3) == -2.0);
180	expect(floor64(0.2) == 0.0);	180	try expect(floor64(0.2) == 0.0);
181	}	181	}
182		182
183	test "math.floor128" {	183	test "math.floor128" {
184	expect(floor128(1.3) == 1.0);	184	try expect(floor128(1.3) == 1.0);
185	expect(floor128(-1.3) == -2.0);	185	try expect(floor128(-1.3) == -2.0);
186	expect(floor128(0.2) == 0.0);	186	try expect(floor128(0.2) == 0.0);
187	}	187	}
188		188
189	test "math.floor16.special" {	189	test "math.floor16.special" {
190	expect(floor16(0.0) == 0.0);	190	try expect(floor16(0.0) == 0.0);
191	expect(floor16(-0.0) == -0.0);	191	try expect(floor16(-0.0) == -0.0);
192	expect(math.isPositiveInf(floor16(math.inf(f16))));	192	try expect(math.isPositiveInf(floor16(math.inf(f16))));
193	expect(math.isNegativeInf(floor16(-math.inf(f16))));	193	try expect(math.isNegativeInf(floor16(-math.inf(f16))));
194	expect(math.isNan(floor16(math.nan(f16))));	194	try expect(math.isNan(floor16(math.nan(f16))));
195	}	195	}
196		196
197	test "math.floor32.special" {	197	test "math.floor32.special" {
198	expect(floor32(0.0) == 0.0);	198	try expect(floor32(0.0) == 0.0);
199	expect(floor32(-0.0) == -0.0);	199	try expect(floor32(-0.0) == -0.0);
200	expect(math.isPositiveInf(floor32(math.inf(f32))));	200	try expect(math.isPositiveInf(floor32(math.inf(f32))));
201	expect(math.isNegativeInf(floor32(-math.inf(f32))));	201	try expect(math.isNegativeInf(floor32(-math.inf(f32))));
202	expect(math.isNan(floor32(math.nan(f32))));	202	try expect(math.isNan(floor32(math.nan(f32))));
203	}	203	}
204		204
205	test "math.floor64.special" {	205	test "math.floor64.special" {
206	expect(floor64(0.0) == 0.0);	206	try expect(floor64(0.0) == 0.0);
207	expect(floor64(-0.0) == -0.0);	207	try expect(floor64(-0.0) == -0.0);
208	expect(math.isPositiveInf(floor64(math.inf(f64))));	208	try expect(math.isPositiveInf(floor64(math.inf(f64))));
209	expect(math.isNegativeInf(floor64(-math.inf(f64))));	209	try expect(math.isNegativeInf(floor64(-math.inf(f64))));
210	expect(math.isNan(floor64(math.nan(f64))));	210	try expect(math.isNan(floor64(math.nan(f64))));
211	}	211	}
212		212
213	test "math.floor128.special" {	213	test "math.floor128.special" {
214	expect(floor128(0.0) == 0.0);	214	try expect(floor128(0.0) == 0.0);
215	expect(floor128(-0.0) == -0.0);	215	try expect(floor128(-0.0) == -0.0);
216	expect(math.isPositiveInf(floor128(math.inf(f128))));	216	try expect(math.isPositiveInf(floor128(math.inf(f128))));
217	expect(math.isNegativeInf(floor128(-math.inf(f128))));	217	try expect(math.isNegativeInf(floor128(-math.inf(f128))));
218	expect(math.isNan(floor128(math.nan(f128))));	218	try expect(math.isNan(floor128(math.nan(f128))));
219	}	219	}

lib/std/math/fma.zig+16-16

lib/std/math/frexp.zig+16-16

...	@@ -115,11 +115,11 @@ fn frexp64(x: f64) frexp64_result {	...	@@ -115,11 +115,11 @@ fn frexp64(x: f64) frexp64_result {
115	test "math.frexp" {	115	test "math.frexp" {
116	const a = frexp(@as(f32, 1.3));	116	const a = frexp(@as(f32, 1.3));
117	const b = frexp32(1.3);	117	const b = frexp32(1.3);
118	expect(a.significand == b.significand and a.exponent == b.exponent);	118	try expect(a.significand == b.significand and a.exponent == b.exponent);
119		119
120	const c = frexp(@as(f64, 1.3));	120	const c = frexp(@as(f64, 1.3));
121	const d = frexp64(1.3);	121	const d = frexp64(1.3);
122	expect(c.significand == d.significand and c.exponent == d.exponent);	122	try expect(c.significand == d.significand and c.exponent == d.exponent);
123	}	123	}
124		124
125	test "math.frexp32" {	125	test "math.frexp32" {
...	@@ -127,10 +127,10 @@ test "math.frexp32" {	...	@@ -127,10 +127,10 @@ test "math.frexp32" {
127	var r: frexp32_result = undefined;	127	var r: frexp32_result = undefined;
128		128
129	r = frexp32(1.3);	129	r = frexp32(1.3);
130	expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1);	130	try expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1);
131		131
132	r = frexp32(78.0234);	132	r = frexp32(78.0234);
133	expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);	133	try expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7);
134	}	134	}
135		135
136	test "math.frexp64" {	136	test "math.frexp64" {
...	@@ -138,46 +138,46 @@ test "math.frexp64" {	...	@@ -138,46 +138,46 @@ test "math.frexp64" {
138	var r: frexp64_result = undefined;	138	var r: frexp64_result = undefined;
139		139
140	r = frexp64(1.3);	140	r = frexp64(1.3);
141	expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1);	141	try expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1);
142		142
143	r = frexp64(78.0234);	143	r = frexp64(78.0234);
144	expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);	144	try expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7);
145	}	145	}
146		146
147	test "math.frexp32.special" {	147	test "math.frexp32.special" {
148	var r: frexp32_result = undefined;	148	var r: frexp32_result = undefined;
149		149
150	r = frexp32(0.0);	150	r = frexp32(0.0);
151	expect(r.significand == 0.0 and r.exponent == 0);	151	try expect(r.significand == 0.0 and r.exponent == 0);
152		152
153	r = frexp32(-0.0);	153	r = frexp32(-0.0);
154	expect(r.significand == -0.0 and r.exponent == 0);	154	try expect(r.significand == -0.0 and r.exponent == 0);
155		155
156	r = frexp32(math.inf(f32));	156	r = frexp32(math.inf(f32));
157	expect(math.isPositiveInf(r.significand) and r.exponent == 0);	157	try expect(math.isPositiveInf(r.significand) and r.exponent == 0);
158		158
159	r = frexp32(-math.inf(f32));	159	r = frexp32(-math.inf(f32));
160	expect(math.isNegativeInf(r.significand) and r.exponent == 0);	160	try expect(math.isNegativeInf(r.significand) and r.exponent == 0);
161		161
162	r = frexp32(math.nan(f32));	162	r = frexp32(math.nan(f32));
163	expect(math.isNan(r.significand));	163	try expect(math.isNan(r.significand));
164	}	164	}
165		165
166	test "math.frexp64.special" {	166	test "math.frexp64.special" {
167	var r: frexp64_result = undefined;	167	var r: frexp64_result = undefined;
168		168
169	r = frexp64(0.0);	169	r = frexp64(0.0);
170	expect(r.significand == 0.0 and r.exponent == 0);	170	try expect(r.significand == 0.0 and r.exponent == 0);
171		171
172	r = frexp64(-0.0);	172	r = frexp64(-0.0);
173	expect(r.significand == -0.0 and r.exponent == 0);	173	try expect(r.significand == -0.0 and r.exponent == 0);
174		174
175	r = frexp64(math.inf(f64));	175	r = frexp64(math.inf(f64));
176	expect(math.isPositiveInf(r.significand) and r.exponent == 0);	176	try expect(math.isPositiveInf(r.significand) and r.exponent == 0);
177		177
178	r = frexp64(-math.inf(f64));	178	r = frexp64(-math.inf(f64));
179	expect(math.isNegativeInf(r.significand) and r.exponent == 0);	179	try expect(math.isNegativeInf(r.significand) and r.exponent == 0);
180		180
181	r = frexp64(math.nan(f64));	181	r = frexp64(math.nan(f64));
182	expect(math.isNan(r.significand));	182	try expect(math.isNan(r.significand));
183	}	183	}

lib/std/math/hypot.zig+28-28

lib/std/math/ilogb.zig+22-22

lib/std/math/isfinite.zig+24-24

lib/std/math/isinf.zig+48-48

lib/std/math/isnan.zig+8-8

...	@@ -21,12 +21,12 @@ pub fn isSignalNan(x: anytype) bool {	...	@@ -21,12 +21,12 @@ pub fn isSignalNan(x: anytype) bool {
21	}	21	}
22		22
23	test "math.isNan" {	23	test "math.isNan" {
24	expect(isNan(math.nan(f16)));	24	try expect(isNan(math.nan(f16)));
25	expect(isNan(math.nan(f32)));	25	try expect(isNan(math.nan(f32)));
26	expect(isNan(math.nan(f64)));	26	try expect(isNan(math.nan(f64)));
27	expect(isNan(math.nan(f128)));	27	try expect(isNan(math.nan(f128)));
28	expect(!isNan(@as(f16, 1.0)));	28	try expect(!isNan(@as(f16, 1.0)));
29	expect(!isNan(@as(f32, 1.0)));	29	try expect(!isNan(@as(f32, 1.0)));
30	expect(!isNan(@as(f64, 1.0)));	30	try expect(!isNan(@as(f64, 1.0)));
31	expect(!isNan(@as(f128, 1.0)));	31	try expect(!isNan(@as(f128, 1.0)));
32	}	32	}

lib/std/math/isnormal.zig+9-9

...	@@ -31,13 +31,13 @@ pub fn isNormal(x: anytype) bool {	...	@@ -31,13 +31,13 @@ pub fn isNormal(x: anytype) bool {
31	}	31	}
32		32
33	test "math.isNormal" {	33	test "math.isNormal" {
34	expect(!isNormal(math.nan(f16)));	34	try expect(!isNormal(math.nan(f16)));
35	expect(!isNormal(math.nan(f32)));	35	try expect(!isNormal(math.nan(f32)));
36	expect(!isNormal(math.nan(f64)));	36	try expect(!isNormal(math.nan(f64)));
37	expect(!isNormal(@as(f16, 0)));	37	try expect(!isNormal(@as(f16, 0)));
38	expect(!isNormal(@as(f32, 0)));	38	try expect(!isNormal(@as(f32, 0)));
39	expect(!isNormal(@as(f64, 0)));	39	try expect(!isNormal(@as(f64, 0)));
40	expect(isNormal(@as(f16, 1.0)));	40	try expect(isNormal(@as(f16, 1.0)));
41	expect(isNormal(@as(f32, 1.0)));	41	try expect(isNormal(@as(f32, 1.0)));
42	expect(isNormal(@as(f64, 1.0)));	42	try expect(isNormal(@as(f64, 1.0)));
43	}	43	}

lib/std/math/ln.zig+22-22

lib/std/math/log.zig+12-12

lib/std/math/log10.zig+22-22

lib/std/math/log1p.zig+28-28

lib/std/math/log2.zig+20-20

lib/std/math/modf.zig+28-28

lib/std/math/pow.zig+52-52

lib/std/math/powi.zig+75-75

lib/std/math/round.zig+30-30

...	@@ -130,52 +130,52 @@ fn round128(x_: f128) f128 {	...	@@ -130,52 +130,52 @@ fn round128(x_: f128) f128 {
130	}	130	}
131		131
132	test "math.round" {	132	test "math.round" {
133	expect(round(@as(f32, 1.3)) == round32(1.3));	133	try expect(round(@as(f32, 1.3)) == round32(1.3));
134	expect(round(@as(f64, 1.3)) == round64(1.3));	134	try expect(round(@as(f64, 1.3)) == round64(1.3));
135	expect(round(@as(f128, 1.3)) == round128(1.3));	135	try expect(round(@as(f128, 1.3)) == round128(1.3));
136	}	136	}
137		137
138	test "math.round32" {	138	test "math.round32" {
139	expect(round32(1.3) == 1.0);	139	try expect(round32(1.3) == 1.0);
140	expect(round32(-1.3) == -1.0);	140	try expect(round32(-1.3) == -1.0);
141	expect(round32(0.2) == 0.0);	141	try expect(round32(0.2) == 0.0);
142	expect(round32(1.8) == 2.0);	142	try expect(round32(1.8) == 2.0);
143	}	143	}
144		144
145	test "math.round64" {	145	test "math.round64" {
146	expect(round64(1.3) == 1.0);	146	try expect(round64(1.3) == 1.0);
147	expect(round64(-1.3) == -1.0);	147	try expect(round64(-1.3) == -1.0);
148	expect(round64(0.2) == 0.0);	148	try expect(round64(0.2) == 0.0);
149	expect(round64(1.8) == 2.0);	149	try expect(round64(1.8) == 2.0);
150	}	150	}
151		151
152	test "math.round128" {	152	test "math.round128" {
153	expect(round128(1.3) == 1.0);	153	try expect(round128(1.3) == 1.0);
154	expect(round128(-1.3) == -1.0);	154	try expect(round128(-1.3) == -1.0);
155	expect(round128(0.2) == 0.0);	155	try expect(round128(0.2) == 0.0);
156	expect(round128(1.8) == 2.0);	156	try expect(round128(1.8) == 2.0);
157	}	157	}
158		158
159	test "math.round32.special" {	159	test "math.round32.special" {
160	expect(round32(0.0) == 0.0);	160	try expect(round32(0.0) == 0.0);
161	expect(round32(-0.0) == -0.0);	161	try expect(round32(-0.0) == -0.0);
162	expect(math.isPositiveInf(round32(math.inf(f32))));	162	try expect(math.isPositiveInf(round32(math.inf(f32))));
163	expect(math.isNegativeInf(round32(-math.inf(f32))));	163	try expect(math.isNegativeInf(round32(-math.inf(f32))));
164	expect(math.isNan(round32(math.nan(f32))));	164	try expect(math.isNan(round32(math.nan(f32))));
165	}	165	}
166		166
167	test "math.round64.special" {	167	test "math.round64.special" {
168	expect(round64(0.0) == 0.0);	168	try expect(round64(0.0) == 0.0);
169	expect(round64(-0.0) == -0.0);	169	try expect(round64(-0.0) == -0.0);
170	expect(math.isPositiveInf(round64(math.inf(f64))));	170	try expect(math.isPositiveInf(round64(math.inf(f64))));
171	expect(math.isNegativeInf(round64(-math.inf(f64))));	171	try expect(math.isNegativeInf(round64(-math.inf(f64))));
172	expect(math.isNan(round64(math.nan(f64))));	172	try expect(math.isNan(round64(math.nan(f64))));
173	}	173	}
174		174
175	test "math.round128.special" {	175	test "math.round128.special" {
176	expect(round128(0.0) == 0.0);	176	try expect(round128(0.0) == 0.0);
177	expect(round128(-0.0) == -0.0);	177	try expect(round128(-0.0) == -0.0);
178	expect(math.isPositiveInf(round128(math.inf(f128))));	178	try expect(math.isPositiveInf(round128(math.inf(f128))));
179	expect(math.isNegativeInf(round128(-math.inf(f128))));	179	try expect(math.isNegativeInf(round128(-math.inf(f128))));
180	expect(math.isNan(round128(math.nan(f128))));	180	try expect(math.isNan(round128(math.nan(f128))));
181	}	181	}

lib/std/math/scalbn.zig+4-4

...	@@ -84,14 +84,14 @@ fn scalbn64(x: f64, n_: i32) f64 {	...	@@ -84,14 +84,14 @@ fn scalbn64(x: f64, n_: i32) f64 {
84	}	84	}
85		85
86	test "math.scalbn" {	86	test "math.scalbn" {
87	expect(scalbn(@as(f32, 1.5), 4) == scalbn32(1.5, 4));	87	try expect(scalbn(@as(f32, 1.5), 4) == scalbn32(1.5, 4));
88	expect(scalbn(@as(f64, 1.5), 4) == scalbn64(1.5, 4));	88	try expect(scalbn(@as(f64, 1.5), 4) == scalbn64(1.5, 4));
89	}	89	}
90		90
91	test "math.scalbn32" {	91	test "math.scalbn32" {
92	expect(scalbn32(1.5, 4) == 24.0);	92	try expect(scalbn32(1.5, 4) == 24.0);
93	}	93	}
94		94
95	test "math.scalbn64" {	95	test "math.scalbn64" {
96	expect(scalbn64(1.5, 4) == 24.0);	96	try expect(scalbn64(1.5, 4) == 24.0);
97	}	97	}

lib/std/math/signbit.zig+12-12

...	@@ -40,28 +40,28 @@ fn signbit128(x: f128) bool {	...	@@ -40,28 +40,28 @@ fn signbit128(x: f128) bool {
40	}	40	}
41		41
42	test "math.signbit" {	42	test "math.signbit" {
43	expect(signbit(@as(f16, 4.0)) == signbit16(4.0));	43	try expect(signbit(@as(f16, 4.0)) == signbit16(4.0));
44	expect(signbit(@as(f32, 4.0)) == signbit32(4.0));	44	try expect(signbit(@as(f32, 4.0)) == signbit32(4.0));
45	expect(signbit(@as(f64, 4.0)) == signbit64(4.0));	45	try expect(signbit(@as(f64, 4.0)) == signbit64(4.0));
46	expect(signbit(@as(f128, 4.0)) == signbit128(4.0));	46	try expect(signbit(@as(f128, 4.0)) == signbit128(4.0));
47	}	47	}
48		48
49	test "math.signbit16" {	49	test "math.signbit16" {
50	expect(!signbit16(4.0));	50	try expect(!signbit16(4.0));
51	expect(signbit16(-3.0));	51	try expect(signbit16(-3.0));
52	}	52	}
53		53
54	test "math.signbit32" {	54	test "math.signbit32" {
55	expect(!signbit32(4.0));	55	try expect(!signbit32(4.0));
56	expect(signbit32(-3.0));	56	try expect(signbit32(-3.0));
57	}	57	}
58		58
59	test "math.signbit64" {	59	test "math.signbit64" {
60	expect(!signbit64(4.0));	60	try expect(!signbit64(4.0));
61	expect(signbit64(-3.0));	61	try expect(signbit64(-3.0));
62	}	62	}
63		63
64	test "math.signbit128" {	64	test "math.signbit128" {
65	expect(!signbit128(4.0));	65	try expect(!signbit128(4.0));
66	expect(signbit128(-3.0));	66	try expect(signbit128(-3.0));
67	}	67	}

lib/std/math/sin.zig+27-27

lib/std/math/sinh.zig+28-28

lib/std/math/sqrt.zig+8-8

...	@@ -69,14 +69,14 @@ fn sqrt_int(comptime T: type, value: T) Sqrt(T) {	...	@@ -69,14 +69,14 @@ fn sqrt_int(comptime T: type, value: T) Sqrt(T) {
69	}	69	}
70		70
71	test "math.sqrt_int" {	71	test "math.sqrt_int" {
72	expect(sqrt_int(u0, 0) == 0);	72	try expect(sqrt_int(u0, 0) == 0);
73	expect(sqrt_int(u1, 1) == 1);	73	try expect(sqrt_int(u1, 1) == 1);
74	expect(sqrt_int(u32, 3) == 1);	74	try expect(sqrt_int(u32, 3) == 1);
75	expect(sqrt_int(u32, 4) == 2);	75	try expect(sqrt_int(u32, 4) == 2);
76	expect(sqrt_int(u32, 5) == 2);	76	try expect(sqrt_int(u32, 5) == 2);
77	expect(sqrt_int(u32, 8) == 2);	77	try expect(sqrt_int(u32, 8) == 2);
78	expect(sqrt_int(u32, 9) == 3);	78	try expect(sqrt_int(u32, 9) == 3);
79	expect(sqrt_int(u32, 10) == 3);	79	try expect(sqrt_int(u32, 10) == 3);
80	}	80	}
81		81
82	/// Returns the return type `sqrt` will return given an operand of type `T`.	82	/// Returns the return type `sqrt` will return given an operand of type `T`.

lib/std/math/tan.zig+24-24

lib/std/math/tanh.zig+22-22

lib/std/math/trunc.zig+27-27

lib/std/mem.zig+359-359

lib/std/meta.zig+190-190

lib/std/meta/trailer_flags.zig+7-7

lib/std/meta/trait.zig+142-142

lib/std/multi_array_list.zig+57-57

lib/std/net/test.zig+24-24

lib/std/once.zig+1-1

...	@@ -67,5 +67,5 @@ test "Once executes its function just once" {	...	@@ -67,5 +67,5 @@ test "Once executes its function just once" {
67	}	67	}
68	}	68	}
69		69
70	testing.expectEqual(@as(i32, 1), global_number);	70	try testing.expectEqual(@as(i32, 1), global_number);
71	}	71	}

lib/std/os/linux/bpf.zig+100-100

lib/std/os/linux/bpf/btf.zig+1-1

...	@@ -92,7 +92,7 @@ pub const IntInfo = packed struct {	...	@@ -92,7 +92,7 @@ pub const IntInfo = packed struct {
92	};	92	};
93		93
94	test "IntInfo is 32 bits" {	94	test "IntInfo is 32 bits" {
95	std.testing.expectEqual(@bitSizeOf(IntInfo), 32);	95	try std.testing.expectEqual(@bitSizeOf(IntInfo), 32);
96	}	96	}
97		97
98	/// Enum kind is followed by this struct	98	/// Enum kind is followed by this struct

lib/std/os/linux/io_uring.zig+104-104

lib/std/os/linux/test.zig+17-17

lib/std/os/test.zig+51-51

lib/std/os/windows.zig+3-3

...	@@ -997,7 +997,7 @@ test "QueryObjectName" {	...	@@ -997,7 +997,7 @@ test "QueryObjectName" {
997	var result_path = try QueryObjectName(handle, &out_buffer);	997	var result_path = try QueryObjectName(handle, &out_buffer);
998	const required_len_in_u16 = result_path.len + @divExact(@ptrToInt(result_path.ptr) - @ptrToInt(&out_buffer), 2) + 1;	998	const required_len_in_u16 = result_path.len + @divExact(@ptrToInt(result_path.ptr) - @ptrToInt(&out_buffer), 2) + 1;
999	//insufficient size	999	//insufficient size
1000	std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1]));	1000	try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1]));
1001	//exactly-sufficient size	1001	//exactly-sufficient size
1002	_ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]);	1002	_ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]);
1003	}	1003	}
...	@@ -1155,8 +1155,8 @@ test "GetFinalPathNameByHandle" {	...	@@ -1155,8 +1155,8 @@ test "GetFinalPathNameByHandle" {
1155		1155
1156	const required_len_in_u16 = nt_path.len + @divExact(@ptrToInt(nt_path.ptr) - @ptrToInt(&buffer), 2) + 1;	1156	const required_len_in_u16 = nt_path.len + @divExact(@ptrToInt(nt_path.ptr) - @ptrToInt(&buffer), 2) + 1;
1157	//check with insufficient size	1157	//check with insufficient size
1158	std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1]));	1158	try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1]));
1159	std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1]));	1159	try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1]));
1160		1160
1161	//check with exactly-sufficient size	1161	//check with exactly-sufficient size
1162	_ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]);	1162	_ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]);

lib/std/packed_int_array.zig+49-49

lib/std/priority_dequeue.zig+89-89

lib/std/priority_queue.zig+70-70

lib/std/process.zig+16-16

lib/std/rand.zig+96-96

...	@@ -319,139 +319,139 @@ const SequentialPrng = struct {	...	@@ -319,139 +319,139 @@ const SequentialPrng = struct {
319	};	319	};
320		320
321	test "Random int" {	321	test "Random int" {
322	testRandomInt();	322	try testRandomInt();
323	comptime testRandomInt();	323	comptime try testRandomInt();
324	}	324	}
325	fn testRandomInt() void {	325	fn testRandomInt() !void {
326	var r = SequentialPrng.init();	326	var r = SequentialPrng.init();
327		327
328	expect(r.random.int(u0) == 0);	328	try expect(r.random.int(u0) == 0);
329		329
330	r.next_value = 0;	330	r.next_value = 0;
331	expect(r.random.int(u1) == 0);	331	try expect(r.random.int(u1) == 0);
332	expect(r.random.int(u1) == 1);	332	try expect(r.random.int(u1) == 1);
333	expect(r.random.int(u2) == 2);	333	try expect(r.random.int(u2) == 2);
334	expect(r.random.int(u2) == 3);	334	try expect(r.random.int(u2) == 3);
335	expect(r.random.int(u2) == 0);	335	try expect(r.random.int(u2) == 0);
336		336
337	r.next_value = 0xff;	337	r.next_value = 0xff;
338	expect(r.random.int(u8) == 0xff);	338	try expect(r.random.int(u8) == 0xff);
339	r.next_value = 0x11;	339	r.next_value = 0x11;
340	expect(r.random.int(u8) == 0x11);	340	try expect(r.random.int(u8) == 0x11);
341		341
342	r.next_value = 0xff;	342	r.next_value = 0xff;
343	expect(r.random.int(u32) == 0xffffffff);	343	try expect(r.random.int(u32) == 0xffffffff);
344	r.next_value = 0x11;	344	r.next_value = 0x11;
345	expect(r.random.int(u32) == 0x11111111);	345	try expect(r.random.int(u32) == 0x11111111);
346		346
347	r.next_value = 0xff;	347	r.next_value = 0xff;
348	expect(r.random.int(i32) == -1);	348	try expect(r.random.int(i32) == -1);
349	r.next_value = 0x11;	349	r.next_value = 0x11;
350	expect(r.random.int(i32) == 0x11111111);	350	try expect(r.random.int(i32) == 0x11111111);
351		351
352	r.next_value = 0xff;	352	r.next_value = 0xff;
353	expect(r.random.int(i8) == -1);	353	try expect(r.random.int(i8) == -1);
354	r.next_value = 0x11;	354	r.next_value = 0x11;
355	expect(r.random.int(i8) == 0x11);	355	try expect(r.random.int(i8) == 0x11);
356		356
357	r.next_value = 0xff;	357	r.next_value = 0xff;
358	expect(r.random.int(u33) == 0x1ffffffff);	358	try expect(r.random.int(u33) == 0x1ffffffff);
359	r.next_value = 0xff;	359	r.next_value = 0xff;
360	expect(r.random.int(i1) == -1);	360	try expect(r.random.int(i1) == -1);
361	r.next_value = 0xff;	361	r.next_value = 0xff;
362	expect(r.random.int(i2) == -1);	362	try expect(r.random.int(i2) == -1);
363	r.next_value = 0xff;	363	r.next_value = 0xff;
364	expect(r.random.int(i33) == -1);	364	try expect(r.random.int(i33) == -1);
365	}	365	}
366		366
367	test "Random boolean" {	367	test "Random boolean" {
368	testRandomBoolean();	368	try testRandomBoolean();
369	comptime testRandomBoolean();	369	comptime try testRandomBoolean();
370	}	370	}
371	fn testRandomBoolean() void {	371	fn testRandomBoolean() !void {
372	var r = SequentialPrng.init();	372	var r = SequentialPrng.init();
373	expect(r.random.boolean() == false);	373	try expect(r.random.boolean() == false);
374	expect(r.random.boolean() == true);	374	try expect(r.random.boolean() == true);
375	expect(r.random.boolean() == false);	375	try expect(r.random.boolean() == false);
376	expect(r.random.boolean() == true);	376	try expect(r.random.boolean() == true);
377	}	377	}
378		378
379	test "Random intLessThan" {	379	test "Random intLessThan" {
380	@setEvalBranchQuota(10000);	380	@setEvalBranchQuota(10000);
381	testRandomIntLessThan();	381	try testRandomIntLessThan();
382	comptime testRandomIntLessThan();	382	comptime try testRandomIntLessThan();
383	}	383	}
384	fn testRandomIntLessThan() void {	384	fn testRandomIntLessThan() !void {
385	var r = SequentialPrng.init();	385	var r = SequentialPrng.init();
386	r.next_value = 0xff;	386	r.next_value = 0xff;
387	expect(r.random.uintLessThan(u8, 4) == 3);	387	try expect(r.random.uintLessThan(u8, 4) == 3);
388	expect(r.next_value == 0);	388	try expect(r.next_value == 0);
389	expect(r.random.uintLessThan(u8, 4) == 0);	389	try expect(r.random.uintLessThan(u8, 4) == 0);
390	expect(r.next_value == 1);	390	try expect(r.next_value == 1);
391		391
392	r.next_value = 0;	392	r.next_value = 0;
393	expect(r.random.uintLessThan(u64, 32) == 0);	393	try expect(r.random.uintLessThan(u64, 32) == 0);
394		394
395	// trigger the bias rejection code path	395	// trigger the bias rejection code path
396	r.next_value = 0;	396	r.next_value = 0;
397	expect(r.random.uintLessThan(u8, 3) == 0);	397	try expect(r.random.uintLessThan(u8, 3) == 0);
398	// verify we incremented twice	398	// verify we incremented twice
399	expect(r.next_value == 2);	399	try expect(r.next_value == 2);
400		400
401	r.next_value = 0xff;	401	r.next_value = 0xff;
402	expect(r.random.intRangeLessThan(u8, 0, 0x80) == 0x7f);	402	try expect(r.random.intRangeLessThan(u8, 0, 0x80) == 0x7f);
403	r.next_value = 0xff;	403	r.next_value = 0xff;
404	expect(r.random.intRangeLessThan(u8, 0x7f, 0xff) == 0xfe);	404	try expect(r.random.intRangeLessThan(u8, 0x7f, 0xff) == 0xfe);
405		405
406	r.next_value = 0xff;	406	r.next_value = 0xff;
407	expect(r.random.intRangeLessThan(i8, 0, 0x40) == 0x3f);	407	try expect(r.random.intRangeLessThan(i8, 0, 0x40) == 0x3f);
408	r.next_value = 0xff;	408	r.next_value = 0xff;
409	expect(r.random.intRangeLessThan(i8, -0x40, 0x40) == 0x3f);	409	try expect(r.random.intRangeLessThan(i8, -0x40, 0x40) == 0x3f);
410	r.next_value = 0xff;	410	r.next_value = 0xff;
411	expect(r.random.intRangeLessThan(i8, -0x80, 0) == -1);	411	try expect(r.random.intRangeLessThan(i8, -0x80, 0) == -1);
412		412
413	r.next_value = 0xff;	413	r.next_value = 0xff;
414	expect(r.random.intRangeLessThan(i3, -4, 0) == -1);	414	try expect(r.random.intRangeLessThan(i3, -4, 0) == -1);
415	r.next_value = 0xff;	415	r.next_value = 0xff;
416	expect(r.random.intRangeLessThan(i3, -2, 2) == 1);	416	try expect(r.random.intRangeLessThan(i3, -2, 2) == 1);
417	}	417	}
418		418
419	test "Random intAtMost" {	419	test "Random intAtMost" {
420	@setEvalBranchQuota(10000);	420	@setEvalBranchQuota(10000);
421	testRandomIntAtMost();	421	try testRandomIntAtMost();
422	comptime testRandomIntAtMost();	422	comptime try testRandomIntAtMost();
423	}	423	}
424	fn testRandomIntAtMost() void {	424	fn testRandomIntAtMost() !void {
425	var r = SequentialPrng.init();	425	var r = SequentialPrng.init();
426	r.next_value = 0xff;	426	r.next_value = 0xff;
427	expect(r.random.uintAtMost(u8, 3) == 3);	427	try expect(r.random.uintAtMost(u8, 3) == 3);
428	expect(r.next_value == 0);	428	try expect(r.next_value == 0);
429	expect(r.random.uintAtMost(u8, 3) == 0);	429	try expect(r.random.uintAtMost(u8, 3) == 0);
430		430
431	// trigger the bias rejection code path	431	// trigger the bias rejection code path
432	r.next_value = 0;	432	r.next_value = 0;
433	expect(r.random.uintAtMost(u8, 2) == 0);	433	try expect(r.random.uintAtMost(u8, 2) == 0);
434	// verify we incremented twice	434	// verify we incremented twice
435	expect(r.next_value == 2);	435	try expect(r.next_value == 2);
436		436
437	r.next_value = 0xff;	437	r.next_value = 0xff;
438	expect(r.random.intRangeAtMost(u8, 0, 0x7f) == 0x7f);	438	try expect(r.random.intRangeAtMost(u8, 0, 0x7f) == 0x7f);
439	r.next_value = 0xff;	439	r.next_value = 0xff;
440	expect(r.random.intRangeAtMost(u8, 0x7f, 0xfe) == 0xfe);	440	try expect(r.random.intRangeAtMost(u8, 0x7f, 0xfe) == 0xfe);
441		441
442	r.next_value = 0xff;	442	r.next_value = 0xff;
443	expect(r.random.intRangeAtMost(i8, 0, 0x3f) == 0x3f);	443	try expect(r.random.intRangeAtMost(i8, 0, 0x3f) == 0x3f);
444	r.next_value = 0xff;	444	r.next_value = 0xff;
445	expect(r.random.intRangeAtMost(i8, -0x40, 0x3f) == 0x3f);	445	try expect(r.random.intRangeAtMost(i8, -0x40, 0x3f) == 0x3f);
446	r.next_value = 0xff;	446	r.next_value = 0xff;
447	expect(r.random.intRangeAtMost(i8, -0x80, -1) == -1);	447	try expect(r.random.intRangeAtMost(i8, -0x80, -1) == -1);
448		448
449	r.next_value = 0xff;	449	r.next_value = 0xff;
450	expect(r.random.intRangeAtMost(i3, -4, -1) == -1);	450	try expect(r.random.intRangeAtMost(i3, -4, -1) == -1);
451	r.next_value = 0xff;	451	r.next_value = 0xff;
452	expect(r.random.intRangeAtMost(i3, -2, 1) == 1);	452	try expect(r.random.intRangeAtMost(i3, -2, 1) == 1);
453		453
454	expect(r.random.uintAtMost(u0, 0) == 0);	454	try expect(r.random.uintAtMost(u0, 0) == 0);
455	}	455	}
456		456
457	test "Random Biased" {	457	test "Random Biased" {
...	@@ -459,30 +459,30 @@ test "Random Biased" {	...	@@ -459,30 +459,30 @@ test "Random Biased" {
459	// Not thoroughly checking the logic here.	459	// Not thoroughly checking the logic here.
460	// Just want to execute all the paths with different types.	460	// Just want to execute all the paths with different types.
461		461
462	expect(r.random.uintLessThanBiased(u1, 1) == 0);	462	try expect(r.random.uintLessThanBiased(u1, 1) == 0);
463	expect(r.random.uintLessThanBiased(u32, 10) < 10);	463	try expect(r.random.uintLessThanBiased(u32, 10) < 10);
464	expect(r.random.uintLessThanBiased(u64, 20) < 20);	464	try expect(r.random.uintLessThanBiased(u64, 20) < 20);
465		465
466	expect(r.random.uintAtMostBiased(u0, 0) == 0);	466	try expect(r.random.uintAtMostBiased(u0, 0) == 0);
467	expect(r.random.uintAtMostBiased(u1, 0) <= 0);	467	try expect(r.random.uintAtMostBiased(u1, 0) <= 0);
468	expect(r.random.uintAtMostBiased(u32, 10) <= 10);	468	try expect(r.random.uintAtMostBiased(u32, 10) <= 10);
469	expect(r.random.uintAtMostBiased(u64, 20) <= 20);	469	try expect(r.random.uintAtMostBiased(u64, 20) <= 20);
470		470
471	expect(r.random.intRangeLessThanBiased(u1, 0, 1) == 0);	471	try expect(r.random.intRangeLessThanBiased(u1, 0, 1) == 0);
472	expect(r.random.intRangeLessThanBiased(i1, -1, 0) == -1);	472	try expect(r.random.intRangeLessThanBiased(i1, -1, 0) == -1);
473	expect(r.random.intRangeLessThanBiased(u32, 10, 20) >= 10);	473	try expect(r.random.intRangeLessThanBiased(u32, 10, 20) >= 10);
474	expect(r.random.intRangeLessThanBiased(i32, 10, 20) >= 10);	474	try expect(r.random.intRangeLessThanBiased(i32, 10, 20) >= 10);
475	expect(r.random.intRangeLessThanBiased(u64, 20, 40) >= 20);	475	try expect(r.random.intRangeLessThanBiased(u64, 20, 40) >= 20);
476	expect(r.random.intRangeLessThanBiased(i64, 20, 40) >= 20);	476	try expect(r.random.intRangeLessThanBiased(i64, 20, 40) >= 20);
477		477
478	// uncomment for broken module error:	478	// uncomment for broken module error:
479	//expect(r.random.intRangeAtMostBiased(u0, 0, 0) == 0);	479	//expect(r.random.intRangeAtMostBiased(u0, 0, 0) == 0);
480	expect(r.random.intRangeAtMostBiased(u1, 0, 1) >= 0);	480	try expect(r.random.intRangeAtMostBiased(u1, 0, 1) >= 0);
481	expect(r.random.intRangeAtMostBiased(i1, -1, 0) >= -1);	481	try expect(r.random.intRangeAtMostBiased(i1, -1, 0) >= -1);
482	expect(r.random.intRangeAtMostBiased(u32, 10, 20) >= 10);	482	try expect(r.random.intRangeAtMostBiased(u32, 10, 20) >= 10);
483	expect(r.random.intRangeAtMostBiased(i32, 10, 20) >= 10);	483	try expect(r.random.intRangeAtMostBiased(i32, 10, 20) >= 10);
484	expect(r.random.intRangeAtMostBiased(u64, 20, 40) >= 20);	484	try expect(r.random.intRangeAtMostBiased(u64, 20, 40) >= 20);
485	expect(r.random.intRangeAtMostBiased(i64, 20, 40) >= 20);	485	try expect(r.random.intRangeAtMostBiased(i64, 20, 40) >= 20);
486	}	486	}
487		487
488	// Generator to extend 64-bit seed values into longer sequences.	488	// Generator to extend 64-bit seed values into longer sequences.
...	@@ -519,7 +519,7 @@ test "splitmix64 sequence" {	...	@@ -519,7 +519,7 @@ test "splitmix64 sequence" {
519	};	519	};
520		520
521	for (seq) \|s\| {	521	for (seq) \|s\| {
522	expect(s == r.next());	522	try expect(s == r.next());
523	}	523	}
524	}	524	}
525		525
...	@@ -530,12 +530,12 @@ test "Random float" {	...	@@ -530,12 +530,12 @@ test "Random float" {
530	var i: usize = 0;	530	var i: usize = 0;
531	while (i < 1000) : (i += 1) {	531	while (i < 1000) : (i += 1) {
532	const val1 = prng.random.float(f32);	532	const val1 = prng.random.float(f32);
533	expect(val1 >= 0.0);	533	try expect(val1 >= 0.0);
534	expect(val1 < 1.0);	534	try expect(val1 < 1.0);
535		535
536	const val2 = prng.random.float(f64);	536	const val2 = prng.random.float(f64);
537	expect(val2 >= 0.0);	537	try expect(val2 >= 0.0);
538	expect(val2 < 1.0);	538	try expect(val2 < 1.0);
539	}	539	}
540	}	540	}
541		541
...	@@ -549,12 +549,12 @@ test "Random shuffle" {	...	@@ -549,12 +549,12 @@ test "Random shuffle" {
549	while (i < 1000) : (i += 1) {	549	while (i < 1000) : (i += 1) {
550	prng.random.shuffle(u8, seq[0..]);	550	prng.random.shuffle(u8, seq[0..]);
551	seen[seq[0]] = true;	551	seen[seq[0]] = true;
552	expect(sumArray(seq[0..]) == 10);	552	try expect(sumArray(seq[0..]) == 10);
553	}	553	}
554		554
555	// we should see every entry at the head at least once	555	// we should see every entry at the head at least once
556	for (seen) \|e\| {	556	for (seen) \|e\| {
557	expect(e == true);	557	try expect(e == true);
558	}	558	}
559	}	559	}
560		560
...	@@ -567,17 +567,17 @@ fn sumArray(s: []const u8) u32 {	...	@@ -567,17 +567,17 @@ fn sumArray(s: []const u8) u32 {
567		567
568	test "Random range" {	568	test "Random range" {
569	var prng = DefaultPrng.init(0);	569	var prng = DefaultPrng.init(0);
570	testRange(&prng.random, -4, 3);	570	try testRange(&prng.random, -4, 3);
571	testRange(&prng.random, -4, -1);	571	try testRange(&prng.random, -4, -1);
572	testRange(&prng.random, 10, 14);	572	try testRange(&prng.random, 10, 14);
573	testRange(&prng.random, -0x80, 0x7f);	573	try testRange(&prng.random, -0x80, 0x7f);
574	}	574	}
575		575
576	fn testRange(r: *Random, start: i8, end: i8) void {	576	fn testRange(r: *Random, start: i8, end: i8) !void {
577	testRangeBias(r, start, end, true);	577	try testRangeBias(r, start, end, true);
578	testRangeBias(r, start, end, false);	578	try testRangeBias(r, start, end, false);
579	}	579	}
580	fn testRangeBias(r: *Random, start: i8, end: i8, biased: bool) void {	580	fn testRangeBias(r: *Random, start: i8, end: i8, biased: bool) !void {
581	const count = @intCast(usize, @as(i32, end) - @as(i32, start));	581	const count = @intCast(usize, @as(i32, end) - @as(i32, start));
582	var values_buffer = [_]bool{false} ** 0x100;	582	var values_buffer = [_]bool{false} ** 0x100;
583	const values = values_buffer[0..count];	583	const values = values_buffer[0..count];
...	@@ -599,7 +599,7 @@ test "CSPRNG" {	...	@@ -599,7 +599,7 @@ test "CSPRNG" {
599	const a = csprng.random.int(u64);	599	const a = csprng.random.int(u64);
600	const b = csprng.random.int(u64);	600	const b = csprng.random.int(u64);
601	const c = csprng.random.int(u64);	601	const c = csprng.random.int(u64);
602	expect(a ^ b ^ c != 0);	602	try expect(a ^ b ^ c != 0);
603	}	603	}
604		604
605	test {	605	test {

lib/std/rand/Isaac64.zig+2-2

...	@@ -205,7 +205,7 @@ test "isaac64 sequence" {	...	@@ -205,7 +205,7 @@ test "isaac64 sequence" {
205	};	205	};
206		206
207	for (seq) \|s\| {	207	for (seq) \|s\| {
208	std.testing.expect(s == r.next());	208	try std.testing.expect(s == r.next());
209	}	209	}
210	}	210	}
211		211
...	@@ -237,6 +237,6 @@ test "isaac64 fill" {	...	@@ -237,6 +237,6 @@ test "isaac64 fill" {
237	var buf1: [7]u8 = undefined;	237	var buf1: [7]u8 = undefined;
238	std.mem.writeIntLittle(u64, &buf0, s);	238	std.mem.writeIntLittle(u64, &buf0, s);
239	Isaac64.fill(&r.random, &buf1);	239	Isaac64.fill(&r.random, &buf1);
240	std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));	240	try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
241	}	241	}
242	}	242	}

lib/std/rand/Pcg.zig+2-2

...	@@ -96,7 +96,7 @@ test "pcg sequence" {	...	@@ -96,7 +96,7 @@ test "pcg sequence" {
96	};	96	};
97		97
98	for (seq) \|s\| {	98	for (seq) \|s\| {
99	std.testing.expect(s == r.next());	99	try std.testing.expect(s == r.next());
100	}	100	}
101	}	101	}
102		102
...	@@ -120,6 +120,6 @@ test "pcg fill" {	...	@@ -120,6 +120,6 @@ test "pcg fill" {
120	var buf1: [3]u8 = undefined;	120	var buf1: [3]u8 = undefined;
121	std.mem.writeIntLittle(u32, &buf0, s);	121	std.mem.writeIntLittle(u32, &buf0, s);
122	Pcg.fill(&r.random, &buf1);	122	Pcg.fill(&r.random, &buf1);
123	std.testing.expect(std.mem.eql(u8, buf0[0..3], buf1[0..]));	123	try std.testing.expect(std.mem.eql(u8, buf0[0..3], buf1[0..]));
124	}	124	}
125	}	125	}

lib/std/rand/Sfc64.zig+2-2

...	@@ -103,7 +103,7 @@ test "Sfc64 sequence" {	...	@@ -103,7 +103,7 @@ test "Sfc64 sequence" {
103	};	103	};
104		104
105	for (seq) \|s\| {	105	for (seq) \|s\| {
106	std.testing.expectEqual(s, r.next());	106	try std.testing.expectEqual(s, r.next());
107	}	107	}
108	}	108	}
109		109
...	@@ -135,6 +135,6 @@ test "Sfc64 fill" {	...	@@ -135,6 +135,6 @@ test "Sfc64 fill" {
135	var buf1: [7]u8 = undefined;	135	var buf1: [7]u8 = undefined;
136	std.mem.writeIntLittle(u64, &buf0, s);	136	std.mem.writeIntLittle(u64, &buf0, s);
137	Sfc64.fill(&r.random, &buf1);	137	Sfc64.fill(&r.random, &buf1);
138	std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));	138	try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
139	}	139	}
140	}	140	}

lib/std/rand/Xoroshiro128.zig+3-3

...	@@ -113,7 +113,7 @@ test "xoroshiro sequence" {	...	@@ -113,7 +113,7 @@ test "xoroshiro sequence" {
113	};	113	};
114		114
115	for (seq1) \|s\| {	115	for (seq1) \|s\| {
116	std.testing.expect(s == r.next());	116	try std.testing.expect(s == r.next());
117	}	117	}
118		118
119	r.jump();	119	r.jump();
...	@@ -128,7 +128,7 @@ test "xoroshiro sequence" {	...	@@ -128,7 +128,7 @@ test "xoroshiro sequence" {
128	};	128	};
129		129
130	for (seq2) \|s\| {	130	for (seq2) \|s\| {
131	std.testing.expect(s == r.next());	131	try std.testing.expect(s == r.next());
132	}	132	}
133	}	133	}
134		134
...	@@ -151,6 +151,6 @@ test "xoroshiro fill" {	...	@@ -151,6 +151,6 @@ test "xoroshiro fill" {
151	var buf1: [7]u8 = undefined;	151	var buf1: [7]u8 = undefined;
152	std.mem.writeIntLittle(u64, &buf0, s);	152	std.mem.writeIntLittle(u64, &buf0, s);
153	Xoroshiro128.fill(&r.random, &buf1);	153	Xoroshiro128.fill(&r.random, &buf1);
154	std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));	154	try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
155	}	155	}
156	}	156	}

lib/std/sort.zig+65-65

lib/std/special/c.zig+47-47

lib/std/special/compiler_rt/addXf3_test.zig+13-13

...	@@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);	...	@@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
13		13
14	const __addtf3 = @import("addXf3.zig").__addtf3;	14	const __addtf3 = @import("addXf3.zig").__addtf3;
15		15
16	fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {	16	fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
17	const x = __addtf3(a, b);	17	const x = __addtf3(a, b);
18		18
19	const rep = @bitCast(u128, x);	19	const rep = @bitCast(u128, x);
...	@@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {	...	@@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
32	}	32	}
33	}	33	}
34		34
35	@panic("__addtf3 test failure");	35	return error.TestFailed;
36	}	36	}
37		37
38	test "addtf3" {	38	test "addtf3" {
39	test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	39	try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
40		40
41	// NaN + any = NaN	41	// NaN + any = NaN
42	test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	42	try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
43		43
44	// inf + inf = inf	44	// inf + inf = inf
45	test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);	45	try test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
46		46
47	// inf + any = inf	47	// inf + any = inf
48	test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);	48	try test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
49		49
50	// any + any	50	// any + any
51	test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);	51	try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
52	}	52	}
53		53
54	const __subtf3 = @import("addXf3.zig").__subtf3;	54	const __subtf3 = @import("addXf3.zig").__subtf3;
55		55
56	fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {	56	fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
57	const x = __subtf3(a, b);	57	const x = __subtf3(a, b);
58		58
59	const rep = @bitCast(u128, x);	59	const rep = @bitCast(u128, x);
...	@@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {	...	@@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
72	}	72	}
73	}	73	}
74		74
75	@panic("__subtf3 test failure");	75	return error.TestFailed;
76	}	76	}
77		77
78	test "subtf3" {	78	test "subtf3" {
79	// qNaN - any = qNaN	79	// qNaN - any = qNaN
80	test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	80	try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
81		81
82	// NaN + any = NaN	82	// NaN + any = NaN
83	test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	83	try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
84		84
85	// inf - any = inf	85	// inf - any = inf
86	test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);	86	try test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
87		87
88	// any + any	88	// any + any
89	test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);	89	try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
90	}	90	}

lib/std/special/compiler_rt/ashldi3_test.zig+20-20

lib/std/special/compiler_rt/ashlti3_test.zig+38-38

lib/std/special/compiler_rt/ashrdi3_test.zig+47-47

lib/std/special/compiler_rt/ashrti3_test.zig+48-48

lib/std/special/compiler_rt/clzsi2_test.zig+281-281

...	@@ -6,294 +6,294 @@	...	@@ -6,294 +6,294 @@
6	const clzsi2 = @import("clzsi2.zig");	6	const clzsi2 = @import("clzsi2.zig");
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__clzsi2(a: u32, expected: i32) void {	9	fn test__clzsi2(a: u32, expected: i32) !void {
10	// XXX At high optimization levels this test may be horribly miscompiled if	10	// XXX At high optimization levels this test may be horribly miscompiled if
11	// one of the naked implementations is selected.	11	// one of the naked implementations is selected.
12	var nakedClzsi2 = clzsi2.__clzsi2;	12	var nakedClzsi2 = clzsi2.__clzsi2;
13	var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2);	13	var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2);
14	var x = @bitCast(i32, a);	14	var x = @bitCast(i32, a);
15	var result = actualClzsi2(x);	15	var result = actualClzsi2(x);
16	testing.expectEqual(expected, result);	16	try testing.expectEqual(expected, result);
17	}	17	}
18		18
19	test "clzsi2" {	19	test "clzsi2" {
20	test__clzsi2(0x00800000, 8);	20	try test__clzsi2(0x00800000, 8);
21	test__clzsi2(0x01000000, 7);	21	try test__clzsi2(0x01000000, 7);
22	test__clzsi2(0x02000000, 6);	22	try test__clzsi2(0x02000000, 6);
23	test__clzsi2(0x03000000, 6);	23	try test__clzsi2(0x03000000, 6);
24	test__clzsi2(0x04000000, 5);	24	try test__clzsi2(0x04000000, 5);
25	test__clzsi2(0x05000000, 5);	25	try test__clzsi2(0x05000000, 5);
26	test__clzsi2(0x06000000, 5);	26	try test__clzsi2(0x06000000, 5);
27	test__clzsi2(0x07000000, 5);	27	try test__clzsi2(0x07000000, 5);
28	test__clzsi2(0x08000000, 4);	28	try test__clzsi2(0x08000000, 4);
29	test__clzsi2(0x09000000, 4);	29	try test__clzsi2(0x09000000, 4);
30	test__clzsi2(0x0A000000, 4);	30	try test__clzsi2(0x0A000000, 4);
31	test__clzsi2(0x0B000000, 4);	31	try test__clzsi2(0x0B000000, 4);
32	test__clzsi2(0x0C000000, 4);	32	try test__clzsi2(0x0C000000, 4);
33	test__clzsi2(0x0D000000, 4);	33	try test__clzsi2(0x0D000000, 4);
34	test__clzsi2(0x0E000000, 4);	34	try test__clzsi2(0x0E000000, 4);
35	test__clzsi2(0x0F000000, 4);	35	try test__clzsi2(0x0F000000, 4);
36	test__clzsi2(0x10000000, 3);	36	try test__clzsi2(0x10000000, 3);
37	test__clzsi2(0x11000000, 3);	37	try test__clzsi2(0x11000000, 3);
38	test__clzsi2(0x12000000, 3);	38	try test__clzsi2(0x12000000, 3);
39	test__clzsi2(0x13000000, 3);	39	try test__clzsi2(0x13000000, 3);
40	test__clzsi2(0x14000000, 3);	40	try test__clzsi2(0x14000000, 3);
41	test__clzsi2(0x15000000, 3);	41	try test__clzsi2(0x15000000, 3);
42	test__clzsi2(0x16000000, 3);	42	try test__clzsi2(0x16000000, 3);
43	test__clzsi2(0x17000000, 3);	43	try test__clzsi2(0x17000000, 3);
44	test__clzsi2(0x18000000, 3);	44	try test__clzsi2(0x18000000, 3);
45	test__clzsi2(0x19000000, 3);	45	try test__clzsi2(0x19000000, 3);
46	test__clzsi2(0x1A000000, 3);	46	try test__clzsi2(0x1A000000, 3);
47	test__clzsi2(0x1B000000, 3);	47	try test__clzsi2(0x1B000000, 3);
48	test__clzsi2(0x1C000000, 3);	48	try test__clzsi2(0x1C000000, 3);
49	test__clzsi2(0x1D000000, 3);	49	try test__clzsi2(0x1D000000, 3);
50	test__clzsi2(0x1E000000, 3);	50	try test__clzsi2(0x1E000000, 3);
51	test__clzsi2(0x1F000000, 3);	51	try test__clzsi2(0x1F000000, 3);
52	test__clzsi2(0x20000000, 2);	52	try test__clzsi2(0x20000000, 2);
53	test__clzsi2(0x21000000, 2);	53	try test__clzsi2(0x21000000, 2);
54	test__clzsi2(0x22000000, 2);	54	try test__clzsi2(0x22000000, 2);
55	test__clzsi2(0x23000000, 2);	55	try test__clzsi2(0x23000000, 2);
56	test__clzsi2(0x24000000, 2);	56	try test__clzsi2(0x24000000, 2);
57	test__clzsi2(0x25000000, 2);	57	try test__clzsi2(0x25000000, 2);
58	test__clzsi2(0x26000000, 2);	58	try test__clzsi2(0x26000000, 2);
59	test__clzsi2(0x27000000, 2);	59	try test__clzsi2(0x27000000, 2);
60	test__clzsi2(0x28000000, 2);	60	try test__clzsi2(0x28000000, 2);
61	test__clzsi2(0x29000000, 2);	61	try test__clzsi2(0x29000000, 2);
62	test__clzsi2(0x2A000000, 2);	62	try test__clzsi2(0x2A000000, 2);
63	test__clzsi2(0x2B000000, 2);	63	try test__clzsi2(0x2B000000, 2);
64	test__clzsi2(0x2C000000, 2);	64	try test__clzsi2(0x2C000000, 2);
65	test__clzsi2(0x2D000000, 2);	65	try test__clzsi2(0x2D000000, 2);
66	test__clzsi2(0x2E000000, 2);	66	try test__clzsi2(0x2E000000, 2);
67	test__clzsi2(0x2F000000, 2);	67	try test__clzsi2(0x2F000000, 2);
68	test__clzsi2(0x30000000, 2);	68	try test__clzsi2(0x30000000, 2);
69	test__clzsi2(0x31000000, 2);	69	try test__clzsi2(0x31000000, 2);
70	test__clzsi2(0x32000000, 2);	70	try test__clzsi2(0x32000000, 2);
71	test__clzsi2(0x33000000, 2);	71	try test__clzsi2(0x33000000, 2);
72	test__clzsi2(0x34000000, 2);	72	try test__clzsi2(0x34000000, 2);
73	test__clzsi2(0x35000000, 2);	73	try test__clzsi2(0x35000000, 2);
74	test__clzsi2(0x36000000, 2);	74	try test__clzsi2(0x36000000, 2);
75	test__clzsi2(0x37000000, 2);	75	try test__clzsi2(0x37000000, 2);
76	test__clzsi2(0x38000000, 2);	76	try test__clzsi2(0x38000000, 2);
77	test__clzsi2(0x39000000, 2);	77	try test__clzsi2(0x39000000, 2);
78	test__clzsi2(0x3A000000, 2);	78	try test__clzsi2(0x3A000000, 2);
79	test__clzsi2(0x3B000000, 2);	79	try test__clzsi2(0x3B000000, 2);
80	test__clzsi2(0x3C000000, 2);	80	try test__clzsi2(0x3C000000, 2);
81	test__clzsi2(0x3D000000, 2);	81	try test__clzsi2(0x3D000000, 2);
82	test__clzsi2(0x3E000000, 2);	82	try test__clzsi2(0x3E000000, 2);
83	test__clzsi2(0x3F000000, 2);	83	try test__clzsi2(0x3F000000, 2);
84	test__clzsi2(0x40000000, 1);	84	try test__clzsi2(0x40000000, 1);
85	test__clzsi2(0x41000000, 1);	85	try test__clzsi2(0x41000000, 1);
86	test__clzsi2(0x42000000, 1);	86	try test__clzsi2(0x42000000, 1);
87	test__clzsi2(0x43000000, 1);	87	try test__clzsi2(0x43000000, 1);
88	test__clzsi2(0x44000000, 1);	88	try test__clzsi2(0x44000000, 1);
89	test__clzsi2(0x45000000, 1);	89	try test__clzsi2(0x45000000, 1);
90	test__clzsi2(0x46000000, 1);	90	try test__clzsi2(0x46000000, 1);
91	test__clzsi2(0x47000000, 1);	91	try test__clzsi2(0x47000000, 1);
92	test__clzsi2(0x48000000, 1);	92	try test__clzsi2(0x48000000, 1);
93	test__clzsi2(0x49000000, 1);	93	try test__clzsi2(0x49000000, 1);
94	test__clzsi2(0x4A000000, 1);	94	try test__clzsi2(0x4A000000, 1);
95	test__clzsi2(0x4B000000, 1);	95	try test__clzsi2(0x4B000000, 1);
96	test__clzsi2(0x4C000000, 1);	96	try test__clzsi2(0x4C000000, 1);
97	test__clzsi2(0x4D000000, 1);	97	try test__clzsi2(0x4D000000, 1);
98	test__clzsi2(0x4E000000, 1);	98	try test__clzsi2(0x4E000000, 1);
99	test__clzsi2(0x4F000000, 1);	99	try test__clzsi2(0x4F000000, 1);
100	test__clzsi2(0x50000000, 1);	100	try test__clzsi2(0x50000000, 1);
101	test__clzsi2(0x51000000, 1);	101	try test__clzsi2(0x51000000, 1);
102	test__clzsi2(0x52000000, 1);	102	try test__clzsi2(0x52000000, 1);
103	test__clzsi2(0x53000000, 1);	103	try test__clzsi2(0x53000000, 1);
104	test__clzsi2(0x54000000, 1);	104	try test__clzsi2(0x54000000, 1);
105	test__clzsi2(0x55000000, 1);	105	try test__clzsi2(0x55000000, 1);
106	test__clzsi2(0x56000000, 1);	106	try test__clzsi2(0x56000000, 1);
107	test__clzsi2(0x57000000, 1);	107	try test__clzsi2(0x57000000, 1);
108	test__clzsi2(0x58000000, 1);	108	try test__clzsi2(0x58000000, 1);
109	test__clzsi2(0x59000000, 1);	109	try test__clzsi2(0x59000000, 1);
110	test__clzsi2(0x5A000000, 1);	110	try test__clzsi2(0x5A000000, 1);
111	test__clzsi2(0x5B000000, 1);	111	try test__clzsi2(0x5B000000, 1);
112	test__clzsi2(0x5C000000, 1);	112	try test__clzsi2(0x5C000000, 1);
113	test__clzsi2(0x5D000000, 1);	113	try test__clzsi2(0x5D000000, 1);
114	test__clzsi2(0x5E000000, 1);	114	try test__clzsi2(0x5E000000, 1);
115	test__clzsi2(0x5F000000, 1);	115	try test__clzsi2(0x5F000000, 1);
116	test__clzsi2(0x60000000, 1);	116	try test__clzsi2(0x60000000, 1);
117	test__clzsi2(0x61000000, 1);	117	try test__clzsi2(0x61000000, 1);
118	test__clzsi2(0x62000000, 1);	118	try test__clzsi2(0x62000000, 1);
119	test__clzsi2(0x63000000, 1);	119	try test__clzsi2(0x63000000, 1);
120	test__clzsi2(0x64000000, 1);	120	try test__clzsi2(0x64000000, 1);
121	test__clzsi2(0x65000000, 1);	121	try test__clzsi2(0x65000000, 1);
122	test__clzsi2(0x66000000, 1);	122	try test__clzsi2(0x66000000, 1);
123	test__clzsi2(0x67000000, 1);	123	try test__clzsi2(0x67000000, 1);
124	test__clzsi2(0x68000000, 1);	124	try test__clzsi2(0x68000000, 1);
125	test__clzsi2(0x69000000, 1);	125	try test__clzsi2(0x69000000, 1);
126	test__clzsi2(0x6A000000, 1);	126	try test__clzsi2(0x6A000000, 1);
127	test__clzsi2(0x6B000000, 1);	127	try test__clzsi2(0x6B000000, 1);
128	test__clzsi2(0x6C000000, 1);	128	try test__clzsi2(0x6C000000, 1);
129	test__clzsi2(0x6D000000, 1);	129	try test__clzsi2(0x6D000000, 1);
130	test__clzsi2(0x6E000000, 1);	130	try test__clzsi2(0x6E000000, 1);
131	test__clzsi2(0x6F000000, 1);	131	try test__clzsi2(0x6F000000, 1);
132	test__clzsi2(0x70000000, 1);	132	try test__clzsi2(0x70000000, 1);
133	test__clzsi2(0x71000000, 1);	133	try test__clzsi2(0x71000000, 1);
134	test__clzsi2(0x72000000, 1);	134	try test__clzsi2(0x72000000, 1);
135	test__clzsi2(0x73000000, 1);	135	try test__clzsi2(0x73000000, 1);
136	test__clzsi2(0x74000000, 1);	136	try test__clzsi2(0x74000000, 1);
137	test__clzsi2(0x75000000, 1);	137	try test__clzsi2(0x75000000, 1);
138	test__clzsi2(0x76000000, 1);	138	try test__clzsi2(0x76000000, 1);
139	test__clzsi2(0x77000000, 1);	139	try test__clzsi2(0x77000000, 1);
140	test__clzsi2(0x78000000, 1);	140	try test__clzsi2(0x78000000, 1);
141	test__clzsi2(0x79000000, 1);	141	try test__clzsi2(0x79000000, 1);
142	test__clzsi2(0x7A000000, 1);	142	try test__clzsi2(0x7A000000, 1);
143	test__clzsi2(0x7B000000, 1);	143	try test__clzsi2(0x7B000000, 1);
144	test__clzsi2(0x7C000000, 1);	144	try test__clzsi2(0x7C000000, 1);
145	test__clzsi2(0x7D000000, 1);	145	try test__clzsi2(0x7D000000, 1);
146	test__clzsi2(0x7E000000, 1);	146	try test__clzsi2(0x7E000000, 1);
147	test__clzsi2(0x7F000000, 1);	147	try test__clzsi2(0x7F000000, 1);
148	test__clzsi2(0x80000000, 0);	148	try test__clzsi2(0x80000000, 0);
149	test__clzsi2(0x81000000, 0);	149	try test__clzsi2(0x81000000, 0);
150	test__clzsi2(0x82000000, 0);	150	try test__clzsi2(0x82000000, 0);
151	test__clzsi2(0x83000000, 0);	151	try test__clzsi2(0x83000000, 0);
152	test__clzsi2(0x84000000, 0);	152	try test__clzsi2(0x84000000, 0);
153	test__clzsi2(0x85000000, 0);	153	try test__clzsi2(0x85000000, 0);
154	test__clzsi2(0x86000000, 0);	154	try test__clzsi2(0x86000000, 0);
155	test__clzsi2(0x87000000, 0);	155	try test__clzsi2(0x87000000, 0);
156	test__clzsi2(0x88000000, 0);	156	try test__clzsi2(0x88000000, 0);
157	test__clzsi2(0x89000000, 0);	157	try test__clzsi2(0x89000000, 0);
158	test__clzsi2(0x8A000000, 0);	158	try test__clzsi2(0x8A000000, 0);
159	test__clzsi2(0x8B000000, 0);	159	try test__clzsi2(0x8B000000, 0);
160	test__clzsi2(0x8C000000, 0);	160	try test__clzsi2(0x8C000000, 0);
161	test__clzsi2(0x8D000000, 0);	161	try test__clzsi2(0x8D000000, 0);
162	test__clzsi2(0x8E000000, 0);	162	try test__clzsi2(0x8E000000, 0);
163	test__clzsi2(0x8F000000, 0);	163	try test__clzsi2(0x8F000000, 0);
164	test__clzsi2(0x90000000, 0);	164	try test__clzsi2(0x90000000, 0);
165	test__clzsi2(0x91000000, 0);	165	try test__clzsi2(0x91000000, 0);
166	test__clzsi2(0x92000000, 0);	166	try test__clzsi2(0x92000000, 0);
167	test__clzsi2(0x93000000, 0);	167	try test__clzsi2(0x93000000, 0);
168	test__clzsi2(0x94000000, 0);	168	try test__clzsi2(0x94000000, 0);
169	test__clzsi2(0x95000000, 0);	169	try test__clzsi2(0x95000000, 0);
170	test__clzsi2(0x96000000, 0);	170	try test__clzsi2(0x96000000, 0);
171	test__clzsi2(0x97000000, 0);	171	try test__clzsi2(0x97000000, 0);
172	test__clzsi2(0x98000000, 0);	172	try test__clzsi2(0x98000000, 0);
173	test__clzsi2(0x99000000, 0);	173	try test__clzsi2(0x99000000, 0);
174	test__clzsi2(0x9A000000, 0);	174	try test__clzsi2(0x9A000000, 0);
175	test__clzsi2(0x9B000000, 0);	175	try test__clzsi2(0x9B000000, 0);
176	test__clzsi2(0x9C000000, 0);	176	try test__clzsi2(0x9C000000, 0);
177	test__clzsi2(0x9D000000, 0);	177	try test__clzsi2(0x9D000000, 0);
178	test__clzsi2(0x9E000000, 0);	178	try test__clzsi2(0x9E000000, 0);
179	test__clzsi2(0x9F000000, 0);	179	try test__clzsi2(0x9F000000, 0);
180	test__clzsi2(0xA0000000, 0);	180	try test__clzsi2(0xA0000000, 0);
181	test__clzsi2(0xA1000000, 0);	181	try test__clzsi2(0xA1000000, 0);
182	test__clzsi2(0xA2000000, 0);	182	try test__clzsi2(0xA2000000, 0);
183	test__clzsi2(0xA3000000, 0);	183	try test__clzsi2(0xA3000000, 0);
184	test__clzsi2(0xA4000000, 0);	184	try test__clzsi2(0xA4000000, 0);
185	test__clzsi2(0xA5000000, 0);	185	try test__clzsi2(0xA5000000, 0);
186	test__clzsi2(0xA6000000, 0);	186	try test__clzsi2(0xA6000000, 0);
187	test__clzsi2(0xA7000000, 0);	187	try test__clzsi2(0xA7000000, 0);
188	test__clzsi2(0xA8000000, 0);	188	try test__clzsi2(0xA8000000, 0);
189	test__clzsi2(0xA9000000, 0);	189	try test__clzsi2(0xA9000000, 0);
190	test__clzsi2(0xAA000000, 0);	190	try test__clzsi2(0xAA000000, 0);
191	test__clzsi2(0xAB000000, 0);	191	try test__clzsi2(0xAB000000, 0);
192	test__clzsi2(0xAC000000, 0);	192	try test__clzsi2(0xAC000000, 0);
193	test__clzsi2(0xAD000000, 0);	193	try test__clzsi2(0xAD000000, 0);
194	test__clzsi2(0xAE000000, 0);	194	try test__clzsi2(0xAE000000, 0);
195	test__clzsi2(0xAF000000, 0);	195	try test__clzsi2(0xAF000000, 0);
196	test__clzsi2(0xB0000000, 0);	196	try test__clzsi2(0xB0000000, 0);
197	test__clzsi2(0xB1000000, 0);	197	try test__clzsi2(0xB1000000, 0);
198	test__clzsi2(0xB2000000, 0);	198	try test__clzsi2(0xB2000000, 0);
199	test__clzsi2(0xB3000000, 0);	199	try test__clzsi2(0xB3000000, 0);
200	test__clzsi2(0xB4000000, 0);	200	try test__clzsi2(0xB4000000, 0);
201	test__clzsi2(0xB5000000, 0);	201	try test__clzsi2(0xB5000000, 0);
202	test__clzsi2(0xB6000000, 0);	202	try test__clzsi2(0xB6000000, 0);
203	test__clzsi2(0xB7000000, 0);	203	try test__clzsi2(0xB7000000, 0);
204	test__clzsi2(0xB8000000, 0);	204	try test__clzsi2(0xB8000000, 0);
205	test__clzsi2(0xB9000000, 0);	205	try test__clzsi2(0xB9000000, 0);
206	test__clzsi2(0xBA000000, 0);	206	try test__clzsi2(0xBA000000, 0);
207	test__clzsi2(0xBB000000, 0);	207	try test__clzsi2(0xBB000000, 0);
208	test__clzsi2(0xBC000000, 0);	208	try test__clzsi2(0xBC000000, 0);
209	test__clzsi2(0xBD000000, 0);	209	try test__clzsi2(0xBD000000, 0);
210	test__clzsi2(0xBE000000, 0);	210	try test__clzsi2(0xBE000000, 0);
211	test__clzsi2(0xBF000000, 0);	211	try test__clzsi2(0xBF000000, 0);
212	test__clzsi2(0xC0000000, 0);	212	try test__clzsi2(0xC0000000, 0);
213	test__clzsi2(0xC1000000, 0);	213	try test__clzsi2(0xC1000000, 0);
214	test__clzsi2(0xC2000000, 0);	214	try test__clzsi2(0xC2000000, 0);
215	test__clzsi2(0xC3000000, 0);	215	try test__clzsi2(0xC3000000, 0);
216	test__clzsi2(0xC4000000, 0);	216	try test__clzsi2(0xC4000000, 0);
217	test__clzsi2(0xC5000000, 0);	217	try test__clzsi2(0xC5000000, 0);
218	test__clzsi2(0xC6000000, 0);	218	try test__clzsi2(0xC6000000, 0);
219	test__clzsi2(0xC7000000, 0);	219	try test__clzsi2(0xC7000000, 0);
220	test__clzsi2(0xC8000000, 0);	220	try test__clzsi2(0xC8000000, 0);
221	test__clzsi2(0xC9000000, 0);	221	try test__clzsi2(0xC9000000, 0);
222	test__clzsi2(0xCA000000, 0);	222	try test__clzsi2(0xCA000000, 0);
223	test__clzsi2(0xCB000000, 0);	223	try test__clzsi2(0xCB000000, 0);
224	test__clzsi2(0xCC000000, 0);	224	try test__clzsi2(0xCC000000, 0);
225	test__clzsi2(0xCD000000, 0);	225	try test__clzsi2(0xCD000000, 0);
226	test__clzsi2(0xCE000000, 0);	226	try test__clzsi2(0xCE000000, 0);
227	test__clzsi2(0xCF000000, 0);	227	try test__clzsi2(0xCF000000, 0);
228	test__clzsi2(0xD0000000, 0);	228	try test__clzsi2(0xD0000000, 0);
229	test__clzsi2(0xD1000000, 0);	229	try test__clzsi2(0xD1000000, 0);
230	test__clzsi2(0xD2000000, 0);	230	try test__clzsi2(0xD2000000, 0);
231	test__clzsi2(0xD3000000, 0);	231	try test__clzsi2(0xD3000000, 0);
232	test__clzsi2(0xD4000000, 0);	232	try test__clzsi2(0xD4000000, 0);
233	test__clzsi2(0xD5000000, 0);	233	try test__clzsi2(0xD5000000, 0);
234	test__clzsi2(0xD6000000, 0);	234	try test__clzsi2(0xD6000000, 0);
235	test__clzsi2(0xD7000000, 0);	235	try test__clzsi2(0xD7000000, 0);
236	test__clzsi2(0xD8000000, 0);	236	try test__clzsi2(0xD8000000, 0);
237	test__clzsi2(0xD9000000, 0);	237	try test__clzsi2(0xD9000000, 0);
238	test__clzsi2(0xDA000000, 0);	238	try test__clzsi2(0xDA000000, 0);
239	test__clzsi2(0xDB000000, 0);	239	try test__clzsi2(0xDB000000, 0);
240	test__clzsi2(0xDC000000, 0);	240	try test__clzsi2(0xDC000000, 0);
241	test__clzsi2(0xDD000000, 0);	241	try test__clzsi2(0xDD000000, 0);
242	test__clzsi2(0xDE000000, 0);	242	try test__clzsi2(0xDE000000, 0);
243	test__clzsi2(0xDF000000, 0);	243	try test__clzsi2(0xDF000000, 0);
244	test__clzsi2(0xE0000000, 0);	244	try test__clzsi2(0xE0000000, 0);
245	test__clzsi2(0xE1000000, 0);	245	try test__clzsi2(0xE1000000, 0);
246	test__clzsi2(0xE2000000, 0);	246	try test__clzsi2(0xE2000000, 0);
247	test__clzsi2(0xE3000000, 0);	247	try test__clzsi2(0xE3000000, 0);
248	test__clzsi2(0xE4000000, 0);	248	try test__clzsi2(0xE4000000, 0);
249	test__clzsi2(0xE5000000, 0);	249	try test__clzsi2(0xE5000000, 0);
250	test__clzsi2(0xE6000000, 0);	250	try test__clzsi2(0xE6000000, 0);
251	test__clzsi2(0xE7000000, 0);	251	try test__clzsi2(0xE7000000, 0);
252	test__clzsi2(0xE8000000, 0);	252	try test__clzsi2(0xE8000000, 0);
253	test__clzsi2(0xE9000000, 0);	253	try test__clzsi2(0xE9000000, 0);
254	test__clzsi2(0xEA000000, 0);	254	try test__clzsi2(0xEA000000, 0);
255	test__clzsi2(0xEB000000, 0);	255	try test__clzsi2(0xEB000000, 0);
256	test__clzsi2(0xEC000000, 0);	256	try test__clzsi2(0xEC000000, 0);
257	test__clzsi2(0xED000000, 0);	257	try test__clzsi2(0xED000000, 0);
258	test__clzsi2(0xEE000000, 0);	258	try test__clzsi2(0xEE000000, 0);
259	test__clzsi2(0xEF000000, 0);	259	try test__clzsi2(0xEF000000, 0);
260	test__clzsi2(0xF0000000, 0);	260	try test__clzsi2(0xF0000000, 0);
261	test__clzsi2(0xF1000000, 0);	261	try test__clzsi2(0xF1000000, 0);
262	test__clzsi2(0xF2000000, 0);	262	try test__clzsi2(0xF2000000, 0);
263	test__clzsi2(0xF3000000, 0);	263	try test__clzsi2(0xF3000000, 0);
264	test__clzsi2(0xF4000000, 0);	264	try test__clzsi2(0xF4000000, 0);
265	test__clzsi2(0xF5000000, 0);	265	try test__clzsi2(0xF5000000, 0);
266	test__clzsi2(0xF6000000, 0);	266	try test__clzsi2(0xF6000000, 0);
267	test__clzsi2(0xF7000000, 0);	267	try test__clzsi2(0xF7000000, 0);
268	test__clzsi2(0xF8000000, 0);	268	try test__clzsi2(0xF8000000, 0);
269	test__clzsi2(0xF9000000, 0);	269	try test__clzsi2(0xF9000000, 0);
270	test__clzsi2(0xFA000000, 0);	270	try test__clzsi2(0xFA000000, 0);
271	test__clzsi2(0xFB000000, 0);	271	try test__clzsi2(0xFB000000, 0);
272	test__clzsi2(0xFC000000, 0);	272	try test__clzsi2(0xFC000000, 0);
273	test__clzsi2(0xFD000000, 0);	273	try test__clzsi2(0xFD000000, 0);
274	test__clzsi2(0xFE000000, 0);	274	try test__clzsi2(0xFE000000, 0);
275	test__clzsi2(0xFF000000, 0);	275	try test__clzsi2(0xFF000000, 0);
276	test__clzsi2(0x00000001, 31);	276	try test__clzsi2(0x00000001, 31);
277	test__clzsi2(0x00000002, 30);	277	try test__clzsi2(0x00000002, 30);
278	test__clzsi2(0x00000004, 29);	278	try test__clzsi2(0x00000004, 29);
279	test__clzsi2(0x00000008, 28);	279	try test__clzsi2(0x00000008, 28);
280	test__clzsi2(0x00000010, 27);	280	try test__clzsi2(0x00000010, 27);
281	test__clzsi2(0x00000020, 26);	281	try test__clzsi2(0x00000020, 26);
282	test__clzsi2(0x00000040, 25);	282	try test__clzsi2(0x00000040, 25);
283	test__clzsi2(0x00000080, 24);	283	try test__clzsi2(0x00000080, 24);
284	test__clzsi2(0x00000100, 23);	284	try test__clzsi2(0x00000100, 23);
285	test__clzsi2(0x00000200, 22);	285	try test__clzsi2(0x00000200, 22);
286	test__clzsi2(0x00000400, 21);	286	try test__clzsi2(0x00000400, 21);
287	test__clzsi2(0x00000800, 20);	287	try test__clzsi2(0x00000800, 20);
288	test__clzsi2(0x00001000, 19);	288	try test__clzsi2(0x00001000, 19);
289	test__clzsi2(0x00002000, 18);	289	try test__clzsi2(0x00002000, 18);
290	test__clzsi2(0x00004000, 17);	290	try test__clzsi2(0x00004000, 17);
291	test__clzsi2(0x00008000, 16);	291	try test__clzsi2(0x00008000, 16);
292	test__clzsi2(0x00010000, 15);	292	try test__clzsi2(0x00010000, 15);
293	test__clzsi2(0x00020000, 14);	293	try test__clzsi2(0x00020000, 14);
294	test__clzsi2(0x00040000, 13);	294	try test__clzsi2(0x00040000, 13);
295	test__clzsi2(0x00080000, 12);	295	try test__clzsi2(0x00080000, 12);
296	test__clzsi2(0x00100000, 11);	296	try test__clzsi2(0x00100000, 11);
297	test__clzsi2(0x00200000, 10);	297	try test__clzsi2(0x00200000, 10);
298	test__clzsi2(0x00400000, 9);	298	try test__clzsi2(0x00400000, 9);
299	}	299	}

lib/std/special/compiler_rt/comparedf2_test.zig+1-1

...	@@ -101,6 +101,6 @@ const test_vectors = init: {	...	@@ -101,6 +101,6 @@ const test_vectors = init: {
101		101
102	test "compare f64" {	102	test "compare f64" {
103	for (test_vectors) \|vector, i\| {	103	for (test_vectors) \|vector, i\| {
104	std.testing.expect(test__cmpdf2(vector));	104	try std.testing.expect(test__cmpdf2(vector));
105	}	105	}
106	}	106	}

lib/std/special/compiler_rt/comparesf2_test.zig+1-1

...	@@ -101,6 +101,6 @@ const test_vectors = init: {	...	@@ -101,6 +101,6 @@ const test_vectors = init: {
101		101
102	test "compare f32" {	102	test "compare f32" {
103	for (test_vectors) \|vector, i\| {	103	for (test_vectors) \|vector, i\| {
104	std.testing.expect(test__cmpsf2(vector));	104	try std.testing.expect(test__cmpsf2(vector));
105	}	105	}
106	}	106	}

lib/std/special/compiler_rt/divdf3_test.zig+4-4

...	@@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool {	...	@@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool {
27	return false;	27	return false;
28	}	28	}
29		29
30	fn test__divdf3(a: f64, b: f64, expected: u64) void {	30	fn test__divdf3(a: f64, b: f64, expected: u64) !void {
31	const x = __divdf3(a, b);	31	const x = __divdf3(a, b);
32	const ret = compareResultD(x, expected);	32	const ret = compareResultD(x, expected);
33	testing.expect(ret == true);	33	try testing.expect(ret == true);
34	}	34	}
35		35
36	test "divdf3" {	36	test "divdf3" {
37	test__divdf3(1.0, 3.0, 0x3fd5555555555555);	37	try test__divdf3(1.0, 3.0, 0x3fd5555555555555);
38	test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);	38	try test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);
39	}	39	}

lib/std/special/compiler_rt/divsf3_test.zig+4-4

...	@@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool {	...	@@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool {
27	return false;	27	return false;
28	}	28	}
29		29
30	fn test__divsf3(a: f32, b: f32, expected: u32) void {	30	fn test__divsf3(a: f32, b: f32, expected: u32) !void {
31	const x = __divsf3(a, b);	31	const x = __divsf3(a, b);
32	const ret = compareResultF(x, expected);	32	const ret = compareResultF(x, expected);
33	testing.expect(ret == true);	33	try testing.expect(ret == true);
34	}	34	}
35		35
36	test "divsf3" {	36	test "divsf3" {
37	test__divsf3(1.0, 3.0, 0x3EAAAAAB);	37	try test__divsf3(1.0, 3.0, 0x3EAAAAAB);
38	test__divsf3(2.3509887e-38, 2.0, 0x00800000);	38	try test__divsf3(2.3509887e-38, 2.0, 0x00800000);
39	}	39	}

lib/std/special/compiler_rt/divtf3_test.zig+11-11

lib/std/special/compiler_rt/divti3_test.zig+12-12

...	@@ -6,21 +6,21 @@	...	@@ -6,21 +6,21 @@
6	const __divti3 = @import("divti3.zig").__divti3;	6	const __divti3 = @import("divti3.zig").__divti3;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__divti3(a: i128, b: i128, expected: i128) void {	9	fn test__divti3(a: i128, b: i128, expected: i128) !void {
10	const x = __divti3(a, b);	10	const x = __divti3(a, b);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "divti3" {	14	test "divti3" {
15	test__divti3(0, 1, 0);	15	try test__divti3(0, 1, 0);
16	test__divti3(0, -1, 0);	16	try test__divti3(0, -1, 0);
17	test__divti3(2, 1, 2);	17	try test__divti3(2, 1, 2);
18	test__divti3(2, -1, -2);	18	try test__divti3(2, -1, -2);
19	test__divti3(-2, 1, -2);	19	try test__divti3(-2, 1, -2);
20	test__divti3(-2, -1, 2);	20	try test__divti3(-2, -1, 2);
21		21
22	test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));	22	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
23	test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));	23	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
24	test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));	24	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
25	test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));	25	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
26	}	26	}

lib/std/special/compiler_rt/emutls.zig+11-11

lib/std/special/compiler_rt/extendXfYf2_test.zig+55-55

lib/std/special/compiler_rt/fixdfdi_test.zig+42-42

lib/std/special/compiler_rt/fixdfsi_test.zig+48-48

lib/std/special/compiler_rt/fixdfti_test.zig+42-42

lib/std/special/compiler_rt/fixint_test.zig+123-123

lib/std/special/compiler_rt/fixsfdi_test.zig+44-44

lib/std/special/compiler_rt/fixsfsi_test.zig+50-50

lib/std/special/compiler_rt/fixsfti_test.zig+58-58

lib/std/special/compiler_rt/fixtfdi_test.zig+50-50

lib/std/special/compiler_rt/fixtfsi_test.zig+50-50

lib/std/special/compiler_rt/fixtfti_test.zig+42-42

lib/std/special/compiler_rt/fixunsdfdi_test.zig+24-24

...	@@ -6,39 +6,39 @@	...	@@ -6,39 +6,39 @@
6	const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;	6	const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunsdfdi(a: f64, expected: u64) void {	9	fn test__fixunsdfdi(a: f64, expected: u64) !void {
10	const x = __fixunsdfdi(a);	10	const x = __fixunsdfdi(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunsdfdi" {	14	test "fixunsdfdi" {
15	//test__fixunsdfdi(0.0, 0);	15	//test__fixunsdfdi(0.0, 0);
16	//test__fixunsdfdi(0.5, 0);	16	//test__fixunsdfdi(0.5, 0);
17	//test__fixunsdfdi(0.99, 0);	17	//test__fixunsdfdi(0.99, 0);
18	test__fixunsdfdi(1.0, 1);	18	try test__fixunsdfdi(1.0, 1);
19	test__fixunsdfdi(1.5, 1);	19	try test__fixunsdfdi(1.5, 1);
20	test__fixunsdfdi(1.99, 1);	20	try test__fixunsdfdi(1.99, 1);
21	test__fixunsdfdi(2.0, 2);	21	try test__fixunsdfdi(2.0, 2);
22	test__fixunsdfdi(2.01, 2);	22	try test__fixunsdfdi(2.01, 2);
23	test__fixunsdfdi(-0.5, 0);	23	try test__fixunsdfdi(-0.5, 0);
24	test__fixunsdfdi(-0.99, 0);	24	try test__fixunsdfdi(-0.99, 0);
25	test__fixunsdfdi(-1.0, 0);	25	try test__fixunsdfdi(-1.0, 0);
26	test__fixunsdfdi(-1.5, 0);	26	try test__fixunsdfdi(-1.5, 0);
27	test__fixunsdfdi(-1.99, 0);	27	try test__fixunsdfdi(-1.99, 0);
28	test__fixunsdfdi(-2.0, 0);	28	try test__fixunsdfdi(-2.0, 0);
29	test__fixunsdfdi(-2.01, 0);	29	try test__fixunsdfdi(-2.01, 0);
30		30
31	test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);	31	try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
32	test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);	32	try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
33		33
34	test__fixunsdfdi(-0x1.FFFFFEp+62, 0);	34	try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
35	test__fixunsdfdi(-0x1.FFFFFCp+62, 0);	35	try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
36		36
37	test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);	37	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
38	test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);	38	try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
39	test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);	39	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
40	test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);	40	try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
41		41
42	test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);	42	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
43	test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);	43	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
44	}	44	}

lib/std/special/compiler_rt/fixunsdfsi_test.zig+27-27

...	@@ -6,39 +6,39 @@	...	@@ -6,39 +6,39 @@
6	const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;	6	const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunsdfsi(a: f64, expected: u32) void {	9	fn test__fixunsdfsi(a: f64, expected: u32) !void {
10	const x = __fixunsdfsi(a);	10	const x = __fixunsdfsi(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunsdfsi" {	14	test "fixunsdfsi" {
15	test__fixunsdfsi(0.0, 0);	15	try test__fixunsdfsi(0.0, 0);
16		16
17	test__fixunsdfsi(0.5, 0);	17	try test__fixunsdfsi(0.5, 0);
18	test__fixunsdfsi(0.99, 0);	18	try test__fixunsdfsi(0.99, 0);
19	test__fixunsdfsi(1.0, 1);	19	try test__fixunsdfsi(1.0, 1);
20	test__fixunsdfsi(1.5, 1);	20	try test__fixunsdfsi(1.5, 1);
21	test__fixunsdfsi(1.99, 1);	21	try test__fixunsdfsi(1.99, 1);
22	test__fixunsdfsi(2.0, 2);	22	try test__fixunsdfsi(2.0, 2);
23	test__fixunsdfsi(2.01, 2);	23	try test__fixunsdfsi(2.01, 2);
24	test__fixunsdfsi(-0.5, 0);	24	try test__fixunsdfsi(-0.5, 0);
25	test__fixunsdfsi(-0.99, 0);	25	try test__fixunsdfsi(-0.99, 0);
26	test__fixunsdfsi(-1.0, 0);	26	try test__fixunsdfsi(-1.0, 0);
27	test__fixunsdfsi(-1.5, 0);	27	try test__fixunsdfsi(-1.5, 0);
28	test__fixunsdfsi(-1.99, 0);	28	try test__fixunsdfsi(-1.99, 0);
29	test__fixunsdfsi(-2.0, 0);	29	try test__fixunsdfsi(-2.0, 0);
30	test__fixunsdfsi(-2.01, 0);	30	try test__fixunsdfsi(-2.01, 0);
31		31
32	test__fixunsdfsi(0x1.000000p+31, 0x80000000);	32	try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
33	test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);	33	try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
34	test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);	34	try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
35	test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);	35	try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
36	test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);	36	try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
37		37
38	test__fixunsdfsi(-0x1.FFFFFEp+30, 0);	38	try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
39	test__fixunsdfsi(-0x1.FFFFFCp+30, 0);	39	try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
40		40
41	test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);	41	try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
42	test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);	42	try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
43	test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);	43	try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
44	}	44	}

lib/std/special/compiler_rt/fixunsdfti_test.zig+38-38

...	@@ -6,46 +6,46 @@	...	@@ -6,46 +6,46 @@
6	const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;	6	const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunsdfti(a: f64, expected: u128) void {	9	fn test__fixunsdfti(a: f64, expected: u128) !void {
10	const x = __fixunsdfti(a);	10	const x = __fixunsdfti(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunsdfti" {	14	test "fixunsdfti" {
15	test__fixunsdfti(0.0, 0);	15	try test__fixunsdfti(0.0, 0);
16		16
17	test__fixunsdfti(0.5, 0);	17	try test__fixunsdfti(0.5, 0);
18	test__fixunsdfti(0.99, 0);	18	try test__fixunsdfti(0.99, 0);
19	test__fixunsdfti(1.0, 1);	19	try test__fixunsdfti(1.0, 1);
20	test__fixunsdfti(1.5, 1);	20	try test__fixunsdfti(1.5, 1);
21	test__fixunsdfti(1.99, 1);	21	try test__fixunsdfti(1.99, 1);
22	test__fixunsdfti(2.0, 2);	22	try test__fixunsdfti(2.0, 2);
23	test__fixunsdfti(2.01, 2);	23	try test__fixunsdfti(2.01, 2);
24	test__fixunsdfti(-0.5, 0);	24	try test__fixunsdfti(-0.5, 0);
25	test__fixunsdfti(-0.99, 0);	25	try test__fixunsdfti(-0.99, 0);
26	test__fixunsdfti(-1.0, 0);	26	try test__fixunsdfti(-1.0, 0);
27	test__fixunsdfti(-1.5, 0);	27	try test__fixunsdfti(-1.5, 0);
28	test__fixunsdfti(-1.99, 0);	28	try test__fixunsdfti(-1.99, 0);
29	test__fixunsdfti(-2.0, 0);	29	try test__fixunsdfti(-2.0, 0);
30	test__fixunsdfti(-2.01, 0);	30	try test__fixunsdfti(-2.01, 0);
31		31
32	test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);	32	try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33	test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);	33	try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
34		34
35	test__fixunsdfti(-0x1.FFFFFEp+62, 0);	35	try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
36	test__fixunsdfti(-0x1.FFFFFCp+62, 0);	36	try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
37		37
38	test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);	38	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
39	test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);	39	try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
40	test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);	40	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
41	test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);	41	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
42		42
43	test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);	43	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
44	test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);	44	try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
45	test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);	45	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
46	test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);	46	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
47	test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);	47	try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
48		48
49	test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);	49	try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
50	test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);	50	try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
51	}	51	}

lib/std/special/compiler_rt/fixunssfdi_test.zig+23-23

...	@@ -6,35 +6,35 @@	...	@@ -6,35 +6,35 @@
6	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;	6	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunssfdi(a: f32, expected: u64) void {	9	fn test__fixunssfdi(a: f32, expected: u64) !void {
10	const x = __fixunssfdi(a);	10	const x = __fixunssfdi(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunssfdi" {	14	test "fixunssfdi" {
15	test__fixunssfdi(0.0, 0);	15	try test__fixunssfdi(0.0, 0);
16		16
17	test__fixunssfdi(0.5, 0);	17	try test__fixunssfdi(0.5, 0);
18	test__fixunssfdi(0.99, 0);	18	try test__fixunssfdi(0.99, 0);
19	test__fixunssfdi(1.0, 1);	19	try test__fixunssfdi(1.0, 1);
20	test__fixunssfdi(1.5, 1);	20	try test__fixunssfdi(1.5, 1);
21	test__fixunssfdi(1.99, 1);	21	try test__fixunssfdi(1.99, 1);
22	test__fixunssfdi(2.0, 2);	22	try test__fixunssfdi(2.0, 2);
23	test__fixunssfdi(2.01, 2);	23	try test__fixunssfdi(2.01, 2);
24	test__fixunssfdi(-0.5, 0);	24	try test__fixunssfdi(-0.5, 0);
25	test__fixunssfdi(-0.99, 0);	25	try test__fixunssfdi(-0.99, 0);
26		26
27	test__fixunssfdi(-1.0, 0);	27	try test__fixunssfdi(-1.0, 0);
28	test__fixunssfdi(-1.5, 0);	28	try test__fixunssfdi(-1.5, 0);
29	test__fixunssfdi(-1.99, 0);	29	try test__fixunssfdi(-1.99, 0);
30	test__fixunssfdi(-2.0, 0);	30	try test__fixunssfdi(-2.0, 0);
31	test__fixunssfdi(-2.01, 0);	31	try test__fixunssfdi(-2.01, 0);
32		32
33	test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);	33	try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34	test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);	34	try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
35	test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);	35	try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36	test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);	36	try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
37		37
38	test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);	38	try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
39	test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);	39	try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
40	}	40	}

lib/std/special/compiler_rt/fixunssfsi_test.zig+24-24

...	@@ -6,36 +6,36 @@	...	@@ -6,36 +6,36 @@
6	const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;	6	const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunssfsi(a: f32, expected: u32) void {	9	fn test__fixunssfsi(a: f32, expected: u32) !void {
10	const x = __fixunssfsi(a);	10	const x = __fixunssfsi(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunssfsi" {	14	test "fixunssfsi" {
15	test__fixunssfsi(0.0, 0);	15	try test__fixunssfsi(0.0, 0);
16		16
17	test__fixunssfsi(0.5, 0);	17	try test__fixunssfsi(0.5, 0);
18	test__fixunssfsi(0.99, 0);	18	try test__fixunssfsi(0.99, 0);
19	test__fixunssfsi(1.0, 1);	19	try test__fixunssfsi(1.0, 1);
20	test__fixunssfsi(1.5, 1);	20	try test__fixunssfsi(1.5, 1);
21	test__fixunssfsi(1.99, 1);	21	try test__fixunssfsi(1.99, 1);
22	test__fixunssfsi(2.0, 2);	22	try test__fixunssfsi(2.0, 2);
23	test__fixunssfsi(2.01, 2);	23	try test__fixunssfsi(2.01, 2);
24	test__fixunssfsi(-0.5, 0);	24	try test__fixunssfsi(-0.5, 0);
25	test__fixunssfsi(-0.99, 0);	25	try test__fixunssfsi(-0.99, 0);
26		26
27	test__fixunssfsi(-1.0, 0);	27	try test__fixunssfsi(-1.0, 0);
28	test__fixunssfsi(-1.5, 0);	28	try test__fixunssfsi(-1.5, 0);
29	test__fixunssfsi(-1.99, 0);	29	try test__fixunssfsi(-1.99, 0);
30	test__fixunssfsi(-2.0, 0);	30	try test__fixunssfsi(-2.0, 0);
31	test__fixunssfsi(-2.01, 0);	31	try test__fixunssfsi(-2.01, 0);
32		32
33	test__fixunssfsi(0x1.000000p+31, 0x80000000);	33	try test__fixunssfsi(0x1.000000p+31, 0x80000000);
34	test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);	34	try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
35	test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);	35	try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
36	test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);	36	try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
37	test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);	37	try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
38		38
39	test__fixunssfsi(-0x1.FFFFFEp+30, 0);	39	try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
40	test__fixunssfsi(-0x1.FFFFFCp+30, 0);	40	try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
41	}	41	}

lib/std/special/compiler_rt/fixunssfti_test.zig+29-29

...	@@ -6,41 +6,41 @@	...	@@ -6,41 +6,41 @@
6	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;	6	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunssfti(a: f32, expected: u128) void {	9	fn test__fixunssfti(a: f32, expected: u128) !void {
10	const x = __fixunssfti(a);	10	const x = __fixunssfti(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunssfti" {	14	test "fixunssfti" {
15	test__fixunssfti(0.0, 0);	15	try test__fixunssfti(0.0, 0);
16		16
17	test__fixunssfti(0.5, 0);	17	try test__fixunssfti(0.5, 0);
18	test__fixunssfti(0.99, 0);	18	try test__fixunssfti(0.99, 0);
19	test__fixunssfti(1.0, 1);	19	try test__fixunssfti(1.0, 1);
20	test__fixunssfti(1.5, 1);	20	try test__fixunssfti(1.5, 1);
21	test__fixunssfti(1.99, 1);	21	try test__fixunssfti(1.99, 1);
22	test__fixunssfti(2.0, 2);	22	try test__fixunssfti(2.0, 2);
23	test__fixunssfti(2.01, 2);	23	try test__fixunssfti(2.01, 2);
24	test__fixunssfti(-0.5, 0);	24	try test__fixunssfti(-0.5, 0);
25	test__fixunssfti(-0.99, 0);	25	try test__fixunssfti(-0.99, 0);
26		26
27	test__fixunssfti(-1.0, 0);	27	try test__fixunssfti(-1.0, 0);
28	test__fixunssfti(-1.5, 0);	28	try test__fixunssfti(-1.5, 0);
29	test__fixunssfti(-1.99, 0);	29	try test__fixunssfti(-1.99, 0);
30	test__fixunssfti(-2.0, 0);	30	try test__fixunssfti(-2.0, 0);
31	test__fixunssfti(-2.01, 0);	31	try test__fixunssfti(-2.01, 0);
32		32
33	test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);	33	try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34	test__fixunssfti(0x1.000000p+63, 0x8000000000000000);	34	try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
35	test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);	35	try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36	test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);	36	try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
37	test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);	37	try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
38	test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);	38	try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
39	test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);	39	try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
40	test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);	40	try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
41		41
42	test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);	42	try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
43	test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);	43	try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
44	test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);	44	try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
45	test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);	45	try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
46	}	46	}

lib/std/special/compiler_rt/fixunstfdi_test.zig+41-41

...	@@ -6,49 +6,49 @@	...	@@ -6,49 +6,49 @@
6	const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;	6	const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunstfdi(a: f128, expected: u64) void {	9	fn test__fixunstfdi(a: f128, expected: u64) !void {
10	const x = __fixunstfdi(a);	10	const x = __fixunstfdi(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "fixunstfdi" {	14	test "fixunstfdi" {
15	test__fixunstfdi(0.0, 0);	15	try test__fixunstfdi(0.0, 0);
16		16
17	test__fixunstfdi(0.5, 0);	17	try test__fixunstfdi(0.5, 0);
18	test__fixunstfdi(0.99, 0);	18	try test__fixunstfdi(0.99, 0);
19	test__fixunstfdi(1.0, 1);	19	try test__fixunstfdi(1.0, 1);
20	test__fixunstfdi(1.5, 1);	20	try test__fixunstfdi(1.5, 1);
21	test__fixunstfdi(1.99, 1);	21	try test__fixunstfdi(1.99, 1);
22	test__fixunstfdi(2.0, 2);	22	try test__fixunstfdi(2.0, 2);
23	test__fixunstfdi(2.01, 2);	23	try test__fixunstfdi(2.01, 2);
24	test__fixunstfdi(-0.5, 0);	24	try test__fixunstfdi(-0.5, 0);
25	test__fixunstfdi(-0.99, 0);	25	try test__fixunstfdi(-0.99, 0);
26	test__fixunstfdi(-1.0, 0);	26	try test__fixunstfdi(-1.0, 0);
27	test__fixunstfdi(-1.5, 0);	27	try test__fixunstfdi(-1.5, 0);
28	test__fixunstfdi(-1.99, 0);	28	try test__fixunstfdi(-1.99, 0);
29	test__fixunstfdi(-2.0, 0);	29	try test__fixunstfdi(-2.0, 0);
30	test__fixunstfdi(-2.01, 0);	30	try test__fixunstfdi(-2.01, 0);
31		31
32	test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);	32	try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33	test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);	33	try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
34		34
35	test__fixunstfdi(-0x1.FFFFFEp+62, 0);	35	try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
36	test__fixunstfdi(-0x1.FFFFFCp+62, 0);	36	try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
37		37
38	test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);	38	try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
39	test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);	39	try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
40		40
41	test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);	41	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
42	test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);	42	try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
43		43
44	test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);	44	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
45	test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);	45	try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
46	test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);	46	try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
47	test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);	47	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
48	test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);	48	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
49	test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);	49	try test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);
50		50
51	test__fixunstfdi(-0x1.0000000000000000p+63, 0);	51	try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
52	test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);	52	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
53	test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);	53	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
54	}	54	}

lib/std/special/compiler_rt/fixunstfsi_test.zig+11-11

lib/std/special/compiler_rt/fixunstfti_test.zig+18-18

...	@@ -6,32 +6,32 @@	...	@@ -6,32 +6,32 @@
6	const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;	6	const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__fixunstfti(a: f128, expected: u128) void {	9	fn test__fixunstfti(a: f128, expected: u128) !void {
10	const x = __fixunstfti(a);	10	const x = __fixunstfti(a);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));	14	const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
15		15
16	test "fixunstfti" {	16	test "fixunstfti" {
17	test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);	17	try test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
18		18
19	test__fixunstfti(0.0, 0);	19	try test__fixunstfti(0.0, 0);
20		20
21	test__fixunstfti(0.5, 0);	21	try test__fixunstfti(0.5, 0);
22	test__fixunstfti(0.99, 0);	22	try test__fixunstfti(0.99, 0);
23	test__fixunstfti(1.0, 1);	23	try test__fixunstfti(1.0, 1);
24	test__fixunstfti(1.5, 1);	24	try test__fixunstfti(1.5, 1);
25	test__fixunstfti(1.99, 1);	25	try test__fixunstfti(1.99, 1);
26	test__fixunstfti(2.0, 2);	26	try test__fixunstfti(2.0, 2);
27	test__fixunstfti(2.01, 2);	27	try test__fixunstfti(2.01, 2);
28	test__fixunstfti(-0.01, 0);	28	try test__fixunstfti(-0.01, 0);
29	test__fixunstfti(-0.99, 0);	29	try test__fixunstfti(-0.99, 0);
30		30
31	test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);	31	try test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);
32		32
33	test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);	33	try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
34	test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);	34	try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
35	test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);	35	try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
36	test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);	36	try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
37	}	37	}

lib/std/special/compiler_rt/floatdidf_test.zig+45-45

lib/std/special/compiler_rt/floatdisf_test.zig+24-24

lib/std/special/compiler_rt/floatditf_test.zig+11-11

lib/std/special/compiler_rt/floatsiXf.zig+22-22

lib/std/special/compiler_rt/floattidf_test.zig+60-60

lib/std/special/compiler_rt/floattisf_test.zig+35-35

lib/std/special/compiler_rt/floattitf_test.zig+70-70

lib/std/special/compiler_rt/floatundidf_test.zig+42-42

lib/std/special/compiler_rt/floatundisf.zig+24-24

lib/std/special/compiler_rt/floatunditf_test.zig+9-9

lib/std/special/compiler_rt/floatunsidf.zig+7-7

...	@@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {	...	@@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
28	return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg});	28	return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg});
29	}	29	}
30		30
31	fn test_one_floatunsidf(a: u32, expected: u64) void {	31	fn test_one_floatunsidf(a: u32, expected: u64) !void {
32	const r = __floatunsidf(a);	32	const r = __floatunsidf(a);
33	std.testing.expect(@bitCast(u64, r) == expected);	33	try std.testing.expect(@bitCast(u64, r) == expected);
34	}	34	}
35		35
36	test "floatsidf" {	36	test "floatsidf" {
37	// Test the produced bit pattern	37	// Test the produced bit pattern
38	test_one_floatunsidf(0, 0x0000000000000000);	38	try test_one_floatunsidf(0, 0x0000000000000000);
39	test_one_floatunsidf(1, 0x3ff0000000000000);	39	try test_one_floatunsidf(1, 0x3ff0000000000000);
40	test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);	40	try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
41	test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);	41	try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
42	test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);	42	try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
43	}	43	}

lib/std/special/compiler_rt/floatunsisf.zig+7-7

...	@@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {	...	@@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
48	return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg});	48	return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg});
49	}	49	}
50		50
51	fn test_one_floatunsisf(a: u32, expected: u32) void {	51	fn test_one_floatunsisf(a: u32, expected: u32) !void {
52	const r = __floatunsisf(a);	52	const r = __floatunsisf(a);
53	std.testing.expect(@bitCast(u32, r) == expected);	53	try std.testing.expect(@bitCast(u32, r) == expected);
54	}	54	}
55		55
56	test "floatunsisf" {	56	test "floatunsisf" {
57	// Test the produced bit pattern	57	// Test the produced bit pattern
58	test_one_floatunsisf(0, 0);	58	try test_one_floatunsisf(0, 0);
59	test_one_floatunsisf(1, 0x3f800000);	59	try test_one_floatunsisf(1, 0x3f800000);
60	test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);	60	try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
61	test_one_floatunsisf(0x80000000, 0x4f000000);	61	try test_one_floatunsisf(0x80000000, 0x4f000000);
62	test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);	62	try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
63	}	63	}

lib/std/special/compiler_rt/floatunsitf_test.zig+5-5

...	@@ -5,7 +5,7 @@	...	@@ -5,7 +5,7 @@
5	// and substantial portions of the software.	5	// and substantial portions of the software.
6	const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;	6	const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;
7		7
8	fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {	8	fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) !void {
9	const x = __floatunsitf(a);	9	const x = __floatunsitf(a);
10		10
11	const x_repr = @bitCast(u128, x);	11	const x_repr = @bitCast(u128, x);
...	@@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {	...	@@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {
26	}	26	}
27		27
28	test "floatunsitf" {	28	test "floatunsitf" {
29	test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);	29	try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
30	test__floatunsitf(0, 0x0, 0x0);	30	try test__floatunsitf(0, 0x0, 0x0);
31	test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);	31	try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
32	test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);	32	try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
33	}	33	}

lib/std/special/compiler_rt/floatuntidf_test.zig+57-57

lib/std/special/compiler_rt/floatuntisf_test.zig+44-44

lib/std/special/compiler_rt/floatuntitf_test.zig+72-72

lib/std/special/compiler_rt/int.zig+65-65

lib/std/special/compiler_rt/lshrdi3_test.zig+47-47

lib/std/special/compiler_rt/lshrti3_test.zig+38-38

lib/std/special/compiler_rt/modti3_test.zig+20-20

lib/std/special/compiler_rt/mulXf3_test.zig+9-9

...	@@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {	...	@@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
34	return false;	34	return false;
35	}	35	}
36		36
37	fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {	37	fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
38	const x = __multf3(a, b);	38	const x = __multf3(a, b);
39		39
40	if (compareResultLD(x, expected_hi, expected_lo))	40	if (compareResultLD(x, expected_hi, expected_lo))
...	@@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 {	...	@@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 {
50	}	50	}
51	test "multf3" {	51	test "multf3" {
52	// qNaN * any = qNaN	52	// qNaN * any = qNaN
53	test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	53	try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
54		54
55	// NaN * any = NaN	55	// NaN * any = NaN
56	const a = makeNaN128(0x800030000000);	56	const a = makeNaN128(0x800030000000);
57	test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);	57	try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
58	// inf * any = inf	58	// inf * any = inf
59	test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);	59	try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
60		60
61	// any * any	61	// any * any
62	test__multf3(	62	try test__multf3(
63	@bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),	63	@bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
64	@bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),	64	@bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
65	0x400423e7f9e3c9fc,	65	0x400423e7f9e3c9fc,
66	0xd906c2c2a85777c4,	66	0xd906c2c2a85777c4,
67	);	67	);
68		68
69	test__multf3(	69	try test__multf3(
70	@bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),	70	@bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
71	@bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),	71	@bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
72	0x3fc52a163c6223fc,	72	0x3fc52a163c6223fc,
73	0xc94c4bf0430768b4,	73	0xc94c4bf0430768b4,
74	);	74	);
75		75
76	test__multf3(	76	try test__multf3(
77	0x1.234425696abcad34a35eeffefdcbap+456,	77	0x1.234425696abcad34a35eeffefdcbap+456,
78	0x451.ed98d76e5d46e5f24323dff21ffp+600,	78	0x451.ed98d76e5d46e5f24323dff21ffp+600,
79	0x44293a91de5e0e94,	79	0x44293a91de5e0e94,
80	0xe8ed17cc2cdf64ac,	80	0xe8ed17cc2cdf64ac,
81	);	81	);
82		82
83	test__multf3(	83	try test__multf3(
84	@bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),	84	@bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
85	@bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),	85	@bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
86	0x3d4f37c1a3137cae,	86	0x3d4f37c1a3137cae,
87	0xfc6807048bc2836a,	87	0xfc6807048bc2836a,
88	);	88	);
89		89
90	test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);	90	try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
91	}	91	}

lib/std/special/compiler_rt/muldi3_test.zig+43-43

...	@@ -6,51 +6,51 @@	...	@@ -6,51 +6,51 @@
6	const __muldi3 = @import("muldi3.zig").__muldi3;	6	const __muldi3 = @import("muldi3.zig").__muldi3;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__muldi3(a: i64, b: i64, expected: i64) void {	9	fn test__muldi3(a: i64, b: i64, expected: i64) !void {
10	const x = __muldi3(a, b);	10	const x = __muldi3(a, b);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "muldi3" {	14	test "muldi3" {
15	test__muldi3(0, 0, 0);	15	try test__muldi3(0, 0, 0);
16	test__muldi3(0, 1, 0);	16	try test__muldi3(0, 1, 0);
17	test__muldi3(1, 0, 0);	17	try test__muldi3(1, 0, 0);
18	test__muldi3(0, 10, 0);	18	try test__muldi3(0, 10, 0);
19	test__muldi3(10, 0, 0);	19	try test__muldi3(10, 0, 0);
20	test__muldi3(0, 81985529216486895, 0);	20	try test__muldi3(0, 81985529216486895, 0);
21	test__muldi3(81985529216486895, 0, 0);	21	try test__muldi3(81985529216486895, 0, 0);
22		22
23	test__muldi3(0, -1, 0);	23	try test__muldi3(0, -1, 0);
24	test__muldi3(-1, 0, 0);	24	try test__muldi3(-1, 0, 0);
25	test__muldi3(0, -10, 0);	25	try test__muldi3(0, -10, 0);
26	test__muldi3(-10, 0, 0);	26	try test__muldi3(-10, 0, 0);
27	test__muldi3(0, -81985529216486895, 0);	27	try test__muldi3(0, -81985529216486895, 0);
28	test__muldi3(-81985529216486895, 0, 0);	28	try test__muldi3(-81985529216486895, 0, 0);
29		29
30	test__muldi3(1, 1, 1);	30	try test__muldi3(1, 1, 1);
31	test__muldi3(1, 10, 10);	31	try test__muldi3(1, 10, 10);
32	test__muldi3(10, 1, 10);	32	try test__muldi3(10, 1, 10);
33	test__muldi3(1, 81985529216486895, 81985529216486895);	33	try test__muldi3(1, 81985529216486895, 81985529216486895);
34	test__muldi3(81985529216486895, 1, 81985529216486895);	34	try test__muldi3(81985529216486895, 1, 81985529216486895);
35		35
36	test__muldi3(1, -1, -1);	36	try test__muldi3(1, -1, -1);
37	test__muldi3(1, -10, -10);	37	try test__muldi3(1, -10, -10);
38	test__muldi3(-10, 1, -10);	38	try test__muldi3(-10, 1, -10);
39	test__muldi3(1, -81985529216486895, -81985529216486895);	39	try test__muldi3(1, -81985529216486895, -81985529216486895);
40	test__muldi3(-81985529216486895, 1, -81985529216486895);	40	try test__muldi3(-81985529216486895, 1, -81985529216486895);
41		41
42	test__muldi3(3037000499, 3037000499, 9223372030926249001);	42	try test__muldi3(3037000499, 3037000499, 9223372030926249001);
43	test__muldi3(-3037000499, 3037000499, -9223372030926249001);	43	try test__muldi3(-3037000499, 3037000499, -9223372030926249001);
44	test__muldi3(3037000499, -3037000499, -9223372030926249001);	44	try test__muldi3(3037000499, -3037000499, -9223372030926249001);
45	test__muldi3(-3037000499, -3037000499, 9223372030926249001);	45	try test__muldi3(-3037000499, -3037000499, 9223372030926249001);
46		46
47	test__muldi3(4398046511103, 2097152, 9223372036852678656);	47	try test__muldi3(4398046511103, 2097152, 9223372036852678656);
48	test__muldi3(-4398046511103, 2097152, -9223372036852678656);	48	try test__muldi3(-4398046511103, 2097152, -9223372036852678656);
49	test__muldi3(4398046511103, -2097152, -9223372036852678656);	49	try test__muldi3(4398046511103, -2097152, -9223372036852678656);
50	test__muldi3(-4398046511103, -2097152, 9223372036852678656);	50	try test__muldi3(-4398046511103, -2097152, 9223372036852678656);
51		51
52	test__muldi3(2097152, 4398046511103, 9223372036852678656);	52	try test__muldi3(2097152, 4398046511103, 9223372036852678656);
53	test__muldi3(-2097152, 4398046511103, -9223372036852678656);	53	try test__muldi3(-2097152, 4398046511103, -9223372036852678656);
54	test__muldi3(2097152, -4398046511103, -9223372036852678656);	54	try test__muldi3(2097152, -4398046511103, -9223372036852678656);
55	test__muldi3(-2097152, -4398046511103, 9223372036852678656);	55	try test__muldi3(-2097152, -4398046511103, 9223372036852678656);
56	}	56	}

lib/std/special/compiler_rt/mulodi4_test.zig+67-67

lib/std/special/compiler_rt/muloti4_test.zig+58-58

lib/std/special/compiler_rt/multi3_test.zig+45-45

...	@@ -6,53 +6,53 @@	...	@@ -6,53 +6,53 @@
6	const __multi3 = @import("multi3.zig").__multi3;	6	const __multi3 = @import("multi3.zig").__multi3;
7	const testing = @import("std").testing;	7	const testing = @import("std").testing;
8		8
9	fn test__multi3(a: i128, b: i128, expected: i128) void {	9	fn test__multi3(a: i128, b: i128, expected: i128) !void {
10	const x = __multi3(a, b);	10	const x = __multi3(a, b);
11	testing.expect(x == expected);	11	try testing.expect(x == expected);
12	}	12	}
13		13
14	test "multi3" {	14	test "multi3" {
15	test__multi3(0, 0, 0);	15	try test__multi3(0, 0, 0);
16	test__multi3(0, 1, 0);	16	try test__multi3(0, 1, 0);
17	test__multi3(1, 0, 0);	17	try test__multi3(1, 0, 0);
18	test__multi3(0, 10, 0);	18	try test__multi3(0, 10, 0);
19	test__multi3(10, 0, 0);	19	try test__multi3(10, 0, 0);
20	test__multi3(0, 81985529216486895, 0);	20	try test__multi3(0, 81985529216486895, 0);
21	test__multi3(81985529216486895, 0, 0);	21	try test__multi3(81985529216486895, 0, 0);
22		22
23	test__multi3(0, -1, 0);	23	try test__multi3(0, -1, 0);
24	test__multi3(-1, 0, 0);	24	try test__multi3(-1, 0, 0);
25	test__multi3(0, -10, 0);	25	try test__multi3(0, -10, 0);
26	test__multi3(-10, 0, 0);	26	try test__multi3(-10, 0, 0);
27	test__multi3(0, -81985529216486895, 0);	27	try test__multi3(0, -81985529216486895, 0);
28	test__multi3(-81985529216486895, 0, 0);	28	try test__multi3(-81985529216486895, 0, 0);
29		29
30	test__multi3(1, 1, 1);	30	try test__multi3(1, 1, 1);
31	test__multi3(1, 10, 10);	31	try test__multi3(1, 10, 10);
32	test__multi3(10, 1, 10);	32	try test__multi3(10, 1, 10);
33	test__multi3(1, 81985529216486895, 81985529216486895);	33	try test__multi3(1, 81985529216486895, 81985529216486895);
34	test__multi3(81985529216486895, 1, 81985529216486895);	34	try test__multi3(81985529216486895, 1, 81985529216486895);
35		35
36	test__multi3(1, -1, -1);	36	try test__multi3(1, -1, -1);
37	test__multi3(1, -10, -10);	37	try test__multi3(1, -10, -10);
38	test__multi3(-10, 1, -10);	38	try test__multi3(-10, 1, -10);
39	test__multi3(1, -81985529216486895, -81985529216486895);	39	try test__multi3(1, -81985529216486895, -81985529216486895);
40	test__multi3(-81985529216486895, 1, -81985529216486895);	40	try test__multi3(-81985529216486895, 1, -81985529216486895);
41		41
42	test__multi3(3037000499, 3037000499, 9223372030926249001);	42	try test__multi3(3037000499, 3037000499, 9223372030926249001);
43	test__multi3(-3037000499, 3037000499, -9223372030926249001);	43	try test__multi3(-3037000499, 3037000499, -9223372030926249001);
44	test__multi3(3037000499, -3037000499, -9223372030926249001);	44	try test__multi3(3037000499, -3037000499, -9223372030926249001);
45	test__multi3(-3037000499, -3037000499, 9223372030926249001);	45	try test__multi3(-3037000499, -3037000499, 9223372030926249001);
46		46
47	test__multi3(4398046511103, 2097152, 9223372036852678656);	47	try test__multi3(4398046511103, 2097152, 9223372036852678656);
48	test__multi3(-4398046511103, 2097152, -9223372036852678656);	48	try test__multi3(-4398046511103, 2097152, -9223372036852678656);
49	test__multi3(4398046511103, -2097152, -9223372036852678656);	49	try test__multi3(4398046511103, -2097152, -9223372036852678656);
50	test__multi3(-4398046511103, -2097152, 9223372036852678656);	50	try test__multi3(-4398046511103, -2097152, 9223372036852678656);
51		51
52	test__multi3(2097152, 4398046511103, 9223372036852678656);	52	try test__multi3(2097152, 4398046511103, 9223372036852678656);
53	test__multi3(-2097152, 4398046511103, -9223372036852678656);	53	try test__multi3(-2097152, 4398046511103, -9223372036852678656);
54	test__multi3(2097152, -4398046511103, -9223372036852678656);	54	try test__multi3(2097152, -4398046511103, -9223372036852678656);
55	test__multi3(-2097152, -4398046511103, 9223372036852678656);	55	try test__multi3(-2097152, -4398046511103, 9223372036852678656);
56		56
57	test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);	57	try test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);
58	}	58	}

lib/std/special/compiler_rt/popcountdi2_test.zig+8-8

...	@@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 {	...	@@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 {
15	return r;	15	return r;
16	}	16	}
17		17
18	fn test__popcountdi2(a: i64) void {	18	fn test__popcountdi2(a: i64) !void {
19	const x = __popcountdi2(a);	19	const x = __popcountdi2(a);
20	const expected = naive_popcount(a);	20	const expected = naive_popcount(a);
21	testing.expect(expected == x);	21	try testing.expect(expected == x);
22	}	22	}
23		23
24	test "popcountdi2" {	24	test "popcountdi2" {
25	test__popcountdi2(0);	25	try test__popcountdi2(0);
26	test__popcountdi2(1);	26	try test__popcountdi2(1);
27	test__popcountdi2(2);	27	try test__popcountdi2(2);
28	test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));	28	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));
29	test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));	29	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));
30	test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));	30	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));
31	// TODO some fuzz testing	31	// TODO some fuzz testing
32	}	32	}

lib/std/special/compiler_rt/truncXfYf2_test.zig+36-36

lib/std/special/compiler_rt/udivmoddi4_test.zig+4-4

...	@@ -8,16 +8,16 @@	...	@@ -8,16 +8,16 @@
8	const __udivmoddi4 = @import("int.zig").__udivmoddi4;	8	const __udivmoddi4 = @import("int.zig").__udivmoddi4;
9	const testing = @import("std").testing;	9	const testing = @import("std").testing;
10		10
11	fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {	11	fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) !void {
12	var r: u64 = undefined;	12	var r: u64 = undefined;
13	const q = __udivmoddi4(a, b, &r);	13	const q = __udivmoddi4(a, b, &r);
14	testing.expect(q == expected_q);	14	try testing.expect(q == expected_q);
15	testing.expect(r == expected_r);	15	try testing.expect(r == expected_r);
16	}	16	}
17		17
18	test "udivmoddi4" {	18	test "udivmoddi4" {
19	for (cases) \|case\| {	19	for (cases) \|case\| {
20	test__udivmoddi4(case[0], case[1], case[2], case[3]);	20	try test__udivmoddi4(case[0], case[1], case[2], case[3]);
21	}	21	}
22	}	22	}
23		23

lib/std/special/compiler_rt/udivmodti4_test.zig+4-4

...	@@ -8,16 +8,16 @@	...	@@ -8,16 +8,16 @@
8	const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;	8	const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
9	const testing = @import("std").testing;	9	const testing = @import("std").testing;
10		10
11	fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {	11	fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) !void {
12	var r: u128 = undefined;	12	var r: u128 = undefined;
13	const q = __udivmodti4(a, b, &r);	13	const q = __udivmodti4(a, b, &r);
14	testing.expect(q == expected_q);	14	try testing.expect(q == expected_q);
15	testing.expect(r == expected_r);	15	try testing.expect(r == expected_r);
16	}	16	}
17		17
18	test "udivmodti4" {	18	test "udivmodti4" {
19	for (cases) \|case\| {	19	for (cases) \|case\| {
20	test__udivmodti4(case[0], case[1], case[2], case[3]);	20	try test__udivmodti4(case[0], case[1], case[2], case[3]);
21	}	21	}
22	}	22	}
23		23

lib/std/special/init-lib/src/main.zig+1-1

...	@@ -6,5 +6,5 @@ export fn add(a: i32, b: i32) i32 {	...	@@ -6,5 +6,5 @@ export fn add(a: i32, b: i32) i32 {
6	}	6	}
7		7
8	test "basic add functionality" {	8	test "basic add functionality" {
9	testing.expect(add(3, 7) == 10);	9	try testing.expect(add(3, 7) == 10);
10	}	10	}

lib/std/special/test_runner.zig+9-6

...	@@ -23,6 +23,7 @@ pub fn main() anyerror!void {	...	@@ -23,6 +23,7 @@ pub fn main() anyerror!void {
23	const test_fn_list = builtin.test_functions;	23	const test_fn_list = builtin.test_functions;
24	var ok_count: usize = 0;	24	var ok_count: usize = 0;
25	var skip_count: usize = 0;	25	var skip_count: usize = 0;
		26	var fail_count: usize = 0;
26	var progress = std.Progress{};	27	var progress = std.Progress{};
27	const root_node = progress.start("Test", test_fn_list.len) catch \|err\| switch (err) {	28	const root_node = progress.start("Test", test_fn_list.len) catch \|err\| switch (err) {
28	// TODO still run tests in this case	29	// TODO still run tests in this case
...	@@ -62,7 +63,7 @@ pub fn main() anyerror!void {	...	@@ -62,7 +63,7 @@ pub fn main() anyerror!void {
62	.blocking => {	63	.blocking => {
63	skip_count += 1;	64	skip_count += 1;
64	test_node.end();	65	test_node.end();
65	progress.log("{s}...SKIP (async test)\n", .{test_fn.name});	66	progress.log("{s}... SKIP (async test)\n", .{test_fn.name});
66	if (progress.terminal == null) std.debug.print("SKIP (async test)\n", .{});	67	if (progress.terminal == null) std.debug.print("SKIP (async test)\n", .{});
67	continue;	68	continue;
68	},	69	},
...	@@ -75,12 +76,14 @@ pub fn main() anyerror!void {	...	@@ -75,12 +76,14 @@ pub fn main() anyerror!void {
75	error.SkipZigTest => {	76	error.SkipZigTest => {
76	skip_count += 1;	77	skip_count += 1;
77	test_node.end();	78	test_node.end();
78	progress.log("{s}...SKIP\n", .{test_fn.name});	79	progress.log("{s}... SKIP\n", .{test_fn.name});
79	if (progress.terminal == null) std.debug.print("SKIP\n", .{});	80	if (progress.terminal == null) std.debug.print("SKIP\n", .{});
80	},	81	},
81	else => {	82	else => {
82	progress.log("", .{});	83	fail_count += 1;
83	return err;	84	test_node.end();
		85	progress.log("{s}... FAIL ({s})\n", .{ test_fn.name, @errorName(err) });
		86	if (progress.terminal == null) std.debug.print("FAIL ({s})\n", .{@errorName(err)});
84	},	87	},
85	}	88	}
86	}	89	}
...	@@ -88,7 +91,7 @@ pub fn main() anyerror!void {	...	@@ -88,7 +91,7 @@ pub fn main() anyerror!void {
88	if (ok_count == test_fn_list.len) {	91	if (ok_count == test_fn_list.len) {
89	std.debug.print("All {d} tests passed.\n", .{ok_count});	92	std.debug.print("All {d} tests passed.\n", .{ok_count});
90	} else {	93	} else {
91	std.debug.print("{d} passed; {d} skipped.\n", .{ ok_count, skip_count });	94	std.debug.print("{d} passed; {d} skipped; {d} failed.\n", .{ ok_count, skip_count, fail_count });
92	}	95	}
93	if (log_err_count != 0) {	96	if (log_err_count != 0) {
94	std.debug.print("{d} errors were logged.\n", .{log_err_count});	97	std.debug.print("{d} errors were logged.\n", .{log_err_count});
...	@@ -96,7 +99,7 @@ pub fn main() anyerror!void {	...	@@ -96,7 +99,7 @@ pub fn main() anyerror!void {
96	if (leaks != 0) {	99	if (leaks != 0) {
97	std.debug.print("{d} tests leaked memory.\n", .{leaks});	100	std.debug.print("{d} tests leaked memory.\n", .{leaks});
98	}	101	}
99	if (leaks != 0 or log_err_count != 0) {	102	if (leaks != 0 or log_err_count != 0 or fail_count != 0) {
100	std.process.exit(1);	103	std.process.exit(1);
101	}	104	}
102	}	105	}

lib/std/testing.zig+63-45

 @@ -27,15 +27,17 @@ pub var zig_exe_path: []const u8 = undefined;
 /// This function is intended to be used only in tests. It prints diagnostics to stderr
 /// and then aborts when actual_error_union is not expected_error.
-pub fn expectError(expected_error: anyerror, actual_error_union: anytype) void {
+pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
     if (actual_error_union) |actual_payload| {
-        std.debug.panic("expected error.{s}, found {any}", .{ @errorName(expected_error), actual_payload });
+        std.debug.print("expected error.{s}, found {any}", .{ @errorName(expected_error), actual_payload });
+        return error.TestUnexpectedError;
     } else |actual_error| {
         if (expected_error != actual_error) {
-            std.debug.panic("expected error.{s}, found error.{s}", .{
+            std.debug.print("expected error.{s}, found error.{s}", .{
                 @errorName(expected_error),
                 @errorName(actual_error),
             });
+            return error.TestExpectedError;
         }
     }
 }
 @@ -44,7 +46,7 @@ pub fn expectError(expected_error: anyerror, actual_error_union: anytype) void {
 /// equal, prints diagnostics to stderr to show exactly how they are not equal,
 /// then aborts.
 /// `actual` is casted to the type of `expected`.
-pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
+pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
     switch (@typeInfo(@TypeOf(actual))) {
         .NoReturn,
         .BoundFn,
 @@ -60,7 +62,8 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
         .Type => {
             if (actual != expected) {
-                std.debug.panic("expected type {s}, found type {s}", .{ @typeName(expected), @typeName(actual) });
+                std.debug.print("expected type {s}, found type {s}", .{ @typeName(expected), @typeName(actual) });
+                return error.TestExpectedEqual;
             }
         },
 @@ -75,7 +78,8 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
         .ErrorSet,
         => {
             if (actual != expected) {
-                std.debug.panic("expected {}, found {}", .{ expected, actual });
+                std.debug.print("expected {}, found {}", .{ expected, actual });
+                return error.TestExpectedEqual;
             }
         },
 @@ -83,34 +87,38 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
             switch (pointer.size) {
                 .One, .Many, .C => {
                     if (actual != expected) {
-                        std.debug.panic("expected {*}, found {*}", .{ expected, actual });
+                        std.debug.print("expected {*}, found {*}", .{ expected, actual });
+                        return error.TestExpectedEqual;
                     }
                 },
                 .Slice => {
                     if (actual.ptr != expected.ptr) {
-                        std.debug.panic("expected slice ptr {*}, found {*}", .{ expected.ptr, actual.ptr });
+                        std.debug.print("expected slice ptr {*}, found {*}", .{ expected.ptr, actual.ptr });
+                        return error.TestExpectedEqual;
                     }
                     if (actual.len != expected.len) {
-                        std.debug.panic("expected slice len {}, found {}", .{ expected.len, actual.len });
+                        std.debug.print("expected slice len {}, found {}", .{ expected.len, actual.len });
+                        return error.TestExpectedEqual;
                     }
                 },
             }
         },
-        .Array => |array| expectEqualSlices(array.child, &expected, &actual),
+        .Array => |array| try expectEqualSlices(array.child, &expected, &actual),
         .Vector => |vectorType| {
             var i: usize = 0;
             while (i < vectorType.len) : (i += 1) {
                 if (!std.meta.eql(expected[i], actual[i])) {
-                    std.debug.panic("index {} incorrect. expected {}, found {}", .{ i, expected[i], actual[i] });
+                    std.debug.print("index {} incorrect. expected {}, found {}", .{ i, expected[i], actual[i] });
+                    return error.TestExpectedEqual;
                 }
             }
         },
         .Struct => |structType| {
             inline for (structType.fields) |field| {
-                expectEqual(@field(expected, field.name), @field(actual, field.name));
+                try expectEqual(@field(expected, field.name), @field(actual, field.name));
             }
         },
 @@ -124,12 +132,12 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
             const expectedTag = @as(Tag, expected);
             const actualTag = @as(Tag, actual);
-            expectEqual(expectedTag, actualTag);
+            try expectEqual(expectedTag, actualTag);
             // we only reach this loop if the tags are equal
             inline for (std.meta.fields(@TypeOf(actual))) |fld| {
                 if (std.mem.eql(u8, fld.name, @tagName(actualTag))) {
-                    expectEqual(@field(expected, fld.name), @field(actual, fld.name));
+                    try expectEqual(@field(expected, fld.name), @field(actual, fld.name));
                     return;
                 }
             }
 @@ -143,13 +151,15 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
         .Optional => {
             if (expected) |expected_payload| {
                 if (actual) |actual_payload| {
-                    expectEqual(expected_payload, actual_payload);
+                    try expectEqual(expected_payload, actual_payload);
                 } else {
-                    std.debug.panic("expected {any}, found null", .{expected_payload});
+                    std.debug.print("expected {any}, found null", .{expected_payload});
+                    return error.TestExpectedEqual;
                 }
             } else {
                 if (actual) |actual_payload| {
-                    std.debug.panic("expected null, found {any}", .{actual_payload});
+                    std.debug.print("expected null, found {any}", .{actual_payload});
+                    return error.TestExpectedEqual;
                 }
             }
         },
 @@ -157,15 +167,17 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
         .ErrorUnion => {
             if (expected) |expected_payload| {
                 if (actual) |actual_payload| {
-                    expectEqual(expected_payload, actual_payload);
+                    try expectEqual(expected_payload, actual_payload);
                 } else |actual_err| {
-                    std.debug.panic("expected {any}, found {}", .{ expected_payload, actual_err });
+                    std.debug.print("expected {any}, found {}", .{ expected_payload, actual_err });
+                    return error.TestExpectedEqual;
                 }
             } else |expected_err| {
                 if (actual) |actual_payload| {
-                    std.debug.panic("expected {}, found {any}", .{ expected_err, actual_payload });
+                    std.debug.print("expected {}, found {any}", .{ expected_err, actual_payload });
+                    return error.TestExpectedEqual;
                 } else |actual_err| {
-                    expectEqual(expected_err, actual_err);
+                    try expectEqual(expected_err, actual_err);
                 }
             }
         },
 @@ -181,7 +193,7 @@ test "expectEqual.union(enum)" {
     const a10 = T{ .a = 10 };
     const a20 = T{ .a = 20 };
-    expectEqual(a10, a10);
+    try expectEqual(a10, a10);
 }
 /// This function is intended to be used only in tests. When the formatted result of the template
 @@ -197,7 +209,7 @@ pub fn expectFmt(expected: []const u8, comptime template: []const u8, args: anyt
     print("\n======== instead found this: =========\n", .{});
     print("{s}", .{result});
     print("\n======================================\n", .{});
-    return error.TestFailed;
+    return error.TestExpectedFmt;
 }
 pub const expectWithinMargin = @compileError("expectWithinMargin is deprecated, use expectApproxEqAbs or expectApproxEqRel");
 @@ -208,12 +220,14 @@ pub const expectWithinEpsilon = @compileError("expectWithinEpsilon is deprecated
 /// to show exactly how they are not equal, then aborts.
 /// See `math.approxEqAbs` for more informations on the tolerance parameter.
 /// The types must be floating point
-pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) void {
+pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
     const T = @TypeOf(expected);
     switch (@typeInfo(T)) {
-        .Float => if (!math.approxEqAbs(T, expected, actual, tolerance))
+        .Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
-            std.debug.panic("actual {}, not within absolute tolerance {} of expected {}", .{ actual, tolerance, expected }),
+            std.debug.print("actual {}, not within absolute tolerance {} of expected {}", .{ actual, tolerance, expected });
+            return error.TestExpectedApproxEqAbs;
+        },
         .ComptimeFloat => @compileError("Cannot approximately compare two comptime_float values"),
 @@ -228,8 +242,8 @@ test "expectApproxEqAbs" {
         const neg_x: T = -12.0;
         const neg_y: T = -12.06;
-        expectApproxEqAbs(pos_x, pos_y, 0.1);
+        try expectApproxEqAbs(pos_x, pos_y, 0.1);
-        expectApproxEqAbs(neg_x, neg_y, 0.1);
+        try expectApproxEqAbs(neg_x, neg_y, 0.1);
     }
 }
 @@ -238,12 +252,14 @@ test "expectApproxEqAbs" {
 /// to show exactly how they are not equal, then aborts.
 /// See `math.approxEqRel` for more informations on the tolerance parameter.
 /// The types must be floating point
-pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) void {
+pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
     const T = @TypeOf(expected);
     switch (@typeInfo(T)) {
-        .Float => if (!math.approxEqRel(T, expected, actual, tolerance))
+        .Float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
-            std.debug.panic("actual {}, not within relative tolerance {} of expected {}", .{ actual, tolerance, expected }),
+            std.debug.print("actual {}, not within relative tolerance {} of expected {}", .{ actual, tolerance, expected });
+            return error.TestExpectedApproxEqRel;
+        },
         .ComptimeFloat => @compileError("Cannot approximately compare two comptime_float values"),
 @@ -261,8 +277,8 @@ test "expectApproxEqRel" {
         const neg_x: T = -12.0;
         const neg_y: T = neg_x - 2 * eps_value;
-        expectApproxEqRel(pos_x, pos_y, sqrt_eps_value);
+        try expectApproxEqRel(pos_x, pos_y, sqrt_eps_value);
-        expectApproxEqRel(neg_x, neg_y, sqrt_eps_value);
+        try expectApproxEqRel(neg_x, neg_y, sqrt_eps_value);
     }
 }
 @@ -270,26 +286,28 @@ test "expectApproxEqRel" {
 /// equal, prints diagnostics to stderr to show exactly how they are not equal,
 /// then aborts.
 /// If your inputs are UTF-8 encoded strings, consider calling `expectEqualStrings` instead.
-pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const T) void {
+pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const T) !void {
     // TODO better printing of the difference
     // If the arrays are small enough we could print the whole thing
     // If the child type is u8 and no weird bytes, we could print it as strings
     // Even for the length difference, it would be useful to see the values of the slices probably.
     if (expected.len != actual.len) {
-        std.debug.panic("slice lengths differ. expected {d}, found {d}", .{ expected.len, actual.len });
+        std.debug.print("slice lengths differ. expected {d}, found {d}", .{ expected.len, actual.len });
+        return error.TestExpectedEqual;
     }
     var i: usize = 0;
     while (i < expected.len) : (i += 1) {
         if (!std.meta.eql(expected[i], actual[i])) {
-            std.debug.panic("index {} incorrect. expected {any}, found {any}", .{ i, expected[i], actual[i] });
+            std.debug.print("index {} incorrect. expected {any}, found {any}", .{ i, expected[i], actual[i] });
+            return error.TestExpectedEqual;
         }
     }
 }
 /// This function is intended to be used only in tests. When `ok` is false, the test fails.
 /// A message is printed to stderr and then abort is called.
-pub fn expect(ok: bool) void {
+pub fn expect(ok: bool) !void {
-    if (!ok) @panic("test failure");
+    if (!ok) return error.TestUnexpectedResult;
 }
 pub const TmpDir = struct {
 @@ -356,17 +374,17 @@ test "expectEqual nested array" {
         [_]f32{ 0.0, 1.0 },
     };
-    expectEqual(a, b);
+    try expectEqual(a, b);
 }
 test "expectEqual vector" {
     var a = @splat(4, @as(u32, 4));
     var b = @splat(4, @as(u32, 4));
-    expectEqual(a, b);
+    try expectEqual(a, b);
 }
-pub fn expectEqualStrings(expected: []const u8, actual: []const u8) void {
+pub fn expectEqualStrings(expected: []const u8, actual: []const u8) !void {
     if (std.mem.indexOfDiff(u8, actual, expected)) |diff_index| {
         print("\n====== expected this output: =========\n", .{});
         printWithVisibleNewlines(expected);
 @@ -386,11 +404,11 @@ pub fn expectEqualStrings(expected: []const u8, actual: []const u8) void {
         print("found:\n", .{});
         printIndicatorLine(actual, diff_index);
-        @panic("test failure");
+        return error.TestExpectedEqual;
     }
 }
-pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8) void {
+pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8) !void {
     if (std.mem.endsWith(u8, actual, expected_ends_with))
         return;
 @@ -407,7 +425,7 @@ pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8)
     printWithVisibleNewlines(actual);
     print("\n======================================\n", .{});
-    @panic("test failure");
+    return error.TestExpectedEndsWith;
 }
 fn printIndicatorLine(source: []const u8, indicator_index: usize) void {
 @@ -446,7 +464,7 @@ fn printLine(line: []const u8) void {
 }
 test {
-    expectEqualStrings("foo", "foo");
+    try expectEqualStrings("foo", "foo");
 }
 /// Given a type, reference all the declarations inside, so that the semantic analyzer sees them.

lib/std/time.zig+4-4

lib/std/unicode.zig+172-172

lib/std/valgrind/memcheck.zig+2-2

...	@@ -149,7 +149,7 @@ pub fn countLeaks() CountResult {	...	@@ -149,7 +149,7 @@ pub fn countLeaks() CountResult {
149	}	149	}
150		150
151	test "countLeaks" {	151	test "countLeaks" {
152	testing.expectEqual(	152	try testing.expectEqual(
153	@as(CountResult, .{	153	@as(CountResult, .{
154	.leaked = 0,	154	.leaked = 0,
155	.dubious = 0,	155	.dubious = 0,
...	@@ -179,7 +179,7 @@ pub fn countLeakBlocks() CountResult {	...	@@ -179,7 +179,7 @@ pub fn countLeakBlocks() CountResult {
179	}	179	}
180		180
181	test "countLeakBlocks" {	181	test "countLeakBlocks" {
182	testing.expectEqual(	182	try testing.expectEqual(
183	@as(CountResult, .{	183	@as(CountResult, .{
184	.leaked = 0,	184	.leaked = 0,
185	.dubious = 0,	185	.dubious = 0,

lib/std/wasm.zig+9-9

lib/std/x/net/tcp.zig+3-3

...	@@ -322,7 +322,7 @@ test "tcp/client: set read timeout of 1 millisecond on blocking client" {	...	@@ -322,7 +322,7 @@ test "tcp/client: set read timeout of 1 millisecond on blocking client" {
322	defer conn.deinit();	322	defer conn.deinit();
323		323
324	var buf: [1]u8 = undefined;	324	var buf: [1]u8 = undefined;
325	testing.expectError(error.WouldBlock, client.read(&buf));	325	try testing.expectError(error.WouldBlock, client.read(&buf));
326	}	326	}
327		327
328	test "tcp/listener: bind to unspecified ipv4 address" {	328	test "tcp/listener: bind to unspecified ipv4 address" {
...	@@ -335,7 +335,7 @@ test "tcp/listener: bind to unspecified ipv4 address" {	...	@@ -335,7 +335,7 @@ test "tcp/listener: bind to unspecified ipv4 address" {
335	try listener.listen(128);	335	try listener.listen(128);
336		336
337	const address = try listener.getLocalAddress();	337	const address = try listener.getLocalAddress();
338	testing.expect(address == .ipv4);	338	try testing.expect(address == .ipv4);
339	}	339	}
340		340
341	test "tcp/listener: bind to unspecified ipv6 address" {	341	test "tcp/listener: bind to unspecified ipv6 address" {
...	@@ -348,5 +348,5 @@ test "tcp/listener: bind to unspecified ipv6 address" {	...	@@ -348,5 +348,5 @@ test "tcp/listener: bind to unspecified ipv6 address" {
348	try listener.listen(128);	348	try listener.listen(128);
349		349
350	const address = try listener.getLocalAddress();	350	const address = try listener.getLocalAddress();
351	testing.expect(address == .ipv6);	351	try testing.expect(address == .ipv6);
352	}	352	}

lib/std/x/os/net.zig+3-3

...	@@ -499,12 +499,12 @@ test {	...	@@ -499,12 +499,12 @@ test {
499		499
500	test "ip: convert to and from ipv6" {	500	test "ip: convert to and from ipv6" {
501	try testing.expectFmt("::7f00:1", "{}", .{IPv4.localhost.toIPv6()});	501	try testing.expectFmt("::7f00:1", "{}", .{IPv4.localhost.toIPv6()});
502	testing.expect(!IPv4.localhost.toIPv6().mapsToIPv4());	502	try testing.expect(!IPv4.localhost.toIPv6().mapsToIPv4());
503		503
504	try testing.expectFmt("::ffff:127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6()});	504	try testing.expectFmt("::ffff:127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6()});
505	testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4());	505	try testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4());
506		506
507	testing.expect(IPv4.localhost.toIPv6().toIPv4() == null);	507	try testing.expect(IPv4.localhost.toIPv6().toIPv4() == null);
508	try testing.expectFmt("127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6().toIPv4()});	508	try testing.expectFmt("127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6().toIPv4()});
509	}	509	}
510		510

lib/std/zig.zig+19-19

lib/std/zig/cross_target.zig+38-38

lib/std/zig/parser_test.zig+9-10

lib/std/zig/string_literal.zig+3-3

...	@@ -153,7 +153,7 @@ test "parse" {	...	@@ -153,7 +153,7 @@ test "parse" {
153	var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(fixed_buf_mem[0..]);	153	var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(fixed_buf_mem[0..]);
154	var alloc = &fixed_buf_alloc.allocator;	154	var alloc = &fixed_buf_alloc.allocator;
155		155
156	expect(eql(u8, "foo", try parseAlloc(alloc, "\"foo\"")));	156	try expect(eql(u8, "foo", try parseAlloc(alloc, "\"foo\"")));
157	expect(eql(u8, "foo", try parseAlloc(alloc, "\"f\x6f\x6f\"")));	157	try expect(eql(u8, "foo", try parseAlloc(alloc, "\"f\x6f\x6f\"")));
158	expect(eql(u8, "f💯", try parseAlloc(alloc, "\"f\u{1f4af}\"")));	158	try expect(eql(u8, "f💯", try parseAlloc(alloc, "\"f\u{1f4af}\"")));
159	}	159	}

lib/std/zig/system/linux.zig+2-2

...	@@ -414,8 +414,8 @@ fn testParser(	...	@@ -414,8 +414,8 @@ fn testParser(
414	) !void {	414	) !void {
415	var fbs = io.fixedBufferStream(input);	415	var fbs = io.fixedBufferStream(input);
416	const result = try parser.parse(arch, fbs.reader());	416	const result = try parser.parse(arch, fbs.reader());
417	testing.expectEqual(expected_model, result.?.model);	417	try testing.expectEqual(expected_model, result.?.model);
418	testing.expect(expected_model.features.eql(result.?.features));	418	try testing.expect(expected_model.features.eql(result.?.features));
419	}	419	}
420		420
421	// The generic implementation of a /proc/cpuinfo parser.	421	// The generic implementation of a /proc/cpuinfo parser.

lib/std/zig/system/macos.zig+1-1

...	@@ -402,7 +402,7 @@ fn testVersionEquality(expected: std.builtin.Version, got: std.builtin.Version)	...	@@ -402,7 +402,7 @@ fn testVersionEquality(expected: std.builtin.Version, got: std.builtin.Version)
402	var b_got: [64]u8 = undefined;	402	var b_got: [64]u8 = undefined;
403	const s_got: []const u8 = try std.fmt.bufPrint(b_got[0..], "{}", .{got});	403	const s_got: []const u8 = try std.fmt.bufPrint(b_got[0..], "{}", .{got});
404		404
405	testing.expectEqualStrings(s_expected, s_got);	405	try testing.expectEqualStrings(s_expected, s_got);
406	}	406	}
407		407
408	/// Detect SDK path on Darwin.	408	/// Detect SDK path on Darwin.

lib/std/zig/tokenizer.zig+294-294

src/Cache.zig+18-18

src/Compilation.zig+8-8

...	@@ -2852,14 +2852,14 @@ pub fn classifyFileExt(filename: []const u8) FileExt {	...	@@ -2852,14 +2852,14 @@ pub fn classifyFileExt(filename: []const u8) FileExt {
2852	}	2852	}
2853		2853
2854	test "classifyFileExt" {	2854	test "classifyFileExt" {
2855	std.testing.expectEqual(FileExt.cpp, classifyFileExt("foo.cc"));	2855	try std.testing.expectEqual(FileExt.cpp, classifyFileExt("foo.cc"));
2856	std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.nim"));	2856	try std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.nim"));
2857	std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so"));	2857	try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so"));
2858	std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1"));	2858	try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1"));
2859	std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2"));	2859	try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2"));
2860	std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2.3"));	2860	try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2.3"));
2861	std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.so.1.2.3~"));	2861	try std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.so.1.2.3~"));
2862	std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));	2862	try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));
2863	}	2863	}
2864		2864
2865	fn haveFramePointer(comp: *const Compilation) bool {	2865	fn haveFramePointer(comp: *const Compilation) bool {

src/DepTokenizer.zig+2-2

...	@@ -918,7 +918,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void {	...	@@ -918,7 +918,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void {
918	}	918	}
919		919
920	if (std.mem.eql(u8, expect, buffer.items)) {	920	if (std.mem.eql(u8, expect, buffer.items)) {
921	testing.expect(true);	921	try testing.expect(true);
922	return;	922	return;
923	}	923	}
924		924
...	@@ -930,7 +930,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void {	...	@@ -930,7 +930,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void {
930	try printSection(out, ">>>> got", buffer.items);	930	try printSection(out, ">>>> got", buffer.items);
931	try printRuler(out);	931	try printRuler(out);
932		932
933	testing.expect(false);	933	try testing.expect(false);
934	}	934	}
935		935
936	fn printSection(out: anytype, label: []const u8, bytes: []const u8) !void {	936	fn printSection(out: anytype, label: []const u8, bytes: []const u8) !void {

src/codegen/aarch64.zig+34-34

src/codegen/arm.zig+12-12

src/codegen/riscv64.zig+1-1

...	@@ -465,6 +465,6 @@ test "serialize instructions" {	...	@@ -465,6 +465,6 @@ test "serialize instructions" {
465		465
466	for (testcases) \|case\| {	466	for (testcases) \|case\| {
467	const actual = case.inst.toU32();	467	const actual = case.inst.toU32();
468	testing.expectEqual(case.expected, actual);	468	try testing.expectEqual(case.expected, actual);
469	}	469	}
470	}	470	}

src/codegen/wasm.zig+5-5

...	@@ -463,11 +463,11 @@ test "Wasm - buildOpcode" {	...	@@ -463,11 +463,11 @@ test "Wasm - buildOpcode" {
463	const i64_extend32_s = buildOpcode(.{ .op = .extend, .valtype1 = .i64, .width = 32, .signedness = .signed });	463	const i64_extend32_s = buildOpcode(.{ .op = .extend, .valtype1 = .i64, .width = 32, .signedness = .signed });
464	const f64_reinterpret_i64 = buildOpcode(.{ .op = .reinterpret, .valtype1 = .f64, .valtype2 = .i64 });	464	const f64_reinterpret_i64 = buildOpcode(.{ .op = .reinterpret, .valtype1 = .f64, .valtype2 = .i64 });
465		465
466	testing.expectEqual(@as(wasm.Opcode, .i32_const), i32_const);	466	try testing.expectEqual(@as(wasm.Opcode, .i32_const), i32_const);
467	testing.expectEqual(@as(wasm.Opcode, .end), end);	467	try testing.expectEqual(@as(wasm.Opcode, .end), end);
468	testing.expectEqual(@as(wasm.Opcode, .local_get), local_get);	468	try testing.expectEqual(@as(wasm.Opcode, .local_get), local_get);
469	testing.expectEqual(@as(wasm.Opcode, .i64_extend32_s), i64_extend32_s);	469	try testing.expectEqual(@as(wasm.Opcode, .i64_extend32_s), i64_extend32_s);
470	testing.expectEqual(@as(wasm.Opcode, .f64_reinterpret_i64), f64_reinterpret_i64);	470	try testing.expectEqual(@as(wasm.Opcode, .f64_reinterpret_i64), f64_reinterpret_i64);
471	}	471	}
472		472
473	pub const Result = union(enum) {	473	pub const Result = union(enum) {

src/link/MachO/CodeSignature.zig+1-1

...	@@ -182,7 +182,7 @@ test "CodeSignature header" {	...	@@ -182,7 +182,7 @@ test "CodeSignature header" {
182	try code_sig.writeHeader(stream.writer());	182	try code_sig.writeHeader(stream.writer());
183		183
184	const expected = &[_]u8{ 0xfa, 0xde, 0x0c, 0xc0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0 };	184	const expected = &[_]u8{ 0xfa, 0xde, 0x0c, 0xc0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0 };
185	testing.expect(mem.eql(u8, expected, &buffer));	185	try testing.expect(mem.eql(u8, expected, &buffer));
186	}	186	}
187		187
188	pub fn calcCodeSignaturePaddingSize(id: []const u8, file_size: u64, page_size: u16) u32 {	188	pub fn calcCodeSignaturePaddingSize(id: []const u8, file_size: u64, page_size: u16) u32 {

src/link/MachO/Trie.zig+26-26

src/link/MachO/commands.zig+2-2

...	@@ -286,13 +286,13 @@ fn testRead(allocator: *Allocator, buffer: []const u8, expected: anytype) !void	...	@@ -286,13 +286,13 @@ fn testRead(allocator: *Allocator, buffer: []const u8, expected: anytype) !void
286	var stream = io.fixedBufferStream(buffer);	286	var stream = io.fixedBufferStream(buffer);
287	var given = try LoadCommand.read(allocator, stream.reader());	287	var given = try LoadCommand.read(allocator, stream.reader());
288	defer given.deinit(allocator);	288	defer given.deinit(allocator);
289	testing.expect(expected.eql(given));	289	try testing.expect(expected.eql(given));
290	}	290	}
291		291
292	fn testWrite(buffer: []u8, cmd: LoadCommand, expected: []const u8) !void {	292	fn testWrite(buffer: []u8, cmd: LoadCommand, expected: []const u8) !void {
293	var stream = io.fixedBufferStream(buffer);	293	var stream = io.fixedBufferStream(buffer);
294	try cmd.write(stream.writer());	294	try cmd.write(stream.writer());
295	testing.expect(mem.eql(u8, expected, buffer[0..expected.len]));	295	try testing.expect(mem.eql(u8, expected, buffer[0..expected.len]));
296	}	296	}
297		297
298	test "read-write segment command" {	298	test "read-write segment command" {

src/register_manager.zig+24-24

src/test.zig+3-3

src/value.zig+3-3

...	@@ -1456,19 +1456,19 @@ test "hash same value different representation" {	...	@@ -1456,19 +1456,19 @@ test "hash same value different representation" {
1456	.data = 0,	1456	.data = 0,
1457	};	1457	};
1458	const zero_2 = Value.initPayload(&payload_1.base);	1458	const zero_2 = Value.initPayload(&payload_1.base);
1459	std.testing.expectEqual(zero_1.hash(), zero_2.hash());	1459	try std.testing.expectEqual(zero_1.hash(), zero_2.hash());
1460		1460
1461	var payload_2 = Value.Payload.I64{	1461	var payload_2 = Value.Payload.I64{
1462	.base = .{ .tag = .int_i64 },	1462	.base = .{ .tag = .int_i64 },
1463	.data = 0,	1463	.data = 0,
1464	};	1464	};
1465	const zero_3 = Value.initPayload(&payload_2.base);	1465	const zero_3 = Value.initPayload(&payload_2.base);
1466	std.testing.expectEqual(zero_2.hash(), zero_3.hash());	1466	try std.testing.expectEqual(zero_2.hash(), zero_3.hash());
1467		1467
1468	var payload_3 = Value.Payload.BigInt{	1468	var payload_3 = Value.Payload.BigInt{
1469	.base = .{ .tag = .int_big_negative },	1469	.base = .{ .tag = .int_big_negative },
1470	.data = &[_]std.math.big.Limb{0},	1470	.data = &[_]std.math.big.Limb{0},
1471	};	1471	};
1472	const zero_4 = Value.initPayload(&payload_3.base);	1472	const zero_4 = Value.initPayload(&payload_3.base);
1473	std.testing.expectEqual(zero_3.hash(), zero_4.hash());	1473	try std.testing.expectEqual(zero_3.hash(), zero_4.hash());
1474	}	1474	}

test/cli.zig+14-14

test/compile_errors.zig+1-1

...	@@ -230,7 +230,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {	...	@@ -230,7 +230,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
230		230
231	cases.add("array in c exported function",	231	cases.add("array in c exported function",
232	\\export fn zig_array(x: [10]u8) void {	232	\\export fn zig_array(x: [10]u8) void {
233	\\ expect(std.mem.eql(u8, &x, "1234567890"));	233	\\try expect(std.mem.eql(u8, &x, "1234567890"));
234	\\}	234	\\}
235	\\	235	\\
236	\\export fn zig_return_array() [10]u8 {	236	\\export fn zig_return_array() [10]u8 {

test/stack_traces.zig+17-17

...	@@ -5,13 +5,13 @@ const tests = @import("tests.zig");	...	@@ -5,13 +5,13 @@ const tests = @import("tests.zig");
5	pub fn addCases(cases: *tests.StackTracesContext) void {	5	pub fn addCases(cases: *tests.StackTracesContext) void {
6	cases.addCase(.{	6	cases.addCase(.{
7	.name = "return",	7	.name = "return",
8	.source =	8	.source =
9	\\pub fn main() !void {	9	\\pub fn main() !void {
10	\\ return error.TheSkyIsFalling;	10	\\ return error.TheSkyIsFalling;
11	\\}	11	\\}
12	,	12	,
13	.Debug = .{	13	.Debug = .{
14	.expect =	14	.expect =
15	\\error: TheSkyIsFalling	15	\\error: TheSkyIsFalling
16	\\source.zig:2:5: [address] in main (test)	16	\\source.zig:2:5: [address] in main (test)
17	\\ return error.TheSkyIsFalling;	17	\\ return error.TheSkyIsFalling;
...	@@ -23,7 +23,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -23,7 +23,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
23	.exclude_os = .{	23	.exclude_os = .{
24	.windows, // segfault	24	.windows, // segfault
25	},	25	},
26	.expect =	26	.expect =
27	\\error: TheSkyIsFalling	27	\\error: TheSkyIsFalling
28	\\source.zig:2:5: [address] in [function]	28	\\source.zig:2:5: [address] in [function]
29	\\ return error.TheSkyIsFalling;	29	\\ return error.TheSkyIsFalling;
...	@@ -32,13 +32,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -32,13 +32,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
32	,	32	,
33	},	33	},
34	.ReleaseFast = .{	34	.ReleaseFast = .{
35	.expect =	35	.expect =
36	\\error: TheSkyIsFalling	36	\\error: TheSkyIsFalling
37	\\	37	\\
38	,	38	,
39	},	39	},
40	.ReleaseSmall = .{	40	.ReleaseSmall = .{
41	.expect =	41	.expect =
42	\\error: TheSkyIsFalling	42	\\error: TheSkyIsFalling
43	\\	43	\\
44	,	44	,
...	@@ -47,7 +47,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -47,7 +47,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
47		47
48	cases.addCase(.{	48	cases.addCase(.{
49	.name = "try return",	49	.name = "try return",
50	.source =	50	.source =
51	\\fn foo() !void {	51	\\fn foo() !void {
52	\\ return error.TheSkyIsFalling;	52	\\ return error.TheSkyIsFalling;
53	\\}	53	\\}
...	@@ -57,7 +57,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -57,7 +57,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
57	\\}	57	\\}
58	,	58	,
59	.Debug = .{	59	.Debug = .{
60	.expect =	60	.expect =
61	\\error: TheSkyIsFalling	61	\\error: TheSkyIsFalling
62	\\source.zig:2:5: [address] in foo (test)	62	\\source.zig:2:5: [address] in foo (test)
63	\\ return error.TheSkyIsFalling;	63	\\ return error.TheSkyIsFalling;
...	@@ -72,7 +72,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -72,7 +72,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
72	.exclude_os = .{	72	.exclude_os = .{
73	.windows, // segfault	73	.windows, // segfault
74	},	74	},
75	.expect =	75	.expect =
76	\\error: TheSkyIsFalling	76	\\error: TheSkyIsFalling
77	\\source.zig:2:5: [address] in [function]	77	\\source.zig:2:5: [address] in [function]
78	\\ return error.TheSkyIsFalling;	78	\\ return error.TheSkyIsFalling;
...	@@ -84,13 +84,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -84,13 +84,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
84	,	84	,
85	},	85	},
86	.ReleaseFast = .{	86	.ReleaseFast = .{
87	.expect =	87	.expect =
88	\\error: TheSkyIsFalling	88	\\error: TheSkyIsFalling
89	\\	89	\\
90	,	90	,
91	},	91	},
92	.ReleaseSmall = .{	92	.ReleaseSmall = .{
93	.expect =	93	.expect =
94	\\error: TheSkyIsFalling	94	\\error: TheSkyIsFalling
95	\\	95	\\
96	,	96	,
...	@@ -99,7 +99,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -99,7 +99,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
99		99
100	cases.addCase(.{	100	cases.addCase(.{
101	.name = "try try return return",	101	.name = "try try return return",
102	.source =	102	.source =
103	\\fn foo() !void {	103	\\fn foo() !void {
104	\\ try bar();	104	\\ try bar();
105	\\}	105	\\}
...	@@ -117,7 +117,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -117,7 +117,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
117	\\}	117	\\}
118	,	118	,
119	.Debug = .{	119	.Debug = .{
120	.expect =	120	.expect =
121	\\error: TheSkyIsFalling	121	\\error: TheSkyIsFalling
122	\\source.zig:10:5: [address] in make_error (test)	122	\\source.zig:10:5: [address] in make_error (test)
123	\\ return error.TheSkyIsFalling;	123	\\ return error.TheSkyIsFalling;
...	@@ -138,7 +138,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -138,7 +138,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
138	.exclude_os = .{	138	.exclude_os = .{
139	.windows, // segfault	139	.windows, // segfault
140	},	140	},
141	.expect =	141	.expect =
142	\\error: TheSkyIsFalling	142	\\error: TheSkyIsFalling
143	\\source.zig:10:5: [address] in [function]	143	\\source.zig:10:5: [address] in [function]
144	\\ return error.TheSkyIsFalling;	144	\\ return error.TheSkyIsFalling;
...	@@ -156,13 +156,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -156,13 +156,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
156	,	156	,
157	},	157	},
158	.ReleaseFast = .{	158	.ReleaseFast = .{
159	.expect =	159	.expect =
160	\\error: TheSkyIsFalling	160	\\error: TheSkyIsFalling
161	\\	161	\\
162	,	162	,
163	},	163	},
164	.ReleaseSmall = .{	164	.ReleaseSmall = .{
165	.expect =	165	.expect =
166	\\error: TheSkyIsFalling	166	\\error: TheSkyIsFalling
167	\\	167	\\
168	,	168	,
...	@@ -174,7 +174,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -174,7 +174,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
174	.windows,	174	.windows,
175	},	175	},
176	.name = "dumpCurrentStackTrace",	176	.name = "dumpCurrentStackTrace",
177	.source =	177	.source =
178	\\const std = @import("std");	178	\\const std = @import("std");
179	\\	179	\\
180	\\fn bar() void {	180	\\fn bar() void {
...	@@ -189,7 +189,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {	...	@@ -189,7 +189,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
189	\\}	189	\\}
190	,	190	,
191	.Debug = .{	191	.Debug = .{
192	.expect =	192	.expect =
193	\\source.zig:7:8: [address] in foo (test)	193	\\source.zig:7:8: [address] in foo (test)
194	\\ bar();	194	\\ bar();
195	\\ ^	195	\\ ^

test/stage1/behavior/align.zig+66-66

test/stage1/behavior/alignof.zig+14-14

...	@@ -10,29 +10,29 @@ const Foo = struct {	...	@@ -10,29 +10,29 @@ const Foo = struct {
10	};	10	};
11		11
12	test "@alignOf(T) before referencing T" {	12	test "@alignOf(T) before referencing T" {
13	comptime expect(@alignOf(Foo) != maxInt(usize));	13	comptime try expect(@alignOf(Foo) != maxInt(usize));
14	if (builtin.arch == builtin.Arch.x86_64) {	14	if (builtin.arch == builtin.Arch.x86_64) {
15	comptime expect(@alignOf(Foo) == 4);	15	comptime try expect(@alignOf(Foo) == 4);
16	}	16	}
17	}	17	}
18		18
19	test "comparison of @alignOf(T) against zero" {	19	test "comparison of @alignOf(T) against zero" {
20	{	20	{
21	const T = struct { x: u32 };	21	const T = struct { x: u32 };
22	expect(!(@alignOf(T) == 0));	22	try expect(!(@alignOf(T) == 0));
23	expect(@alignOf(T) != 0);	23	try expect(@alignOf(T) != 0);
24	expect(!(@alignOf(T) < 0));	24	try expect(!(@alignOf(T) < 0));
25	expect(!(@alignOf(T) <= 0));	25	try expect(!(@alignOf(T) <= 0));
26	expect(@alignOf(T) > 0);	26	try expect(@alignOf(T) > 0);
27	expect(@alignOf(T) >= 0);	27	try expect(@alignOf(T) >= 0);
28	}	28	}
29	{	29	{
30	const T = struct {};	30	const T = struct {};
31	expect(@alignOf(T) == 0);	31	try expect(@alignOf(T) == 0);
32	expect(!(@alignOf(T) != 0));	32	try expect(!(@alignOf(T) != 0));
33	expect(!(@alignOf(T) < 0));	33	try expect(!(@alignOf(T) < 0));
34	expect(@alignOf(T) <= 0);	34	try expect(@alignOf(T) <= 0);
35	expect(!(@alignOf(T) > 0));	35	try expect(!(@alignOf(T) > 0));
36	expect(@alignOf(T) >= 0);	36	try expect(@alignOf(T) >= 0);
37	}	37	}
38	}	38	}

test/stage1/behavior/array.zig+141-141

...	@@ -21,8 +21,8 @@ test "arrays" {	...	@@ -21,8 +21,8 @@ test "arrays" {
21	i += 1;	21	i += 1;
22	}	22	}
23		23
24	expect(accumulator == 15);	24	try expect(accumulator == 15);
25	expect(getArrayLen(&array) == 5);	25	try expect(getArrayLen(&array) == 5);
26	}	26	}
27	fn getArrayLen(a: []const u32) usize {	27	fn getArrayLen(a: []const u32) usize {
28	return a.len;	28	return a.len;
...	@@ -30,37 +30,37 @@ fn getArrayLen(a: []const u32) usize {	...	@@ -30,37 +30,37 @@ fn getArrayLen(a: []const u32) usize {
30		30
31	test "array with sentinels" {	31	test "array with sentinels" {
32	const S = struct {	32	const S = struct {
33	fn doTheTest(is_ct: bool) void {	33	fn doTheTest(is_ct: bool) !void {
34	if (is_ct) {	34	if (is_ct) {
35	var zero_sized: [0:0xde]u8 = [_:0xde]u8{};	35	var zero_sized: [0:0xde]u8 = [_:0xde]u8{};
36	// Disabled at runtime because of	36	// Disabled at runtime because of
37	// https://github.com/ziglang/zig/issues/4372	37	// https://github.com/ziglang/zig/issues/4372
38	expectEqual(@as(u8, 0xde), zero_sized[0]);	38	try expectEqual(@as(u8, 0xde), zero_sized[0]);
39	var reinterpreted = @ptrCast(*[1]u8, &zero_sized);	39	var reinterpreted = @ptrCast(*[1]u8, &zero_sized);
40	expectEqual(@as(u8, 0xde), reinterpreted[0]);	40	try expectEqual(@as(u8, 0xde), reinterpreted[0]);
41	}	41	}
42	var arr: [3:0x55]u8 = undefined;	42	var arr: [3:0x55]u8 = undefined;
43	// Make sure the sentinel pointer is pointing after the last element	43	// Make sure the sentinel pointer is pointing after the last element
44	if (!is_ct) {	44	if (!is_ct) {
45	const sentinel_ptr = @ptrToInt(&arr[3]);	45	const sentinel_ptr = @ptrToInt(&arr[3]);
46	const last_elem_ptr = @ptrToInt(&arr[2]);	46	const last_elem_ptr = @ptrToInt(&arr[2]);
47	expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr);	47	try expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr);
48	}	48	}
49	// Make sure the sentinel is writeable	49	// Make sure the sentinel is writeable
50	arr[3] = 0x55;	50	arr[3] = 0x55;
51	}	51	}
52	};	52	};
53		53
54	S.doTheTest(false);	54	try S.doTheTest(false);
55	comptime S.doTheTest(true);	55	comptime try S.doTheTest(true);
56	}	56	}
57		57
58	test "void arrays" {	58	test "void arrays" {
59	var array: [4]void = undefined;	59	var array: [4]void = undefined;
60	array[0] = void{};	60	array[0] = void{};
61	array[1] = array[2];	61	array[1] = array[2];
62	expect(@sizeOf(@TypeOf(array)) == 0);	62	try expect(@sizeOf(@TypeOf(array)) == 0);
63	expect(array.len == 4);	63	try expect(array.len == 4);
64	}	64	}
65		65
66	test "array literal" {	66	test "array literal" {
...	@@ -71,12 +71,12 @@ test "array literal" {	...	@@ -71,12 +71,12 @@ test "array literal" {
71	1,	71	1,
72	};	72	};
73		73
74	expect(hex_mult.len == 4);	74	try expect(hex_mult.len == 4);
75	expect(hex_mult[1] == 256);	75	try expect(hex_mult[1] == 256);
76	}	76	}
77		77
78	test "array dot len const expr" {	78	test "array dot len const expr" {
79	expect(comptime x: {	79	try expect(comptime x: {
80	break :x some_array.len == 4;	80	break :x some_array.len == 4;
81	});	81	});
82	}	82	}
...	@@ -100,11 +100,11 @@ test "nested arrays" {	...	@@ -100,11 +100,11 @@ test "nested arrays" {
100	"thing",	100	"thing",
101	};	101	};
102	for (array_of_strings) \|s, i\| {	102	for (array_of_strings) \|s, i\| {
103	if (i == 0) expect(mem.eql(u8, s, "hello"));	103	if (i == 0) try expect(mem.eql(u8, s, "hello"));
104	if (i == 1) expect(mem.eql(u8, s, "this"));	104	if (i == 1) try expect(mem.eql(u8, s, "this"));
105	if (i == 2) expect(mem.eql(u8, s, "is"));	105	if (i == 2) try expect(mem.eql(u8, s, "is"));
106	if (i == 3) expect(mem.eql(u8, s, "my"));	106	if (i == 3) try expect(mem.eql(u8, s, "my"));
107	if (i == 4) expect(mem.eql(u8, s, "thing"));	107	if (i == 4) try expect(mem.eql(u8, s, "thing"));
108	}	108	}
109	}	109	}
110		110
...	@@ -122,9 +122,9 @@ test "set global var array via slice embedded in struct" {	...	@@ -122,9 +122,9 @@ test "set global var array via slice embedded in struct" {
122	s.a[1].b = 2;	122	s.a[1].b = 2;
123	s.a[2].b = 3;	123	s.a[2].b = 3;
124		124
125	expect(s_array[0].b == 1);	125	try expect(s_array[0].b == 1);
126	expect(s_array[1].b == 2);	126	try expect(s_array[1].b == 2);
127	expect(s_array[2].b == 3);	127	try expect(s_array[2].b == 3);
128	}	128	}
129		129
130	test "array literal with specified size" {	130	test "array literal with specified size" {
...	@@ -132,34 +132,34 @@ test "array literal with specified size" {	...	@@ -132,34 +132,34 @@ test "array literal with specified size" {
132	1,	132	1,
133	2,	133	2,
134	};	134	};
135	expect(array[0] == 1);	135	try expect(array[0] == 1);
136	expect(array[1] == 2);	136	try expect(array[1] == 2);
137	}	137	}
138		138
139	test "array len field" {	139	test "array len field" {
140	var arr = [4]u8{ 0, 0, 0, 0 };	140	var arr = [4]u8{ 0, 0, 0, 0 };
141	var ptr = &arr;	141	var ptr = &arr;
142	expect(arr.len == 4);	142	try expect(arr.len == 4);
143	comptime expect(arr.len == 4);	143	comptime try expect(arr.len == 4);
144	expect(ptr.len == 4);	144	try expect(ptr.len == 4);
145	comptime expect(ptr.len == 4);	145	comptime try expect(ptr.len == 4);
146	}	146	}
147		147
148	test "single-item pointer to array indexing and slicing" {	148	test "single-item pointer to array indexing and slicing" {
149	testSingleItemPtrArrayIndexSlice();	149	try testSingleItemPtrArrayIndexSlice();
150	comptime testSingleItemPtrArrayIndexSlice();	150	comptime try testSingleItemPtrArrayIndexSlice();
151	}	151	}
152		152
153	fn testSingleItemPtrArrayIndexSlice() void {	153	fn testSingleItemPtrArrayIndexSlice() !void {
154	{	154	{
155	var array: [4]u8 = "aaaa".*;	155	var array: [4]u8 = "aaaa".*;
156	doSomeMangling(&array);	156	doSomeMangling(&array);
157	expect(mem.eql(u8, "azya", &array));	157	try expect(mem.eql(u8, "azya", &array));
158	}	158	}
159	{	159	{
160	var array = "aaaa".*;	160	var array = "aaaa".*;
161	doSomeMangling(&array);	161	doSomeMangling(&array);
162	expect(mem.eql(u8, "azya", &array));	162	try expect(mem.eql(u8, "azya", &array));
163	}	163	}
164	}	164	}
165		165
...	@@ -169,15 +169,15 @@ fn doSomeMangling(array: *[4]u8) void {	...	@@ -169,15 +169,15 @@ fn doSomeMangling(array: *[4]u8) void {
169	}	169	}
170		170
171	test "implicit cast single-item pointer" {	171	test "implicit cast single-item pointer" {
172	testImplicitCastSingleItemPtr();	172	try testImplicitCastSingleItemPtr();
173	comptime testImplicitCastSingleItemPtr();	173	comptime try testImplicitCastSingleItemPtr();
174	}	174	}
175		175
176	fn testImplicitCastSingleItemPtr() void {	176	fn testImplicitCastSingleItemPtr() !void {
177	var byte: u8 = 100;	177	var byte: u8 = 100;
178	const slice = @as(*[1]u8, &byte)[0..];	178	const slice = @as(*[1]u8, &byte)[0..];
179	slice[0] += 1;	179	slice[0] += 1;
180	expect(byte == 101);	180	try expect(byte == 101);
181	}	181	}
182		182
183	fn testArrayByValAtComptime(b: [2]u8) u8 {	183	fn testArrayByValAtComptime(b: [2]u8) u8 {
...	@@ -192,7 +192,7 @@ test "comptime evalutating function that takes array by value" {	...	@@ -192,7 +192,7 @@ test "comptime evalutating function that takes array by value" {
192		192
193	test "implicit comptime in array type size" {	193	test "implicit comptime in array type size" {
194	var arr: [plusOne(10)]bool = undefined;	194	var arr: [plusOne(10)]bool = undefined;
195	expect(arr.len == 11);	195	try expect(arr.len == 11);
196	}	196	}
197		197
198	fn plusOne(x: u32) u32 {	198	fn plusOne(x: u32) u32 {
...	@@ -202,52 +202,52 @@ fn plusOne(x: u32) u32 {	...	@@ -202,52 +202,52 @@ fn plusOne(x: u32) u32 {
202	test "runtime initialize array elem and then implicit cast to slice" {	202	test "runtime initialize array elem and then implicit cast to slice" {
203	var two: i32 = 2;	203	var two: i32 = 2;
204	const x: []const i32 = &[_]i32{two};	204	const x: []const i32 = &[_]i32{two};
205	expect(x[0] == 2);	205	try expect(x[0] == 2);
206	}	206	}
207		207
208	test "array literal as argument to function" {	208	test "array literal as argument to function" {
209	const S = struct {	209	const S = struct {
210	fn entry(two: i32) void {	210	fn entry(two: i32) !void {
211	foo(&[_]i32{	211	try foo(&[_]i32{
212	1,	212	1,
213	2,	213	2,
214	3,	214	3,
215	});	215	});
216	foo(&[_]i32{	216	try foo(&[_]i32{
217	1,	217	1,
218	two,	218	two,
219	3,	219	3,
220	});	220	});
221	foo2(true, &[_]i32{	221	try foo2(true, &[_]i32{
222	1,	222	1,
223	2,	223	2,
224	3,	224	3,
225	});	225	});
226	foo2(true, &[_]i32{	226	try foo2(true, &[_]i32{
227	1,	227	1,
228	two,	228	two,
229	3,	229	3,
230	});	230	});
231	}	231	}
232	fn foo(x: []const i32) void {	232	fn foo(x: []const i32) !void {
233	expect(x[0] == 1);	233	try expect(x[0] == 1);
234	expect(x[1] == 2);	234	try expect(x[1] == 2);
235	expect(x[2] == 3);	235	try expect(x[2] == 3);
236	}	236	}
237	fn foo2(trash: bool, x: []const i32) void {	237	fn foo2(trash: bool, x: []const i32) !void {
238	expect(trash);	238	try expect(trash);
239	expect(x[0] == 1);	239	try expect(x[0] == 1);
240	expect(x[1] == 2);	240	try expect(x[1] == 2);
241	expect(x[2] == 3);	241	try expect(x[2] == 3);
242	}	242	}
243	};	243	};
244	S.entry(2);	244	try S.entry(2);
245	comptime S.entry(2);	245	comptime try S.entry(2);
246	}	246	}
247		247
248	test "double nested array to const slice cast in array literal" {	248	test "double nested array to const slice cast in array literal" {
249	const S = struct {	249	const S = struct {
250	fn entry(two: i32) void {	250	fn entry(two: i32) !void {
251	const cases = [_][]const []const i32{	251	const cases = [_][]const []const i32{
252	&[_][]const i32{&[_]i32{1}},	252	&[_][]const i32{&[_]i32{1}},
253	&[_][]const i32{&[_]i32{ 2, 3 }},	253	&[_][]const i32{&[_]i32{ 2, 3 }},
...	@@ -256,18 +256,18 @@ test "double nested array to const slice cast in array literal" {	...	@@ -256,18 +256,18 @@ test "double nested array to const slice cast in array literal" {
256	&[_]i32{ 5, 6, 7 },	256	&[_]i32{ 5, 6, 7 },
257	},	257	},
258	};	258	};
259	check(&cases);	259	try check(&cases);
260		260
261	const cases2 = [_][]const i32{	261	const cases2 = [_][]const i32{
262	&[_]i32{1},	262	&[_]i32{1},
263	&[_]i32{ two, 3 },	263	&[_]i32{ two, 3 },
264	};	264	};
265	expect(cases2.len == 2);	265	try expect(cases2.len == 2);
266	expect(cases2[0].len == 1);	266	try expect(cases2[0].len == 1);
267	expect(cases2[0][0] == 1);	267	try expect(cases2[0][0] == 1);
268	expect(cases2[1].len == 2);	268	try expect(cases2[1].len == 2);
269	expect(cases2[1][0] == 2);	269	try expect(cases2[1][0] == 2);
270	expect(cases2[1][1] == 3);	270	try expect(cases2[1][1] == 3);
271		271
272	const cases3 = [_][]const []const i32{	272	const cases3 = [_][]const []const i32{
273	&[_][]const i32{&[_]i32{1}},	273	&[_][]const i32{&[_]i32{1}},
...	@@ -277,37 +277,37 @@ test "double nested array to const slice cast in array literal" {	...	@@ -277,37 +277,37 @@ test "double nested array to const slice cast in array literal" {
277	&[_]i32{ 5, 6, 7 },	277	&[_]i32{ 5, 6, 7 },
278	},	278	},
279	};	279	};
280	check(&cases3);	280	try check(&cases3);
281	}	281	}
282		282
283	fn check(cases: []const []const []const i32) void {	283	fn check(cases: []const []const []const i32) !void {
284	expect(cases.len == 3);	284	try expect(cases.len == 3);
285	expect(cases[0].len == 1);	285	try expect(cases[0].len == 1);
286	expect(cases[0][0].len == 1);	286	try expect(cases[0][0].len == 1);
287	expect(cases[0][0][0] == 1);	287	try expect(cases[0][0][0] == 1);
288	expect(cases[1].len == 1);	288	try expect(cases[1].len == 1);
289	expect(cases[1][0].len == 2);	289	try expect(cases[1][0].len == 2);
290	expect(cases[1][0][0] == 2);	290	try expect(cases[1][0][0] == 2);
291	expect(cases[1][0][1] == 3);	291	try expect(cases[1][0][1] == 3);
292	expect(cases[2].len == 2);	292	try expect(cases[2].len == 2);
293	expect(cases[2][0].len == 1);	293	try expect(cases[2][0].len == 1);
294	expect(cases[2][0][0] == 4);	294	try expect(cases[2][0][0] == 4);
295	expect(cases[2][1].len == 3);	295	try expect(cases[2][1].len == 3);
296	expect(cases[2][1][0] == 5);	296	try expect(cases[2][1][0] == 5);
297	expect(cases[2][1][1] == 6);	297	try expect(cases[2][1][1] == 6);
298	expect(cases[2][1][2] == 7);	298	try expect(cases[2][1][2] == 7);
299	}	299	}
300	};	300	};
301	S.entry(2);	301	try S.entry(2);
302	comptime S.entry(2);	302	comptime try S.entry(2);
303	}	303	}
304		304
305	test "read/write through global variable array of struct fields initialized via array mult" {	305	test "read/write through global variable array of struct fields initialized via array mult" {
306	const S = struct {	306	const S = struct {
307	fn doTheTest() void {	307	fn doTheTest() !void {
308	expect(storage[0].term == 1);	308	try expect(storage[0].term == 1);
309	storage[0] = MyStruct{ .term = 123 };	309	storage[0] = MyStruct{ .term = 123 };
310	expect(storage[0].term == 123);	310	try expect(storage[0].term == 123);
311	}	311	}
312		312
313	pub const MyStruct = struct {	313	pub const MyStruct = struct {
...	@@ -316,34 +316,34 @@ test "read/write through global variable array of struct fields initialized via	...	@@ -316,34 +316,34 @@ test "read/write through global variable array of struct fields initialized via
316		316
317	var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1;	317	var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1;
318	};	318	};
319	S.doTheTest();	319	try S.doTheTest();
320	}	320	}
321		321
322	test "implicit cast zero sized array ptr to slice" {	322	test "implicit cast zero sized array ptr to slice" {
323	{	323	{
324	var b = "".*;	324	var b = "".*;
325	const c: []const u8 = &b;	325	const c: []const u8 = &b;
326	expect(c.len == 0);	326	try expect(c.len == 0);
327	}	327	}
328	{	328	{
329	var b: [0]u8 = "".*;	329	var b: [0]u8 = "".*;
330	const c: []const u8 = &b;	330	const c: []const u8 = &b;
331	expect(c.len == 0);	331	try expect(c.len == 0);
332	}	332	}
333	}	333	}
334		334
335	test "anonymous list literal syntax" {	335	test "anonymous list literal syntax" {
336	const S = struct {	336	const S = struct {
337	fn doTheTest() void {	337	fn doTheTest() !void {
338	var array: [4]u8 = .{ 1, 2, 3, 4 };	338	var array: [4]u8 = .{ 1, 2, 3, 4 };
339	expect(array[0] == 1);	339	try expect(array[0] == 1);
340	expect(array[1] == 2);	340	try expect(array[1] == 2);
341	expect(array[2] == 3);	341	try expect(array[2] == 3);
342	expect(array[3] == 4);	342	try expect(array[3] == 4);
343	}	343	}
344	};	344	};
345	S.doTheTest();	345	try S.doTheTest();
346	comptime S.doTheTest();	346	comptime try S.doTheTest();
347	}	347	}
348		348
349	test "anonymous literal in array" {	349	test "anonymous literal in array" {
...	@@ -352,51 +352,51 @@ test "anonymous literal in array" {	...	@@ -352,51 +352,51 @@ test "anonymous literal in array" {
352	a: usize = 2,	352	a: usize = 2,
353	b: usize = 4,	353	b: usize = 4,
354	};	354	};
355	fn doTheTest() void {	355	fn doTheTest() !void {
356	var array: [2]Foo = .{	356	var array: [2]Foo = .{
357	.{ .a = 3 },	357	.{ .a = 3 },
358	.{ .b = 3 },	358	.{ .b = 3 },
359	};	359	};
360	expect(array[0].a == 3);	360	try expect(array[0].a == 3);
361	expect(array[0].b == 4);	361	try expect(array[0].b == 4);
362	expect(array[1].a == 2);	362	try expect(array[1].a == 2);
363	expect(array[1].b == 3);	363	try expect(array[1].b == 3);
364	}	364	}
365	};	365	};
366	S.doTheTest();	366	try S.doTheTest();
367	comptime S.doTheTest();	367	comptime try S.doTheTest();
368	}	368	}
369		369
370	test "access the null element of a null terminated array" {	370	test "access the null element of a null terminated array" {
371	const S = struct {	371	const S = struct {
372	fn doTheTest() void {	372	fn doTheTest() !void {
373	var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };	373	var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
374	expect(array[4] == 0);	374	try expect(array[4] == 0);
375	var len: usize = 4;	375	var len: usize = 4;
376	expect(array[len] == 0);	376	try expect(array[len] == 0);
377	}	377	}
378	};	378	};
379	S.doTheTest();	379	try S.doTheTest();
380	comptime S.doTheTest();	380	comptime try S.doTheTest();
381	}	381	}
382		382
383	test "type deduction for array subscript expression" {	383	test "type deduction for array subscript expression" {
384	const S = struct {	384	const S = struct {
385	fn doTheTest() void {	385	fn doTheTest() !void {
386	var array = [_]u8{ 0x55, 0xAA };	386	var array = [_]u8{ 0x55, 0xAA };
387	var v0 = true;	387	var v0 = true;
388	expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]);	388	try expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]);
389	var v1 = false;	389	var v1 = false;
390	expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]);	390	try expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]);
391	}	391	}
392	};	392	};
393	S.doTheTest();	393	try S.doTheTest();
394	comptime S.doTheTest();	394	comptime try S.doTheTest();
395	}	395	}
396		396
397	test "sentinel element count towards the ABI size calculation" {	397	test "sentinel element count towards the ABI size calculation" {
398	const S = struct {	398	const S = struct {
399	fn doTheTest() void {	399	fn doTheTest() !void {
400	const T = packed struct {	400	const T = packed struct {
401	fill_pre: u8 = 0x55,	401	fill_pre: u8 = 0x55,
402	data: [0:0]u8 = undefined,	402	data: [0:0]u8 = undefined,
...	@@ -404,14 +404,14 @@ test "sentinel element count towards the ABI size calculation" {	...	@@ -404,14 +404,14 @@ test "sentinel element count towards the ABI size calculation" {
404	};	404	};
405	var x = T{};	405	var x = T{};
406	var as_slice = mem.asBytes(&x);	406	var as_slice = mem.asBytes(&x);
407	expectEqual(@as(usize, 3), as_slice.len);	407	try expectEqual(@as(usize, 3), as_slice.len);
408	expectEqual(@as(u8, 0x55), as_slice[0]);	408	try expectEqual(@as(u8, 0x55), as_slice[0]);
409	expectEqual(@as(u8, 0xAA), as_slice[2]);	409	try expectEqual(@as(u8, 0xAA), as_slice[2]);
410	}	410	}
411	};	411	};
412		412
413	S.doTheTest();	413	try S.doTheTest();
414	comptime S.doTheTest();	414	comptime try S.doTheTest();
415	}	415	}
416		416
417	test "zero-sized array with recursive type definition" {	417	test "zero-sized array with recursive type definition" {
...	@@ -429,61 +429,61 @@ test "zero-sized array with recursive type definition" {	...	@@ -429,61 +429,61 @@ test "zero-sized array with recursive type definition" {
429	};	429	};
430		430
431	var t: S = .{ .list = .{ .s = undefined } };	431	var t: S = .{ .list = .{ .s = undefined } };
432	expectEqual(@as(usize, 0), t.list.x);	432	try expectEqual(@as(usize, 0), t.list.x);
433	}	433	}
434		434
435	test "type coercion of anon struct literal to array" {	435	test "type coercion of anon struct literal to array" {
436	const S = struct {	436	const S = struct {
437	const U = union{	437	const U = union {
438	a: u32,	438	a: u32,
439	b: bool,	439	b: bool,
440	c: []const u8,	440	c: []const u8,
441	};	441	};
442		442
443	fn doTheTest() void {	443	fn doTheTest() !void {
444	var x1: u8 = 42;	444	var x1: u8 = 42;
445	const t1 = .{ x1, 56, 54 };	445	const t1 = .{ x1, 56, 54 };
446	var arr1: [3]u8 = t1;	446	var arr1: [3]u8 = t1;
447	expect(arr1[0] == 42);	447	try expect(arr1[0] == 42);
448	expect(arr1[1] == 56);	448	try expect(arr1[1] == 56);
449	expect(arr1[2] == 54);	449	try expect(arr1[2] == 54);
450		450
451	var x2: U = .{ .a = 42 };	451	var x2: U = .{ .a = 42 };
452	const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };	452	const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
453	var arr2: [3]U = t2;	453	var arr2: [3]U = t2;
454	expect(arr2[0].a == 42);	454	try expect(arr2[0].a == 42);
455	expect(arr2[1].b == true);	455	try expect(arr2[1].b == true);
456	expect(mem.eql(u8, arr2[2].c, "hello"));	456	try expect(mem.eql(u8, arr2[2].c, "hello"));
457	}	457	}
458	};	458	};
459	S.doTheTest();	459	try S.doTheTest();
460	comptime S.doTheTest();	460	comptime try S.doTheTest();
461	}	461	}
462		462
463	test "type coercion of pointer to anon struct literal to pointer to array" {	463	test "type coercion of pointer to anon struct literal to pointer to array" {
464	const S = struct {	464	const S = struct {
465	const U = union{	465	const U = union {
466	a: u32,	466	a: u32,
467	b: bool,	467	b: bool,
468	c: []const u8,	468	c: []const u8,
469	};	469	};
470		470
471	fn doTheTest() void {	471	fn doTheTest() !void {
472	var x1: u8 = 42;	472	var x1: u8 = 42;
473	const t1 = &.{ x1, 56, 54 };	473	const t1 = &.{ x1, 56, 54 };
474	var arr1: *const[3]u8 = t1;	474	var arr1: *const [3]u8 = t1;
475	expect(arr1[0] == 42);	475	try expect(arr1[0] == 42);
476	expect(arr1[1] == 56);	476	try expect(arr1[1] == 56);
477	expect(arr1[2] == 54);	477	try expect(arr1[2] == 54);
478		478
479	var x2: U = .{ .a = 42 };	479	var x2: U = .{ .a = 42 };
480	const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };	480	const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
481	var arr2: *const [3]U = t2;	481	var arr2: *const [3]U = t2;
482	expect(arr2[0].a == 42);	482	try expect(arr2[0].a == 42);
483	expect(arr2[1].b == true);	483	try expect(arr2[1].b == true);
484	expect(mem.eql(u8, arr2[2].c, "hello"));	484	try expect(mem.eql(u8, arr2[2].c, "hello"));
485	}	485	}
486	};	486	};
487	S.doTheTest();	487	try S.doTheTest();
488	comptime S.doTheTest();	488	comptime try S.doTheTest();
489	}	489	}

test/stage1/behavior/asm.zig+1-1

...	@@ -15,7 +15,7 @@ comptime {	...	@@ -15,7 +15,7 @@ comptime {
15		15
16	test "module level assembly" {	16	test "module level assembly" {
17	if (is_x86_64_linux) {	17	if (is_x86_64_linux) {
18	expect(this_is_my_alias() == 1234);	18	try expect(this_is_my_alias() == 1234);
19	}	19	}
20	}	20	}
21		21

test/stage1/behavior/async_fn.zig+165-165

...	@@ -9,12 +9,12 @@ var global_x: i32 = 1;	...	@@ -9,12 +9,12 @@ var global_x: i32 = 1;
9		9
10	test "simple coroutine suspend and resume" {	10	test "simple coroutine suspend and resume" {
11	var frame = async simpleAsyncFn();	11	var frame = async simpleAsyncFn();
12	expect(global_x == 2);	12	try expect(global_x == 2);
13	resume frame;	13	resume frame;
14	expect(global_x == 3);	14	try expect(global_x == 3);
15	const af: anyframe->void = &frame;	15	const af: anyframe->void = &frame;
16	resume frame;	16	resume frame;
17	expect(global_x == 4);	17	try expect(global_x == 4);
18	}	18	}
19	fn simpleAsyncFn() void {	19	fn simpleAsyncFn() void {
20	global_x += 1;	20	global_x += 1;
...	@@ -28,9 +28,9 @@ var global_y: i32 = 1;	...	@@ -28,9 +28,9 @@ var global_y: i32 = 1;
28		28
29	test "pass parameter to coroutine" {	29	test "pass parameter to coroutine" {
30	var p = async simpleAsyncFnWithArg(2);	30	var p = async simpleAsyncFnWithArg(2);
31	expect(global_y == 3);	31	try expect(global_y == 3);
32	resume p;	32	resume p;
33	expect(global_y == 5);	33	try expect(global_y == 5);
34	}	34	}
35	fn simpleAsyncFnWithArg(delta: i32) void {	35	fn simpleAsyncFnWithArg(delta: i32) void {
36	global_y += delta;	36	global_y += delta;
...	@@ -42,10 +42,10 @@ test "suspend at end of function" {	...	@@ -42,10 +42,10 @@ test "suspend at end of function" {
42	const S = struct {	42	const S = struct {
43	var x: i32 = 1;	43	var x: i32 = 1;
44		44
45	fn doTheTest() void {	45	fn doTheTest() !void {
46	expect(x == 1);	46	try expect(x == 1);
47	const p = async suspendAtEnd();	47	const p = async suspendAtEnd();
48	expect(x == 2);	48	try expect(x == 2);
49	}	49	}
50		50
51	fn suspendAtEnd() void {	51	fn suspendAtEnd() void {
...	@@ -53,23 +53,23 @@ test "suspend at end of function" {	...	@@ -53,23 +53,23 @@ test "suspend at end of function" {
53	suspend {}	53	suspend {}
54	}	54	}
55	};	55	};
56	S.doTheTest();	56	try S.doTheTest();
57	}	57	}
58		58
59	test "local variable in async function" {	59	test "local variable in async function" {
60	const S = struct {	60	const S = struct {
61	var x: i32 = 0;	61	var x: i32 = 0;
62		62
63	fn doTheTest() void {	63	fn doTheTest() !void {
64	expect(x == 0);	64	try expect(x == 0);
65	var p = async add(1, 2);	65	var p = async add(1, 2);
66	expect(x == 0);	66	try expect(x == 0);
67	resume p;	67	resume p;
68	expect(x == 0);	68	try expect(x == 0);
69	resume p;	69	resume p;
70	expect(x == 0);	70	try expect(x == 0);
71	resume p;	71	resume p;
72	expect(x == 3);	72	try expect(x == 3);
73	}	73	}
74		74
75	fn add(a: i32, b: i32) void {	75	fn add(a: i32, b: i32) void {
...	@@ -82,7 +82,7 @@ test "local variable in async function" {	...	@@ -82,7 +82,7 @@ test "local variable in async function" {
82	x = accum;	82	x = accum;
83	}	83	}
84	};	84	};
85	S.doTheTest();	85	try S.doTheTest();
86	}	86	}
87		87
88	test "calling an inferred async function" {	88	test "calling an inferred async function" {
...	@@ -90,11 +90,11 @@ test "calling an inferred async function" {	...	@@ -90,11 +90,11 @@ test "calling an inferred async function" {
90	var x: i32 = 1;	90	var x: i32 = 1;
91	var other_frame: *@Frame(other) = undefined;	91	var other_frame: *@Frame(other) = undefined;
92		92
93	fn doTheTest() void {	93	fn doTheTest() !void {
94	_ = async first();	94	_ = async first();
95	expect(x == 1);	95	try expect(x == 1);
96	resume other_frame.*;	96	resume other_frame.*;
97	expect(x == 2);	97	try expect(x == 2);
98	}	98	}
99		99
100	fn first() void {	100	fn first() void {
...	@@ -106,7 +106,7 @@ test "calling an inferred async function" {	...	@@ -106,7 +106,7 @@ test "calling an inferred async function" {
106	x += 1;	106	x += 1;
107	}	107	}
108	};	108	};
109	S.doTheTest();	109	try S.doTheTest();
110	}	110	}
111		111
112	test "@frameSize" {	112	test "@frameSize" {
...	@@ -114,16 +114,16 @@ test "@frameSize" {	...	@@ -114,16 +114,16 @@ test "@frameSize" {
114	return error.SkipZigTest;	114	return error.SkipZigTest;
115		115
116	const S = struct {	116	const S = struct {
117	fn doTheTest() void {	117	fn doTheTest() !void {
118	{	118	{
119	var ptr = @ptrCast(fn (i32) callconv(.Async) void, other);	119	var ptr = @ptrCast(fn (i32) callconv(.Async) void, other);
120	const size = @frameSize(ptr);	120	const size = @frameSize(ptr);
121	expect(size == @sizeOf(@Frame(other)));	121	try expect(size == @sizeOf(@Frame(other)));
122	}	122	}
123	{	123	{
124	var ptr = @ptrCast(fn () callconv(.Async) void, first);	124	var ptr = @ptrCast(fn () callconv(.Async) void, first);
125	const size = @frameSize(ptr);	125	const size = @frameSize(ptr);
126	expect(size == @sizeOf(@Frame(first)));	126	try expect(size == @sizeOf(@Frame(first)));
127	}	127	}
128	}	128	}
129		129
...	@@ -135,20 +135,20 @@ test "@frameSize" {	...	@@ -135,20 +135,20 @@ test "@frameSize" {
135	suspend {}	135	suspend {}
136	}	136	}
137	};	137	};
138	S.doTheTest();	138	try S.doTheTest();
139	}	139	}
140		140
141	test "coroutine suspend, resume" {	141	test "coroutine suspend, resume" {
142	const S = struct {	142	const S = struct {
143	var frame: anyframe = undefined;	143	var frame: anyframe = undefined;
144		144
145	fn doTheTest() void {	145	fn doTheTest() !void {
146	_ = async amain();	146	_ = async amain();
147	seq('d');	147	seq('d');
148	resume frame;	148	resume frame;
149	seq('h');	149	seq('h');
150		150
151	expect(std.mem.eql(u8, &points, "abcdefgh"));	151	try expect(std.mem.eql(u8, &points, "abcdefgh"));
152	}	152	}
153		153
154	fn amain() void {	154	fn amain() void {
...	@@ -176,27 +176,27 @@ test "coroutine suspend, resume" {	...	@@ -176,27 +176,27 @@ test "coroutine suspend, resume" {
176	index += 1;	176	index += 1;
177	}	177	}
178	};	178	};
179	S.doTheTest();	179	try S.doTheTest();
180	}	180	}
181		181
182	test "coroutine suspend with block" {	182	test "coroutine suspend with block" {
183	const p = async testSuspendBlock();	183	const p = async testSuspendBlock();
184	expect(!global_result);	184	try expect(!global_result);
185	resume a_promise;	185	resume a_promise;
186	expect(global_result);	186	try expect(global_result);
187	}	187	}
188		188
189	var a_promise: anyframe = undefined;	189	var a_promise: anyframe = undefined;
190	var global_result = false;	190	var global_result = false;
191	fn testSuspendBlock() callconv(.Async) void {	191	fn testSuspendBlock() callconv(.Async) void {
192	suspend {	192	suspend {
193	comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock));	193	comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock)) catch unreachable;
194	a_promise = @frame();	194	a_promise = @frame();
195	}	195	}
196		196
197	// Test to make sure that @frame() works as advertised (issue #1296)	197	// Test to make sure that @frame() works as advertised (issue #1296)
198	// var our_handle: anyframe = @frame();	198	// var our_handle: anyframe = @frame();
199	expect(a_promise == @as(anyframe, @frame()));	199	expect(a_promise == @as(anyframe, @frame())) catch @panic("test failed");
200		200
201	global_result = true;	201	global_result = true;
202	}	202	}
...	@@ -210,8 +210,8 @@ test "coroutine await" {	...	@@ -210,8 +210,8 @@ test "coroutine await" {
210	await_seq('f');	210	await_seq('f');
211	resume await_a_promise;	211	resume await_a_promise;
212	await_seq('i');	212	await_seq('i');
213	expect(await_final_result == 1234);	213	try expect(await_final_result == 1234);
214	expect(std.mem.eql(u8, &await_points, "abcdefghi"));	214	try expect(std.mem.eql(u8, &await_points, "abcdefghi"));
215	}	215	}
216	fn await_amain() callconv(.Async) void {	216	fn await_amain() callconv(.Async) void {
217	await_seq('b');	217	await_seq('b');
...	@@ -244,8 +244,8 @@ test "coroutine await early return" {	...	@@ -244,8 +244,8 @@ test "coroutine await early return" {
244	early_seq('a');	244	early_seq('a');
245	var p = async early_amain();	245	var p = async early_amain();
246	early_seq('f');	246	early_seq('f');
247	expect(early_final_result == 1234);	247	try expect(early_final_result == 1234);
248	expect(std.mem.eql(u8, &early_points, "abcdef"));	248	try expect(std.mem.eql(u8, &early_points, "abcdef"));
249	}	249	}
250	fn early_amain() callconv(.Async) void {	250	fn early_amain() callconv(.Async) void {
251	early_seq('b');	251	early_seq('b');
...	@@ -276,7 +276,7 @@ test "async function with dot syntax" {	...	@@ -276,7 +276,7 @@ test "async function with dot syntax" {
276	}	276	}
277	};	277	};
278	const p = async S.foo();	278	const p = async S.foo();
279	expect(S.y == 2);	279	try expect(S.y == 2);
280	}	280	}
281		281
282	test "async fn pointer in a struct field" {	282	test "async fn pointer in a struct field" {
...	@@ -287,12 +287,12 @@ test "async fn pointer in a struct field" {	...	@@ -287,12 +287,12 @@ test "async fn pointer in a struct field" {
287	var foo = Foo{ .bar = simpleAsyncFn2 };	287	var foo = Foo{ .bar = simpleAsyncFn2 };
288	var bytes: [64]u8 align(16) = undefined;	288	var bytes: [64]u8 align(16) = undefined;
289	const f = @asyncCall(&bytes, {}, foo.bar, .{&data});	289	const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
290	comptime expect(@TypeOf(f) == anyframe->void);	290	comptime try expect(@TypeOf(f) == anyframe->void);
291	expect(data == 2);	291	try expect(data == 2);
292	resume f;	292	resume f;
293	expect(data == 4);	293	try expect(data == 4);
294	_ = async doTheAwait(f);	294	_ = async doTheAwait(f);
295	expect(data == 4);	295	try expect(data == 4);
296	}	296	}
297		297
298	fn doTheAwait(f: anyframe->void) void {	298	fn doTheAwait(f: anyframe->void) void {
...	@@ -323,22 +323,22 @@ test "@asyncCall with return type" {	...	@@ -323,22 +323,22 @@ test "@asyncCall with return type" {
323	var bytes: [150]u8 align(16) = undefined;	323	var bytes: [150]u8 align(16) = undefined;
324	var aresult: i32 = 0;	324	var aresult: i32 = 0;
325	_ = @asyncCall(&bytes, &aresult, foo.bar, .{});	325	_ = @asyncCall(&bytes, &aresult, foo.bar, .{});
326	expect(aresult == 0);	326	try expect(aresult == 0);
327	resume Foo.global_frame;	327	resume Foo.global_frame;
328	expect(aresult == 1234);	328	try expect(aresult == 1234);
329	}	329	}
330		330
331	test "async fn with inferred error set" {	331	test "async fn with inferred error set" {
332	const S = struct {	332	const S = struct {
333	var global_frame: anyframe = undefined;	333	var global_frame: anyframe = undefined;
334		334
335	fn doTheTest() void {	335	fn doTheTest() !void {
336	var frame: [1]@Frame(middle) = undefined;	336	var frame: [1]@Frame(middle) = undefined;
337	var fn_ptr = middle;	337	var fn_ptr = middle;
338	var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;	338	var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
339	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});	339	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
340	resume global_frame;	340	resume global_frame;
341	std.testing.expectError(error.Fail, result);	341	try std.testing.expectError(error.Fail, result);
342	}	342	}
343	fn middle() callconv(.Async) !void {	343	fn middle() callconv(.Async) !void {
344	var f = async middle2();	344	var f = async middle2();
...	@@ -355,7 +355,7 @@ test "async fn with inferred error set" {	...	@@ -355,7 +355,7 @@ test "async fn with inferred error set" {
355	return error.Fail;	355	return error.Fail;
356	}	356	}
357	};	357	};
358	S.doTheTest();	358	try S.doTheTest();
359	}	359	}
360		360
361	test "error return trace across suspend points - early return" {	361	test "error return trace across suspend points - early return" {
...	@@ -383,9 +383,9 @@ fn suspendThenFail() callconv(.Async) anyerror!void {	...	@@ -383,9 +383,9 @@ fn suspendThenFail() callconv(.Async) anyerror!void {
383	}	383	}
384	fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {	384	fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
385	(await p) catch \|e\| {	385	(await p) catch \|e\| {
386	std.testing.expect(e == error.Fail);	386	std.testing.expect(e == error.Fail) catch @panic("test failure");
387	if (@errorReturnTrace()) \|trace\| {	387	if (@errorReturnTrace()) \|trace\| {
388	expect(trace.index == 1);	388	expect(trace.index == 1) catch @panic("test failure");
389	} else switch (builtin.mode) {	389	} else switch (builtin.mode) {
390	.Debug, .ReleaseSafe => @panic("expected return trace"),	390	.Debug, .ReleaseSafe => @panic("expected return trace"),
391	.ReleaseFast, .ReleaseSmall => {},	391	.ReleaseFast, .ReleaseSmall => {},
...	@@ -396,7 +396,7 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {	...	@@ -396,7 +396,7 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void {
396	test "break from suspend" {	396	test "break from suspend" {
397	var my_result: i32 = 1;	397	var my_result: i32 = 1;
398	const p = async testBreakFromSuspend(&my_result);	398	const p = async testBreakFromSuspend(&my_result);
399	std.testing.expect(my_result == 2);	399	try std.testing.expect(my_result == 2);
400	}	400	}
401	fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void {	401	fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void {
402	suspend {	402	suspend {
...	@@ -415,11 +415,11 @@ test "heap allocated async function frame" {	...	@@ -415,11 +415,11 @@ test "heap allocated async function frame" {
415	const frame = try std.testing.allocator.create(@Frame(someFunc));	415	const frame = try std.testing.allocator.create(@Frame(someFunc));
416	defer std.testing.allocator.destroy(frame);	416	defer std.testing.allocator.destroy(frame);
417		417
418	expect(x == 42);	418	try expect(x == 42);
419	frame.* = async someFunc();	419	frame.* = async someFunc();
420	expect(x == 43);	420	try expect(x == 43);
421	resume frame;	421	resume frame;
422	expect(x == 44);	422	try expect(x == 44);
423	}	423	}
424		424
425	fn someFunc() void {	425	fn someFunc() void {
...	@@ -436,15 +436,15 @@ test "async function call return value" {	...	@@ -436,15 +436,15 @@ test "async function call return value" {
436	var frame: anyframe = undefined;	436	var frame: anyframe = undefined;
437	var pt = Point{ .x = 10, .y = 11 };	437	var pt = Point{ .x = 10, .y = 11 };
438		438
439	fn doTheTest() void {	439	fn doTheTest() !void {
440	expectEqual(pt.x, 10);	440	try expectEqual(pt.x, 10);
441	expectEqual(pt.y, 11);	441	try expectEqual(pt.y, 11);
442	_ = async first();	442	_ = async first();
443	expectEqual(pt.x, 10);	443	try expectEqual(pt.x, 10);
444	expectEqual(pt.y, 11);	444	try expectEqual(pt.y, 11);
445	resume frame;	445	resume frame;
446	expectEqual(pt.x, 1);	446	try expectEqual(pt.x, 1);
447	expectEqual(pt.y, 2);	447	try expectEqual(pt.y, 2);
448	}	448	}
449		449
450	fn first() void {	450	fn first() void {
...	@@ -469,23 +469,23 @@ test "async function call return value" {	...	@@ -469,23 +469,23 @@ test "async function call return value" {
469	y: i32,	469	y: i32,
470	};	470	};
471	};	471	};
472	S.doTheTest();	472	try S.doTheTest();
473	}	473	}
474		474
475	test "suspension points inside branching control flow" {	475	test "suspension points inside branching control flow" {
476	const S = struct {	476	const S = struct {
477	var result: i32 = 10;	477	var result: i32 = 10;
478		478
479	fn doTheTest() void {	479	fn doTheTest() !void {
480	expect(10 == result);	480	try expect(10 == result);
481	var frame = async func(true);	481	var frame = async func(true);
482	expect(10 == result);	482	try expect(10 == result);
483	resume frame;	483	resume frame;
484	expect(11 == result);	484	try expect(11 == result);
485	resume frame;	485	resume frame;
486	expect(12 == result);	486	try expect(12 == result);
487	resume frame;	487	resume frame;
488	expect(13 == result);	488	try expect(13 == result);
489	}	489	}
490		490
491	fn func(b: bool) void {	491	fn func(b: bool) void {
...	@@ -495,7 +495,7 @@ test "suspension points inside branching control flow" {	...	@@ -495,7 +495,7 @@ test "suspension points inside branching control flow" {
495	}	495	}
496	}	496	}
497	};	497	};
498	S.doTheTest();	498	try S.doTheTest();
499	}	499	}
500		500
501	test "call async function which has struct return type" {	501	test "call async function which has struct return type" {
...	@@ -509,8 +509,8 @@ test "call async function which has struct return type" {	...	@@ -509,8 +509,8 @@ test "call async function which has struct return type" {
509		509
510	fn atest() void {	510	fn atest() void {
511	const result = func();	511	const result = func();
512	expect(result.x == 5);	512	expect(result.x == 5) catch @panic("test failed");
513	expect(result.y == 6);	513	expect(result.y == 6) catch @panic("test failed");
514	}	514	}
515		515
516	const Point = struct {	516	const Point = struct {
...	@@ -536,27 +536,27 @@ test "pass string literal to async function" {	...	@@ -536,27 +536,27 @@ test "pass string literal to async function" {
536	var frame: anyframe = undefined;	536	var frame: anyframe = undefined;
537	var ok: bool = false;	537	var ok: bool = false;
538		538
539	fn doTheTest() void {	539	fn doTheTest() !void {
540	_ = async hello("hello");	540	_ = async hello("hello");
541	resume frame;	541	resume frame;
542	expect(ok);	542	try expect(ok);
543	}	543	}
544		544
545	fn hello(msg: []const u8) void {	545	fn hello(msg: []const u8) void {
546	frame = @frame();	546	frame = @frame();
547	suspend {}	547	suspend {}
548	expectEqualStrings("hello", msg);	548	expectEqualStrings("hello", msg) catch @panic("test failed");
549	ok = true;	549	ok = true;
550	}	550	}
551	};	551	};
552	S.doTheTest();	552	try S.doTheTest();
553	}	553	}
554		554
555	test "await inside an errdefer" {	555	test "await inside an errdefer" {
556	const S = struct {	556	const S = struct {
557	var frame: anyframe = undefined;	557	var frame: anyframe = undefined;
558		558
559	fn doTheTest() void {	559	fn doTheTest() !void {
560	_ = async amainWrap();	560	_ = async amainWrap();
561	resume frame;	561	resume frame;
562	}	562	}
...	@@ -572,7 +572,7 @@ test "await inside an errdefer" {	...	@@ -572,7 +572,7 @@ test "await inside an errdefer" {
572	suspend {}	572	suspend {}
573	}	573	}
574	};	574	};
575	S.doTheTest();	575	try S.doTheTest();
576	}	576	}
577		577
578	test "try in an async function with error union and non-zero-bit payload" {	578	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" {	...	@@ -580,14 +580,14 @@ test "try in an async function with error union and non-zero-bit payload" {
580	var frame: anyframe = undefined;	580	var frame: anyframe = undefined;
581	var ok = false;	581	var ok = false;
582		582
583	fn doTheTest() void {	583	fn doTheTest() !void {
584	_ = async amain();	584	_ = async amain();
585	resume frame;	585	resume frame;
586	expect(ok);	586	try expect(ok);
587	}	587	}
588		588
589	fn amain() void {	589	fn amain() void {
590	std.testing.expectError(error.Bad, theProblem());	590	std.testing.expectError(error.Bad, theProblem()) catch @panic("test failed");
591	ok = true;	591	ok = true;
592	}	592	}
593		593
...	@@ -602,7 +602,7 @@ test "try in an async function with error union and non-zero-bit payload" {	...	@@ -602,7 +602,7 @@ test "try in an async function with error union and non-zero-bit payload" {
602	return error.Bad;	602	return error.Bad;
603	}	603	}
604	};	604	};
605	S.doTheTest();	605	try S.doTheTest();
606	}	606	}
607		607
608	test "returning a const error from async function" {	608	test "returning a const error from async function" {
...	@@ -610,10 +610,10 @@ test "returning a const error from async function" {	...	@@ -610,10 +610,10 @@ test "returning a const error from async function" {
610	var frame: anyframe = undefined;	610	var frame: anyframe = undefined;
611	var ok = false;	611	var ok = false;
612		612
613	fn doTheTest() void {	613	fn doTheTest() !void {
614	_ = async amain();	614	_ = async amain();
615	resume frame;	615	resume frame;
616	expect(ok);	616	try expect(ok);
617	}	617	}
618		618
619	fn amain() !void {	619	fn amain() !void {
...	@@ -630,7 +630,7 @@ test "returning a const error from async function" {	...	@@ -630,7 +630,7 @@ test "returning a const error from async function" {
630	return error.OutOfMemory;	630	return error.OutOfMemory;
631	}	631	}
632	};	632	};
633	S.doTheTest();	633	try S.doTheTest();
634	}	634	}
635		635
636	test "async/await typical usage" {	636	test "async/await typical usage" {
...	@@ -663,11 +663,11 @@ fn testAsyncAwaitTypicalUsage(	...	@@ -663,11 +663,11 @@ fn testAsyncAwaitTypicalUsage(
663	}	663	}
664	fn amainWrap() void {	664	fn amainWrap() void {
665	if (amain()) \|_\| {	665	if (amain()) \|_\| {
666	expect(!simulate_fail_download);	666	expect(!simulate_fail_download) catch @panic("test failure");
667	expect(!simulate_fail_file);	667	expect(!simulate_fail_file) catch @panic("test failure");
668	} else \|e\| switch (e) {	668	} else \|e\| switch (e) {
669	error.NoResponse => expect(simulate_fail_download),	669	error.NoResponse => expect(simulate_fail_download) catch @panic("test failure"),
670	error.FileNotFound => expect(simulate_fail_file),	670	error.FileNotFound => expect(simulate_fail_file) catch @panic("test failure"),
671	else => @panic("test failure"),	671	else => @panic("test failure"),
672	}	672	}
673	}	673	}
...	@@ -694,8 +694,8 @@ fn testAsyncAwaitTypicalUsage(	...	@@ -694,8 +694,8 @@ fn testAsyncAwaitTypicalUsage(
694	const file_text = try await file_frame;	694	const file_text = try await file_frame;
695	defer allocator.free(file_text);	695	defer allocator.free(file_text);
696		696
697	expect(std.mem.eql(u8, "expected download text", download_text));	697	try expect(std.mem.eql(u8, "expected download text", download_text));
698	expect(std.mem.eql(u8, "expected file text", file_text));	698	try expect(std.mem.eql(u8, "expected file text", file_text));
699	}	699	}
700		700
701	var global_download_frame: anyframe = undefined;	701	var global_download_frame: anyframe = undefined;
...	@@ -728,13 +728,13 @@ fn testAsyncAwaitTypicalUsage(	...	@@ -728,13 +728,13 @@ fn testAsyncAwaitTypicalUsage(
728		728
729	test "alignment of local variables in async functions" {	729	test "alignment of local variables in async functions" {
730	const S = struct {	730	const S = struct {
731	fn doTheTest() void {	731	fn doTheTest() !void {
732	var y: u8 = 123;	732	var y: u8 = 123;
733	var x: u8 align(128) = 1;	733	var x: u8 align(128) = 1;
734	expect(@ptrToInt(&x) % 128 == 0);	734	try expect(@ptrToInt(&x) % 128 == 0);
735	}	735	}
736	};	736	};
737	S.doTheTest();	737	try S.doTheTest();
738	}	738	}
739		739
740	test "no reason to resolve frame still works" {	740	test "no reason to resolve frame still works" {
...	@@ -746,10 +746,10 @@ fn simpleNothing() void {	...	@@ -746,10 +746,10 @@ fn simpleNothing() void {
746		746
747	test "async call a generic function" {	747	test "async call a generic function" {
748	const S = struct {	748	const S = struct {
749	fn doTheTest() void {	749	fn doTheTest() !void {
750	var f = async func(i32, 2);	750	var f = async func(i32, 2);
751	const result = await f;	751	const result = await f;
752	expect(result == 3);	752	try expect(result == 3);
753	}	753	}
754		754
755	fn func(comptime T: type, inc: T) T {	755	fn func(comptime T: type, inc: T) T {
...	@@ -766,8 +766,8 @@ test "async call a generic function" {	...	@@ -766,8 +766,8 @@ test "async call a generic function" {
766		766
767	test "return from suspend block" {	767	test "return from suspend block" {
768	const S = struct {	768	const S = struct {
769	fn doTheTest() void {	769	fn doTheTest() !void {
770	expect(func() == 1234);	770	expect(func() == 1234) catch @panic("test failure");
771	}	771	}
772	fn func() i32 {	772	fn func() i32 {
773	suspend {	773	suspend {
...	@@ -808,7 +808,7 @@ test "struct parameter to async function is copied to the frame" {	...	@@ -808,7 +808,7 @@ test "struct parameter to async function is copied to the frame" {
808	var pt = Point{ .x = 1, .y = 2 };	808	var pt = Point{ .x = 1, .y = 2 };
809	f.* = async foo(pt);	809	f.* = async foo(pt);
810	var result = await f;	810	var result = await f;
811	expect(result == 1);	811	expect(result == 1) catch @panic("test failure");
812	}	812	}
813		813
814	fn foo(point: Point) i32 {	814	fn foo(point: Point) i32 {
...	@@ -833,7 +833,7 @@ test "cast fn to async fn when it is inferred to be async" {	...	@@ -833,7 +833,7 @@ test "cast fn to async fn when it is inferred to be async" {
833	var result: i32 = undefined;	833	var result: i32 = undefined;
834	const f = @asyncCall(&buf, &result, ptr, .{});	834	const f = @asyncCall(&buf, &result, ptr, .{});
835	_ = await f;	835	_ = await f;
836	expect(result == 1234);	836	expect(result == 1234) catch @panic("test failure");
837	ok = true;	837	ok = true;
838	}	838	}
839		839
...	@@ -846,7 +846,7 @@ test "cast fn to async fn when it is inferred to be async" {	...	@@ -846,7 +846,7 @@ test "cast fn to async fn when it is inferred to be async" {
846	};	846	};
847	_ = async S.doTheTest();	847	_ = async S.doTheTest();
848	resume S.frame;	848	resume S.frame;
849	expect(S.ok);	849	try expect(S.ok);
850	}	850	}
851		851
852	test "cast fn to async fn when it is inferred to be async, awaited directly" {	852	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" {	...	@@ -860,7 +860,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
860	var buf: [100]u8 align(16) = undefined;	860	var buf: [100]u8 align(16) = undefined;
861	var result: i32 = undefined;	861	var result: i32 = undefined;
862	_ = await @asyncCall(&buf, &result, ptr, .{});	862	_ = await @asyncCall(&buf, &result, ptr, .{});
863	expect(result == 1234);	863	expect(result == 1234) catch @panic("test failure");
864	ok = true;	864	ok = true;
865	}	865	}
866		866
...	@@ -873,7 +873,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {	...	@@ -873,7 +873,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" {
873	};	873	};
874	_ = async S.doTheTest();	874	_ = async S.doTheTest();
875	resume S.frame;	875	resume S.frame;
876	expect(S.ok);	876	try expect(S.ok);
877	}	877	}
878		878
879	test "await does not force async if callee is blocking" {	879	test "await does not force async if callee is blocking" {
...	@@ -883,12 +883,12 @@ test "await does not force async if callee is blocking" {	...	@@ -883,12 +883,12 @@ test "await does not force async if callee is blocking" {
883	}	883	}
884	};	884	};
885	var x = async S.simple();	885	var x = async S.simple();
886	expect(await x == 1234);	886	try expect(await x == 1234);
887	}	887	}
888		888
889	test "recursive async function" {	889	test "recursive async function" {
890	expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);	890	try expect(recursiveAsyncFunctionTest(false).doTheTest() == 55);
891	expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);	891	try expect(recursiveAsyncFunctionTest(true).doTheTest() == 55);
892	}	892	}
893		893
894	fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {	894	fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
...	@@ -952,12 +952,12 @@ test "@asyncCall with comptime-known function, but not awaited directly" {	...	@@ -952,12 +952,12 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
952	const S = struct {	952	const S = struct {
953	var global_frame: anyframe = undefined;	953	var global_frame: anyframe = undefined;
954		954
955	fn doTheTest() void {	955	fn doTheTest() !void {
956	var frame: [1]@Frame(middle) = undefined;	956	var frame: [1]@Frame(middle) = undefined;
957	var result: @typeInfo(@typeInfo(@TypeOf(middle)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;	957	var result: @typeInfo(@typeInfo(@TypeOf(middle)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
958	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{});	958	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{});
959	resume global_frame;	959	resume global_frame;
960	std.testing.expectError(error.Fail, result);	960	try std.testing.expectError(error.Fail, result);
961	}	961	}
962	fn middle() callconv(.Async) !void {	962	fn middle() callconv(.Async) !void {
963	var f = async middle2();	963	var f = async middle2();
...	@@ -974,7 +974,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {	...	@@ -974,7 +974,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
974	return error.Fail;	974	return error.Fail;
975	}	975	}
976	};	976	};
977	S.doTheTest();	977	try S.doTheTest();
978	}	978	}
979		979
980	test "@asyncCall with actual frame instead of byte buffer" {	980	test "@asyncCall with actual frame instead of byte buffer" {
...	@@ -988,7 +988,7 @@ test "@asyncCall with actual frame instead of byte buffer" {	...	@@ -988,7 +988,7 @@ test "@asyncCall with actual frame instead of byte buffer" {
988	var result: i32 = undefined;	988	var result: i32 = undefined;
989	const ptr = @asyncCall(&frame, &result, S.func, .{});	989	const ptr = @asyncCall(&frame, &result, S.func, .{});
990	resume ptr;	990	resume ptr;
991	expect(result == 1234);	991	try expect(result == 1234);
992	}	992	}
993		993
994	test "@asyncCall using the result location inside the frame" {	994	test "@asyncCall using the result location inside the frame" {
...	@@ -1010,19 +1010,19 @@ test "@asyncCall using the result location inside the frame" {	...	@@ -1010,19 +1010,19 @@ test "@asyncCall using the result location inside the frame" {
1010	var foo = Foo{ .bar = S.simple2 };	1010	var foo = Foo{ .bar = S.simple2 };
1011	var bytes: [64]u8 align(16) = undefined;	1011	var bytes: [64]u8 align(16) = undefined;
1012	const f = @asyncCall(&bytes, {}, foo.bar, .{&data});	1012	const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
1013	comptime expect(@TypeOf(f) == anyframe->i32);	1013	comptime try expect(@TypeOf(f) == anyframe->i32);
1014	expect(data == 2);	1014	try expect(data == 2);
1015	resume f;	1015	resume f;
1016	expect(data == 4);	1016	try expect(data == 4);
1017	_ = async S.getAnswer(f, &data);	1017	_ = async S.getAnswer(f, &data);
1018	expect(data == 1234);	1018	try expect(data == 1234);
1019	}	1019	}
1020		1020
1021	test "@TypeOf an async function call of generic fn with error union type" {	1021	test "@TypeOf an async function call of generic fn with error union type" {
1022	const S = struct {	1022	const S = struct {
1023	fn func(comptime x: anytype) anyerror!i32 {	1023	fn func(comptime x: anytype) anyerror!i32 {
1024	const T = @TypeOf(async func(x));	1024	const T = @TypeOf(async func(x));
1025	comptime expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child);	1025	comptime try expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child);
1026	return undefined;	1026	return undefined;
1027	}	1027	}
1028	};	1028	};
...	@@ -1051,7 +1051,7 @@ test "using @TypeOf on a generic function call" {	...	@@ -1051,7 +1051,7 @@ test "using @TypeOf on a generic function call" {
1051	};	1051	};
1052	_ = async S.amain(@as(u32, 1));	1052	_ = async S.amain(@as(u32, 1));
1053	resume S.global_frame;	1053	resume S.global_frame;
1054	expect(S.global_ok);	1054	try expect(S.global_ok);
1055	}	1055	}
1056		1056
1057	test "recursive call of await @asyncCall with struct return type" {	1057	test "recursive call of await @asyncCall with struct return type" {
...	@@ -1084,17 +1084,17 @@ test "recursive call of await @asyncCall with struct return type" {	...	@@ -1084,17 +1084,17 @@ test "recursive call of await @asyncCall with struct return type" {
1084	var frame: @TypeOf(async S.amain(@as(u32, 1))) = undefined;	1084	var frame: @TypeOf(async S.amain(@as(u32, 1))) = undefined;
1085	_ = @asyncCall(&frame, &res, S.amain, .{@as(u32, 1)});	1085	_ = @asyncCall(&frame, &res, S.amain, .{@as(u32, 1)});
1086	resume S.global_frame;	1086	resume S.global_frame;
1087	expect(S.global_ok);	1087	try expect(S.global_ok);
1088	expect(res.x == 1);	1088	try expect(res.x == 1);
1089	expect(res.y == 2);	1089	try expect(res.y == 2);
1090	expect(res.z == 3);	1090	try expect(res.z == 3);
1091	}	1091	}
1092		1092
1093	test "nosuspend function call" {	1093	test "nosuspend function call" {
1094	const S = struct {	1094	const S = struct {
1095	fn doTheTest() void {	1095	fn doTheTest() !void {
1096	const result = nosuspend add(50, 100);	1096	const result = nosuspend add(50, 100);
1097	expect(result == 150);	1097	try expect(result == 150);
1098	}	1098	}
1099	fn add(a: i32, b: i32) i32 {	1099	fn add(a: i32, b: i32) i32 {
1100	if (a > 100) {	1100	if (a > 100) {
...	@@ -1103,7 +1103,7 @@ test "nosuspend function call" {	...	@@ -1103,7 +1103,7 @@ test "nosuspend function call" {
1103	return a + b;	1103	return a + b;
1104	}	1104	}
1105	};	1105	};
1106	S.doTheTest();	1106	try S.doTheTest();
1107	}	1107	}
1108		1108
1109	test "await used in expression and awaiting fn with no suspend but async calling convention" {	1109	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	...	@@ -1113,7 +1113,7 @@ test "await used in expression and awaiting fn with no suspend but async calling
1113	var f2 = async add(3, 4);	1113	var f2 = async add(3, 4);
1114		1114
1115	const sum = (await f1) + (await f2);	1115	const sum = (await f1) + (await f2);
1116	expect(sum == 10);	1116	expect(sum == 10) catch @panic("test failure");
1117	}	1117	}
1118	fn add(a: i32, b: i32) callconv(.Async) i32 {	1118	fn add(a: i32, b: i32) callconv(.Async) i32 {
1119	return a + b;	1119	return a + b;
...	@@ -1128,7 +1128,7 @@ test "await used in expression after a fn call" {	...	@@ -1128,7 +1128,7 @@ test "await used in expression after a fn call" {
1128	var f1 = async add(3, 4);	1128	var f1 = async add(3, 4);
1129	var sum: i32 = 0;	1129	var sum: i32 = 0;
1130	sum = foo() + await f1;	1130	sum = foo() + await f1;
1131	expect(sum == 8);	1131	expect(sum == 8) catch @panic("test failure");
1132	}	1132	}
1133	fn add(a: i32, b: i32) callconv(.Async) i32 {	1133	fn add(a: i32, b: i32) callconv(.Async) i32 {
1134	return a + b;	1134	return a + b;
...	@@ -1145,7 +1145,7 @@ test "async fn call used in expression after a fn call" {	...	@@ -1145,7 +1145,7 @@ test "async fn call used in expression after a fn call" {
1145	fn atest() void {	1145	fn atest() void {
1146	var sum: i32 = 0;	1146	var sum: i32 = 0;
1147	sum = foo() + add(3, 4);	1147	sum = foo() + add(3, 4);
1148	expect(sum == 8);	1148	expect(sum == 8) catch @panic("test failure");
1149	}	1149	}
1150	fn add(a: i32, b: i32) callconv(.Async) i32 {	1150	fn add(a: i32, b: i32) callconv(.Async) i32 {
1151	return a + b;	1151	return a + b;
...	@@ -1167,7 +1167,7 @@ test "suspend in for loop" {	...	@@ -1167,7 +1167,7 @@ test "suspend in for loop" {
1167	}	1167	}
1168		1168
1169	fn atest() void {	1169	fn atest() void {
1170	expect(func(&[_]u8{ 1, 2, 3 }) == 6);	1170	expect(func(&[_]u8{ 1, 2, 3 }) == 6) catch @panic("test failure");
1171	}	1171	}
1172	fn func(stuff: []const u8) u32 {	1172	fn func(stuff: []const u8) u32 {
1173	global_frame = @frame();	1173	global_frame = @frame();
...	@@ -1193,8 +1193,8 @@ test "suspend in while loop" {	...	@@ -1193,8 +1193,8 @@ test "suspend in while loop" {
1193	}	1193	}
1194		1194
1195	fn atest() void {	1195	fn atest() void {
1196	expect(optional(6) == 6);	1196	expect(optional(6) == 6) catch @panic("test failure");
1197	expect(errunion(6) == 6);	1197	expect(errunion(6) == 6) catch @panic("test failure");
1198	}	1198	}
1199	fn optional(stuff: ?u32) u32 {	1199	fn optional(stuff: ?u32) u32 {
1200	global_frame = @frame();	1200	global_frame = @frame();
...	@@ -1223,8 +1223,8 @@ test "correctly spill when returning the error union result of another async fn"	...	@@ -1223,8 +1223,8 @@ test "correctly spill when returning the error union result of another async fn"
1223	const S = struct {	1223	const S = struct {
1224	var global_frame: anyframe = undefined;	1224	var global_frame: anyframe = undefined;
1225		1225
1226	fn doTheTest() void {	1226	fn doTheTest() !void {
1227	expect((atest() catch unreachable) == 1234);	1227	expect((atest() catch unreachable) == 1234) catch @panic("test failure");
1228	}	1228	}
1229		1229
1230	fn atest() !i32 {	1230	fn atest() !i32 {
...	@@ -1246,11 +1246,11 @@ test "spill target expr in a for loop" {	...	@@ -1246,11 +1246,11 @@ test "spill target expr in a for loop" {
1246	const S = struct {	1246	const S = struct {
1247	var global_frame: anyframe = undefined;	1247	var global_frame: anyframe = undefined;
1248		1248
1249	fn doTheTest() void {	1249	fn doTheTest() !void {
1250	var foo = Foo{	1250	var foo = Foo{
1251	.slice = &[_]i32{ 1, 2 },	1251	.slice = &[_]i32{ 1, 2 },
1252	};	1252	};
1253	expect(atest(&foo) == 3);	1253	expect(atest(&foo) == 3) catch @panic("test failure");
1254	}	1254	}
1255		1255
1256	const Foo = struct {	1256	const Foo = struct {
...	@@ -1277,11 +1277,11 @@ test "spill target expr in a for loop, with a var decl in the loop body" {	...	@@ -1277,11 +1277,11 @@ test "spill target expr in a for loop, with a var decl in the loop body" {
1277	const S = struct {	1277	const S = struct {
1278	var global_frame: anyframe = undefined;	1278	var global_frame: anyframe = undefined;
1279		1279
1280	fn doTheTest() void {	1280	fn doTheTest() !void {
1281	var foo = Foo{	1281	var foo = Foo{
1282	.slice = &[_]i32{ 1, 2 },	1282	.slice = &[_]i32{ 1, 2 },
1283	};	1283	};
1284	expect(atest(&foo) == 3);	1284	expect(atest(&foo) == 3) catch @panic("test failure");
1285	}	1285	}
1286		1286
1287	const Foo = struct {	1287	const Foo = struct {
...	@@ -1319,7 +1319,7 @@ test "async call with @call" {	...	@@ -1319,7 +1319,7 @@ test "async call with @call" {
1319	fn atest() void {	1319	fn atest() void {
1320	var frame = @call(.{ .modifier = .async_kw }, afoo, .{});	1320	var frame = @call(.{ .modifier = .async_kw }, afoo, .{});
1321	const res = await frame;	1321	const res = await frame;
1322	expect(res == 42);	1322	expect(res == 42) catch @panic("test failure");
1323	}	1323	}
1324	fn afoo() i32 {	1324	fn afoo() i32 {
1325	suspend {	1325	suspend {
...	@@ -1348,7 +1348,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {	...	@@ -1348,7 +1348,7 @@ test "async function passed 0-bit arg after non-0-bit arg" {
1348	};	1348	};
1349	_ = async S.foo();	1349	_ = async S.foo();
1350	resume S.global_frame;	1350	resume S.global_frame;
1351	expect(S.global_int == 1);	1351	try expect(S.global_int == 1);
1352	}	1352	}
1353		1353
1354	test "async function passed align(16) arg after align(8) arg" {	1354	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" {	...	@@ -1362,7 +1362,7 @@ test "async function passed align(16) arg after align(8) arg" {
1362	}	1362	}
1363		1363
1364	fn bar(x: u64, args: anytype) anyerror!void {	1364	fn bar(x: u64, args: anytype) anyerror!void {
1365	expect(x == 10);	1365	try expect(x == 10);
1366	global_frame = @frame();	1366	global_frame = @frame();
1367	suspend {}	1367	suspend {}
1368	global_int = args[0];	1368	global_int = args[0];
...	@@ -1370,7 +1370,7 @@ test "async function passed align(16) arg after align(8) arg" {	...	@@ -1370,7 +1370,7 @@ test "async function passed align(16) arg after align(8) arg" {
1370	};	1370	};
1371	_ = async S.foo();	1371	_ = async S.foo();
1372	resume S.global_frame;	1372	resume S.global_frame;
1373	expect(S.global_int == 99);	1373	try expect(S.global_int == 99);
1374	}	1374	}
1375		1375
1376	test "async function call resolves target fn frame, comptime func" {	1376	test "async function call resolves target fn frame, comptime func" {
...	@@ -1392,7 +1392,7 @@ test "async function call resolves target fn frame, comptime func" {	...	@@ -1392,7 +1392,7 @@ test "async function call resolves target fn frame, comptime func" {
1392	};	1392	};
1393	_ = async S.foo();	1393	_ = async S.foo();
1394	resume S.global_frame;	1394	resume S.global_frame;
1395	expect(S.global_int == 10);	1395	try expect(S.global_int == 10);
1396	}	1396	}
1397		1397
1398	test "async function call resolves target fn frame, runtime func" {	1398	test "async function call resolves target fn frame, runtime func" {
...	@@ -1415,7 +1415,7 @@ test "async function call resolves target fn frame, runtime func" {	...	@@ -1415,7 +1415,7 @@ test "async function call resolves target fn frame, runtime func" {
1415	};	1415	};
1416	_ = async S.foo();	1416	_ = async S.foo();
1417	resume S.global_frame;	1417	resume S.global_frame;
1418	expect(S.global_int == 10);	1418	try expect(S.global_int == 10);
1419	}	1419	}
1420		1420
1421	test "properly spill optional payload capture value" {	1421	test "properly spill optional payload capture value" {
...	@@ -1439,7 +1439,7 @@ test "properly spill optional payload capture value" {	...	@@ -1439,7 +1439,7 @@ test "properly spill optional payload capture value" {
1439	};	1439	};
1440	_ = async S.foo();	1440	_ = async S.foo();
1441	resume S.global_frame;	1441	resume S.global_frame;
1442	expect(S.global_int == 1237);	1442	try expect(S.global_int == 1237);
1443	}	1443	}
1444		1444
1445	test "handle defer interfering with return value spill" {	1445	test "handle defer interfering with return value spill" {
...	@@ -1449,16 +1449,16 @@ test "handle defer interfering with return value spill" {	...	@@ -1449,16 +1449,16 @@ test "handle defer interfering with return value spill" {
1449	var finished = false;	1449	var finished = false;
1450	var baz_happened = false;	1450	var baz_happened = false;
1451		1451
1452	fn doTheTest() void {	1452	fn doTheTest() !void {
1453	_ = async testFoo();	1453	_ = async testFoo();
1454	resume global_frame1;	1454	resume global_frame1;
1455	resume global_frame2;	1455	resume global_frame2;
1456	expect(baz_happened);	1456	try expect(baz_happened);
1457	expect(finished);	1457	try expect(finished);
1458	}	1458	}
1459		1459
1460	fn testFoo() void {	1460	fn testFoo() void {
1461	expectError(error.Bad, foo());	1461	expectError(error.Bad, foo()) catch @panic("test failure");
1462	finished = true;	1462	finished = true;
1463	}	1463	}
1464		1464
...	@@ -1479,7 +1479,7 @@ test "handle defer interfering with return value spill" {	...	@@ -1479,7 +1479,7 @@ test "handle defer interfering with return value spill" {
1479	baz_happened = true;	1479	baz_happened = true;
1480	}	1480	}
1481	};	1481	};
1482	S.doTheTest();	1482	try S.doTheTest();
1483	}	1483	}
1484		1484
1485	test "take address of temporary async frame" {	1485	test "take address of temporary async frame" {
...	@@ -1487,14 +1487,14 @@ test "take address of temporary async frame" {	...	@@ -1487,14 +1487,14 @@ test "take address of temporary async frame" {
1487	var global_frame: anyframe = undefined;	1487	var global_frame: anyframe = undefined;
1488	var finished = false;	1488	var finished = false;
1489		1489
1490	fn doTheTest() void {	1490	fn doTheTest() !void {
1491	_ = async asyncDoTheTest();	1491	_ = async asyncDoTheTest();
1492	resume global_frame;	1492	resume global_frame;
1493	expect(finished);	1493	try expect(finished);
1494	}	1494	}
1495		1495
1496	fn asyncDoTheTest() void {	1496	fn asyncDoTheTest() void {
1497	expect(finishIt(&async foo(10)) == 1245);	1497	expect(finishIt(&async foo(10)) == 1245) catch @panic("test failure");
1498	finished = true;	1498	finished = true;
1499	}	1499	}
1500		1500
...	@@ -1508,16 +1508,16 @@ test "take address of temporary async frame" {	...	@@ -1508,16 +1508,16 @@ test "take address of temporary async frame" {
1508	return (await frame) + 1;	1508	return (await frame) + 1;
1509	}	1509	}
1510	};	1510	};
1511	S.doTheTest();	1511	try S.doTheTest();
1512	}	1512	}
1513		1513
1514	test "nosuspend await" {	1514	test "nosuspend await" {
1515	const S = struct {	1515	const S = struct {
1516	var finished = false;	1516	var finished = false;
1517		1517
1518	fn doTheTest() void {	1518	fn doTheTest() !void {
1519	var frame = async foo(false);	1519	var frame = async foo(false);
1520	expect(nosuspend await frame == 42);	1520	try expect(nosuspend await frame == 42);
1521	finished = true;	1521	finished = true;
1522	}	1522	}
1523		1523
...	@@ -1528,8 +1528,8 @@ test "nosuspend await" {	...	@@ -1528,8 +1528,8 @@ test "nosuspend await" {
1528	return 42;	1528	return 42;
1529	}	1529	}
1530	};	1530	};
1531	S.doTheTest();	1531	try S.doTheTest();
1532	expect(S.finished);	1532	try expect(S.finished);
1533	}	1533	}
1534		1534
1535	test "nosuspend on function calls" {	1535	test "nosuspend on function calls" {
...	@@ -1544,8 +1544,8 @@ test "nosuspend on function calls" {	...	@@ -1544,8 +1544,8 @@ test "nosuspend on function calls" {
1544	return S0{};	1544	return S0{};
1545	}	1545	}
1546	};	1546	};
1547	expectEqual(@as(i32, 42), nosuspend S1.c().b);	1547	try expectEqual(@as(i32, 42), nosuspend S1.c().b);
1548	expectEqual(@as(i32, 42), (try nosuspend S1.d()).b);	1548	try expectEqual(@as(i32, 42), (try nosuspend S1.d()).b);
1549	}	1549	}
1550		1550
1551	test "nosuspend on async function calls" {	1551	test "nosuspend on async function calls" {
...	@@ -1561,9 +1561,9 @@ test "nosuspend on async function calls" {	...	@@ -1561,9 +1561,9 @@ test "nosuspend on async function calls" {
1561	}	1561	}
1562	};	1562	};
1563	var frame_c = nosuspend async S1.c();	1563	var frame_c = nosuspend async S1.c();
1564	expectEqual(@as(i32, 42), (await frame_c).b);	1564	try expectEqual(@as(i32, 42), (await frame_c).b);
1565	var frame_d = nosuspend async S1.d();	1565	var frame_d = nosuspend async S1.d();
1566	expectEqual(@as(i32, 42), (try await frame_d).b);	1566	try expectEqual(@as(i32, 42), (try await frame_d).b);
1567	}	1567	}
1568		1568
1569	// test "resume nosuspend async function calls" {	1569	// test "resume nosuspend async function calls" {
...	@@ -1582,10 +1582,10 @@ test "nosuspend on async function calls" {	...	@@ -1582,10 +1582,10 @@ test "nosuspend on async function calls" {
1582	// };	1582	// };
1583	// var frame_c = nosuspend async S1.c();	1583	// var frame_c = nosuspend async S1.c();
1584	// resume frame_c;	1584	// resume frame_c;
1585	// expectEqual(@as(i32, 42), (await frame_c).b);	1585	// try expectEqual(@as(i32, 42), (await frame_c).b);
1586	// var frame_d = nosuspend async S1.d();	1586	// var frame_d = nosuspend async S1.d();
1587	// resume frame_d;	1587	// resume frame_d;
1588	// expectEqual(@as(i32, 42), (try await frame_d).b);	1588	// try expectEqual(@as(i32, 42), (try await frame_d).b);
1589	// }	1589	// }
1590		1590
1591	test "nosuspend resume async function calls" {	1591	test "nosuspend resume async function calls" {
...	@@ -1604,10 +1604,10 @@ test "nosuspend resume async function calls" {	...	@@ -1604,10 +1604,10 @@ test "nosuspend resume async function calls" {
1604	};	1604	};
1605	var frame_c = async S1.c();	1605	var frame_c = async S1.c();
1606	nosuspend resume frame_c;	1606	nosuspend resume frame_c;
1607	expectEqual(@as(i32, 42), (await frame_c).b);	1607	try expectEqual(@as(i32, 42), (await frame_c).b);
1608	var frame_d = async S1.d();	1608	var frame_d = async S1.d();
1609	nosuspend resume frame_d;	1609	nosuspend resume frame_d;
1610	expectEqual(@as(i32, 42), (try await frame_d).b);	1610	try expectEqual(@as(i32, 42), (try await frame_d).b);
1611	}	1611	}
1612		1612
1613	test "avoid forcing frame alignment resolution implicit cast to *c_void" {	1613	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" {	...	@@ -1623,7 +1623,7 @@ test "avoid forcing frame alignment resolution implicit cast to *c_void" {
1623	};	1623	};
1624	var frame = async S.foo();	1624	var frame = async S.foo();
1625	resume @ptrCast(anyframe->bool, @alignCast(@alignOf(@Frame(S.foo)), S.x));	1625	resume @ptrCast(anyframe->bool, @alignCast(@alignOf(@Frame(S.foo)), S.x));
1626	expect(nosuspend await frame);	1626	try expect(nosuspend await frame);
1627	}	1627	}
1628		1628
1629	test "@asyncCall with pass-by-value arguments" {	1629	test "@asyncCall with pass-by-value arguments" {
...	@@ -1638,9 +1638,9 @@ test "@asyncCall with pass-by-value arguments" {	...	@@ -1638,9 +1638,9 @@ test "@asyncCall with pass-by-value arguments" {
1638	pub fn f(_fill0: u64, s: ST, _fill1: u64, a: AT, _fill2: u64) callconv(.Async) void {	1638	pub fn f(_fill0: u64, s: ST, _fill1: u64, a: AT, _fill2: u64) callconv(.Async) void {
1639	// Check that the array and struct arguments passed by value don't	1639	// Check that the array and struct arguments passed by value don't
1640	// end up overflowing the adjacent fields in the frame structure.	1640	// end up overflowing the adjacent fields in the frame structure.
1641	expectEqual(F0, _fill0);	1641	expectEqual(F0, _fill0) catch @panic("test failure");
1642	expectEqual(F1, _fill1);	1642	expectEqual(F1, _fill1) catch @panic("test failure");
1643	expectEqual(F2, _fill2);	1643	expectEqual(F2, _fill2) catch @panic("test failure");
1644	}	1644	}
1645	};	1645	};
1646		1646
...	@@ -1664,8 +1664,8 @@ test "@asyncCall with arguments having non-standard alignment" {	...	@@ -1664,8 +1664,8 @@ test "@asyncCall with arguments having non-standard alignment" {
1664	pub fn f(_fill0: u32, s: struct { x: u64 align(16) }, _fill1: u64) callconv(.Async) void {	1664	pub fn f(_fill0: u32, s: struct { x: u64 align(16) }, _fill1: u64) callconv(.Async) void {
1665	// The compiler inserts extra alignment for s, check that the	1665	// The compiler inserts extra alignment for s, check that the
1666	// generated code picks the right slot for fill1.	1666	// generated code picks the right slot for fill1.
1667	expectEqual(F0, _fill0);	1667	expectEqual(F0, _fill0) catch @panic("test failure");
1668	expectEqual(F1, _fill1);	1668	expectEqual(F1, _fill1) catch @panic("test failure");
1669	}	1669	}
1670	};	1670	};
1671		1671

test/stage1/behavior/atomics.zig+69-69

...	@@ -4,25 +4,25 @@ const expectEqual = std.testing.expectEqual;	...	@@ -4,25 +4,25 @@ const expectEqual = std.testing.expectEqual;
4	const builtin = @import("builtin");	4	const builtin = @import("builtin");
5		5
6	test "cmpxchg" {	6	test "cmpxchg" {
7	testCmpxchg();	7	try testCmpxchg();
8	comptime testCmpxchg();	8	comptime try testCmpxchg();
9	}	9	}
10		10
11	fn testCmpxchg() void {	11	fn testCmpxchg() !void {
12	var x: i32 = 1234;	12	var x: i32 = 1234;
13	if (@cmpxchgWeak(i32, &x, 99, 5678, .SeqCst, .SeqCst)) \|x1\| {	13	if (@cmpxchgWeak(i32, &x, 99, 5678, .SeqCst, .SeqCst)) \|x1\| {
14	expect(x1 == 1234);	14	try expect(x1 == 1234);
15	} else {	15	} else {
16	@panic("cmpxchg should have failed");	16	@panic("cmpxchg should have failed");
17	}	17	}
18		18
19	while (@cmpxchgWeak(i32, &x, 1234, 5678, .SeqCst, .SeqCst)) \|x1\| {	19	while (@cmpxchgWeak(i32, &x, 1234, 5678, .SeqCst, .SeqCst)) \|x1\| {
20	expect(x1 == 1234);	20	try expect(x1 == 1234);
21	}	21	}
22	expect(x == 5678);	22	try expect(x == 5678);
23		23
24	expect(@cmpxchgStrong(i32, &x, 5678, 42, .SeqCst, .SeqCst) == null);	24	try expect(@cmpxchgStrong(i32, &x, 5678, 42, .SeqCst, .SeqCst) == null);
25	expect(x == 42);	25	try expect(x == 42);
26	}	26	}
27		27
28	test "fence" {	28	test "fence" {
...	@@ -33,25 +33,25 @@ test "fence" {	...	@@ -33,25 +33,25 @@ test "fence" {
33		33
34	test "atomicrmw and atomicload" {	34	test "atomicrmw and atomicload" {
35	var data: u8 = 200;	35	var data: u8 = 200;
36	testAtomicRmw(&data);	36	try testAtomicRmw(&data);
37	expect(data == 42);	37	try expect(data == 42);
38	testAtomicLoad(&data);	38	try testAtomicLoad(&data);
39	}	39	}
40		40
41	fn testAtomicRmw(ptr: *u8) void {	41	fn testAtomicRmw(ptr: *u8) !void {
42	const prev_value = @atomicRmw(u8, ptr, .Xchg, 42, .SeqCst);	42	const prev_value = @atomicRmw(u8, ptr, .Xchg, 42, .SeqCst);
43	expect(prev_value == 200);	43	try expect(prev_value == 200);
44	comptime {	44	comptime {
45	var x: i32 = 1234;	45	var x: i32 = 1234;
46	const y: i32 = 12345;	46	const y: i32 = 12345;
47	expect(@atomicLoad(i32, &x, .SeqCst) == 1234);	47	try expect(@atomicLoad(i32, &x, .SeqCst) == 1234);
48	expect(@atomicLoad(i32, &y, .SeqCst) == 12345);	48	try expect(@atomicLoad(i32, &y, .SeqCst) == 12345);
49	}	49	}
50	}	50	}
51		51
52	fn testAtomicLoad(ptr: *u8) void {	52	fn testAtomicLoad(ptr: *u8) !void {
53	const x = @atomicLoad(u8, ptr, .SeqCst);	53	const x = @atomicLoad(u8, ptr, .SeqCst);
54	expect(x == 42);	54	try expect(x == 42);
55	}	55	}
56		56
57	test "cmpxchg with ptr" {	57	test "cmpxchg with ptr" {
...	@@ -60,18 +60,18 @@ test "cmpxchg with ptr" {	...	@@ -60,18 +60,18 @@ test "cmpxchg with ptr" {
60	var data3: i32 = 9101;	60	var data3: i32 = 9101;
61	var x: *i32 = &data1;	61	var x: *i32 = &data1;
62	if (@cmpxchgWeak(*i32, &x, &data2, &data3, .SeqCst, .SeqCst)) \|x1\| {	62	if (@cmpxchgWeak(*i32, &x, &data2, &data3, .SeqCst, .SeqCst)) \|x1\| {
63	expect(x1 == &data1);	63	try expect(x1 == &data1);
64	} else {	64	} else {
65	@panic("cmpxchg should have failed");	65	@panic("cmpxchg should have failed");
66	}	66	}
67		67
68	while (@cmpxchgWeak(*i32, &x, &data1, &data3, .SeqCst, .SeqCst)) \|x1\| {	68	while (@cmpxchgWeak(*i32, &x, &data1, &data3, .SeqCst, .SeqCst)) \|x1\| {
69	expect(x1 == &data1);	69	try expect(x1 == &data1);
70	}	70	}
71	expect(x == &data3);	71	try expect(x == &data3);
72		72
73	expect(@cmpxchgStrong(*i32, &x, &data3, &data2, .SeqCst, .SeqCst) == null);	73	try expect(@cmpxchgStrong(*i32, &x, &data3, &data2, .SeqCst, .SeqCst) == null);
74	expect(x == &data2);	74	try expect(x == &data2);
75	}	75	}
76		76
77	// TODO this test is disabled until this issue is resolved:	77	// TODO this test is disabled until this issue is resolved:
...	@@ -81,18 +81,18 @@ test "cmpxchg with ptr" {	...	@@ -81,18 +81,18 @@ test "cmpxchg with ptr" {
81	//test "128-bit cmpxchg" {	81	//test "128-bit cmpxchg" {
82	// var x: u128 align(16) = 1234; // TODO: https://github.com/ziglang/zig/issues/2987	82	// var x: u128 align(16) = 1234; // TODO: https://github.com/ziglang/zig/issues/2987
83	// if (@cmpxchgWeak(u128, &x, 99, 5678, .SeqCst, .SeqCst)) \|x1\| {	83	// if (@cmpxchgWeak(u128, &x, 99, 5678, .SeqCst, .SeqCst)) \|x1\| {
84	// expect(x1 == 1234);	84	// try expect(x1 == 1234);
85	// } else {	85	// } else {
86	// @panic("cmpxchg should have failed");	86	// @panic("cmpxchg should have failed");
87	// }	87	// }
88	//	88	//
89	// while (@cmpxchgWeak(u128, &x, 1234, 5678, .SeqCst, .SeqCst)) \|x1\| {	89	// while (@cmpxchgWeak(u128, &x, 1234, 5678, .SeqCst, .SeqCst)) \|x1\| {
90	// expect(x1 == 1234);	90	// try expect(x1 == 1234);
91	// }	91	// }
92	// expect(x == 5678);	92	// try expect(x == 5678);
93	//	93	//
94	// expect(@cmpxchgStrong(u128, &x, 5678, 42, .SeqCst, .SeqCst) == null);	94	// try expect(@cmpxchgStrong(u128, &x, 5678, 42, .SeqCst, .SeqCst) == null);
95	// expect(x == 42);	95	// try expect(x == 42);
96	//}	96	//}
97		97
98	test "cmpxchg with ignored result" {	98	test "cmpxchg with ignored result" {
...	@@ -101,14 +101,14 @@ test "cmpxchg with ignored result" {	...	@@ -101,14 +101,14 @@ test "cmpxchg with ignored result" {
101		101
102	_ = @cmpxchgStrong(i32, &x, 1234, 5678, .Monotonic, .Monotonic);	102	_ = @cmpxchgStrong(i32, &x, 1234, 5678, .Monotonic, .Monotonic);
103		103
104	expectEqual(@as(i32, 5678), x);	104	try expectEqual(@as(i32, 5678), x);
105	}	105	}
106		106
107	var a_global_variable = @as(u32, 1234);	107	var a_global_variable = @as(u32, 1234);
108		108
109	test "cmpxchg on a global variable" {	109	test "cmpxchg on a global variable" {
110	_ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .Acquire, .Monotonic);	110	_ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .Acquire, .Monotonic);
111	expectEqual(@as(u32, 42), a_global_variable);	111	try expectEqual(@as(u32, 42), a_global_variable);
112	}	112	}
113		113
114	test "atomic load and rmw with enum" {	114	test "atomic load and rmw with enum" {
...	@@ -119,33 +119,33 @@ test "atomic load and rmw with enum" {	...	@@ -119,33 +119,33 @@ test "atomic load and rmw with enum" {
119	};	119	};
120	var x = Value.a;	120	var x = Value.a;
121		121
122	expect(@atomicLoad(Value, &x, .SeqCst) != .b);	122	try expect(@atomicLoad(Value, &x, .SeqCst) != .b);
123		123
124	_ = @atomicRmw(Value, &x, .Xchg, .c, .SeqCst);	124	_ = @atomicRmw(Value, &x, .Xchg, .c, .SeqCst);
125	expect(@atomicLoad(Value, &x, .SeqCst) == .c);	125	try expect(@atomicLoad(Value, &x, .SeqCst) == .c);
126	expect(@atomicLoad(Value, &x, .SeqCst) != .a);	126	try expect(@atomicLoad(Value, &x, .SeqCst) != .a);
127	expect(@atomicLoad(Value, &x, .SeqCst) != .b);	127	try expect(@atomicLoad(Value, &x, .SeqCst) != .b);
128	}	128	}
129		129
130	test "atomic store" {	130	test "atomic store" {
131	var x: u32 = 0;	131	var x: u32 = 0;
132	@atomicStore(u32, &x, 1, .SeqCst);	132	@atomicStore(u32, &x, 1, .SeqCst);
133	expect(@atomicLoad(u32, &x, .SeqCst) == 1);	133	try expect(@atomicLoad(u32, &x, .SeqCst) == 1);
134	@atomicStore(u32, &x, 12345678, .SeqCst);	134	@atomicStore(u32, &x, 12345678, .SeqCst);
135	expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);	135	try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);
136	}	136	}
137		137
138	test "atomic store comptime" {	138	test "atomic store comptime" {
139	comptime testAtomicStore();	139	comptime try testAtomicStore();
140	testAtomicStore();	140	try testAtomicStore();
141	}	141	}
142		142
143	fn testAtomicStore() void {	143	fn testAtomicStore() !void {
144	var x: u32 = 0;	144	var x: u32 = 0;
145	@atomicStore(u32, &x, 1, .SeqCst);	145	@atomicStore(u32, &x, 1, .SeqCst);
146	expect(@atomicLoad(u32, &x, .SeqCst) == 1);	146	try expect(@atomicLoad(u32, &x, .SeqCst) == 1);
147	@atomicStore(u32, &x, 12345678, .SeqCst);	147	@atomicStore(u32, &x, 12345678, .SeqCst);
148	expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);	148	try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);
149	}	149	}
150		150
151	test "atomicrmw with floats" {	151	test "atomicrmw with floats" {
...	@@ -154,66 +154,66 @@ test "atomicrmw with floats" {	...	@@ -154,66 +154,66 @@ test "atomicrmw with floats" {
154	.aarch64, .arm, .thumb, .riscv64 => return error.SkipZigTest,	154	.aarch64, .arm, .thumb, .riscv64 => return error.SkipZigTest,
155	else => {},	155	else => {},
156	}	156	}
157	testAtomicRmwFloat();	157	try testAtomicRmwFloat();
158	comptime testAtomicRmwFloat();	158	comptime try testAtomicRmwFloat();
159	}	159	}
160		160
161	fn testAtomicRmwFloat() void {	161	fn testAtomicRmwFloat() !void {
162	var x: f32 = 0;	162	var x: f32 = 0;
163	expect(x == 0);	163	try expect(x == 0);
164	_ = @atomicRmw(f32, &x, .Xchg, 1, .SeqCst);	164	_ = @atomicRmw(f32, &x, .Xchg, 1, .SeqCst);
165	expect(x == 1);	165	try expect(x == 1);
166	_ = @atomicRmw(f32, &x, .Add, 5, .SeqCst);	166	_ = @atomicRmw(f32, &x, .Add, 5, .SeqCst);
167	expect(x == 6);	167	try expect(x == 6);
168	_ = @atomicRmw(f32, &x, .Sub, 2, .SeqCst);	168	_ = @atomicRmw(f32, &x, .Sub, 2, .SeqCst);
169	expect(x == 4);	169	try expect(x == 4);
170	}	170	}
171		171
172	test "atomicrmw with ints" {	172	test "atomicrmw with ints" {
173	testAtomicRmwInt();	173	try testAtomicRmwInt();
174	comptime testAtomicRmwInt();	174	comptime try testAtomicRmwInt();
175	}	175	}
176		176
177	fn testAtomicRmwInt() void {	177	fn testAtomicRmwInt() !void {
178	var x: u8 = 1;	178	var x: u8 = 1;
179	var res = @atomicRmw(u8, &x, .Xchg, 3, .SeqCst);	179	var res = @atomicRmw(u8, &x, .Xchg, 3, .SeqCst);
180	expect(x == 3 and res == 1);	180	try expect(x == 3 and res == 1);
181	_ = @atomicRmw(u8, &x, .Add, 3, .SeqCst);	181	_ = @atomicRmw(u8, &x, .Add, 3, .SeqCst);
182	expect(x == 6);	182	try expect(x == 6);
183	_ = @atomicRmw(u8, &x, .Sub, 1, .SeqCst);	183	_ = @atomicRmw(u8, &x, .Sub, 1, .SeqCst);
184	expect(x == 5);	184	try expect(x == 5);
185	_ = @atomicRmw(u8, &x, .And, 4, .SeqCst);	185	_ = @atomicRmw(u8, &x, .And, 4, .SeqCst);
186	expect(x == 4);	186	try expect(x == 4);
187	_ = @atomicRmw(u8, &x, .Nand, 4, .SeqCst);	187	_ = @atomicRmw(u8, &x, .Nand, 4, .SeqCst);
188	expect(x == 0xfb);	188	try expect(x == 0xfb);
189	_ = @atomicRmw(u8, &x, .Or, 6, .SeqCst);	189	_ = @atomicRmw(u8, &x, .Or, 6, .SeqCst);
190	expect(x == 0xff);	190	try expect(x == 0xff);
191	_ = @atomicRmw(u8, &x, .Xor, 2, .SeqCst);	191	_ = @atomicRmw(u8, &x, .Xor, 2, .SeqCst);
192	expect(x == 0xfd);	192	try expect(x == 0xfd);
193		193
194	_ = @atomicRmw(u8, &x, .Max, 1, .SeqCst);	194	_ = @atomicRmw(u8, &x, .Max, 1, .SeqCst);
195	expect(x == 0xfd);	195	try expect(x == 0xfd);
196	_ = @atomicRmw(u8, &x, .Min, 1, .SeqCst);	196	_ = @atomicRmw(u8, &x, .Min, 1, .SeqCst);
197	expect(x == 1);	197	try expect(x == 1);
198	}	198	}
199		199
200	test "atomics with different types" {	200	test "atomics with different types" {
201	testAtomicsWithType(bool, true, false);	201	try testAtomicsWithType(bool, true, false);
202	inline for (.{ u1, i5, u15 }) \|T\| {	202	inline for (.{ u1, i5, u15 }) \|T\| {
203	var x: T = 0;	203	var x: T = 0;
204	testAtomicsWithType(T, 0, 1);	204	try testAtomicsWithType(T, 0, 1);
205	}	205	}
206	testAtomicsWithType(u0, 0, 0);	206	try testAtomicsWithType(u0, 0, 0);
207	testAtomicsWithType(i0, 0, 0);	207	try testAtomicsWithType(i0, 0, 0);
208	}	208	}
209		209
210	fn testAtomicsWithType(comptime T: type, a: T, b: T) void {	210	fn testAtomicsWithType(comptime T: type, a: T, b: T) !void {
211	var x: T = b;	211	var x: T = b;
212	@atomicStore(T, &x, a, .SeqCst);	212	@atomicStore(T, &x, a, .SeqCst);
213	expect(x == a);	213	try expect(x == a);
214	expect(@atomicLoad(T, &x, .SeqCst) == a);	214	try expect(@atomicLoad(T, &x, .SeqCst) == a);
215	expect(@atomicRmw(T, &x, .Xchg, b, .SeqCst) == a);	215	try expect(@atomicRmw(T, &x, .Xchg, b, .SeqCst) == a);
216	expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst) == null);	216	try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst) == null);
217	if (@sizeOf(T) != 0)	217	if (@sizeOf(T) != 0)
218	expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst).? == a);	218	try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst).? == a);
219	}	219	}

test/stage1/behavior/await_struct.zig+2-2

...	@@ -15,8 +15,8 @@ test "coroutine await struct" {	...	@@ -15,8 +15,8 @@ test "coroutine await struct" {
15	await_seq('f');	15	await_seq('f');
16	resume await_a_promise;	16	resume await_a_promise;
17	await_seq('i');	17	await_seq('i');
18	expect(await_final_result.x == 1234);	18	try expect(await_final_result.x == 1234);
19	expect(std.mem.eql(u8, &await_points, "abcdefghi"));	19	try expect(std.mem.eql(u8, &await_points, "abcdefghi"));
20	}	20	}
21	fn await_amain() callconv(.Async) void {	21	fn await_amain() callconv(.Async) void {
22	await_seq('b');	22	await_seq('b');

test/stage1/behavior/bit_shifting.zig+14-14

...	@@ -3,8 +3,8 @@ const expect = std.testing.expect;	...	@@ -3,8 +3,8 @@ const expect = std.testing.expect;
3		3
4	fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {	4	fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {
5	const key_bits = @typeInfo(Key).Int.bits;	5	const key_bits = @typeInfo(Key).Int.bits;
6	expect(Key == std.meta.Int(.unsigned, key_bits));	6	std.debug.assert(Key == std.meta.Int(.unsigned, key_bits));
7	expect(key_bits >= mask_bit_count);	7	std.debug.assert(key_bits >= mask_bit_count);
8	const shard_key_bits = mask_bit_count;	8	const shard_key_bits = mask_bit_count;
9	const ShardKey = std.meta.Int(.unsigned, mask_bit_count);	9	const ShardKey = std.meta.Int(.unsigned, mask_bit_count);
10	const shift_amount = key_bits - shard_key_bits;	10	const shift_amount = key_bits - shard_key_bits;
...	@@ -61,31 +61,31 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt	...	@@ -61,31 +61,31 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt
61		61
62	test "sharded table" {	62	test "sharded table" {
63	// realistic 16-way sharding	63	// realistic 16-way sharding
64	testShardedTable(u32, 4, 8);	64	try testShardedTable(u32, 4, 8);
65		65
66	testShardedTable(u5, 0, 32); // ShardKey == u0	66	try testShardedTable(u5, 0, 32); // ShardKey == u0
67	testShardedTable(u5, 2, 32);	67	try testShardedTable(u5, 2, 32);
68	testShardedTable(u5, 5, 32);	68	try testShardedTable(u5, 5, 32);
69		69
70	testShardedTable(u1, 0, 2);	70	try testShardedTable(u1, 0, 2);
71	testShardedTable(u1, 1, 2); // this does u1 >> u0	71	try testShardedTable(u1, 1, 2); // this does u1 >> u0
72		72
73	testShardedTable(u0, 0, 1);	73	try testShardedTable(u0, 0, 1);
74	}	74	}
75	fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime node_count: comptime_int) void {	75	fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime node_count: comptime_int) !void {
76	const Table = ShardedTable(Key, mask_bit_count, void);	76	const Table = ShardedTable(Key, mask_bit_count, void);
77		77
78	var table = Table.create();	78	var table = Table.create();
79	var node_buffer: [node_count]Table.Node = undefined;	79	var node_buffer: [node_count]Table.Node = undefined;
80	for (node_buffer) \|*node, i\| {	80	for (node_buffer) \|*node, i\| {
81	const key = @intCast(Key, i);	81	const key = @intCast(Key, i);
82	expect(table.get(key) == null);	82	try expect(table.get(key) == null);
83	node.init(key, {});	83	node.init(key, {});
84	table.put(node);	84	table.put(node);
85	}	85	}
86		86
87	for (node_buffer) \|*node, i\| {	87	for (node_buffer) \|*node, i\| {
88	expect(table.get(@intCast(Key, i)) == node);	88	try expect(table.get(@intCast(Key, i)) == node);
89	}	89	}
90	}	90	}
91		91
...	@@ -93,9 +93,9 @@ fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, c	...	@@ -93,9 +93,9 @@ fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, c
93	test "comptime shr of BigInt" {	93	test "comptime shr of BigInt" {
94	comptime {	94	comptime {
95	var n0 = 0xdeadbeef0000000000000000;	95	var n0 = 0xdeadbeef0000000000000000;
96	std.debug.assert(n0 >> 64 == 0xdeadbeef);	96	try expect(n0 >> 64 == 0xdeadbeef);
97	var n1 = 17908056155735594659;	97	var n1 = 17908056155735594659;
98	std.debug.assert(n1 >> 64 == 0);	98	try expect(n1 >> 64 == 0);
99	}	99	}
100	}	100	}
101		101

test/stage1/behavior/bitcast.zig+52-52

...	@@ -5,13 +5,13 @@ const expectEqual = std.testing.expectEqual;	...	@@ -5,13 +5,13 @@ const expectEqual = std.testing.expectEqual;
5	const maxInt = std.math.maxInt;	5	const maxInt = std.math.maxInt;
6		6
7	test "@bitCast i32 -> u32" {	7	test "@bitCast i32 -> u32" {
8	testBitCast_i32_u32();	8	try testBitCast_i32_u32();
9	comptime testBitCast_i32_u32();	9	comptime try testBitCast_i32_u32();
10	}	10	}
11		11
12	fn testBitCast_i32_u32() void {	12	fn testBitCast_i32_u32() !void {
13	expect(conv(-1) == maxInt(u32));	13	try expect(conv(-1) == maxInt(u32));
14	expect(conv2(maxInt(u32)) == -1);	14	try expect(conv2(maxInt(u32)) == -1);
15	}	15	}
16		16
17	fn conv(x: i32) u32 {	17	fn conv(x: i32) u32 {
...	@@ -26,15 +26,15 @@ test "@bitCast extern enum to its integer type" {	...	@@ -26,15 +26,15 @@ test "@bitCast extern enum to its integer type" {
26	A,	26	A,
27	B,	27	B,
28		28
29	fn testBitCastExternEnum() void {	29	fn testBitCastExternEnum() !void {
30	var SOCK_DGRAM = @This().B;	30	var SOCK_DGRAM = @This().B;
31	var sock_dgram = @bitCast(c_int, SOCK_DGRAM);	31	var sock_dgram = @bitCast(c_int, SOCK_DGRAM);
32	expect(sock_dgram == 1);	32	try expect(sock_dgram == 1);
33	}	33	}
34	};	34	};
35		35
36	SOCK.testBitCastExternEnum();	36	try SOCK.testBitCastExternEnum();
37	comptime SOCK.testBitCastExternEnum();	37	comptime try SOCK.testBitCastExternEnum();
38	}	38	}
39		39
40	test "@bitCast packed structs at runtime and comptime" {	40	test "@bitCast packed structs at runtime and comptime" {
...	@@ -47,25 +47,25 @@ test "@bitCast packed structs at runtime and comptime" {	...	@@ -47,25 +47,25 @@ test "@bitCast packed structs at runtime and comptime" {
47	quarter4: u4,	47	quarter4: u4,
48	};	48	};
49	const S = struct {	49	const S = struct {
50	fn doTheTest() void {	50	fn doTheTest() !void {
51	var full = Full{ .number = 0x1234 };	51	var full = Full{ .number = 0x1234 };
52	var two_halves = @bitCast(Divided, full);	52	var two_halves = @bitCast(Divided, full);
53	switch (builtin.endian) {	53	switch (builtin.endian) {
54	builtin.Endian.Big => {	54	builtin.Endian.Big => {
55	expect(two_halves.half1 == 0x12);	55	try expect(two_halves.half1 == 0x12);
56	expect(two_halves.quarter3 == 0x3);	56	try expect(two_halves.quarter3 == 0x3);
57	expect(two_halves.quarter4 == 0x4);	57	try expect(two_halves.quarter4 == 0x4);
58	},	58	},
59	builtin.Endian.Little => {	59	builtin.Endian.Little => {
60	expect(two_halves.half1 == 0x34);	60	try expect(two_halves.half1 == 0x34);
61	expect(two_halves.quarter3 == 0x2);	61	try expect(two_halves.quarter3 == 0x2);
62	expect(two_halves.quarter4 == 0x1);	62	try expect(two_halves.quarter4 == 0x1);
63	},	63	},
64	}	64	}
65	}	65	}
66	};	66	};
67	S.doTheTest();	67	try S.doTheTest();
68	comptime S.doTheTest();	68	comptime try S.doTheTest();
69	}	69	}
70		70
71	test "@bitCast extern structs at runtime and comptime" {	71	test "@bitCast extern structs at runtime and comptime" {
...	@@ -77,23 +77,23 @@ test "@bitCast extern structs at runtime and comptime" {	...	@@ -77,23 +77,23 @@ test "@bitCast extern structs at runtime and comptime" {
77	half2: u8,	77	half2: u8,
78	};	78	};
79	const S = struct {	79	const S = struct {
80	fn doTheTest() void {	80	fn doTheTest() !void {
81	var full = Full{ .number = 0x1234 };	81	var full = Full{ .number = 0x1234 };
82	var two_halves = @bitCast(TwoHalves, full);	82	var two_halves = @bitCast(TwoHalves, full);
83	switch (builtin.endian) {	83	switch (builtin.endian) {
84	builtin.Endian.Big => {	84	builtin.Endian.Big => {
85	expect(two_halves.half1 == 0x12);	85	try expect(two_halves.half1 == 0x12);
86	expect(two_halves.half2 == 0x34);	86	try expect(two_halves.half2 == 0x34);
87	},	87	},
88	builtin.Endian.Little => {	88	builtin.Endian.Little => {
89	expect(two_halves.half1 == 0x34);	89	try expect(two_halves.half1 == 0x34);
90	expect(two_halves.half2 == 0x12);	90	try expect(two_halves.half2 == 0x12);
91	},	91	},
92	}	92	}
93	}	93	}
94	};	94	};
95	S.doTheTest();	95	try S.doTheTest();
96	comptime S.doTheTest();	96	comptime try S.doTheTest();
97	}	97	}
98		98
99	test "bitcast packed struct to integer and back" {	99	test "bitcast packed struct to integer and back" {
...	@@ -102,35 +102,35 @@ test "bitcast packed struct to integer and back" {	...	@@ -102,35 +102,35 @@ test "bitcast packed struct to integer and back" {
102	level: u7,	102	level: u7,
103	};	103	};
104	const S = struct {	104	const S = struct {
105	fn doTheTest() void {	105	fn doTheTest() !void {
106	var move = LevelUpMove{ .move_id = 1, .level = 2 };	106	var move = LevelUpMove{ .move_id = 1, .level = 2 };
107	var v = @bitCast(u16, move);	107	var v = @bitCast(u16, move);
108	var back_to_a_move = @bitCast(LevelUpMove, v);	108	var back_to_a_move = @bitCast(LevelUpMove, v);
109	expect(back_to_a_move.move_id == 1);	109	try expect(back_to_a_move.move_id == 1);
110	expect(back_to_a_move.level == 2);	110	try expect(back_to_a_move.level == 2);
111	}	111	}
112	};	112	};
113	S.doTheTest();	113	try S.doTheTest();
114	comptime S.doTheTest();	114	comptime try S.doTheTest();
115	}	115	}
116		116
117	test "implicit cast to error union by returning" {	117	test "implicit cast to error union by returning" {
118	const S = struct {	118	const S = struct {
119	fn entry() void {	119	fn entry() !void {
120	expect((func(-1) catch unreachable) == maxInt(u64));	120	try expect((func(-1) catch unreachable) == maxInt(u64));
121	}	121	}
122	pub fn func(sz: i64) anyerror!u64 {	122	pub fn func(sz: i64) anyerror!u64 {
123	return @bitCast(u64, sz);	123	return @bitCast(u64, sz);
124	}	124	}
125	};	125	};
126	S.entry();	126	try S.entry();
127	comptime S.entry();	127	comptime try S.entry();
128	}	128	}
129		129
130	// issue #3010: compiler segfault	130	// issue #3010: compiler segfault
131	test "bitcast literal [4]u8 param to u32" {	131	test "bitcast literal [4]u8 param to u32" {
132	const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });	132	const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });
133	expect(ip == maxInt(u32));	133	try expect(ip == maxInt(u32));
134	}	134	}
135		135
136	test "bitcast packed struct literal to byte" {	136	test "bitcast packed struct literal to byte" {
...	@@ -138,14 +138,14 @@ test "bitcast packed struct literal to byte" {	...	@@ -138,14 +138,14 @@ test "bitcast packed struct literal to byte" {
138	value: u8,	138	value: u8,
139	};	139	};
140	const casted = @bitCast(u8, Foo{ .value = 0xF });	140	const casted = @bitCast(u8, Foo{ .value = 0xF });
141	expect(casted == 0xf);	141	try expect(casted == 0xf);
142	}	142	}
143		143
144	test "comptime bitcast used in expression has the correct type" {	144	test "comptime bitcast used in expression has the correct type" {
145	const Foo = packed struct {	145	const Foo = packed struct {
146	value: u8,	146	value: u8,
147	};	147	};
148	expect(@bitCast(u8, Foo{ .value = 0xF }) == 0xf);	148	try expect(@bitCast(u8, Foo{ .value = 0xF }) == 0xf);
149	}	149	}
150		150
151	test "bitcast result to _" {	151	test "bitcast result to _" {
...	@@ -154,43 +154,43 @@ test "bitcast result to _" {	...	@@ -154,43 +154,43 @@ test "bitcast result to _" {
154		154
155	test "nested bitcast" {	155	test "nested bitcast" {
156	const S = struct {	156	const S = struct {
157	fn moo(x: isize) void {	157	fn moo(x: isize) !void {
158	@import("std").testing.expectEqual(@intCast(isize, 42), x);	158	try @import("std").testing.expectEqual(@intCast(isize, 42), x);
159	}	159	}
160		160
161	fn foo(x: isize) void {	161	fn foo(x: isize) !void {
162	@This().moo(	162	try @This().moo(
163	@bitCast(isize, if (x != 0) @bitCast(usize, x) else @bitCast(usize, x)),	163	@bitCast(isize, if (x != 0) @bitCast(usize, x) else @bitCast(usize, x)),
164	);	164	);
165	}	165	}
166	};	166	};
167		167
168	S.foo(42);	168	try S.foo(42);
169	comptime S.foo(42);	169	comptime try S.foo(42);
170	}	170	}
171		171
172	test "bitcast passed as tuple element" {	172	test "bitcast passed as tuple element" {
173	const S = struct {	173	const S = struct {
174	fn foo(args: anytype) void {	174	fn foo(args: anytype) !void {
175	comptime expect(@TypeOf(args[0]) == f32);	175	comptime try expect(@TypeOf(args[0]) == f32);
176	expect(args[0] == 12.34);	176	try expect(args[0] == 12.34);
177	}	177	}
178	};	178	};
179	S.foo(.{@bitCast(f32, @as(u32, 0x414570A4))});	179	try S.foo(.{@bitCast(f32, @as(u32, 0x414570A4))});
180	}	180	}
181		181
182	test "triple level result location with bitcast sandwich passed as tuple element" {	182	test "triple level result location with bitcast sandwich passed as tuple element" {
183	const S = struct {	183	const S = struct {
184	fn foo(args: anytype) void {	184	fn foo(args: anytype) !void {
185	comptime expect(@TypeOf(args[0]) == f64);	185	comptime try expect(@TypeOf(args[0]) == f64);
186	expect(args[0] > 12.33 and args[0] < 12.35);	186	try expect(args[0] > 12.33 and args[0] < 12.35);
187	}	187	}
188	};	188	};
189	S.foo(.{@as(f64, @bitCast(f32, @as(u32, 0x414570A4)))});	189	try S.foo(.{@as(f64, @bitCast(f32, @as(u32, 0x414570A4)))});
190	}	190	}
191		191
192	test "bitcast generates a temporary value" {	192	test "bitcast generates a temporary value" {
193	var y = @as(u16, 0x55AA);	193	var y = @as(u16, 0x55AA);
194	const x = @bitCast(u16, @bitCast([2]u8, y));	194	const x = @bitCast(u16, @bitCast([2]u8, y));
195	expectEqual(y, x);	195	try expectEqual(y, x);
196	}	196	}

test/stage1/behavior/bitreverse.zig+39-39

test/stage1/behavior/bool.zig+11-11

...	@@ -1,25 +1,25 @@	...	@@ -1,25 +1,25 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "bool literals" {	3	test "bool literals" {
4	expect(true);	4	try expect(true);
5	expect(!false);	5	try expect(!false);
6	}	6	}
7		7
8	test "cast bool to int" {	8	test "cast bool to int" {
9	const t = true;	9	const t = true;
10	const f = false;	10	const f = false;
11	expect(@boolToInt(t) == @as(u32, 1));	11	try expect(@boolToInt(t) == @as(u32, 1));
12	expect(@boolToInt(f) == @as(u32, 0));	12	try expect(@boolToInt(f) == @as(u32, 0));
13	nonConstCastBoolToInt(t, f);	13	try nonConstCastBoolToInt(t, f);
14	}	14	}
15		15
16	fn nonConstCastBoolToInt(t: bool, f: bool) void {	16	fn nonConstCastBoolToInt(t: bool, f: bool) !void {
17	expect(@boolToInt(t) == @as(u32, 1));	17	try expect(@boolToInt(t) == @as(u32, 1));
18	expect(@boolToInt(f) == @as(u32, 0));	18	try expect(@boolToInt(f) == @as(u32, 0));
19	}	19	}
20		20
21	test "bool cmp" {	21	test "bool cmp" {
22	expect(testBoolCmp(true, false) == false);	22	try expect(testBoolCmp(true, false) == false);
23	}	23	}
24	fn testBoolCmp(a: bool, b: bool) bool {	24	fn testBoolCmp(a: bool, b: bool) bool {
25	return a == b;	25	return a == b;
...	@@ -30,6 +30,6 @@ const global_t = true;	...	@@ -30,6 +30,6 @@ const global_t = true;
30	const not_global_f = !global_f;	30	const not_global_f = !global_f;
31	const not_global_t = !global_t;	31	const not_global_t = !global_t;
32	test "compile time bool not" {	32	test "compile time bool not" {
33	expect(not_global_f);	33	try expect(not_global_f);
34	expect(!not_global_t);	34	try expect(!not_global_t);
35	}	35	}

test/stage1/behavior/bugs/1025.zig+1-1

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

test/stage1/behavior/bugs/1076.zig+5-5

...	@@ -3,21 +3,21 @@ const mem = std.mem;	...	@@ -3,21 +3,21 @@ const mem = std.mem;
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4		4
5	test "comptime code should not modify constant data" {	5	test "comptime code should not modify constant data" {
6	testCastPtrOfArrayToSliceAndPtr();	6	try testCastPtrOfArrayToSliceAndPtr();
7	comptime testCastPtrOfArrayToSliceAndPtr();	7	comptime try testCastPtrOfArrayToSliceAndPtr();
8	}	8	}
9		9
10	fn testCastPtrOfArrayToSliceAndPtr() void {	10	fn testCastPtrOfArrayToSliceAndPtr() !void {
11	{	11	{
12	var array = "aoeu".*;	12	var array = "aoeu".*;
13	const x: [*]u8 = &array;	13	const x: [*]u8 = &array;
14	x[0] += 1;	14	x[0] += 1;
15	expect(mem.eql(u8, array[0..], "boeu"));	15	try expect(mem.eql(u8, array[0..], "boeu"));
16	}	16	}
17	{	17	{
18	var array: [4]u8 = "aoeu".*;	18	var array: [4]u8 = "aoeu".*;
19	const x: [*]u8 = &array;	19	const x: [*]u8 = &array;
20	x[0] += 1;	20	x[0] += 1;
21	expect(mem.eql(u8, array[0..], "boeu"));	21	try expect(mem.eql(u8, array[0..], "boeu"));
22	}	22	}
23	}	23	}

test/stage1/behavior/bugs/1120.zig+1-1

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

test/stage1/behavior/bugs/1277.zig+1-1

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

test/stage1/behavior/bugs/1310.zig+1-1

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

test/stage1/behavior/bugs/1322.zig+2-2

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

test/stage1/behavior/bugs/1381.zig+1-1

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

test/stage1/behavior/bugs/1421.zig+1-1

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

test/stage1/behavior/bugs/1442.zig+1-1

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

test/stage1/behavior/bugs/1486.zig+2-2

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

test/stage1/behavior/bugs/1607.zig+4-4

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

test/stage1/behavior/bugs/1735.zig+1-1

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

test/stage1/behavior/bugs/1741.zig+1-1

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

test/stage1/behavior/bugs/1851.zig+9-9

...	@@ -2,25 +2,25 @@ const std = @import("std");	...	@@ -2,25 +2,25 @@ const std = @import("std");
2	const expect = std.testing.expect;	2	const expect = std.testing.expect;
3		3
4	test "allocation and looping over 3-byte integer" {	4	test "allocation and looping over 3-byte integer" {
5	expect(@sizeOf(u24) == 4);	5	try expect(@sizeOf(u24) == 4);
6	expect(@sizeOf([1]u24) == 4);	6	try expect(@sizeOf([1]u24) == 4);
7	expect(@alignOf(u24) == 4);	7	try expect(@alignOf(u24) == 4);
8	expect(@alignOf([1]u24) == 4);	8	try expect(@alignOf([1]u24) == 4);
9		9
10	var x = try std.testing.allocator.alloc(u24, 2);	10	var x = try std.testing.allocator.alloc(u24, 2);
11	defer std.testing.allocator.free(x);	11	defer std.testing.allocator.free(x);
12	expect(x.len == 2);	12	try expect(x.len == 2);
13	x[0] = 0xFFFFFF;	13	x[0] = 0xFFFFFF;
14	x[1] = 0xFFFFFF;	14	x[1] = 0xFFFFFF;
15		15
16	const bytes = std.mem.sliceAsBytes(x);	16	const bytes = std.mem.sliceAsBytes(x);
17	expect(@TypeOf(bytes) == []align(4) u8);	17	try expect(@TypeOf(bytes) == []align(4) u8);
18	expect(bytes.len == 8);	18	try expect(bytes.len == 8);
19		19
20	for (bytes) \|*b\| {	20	for (bytes) \|*b\| {
21	b.* = 0x00;	21	b.* = 0x00;
22	}	22	}
23		23
24	expect(x[0] == 0x00);	24	try expect(x[0] == 0x00);
25	expect(x[1] == 0x00);	25	try expect(x[1] == 0x00);
26	}	26	}

test/stage1/behavior/bugs/2006.zig+2-2

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

test/stage1/behavior/bugs/2114.zig+7-7

...	@@ -7,13 +7,13 @@ fn ctz(x: anytype) usize {	...	@@ -7,13 +7,13 @@ fn ctz(x: anytype) usize {
7	}	7	}
8		8
9	test "fixed" {	9	test "fixed" {
10	testClz();	10	try testClz();
11	comptime testClz();	11	comptime try testClz();
12	}	12	}
13		13
14	fn testClz() void {	14	fn testClz() !void {
15	expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126);	15	try expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126);
16	expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));	16	try expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));
17	expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127);	17	try expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127);
18	expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);	18	try expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);
19	}	19	}

test/stage1/behavior/bugs/2889.zig+1-1

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

test/stage1/behavior/bugs/3007.zig+1-1

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

test/stage1/behavior/bugs/3046.zig+1-1

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

test/stage1/behavior/bugs/3112.zig+1-1

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

test/stage1/behavior/bugs/3384.zig+6-6

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

test/stage1/behavior/bugs/394.zig+1-1

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

test/stage1/behavior/bugs/421.zig+4-4

...	@@ -1,12 +1,12 @@	...	@@ -1,12 +1,12 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "bitCast to array" {	3	test "bitCast to array" {
4	comptime testBitCastArray();	4	comptime try testBitCastArray();
5	testBitCastArray();	5	try testBitCastArray();
6	}	6	}
7		7
8	fn testBitCastArray() void {	8	fn testBitCastArray() !void {
9	expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef);	9	try expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef);
10	}	10	}
11		11
12	fn extractOne64(a: u128) u64 {	12	fn extractOne64(a: u128) u64 {

test/stage1/behavior/bugs/4328.zig+14-14

...	@@ -25,14 +25,14 @@ test "Extern function calls in @TypeOf" {	...	@@ -25,14 +25,14 @@ test "Extern function calls in @TypeOf" {
25	return 1;	25	return 1;
26	}	26	}
27		27
28	fn doTheTest() void {	28	fn doTheTest() !void {
29	expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));	29	try expectEqual(c_int, @TypeOf(test_fn_1(0, 42)));
30	expectEqual(c_short, @TypeOf(test_fn_2(0)));	30	try expectEqual(c_short, @TypeOf(test_fn_2(0)));
31	}	31	}
32	};	32	};
33		33
34	Test.doTheTest();	34	try Test.doTheTest();
35	comptime Test.doTheTest();	35	comptime try Test.doTheTest();
36	}	36	}
37		37
38	test "Peer resolution of extern function calls in @TypeOf" {	38	test "Peer resolution of extern function calls in @TypeOf" {
...	@@ -41,13 +41,13 @@ test "Peer resolution of extern function calls in @TypeOf" {	...	@@ -41,13 +41,13 @@ test "Peer resolution of extern function calls in @TypeOf" {
41	return 0;	41	return 0;
42	}	42	}
43		43
44	fn doTheTest() void {	44	fn doTheTest() !void {
45	expectEqual(c_long, @TypeOf(test_fn()));	45	try expectEqual(c_long, @TypeOf(test_fn()));
46	}	46	}
47	};	47	};
48		48
49	Test.doTheTest();	49	try Test.doTheTest();
50	comptime Test.doTheTest();	50	comptime try Test.doTheTest();
51	}	51	}
52		52
53	test "Extern function calls, dereferences and field access in @TypeOf" {	53	test "Extern function calls, dereferences and field access in @TypeOf" {
...	@@ -60,12 +60,12 @@ test "Extern function calls, dereferences and field access in @TypeOf" {	...	@@ -60,12 +60,12 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
60	return 255;	60	return 255;
61	}	61	}
62		62
63	fn doTheTest() void {	63	fn doTheTest() !void {
64	expectEqual(FILE, @TypeOf(test_fn_1(0)));	64	try expectEqual(FILE, @TypeOf(test_fn_1(0)));
65	expectEqual(u8, @TypeOf(test_fn_2(0)));	65	try expectEqual(u8, @TypeOf(test_fn_2(0)));
66	}	66	}
67	};	67	};
68		68
69	Test.doTheTest();	69	try Test.doTheTest();
70	comptime Test.doTheTest();	70	comptime try Test.doTheTest();
71	}	71	}

test/stage1/behavior/bugs/4560.zig+3-3

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

test/stage1/behavior/bugs/4769_a.zig+1-1

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

test/stage1/behavior/bugs/4769_b.zig+1-1

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

test/stage1/behavior/bugs/5398.zig+3-3

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

test/stage1/behavior/bugs/5413.zig+2-2

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

test/stage1/behavior/bugs/5474.zig+9-9

test/stage1/behavior/bugs/624.zig+1-1

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

test/stage1/behavior/bugs/6456.zig+4-4

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

test/stage1/behavior/bugs/655.zig+4-4

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

test/stage1/behavior/bugs/656.zig+3-3

...	@@ -10,10 +10,10 @@ const Value = struct {	...	@@ -10,10 +10,10 @@ const Value = struct {
10	};	10	};
11		11
12	test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {	12	test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
13	foo(false, true);	13	try foo(false, true);
14	}	14	}
15		15
16	fn foo(a: bool, b: bool) void {	16	fn foo(a: bool, b: bool) !void {
17	var prefix_op = PrefixOp{	17	var prefix_op = PrefixOp{
18	.AddrOf = Value{ .align_expr = 1234 },	18	.AddrOf = Value{ .align_expr = 1234 },
19	};	19	};
...	@@ -22,7 +22,7 @@ fn foo(a: bool, b: bool) void {	...	@@ -22,7 +22,7 @@ fn foo(a: bool, b: bool) void {
22	PrefixOp.AddrOf => \|addr_of_info\| {	22	PrefixOp.AddrOf => \|addr_of_info\| {
23	if (b) {}	23	if (b) {}
24	if (addr_of_info.align_expr) \|align_expr\| {	24	if (addr_of_info.align_expr) \|align_expr\| {
25	expect(align_expr == 1234);	25	try expect(align_expr == 1234);
26	}	26	}
27	},	27	},
28	PrefixOp.Return => {},	28	PrefixOp.Return => {},

test/stage1/behavior/bugs/679.zig+1-1

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

test/stage1/behavior/bugs/6850.zig+1-1

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

test/stage1/behavior/bugs/7047.zig+2-2

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

test/stage1/behavior/bugs/718.zig+4-4

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

test/stage1/behavior/bugs/726.zig+2-2

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

test/stage1/behavior/bugs/920.zig+1-1

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

test/stage1/behavior/byteswap.zig+33-33

test/stage1/behavior/byval_arg_var.zig+1-1

...	@@ -6,7 +6,7 @@ test "pass string literal byvalue to a generic var param" {	...	@@ -6,7 +6,7 @@ test "pass string literal byvalue to a generic var param" {
6	start();	6	start();
7	blowUpStack(10);	7	blowUpStack(10);
8		8
9	std.testing.expect(std.mem.eql(u8, result, "string literal"));	9	try std.testing.expect(std.mem.eql(u8, result, "string literal"));
10	}	10	}
11		11
12	fn start() void {	12	fn start() void {

test/stage1/behavior/call.zig+19-19

test/stage1/behavior/cast.zig+226-226

...	@@ -8,12 +8,12 @@ test "int to ptr cast" {	...	@@ -8,12 +8,12 @@ test "int to ptr cast" {
8	const x = @as(usize, 13);	8	const x = @as(usize, 13);
9	const y = @intToPtr(*u8, x);	9	const y = @intToPtr(*u8, x);
10	const z = @ptrToInt(y);	10	const z = @ptrToInt(y);
11	expect(z == 13);	11	try expect(z == 13);
12	}	12	}
13		13
14	test "integer literal to pointer cast" {	14	test "integer literal to pointer cast" {
15	const vga_mem = @intToPtr(*u16, 0xB8000);	15	const vga_mem = @intToPtr(*u16, 0xB8000);
16	expect(@ptrToInt(vga_mem) == 0xB8000);	16	try expect(@ptrToInt(vga_mem) == 0xB8000);
17	}	17	}
18		18
19	test "pointer reinterpret const float to int" {	19	test "pointer reinterpret const float to int" {
...	@@ -23,9 +23,9 @@ test "pointer reinterpret const float to int" {	...	@@ -23,9 +23,9 @@ test "pointer reinterpret const float to int" {
23	const int_ptr = @ptrCast(*const i32, float_ptr);	23	const int_ptr = @ptrCast(*const i32, float_ptr);
24	const int_val = int_ptr.*;	24	const int_val = int_ptr.*;
25	if (std.builtin.endian == .Little)	25	if (std.builtin.endian == .Little)
26	expect(int_val == 0x33333303)	26	try expect(int_val == 0x33333303)
27	else	27	else
28	expect(int_val == 0x3fe33333);	28	try expect(int_val == 0x3fe33333);
29	}	29	}
30		30
31	test "implicitly cast indirect pointer to maybe-indirect pointer" {	31	test "implicitly cast indirect pointer to maybe-indirect pointer" {
...	@@ -49,62 +49,62 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" {	...	@@ -49,62 +49,62 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" {
49	const p = &s;	49	const p = &s;
50	const q = &p;	50	const q = &p;
51	const r = &q;	51	const r = &q;
52	expect(42 == S.constConst(q));	52	try expect(42 == S.constConst(q));
53	expect(42 == S.maybeConstConst(q));	53	try expect(42 == S.maybeConstConst(q));
54	expect(42 == S.constConstConst(r));	54	try expect(42 == S.constConstConst(r));
55	expect(42 == S.maybeConstConstConst(r));	55	try expect(42 == S.maybeConstConstConst(r));
56	}	56	}
57		57
58	test "explicit cast from integer to error type" {	58	test "explicit cast from integer to error type" {
59	testCastIntToErr(error.ItBroke);	59	try testCastIntToErr(error.ItBroke);
60	comptime testCastIntToErr(error.ItBroke);	60	comptime try testCastIntToErr(error.ItBroke);
61	}	61	}
62	fn testCastIntToErr(err: anyerror) void {	62	fn testCastIntToErr(err: anyerror) !void {
63	const x = @errorToInt(err);	63	const x = @errorToInt(err);
64	const y = @intToError(x);	64	const y = @intToError(x);
65	expect(error.ItBroke == y);	65	try expect(error.ItBroke == y);
66	}	66	}
67		67
68	test "peer resolve arrays of different size to const slice" {	68	test "peer resolve arrays of different size to const slice" {
69	expect(mem.eql(u8, boolToStr(true), "true"));	69	try expect(mem.eql(u8, boolToStr(true), "true"));
70	expect(mem.eql(u8, boolToStr(false), "false"));	70	try expect(mem.eql(u8, boolToStr(false), "false"));
71	comptime expect(mem.eql(u8, boolToStr(true), "true"));	71	comptime try expect(mem.eql(u8, boolToStr(true), "true"));
72	comptime expect(mem.eql(u8, boolToStr(false), "false"));	72	comptime try expect(mem.eql(u8, boolToStr(false), "false"));
73	}	73	}
74	fn boolToStr(b: bool) []const u8 {	74	fn boolToStr(b: bool) []const u8 {
75	return if (b) "true" else "false";	75	return if (b) "true" else "false";
76	}	76	}
77		77
78	test "peer resolve array and const slice" {	78	test "peer resolve array and const slice" {
79	testPeerResolveArrayConstSlice(true);	79	try testPeerResolveArrayConstSlice(true);
80	comptime testPeerResolveArrayConstSlice(true);	80	comptime try testPeerResolveArrayConstSlice(true);
81	}	81	}
82	fn testPeerResolveArrayConstSlice(b: bool) void {	82	fn testPeerResolveArrayConstSlice(b: bool) !void {
83	const value1 = if (b) "aoeu" else @as([]const u8, "zz");	83	const value1 = if (b) "aoeu" else @as([]const u8, "zz");
84	const value2 = if (b) @as([]const u8, "zz") else "aoeu";	84	const value2 = if (b) @as([]const u8, "zz") else "aoeu";
85	expect(mem.eql(u8, value1, "aoeu"));	85	try expect(mem.eql(u8, value1, "aoeu"));
86	expect(mem.eql(u8, value2, "zz"));	86	try expect(mem.eql(u8, value2, "zz"));
87	}	87	}
88		88
89	test "implicitly cast from T to anyerror!?T" {	89	test "implicitly cast from T to anyerror!?T" {
90	castToOptionalTypeError(1);	90	try castToOptionalTypeError(1);
91	comptime castToOptionalTypeError(1);	91	comptime try castToOptionalTypeError(1);
92	}	92	}
93		93
94	const A = struct {	94	const A = struct {
95	a: i32,	95	a: i32,
96	};	96	};
97	fn castToOptionalTypeError(z: i32) void {	97	fn castToOptionalTypeError(z: i32) !void {
98	const x = @as(i32, 1);	98	const x = @as(i32, 1);
99	const y: anyerror!?i32 = x;	99	const y: anyerror!?i32 = x;
100	expect((try y).? == 1);	100	try expect((try y).? == 1);
101		101
102	const f = z;	102	const f = z;
103	const g: anyerror!?i32 = f;	103	const g: anyerror!?i32 = f;
104		104
105	const a = A{ .a = z };	105	const a = A{ .a = z };
106	const b: anyerror!?A = a;	106	const b: anyerror!?A = a;
107	expect((b catch unreachable).?.a == 1);	107	try expect((b catch unreachable).?.a == 1);
108	}	108	}
109		109
110	test "implicitly cast from int to anyerror!?T" {	110	test "implicitly cast from int to anyerror!?T" {
...	@@ -119,7 +119,7 @@ fn implicitIntLitToOptional() void {	...	@@ -119,7 +119,7 @@ fn implicitIntLitToOptional() void {
119	test "return null from fn() anyerror!?&T" {	119	test "return null from fn() anyerror!?&T" {
120	const a = returnNullFromOptionalTypeErrorRef();	120	const a = returnNullFromOptionalTypeErrorRef();
121	const b = returnNullLitFromOptionalTypeErrorRef();	121	const b = returnNullLitFromOptionalTypeErrorRef();
122	expect((try a) == null and (try b) == null);	122	try expect((try a) == null and (try b) == null);
123	}	123	}
124	fn returnNullFromOptionalTypeErrorRef() anyerror!?*A {	124	fn returnNullFromOptionalTypeErrorRef() anyerror!?*A {
125	const a: ?*A = null;	125	const a: ?*A = null;
...	@@ -130,11 +130,11 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {	...	@@ -130,11 +130,11 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
130	}	130	}
131		131
132	test "peer type resolution: ?T and T" {	132	test "peer type resolution: ?T and T" {
133	expect(peerTypeTAndOptionalT(true, false).? == 0);	133	try expect(peerTypeTAndOptionalT(true, false).? == 0);
134	expect(peerTypeTAndOptionalT(false, false).? == 3);	134	try expect(peerTypeTAndOptionalT(false, false).? == 3);
135	comptime {	135	comptime {
136	expect(peerTypeTAndOptionalT(true, false).? == 0);	136	try expect(peerTypeTAndOptionalT(true, false).? == 0);
137	expect(peerTypeTAndOptionalT(false, false).? == 3);	137	try expect(peerTypeTAndOptionalT(false, false).? == 3);
138	}	138	}
139	}	139	}
140	fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {	140	fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
...	@@ -146,11 +146,11 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {	...	@@ -146,11 +146,11 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
146	}	146	}
147		147
148	test "peer type resolution: [0]u8 and []const u8" {	148	test "peer type resolution: [0]u8 and []const u8" {
149	expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);	149	try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
150	expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);	150	try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
151	comptime {	151	comptime {
152	expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);	152	try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
153	expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);	153	try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
154	}	154	}
155	}	155	}
156	fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {	156	fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
...	@@ -162,8 +162,8 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {	...	@@ -162,8 +162,8 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
162	}	162	}
163		163
164	test "implicitly cast from [N]T to ?[]const T" {	164	test "implicitly cast from [N]T to ?[]const T" {
165	expect(mem.eql(u8, castToOptionalSlice().?, "hi"));	165	try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
166	comptime expect(mem.eql(u8, castToOptionalSlice().?, "hi"));	166	comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
167	}	167	}
168		168
169	fn castToOptionalSlice() ?[]const u8 {	169	fn castToOptionalSlice() ?[]const u8 {
...	@@ -171,12 +171,12 @@ fn castToOptionalSlice() ?[]const u8 {	...	@@ -171,12 +171,12 @@ fn castToOptionalSlice() ?[]const u8 {
171	}	171	}
172		172
173	test "implicitly cast from [0]T to anyerror![]T" {	173	test "implicitly cast from [0]T to anyerror![]T" {
174	testCastZeroArrayToErrSliceMut();	174	try testCastZeroArrayToErrSliceMut();
175	comptime testCastZeroArrayToErrSliceMut();	175	comptime try testCastZeroArrayToErrSliceMut();
176	}	176	}
177		177
178	fn testCastZeroArrayToErrSliceMut() void {	178	fn testCastZeroArrayToErrSliceMut() !void {
179	expect((gimmeErrOrSlice() catch unreachable).len == 0);	179	try expect((gimmeErrOrSlice() catch unreachable).len == 0);
180	}	180	}
181		181
182	fn gimmeErrOrSlice() anyerror![]u8 {	182	fn gimmeErrOrSlice() anyerror![]u8 {
...	@@ -189,19 +189,19 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {	...	@@ -189,19 +189,19 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
189	{	189	{
190	var data = "hi".*;	190	var data = "hi".*;
191	const slice = data[0..];	191	const slice = data[0..];
192	expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);	192	try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
193	expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);	193	try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
194	}	194	}
195	{	195	{
196	var data: [2]u8 = "hi".*;	196	var data: [2]u8 = "hi".*;
197	const slice = data[0..];	197	const slice = data[0..];
198	expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);	198	try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
199	expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);	199	try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
200	}	200	}
201	}	201	}
202	};	202	};
203	try S.doTheTest();	203	try S.doTheTest();
204	try comptime S.doTheTest();	204	comptime try S.doTheTest();
205	}	205	}
206	fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {	206	fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
207	if (a) {	207	if (a) {
...	@@ -212,43 +212,43 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {	...	@@ -212,43 +212,43 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
212	}	212	}
213		213
214	test "resolve undefined with integer" {	214	test "resolve undefined with integer" {
215	testResolveUndefWithInt(true, 1234);	215	try testResolveUndefWithInt(true, 1234);
216	comptime testResolveUndefWithInt(true, 1234);	216	comptime try testResolveUndefWithInt(true, 1234);
217	}	217	}
218	fn testResolveUndefWithInt(b: bool, x: i32) void {	218	fn testResolveUndefWithInt(b: bool, x: i32) !void {
219	const value = if (b) x else undefined;	219	const value = if (b) x else undefined;
220	if (b) {	220	if (b) {
221	expect(value == x);	221	try expect(value == x);
222	}	222	}
223	}	223	}
224		224
225	test "implicit cast from &const [N]T to []const T" {	225	test "implicit cast from &const [N]T to []const T" {
226	testCastConstArrayRefToConstSlice();	226	try testCastConstArrayRefToConstSlice();
227	comptime testCastConstArrayRefToConstSlice();	227	comptime try testCastConstArrayRefToConstSlice();
228	}	228	}
229		229
230	fn testCastConstArrayRefToConstSlice() void {	230	fn testCastConstArrayRefToConstSlice() !void {
231	{	231	{
232	const blah = "aoeu".*;	232	const blah = "aoeu".*;
233	const const_array_ref = &blah;	233	const const_array_ref = &blah;
234	expect(@TypeOf(const_array_ref) == *const [4:0]u8);	234	try expect(@TypeOf(const_array_ref) == *const [4:0]u8);
235	const slice: []const u8 = const_array_ref;	235	const slice: []const u8 = const_array_ref;
236	expect(mem.eql(u8, slice, "aoeu"));	236	try expect(mem.eql(u8, slice, "aoeu"));
237	}	237	}
238	{	238	{
239	const blah: [4]u8 = "aoeu".*;	239	const blah: [4]u8 = "aoeu".*;
240	const const_array_ref = &blah;	240	const const_array_ref = &blah;
241	expect(@TypeOf(const_array_ref) == *const [4]u8);	241	try expect(@TypeOf(const_array_ref) == *const [4]u8);
242	const slice: []const u8 = const_array_ref;	242	const slice: []const u8 = const_array_ref;
243	expect(mem.eql(u8, slice, "aoeu"));	243	try expect(mem.eql(u8, slice, "aoeu"));
244	}	244	}
245	}	245	}
246		246
247	test "peer type resolution: error and [N]T" {	247	test "peer type resolution: error and [N]T" {
248	expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));	248	try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
249	comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));	249	comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
250	expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));	250	try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
251	comptime expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));	251	comptime try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
252	}	252	}
253		253
254	fn testPeerErrorAndArray(x: u8) anyerror![]const u8 {	254	fn testPeerErrorAndArray(x: u8) anyerror![]const u8 {
...	@@ -266,35 +266,35 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {	...	@@ -266,35 +266,35 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
266	}	266	}
267		267
268	test "@floatToInt" {	268	test "@floatToInt" {
269	testFloatToInts();	269	try testFloatToInts();
270	comptime testFloatToInts();	270	comptime try testFloatToInts();
271	}	271	}
272		272
273	fn testFloatToInts() void {	273	fn testFloatToInts() !void {
274	const x = @as(i32, 1e4);	274	const x = @as(i32, 1e4);
275	expect(x == 10000);	275	try expect(x == 10000);
276	const y = @floatToInt(i32, @as(f32, 1e4));	276	const y = @floatToInt(i32, @as(f32, 1e4));
277	expect(y == 10000);	277	try expect(y == 10000);
278	expectFloatToInt(f16, 255.1, u8, 255);	278	try expectFloatToInt(f16, 255.1, u8, 255);
279	expectFloatToInt(f16, 127.2, i8, 127);	279	try expectFloatToInt(f16, 127.2, i8, 127);
280	expectFloatToInt(f16, -128.2, i8, -128);	280	try expectFloatToInt(f16, -128.2, i8, -128);
281	expectFloatToInt(f32, 255.1, u8, 255);	281	try expectFloatToInt(f32, 255.1, u8, 255);
282	expectFloatToInt(f32, 127.2, i8, 127);	282	try expectFloatToInt(f32, 127.2, i8, 127);
283	expectFloatToInt(f32, -128.2, i8, -128);	283	try expectFloatToInt(f32, -128.2, i8, -128);
284	expectFloatToInt(comptime_int, 1234, i16, 1234);	284	try expectFloatToInt(comptime_int, 1234, i16, 1234);
285	}	285	}
286		286
287	fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) void {	287	fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void {
288	expect(@floatToInt(I, f) == i);	288	try expect(@floatToInt(I, f) == i);
289	}	289	}
290		290
291	test "cast u128 to f128 and back" {	291	test "cast u128 to f128 and back" {
292	comptime testCast128();	292	comptime try testCast128();
293	testCast128();	293	try testCast128();
294	}	294	}
295		295
296	fn testCast128() void {	296	fn testCast128() !void {
297	expect(cast128Int(cast128Float(0x7fff0000000000000000000000000000)) == 0x7fff0000000000000000000000000000);	297	try expect(cast128Int(cast128Float(0x7fff0000000000000000000000000000)) == 0x7fff0000000000000000000000000000);
298	}	298	}
299		299
300	fn cast128Int(x: f128) u128 {	300	fn cast128Int(x: f128) u128 {
...	@@ -306,69 +306,69 @@ fn cast128Float(x: u128) f128 {	...	@@ -306,69 +306,69 @@ fn cast128Float(x: u128) f128 {
306	}	306	}
307		307
308	test "single-item pointer of array to slice and to unknown length pointer" {	308	test "single-item pointer of array to slice and to unknown length pointer" {
309	testCastPtrOfArrayToSliceAndPtr();	309	try testCastPtrOfArrayToSliceAndPtr();
310	comptime testCastPtrOfArrayToSliceAndPtr();	310	comptime try testCastPtrOfArrayToSliceAndPtr();
311	}	311	}
312		312
313	fn testCastPtrOfArrayToSliceAndPtr() void {	313	fn testCastPtrOfArrayToSliceAndPtr() !void {
314	{	314	{
315	var array = "aoeu".*;	315	var array = "aoeu".*;
316	const x: [*]u8 = &array;	316	const x: [*]u8 = &array;
317	x[0] += 1;	317	x[0] += 1;
318	expect(mem.eql(u8, array[0..], "boeu"));	318	try expect(mem.eql(u8, array[0..], "boeu"));
319	const y: []u8 = &array;	319	const y: []u8 = &array;
320	y[0] += 1;	320	y[0] += 1;
321	expect(mem.eql(u8, array[0..], "coeu"));	321	try expect(mem.eql(u8, array[0..], "coeu"));
322	}	322	}
323	{	323	{
324	var array: [4]u8 = "aoeu".*;	324	var array: [4]u8 = "aoeu".*;
325	const x: [*]u8 = &array;	325	const x: [*]u8 = &array;
326	x[0] += 1;	326	x[0] += 1;
327	expect(mem.eql(u8, array[0..], "boeu"));	327	try expect(mem.eql(u8, array[0..], "boeu"));
328	const y: []u8 = &array;	328	const y: []u8 = &array;
329	y[0] += 1;	329	y[0] += 1;
330	expect(mem.eql(u8, array[0..], "coeu"));	330	try expect(mem.eql(u8, array[0..], "coeu"));
331	}	331	}
332	}	332	}
333		333
334	test "cast [1][]const u8 to []const ?[]const u8" {	334	test "cast [1][]const u8 to []const ?[]const u8" {
335	const window_name = [1][*]const u8{"window name"};	335	const window_name = [1][*]const u8{"window name"};
336	const x: []const ?[]const u8 = &window_name;	336	const x: []const ?[]const u8 = &window_name;
337	expect(mem.eql(u8, std.mem.spanZ(@ptrCast([*:0]const u8, x[0].?)), "window name"));	337	try expect(mem.eql(u8, std.mem.spanZ(@ptrCast([*:0]const u8, x[0].?)), "window name"));
338	}	338	}
339		339
340	test "@intCast comptime_int" {	340	test "@intCast comptime_int" {
341	const result = @intCast(i32, 1234);	341	const result = @intCast(i32, 1234);
342	expect(@TypeOf(result) == i32);	342	try expect(@TypeOf(result) == i32);
343	expect(result == 1234);	343	try expect(result == 1234);
344	}	344	}
345		345
346	test "@floatCast comptime_int and comptime_float" {	346	test "@floatCast comptime_int and comptime_float" {
347	{	347	{
348	const result = @floatCast(f16, 1234);	348	const result = @floatCast(f16, 1234);
349	expect(@TypeOf(result) == f16);	349	try expect(@TypeOf(result) == f16);
350	expect(result == 1234.0);	350	try expect(result == 1234.0);
351	}	351	}
352	{	352	{
353	const result = @floatCast(f16, 1234.0);	353	const result = @floatCast(f16, 1234.0);
354	expect(@TypeOf(result) == f16);	354	try expect(@TypeOf(result) == f16);
355	expect(result == 1234.0);	355	try expect(result == 1234.0);
356	}	356	}
357	{	357	{
358	const result = @floatCast(f32, 1234);	358	const result = @floatCast(f32, 1234);
359	expect(@TypeOf(result) == f32);	359	try expect(@TypeOf(result) == f32);
360	expect(result == 1234.0);	360	try expect(result == 1234.0);
361	}	361	}
362	{	362	{
363	const result = @floatCast(f32, 1234.0);	363	const result = @floatCast(f32, 1234.0);
364	expect(@TypeOf(result) == f32);	364	try expect(@TypeOf(result) == f32);
365	expect(result == 1234.0);	365	try expect(result == 1234.0);
366	}	366	}
367	}	367	}
368		368
369	test "vector casts" {	369	test "vector casts" {
370	const S = struct {	370	const S = struct {
371	fn doTheTest() void {	371	fn doTheTest() !void {
372	// Upcast (implicit, equivalent to @intCast)	372	// Upcast (implicit, equivalent to @intCast)
373	var up0: Vector(2, u8) = [_]u8{ 0x55, 0xaa };	373	var up0: Vector(2, u8) = [_]u8{ 0x55, 0xaa };
374	var up1 = @as(Vector(2, u16), up0);	374	var up1 = @as(Vector(2, u16), up0);
...	@@ -380,55 +380,55 @@ test "vector casts" {	...	@@ -380,55 +380,55 @@ test "vector casts" {
380	var down2 = @intCast(Vector(2, u16), down0);	380	var down2 = @intCast(Vector(2, u16), down0);
381	var down3 = @intCast(Vector(2, u8), down0);	381	var down3 = @intCast(Vector(2, u8), down0);
382		382
383	expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa }));	383	try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa }));
384	expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa }));	384	try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa }));
385	expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa }));	385	try expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa }));
386		386
387	expect(mem.eql(u32, &@as([2]u32, down1), &[2]u32{ 0x55, 0xaa }));	387	try expect(mem.eql(u32, &@as([2]u32, down1), &[2]u32{ 0x55, 0xaa }));
388	expect(mem.eql(u16, &@as([2]u16, down2), &[2]u16{ 0x55, 0xaa }));	388	try expect(mem.eql(u16, &@as([2]u16, down2), &[2]u16{ 0x55, 0xaa }));
389	expect(mem.eql(u8, &@as([2]u8, down3), &[2]u8{ 0x55, 0xaa }));	389	try expect(mem.eql(u8, &@as([2]u8, down3), &[2]u8{ 0x55, 0xaa }));
390	}	390	}
391		391
392	fn doTheTestFloat() void {	392	fn doTheTestFloat() !void {
393	var vec = @splat(2, @as(f32, 1234.0));	393	var vec = @splat(2, @as(f32, 1234.0));
394	var wider: Vector(2, f64) = vec;	394	var wider: Vector(2, f64) = vec;
395	expect(wider[0] == 1234.0);	395	try expect(wider[0] == 1234.0);
396	expect(wider[1] == 1234.0);	396	try expect(wider[1] == 1234.0);
397	}	397	}
398	};	398	};
399		399
400	S.doTheTest();	400	try S.doTheTest();
401	comptime S.doTheTest();	401	comptime try S.doTheTest();
402	S.doTheTestFloat();	402	try S.doTheTestFloat();
403	comptime S.doTheTestFloat();	403	comptime try S.doTheTestFloat();
404	}	404	}
405		405
406	test "comptime_int @intToFloat" {	406	test "comptime_int @intToFloat" {
407	{	407	{
408	const result = @intToFloat(f16, 1234);	408	const result = @intToFloat(f16, 1234);
409	expect(@TypeOf(result) == f16);	409	try expect(@TypeOf(result) == f16);
410	expect(result == 1234.0);	410	try expect(result == 1234.0);
411	}	411	}
412	{	412	{
413	const result = @intToFloat(f32, 1234);	413	const result = @intToFloat(f32, 1234);
414	expect(@TypeOf(result) == f32);	414	try expect(@TypeOf(result) == f32);
415	expect(result == 1234.0);	415	try expect(result == 1234.0);
416	}	416	}
417	{	417	{
418	const result = @intToFloat(f64, 1234);	418	const result = @intToFloat(f64, 1234);
419	expect(@TypeOf(result) == f64);	419	try expect(@TypeOf(result) == f64);
420	expect(result == 1234.0);	420	try expect(result == 1234.0);
421	}	421	}
422	{	422	{
423	const result = @intToFloat(f128, 1234);	423	const result = @intToFloat(f128, 1234);
424	expect(@TypeOf(result) == f128);	424	try expect(@TypeOf(result) == f128);
425	expect(result == 1234.0);	425	try expect(result == 1234.0);
426	}	426	}
427	// big comptime_int (> 64 bits) to f128 conversion	427	// big comptime_int (> 64 bits) to f128 conversion
428	{	428	{
429	const result = @intToFloat(f128, 0x1_0000_0000_0000_0000);	429	const result = @intToFloat(f128, 0x1_0000_0000_0000_0000);
430	expect(@TypeOf(result) == f128);	430	try expect(@TypeOf(result) == f128);
431	expect(result == 0x1_0000_0000_0000_0000.0);	431	try expect(result == 0x1_0000_0000_0000_0000.0);
432	}	432	}
433	}	433	}
434		434
...	@@ -436,25 +436,25 @@ test "@intCast i32 to u7" {	...	@@ -436,25 +436,25 @@ test "@intCast i32 to u7" {
436	var x: u128 = maxInt(u128);	436	var x: u128 = maxInt(u128);
437	var y: i32 = 120;	437	var y: i32 = 120;
438	var z = x >> @intCast(u7, y);	438	var z = x >> @intCast(u7, y);
439	expect(z == 0xff);	439	try expect(z == 0xff);
440	}	440	}
441		441
442	test "@floatCast cast down" {	442	test "@floatCast cast down" {
443	{	443	{
444	var double: f64 = 0.001534;	444	var double: f64 = 0.001534;
445	var single = @floatCast(f32, double);	445	var single = @floatCast(f32, double);
446	expect(single == 0.001534);	446	try expect(single == 0.001534);
447	}	447	}
448	{	448	{
449	const double: f64 = 0.001534;	449	const double: f64 = 0.001534;
450	const single = @floatCast(f32, double);	450	const single = @floatCast(f32, double);
451	expect(single == 0.001534);	451	try expect(single == 0.001534);
452	}	452	}
453	}	453	}
454		454
455	test "implicit cast undefined to optional" {	455	test "implicit cast undefined to optional" {
456	expect(MakeType(void).getNull() == null);	456	try expect(MakeType(void).getNull() == null);
457	expect(MakeType(void).getNonNull() != null);	457	try expect(MakeType(void).getNonNull() != null);
458	}	458	}
459		459
460	fn MakeType(comptime T: type) type {	460	fn MakeType(comptime T: type) type {
...	@@ -474,26 +474,26 @@ test "implicit cast from [N]T to ?[]T" {	...	@@ -474,26 +474,26 @@ test "implicit cast from [N]T to ?[]T" {
474	var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };	474	var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
475		475
476	x = &y;	476	x = &y;
477	expect(std.mem.eql(u16, x.?[0..4], y[0..4]));	477	try expect(std.mem.eql(u16, x.?[0..4], y[0..4]));
478	x.?[0] = 8;	478	x.?[0] = 8;
479	y[3] = 6;	479	y[3] = 6;
480	expect(std.mem.eql(u16, x.?[0..4], y[0..4]));	480	try expect(std.mem.eql(u16, x.?[0..4], y[0..4]));
481	}	481	}
482		482
483	test "implicit cast from [N]T to [c]T" {	483	test "implicit cast from [N]T to [c]T" {
484	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };	484	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
485	var y: [*c]u16 = &x;	485	var y: [*c]u16 = &x;
486		486
487	expect(std.mem.eql(u16, x[0..4], y[0..4]));	487	try expect(std.mem.eql(u16, x[0..4], y[0..4]));
488	x[0] = 8;	488	x[0] = 8;
489	y[3] = 6;	489	y[3] = 6;
490	expect(std.mem.eql(u16, x[0..4], y[0..4]));	490	try expect(std.mem.eql(u16, x[0..4], y[0..4]));
491	}	491	}
492		492
493	test "implicit cast from T to ?c_void" {	493	test "implicit cast from T to ?c_void" {
494	var a: u8 = 1;	494	var a: u8 = 1;
495	incrementVoidPtrValue(&a);	495	incrementVoidPtrValue(&a);
496	std.testing.expect(a == 2);	496	try std.testing.expect(a == 2);
497	}	497	}
498		498
499	fn incrementVoidPtrValue(value: ?*c_void) void {	499	fn incrementVoidPtrValue(value: ?*c_void) void {
...	@@ -504,7 +504,7 @@ test "implicit cast from []T to ?c_void" {	...	@@ -504,7 +504,7 @@ test "implicit cast from []T to ?c_void" {
504	var a = [_]u8{ 3, 2, 1 };	504	var a = [_]u8{ 3, 2, 1 };
505	var runtime_zero: usize = 0;	505	var runtime_zero: usize = 0;
506	incrementVoidPtrArray(a[runtime_zero..].ptr, 3);	506	incrementVoidPtrArray(a[runtime_zero..].ptr, 3);
507	expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 }));	507	try expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 }));
508	}	508	}
509		509
510	fn incrementVoidPtrArray(array: ?*c_void, len: usize) void {	510	fn incrementVoidPtrArray(array: ?*c_void, len: usize) void {
...	@@ -521,34 +521,34 @@ test "usize to void" {	...	@@ -521,34 +521,34 @@ test "usize to void" {
521	}	521	}
522		522
523	test "compile time int to ptr of function" {	523	test "compile time int to ptr of function" {
524	foobar(FUNCTION_CONSTANT);	524	try foobar(FUNCTION_CONSTANT);
525	}	525	}
526		526
527	pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize));	527	pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize));
528	pub const PFN_void = fn (*c_void) callconv(.C) void;	528	pub const PFN_void = fn (*c_void) callconv(.C) void;
529		529
530	fn foobar(func: PFN_void) void {	530	fn foobar(func: PFN_void) !void {
531	std.testing.expect(@ptrToInt(func) == maxInt(usize));	531	try std.testing.expect(@ptrToInt(func) == maxInt(usize));
532	}	532	}
533		533
534	test "implicit ptr to *c_void" {	534	test "implicit ptr to *c_void" {
535	var a: u32 = 1;	535	var a: u32 = 1;
536	var ptr: *align(@alignOf(u32)) c_void = &a;	536	var ptr: *align(@alignOf(u32)) c_void = &a;
537	var b: u32 = @ptrCast(u32, ptr);	537	var b: u32 = @ptrCast(u32, ptr);
538	expect(b.* == 1);	538	try expect(b.* == 1);
539	var ptr2: ?*align(@alignOf(u32)) c_void = &a;	539	var ptr2: ?*align(@alignOf(u32)) c_void = &a;
540	var c: u32 = @ptrCast(u32, ptr2.?);	540	var c: u32 = @ptrCast(u32, ptr2.?);
541	expect(c.* == 1);	541	try expect(c.* == 1);
542	}	542	}
543		543
544	test "@intCast to comptime_int" {	544	test "@intCast to comptime_int" {
545	expect(@intCast(comptime_int, 0) == 0);	545	try expect(@intCast(comptime_int, 0) == 0);
546	}	546	}
547		547
548	test "implicit cast comptime numbers to any type when the value fits" {	548	test "implicit cast comptime numbers to any type when the value fits" {
549	const a: u64 = 255;	549	const a: u64 = 255;
550	var b: u8 = a;	550	var b: u8 = a;
551	expect(b == 255);	551	try expect(b == 255);
552	}	552	}
553		553
554	test "@intToEnum passed a comptime_int to an enum with one item" {	554	test "@intToEnum passed a comptime_int to an enum with one item" {
...	@@ -556,7 +556,7 @@ test "@intToEnum passed a comptime_int to an enum with one item" {	...	@@ -556,7 +556,7 @@ test "@intToEnum passed a comptime_int to an enum with one item" {
556	A,	556	A,
557	};	557	};
558	const x = @intToEnum(E, 0);	558	const x = @intToEnum(E, 0);
559	expect(x == E.A);	559	try expect(x == E.A);
560	}	560	}
561		561
562	test "@intToEnum runtime to an extern enum with duplicate values" {	562	test "@intToEnum runtime to an extern enum with duplicate values" {
...	@@ -566,33 +566,33 @@ test "@intToEnum runtime to an extern enum with duplicate values" {	...	@@ -566,33 +566,33 @@ test "@intToEnum runtime to an extern enum with duplicate values" {
566	};	566	};
567	var a: u8 = 1;	567	var a: u8 = 1;
568	var x = @intToEnum(E, a);	568	var x = @intToEnum(E, a);
569	expect(x == E.A);	569	try expect(x == E.A);
570	expect(x == E.B);	570	try expect(x == E.B);
571	}	571	}
572		572
573	test "@intCast to u0 and use the result" {	573	test "@intCast to u0 and use the result" {
574	const S = struct {	574	const S = struct {
575	fn doTheTest(zero: u1, one: u1, bigzero: i32) void {	575	fn doTheTest(zero: u1, one: u1, bigzero: i32) !void {
576	expect((one << @intCast(u0, bigzero)) == 1);	576	try expect((one << @intCast(u0, bigzero)) == 1);
577	expect((zero << @intCast(u0, bigzero)) == 0);	577	try expect((zero << @intCast(u0, bigzero)) == 0);
578	}	578	}
579	};	579	};
580	S.doTheTest(0, 1, 0);	580	try S.doTheTest(0, 1, 0);
581	comptime S.doTheTest(0, 1, 0);	581	comptime try S.doTheTest(0, 1, 0);
582	}	582	}
583		583
584	test "peer type resolution: unreachable, null, slice" {	584	test "peer type resolution: unreachable, null, slice" {
585	const S = struct {	585	const S = struct {
586	fn doTheTest(num: usize, word: []const u8) void {	586	fn doTheTest(num: usize, word: []const u8) !void {
587	const result = switch (num) {	587	const result = switch (num) {
588	0 => null,	588	0 => null,
589	1 => word,	589	1 => word,
590	else => unreachable,	590	else => unreachable,
591	};	591	};
592	expect(mem.eql(u8, result.?, "hi"));	592	try expect(mem.eql(u8, result.?, "hi"));
593	}	593	}
594	};	594	};
595	S.doTheTest(1, "hi");	595	try S.doTheTest(1, "hi");
596	}	596	}
597		597
598	test "peer type resolution: unreachable, error set, unreachable" {	598	test "peer type resolution: unreachable, error set, unreachable" {
...	@@ -615,17 +615,17 @@ test "peer type resolution: unreachable, error set, unreachable" {	...	@@ -615,17 +615,17 @@ test "peer type resolution: unreachable, error set, unreachable" {
615	error.FileDescriptorIncompatibleWithEpoll => unreachable,	615	error.FileDescriptorIncompatibleWithEpoll => unreachable,
616	error.Unexpected => unreachable,	616	error.Unexpected => unreachable,
617	};	617	};
618	expect(transformed_err == error.SystemResources);	618	try expect(transformed_err == error.SystemResources);
619	}	619	}
620		620
621	test "implicit cast comptime_int to comptime_float" {	621	test "implicit cast comptime_int to comptime_float" {
622	comptime expect(@as(comptime_float, 10) == @as(f32, 10));	622	comptime try expect(@as(comptime_float, 10) == @as(f32, 10));
623	expect(2 == 2.0);	623	try expect(2 == 2.0);
624	}	624	}
625		625
626	test "implicit cast *[0]T to E![]const u8" {	626	test "implicit cast *[0]T to E![]const u8" {
627	var x = @as(anyerror![]const u8, &[0]u8{});	627	var x = @as(anyerror![]const u8, &[0]u8{});
628	expect((x catch unreachable).len == 0);	628	try expect((x catch unreachable).len == 0);
629	}	629	}
630		630
631	test "peer cast *[0]T to E![]const T" {	631	test "peer cast *[0]T to E![]const T" {
...	@@ -633,7 +633,7 @@ test "peer cast *[0]T to E![]const T" {	...	@@ -633,7 +633,7 @@ test "peer cast *[0]T to E![]const T" {
633	var buf: anyerror![]const u8 = buffer[0..];	633	var buf: anyerror![]const u8 = buffer[0..];
634	var b = false;	634	var b = false;
635	var y = if (b) &[0]u8{} else buf;	635	var y = if (b) &[0]u8{} else buf;
636	expect(mem.eql(u8, "abcde", y catch unreachable));	636	try expect(mem.eql(u8, "abcde", y catch unreachable));
637	}	637	}
638		638
639	test "peer cast *[0]T to []const T" {	639	test "peer cast *[0]T to []const T" {
...	@@ -641,25 +641,25 @@ test "peer cast *[0]T to []const T" {	...	@@ -641,25 +641,25 @@ test "peer cast *[0]T to []const T" {
641	var buf: []const u8 = buffer[0..];	641	var buf: []const u8 = buffer[0..];
642	var b = false;	642	var b = false;
643	var y = if (b) &[0]u8{} else buf;	643	var y = if (b) &[0]u8{} else buf;
644	expect(mem.eql(u8, "abcde", y));	644	try expect(mem.eql(u8, "abcde", y));
645	}	645	}
646		646
647	var global_array: [4]u8 = undefined;	647	var global_array: [4]u8 = undefined;
648	test "cast from array reference to fn" {	648	test "cast from array reference to fn" {
649	const f = @ptrCast(fn () callconv(.C) void, &global_array);	649	const f = @ptrCast(fn () callconv(.C) void, &global_array);
650	expect(@ptrToInt(f) == @ptrToInt(&global_array));	650	try expect(@ptrToInt(f) == @ptrToInt(&global_array));
651	}	651	}
652		652
653	test "*const [N]null u8 to ?[]const u8" {	653	test "*const [N]null u8 to ?[]const u8" {
654	const S = struct {	654	const S = struct {
655	fn doTheTest() void {	655	fn doTheTest() !void {
656	var a = "Hello";	656	var a = "Hello";
657	var b: ?[]const u8 = a;	657	var b: ?[]const u8 = a;
658	expect(mem.eql(u8, b.?, "Hello"));	658	try expect(mem.eql(u8, b.?, "Hello"));
659	}	659	}
660	};	660	};
661	S.doTheTest();	661	try S.doTheTest();
662	comptime S.doTheTest();	662	comptime try S.doTheTest();
663	}	663	}
664		664
665	test "peer resolution of string literals" {	665	test "peer resolution of string literals" {
...	@@ -671,54 +671,54 @@ test "peer resolution of string literals" {	...	@@ -671,54 +671,54 @@ test "peer resolution of string literals" {
671	d,	671	d,
672	};	672	};
673		673
674	fn doTheTest(e: E) void {	674	fn doTheTest(e: E) !void {
675	const cmd = switch (e) {	675	const cmd = switch (e) {
676	.a => "one",	676	.a => "one",
677	.b => "two",	677	.b => "two",
678	.c => "three",	678	.c => "three",
679	.d => "four",	679	.d => "four",
680	};	680	};
681	expect(mem.eql(u8, cmd, "two"));	681	try expect(mem.eql(u8, cmd, "two"));
682	}	682	}
683	};	683	};
684	S.doTheTest(.b);	684	try S.doTheTest(.b);
685	comptime S.doTheTest(.b);	685	comptime try S.doTheTest(.b);
686	}	686	}
687		687
688	test "type coercion related to sentinel-termination" {	688	test "type coercion related to sentinel-termination" {
689	const S = struct {	689	const S = struct {
690	fn doTheTest() void {	690	fn doTheTest() !void {
691	// [:x]T to []T	691	// [:x]T to []T
692	{	692	{
693	var array = [4:0]i32{ 1, 2, 3, 4 };	693	var array = [4:0]i32{ 1, 2, 3, 4 };
694	var slice: [:0]i32 = &array;	694	var slice: [:0]i32 = &array;
695	var dest: []i32 = slice;	695	var dest: []i32 = slice;
696	expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));	696	try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
697	}	697	}
698		698
699	// [:x]T to []T	699	// [:x]T to []T
700	{	700	{
701	var array = [4:99]i32{ 1, 2, 3, 4 };	701	var array = [4:99]i32{ 1, 2, 3, 4 };
702	var dest: [*]i32 = &array;	702	var dest: [*]i32 = &array;
703	expect(dest[0] == 1);	703	try expect(dest[0] == 1);
704	expect(dest[1] == 2);	704	try expect(dest[1] == 2);
705	expect(dest[2] == 3);	705	try expect(dest[2] == 3);
706	expect(dest[3] == 4);	706	try expect(dest[3] == 4);
707	expect(dest[4] == 99);	707	try expect(dest[4] == 99);
708	}	708	}
709		709
710	// [N:x]T to [N]T	710	// [N:x]T to [N]T
711	{	711	{
712	var array = [4:0]i32{ 1, 2, 3, 4 };	712	var array = [4:0]i32{ 1, 2, 3, 4 };
713	var dest: [4]i32 = array;	713	var dest: [4]i32 = array;
714	expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 }));	714	try expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 }));
715	}	715	}
716		716
717	// [N:x]T to [N]T	717	// [N:x]T to [N]T
718	{	718	{
719	var array = [4:0]i32{ 1, 2, 3, 4 };	719	var array = [4:0]i32{ 1, 2, 3, 4 };
720	var dest: *[4]i32 = &array;	720	var dest: *[4]i32 = &array;
721	expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));	721	try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
722	}	722	}
723		723
724	// [:x]T to [*:x]T	724	// [:x]T to [*:x]T
...	@@ -726,24 +726,24 @@ test "type coercion related to sentinel-termination" {	...	@@ -726,24 +726,24 @@ test "type coercion related to sentinel-termination" {
726	var array = [4:0]i32{ 1, 2, 3, 4 };	726	var array = [4:0]i32{ 1, 2, 3, 4 };
727	var slice: [:0]i32 = &array;	727	var slice: [:0]i32 = &array;
728	var dest: [*:0]i32 = slice;	728	var dest: [*:0]i32 = slice;
729	expect(dest[0] == 1);	729	try expect(dest[0] == 1);
730	expect(dest[1] == 2);	730	try expect(dest[1] == 2);
731	expect(dest[2] == 3);	731	try expect(dest[2] == 3);
732	expect(dest[3] == 4);	732	try expect(dest[3] == 4);
733	expect(dest[4] == 0);	733	try expect(dest[4] == 0);
734	}	734	}
735	}	735	}
736	};	736	};
737	S.doTheTest();	737	try S.doTheTest();
738	comptime S.doTheTest();	738	comptime try S.doTheTest();
739	}	739	}
740		740
741	test "cast i8 fn call peers to i32 result" {	741	test "cast i8 fn call peers to i32 result" {
742	const S = struct {	742	const S = struct {
743	fn doTheTest() void {	743	fn doTheTest() !void {
744	var cond = true;	744	var cond = true;
745	const value: i32 = if (cond) smallBoi() else bigBoi();	745	const value: i32 = if (cond) smallBoi() else bigBoi();
746	expect(value == 123);	746	try expect(value == 123);
747	}	747	}
748	fn smallBoi() i8 {	748	fn smallBoi() i8 {
749	return 123;	749	return 123;
...	@@ -752,21 +752,21 @@ test "cast i8 fn call peers to i32 result" {	...	@@ -752,21 +752,21 @@ test "cast i8 fn call peers to i32 result" {
752	return 1234;	752	return 1234;
753	}	753	}
754	};	754	};
755	S.doTheTest();	755	try S.doTheTest();
756	comptime S.doTheTest();	756	comptime try S.doTheTest();
757	}	757	}
758		758
759	test "return u8 coercing into ?u32 return type" {	759	test "return u8 coercing into ?u32 return type" {
760	const S = struct {	760	const S = struct {
761	fn doTheTest() void {	761	fn doTheTest() !void {
762	expect(foo(123).? == 123);	762	try expect(foo(123).? == 123);
763	}	763	}
764	fn foo(arg: u8) ?u32 {	764	fn foo(arg: u8) ?u32 {
765	return arg;	765	return arg;
766	}	766	}
767	};	767	};
768	S.doTheTest();	768	try S.doTheTest();
769	comptime S.doTheTest();	769	comptime try S.doTheTest();
770	}	770	}
771		771
772	test "peer result null and comptime_int" {	772	test "peer result null and comptime_int" {
...	@@ -782,17 +782,17 @@ test "peer result null and comptime_int" {	...	@@ -782,17 +782,17 @@ test "peer result null and comptime_int" {
782	}	782	}
783	};	783	};
784		784
785	expect(S.blah(0) == null);	785	try expect(S.blah(0) == null);
786	comptime expect(S.blah(0) == null);	786	comptime try expect(S.blah(0) == null);
787	expect(S.blah(10).? == 1);	787	try expect(S.blah(10).? == 1);
788	comptime expect(S.blah(10).? == 1);	788	comptime try expect(S.blah(10).? == 1);
789	expect(S.blah(-10).? == -1);	789	try expect(S.blah(-10).? == -1);
790	comptime expect(S.blah(-10).? == -1);	790	comptime try expect(S.blah(-10).? == -1);
791	}	791	}
792		792
793	test "peer type resolution implicit cast to return type" {	793	test "peer type resolution implicit cast to return type" {
794	const S = struct {	794	const S = struct {
795	fn doTheTest() void {	795	fn doTheTest() !void {
796	for ("hello") \|c\| _ = f(c);	796	for ("hello") \|c\| _ = f(c);
797	}	797	}
798	fn f(c: u8) []const u8 {	798	fn f(c: u8) []const u8 {
...	@@ -803,13 +803,13 @@ test "peer type resolution implicit cast to return type" {	...	@@ -803,13 +803,13 @@ test "peer type resolution implicit cast to return type" {
803	};	803	};
804	}	804	}
805	};	805	};
806	S.doTheTest();	806	try S.doTheTest();
807	comptime S.doTheTest();	807	comptime try S.doTheTest();
808	}	808	}
809		809
810	test "peer type resolution implicit cast to variable type" {	810	test "peer type resolution implicit cast to variable type" {
811	const S = struct {	811	const S = struct {
812	fn doTheTest() void {	812	fn doTheTest() !void {
813	var x: []const u8 = undefined;	813	var x: []const u8 = undefined;
814	for ("hello") \|c\| x = switch (c) {	814	for ("hello") \|c\| x = switch (c) {
815	'h', 'e' => &[_]u8{c}, // should cast to slice	815	'h', 'e' => &[_]u8{c}, // should cast to slice
...	@@ -818,14 +818,14 @@ test "peer type resolution implicit cast to variable type" {	...	@@ -818,14 +818,14 @@ test "peer type resolution implicit cast to variable type" {
818	};	818	};
819	}	819	}
820	};	820	};
821	S.doTheTest();	821	try S.doTheTest();
822	comptime S.doTheTest();	822	comptime try S.doTheTest();
823	}	823	}
824		824
825	test "variable initialization uses result locations properly with regards to the type" {	825	test "variable initialization uses result locations properly with regards to the type" {
826	var b = true;	826	var b = true;
827	const x: i32 = if (b) 1 else 2;	827	const x: i32 = if (b) 1 else 2;
828	expect(x == 1);	828	try expect(x == 1);
829	}	829	}
830		830
831	test "cast between [c]T and ?[:0]T on fn parameter" {	831	test "cast between [c]T and ?[:0]T on fn parameter" {
...	@@ -847,27 +847,27 @@ test "cast between C pointer with different but compatible types" {	...	@@ -847,27 +847,27 @@ test "cast between C pointer with different but compatible types" {
847	fn foo(arg: [*]c_ushort) u16 {	847	fn foo(arg: [*]c_ushort) u16 {
848	return arg[0];	848	return arg[0];
849	}	849	}
850	fn doTheTest() void {	850	fn doTheTest() !void {
851	var x = [_]u16{ 4, 2, 1, 3 };	851	var x = [_]u16{ 4, 2, 1, 3 };
852	expect(foo(@ptrCast([*]u16, &x)) == 4);	852	try expect(foo(@ptrCast([*]u16, &x)) == 4);
853	}	853	}
854	};	854	};
855	S.doTheTest();	855	try S.doTheTest();
856	}	856	}
857		857
858	var global_struct: struct { f0: usize } = undefined;	858	var global_struct: struct { f0: usize } = undefined;
859		859
860	test "assignment to optional pointer result loc" {	860	test "assignment to optional pointer result loc" {
861	var foo: struct { ptr: ?*c_void } = .{ .ptr = &global_struct };	861	var foo: struct { ptr: ?*c_void } = .{ .ptr = &global_struct };
862	expect(foo.ptr.? == @ptrCast(*c_void, &global_struct));	862	try expect(foo.ptr.? == @ptrCast(*c_void, &global_struct));
863	}	863	}
864		864
865	test "peer type resolve string lit with sentinel-terminated mutable slice" {	865	test "peer type resolve string lit with sentinel-terminated mutable slice" {
866	var array: [4:0]u8 = undefined;	866	var array: [4:0]u8 = undefined;
867	array[4] = 0; // TODO remove this when #4372 is solved	867	array[4] = 0; // TODO remove this when #4372 is solved
868	var slice: [:0]u8 = array[0..4 :0];	868	var slice: [:0]u8 = array[0..4 :0];
869	comptime expect(@TypeOf(slice, "hi") == [:0]const u8);	869	comptime try expect(@TypeOf(slice, "hi") == [:0]const u8);
870	comptime expect(@TypeOf("hi", slice) == [:0]const u8);	870	comptime try expect(@TypeOf("hi", slice) == [:0]const u8);
871	}	871	}
872		872
873	test "peer type unsigned int to signed" {	873	test "peer type unsigned int to signed" {
...	@@ -875,15 +875,15 @@ test "peer type unsigned int to signed" {	...	@@ -875,15 +875,15 @@ test "peer type unsigned int to signed" {
875	var x: u8 = 7;	875	var x: u8 = 7;
876	var y: i32 = -5;	876	var y: i32 = -5;
877	var a = w + y + x;	877	var a = w + y + x;
878	comptime expect(@TypeOf(a) == i32);	878	comptime try expect(@TypeOf(a) == i32);
879	expect(a == 7);	879	try expect(a == 7);
880	}	880	}
881		881
882	test "peer type resolve array pointers, one of them const" {	882	test "peer type resolve array pointers, one of them const" {
883	var array1: [4]u8 = undefined;	883	var array1: [4]u8 = undefined;
884	const array2: [5]u8 = undefined;	884	const array2: [5]u8 = undefined;
885	comptime expect(@TypeOf(&array1, &array2) == []const u8);	885	comptime try expect(@TypeOf(&array1, &array2) == []const u8);
886	comptime expect(@TypeOf(&array2, &array1) == []const u8);	886	comptime try expect(@TypeOf(&array2, &array1) == []const u8);
887	}	887	}
888		888
889	test "peer type resolve array pointer and unknown pointer" {	889	test "peer type resolve array pointer and unknown pointer" {
...	@@ -892,35 +892,35 @@ test "peer type resolve array pointer and unknown pointer" {	...	@@ -892,35 +892,35 @@ test "peer type resolve array pointer and unknown pointer" {
892	var const_ptr: [*]const u8 = undefined;	892	var const_ptr: [*]const u8 = undefined;
893	var ptr: [*]u8 = undefined;	893	var ptr: [*]u8 = undefined;
894		894
895	comptime expect(@TypeOf(&array, ptr) == [*]u8);	895	comptime try expect(@TypeOf(&array, ptr) == [*]u8);
896	comptime expect(@TypeOf(ptr, &array) == [*]u8);	896	comptime try expect(@TypeOf(ptr, &array) == [*]u8);
897		897
898	comptime expect(@TypeOf(&const_array, ptr) == [*]const u8);	898	comptime try expect(@TypeOf(&const_array, ptr) == [*]const u8);
899	comptime expect(@TypeOf(ptr, &const_array) == [*]const u8);	899	comptime try expect(@TypeOf(ptr, &const_array) == [*]const u8);
900		900
901	comptime expect(@TypeOf(&array, const_ptr) == [*]const u8);	901	comptime try expect(@TypeOf(&array, const_ptr) == [*]const u8);
902	comptime expect(@TypeOf(const_ptr, &array) == [*]const u8);	902	comptime try expect(@TypeOf(const_ptr, &array) == [*]const u8);
903		903
904	comptime expect(@TypeOf(&const_array, const_ptr) == [*]const u8);	904	comptime try expect(@TypeOf(&const_array, const_ptr) == [*]const u8);
905	comptime expect(@TypeOf(const_ptr, &const_array) == [*]const u8);	905	comptime try expect(@TypeOf(const_ptr, &const_array) == [*]const u8);
906	}	906	}
907		907
908	test "comptime float casts" {	908	test "comptime float casts" {
909	const a = @intToFloat(comptime_float, 1);	909	const a = @intToFloat(comptime_float, 1);
910	expect(a == 1);	910	try expect(a == 1);
911	expect(@TypeOf(a) == comptime_float);	911	try expect(@TypeOf(a) == comptime_float);
912	const b = @floatToInt(comptime_int, 2);	912	const b = @floatToInt(comptime_int, 2);
913	expect(b == 2);	913	try expect(b == 2);
914	expect(@TypeOf(b) == comptime_int);	914	try expect(@TypeOf(b) == comptime_int);
915	}	915	}
916		916
917	test "cast from ?[]T to ??[]T" {	917	test "cast from ?[]T to ??[]T" {
918	const a: ??[]u8 = @as(?[]u8, null);	918	const a: ??[]u8 = @as(?[]u8, null);
919	expect(a != null and a.? == null);	919	try expect(a != null and a.? == null);
920	}	920	}
921		921
922	test "cast between *[N]void and []void" {	922	test "cast between *[N]void and []void" {
923	var a: [4]void = undefined;	923	var a: [4]void = undefined;
924	var b: []void = &a;	924	var b: []void = &a;
925	expect(b.len == 4);	925	try expect(b.len == 4);
926	}	926	}

test/stage1/behavior/const_slice_child.zig+8-8

...	@@ -12,24 +12,24 @@ test "const slice child" {	...	@@ -12,24 +12,24 @@ test "const slice child" {
12	"three",	12	"three",
13	};	13	};
14	argv = &strs;	14	argv = &strs;
15	bar(strs.len);	15	try bar(strs.len);
16	}	16	}
17		17
18	fn foo(args: [][]const u8) void {	18	fn foo(args: [][]const u8) !void {
19	expect(args.len == 3);	19	try expect(args.len == 3);
20	expect(streql(args[0], "one"));	20	try expect(streql(args[0], "one"));
21	expect(streql(args[1], "two"));	21	try expect(streql(args[1], "two"));
22	expect(streql(args[2], "three"));	22	try expect(streql(args[2], "three"));
23	}	23	}
24		24
25	fn bar(argc: usize) void {	25	fn bar(argc: usize) !void {
26	const args = testing.allocator.alloc([]const u8, argc) catch unreachable;	26	const args = testing.allocator.alloc([]const u8, argc) catch unreachable;
27	defer testing.allocator.free(args);	27	defer testing.allocator.free(args);
28	for (args) \|_, i\| {	28	for (args) \|_, i\| {
29	const ptr = argv[i];	29	const ptr = argv[i];
30	args[i] = ptr[0..strlen(ptr)];	30	args[i] = ptr[0..strlen(ptr)];
31	}	31	}
32	foo(args);	32	try foo(args);
33	}	33	}
34		34
35	fn strlen(ptr: [*]const u8) usize {	35	fn strlen(ptr: [*]const u8) usize {

test/stage1/behavior/defer.zig+20-20

...	@@ -24,18 +24,18 @@ fn runSomeErrorDefers(x: bool) !bool {	...	@@ -24,18 +24,18 @@ fn runSomeErrorDefers(x: bool) !bool {
24	}	24	}
25		25
26	test "mixing normal and error defers" {	26	test "mixing normal and error defers" {
27	expect(runSomeErrorDefers(true) catch unreachable);	27	try expect(runSomeErrorDefers(true) catch unreachable);
28	expect(result[0] == 'c');	28	try expect(result[0] == 'c');
29	expect(result[1] == 'a');	29	try expect(result[1] == 'a');
30		30
31	const ok = runSomeErrorDefers(false) catch \|err\| x: {	31	const ok = runSomeErrorDefers(false) catch \|err\| x: {
32	expect(err == error.FalseNotAllowed);	32	try expect(err == error.FalseNotAllowed);
33	break :x true;	33	break :x true;
34	};	34	};
35	expect(ok);	35	try expect(ok);
36	expect(result[0] == 'c');	36	try expect(result[0] == 'c');
37	expect(result[1] == 'b');	37	try expect(result[1] == 'b');
38	expect(result[2] == 'a');	38	try expect(result[2] == 'a');
39	}	39	}
40		40
41	test "break and continue inside loop inside defer expression" {	41	test "break and continue inside loop inside defer expression" {
...	@@ -50,7 +50,7 @@ fn testBreakContInDefer(x: usize) void {	...	@@ -50,7 +50,7 @@ fn testBreakContInDefer(x: usize) void {
50	if (i < 5) continue;	50	if (i < 5) continue;
51	if (i == 5) break;	51	if (i == 5) break;
52	}	52	}
53	expect(i == 5);	53	expect(i == 5) catch @panic("test failure");
54	}	54	}
55	}	55	}
56		56
...	@@ -62,11 +62,11 @@ test "defer and labeled break" {	...	@@ -62,11 +62,11 @@ test "defer and labeled break" {
62	break :blk;	62	break :blk;
63	}	63	}
64		64
65	expect(i == 1);	65	try expect(i == 1);
66	}	66	}
67		67
68	test "errdefer does not apply to fn inside fn" {	68	test "errdefer does not apply to fn inside fn" {
69	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| expect(e == error.Bad);	69	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| try expect(e == error.Bad);
70	}	70	}
71		71
72	fn testNestedFnErrDefer() anyerror!void {	72	fn testNestedFnErrDefer() anyerror!void {
...	@@ -82,8 +82,8 @@ fn testNestedFnErrDefer() anyerror!void {	...	@@ -82,8 +82,8 @@ fn testNestedFnErrDefer() anyerror!void {
82		82
83	test "return variable while defer expression in scope to modify it" {	83	test "return variable while defer expression in scope to modify it" {
84	const S = struct {	84	const S = struct {
85	fn doTheTest() void {	85	fn doTheTest() !void {
86	expect(notNull().? == 1);	86	try expect(notNull().? == 1);
87	}	87	}
88		88
89	fn notNull() ?u8 {	89	fn notNull() ?u8 {
...	@@ -93,22 +93,22 @@ test "return variable while defer expression in scope to modify it" {	...	@@ -93,22 +93,22 @@ test "return variable while defer expression in scope to modify it" {
93	}	93	}
94	};	94	};
95		95
96	S.doTheTest();	96	try S.doTheTest();
97	comptime S.doTheTest();	97	comptime try S.doTheTest();
98	}	98	}
99		99
100	test "errdefer with payload" {	100	test "errdefer with payload" {
101	const S = struct {	101	const S = struct {
102	fn foo() !i32 {	102	fn foo() !i32 {
103	errdefer \|a\| {	103	errdefer \|a\| {
104	expectEqual(error.One, a);	104	expectEqual(error.One, a) catch @panic("test failure");
105	}	105	}
106	return error.One;	106	return error.One;
107	}	107	}
108	fn doTheTest() void {	108	fn doTheTest() !void {
109	expectError(error.One, foo());	109	try expectError(error.One, foo());
110	}	110	}
111	};	111	};
112	S.doTheTest();	112	try S.doTheTest();
113	comptime S.doTheTest();	113	comptime try S.doTheTest();
114	}	114	}

test/stage1/behavior/enum.zig+112-112

...	@@ -29,41 +29,41 @@ test "non-exhaustive enum" {	...	@@ -29,41 +29,41 @@ test "non-exhaustive enum" {
29	b,	29	b,
30	_,	30	_,
31	};	31	};
32	fn doTheTest(y: u8) void {	32	fn doTheTest(y: u8) !void {
33	var e: E = .b;	33	var e: E = .b;
34	expect(switch (e) {	34	try expect(switch (e) {
35	.a => false,	35	.a => false,
36	.b => true,	36	.b => true,
37	_ => false,	37	_ => false,
38	});	38	});
39	e = @intToEnum(E, 12);	39	e = @intToEnum(E, 12);
40	expect(switch (e) {	40	try expect(switch (e) {
41	.a => false,	41	.a => false,
42	.b => false,	42	.b => false,
43	_ => true,	43	_ => true,
44	});	44	});
45		45
46	expect(switch (e) {	46	try expect(switch (e) {
47	.a => false,	47	.a => false,
48	.b => false,	48	.b => false,
49	else => true,	49	else => true,
50	});	50	});
51	e = .b;	51	e = .b;
52	expect(switch (e) {	52	try expect(switch (e) {
53	.a => false,	53	.a => false,
54	else => true,	54	else => true,
55	});	55	});
56		56
57	expect(@typeInfo(E).Enum.fields.len == 2);	57	try expect(@typeInfo(E).Enum.fields.len == 2);
58	e = @intToEnum(E, 12);	58	e = @intToEnum(E, 12);
59	expect(@enumToInt(e) == 12);	59	try expect(@enumToInt(e) == 12);
60	e = @intToEnum(E, y);	60	e = @intToEnum(E, y);
61	expect(@enumToInt(e) == 52);	61	try expect(@enumToInt(e) == 52);
62	expect(@typeInfo(E).Enum.is_exhaustive == false);	62	try expect(@typeInfo(E).Enum.is_exhaustive == false);
63	}	63	}
64	};	64	};
65	S.doTheTest(52);	65	try S.doTheTest(52);
66	comptime S.doTheTest(52);	66	comptime try S.doTheTest(52);
67	}	67	}
68		68
69	test "empty non-exhaustive enum" {	69	test "empty non-exhaustive enum" {
...	@@ -71,19 +71,19 @@ test "empty non-exhaustive enum" {	...	@@ -71,19 +71,19 @@ test "empty non-exhaustive enum" {
71	const E = enum(u8) {	71	const E = enum(u8) {
72	_,	72	_,
73	};	73	};
74	fn doTheTest(y: u8) void {	74	fn doTheTest(y: u8) !void {
75	var e = @intToEnum(E, y);	75	var e = @intToEnum(E, y);
76	expect(switch (e) {	76	try expect(switch (e) {
77	_ => true,	77	_ => true,
78	});	78	});
79	expect(@enumToInt(e) == y);	79	try expect(@enumToInt(e) == y);
80		80
81	expect(@typeInfo(E).Enum.fields.len == 0);	81	try expect(@typeInfo(E).Enum.fields.len == 0);
82	expect(@typeInfo(E).Enum.is_exhaustive == false);	82	try expect(@typeInfo(E).Enum.is_exhaustive == false);
83	}	83	}
84	};	84	};
85	S.doTheTest(42);	85	try S.doTheTest(42);
86	comptime S.doTheTest(42);	86	comptime try S.doTheTest(42);
87	}	87	}
88		88
89	test "single field non-exhaustive enum" {	89	test "single field non-exhaustive enum" {
...	@@ -92,35 +92,35 @@ test "single field non-exhaustive enum" {	...	@@ -92,35 +92,35 @@ test "single field non-exhaustive enum" {
92	a,	92	a,
93	_,	93	_,
94	};	94	};
95	fn doTheTest(y: u8) void {	95	fn doTheTest(y: u8) !void {
96	var e: E = .a;	96	var e: E = .a;
97	expect(switch (e) {	97	try expect(switch (e) {
98	.a => true,	98	.a => true,
99	_ => false,	99	_ => false,
100	});	100	});
101	e = @intToEnum(E, 12);	101	e = @intToEnum(E, 12);
102	expect(switch (e) {	102	try expect(switch (e) {
103	.a => false,	103	.a => false,
104	_ => true,	104	_ => true,
105	});	105	});
106		106
107	expect(switch (e) {	107	try expect(switch (e) {
108	.a => false,	108	.a => false,
109	else => true,	109	else => true,
110	});	110	});
111	e = .a;	111	e = .a;
112	expect(switch (e) {	112	try expect(switch (e) {
113	.a => true,	113	.a => true,
114	else => false,	114	else => false,
115	});	115	});
116		116
117	expect(@enumToInt(@intToEnum(E, y)) == y);	117	try expect(@enumToInt(@intToEnum(E, y)) == y);
118	expect(@typeInfo(E).Enum.fields.len == 1);	118	try expect(@typeInfo(E).Enum.fields.len == 1);
119	expect(@typeInfo(E).Enum.is_exhaustive == false);	119	try expect(@typeInfo(E).Enum.is_exhaustive == false);
120	}	120	}
121	};	121	};
122	S.doTheTest(23);	122	try S.doTheTest(23);
123	comptime S.doTheTest(23);	123	comptime try S.doTheTest(23);
124	}	124	}
125		125
126	test "enum type" {	126	test "enum type" {
...	@@ -133,16 +133,16 @@ test "enum type" {	...	@@ -133,16 +133,16 @@ test "enum type" {
133	};	133	};
134	const bar = Bar.B;	134	const bar = Bar.B;
135		135
136	expect(bar == Bar.B);	136	try expect(bar == Bar.B);
137	expect(@typeInfo(Foo).Union.fields.len == 3);	137	try expect(@typeInfo(Foo).Union.fields.len == 3);
138	expect(@typeInfo(Bar).Enum.fields.len == 4);	138	try expect(@typeInfo(Bar).Enum.fields.len == 4);
139	expect(@sizeOf(Foo) == @sizeOf(FooNoVoid));	139	try expect(@sizeOf(Foo) == @sizeOf(FooNoVoid));
140	expect(@sizeOf(Bar) == 1);	140	try expect(@sizeOf(Bar) == 1);
141	}	141	}
142		142
143	test "enum as return value" {	143	test "enum as return value" {
144	switch (returnAnInt(13)) {	144	switch (returnAnInt(13)) {
145	Foo.One => \|value\| expect(value == 13),	145	Foo.One => \|value\| try expect(value == 13),
146	else => unreachable,	146	else => unreachable,
147	}	147	}
148	}	148	}
...	@@ -206,22 +206,22 @@ const Number = enum {	...	@@ -206,22 +206,22 @@ const Number = enum {
206	};	206	};
207		207
208	test "enum to int" {	208	test "enum to int" {
209	shouldEqual(Number.Zero, 0);	209	try shouldEqual(Number.Zero, 0);
210	shouldEqual(Number.One, 1);	210	try shouldEqual(Number.One, 1);
211	shouldEqual(Number.Two, 2);	211	try shouldEqual(Number.Two, 2);
212	shouldEqual(Number.Three, 3);	212	try shouldEqual(Number.Three, 3);
213	shouldEqual(Number.Four, 4);	213	try shouldEqual(Number.Four, 4);
214	}	214	}
215		215
216	fn shouldEqual(n: Number, expected: u3) void {	216	fn shouldEqual(n: Number, expected: u3) !void {
217	expect(@enumToInt(n) == expected);	217	try expect(@enumToInt(n) == expected);
218	}	218	}
219		219
220	test "int to enum" {	220	test "int to enum" {
221	testIntToEnumEval(3);	221	try testIntToEnumEval(3);
222	}	222	}
223	fn testIntToEnumEval(x: i32) void {	223	fn testIntToEnumEval(x: i32) !void {
224	expect(@intToEnum(IntToEnumNumber, @intCast(u3, x)) == IntToEnumNumber.Three);	224	try expect(@intToEnum(IntToEnumNumber, @intCast(u3, x)) == IntToEnumNumber.Three);
225	}	225	}
226	const IntToEnumNumber = enum {	226	const IntToEnumNumber = enum {
227	Zero,	227	Zero,
...	@@ -232,18 +232,18 @@ const IntToEnumNumber = enum {	...	@@ -232,18 +232,18 @@ const IntToEnumNumber = enum {
232	};	232	};
233		233
234	test "@tagName" {	234	test "@tagName" {
235	expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));	235	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
236	comptime expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));	236	comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
237	}	237	}
238		238
239	test "@tagName extern enum with duplicates" {	239	test "@tagName extern enum with duplicates" {
240	expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A"));	240	try expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A"));
241	comptime expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A"));	241	comptime try expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A"));
242	}	242	}
243		243
244	test "@tagName non-exhaustive enum" {	244	test "@tagName non-exhaustive enum" {
245	expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));	245	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
246	comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));	246	comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
247	}	247	}
248		248
249	fn testEnumTagNameBare(n: anytype) []const u8 {	249	fn testEnumTagNameBare(n: anytype) []const u8 {
...	@@ -269,8 +269,8 @@ const NonExhaustive = enum(u8) {	...	@@ -269,8 +269,8 @@ const NonExhaustive = enum(u8) {
269		269
270	test "enum alignment" {	270	test "enum alignment" {
271	comptime {	271	comptime {
272	expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8));	272	try expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8));
273	expect(@alignOf(AlignTestEnum) >= @alignOf(u64));	273	try expect(@alignOf(AlignTestEnum) >= @alignOf(u64));
274	}	274	}
275	}	275	}
276		276
...	@@ -806,10 +806,10 @@ const ValueCount257 = enum {	...	@@ -806,10 +806,10 @@ const ValueCount257 = enum {
806		806
807	test "enum sizes" {	807	test "enum sizes" {
808	comptime {	808	comptime {
809	expect(@sizeOf(ValueCount1) == 0);	809	try expect(@sizeOf(ValueCount1) == 0);
810	expect(@sizeOf(ValueCount2) == 1);	810	try expect(@sizeOf(ValueCount2) == 1);
811	expect(@sizeOf(ValueCount256) == 1);	811	try expect(@sizeOf(ValueCount256) == 1);
812	expect(@sizeOf(ValueCount257) == 2);	812	try expect(@sizeOf(ValueCount257) == 2);
813	}	813	}
814	}	814	}
815		815
...	@@ -828,12 +828,12 @@ test "set enum tag type" {	...	@@ -828,12 +828,12 @@ test "set enum tag type" {
828	{	828	{
829	var x = Small.One;	829	var x = Small.One;
830	x = Small.Two;	830	x = Small.Two;
831	comptime expect(Tag(Small) == u2);	831	comptime try expect(Tag(Small) == u2);
832	}	832	}
833	{	833	{
834	var x = Small2.One;	834	var x = Small2.One;
835	x = Small2.Two;	835	x = Small2.Two;
836	comptime expect(Tag(Small2) == u2);	836	comptime try expect(Tag(Small2) == u2);
837	}	837	}
838	}	838	}
839		839
...	@@ -880,17 +880,17 @@ const bit_field_1 = BitFieldOfEnums{	...	@@ -880,17 +880,17 @@ const bit_field_1 = BitFieldOfEnums{
880		880
881	test "bit field access with enum fields" {	881	test "bit field access with enum fields" {
882	var data = bit_field_1;	882	var data = bit_field_1;
883	expect(getA(&data) == A.Two);	883	try expect(getA(&data) == A.Two);
884	expect(getB(&data) == B.Three3);	884	try expect(getB(&data) == B.Three3);
885	expect(getC(&data) == C.Four4);	885	try expect(getC(&data) == C.Four4);
886	comptime expect(@sizeOf(BitFieldOfEnums) == 1);	886	comptime try expect(@sizeOf(BitFieldOfEnums) == 1);
887		887
888	data.b = B.Four3;	888	data.b = B.Four3;
889	expect(data.b == B.Four3);	889	try expect(data.b == B.Four3);
890		890
891	data.a = A.Three;	891	data.a = A.Three;
892	expect(data.a == A.Three);	892	try expect(data.a == A.Three);
893	expect(data.b == B.Four3);	893	try expect(data.b == B.Four3);
894	}	894	}
895		895
896	fn getA(data: *const BitFieldOfEnums) A {	896	fn getA(data: *const BitFieldOfEnums) A {
...	@@ -906,12 +906,12 @@ fn getC(data: *const BitFieldOfEnums) C {	...	@@ -906,12 +906,12 @@ fn getC(data: *const BitFieldOfEnums) C {
906	}	906	}
907		907
908	test "casting enum to its tag type" {	908	test "casting enum to its tag type" {
909	testCastEnumTag(Small2.Two);	909	try testCastEnumTag(Small2.Two);
910	comptime testCastEnumTag(Small2.Two);	910	comptime try testCastEnumTag(Small2.Two);
911	}	911	}
912		912
913	fn testCastEnumTag(value: Small2) void {	913	fn testCastEnumTag(value: Small2) !void {
914	expect(@enumToInt(value) == 1);	914	try expect(@enumToInt(value) == 1);
915	}	915	}
916		916
917	const MultipleChoice = enum(u32) {	917	const MultipleChoice = enum(u32) {
...	@@ -922,13 +922,13 @@ const MultipleChoice = enum(u32) {	...	@@ -922,13 +922,13 @@ const MultipleChoice = enum(u32) {
922	};	922	};
923		923
924	test "enum with specified tag values" {	924	test "enum with specified tag values" {
925	testEnumWithSpecifiedTagValues(MultipleChoice.C);	925	try testEnumWithSpecifiedTagValues(MultipleChoice.C);
926	comptime testEnumWithSpecifiedTagValues(MultipleChoice.C);	926	comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C);
927	}	927	}
928		928
929	fn testEnumWithSpecifiedTagValues(x: MultipleChoice) void {	929	fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
930	expect(@enumToInt(x) == 60);	930	try expect(@enumToInt(x) == 60);
931	expect(1234 == switch (x) {	931	try expect(1234 == switch (x) {
932	MultipleChoice.A => 1,	932	MultipleChoice.A => 1,
933	MultipleChoice.B => 2,	933	MultipleChoice.B => 2,
934	MultipleChoice.C => @as(u32, 1234),	934	MultipleChoice.C => @as(u32, 1234),
...	@@ -949,13 +949,13 @@ const MultipleChoice2 = enum(u32) {	...	@@ -949,13 +949,13 @@ const MultipleChoice2 = enum(u32) {
949	};	949	};
950		950
951	test "enum with specified and unspecified tag values" {	951	test "enum with specified and unspecified tag values" {
952	testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);	952	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
953	comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);	953	comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
954	}	954	}
955		955
956	fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {	956	fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
957	expect(@enumToInt(x) == 1000);	957	try expect(@enumToInt(x) == 1000);
958	expect(1234 == switch (x) {	958	try expect(1234 == switch (x) {
959	MultipleChoice2.A => 1,	959	MultipleChoice2.A => 1,
960	MultipleChoice2.B => 2,	960	MultipleChoice2.B => 2,
961	MultipleChoice2.C => 3,	961	MultipleChoice2.C => 3,
...	@@ -969,8 +969,8 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {	...	@@ -969,8 +969,8 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
969	}	969	}
970		970
971	test "cast integer literal to enum" {	971	test "cast integer literal to enum" {
972	expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);	972	try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
973	expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B);	973	try expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B);
974	}	974	}
975		975
976	const EnumWithOneMember = enum {	976	const EnumWithOneMember = enum {
...	@@ -1008,14 +1008,14 @@ const EnumWithTagValues = enum(u4) {	...	@@ -1008,14 +1008,14 @@ const EnumWithTagValues = enum(u4) {
1008	D = 1 << 3,	1008	D = 1 << 3,
1009	};	1009	};
1010	test "enum with tag values don't require parens" {	1010	test "enum with tag values don't require parens" {
1011	expect(@enumToInt(EnumWithTagValues.C) == 0b0100);	1011	try expect(@enumToInt(EnumWithTagValues.C) == 0b0100);
1012	}	1012	}
1013		1013
1014	test "enum with 1 field but explicit tag type should still have the tag type" {	1014	test "enum with 1 field but explicit tag type should still have the tag type" {
1015	const Enum = enum(u8) {	1015	const Enum = enum(u8) {
1016	B = 2,	1016	B = 2,
1017	};	1017	};
1018	comptime @import("std").testing.expect(@sizeOf(Enum) == @sizeOf(u8));	1018	comptime try expect(@sizeOf(Enum) == @sizeOf(u8));
1019	}	1019	}
1020		1020
1021	test "empty extern enum with members" {	1021	test "empty extern enum with members" {
...	@@ -1024,7 +1024,7 @@ test "empty extern enum with members" {	...	@@ -1024,7 +1024,7 @@ test "empty extern enum with members" {
1024	B,	1024	B,
1025	C,	1025	C,
1026	};	1026	};
1027	expect(@sizeOf(E) == @sizeOf(c_int));	1027	try expect(@sizeOf(E) == @sizeOf(c_int));
1028	}	1028	}
1029		1029
1030	test "tag name with assigned enum values" {	1030	test "tag name with assigned enum values" {
...	@@ -1033,7 +1033,7 @@ test "tag name with assigned enum values" {	...	@@ -1033,7 +1033,7 @@ test "tag name with assigned enum values" {
1033	B = 0,	1033	B = 0,
1034	};	1034	};
1035	var b = LocalFoo.B;	1035	var b = LocalFoo.B;
1036	expect(mem.eql(u8, @tagName(b), "B"));	1036	try expect(mem.eql(u8, @tagName(b), "B"));
1037	}	1037	}
1038		1038
1039	test "enum literal equality" {	1039	test "enum literal equality" {
...	@@ -1041,8 +1041,8 @@ test "enum literal equality" {	...	@@ -1041,8 +1041,8 @@ test "enum literal equality" {
1041	const y = .ok;	1041	const y = .ok;
1042	const z = .hi;	1042	const z = .hi;
1043		1043
1044	expect(x != y);	1044	try expect(x != y);
1045	expect(x == z);	1045	try expect(x == z);
1046	}	1046	}
1047		1047
1048	test "enum literal cast to enum" {	1048	test "enum literal cast to enum" {
...	@@ -1054,7 +1054,7 @@ test "enum literal cast to enum" {	...	@@ -1054,7 +1054,7 @@ test "enum literal cast to enum" {
1054		1054
1055	var color1: Color = .Auto;	1055	var color1: Color = .Auto;
1056	var color2 = Color.Auto;	1056	var color2 = Color.Auto;
1057	expect(color1 == color2);	1057	try expect(color1 == color2);
1058	}	1058	}
1059		1059
1060	test "peer type resolution with enum literal" {	1060	test "peer type resolution with enum literal" {
...	@@ -1063,8 +1063,8 @@ test "peer type resolution with enum literal" {	...	@@ -1063,8 +1063,8 @@ test "peer type resolution with enum literal" {
1063	two,	1063	two,
1064	};	1064	};
1065		1065
1066	expect(Items.two == .two);	1066	try expect(Items.two == .two);
1067	expect(.two == Items.two);	1067	try expect(.two == Items.two);
1068	}	1068	}
1069		1069
1070	test "enum literal in array literal" {	1070	test "enum literal in array literal" {
...	@@ -1078,8 +1078,8 @@ test "enum literal in array literal" {	...	@@ -1078,8 +1078,8 @@ test "enum literal in array literal" {
1078	.two,	1078	.two,
1079	};	1079	};
1080		1080
1081	expect(array[0] == .one);	1081	try expect(array[0] == .one);
1082	expect(array[1] == .two);	1082	try expect(array[1] == .two);
1083	}	1083	}
1084		1084
1085	test "signed integer as enum tag" {	1085	test "signed integer as enum tag" {
...	@@ -1089,9 +1089,9 @@ test "signed integer as enum tag" {	...	@@ -1089,9 +1089,9 @@ test "signed integer as enum tag" {
1089	A2 = 1,	1089	A2 = 1,
1090	};	1090	};
1091		1091
1092	expect(@enumToInt(SignedEnum.A0) == -1);	1092	try expect(@enumToInt(SignedEnum.A0) == -1);
1093	expect(@enumToInt(SignedEnum.A1) == 0);	1093	try expect(@enumToInt(SignedEnum.A1) == 0);
1094	expect(@enumToInt(SignedEnum.A2) == 1);	1094	try expect(@enumToInt(SignedEnum.A2) == 1);
1095	}	1095	}
1096		1096
1097	test "enum value allocation" {	1097	test "enum value allocation" {
...	@@ -1101,9 +1101,9 @@ test "enum value allocation" {	...	@@ -1101,9 +1101,9 @@ test "enum value allocation" {
1101	A2,	1101	A2,
1102	};	1102	};
1103		1103
1104	expect(@enumToInt(LargeEnum.A0) == 0x80000000);	1104	try expect(@enumToInt(LargeEnum.A0) == 0x80000000);
1105	expect(@enumToInt(LargeEnum.A1) == 0x80000001);	1105	try expect(@enumToInt(LargeEnum.A1) == 0x80000001);
1106	expect(@enumToInt(LargeEnum.A2) == 0x80000002);	1106	try expect(@enumToInt(LargeEnum.A2) == 0x80000002);
1107	}	1107	}
1108		1108
1109	test "enum literal casting to tagged union" {	1109	test "enum literal casting to tagged union" {
...	@@ -1130,32 +1130,32 @@ test "enum with one member and custom tag type" {	...	@@ -1130,32 +1130,32 @@ test "enum with one member and custom tag type" {
1130	const E = enum(u2) {	1130	const E = enum(u2) {
1131	One,	1131	One,
1132	};	1132	};
1133	expect(@enumToInt(E.One) == 0);	1133	try expect(@enumToInt(E.One) == 0);
1134	const E2 = enum(u2) {	1134	const E2 = enum(u2) {
1135	One = 2,	1135	One = 2,
1136	};	1136	};
1137	expect(@enumToInt(E2.One) == 2);	1137	try expect(@enumToInt(E2.One) == 2);
1138	}	1138	}
1139		1139
1140	test "enum literal casting to optional" {	1140	test "enum literal casting to optional" {
1141	var bar: ?Bar = undefined;	1141	var bar: ?Bar = undefined;
1142	bar = .B;	1142	bar = .B;
1143		1143
1144	expect(bar.? == Bar.B);	1144	try expect(bar.? == Bar.B);
1145	}	1145	}
1146		1146
1147	test "enum literal casting to error union with payload enum" {	1147	test "enum literal casting to error union with payload enum" {
1148	var bar: error{B}!Bar = undefined;	1148	var bar: error{B}!Bar = undefined;
1149	bar = .B; // should never cast to the error set	1149	bar = .B; // should never cast to the error set
1150		1150
1151	expect((try bar) == Bar.B);	1151	try expect((try bar) == Bar.B);
1152	}	1152	}
1153		1153
1154	test "enum with one member and u1 tag type @enumToInt" {	1154	test "enum with one member and u1 tag type @enumToInt" {
1155	const Enum = enum(u1) {	1155	const Enum = enum(u1) {
1156	Test,	1156	Test,
1157	};	1157	};
1158	expect(@enumToInt(Enum.Test) == 0);	1158	try expect(@enumToInt(Enum.Test) == 0);
1159	}	1159	}
1160		1160
1161	test "enum with comptime_int tag type" {	1161	test "enum with comptime_int tag type" {
...	@@ -1164,19 +1164,19 @@ test "enum with comptime_int tag type" {	...	@@ -1164,19 +1164,19 @@ test "enum with comptime_int tag type" {
1164	Two = 2,	1164	Two = 2,
1165	Three = 1,	1165	Three = 1,
1166	};	1166	};
1167	comptime expect(Tag(Enum) == comptime_int);	1167	comptime try expect(Tag(Enum) == comptime_int);
1168	}	1168	}
1169		1169
1170	test "enum with one member default to u0 tag type" {	1170	test "enum with one member default to u0 tag type" {
1171	const E0 = enum {	1171	const E0 = enum {
1172	X,	1172	X,
1173	};	1173	};
1174	comptime expect(Tag(E0) == u0);	1174	comptime try expect(Tag(E0) == u0);
1175	}	1175	}
1176		1176
1177	test "tagName on enum literals" {	1177	test "tagName on enum literals" {
1178	expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));	1178	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1179	comptime expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));	1179	comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1180	}	1180	}
1181		1181
1182	test "method call on an enum" {	1182	test "method call on an enum" {
...	@@ -1193,12 +1193,12 @@ test "method call on an enum" {	...	@@ -1193,12 +1193,12 @@ test "method call on an enum" {
1193	return self.* == .two and foo == bool;	1193	return self.* == .two and foo == bool;
1194	}	1194	}
1195	};	1195	};
1196	fn doTheTest() void {	1196	fn doTheTest() !void {
1197	var e = E.two;	1197	var e = E.two;
1198	expect(e.method());	1198	try expect(e.method());
1199	expect(e.generic_method(bool));	1199	try expect(e.generic_method(bool));
1200	}	1200	}
1201	};	1201	};
1202	S.doTheTest();	1202	try S.doTheTest();
1203	comptime S.doTheTest();	1203	comptime try S.doTheTest();
1204	}	1204	}

test/stage1/behavior/enum_with_members.zig+4-4

...	@@ -19,9 +19,9 @@ test "enum with members" {	...	@@ -19,9 +19,9 @@ test "enum with members" {
19	const b = ET{ .UINT = 42 };	19	const b = ET{ .UINT = 42 };
20	var buf: [20]u8 = undefined;	20	var buf: [20]u8 = undefined;
21		21
22	expect((a.print(buf[0..]) catch unreachable) == 3);	22	try expect((a.print(buf[0..]) catch unreachable) == 3);
23	expect(mem.eql(u8, buf[0..3], "-42"));	23	try expect(mem.eql(u8, buf[0..3], "-42"));
24		24
25	expect((b.print(buf[0..]) catch unreachable) == 2);	25	try expect((b.print(buf[0..]) catch unreachable) == 2);
26	expect(mem.eql(u8, buf[0..2], "42"));	26	try expect(mem.eql(u8, buf[0..2], "42"));
27	}	27	}

test/stage1/behavior/error.zig+60-60

 @@ -19,7 +19,7 @@ pub fn baz() anyerror!i32 {
 }
 test "error wrapping" {
-    expect((baz() catch unreachable) == 15);
+    try expect((baz() catch unreachable) == 15);
 }
 fn gimmeItBroke() []const u8 {
 @@ -27,14 +27,14 @@ fn gimmeItBroke() []const u8 {
 }
 test "@errorName" {
-    expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
+    try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
-    expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName"));
+    try expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName"));
 }
 test "error values" {
     const a = @errorToInt(error.err1);
     const b = @errorToInt(error.err2);
-    expect(a != b);
+    try expect(a != b);
 }
 test "redefinition of error values allowed" {
 @@ -47,8 +47,8 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
 test "error binary operator" {
     const a = errBinaryOperatorG(true) catch 3;
     const b = errBinaryOperatorG(false) catch 3;
-    expect(a == 3);
+    try expect(a == 3);
-    expect(b == 10);
+    try expect(b == 10);
 }
 fn errBinaryOperatorG(x: bool) anyerror!isize {
     return if (x) error.ItBroke else @as(isize, 10);
 @@ -56,7 +56,7 @@ fn errBinaryOperatorG(x: bool) anyerror!isize {
 test "unwrap simple value from error" {
     const i = unwrapSimpleValueFromErrorDo() catch unreachable;
-    expect(i == 13);
+    try expect(i == 13);
 }
 fn unwrapSimpleValueFromErrorDo() anyerror!isize {
     return 13;
 @@ -76,21 +76,21 @@ fn makeANonErr() anyerror!i32 {
 }
 test "error union type " {
-    testErrorUnionType();
+    try testErrorUnionType();
-    comptime testErrorUnionType();
+    comptime try testErrorUnionType();
 }
-fn testErrorUnionType() void {
+fn testErrorUnionType() !void {
     const x: anyerror!i32 = 1234;
-    if (x) |value| expect(value == 1234) else |_| unreachable;
+    if (x) |value| try expect(value == 1234) else |_| unreachable;
-    expect(@typeInfo(@TypeOf(x)) == .ErrorUnion);
+    try expect(@typeInfo(@TypeOf(x)) == .ErrorUnion);
-    expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet);
+    try expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet);
-    expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror);
+    try expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror);
 }
 test "error set type" {
-    testErrorSetType();
+    try testErrorSetType();
-    comptime testErrorSetType();
+    comptime try testErrorSetType();
 }
 const MyErrSet = error{
 @@ -98,21 +98,21 @@ const MyErrSet = error{
     FileNotFound,
 };
-fn testErrorSetType() void {
+fn testErrorSetType() !void {
-    expect(@typeInfo(MyErrSet).ErrorSet.?.len == 2);
+    try expect(@typeInfo(MyErrSet).ErrorSet.?.len == 2);
     const a: MyErrSet!i32 = 5678;
     const b: MyErrSet!i32 = MyErrSet.OutOfMemory;
-    if (a) |value| expect(value == 5678) else |err| switch (err) {
+    if (a) |value| try expect(value == 5678) else |err| switch (err) {
         error.OutOfMemory => unreachable,
         error.FileNotFound => unreachable,
     }
 }
 test "explicit error set cast" {
-    testExplicitErrorSetCast(Set1.A);
+    try testExplicitErrorSetCast(Set1.A);
-    comptime testExplicitErrorSetCast(Set1.A);
+    comptime try testExplicitErrorSetCast(Set1.A);
 }
 const Set1 = error{
 @@ -124,26 +124,26 @@ const Set2 = error{
     C,
 };
-fn testExplicitErrorSetCast(set1: Set1) void {
+fn testExplicitErrorSetCast(set1: Set1) !void {
     var x = @errSetCast(Set2, set1);
     var y = @errSetCast(Set1, x);
-    expect(y == error.A);
+    try expect(y == error.A);
 }
 test "comptime test error for empty error set" {
-    testComptimeTestErrorEmptySet(1234);
+    try testComptimeTestErrorEmptySet(1234);
-    comptime testComptimeTestErrorEmptySet(1234);
+    comptime try testComptimeTestErrorEmptySet(1234);
 }
 const EmptyErrorSet = error{};
-fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) void {
+fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void {
-    if (x) |v| expect(v == 1234) else |err| @compileError("bad");
+    if (x) |v| try expect(v == 1234) else |err| @compileError("bad");
 }
 test "syntax: optional operator in front of error union operator" {
     comptime {
-        expect(?(anyerror!i32) == ?(anyerror!i32));
+        try expect(?(anyerror!i32) == ?(anyerror!i32));
     }
 }
 @@ -165,10 +165,10 @@ test "empty error union" {
 }
 test "error union peer type resolution" {
-    testErrorUnionPeerTypeResolution(1);
+    try testErrorUnionPeerTypeResolution(1);
 }
-fn testErrorUnionPeerTypeResolution(x: i32) void {
+fn testErrorUnionPeerTypeResolution(x: i32) !void {
     const y = switch (x) {
         1 => bar_1(),
         2 => baz_1(),
 @@ -177,7 +177,7 @@ fn testErrorUnionPeerTypeResolution(x: i32) void {
     if (y) |_| {
         @panic("expected error");
     } else |e| {
-        expect(e == error.A);
+        try expect(e == error.A);
     }
 }
 @@ -286,13 +286,13 @@ test "nested error union function call in optional unwrap" {
             return null;
         }
     };
-    expect((try S.errorable()) == 1234);
+    try expect((try S.errorable()) == 1234);
-    expectError(error.Failure, S.errorable2());
+    try expectError(error.Failure, S.errorable2());
-    expectError(error.Other, S.errorable3());
+    try expectError(error.Other, S.errorable3());
     comptime {
-        expect((try S.errorable()) == 1234);
+        try expect((try S.errorable()) == 1234);
-        expectError(error.Failure, S.errorable2());
+        try expectError(error.Failure, S.errorable2());
-        expectError(error.Other, S.errorable3());
+        try expectError(error.Other, S.errorable3());
     }
 }
 @@ -307,7 +307,7 @@ test "widen cast integer payload of error union function call" {
             return 1234;
         }
     };
-    expect((try S.errorable()) == 1234);
+    try expect((try S.errorable()) == 1234);
 }
 test "return function call to error set from error union function" {
 @@ -320,19 +320,19 @@ test "return function call to error set from error union function" {
             return error.Failure;
         }
     };
-    expectError(error.Failure, S.errorable());
+    try expectError(error.Failure, S.errorable());
-    comptime expectError(error.Failure, S.errorable());
+    comptime try expectError(error.Failure, S.errorable());
 }
 test "optional error set is the same size as error set" {
-    comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
+    comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
     const S = struct {
         fn returnsOptErrSet() ?anyerror {
             return null;
         }
     };
-    expect(S.returnsOptErrSet() == null);
+    try expect(S.returnsOptErrSet() == null);
-    comptime expect(S.returnsOptErrSet() == null);
+    comptime try expect(S.returnsOptErrSet() == null);
 }
 test "debug info for optional error set" {
 @@ -342,8 +342,8 @@ test "debug info for optional error set" {
 test "nested catch" {
     const S = struct {
-        fn entry() void {
+        fn entry() !void {
-            expectError(error.Bad, func());
+            try expectError(error.Bad, func());
         }
         fn fail() anyerror!Foo {
             return error.Wrong;
 @@ -358,16 +358,16 @@ test "nested catch" {
             field: i32,
         };
     };
-    S.entry();
+    try S.entry();
-    comptime S.entry();
+    comptime try S.entry();
 }
 test "implicit cast to optional to error union to return result loc" {
     const S = struct {
-        fn entry() void {
+        fn entry() !void {
             var x: Foo = undefined;
             if (func(&x)) |opt| {
-                expect(opt != null);
+                try expect(opt != null);
             } else |_| @panic("expected non error");
         }
         fn func(f: *Foo) anyerror!?*Foo {
 @@ -377,7 +377,7 @@ test "implicit cast to optional to error union to return result loc" {
             field: i32,
         };
     };
-    S.entry();
+    try S.entry();
     //comptime S.entry(); TODO
 }
 @@ -393,23 +393,23 @@ test "function pointer with return type that is error union with payload which i
             return Err.UnspecifiedErr;
         }
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var x = Foo{ .fun = bar };
-            expectError(error.UnspecifiedErr, x.fun(1));
+            try expectError(error.UnspecifiedErr, x.fun(1));
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 test "return result loc as peer result loc in inferred error set function" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             if (foo(2)) |x| {
-                expect(x.Two);
+                try expect(x.Two);
             } else |e| switch (e) {
                 error.Whatever => @panic("fail"),
             }
-            expectError(error.Whatever, foo(99));
+            try expectError(error.Whatever, foo(99));
         }
         const FormValue = union(enum) {
             One: void,
 @@ -424,8 +424,8 @@ test "return result loc as peer result loc in inferred error set function" {
             };
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "error payload type is correctly resolved" {
 @@ -439,7 +439,7 @@ test "error payload type is correctly resolved" {
         }
     };
-    expectEqual(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create());
+    try expectEqual(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create());
 }
 test "error union comptime caching" {
 @@ -449,4 +449,4 @@ test "error union comptime caching" {
     S.foo(@as(anyerror!void, {}));
     S.foo(@as(anyerror!void, {}));
-}
+}

test/stage1/behavior/eval.zig+119-119

...	@@ -4,7 +4,7 @@ const expectEqual = std.testing.expectEqual;	...	@@ -4,7 +4,7 @@ const expectEqual = std.testing.expectEqual;
4	const builtin = @import("builtin");	4	const builtin = @import("builtin");
5		5
6	test "compile time recursion" {	6	test "compile time recursion" {
7	expect(some_data.len == 21);	7	try expect(some_data.len == 21);
8	}	8	}
9	var some_data: [@intCast(usize, fibonacci(7))]u8 = undefined;	9	var some_data: [@intCast(usize, fibonacci(7))]u8 = undefined;
10	fn fibonacci(x: i32) i32 {	10	fn fibonacci(x: i32) i32 {
...	@@ -17,7 +17,7 @@ fn unwrapAndAddOne(blah: ?i32) i32 {	...	@@ -17,7 +17,7 @@ fn unwrapAndAddOne(blah: ?i32) i32 {
17	}	17	}
18	const should_be_1235 = unwrapAndAddOne(1234);	18	const should_be_1235 = unwrapAndAddOne(1234);
19	test "static add one" {	19	test "static add one" {
20	expect(should_be_1235 == 1235);	20	try expect(should_be_1235 == 1235);
21	}	21	}
22		22
23	test "inlined loop" {	23	test "inlined loop" {
...	@@ -25,7 +25,7 @@ test "inlined loop" {	...	@@ -25,7 +25,7 @@ test "inlined loop" {
25	comptime var sum = 0;	25	comptime var sum = 0;
26	inline while (i <= 5) : (i += 1)	26	inline while (i <= 5) : (i += 1)
27	sum += i;	27	sum += i;
28	expect(sum == 15);	28	try expect(sum == 15);
29	}	29	}
30		30
31	fn gimme1or2(comptime a: bool) i32 {	31	fn gimme1or2(comptime a: bool) i32 {
...	@@ -35,12 +35,12 @@ fn gimme1or2(comptime a: bool) i32 {	...	@@ -35,12 +35,12 @@ fn gimme1or2(comptime a: bool) i32 {
35	return z;	35	return z;
36	}	36	}
37	test "inline variable gets result of const if" {	37	test "inline variable gets result of const if" {
38	expect(gimme1or2(true) == 1);	38	try expect(gimme1or2(true) == 1);
39	expect(gimme1or2(false) == 2);	39	try expect(gimme1or2(false) == 2);
40	}	40	}
41		41
42	test "static function evaluation" {	42	test "static function evaluation" {
43	expect(statically_added_number == 3);	43	try expect(statically_added_number == 3);
44	}	44	}
45	const statically_added_number = staticAdd(1, 2);	45	const statically_added_number = staticAdd(1, 2);
46	fn staticAdd(a: i32, b: i32) i32 {	46	fn staticAdd(a: i32, b: i32) i32 {
...	@@ -48,8 +48,8 @@ fn staticAdd(a: i32, b: i32) i32 {	...	@@ -48,8 +48,8 @@ fn staticAdd(a: i32, b: i32) i32 {
48	}	48	}
49		49
50	test "const expr eval on single expr blocks" {	50	test "const expr eval on single expr blocks" {
51	expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3);	51	try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3);
52	comptime expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3);	52	comptime try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3);
53	}	53	}
54		54
55	fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {	55	fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
...	@@ -65,10 +65,10 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {	...	@@ -65,10 +65,10 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
65	}	65	}
66		66
67	test "statically initialized list" {	67	test "statically initialized list" {
68	expect(static_point_list[0].x == 1);	68	try expect(static_point_list[0].x == 1);
69	expect(static_point_list[0].y == 2);	69	try expect(static_point_list[0].y == 2);
70	expect(static_point_list[1].x == 3);	70	try expect(static_point_list[1].x == 3);
71	expect(static_point_list[1].y == 4);	71	try expect(static_point_list[1].y == 4);
72	}	72	}
73	const Point = struct {	73	const Point = struct {
74	x: i32,	74	x: i32,
...	@@ -86,8 +86,8 @@ fn makePoint(x: i32, y: i32) Point {	...	@@ -86,8 +86,8 @@ fn makePoint(x: i32, y: i32) Point {
86	}	86	}
87		87
88	test "static eval list init" {	88	test "static eval list init" {
89	expect(static_vec3.data[2] == 1.0);	89	try expect(static_vec3.data[2] == 1.0);
90	expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);	90	try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
91	}	91	}
92	const static_vec3 = vec3(0.0, 0.0, 1.0);	92	const static_vec3 = vec3(0.0, 0.0, 1.0);
93	pub const Vec3 = struct {	93	pub const Vec3 = struct {
...	@@ -105,12 +105,12 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {	...	@@ -105,12 +105,12 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
105		105
106	test "constant expressions" {	106	test "constant expressions" {
107	var array: [array_size]u8 = undefined;	107	var array: [array_size]u8 = undefined;
108	expect(@sizeOf(@TypeOf(array)) == 20);	108	try expect(@sizeOf(@TypeOf(array)) == 20);
109	}	109	}
110	const array_size: u8 = 20;	110	const array_size: u8 = 20;
111		111
112	test "constant struct with negation" {	112	test "constant struct with negation" {
113	expect(vertices[0].x == -0.6);	113	try expect(vertices[0].x == -0.6);
114	}	114	}
115	const Vertex = struct {	115	const Vertex = struct {
116	x: f32,	116	x: f32,
...	@@ -145,7 +145,7 @@ const vertices = [_]Vertex{	...	@@ -145,7 +145,7 @@ const vertices = [_]Vertex{
145		145
146	test "statically initialized struct" {	146	test "statically initialized struct" {
147	st_init_str_foo.x += 1;	147	st_init_str_foo.x += 1;
148	expect(st_init_str_foo.x == 14);	148	try expect(st_init_str_foo.x == 14);
149	}	149	}
150	const StInitStrFoo = struct {	150	const StInitStrFoo = struct {
151	x: i32,	151	x: i32,
...	@@ -158,7 +158,7 @@ var st_init_str_foo = StInitStrFoo{	...	@@ -158,7 +158,7 @@ var st_init_str_foo = StInitStrFoo{
158		158
159	test "statically initalized array literal" {	159	test "statically initalized array literal" {
160	const y: [4]u8 = st_init_arr_lit_x;	160	const y: [4]u8 = st_init_arr_lit_x;
161	expect(y[3] == 4);	161	try expect(y[3] == 4);
162	}	162	}
163	const st_init_arr_lit_x = [_]u8{	163	const st_init_arr_lit_x = [_]u8{
164	1,	164	1,
...	@@ -170,15 +170,15 @@ const st_init_arr_lit_x = [_]u8{	...	@@ -170,15 +170,15 @@ const st_init_arr_lit_x = [_]u8{
170	test "const slice" {	170	test "const slice" {
171	comptime {	171	comptime {
172	const a = "1234567890";	172	const a = "1234567890";
173	expect(a.len == 10);	173	try expect(a.len == 10);
174	const b = a[1..2];	174	const b = a[1..2];
175	expect(b.len == 1);	175	try expect(b.len == 1);
176	expect(b[0] == '2');	176	try expect(b[0] == '2');
177	}	177	}
178	}	178	}
179		179
180	test "try to trick eval with runtime if" {	180	test "try to trick eval with runtime if" {
181	expect(testTryToTrickEvalWithRuntimeIf(true) == 10);	181	try expect(testTryToTrickEvalWithRuntimeIf(true) == 10);
182	}	182	}
183		183
184	fn testTryToTrickEvalWithRuntimeIf(b: bool) usize {	184	fn testTryToTrickEvalWithRuntimeIf(b: bool) usize {
...	@@ -198,7 +198,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio	...	@@ -198,7 +198,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
198	const result = if (i == 0) [1]i32{2} else runtime;	198	const result = if (i == 0) [1]i32{2} else runtime;
199	}	199	}
200	comptime {	200	comptime {
201	expect(i == 2);	201	try expect(i == 2);
202	}	202	}
203	}	203	}
204		204
...	@@ -215,16 +215,16 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {	...	@@ -215,16 +215,16 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
215	return max(bool, a, b);	215	return max(bool, a, b);
216	}	216	}
217	test "inlined block and runtime block phi" {	217	test "inlined block and runtime block phi" {
218	expect(letsTryToCompareBools(true, true));	218	try expect(letsTryToCompareBools(true, true));
219	expect(letsTryToCompareBools(true, false));	219	try expect(letsTryToCompareBools(true, false));
220	expect(letsTryToCompareBools(false, true));	220	try expect(letsTryToCompareBools(false, true));
221	expect(!letsTryToCompareBools(false, false));	221	try expect(!letsTryToCompareBools(false, false));
222		222
223	comptime {	223	comptime {
224	expect(letsTryToCompareBools(true, true));	224	try expect(letsTryToCompareBools(true, true));
225	expect(letsTryToCompareBools(true, false));	225	try expect(letsTryToCompareBools(true, false));
226	expect(letsTryToCompareBools(false, true));	226	try expect(letsTryToCompareBools(false, true));
227	expect(!letsTryToCompareBools(false, false));	227	try expect(!letsTryToCompareBools(false, false));
228	}	228	}
229	}	229	}
230		230
...	@@ -269,14 +269,14 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {	...	@@ -269,14 +269,14 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
269	}	269	}
270		270
271	test "comptime iterate over fn ptr list" {	271	test "comptime iterate over fn ptr list" {
272	expect(performFn('t', 1) == 6);	272	try expect(performFn('t', 1) == 6);
273	expect(performFn('o', 0) == 1);	273	try expect(performFn('o', 0) == 1);
274	expect(performFn('w', 99) == 99);	274	try expect(performFn('w', 99) == 99);
275	}	275	}
276		276
277	test "eval @setRuntimeSafety at compile-time" {	277	test "eval @setRuntimeSafety at compile-time" {
278	const result = comptime fnWithSetRuntimeSafety();	278	const result = comptime fnWithSetRuntimeSafety();
279	expect(result == 1234);	279	try expect(result == 1234);
280	}	280	}
281		281
282	fn fnWithSetRuntimeSafety() i32 {	282	fn fnWithSetRuntimeSafety() i32 {
...	@@ -286,7 +286,7 @@ fn fnWithSetRuntimeSafety() i32 {	...	@@ -286,7 +286,7 @@ fn fnWithSetRuntimeSafety() i32 {
286		286
287	test "eval @setFloatMode at compile-time" {	287	test "eval @setFloatMode at compile-time" {
288	const result = comptime fnWithFloatMode();	288	const result = comptime fnWithFloatMode();
289	expect(result == 1234.0);	289	try expect(result == 1234.0);
290	}	290	}
291		291
292	fn fnWithFloatMode() f32 {	292	fn fnWithFloatMode() f32 {
...	@@ -307,15 +307,15 @@ var simple_struct = SimpleStruct{ .field = 1234 };	...	@@ -307,15 +307,15 @@ var simple_struct = SimpleStruct{ .field = 1234 };
307	const bound_fn = simple_struct.method;	307	const bound_fn = simple_struct.method;
308		308
309	test "call method on bound fn referring to var instance" {	309	test "call method on bound fn referring to var instance" {
310	expect(bound_fn() == 1237);	310	try expect(bound_fn() == 1237);
311	}	311	}
312		312
313	test "ptr to local array argument at comptime" {	313	test "ptr to local array argument at comptime" {
314	comptime {	314	comptime {
315	var bytes: [10]u8 = undefined;	315	var bytes: [10]u8 = undefined;
316	modifySomeBytes(bytes[0..]);	316	modifySomeBytes(bytes[0..]);
317	expect(bytes[0] == 'a');	317	try expect(bytes[0] == 'a');
318	expect(bytes[9] == 'b');	318	try expect(bytes[9] == 'b');
319	}	319	}
320	}	320	}
321		321
...	@@ -343,9 +343,9 @@ fn testCompTimeUIntComparisons(x: u32) void {	...	@@ -343,9 +343,9 @@ fn testCompTimeUIntComparisons(x: u32) void {
343	}	343	}
344		344
345	test "const ptr to variable data changes at runtime" {	345	test "const ptr to variable data changes at runtime" {
346	expect(foo_ref.name[0] == 'a');	346	try expect(foo_ref.name[0] == 'a');
347	foo_ref.name = "b";	347	foo_ref.name = "b";
348	expect(foo_ref.name[0] == 'b');	348	try expect(foo_ref.name[0] == 'b');
349	}	349	}
350		350
351	const Foo = struct {	351	const Foo = struct {
...	@@ -356,8 +356,8 @@ var foo_contents = Foo{ .name = "a" };	...	@@ -356,8 +356,8 @@ var foo_contents = Foo{ .name = "a" };
356	const foo_ref = &foo_contents;	356	const foo_ref = &foo_contents;
357		357
358	test "create global array with for loop" {	358	test "create global array with for loop" {
359	expect(global_array[5] == 5 * 5);	359	try expect(global_array[5] == 5 * 5);
360	expect(global_array[9] == 9 * 9);	360	try expect(global_array[9] == 9 * 9);
361	}	361	}
362		362
363	const global_array = x: {	363	const global_array = x: {
...	@@ -372,18 +372,18 @@ test "compile-time downcast when the bits fit" {	...	@@ -372,18 +372,18 @@ test "compile-time downcast when the bits fit" {
372	comptime {	372	comptime {
373	const spartan_count: u16 = 255;	373	const spartan_count: u16 = 255;
374	const byte = @intCast(u8, spartan_count);	374	const byte = @intCast(u8, spartan_count);
375	expect(byte == 255);	375	try expect(byte == 255);
376	}	376	}
377	}	377	}
378		378
379	const hi1 = "hi";	379	const hi1 = "hi";
380	const hi2 = hi1;	380	const hi2 = hi1;
381	test "const global shares pointer with other same one" {	381	test "const global shares pointer with other same one" {
382	assertEqualPtrs(&hi1[0], &hi2[0]);	382	try assertEqualPtrs(&hi1[0], &hi2[0]);
383	comptime expect(&hi1[0] == &hi2[0]);	383	comptime try expect(&hi1[0] == &hi2[0]);
384	}	384	}
385	fn assertEqualPtrs(ptr1: const u8, ptr2: const u8) void {	385	fn assertEqualPtrs(ptr1: const u8, ptr2: const u8) !void {
386	expect(ptr1 == ptr2);	386	try expect(ptr1 == ptr2);
387	}	387	}
388		388
389	test "@setEvalBranchQuota" {	389	test "@setEvalBranchQuota" {
...	@@ -395,29 +395,29 @@ test "@setEvalBranchQuota" {	...	@@ -395,29 +395,29 @@ test "@setEvalBranchQuota" {
395	while (i < 1001) : (i += 1) {	395	while (i < 1001) : (i += 1) {
396	sum += i;	396	sum += i;
397	}	397	}
398	expect(sum == 500500);	398	try expect(sum == 500500);
399	}	399	}
400	}	400	}
401		401
402	test "float literal at compile time not lossy" {	402	test "float literal at compile time not lossy" {
403	expect(16777216.0 + 1.0 == 16777217.0);	403	try expect(16777216.0 + 1.0 == 16777217.0);
404	expect(9007199254740992.0 + 1.0 == 9007199254740993.0);	404	try expect(9007199254740992.0 + 1.0 == 9007199254740993.0);
405	}	405	}
406		406
407	test "f32 at compile time is lossy" {	407	test "f32 at compile time is lossy" {
408	expect(@as(f32, 1 << 24) + 1 == 1 << 24);	408	try expect(@as(f32, 1 << 24) + 1 == 1 << 24);
409	}	409	}
410		410
411	test "f64 at compile time is lossy" {	411	test "f64 at compile time is lossy" {
412	expect(@as(f64, 1 << 53) + 1 == 1 << 53);	412	try expect(@as(f64, 1 << 53) + 1 == 1 << 53);
413	}	413	}
414		414
415	test "f128 at compile time is lossy" {	415	test "f128 at compile time is lossy" {
416	expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);	416	try expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);
417	}	417	}
418		418
419	comptime {	419	comptime {
420	expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192);	420	try expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192);
421	}	421	}
422		422
423	pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {	423	pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
...	@@ -429,15 +429,15 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {	...	@@ -429,15 +429,15 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
429	test "string literal used as comptime slice is memoized" {	429	test "string literal used as comptime slice is memoized" {
430	const a = "link";	430	const a = "link";
431	const b = "link";	431	const b = "link";
432	comptime expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node);	432	comptime try expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node);
433	comptime expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node);	433	comptime try expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node);
434	}	434	}
435		435
436	test "comptime slice of undefined pointer of length 0" {	436	test "comptime slice of undefined pointer of length 0" {
437	const slice1 = @as([*]i32, undefined)[0..0];	437	const slice1 = @as([*]i32, undefined)[0..0];
438	expect(slice1.len == 0);	438	try expect(slice1.len == 0);
439	const slice2 = @as([*]i32, undefined)[100..100];	439	const slice2 = @as([*]i32, undefined)[100..100];
440	expect(slice2.len == 0);	440	try expect(slice2.len == 0);
441	}	441	}
442		442
443	fn copyWithPartialInline(s: []u32, b: []u8) void {	443	fn copyWithPartialInline(s: []u32, b: []u8) void {
...	@@ -459,16 +459,16 @@ test "binary math operator in partially inlined function" {	...	@@ -459,16 +459,16 @@ test "binary math operator in partially inlined function" {
459	r.* = @intCast(u8, i + 1);	459	r.* = @intCast(u8, i + 1);
460		460
461	copyWithPartialInline(s[0..], b[0..]);	461	copyWithPartialInline(s[0..], b[0..]);
462	expect(s[0] == 0x1020304);	462	try expect(s[0] == 0x1020304);
463	expect(s[1] == 0x5060708);	463	try expect(s[1] == 0x5060708);
464	expect(s[2] == 0x90a0b0c);	464	try expect(s[2] == 0x90a0b0c);
465	expect(s[3] == 0xd0e0f10);	465	try expect(s[3] == 0xd0e0f10);
466	}	466	}
467		467
468	test "comptime function with the same args is memoized" {	468	test "comptime function with the same args is memoized" {
469	comptime {	469	comptime {
470	expect(MakeType(i32) == MakeType(i32));	470	try expect(MakeType(i32) == MakeType(i32));
471	expect(MakeType(i32) != MakeType(f64));	471	try expect(MakeType(i32) != MakeType(f64));
472	}	472	}
473	}	473	}
474		474
...	@@ -484,7 +484,7 @@ test "comptime function with mutable pointer is not memoized" {	...	@@ -484,7 +484,7 @@ test "comptime function with mutable pointer is not memoized" {
484	const ptr = &x;	484	const ptr = &x;
485	increment(ptr);	485	increment(ptr);
486	increment(ptr);	486	increment(ptr);
487	expect(x == 3);	487	try expect(x == 3);
488	}	488	}
489	}	489	}
490		490
...	@@ -510,14 +510,14 @@ fn doesAlotT(comptime T: type, value: usize) T {	...	@@ -510,14 +510,14 @@ fn doesAlotT(comptime T: type, value: usize) T {
510	}	510	}
511		511
512	test "@setEvalBranchQuota at same scope as generic function call" {	512	test "@setEvalBranchQuota at same scope as generic function call" {
513	expect(doesAlotT(u32, 2) == 2);	513	try expect(doesAlotT(u32, 2) == 2);
514	}	514	}
515		515
516	test "comptime slice of slice preserves comptime var" {	516	test "comptime slice of slice preserves comptime var" {
517	comptime {	517	comptime {
518	var buff: [10]u8 = undefined;	518	var buff: [10]u8 = undefined;
519	buff[0..][0..][0] = 1;	519	buff[0..][0..][0] = 1;
520	expect(buff[0..][0..][0] == 1);	520	try expect(buff[0..][0..][0] == 1);
521	}	521	}
522	}	522	}
523		523
...	@@ -526,7 +526,7 @@ test "comptime slice of pointer preserves comptime var" {	...	@@ -526,7 +526,7 @@ test "comptime slice of pointer preserves comptime var" {
526	var buff: [10]u8 = undefined;	526	var buff: [10]u8 = undefined;
527	var a = @ptrCast([*]u8, &buff);	527	var a = @ptrCast([*]u8, &buff);
528	a[0..1][0] = 1;	528	a[0..1][0] = 1;
529	expect(buff[0..][0..][0] == 1);	529	try expect(buff[0..][0..][0] == 1);
530	}	530	}
531	}	531	}
532		532
...	@@ -540,9 +540,9 @@ const SingleFieldStruct = struct {	...	@@ -540,9 +540,9 @@ const SingleFieldStruct = struct {
540	test "const ptr to comptime mutable data is not memoized" {	540	test "const ptr to comptime mutable data is not memoized" {
541	comptime {	541	comptime {
542	var foo = SingleFieldStruct{ .x = 1 };	542	var foo = SingleFieldStruct{ .x = 1 };
543	expect(foo.read_x() == 1);	543	try expect(foo.read_x() == 1);
544	foo.x = 2;	544	foo.x = 2;
545	expect(foo.read_x() == 2);	545	try expect(foo.read_x() == 2);
546	}	546	}
547	}	547	}
548		548
...	@@ -551,7 +551,7 @@ test "array concat of slices gives slice" {	...	@@ -551,7 +551,7 @@ test "array concat of slices gives slice" {
551	var a: []const u8 = "aoeu";	551	var a: []const u8 = "aoeu";
552	var b: []const u8 = "asdf";	552	var b: []const u8 = "asdf";
553	const c = a ++ b;	553	const c = a ++ b;
554	expect(std.mem.eql(u8, c, "aoeuasdf"));	554	try expect(std.mem.eql(u8, c, "aoeuasdf"));
555	}	555	}
556	}	556	}
557		557
...	@@ -568,14 +568,14 @@ test "comptime shlWithOverflow" {	...	@@ -568,14 +568,14 @@ test "comptime shlWithOverflow" {
568	break :amt amt;	568	break :amt amt;
569	};	569	};
570		570
571	expect(ct_shifted == rt_shifted);	571	try expect(ct_shifted == rt_shifted);
572	}	572	}
573		573
574	test "runtime 128 bit integer division" {	574	test "runtime 128 bit integer division" {
575	var a: u128 = 152313999999999991610955792383;	575	var a: u128 = 152313999999999991610955792383;
576	var b: u128 = 10000000000000000000;	576	var b: u128 = 10000000000000000000;
577	var c = a / b;	577	var c = a / b;
578	expect(c == 15231399999);	578	try expect(c == 15231399999);
579	}	579	}
580		580
581	pub const Info = struct {	581	pub const Info = struct {
...	@@ -588,20 +588,20 @@ test "comptime modification of const struct field" {	...	@@ -588,20 +588,20 @@ test "comptime modification of const struct field" {
588	comptime {	588	comptime {
589	var res = diamond_info;	589	var res = diamond_info;
590	res.version = 1;	590	res.version = 1;
591	expect(diamond_info.version == 0);	591	try expect(diamond_info.version == 0);
592	expect(res.version == 1);	592	try expect(res.version == 1);
593	}	593	}
594	}	594	}
595		595
596	test "pointer to type" {	596	test "pointer to type" {
597	comptime {	597	comptime {
598	var T: type = i32;	598	var T: type = i32;
599	expect(T == i32);	599	try expect(T == i32);
600	var ptr = &T;	600	var ptr = &T;
601	expect(@TypeOf(ptr) == *type);	601	try expect(@TypeOf(ptr) == *type);
602	ptr.* = f32;	602	ptr.* = f32;
603	expect(T == f32);	603	try expect(T == f32);
604	expect(T == f32);	604	try expect(T == f32);
605	}	605	}
606	}	606	}
607		607
...	@@ -610,17 +610,17 @@ test "slice of type" {	...	@@ -610,17 +610,17 @@ test "slice of type" {
610	var types_array = [_]type{ i32, f64, type };	610	var types_array = [_]type{ i32, f64, type };
611	for (types_array) \|T, i\| {	611	for (types_array) \|T, i\| {
612	switch (i) {	612	switch (i) {
613	0 => expect(T == i32),	613	0 => try expect(T == i32),
614	1 => expect(T == f64),	614	1 => try expect(T == f64),
615	2 => expect(T == type),	615	2 => try expect(T == type),
616	else => unreachable,	616	else => unreachable,
617	}	617	}
618	}	618	}
619	for (types_array[0..]) \|T, i\| {	619	for (types_array[0..]) \|T, i\| {
620	switch (i) {	620	switch (i) {
621	0 => expect(T == i32),	621	0 => try expect(T == i32),
622	1 => expect(T == f64),	622	1 => try expect(T == f64),
623	2 => expect(T == type),	623	2 => try expect(T == type),
624	else => unreachable,	624	else => unreachable,
625	}	625	}
626	}	626	}
...	@@ -637,7 +637,7 @@ fn wrap(comptime T: type) Wrapper {	...	@@ -637,7 +637,7 @@ fn wrap(comptime T: type) Wrapper {
637		637
638	test "function which returns struct with type field causes implicit comptime" {	638	test "function which returns struct with type field causes implicit comptime" {
639	const ty = wrap(i32).T;	639	const ty = wrap(i32).T;
640	expect(ty == i32);	640	try expect(ty == i32);
641	}	641	}
642		642
643	test "call method with comptime pass-by-non-copying-value self parameter" {	643	test "call method with comptime pass-by-non-copying-value self parameter" {
...	@@ -651,12 +651,12 @@ test "call method with comptime pass-by-non-copying-value self parameter" {	...	@@ -651,12 +651,12 @@ test "call method with comptime pass-by-non-copying-value self parameter" {
651		651
652	const s = S{ .a = 2 };	652	const s = S{ .a = 2 };
653	var b = s.b();	653	var b = s.b();
654	expect(b == 2);	654	try expect(b == 2);
655	}	655	}
656		656
657	test "@tagName of @typeInfo" {	657	test "@tagName of @typeInfo" {
658	const str = @tagName(@typeInfo(u8));	658	const str = @tagName(@typeInfo(u8));
659	expect(std.mem.eql(u8, str, "Int"));	659	try expect(std.mem.eql(u8, str, "Int"));
660	}	660	}
661		661
662	test "setting backward branch quota just before a generic fn call" {	662	test "setting backward branch quota just before a generic fn call" {
...	@@ -670,15 +670,15 @@ fn loopNTimes(comptime n: usize) void {	...	@@ -670,15 +670,15 @@ fn loopNTimes(comptime n: usize) void {
670	}	670	}
671		671
672	test "variable inside inline loop that has different types on different iterations" {	672	test "variable inside inline loop that has different types on different iterations" {
673	testVarInsideInlineLoop(.{ true, @as(u32, 42) });	673	try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
674	}	674	}
675		675
676	fn testVarInsideInlineLoop(args: anytype) void {	676	fn testVarInsideInlineLoop(args: anytype) !void {
677	comptime var i = 0;	677	comptime var i = 0;
678	inline while (i < args.len) : (i += 1) {	678	inline while (i < args.len) : (i += 1) {
679	const x = args[i];	679	const x = args[i];
680	if (i == 0) expect(x);	680	if (i == 0) try expect(x);
681	if (i == 1) expect(x == 42);	681	if (i == 1) try expect(x == 42);
682	}	682	}
683	}	683	}
684		684
...	@@ -688,7 +688,7 @@ test "inline for with same type but different values" {	...	@@ -688,7 +688,7 @@ test "inline for with same type but different values" {
688	var a: T = undefined;	688	var a: T = undefined;
689	res += a.len;	689	res += a.len;
690	}	690	}
691	expect(res == 5);	691	try expect(res == 5);
692	}	692	}
693		693
694	test "refer to the type of a generic function" {	694	test "refer to the type of a generic function" {
...	@@ -702,13 +702,13 @@ fn doNothingWithType(comptime T: type) void {}	...	@@ -702,13 +702,13 @@ fn doNothingWithType(comptime T: type) void {}
702	test "zero extend from u0 to u1" {	702	test "zero extend from u0 to u1" {
703	var zero_u0: u0 = 0;	703	var zero_u0: u0 = 0;
704	var zero_u1: u1 = zero_u0;	704	var zero_u1: u1 = zero_u0;
705	expect(zero_u1 == 0);	705	try expect(zero_u1 == 0);
706	}	706	}
707		707
708	test "bit shift a u1" {	708	test "bit shift a u1" {
709	var x: u1 = 1;	709	var x: u1 = 1;
710	var y = x << 0;	710	var y = x << 0;
711	expect(y == 1);	711	try expect(y == 1);
712	}	712	}
713		713
714	test "comptime pointer cast array and then slice" {	714	test "comptime pointer cast array and then slice" {
...	@@ -720,8 +720,8 @@ test "comptime pointer cast array and then slice" {	...	@@ -720,8 +720,8 @@ test "comptime pointer cast array and then slice" {
720	const ptrB: [*]const u8 = &array;	720	const ptrB: [*]const u8 = &array;
721	const sliceB: []const u8 = ptrB[0..2];	721	const sliceB: []const u8 = ptrB[0..2];
722		722
723	expect(sliceA[1] == 2);	723	try expect(sliceA[1] == 2);
724	expect(sliceB[1] == 2);	724	try expect(sliceB[1] == 2);
725	}	725	}
726		726
727	test "slice bounds in comptime concatenation" {	727	test "slice bounds in comptime concatenation" {
...	@@ -730,46 +730,46 @@ test "slice bounds in comptime concatenation" {	...	@@ -730,46 +730,46 @@ test "slice bounds in comptime concatenation" {
730	break :blk b[8..9];	730	break :blk b[8..9];
731	};	731	};
732	const str = "" ++ bs;	732	const str = "" ++ bs;
733	expect(str.len == 1);	733	try expect(str.len == 1);
734	expect(std.mem.eql(u8, str, "1"));	734	try expect(std.mem.eql(u8, str, "1"));
735		735
736	const str2 = bs ++ "";	736	const str2 = bs ++ "";
737	expect(str2.len == 1);	737	try expect(str2.len == 1);
738	expect(std.mem.eql(u8, str2, "1"));	738	try expect(std.mem.eql(u8, str2, "1"));
739	}	739	}
740		740
741	test "comptime bitwise operators" {	741	test "comptime bitwise operators" {
742	comptime {	742	comptime {
743	expect(3 & 1 == 1);	743	try expect(3 & 1 == 1);
744	expect(3 & -1 == 3);	744	try expect(3 & -1 == 3);
745	expect(-3 & -1 == -3);	745	try expect(-3 & -1 == -3);
746	expect(3 \| -1 == -1);	746	try expect(3 \| -1 == -1);
747	expect(-3 \| -1 == -1);	747	try expect(-3 \| -1 == -1);
748	expect(3 ^ -1 == -4);	748	try expect(3 ^ -1 == -4);
749	expect(-3 ^ -1 == 2);	749	try expect(-3 ^ -1 == 2);
750	expect(~@as(i8, -1) == 0);	750	try expect(~@as(i8, -1) == 0);
751	expect(~@as(i128, -1) == 0);	751	try expect(~@as(i128, -1) == 0);
752	expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611);	752	try expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611);
753	expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615);	753	try expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615);
754	expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff);	754	try expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff);
755	}	755	}
756	}	756	}
757		757
758	test "align(1) u16 is the same as align(1:0:2) u16" {	758	test "align(1) u16 is the same as align(1:0:2) u16" {
759	comptime {	759	comptime {
760	expect(align(1:0:2) u16 == align(1) u16);	760	try expect(align(1:0:2) u16 == align(1) u16);
761	expect(align(2:0:2) u16 == u16);	761	try expect(align(2:0:2) u16 == u16);
762	}	762	}
763	}	763	}
764		764
765	test "array concatenation forces comptime" {	765	test "array concatenation forces comptime" {
766	var a = oneItem(3) ++ oneItem(4);	766	var a = oneItem(3) ++ oneItem(4);
767	expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));	767	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
768	}	768	}
769		769
770	test "array multiplication forces comptime" {	770	test "array multiplication forces comptime" {
771	var a = oneItem(3) ** scalar(2);	771	var a = oneItem(3) ** scalar(2);
772	expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));	772	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
773	}	773	}
774		774
775	fn oneItem(x: i32) [1]i32 {	775	fn oneItem(x: i32) [1]i32 {
...	@@ -791,7 +791,7 @@ test "comptime assign int to optional int" {	...	@@ -791,7 +791,7 @@ test "comptime assign int to optional int" {
791	var x: ?i32 = null;	791	var x: ?i32 = null;
792	x = 2;	792	x = 2;
793	x.? *= 10;	793	x.? *= 10;
794	expectEqual(20, x.?);	794	try expectEqual(20, x.?);
795	}	795	}
796	}	796	}
797		797

test/stage1/behavior/field_parent_ptr.zig+12-12

...	@@ -1,13 +1,13 @@	...	@@ -1,13 +1,13 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "@fieldParentPtr non-first field" {	3	test "@fieldParentPtr non-first field" {
4	testParentFieldPtr(&foo.c);	4	try testParentFieldPtr(&foo.c);
5	comptime testParentFieldPtr(&foo.c);	5	comptime try testParentFieldPtr(&foo.c);
6	}	6	}
7		7
8	test "@fieldParentPtr first field" {	8	test "@fieldParentPtr first field" {
9	testParentFieldPtrFirst(&foo.a);	9	try testParentFieldPtrFirst(&foo.a);
10	comptime testParentFieldPtrFirst(&foo.a);	10	comptime try testParentFieldPtrFirst(&foo.a);
11	}	11	}
12		12
13	const Foo = struct {	13	const Foo = struct {
...	@@ -24,18 +24,18 @@ const foo = Foo{	...	@@ -24,18 +24,18 @@ const foo = Foo{
24	.d = -10,	24	.d = -10,
25	};	25	};
26		26
27	fn testParentFieldPtr(c: *const i32) void {	27	fn testParentFieldPtr(c: *const i32) !void {
28	expect(c == &foo.c);	28	try expect(c == &foo.c);
29		29
30	const base = @fieldParentPtr(Foo, "c", c);	30	const base = @fieldParentPtr(Foo, "c", c);
31	expect(base == &foo);	31	try expect(base == &foo);
32	expect(&base.c == c);	32	try expect(&base.c == c);
33	}	33	}
34		34
35	fn testParentFieldPtrFirst(a: *const bool) void {	35	fn testParentFieldPtrFirst(a: *const bool) !void {
36	expect(a == &foo.a);	36	try expect(a == &foo.a);
37		37
38	const base = @fieldParentPtr(Foo, "a", a);	38	const base = @fieldParentPtr(Foo, "a", a);
39	expect(base == &foo);	39	try expect(base == &foo);
40	expect(&base.a == a);	40	try expect(&base.a == a);
41	}	41	}

test/stage1/behavior/floatop.zig+161-161

...	@@ -8,441 +8,441 @@ const Vector = std.meta.Vector;	...	@@ -8,441 +8,441 @@ const Vector = std.meta.Vector;
8	const epsilon = 0.000001;	8	const epsilon = 0.000001;
9		9
10	test "@sqrt" {	10	test "@sqrt" {
11	comptime testSqrt();	11	comptime try testSqrt();
12	testSqrt();	12	try testSqrt();
13	}	13	}
14		14
15	fn testSqrt() void {	15	fn testSqrt() !void {
16	{	16	{
17	var a: f16 = 4;	17	var a: f16 = 4;
18	expect(@sqrt(a) == 2);	18	try expect(@sqrt(a) == 2);
19	}	19	}
20	{	20	{
21	var a: f32 = 9;	21	var a: f32 = 9;
22	expect(@sqrt(a) == 3);	22	try expect(@sqrt(a) == 3);
23	var b: f32 = 1.1;	23	var b: f32 = 1.1;
24	expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon));	24	try expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon));
25	}	25	}
26	{	26	{
27	var a: f64 = 25;	27	var a: f64 = 25;
28	expect(@sqrt(a) == 5);	28	try expect(@sqrt(a) == 5);
29	}	29	}
30	{	30	{
31	const a: comptime_float = 25.0;	31	const a: comptime_float = 25.0;
32	expect(@sqrt(a) == 5.0);	32	try expect(@sqrt(a) == 5.0);
33	}	33	}
34	// TODO https://github.com/ziglang/zig/issues/4026	34	// TODO https://github.com/ziglang/zig/issues/4026
35	//{	35	//{
36	// var a: f128 = 49;	36	// var a: f128 = 49;
37	// expect(@sqrt(a) == 7);	37	//try expect(@sqrt(a) == 7);
38	//}	38	//}
39	{	39	{
40	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };	40	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
41	var result = @sqrt(v);	41	var result = @sqrt(v);
42	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));	42	try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon));
43	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));	43	try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon));
44	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));	44	try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon));
45	expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));	45	try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon));
46	}	46	}
47	}	47	}
48		48
49	test "more @sqrt f16 tests" {	49	test "more @sqrt f16 tests" {
50	// TODO these are not all passing at comptime	50	// TODO these are not all passing at comptime
51	expect(@sqrt(@as(f16, 0.0)) == 0.0);	51	try expect(@sqrt(@as(f16, 0.0)) == 0.0);
52	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));	52	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon));
53	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));	53	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon));
54	expect(@sqrt(@as(f16, 4.0)) == 2.0);	54	try expect(@sqrt(@as(f16, 4.0)) == 2.0);
55	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));	55	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon));
56	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));	56	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon));
57	expect(@sqrt(@as(f16, 64.0)) == 8.0);	57	try expect(@sqrt(@as(f16, 64.0)) == 8.0);
58	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));	58	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon));
59	expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));	59	try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon));
60		60
61	// special cases	61	// special cases
62	expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));	62	try expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16)))));
63	expect(@sqrt(@as(f16, 0.0)) == 0.0);	63	try expect(@sqrt(@as(f16, 0.0)) == 0.0);
64	expect(@sqrt(@as(f16, -0.0)) == -0.0);	64	try expect(@sqrt(@as(f16, -0.0)) == -0.0);
65	expect(math.isNan(@sqrt(@as(f16, -1.0))));	65	try expect(math.isNan(@sqrt(@as(f16, -1.0))));
66	expect(math.isNan(@sqrt(@as(f16, math.nan(f16)))));	66	try expect(math.isNan(@sqrt(@as(f16, math.nan(f16)))));
67	}	67	}
68		68
69	test "@sin" {	69	test "@sin" {
70	comptime testSin();	70	comptime try testSin();
71	testSin();	71	try testSin();
72	}	72	}
73		73
74	fn testSin() void {	74	fn testSin() !void {
75	// TODO test f128, and c_longdouble	75	// TODO test f128, and c_longdouble
76	// https://github.com/ziglang/zig/issues/4026	76	// https://github.com/ziglang/zig/issues/4026
77	{	77	{
78	var a: f16 = 0;	78	var a: f16 = 0;
79	expect(@sin(a) == 0);	79	try expect(@sin(a) == 0);
80	}	80	}
81	{	81	{
82	var a: f32 = 0;	82	var a: f32 = 0;
83	expect(@sin(a) == 0);	83	try expect(@sin(a) == 0);
84	}	84	}
85	{	85	{
86	var a: f64 = 0;	86	var a: f64 = 0;
87	expect(@sin(a) == 0);	87	try expect(@sin(a) == 0);
88	}	88	}
89	{	89	{
90	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };	90	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
91	var result = @sin(v);	91	var result = @sin(v);
92	expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));	92	try expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon));
93	expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));	93	try expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon));
94	expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));	94	try expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon));
95	expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon));	95	try expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon));
96	}	96	}
97	}	97	}
98		98
99	test "@cos" {	99	test "@cos" {
100	comptime testCos();	100	comptime try testCos();
101	testCos();	101	try testCos();
102	}	102	}
103		103
104	fn testCos() void {	104	fn testCos() !void {
105	// TODO test f128, and c_longdouble	105	// TODO test f128, and c_longdouble
106	// https://github.com/ziglang/zig/issues/4026	106	// https://github.com/ziglang/zig/issues/4026
107	{	107	{
108	var a: f16 = 0;	108	var a: f16 = 0;
109	expect(@cos(a) == 1);	109	try expect(@cos(a) == 1);
110	}	110	}
111	{	111	{
112	var a: f32 = 0;	112	var a: f32 = 0;
113	expect(@cos(a) == 1);	113	try expect(@cos(a) == 1);
114	}	114	}
115	{	115	{
116	var a: f64 = 0;	116	var a: f64 = 0;
117	expect(@cos(a) == 1);	117	try expect(@cos(a) == 1);
118	}	118	}
119	{	119	{
120	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };	120	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 };
121	var result = @cos(v);	121	var result = @cos(v);
122	expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));	122	try expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon));
123	expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));	123	try expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon));
124	expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));	124	try expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon));
125	expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon));	125	try expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon));
126	}	126	}
127	}	127	}
128		128
129	test "@exp" {	129	test "@exp" {
130	comptime testExp();	130	comptime try testExp();
131	testExp();	131	try testExp();
132	}	132	}
133		133
134	fn testExp() void {	134	fn testExp() !void {
135	// TODO test f128, and c_longdouble	135	// TODO test f128, and c_longdouble
136	// https://github.com/ziglang/zig/issues/4026	136	// https://github.com/ziglang/zig/issues/4026
137	{	137	{
138	var a: f16 = 0;	138	var a: f16 = 0;
139	expect(@exp(a) == 1);	139	try expect(@exp(a) == 1);
140	}	140	}
141	{	141	{
142	var a: f32 = 0;	142	var a: f32 = 0;
143	expect(@exp(a) == 1);	143	try expect(@exp(a) == 1);
144	}	144	}
145	{	145	{
146	var a: f64 = 0;	146	var a: f64 = 0;
147	expect(@exp(a) == 1);	147	try expect(@exp(a) == 1);
148	}	148	}
149	{	149	{
150	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };	150	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
151	var result = @exp(v);	151	var result = @exp(v);
152	expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));	152	try expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon));
153	expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));	153	try expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon));
154	expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));	154	try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon));
155	expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon));	155	try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon));
156	}	156	}
157	}	157	}
158		158
159	test "@exp2" {	159	test "@exp2" {
160	comptime testExp2();	160	comptime try testExp2();
161	testExp2();	161	try testExp2();
162	}	162	}
163		163
164	fn testExp2() void {	164	fn testExp2() !void {
165	// TODO test f128, and c_longdouble	165	// TODO test f128, and c_longdouble
166	// https://github.com/ziglang/zig/issues/4026	166	// https://github.com/ziglang/zig/issues/4026
167	{	167	{
168	var a: f16 = 2;	168	var a: f16 = 2;
169	expect(@exp2(a) == 4);	169	try expect(@exp2(a) == 4);
170	}	170	}
171	{	171	{
172	var a: f32 = 2;	172	var a: f32 = 2;
173	expect(@exp2(a) == 4);	173	try expect(@exp2(a) == 4);
174	}	174	}
175	{	175	{
176	var a: f64 = 2;	176	var a: f64 = 2;
177	expect(@exp2(a) == 4);	177	try expect(@exp2(a) == 4);
178	}	178	}
179	{	179	{
180	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };	180	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
181	var result = @exp2(v);	181	var result = @exp2(v);
182	expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));	182	try expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon));
183	expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));	183	try expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon));
184	expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));	184	try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon));
185	expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));	185	try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon));
186	}	186	}
187	}	187	}
188		188
189	test "@log" {	189	test "@log" {
190	// Old musl (and glibc?), and our current math.ln implementation do not return 1	190	// Old musl (and glibc?), and our current math.ln implementation do not return 1
191	// so also accept those values.	191	// so also accept those values.
192	comptime testLog();	192	comptime try testLog();
193	testLog();	193	try testLog();
194	}	194	}
195		195
196	fn testLog() void {	196	fn testLog() !void {
197	// TODO test f128, and c_longdouble	197	// TODO test f128, and c_longdouble
198	// https://github.com/ziglang/zig/issues/4026	198	// https://github.com/ziglang/zig/issues/4026
199	{	199	{
200	var a: f16 = e;	200	var a: f16 = e;
201	expect(math.approxEqAbs(f16, @log(a), 1, epsilon));	201	try expect(math.approxEqAbs(f16, @log(a), 1, epsilon));
202	}	202	}
203	{	203	{
204	var a: f32 = e;	204	var a: f32 = e;
205	expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff)));	205	try expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff)));
206	}	206	}
207	{	207	{
208	var a: f64 = e;	208	var a: f64 = e;
209	expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));	209	try expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
210	}	210	}
211	{	211	{
212	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };	212	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
213	var result = @log(v);	213	var result = @log(v);
214	expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon));	214	try expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon));
215	expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon));	215	try expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon));
216	expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon));	216	try expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon));
217	expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon));	217	try expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon));
218	}	218	}
219	}	219	}
220		220
221	test "@log2" {	221	test "@log2" {
222	comptime testLog2();	222	comptime try testLog2();
223	testLog2();	223	try testLog2();
224	}	224	}
225		225
226	fn testLog2() void {	226	fn testLog2() !void {
227	// TODO test f128, and c_longdouble	227	// TODO test f128, and c_longdouble
228	// https://github.com/ziglang/zig/issues/4026	228	// https://github.com/ziglang/zig/issues/4026
229	{	229	{
230	var a: f16 = 4;	230	var a: f16 = 4;
231	expect(@log2(a) == 2);	231	try expect(@log2(a) == 2);
232	}	232	}
233	{	233	{
234	var a: f32 = 4;	234	var a: f32 = 4;
235	expect(@log2(a) == 2);	235	try expect(@log2(a) == 2);
236	}	236	}
237	{	237	{
238	var a: f64 = 4;	238	var a: f64 = 4;
239	expect(@log2(a) == 2);	239	try expect(@log2(a) == 2);
240	}	240	}
241	{	241	{
242	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };	242	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
243	var result = @log2(v);	243	var result = @log2(v);
244	expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon));	244	try expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon));
245	expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon));	245	try expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon));
246	expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon));	246	try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon));
247	expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon));	247	try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon));
248	}	248	}
249	}	249	}
250		250
251	test "@log10" {	251	test "@log10" {
252	comptime testLog10();	252	comptime try testLog10();
253	testLog10();	253	try testLog10();
254	}	254	}
255		255
256	fn testLog10() void {	256	fn testLog10() !void {
257	// TODO test f128, and c_longdouble	257	// TODO test f128, and c_longdouble
258	// https://github.com/ziglang/zig/issues/4026	258	// https://github.com/ziglang/zig/issues/4026
259	{	259	{
260	var a: f16 = 100;	260	var a: f16 = 100;
261	expect(@log10(a) == 2);	261	try expect(@log10(a) == 2);
262	}	262	}
263	{	263	{
264	var a: f32 = 100;	264	var a: f32 = 100;
265	expect(@log10(a) == 2);	265	try expect(@log10(a) == 2);
266	}	266	}
267	{	267	{
268	var a: f64 = 1000;	268	var a: f64 = 1000;
269	expect(@log10(a) == 3);	269	try expect(@log10(a) == 3);
270	}	270	}
271	{	271	{
272	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };	272	var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
273	var result = @log10(v);	273	var result = @log10(v);
274	expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon));	274	try expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon));
275	expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon));	275	try expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon));
276	expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon));	276	try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon));
277	expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon));	277	try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon));
278	}	278	}
279	}	279	}
280		280
281	test "@fabs" {	281	test "@fabs" {
282	comptime testFabs();	282	comptime try testFabs();
283	testFabs();	283	try testFabs();
284	}	284	}
285		285
286	fn testFabs() void {	286	fn testFabs() !void {
287	// TODO test f128, and c_longdouble	287	// TODO test f128, and c_longdouble
288	// https://github.com/ziglang/zig/issues/4026	288	// https://github.com/ziglang/zig/issues/4026
289	{	289	{
290	var a: f16 = -2.5;	290	var a: f16 = -2.5;
291	var b: f16 = 2.5;	291	var b: f16 = 2.5;
292	expect(@fabs(a) == 2.5);	292	try expect(@fabs(a) == 2.5);
293	expect(@fabs(b) == 2.5);	293	try expect(@fabs(b) == 2.5);
294	}	294	}
295	{	295	{
296	var a: f32 = -2.5;	296	var a: f32 = -2.5;
297	var b: f32 = 2.5;	297	var b: f32 = 2.5;
298	expect(@fabs(a) == 2.5);	298	try expect(@fabs(a) == 2.5);
299	expect(@fabs(b) == 2.5);	299	try expect(@fabs(b) == 2.5);
300	}	300	}
301	{	301	{
302	var a: f64 = -2.5;	302	var a: f64 = -2.5;
303	var b: f64 = 2.5;	303	var b: f64 = 2.5;
304	expect(@fabs(a) == 2.5);	304	try expect(@fabs(a) == 2.5);
305	expect(@fabs(b) == 2.5);	305	try expect(@fabs(b) == 2.5);
306	}	306	}
307	{	307	{
308	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };	308	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
309	var result = @fabs(v);	309	var result = @fabs(v);
310	expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));	310	try expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon));
311	expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));	311	try expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon));
312	expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));	312	try expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon));
313	expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));	313	try expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
314	}	314	}
315	}	315	}
316		316
317	test "@floor" {	317	test "@floor" {
318	comptime testFloor();	318	comptime try testFloor();
319	testFloor();	319	try testFloor();
320	}	320	}
321		321
322	fn testFloor() void {	322	fn testFloor() !void {
323	// TODO test f128, and c_longdouble	323	// TODO test f128, and c_longdouble
324	// https://github.com/ziglang/zig/issues/4026	324	// https://github.com/ziglang/zig/issues/4026
325	{	325	{
326	var a: f16 = 2.1;	326	var a: f16 = 2.1;
327	expect(@floor(a) == 2);	327	try expect(@floor(a) == 2);
328	}	328	}
329	{	329	{
330	var a: f32 = 2.1;	330	var a: f32 = 2.1;
331	expect(@floor(a) == 2);	331	try expect(@floor(a) == 2);
332	}	332	}
333	{	333	{
334	var a: f64 = 3.5;	334	var a: f64 = 3.5;
335	expect(@floor(a) == 3);	335	try expect(@floor(a) == 3);
336	}	336	}
337	{	337	{
338	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };	338	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
339	var result = @floor(v);	339	var result = @floor(v);
340	expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));	340	try expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon));
341	expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));	341	try expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon));
342	expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));	342	try expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon));
343	expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));	343	try expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
344	}	344	}
345	}	345	}
346		346
347	test "@ceil" {	347	test "@ceil" {
348	comptime testCeil();	348	comptime try testCeil();
349	testCeil();	349	try testCeil();
350	}	350	}
351		351
352	fn testCeil() void {	352	fn testCeil() !void {
353	// TODO test f128, and c_longdouble	353	// TODO test f128, and c_longdouble
354	// https://github.com/ziglang/zig/issues/4026	354	// https://github.com/ziglang/zig/issues/4026
355	{	355	{
356	var a: f16 = 2.1;	356	var a: f16 = 2.1;
357	expect(@ceil(a) == 3);	357	try expect(@ceil(a) == 3);
358	}	358	}
359	{	359	{
360	var a: f32 = 2.1;	360	var a: f32 = 2.1;
361	expect(@ceil(a) == 3);	361	try expect(@ceil(a) == 3);
362	}	362	}
363	{	363	{
364	var a: f64 = 3.5;	364	var a: f64 = 3.5;
365	expect(@ceil(a) == 4);	365	try expect(@ceil(a) == 4);
366	}	366	}
367	{	367	{
368	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };	368	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
369	var result = @ceil(v);	369	var result = @ceil(v);
370	expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));	370	try expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon));
371	expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));	371	try expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon));
372	expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));	372	try expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon));
373	expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));	373	try expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
374	}	374	}
375	}	375	}
376		376
377	test "@trunc" {	377	test "@trunc" {
378	comptime testTrunc();	378	comptime try testTrunc();
379	testTrunc();	379	try testTrunc();
380	}	380	}
381		381
382	fn testTrunc() void {	382	fn testTrunc() !void {
383	// TODO test f128, and c_longdouble	383	// TODO test f128, and c_longdouble
384	// https://github.com/ziglang/zig/issues/4026	384	// https://github.com/ziglang/zig/issues/4026
385	{	385	{
386	var a: f16 = 2.1;	386	var a: f16 = 2.1;
387	expect(@trunc(a) == 2);	387	try expect(@trunc(a) == 2);
388	}	388	}
389	{	389	{
390	var a: f32 = 2.1;	390	var a: f32 = 2.1;
391	expect(@trunc(a) == 2);	391	try expect(@trunc(a) == 2);
392	}	392	}
393	{	393	{
394	var a: f64 = -3.5;	394	var a: f64 = -3.5;
395	expect(@trunc(a) == -3);	395	try expect(@trunc(a) == -3);
396	}	396	}
397	{	397	{
398	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };	398	var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 };
399	var result = @trunc(v);	399	var result = @trunc(v);
400	expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));	400	try expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon));
401	expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));	401	try expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon));
402	expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));	402	try expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon));
403	expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));	403	try expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
404	}	404	}
405	}	405	}
406		406
407	test "floating point comparisons" {	407	test "floating point comparisons" {
408	testFloatComparisons();	408	try testFloatComparisons();
409	comptime testFloatComparisons();	409	comptime try testFloatComparisons();
410	}	410	}
411		411
412	fn testFloatComparisons() void {	412	fn testFloatComparisons() !void {
413	inline for ([_]type{ f16, f32, f64, f128 }) \|ty\| {	413	inline for ([_]type{ f16, f32, f64, f128 }) \|ty\| {
414	// No decimal part	414	// No decimal part
415	{	415	{
416	const x: ty = 1.0;	416	const x: ty = 1.0;
417	expect(x == 1);	417	try expect(x == 1);
418	expect(x != 0);	418	try expect(x != 0);
419	expect(x > 0);	419	try expect(x > 0);
420	expect(x < 2);	420	try expect(x < 2);
421	expect(x >= 1);	421	try expect(x >= 1);
422	expect(x <= 1);	422	try expect(x <= 1);
423	}	423	}
424	// Non-zero decimal part	424	// Non-zero decimal part
425	{	425	{
426	const x: ty = 1.5;	426	const x: ty = 1.5;
427	expect(x != 1);	427	try expect(x != 1);
428	expect(x != 2);	428	try expect(x != 2);
429	expect(x > 1);	429	try expect(x > 1);
430	expect(x < 2);	430	try expect(x < 2);
431	expect(x >= 1);	431	try expect(x >= 1);
432	expect(x <= 2);	432	try expect(x <= 2);
433	}	433	}
434	}	434	}
435	}	435	}
436		436
437	test "different sized float comparisons" {	437	test "different sized float comparisons" {
438	testDifferentSizedFloatComparisons();	438	try testDifferentSizedFloatComparisons();
439	comptime testDifferentSizedFloatComparisons();	439	comptime try testDifferentSizedFloatComparisons();
440	}	440	}
441		441
442	fn testDifferentSizedFloatComparisons() void {	442	fn testDifferentSizedFloatComparisons() !void {
443	var a: f16 = 1;	443	var a: f16 = 1;
444	var b: f64 = 2;	444	var b: f64 = 2;
445	expect(a < b);	445	try expect(a < b);
446	}	446	}
447		447
448	// TODO This is waiting on library support for the Windows build (not sure why the other's don't need it)	448	// TODO This is waiting on library support for the Windows build (not sure why the other's don't need it)
...	@@ -456,10 +456,10 @@ fn testDifferentSizedFloatComparisons() void {	...	@@ -456,10 +456,10 @@ fn testDifferentSizedFloatComparisons() void {
456	// // https://github.com/ziglang/zig/issues/4026	456	// // https://github.com/ziglang/zig/issues/4026
457	// {	457	// {
458	// var a: f32 = 2.1;	458	// var a: f32 = 2.1;
459	// expect(@nearbyint(a) == 2);	459	// try expect(@nearbyint(a) == 2);
460	// }	460	// }
461	// {	461	// {
462	// var a: f64 = -3.75;	462	// var a: f64 = -3.75;
463	// expect(@nearbyint(a) == -4);	463	// try expect(@nearbyint(a) == -4);
464	// }	464	// }
465	//}	465	//}

test/stage1/behavior/fn.zig+41-41

...	@@ -4,7 +4,7 @@ const expect = testing.expect;	...	@@ -4,7 +4,7 @@ const expect = testing.expect;
4	const expectEqual = testing.expectEqual;	4	const expectEqual = testing.expectEqual;
5		5
6	test "params" {	6	test "params" {
7	expect(testParamsAdd(22, 11) == 33);	7	try expect(testParamsAdd(22, 11) == 33);
8	}	8	}
9	fn testParamsAdd(a: i32, b: i32) i32 {	9	fn testParamsAdd(a: i32, b: i32) i32 {
10	return a + b;	10	return a + b;
...	@@ -19,37 +19,37 @@ fn testLocVars(b: i32) void {	...	@@ -19,37 +19,37 @@ fn testLocVars(b: i32) void {
19	}	19	}
20		20
21	test "void parameters" {	21	test "void parameters" {
22	voidFun(1, void{}, 2, {});	22	try voidFun(1, void{}, 2, {});
23	}	23	}
24	fn voidFun(a: i32, b: void, c: i32, d: void) void {	24	fn voidFun(a: i32, b: void, c: i32, d: void) !void {
25	const v = b;	25	const v = b;
26	const vv: void = if (a == 1) v else {};	26	const vv: void = if (a == 1) v else {};
27	expect(a + c == 3);	27	try expect(a + c == 3);
28	return vv;	28	return vv;
29	}	29	}
30		30
31	test "mutable local variables" {	31	test "mutable local variables" {
32	var zero: i32 = 0;	32	var zero: i32 = 0;
33	expect(zero == 0);	33	try expect(zero == 0);
34		34
35	var i = @as(i32, 0);	35	var i = @as(i32, 0);
36	while (i != 3) {	36	while (i != 3) {
37	i += 1;	37	i += 1;
38	}	38	}
39	expect(i == 3);	39	try expect(i == 3);
40	}	40	}
41		41
42	test "separate block scopes" {	42	test "separate block scopes" {
43	{	43	{
44	const no_conflict: i32 = 5;	44	const no_conflict: i32 = 5;
45	expect(no_conflict == 5);	45	try expect(no_conflict == 5);
46	}	46	}
47		47
48	const c = x: {	48	const c = x: {
49	const no_conflict = @as(i32, 10);	49	const no_conflict = @as(i32, 10);
50	break :x no_conflict;	50	break :x no_conflict;
51	};	51	};
52	expect(c == 10);	52	try expect(c == 10);
53	}	53	}
54		54
55	test "call function with empty string" {	55	test "call function with empty string" {
...	@@ -62,7 +62,7 @@ fn @"weird function name"() i32 {	...	@@ -62,7 +62,7 @@ fn @"weird function name"() i32 {
62	return 1234;	62	return 1234;
63	}	63	}
64	test "weird function name" {	64	test "weird function name" {
65	expect(@"weird function name"() == 1234);	65	try expect(@"weird function name"() == 1234);
66	}	66	}
67		67
68	test "implicit cast function unreachable return" {	68	test "implicit cast function unreachable return" {
...	@@ -83,7 +83,7 @@ test "function pointers" {	...	@@ -83,7 +83,7 @@ test "function pointers" {
83	fn4,	83	fn4,
84	};	84	};
85	for (fns) \|f, i\| {	85	for (fns) \|f, i\| {
86	expect(f() == @intCast(u32, i) + 5);	86	try expect(f() == @intCast(u32, i) + 5);
87	}	87	}
88	}	88	}
89	fn fn1() u32 {	89	fn fn1() u32 {
...	@@ -100,12 +100,12 @@ fn fn4() u32 {	...	@@ -100,12 +100,12 @@ fn fn4() u32 {
100	}	100	}
101		101
102	test "number literal as an argument" {	102	test "number literal as an argument" {
103	numberLiteralArg(3);	103	try numberLiteralArg(3);
104	comptime numberLiteralArg(3);	104	comptime try numberLiteralArg(3);
105	}	105	}
106		106
107	fn numberLiteralArg(a: anytype) void {	107	fn numberLiteralArg(a: anytype) !void {
108	expect(a == 3);	108	try expect(a == 3);
109	}	109	}
110		110
111	test "assign inline fn to const variable" {	111	test "assign inline fn to const variable" {
...	@@ -116,7 +116,7 @@ test "assign inline fn to const variable" {	...	@@ -116,7 +116,7 @@ test "assign inline fn to const variable" {
116	fn inlineFn() callconv(.Inline) void {}	116	fn inlineFn() callconv(.Inline) void {}
117		117
118	test "pass by non-copying value" {	118	test "pass by non-copying value" {
119	expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);	119	try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
120	}	120	}
121		121
122	const Point = struct {	122	const Point = struct {
...	@@ -129,17 +129,17 @@ fn addPointCoords(pt: Point) i32 {	...	@@ -129,17 +129,17 @@ fn addPointCoords(pt: Point) i32 {
129	}	129	}
130		130
131	test "pass by non-copying value through var arg" {	131	test "pass by non-copying value through var arg" {
132	expect(addPointCoordsVar(Point{ .x = 1, .y = 2 }) == 3);	132	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
133	}	133	}
134		134
135	fn addPointCoordsVar(pt: anytype) i32 {	135	fn addPointCoordsVar(pt: anytype) !i32 {
136	comptime expect(@TypeOf(pt) == Point);	136	comptime try expect(@TypeOf(pt) == Point);
137	return pt.x + pt.y;	137	return pt.x + pt.y;
138	}	138	}
139		139
140	test "pass by non-copying value as method" {	140	test "pass by non-copying value as method" {
141	var pt = Point2{ .x = 1, .y = 2 };	141	var pt = Point2{ .x = 1, .y = 2 };
142	expect(pt.addPointCoords() == 3);	142	try expect(pt.addPointCoords() == 3);
143	}	143	}
144		144
145	const Point2 = struct {	145	const Point2 = struct {
...	@@ -153,7 +153,7 @@ const Point2 = struct {	...	@@ -153,7 +153,7 @@ const Point2 = struct {
153		153
154	test "pass by non-copying value as method, which is generic" {	154	test "pass by non-copying value as method, which is generic" {
155	var pt = Point3{ .x = 1, .y = 2 };	155	var pt = Point3{ .x = 1, .y = 2 };
156	expect(pt.addPointCoords(i32) == 3);	156	try expect(pt.addPointCoords(i32) == 3);
157	}	157	}
158		158
159	const Point3 = struct {	159	const Point3 = struct {
...	@@ -168,7 +168,7 @@ const Point3 = struct {	...	@@ -168,7 +168,7 @@ const Point3 = struct {
168	test "pass by non-copying value as method, at comptime" {	168	test "pass by non-copying value as method, at comptime" {
169	comptime {	169	comptime {
170	var pt = Point2{ .x = 1, .y = 2 };	170	var pt = Point2{ .x = 1, .y = 2 };
171	expect(pt.addPointCoords() == 3);	171	try expect(pt.addPointCoords() == 3);
172	}	172	}
173	}	173	}
174		174
...	@@ -184,7 +184,7 @@ fn outer(y: u32) fn (u32) u32 {	...	@@ -184,7 +184,7 @@ fn outer(y: u32) fn (u32) u32 {
184		184
185	test "return inner function which references comptime variable of outer function" {	185	test "return inner function which references comptime variable of outer function" {
186	var func = outer(10);	186	var func = outer(10);
187	expect(func(3) == 7);	187	try expect(func(3) == 7);
188	}	188	}
189		189
190	test "extern struct with stdcallcc fn pointer" {	190	test "extern struct with stdcallcc fn pointer" {
...	@@ -198,16 +198,16 @@ test "extern struct with stdcallcc fn pointer" {	...	@@ -198,16 +198,16 @@ test "extern struct with stdcallcc fn pointer" {
198		198
199	var s: S = undefined;	199	var s: S = undefined;
200	s.ptr = S.foo;	200	s.ptr = S.foo;
201	expect(s.ptr() == 1234);	201	try expect(s.ptr() == 1234);
202	}	202	}
203		203
204	test "implicit cast fn call result to optional in field result" {	204	test "implicit cast fn call result to optional in field result" {
205	const S = struct {	205	const S = struct {
206	fn entry() void {	206	fn entry() !void {
207	var x = Foo{	207	var x = Foo{
208	.field = optionalPtr(),	208	.field = optionalPtr(),
209	};	209	};
210	expect(x.field.?.* == 999);	210	try expect(x.field.?.* == 999);
211	}	211	}
212		212
213	const glob: i32 = 999;	213	const glob: i32 = 999;
...	@@ -220,8 +220,8 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -220,8 +220,8 @@ test "implicit cast fn call result to optional in field result" {
220	field: ?*const i32,	220	field: ?*const i32,
221	};	221	};
222	};	222	};
223	S.entry();	223	try S.entry();
224	comptime S.entry();	224	comptime try S.entry();
225	}	225	}
226		226
227	test "discard the result of a function that returns a struct" {	227	test "discard the result of a function that returns a struct" {
...	@@ -245,26 +245,26 @@ test "discard the result of a function that returns a struct" {	...	@@ -245,26 +245,26 @@ test "discard the result of a function that returns a struct" {
245		245
246	test "function call with anon list literal" {	246	test "function call with anon list literal" {
247	const S = struct {	247	const S = struct {
248	fn doTheTest() void {	248	fn doTheTest() !void {
249	consumeVec(.{ 9, 8, 7 });	249	try consumeVec(.{ 9, 8, 7 });
250	}	250	}
251		251
252	fn consumeVec(vec: [3]f32) void {	252	fn consumeVec(vec: [3]f32) !void {
253	expect(vec[0] == 9);	253	try expect(vec[0] == 9);
254	expect(vec[1] == 8);	254	try expect(vec[1] == 8);
255	expect(vec[2] == 7);	255	try expect(vec[2] == 7);
256	}	256	}
257	};	257	};
258	S.doTheTest();	258	try S.doTheTest();
259	comptime S.doTheTest();	259	comptime try S.doTheTest();
260	}	260	}
261		261
262	test "ability to give comptime types and non comptime types to same parameter" {	262	test "ability to give comptime types and non comptime types to same parameter" {
263	const S = struct {	263	const S = struct {
264	fn doTheTest() void {	264	fn doTheTest() !void {
265	var x: i32 = 1;	265	var x: i32 = 1;
266	expect(foo(x) == 10);	266	try expect(foo(x) == 10);
267	expect(foo(i32) == 20);	267	try expect(foo(i32) == 20);
268	}	268	}
269		269
270	fn foo(arg: anytype) i32 {	270	fn foo(arg: anytype) i32 {
...	@@ -272,8 +272,8 @@ test "ability to give comptime types and non comptime types to same parameter" {	...	@@ -272,8 +272,8 @@ test "ability to give comptime types and non comptime types to same parameter" {
272	return 9 + arg;	272	return 9 + arg;
273	}	273	}
274	};	274	};
275	S.doTheTest();	275	try S.doTheTest();
276	comptime S.doTheTest();	276	comptime try S.doTheTest();
277	}	277	}
278		278
279	test "function with inferred error set but returning no error" {	279	test "function with inferred error set but returning no error" {
...	@@ -282,5 +282,5 @@ test "function with inferred error set but returning no error" {	...	@@ -282,5 +282,5 @@ test "function with inferred error set but returning no error" {
282	};	282	};
283		283
284	const return_ty = @typeInfo(@TypeOf(S.foo)).Fn.return_type.?;	284	const return_ty = @typeInfo(@TypeOf(S.foo)).Fn.return_type.?;
285	expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len);	285	try expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len);
286	}	286	}

test/stage1/behavior/fn_delegation.zig+4-4

...	@@ -32,8 +32,8 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {	...	@@ -32,8 +32,8 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
32		32
33	test "fn delegation" {	33	test "fn delegation" {
34	const foo = Foo{};	34	const foo = Foo{};
35	expect(foo.one() == 11);	35	try expect(foo.one() == 11);
36	expect(foo.two() == 12);	36	try expect(foo.two() == 12);
37	expect(foo.three() == 13);	37	try expect(foo.three() == 13);
38	expect(foo.four() == 14);	38	try expect(foo.four() == 14);
39	}	39	}

test/stage1/behavior/fn_in_struct_in_comptime.zig+1-1

...	@@ -13,5 +13,5 @@ fn get_foo() fn (*u8) usize {	...	@@ -13,5 +13,5 @@ fn get_foo() fn (*u8) usize {
13		13
14	test "define a function in an anonymous struct in comptime" {	14	test "define a function in an anonymous struct in comptime" {
15	const foo = get_foo();	15	const foo = get_foo();
16	expect(foo(@intToPtr(*u8, 12345)) == 12345);	16	try expect(foo(@intToPtr(*u8, 12345)) == 12345);
17	}	17	}

test/stage1/behavior/for.zig+28-28

...	@@ -27,12 +27,12 @@ test "for loop with pointer elem var" {	...	@@ -27,12 +27,12 @@ test "for loop with pointer elem var" {
27	var target: [source.len]u8 = undefined;	27	var target: [source.len]u8 = undefined;
28	mem.copy(u8, target[0..], source);	28	mem.copy(u8, target[0..], source);
29	mangleString(target[0..]);	29	mangleString(target[0..]);
30	expect(mem.eql(u8, &target, "bcdefgh"));	30	try expect(mem.eql(u8, &target, "bcdefgh"));
31		31
32	for (source) \|*c, i\|	32	for (source) \|*c, i\|
33	expect(@TypeOf(c) == *const u8);	33	try expect(@TypeOf(c) == *const u8);
34	for (target) \|*c, i\|	34	for (target) \|*c, i\|
35	expect(@TypeOf(c) == *u8);	35	try expect(@TypeOf(c) == *u8);
36	}	36	}
37		37
38	fn mangleString(s: []u8) void {	38	fn mangleString(s: []u8) void {
...	@@ -75,15 +75,15 @@ test "basic for loop" {	...	@@ -75,15 +75,15 @@ test "basic for loop" {
75	buf_index += 1;	75	buf_index += 1;
76	}	76	}
77		77
78	expect(mem.eql(u8, buffer[0..buf_index], &expected_result));	78	try expect(mem.eql(u8, buffer[0..buf_index], &expected_result));
79	}	79	}
80		80
81	test "break from outer for loop" {	81	test "break from outer for loop" {
82	testBreakOuter();	82	try testBreakOuter();
83	comptime testBreakOuter();	83	comptime try testBreakOuter();
84	}	84	}
85		85
86	fn testBreakOuter() void {	86	fn testBreakOuter() !void {
87	var array = "aoeu";	87	var array = "aoeu";
88	var count: usize = 0;	88	var count: usize = 0;
89	outer: for (array) \|_\| {	89	outer: for (array) \|_\| {
...	@@ -92,15 +92,15 @@ fn testBreakOuter() void {	...	@@ -92,15 +92,15 @@ fn testBreakOuter() void {
92	break :outer;	92	break :outer;
93	}	93	}
94	}	94	}
95	expect(count == 1);	95	try expect(count == 1);
96	}	96	}
97		97
98	test "continue outer for loop" {	98	test "continue outer for loop" {
99	testContinueOuter();	99	try testContinueOuter();
100	comptime testContinueOuter();	100	comptime try testContinueOuter();
101	}	101	}
102		102
103	fn testContinueOuter() void {	103	fn testContinueOuter() !void {
104	var array = "aoeu";	104	var array = "aoeu";
105	var counter: usize = 0;	105	var counter: usize = 0;
106	outer: for (array) \|_\| {	106	outer: for (array) \|_\| {
...	@@ -109,28 +109,28 @@ fn testContinueOuter() void {	...	@@ -109,28 +109,28 @@ fn testContinueOuter() void {
109	continue :outer;	109	continue :outer;
110	}	110	}
111	}	111	}
112	expect(counter == array.len);	112	try expect(counter == array.len);
113	}	113	}
114		114
115	test "2 break statements and an else" {	115	test "2 break statements and an else" {
116	const S = struct {	116	const S = struct {
117	fn entry(t: bool, f: bool) void {	117	fn entry(t: bool, f: bool) !void {
118	var buf: [10]u8 = undefined;	118	var buf: [10]u8 = undefined;
119	var ok = false;	119	var ok = false;
120	ok = for (buf) \|item\| {	120	ok = for (buf) \|item\| {
121	if (f) break false;	121	if (f) break false;
122	if (t) break true;	122	if (t) break true;
123	} else false;	123	} else false;
124	expect(ok);	124	try expect(ok);
125	}	125	}
126	};	126	};
127	S.entry(true, false);	127	try S.entry(true, false);
128	comptime S.entry(true, false);	128	comptime try S.entry(true, false);
129	}	129	}
130		130
131	test "for with null and T peer types and inferred result location type" {	131	test "for with null and T peer types and inferred result location type" {
132	const S = struct {	132	const S = struct {
133	fn doTheTest(slice: []const u8) void {	133	fn doTheTest(slice: []const u8) !void {
134	if (for (slice) \|item\| {	134	if (for (slice) \|item\| {
135	if (item == 10) {	135	if (item == 10) {
136	break item;	136	break item;
...	@@ -140,33 +140,33 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -140,33 +140,33 @@ test "for with null and T peer types and inferred result location type" {
140	}	140	}
141	}	141	}
142	};	142	};
143	S.doTheTest(&[_]u8{ 1, 2 });	143	try S.doTheTest(&[_]u8{ 1, 2 });
144	comptime S.doTheTest(&[_]u8{ 1, 2 });	144	comptime try S.doTheTest(&[_]u8{ 1, 2 });
145	}	145	}
146		146
147	test "for copies its payload" {	147	test "for copies its payload" {
148	const S = struct {	148	const S = struct {
149	fn doTheTest() void {	149	fn doTheTest() !void {
150	var x = [_]usize{ 1, 2, 3 };	150	var x = [_]usize{ 1, 2, 3 };
151	for (x) \|value, i\| {	151	for (x) \|value, i\| {
152	// Modify the original array	152	// Modify the original array
153	x[i] += 99;	153	x[i] += 99;
154	expectEqual(value, i + 1);	154	try expectEqual(value, i + 1);
155	}	155	}
156	}	156	}
157	};	157	};
158	S.doTheTest();	158	try S.doTheTest();
159	comptime S.doTheTest();	159	comptime try S.doTheTest();
160	}	160	}
161		161
162	test "for on slice with allowzero ptr" {	162	test "for on slice with allowzero ptr" {
163	const S = struct {	163	const S = struct {
164	fn doTheTest(slice: []const u8) void {	164	fn doTheTest(slice: []const u8) !void {
165	var ptr = @ptrCast([*]allowzero const u8, slice.ptr)[0..slice.len];	165	var ptr = @ptrCast([*]allowzero const u8, slice.ptr)[0..slice.len];
166	for (ptr) \|x, i\| expect(x == i + 1);	166	for (ptr) \|x, i\| try expect(x == i + 1);
167	for (ptr) \|x, i\| expect(x. == i + 1);	167	for (ptr) \|x, i\| try expect(x. == i + 1);
168	}	168	}
169	};	169	};
170	S.doTheTest(&[_]u8{ 1, 2, 3, 4 });	170	try S.doTheTest(&[_]u8{ 1, 2, 3, 4 });
171	comptime S.doTheTest(&[_]u8{ 1, 2, 3, 4 });	171	comptime try S.doTheTest(&[_]u8{ 1, 2, 3, 4 });
172	}	172	}

test/stage1/behavior/generics.zig+25-25

test/stage1/behavior/hasdecl.zig+6-6

...	@@ -11,11 +11,11 @@ const Bar = struct {	...	@@ -11,11 +11,11 @@ const Bar = struct {
11	};	11	};
12		12
13	test "@hasDecl" {	13	test "@hasDecl" {
14	expect(@hasDecl(Foo, "public_thing"));	14	try expect(@hasDecl(Foo, "public_thing"));
15	expect(!@hasDecl(Foo, "private_thing"));	15	try expect(!@hasDecl(Foo, "private_thing"));
16	expect(!@hasDecl(Foo, "no_thing"));	16	try expect(!@hasDecl(Foo, "no_thing"));
17		17
18	expect(@hasDecl(Bar, "hi"));	18	try expect(@hasDecl(Bar, "hi"));
19	expect(@hasDecl(Bar, "blah"));	19	try expect(@hasDecl(Bar, "blah"));
20	expect(!@hasDecl(Bar, "nope"));	20	try expect(!@hasDecl(Bar, "nope"));
21	}	21	}

test/stage1/behavior/hasfield.zig+12-12

test/stage1/behavior/if.zig+14-14

...	@@ -26,7 +26,7 @@ fn firstEqlThird(a: i32, b: i32, c: i32) void {	...	@@ -26,7 +26,7 @@ fn firstEqlThird(a: i32, b: i32, c: i32) void {
26	}	26	}
27		27
28	test "else if expression" {	28	test "else if expression" {
29	expect(elseIfExpressionF(1) == 1);	29	try expect(elseIfExpressionF(1) == 1);
30	}	30	}
31	fn elseIfExpressionF(c: u8) u8 {	31	fn elseIfExpressionF(c: u8) u8 {
32	if (c == 0) {	32	if (c == 0) {
...	@@ -44,14 +44,14 @@ var global_with_err: anyerror!u32 = error.SomeError;	...	@@ -44,14 +44,14 @@ var global_with_err: anyerror!u32 = error.SomeError;
44		44
45	test "unwrap mutable global var" {	45	test "unwrap mutable global var" {
46	if (global_with_val) \|v\| {	46	if (global_with_val) \|v\| {
47	expect(v == 0);	47	try expect(v == 0);
48	} else \|e\| {	48	} else \|e\| {
49	unreachable;	49	unreachable;
50	}	50	}
51	if (global_with_err) \|_\| {	51	if (global_with_err) \|_\| {
52	unreachable;	52	unreachable;
53	} else \|e\| {	53	} else \|e\| {
54	expect(e == error.SomeError);	54	try expect(e == error.SomeError);
55	}	55	}
56	}	56	}
57		57
...	@@ -63,7 +63,7 @@ test "labeled break inside comptime if inside runtime if" {	...	@@ -63,7 +63,7 @@ test "labeled break inside comptime if inside runtime if" {
63	break :blk @as(i32, 42);	63	break :blk @as(i32, 42);
64	};	64	};
65	}	65	}
66	expect(answer == 42);	66	try expect(answer == 42);
67	}	67	}
68		68
69	test "const result loc, runtime if cond, else unreachable" {	69	test "const result loc, runtime if cond, else unreachable" {
...	@@ -74,36 +74,36 @@ test "const result loc, runtime if cond, else unreachable" {	...	@@ -74,36 +74,36 @@ test "const result loc, runtime if cond, else unreachable" {
74		74
75	var t = true;	75	var t = true;
76	const x = if (t) Num.Two else unreachable;	76	const x = if (t) Num.Two else unreachable;
77	expect(x == .Two);	77	try expect(x == .Two);
78	}	78	}
79		79
80	test "if prongs cast to expected type instead of peer type resolution" {	80	test "if prongs cast to expected type instead of peer type resolution" {
81	const S = struct {	81	const S = struct {
82	fn doTheTest(f: bool) void {	82	fn doTheTest(f: bool) !void {
83	var x: i32 = 0;	83	var x: i32 = 0;
84	x = if (f) 1 else 2;	84	x = if (f) 1 else 2;
85	expect(x == 2);	85	try expect(x == 2);
86		86
87	var b = true;	87	var b = true;
88	const y: i32 = if (b) 1 else 2;	88	const y: i32 = if (b) 1 else 2;
89	expect(y == 1);	89	try expect(y == 1);
90	}	90	}
91	};	91	};
92	S.doTheTest(false);	92	try S.doTheTest(false);
93	comptime S.doTheTest(false);	93	comptime try S.doTheTest(false);
94	}	94	}
95		95
96	test "while copies its payload" {	96	test "while copies its payload" {
97	const S = struct {	97	const S = struct {
98	fn doTheTest() void {	98	fn doTheTest() !void {
99	var tmp: ?i32 = 10;	99	var tmp: ?i32 = 10;
100	if (tmp) \|value\| {	100	if (tmp) \|value\| {
101	// Modify the original variable	101	// Modify the original variable
102	tmp = null;	102	tmp = null;
103	expectEqual(@as(i32, 10), value);	103	try expectEqual(@as(i32, 10), value);
104	} else unreachable;	104	} else unreachable;
105	}	105	}
106	};	106	};
107	S.doTheTest();	107	try S.doTheTest();
108	comptime S.doTheTest();	108	comptime try S.doTheTest();
109	}	109	}

test/stage1/behavior/import.zig+3-3

...	@@ -3,18 +3,18 @@ const expectEqual = @import("std").testing.expectEqual;	...	@@ -3,18 +3,18 @@ const expectEqual = @import("std").testing.expectEqual;
3	const a_namespace = @import("import/a_namespace.zig");	3	const a_namespace = @import("import/a_namespace.zig");
4		4
5	test "call fn via namespace lookup" {	5	test "call fn via namespace lookup" {
6	expectEqual(@as(i32, 1234), a_namespace.foo());	6	try expectEqual(@as(i32, 1234), a_namespace.foo());
7	}	7	}
8		8
9	test "importing the same thing gives the same import" {	9	test "importing the same thing gives the same import" {
10	expect(@import("std") == @import("std"));	10	try expect(@import("std") == @import("std"));
11	}	11	}
12		12
13	test "import in non-toplevel scope" {	13	test "import in non-toplevel scope" {
14	const S = struct {	14	const S = struct {
15	usingnamespace @import("import/a_namespace.zig");	15	usingnamespace @import("import/a_namespace.zig");
16	};	16	};
17	expectEqual(@as(i32, 1234), S.foo());	17	try expectEqual(@as(i32, 1234), S.foo());
18	}	18	}
19		19
20	test "import empty file" {	20	test "import empty file" {

test/stage1/behavior/incomplete_struct_param_tld.zig+1-1

...	@@ -26,5 +26,5 @@ test "incomplete struct param top level declaration" {	...	@@ -26,5 +26,5 @@ test "incomplete struct param top level declaration" {
26	.c = C{ .x = 13 },	26	.c = C{ .x = 13 },
27	},	27	},
28	};	28	};
29	expect(foo(a) == 13);	29	try expect(foo(a) == 13);
30	}	30	}

test/stage1/behavior/inttoptr.zig-4

...	@@ -1,7 +1,3 @@	...	@@ -1,7 +1,3 @@
1	const builtin = @import("builtin");
2	const std = @import("std");
3	const expect = std.testing.expect;
4
5	test "casting random address to function pointer" {	1	test "casting random address to function pointer" {
6	randomAddressToFunction();	2	randomAddressToFunction();
7	comptime randomAddressToFunction();	3	comptime randomAddressToFunction();

test/stage1/behavior/ir_block_deps.zig+2-2

...	@@ -16,6 +16,6 @@ fn getErrInt() anyerror!i32 {	...	@@ -16,6 +16,6 @@ fn getErrInt() anyerror!i32 {
16	}	16	}
17		17
18	test "ir block deps" {	18	test "ir block deps" {
19	expect((foo(1) catch unreachable) == 0);	19	try expect((foo(1) catch unreachable) == 0);
20	expect((foo(2) catch unreachable) == 0);	20	try expect((foo(2) catch unreachable) == 0);
21	}	21	}

test/stage1/behavior/math.zig+357-357

...	@@ -7,71 +7,71 @@ const minInt = std.math.minInt;	...	@@ -7,71 +7,71 @@ const minInt = std.math.minInt;
7	const mem = std.mem;	7	const mem = std.mem;
8		8
9	test "division" {	9	test "division" {
10	testDivision();	10	try testDivision();
11	comptime testDivision();	11	comptime try testDivision();
12	}	12	}
13	fn testDivision() void {	13	fn testDivision() !void {
14	expect(div(u32, 13, 3) == 4);	14	try expect(div(u32, 13, 3) == 4);
15	expect(div(f16, 1.0, 2.0) == 0.5);	15	try expect(div(f16, 1.0, 2.0) == 0.5);
16	expect(div(f32, 1.0, 2.0) == 0.5);	16	try expect(div(f32, 1.0, 2.0) == 0.5);
17		17
18	expect(divExact(u32, 55, 11) == 5);	18	try expect(divExact(u32, 55, 11) == 5);
19	expect(divExact(i32, -55, 11) == -5);	19	try expect(divExact(i32, -55, 11) == -5);
20	expect(divExact(f16, 55.0, 11.0) == 5.0);	20	try expect(divExact(f16, 55.0, 11.0) == 5.0);
21	expect(divExact(f16, -55.0, 11.0) == -5.0);	21	try expect(divExact(f16, -55.0, 11.0) == -5.0);
22	expect(divExact(f32, 55.0, 11.0) == 5.0);	22	try expect(divExact(f32, 55.0, 11.0) == 5.0);
23	expect(divExact(f32, -55.0, 11.0) == -5.0);	23	try expect(divExact(f32, -55.0, 11.0) == -5.0);
24		24
25	expect(divFloor(i32, 5, 3) == 1);	25	try expect(divFloor(i32, 5, 3) == 1);
26	expect(divFloor(i32, -5, 3) == -2);	26	try expect(divFloor(i32, -5, 3) == -2);
27	expect(divFloor(f16, 5.0, 3.0) == 1.0);	27	try expect(divFloor(f16, 5.0, 3.0) == 1.0);
28	expect(divFloor(f16, -5.0, 3.0) == -2.0);	28	try expect(divFloor(f16, -5.0, 3.0) == -2.0);
29	expect(divFloor(f32, 5.0, 3.0) == 1.0);	29	try expect(divFloor(f32, 5.0, 3.0) == 1.0);
30	expect(divFloor(f32, -5.0, 3.0) == -2.0);	30	try expect(divFloor(f32, -5.0, 3.0) == -2.0);
31	expect(divFloor(i32, -0x80000000, -2) == 0x40000000);	31	try expect(divFloor(i32, -0x80000000, -2) == 0x40000000);
32	expect(divFloor(i32, 0, -0x80000000) == 0);	32	try expect(divFloor(i32, 0, -0x80000000) == 0);
33	expect(divFloor(i32, -0x40000001, 0x40000000) == -2);	33	try expect(divFloor(i32, -0x40000001, 0x40000000) == -2);
34	expect(divFloor(i32, -0x80000000, 1) == -0x80000000);	34	try expect(divFloor(i32, -0x80000000, 1) == -0x80000000);
35	expect(divFloor(i32, 10, 12) == 0);	35	try expect(divFloor(i32, 10, 12) == 0);
36	expect(divFloor(i32, -14, 12) == -2);	36	try expect(divFloor(i32, -14, 12) == -2);
37	expect(divFloor(i32, -2, 12) == -1);	37	try expect(divFloor(i32, -2, 12) == -1);
38		38
39	expect(divTrunc(i32, 5, 3) == 1);	39	try expect(divTrunc(i32, 5, 3) == 1);
40	expect(divTrunc(i32, -5, 3) == -1);	40	try expect(divTrunc(i32, -5, 3) == -1);
41	expect(divTrunc(f16, 5.0, 3.0) == 1.0);	41	try expect(divTrunc(f16, 5.0, 3.0) == 1.0);
42	expect(divTrunc(f16, -5.0, 3.0) == -1.0);	42	try expect(divTrunc(f16, -5.0, 3.0) == -1.0);
43	expect(divTrunc(f32, 5.0, 3.0) == 1.0);	43	try expect(divTrunc(f32, 5.0, 3.0) == 1.0);
44	expect(divTrunc(f32, -5.0, 3.0) == -1.0);	44	try expect(divTrunc(f32, -5.0, 3.0) == -1.0);
45	expect(divTrunc(f64, 5.0, 3.0) == 1.0);	45	try expect(divTrunc(f64, 5.0, 3.0) == 1.0);
46	expect(divTrunc(f64, -5.0, 3.0) == -1.0);	46	try expect(divTrunc(f64, -5.0, 3.0) == -1.0);
47	expect(divTrunc(i32, 10, 12) == 0);	47	try expect(divTrunc(i32, 10, 12) == 0);
48	expect(divTrunc(i32, -14, 12) == -1);	48	try expect(divTrunc(i32, -14, 12) == -1);
49	expect(divTrunc(i32, -2, 12) == 0);	49	try expect(divTrunc(i32, -2, 12) == 0);
50		50
51	expect(mod(i32, 10, 12) == 10);	51	try expect(mod(i32, 10, 12) == 10);
52	expect(mod(i32, -14, 12) == 10);	52	try expect(mod(i32, -14, 12) == 10);
53	expect(mod(i32, -2, 12) == 10);	53	try expect(mod(i32, -2, 12) == 10);
54		54
55	comptime {	55	comptime {
56	expect(	56	try expect(
57	1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600,	57	1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600,
58	);	58	);
59	expect(	59	try expect(
60	@rem(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -177254337427586449086438229241342047632117600,	60	@rem(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -177254337427586449086438229241342047632117600,
61	);	61	);
62	expect(	62	try expect(
63	1194735857077236777412821811143690633098347576 / 508740759824825164163191790951174292733114988 == 2,	63	1194735857077236777412821811143690633098347576 / 508740759824825164163191790951174292733114988 == 2,
64	);	64	);
65	expect(	65	try expect(
66	@divTrunc(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -2,	66	@divTrunc(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -2,
67	);	67	);
68	expect(	68	try expect(
69	@divTrunc(1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == -2,	69	@divTrunc(1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == -2,
70	);	70	);
71	expect(	71	try expect(
72	@divTrunc(-1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == 2,	72	@divTrunc(-1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == 2,
73	);	73	);
74	expect(	74	try expect(
75	4126227191251978491697987544882340798050766755606969681711 % 10 == 1,	75	4126227191251978491697987544882340798050766755606969681711 % 10 == 1,
76	);	76	);
77	}	77	}
...	@@ -94,9 +94,9 @@ fn mod(comptime T: type, a: T, b: T) T {	...	@@ -94,9 +94,9 @@ fn mod(comptime T: type, a: T, b: T) T {
94		94
95	test "@addWithOverflow" {	95	test "@addWithOverflow" {
96	var result: u8 = undefined;	96	var result: u8 = undefined;
97	expect(@addWithOverflow(u8, 250, 100, &result));	97	try expect(@addWithOverflow(u8, 250, 100, &result));
98	expect(!@addWithOverflow(u8, 100, 150, &result));	98	try expect(!@addWithOverflow(u8, 100, 150, &result));
99	expect(result == 250);	99	try expect(result == 250);
100	}	100	}
101		101
102	// TODO test mulWithOverflow	102	// TODO test mulWithOverflow
...	@@ -104,31 +104,31 @@ test "@addWithOverflow" {	...	@@ -104,31 +104,31 @@ test "@addWithOverflow" {
104		104
105	test "@shlWithOverflow" {	105	test "@shlWithOverflow" {
106	var result: u16 = undefined;	106	var result: u16 = undefined;
107	expect(@shlWithOverflow(u16, 0b0010111111111111, 3, &result));	107	try expect(@shlWithOverflow(u16, 0b0010111111111111, 3, &result));
108	expect(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result));	108	try expect(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result));
109	expect(result == 0b1011111111111100);	109	try expect(result == 0b1011111111111100);
110	}	110	}
111		111
112	test "@*WithOverflow with u0 values" {	112	test "@*WithOverflow with u0 values" {
113	var result: u0 = undefined;	113	var result: u0 = undefined;
114	expect(!@addWithOverflow(u0, 0, 0, &result));	114	try expect(!@addWithOverflow(u0, 0, 0, &result));
115	expect(!@subWithOverflow(u0, 0, 0, &result));	115	try expect(!@subWithOverflow(u0, 0, 0, &result));
116	expect(!@mulWithOverflow(u0, 0, 0, &result));	116	try expect(!@mulWithOverflow(u0, 0, 0, &result));
117	expect(!@shlWithOverflow(u0, 0, 0, &result));	117	try expect(!@shlWithOverflow(u0, 0, 0, &result));
118	}	118	}
119		119
120	test "@clz" {	120	test "@clz" {
121	testClz();	121	try testClz();
122	comptime testClz();	122	comptime try testClz();
123	}	123	}
124		124
125	fn testClz() void {	125	fn testClz() !void {
126	expect(clz(u8, 0b10001010) == 0);	126	try expect(clz(u8, 0b10001010) == 0);
127	expect(clz(u8, 0b00001010) == 4);	127	try expect(clz(u8, 0b00001010) == 4);
128	expect(clz(u8, 0b00011010) == 3);	128	try expect(clz(u8, 0b00011010) == 3);
129	expect(clz(u8, 0b00000000) == 8);	129	try expect(clz(u8, 0b00000000) == 8);
130	expect(clz(u128, 0xffffffffffffffff) == 64);	130	try expect(clz(u128, 0xffffffffffffffff) == 64);
131	expect(clz(u128, 0x10000000000000000) == 63);	131	try expect(clz(u128, 0x10000000000000000) == 63);
132	}	132	}
133		133
134	fn clz(comptime T: type, x: T) usize {	134	fn clz(comptime T: type, x: T) usize {
...	@@ -136,15 +136,15 @@ fn clz(comptime T: type, x: T) usize {	...	@@ -136,15 +136,15 @@ fn clz(comptime T: type, x: T) usize {
136	}	136	}
137		137
138	test "@ctz" {	138	test "@ctz" {
139	testCtz();	139	try testCtz();
140	comptime testCtz();	140	comptime try testCtz();
141	}	141	}
142		142
143	fn testCtz() void {	143	fn testCtz() !void {
144	expect(ctz(u8, 0b10100000) == 5);	144	try expect(ctz(u8, 0b10100000) == 5);
145	expect(ctz(u8, 0b10001010) == 1);	145	try expect(ctz(u8, 0b10001010) == 1);
146	expect(ctz(u8, 0b00000000) == 8);	146	try expect(ctz(u8, 0b00000000) == 8);
147	expect(ctz(u16, 0b00000000) == 16);	147	try expect(ctz(u16, 0b00000000) == 16);
148	}	148	}
149		149
150	fn ctz(comptime T: type, x: T) usize {	150	fn ctz(comptime T: type, x: T) usize {
...	@@ -154,109 +154,109 @@ fn ctz(comptime T: type, x: T) usize {	...	@@ -154,109 +154,109 @@ fn ctz(comptime T: type, x: T) usize {
154	test "assignment operators" {	154	test "assignment operators" {
155	var i: u32 = 0;	155	var i: u32 = 0;
156	i += 5;	156	i += 5;
157	expect(i == 5);	157	try expect(i == 5);
158	i -= 2;	158	i -= 2;
159	expect(i == 3);	159	try expect(i == 3);
160	i *= 20;	160	i *= 20;
161	expect(i == 60);	161	try expect(i == 60);
162	i /= 3;	162	i /= 3;
163	expect(i == 20);	163	try expect(i == 20);
164	i %= 11;	164	i %= 11;
165	expect(i == 9);	165	try expect(i == 9);
166	i <<= 1;	166	i <<= 1;
167	expect(i == 18);	167	try expect(i == 18);
168	i >>= 2;	168	i >>= 2;
169	expect(i == 4);	169	try expect(i == 4);
170	i = 6;	170	i = 6;
171	i &= 5;	171	i &= 5;
172	expect(i == 4);	172	try expect(i == 4);
173	i ^= 6;	173	i ^= 6;
174	expect(i == 2);	174	try expect(i == 2);
175	i = 6;	175	i = 6;
176	i \|= 3;	176	i \|= 3;
177	expect(i == 7);	177	try expect(i == 7);
178	}	178	}
179		179
180	test "three expr in a row" {	180	test "three expr in a row" {
181	testThreeExprInARow(false, true);	181	try testThreeExprInARow(false, true);
182	comptime testThreeExprInARow(false, true);	182	comptime try testThreeExprInARow(false, true);
183	}	183	}
184	fn testThreeExprInARow(f: bool, t: bool) void {	184	fn testThreeExprInARow(f: bool, t: bool) !void {
185	assertFalse(f or f or f);	185	try assertFalse(f or f or f);
186	assertFalse(t and t and f);	186	try assertFalse(t and t and f);
187	assertFalse(1 \| 2 \| 4 != 7);	187	try assertFalse(1 \| 2 \| 4 != 7);
188	assertFalse(3 ^ 6 ^ 8 != 13);	188	try assertFalse(3 ^ 6 ^ 8 != 13);
189	assertFalse(7 & 14 & 28 != 4);	189	try assertFalse(7 & 14 & 28 != 4);
190	assertFalse(9 << 1 << 2 != 9 << 3);	190	try assertFalse(9 << 1 << 2 != 9 << 3);
191	assertFalse(90 >> 1 >> 2 != 90 >> 3);	191	try assertFalse(90 >> 1 >> 2 != 90 >> 3);
192	assertFalse(100 - 1 + 1000 != 1099);	192	try assertFalse(100 - 1 + 1000 != 1099);
193	assertFalse(5 * 4 / 2 % 3 != 1);	193	try assertFalse(5 * 4 / 2 % 3 != 1);
194	assertFalse(@as(i32, @as(i32, 5)) != 5);	194	try assertFalse(@as(i32, @as(i32, 5)) != 5);
195	assertFalse(!!false);	195	try assertFalse(!!false);
196	assertFalse(@as(i32, 7) != --(@as(i32, 7)));	196	try assertFalse(@as(i32, 7) != --(@as(i32, 7)));
197	}	197	}
198	fn assertFalse(b: bool) void {	198	fn assertFalse(b: bool) !void {
199	expect(!b);	199	try expect(!b);
200	}	200	}
201		201
202	test "const number literal" {	202	test "const number literal" {
203	const one = 1;	203	const one = 1;
204	const eleven = ten + one;	204	const eleven = ten + one;
205		205
206	expect(eleven == 11);	206	try expect(eleven == 11);
207	}	207	}
208	const ten = 10;	208	const ten = 10;
209		209
210	test "unsigned wrapping" {	210	test "unsigned wrapping" {
211	testUnsignedWrappingEval(maxInt(u32));	211	try testUnsignedWrappingEval(maxInt(u32));
212	comptime testUnsignedWrappingEval(maxInt(u32));	212	comptime try testUnsignedWrappingEval(maxInt(u32));
213	}	213	}
214	fn testUnsignedWrappingEval(x: u32) void {	214	fn testUnsignedWrappingEval(x: u32) !void {
215	const zero = x +% 1;	215	const zero = x +% 1;
216	expect(zero == 0);	216	try expect(zero == 0);
217	const orig = zero -% 1;	217	const orig = zero -% 1;
218	expect(orig == maxInt(u32));	218	try expect(orig == maxInt(u32));
219	}	219	}
220		220
221	test "signed wrapping" {	221	test "signed wrapping" {
222	testSignedWrappingEval(maxInt(i32));	222	try testSignedWrappingEval(maxInt(i32));
223	comptime testSignedWrappingEval(maxInt(i32));	223	comptime try testSignedWrappingEval(maxInt(i32));
224	}	224	}
225	fn testSignedWrappingEval(x: i32) void {	225	fn testSignedWrappingEval(x: i32) !void {
226	const min_val = x +% 1;	226	const min_val = x +% 1;
227	expect(min_val == minInt(i32));	227	try expect(min_val == minInt(i32));
228	const max_val = min_val -% 1;	228	const max_val = min_val -% 1;
229	expect(max_val == maxInt(i32));	229	try expect(max_val == maxInt(i32));
230	}	230	}
231		231
232	test "signed negation wrapping" {	232	test "signed negation wrapping" {
233	testSignedNegationWrappingEval(minInt(i16));	233	try testSignedNegationWrappingEval(minInt(i16));
234	comptime testSignedNegationWrappingEval(minInt(i16));	234	comptime try testSignedNegationWrappingEval(minInt(i16));
235	}	235	}
236	fn testSignedNegationWrappingEval(x: i16) void {	236	fn testSignedNegationWrappingEval(x: i16) !void {
237	expect(x == -32768);	237	try expect(x == -32768);
238	const neg = -%x;	238	const neg = -%x;
239	expect(neg == -32768);	239	try expect(neg == -32768);
240	}	240	}
241		241
242	test "unsigned negation wrapping" {	242	test "unsigned negation wrapping" {
243	testUnsignedNegationWrappingEval(1);	243	try testUnsignedNegationWrappingEval(1);
244	comptime testUnsignedNegationWrappingEval(1);	244	comptime try testUnsignedNegationWrappingEval(1);
245	}	245	}
246	fn testUnsignedNegationWrappingEval(x: u16) void {	246	fn testUnsignedNegationWrappingEval(x: u16) !void {
247	expect(x == 1);	247	try expect(x == 1);
248	const neg = -%x;	248	const neg = -%x;
249	expect(neg == maxInt(u16));	249	try expect(neg == maxInt(u16));
250	}	250	}
251		251
252	test "unsigned 64-bit division" {	252	test "unsigned 64-bit division" {
253	test_u64_div();	253	try test_u64_div();
254	comptime test_u64_div();	254	comptime try test_u64_div();
255	}	255	}
256	fn test_u64_div() void {	256	fn test_u64_div() !void {
257	const result = divWithResult(1152921504606846976, 34359738365);	257	const result = divWithResult(1152921504606846976, 34359738365);
258	expect(result.quotient == 33554432);	258	try expect(result.quotient == 33554432);
259	expect(result.remainder == 100663296);	259	try expect(result.remainder == 100663296);
260	}	260	}
261	fn divWithResult(a: u64, b: u64) DivResult {	261	fn divWithResult(a: u64, b: u64) DivResult {
262	return DivResult{	262	return DivResult{
...	@@ -270,62 +270,62 @@ const DivResult = struct {	...	@@ -270,62 +270,62 @@ const DivResult = struct {
270	};	270	};
271		271
272	test "binary not" {	272	test "binary not" {
273	expect(comptime x: {	273	try expect(comptime x: {
274	break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101;	274	break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101;
275	});	275	});
276	expect(comptime x: {	276	try expect(comptime x: {
277	break :x ~@as(u64, 2147483647) == 18446744071562067968;	277	break :x ~@as(u64, 2147483647) == 18446744071562067968;
278	});	278	});
279	testBinaryNot(0b1010101010101010);	279	try testBinaryNot(0b1010101010101010);
280	}	280	}
281		281
282	fn testBinaryNot(x: u16) void {	282	fn testBinaryNot(x: u16) !void {
283	expect(~x == 0b0101010101010101);	283	try expect(~x == 0b0101010101010101);
284	}	284	}
285		285
286	test "small int addition" {	286	test "small int addition" {
287	var x: u2 = 0;	287	var x: u2 = 0;
288	expect(x == 0);	288	try expect(x == 0);
289		289
290	x += 1;	290	x += 1;
291	expect(x == 1);	291	try expect(x == 1);
292		292
293	x += 1;	293	x += 1;
294	expect(x == 2);	294	try expect(x == 2);
295		295
296	x += 1;	296	x += 1;
297	expect(x == 3);	297	try expect(x == 3);
298		298
299	var result: @TypeOf(x) = 3;	299	var result: @TypeOf(x) = 3;
300	expect(@addWithOverflow(@TypeOf(x), x, 1, &result));	300	try expect(@addWithOverflow(@TypeOf(x), x, 1, &result));
301		301
302	expect(result == 0);	302	try expect(result == 0);
303	}	303	}
304		304
305	test "float equality" {	305	test "float equality" {
306	const x: f64 = 0.012;	306	const x: f64 = 0.012;
307	const y: f64 = x + 1.0;	307	const y: f64 = x + 1.0;
308		308
309	testFloatEqualityImpl(x, y);	309	try testFloatEqualityImpl(x, y);
310	comptime testFloatEqualityImpl(x, y);	310	comptime try testFloatEqualityImpl(x, y);
311	}	311	}
312		312
313	fn testFloatEqualityImpl(x: f64, y: f64) void {	313	fn testFloatEqualityImpl(x: f64, y: f64) !void {
314	const y2 = x + 1.0;	314	const y2 = x + 1.0;
315	expect(y == y2);	315	try expect(y == y2);
316	}	316	}
317		317
318	test "allow signed integer division/remainder when values are comptime known and positive or exact" {	318	test "allow signed integer division/remainder when values are comptime known and positive or exact" {
319	expect(5 / 3 == 1);	319	try expect(5 / 3 == 1);
320	expect(-5 / -3 == 1);	320	try expect(-5 / -3 == 1);
321	expect(-6 / 3 == -2);	321	try expect(-6 / 3 == -2);
322		322
323	expect(5 % 3 == 2);	323	try expect(5 % 3 == 2);
324	expect(-6 % 3 == 0);	324	try expect(-6 % 3 == 0);
325	}	325	}
326		326
327	test "hex float literal parsing" {	327	test "hex float literal parsing" {
328	comptime expect(0x1.0 == 1.0);	328	comptime try expect(0x1.0 == 1.0);
329	}	329	}
330		330
331	test "quad hex float literal parsing in range" {	331	test "quad hex float literal parsing in range" {
...	@@ -340,29 +340,29 @@ test "quad hex float literal parsing accurate" {	...	@@ -340,29 +340,29 @@ test "quad hex float literal parsing accurate" {
340		340
341	// implied 1 is dropped, with an exponent of 0 (0x3fff) after biasing.	341	// implied 1 is dropped, with an exponent of 0 (0x3fff) after biasing.
342	const expected: u128 = 0x3fff1111222233334444555566667777;	342	const expected: u128 = 0x3fff1111222233334444555566667777;
343	expect(@bitCast(u128, a) == expected);	343	try expect(@bitCast(u128, a) == expected);
344		344
345	// non-normalized	345	// non-normalized
346	const b: f128 = 0x11.111222233334444555566667777p-4;	346	const b: f128 = 0x11.111222233334444555566667777p-4;
347	expect(@bitCast(u128, b) == expected);	347	try expect(@bitCast(u128, b) == expected);
348		348
349	const S = struct {	349	const S = struct {
350	fn doTheTest() void {	350	fn doTheTest() !void {
351	{	351	{
352	var f: f128 = 0x1.2eab345678439abcdefea56782346p+5;	352	var f: f128 = 0x1.2eab345678439abcdefea56782346p+5;
353	expect(@bitCast(u128, f) == 0x40042eab345678439abcdefea5678234);	353	try expect(@bitCast(u128, f) == 0x40042eab345678439abcdefea5678234);
354	}	354	}
355	{	355	{
356	var f: f128 = 0x1.edcb34a235253948765432134674fp-1;	356	var f: f128 = 0x1.edcb34a235253948765432134674fp-1;
357	expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134674);	357	try expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134674);
358	}	358	}
359	{	359	{
360	var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50;	360	var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50;
361	expect(@bitCast(u128, f) == 0x3fcd353e45674d89abacc3a2ebf3ff50);	361	try expect(@bitCast(u128, f) == 0x3fcd353e45674d89abacc3a2ebf3ff50);
362	}	362	}
363	{	363	{
364	var f: f128 = 0x1.ed8764648369535adf4be3214567fp-9;	364	var f: f128 = 0x1.ed8764648369535adf4be3214567fp-9;
365	expect(@bitCast(u128, f) == 0x3ff6ed8764648369535adf4be3214568);	365	try expect(@bitCast(u128, f) == 0x3ff6ed8764648369535adf4be3214568);
366	}	366	}
367	const exp2ft = [_]f64{	367	const exp2ft = [_]f64{
368	0x1.6a09e667f3bcdp-1,	368	0x1.6a09e667f3bcdp-1,
...	@@ -417,40 +417,40 @@ test "quad hex float literal parsing accurate" {	...	@@ -417,40 +417,40 @@ test "quad hex float literal parsing accurate" {
417	};	417	};
418		418
419	for (exp2ft) \|x, i\| {	419	for (exp2ft) \|x, i\| {
420	expect(@bitCast(u64, x) == answers[i]);	420	try expect(@bitCast(u64, x) == answers[i]);
421	}	421	}
422	}	422	}
423	};	423	};
424	S.doTheTest();	424	try S.doTheTest();
425	comptime S.doTheTest();	425	comptime try S.doTheTest();
426	}	426	}
427		427
428	test "underscore separator parsing" {	428	test "underscore separator parsing" {
429	expect(0_0_0_0 == 0);	429	try expect(0_0_0_0 == 0);
430	expect(1_234_567 == 1234567);	430	try expect(1_234_567 == 1234567);
431	expect(001_234_567 == 1234567);	431	try expect(001_234_567 == 1234567);
432	expect(0_0_1_2_3_4_5_6_7 == 1234567);	432	try expect(0_0_1_2_3_4_5_6_7 == 1234567);
433		433
434	expect(0b0_0_0_0 == 0);	434	try expect(0b0_0_0_0 == 0);
435	expect(0b1010_1010 == 0b10101010);	435	try expect(0b1010_1010 == 0b10101010);
436	expect(0b0000_1010_1010 == 0b10101010);	436	try expect(0b0000_1010_1010 == 0b10101010);
437	expect(0b1_0_1_0_1_0_1_0 == 0b10101010);	437	try expect(0b1_0_1_0_1_0_1_0 == 0b10101010);
438		438
439	expect(0o0_0_0_0 == 0);	439	try expect(0o0_0_0_0 == 0);
440	expect(0o1010_1010 == 0o10101010);	440	try expect(0o1010_1010 == 0o10101010);
441	expect(0o0000_1010_1010 == 0o10101010);	441	try expect(0o0000_1010_1010 == 0o10101010);
442	expect(0o1_0_1_0_1_0_1_0 == 0o10101010);	442	try expect(0o1_0_1_0_1_0_1_0 == 0o10101010);
443		443
444	expect(0x0_0_0_0 == 0);	444	try expect(0x0_0_0_0 == 0);
445	expect(0x1010_1010 == 0x10101010);	445	try expect(0x1010_1010 == 0x10101010);
446	expect(0x0000_1010_1010 == 0x10101010);	446	try expect(0x0000_1010_1010 == 0x10101010);
447	expect(0x1_0_1_0_1_0_1_0 == 0x10101010);	447	try expect(0x1_0_1_0_1_0_1_0 == 0x10101010);
448		448
449	expect(123_456.789_000e1_0 == 123456.789000e10);	449	try expect(123_456.789_000e1_0 == 123456.789000e10);
450	expect(0_1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10);	450	try expect(0_1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10);
451		451
452	expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10);	452	try expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10);
453	expect(0x1_2_3_4_5_6_7_8.9_A_B_C_D_E_F_0p-0_0_0_1_0 == 0x12345678.9ABCDEF0p-10);	453	try expect(0x1_2_3_4_5_6_7_8.9_A_B_C_D_E_F_0p-0_0_0_1_0 == 0x12345678.9ABCDEF0p-10);
454	}	454	}
455		455
456	test "hex float literal within range" {	456	test "hex float literal within range" {
...	@@ -460,73 +460,73 @@ test "hex float literal within range" {	...	@@ -460,73 +460,73 @@ test "hex float literal within range" {
460	}	460	}
461		461
462	test "truncating shift left" {	462	test "truncating shift left" {
463	testShlTrunc(maxInt(u16));	463	try testShlTrunc(maxInt(u16));
464	comptime testShlTrunc(maxInt(u16));	464	comptime try testShlTrunc(maxInt(u16));
465	}	465	}
466	fn testShlTrunc(x: u16) void {	466	fn testShlTrunc(x: u16) !void {
467	const shifted = x << 1;	467	const shifted = x << 1;
468	expect(shifted == 65534);	468	try expect(shifted == 65534);
469	}	469	}
470		470
471	test "truncating shift right" {	471	test "truncating shift right" {
472	testShrTrunc(maxInt(u16));	472	try testShrTrunc(maxInt(u16));
473	comptime testShrTrunc(maxInt(u16));	473	comptime try testShrTrunc(maxInt(u16));
474	}	474	}
475	fn testShrTrunc(x: u16) void {	475	fn testShrTrunc(x: u16) !void {
476	const shifted = x >> 1;	476	const shifted = x >> 1;
477	expect(shifted == 32767);	477	try expect(shifted == 32767);
478	}	478	}
479		479
480	test "exact shift left" {	480	test "exact shift left" {
481	testShlExact(0b00110101);	481	try testShlExact(0b00110101);
482	comptime testShlExact(0b00110101);	482	comptime try testShlExact(0b00110101);
483	}	483	}
484	fn testShlExact(x: u8) void {	484	fn testShlExact(x: u8) !void {
485	const shifted = @shlExact(x, 2);	485	const shifted = @shlExact(x, 2);
486	expect(shifted == 0b11010100);	486	try expect(shifted == 0b11010100);
487	}	487	}
488		488
489	test "exact shift right" {	489	test "exact shift right" {
490	testShrExact(0b10110100);	490	try testShrExact(0b10110100);
491	comptime testShrExact(0b10110100);	491	comptime try testShrExact(0b10110100);
492	}	492	}
493	fn testShrExact(x: u8) void {	493	fn testShrExact(x: u8) !void {
494	const shifted = @shrExact(x, 2);	494	const shifted = @shrExact(x, 2);
495	expect(shifted == 0b00101101);	495	try expect(shifted == 0b00101101);
496	}	496	}
497		497
498	test "shift left/right on u0 operand" {	498	test "shift left/right on u0 operand" {
499	const S = struct {	499	const S = struct {
500	fn doTheTest() void {	500	fn doTheTest() !void {
501	var x: u0 = 0;	501	var x: u0 = 0;
502	var y: u0 = 0;	502	var y: u0 = 0;
503	expectEqual(@as(u0, 0), x << 0);	503	try expectEqual(@as(u0, 0), x << 0);
504	expectEqual(@as(u0, 0), x >> 0);	504	try expectEqual(@as(u0, 0), x >> 0);
505	expectEqual(@as(u0, 0), x << y);	505	try expectEqual(@as(u0, 0), x << y);
506	expectEqual(@as(u0, 0), x >> y);	506	try expectEqual(@as(u0, 0), x >> y);
507	expectEqual(@as(u0, 0), @shlExact(x, 0));	507	try expectEqual(@as(u0, 0), @shlExact(x, 0));
508	expectEqual(@as(u0, 0), @shrExact(x, 0));	508	try expectEqual(@as(u0, 0), @shrExact(x, 0));
509	expectEqual(@as(u0, 0), @shlExact(x, y));	509	try expectEqual(@as(u0, 0), @shlExact(x, y));
510	expectEqual(@as(u0, 0), @shrExact(x, y));	510	try expectEqual(@as(u0, 0), @shrExact(x, y));
511	}	511	}
512	};	512	};
513	S.doTheTest();	513	try S.doTheTest();
514	comptime S.doTheTest();	514	comptime try S.doTheTest();
515	}	515	}
516		516
517	test "comptime_int addition" {	517	test "comptime_int addition" {
518	comptime {	518	comptime {
519	expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950);	519	try expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950);
520	expect(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380);	520	try expect(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380);
521	}	521	}
522	}	522	}
523		523
524	test "comptime_int multiplication" {	524	test "comptime_int multiplication" {
525	comptime {	525	comptime {
526	expect(	526	try expect(
527	45960427431263824329884196484953148229 * 128339149605334697009938835852565949723 == 5898522172026096622534201617172456926982464453350084962781392314016180490567,	527	45960427431263824329884196484953148229 * 128339149605334697009938835852565949723 == 5898522172026096622534201617172456926982464453350084962781392314016180490567,
528	);	528	);
529	expect(	529	try expect(
530	594491908217841670578297176641415611445982232488944558774612 * 390603545391089362063884922208143568023166603618446395589768 == 232210647056203049913662402532976186578842425262306016094292237500303028346593132411865381225871291702600263463125370016,	530	594491908217841670578297176641415611445982232488944558774612 * 390603545391089362063884922208143568023166603618446395589768 == 232210647056203049913662402532976186578842425262306016094292237500303028346593132411865381225871291702600263463125370016,
531	);	531	);
532	}	532	}
...	@@ -534,7 +534,7 @@ test "comptime_int multiplication" {	...	@@ -534,7 +534,7 @@ test "comptime_int multiplication" {
534		534
535	test "comptime_int shifting" {	535	test "comptime_int shifting" {
536	comptime {	536	comptime {
537	expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000);	537	try expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000);
538	}	538	}
539	}	539	}
540		540
...	@@ -542,16 +542,16 @@ test "comptime_int multi-limb shift and mask" {	...	@@ -542,16 +542,16 @@ test "comptime_int multi-limb shift and mask" {
542	comptime {	542	comptime {
543	var a = 0xefffffffa0000001eeeeeeefaaaaaaab;	543	var a = 0xefffffffa0000001eeeeeeefaaaaaaab;
544		544
545	expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab);	545	try expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab);
546	a >>= 32;	546	a >>= 32;
547	expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef);	547	try expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef);
548	a >>= 32;	548	a >>= 32;
549	expect(@as(u32, a & 0xffffffff) == 0xa0000001);	549	try expect(@as(u32, a & 0xffffffff) == 0xa0000001);
550	a >>= 32;	550	a >>= 32;
551	expect(@as(u32, a & 0xffffffff) == 0xefffffff);	551	try expect(@as(u32, a & 0xffffffff) == 0xefffffff);
552	a >>= 32;	552	a >>= 32;
553		553
554	expect(a == 0);	554	try expect(a == 0);
555	}	555	}
556	}	556	}
557		557
...	@@ -559,227 +559,227 @@ test "comptime_int multi-limb partial shift right" {	...	@@ -559,227 +559,227 @@ test "comptime_int multi-limb partial shift right" {
559	comptime {	559	comptime {
560	var a = 0x1ffffffffeeeeeeee;	560	var a = 0x1ffffffffeeeeeeee;
561	a >>= 16;	561	a >>= 16;
562	expect(a == 0x1ffffffffeeee);	562	try expect(a == 0x1ffffffffeeee);
563	}	563	}
564	}	564	}
565		565
566	test "xor" {	566	test "xor" {
567	test_xor();	567	try test_xor();
568	comptime test_xor();	568	comptime try test_xor();
569	}	569	}
570		570
571	fn test_xor() void {	571	fn test_xor() !void {
572	expect(0xFF ^ 0x00 == 0xFF);	572	try expect(0xFF ^ 0x00 == 0xFF);
573	expect(0xF0 ^ 0x0F == 0xFF);	573	try expect(0xF0 ^ 0x0F == 0xFF);
574	expect(0xFF ^ 0xF0 == 0x0F);	574	try expect(0xFF ^ 0xF0 == 0x0F);
575	expect(0xFF ^ 0x0F == 0xF0);	575	try expect(0xFF ^ 0x0F == 0xF0);
576	expect(0xFF ^ 0xFF == 0x00);	576	try expect(0xFF ^ 0xFF == 0x00);
577	}	577	}
578		578
579	test "comptime_int xor" {	579	test "comptime_int xor" {
580	comptime {	580	comptime {
581	expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);	581	try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
582	expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);	582	try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
583	expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x0000000000000000FFFFFFFFFFFFFFFF);	583	try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x0000000000000000FFFFFFFFFFFFFFFF);
584	expect(0x0000000000000000FFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFF0000000000000000);	584	try expect(0x0000000000000000FFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFF0000000000000000);
585	expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000000000000000000000000000);	585	try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000000000000000000000000000);
586	expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0x00000000FFFFFFFF00000000FFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);	586	try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0x00000000FFFFFFFF00000000FFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
587	expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000FFFFFFFF00000000FFFFFFFF);	587	try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000FFFFFFFF00000000FFFFFFFF);
588	expect(0x00000000FFFFFFFF00000000FFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFF00000000FFFFFFFF00000000);	588	try expect(0x00000000FFFFFFFF00000000FFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFF00000000FFFFFFFF00000000);
589	}	589	}
590	}	590	}
591		591
592	test "f128" {	592	test "f128" {
593	test_f128();	593	try test_f128();
594	comptime test_f128();	594	comptime try test_f128();
595	}	595	}
596		596
597	fn make_f128(x: f128) f128 {	597	fn make_f128(x: f128) f128 {
598	return x;	598	return x;
599	}	599	}
600		600
601	fn test_f128() void {	601	fn test_f128() !void {
602	expect(@sizeOf(f128) == 16);	602	try expect(@sizeOf(f128) == 16);
603	expect(make_f128(1.0) == 1.0);	603	try expect(make_f128(1.0) == 1.0);
604	expect(make_f128(1.0) != 1.1);	604	try expect(make_f128(1.0) != 1.1);
605	expect(make_f128(1.0) > 0.9);	605	try expect(make_f128(1.0) > 0.9);
606	expect(make_f128(1.0) >= 0.9);	606	try expect(make_f128(1.0) >= 0.9);
607	expect(make_f128(1.0) >= 1.0);	607	try expect(make_f128(1.0) >= 1.0);
608	should_not_be_zero(1.0);	608	try should_not_be_zero(1.0);
609	}	609	}
610		610
611	fn should_not_be_zero(x: f128) void {	611	fn should_not_be_zero(x: f128) !void {
612	expect(x != 0.0);	612	try expect(x != 0.0);
613	}	613	}
614		614
615	test "comptime float rem int" {	615	test "comptime float rem int" {
616	comptime {	616	comptime {
617	var x = @as(f32, 1) % 2;	617	var x = @as(f32, 1) % 2;
618	expect(x == 1.0);	618	try expect(x == 1.0);
619	}	619	}
620	}	620	}
621		621
622	test "remainder division" {	622	test "remainder division" {
623	comptime remdiv(f16);	623	comptime try remdiv(f16);
624	comptime remdiv(f32);	624	comptime try remdiv(f32);
625	comptime remdiv(f64);	625	comptime try remdiv(f64);
626	comptime remdiv(f128);	626	comptime try remdiv(f128);
627	remdiv(f16);	627	try remdiv(f16);
628	remdiv(f64);	628	try remdiv(f64);
629	remdiv(f128);	629	try remdiv(f128);
630	}	630	}
631		631
632	fn remdiv(comptime T: type) void {	632	fn remdiv(comptime T: type) !void {
633	expect(@as(T, 1) == @as(T, 1) % @as(T, 2));	633	try expect(@as(T, 1) == @as(T, 1) % @as(T, 2));
634	expect(@as(T, 1) == @as(T, 7) % @as(T, 3));	634	try expect(@as(T, 1) == @as(T, 7) % @as(T, 3));
635	}	635	}
636		636
637	test "@sqrt" {	637	test "@sqrt" {
638	testSqrt(f64, 12.0);	638	try testSqrt(f64, 12.0);
639	comptime testSqrt(f64, 12.0);	639	comptime try testSqrt(f64, 12.0);
640	testSqrt(f32, 13.0);	640	try testSqrt(f32, 13.0);
641	comptime testSqrt(f32, 13.0);	641	comptime try testSqrt(f32, 13.0);
642	testSqrt(f16, 13.0);	642	try testSqrt(f16, 13.0);
643	comptime testSqrt(f16, 13.0);	643	comptime try testSqrt(f16, 13.0);
644		644
645	const x = 14.0;	645	const x = 14.0;
646	const y = x * x;	646	const y = x * x;
647	const z = @sqrt(y);	647	const z = @sqrt(y);
648	comptime expect(z == x);	648	comptime try expect(z == x);
649	}	649	}
650		650
651	fn testSqrt(comptime T: type, x: T) void {	651	fn testSqrt(comptime T: type, x: T) !void {
652	expect(@sqrt(x * x) == x);	652	try expect(@sqrt(x * x) == x);
653	}	653	}
654		654
655	test "@fabs" {	655	test "@fabs" {
656	testFabs(f128, 12.0);	656	try testFabs(f128, 12.0);
657	comptime testFabs(f128, 12.0);	657	comptime try testFabs(f128, 12.0);
658	testFabs(f64, 12.0);	658	try testFabs(f64, 12.0);
659	comptime testFabs(f64, 12.0);	659	comptime try testFabs(f64, 12.0);
660	testFabs(f32, 12.0);	660	try testFabs(f32, 12.0);
661	comptime testFabs(f32, 12.0);	661	comptime try testFabs(f32, 12.0);
662	testFabs(f16, 12.0);	662	try testFabs(f16, 12.0);
663	comptime testFabs(f16, 12.0);	663	comptime try testFabs(f16, 12.0);
664		664
665	const x = 14.0;	665	const x = 14.0;
666	const y = -x;	666	const y = -x;
667	const z = @fabs(y);	667	const z = @fabs(y);
668	comptime expectEqual(x, z);	668	comptime try expectEqual(x, z);
669	}	669	}
670		670
671	fn testFabs(comptime T: type, x: T) void {	671	fn testFabs(comptime T: type, x: T) !void {
672	const y = -x;	672	const y = -x;
673	const z = @fabs(y);	673	const z = @fabs(y);
674	expectEqual(x, z);	674	try expectEqual(x, z);
675	}	675	}
676		676
677	test "@floor" {	677	test "@floor" {
678	// FIXME: Generates a floorl function call	678	// FIXME: Generates a floorl function call
679	// testFloor(f128, 12.0);	679	// testFloor(f128, 12.0);
680	comptime testFloor(f128, 12.0);	680	comptime try testFloor(f128, 12.0);
681	testFloor(f64, 12.0);	681	try testFloor(f64, 12.0);
682	comptime testFloor(f64, 12.0);	682	comptime try testFloor(f64, 12.0);
683	testFloor(f32, 12.0);	683	try testFloor(f32, 12.0);
684	comptime testFloor(f32, 12.0);	684	comptime try testFloor(f32, 12.0);
685	testFloor(f16, 12.0);	685	try testFloor(f16, 12.0);
686	comptime testFloor(f16, 12.0);	686	comptime try testFloor(f16, 12.0);
687		687
688	const x = 14.0;	688	const x = 14.0;
689	const y = x + 0.7;	689	const y = x + 0.7;
690	const z = @floor(y);	690	const z = @floor(y);
691	comptime expectEqual(x, z);	691	comptime try expectEqual(x, z);
692	}	692	}
693		693
694	fn testFloor(comptime T: type, x: T) void {	694	fn testFloor(comptime T: type, x: T) !void {
695	const y = x + 0.6;	695	const y = x + 0.6;
696	const z = @floor(y);	696	const z = @floor(y);
697	expectEqual(x, z);	697	try expectEqual(x, z);
698	}	698	}
699		699
700	test "@ceil" {	700	test "@ceil" {
701	// FIXME: Generates a ceill function call	701	// FIXME: Generates a ceill function call
702	//testCeil(f128, 12.0);	702	//testCeil(f128, 12.0);
703	comptime testCeil(f128, 12.0);	703	comptime try testCeil(f128, 12.0);
704	testCeil(f64, 12.0);	704	try testCeil(f64, 12.0);
705	comptime testCeil(f64, 12.0);	705	comptime try testCeil(f64, 12.0);
706	testCeil(f32, 12.0);	706	try testCeil(f32, 12.0);
707	comptime testCeil(f32, 12.0);	707	comptime try testCeil(f32, 12.0);
708	testCeil(f16, 12.0);	708	try testCeil(f16, 12.0);
709	comptime testCeil(f16, 12.0);	709	comptime try testCeil(f16, 12.0);
710		710
711	const x = 14.0;	711	const x = 14.0;
712	const y = x - 0.7;	712	const y = x - 0.7;
713	const z = @ceil(y);	713	const z = @ceil(y);
714	comptime expectEqual(x, z);	714	comptime try expectEqual(x, z);
715	}	715	}
716		716
717	fn testCeil(comptime T: type, x: T) void {	717	fn testCeil(comptime T: type, x: T) !void {
718	const y = x - 0.8;	718	const y = x - 0.8;
719	const z = @ceil(y);	719	const z = @ceil(y);
720	expectEqual(x, z);	720	try expectEqual(x, z);
721	}	721	}
722		722
723	test "@trunc" {	723	test "@trunc" {
724	// FIXME: Generates a truncl function call	724	// FIXME: Generates a truncl function call
725	//testTrunc(f128, 12.0);	725	//testTrunc(f128, 12.0);
726	comptime testTrunc(f128, 12.0);	726	comptime try testTrunc(f128, 12.0);
727	testTrunc(f64, 12.0);	727	try testTrunc(f64, 12.0);
728	comptime testTrunc(f64, 12.0);	728	comptime try testTrunc(f64, 12.0);
729	testTrunc(f32, 12.0);	729	try testTrunc(f32, 12.0);
730	comptime testTrunc(f32, 12.0);	730	comptime try testTrunc(f32, 12.0);
731	testTrunc(f16, 12.0);	731	try testTrunc(f16, 12.0);
732	comptime testTrunc(f16, 12.0);	732	comptime try testTrunc(f16, 12.0);
733		733
734	const x = 14.0;	734	const x = 14.0;
735	const y = x + 0.7;	735	const y = x + 0.7;
736	const z = @trunc(y);	736	const z = @trunc(y);
737	comptime expectEqual(x, z);	737	comptime try expectEqual(x, z);
738	}	738	}
739		739
740	fn testTrunc(comptime T: type, x: T) void {	740	fn testTrunc(comptime T: type, x: T) !void {
741	{	741	{
742	const y = x + 0.8;	742	const y = x + 0.8;
743	const z = @trunc(y);	743	const z = @trunc(y);
744	expectEqual(x, z);	744	try expectEqual(x, z);
745	}	745	}
746		746
747	{	747	{
748	const y = -x - 0.8;	748	const y = -x - 0.8;
749	const z = @trunc(y);	749	const z = @trunc(y);
750	expectEqual(-x, z);	750	try expectEqual(-x, z);
751	}	751	}
752	}	752	}
753		753
754	test "@round" {	754	test "@round" {
755	// FIXME: Generates a roundl function call	755	// FIXME: Generates a roundl function call
756	//testRound(f128, 12.0);	756	//testRound(f128, 12.0);
757	comptime testRound(f128, 12.0);	757	comptime try testRound(f128, 12.0);
758	testRound(f64, 12.0);	758	try testRound(f64, 12.0);
759	comptime testRound(f64, 12.0);	759	comptime try testRound(f64, 12.0);
760	testRound(f32, 12.0);	760	try testRound(f32, 12.0);
761	comptime testRound(f32, 12.0);	761	comptime try testRound(f32, 12.0);
762	testRound(f16, 12.0);	762	try testRound(f16, 12.0);
763	comptime testRound(f16, 12.0);	763	comptime try testRound(f16, 12.0);
764		764
765	const x = 14.0;	765	const x = 14.0;
766	const y = x + 0.4;	766	const y = x + 0.4;
767	const z = @round(y);	767	const z = @round(y);
768	comptime expectEqual(x, z);	768	comptime try expectEqual(x, z);
769	}	769	}
770		770
771	fn testRound(comptime T: type, x: T) void {	771	fn testRound(comptime T: type, x: T) !void {
772	const y = x - 0.5;	772	const y = x - 0.5;
773	const z = @round(y);	773	const z = @round(y);
774	expectEqual(x, z);	774	try expectEqual(x, z);
775	}	775	}
776		776
777	test "comptime_int param and return" {	777	test "comptime_int param and return" {
778	const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702);	778	const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702);
779	expect(a == 137114567242441932203689521744947848950);	779	try expect(a == 137114567242441932203689521744947848950);
780		780
781	const b = comptimeAdd(594491908217841670578297176641415611445982232488944558774612, 390603545391089362063884922208143568023166603618446395589768);	781	const b = comptimeAdd(594491908217841670578297176641415611445982232488944558774612, 390603545391089362063884922208143568023166603618446395589768);
782	expect(b == 985095453608931032642182098849559179469148836107390954364380);	782	try expect(b == 985095453608931032642182098849559179469148836107390954364380);
783	}	783	}
784		784
785	fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int {	785	fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int {
...	@@ -788,85 +788,85 @@ fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int	...	@@ -788,85 +788,85 @@ fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int
788		788
789	test "vector integer addition" {	789	test "vector integer addition" {
790	const S = struct {	790	const S = struct {
791	fn doTheTest() void {	791	fn doTheTest() !void {
792	var a: std.meta.Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };	792	var a: std.meta.Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
793	var b: std.meta.Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };	793	var b: std.meta.Vector(4, i32) = [_]i32{ 5, 6, 7, 8 };
794	var result = a + b;	794	var result = a + b;
795	var result_array: [4]i32 = result;	795	var result_array: [4]i32 = result;
796	const expected = [_]i32{ 6, 8, 10, 12 };	796	const expected = [_]i32{ 6, 8, 10, 12 };
797	expectEqualSlices(i32, &expected, &result_array);	797	try expectEqualSlices(i32, &expected, &result_array);
798	}	798	}
799	};	799	};
800	S.doTheTest();	800	try S.doTheTest();
801	comptime S.doTheTest();	801	comptime try S.doTheTest();
802	}	802	}
803		803
804	test "NaN comparison" {	804	test "NaN comparison" {
805	testNanEqNan(f16);	805	try testNanEqNan(f16);
806	testNanEqNan(f32);	806	try testNanEqNan(f32);
807	testNanEqNan(f64);	807	try testNanEqNan(f64);
808	testNanEqNan(f128);	808	try testNanEqNan(f128);
809	comptime testNanEqNan(f16);	809	comptime try testNanEqNan(f16);
810	comptime testNanEqNan(f32);	810	comptime try testNanEqNan(f32);
811	comptime testNanEqNan(f64);	811	comptime try testNanEqNan(f64);
812	comptime testNanEqNan(f128);	812	comptime try testNanEqNan(f128);
813	}	813	}
814		814
815	fn testNanEqNan(comptime F: type) void {	815	fn testNanEqNan(comptime F: type) !void {
816	var nan1 = std.math.nan(F);	816	var nan1 = std.math.nan(F);
817	var nan2 = std.math.nan(F);	817	var nan2 = std.math.nan(F);
818	expect(nan1 != nan2);	818	try expect(nan1 != nan2);
819	expect(!(nan1 == nan2));	819	try expect(!(nan1 == nan2));
820	expect(!(nan1 > nan2));	820	try expect(!(nan1 > nan2));
821	expect(!(nan1 >= nan2));	821	try expect(!(nan1 >= nan2));
822	expect(!(nan1 < nan2));	822	try expect(!(nan1 < nan2));
823	expect(!(nan1 <= nan2));	823	try expect(!(nan1 <= nan2));
824	}	824	}
825		825
826	test "128-bit multiplication" {	826	test "128-bit multiplication" {
827	var a: i128 = 3;	827	var a: i128 = 3;
828	var b: i128 = 2;	828	var b: i128 = 2;
829	var c = a * b;	829	var c = a * b;
830	expect(c == 6);	830	try expect(c == 6);
831	}	831	}
832		832
833	test "vector comparison" {	833	test "vector comparison" {
834	const S = struct {	834	const S = struct {
835	fn doTheTest() void {	835	fn doTheTest() !void {
836	var a: std.meta.Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };	836	var a: std.meta.Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 };
837	var b: std.meta.Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };	837	var b: std.meta.Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 };
838	expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false }));	838	try expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false }));
839	expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false }));	839	try expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false }));
840	expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false }));	840	try expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false }));
841	expect(mem.eql(bool, &@as([6]bool, a != b), &[_]bool{ true, false, true, true, true, true }));	841	try expect(mem.eql(bool, &@as([6]bool, a != b), &[_]bool{ true, false, true, true, true, true }));
842	expect(mem.eql(bool, &@as([6]bool, a > b), &[_]bool{ true, false, false, false, false, true }));	842	try expect(mem.eql(bool, &@as([6]bool, a > b), &[_]bool{ true, false, false, false, false, true }));
843	expect(mem.eql(bool, &@as([6]bool, a >= b), &[_]bool{ true, true, false, false, false, true }));	843	try expect(mem.eql(bool, &@as([6]bool, a >= b), &[_]bool{ true, true, false, false, false, true }));
844	}	844	}
845	};	845	};
846	S.doTheTest();	846	try S.doTheTest();
847	comptime S.doTheTest();	847	comptime try S.doTheTest();
848	}	848	}
849		849
850	test "compare undefined literal with comptime_int" {	850	test "compare undefined literal with comptime_int" {
851	var x = undefined == 1;	851	var x = undefined == 1;
852	// x is now undefined with type bool	852	// x is now undefined with type bool
853	x = true;	853	x = true;
854	expect(x);	854	try expect(x);
855	}	855	}
856		856
857	test "signed zeros are represented properly" {	857	test "signed zeros are represented properly" {
858	const S = struct {	858	const S = struct {
859	fn doTheTest() void {	859	fn doTheTest() !void {
860	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {	860	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
861	const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);	861	const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
862	var as_fp_val = -@as(T, 0.0);	862	var as_fp_val = -@as(T, 0.0);
863	var as_uint_val = @bitCast(ST, as_fp_val);	863	var as_uint_val = @bitCast(ST, as_fp_val);
864	// Ensure the sign bit is set.	864	// Ensure the sign bit is set.
865	expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);	865	try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
866	}	866	}
867	}	867	}
868	};	868	};
869		869
870	S.doTheTest();	870	try S.doTheTest();
871	comptime S.doTheTest();	871	comptime try S.doTheTest();
872	}	872	}

test/stage1/behavior/misc.zig+107-107

...	@@ -25,18 +25,18 @@ test "call disabled extern fn" {	...	@@ -25,18 +25,18 @@ test "call disabled extern fn" {
25	}	25	}
26		26
27	test "short circuit" {	27	test "short circuit" {
28	testShortCircuit(false, true);	28	try testShortCircuit(false, true);
29	comptime testShortCircuit(false, true);	29	comptime try testShortCircuit(false, true);
30	}	30	}
31		31
32	fn testShortCircuit(f: bool, t: bool) void {	32	fn testShortCircuit(f: bool, t: bool) !void {
33	var hit_1 = f;	33	var hit_1 = f;
34	var hit_2 = f;	34	var hit_2 = f;
35	var hit_3 = f;	35	var hit_3 = f;
36	var hit_4 = f;	36	var hit_4 = f;
37		37
38	if (t or x: {	38	if (t or x: {
39	expect(f);	39	try expect(f);
40	break :x f;	40	break :x f;
41	}) {	41	}) {
42	hit_1 = t;	42	hit_1 = t;
...	@@ -45,31 +45,31 @@ fn testShortCircuit(f: bool, t: bool) void {	...	@@ -45,31 +45,31 @@ fn testShortCircuit(f: bool, t: bool) void {
45	hit_2 = t;	45	hit_2 = t;
46	break :x f;	46	break :x f;
47	}) {	47	}) {
48	expect(f);	48	try expect(f);
49	}	49	}
50		50
51	if (t and x: {	51	if (t and x: {
52	hit_3 = t;	52	hit_3 = t;
53	break :x f;	53	break :x f;
54	}) {	54	}) {
55	expect(f);	55	try expect(f);
56	}	56	}
57	if (f and x: {	57	if (f and x: {
58	expect(f);	58	try expect(f);
59	break :x f;	59	break :x f;
60	}) {	60	}) {
61	expect(f);	61	try expect(f);
62	} else {	62	} else {
63	hit_4 = t;	63	hit_4 = t;
64	}	64	}
65	expect(hit_1);	65	try expect(hit_1);
66	expect(hit_2);	66	try expect(hit_2);
67	expect(hit_3);	67	try expect(hit_3);
68	expect(hit_4);	68	try expect(hit_4);
69	}	69	}
70		70
71	test "truncate" {	71	test "truncate" {
72	expect(testTruncate(0x10fd) == 0xfd);	72	try expect(testTruncate(0x10fd) == 0xfd);
73	}	73	}
74	fn testTruncate(x: u32) u8 {	74	fn testTruncate(x: u32) u8 {
75	return @truncate(u8, x);	75	return @truncate(u8, x);
...	@@ -80,16 +80,16 @@ fn first4KeysOfHomeRow() []const u8 {	...	@@ -80,16 +80,16 @@ fn first4KeysOfHomeRow() []const u8 {
80	}	80	}
81		81
82	test "return string from function" {	82	test "return string from function" {
83	expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));	83	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
84	}	84	}
85		85
86	const g1: i32 = 1233 + 1;	86	const g1: i32 = 1233 + 1;
87	var g2: i32 = 0;	87	var g2: i32 = 0;
88		88
89	test "global variables" {	89	test "global variables" {
90	expect(g2 == 0);	90	try expect(g2 == 0);
91	g2 = g1;	91	g2 = g1;
92	expect(g2 == 1234);	92	try expect(g2 == 1234);
93	}	93	}
94		94
95	test "memcpy and memset intrinsics" {	95	test "memcpy and memset intrinsics" {
...	@@ -106,7 +106,7 @@ test "builtin static eval" {	...	@@ -106,7 +106,7 @@ test "builtin static eval" {
106	const x: i32 = comptime x: {	106	const x: i32 = comptime x: {
107	break :x 1 + 2 + 3;	107	break :x 1 + 2 + 3;
108	};	108	};
109	expect(x == comptime 6);	109	try expect(x == comptime 6);
110	}	110	}
111		111
112	test "slicing" {	112	test "slicing" {
...	@@ -127,7 +127,7 @@ test "slicing" {	...	@@ -127,7 +127,7 @@ test "slicing" {
127		127
128	test "constant equal function pointers" {	128	test "constant equal function pointers" {
129	const alias = emptyFn;	129	const alias = emptyFn;
130	expect(comptime x: {	130	try expect(comptime x: {
131	break :x emptyFn == alias;	131	break :x emptyFn == alias;
132	});	132	});
133	}	133	}
...	@@ -135,25 +135,25 @@ test "constant equal function pointers" {	...	@@ -135,25 +135,25 @@ test "constant equal function pointers" {
135	fn emptyFn() void {}	135	fn emptyFn() void {}
136		136
137	test "hex escape" {	137	test "hex escape" {
138	expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));	138	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
139	}	139	}
140		140
141	test "string concatenation" {	141	test "string concatenation" {
142	expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));	142	try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
143	}	143	}
144		144
145	test "array mult operator" {	145	test "array mult operator" {
146	expect(mem.eql(u8, "ab" ** 5, "ababababab"));	146	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
147	}	147	}
148		148
149	test "string escapes" {	149	test "string escapes" {
150	expect(mem.eql(u8, "\"", "\x22"));	150	try expect(mem.eql(u8, "\"", "\x22"));
151	expect(mem.eql(u8, "\'", "\x27"));	151	try expect(mem.eql(u8, "\'", "\x27"));
152	expect(mem.eql(u8, "\n", "\x0a"));	152	try expect(mem.eql(u8, "\n", "\x0a"));
153	expect(mem.eql(u8, "\r", "\x0d"));	153	try expect(mem.eql(u8, "\r", "\x0d"));
154	expect(mem.eql(u8, "\t", "\x09"));	154	try expect(mem.eql(u8, "\t", "\x09"));
155	expect(mem.eql(u8, "\\", "\x5c"));	155	try expect(mem.eql(u8, "\\", "\x5c"));
156	expect(mem.eql(u8, "\u{1234}\u{069}\u{1}", "\xe1\x88\xb4\x69\x01"));	156	try expect(mem.eql(u8, "\u{1234}\u{069}\u{1}", "\xe1\x88\xb4\x69\x01"));
157	}	157	}
158		158
159	test "multiline string" {	159	test "multiline string" {
...	@@ -163,7 +163,7 @@ test "multiline string" {	...	@@ -163,7 +163,7 @@ test "multiline string" {
163	\\three	163	\\three
164	;	164	;
165	const s2 = "one\ntwo)\nthree";	165	const s2 = "one\ntwo)\nthree";
166	expect(mem.eql(u8, s1, s2));	166	try expect(mem.eql(u8, s1, s2));
167	}	167	}
168		168
169	test "multiline string comments at start" {	169	test "multiline string comments at start" {
...	@@ -173,7 +173,7 @@ test "multiline string comments at start" {	...	@@ -173,7 +173,7 @@ test "multiline string comments at start" {
173	\\three	173	\\three
174	;	174	;
175	const s2 = "two)\nthree";	175	const s2 = "two)\nthree";
176	expect(mem.eql(u8, s1, s2));	176	try expect(mem.eql(u8, s1, s2));
177	}	177	}
178		178
179	test "multiline string comments at end" {	179	test "multiline string comments at end" {
...	@@ -183,7 +183,7 @@ test "multiline string comments at end" {	...	@@ -183,7 +183,7 @@ test "multiline string comments at end" {
183	//\\three	183	//\\three
184	;	184	;
185	const s2 = "one\ntwo)";	185	const s2 = "one\ntwo)";
186	expect(mem.eql(u8, s1, s2));	186	try expect(mem.eql(u8, s1, s2));
187	}	187	}
188		188
189	test "multiline string comments in middle" {	189	test "multiline string comments in middle" {
...	@@ -193,7 +193,7 @@ test "multiline string comments in middle" {	...	@@ -193,7 +193,7 @@ test "multiline string comments in middle" {
193	\\three	193	\\three
194	;	194	;
195	const s2 = "one\nthree";	195	const s2 = "one\nthree";
196	expect(mem.eql(u8, s1, s2));	196	try expect(mem.eql(u8, s1, s2));
197	}	197	}
198		198
199	test "multiline string comments at multiple places" {	199	test "multiline string comments at multiple places" {
...	@@ -205,7 +205,7 @@ test "multiline string comments at multiple places" {	...	@@ -205,7 +205,7 @@ test "multiline string comments at multiple places" {
205	\\five	205	\\five
206	;	206	;
207	const s2 = "one\nthree\nfive";	207	const s2 = "one\nthree\nfive";
208	expect(mem.eql(u8, s1, s2));	208	try expect(mem.eql(u8, s1, s2));
209	}	209	}
210		210
211	test "multiline C string" {	211	test "multiline C string" {
...	@@ -215,11 +215,11 @@ test "multiline C string" {	...	@@ -215,11 +215,11 @@ test "multiline C string" {
215	\\three	215	\\three
216	;	216	;
217	const s2 = "one\ntwo)\nthree";	217	const s2 = "one\ntwo)\nthree";
218	expect(std.cstr.cmp(s1, s2) == 0);	218	try expect(std.cstr.cmp(s1, s2) == 0);
219	}	219	}
220		220
221	test "type equality" {	221	test "type equality" {
222	expect(const u8 != u8);	222	try expect(const u8 != u8);
223	}	223	}
224		224
225	const global_a: i32 = 1234;	225	const global_a: i32 = 1234;
...	@@ -227,7 +227,7 @@ const global_b: *const i32 = &global_a;	...	@@ -227,7 +227,7 @@ const global_b: *const i32 = &global_a;
227	const global_c: const f32 = @ptrCast(const f32, global_b);	227	const global_c: const f32 = @ptrCast(const f32, global_b);
228	test "compile time global reinterpret" {	228	test "compile time global reinterpret" {
229	const d = @ptrCast(*const i32, global_c);	229	const d = @ptrCast(*const i32, global_c);
230	expect(d.* == 1234);	230	try expect(d.* == 1234);
231	}	231	}
232		232
233	test "explicit cast maybe pointers" {	233	test "explicit cast maybe pointers" {
...	@@ -253,8 +253,8 @@ test "cast undefined" {	...	@@ -253,8 +253,8 @@ test "cast undefined" {
253	fn testCastUndefined(x: []const u8) void {}	253	fn testCastUndefined(x: []const u8) void {}
254		254
255	test "cast small unsigned to larger signed" {	255	test "cast small unsigned to larger signed" {
256	expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));	256	try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
257	expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));	257	try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
258	}	258	}
259	fn castSmallUnsignedToLargerSigned1(x: u8) i16 {	259	fn castSmallUnsignedToLargerSigned1(x: u8) i16 {
260	return x;	260	return x;
...	@@ -264,7 +264,7 @@ fn castSmallUnsignedToLargerSigned2(x: u16) i64 {	...	@@ -264,7 +264,7 @@ fn castSmallUnsignedToLargerSigned2(x: u16) i64 {
264	}	264	}
265		265
266	test "implicit cast after unreachable" {	266	test "implicit cast after unreachable" {
267	expect(outer() == 1234);	267	try expect(outer() == 1234);
268	}	268	}
269	fn inner() i32 {	269	fn inner() i32 {
270	return 1234;	270	return 1234;
...	@@ -279,13 +279,13 @@ test "pointer dereferencing" {	...	@@ -279,13 +279,13 @@ test "pointer dereferencing" {
279		279
280	y.* += 1;	280	y.* += 1;
281		281
282	expect(x == 4);	282	try expect(x == 4);
283	expect(y.* == 4);	283	try expect(y.* == 4);
284	}	284	}
285		285
286	test "call result of if else expression" {	286	test "call result of if else expression" {
287	expect(mem.eql(u8, f2(true), "a"));	287	try expect(mem.eql(u8, f2(true), "a"));
288	expect(mem.eql(u8, f2(false), "b"));	288	try expect(mem.eql(u8, f2(false), "b"));
289	}	289	}
290	fn f2(x: bool) []const u8 {	290	fn f2(x: bool) []const u8 {
291	return (if (x) fA else fB)();	291	return (if (x) fA else fB)();
...	@@ -305,8 +305,8 @@ test "const expression eval handling of variables" {	...	@@ -305,8 +305,8 @@ test "const expression eval handling of variables" {
305	}	305	}
306		306
307	test "constant enum initialization with differing sizes" {	307	test "constant enum initialization with differing sizes" {
308	test3_1(test3_foo);	308	try test3_1(test3_foo);
309	test3_2(test3_bar);	309	try test3_2(test3_bar);
310	}	310	}
311	const Test3Foo = union(enum) {	311	const Test3Foo = union(enum) {
312	One: void,	312	One: void,
...	@@ -324,41 +324,41 @@ const test3_foo = Test3Foo{	...	@@ -324,41 +324,41 @@ const test3_foo = Test3Foo{
324	},	324	},
325	};	325	};
326	const test3_bar = Test3Foo{ .Two = 13 };	326	const test3_bar = Test3Foo{ .Two = 13 };
327	fn test3_1(f: Test3Foo) void {	327	fn test3_1(f: Test3Foo) !void {
328	switch (f) {	328	switch (f) {
329	Test3Foo.Three => \|pt\| {	329	Test3Foo.Three => \|pt\| {
330	expect(pt.x == 3);	330	try expect(pt.x == 3);
331	expect(pt.y == 4);	331	try expect(pt.y == 4);
332	},	332	},
333	else => unreachable,	333	else => unreachable,
334	}	334	}
335	}	335	}
336	fn test3_2(f: Test3Foo) void {	336	fn test3_2(f: Test3Foo) !void {
337	switch (f) {	337	switch (f) {
338	Test3Foo.Two => \|x\| {	338	Test3Foo.Two => \|x\| {
339	expect(x == 13);	339	try expect(x == 13);
340	},	340	},
341	else => unreachable,	341	else => unreachable,
342	}	342	}
343	}	343	}
344		344
345	test "character literals" {	345	test "character literals" {
346	expect('\'' == single_quote);	346	try expect('\'' == single_quote);
347	}	347	}
348	const single_quote = '\'';	348	const single_quote = '\'';
349		349
350	test "take address of parameter" {	350	test "take address of parameter" {
351	testTakeAddressOfParameter(12.34);	351	try testTakeAddressOfParameter(12.34);
352	}	352	}
353	fn testTakeAddressOfParameter(f: f32) void {	353	fn testTakeAddressOfParameter(f: f32) !void {
354	const f_ptr = &f;	354	const f_ptr = &f;
355	expect(f_ptr.* == 12.34);	355	try expect(f_ptr.* == 12.34);
356	}	356	}
357		357
358	test "pointer comparison" {	358	test "pointer comparison" {
359	const a = @as([]const u8, "a");	359	const a = @as([]const u8, "a");
360	const b = &a;	360	const b = &a;
361	expect(ptrEql(b, b));	361	try expect(ptrEql(b, b));
362	}	362	}
363	fn ptrEql(a: const []const u8, b: const []const u8) bool {	363	fn ptrEql(a: const []const u8, b: const []const u8) bool {
364	return a == b;	364	return a == b;
...	@@ -368,19 +368,19 @@ test "string concatenation" {	...	@@ -368,19 +368,19 @@ test "string concatenation" {
368	const a = "OK" ++ " IT " ++ "WORKED";	368	const a = "OK" ++ " IT " ++ "WORKED";
369	const b = "OK IT WORKED";	369	const b = "OK IT WORKED";
370		370
371	comptime expect(@TypeOf(a) == *const [12:0]u8);	371	comptime try expect(@TypeOf(a) == *const [12:0]u8);
372	comptime expect(@TypeOf(b) == *const [12:0]u8);	372	comptime try expect(@TypeOf(b) == *const [12:0]u8);
373		373
374	const len = mem.len(b);	374	const len = mem.len(b);
375	const len_with_null = len + 1;	375	const len_with_null = len + 1;
376	{	376	{
377	var i: u32 = 0;	377	var i: u32 = 0;
378	while (i < len_with_null) : (i += 1) {	378	while (i < len_with_null) : (i += 1) {
379	expect(a[i] == b[i]);	379	try expect(a[i] == b[i]);
380	}	380	}
381	}	381	}
382	expect(a[len] == 0);	382	try expect(a[len] == 0);
383	expect(b[len] == 0);	383	try expect(b[len] == 0);
384	}	384	}
385		385
386	test "pointer to void return type" {	386	test "pointer to void return type" {
...	@@ -397,7 +397,7 @@ fn testPointerToVoidReturnType2() *const void {	...	@@ -397,7 +397,7 @@ fn testPointerToVoidReturnType2() *const void {
397		397
398	test "non const ptr to aliased type" {	398	test "non const ptr to aliased type" {
399	const int = i32;	399	const int = i32;
400	expect(?int == ?i32);	400	try expect(?int == ?i32);
401	}	401	}
402		402
403	test "array 2D const double ptr" {	403	test "array 2D const double ptr" {
...	@@ -405,13 +405,13 @@ test "array 2D const double ptr" {	...	@@ -405,13 +405,13 @@ test "array 2D const double ptr" {
405	[_]f32{1.0},	405	[_]f32{1.0},
406	[_]f32{2.0},	406	[_]f32{2.0},
407	};	407	};
408	testArray2DConstDoublePtr(&rect_2d_vertexes[0][0]);	408	try testArray2DConstDoublePtr(&rect_2d_vertexes[0][0]);
409	}	409	}
410		410
411	fn testArray2DConstDoublePtr(ptr: *const f32) void {	411	fn testArray2DConstDoublePtr(ptr: *const f32) !void {
412	const ptr2 = @ptrCast([*]const f32, ptr);	412	const ptr2 = @ptrCast([*]const f32, ptr);
413	expect(ptr2[0] == 1.0);	413	try expect(ptr2[0] == 1.0);
414	expect(ptr2[1] == 2.0);	414	try expect(ptr2[1] == 2.0);
415	}	415	}
416		416
417	const AStruct = struct {	417	const AStruct = struct {
...	@@ -439,13 +439,13 @@ test "@typeName" {	...	@@ -439,13 +439,13 @@ test "@typeName" {
439	Unused,	439	Unused,
440	};	440	};
441	comptime {	441	comptime {
442	expect(mem.eql(u8, @typeName(i64), "i64"));	442	try expect(mem.eql(u8, @typeName(i64), "i64"));
443	expect(mem.eql(u8, @typeName(usize), "usize"));	443	try expect(mem.eql(u8, @typeName(usize), "usize"));
444	// https://github.com/ziglang/zig/issues/675	444	// https://github.com/ziglang/zig/issues/675
445	expect(mem.eql(u8, "behavior.misc.TypeFromFn(u8)", @typeName(TypeFromFn(u8))));	445	try expect(mem.eql(u8, "behavior.misc.TypeFromFn(u8)", @typeName(TypeFromFn(u8))));
446	expect(mem.eql(u8, @typeName(Struct), "Struct"));	446	try expect(mem.eql(u8, @typeName(Struct), "Struct"));
447	expect(mem.eql(u8, @typeName(Union), "Union"));	447	try expect(mem.eql(u8, @typeName(Union), "Union"));
448	expect(mem.eql(u8, @typeName(Enum), "Enum"));	448	try expect(mem.eql(u8, @typeName(Enum), "Enum"));
449	}	449	}
450	}	450	}
451		451
...	@@ -455,14 +455,14 @@ fn TypeFromFn(comptime T: type) type {	...	@@ -455,14 +455,14 @@ fn TypeFromFn(comptime T: type) type {
455		455
456	test "double implicit cast in same expression" {	456	test "double implicit cast in same expression" {
457	var x = @as(i32, @as(u16, nine()));	457	var x = @as(i32, @as(u16, nine()));
458	expect(x == 9);	458	try expect(x == 9);
459	}	459	}
460	fn nine() u8 {	460	fn nine() u8 {
461	return 9;	461	return 9;
462	}	462	}
463		463
464	test "global variable initialized to global variable array element" {	464	test "global variable initialized to global variable array element" {
465	expect(global_ptr == &gdt[0]);	465	try expect(global_ptr == &gdt[0]);
466	}	466	}
467	const GDTEntry = struct {	467	const GDTEntry = struct {
468	field: i32,	468	field: i32,
...	@@ -483,9 +483,9 @@ export fn writeToVRam() void {	...	@@ -483,9 +483,9 @@ export fn writeToVRam() void {
483	const OpaqueA = opaque {};	483	const OpaqueA = opaque {};
484	const OpaqueB = opaque {};	484	const OpaqueB = opaque {};
485	test "opaque types" {	485	test "opaque types" {
486	expect(OpaqueA != OpaqueB);	486	try expect(OpaqueA != OpaqueB);
487	expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA"));	487	try expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA"));
488	expect(mem.eql(u8, @typeName(OpaqueB), "OpaqueB"));	488	try expect(mem.eql(u8, @typeName(OpaqueB), "OpaqueB"));
489	}	489	}
490		490
491	test "variable is allowed to be a pointer to an opaque type" {	491	test "variable is allowed to be a pointer to an opaque type" {
...	@@ -525,7 +525,7 @@ fn fnThatClosesOverLocalConst() type {	...	@@ -525,7 +525,7 @@ fn fnThatClosesOverLocalConst() type {
525		525
526	test "function closes over local const" {	526	test "function closes over local const" {
527	const x = fnThatClosesOverLocalConst().g();	527	const x = fnThatClosesOverLocalConst().g();
528	expect(x == 1);	528	try expect(x == 1);
529	}	529	}
530		530
531	test "cold function" {	531	test "cold function" {
...	@@ -562,21 +562,21 @@ export fn testPackedStuff(a: const PackedStruct, b: const PackedUnion, c: Pack	...	@@ -562,21 +562,21 @@ export fn testPackedStuff(a: const PackedStruct, b: const PackedUnion, c: Pack
562	test "slicing zero length array" {	562	test "slicing zero length array" {
563	const s1 = ""[0..];	563	const s1 = ""[0..];
564	const s2 = ([_]u32{})[0..];	564	const s2 = ([_]u32{})[0..];
565	expect(s1.len == 0);	565	try expect(s1.len == 0);
566	expect(s2.len == 0);	566	try expect(s2.len == 0);
567	expect(mem.eql(u8, s1, ""));	567	try expect(mem.eql(u8, s1, ""));
568	expect(mem.eql(u32, s2, &[_]u32{}));	568	try expect(mem.eql(u32, s2, &[_]u32{}));
569	}	569	}
570		570
571	const addr1 = @ptrCast(*const u8, emptyFn);	571	const addr1 = @ptrCast(*const u8, emptyFn);
572	test "comptime cast fn to ptr" {	572	test "comptime cast fn to ptr" {
573	const addr2 = @ptrCast(*const u8, emptyFn);	573	const addr2 = @ptrCast(*const u8, emptyFn);
574	comptime expect(addr1 == addr2);	574	comptime try expect(addr1 == addr2);
575	}	575	}
576		576
577	test "equality compare fn ptrs" {	577	test "equality compare fn ptrs" {
578	var a = emptyFn;	578	var a = emptyFn;
579	expect(a == a);	579	try expect(a == a);
580	}	580	}
581		581
582	test "self reference through fn ptr field" {	582	test "self reference through fn ptr field" {
...	@@ -591,34 +591,34 @@ test "self reference through fn ptr field" {	...	@@ -591,34 +591,34 @@ test "self reference through fn ptr field" {
591	};	591	};
592	var a: S.A = undefined;	592	var a: S.A = undefined;
593	a.f = S.foo;	593	a.f = S.foo;
594	expect(a.f(a) == 12);	594	try expect(a.f(a) == 12);
595	}	595	}
596		596
597	test "volatile load and store" {	597	test "volatile load and store" {
598	var number: i32 = 1234;	598	var number: i32 = 1234;
599	const ptr = @as(*volatile i32, &number);	599	const ptr = @as(*volatile i32, &number);
600	ptr.* += 1;	600	ptr.* += 1;
601	expect(ptr.* == 1235);	601	try expect(ptr.* == 1235);
602	}	602	}
603		603
604	test "slice string literal has correct type" {	604	test "slice string literal has correct type" {
605	comptime {	605	comptime {
606	expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);	606	try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
607	const array = [_]i32{ 1, 2, 3, 4 };	607	const array = [_]i32{ 1, 2, 3, 4 };
608	expect(@TypeOf(array[0..]) == *const [4]i32);	608	try expect(@TypeOf(array[0..]) == *const [4]i32);
609	}	609	}
610	var runtime_zero: usize = 0;	610	var runtime_zero: usize = 0;
611	comptime expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8);	611	comptime try expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8);
612	const array = [_]i32{ 1, 2, 3, 4 };	612	const array = [_]i32{ 1, 2, 3, 4 };
613	comptime expect(@TypeOf(array[runtime_zero..]) == []const i32);	613	comptime try expect(@TypeOf(array[runtime_zero..]) == []const i32);
614	}	614	}
615		615
616	test "struct inside function" {	616	test "struct inside function" {
617	testStructInFn();	617	try testStructInFn();
618	comptime testStructInFn();	618	comptime try testStructInFn();
619	}	619	}
620		620
621	fn testStructInFn() void {	621	fn testStructInFn() !void {
622	const BlockKind = u32;	622	const BlockKind = u32;
623		623
624	const Block = struct {	624	const Block = struct {
...	@@ -629,11 +629,11 @@ fn testStructInFn() void {	...	@@ -629,11 +629,11 @@ fn testStructInFn() void {
629		629
630	block.kind += 1;	630	block.kind += 1;
631		631
632	expect(block.kind == 1235);	632	try expect(block.kind == 1235);
633	}	633	}
634		634
635	test "fn call returning scalar optional in equality expression" {	635	test "fn call returning scalar optional in equality expression" {
636	expect(getNull() == null);	636	try expect(getNull() == null);
637	}	637	}
638		638
639	fn getNull() ?*i32 {	639	fn getNull() ?*i32 {
...	@@ -645,16 +645,16 @@ test "thread local variable" {	...	@@ -645,16 +645,16 @@ test "thread local variable" {
645	threadlocal var t: i32 = 1234;	645	threadlocal var t: i32 = 1234;
646	};	646	};
647	S.t += 1;	647	S.t += 1;
648	expect(S.t == 1235);	648	try expect(S.t == 1235);
649	}	649	}
650		650
651	test "unicode escape in character literal" {	651	test "unicode escape in character literal" {
652	var a: u24 = '\u{01f4a9}';	652	var a: u24 = '\u{01f4a9}';
653	expect(a == 128169);	653	try expect(a == 128169);
654	}	654	}
655		655
656	test "unicode character in character literal" {	656	test "unicode character in character literal" {
657	expect('💩' == 128169);	657	try expect('💩' == 128169);
658	}	658	}
659		659
660	test "result location zero sized array inside struct field implicit cast to slice" {	660	test "result location zero sized array inside struct field implicit cast to slice" {
...	@@ -662,7 +662,7 @@ test "result location zero sized array inside struct field implicit cast to slic	...	@@ -662,7 +662,7 @@ test "result location zero sized array inside struct field implicit cast to slic
662	entries: []u32,	662	entries: []u32,
663	};	663	};
664	var foo = E{ .entries = &[_]u32{} };	664	var foo = E{ .entries = &[_]u32{} };
665	expect(foo.entries.len == 0);	665	try expect(foo.entries.len == 0);
666	}	666	}
667		667
668	var global_foo: *i32 = undefined;	668	var global_foo: *i32 = undefined;
...	@@ -677,7 +677,7 @@ test "global variable assignment with optional unwrapping with var initialized t	...	@@ -677,7 +677,7 @@ test "global variable assignment with optional unwrapping with var initialized t
677	global_foo = S.foo() orelse {	677	global_foo = S.foo() orelse {
678	@panic("bad");	678	@panic("bad");
679	};	679	};
680	expect(global_foo.* == 1234);	680	try expect(global_foo.* == 1234);
681	}	681	}
682		682
683	test "peer result location with typed parent, runtime condition, comptime prongs" {	683	test "peer result location with typed parent, runtime condition, comptime prongs" {
...	@@ -696,8 +696,8 @@ test "peer result location with typed parent, runtime condition, comptime prongs	...	@@ -696,8 +696,8 @@ test "peer result location with typed parent, runtime condition, comptime prongs
696	bleh: i32,	696	bleh: i32,
697	};	697	};
698	};	698	};
699	expect(S.doTheTest(0) == 1234);	699	try expect(S.doTheTest(0) == 1234);
700	expect(S.doTheTest(1) == 1234);	700	try expect(S.doTheTest(1) == 1234);
701	}	701	}
702		702
703	test "nested optional field in struct" {	703	test "nested optional field in struct" {
...	@@ -710,7 +710,7 @@ test "nested optional field in struct" {	...	@@ -710,7 +710,7 @@ test "nested optional field in struct" {
710	var s = S1{	710	var s = S1{
711	.x = S2{ .y = 127 },	711	.x = S2{ .y = 127 },
712	};	712	};
713	expect(s.x.?.y == 127);	713	try expect(s.x.?.y == 127);
714	}	714	}
715		715
716	fn maybe(x: bool) anyerror!?u32 {	716	fn maybe(x: bool) anyerror!?u32 {
...	@@ -722,7 +722,7 @@ fn maybe(x: bool) anyerror!?u32 {	...	@@ -722,7 +722,7 @@ fn maybe(x: bool) anyerror!?u32 {
722		722
723	test "result location is optional inside error union" {	723	test "result location is optional inside error union" {
724	const x = maybe(true) catch unreachable;	724	const x = maybe(true) catch unreachable;
725	expect(x.? == 42);	725	try expect(x.? == 42);
726	}	726	}
727		727
728	threadlocal var buffer: [11]u8 = undefined;	728	threadlocal var buffer: [11]u8 = undefined;
...	@@ -730,7 +730,7 @@ threadlocal var buffer: [11]u8 = undefined;	...	@@ -730,7 +730,7 @@ threadlocal var buffer: [11]u8 = undefined;
730	test "pointer to thread local array" {	730	test "pointer to thread local array" {
731	const s = "Hello world";	731	const s = "Hello world";
732	std.mem.copy(u8, buffer[0..], s);	732	std.mem.copy(u8, buffer[0..], s);
733	std.testing.expectEqualSlices(u8, buffer[0..], s);	733	try std.testing.expectEqualSlices(u8, buffer[0..], s);
734	}	734	}
735		735
736	test "auto created variables have correct alignment" {	736	test "auto created variables have correct alignment" {
...	@@ -742,15 +742,15 @@ test "auto created variables have correct alignment" {	...	@@ -742,15 +742,15 @@ test "auto created variables have correct alignment" {
742	return 0;	742	return 0;
743	}	743	}
744	};	744	};
745	expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);	745	try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
746	comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);	746	comptime try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
747	}	747	}
748		748
749	extern var opaque_extern_var: opaque {};	749	extern var opaque_extern_var: opaque {};
750	var var_to_export: u32 = 42;	750	var var_to_export: u32 = 42;
751	test "extern variable with non-pointer opaque type" {	751	test "extern variable with non-pointer opaque type" {
752	@export(var_to_export, .{ .name = "opaque_extern_var" });	752	@export(var_to_export, .{ .name = "opaque_extern_var" });
753	expect(@ptrCast(align(1) u32, &opaque_extern_var). == 42);	753	try expect(@ptrCast(align(1) u32, &opaque_extern_var). == 42);
754	}	754	}
755		755
756	test "lazy typeInfo value as generic parameter" {	756	test "lazy typeInfo value as generic parameter" {

test/stage1/behavior/muladd.zig+7-7

...	@@ -1,34 +1,34 @@	...	@@ -1,34 +1,34 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "@mulAdd" {	3	test "@mulAdd" {
4	comptime testMulAdd();	4	comptime try testMulAdd();
5	testMulAdd();	5	try testMulAdd();
6	}	6	}
7		7
8	fn testMulAdd() void {	8	fn testMulAdd() !void {
9	{	9	{
10	var a: f16 = 5.5;	10	var a: f16 = 5.5;
11	var b: f16 = 2.5;	11	var b: f16 = 2.5;
12	var c: f16 = 6.25;	12	var c: f16 = 6.25;
13	expect(@mulAdd(f16, a, b, c) == 20);	13	try expect(@mulAdd(f16, a, b, c) == 20);
14	}	14	}
15	{	15	{
16	var a: f32 = 5.5;	16	var a: f32 = 5.5;
17	var b: f32 = 2.5;	17	var b: f32 = 2.5;
18	var c: f32 = 6.25;	18	var c: f32 = 6.25;
19	expect(@mulAdd(f32, a, b, c) == 20);	19	try expect(@mulAdd(f32, a, b, c) == 20);
20	}	20	}
21	{	21	{
22	var a: f64 = 5.5;	22	var a: f64 = 5.5;
23	var b: f64 = 2.5;	23	var b: f64 = 2.5;
24	var c: f64 = 6.25;	24	var c: f64 = 6.25;
25	expect(@mulAdd(f64, a, b, c) == 20);	25	try expect(@mulAdd(f64, a, b, c) == 20);
26	}	26	}
27	// Awaits implementation in libm.zig	27	// Awaits implementation in libm.zig
28	//{	28	//{
29	// var a: f16 = 5.5;	29	// var a: f16 = 5.5;
30	// var b: f128 = 2.5;	30	// var b: f128 = 2.5;
31	// var c: f128 = 6.25;	31	// var c: f128 = 6.25;
32	// expect(@mulAdd(f128, a, b, c) == 20);	32	//try expect(@mulAdd(f128, a, b, c) == 20);
33	//}	33	//}
34	}	34	}

test/stage1/behavior/namespace_depends_on_compile_var.zig+2-2

...	@@ -3,9 +3,9 @@ const expect = std.testing.expect;	...	@@ -3,9 +3,9 @@ const expect = std.testing.expect;
3		3
4	test "namespace depends on compile var" {	4	test "namespace depends on compile var" {
5	if (some_namespace.a_bool) {	5	if (some_namespace.a_bool) {
6	expect(some_namespace.a_bool);	6	try expect(some_namespace.a_bool);
7	} else {	7	} else {
8	expect(!some_namespace.a_bool);	8	try expect(!some_namespace.a_bool);
9	}	9	}
10	}	10	}
11	const some_namespace = switch (std.builtin.os.tag) {	11	const some_namespace = switch (std.builtin.os.tag) {

test/stage1/behavior/null.zig+24-24

...	@@ -17,13 +17,13 @@ test "optional type" {	...	@@ -17,13 +17,13 @@ test "optional type" {
17		17
18	const z = next_x orelse 1234;	18	const z = next_x orelse 1234;
19		19
20	expect(z == 1234);	20	try expect(z == 1234);
21		21
22	const final_x: ?i32 = 13;	22	const final_x: ?i32 = 13;
23		23
24	const num = final_x orelse unreachable;	24	const num = final_x orelse unreachable;
25		25
26	expect(num == 13);	26	try expect(num == 13);
27	}	27	}
28		28
29	test "test maybe object and get a pointer to the inner value" {	29	test "test maybe object and get a pointer to the inner value" {
...	@@ -33,7 +33,7 @@ test "test maybe object and get a pointer to the inner value" {	...	@@ -33,7 +33,7 @@ test "test maybe object and get a pointer to the inner value" {
33	b.* = false;	33	b.* = false;
34	}	34	}
35		35
36	expect(maybe_bool.? == false);	36	try expect(maybe_bool.? == false);
37	}	37	}
38		38
39	test "rhs maybe unwrap return" {	39	test "rhs maybe unwrap return" {
...	@@ -42,14 +42,14 @@ test "rhs maybe unwrap return" {	...	@@ -42,14 +42,14 @@ test "rhs maybe unwrap return" {
42	}	42	}
43		43
44	test "maybe return" {	44	test "maybe return" {
45	maybeReturnImpl();	45	try maybeReturnImpl();
46	comptime maybeReturnImpl();	46	comptime try maybeReturnImpl();
47	}	47	}
48		48
49	fn maybeReturnImpl() void {	49	fn maybeReturnImpl() !void {
50	expect(foo(1235).?);	50	try expect(foo(1235).?);
51	if (foo(null) != null) unreachable;	51	if (foo(null) != null) unreachable;
52	expect(!foo(1234).?);	52	try expect(!foo(1234).?);
53	}	53	}
54		54
55	fn foo(x: ?i32) ?bool {	55	fn foo(x: ?i32) ?bool {
...	@@ -58,7 +58,7 @@ fn foo(x: ?i32) ?bool {	...	@@ -58,7 +58,7 @@ fn foo(x: ?i32) ?bool {
58	}	58	}
59		59
60	test "if var maybe pointer" {	60	test "if var maybe pointer" {
61	expect(shouldBeAPlus1(Particle{	61	try expect(shouldBeAPlus1(Particle{
62	.a = 14,	62	.a = 14,
63	.b = 1,	63	.b = 1,
64	.c = 1,	64	.c = 1,
...	@@ -84,10 +84,10 @@ const Particle = struct {	...	@@ -84,10 +84,10 @@ const Particle = struct {
84		84
85	test "null literal outside function" {	85	test "null literal outside function" {
86	const is_null = here_is_a_null_literal.context == null;	86	const is_null = here_is_a_null_literal.context == null;
87	expect(is_null);	87	try expect(is_null);
88		88
89	const is_non_null = here_is_a_null_literal.context != null;	89	const is_non_null = here_is_a_null_literal.context != null;
90	expect(!is_non_null);	90	try expect(!is_non_null);
91	}	91	}
92	const SillyStruct = struct {	92	const SillyStruct = struct {
93	context: ?i32,	93	context: ?i32,
...	@@ -95,21 +95,21 @@ const SillyStruct = struct {	...	@@ -95,21 +95,21 @@ const SillyStruct = struct {
95	const here_is_a_null_literal = SillyStruct{ .context = null };	95	const here_is_a_null_literal = SillyStruct{ .context = null };
96		96
97	test "test null runtime" {	97	test "test null runtime" {
98	testTestNullRuntime(null);	98	try testTestNullRuntime(null);
99	}	99	}
100	fn testTestNullRuntime(x: ?i32) void {	100	fn testTestNullRuntime(x: ?i32) !void {
101	expect(x == null);	101	try expect(x == null);
102	expect(!(x != null));	102	try expect(!(x != null));
103	}	103	}
104		104
105	test "optional void" {	105	test "optional void" {
106	optionalVoidImpl();	106	try optionalVoidImpl();
107	comptime optionalVoidImpl();	107	comptime try optionalVoidImpl();
108	}	108	}
109		109
110	fn optionalVoidImpl() void {	110	fn optionalVoidImpl() !void {
111	expect(bar(null) == null);	111	try expect(bar(null) == null);
112	expect(bar({}) != null);	112	try expect(bar({}) != null);
113	}	113	}
114		114
115	fn bar(x: ?void) ?void {	115	fn bar(x: ?void) ?void {
...	@@ -133,7 +133,7 @@ test "unwrap optional which is field of global var" {	...	@@ -133,7 +133,7 @@ test "unwrap optional which is field of global var" {
133	}	133	}
134	struct_with_optional.field = 1234;	134	struct_with_optional.field = 1234;
135	if (struct_with_optional.field) \|payload\| {	135	if (struct_with_optional.field) \|payload\| {
136	expect(payload == 1234);	136	try expect(payload == 1234);
137	} else {	137	} else {
138	unreachable;	138	unreachable;
139	}	139	}
...	@@ -141,13 +141,13 @@ test "unwrap optional which is field of global var" {	...	@@ -141,13 +141,13 @@ test "unwrap optional which is field of global var" {
141		141
142	test "null with default unwrap" {	142	test "null with default unwrap" {
143	const x: i32 = null orelse 1;	143	const x: i32 = null orelse 1;
144	expect(x == 1);	144	try expect(x == 1);
145	}	145	}
146		146
147	test "optional types" {	147	test "optional types" {
148	comptime {	148	comptime {
149	const opt_type_struct = StructWithOptionalType{ .t = u8 };	149	const opt_type_struct = StructWithOptionalType{ .t = u8 };
150	expect(opt_type_struct.t != null and opt_type_struct.t.? == u8);	150	try expect(opt_type_struct.t != null and opt_type_struct.t.? == u8);
151	}	151	}
152	}	152	}
153		153
...	@@ -158,5 +158,5 @@ const StructWithOptionalType = struct {	...	@@ -158,5 +158,5 @@ const StructWithOptionalType = struct {
158	test "optional pointer to 0 bit type null value at runtime" {	158	test "optional pointer to 0 bit type null value at runtime" {
159	const EmptyStruct = struct {};	159	const EmptyStruct = struct {};
160	var x: ?*EmptyStruct = null;	160	var x: ?*EmptyStruct = null;
161	expect(x == null);	161	try expect(x == null);
162	}	162	}

test/stage1/behavior/optional.zig+51-51

...	@@ -8,28 +8,28 @@ pub const EmptyStruct = struct {};	...	@@ -8,28 +8,28 @@ pub const EmptyStruct = struct {};
8	test "optional pointer to size zero struct" {	8	test "optional pointer to size zero struct" {
9	var e = EmptyStruct{};	9	var e = EmptyStruct{};
10	var o: ?*EmptyStruct = &e;	10	var o: ?*EmptyStruct = &e;
11	expect(o != null);	11	try expect(o != null);
12	}	12	}
13		13
14	test "equality compare nullable pointers" {	14	test "equality compare nullable pointers" {
15	testNullPtrsEql();	15	try testNullPtrsEql();
16	comptime testNullPtrsEql();	16	comptime try testNullPtrsEql();
17	}	17	}
18		18
19	fn testNullPtrsEql() void {	19	fn testNullPtrsEql() !void {
20	var number: i32 = 1234;	20	var number: i32 = 1234;
21		21
22	var x: ?*i32 = null;	22	var x: ?*i32 = null;
23	var y: ?*i32 = null;	23	var y: ?*i32 = null;
24	expect(x == y);	24	try expect(x == y);
25	y = &number;	25	y = &number;
26	expect(x != y);	26	try expect(x != y);
27	expect(x != &number);	27	try expect(x != &number);
28	expect(&number != x);	28	try expect(&number != x);
29	x = &number;	29	x = &number;
30	expect(x == y);	30	try expect(x == y);
31	expect(x == &number);	31	try expect(x == &number);
32	expect(&number == x);	32	try expect(&number == x);
33	}	33	}
34		34
35	test "address of unwrap optional" {	35	test "address of unwrap optional" {
...	@@ -46,23 +46,23 @@ test "address of unwrap optional" {	...	@@ -46,23 +46,23 @@ test "address of unwrap optional" {
46	};	46	};
47	S.global = S.Foo{ .a = 1234 };	47	S.global = S.Foo{ .a = 1234 };
48	const foo = S.getFoo() catch unreachable;	48	const foo = S.getFoo() catch unreachable;
49	expect(foo.a == 1234);	49	try expect(foo.a == 1234);
50	}	50	}
51		51
52	test "equality compare optional with non-optional" {	52	test "equality compare optional with non-optional" {
53	test_cmp_optional_non_optional();	53	try test_cmp_optional_non_optional();
54	comptime test_cmp_optional_non_optional();	54	comptime try test_cmp_optional_non_optional();
55	}	55	}
56		56
57	fn test_cmp_optional_non_optional() void {	57	fn test_cmp_optional_non_optional() !void {
58	var ten: i32 = 10;	58	var ten: i32 = 10;
59	var opt_ten: ?i32 = 10;	59	var opt_ten: ?i32 = 10;
60	var five: i32 = 5;	60	var five: i32 = 5;
61	var int_n: ?i32 = null;	61	var int_n: ?i32 = null;
62		62
63	expect(int_n != ten);	63	try expect(int_n != ten);
64	expect(opt_ten == ten);	64	try expect(opt_ten == ten);
65	expect(opt_ten != five);	65	try expect(opt_ten != five);
66		66
67	// test evaluation is always lexical	67	// test evaluation is always lexical
68	// ensure that the optional isn't always computed before the non-optional	68	// ensure that the optional isn't always computed before the non-optional
...	@@ -71,14 +71,14 @@ fn test_cmp_optional_non_optional() void {	...	@@ -71,14 +71,14 @@ fn test_cmp_optional_non_optional() void {
71	mutable_state += 1;	71	mutable_state += 1;
72	break :blk1 @as(?f64, 10.0);	72	break :blk1 @as(?f64, 10.0);
73	} != blk2: {	73	} != blk2: {
74	expect(mutable_state == 1);	74	try expect(mutable_state == 1);
75	break :blk2 @as(f64, 5.0);	75	break :blk2 @as(f64, 5.0);
76	};	76	};
77	_ = blk1: {	77	_ = blk1: {
78	mutable_state += 1;	78	mutable_state += 1;
79	break :blk1 @as(f64, 10.0);	79	break :blk1 @as(f64, 10.0);
80	} != blk2: {	80	} != blk2: {
81	expect(mutable_state == 2);	81	try expect(mutable_state == 2);
82	break :blk2 @as(?f64, 5.0);	82	break :blk2 @as(?f64, 5.0);
83	};	83	};
84	}	84	}
...	@@ -94,15 +94,15 @@ test "passing an optional integer as a parameter" {	...	@@ -94,15 +94,15 @@ test "passing an optional integer as a parameter" {
94	return x.? == 1234;	94	return x.? == 1234;
95	}	95	}
96	};	96	};
97	expect(S.entry());	97	try expect(S.entry());
98	comptime expect(S.entry());	98	comptime try expect(S.entry());
99	}	99	}
100		100
101	test "unwrap function call with optional pointer return value" {	101	test "unwrap function call with optional pointer return value" {
102	const S = struct {	102	const S = struct {
103	fn entry() void {	103	fn entry() !void {
104	expect(foo().?.* == 1234);	104	try expect(foo().?.* == 1234);
105	expect(bar() == null);	105	try expect(bar() == null);
106	}	106	}
107	const global: i32 = 1234;	107	const global: i32 = 1234;
108	fn foo() ?*const i32 {	108	fn foo() ?*const i32 {
...	@@ -112,14 +112,14 @@ test "unwrap function call with optional pointer return value" {	...	@@ -112,14 +112,14 @@ test "unwrap function call with optional pointer return value" {
112	return null;	112	return null;
113	}	113	}
114	};	114	};
115	S.entry();	115	try S.entry();
116	comptime S.entry();	116	comptime try S.entry();
117	}	117	}
118		118
119	test "nested orelse" {	119	test "nested orelse" {
120	const S = struct {	120	const S = struct {
121	fn entry() void {	121	fn entry() !void {
122	expect(func() == null);	122	try expect(func() == null);
123	}	123	}
124	fn maybe() ?Foo {	124	fn maybe() ?Foo {
125	return null;	125	return null;
...	@@ -134,8 +134,8 @@ test "nested orelse" {	...	@@ -134,8 +134,8 @@ test "nested orelse" {
134	field: i32,	134	field: i32,
135	};	135	};
136	};	136	};
137	S.entry();	137	try S.entry();
138	comptime S.entry();	138	comptime try S.entry();
139	}	139	}
140		140
141	test "self-referential struct through a slice of optional" {	141	test "self-referential struct through a slice of optional" {
...	@@ -154,7 +154,7 @@ test "self-referential struct through a slice of optional" {	...	@@ -154,7 +154,7 @@ test "self-referential struct through a slice of optional" {
154	};	154	};
155		155
156	var n = S.Node.new();	156	var n = S.Node.new();
157	expect(n.data == null);	157	try expect(n.data == null);
158	}	158	}
159		159
160	test "assigning to an unwrapped optional field in an inline loop" {	160	test "assigning to an unwrapped optional field in an inline loop" {
...	@@ -173,14 +173,14 @@ test "coerce an anon struct literal to optional struct" {	...	@@ -173,14 +173,14 @@ test "coerce an anon struct literal to optional struct" {
173	const Struct = struct {	173	const Struct = struct {
174	field: u32,	174	field: u32,
175	};	175	};
176	export fn doTheTest() void {	176	fn doTheTest() !void {
177	var maybe_dims: ?Struct = null;	177	var maybe_dims: ?Struct = null;
178	maybe_dims = .{ .field = 1 };	178	maybe_dims = .{ .field = 1 };
179	expect(maybe_dims.?.field == 1);	179	try expect(maybe_dims.?.field == 1);
180	}	180	}
181	};	181	};
182	S.doTheTest();	182	try S.doTheTest();
183	comptime S.doTheTest();	183	comptime try S.doTheTest();
184	}	184	}
185		185
186	test "optional with void type" {	186	test "optional with void type" {
...	@@ -188,15 +188,15 @@ test "optional with void type" {	...	@@ -188,15 +188,15 @@ test "optional with void type" {
188	x: ?void,	188	x: ?void,
189	};	189	};
190	var x = Foo{ .x = null };	190	var x = Foo{ .x = null };
191	expect(x.x == null);	191	try expect(x.x == null);
192	}	192	}
193		193
194	test "0-bit child type coerced to optional return ptr result location" {	194	test "0-bit child type coerced to optional return ptr result location" {
195	const S = struct {	195	const S = struct {
196	fn doTheTest() void {	196	fn doTheTest() !void {
197	var y = Foo{};	197	var y = Foo{};
198	var z = y.thing();	198	var z = y.thing();
199	expect(z != null);	199	try expect(z != null);
200	}	200	}
201		201
202	const Foo = struct {	202	const Foo = struct {
...	@@ -209,17 +209,17 @@ test "0-bit child type coerced to optional return ptr result location" {	...	@@ -209,17 +209,17 @@ test "0-bit child type coerced to optional return ptr result location" {
209	}	209	}
210	};	210	};
211	};	211	};
212	S.doTheTest();	212	try S.doTheTest();
213	comptime S.doTheTest();	213	comptime try S.doTheTest();
214	}	214	}
215		215
216	test "0-bit child type coerced to optional" {	216	test "0-bit child type coerced to optional" {
217	const S = struct {	217	const S = struct {
218	fn doTheTest() void {	218	fn doTheTest() !void {
219	var it: Foo = .{	219	var it: Foo = .{
220	.list = undefined,	220	.list = undefined,
221	};	221	};
222	expect(it.foo() != null);	222	try expect(it.foo() != null);
223	}	223	}
224		224
225	const Empty = struct {};	225	const Empty = struct {};
...	@@ -232,8 +232,8 @@ test "0-bit child type coerced to optional" {	...	@@ -232,8 +232,8 @@ test "0-bit child type coerced to optional" {
232	}	232	}
233	};	233	};
234	};	234	};
235	S.doTheTest();	235	try S.doTheTest();
236	comptime S.doTheTest();	236	comptime try S.doTheTest();
237	}	237	}
238		238
239	test "array of optional unaligned types" {	239	test "array of optional unaligned types" {
...	@@ -255,15 +255,15 @@ test "array of optional unaligned types" {	...	@@ -255,15 +255,15 @@ test "array of optional unaligned types" {
255		255
256	// The index must be a runtime value	256	// The index must be a runtime value
257	var i: usize = 0;	257	var i: usize = 0;
258	expectEqual(Enum.one, values[i].?.Num);	258	try expectEqual(Enum.one, values[i].?.Num);
259	i += 1;	259	i += 1;
260	expectEqual(Enum.two, values[i].?.Num);	260	try expectEqual(Enum.two, values[i].?.Num);
261	i += 1;	261	i += 1;
262	expectEqual(Enum.three, values[i].?.Num);	262	try expectEqual(Enum.three, values[i].?.Num);
263	i += 1;	263	i += 1;
264	expectEqual(Enum.one, values[i].?.Num);	264	try expectEqual(Enum.one, values[i].?.Num);
265	i += 1;	265	i += 1;
266	expectEqual(Enum.two, values[i].?.Num);	266	try expectEqual(Enum.two, values[i].?.Num);
267	i += 1;	267	i += 1;
268	expectEqual(Enum.three, values[i].?.Num);	268	try expectEqual(Enum.three, values[i].?.Num);
269	}	269	}

test/stage1/behavior/pointers.zig+108-108

...	@@ -4,15 +4,15 @@ const expect = testing.expect;	...	@@ -4,15 +4,15 @@ const expect = testing.expect;
4	const expectError = testing.expectError;	4	const expectError = testing.expectError;
5		5
6	test "dereference pointer" {	6	test "dereference pointer" {
7	comptime testDerefPtr();	7	comptime try testDerefPtr();
8	testDerefPtr();	8	try testDerefPtr();
9	}	9	}
10		10
11	fn testDerefPtr() void {	11	fn testDerefPtr() !void {
12	var x: i32 = 1234;	12	var x: i32 = 1234;
13	var y = &x;	13	var y = &x;
14	y.* += 1;	14	y.* += 1;
15	expect(x == 1235);	15	try expect(x == 1235);
16	}	16	}
17		17
18	const Foo1 = struct {	18	const Foo1 = struct {
...	@@ -20,41 +20,41 @@ const Foo1 = struct {	...	@@ -20,41 +20,41 @@ const Foo1 = struct {
20	};	20	};
21		21
22	test "dereference pointer again" {	22	test "dereference pointer again" {
23	testDerefPtrOneVal();	23	try testDerefPtrOneVal();
24	comptime testDerefPtrOneVal();	24	comptime try testDerefPtrOneVal();
25	}	25	}
26		26
27	fn testDerefPtrOneVal() void {	27	fn testDerefPtrOneVal() !void {
28	// Foo1 satisfies the OnePossibleValueYes criteria	28	// Foo1 satisfies the OnePossibleValueYes criteria
29	const x = &Foo1{ .x = {} };	29	const x = &Foo1{ .x = {} };
30	const y = x.*;	30	const y = x.*;
31	expect(@TypeOf(y.x) == void);	31	try expect(@TypeOf(y.x) == void);
32	}	32	}
33		33
34	test "pointer arithmetic" {	34	test "pointer arithmetic" {
35	var ptr: [*]const u8 = "abcd";	35	var ptr: [*]const u8 = "abcd";
36		36
37	expect(ptr[0] == 'a');	37	try expect(ptr[0] == 'a');
38	ptr += 1;	38	ptr += 1;
39	expect(ptr[0] == 'b');	39	try expect(ptr[0] == 'b');
40	ptr += 1;	40	ptr += 1;
41	expect(ptr[0] == 'c');	41	try expect(ptr[0] == 'c');
42	ptr += 1;	42	ptr += 1;
43	expect(ptr[0] == 'd');	43	try expect(ptr[0] == 'd');
44	ptr += 1;	44	ptr += 1;
45	expect(ptr[0] == 0);	45	try expect(ptr[0] == 0);
46	ptr -= 1;	46	ptr -= 1;
47	expect(ptr[0] == 'd');	47	try expect(ptr[0] == 'd');
48	ptr -= 1;	48	ptr -= 1;
49	expect(ptr[0] == 'c');	49	try expect(ptr[0] == 'c');
50	ptr -= 1;	50	ptr -= 1;
51	expect(ptr[0] == 'b');	51	try expect(ptr[0] == 'b');
52	ptr -= 1;	52	ptr -= 1;
53	expect(ptr[0] == 'a');	53	try expect(ptr[0] == 'a');
54	}	54	}
55		55
56	test "double pointer parsing" {	56	test "double pointer parsing" {
57	comptime expect(PtrOf(PtrOf(i32)) == **i32);	57	comptime try expect(PtrOf(PtrOf(i32)) == **i32);
58	}	58	}
59		59
60	fn PtrOf(comptime T: type) type {	60	fn PtrOf(comptime T: type) type {
...	@@ -72,33 +72,33 @@ test "implicit cast single item pointer to C pointer and back" {	...	@@ -72,33 +72,33 @@ test "implicit cast single item pointer to C pointer and back" {
72	var x: [*c]u8 = &y;	72	var x: [*c]u8 = &y;
73	var z: *u8 = x;	73	var z: *u8 = x;
74	z.* += 1;	74	z.* += 1;
75	expect(y == 12);	75	try expect(y == 12);
76	}	76	}
77		77
78	test "C pointer comparison and arithmetic" {	78	test "C pointer comparison and arithmetic" {
79	const S = struct {	79	const S = struct {
80	fn doTheTest() void {	80	fn doTheTest() !void {
81	var one: usize = 1;	81	var one: usize = 1;
82	var ptr1: [*c]u32 = 0;	82	var ptr1: [*c]u32 = 0;
83	var ptr2 = ptr1 + 10;	83	var ptr2 = ptr1 + 10;
84	expect(ptr1 == 0);	84	try expect(ptr1 == 0);
85	expect(ptr1 >= 0);	85	try expect(ptr1 >= 0);
86	expect(ptr1 <= 0);	86	try expect(ptr1 <= 0);
87	// expect(ptr1 < 1);	87	// expect(ptr1 < 1);
88	// expect(ptr1 < one);	88	// expect(ptr1 < one);
89	// expect(1 > ptr1);	89	// expect(1 > ptr1);
90	// expect(one > ptr1);	90	// expect(one > ptr1);
91	expect(ptr1 < ptr2);	91	try expect(ptr1 < ptr2);
92	expect(ptr2 > ptr1);	92	try expect(ptr2 > ptr1);
93	expect(ptr2 >= 40);	93	try expect(ptr2 >= 40);
94	expect(ptr2 == 40);	94	try expect(ptr2 == 40);
95	expect(ptr2 <= 40);	95	try expect(ptr2 <= 40);
96	ptr2 -= 10;	96	ptr2 -= 10;
97	expect(ptr1 == ptr2);	97	try expect(ptr1 == ptr2);
98	}	98	}
99	};	99	};
100	S.doTheTest();	100	try S.doTheTest();
101	comptime S.doTheTest();	101	comptime try S.doTheTest();
102	}	102	}
103		103
104	test "peer type resolution with C pointers" {	104	test "peer type resolution with C pointers" {
...	@@ -110,10 +110,10 @@ test "peer type resolution with C pointers" {	...	@@ -110,10 +110,10 @@ test "peer type resolution with C pointers" {
110	var x2 = if (t) ptr_many else ptr_c;	110	var x2 = if (t) ptr_many else ptr_c;
111	var x3 = if (t) ptr_c else ptr_one;	111	var x3 = if (t) ptr_c else ptr_one;
112	var x4 = if (t) ptr_c else ptr_many;	112	var x4 = if (t) ptr_c else ptr_many;
113	expect(@TypeOf(x1) == [*c]u8);	113	try expect(@TypeOf(x1) == [*c]u8);
114	expect(@TypeOf(x2) == [*c]u8);	114	try expect(@TypeOf(x2) == [*c]u8);
115	expect(@TypeOf(x3) == [*c]u8);	115	try expect(@TypeOf(x3) == [*c]u8);
116	expect(@TypeOf(x4) == [*c]u8);	116	try expect(@TypeOf(x4) == [*c]u8);
117	}	117	}
118		118
119	test "implicit casting between C pointer and optional non-C pointer" {	119	test "implicit casting between C pointer and optional non-C pointer" {
...	@@ -121,15 +121,15 @@ test "implicit casting between C pointer and optional non-C pointer" {	...	@@ -121,15 +121,15 @@ test "implicit casting between C pointer and optional non-C pointer" {
121	const opt_many_ptr: ?[*]const u8 = slice.ptr;	121	const opt_many_ptr: ?[*]const u8 = slice.ptr;
122	var ptr_opt_many_ptr = &opt_many_ptr;	122	var ptr_opt_many_ptr = &opt_many_ptr;
123	var c_ptr: [c]const [c]const u8 = ptr_opt_many_ptr;	123	var c_ptr: [c]const [c]const u8 = ptr_opt_many_ptr;
124	expect(c_ptr.. == 'a');	124	try expect(c_ptr.. == 'a');
125	ptr_opt_many_ptr = c_ptr;	125	ptr_opt_many_ptr = c_ptr;
126	expect(ptr_opt_many_ptr.*.?[1] == 'o');	126	try expect(ptr_opt_many_ptr.*.?[1] == 'o');
127	}	127	}
128		128
129	test "implicit cast error unions with non-optional to optional pointer" {	129	test "implicit cast error unions with non-optional to optional pointer" {
130	const S = struct {	130	const S = struct {
131	fn doTheTest() void {	131	fn doTheTest() !void {
132	expectError(error.Fail, foo());	132	try expectError(error.Fail, foo());
133	}	133	}
134	fn foo() anyerror!?*u8 {	134	fn foo() anyerror!?*u8 {
135	return bar() orelse error.Fail;	135	return bar() orelse error.Fail;
...	@@ -138,111 +138,111 @@ test "implicit cast error unions with non-optional to optional pointer" {	...	@@ -138,111 +138,111 @@ test "implicit cast error unions with non-optional to optional pointer" {
138	return null;	138	return null;
139	}	139	}
140	};	140	};
141	S.doTheTest();	141	try S.doTheTest();
142	comptime S.doTheTest();	142	comptime try S.doTheTest();
143	}	143	}
144		144
145	test "initialize const optional C pointer to null" {	145	test "initialize const optional C pointer to null" {
146	const a: ?[*c]i32 = null;	146	const a: ?[*c]i32 = null;
147	expect(a == null);	147	try expect(a == null);
148	comptime expect(a == null);	148	comptime try expect(a == null);
149	}	149	}
150		150
151	test "compare equality of optional and non-optional pointer" {	151	test "compare equality of optional and non-optional pointer" {
152	const a = @intToPtr(*const usize, 0x12345678);	152	const a = @intToPtr(*const usize, 0x12345678);
153	const b = @intToPtr(?*usize, 0x12345678);	153	const b = @intToPtr(?*usize, 0x12345678);
154	expect(a == b);	154	try expect(a == b);
155	expect(b == a);	155	try expect(b == a);
156	}	156	}
157		157
158	test "allowzero pointer and slice" {	158	test "allowzero pointer and slice" {
159	var ptr = @intToPtr([*]allowzero i32, 0);	159	var ptr = @intToPtr([*]allowzero i32, 0);
160	var opt_ptr: ?[*]allowzero i32 = ptr;	160	var opt_ptr: ?[*]allowzero i32 = ptr;
161	expect(opt_ptr != null);	161	try expect(opt_ptr != null);
162	expect(@ptrToInt(ptr) == 0);	162	try expect(@ptrToInt(ptr) == 0);
163	var runtime_zero: usize = 0;	163	var runtime_zero: usize = 0;
164	var slice = ptr[runtime_zero..10];	164	var slice = ptr[runtime_zero..10];
165	comptime expect(@TypeOf(slice) == []allowzero i32);	165	comptime try expect(@TypeOf(slice) == []allowzero i32);
166	expect(@ptrToInt(&slice[5]) == 20);	166	try expect(@ptrToInt(&slice[5]) == 20);
167		167
168	comptime expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero);	168	comptime try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero);
169	comptime expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero);	169	comptime try expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero);
170	}	170	}
171		171
172	test "assign null directly to C pointer and test null equality" {	172	test "assign null directly to C pointer and test null equality" {
173	var x: [*c]i32 = null;	173	var x: [*c]i32 = null;
174	expect(x == null);	174	try expect(x == null);
175	expect(null == x);	175	try expect(null == x);
176	expect(!(x != null));	176	try expect(!(x != null));
177	expect(!(null != x));	177	try expect(!(null != x));
178	if (x) \|same_x\| {	178	if (x) \|same_x\| {
179	@panic("fail");	179	@panic("fail");
180	}	180	}
181	var otherx: i32 = undefined;	181	var otherx: i32 = undefined;
182	expect((x orelse &otherx) == &otherx);	182	try expect((x orelse &otherx) == &otherx);
183		183
184	const y: [*c]i32 = null;	184	const y: [*c]i32 = null;
185	comptime expect(y == null);	185	comptime try expect(y == null);
186	comptime expect(null == y);	186	comptime try expect(null == y);
187	comptime expect(!(y != null));	187	comptime try expect(!(y != null));
188	comptime expect(!(null != y));	188	comptime try expect(!(null != y));
189	if (y) \|same_y\| @panic("fail");	189	if (y) \|same_y\| @panic("fail");
190	const othery: i32 = undefined;	190	const othery: i32 = undefined;
191	comptime expect((y orelse &othery) == &othery);	191	comptime try expect((y orelse &othery) == &othery);
192		192
193	var n: i32 = 1234;	193	var n: i32 = 1234;
194	var x1: [*c]i32 = &n;	194	var x1: [*c]i32 = &n;
195	expect(!(x1 == null));	195	try expect(!(x1 == null));
196	expect(!(null == x1));	196	try expect(!(null == x1));
197	expect(x1 != null);	197	try expect(x1 != null);
198	expect(null != x1);	198	try expect(null != x1);
199	expect(x1.?.* == 1234);	199	try expect(x1.?.* == 1234);
200	if (x1) \|same_x1\| {	200	if (x1) \|same_x1\| {
201	expect(same_x1.* == 1234);	201	try expect(same_x1.* == 1234);
202	} else {	202	} else {
203	@panic("fail");	203	@panic("fail");
204	}	204	}
205	expect((x1 orelse &otherx) == x1);	205	try expect((x1 orelse &otherx) == x1);
206		206
207	const nc: i32 = 1234;	207	const nc: i32 = 1234;
208	const y1: [*c]const i32 = &nc;	208	const y1: [*c]const i32 = &nc;
209	comptime expect(!(y1 == null));	209	comptime try expect(!(y1 == null));
210	comptime expect(!(null == y1));	210	comptime try expect(!(null == y1));
211	comptime expect(y1 != null);	211	comptime try expect(y1 != null);
212	comptime expect(null != y1);	212	comptime try expect(null != y1);
213	comptime expect(y1.?.* == 1234);	213	comptime try expect(y1.?.* == 1234);
214	if (y1) \|same_y1\| {	214	if (y1) \|same_y1\| {
215	expect(same_y1.* == 1234);	215	try expect(same_y1.* == 1234);
216	} else {	216	} else {
217	@compileError("fail");	217	@compileError("fail");
218	}	218	}
219	comptime expect((y1 orelse &othery) == y1);	219	comptime try expect((y1 orelse &othery) == y1);
220	}	220	}
221		221
222	test "null terminated pointer" {	222	test "null terminated pointer" {
223	const S = struct {	223	const S = struct {
224	fn doTheTest() void {	224	fn doTheTest() !void {
225	var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' };	225	var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' };
226	var zero_ptr: [:0]const u8 = @ptrCast([:0]const u8, &array_with_zero);	226	var zero_ptr: [:0]const u8 = @ptrCast([:0]const u8, &array_with_zero);
227	var no_zero_ptr: [*]const u8 = zero_ptr;	227	var no_zero_ptr: [*]const u8 = zero_ptr;
228	var zero_ptr_again = @ptrCast([*:0]const u8, no_zero_ptr);	228	var zero_ptr_again = @ptrCast([*:0]const u8, no_zero_ptr);
229	expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello"));	229	try expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello"));
230	}	230	}
231	};	231	};
232	S.doTheTest();	232	try S.doTheTest();
233	comptime S.doTheTest();	233	comptime try S.doTheTest();
234	}	234	}
235		235
236	test "allow any sentinel" {	236	test "allow any sentinel" {
237	const S = struct {	237	const S = struct {
238	fn doTheTest() void {	238	fn doTheTest() !void {
239	var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 };	239	var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 };
240	var ptr: [*:std.math.minInt(i32)]i32 = &array;	240	var ptr: [*:std.math.minInt(i32)]i32 = &array;
241	expect(ptr[4] == std.math.minInt(i32));	241	try expect(ptr[4] == std.math.minInt(i32));
242	}	242	}
243	};	243	};
244	S.doTheTest();	244	try S.doTheTest();
245	comptime S.doTheTest();	245	comptime try S.doTheTest();
246	}	246	}
247		247
248	test "pointer sentinel with enums" {	248	test "pointer sentinel with enums" {
...	@@ -253,42 +253,42 @@ test "pointer sentinel with enums" {	...	@@ -253,42 +253,42 @@ test "pointer sentinel with enums" {
253	sentinel,	253	sentinel,
254	};	254	};
255		255
256	fn doTheTest() void {	256	fn doTheTest() !void {
257	var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };	257	var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };
258	expect(ptr[4] == .sentinel); // TODO this should be comptime expect, see #3731	258	try expect(ptr[4] == .sentinel); // TODO this should be comptime try expect, see #3731
259	}	259	}
260	};	260	};
261	S.doTheTest();	261	try S.doTheTest();
262	comptime S.doTheTest();	262	comptime try S.doTheTest();
263	}	263	}
264		264
265	test "pointer sentinel with optional element" {	265	test "pointer sentinel with optional element" {
266	const S = struct {	266	const S = struct {
267	fn doTheTest() void {	267	fn doTheTest() !void {
268	var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };	268	var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };
269	expect(ptr[4] == null); // TODO this should be comptime expect, see #3731	269	try expect(ptr[4] == null); // TODO this should be comptime try expect, see #3731
270	}	270	}
271	};	271	};
272	S.doTheTest();	272	try S.doTheTest();
273	comptime S.doTheTest();	273	comptime try S.doTheTest();
274	}	274	}
275		275
276	test "pointer sentinel with +inf" {	276	test "pointer sentinel with +inf" {
277	const S = struct {	277	const S = struct {
278	fn doTheTest() void {	278	fn doTheTest() !void {
279	const inf = std.math.inf_f32;	279	const inf = std.math.inf_f32;
280	var ptr: [*:inf]const f32 = &[_:inf]f32{ 1.1, 2.2, 3.3, 4.4 };	280	var ptr: [*:inf]const f32 = &[_:inf]f32{ 1.1, 2.2, 3.3, 4.4 };
281	expect(ptr[4] == inf); // TODO this should be comptime expect, see #3731	281	try expect(ptr[4] == inf); // TODO this should be comptime try expect, see #3731
282	}	282	}
283	};	283	};
284	S.doTheTest();	284	try S.doTheTest();
285	comptime S.doTheTest();	285	comptime try S.doTheTest();
286	}	286	}
287		287
288	test "pointer to array at fixed address" {	288	test "pointer to array at fixed address" {
289	const array = @intToPtr(*volatile [1]u32, 0x10);	289	const array = @intToPtr(*volatile [1]u32, 0x10);
290	// Silly check just to reference `array`	290	// Silly check just to reference `array`
291	expect(@ptrToInt(&array[0]) == 0x10);	291	try expect(@ptrToInt(&array[0]) == 0x10);
292	}	292	}
293		293
294	test "pointer arithmetic affects the alignment" {	294	test "pointer arithmetic affects the alignment" {
...	@@ -296,28 +296,28 @@ test "pointer arithmetic affects the alignment" {	...	@@ -296,28 +296,28 @@ test "pointer arithmetic affects the alignment" {
296	var ptr: [*]align(8) u32 = undefined;	296	var ptr: [*]align(8) u32 = undefined;
297	var x: usize = 1;	297	var x: usize = 1;
298		298
299	expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8);	299	try expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8);
300	const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4	300	const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4
301	expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4);	301	try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4);
302	const ptr2 = ptr + 4; // 4 * 4 = 16 -> lcd(16,8) = 8	302	const ptr2 = ptr + 4; // 4 * 4 = 16 -> lcd(16,8) = 8
303	expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8);	303	try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8);
304	const ptr3 = ptr + 0; // no-op	304	const ptr3 = ptr + 0; // no-op
305	expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);	305	try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
306	const ptr4 = ptr + x; // runtime-known addend	306	const ptr4 = ptr + x; // runtime-known addend
307	expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);	307	try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
308	}	308	}
309	{	309	{
310	var ptr: [*]align(8) [3]u8 = undefined;	310	var ptr: [*]align(8) [3]u8 = undefined;
311	var x: usize = 1;	311	var x: usize = 1;
312		312
313	const ptr1 = ptr + 17; // 3 * 17 = 51	313	const ptr1 = ptr + 17; // 3 * 17 = 51
314	expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1);	314	try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1);
315	const ptr2 = ptr + x; // runtime-known addend	315	const ptr2 = ptr + x; // runtime-known addend
316	expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1);	316	try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1);
317	const ptr3 = ptr + 8; // 3 * 8 = 24 -> lcd(8,24) = 8	317	const ptr3 = ptr + 8; // 3 * 8 = 24 -> lcd(8,24) = 8
318	expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);	318	try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
319	const ptr4 = ptr + 4; // 3 * 4 = 12 -> lcd(8,12) = 4	319	const ptr4 = ptr + 4; // 3 * 4 = 12 -> lcd(8,12) = 4
320	expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);	320	try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
321	}	321	}
322	}	322	}
323		323
...	@@ -325,15 +325,15 @@ test "@ptrToInt on null optional at comptime" {	...	@@ -325,15 +325,15 @@ test "@ptrToInt on null optional at comptime" {
325	{	325	{
326	const pointer = @intToPtr(?*u8, 0x000);	326	const pointer = @intToPtr(?*u8, 0x000);
327	const x = @ptrToInt(pointer);	327	const x = @ptrToInt(pointer);
328	comptime expect(0 == @ptrToInt(pointer));	328	comptime try expect(0 == @ptrToInt(pointer));
329	}	329	}
330	{	330	{
331	const pointer = @intToPtr(?*u8, 0xf00);	331	const pointer = @intToPtr(?*u8, 0xf00);
332	comptime expect(0xf00 == @ptrToInt(pointer));	332	comptime try expect(0xf00 == @ptrToInt(pointer));
333	}	333	}
334	}	334	}
335		335
336	test "indexing array with sentinel returns correct type" {	336	test "indexing array with sentinel returns correct type" {
337	var s: [:0]const u8 = "abc";	337	var s: [:0]const u8 = "abc";
338	testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));	338	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
339	}	339	}

test/stage1/behavior/popcount.zig+12-12

...	@@ -1,43 +1,43 @@	...	@@ -1,43 +1,43 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "@popCount" {	3	test "@popCount" {
4	comptime testPopCount();	4	comptime try testPopCount();
5	testPopCount();	5	try testPopCount();
6	}	6	}
7		7
8	fn testPopCount() void {	8	fn testPopCount() !void {
9	{	9	{
10	var x: u32 = 0xffffffff;	10	var x: u32 = 0xffffffff;
11	expect(@popCount(u32, x) == 32);	11	try expect(@popCount(u32, x) == 32);
12	}	12	}
13	{	13	{
14	var x: u5 = 0x1f;	14	var x: u5 = 0x1f;
15	expect(@popCount(u5, x) == 5);	15	try expect(@popCount(u5, x) == 5);
16	}	16	}
17	{	17	{
18	var x: u32 = 0xaa;	18	var x: u32 = 0xaa;
19	expect(@popCount(u32, x) == 4);	19	try expect(@popCount(u32, x) == 4);
20	}	20	}
21	{	21	{
22	var x: u32 = 0xaaaaaaaa;	22	var x: u32 = 0xaaaaaaaa;
23	expect(@popCount(u32, x) == 16);	23	try expect(@popCount(u32, x) == 16);
24	}	24	}
25	{	25	{
26	var x: u32 = 0xaaaaaaaa;	26	var x: u32 = 0xaaaaaaaa;
27	expect(@popCount(u32, x) == 16);	27	try expect(@popCount(u32, x) == 16);
28	}	28	}
29	{	29	{
30	var x: i16 = -1;	30	var x: i16 = -1;
31	expect(@popCount(i16, x) == 16);	31	try expect(@popCount(i16, x) == 16);
32	}	32	}
33	{	33	{
34	var x: i8 = -120;	34	var x: i8 = -120;
35	expect(@popCount(i8, x) == 2);	35	try expect(@popCount(i8, x) == 2);
36	}	36	}
37	comptime {	37	comptime {
38	expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2);	38	try expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2);
39	}	39	}
40	comptime {	40	comptime {
41	expect(@popCount(i128, 0b11111111000110001100010000100001000011000011100101010001) == 24);	41	try expect(@popCount(i128, 0b11111111000110001100010000100001000011000011100101010001) == 24);
42	}	42	}
43	}	43	}

test/stage1/behavior/ptrcast.zig+12-12

test/stage1/behavior/pub_enum.zig+4-4

...	@@ -2,12 +2,12 @@ const other = @import("pub_enum/other.zig");	...	@@ -2,12 +2,12 @@ const other = @import("pub_enum/other.zig");
2	const expect = @import("std").testing.expect;	2	const expect = @import("std").testing.expect;
3		3
4	test "pub enum" {	4	test "pub enum" {
5	pubEnumTest(other.APubEnum.Two);	5	try pubEnumTest(other.APubEnum.Two);
6	}	6	}
7	fn pubEnumTest(foo: other.APubEnum) void {	7	fn pubEnumTest(foo: other.APubEnum) !void {
8	expect(foo == other.APubEnum.Two);	8	try expect(foo == other.APubEnum.Two);
9	}	9	}
10		10
11	test "cast with imported symbol" {	11	test "cast with imported symbol" {
12	expect(@as(other.size_t, 42) == 42);	12	try expect(@as(other.size_t, 42) == 42);
13	}	13	}

test/stage1/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+10-10

...	@@ -3,12 +3,12 @@ const mem = @import("std").mem;	...	@@ -3,12 +3,12 @@ const mem = @import("std").mem;
3		3
4	var ok: bool = false;	4	var ok: bool = false;
5	test "reference a variable in an if after an if in the 2nd switch prong" {	5	test "reference a variable in an if after an if in the 2nd switch prong" {
6	foo(true, Num.Two, false, "aoeu");	6	try foo(true, Num.Two, false, "aoeu");
7	expect(!ok);	7	try expect(!ok);
8	foo(false, Num.One, false, "aoeu");	8	try foo(false, Num.One, false, "aoeu");
9	expect(!ok);	9	try expect(!ok);
10	foo(true, Num.One, false, "aoeu");	10	try foo(true, Num.One, false, "aoeu");
11	expect(ok);	11	try expect(ok);
12	}	12	}
13		13
14	const Num = enum {	14	const Num = enum {
...	@@ -16,7 +16,7 @@ const Num = enum {	...	@@ -16,7 +16,7 @@ const Num = enum {
16	Two,	16	Two,
17	};	17	};
18		18
19	fn foo(c: bool, k: Num, c2: bool, b: []const u8) void {	19	fn foo(c: bool, k: Num, c2: bool, b: []const u8) !void {
20	switch (k) {	20	switch (k) {
21	Num.Two => {},	21	Num.Two => {},
22	Num.One => {	22	Num.One => {
...	@@ -25,13 +25,13 @@ fn foo(c: bool, k: Num, c2: bool, b: []const u8) void {	...	@@ -25,13 +25,13 @@ fn foo(c: bool, k: Num, c2: bool, b: []const u8) void {
25		25
26	if (c2) {}	26	if (c2) {}
27		27
28	a(output_path);	28	try a(output_path);
29	}	29	}
30	},	30	},
31	}	31	}
32	}	32	}
33		33
34	fn a(x: []const u8) void {	34	fn a(x: []const u8) !void {
35	expect(mem.eql(u8, x, "aoeu"));	35	try expect(mem.eql(u8, x, "aoeu"));
36	ok = true;	36	ok = true;
37	}	37	}

test/stage1/behavior/reflection.zig+17-17

test/stage1/behavior/shuffle.zig+10-10

test/stage1/behavior/sizeof_and_typeof.zig+75-75

...	@@ -5,7 +5,7 @@ const expectEqual = std.testing.expectEqual;	...	@@ -5,7 +5,7 @@ const expectEqual = std.testing.expectEqual;
5		5
6	test "@sizeOf and @TypeOf" {	6	test "@sizeOf and @TypeOf" {
7	const y: @TypeOf(x) = 120;	7	const y: @TypeOf(x) = 120;
8	expect(@sizeOf(@TypeOf(y)) == 2);	8	try expect(@sizeOf(@TypeOf(y)) == 2);
9	}	9	}
10	const x: u16 = 13;	10	const x: u16 = 13;
11	const z: @TypeOf(x) = 19;	11	const z: @TypeOf(x) = 19;
...	@@ -36,27 +36,27 @@ const P = packed struct {	...	@@ -36,27 +36,27 @@ const P = packed struct {
36		36
37	test "@byteOffsetOf" {	37	test "@byteOffsetOf" {
38	// Packed structs have fixed memory layout	38	// Packed structs have fixed memory layout
39	expect(@byteOffsetOf(P, "a") == 0);	39	try expect(@byteOffsetOf(P, "a") == 0);
40	expect(@byteOffsetOf(P, "b") == 1);	40	try expect(@byteOffsetOf(P, "b") == 1);
41	expect(@byteOffsetOf(P, "c") == 5);	41	try expect(@byteOffsetOf(P, "c") == 5);
42	expect(@byteOffsetOf(P, "d") == 6);	42	try expect(@byteOffsetOf(P, "d") == 6);
43	expect(@byteOffsetOf(P, "e") == 6);	43	try expect(@byteOffsetOf(P, "e") == 6);
44	expect(@byteOffsetOf(P, "f") == 7);	44	try expect(@byteOffsetOf(P, "f") == 7);
45	expect(@byteOffsetOf(P, "g") == 9);	45	try expect(@byteOffsetOf(P, "g") == 9);
46	expect(@byteOffsetOf(P, "h") == 11);	46	try expect(@byteOffsetOf(P, "h") == 11);
47	expect(@byteOffsetOf(P, "i") == 12);	47	try expect(@byteOffsetOf(P, "i") == 12);
48		48
49	// Normal struct fields can be moved/padded	49	// Normal struct fields can be moved/padded
50	var a: A = undefined;	50	var a: A = undefined;
51	expect(@ptrToInt(&a.a) - @ptrToInt(&a) == @byteOffsetOf(A, "a"));	51	try expect(@ptrToInt(&a.a) - @ptrToInt(&a) == @byteOffsetOf(A, "a"));
52	expect(@ptrToInt(&a.b) - @ptrToInt(&a) == @byteOffsetOf(A, "b"));	52	try expect(@ptrToInt(&a.b) - @ptrToInt(&a) == @byteOffsetOf(A, "b"));
53	expect(@ptrToInt(&a.c) - @ptrToInt(&a) == @byteOffsetOf(A, "c"));	53	try expect(@ptrToInt(&a.c) - @ptrToInt(&a) == @byteOffsetOf(A, "c"));
54	expect(@ptrToInt(&a.d) - @ptrToInt(&a) == @byteOffsetOf(A, "d"));	54	try expect(@ptrToInt(&a.d) - @ptrToInt(&a) == @byteOffsetOf(A, "d"));
55	expect(@ptrToInt(&a.e) - @ptrToInt(&a) == @byteOffsetOf(A, "e"));	55	try expect(@ptrToInt(&a.e) - @ptrToInt(&a) == @byteOffsetOf(A, "e"));
56	expect(@ptrToInt(&a.f) - @ptrToInt(&a) == @byteOffsetOf(A, "f"));	56	try expect(@ptrToInt(&a.f) - @ptrToInt(&a) == @byteOffsetOf(A, "f"));
57	expect(@ptrToInt(&a.g) - @ptrToInt(&a) == @byteOffsetOf(A, "g"));	57	try expect(@ptrToInt(&a.g) - @ptrToInt(&a) == @byteOffsetOf(A, "g"));
58	expect(@ptrToInt(&a.h) - @ptrToInt(&a) == @byteOffsetOf(A, "h"));	58	try expect(@ptrToInt(&a.h) - @ptrToInt(&a) == @byteOffsetOf(A, "h"));
59	expect(@ptrToInt(&a.i) - @ptrToInt(&a) == @byteOffsetOf(A, "i"));	59	try expect(@ptrToInt(&a.i) - @ptrToInt(&a) == @byteOffsetOf(A, "i"));
60	}	60	}
61		61
62	test "@byteOffsetOf packed struct, array length not power of 2 or multiple of native pointer width in bytes" {	62	test "@byteOffsetOf packed struct, array length not power of 2 or multiple of native pointer width in bytes" {
...	@@ -65,68 +65,68 @@ test "@byteOffsetOf packed struct, array length not power of 2 or multiple of na	...	@@ -65,68 +65,68 @@ test "@byteOffsetOf packed struct, array length not power of 2 or multiple of na
65	a: [p3a_len]u8,	65	a: [p3a_len]u8,
66	b: usize,	66	b: usize,
67	};	67	};
68	std.testing.expectEqual(0, @byteOffsetOf(P3, "a"));	68	try std.testing.expectEqual(0, @byteOffsetOf(P3, "a"));
69	std.testing.expectEqual(p3a_len, @byteOffsetOf(P3, "b"));	69	try std.testing.expectEqual(p3a_len, @byteOffsetOf(P3, "b"));
70		70
71	const p5a_len = 5;	71	const p5a_len = 5;
72	const P5 = packed struct {	72	const P5 = packed struct {
73	a: [p5a_len]u8,	73	a: [p5a_len]u8,
74	b: usize,	74	b: usize,
75	};	75	};
76	std.testing.expectEqual(0, @byteOffsetOf(P5, "a"));	76	try std.testing.expectEqual(0, @byteOffsetOf(P5, "a"));
77	std.testing.expectEqual(p5a_len, @byteOffsetOf(P5, "b"));	77	try std.testing.expectEqual(p5a_len, @byteOffsetOf(P5, "b"));
78		78
79	const p6a_len = 6;	79	const p6a_len = 6;
80	const P6 = packed struct {	80	const P6 = packed struct {
81	a: [p6a_len]u8,	81	a: [p6a_len]u8,
82	b: usize,	82	b: usize,
83	};	83	};
84	std.testing.expectEqual(0, @byteOffsetOf(P6, "a"));	84	try std.testing.expectEqual(0, @byteOffsetOf(P6, "a"));
85	std.testing.expectEqual(p6a_len, @byteOffsetOf(P6, "b"));	85	try std.testing.expectEqual(p6a_len, @byteOffsetOf(P6, "b"));
86		86
87	const p7a_len = 7;	87	const p7a_len = 7;
88	const P7 = packed struct {	88	const P7 = packed struct {
89	a: [p7a_len]u8,	89	a: [p7a_len]u8,
90	b: usize,	90	b: usize,
91	};	91	};
92	std.testing.expectEqual(0, @byteOffsetOf(P7, "a"));	92	try std.testing.expectEqual(0, @byteOffsetOf(P7, "a"));
93	std.testing.expectEqual(p7a_len, @byteOffsetOf(P7, "b"));	93	try std.testing.expectEqual(p7a_len, @byteOffsetOf(P7, "b"));
94		94
95	const p9a_len = 9;	95	const p9a_len = 9;
96	const P9 = packed struct {	96	const P9 = packed struct {
97	a: [p9a_len]u8,	97	a: [p9a_len]u8,
98	b: usize,	98	b: usize,
99	};	99	};
100	std.testing.expectEqual(0, @byteOffsetOf(P9, "a"));	100	try std.testing.expectEqual(0, @byteOffsetOf(P9, "a"));
101	std.testing.expectEqual(p9a_len, @byteOffsetOf(P9, "b"));	101	try std.testing.expectEqual(p9a_len, @byteOffsetOf(P9, "b"));
102		102
103	// 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25 etc. are further cases	103	// 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25 etc. are further cases
104	}	104	}
105		105
106	test "@bitOffsetOf" {	106	test "@bitOffsetOf" {
107	// Packed structs have fixed memory layout	107	// Packed structs have fixed memory layout
108	expect(@bitOffsetOf(P, "a") == 0);	108	try expect(@bitOffsetOf(P, "a") == 0);
109	expect(@bitOffsetOf(P, "b") == 8);	109	try expect(@bitOffsetOf(P, "b") == 8);
110	expect(@bitOffsetOf(P, "c") == 40);	110	try expect(@bitOffsetOf(P, "c") == 40);
111	expect(@bitOffsetOf(P, "d") == 48);	111	try expect(@bitOffsetOf(P, "d") == 48);
112	expect(@bitOffsetOf(P, "e") == 51);	112	try expect(@bitOffsetOf(P, "e") == 51);
113	expect(@bitOffsetOf(P, "f") == 56);	113	try expect(@bitOffsetOf(P, "f") == 56);
114	expect(@bitOffsetOf(P, "g") == 72);	114	try expect(@bitOffsetOf(P, "g") == 72);
115		115
116	expect(@byteOffsetOf(A, "a") * 8 == @bitOffsetOf(A, "a"));	116	try expect(@byteOffsetOf(A, "a") * 8 == @bitOffsetOf(A, "a"));
117	expect(@byteOffsetOf(A, "b") * 8 == @bitOffsetOf(A, "b"));	117	try expect(@byteOffsetOf(A, "b") * 8 == @bitOffsetOf(A, "b"));
118	expect(@byteOffsetOf(A, "c") * 8 == @bitOffsetOf(A, "c"));	118	try expect(@byteOffsetOf(A, "c") * 8 == @bitOffsetOf(A, "c"));
119	expect(@byteOffsetOf(A, "d") * 8 == @bitOffsetOf(A, "d"));	119	try expect(@byteOffsetOf(A, "d") * 8 == @bitOffsetOf(A, "d"));
120	expect(@byteOffsetOf(A, "e") * 8 == @bitOffsetOf(A, "e"));	120	try expect(@byteOffsetOf(A, "e") * 8 == @bitOffsetOf(A, "e"));
121	expect(@byteOffsetOf(A, "f") * 8 == @bitOffsetOf(A, "f"));	121	try expect(@byteOffsetOf(A, "f") * 8 == @bitOffsetOf(A, "f"));
122	expect(@byteOffsetOf(A, "g") * 8 == @bitOffsetOf(A, "g"));	122	try expect(@byteOffsetOf(A, "g") * 8 == @bitOffsetOf(A, "g"));
123	}	123	}
124		124
125	test "@sizeOf on compile-time types" {	125	test "@sizeOf on compile-time types" {
126	expect(@sizeOf(comptime_int) == 0);	126	try expect(@sizeOf(comptime_int) == 0);
127	expect(@sizeOf(comptime_float) == 0);	127	try expect(@sizeOf(comptime_float) == 0);
128	expect(@sizeOf(@TypeOf(.hi)) == 0);	128	try expect(@sizeOf(@TypeOf(.hi)) == 0);
129	expect(@sizeOf(@TypeOf(type)) == 0);	129	try expect(@sizeOf(@TypeOf(type)) == 0);
130	}	130	}
131		131
132	test "@sizeOf(T) == 0 doesn't force resolving struct size" {	132	test "@sizeOf(T) == 0 doesn't force resolving struct size" {
...	@@ -140,8 +140,8 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {	...	@@ -140,8 +140,8 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
140	};	140	};
141	};	141	};
142		142
143	expect(@sizeOf(S.Foo) == 4);	143	try expect(@sizeOf(S.Foo) == 4);
144	expect(@sizeOf(S.Bar) == 8);	144	try expect(@sizeOf(S.Bar) == 8);
145	}	145	}
146		146
147	test "@TypeOf() has no runtime side effects" {	147	test "@TypeOf() has no runtime side effects" {
...	@@ -153,8 +153,8 @@ test "@TypeOf() has no runtime side effects" {	...	@@ -153,8 +153,8 @@ test "@TypeOf() has no runtime side effects" {
153	};	153	};
154	var data: i32 = 0;	154	var data: i32 = 0;
155	const T = @TypeOf(S.foo(i32, &data));	155	const T = @TypeOf(S.foo(i32, &data));
156	comptime expect(T == i32);	156	comptime try expect(T == i32);
157	expect(data == 0);	157	try expect(data == 0);
158	}	158	}
159		159
160	test "@TypeOf() with multiple arguments" {	160	test "@TypeOf() with multiple arguments" {
...	@@ -162,21 +162,21 @@ test "@TypeOf() with multiple arguments" {	...	@@ -162,21 +162,21 @@ test "@TypeOf() with multiple arguments" {
162	var var_1: u32 = undefined;	162	var var_1: u32 = undefined;
163	var var_2: u8 = undefined;	163	var var_2: u8 = undefined;
164	var var_3: u64 = undefined;	164	var var_3: u64 = undefined;
165	comptime expect(@TypeOf(var_1, var_2, var_3) == u64);	165	comptime try expect(@TypeOf(var_1, var_2, var_3) == u64);
166	}	166	}
167	{	167	{
168	var var_1: f16 = undefined;	168	var var_1: f16 = undefined;
169	var var_2: f32 = undefined;	169	var var_2: f32 = undefined;
170	var var_3: f64 = undefined;	170	var var_3: f64 = undefined;
171	comptime expect(@TypeOf(var_1, var_2, var_3) == f64);	171	comptime try expect(@TypeOf(var_1, var_2, var_3) == f64);
172	}	172	}
173	{	173	{
174	var var_1: u16 = undefined;	174	var var_1: u16 = undefined;
175	comptime expect(@TypeOf(var_1, 0xffff) == u16);	175	comptime try expect(@TypeOf(var_1, 0xffff) == u16);
176	}	176	}
177	{	177	{
178	var var_1: f32 = undefined;	178	var var_1: f32 = undefined;
179	comptime expect(@TypeOf(var_1, 3.1415) == f32);	179	comptime try expect(@TypeOf(var_1, 3.1415) == f32);
180	}	180	}
181	}	181	}
182		182
...	@@ -189,8 +189,8 @@ test "branching logic inside @TypeOf" {	...	@@ -189,8 +189,8 @@ test "branching logic inside @TypeOf" {
189	}	189	}
190	};	190	};
191	const T = @TypeOf(S.foo() catch undefined);	191	const T = @TypeOf(S.foo() catch undefined);
192	comptime expect(T == i32);	192	comptime try expect(T == i32);
193	expect(S.data == 0);	193	try expect(S.data == 0);
194	}	194	}
195		195
196	fn fn1(alpha: bool) void {	196	fn fn1(alpha: bool) void {
...	@@ -203,12 +203,12 @@ test "lazy @sizeOf result is checked for definedness" {	...	@@ -203,12 +203,12 @@ test "lazy @sizeOf result is checked for definedness" {
203	}	203	}
204		204
205	test "@bitSizeOf" {	205	test "@bitSizeOf" {
206	expect(@bitSizeOf(u2) == 2);	206	try expect(@bitSizeOf(u2) == 2);
207	expect(@bitSizeOf(u8) == @sizeOf(u8) * 8);	207	try expect(@bitSizeOf(u8) == @sizeOf(u8) * 8);
208	expect(@bitSizeOf(struct {	208	try expect(@bitSizeOf(struct {
209	a: u2,	209	a: u2,
210	}) == 8);	210	}) == 8);
211	expect(@bitSizeOf(packed struct {	211	try expect(@bitSizeOf(packed struct {
212	a: u2,	212	a: u2,
213	}) == 2);	213	}) == 2);
214	}	214	}
...	@@ -241,24 +241,24 @@ test "@sizeOf comparison against zero" {	...	@@ -241,24 +241,24 @@ test "@sizeOf comparison against zero" {
241	f2: H(***@This()),	241	f2: H(***@This()),
242	};	242	};
243	const S = struct {	243	const S = struct {
244	fn doTheTest(comptime T: type, comptime result: bool) void {	244	fn doTheTest(comptime T: type, comptime result: bool) !void {
245	expectEqual(result, @sizeOf(T) > 0);	245	try expectEqual(result, @sizeOf(T) > 0);
246	}	246	}
247	};	247	};
248	// Zero-sized type	248	// Zero-sized type
249	S.doTheTest(u0, false);	249	try S.doTheTest(u0, false);
250	S.doTheTest(*u0, false);	250	try S.doTheTest(*u0, false);
251	// Non byte-sized type	251	// Non byte-sized type
252	S.doTheTest(u1, true);	252	try S.doTheTest(u1, true);
253	S.doTheTest(*u1, true);	253	try S.doTheTest(*u1, true);
254	// Regular type	254	// Regular type
255	S.doTheTest(u8, true);	255	try S.doTheTest(u8, true);
256	S.doTheTest(*u8, true);	256	try S.doTheTest(*u8, true);
257	S.doTheTest(f32, true);	257	try S.doTheTest(f32, true);
258	S.doTheTest(*f32, true);	258	try S.doTheTest(*f32, true);
259	// Container with ptr pointing to themselves	259	// Container with ptr pointing to themselves
260	S.doTheTest(S0, true);	260	try S.doTheTest(S0, true);
261	S.doTheTest(U0, true);	261	try S.doTheTest(U0, true);
262	S.doTheTest(S1, true);	262	try S.doTheTest(S1, true);
263	S.doTheTest(U1, true);	263	try S.doTheTest(U1, true);
264	}	264	}

test/stage1/behavior/slice.zig+119-119

...	@@ -7,11 +7,11 @@ const mem = std.mem;	...	@@ -7,11 +7,11 @@ const mem = std.mem;
7	const x = @intToPtr([*]i32, 0x1000)[0..0x500];	7	const x = @intToPtr([*]i32, 0x1000)[0..0x500];
8	const y = x[0x100..];	8	const y = x[0x100..];
9	test "compile time slice of pointer to hard coded address" {	9	test "compile time slice of pointer to hard coded address" {
10	expect(@ptrToInt(x) == 0x1000);	10	try expect(@ptrToInt(x) == 0x1000);
11	expect(x.len == 0x500);	11	try expect(x.len == 0x500);
12		12
13	expect(@ptrToInt(y) == 0x1100);	13	try expect(@ptrToInt(y) == 0x1100);
14	expect(y.len == 0x400);	14	try expect(y.len == 0x400);
15	}	15	}
16		16
17	test "runtime safety lets us slice from len..len" {	17	test "runtime safety lets us slice from len..len" {
...	@@ -20,7 +20,7 @@ test "runtime safety lets us slice from len..len" {	...	@@ -20,7 +20,7 @@ test "runtime safety lets us slice from len..len" {
20	2,	20	2,
21	3,	21	3,
22	};	22	};
23	expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));	23	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
24	}	24	}
25		25
26	fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {	26	fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
...	@@ -29,18 +29,18 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {	...	@@ -29,18 +29,18 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
29		29
30	test "implicitly cast array of size 0 to slice" {	30	test "implicitly cast array of size 0 to slice" {
31	var msg = [_]u8{};	31	var msg = [_]u8{};
32	assertLenIsZero(&msg);	32	try assertLenIsZero(&msg);
33	}	33	}
34		34
35	fn assertLenIsZero(msg: []const u8) void {	35	fn assertLenIsZero(msg: []const u8) !void {
36	expect(msg.len == 0);	36	try expect(msg.len == 0);
37	}	37	}
38		38
39	test "C pointer" {	39	test "C pointer" {
40	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";	40	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
41	var len: u32 = 10;	41	var len: u32 = 10;
42	var slice = buf[0..len];	42	var slice = buf[0..len];
43	expectEqualSlices(u8, "kjdhfkjdhf", slice);	43	try expectEqualSlices(u8, "kjdhfkjdhf", slice);
44	}	44	}
45		45
46	test "C pointer slice access" {	46	test "C pointer slice access" {
...	@@ -48,11 +48,11 @@ test "C pointer slice access" {	...	@@ -48,11 +48,11 @@ test "C pointer slice access" {
48	const c_ptr = @ptrCast([*c]const u32, &buf);	48	const c_ptr = @ptrCast([*c]const u32, &buf);
49		49
50	var runtime_zero: usize = 0;	50	var runtime_zero: usize = 0;
51	comptime expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1]));	51	comptime try expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1]));
52	comptime expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1]));	52	comptime try expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1]));
53		53
54	for (c_ptr[0..5]) \|*cl\| {	54	for (c_ptr[0..5]) \|*cl\| {
55	expectEqual(@as(u32, 42), cl.*);	55	try expectEqual(@as(u32, 42), cl.*);
56	}	56	}
57	}	57	}
58		58
...	@@ -65,8 +65,8 @@ fn sliceSum(comptime q: []const u8) i32 {	...	@@ -65,8 +65,8 @@ fn sliceSum(comptime q: []const u8) i32 {
65	}	65	}
66		66
67	test "comptime slices are disambiguated" {	67	test "comptime slices are disambiguated" {
68	expect(sliceSum(&[_]u8{ 1, 2 }) == 3);	68	try expect(sliceSum(&[_]u8{ 1, 2 }) == 3);
69	expect(sliceSum(&[_]u8{ 3, 4 }) == 7);	69	try expect(sliceSum(&[_]u8{ 3, 4 }) == 7);
70	}	70	}
71		71
72	test "slice type with custom alignment" {	72	test "slice type with custom alignment" {
...	@@ -77,20 +77,20 @@ test "slice type with custom alignment" {	...	@@ -77,20 +77,20 @@ test "slice type with custom alignment" {
77	var array: [10]LazilyResolvedType align(32) = undefined;	77	var array: [10]LazilyResolvedType align(32) = undefined;
78	slice = &array;	78	slice = &array;
79	slice[1].anything = 42;	79	slice[1].anything = 42;
80	expect(array[1].anything == 42);	80	try expect(array[1].anything == 42);
81	}	81	}
82		82
83	test "access len index of sentinel-terminated slice" {	83	test "access len index of sentinel-terminated slice" {
84	const S = struct {	84	const S = struct {
85	fn doTheTest() void {	85	fn doTheTest() !void {
86	var slice: [:0]const u8 = "hello";	86	var slice: [:0]const u8 = "hello";
87		87
88	expect(slice.len == 5);	88	try expect(slice.len == 5);
89	expect(slice[5] == 0);	89	try expect(slice[5] == 0);
90	}	90	}
91	};	91	};
92	S.doTheTest();	92	try S.doTheTest();
93	comptime S.doTheTest();	93	comptime try S.doTheTest();
94	}	94	}
95		95
96	test "obtaining a null terminated slice" {	96	test "obtaining a null terminated slice" {
...	@@ -108,230 +108,230 @@ test "obtaining a null terminated slice" {	...	@@ -108,230 +108,230 @@ test "obtaining a null terminated slice" {
108	var runtime_len: usize = 3;	108	var runtime_len: usize = 3;
109	const ptr2 = buf[0..runtime_len :0];	109	const ptr2 = buf[0..runtime_len :0];
110	// ptr2 is a null-terminated slice	110	// ptr2 is a null-terminated slice
111	comptime expect(@TypeOf(ptr2) == [:0]u8);	111	comptime try expect(@TypeOf(ptr2) == [:0]u8);
112	comptime expect(@TypeOf(ptr2[0..2]) == *[2]u8);	112	comptime try expect(@TypeOf(ptr2[0..2]) == *[2]u8);
113	var runtime_zero: usize = 0;	113	var runtime_zero: usize = 0;
114	comptime expect(@TypeOf(ptr2[runtime_zero..2]) == []u8);	114	comptime try expect(@TypeOf(ptr2[runtime_zero..2]) == []u8);
115	}	115	}
116		116
117	test "empty array to slice" {	117	test "empty array to slice" {
118	const S = struct {	118	const S = struct {
119	fn doTheTest() void {	119	fn doTheTest() !void {
120	const empty: []align(16) u8 = &[_]u8{};	120	const empty: []align(16) u8 = &[_]u8{};
121	const align_1: []align(1) u8 = empty;	121	const align_1: []align(1) u8 = empty;
122	const align_4: []align(4) u8 = empty;	122	const align_4: []align(4) u8 = empty;
123	const align_16: []align(16) u8 = empty;	123	const align_16: []align(16) u8 = empty;
124	expectEqual(1, @typeInfo(@TypeOf(align_1)).Pointer.alignment);	124	try expectEqual(1, @typeInfo(@TypeOf(align_1)).Pointer.alignment);
125	expectEqual(4, @typeInfo(@TypeOf(align_4)).Pointer.alignment);	125	try expectEqual(4, @typeInfo(@TypeOf(align_4)).Pointer.alignment);
126	expectEqual(16, @typeInfo(@TypeOf(align_16)).Pointer.alignment);	126	try expectEqual(16, @typeInfo(@TypeOf(align_16)).Pointer.alignment);
127	}	127	}
128	};	128	};
129		129
130	S.doTheTest();	130	try S.doTheTest();
131	comptime S.doTheTest();	131	comptime try S.doTheTest();
132	}	132	}
133		133
134	test "@ptrCast slice to pointer" {	134	test "@ptrCast slice to pointer" {
135	const S = struct {	135	const S = struct {
136	fn doTheTest() void {	136	fn doTheTest() !void {
137	var array align(@alignOf(u16)) = [5]u8{ 0xff, 0xff, 0xff, 0xff, 0xff };	137	var array align(@alignOf(u16)) = [5]u8{ 0xff, 0xff, 0xff, 0xff, 0xff };
138	var slice: []u8 = &array;	138	var slice: []u8 = &array;
139	var ptr = @ptrCast(*u16, slice);	139	var ptr = @ptrCast(*u16, slice);
140	expect(ptr.* == 65535);	140	try expect(ptr.* == 65535);
141	}	141	}
142	};	142	};
143		143
144	S.doTheTest();	144	try S.doTheTest();
145	comptime S.doTheTest();	145	comptime try S.doTheTest();
146	}	146	}
147		147
148	test "slice syntax resulting in pointer-to-array" {	148	test "slice syntax resulting in pointer-to-array" {
149	const S = struct {	149	const S = struct {
150	fn doTheTest() void {	150	fn doTheTest() !void {
151	testArray();	151	try testArray();
152	testArrayZ();	152	try testArrayZ();
153	testArray0();	153	try testArray0();
154	testArrayAlign();	154	try testArrayAlign();
155	testPointer();	155	try testPointer();
156	testPointerZ();	156	try testPointerZ();
157	testPointer0();	157	try testPointer0();
158	testPointerAlign();	158	try testPointerAlign();
159	testSlice();	159	try testSlice();
160	testSliceZ();	160	try testSliceZ();
161	testSlice0();	161	try testSlice0();
162	testSliceOpt();	162	try testSliceOpt();
163	testSliceAlign();	163	try testSliceAlign();
164	}	164	}
165		165
166	fn testArray() void {	166	fn testArray() !void {
167	var array = [5]u8{ 1, 2, 3, 4, 5 };	167	var array = [5]u8{ 1, 2, 3, 4, 5 };
168	var slice = array[1..3];	168	var slice = array[1..3];
169	comptime expect(@TypeOf(slice) == *[2]u8);	169	comptime try expect(@TypeOf(slice) == *[2]u8);
170	expect(slice[0] == 2);	170	try expect(slice[0] == 2);
171	expect(slice[1] == 3);	171	try expect(slice[1] == 3);
172	}	172	}
173		173
174	fn testArrayZ() void {	174	fn testArrayZ() !void {
175	var array = [5:0]u8{ 1, 2, 3, 4, 5 };	175	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
176	comptime expect(@TypeOf(array[1..3]) == *[2]u8);	176	comptime try expect(@TypeOf(array[1..3]) == *[2]u8);
177	comptime expect(@TypeOf(array[1..5]) == *[4:0]u8);	177	comptime try expect(@TypeOf(array[1..5]) == *[4:0]u8);
178	comptime expect(@TypeOf(array[1..]) == *[4:0]u8);	178	comptime try expect(@TypeOf(array[1..]) == *[4:0]u8);
179	comptime expect(@TypeOf(array[1..3 :4]) == *[2:4]u8);	179	comptime try expect(@TypeOf(array[1..3 :4]) == *[2:4]u8);
180	}	180	}
181		181
182	fn testArray0() void {	182	fn testArray0() !void {
183	{	183	{
184	var array = [0]u8{};	184	var array = [0]u8{};
185	var slice = array[0..0];	185	var slice = array[0..0];
186	comptime expect(@TypeOf(slice) == *[0]u8);	186	comptime try expect(@TypeOf(slice) == *[0]u8);
187	}	187	}
188	{	188	{
189	var array = [0:0]u8{};	189	var array = [0:0]u8{};
190	var slice = array[0..0];	190	var slice = array[0..0];
191	comptime expect(@TypeOf(slice) == *[0:0]u8);	191	comptime try expect(@TypeOf(slice) == *[0:0]u8);
192	expect(slice[0] == 0);	192	try expect(slice[0] == 0);
193	}	193	}
194	}	194	}
195		195
196	fn testArrayAlign() void {	196	fn testArrayAlign() !void {
197	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };	197	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
198	var slice = array[4..5];	198	var slice = array[4..5];
199	comptime expect(@TypeOf(slice) == *align(4) [1]u8);	199	comptime try expect(@TypeOf(slice) == *align(4) [1]u8);
200	expect(slice[0] == 5);	200	try expect(slice[0] == 5);
201	comptime expect(@TypeOf(array[0..2]) == *align(4) [2]u8);	201	comptime try expect(@TypeOf(array[0..2]) == *align(4) [2]u8);
202	}	202	}
203		203
204	fn testPointer() void {	204	fn testPointer() !void {
205	var array = [5]u8{ 1, 2, 3, 4, 5 };	205	var array = [5]u8{ 1, 2, 3, 4, 5 };
206	var pointer: [*]u8 = &array;	206	var pointer: [*]u8 = &array;
207	var slice = pointer[1..3];	207	var slice = pointer[1..3];
208	comptime expect(@TypeOf(slice) == *[2]u8);	208	comptime try expect(@TypeOf(slice) == *[2]u8);
209	expect(slice[0] == 2);	209	try expect(slice[0] == 2);
210	expect(slice[1] == 3);	210	try expect(slice[1] == 3);
211	}	211	}
212		212
213	fn testPointerZ() void {	213	fn testPointerZ() !void {
214	var array = [5:0]u8{ 1, 2, 3, 4, 5 };	214	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
215	var pointer: [*:0]u8 = &array;	215	var pointer: [*:0]u8 = &array;
216	comptime expect(@TypeOf(pointer[1..3]) == *[2]u8);	216	comptime try expect(@TypeOf(pointer[1..3]) == *[2]u8);
217	comptime expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8);	217	comptime try expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8);
218	}	218	}
219		219
220	fn testPointer0() void {	220	fn testPointer0() !void {
221	var pointer: [*]const u0 = &[1]u0{0};	221	var pointer: [*]const u0 = &[1]u0{0};
222	var slice = pointer[0..1];	222	var slice = pointer[0..1];
223	comptime expect(@TypeOf(slice) == *const [1]u0);	223	comptime try expect(@TypeOf(slice) == *const [1]u0);
224	expect(slice[0] == 0);	224	try expect(slice[0] == 0);
225	}	225	}
226		226
227	fn testPointerAlign() void {	227	fn testPointerAlign() !void {
228	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };	228	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
229	var pointer: [*]align(4) u8 = &array;	229	var pointer: [*]align(4) u8 = &array;
230	var slice = pointer[4..5];	230	var slice = pointer[4..5];
231	comptime expect(@TypeOf(slice) == *align(4) [1]u8);	231	comptime try expect(@TypeOf(slice) == *align(4) [1]u8);
232	expect(slice[0] == 5);	232	try expect(slice[0] == 5);
233	comptime expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8);	233	comptime try expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8);
234	}	234	}
235		235
236	fn testSlice() void {	236	fn testSlice() !void {
237	var array = [5]u8{ 1, 2, 3, 4, 5 };	237	var array = [5]u8{ 1, 2, 3, 4, 5 };
238	var src_slice: []u8 = &array;	238	var src_slice: []u8 = &array;
239	var slice = src_slice[1..3];	239	var slice = src_slice[1..3];
240	comptime expect(@TypeOf(slice) == *[2]u8);	240	comptime try expect(@TypeOf(slice) == *[2]u8);
241	expect(slice[0] == 2);	241	try expect(slice[0] == 2);
242	expect(slice[1] == 3);	242	try expect(slice[1] == 3);
243	}	243	}
244		244
245	fn testSliceZ() void {	245	fn testSliceZ() !void {
246	var array = [5:0]u8{ 1, 2, 3, 4, 5 };	246	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
247	var slice: [:0]u8 = &array;	247	var slice: [:0]u8 = &array;
248	comptime expect(@TypeOf(slice[1..3]) == *[2]u8);	248	comptime try expect(@TypeOf(slice[1..3]) == *[2]u8);
249	comptime expect(@TypeOf(slice[1..]) == [:0]u8);	249	comptime try expect(@TypeOf(slice[1..]) == [:0]u8);
250	comptime expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8);	250	comptime try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8);
251	}	251	}
252		252
253	fn testSliceOpt() void {	253	fn testSliceOpt() !void {
254	var array: [2]u8 = [2]u8{ 1, 2 };	254	var array: [2]u8 = [2]u8{ 1, 2 };
255	var slice: ?[]u8 = &array;	255	var slice: ?[]u8 = &array;
256	comptime expect(@TypeOf(&array, slice) == ?[]u8);	256	comptime try expect(@TypeOf(&array, slice) == ?[]u8);
257	comptime expect(@TypeOf(slice.?[0..2]) == *[2]u8);	257	comptime try expect(@TypeOf(slice.?[0..2]) == *[2]u8);
258	}	258	}
259		259
260	fn testSlice0() void {	260	fn testSlice0() !void {
261	{	261	{
262	var array = [0]u8{};	262	var array = [0]u8{};
263	var src_slice: []u8 = &array;	263	var src_slice: []u8 = &array;
264	var slice = src_slice[0..0];	264	var slice = src_slice[0..0];
265	comptime expect(@TypeOf(slice) == *[0]u8);	265	comptime try expect(@TypeOf(slice) == *[0]u8);
266	}	266	}
267	{	267	{
268	var array = [0:0]u8{};	268	var array = [0:0]u8{};
269	var src_slice: [:0]u8 = &array;	269	var src_slice: [:0]u8 = &array;
270	var slice = src_slice[0..0];	270	var slice = src_slice[0..0];
271	comptime expect(@TypeOf(slice) == *[0]u8);	271	comptime try expect(@TypeOf(slice) == *[0]u8);
272	}	272	}
273	}	273	}
274		274
275	fn testSliceAlign() void {	275	fn testSliceAlign() !void {
276	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };	276	var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
277	var src_slice: []align(4) u8 = &array;	277	var src_slice: []align(4) u8 = &array;
278	var slice = src_slice[4..5];	278	var slice = src_slice[4..5];
279	comptime expect(@TypeOf(slice) == *align(4) [1]u8);	279	comptime try expect(@TypeOf(slice) == *align(4) [1]u8);
280	expect(slice[0] == 5);	280	try expect(slice[0] == 5);
281	comptime expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8);	281	comptime try expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8);
282	}	282	}
283		283
284	fn testConcatStrLiterals() void {	284	fn testConcatStrLiterals() !void {
285	expectEqualSlices("a"[0..] ++ "b"[0..], "ab");	285	try expectEqualSlices("a"[0..] ++ "b"[0..], "ab");
286	expectEqualSlices("a"[0..:0] ++ "b"[0..:0], "ab");	286	try expectEqualSlices("a"[0.. :0] ++ "b"[0.. :0], "ab");
287	}	287	}
288	};	288	};
289		289
290	S.doTheTest();	290	try S.doTheTest();
291	comptime S.doTheTest();	291	comptime try S.doTheTest();
292	}	292	}
293		293
294	test "slice of hardcoded address to pointer" {	294	test "slice of hardcoded address to pointer" {
295	const S = struct {	295	const S = struct {
296	fn doTheTest() void {	296	fn doTheTest() !void {
297	const pointer = @intToPtr([*]u8, 0x04)[0..2];	297	const pointer = @intToPtr([*]u8, 0x04)[0..2];
298	comptime expect(@TypeOf(pointer) == *[2]u8);	298	comptime try expect(@TypeOf(pointer) == *[2]u8);
299	const slice: []const u8 = pointer;	299	const slice: []const u8 = pointer;
300	expect(@ptrToInt(slice.ptr) == 4);	300	try expect(@ptrToInt(slice.ptr) == 4);
301	expect(slice.len == 2);	301	try expect(slice.len == 2);
302	}	302	}
303	};	303	};
304		304
305	S.doTheTest();	305	try S.doTheTest();
306	}	306	}
307		307
308	test "type coercion of pointer to anon struct literal to pointer to slice" {	308	test "type coercion of pointer to anon struct literal to pointer to slice" {
309	const S = struct {	309	const S = struct {
310	const U = union{	310	const U = union {
311	a: u32,	311	a: u32,
312	b: bool,	312	b: bool,
313	c: []const u8,	313	c: []const u8,
314	};	314	};
315		315
316	fn doTheTest() void {	316	fn doTheTest() !void {
317	var x1: u8 = 42;	317	var x1: u8 = 42;
318	const t1 = &.{ x1, 56, 54 };	318	const t1 = &.{ x1, 56, 54 };
319	var slice1: []const u8 = t1;	319	var slice1: []const u8 = t1;
320	expect(slice1.len == 3);	320	try expect(slice1.len == 3);
321	expect(slice1[0] == 42);	321	try expect(slice1[0] == 42);
322	expect(slice1[1] == 56);	322	try expect(slice1[1] == 56);
323	expect(slice1[2] == 54);	323	try expect(slice1[2] == 54);
324		324
325	var x2: []const u8 = "hello";	325	var x2: []const u8 = "hello";
326	const t2 = &.{ x2, ", ", "world!" };	326	const t2 = &.{ x2, ", ", "world!" };
327	// @compileLog(@TypeOf(t2));	327	// @compileLog(@TypeOf(t2));
328	var slice2: []const []const u8 = t2;	328	var slice2: []const []const u8 = t2;
329	expect(slice2.len == 3);	329	try expect(slice2.len == 3);
330	expect(mem.eql(u8, slice2[0], "hello"));	330	try expect(mem.eql(u8, slice2[0], "hello"));
331	expect(mem.eql(u8, slice2[1], ", "));	331	try expect(mem.eql(u8, slice2[1], ", "));
332	expect(mem.eql(u8, slice2[2], "world!"));	332	try expect(mem.eql(u8, slice2[2], "world!"));
333	}	333	}
334	};	334	};
335	// S.doTheTest();	335	// try S.doTheTest();
336	comptime S.doTheTest();	336	comptime try S.doTheTest();
337	}	337	}

test/stage1/behavior/src.zig+8-8

...	@@ -2,16 +2,16 @@ const std = @import("std");	...	@@ -2,16 +2,16 @@ const std = @import("std");
2	const expect = std.testing.expect;	2	const expect = std.testing.expect;
3		3
4	test "@src" {	4	test "@src" {
5	doTheTest();	5	try doTheTest();
6	}	6	}
7		7
8	fn doTheTest() void {	8	fn doTheTest() !void {
9	const src = @src();	9	const src = @src();
10		10
11	expect(src.line == 9);	11	try expect(src.line == 9);
12	expect(src.column == 17);	12	try expect(src.column == 17);
13	expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));	13	try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
14	expect(std.mem.endsWith(u8, src.file, "src.zig"));	14	try expect(std.mem.endsWith(u8, src.file, "src.zig"));
15	expect(src.fn_name[src.fn_name.len] == 0);	15	try expect(src.fn_name[src.fn_name.len] == 0);
16	expect(src.file[src.file.len] == 0);	16	try expect(src.file[src.file.len] == 0);
17	}	17	}

test/stage1/behavior/struct.zig+191-190

 @@ -18,12 +18,12 @@ test "top level fields" {
         .top_level_field = 1234,
     };
     instance.top_level_field += 1;
-    expectEqual(@as(i32, 1235), instance.top_level_field);
+    try expectEqual(@as(i32, 1235), instance.top_level_field);
 }
 test "call struct static method" {
     const result = StructWithNoFields.add(3, 4);
-    expect(result == 7);
+    try expect(result == 7);
 }
 test "return empty struct instance" {
 @@ -36,7 +36,7 @@ fn returnEmptyStructInstance() StructWithNoFields {
 const should_be_11 = StructWithNoFields.add(5, 6);
 test "invoke static method in global scope" {
-    expect(should_be_11 == 11);
+    try expect(should_be_11 == 11);
 }
 test "void struct fields" {
 @@ -45,8 +45,8 @@ test "void struct fields" {
         .b = 1,
         .c = void{},
     };
-    expect(foo.b == 1);
+    try expect(foo.b == 1);
-    expect(@sizeOf(VoidStructFieldsFoo) == 4);
+    try expect(@sizeOf(VoidStructFieldsFoo) == 4);
 }
 const VoidStructFieldsFoo = struct {
     a: void,
 @@ -59,17 +59,17 @@ test "structs" {
     @memset(@ptrCast([*]u8, &foo), 0, @sizeOf(StructFoo));
     foo.a += 1;
     foo.b = foo.a == 1;
-    testFoo(foo);
+    try testFoo(foo);
     testMutation(&foo);
-    expect(foo.c == 100);
+    try expect(foo.c == 100);
 }
 const StructFoo = struct {
     a: i32,
     b: bool,
     c: f32,
 };
-fn testFoo(foo: StructFoo) void {
+fn testFoo(foo: StructFoo) !void {
-    expect(foo.b);
+    try expect(foo.b);
 }
 fn testMutation(foo: *StructFoo) void {
     foo.c = 100;
 @@ -94,7 +94,7 @@ test "struct point to self" {
     root.next = &node;
-    expect(node.next.next.next.val.x == 1);
+    try expect(node.next.next.next.val.x == 1);
 }
 test "struct byval assign" {
 @@ -103,14 +103,14 @@ test "struct byval assign" {
     foo1.a = 1234;
     foo2.a = 0;
-    expect(foo2.a == 0);
+    try expect(foo2.a == 0);
     foo2 = foo1;
-    expect(foo2.a == 1234);
+    try expect(foo2.a == 1234);
 }
 fn structInitializer() void {
     const val = Val{ .x = 42 };
-    expect(val.x == 42);
+    try expect(val.x == 42);
 }
 test "fn call of struct field" {
 @@ -127,14 +127,14 @@ test "fn call of struct field" {
         }
     };
-    expect(S.callStructField(Foo{ .ptr = S.aFunc }) == 13);
+    try expect(S.callStructField(Foo{ .ptr = S.aFunc }) == 13);
 }
 test "store member function in variable" {
     const instance = MemberFnTestFoo{ .x = 1234 };
     const memberFn = MemberFnTestFoo.member;
     const result = memberFn(instance);
-    expect(result == 1234);
+    try expect(result == 1234);
 }
 const MemberFnTestFoo = struct {
     x: i32,
 @@ -146,12 +146,12 @@ const MemberFnTestFoo = struct {
 test "call member function directly" {
     const instance = MemberFnTestFoo{ .x = 1234 };
     const result = MemberFnTestFoo.member(instance);
-    expect(result == 1234);
+    try expect(result == 1234);
 }
 test "member functions" {
     const r = MemberFnRand{ .seed = 1234 };
-    expect(r.getSeed() == 1234);
+    try expect(r.getSeed() == 1234);
 }
 const MemberFnRand = struct {
     seed: u32,
 @@ -162,7 +162,7 @@ const MemberFnRand = struct {
 test "return struct byval from function" {
     const bar = makeBar(1234, 5678);
-    expect(bar.y == 5678);
+    try expect(bar.y == 5678);
 }
 const Bar = struct {
     x: i32,
 @@ -177,7 +177,7 @@ fn makeBar(x: i32, y: i32) Bar {
 test "empty struct method call" {
     const es = EmptyStruct{};
-    expect(es.method() == 1234);
+    try expect(es.method() == 1234);
 }
 const EmptyStruct = struct {
     fn method(es: *const EmptyStruct) i32 {
 @@ -194,7 +194,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
 }
 test "pass slice of empty struct to fn" {
-    expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
+    try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
 }
 fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {
     return slice.len;
 @@ -212,7 +212,7 @@ test "packed struct" {
     };
     foo.y += 1;
     const four = foo.x + foo.y;
-    expect(four == 4);
+    try expect(four == 4);
 }
 const BitField1 = packed struct {
 @@ -229,17 +229,17 @@ const bit_field_1 = BitField1{
 test "bit field access" {
     var data = bit_field_1;
-    expect(getA(&data) == 1);
+    try expect(getA(&data) == 1);
-    expect(getB(&data) == 2);
+    try expect(getB(&data) == 2);
-    expect(getC(&data) == 3);
+    try expect(getC(&data) == 3);
-    comptime expect(@sizeOf(BitField1) == 1);
+    comptime try expect(@sizeOf(BitField1) == 1);
     data.b += 1;
-    expect(data.b == 3);
+    try expect(data.b == 3);
     data.a += 1;
-    expect(data.a == 2);
+    try expect(data.a == 2);
-    expect(data.b == 3);
+    try expect(data.b == 3);
 }
 fn getA(data: *const BitField1) u3 {
 @@ -266,11 +266,11 @@ const Foo96Bits = packed struct {
 test "packed struct 24bits" {
     comptime {
-        expect(@sizeOf(Foo24Bits) == 4);
+        try expect(@sizeOf(Foo24Bits) == 4);
         if (@sizeOf(usize) == 4) {
-            expect(@sizeOf(Foo96Bits) == 12);
+            try expect(@sizeOf(Foo96Bits) == 12);
         } else {
-            expect(@sizeOf(Foo96Bits) == 16);
+            try expect(@sizeOf(Foo96Bits) == 16);
         }
     }
 @@ -281,28 +281,28 @@ test "packed struct 24bits" {
         .d = 0,
     };
     value.a += 1;
-    expect(value.a == 1);
+    try expect(value.a == 1);
-    expect(value.b == 0);
+    try expect(value.b == 0);
-    expect(value.c == 0);
+    try expect(value.c == 0);
-    expect(value.d == 0);
+    try expect(value.d == 0);
     value.b += 1;
-    expect(value.a == 1);
+    try expect(value.a == 1);
-    expect(value.b == 1);
+    try expect(value.b == 1);
-    expect(value.c == 0);
+    try expect(value.c == 0);
-    expect(value.d == 0);
+    try expect(value.d == 0);
     value.c += 1;
-    expect(value.a == 1);
+    try expect(value.a == 1);
-    expect(value.b == 1);
+    try expect(value.b == 1);
-    expect(value.c == 1);
+    try expect(value.c == 1);
-    expect(value.d == 0);
+    try expect(value.d == 0);
     value.d += 1;
-    expect(value.a == 1);
+    try expect(value.a == 1);
-    expect(value.b == 1);
+    try expect(value.b == 1);
-    expect(value.c == 1);
+    try expect(value.c == 1);
-    expect(value.d == 1);
+    try expect(value.d == 1);
 }
 const Foo32Bits = packed struct {
 @@ -319,43 +319,43 @@ const FooArray24Bits = packed struct {
 // TODO revisit this test when doing https://github.com/ziglang/zig/issues/1512
 test "packed array 24bits" {
     comptime {
-        expect(@sizeOf([9]Foo32Bits) == 9 * 4);
+        try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
-        expect(@sizeOf(FooArray24Bits) == 2 + 2 * 4 + 2);
+        try expect(@sizeOf(FooArray24Bits) == 2 + 2 * 4 + 2);
     }
     var bytes = [_]u8{0} ** (@sizeOf(FooArray24Bits) + 1);
     bytes[bytes.len - 1] = 0xaa;
     const ptr = &std.mem.bytesAsSlice(FooArray24Bits, bytes[0 .. bytes.len - 1])[0];
-    expect(ptr.a == 0);
+    try expect(ptr.a == 0);
-    expect(ptr.b[0].field == 0);
+    try expect(ptr.b[0].field == 0);
-    expect(ptr.b[1].field == 0);
+    try expect(ptr.b[1].field == 0);
-    expect(ptr.c == 0);
+    try expect(ptr.c == 0);
     ptr.a = maxInt(u16);
-    expect(ptr.a == maxInt(u16));
+    try expect(ptr.a == maxInt(u16));
-    expect(ptr.b[0].field == 0);
+    try expect(ptr.b[0].field == 0);
-    expect(ptr.b[1].field == 0);
+    try expect(ptr.b[1].field == 0);
-    expect(ptr.c == 0);
+    try expect(ptr.c == 0);
     ptr.b[0].field = maxInt(u24);
-    expect(ptr.a == maxInt(u16));
+    try expect(ptr.a == maxInt(u16));
-    expect(ptr.b[0].field == maxInt(u24));
+    try expect(ptr.b[0].field == maxInt(u24));
-    expect(ptr.b[1].field == 0);
+    try expect(ptr.b[1].field == 0);
-    expect(ptr.c == 0);
+    try expect(ptr.c == 0);
     ptr.b[1].field = maxInt(u24);
-    expect(ptr.a == maxInt(u16));
+    try expect(ptr.a == maxInt(u16));
-    expect(ptr.b[0].field == maxInt(u24));
+    try expect(ptr.b[0].field == maxInt(u24));
-    expect(ptr.b[1].field == maxInt(u24));
+    try expect(ptr.b[1].field == maxInt(u24));
-    expect(ptr.c == 0);
+    try expect(ptr.c == 0);
     ptr.c = maxInt(u16);
-    expect(ptr.a == maxInt(u16));
+    try expect(ptr.a == maxInt(u16));
-    expect(ptr.b[0].field == maxInt(u24));
+    try expect(ptr.b[0].field == maxInt(u24));
-    expect(ptr.b[1].field == maxInt(u24));
+    try expect(ptr.b[1].field == maxInt(u24));
-    expect(ptr.c == maxInt(u16));
+    try expect(ptr.c == maxInt(u16));
-    expect(bytes[bytes.len - 1] == 0xaa);
+    try expect(bytes[bytes.len - 1] == 0xaa);
 }
 const FooStructAligned = packed struct {
 @@ -369,17 +369,17 @@ const FooArrayOfAligned = packed struct {
 test "aligned array of packed struct" {
     comptime {
-        expect(@sizeOf(FooStructAligned) == 2);
+        try expect(@sizeOf(FooStructAligned) == 2);
-        expect(@sizeOf(FooArrayOfAligned) == 2 * 2);
+        try expect(@sizeOf(FooArrayOfAligned) == 2 * 2);
     }
     var bytes = [_]u8{0xbb} ** @sizeOf(FooArrayOfAligned);
     const ptr = &std.mem.bytesAsSlice(FooArrayOfAligned, bytes[0..])[0];
-    expect(ptr.a[0].a == 0xbb);
+    try expect(ptr.a[0].a == 0xbb);
-    expect(ptr.a[0].b == 0xbb);
+    try expect(ptr.a[0].b == 0xbb);
-    expect(ptr.a[1].a == 0xbb);
+    try expect(ptr.a[1].a == 0xbb);
-    expect(ptr.a[1].b == 0xbb);
+    try expect(ptr.a[1].b == 0xbb);
 }
 test "runtime struct initialization of bitfield" {
 @@ -392,10 +392,10 @@ test "runtime struct initialization of bitfield" {
         .y = @intCast(u4, x2),
     };
-    expect(s1.x == x1);
+    try expect(s1.x == x1);
-    expect(s1.y == x1);
+    try expect(s1.y == x1);
-    expect(s2.x == @intCast(u4, x2));
+    try expect(s2.x == @intCast(u4, x2));
-    expect(s2.y == @intCast(u4, x2));
+    try expect(s2.y == @intCast(u4, x2));
 }
 var x1 = @as(u4, 1);
 @@ -425,18 +425,18 @@ test "native bit field understands endianness" {
     @memcpy(&bytes, @ptrCast([*]u8, &all), 8);
     var bitfields = @ptrCast(*Bitfields, &bytes).*;
-    expect(bitfields.f1 == 0x1111);
+    try expect(bitfields.f1 == 0x1111);
-    expect(bitfields.f2 == 0x2222);
+    try expect(bitfields.f2 == 0x2222);
-    expect(bitfields.f3 == 0x33);
+    try expect(bitfields.f3 == 0x33);
-    expect(bitfields.f4 == 0x44);
+    try expect(bitfields.f4 == 0x44);
-    expect(bitfields.f5 == 0x5);
+    try expect(bitfields.f5 == 0x5);
-    expect(bitfields.f6 == 0x6);
+    try expect(bitfields.f6 == 0x6);
-    expect(bitfields.f7 == 0x77);
+    try expect(bitfields.f7 == 0x77);
 }
 test "align 1 field before self referential align 8 field as slice return type" {
     const result = alloc(Expr);
-    expect(result.len == 0);
+    try expect(result.len == 0);
 }
 const Expr = union(enum) {
 @@ -459,10 +459,10 @@ test "call method with mutable reference to struct with no fields" {
     };
     var s = S{};
-    expect(S.doC(&s));
+    try expect(S.doC(&s));
-    expect(s.doC());
+    try expect(s.doC());
-    expect(S.do(&s));
+    try expect(S.do(&s));
-    expect(s.do());
+    try expect(s.do());
 }
 test "implicit cast packed struct field to const ptr" {
 @@ -478,7 +478,7 @@ test "implicit cast packed struct field to const ptr" {
     var lup: LevelUpMove = undefined;
     lup.level = 12;
     const res = LevelUpMove.toInt(lup.level);
-    expect(res == 12);
+    try expect(res == 12);
 }
 test "pointer to packed struct member in a stack variable" {
 @@ -489,9 +489,9 @@ test "pointer to packed struct member in a stack variable" {
     var s = S{ .a = 2, .b = 0 };
     var b_ptr = &s.b;
-    expect(s.b == 0);
+    try expect(s.b == 0);
     b_ptr.* = 2;
-    expect(s.b == 2);
+    try expect(s.b == 2);
 }
 test "non-byte-aligned array inside packed struct" {
 @@ -500,20 +500,20 @@ test "non-byte-aligned array inside packed struct" {
         b: [0x16]u8,
     };
     const S = struct {
-        fn bar(slice: []const u8) void {
+        fn bar(slice: []const u8) !void {
-            expectEqualSlices(u8, slice, "abcdefghijklmnopqurstu");
+            try expectEqualSlices(u8, slice, "abcdefghijklmnopqurstu");
         }
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var foo = Foo{
                 .a = true,
                 .b = "abcdefghijklmnopqurstu".*,
             };
             const value = foo.b;
-            bar(&value);
+            try bar(&value);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "packed struct with u0 field access" {
 @@ -521,7 +521,7 @@ test "packed struct with u0 field access" {
         f0: u0,
     };
     var s = S{ .f0 = 0 };
-    comptime expect(s.f0 == 0);
+    comptime try expect(s.f0 == 0);
 }
 const S0 = struct {
 @@ -540,7 +540,7 @@ var g_foo: S0 = S0.init();
 test "access to global struct fields" {
     g_foo.bar.value = 42;
-    expect(g_foo.bar.value == 42);
+    try expect(g_foo.bar.value == 42);
 }
 test "packed struct with fp fields" {
 @@ -559,9 +559,9 @@ test "packed struct with fp fields" {
     s.data[1] = 2.0;
     s.data[2] = 3.0;
     s.frob();
-    expectEqual(@as(f32, 6.0), s.data[0]);
+    try expectEqual(@as(f32, 6.0), s.data[0]);
-    expectEqual(@as(f32, 11.0), s.data[1]);
+    try expectEqual(@as(f32, 11.0), s.data[1]);
-    expectEqual(@as(f32, 20.0), s.data[2]);
+    try expectEqual(@as(f32, 20.0), s.data[2]);
 }
 test "use within struct scope" {
 @@ -572,7 +572,7 @@ test "use within struct scope" {
             }
         };
     };
-    expectEqual(@as(i32, 42), S.inner());
+    try expectEqual(@as(i32, 42), S.inner());
 }
 test "default struct initialization fields" {
 @@ -590,14 +590,14 @@ test "default struct initialization fields" {
     const y = S{
         .b = five,
     };
-    expectEqual(1239, x.a + x.b);
+    try expectEqual(1239, x.a + x.b);
 }
 test "fn with C calling convention returns struct by value" {
     const S = struct {
-        fn entry() void {
+        fn entry() !void {
             var x = makeBar(10);
-            expectEqual(@as(i32, 10), x.handle);
+            try expectEqual(@as(i32, 10), x.handle);
         }
         const ExternBar = extern struct {
 @@ -610,8 +610,8 @@ test "fn with C calling convention returns struct by value" {
             };
         }
     };
-    S.entry();
+    try S.entry();
-    comptime S.entry();
+    comptime try S.entry();
 }
 test "for loop over pointers to struct, getting field from struct pointer" {
 @@ -632,7 +632,7 @@ test "for loop over pointers to struct, getting field from struct pointer" {
             }
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var objects: ArrayList = undefined;
             for (objects.toSlice()) |obj| {
 @@ -641,10 +641,10 @@ test "for loop over pointers to struct, getting field from struct pointer" {
                 }
             }
-            expect(ok);
+            try expect(ok);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
 }
 test "zero-bit field in packed struct" {
 @@ -657,20 +657,20 @@ test "zero-bit field in packed struct" {
 test "struct field init with catch" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var x: anyerror!isize = 1;
             var req = Foo{
                 .field = x catch undefined,
             };
-            expect(req.field == 1);
+            try expect(req.field == 1);
         }
         pub const Foo = extern struct {
             field: isize,
         };
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "packed struct with non-ABI-aligned field" {
 @@ -681,8 +681,8 @@ test "packed struct with non-ABI-aligned field" {
     var s: S = undefined;
     s.x = 1;
     s.y = 42;
-    expect(s.x == 1);
+    try expect(s.x == 1);
-    expect(s.y == 42);
+    try expect(s.y == 42);
 }
 test "non-packed struct with u128 entry in union" {
 @@ -698,10 +698,10 @@ test "non-packed struct with u128 entry in union" {
     var sx: S = undefined;
     var s = &sx;
-    std.testing.expect(@ptrToInt(&s.f2) - @ptrToInt(&s.f1) == @byteOffsetOf(S, "f2"));
+    try std.testing.expect(@ptrToInt(&s.f2) - @ptrToInt(&s.f1) == @byteOffsetOf(S, "f2"));
     var v2 = U{ .Num = 123 };
     s.f2 = v2;
-    std.testing.expect(s.f2.Num == 123);
+    try std.testing.expect(s.f2.Num == 123);
 }
 test "packed struct field passed to generic function" {
 @@ -721,7 +721,7 @@ test "packed struct field passed to generic function" {
     var p: S.P = undefined;
     p.b = 29;
     var loaded = S.genericReadPackedField(&p.b);
-    expect(loaded == 29);
+    try expect(loaded == 29);
 }
 test "anonymous struct literal syntax" {
 @@ -731,63 +731,63 @@ test "anonymous struct literal syntax" {
             y: i32,
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var p: Point = .{
                 .x = 1,
                 .y = 2,
             };
-            expect(p.x == 1);
+            try expect(p.x == 1);
-            expect(p.y == 2);
+            try expect(p.y == 2);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "fully anonymous struct" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
-            dump(.{
+            try dump(.{
                 .int = @as(u32, 1234),
                 .float = @as(f64, 12.34),
                 .b = true,
                 .s = "hi",
             });
         }
-        fn dump(args: anytype) void {
+        fn dump(args: anytype) !void {
-            expect(args.int == 1234);
+            try expect(args.int == 1234);
-            expect(args.float == 12.34);
+            try expect(args.float == 12.34);
-            expect(args.b);
+            try expect(args.b);
-            expect(args.s[0] == 'h');
+            try expect(args.s[0] == 'h');
-            expect(args.s[1] == 'i');
+            try expect(args.s[1] == 'i');
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "fully anonymous list literal" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
-            dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
+            try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
         }
-        fn dump(args: anytype) void {
+        fn dump(args: anytype) !void {
-            expect(args.@"0" == 1234);
+            try expect(args.@"0" == 1234);
-            expect(args.@"1" == 12.34);
+            try expect(args.@"1" == 12.34);
-            expect(args.@"2");
+            try expect(args.@"2");
-            expect(args.@"3"[0] == 'h');
+            try expect(args.@"3"[0] == 'h');
-            expect(args.@"3"[1] == 'i');
+            try expect(args.@"3"[1] == 'i');
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "anonymous struct literal assigned to variable" {
     var vec = .{ @as(i32, 22), @as(i32, 55), @as(i32, 99) };
-    expect(vec.@"0" == 22);
+    try expect(vec.@"0" == 22);
-    expect(vec.@"1" == 55);
+    try expect(vec.@"1" == 55);
-    expect(vec.@"2" == 99);
+    try expect(vec.@"2" == 99);
 }
 test "struct with var field" {
 @@ -799,8 +799,8 @@ test "struct with var field" {
         .x = 1,
         .y = 2,
     };
-    expect(pt.x == 1);
+    try expect(pt.x == 1);
-    expect(pt.y == 2);
+    try expect(pt.y == 2);
 }
 test "comptime struct field" {
 @@ -810,21 +810,21 @@ test "comptime struct field" {
     };
     var foo: T = undefined;
-    comptime expect(foo.b == 1234);
+    comptime try expect(foo.b == 1234);
 }
 test "anon struct literal field value initialized with fn call" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var x = .{foo()};
-            expectEqualSlices(u8, x[0], "hi");
+            try expectEqualSlices(u8, x[0], "hi");
         }
         fn foo() []const u8 {
             return "hi";
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "self-referencing struct via array member" {
 @@ -833,7 +833,7 @@ test "self-referencing struct via array member" {
     };
     var x: T = undefined;
     x = T{ .children = .{&x} };
-    expect(x.children[0] == &x);
+    try expect(x.children[0] == &x);
 }
 test "struct with union field" {
 @@ -848,8 +848,8 @@ test "struct with union field" {
     var True = Value{
         .kind = .{ .Bool = true },
     };
-    expectEqual(@as(u32, 2), True.ref);
+    try expectEqual(@as(u32, 2), True.ref);
-    expectEqual(true, True.kind.Bool);
+    try expectEqual(true, True.kind.Bool);
 }
 test "type coercion of anon struct literal to struct" {
 @@ -865,24 +865,24 @@ test "type coercion of anon struct literal to struct" {
             field: i32 = 1234,
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var y: u32 = 42;
             const t0 = .{ .A = 123, .B = "foo", .C = {} };
             const t1 = .{ .A = y, .B = "foo", .C = {} };
             const y0: S2 = t0;
             var y1: S2 = t1;
-            expect(y0.A == 123);
+            try expect(y0.A == 123);
-            expect(std.mem.eql(u8, y0.B, "foo"));
+            try expect(std.mem.eql(u8, y0.B, "foo"));
-            expect(y0.C == {});
+            try expect(y0.C == {});
-            expect(y0.D.field == 1234);
+            try expect(y0.D.field == 1234);
-            expect(y1.A == y);
+            try expect(y1.A == y);
-            expect(std.mem.eql(u8, y1.B, "foo"));
+            try expect(std.mem.eql(u8, y1.B, "foo"));
-            expect(y1.C == {});
+            try expect(y1.C == {});
-            expect(y1.D.field == 1234);
+            try expect(y1.D.field == 1234);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "type coercion of pointer to anon struct literal to pointer to struct" {
 @@ -898,24 +898,24 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
             field: i32 = 1234,
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var y: u32 = 42;
             const t0 = &.{ .A = 123, .B = "foo", .C = {} };
             const t1 = &.{ .A = y, .B = "foo", .C = {} };
             const y0: *const S2 = t0;
             var y1: *const S2 = t1;
-            expect(y0.A == 123);
+            try expect(y0.A == 123);
-            expect(std.mem.eql(u8, y0.B, "foo"));
+            try expect(std.mem.eql(u8, y0.B, "foo"));
-            expect(y0.C == {});
+            try expect(y0.C == {});
-            expect(y0.D.field == 1234);
+            try expect(y0.D.field == 1234);
-            expect(y1.A == y);
+            try expect(y1.A == y);
-            expect(std.mem.eql(u8, y1.B, "foo"));
+            try expect(std.mem.eql(u8, y1.B, "foo"));
-            expect(y1.C == {});
+            try expect(y1.C == {});
-            expect(y1.D.field == 1234);
+            try expect(y1.D.field == 1234);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }
 test "packed struct with undefined initializers" {
 @@ -929,16 +929,17 @@ test "packed struct with undefined initializers" {
             _c: u3 = undefined,
         };
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var p: P = undefined;
             p = P{ .a = 2, .b = 4, .c = 6 };
             // Make sure the compiler doesn't touch the unprefixed fields.
-            expectEqual(@as(u3, 2), p.a);
+            // Use expect since i386-linux doesn't like expectEqual
-            expectEqual(@as(u3, 4), p.b);
+            try expect(p.a == 2);
-            expectEqual(@as(u3, 6), p.c);
+            try expect(p.b == 4);
+            try expect(p.c == 6);
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }

test/stage1/behavior/struct_contains_null_ptr_itself.zig+1-1

...	@@ -3,7 +3,7 @@ const expect = std.testing.expect;	...	@@ -3,7 +3,7 @@ const expect = std.testing.expect;
3		3
4	test "struct contains null pointer which contains original struct" {	4	test "struct contains null pointer which contains original struct" {
5	var x: ?*NodeLineComment = null;	5	var x: ?*NodeLineComment = null;
6	expect(x == null);	6	try expect(x == null);
7	}	7	}
8		8
9	pub const Node = struct {	9	pub const Node = struct {

test/stage1/behavior/struct_contains_slice_of_itself.zig+12-12

test/stage1/behavior/switch.zig+104-104

...	@@ -4,23 +4,23 @@ const expectError = std.testing.expectError;	...	@@ -4,23 +4,23 @@ const expectError = std.testing.expectError;
4	const expectEqual = std.testing.expectEqual;	4	const expectEqual = std.testing.expectEqual;
5		5
6	test "switch with numbers" {	6	test "switch with numbers" {
7	testSwitchWithNumbers(13);	7	try testSwitchWithNumbers(13);
8	}	8	}
9		9
10	fn testSwitchWithNumbers(x: u32) void {	10	fn testSwitchWithNumbers(x: u32) !void {
11	const result = switch (x) {	11	const result = switch (x) {
12	1, 2, 3, 4...8 => false,	12	1, 2, 3, 4...8 => false,
13	13 => true,	13	13 => true,
14	else => false,	14	else => false,
15	};	15	};
16	expect(result);	16	try expect(result);
17	}	17	}
18		18
19	test "switch with all ranges" {	19	test "switch with all ranges" {
20	expect(testSwitchWithAllRanges(50, 3) == 1);	20	try expect(testSwitchWithAllRanges(50, 3) == 1);
21	expect(testSwitchWithAllRanges(101, 0) == 2);	21	try expect(testSwitchWithAllRanges(101, 0) == 2);
22	expect(testSwitchWithAllRanges(300, 5) == 3);	22	try expect(testSwitchWithAllRanges(300, 5) == 3);
23	expect(testSwitchWithAllRanges(301, 6) == 6);	23	try expect(testSwitchWithAllRanges(301, 6) == 6);
24	}	24	}
25		25
26	fn testSwitchWithAllRanges(x: u32, y: u32) u32 {	26	fn testSwitchWithAllRanges(x: u32, y: u32) u32 {
...	@@ -43,7 +43,7 @@ test "implicit comptime switch" {	...	@@ -43,7 +43,7 @@ test "implicit comptime switch" {
43	};	43	};
44		44
45	comptime {	45	comptime {
46	expect(result + 1 == 14);	46	try expect(result + 1 == 14);
47	}	47	}
48	}	48	}
49		49
...	@@ -65,16 +65,16 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {	...	@@ -65,16 +65,16 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {
65	}	65	}
66		66
67	test "switch statement" {	67	test "switch statement" {
68	nonConstSwitch(SwitchStatmentFoo.C);	68	try nonConstSwitch(SwitchStatmentFoo.C);
69	}	69	}
70	fn nonConstSwitch(foo: SwitchStatmentFoo) void {	70	fn nonConstSwitch(foo: SwitchStatmentFoo) !void {
71	const val = switch (foo) {	71	const val = switch (foo) {
72	SwitchStatmentFoo.A => @as(i32, 1),	72	SwitchStatmentFoo.A => @as(i32, 1),
73	SwitchStatmentFoo.B => 2,	73	SwitchStatmentFoo.B => 2,
74	SwitchStatmentFoo.C => 3,	74	SwitchStatmentFoo.C => 3,
75	SwitchStatmentFoo.D => 4,	75	SwitchStatmentFoo.D => 4,
76	};	76	};
77	expect(val == 3);	77	try expect(val == 3);
78	}	78	}
79	const SwitchStatmentFoo = enum {	79	const SwitchStatmentFoo = enum {
80	A,	80	A,
...	@@ -84,22 +84,22 @@ const SwitchStatmentFoo = enum {	...	@@ -84,22 +84,22 @@ const SwitchStatmentFoo = enum {
84	};	84	};
85		85
86	test "switch prong with variable" {	86	test "switch prong with variable" {
87	switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });	87	try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
88	switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });	88	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
89	switchProngWithVarFn(SwitchProngWithVarEnum{ .Meh = {} });	89	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Meh = {} });
90	}	90	}
91	const SwitchProngWithVarEnum = union(enum) {	91	const SwitchProngWithVarEnum = union(enum) {
92	One: i32,	92	One: i32,
93	Two: f32,	93	Two: f32,
94	Meh: void,	94	Meh: void,
95	};	95	};
96	fn switchProngWithVarFn(a: SwitchProngWithVarEnum) void {	96	fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
97	switch (a) {	97	switch (a) {
98	SwitchProngWithVarEnum.One => \|x\| {	98	SwitchProngWithVarEnum.One => \|x\| {
99	expect(x == 13);	99	try expect(x == 13);
100	},	100	},
101	SwitchProngWithVarEnum.Two => \|x\| {	101	SwitchProngWithVarEnum.Two => \|x\| {
102	expect(x == 13.0);	102	try expect(x == 13.0);
103	},	103	},
104	SwitchProngWithVarEnum.Meh => \|x\| {	104	SwitchProngWithVarEnum.Meh => \|x\| {
105	const v: void = x;	105	const v: void = x;
...	@@ -108,18 +108,18 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) void {	...	@@ -108,18 +108,18 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) void {
108	}	108	}
109		109
110	test "switch on enum using pointer capture" {	110	test "switch on enum using pointer capture" {
111	testSwitchEnumPtrCapture();	111	try testSwitchEnumPtrCapture();
112	comptime testSwitchEnumPtrCapture();	112	comptime try testSwitchEnumPtrCapture();
113	}	113	}
114		114
115	fn testSwitchEnumPtrCapture() void {	115	fn testSwitchEnumPtrCapture() !void {
116	var value = SwitchProngWithVarEnum{ .One = 1234 };	116	var value = SwitchProngWithVarEnum{ .One = 1234 };
117	switch (value) {	117	switch (value) {
118	SwitchProngWithVarEnum.One => \|x\| x. += 1,	118	SwitchProngWithVarEnum.One => \|x\| x. += 1,
119	else => unreachable,	119	else => unreachable,
120	}	120	}
121	switch (value) {	121	switch (value) {
122	SwitchProngWithVarEnum.One => \|x\| expect(x == 1235),	122	SwitchProngWithVarEnum.One => \|x\| try expect(x == 1235),
123	else => unreachable,	123	else => unreachable,
124	}	124	}
125	}	125	}
...	@@ -130,7 +130,7 @@ test "switch with multiple expressions" {	...	@@ -130,7 +130,7 @@ test "switch with multiple expressions" {
130	4, 5, 6 => 2,	130	4, 5, 6 => 2,
131	else => @as(i32, 3),	131	else => @as(i32, 3),
132	};	132	};
133	expect(x == 2);	133	try expect(x == 2);
134	}	134	}
135	fn returnsFive() i32 {	135	fn returnsFive() i32 {
136	return 5;	136	return 5;
...	@@ -152,12 +152,12 @@ fn returnsFalse() bool {	...	@@ -152,12 +152,12 @@ fn returnsFalse() bool {
152	}	152	}
153	}	153	}
154	test "switch on const enum with var" {	154	test "switch on const enum with var" {
155	expect(!returnsFalse());	155	try expect(!returnsFalse());
156	}	156	}
157		157
158	test "switch on type" {	158	test "switch on type" {
159	expect(trueIfBoolFalseOtherwise(bool));	159	try expect(trueIfBoolFalseOtherwise(bool));
160	expect(!trueIfBoolFalseOtherwise(i32));	160	try expect(!trueIfBoolFalseOtherwise(i32));
161	}	161	}
162		162
163	fn trueIfBoolFalseOtherwise(comptime T: type) bool {	163	fn trueIfBoolFalseOtherwise(comptime T: type) bool {
...	@@ -168,21 +168,21 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {	...	@@ -168,21 +168,21 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
168	}	168	}
169		169
170	test "switch handles all cases of number" {	170	test "switch handles all cases of number" {
171	testSwitchHandleAllCases();	171	try testSwitchHandleAllCases();
172	comptime testSwitchHandleAllCases();	172	comptime try testSwitchHandleAllCases();
173	}	173	}
174		174
175	fn testSwitchHandleAllCases() void {	175	fn testSwitchHandleAllCases() !void {
176	expect(testSwitchHandleAllCasesExhaustive(0) == 3);	176	try expect(testSwitchHandleAllCasesExhaustive(0) == 3);
177	expect(testSwitchHandleAllCasesExhaustive(1) == 2);	177	try expect(testSwitchHandleAllCasesExhaustive(1) == 2);
178	expect(testSwitchHandleAllCasesExhaustive(2) == 1);	178	try expect(testSwitchHandleAllCasesExhaustive(2) == 1);
179	expect(testSwitchHandleAllCasesExhaustive(3) == 0);	179	try expect(testSwitchHandleAllCasesExhaustive(3) == 0);
180		180
181	expect(testSwitchHandleAllCasesRange(100) == 0);	181	try expect(testSwitchHandleAllCasesRange(100) == 0);
182	expect(testSwitchHandleAllCasesRange(200) == 1);	182	try expect(testSwitchHandleAllCasesRange(200) == 1);
183	expect(testSwitchHandleAllCasesRange(201) == 2);	183	try expect(testSwitchHandleAllCasesRange(201) == 2);
184	expect(testSwitchHandleAllCasesRange(202) == 4);	184	try expect(testSwitchHandleAllCasesRange(202) == 4);
185	expect(testSwitchHandleAllCasesRange(230) == 3);	185	try expect(testSwitchHandleAllCasesRange(230) == 3);
186	}	186	}
187		187
188	fn testSwitchHandleAllCasesExhaustive(x: u2) u2 {	188	fn testSwitchHandleAllCasesExhaustive(x: u2) u2 {
...	@@ -205,13 +205,13 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {	...	@@ -205,13 +205,13 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {
205	}	205	}
206		206
207	test "switch all prongs unreachable" {	207	test "switch all prongs unreachable" {
208	testAllProngsUnreachable();	208	try testAllProngsUnreachable();
209	comptime testAllProngsUnreachable();	209	comptime try testAllProngsUnreachable();
210	}	210	}
211		211
212	fn testAllProngsUnreachable() void {	212	fn testAllProngsUnreachable() !void {
213	expect(switchWithUnreachable(1) == 2);	213	try expect(switchWithUnreachable(1) == 2);
214	expect(switchWithUnreachable(2) == 10);	214	try expect(switchWithUnreachable(2) == 10);
215	}	215	}
216		216
217	fn switchWithUnreachable(x: i32) i32 {	217	fn switchWithUnreachable(x: i32) i32 {
...	@@ -233,23 +233,23 @@ test "capture value of switch with all unreachable prongs" {	...	@@ -233,23 +233,23 @@ test "capture value of switch with all unreachable prongs" {
233	const x = return_a_number() catch \|err\| switch (err) {	233	const x = return_a_number() catch \|err\| switch (err) {
234	else => unreachable,	234	else => unreachable,
235	};	235	};
236	expect(x == 1);	236	try expect(x == 1);
237	}	237	}
238		238
239	test "switching on booleans" {	239	test "switching on booleans" {
240	testSwitchOnBools();	240	try testSwitchOnBools();
241	comptime testSwitchOnBools();	241	comptime try testSwitchOnBools();
242	}	242	}
243		243
244	fn testSwitchOnBools() void {	244	fn testSwitchOnBools() !void {
245	expect(testSwitchOnBoolsTrueAndFalse(true) == false);	245	try expect(testSwitchOnBoolsTrueAndFalse(true) == false);
246	expect(testSwitchOnBoolsTrueAndFalse(false) == true);	246	try expect(testSwitchOnBoolsTrueAndFalse(false) == true);
247		247
248	expect(testSwitchOnBoolsTrueWithElse(true) == false);	248	try expect(testSwitchOnBoolsTrueWithElse(true) == false);
249	expect(testSwitchOnBoolsTrueWithElse(false) == true);	249	try expect(testSwitchOnBoolsTrueWithElse(false) == true);
250		250
251	expect(testSwitchOnBoolsFalseWithElse(true) == false);	251	try expect(testSwitchOnBoolsFalseWithElse(true) == false);
252	expect(testSwitchOnBoolsFalseWithElse(false) == true);	252	try expect(testSwitchOnBoolsFalseWithElse(false) == true);
253	}	253	}
254		254
255	fn testSwitchOnBoolsTrueAndFalse(x: bool) bool {	255	fn testSwitchOnBoolsTrueAndFalse(x: bool) bool {
...	@@ -276,14 +276,14 @@ fn testSwitchOnBoolsFalseWithElse(x: bool) bool {	...	@@ -276,14 +276,14 @@ fn testSwitchOnBoolsFalseWithElse(x: bool) bool {
276	test "u0" {	276	test "u0" {
277	var val: u0 = 0;	277	var val: u0 = 0;
278	switch (val) {	278	switch (val) {
279	0 => expect(val == 0),	279	0 => try expect(val == 0),
280	}	280	}
281	}	281	}
282		282
283	test "undefined.u0" {	283	test "undefined.u0" {
284	var val: u0 = undefined;	284	var val: u0 = undefined;
285	switch (val) {	285	switch (val) {
286	0 => expect(val == 0),	286	0 => try expect(val == 0),
287	}	287	}
288	}	288	}
289		289
...	@@ -295,15 +295,15 @@ test "anon enum literal used in switch on union enum" {	...	@@ -295,15 +295,15 @@ test "anon enum literal used in switch on union enum" {
295	var foo = Foo{ .a = 1234 };	295	var foo = Foo{ .a = 1234 };
296	switch (foo) {	296	switch (foo) {
297	.a => \|x\| {	297	.a => \|x\| {
298	expect(x == 1234);	298	try expect(x == 1234);
299	},	299	},
300	}	300	}
301	}	301	}
302		302
303	test "else prong of switch on error set excludes other cases" {	303	test "else prong of switch on error set excludes other cases" {
304	const S = struct {	304	const S = struct {
305	fn doTheTest() void {	305	fn doTheTest() !void {
306	expectError(error.C, bar());	306	try expectError(error.C, bar());
307	}	307	}
308	const E = error{	308	const E = error{
309	A,	309	A,
...	@@ -326,14 +326,14 @@ test "else prong of switch on error set excludes other cases" {	...	@@ -326,14 +326,14 @@ test "else prong of switch on error set excludes other cases" {
326	};	326	};
327	}	327	}
328	};	328	};
329	S.doTheTest();	329	try S.doTheTest();
330	comptime S.doTheTest();	330	comptime try S.doTheTest();
331	}	331	}
332		332
333	test "switch prongs with error set cases make a new error set type for capture value" {	333	test "switch prongs with error set cases make a new error set type for capture value" {
334	const S = struct {	334	const S = struct {
335	fn doTheTest() void {	335	fn doTheTest() !void {
336	expectError(error.B, bar());	336	try expectError(error.B, bar());
337	}	337	}
338	const E = E1 \|\| E2;	338	const E = E1 \|\| E2;
339		339
...	@@ -358,14 +358,14 @@ test "switch prongs with error set cases make a new error set type for capture v	...	@@ -358,14 +358,14 @@ test "switch prongs with error set cases make a new error set type for capture v
358	};	358	};
359	}	359	}
360	};	360	};
361	S.doTheTest();	361	try S.doTheTest();
362	comptime S.doTheTest();	362	comptime try S.doTheTest();
363	}	363	}
364		364
365	test "return result loc and then switch with range implicit casted to error union" {	365	test "return result loc and then switch with range implicit casted to error union" {
366	const S = struct {	366	const S = struct {
367	fn doTheTest() void {	367	fn doTheTest() !void {
368	expect((func(0xb) catch unreachable) == 0xb);	368	try expect((func(0xb) catch unreachable) == 0xb);
369	}	369	}
370	fn func(d: u8) anyerror!u8 {	370	fn func(d: u8) anyerror!u8 {
371	return switch (d) {	371	return switch (d) {
...	@@ -374,13 +374,13 @@ test "return result loc and then switch with range implicit casted to error unio	...	@@ -374,13 +374,13 @@ test "return result loc and then switch with range implicit casted to error unio
374	};	374	};
375	}	375	}
376	};	376	};
377	S.doTheTest();	377	try S.doTheTest();
378	comptime S.doTheTest();	378	comptime try S.doTheTest();
379	}	379	}
380		380
381	test "switch with null and T peer types and inferred result location type" {	381	test "switch with null and T peer types and inferred result location type" {
382	const S = struct {	382	const S = struct {
383	fn doTheTest(c: u8) void {	383	fn doTheTest(c: u8) !void {
384	if (switch (c) {	384	if (switch (c) {
385	0 => true,	385	0 => true,
386	else => null,	386	else => null,
...	@@ -389,8 +389,8 @@ test "switch with null and T peer types and inferred result location type" {	...	@@ -389,8 +389,8 @@ test "switch with null and T peer types and inferred result location type" {
389	}	389	}
390	}	390	}
391	};	391	};
392	S.doTheTest(1);	392	try S.doTheTest(1);
393	comptime S.doTheTest(1);	393	comptime try S.doTheTest(1);
394	}	394	}
395		395
396	test "switch prongs with cases with identical payload types" {	396	test "switch prongs with cases with identical payload types" {
...	@@ -400,31 +400,31 @@ test "switch prongs with cases with identical payload types" {	...	@@ -400,31 +400,31 @@ test "switch prongs with cases with identical payload types" {
400	C: usize,	400	C: usize,
401	};	401	};
402	const S = struct {	402	const S = struct {
403	fn doTheTest() void {	403	fn doTheTest() !void {
404	doTheSwitch1(Union{ .A = 8 });	404	try doTheSwitch1(Union{ .A = 8 });
405	doTheSwitch2(Union{ .B = -8 });	405	try doTheSwitch2(Union{ .B = -8 });
406	}	406	}
407	fn doTheSwitch1(u: Union) void {	407	fn doTheSwitch1(u: Union) !void {
408	switch (u) {	408	switch (u) {
409	.A, .C => \|e\| {	409	.A, .C => \|e\| {
410	expect(@TypeOf(e) == usize);	410	try expect(@TypeOf(e) == usize);
411	expect(e == 8);	411	try expect(e == 8);
412	},	412	},
413	.B => \|e\| @panic("fail"),	413	.B => \|e\| @panic("fail"),
414	}	414	}
415	}	415	}
416	fn doTheSwitch2(u: Union) void {	416	fn doTheSwitch2(u: Union) !void {
417	switch (u) {	417	switch (u) {
418	.A, .C => \|e\| @panic("fail"),	418	.A, .C => \|e\| @panic("fail"),
419	.B => \|e\| {	419	.B => \|e\| {
420	expect(@TypeOf(e) == isize);	420	try expect(@TypeOf(e) == isize);
421	expect(e == -8);	421	try expect(e == -8);
422	},	422	},
423	}	423	}
424	}	424	}
425	};	425	};
426	S.doTheTest();	426	try S.doTheTest();
427	comptime S.doTheTest();	427	comptime try S.doTheTest();
428	}	428	}
429		429
430	test "switch with disjoint range" {	430	test "switch with disjoint range" {
...	@@ -438,19 +438,19 @@ test "switch with disjoint range" {	...	@@ -438,19 +438,19 @@ test "switch with disjoint range" {
438		438
439	test "switch variable for range and multiple prongs" {	439	test "switch variable for range and multiple prongs" {
440	const S = struct {	440	const S = struct {
441	fn doTheTest() void {	441	fn doTheTest() !void {
442	var u: u8 = 16;	442	var u: u8 = 16;
443	doTheSwitch(u);	443	try doTheSwitch(u);
444	comptime doTheSwitch(u);	444	comptime try doTheSwitch(u);
445	var v: u8 = 42;	445	var v: u8 = 42;
446	doTheSwitch(v);	446	try doTheSwitch(v);
447	comptime doTheSwitch(v);	447	comptime try doTheSwitch(v);
448	}	448	}
449	fn doTheSwitch(q: u8) void {	449	fn doTheSwitch(q: u8) !void {
450	switch (q) {	450	switch (q) {
451	0...40 => \|x\| expect(x == 16),	451	0...40 => \|x\| try expect(x == 16),
452	41, 42, 43 => \|x\| expect(x == 42),	452	41, 42, 43 => \|x\| try expect(x == 42),
453	else => expect(false),	453	else => try expect(false),
454	}	454	}
455	}	455	}
456	};	456	};
...	@@ -493,31 +493,31 @@ test "switch on pointer type" {	...	@@ -493,31 +493,31 @@ test "switch on pointer type" {
493	}	493	}
494	};	494	};
495		495
496	expect(1 == S.doTheTest(S.P1));	496	try expect(1 == S.doTheTest(S.P1));
497	expect(2 == S.doTheTest(S.P2));	497	try expect(2 == S.doTheTest(S.P2));
498	expect(3 == S.doTheTest(S.P3));	498	try expect(3 == S.doTheTest(S.P3));
499	comptime expect(1 == S.doTheTest(S.P1));	499	comptime try expect(1 == S.doTheTest(S.P1));
500	comptime expect(2 == S.doTheTest(S.P2));	500	comptime try expect(2 == S.doTheTest(S.P2));
501	comptime expect(3 == S.doTheTest(S.P3));	501	comptime try expect(3 == S.doTheTest(S.P3));
502	}	502	}
503		503
504	test "switch on error set with single else" {	504	test "switch on error set with single else" {
505	const S = struct {	505	const S = struct {
506	fn doTheTest() void {	506	fn doTheTest() !void {
507	var some: error{Foo} = error.Foo;	507	var some: error{Foo} = error.Foo;
508	expect(switch (some) {	508	try expect(switch (some) {
509	else => \|a\| true,	509	else => \|a\| true,
510	});	510	});
511	}	511	}
512	};	512	};
513		513
514	S.doTheTest();	514	try S.doTheTest();
515	comptime S.doTheTest();	515	comptime try S.doTheTest();
516	}	516	}
517		517
518	test "while copies its payload" {	518	test "while copies its payload" {
519	const S = struct {	519	const S = struct {
520	fn doTheTest() void {	520	fn doTheTest() !void {
521	var tmp: union(enum) {	521	var tmp: union(enum) {
522	A: u8,	522	A: u8,
523	B: u32,	523	B: u32,
...	@@ -526,12 +526,12 @@ test "while copies its payload" {	...	@@ -526,12 +526,12 @@ test "while copies its payload" {
526	.A => \|value\| {	526	.A => \|value\| {
527	// Modify the original union	527	// Modify the original union
528	tmp = .{ .B = 0x10101010 };	528	tmp = .{ .B = 0x10101010 };
529	expectEqual(@as(u8, 42), value);	529	try expectEqual(@as(u8, 42), value);
530	},	530	},
531	else => unreachable,	531	else => unreachable,
532	}	532	}
533	}	533	}
534	};	534	};
535	S.doTheTest();	535	try S.doTheTest();
536	comptime S.doTheTest();	536	comptime try S.doTheTest();
537	}	537	}

test/stage1/behavior/switch_prong_err_enum.zig+2-2

...	@@ -22,9 +22,9 @@ fn doThing(form_id: u64) anyerror!FormValue {	...	@@ -22,9 +22,9 @@ fn doThing(form_id: u64) anyerror!FormValue {
22	test "switch prong returns error enum" {	22	test "switch prong returns error enum" {
23	switch (doThing(17) catch unreachable) {	23	switch (doThing(17) catch unreachable) {
24	FormValue.Address => \|payload\| {	24	FormValue.Address => \|payload\| {
25	expect(payload == 1);	25	try expect(payload == 1);
26	},	26	},
27	else => unreachable,	27	else => unreachable,
28	}	28	}
29	expect(read_count == 1);	29	try expect(read_count == 1);
30	}	30	}

test/stage1/behavior/switch_prong_implicit_cast.zig+1-1

...	@@ -18,5 +18,5 @@ test "switch prong implicit cast" {	...	@@ -18,5 +18,5 @@ test "switch prong implicit cast" {
18	FormValue.One => false,	18	FormValue.One => false,
19	FormValue.Two => \|x\| x,	19	FormValue.Two => \|x\| x,
20	};	20	};
21	expect(result);	21	try expect(result);
22	}	22	}

test/stage1/behavior/this.zig+3-3

...	@@ -20,7 +20,7 @@ fn add(x: i32, y: i32) i32 {	...	@@ -20,7 +20,7 @@ fn add(x: i32, y: i32) i32 {
20	}	20	}
21		21
22	test "this refer to module call private fn" {	22	test "this refer to module call private fn" {
23	expect(module.add(1, 2) == 3);	23	try expect(module.add(1, 2) == 3);
24	}	24	}
25		25
26	test "this refer to container" {	26	test "this refer to container" {
...	@@ -29,6 +29,6 @@ test "this refer to container" {	...	@@ -29,6 +29,6 @@ test "this refer to container" {
29	.y = 34,	29	.y = 34,
30	};	30	};
31	pt.addOne();	31	pt.addOne();
32	expect(pt.x == 13);	32	try expect(pt.x == 13);
33	expect(pt.y == 35);	33	try expect(pt.y == 35);
34	}	34	}

test/stage1/behavior/translate_c_macros.zig+4-4

...	@@ -4,7 +4,7 @@ const expectEqual = @import("std").testing.expectEqual;	...	@@ -4,7 +4,7 @@ const expectEqual = @import("std").testing.expectEqual;
4	const h = @cImport(@cInclude("stage1/behavior/translate_c_macros.h"));	4	const h = @cImport(@cInclude("stage1/behavior/translate_c_macros.h"));
5		5
6	test "initializer list expression" {	6	test "initializer list expression" {
7	expectEqual(h.Color{	7	try expectEqual(h.Color{
8	.r = 200,	8	.r = 200,
9	.g = 200,	9	.g = 200,
10	.b = 200,	10	.b = 200,
...	@@ -13,10 +13,10 @@ test "initializer list expression" {	...	@@ -13,10 +13,10 @@ test "initializer list expression" {
13	}	13	}
14		14
15	test "sizeof in macros" {	15	test "sizeof in macros" {
16	expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32));	16	try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32));
17	expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32));	17	try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32));
18	}	18	}
19		19
20	test "reference to a struct type" {	20	test "reference to a struct type" {
21	expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO);	21	try expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO);
22	}	22	}

test/stage1/behavior/truncate.zig+6-6

...	@@ -4,33 +4,33 @@ const expect = std.testing.expect;	...	@@ -4,33 +4,33 @@ const expect = std.testing.expect;
4	test "truncate u0 to larger integer allowed and has comptime known result" {	4	test "truncate u0 to larger integer allowed and has comptime known result" {
5	var x: u0 = 0;	5	var x: u0 = 0;
6	const y = @truncate(u8, x);	6	const y = @truncate(u8, x);
7	comptime expect(y == 0);	7	comptime try expect(y == 0);
8	}	8	}
9		9
10	test "truncate.u0.literal" {	10	test "truncate.u0.literal" {
11	var z = @truncate(u0, 0);	11	var z = @truncate(u0, 0);
12	expect(z == 0);	12	try expect(z == 0);
13	}	13	}
14		14
15	test "truncate.u0.const" {	15	test "truncate.u0.const" {
16	const c0: usize = 0;	16	const c0: usize = 0;
17	var z = @truncate(u0, c0);	17	var z = @truncate(u0, c0);
18	expect(z == 0);	18	try expect(z == 0);
19	}	19	}
20		20
21	test "truncate.u0.var" {	21	test "truncate.u0.var" {
22	var d: u8 = 2;	22	var d: u8 = 2;
23	var z = @truncate(u0, d);	23	var z = @truncate(u0, d);
24	expect(z == 0);	24	try expect(z == 0);
25	}	25	}
26		26
27	test "truncate sign mismatch but comptime known so it works anyway" {	27	test "truncate sign mismatch but comptime known so it works anyway" {
28	const x: u32 = 10;	28	const x: u32 = 10;
29	var result = @truncate(i8, x);	29	var result = @truncate(i8, x);
30	expect(result == 10);	30	try expect(result == 10);
31	}	31	}
32		32
33	test "truncate on comptime integer" {	33	test "truncate on comptime integer" {
34	var x = @truncate(u16, 9999);	34	var x = @truncate(u16, 9999);
35	expect(x == 9999);	35	try expect(x == 9999);
36	}	36	}

test/stage1/behavior/try.zig+7-7

...	@@ -1,17 +1,17 @@	...	@@ -1,17 +1,17 @@
1	const expect = @import("std").testing.expect;	1	const expect = @import("std").testing.expect;
2		2
3	test "try on error union" {	3	test "try on error union" {
4	tryOnErrorUnionImpl();	4	try tryOnErrorUnionImpl();
5	comptime tryOnErrorUnionImpl();	5	comptime try tryOnErrorUnionImpl();
6	}	6	}
7		7
8	fn tryOnErrorUnionImpl() void {	8	fn tryOnErrorUnionImpl() !void {
9	const x = if (returnsTen()) \|val\| val + 1 else \|err\| switch (err) {	9	const x = if (returnsTen()) \|val\| val + 1 else \|err\| switch (err) {
10	error.ItBroke, error.NoMem => 1,	10	error.ItBroke, error.NoMem => 1,
11	error.CrappedOut => @as(i32, 2),	11	error.CrappedOut => @as(i32, 2),
12	else => unreachable,	12	else => unreachable,
13	};	13	};
14	expect(x == 11);	14	try expect(x == 11);
15	}	15	}
16		16
17	fn returnsTen() anyerror!i32 {	17	fn returnsTen() anyerror!i32 {
...	@@ -20,10 +20,10 @@ fn returnsTen() anyerror!i32 {	...	@@ -20,10 +20,10 @@ fn returnsTen() anyerror!i32 {
20		20
21	test "try without vars" {	21	test "try without vars" {
22	const result1 = if (failIfTrue(true)) 1 else \|_\| @as(i32, 2);	22	const result1 = if (failIfTrue(true)) 1 else \|_\| @as(i32, 2);
23	expect(result1 == 2);	23	try expect(result1 == 2);
24		24
25	const result2 = if (failIfTrue(false)) 1 else \|_\| @as(i32, 2);	25	const result2 = if (failIfTrue(false)) 1 else \|_\| @as(i32, 2);
26	expect(result2 == 1);	26	try expect(result2 == 1);
27	}	27	}
28		28
29	fn failIfTrue(ok: bool) anyerror!void {	29	fn failIfTrue(ok: bool) anyerror!void {
...	@@ -38,6 +38,6 @@ test "try then not executed with assignment" {	...	@@ -38,6 +38,6 @@ test "try then not executed with assignment" {
38	if (failIfTrue(true)) {	38	if (failIfTrue(true)) {
39	unreachable;	39	unreachable;
40	} else \|err\| {	40	} else \|err\| {
41	expect(err == error.ItBroke);	41	try expect(err == error.ItBroke);
42	}	42	}
43	}	43	}

test/stage1/behavior/tuple.zig+44-44

...	@@ -5,93 +5,93 @@ const expectEqual = testing.expectEqual;	...	@@ -5,93 +5,93 @@ const expectEqual = testing.expectEqual;
5		5
6	test "tuple concatenation" {	6	test "tuple concatenation" {
7	const S = struct {	7	const S = struct {
8	fn doTheTest() void {	8	fn doTheTest() !void {
9	var a: i32 = 1;	9	var a: i32 = 1;
10	var b: i32 = 2;	10	var b: i32 = 2;
11	var x = .{a};	11	var x = .{a};
12	var y = .{b};	12	var y = .{b};
13	var c = x ++ y;	13	var c = x ++ y;
14	expectEqual(@as(i32, 1), c[0]);	14	try expectEqual(@as(i32, 1), c[0]);
15	expectEqual(@as(i32, 2), c[1]);	15	try expectEqual(@as(i32, 2), c[1]);
16	}	16	}
17	};	17	};
18	S.doTheTest();	18	try S.doTheTest();
19	comptime S.doTheTest();	19	comptime try S.doTheTest();
20	}	20	}
21		21
22	test "tuple multiplication" {	22	test "tuple multiplication" {
23	const S = struct {	23	const S = struct {
24	fn doTheTest() void {	24	fn doTheTest() !void {
25	{	25	{
26	const t = .{} ** 4;	26	const t = .{} ** 4;
27	expectEqual(0, @typeInfo(@TypeOf(t)).Struct.fields.len);	27	try expectEqual(0, @typeInfo(@TypeOf(t)).Struct.fields.len);
28	}	28	}
29	{	29	{
30	const t = .{'a'} ** 4;	30	const t = .{'a'} ** 4;
31	expectEqual(4, @typeInfo(@TypeOf(t)).Struct.fields.len);	31	try expectEqual(4, @typeInfo(@TypeOf(t)).Struct.fields.len);
32	inline for (t) \|x\| expectEqual('a', x);	32	inline for (t) \|x\| try expectEqual('a', x);
33	}	33	}
34	{	34	{
35	const t = .{ 1, 2, 3 } ** 4;	35	const t = .{ 1, 2, 3 } ** 4;
36	expectEqual(12, @typeInfo(@TypeOf(t)).Struct.fields.len);	36	try expectEqual(12, @typeInfo(@TypeOf(t)).Struct.fields.len);
37	inline for (t) \|x, i\| expectEqual(1 + i % 3, x);	37	inline for (t) \|x, i\| try expectEqual(1 + i % 3, x);
38	}	38	}
39	}	39	}
40	};	40	};
41	S.doTheTest();	41	try S.doTheTest();
42	comptime S.doTheTest();	42	comptime try S.doTheTest();
43		43
44	const T = struct {	44	const T = struct {
45	fn consume_tuple(tuple: anytype, len: usize) void {	45	fn consume_tuple(tuple: anytype, len: usize) !void {
46	expect(tuple.len == len);	46	try expect(tuple.len == len);
47	}	47	}
48		48
49	fn doTheTest() void {	49	fn doTheTest() !void {
50	const t1 = .{};	50	const t1 = .{};
51		51
52	var rt_var: u8 = 42;	52	var rt_var: u8 = 42;
53	const t2 = .{rt_var} ++ .{};	53	const t2 = .{rt_var} ++ .{};
54		54
55	expect(t2.len == 1);	55	try expect(t2.len == 1);
56	expect(t2.@"0" == rt_var);	56	try expect(t2.@"0" == rt_var);
57	expect(t2.@"0" == 42);	57	try expect(t2.@"0" == 42);
58	expect(&t2.@"0" != &rt_var);	58	try expect(&t2.@"0" != &rt_var);
59		59
60	consume_tuple(t1 ++ t1, 0);	60	try consume_tuple(t1 ++ t1, 0);
61	consume_tuple(.{} ++ .{}, 0);	61	try consume_tuple(.{} ++ .{}, 0);
62	consume_tuple(.{0} ++ .{}, 1);	62	try consume_tuple(.{0} ++ .{}, 1);
63	consume_tuple(.{0} ++ .{1}, 2);	63	try consume_tuple(.{0} ++ .{1}, 2);
64	consume_tuple(.{ 0, 1, 2 } ++ .{ u8, 1, noreturn }, 6);	64	try consume_tuple(.{ 0, 1, 2 } ++ .{ u8, 1, noreturn }, 6);
65	consume_tuple(t2 ++ t1, 1);	65	try consume_tuple(t2 ++ t1, 1);
66	consume_tuple(t1 ++ t2, 1);	66	try consume_tuple(t1 ++ t2, 1);
67	consume_tuple(t2 ++ t2, 2);	67	try consume_tuple(t2 ++ t2, 2);
68	consume_tuple(.{rt_var} ++ .{}, 1);	68	try consume_tuple(.{rt_var} ++ .{}, 1);
69	consume_tuple(.{rt_var} ++ t1, 1);	69	try consume_tuple(.{rt_var} ++ t1, 1);
70	consume_tuple(.{} ++ .{rt_var}, 1);	70	try consume_tuple(.{} ++ .{rt_var}, 1);
71	consume_tuple(t2 ++ .{void}, 2);	71	try consume_tuple(t2 ++ .{void}, 2);
72	consume_tuple(t2 ++ .{0}, 2);	72	try consume_tuple(t2 ++ .{0}, 2);
73	consume_tuple(.{0} ++ t2, 2);	73	try consume_tuple(.{0} ++ t2, 2);
74	consume_tuple(.{void} ++ t2, 2);	74	try consume_tuple(.{void} ++ t2, 2);
75	consume_tuple(.{u8} ++ .{rt_var} ++ .{true}, 3);	75	try consume_tuple(.{u8} ++ .{rt_var} ++ .{true}, 3);
76	}	76	}
77	};	77	};
78		78
79	T.doTheTest();	79	try T.doTheTest();
80	comptime T.doTheTest();	80	comptime try T.doTheTest();
81	}	81	}
82		82
83	test "pass tuple to comptime var parameter" {	83	test "pass tuple to comptime var parameter" {
84	const S = struct {	84	const S = struct {
85	fn Foo(comptime args: anytype) void {	85	fn Foo(comptime args: anytype) !void {
86	expect(args[0] == 1);	86	try expect(args[0] == 1);
87	}	87	}
88		88
89	fn doTheTest() void {	89	fn doTheTest() !void {
90	Foo(.{1});	90	try Foo(.{1});
91	}	91	}
92	};	92	};
93	S.doTheTest();	93	try S.doTheTest();
94	comptime S.doTheTest();	94	comptime try S.doTheTest();
95	}	95	}
96		96
97	test "tuple initializer for var" {	97	test "tuple initializer for var" {

test/stage1/behavior/type.zig+84-84

...	@@ -4,52 +4,52 @@ const TypeInfo = builtin.TypeInfo;	...	@@ -4,52 +4,52 @@ const TypeInfo = builtin.TypeInfo;
4	const std = @import("std");	4	const std = @import("std");
5	const testing = std.testing;	5	const testing = std.testing;
6		6
7	fn testTypes(comptime types: []const type) void {	7	fn testTypes(comptime types: []const type) !void {
8	inline for (types) \|testType\| {	8	inline for (types) \|testType\| {
9	testing.expect(testType == @Type(@typeInfo(testType)));	9	try testing.expect(testType == @Type(@typeInfo(testType)));
10	}	10	}
11	}	11	}
12		12
13	test "Type.MetaType" {	13	test "Type.MetaType" {
14	testing.expect(type == @Type(TypeInfo{ .Type = undefined }));	14	try testing.expect(type == @Type(TypeInfo{ .Type = undefined }));
15	testTypes(&[_]type{type});	15	try testTypes(&[_]type{type});
16	}	16	}
17		17
18	test "Type.Void" {	18	test "Type.Void" {
19	testing.expect(void == @Type(TypeInfo{ .Void = undefined }));	19	try testing.expect(void == @Type(TypeInfo{ .Void = undefined }));
20	testTypes(&[_]type{void});	20	try testTypes(&[_]type{void});
21	}	21	}
22		22
23	test "Type.Bool" {	23	test "Type.Bool" {
24	testing.expect(bool == @Type(TypeInfo{ .Bool = undefined }));	24	try testing.expect(bool == @Type(TypeInfo{ .Bool = undefined }));
25	testTypes(&[_]type{bool});	25	try testTypes(&[_]type{bool});
26	}	26	}
27		27
28	test "Type.NoReturn" {	28	test "Type.NoReturn" {
29	testing.expect(noreturn == @Type(TypeInfo{ .NoReturn = undefined }));	29	try testing.expect(noreturn == @Type(TypeInfo{ .NoReturn = undefined }));
30	testTypes(&[_]type{noreturn});	30	try testTypes(&[_]type{noreturn});
31	}	31	}
32		32
33	test "Type.Int" {	33	test "Type.Int" {
34	testing.expect(u1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 1 } }));	34	try testing.expect(u1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 1 } }));
35	testing.expect(i1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 1 } }));	35	try testing.expect(i1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 1 } }));
36	testing.expect(u8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 8 } }));	36	try testing.expect(u8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 8 } }));
37	testing.expect(i8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 8 } }));	37	try testing.expect(i8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 8 } }));
38	testing.expect(u64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 64 } }));	38	try testing.expect(u64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 64 } }));
39	testing.expect(i64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 64 } }));	39	try testing.expect(i64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 64 } }));
40	testTypes(&[_]type{ u8, u32, i64 });	40	try testTypes(&[_]type{ u8, u32, i64 });
41	}	41	}
42		42
43	test "Type.Float" {	43	test "Type.Float" {
44	testing.expect(f16 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 16 } }));	44	try testing.expect(f16 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 16 } }));
45	testing.expect(f32 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 32 } }));	45	try testing.expect(f32 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 32 } }));
46	testing.expect(f64 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 64 } }));	46	try testing.expect(f64 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 64 } }));
47	testing.expect(f128 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 128 } }));	47	try testing.expect(f128 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 128 } }));
48	testTypes(&[_]type{ f16, f32, f64, f128 });	48	try testTypes(&[_]type{ f16, f32, f64, f128 });
49	}	49	}
50		50
51	test "Type.Pointer" {	51	test "Type.Pointer" {
52	testTypes(&[_]type{	52	try testTypes(&[_]type{
53	// One Value Pointer Types	53	// One Value Pointer Types
54	u8, const u8,	54	u8, const u8,
55	volatile u8, const volatile u8,	55	volatile u8, const volatile u8,
...	@@ -94,41 +94,41 @@ test "Type.Pointer" {	...	@@ -94,41 +94,41 @@ test "Type.Pointer" {
94	}	94	}
95		95
96	test "Type.Array" {	96	test "Type.Array" {
97	testing.expect([123]u8 == @Type(TypeInfo{	97	try testing.expect([123]u8 == @Type(TypeInfo{
98	.Array = TypeInfo.Array{	98	.Array = TypeInfo.Array{
99	.len = 123,	99	.len = 123,
100	.child = u8,	100	.child = u8,
101	.sentinel = null,	101	.sentinel = null,
102	},	102	},
103	}));	103	}));
104	testing.expect([2]u32 == @Type(TypeInfo{	104	try testing.expect([2]u32 == @Type(TypeInfo{
105	.Array = TypeInfo.Array{	105	.Array = TypeInfo.Array{
106	.len = 2,	106	.len = 2,
107	.child = u32,	107	.child = u32,
108	.sentinel = null,	108	.sentinel = null,
109	},	109	},
110	}));	110	}));
111	testing.expect([2:0]u32 == @Type(TypeInfo{	111	try testing.expect([2:0]u32 == @Type(TypeInfo{
112	.Array = TypeInfo.Array{	112	.Array = TypeInfo.Array{
113	.len = 2,	113	.len = 2,
114	.child = u32,	114	.child = u32,
115	.sentinel = 0,	115	.sentinel = 0,
116	},	116	},
117	}));	117	}));
118	testTypes(&[_]type{ [1]u8, [30]usize, [7]bool });	118	try testTypes(&[_]type{ [1]u8, [30]usize, [7]bool });
119	}	119	}
120		120
121	test "Type.ComptimeFloat" {	121	test "Type.ComptimeFloat" {
122	testTypes(&[_]type{comptime_float});	122	try testTypes(&[_]type{comptime_float});
123	}	123	}
124	test "Type.ComptimeInt" {	124	test "Type.ComptimeInt" {
125	testTypes(&[_]type{comptime_int});	125	try testTypes(&[_]type{comptime_int});
126	}	126	}
127	test "Type.Undefined" {	127	test "Type.Undefined" {
128	testTypes(&[_]type{@TypeOf(undefined)});	128	try testTypes(&[_]type{@TypeOf(undefined)});
129	}	129	}
130	test "Type.Null" {	130	test "Type.Null" {
131	testTypes(&[_]type{@TypeOf(null)});	131	try testTypes(&[_]type{@TypeOf(null)});
132	}	132	}
133	test "@Type create slice with null sentinel" {	133	test "@Type create slice with null sentinel" {
134	const Slice = @Type(builtin.TypeInfo{	134	const Slice = @Type(builtin.TypeInfo{
...	@@ -142,10 +142,10 @@ test "@Type create slice with null sentinel" {	...	@@ -142,10 +142,10 @@ test "@Type create slice with null sentinel" {
142	.sentinel = null,	142	.sentinel = null,
143	},	143	},
144	});	144	});
145	testing.expect(Slice == []align(8) const *i32);	145	try testing.expect(Slice == []align(8) const *i32);
146	}	146	}
147	test "@Type picks up the sentinel value from TypeInfo" {	147	test "@Type picks up the sentinel value from TypeInfo" {
148	testTypes(&[_]type{	148	try testTypes(&[_]type{
149	[11:0]u8, [4:10]u8,	149	[11:0]u8, [4:10]u8,
150	[:0]u8, [:0]const u8,	150	[:0]u8, [:0]const u8,
151	[:0]volatile u8, [:0]const volatile u8,	151	[:0]volatile u8, [:0]const volatile u8,
...	@@ -173,7 +173,7 @@ test "@Type picks up the sentinel value from TypeInfo" {	...	@@ -173,7 +173,7 @@ test "@Type picks up the sentinel value from TypeInfo" {
173	}	173	}
174		174
175	test "Type.Optional" {	175	test "Type.Optional" {
176	testTypes(&[_]type{	176	try testTypes(&[_]type{
177	?u8,	177	?u8,
178	?*u8,	178	?*u8,
179	?[]u8,	179	?[]u8,
...	@@ -183,7 +183,7 @@ test "Type.Optional" {	...	@@ -183,7 +183,7 @@ test "Type.Optional" {
183	}	183	}
184		184
185	test "Type.ErrorUnion" {	185	test "Type.ErrorUnion" {
186	testTypes(&[_]type{	186	try testTypes(&[_]type{
187	error{}!void,	187	error{}!void,
188	error{Error}!void,	188	error{Error}!void,
189	});	189	});
...	@@ -195,8 +195,8 @@ test "Type.Opaque" {	...	@@ -195,8 +195,8 @@ test "Type.Opaque" {
195	.decls = &[_]TypeInfo.Declaration{},	195	.decls = &[_]TypeInfo.Declaration{},
196	},	196	},
197	});	197	});
198	testing.expect(Opaque != opaque {});	198	try testing.expect(Opaque != opaque {});
199	testing.expectEqualSlices(	199	try testing.expectEqualSlices(
200	TypeInfo.Declaration,	200	TypeInfo.Declaration,
201	&[_]TypeInfo.Declaration{},	201	&[_]TypeInfo.Declaration{},
202	@typeInfo(Opaque).Opaque.decls,	202	@typeInfo(Opaque).Opaque.decls,
...	@@ -204,7 +204,7 @@ test "Type.Opaque" {	...	@@ -204,7 +204,7 @@ test "Type.Opaque" {
204	}	204	}
205		205
206	test "Type.Vector" {	206	test "Type.Vector" {
207	testTypes(&[_]type{	207	try testTypes(&[_]type{
208	@Vector(0, u8),	208	@Vector(0, u8),
209	@Vector(4, u8),	209	@Vector(4, u8),
210	@Vector(8, *u8),	210	@Vector(8, *u8),
...	@@ -215,7 +215,7 @@ test "Type.Vector" {	...	@@ -215,7 +215,7 @@ test "Type.Vector" {
215	}	215	}
216		216
217	test "Type.AnyFrame" {	217	test "Type.AnyFrame" {
218	testTypes(&[_]type{	218	try testTypes(&[_]type{
219	anyframe,	219	anyframe,
220	anyframe->u8,	220	anyframe->u8,
221	anyframe->anyframe->u8,	221	anyframe->anyframe->u8,
...	@@ -223,7 +223,7 @@ test "Type.AnyFrame" {	...	@@ -223,7 +223,7 @@ test "Type.AnyFrame" {
223	}	223	}
224		224
225	test "Type.EnumLiteral" {	225	test "Type.EnumLiteral" {
226	testTypes(&[_]type{	226	try testTypes(&[_]type{
227	@TypeOf(.Dummy),	227	@TypeOf(.Dummy),
228	});	228	});
229	}	229	}
...	@@ -233,7 +233,7 @@ fn add(a: i32, b: i32) i32 {	...	@@ -233,7 +233,7 @@ fn add(a: i32, b: i32) i32 {
233	}	233	}
234		234
235	test "Type.Frame" {	235	test "Type.Frame" {
236	testTypes(&[_]type{	236	try testTypes(&[_]type{
237	@Frame(add),	237	@Frame(add),
238	});	238	});
239	}	239	}
...	@@ -248,45 +248,45 @@ test "Type.ErrorSet" {	...	@@ -248,45 +248,45 @@ test "Type.ErrorSet" {
248	test "Type.Struct" {	248	test "Type.Struct" {
249	const A = @Type(@typeInfo(struct { x: u8, y: u32 }));	249	const A = @Type(@typeInfo(struct { x: u8, y: u32 }));
250	const infoA = @typeInfo(A).Struct;	250	const infoA = @typeInfo(A).Struct;
251	testing.expectEqual(TypeInfo.ContainerLayout.Auto, infoA.layout);	251	try testing.expectEqual(TypeInfo.ContainerLayout.Auto, infoA.layout);
252	testing.expectEqualSlices(u8, "x", infoA.fields[0].name);	252	try testing.expectEqualSlices(u8, "x", infoA.fields[0].name);
253	testing.expectEqual(u8, infoA.fields[0].field_type);	253	try testing.expectEqual(u8, infoA.fields[0].field_type);
254	testing.expectEqual(@as(?u8, null), infoA.fields[0].default_value);	254	try testing.expectEqual(@as(?u8, null), infoA.fields[0].default_value);
255	testing.expectEqualSlices(u8, "y", infoA.fields[1].name);	255	try testing.expectEqualSlices(u8, "y", infoA.fields[1].name);
256	testing.expectEqual(u32, infoA.fields[1].field_type);	256	try testing.expectEqual(u32, infoA.fields[1].field_type);
257	testing.expectEqual(@as(?u32, null), infoA.fields[1].default_value);	257	try testing.expectEqual(@as(?u32, null), infoA.fields[1].default_value);
258	testing.expectEqualSlices(TypeInfo.Declaration, &[_]TypeInfo.Declaration{}, infoA.decls);	258	try testing.expectEqualSlices(TypeInfo.Declaration, &[_]TypeInfo.Declaration{}, infoA.decls);
259	testing.expectEqual(@as(bool, false), infoA.is_tuple);	259	try testing.expectEqual(@as(bool, false), infoA.is_tuple);
260		260
261	var a = A{ .x = 0, .y = 1 };	261	var a = A{ .x = 0, .y = 1 };
262	testing.expectEqual(@as(u8, 0), a.x);	262	try testing.expectEqual(@as(u8, 0), a.x);
263	testing.expectEqual(@as(u32, 1), a.y);	263	try testing.expectEqual(@as(u32, 1), a.y);
264	a.y += 1;	264	a.y += 1;
265	testing.expectEqual(@as(u32, 2), a.y);	265	try testing.expectEqual(@as(u32, 2), a.y);
266		266
267	const B = @Type(@typeInfo(extern struct { x: u8, y: u32 = 5 }));	267	const B = @Type(@typeInfo(extern struct { x: u8, y: u32 = 5 }));
268	const infoB = @typeInfo(B).Struct;	268	const infoB = @typeInfo(B).Struct;
269	testing.expectEqual(TypeInfo.ContainerLayout.Extern, infoB.layout);	269	try testing.expectEqual(TypeInfo.ContainerLayout.Extern, infoB.layout);
270	testing.expectEqualSlices(u8, "x", infoB.fields[0].name);	270	try testing.expectEqualSlices(u8, "x", infoB.fields[0].name);
271	testing.expectEqual(u8, infoB.fields[0].field_type);	271	try testing.expectEqual(u8, infoB.fields[0].field_type);
272	testing.expectEqual(@as(?u8, null), infoB.fields[0].default_value);	272	try testing.expectEqual(@as(?u8, null), infoB.fields[0].default_value);
273	testing.expectEqualSlices(u8, "y", infoB.fields[1].name);	273	try testing.expectEqualSlices(u8, "y", infoB.fields[1].name);
274	testing.expectEqual(u32, infoB.fields[1].field_type);	274	try testing.expectEqual(u32, infoB.fields[1].field_type);
275	testing.expectEqual(@as(?u32, 5), infoB.fields[1].default_value);	275	try testing.expectEqual(@as(?u32, 5), infoB.fields[1].default_value);
276	testing.expectEqual(@as(usize, 0), infoB.decls.len);	276	try testing.expectEqual(@as(usize, 0), infoB.decls.len);
277	testing.expectEqual(@as(bool, false), infoB.is_tuple);	277	try testing.expectEqual(@as(bool, false), infoB.is_tuple);
278		278
279	const C = @Type(@typeInfo(packed struct { x: u8 = 3, y: u32 = 5 }));	279	const C = @Type(@typeInfo(packed struct { x: u8 = 3, y: u32 = 5 }));
280	const infoC = @typeInfo(C).Struct;	280	const infoC = @typeInfo(C).Struct;
281	testing.expectEqual(TypeInfo.ContainerLayout.Packed, infoC.layout);	281	try testing.expectEqual(TypeInfo.ContainerLayout.Packed, infoC.layout);
282	testing.expectEqualSlices(u8, "x", infoC.fields[0].name);	282	try testing.expectEqualSlices(u8, "x", infoC.fields[0].name);
283	testing.expectEqual(u8, infoC.fields[0].field_type);	283	try testing.expectEqual(u8, infoC.fields[0].field_type);
284	testing.expectEqual(@as(?u8, 3), infoC.fields[0].default_value);	284	try testing.expectEqual(@as(?u8, 3), infoC.fields[0].default_value);
285	testing.expectEqualSlices(u8, "y", infoC.fields[1].name);	285	try testing.expectEqualSlices(u8, "y", infoC.fields[1].name);
286	testing.expectEqual(u32, infoC.fields[1].field_type);	286	try testing.expectEqual(u32, infoC.fields[1].field_type);
287	testing.expectEqual(@as(?u32, 5), infoC.fields[1].default_value);	287	try testing.expectEqual(@as(?u32, 5), infoC.fields[1].default_value);
288	testing.expectEqual(@as(usize, 0), infoC.decls.len);	288	try testing.expectEqual(@as(usize, 0), infoC.decls.len);
289	testing.expectEqual(@as(bool, false), infoC.is_tuple);	289	try testing.expectEqual(@as(bool, false), infoC.is_tuple);
290	}	290	}
291		291
292	test "Type.Enum" {	292	test "Type.Enum" {
...	@@ -302,9 +302,9 @@ test "Type.Enum" {	...	@@ -302,9 +302,9 @@ test "Type.Enum" {
302	.is_exhaustive = true,	302	.is_exhaustive = true,
303	},	303	},
304	});	304	});
305	testing.expectEqual(true, @typeInfo(Foo).Enum.is_exhaustive);	305	try testing.expectEqual(true, @typeInfo(Foo).Enum.is_exhaustive);
306	testing.expectEqual(@as(u8, 1), @enumToInt(Foo.a));	306	try testing.expectEqual(@as(u8, 1), @enumToInt(Foo.a));
307	testing.expectEqual(@as(u8, 5), @enumToInt(Foo.b));	307	try testing.expectEqual(@as(u8, 5), @enumToInt(Foo.b));
308	const Bar = @Type(.{	308	const Bar = @Type(.{
309	.Enum = .{	309	.Enum = .{
310	.layout = .Extern,	310	.layout = .Extern,
...	@@ -317,10 +317,10 @@ test "Type.Enum" {	...	@@ -317,10 +317,10 @@ test "Type.Enum" {
317	.is_exhaustive = false,	317	.is_exhaustive = false,
318	},	318	},
319	});	319	});
320	testing.expectEqual(false, @typeInfo(Bar).Enum.is_exhaustive);	320	try testing.expectEqual(false, @typeInfo(Bar).Enum.is_exhaustive);
321	testing.expectEqual(@as(u32, 1), @enumToInt(Bar.a));	321	try testing.expectEqual(@as(u32, 1), @enumToInt(Bar.a));
322	testing.expectEqual(@as(u32, 5), @enumToInt(Bar.b));	322	try testing.expectEqual(@as(u32, 5), @enumToInt(Bar.b));
323	testing.expectEqual(@as(u32, 6), @enumToInt(@intToEnum(Bar, 6)));	323	try testing.expectEqual(@as(u32, 6), @enumToInt(@intToEnum(Bar, 6)));
324	}	324	}
325		325
326	test "Type.Union" {	326	test "Type.Union" {
...	@@ -338,7 +338,7 @@ test "Type.Union" {	...	@@ -338,7 +338,7 @@ test "Type.Union" {
338	var untagged = Untagged{ .int = 1 };	338	var untagged = Untagged{ .int = 1 };
339	untagged.float = 2.0;	339	untagged.float = 2.0;
340	untagged.int = 3;	340	untagged.int = 3;
341	testing.expectEqual(@as(i32, 3), untagged.int);	341	try testing.expectEqual(@as(i32, 3), untagged.int);
342		342
343	const PackedUntagged = @Type(.{	343	const PackedUntagged = @Type(.{
344	.Union = .{	344	.Union = .{
...	@@ -352,8 +352,8 @@ test "Type.Union" {	...	@@ -352,8 +352,8 @@ test "Type.Union" {
352	},	352	},
353	});	353	});
354	var packed_untagged = PackedUntagged{ .signed = -1 };	354	var packed_untagged = PackedUntagged{ .signed = -1 };
355	testing.expectEqual(@as(i32, -1), packed_untagged.signed);	355	try testing.expectEqual(@as(i32, -1), packed_untagged.signed);
356	testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned);	356	try testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned);
357		357
358	const Tag = @Type(.{	358	const Tag = @Type(.{
359	.Enum = .{	359	.Enum = .{
...	@@ -379,9 +379,9 @@ test "Type.Union" {	...	@@ -379,9 +379,9 @@ test "Type.Union" {
379	},	379	},
380	});	380	});
381	var tagged = Tagged{ .signed = -1 };	381	var tagged = Tagged{ .signed = -1 };
382	testing.expectEqual(Tag.signed, tagged);	382	try testing.expectEqual(Tag.signed, tagged);
383	tagged = .{ .unsigned = 1 };	383	tagged = .{ .unsigned = 1 };
384	testing.expectEqual(Tag.unsigned, tagged);	384	try testing.expectEqual(Tag.unsigned, tagged);
385	}	385	}
386		386
387	test "Type.Union from Type.Enum" {	387	test "Type.Union from Type.Enum" {
...	@@ -447,7 +447,7 @@ test "Type.BoundFn" {	...	@@ -447,7 +447,7 @@ test "Type.BoundFn" {
447	pub fn foo(self: *const @This()) align(4) callconv(.Unspecified) void {}	447	pub fn foo(self: *const @This()) align(4) callconv(.Unspecified) void {}
448	};	448	};
449	const test_instance: TestStruct = undefined;	449	const test_instance: TestStruct = undefined;
450	testing.expect(std.meta.eql(	450	try testing.expect(std.meta.eql(
451	@typeName(@TypeOf(test_instance.foo)),	451	@typeName(@TypeOf(test_instance.foo)),
452	@typeName(@Type(@typeInfo(@TypeOf(test_instance.foo)))),	452	@typeName(@Type(@typeInfo(@TypeOf(test_instance.foo)))),
453	));	453	));

test/stage1/behavior/type_info.zig+187-187

test/stage1/behavior/typename.zig+1-1

...	@@ -3,5 +3,5 @@ const expect = std.testing.expect;	...	@@ -3,5 +3,5 @@ const expect = std.testing.expect;
3	const expectEqualSlices = std.testing.expectEqualSlices;	3	const expectEqualSlices = std.testing.expectEqualSlices;
4		4
5	test "slice" {	5	test "slice" {
6	expectEqualSlices(u8, "[]u8", @typeName([]u8));	6	try expectEqualSlices(u8, "[]u8", @typeName([]u8));
7	}	7	}

test/stage1/behavior/undefined.zig+13-13

...	@@ -12,16 +12,16 @@ fn initStaticArray() [10]i32 {	...	@@ -12,16 +12,16 @@ fn initStaticArray() [10]i32 {
12	}	12	}
13	const static_array = initStaticArray();	13	const static_array = initStaticArray();
14	test "init static array to undefined" {	14	test "init static array to undefined" {
15	expect(static_array[0] == 1);	15	try expect(static_array[0] == 1);
16	expect(static_array[4] == 2);	16	try expect(static_array[4] == 2);
17	expect(static_array[7] == 3);	17	try expect(static_array[7] == 3);
18	expect(static_array[9] == 4);	18	try expect(static_array[9] == 4);
19		19
20	comptime {	20	comptime {
21	expect(static_array[0] == 1);	21	try expect(static_array[0] == 1);
22	expect(static_array[4] == 2);	22	try expect(static_array[4] == 2);
23	expect(static_array[7] == 3);	23	try expect(static_array[7] == 3);
24	expect(static_array[9] == 4);	24	try expect(static_array[9] == 4);
25	}	25	}
26	}	26	}
27		27
...	@@ -41,12 +41,12 @@ test "assign undefined to struct" {	...	@@ -41,12 +41,12 @@ test "assign undefined to struct" {
41	comptime {	41	comptime {
42	var foo: Foo = undefined;	42	var foo: Foo = undefined;
43	setFooX(&foo);	43	setFooX(&foo);
44	expect(foo.x == 2);	44	try expect(foo.x == 2);
45	}	45	}
46	{	46	{
47	var foo: Foo = undefined;	47	var foo: Foo = undefined;
48	setFooX(&foo);	48	setFooX(&foo);
49	expect(foo.x == 2);	49	try expect(foo.x == 2);
50	}	50	}
51	}	51	}
52		52
...	@@ -54,16 +54,16 @@ test "assign undefined to struct with method" {	...	@@ -54,16 +54,16 @@ test "assign undefined to struct with method" {
54	comptime {	54	comptime {
55	var foo: Foo = undefined;	55	var foo: Foo = undefined;
56	foo.setFooXMethod();	56	foo.setFooXMethod();
57	expect(foo.x == 3);	57	try expect(foo.x == 3);
58	}	58	}
59	{	59	{
60	var foo: Foo = undefined;	60	var foo: Foo = undefined;
61	foo.setFooXMethod();	61	foo.setFooXMethod();
62	expect(foo.x == 3);	62	try expect(foo.x == 3);
63	}	63	}
64	}	64	}
65		65
66	test "type name of undefined" {	66	test "type name of undefined" {
67	const x = undefined;	67	const x = undefined;
68	expect(mem.eql(u8, @typeName(@TypeOf(x)), "(undefined)"));	68	try expect(mem.eql(u8, @typeName(@TypeOf(x)), "(undefined)"));
69	}	69	}

test/stage1/behavior/union.zig+142-142

...	@@ -30,11 +30,11 @@ const array = [_]Value{	...	@@ -30,11 +30,11 @@ const array = [_]Value{
30		30
31	test "unions embedded in aggregate types" {	31	test "unions embedded in aggregate types" {
32	switch (array[1]) {	32	switch (array[1]) {
33	Value.Array => \|arr\| expect(arr[4] == 3),	33	Value.Array => \|arr\| try expect(arr[4] == 3),
34	else => unreachable,	34	else => unreachable,
35	}	35	}
36	switch ((err catch unreachable).val1) {	36	switch ((err catch unreachable).val1) {
37	Value.Int => \|x\| expect(x == 1234),	37	Value.Int => \|x\| try expect(x == 1234),
38	else => unreachable,	38	else => unreachable,
39	}	39	}
40	}	40	}
...	@@ -46,18 +46,18 @@ const Foo = union {	...	@@ -46,18 +46,18 @@ const Foo = union {
46		46
47	test "basic unions" {	47	test "basic unions" {
48	var foo = Foo{ .int = 1 };	48	var foo = Foo{ .int = 1 };
49	expect(foo.int == 1);	49	try expect(foo.int == 1);
50	foo = Foo{ .float = 12.34 };	50	foo = Foo{ .float = 12.34 };
51	expect(foo.float == 12.34);	51	try expect(foo.float == 12.34);
52	}	52	}
53		53
54	test "comptime union field access" {	54	test "comptime union field access" {
55	comptime {	55	comptime {
56	var foo = Foo{ .int = 0 };	56	var foo = Foo{ .int = 0 };
57	expect(foo.int == 0);	57	try expect(foo.int == 0);
58		58
59	foo = Foo{ .float = 42.42 };	59	foo = Foo{ .float = 42.42 };
60	expect(foo.float == 42.42);	60	try expect(foo.float == 42.42);
61	}	61	}
62	}	62	}
63		63
...	@@ -65,10 +65,10 @@ test "init union with runtime value" {	...	@@ -65,10 +65,10 @@ test "init union with runtime value" {
65	var foo: Foo = undefined;	65	var foo: Foo = undefined;
66		66
67	setFloat(&foo, 12.34);	67	setFloat(&foo, 12.34);
68	expect(foo.float == 12.34);	68	try expect(foo.float == 12.34);
69		69
70	setInt(&foo, 42);	70	setInt(&foo, 42);
71	expect(foo.int == 42);	71	try expect(foo.int == 42);
72	}	72	}
73		73
74	fn setFloat(foo: *Foo, x: f64) void {	74	fn setFloat(foo: *Foo, x: f64) void {
...	@@ -86,9 +86,9 @@ const FooExtern = extern union {	...	@@ -86,9 +86,9 @@ const FooExtern = extern union {
86		86
87	test "basic extern unions" {	87	test "basic extern unions" {
88	var foo = FooExtern{ .int = 1 };	88	var foo = FooExtern{ .int = 1 };
89	expect(foo.int == 1);	89	try expect(foo.int == 1);
90	foo.float = 12.34;	90	foo.float = 12.34;
91	expect(foo.float == 12.34);	91	try expect(foo.float == 12.34);
92	}	92	}
93		93
94	const Letter = enum {	94	const Letter = enum {
...	@@ -103,16 +103,16 @@ const Payload = union(Letter) {	...	@@ -103,16 +103,16 @@ const Payload = union(Letter) {
103	};	103	};
104		104
105	test "union with specified enum tag" {	105	test "union with specified enum tag" {
106	doTest();	106	try doTest();
107	comptime doTest();	107	comptime try doTest();
108	}	108	}
109		109
110	fn doTest() void {	110	fn doTest() !void {
111	expect(bar(Payload{ .A = 1234 }) == -10);	111	try expect((try bar(Payload{ .A = 1234 })) == -10);
112	}	112	}
113		113
114	fn bar(value: Payload) i32 {	114	fn bar(value: Payload) !i32 {
115	expect(@as(Letter, value) == Letter.A);	115	try expect(@as(Letter, value) == Letter.A);
116	return switch (value) {	116	return switch (value) {
117	Payload.A => \|x\| return x - 1244,	117	Payload.A => \|x\| return x - 1244,
118	Payload.B => \|x\| if (x == 12.34) @as(i32, 20) else 21,	118	Payload.B => \|x\| if (x == 12.34) @as(i32, 20) else 21,
...	@@ -128,8 +128,8 @@ const MultipleChoice = union(enum(u32)) {	...	@@ -128,8 +128,8 @@ const MultipleChoice = union(enum(u32)) {
128	};	128	};
129	test "simple union(enum(u32))" {	129	test "simple union(enum(u32))" {
130	var x = MultipleChoice.C;	130	var x = MultipleChoice.C;
131	expect(x == MultipleChoice.C);	131	try expect(x == MultipleChoice.C);
132	expect(@enumToInt(@as(Tag(MultipleChoice), x)) == 60);	132	try expect(@enumToInt(@as(Tag(MultipleChoice), x)) == 60);
133	}	133	}
134		134
135	const MultipleChoice2 = union(enum(u32)) {	135	const MultipleChoice2 = union(enum(u32)) {
...	@@ -145,14 +145,14 @@ const MultipleChoice2 = union(enum(u32)) {	...	@@ -145,14 +145,14 @@ const MultipleChoice2 = union(enum(u32)) {
145	};	145	};
146		146
147	test "union(enum(u32)) with specified and unspecified tag values" {	147	test "union(enum(u32)) with specified and unspecified tag values" {
148	comptime expect(Tag(Tag(MultipleChoice2)) == u32);	148	comptime try expect(Tag(Tag(MultipleChoice2)) == u32);
149	testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });	149	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
150	comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });	150	comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
151	}	151	}
152		152
153	fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {	153	fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
154	expect(@enumToInt(@as(Tag(MultipleChoice2), x)) == 60);	154	try expect(@enumToInt(@as(Tag(MultipleChoice2), x)) == 60);
155	expect(1123 == switch (x) {	155	try expect(1123 == switch (x) {
156	MultipleChoice2.A => 1,	156	MultipleChoice2.A => 1,
157	MultipleChoice2.B => 2,	157	MultipleChoice2.B => 2,
158	MultipleChoice2.C => \|v\| @as(i32, 1000) + v,	158	MultipleChoice2.C => \|v\| @as(i32, 1000) + v,
...	@@ -170,7 +170,7 @@ const ExternPtrOrInt = extern union {	...	@@ -170,7 +170,7 @@ const ExternPtrOrInt = extern union {
170	int: u64,	170	int: u64,
171	};	171	};
172	test "extern union size" {	172	test "extern union size" {
173	comptime expect(@sizeOf(ExternPtrOrInt) == 8);	173	comptime try expect(@sizeOf(ExternPtrOrInt) == 8);
174	}	174	}
175		175
176	const PackedPtrOrInt = packed union {	176	const PackedPtrOrInt = packed union {
...	@@ -178,14 +178,14 @@ const PackedPtrOrInt = packed union {	...	@@ -178,14 +178,14 @@ const PackedPtrOrInt = packed union {
178	int: u64,	178	int: u64,
179	};	179	};
180	test "extern union size" {	180	test "extern union size" {
181	comptime expect(@sizeOf(PackedPtrOrInt) == 8);	181	comptime try expect(@sizeOf(PackedPtrOrInt) == 8);
182	}	182	}
183		183
184	const ZeroBits = union {	184	const ZeroBits = union {
185	OnlyField: void,	185	OnlyField: void,
186	};	186	};
187	test "union with only 1 field which is void should be zero bits" {	187	test "union with only 1 field which is void should be zero bits" {
188	comptime expect(@sizeOf(ZeroBits) == 0);	188	comptime try expect(@sizeOf(ZeroBits) == 0);
189	}	189	}
190		190
191	const TheTag = enum {	191	const TheTag = enum {
...	@@ -199,23 +199,23 @@ const TheUnion = union(TheTag) {	...	@@ -199,23 +199,23 @@ const TheUnion = union(TheTag) {
199	C: i32,	199	C: i32,
200	};	200	};
201	test "union field access gives the enum values" {	201	test "union field access gives the enum values" {
202	expect(TheUnion.A == TheTag.A);	202	try expect(TheUnion.A == TheTag.A);
203	expect(TheUnion.B == TheTag.B);	203	try expect(TheUnion.B == TheTag.B);
204	expect(TheUnion.C == TheTag.C);	204	try expect(TheUnion.C == TheTag.C);
205	}	205	}
206		206
207	test "cast union to tag type of union" {	207	test "cast union to tag type of union" {
208	testCastUnionToTag(TheUnion{ .B = 1234 });	208	try testCastUnionToTag(TheUnion{ .B = 1234 });
209	comptime testCastUnionToTag(TheUnion{ .B = 1234 });	209	comptime try testCastUnionToTag(TheUnion{ .B = 1234 });
210	}	210	}
211		211
212	fn testCastUnionToTag(x: TheUnion) void {	212	fn testCastUnionToTag(x: TheUnion) !void {
213	expect(@as(TheTag, x) == TheTag.B);	213	try expect(@as(TheTag, x) == TheTag.B);
214	}	214	}
215		215
216	test "cast tag type of union to union" {	216	test "cast tag type of union to union" {
217	var x: Value2 = Letter2.B;	217	var x: Value2 = Letter2.B;
218	expect(@as(Letter2, x) == Letter2.B);	218	try expect(@as(Letter2, x) == Letter2.B);
219	}	219	}
220	const Letter2 = enum {	220	const Letter2 = enum {
221	A,	221	A,
...	@@ -230,11 +230,11 @@ const Value2 = union(Letter2) {	...	@@ -230,11 +230,11 @@ const Value2 = union(Letter2) {
230		230
231	test "implicit cast union to its tag type" {	231	test "implicit cast union to its tag type" {
232	var x: Value2 = Letter2.B;	232	var x: Value2 = Letter2.B;
233	expect(x == Letter2.B);	233	try expect(x == Letter2.B);
234	giveMeLetterB(x);	234	try giveMeLetterB(x);
235	}	235	}
236	fn giveMeLetterB(x: Letter2) void {	236	fn giveMeLetterB(x: Letter2) !void {
237	expect(x == Value2.B);	237	try expect(x == Value2.B);
238	}	238	}
239		239
240	pub const PackThis = union(enum) {	240	pub const PackThis = union(enum) {
...	@@ -243,11 +243,11 @@ pub const PackThis = union(enum) {	...	@@ -243,11 +243,11 @@ pub const PackThis = union(enum) {
243	};	243	};
244		244
245	test "constant packed union" {	245	test "constant packed union" {
246	testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});	246	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
247	}	247	}
248		248
249	fn testConstPackedUnion(expected_tokens: []const PackThis) void {	249	fn testConstPackedUnion(expected_tokens: []const PackThis) !void {
250	expect(expected_tokens[0].StringLiteral == 1);	250	try expect(expected_tokens[0].StringLiteral == 1);
251	}	251	}
252		252
253	test "switch on union with only 1 field" {	253	test "switch on union with only 1 field" {
...	@@ -259,7 +259,7 @@ test "switch on union with only 1 field" {	...	@@ -259,7 +259,7 @@ test "switch on union with only 1 field" {
259	z = PartialInstWithPayload{ .Compiled = 1234 };	259	z = PartialInstWithPayload{ .Compiled = 1234 };
260	switch (z) {	260	switch (z) {
261	PartialInstWithPayload.Compiled => \|x\| {	261	PartialInstWithPayload.Compiled => \|x\| {
262	expect(x == 1234);	262	try expect(x == 1234);
263	return;	263	return;
264	},	264	},
265	}	265	}
...	@@ -285,11 +285,11 @@ test "access a member of tagged union with conflicting enum tag name" {	...	@@ -285,11 +285,11 @@ test "access a member of tagged union with conflicting enum tag name" {
285	const B = void;	285	const B = void;
286	};	286	};
287		287
288	comptime expect(Bar.A == u8);	288	comptime try expect(Bar.A == u8);
289	}	289	}
290		290
291	test "tagged union initialization with runtime void" {	291	test "tagged union initialization with runtime void" {
292	expect(testTaggedUnionInit({}));	292	try expect(testTaggedUnionInit({}));
293	}	293	}
294		294
295	const TaggedUnionWithAVoid = union(enum) {	295	const TaggedUnionWithAVoid = union(enum) {
...	@@ -327,9 +327,9 @@ test "union with only 1 field casted to its enum type" {	...	@@ -327,9 +327,9 @@ test "union with only 1 field casted to its enum type" {
327		327
328	var e = Expr{ .Literal = Literal{ .Bool = true } };	328	var e = Expr{ .Literal = Literal{ .Bool = true } };
329	const ExprTag = Tag(Expr);	329	const ExprTag = Tag(Expr);
330	comptime expect(Tag(ExprTag) == u0);	330	comptime try expect(Tag(ExprTag) == u0);
331	var t = @as(ExprTag, e);	331	var t = @as(ExprTag, e);
332	expect(t == Expr.Literal);	332	try expect(t == Expr.Literal);
333	}	333	}
334		334
335	test "union with only 1 field casted to its enum type which has enum value specified" {	335	test "union with only 1 field casted to its enum type which has enum value specified" {
...	@@ -347,11 +347,11 @@ test "union with only 1 field casted to its enum type which has enum value speci	...	@@ -347,11 +347,11 @@ test "union with only 1 field casted to its enum type which has enum value speci
347	};	347	};
348		348
349	var e = Expr{ .Literal = Literal{ .Bool = true } };	349	var e = Expr{ .Literal = Literal{ .Bool = true } };
350	comptime expect(Tag(ExprTag) == comptime_int);	350	comptime try expect(Tag(ExprTag) == comptime_int);
351	var t = @as(ExprTag, e);	351	var t = @as(ExprTag, e);
352	expect(t == Expr.Literal);	352	try expect(t == Expr.Literal);
353	expect(@enumToInt(t) == 33);	353	try expect(@enumToInt(t) == 33);
354	comptime expect(@enumToInt(t) == 33);	354	comptime try expect(@enumToInt(t) == 33);
355	}	355	}
356		356
357	test "@enumToInt works on unions" {	357	test "@enumToInt works on unions" {
...	@@ -364,9 +364,9 @@ test "@enumToInt works on unions" {	...	@@ -364,9 +364,9 @@ test "@enumToInt works on unions" {
364	const a = Bar{ .A = true };	364	const a = Bar{ .A = true };
365	var b = Bar{ .B = undefined };	365	var b = Bar{ .B = undefined };
366	var c = Bar.C;	366	var c = Bar.C;
367	expect(@enumToInt(a) == 0);	367	try expect(@enumToInt(a) == 0);
368	expect(@enumToInt(b) == 1);	368	try expect(@enumToInt(b) == 1);
369	expect(@enumToInt(c) == 2);	369	try expect(@enumToInt(c) == 2);
370	}	370	}
371		371
372	const Attribute = union(enum) {	372	const Attribute = union(enum) {
...	@@ -393,23 +393,23 @@ test "comptime union field value equality" {	...	@@ -393,23 +393,23 @@ test "comptime union field value equality" {
393	const b1 = Setter(Attribute{ .B = 9 });	393	const b1 = Setter(Attribute{ .B = 9 });
394	const b2 = Setter(Attribute{ .B = 5 });	394	const b2 = Setter(Attribute{ .B = 5 });
395		395
396	expect(a0 == a0);	396	try expect(a0 == a0);
397	expect(a1 == a1);	397	try expect(a1 == a1);
398	expect(a0 == a2);	398	try expect(a0 == a2);
399		399
400	expect(b0 == b0);	400	try expect(b0 == b0);
401	expect(b1 == b1);	401	try expect(b1 == b1);
402	expect(b0 == b2);	402	try expect(b0 == b2);
403		403
404	expect(a0 != b0);	404	try expect(a0 != b0);
405	expect(a0 != a1);	405	try expect(a0 != a1);
406	expect(b0 != b1);	406	try expect(b0 != b1);
407	}	407	}
408		408
409	test "return union init with void payload" {	409	test "return union init with void payload" {
410	const S = struct {	410	const S = struct {
411	fn entry() void {	411	fn entry() !void {
412	expect(func().state == State.one);	412	try expect(func().state == State.one);
413	}	413	}
414	const Outer = union(enum) {	414	const Outer = union(enum) {
415	state: State,	415	state: State,
...	@@ -422,8 +422,8 @@ test "return union init with void payload" {	...	@@ -422,8 +422,8 @@ test "return union init with void payload" {
422	return Outer{ .state = State{ .one = {} } };	422	return Outer{ .state = State{ .one = {} } };
423	}	423	}
424	};	424	};
425	S.entry();	425	try S.entry();
426	comptime S.entry();	426	comptime try S.entry();
427	}	427	}
428		428
429	test "@unionInit can modify a union type" {	429	test "@unionInit can modify a union type" {
...	@@ -435,14 +435,14 @@ test "@unionInit can modify a union type" {	...	@@ -435,14 +435,14 @@ test "@unionInit can modify a union type" {
435	var value: UnionInitEnum = undefined;	435	var value: UnionInitEnum = undefined;
436		436
437	value = @unionInit(UnionInitEnum, "Boolean", true);	437	value = @unionInit(UnionInitEnum, "Boolean", true);
438	expect(value.Boolean == true);	438	try expect(value.Boolean == true);
439	value.Boolean = false;	439	value.Boolean = false;
440	expect(value.Boolean == false);	440	try expect(value.Boolean == false);
441		441
442	value = @unionInit(UnionInitEnum, "Byte", 2);	442	value = @unionInit(UnionInitEnum, "Byte", 2);
443	expect(value.Byte == 2);	443	try expect(value.Byte == 2);
444	value.Byte = 3;	444	value.Byte = 3;
445	expect(value.Byte == 3);	445	try expect(value.Byte == 3);
446	}	446	}
447		447
448	test "@unionInit can modify a pointer value" {	448	test "@unionInit can modify a pointer value" {
...	@@ -455,10 +455,10 @@ test "@unionInit can modify a pointer value" {	...	@@ -455,10 +455,10 @@ test "@unionInit can modify a pointer value" {
455	var value_ptr = &value;	455	var value_ptr = &value;
456		456
457	value_ptr.* = @unionInit(UnionInitEnum, "Boolean", true);	457	value_ptr.* = @unionInit(UnionInitEnum, "Boolean", true);
458	expect(value.Boolean == true);	458	try expect(value.Boolean == true);
459		459
460	value_ptr.* = @unionInit(UnionInitEnum, "Byte", 2);	460	value_ptr.* = @unionInit(UnionInitEnum, "Byte", 2);
461	expect(value.Byte == 2);	461	try expect(value.Byte == 2);
462	}	462	}
463		463
464	test "union no tag with struct member" {	464	test "union no tag with struct member" {
...	@@ -471,38 +471,38 @@ test "union no tag with struct member" {	...	@@ -471,38 +471,38 @@ test "union no tag with struct member" {
471	u.foo();	471	u.foo();
472	}	472	}
473		473
474	fn testComparison() void {	474	fn testComparison() !void {
475	var x = Payload{ .A = 42 };	475	var x = Payload{ .A = 42 };
476	expect(x == .A);	476	try expect(x == .A);
477	expect(x != .B);	477	try expect(x != .B);
478	expect(x != .C);	478	try expect(x != .C);
479	expect((x == .B) == false);	479	try expect((x == .B) == false);
480	expect((x == .C) == false);	480	try expect((x == .C) == false);
481	expect((x != .A) == false);	481	try expect((x != .A) == false);
482	}	482	}
483		483
484	test "comparison between union and enum literal" {	484	test "comparison between union and enum literal" {
485	testComparison();	485	try testComparison();
486	comptime testComparison();	486	comptime try testComparison();
487	}	487	}
488		488
489	test "packed union generates correctly aligned LLVM type" {	489	test "packed union generates correctly aligned LLVM type" {
490	const U = packed union {	490	const U = packed union {
491	f1: fn () void,	491	f1: fn () error{TestUnexpectedResult}!void,
492	f2: u32,	492	f2: u32,
493	};	493	};
494	var foo = [_]U{	494	var foo = [_]U{
495	U{ .f1 = doTest },	495	U{ .f1 = doTest },
496	U{ .f2 = 0 },	496	U{ .f2 = 0 },
497	};	497	};
498	foo[0].f1();	498	try foo[0].f1();
499	}	499	}
500		500
501	test "union with one member defaults to u0 tag type" {	501	test "union with one member defaults to u0 tag type" {
502	const U0 = union(enum) {	502	const U0 = union(enum) {
503	X: u32,	503	X: u32,
504	};	504	};
505	comptime expect(Tag(Tag(U0)) == u0);	505	comptime try expect(Tag(Tag(U0)) == u0);
506	}	506	}
507		507
508	test "union with comptime_int tag" {	508	test "union with comptime_int tag" {
...	@@ -511,7 +511,7 @@ test "union with comptime_int tag" {	...	@@ -511,7 +511,7 @@ test "union with comptime_int tag" {
511	Y: u16,	511	Y: u16,
512	Z: u8,	512	Z: u8,
513	};	513	};
514	comptime expect(Tag(Tag(Union)) == comptime_int);	514	comptime try expect(Tag(Tag(Union)) == comptime_int);
515	}	515	}
516		516
517	test "extern union doesn't trigger field check at comptime" {	517	test "extern union doesn't trigger field check at comptime" {
...	@@ -521,7 +521,7 @@ test "extern union doesn't trigger field check at comptime" {	...	@@ -521,7 +521,7 @@ test "extern union doesn't trigger field check at comptime" {
521	};	521	};
522		522
523	const x = U{ .x = 0x55AAAA55 };	523	const x = U{ .x = 0x55AAAA55 };
524	comptime expect(x.y == 0x55);	524	comptime try expect(x.y == 0x55);
525	}	525	}
526		526
527	const Foo1 = union(enum) {	527	const Foo1 = union(enum) {
...	@@ -535,7 +535,7 @@ test "global union with single field is correctly initialized" {	...	@@ -535,7 +535,7 @@ test "global union with single field is correctly initialized" {
535	glbl = Foo1{	535	glbl = Foo1{
536	.f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 },	536	.f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 },
537	};	537	};
538	expect(glbl.f.x == 123);	538	try expect(glbl.f.x == 123);
539	}	539	}
540		540
541	pub const FooUnion = union(enum) {	541	pub const FooUnion = union(enum) {
...	@@ -548,8 +548,8 @@ var glbl_array: [2]FooUnion = undefined;	...	@@ -548,8 +548,8 @@ var glbl_array: [2]FooUnion = undefined;
548	test "initialize global array of union" {	548	test "initialize global array of union" {
549	glbl_array[1] = FooUnion{ .U1 = 2 };	549	glbl_array[1] = FooUnion{ .U1 = 2 };
550	glbl_array[0] = FooUnion{ .U0 = 1 };	550	glbl_array[0] = FooUnion{ .U0 = 1 };
551	expect(glbl_array[0].U0 == 1);	551	try expect(glbl_array[0].U0 == 1);
552	expect(glbl_array[1].U1 == 2);	552	try expect(glbl_array[1].U1 == 2);
553	}	553	}
554		554
555	test "anonymous union literal syntax" {	555	test "anonymous union literal syntax" {
...	@@ -559,19 +559,19 @@ test "anonymous union literal syntax" {	...	@@ -559,19 +559,19 @@ test "anonymous union literal syntax" {
559	float: f64,	559	float: f64,
560	};	560	};
561		561
562	fn doTheTest() void {	562	fn doTheTest() !void {
563	var i: Number = .{ .int = 42 };	563	var i: Number = .{ .int = 42 };
564	var f = makeNumber();	564	var f = makeNumber();
565	expect(i.int == 42);	565	try expect(i.int == 42);
566	expect(f.float == 12.34);	566	try expect(f.float == 12.34);
567	}	567	}
568		568
569	fn makeNumber() Number {	569	fn makeNumber() Number {
570	return .{ .float = 12.34 };	570	return .{ .float = 12.34 };
571	}	571	}
572	};	572	};
573	S.doTheTest();	573	try S.doTheTest();
574	comptime S.doTheTest();	574	comptime try S.doTheTest();
575	}	575	}
576		576
577	test "update the tag value for zero-sized unions" {	577	test "update the tag value for zero-sized unions" {
...	@@ -580,9 +580,9 @@ test "update the tag value for zero-sized unions" {	...	@@ -580,9 +580,9 @@ test "update the tag value for zero-sized unions" {
580	U1: void,	580	U1: void,
581	};	581	};
582	var x = S{ .U0 = {} };	582	var x = S{ .U0 = {} };
583	expect(x == .U0);	583	try expect(x == .U0);
584	x = S{ .U1 = {} };	584	x = S{ .U1 = {} };
585	expect(x == .U1);	585	try expect(x == .U1);
586	}	586	}
587		587
588	test "function call result coerces from tagged union to the tag" {	588	test "function call result coerces from tagged union to the tag" {
...	@@ -594,12 +594,12 @@ test "function call result coerces from tagged union to the tag" {	...	@@ -594,12 +594,12 @@ test "function call result coerces from tagged union to the tag" {
594		594
595	const ArchTag = Tag(Arch);	595	const ArchTag = Tag(Arch);
596		596
597	fn doTheTest() void {	597	fn doTheTest() !void {
598	var x: ArchTag = getArch1();	598	var x: ArchTag = getArch1();
599	expect(x == .One);	599	try expect(x == .One);
600		600
601	var y: ArchTag = getArch2();	601	var y: ArchTag = getArch2();
602	expect(y == .Two);	602	try expect(y == .Two);
603	}	603	}
604		604
605	pub fn getArch1() Arch {	605	pub fn getArch1() Arch {
...	@@ -610,8 +610,8 @@ test "function call result coerces from tagged union to the tag" {	...	@@ -610,8 +610,8 @@ test "function call result coerces from tagged union to the tag" {
610	return .{ .Two = 99 };	610	return .{ .Two = 99 };
611	}	611	}
612	};	612	};
613	S.doTheTest();	613	try S.doTheTest();
614	comptime S.doTheTest();	614	comptime try S.doTheTest();
615	}	615	}
616		616
617	test "0-sized extern union definition" {	617	test "0-sized extern union definition" {
...	@@ -620,7 +620,7 @@ test "0-sized extern union definition" {	...	@@ -620,7 +620,7 @@ test "0-sized extern union definition" {
620	const f = 1;	620	const f = 1;
621	};	621	};
622		622
623	expect(U.f == 1);	623	try expect(U.f == 1);
624	}	624	}
625		625
626	test "union initializer generates padding only if needed" {	626	test "union initializer generates padding only if needed" {
...	@@ -629,7 +629,7 @@ test "union initializer generates padding only if needed" {	...	@@ -629,7 +629,7 @@ test "union initializer generates padding only if needed" {
629	};	629	};
630		630
631	var v = U{ .A = 532 };	631	var v = U{ .A = 532 };
632	expect(v.A == 532);	632	try expect(v.A == 532);
633	}	633	}
634		634
635	test "runtime tag name with single field" {	635	test "runtime tag name with single field" {
...	@@ -638,7 +638,7 @@ test "runtime tag name with single field" {	...	@@ -638,7 +638,7 @@ test "runtime tag name with single field" {
638	};	638	};
639		639
640	var v = U{ .A = 42 };	640	var v = U{ .A = 42 };
641	expect(std.mem.eql(u8, @tagName(v), "A"));	641	try expect(std.mem.eql(u8, @tagName(v), "A"));
642	}	642	}
643		643
644	test "cast from anonymous struct to union" {	644	test "cast from anonymous struct to union" {
...	@@ -648,7 +648,7 @@ test "cast from anonymous struct to union" {	...	@@ -648,7 +648,7 @@ test "cast from anonymous struct to union" {
648	B: []const u8,	648	B: []const u8,
649	C: void,	649	C: void,
650	};	650	};
651	fn doTheTest() void {	651	fn doTheTest() !void {
652	var y: u32 = 42;	652	var y: u32 = 42;
653	const t0 = .{ .A = 123 };	653	const t0 = .{ .A = 123 };
654	const t1 = .{ .B = "foo" };	654	const t1 = .{ .B = "foo" };
...	@@ -658,14 +658,14 @@ test "cast from anonymous struct to union" {	...	@@ -658,14 +658,14 @@ test "cast from anonymous struct to union" {
658	var x1: U = t1;	658	var x1: U = t1;
659	const x2: U = t2;	659	const x2: U = t2;
660	var x3: U = t3;	660	var x3: U = t3;
661	expect(x0.A == 123);	661	try expect(x0.A == 123);
662	expect(std.mem.eql(u8, x1.B, "foo"));	662	try expect(std.mem.eql(u8, x1.B, "foo"));
663	expect(x2 == .C);	663	try expect(x2 == .C);
664	expect(x3.A == y);	664	try expect(x3.A == y);
665	}	665	}
666	};	666	};
667	S.doTheTest();	667	try S.doTheTest();
668	comptime S.doTheTest();	668	comptime try S.doTheTest();
669	}	669	}
670		670
671	test "cast from pointer to anonymous struct to pointer to union" {	671	test "cast from pointer to anonymous struct to pointer to union" {
...	@@ -675,7 +675,7 @@ test "cast from pointer to anonymous struct to pointer to union" {	...	@@ -675,7 +675,7 @@ test "cast from pointer to anonymous struct to pointer to union" {
675	B: []const u8,	675	B: []const u8,
676	C: void,	676	C: void,
677	};	677	};
678	fn doTheTest() void {	678	fn doTheTest() !void {
679	var y: u32 = 42;	679	var y: u32 = 42;
680	const t0 = &.{ .A = 123 };	680	const t0 = &.{ .A = 123 };
681	const t1 = &.{ .B = "foo" };	681	const t1 = &.{ .B = "foo" };
...	@@ -685,14 +685,14 @@ test "cast from pointer to anonymous struct to pointer to union" {	...	@@ -685,14 +685,14 @@ test "cast from pointer to anonymous struct to pointer to union" {
685	var x1: *const U = t1;	685	var x1: *const U = t1;
686	const x2: *const U = t2;	686	const x2: *const U = t2;
687	var x3: *const U = t3;	687	var x3: *const U = t3;
688	expect(x0.A == 123);	688	try expect(x0.A == 123);
689	expect(std.mem.eql(u8, x1.B, "foo"));	689	try expect(std.mem.eql(u8, x1.B, "foo"));
690	expect(x2.* == .C);	690	try expect(x2.* == .C);
691	expect(x3.A == y);	691	try expect(x3.A == y);
692	}	692	}
693	};	693	};
694	S.doTheTest();	694	try S.doTheTest();
695	comptime S.doTheTest();	695	comptime try S.doTheTest();
696	}	696	}
697		697
698	test "method call on an empty union" {	698	test "method call on an empty union" {
...	@@ -707,13 +707,13 @@ test "method call on an empty union" {	...	@@ -707,13 +707,13 @@ test "method call on an empty union" {
707	}	707	}
708	};	708	};
709		709
710	fn doTheTest() void {	710	fn doTheTest() !void {
711	var u = MyUnion{ .X1 = [0]u8{} };	711	var u = MyUnion{ .X1 = [0]u8{} };
712	expect(u.useIt());	712	try expect(u.useIt());
713	}	713	}
714	};	714	};
715	S.doTheTest();	715	try S.doTheTest();
716	comptime S.doTheTest();	716	comptime try S.doTheTest();
717	}	717	}
718		718
719	test "switching on non exhaustive union" {	719	test "switching on non exhaustive union" {
...	@@ -727,16 +727,16 @@ test "switching on non exhaustive union" {	...	@@ -727,16 +727,16 @@ test "switching on non exhaustive union" {
727	a: i32,	727	a: i32,
728	b: u32,	728	b: u32,
729	};	729	};
730	fn doTheTest() void {	730	fn doTheTest() !void {
731	var a = U{ .a = 2 };	731	var a = U{ .a = 2 };
732	switch (a) {	732	switch (a) {
733	.a => \|val\| expect(val == 2),	733	.a => \|val\| try expect(val == 2),
734	.b => unreachable,	734	.b => unreachable,
735	}	735	}
736	}	736	}
737	};	737	};
738	S.doTheTest();	738	try S.doTheTest();
739	comptime S.doTheTest();	739	comptime try S.doTheTest();
740	}	740	}
741		741
742	test "containers with single-field enums" {	742	test "containers with single-field enums" {
...	@@ -746,21 +746,21 @@ test "containers with single-field enums" {	...	@@ -746,21 +746,21 @@ test "containers with single-field enums" {
746	const C = struct { a: A };	746	const C = struct { a: A };
747	const D = struct { a: B };	747	const D = struct { a: B };
748		748
749	fn doTheTest() void {	749	fn doTheTest() !void {
750	var array1 = [1]A{A{ .f1 = {} }};	750	var array1 = [1]A{A{ .f1 = {} }};
751	var array2 = [1]B{B{ .f1 = {} }};	751	var array2 = [1]B{B{ .f1 = {} }};
752	expect(array1[0] == .f1);	752	try expect(array1[0] == .f1);
753	expect(array2[0] == .f1);	753	try expect(array2[0] == .f1);
754		754
755	var struct1 = C{ .a = A{ .f1 = {} } };	755	var struct1 = C{ .a = A{ .f1 = {} } };
756	var struct2 = D{ .a = B{ .f1 = {} } };	756	var struct2 = D{ .a = B{ .f1 = {} } };
757	expect(struct1.a == .f1);	757	try expect(struct1.a == .f1);
758	expect(struct2.a == .f1);	758	try expect(struct2.a == .f1);
759	}	759	}
760	};	760	};
761		761
762	S.doTheTest();	762	try S.doTheTest();
763	comptime S.doTheTest();	763	comptime try S.doTheTest();
764	}	764	}
765		765
766	test "@unionInit on union w/ tag but no fields" {	766	test "@unionInit on union w/ tag but no fields" {
...	@@ -776,18 +776,18 @@ test "@unionInit on union w/ tag but no fields" {	...	@@ -776,18 +776,18 @@ test "@unionInit on union w/ tag but no fields" {
776	};	776	};
777		777
778	comptime {	778	comptime {
779	expect(@sizeOf(Data) != 0);	779	try expect(@sizeOf(Data) != 0);
780	}	780	}
781		781
782	fn doTheTest() void {	782	fn doTheTest() !void {
783	var data: Data = .{ .no_op = .{} };	783	var data: Data = .{ .no_op = .{} };
784	var o = Data.decode(&[_]u8{});	784	var o = Data.decode(&[_]u8{});
785	expectEqual(Type.no_op, o);	785	try expectEqual(Type.no_op, o);
786	}	786	}
787	};	787	};
788		788
789	S.doTheTest();	789	try S.doTheTest();
790	comptime S.doTheTest();	790	comptime try S.doTheTest();
791	}	791	}
792		792
793	test "union enum type gets a separate scope" {	793	test "union enum type gets a separate scope" {
...	@@ -797,10 +797,10 @@ test "union enum type gets a separate scope" {	...	@@ -797,10 +797,10 @@ test "union enum type gets a separate scope" {
797	const foo = 1;	797	const foo = 1;
798	};	798	};
799		799
800	fn doTheTest() void {	800	fn doTheTest() !void {
801	expect(!@hasDecl(Tag(U), "foo"));	801	try expect(!@hasDecl(Tag(U), "foo"));
802	}	802	}
803	};	803	};
804		804
805	S.doTheTest();	805	try S.doTheTest();
806	}	806	}

test/stage1/behavior/usingnamespace.zig+3-3

...	@@ -9,8 +9,8 @@ fn Foo(comptime T: type) type {	...	@@ -9,8 +9,8 @@ fn Foo(comptime T: type) type {
9	test "usingnamespace inside a generic struct" {	9	test "usingnamespace inside a generic struct" {
10	const std2 = Foo(std);	10	const std2 = Foo(std);
11	const testing2 = Foo(std.testing);	11	const testing2 = Foo(std.testing);
12	std2.testing.expect(true);	12	try std2.testing.expect(true);
13	testing2.expect(true);	13	try testing2.expect(true);
14	}	14	}
15		15
16	usingnamespace struct {	16	usingnamespace struct {
...	@@ -18,5 +18,5 @@ usingnamespace struct {	...	@@ -18,5 +18,5 @@ usingnamespace struct {
18	};	18	};
19		19
20	test "usingnamespace does not redeclare an imported variable" {	20	test "usingnamespace does not redeclare an imported variable" {
21	comptime std.testing.expect(foo == 42);	21	comptime try std.testing.expect(foo == 42);
22	}	22	}

test/stage1/behavior/var_args.zig+17-17

...	@@ -12,9 +12,9 @@ fn add(args: anytype) i32 {	...	@@ -12,9 +12,9 @@ fn add(args: anytype) i32 {
12	}	12	}
13		13
14	test "add arbitrary args" {	14	test "add arbitrary args" {
15	expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);	15	try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
16	expect(add(.{@as(i32, 1234)}) == 1234);	16	try expect(add(.{@as(i32, 1234)}) == 1234);
17	expect(add(.{}) == 0);	17	try expect(add(.{}) == 0);
18	}	18	}
19		19
20	fn readFirstVarArg(args: anytype) void {	20	fn readFirstVarArg(args: anytype) void {
...	@@ -26,9 +26,9 @@ test "send void arg to var args" {	...	@@ -26,9 +26,9 @@ test "send void arg to var args" {
26	}	26	}
27		27
28	test "pass args directly" {	28	test "pass args directly" {
29	expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);	29	try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
30	expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);	30	try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
31	expect(addSomeStuff(.{}) == 0);	31	try expect(addSomeStuff(.{}) == 0);
32	}	32	}
33		33
34	fn addSomeStuff(args: anytype) i32 {	34	fn addSomeStuff(args: anytype) i32 {
...	@@ -36,23 +36,23 @@ fn addSomeStuff(args: anytype) i32 {	...	@@ -36,23 +36,23 @@ fn addSomeStuff(args: anytype) i32 {
36	}	36	}
37		37
38	test "runtime parameter before var args" {	38	test "runtime parameter before var args" {
39	expect(extraFn(10, .{}) == 0);	39	try expect((try extraFn(10, .{})) == 0);
40	expect(extraFn(10, .{false}) == 1);	40	try expect((try extraFn(10, .{false})) == 1);
41	expect(extraFn(10, .{ false, true }) == 2);	41	try expect((try extraFn(10, .{ false, true })) == 2);
42		42
43	comptime {	43	comptime {
44	expect(extraFn(10, .{}) == 0);	44	try expect((try extraFn(10, .{})) == 0);
45	expect(extraFn(10, .{false}) == 1);	45	try expect((try extraFn(10, .{false})) == 1);
46	expect(extraFn(10, .{ false, true }) == 2);	46	try expect((try extraFn(10, .{ false, true })) == 2);
47	}	47	}
48	}	48	}
49		49
50	fn extraFn(extra: u32, args: anytype) usize {	50	fn extraFn(extra: u32, args: anytype) !usize {
51	if (args.len >= 1) {	51	if (args.len >= 1) {
52	expect(args[0] == false);	52	try expect(args[0] == false);
53	}	53	}
54	if (args.len >= 2) {	54	if (args.len >= 2) {
55	expect(args[1] == true);	55	try expect(args[1] == true);
56	}	56	}
57	return args.len;	57	return args.len;
58	}	58	}
...	@@ -70,8 +70,8 @@ fn foo2(args: anytype) bool {	...	@@ -70,8 +70,8 @@ fn foo2(args: anytype) bool {
70	}	70	}
71		71
72	test "array of var args functions" {	72	test "array of var args functions" {
73	expect(foos[0](.{}));	73	try expect(foos[0](.{}));
74	expect(!foos[1](.{}));	74	try expect(!foos[1](.{}));
75	}	75	}
76		76
77	test "pass zero length array to var args param" {	77	test "pass zero length array to var args param" {

test/stage1/behavior/vector.zig+280-280

test/stage1/behavior/void.zig+3-3

...	@@ -13,14 +13,14 @@ test "compare void with void compile time known" {	...	@@ -13,14 +13,14 @@ test "compare void with void compile time known" {
13	.b = 1,	13	.b = 1,
14	.c = {},	14	.c = {},
15	};	15	};
16	expect(foo.a == {});	16	try expect(foo.a == {});
17	}	17	}
18	}	18	}
19		19
20	test "iterate over a void slice" {	20	test "iterate over a void slice" {
21	var j: usize = 0;	21	var j: usize = 0;
22	for (times(10)) \|_, i\| {	22	for (times(10)) \|_, i\| {
23	expect(i == j);	23	try expect(i == j);
24	j += 1;	24	j += 1;
25	}	25	}
26	}	26	}
...	@@ -31,7 +31,7 @@ fn times(n: usize) []const void {	...	@@ -31,7 +31,7 @@ fn times(n: usize) []const void {
31		31
32	test "void optional" {	32	test "void optional" {
33	var x: ?void = {};	33	var x: ?void = {};
34	expect(x != null);	34	try expect(x != null);
35	}	35	}
36		36
37	test "void array as a local variable initializer" {	37	test "void array as a local variable initializer" {

test/stage1/behavior/wasm.zig+2-2

...	@@ -3,6 +3,6 @@ const expect = std.testing.expect;	...	@@ -3,6 +3,6 @@ const expect = std.testing.expect;
3		3
4	test "memory size and grow" {	4	test "memory size and grow" {
5	var prev = @wasmMemorySize(0);	5	var prev = @wasmMemorySize(0);
6	expect(prev == @wasmMemoryGrow(0, 1));	6	try expect(prev == @wasmMemoryGrow(0, 1));
7	expect(prev + 1 == @wasmMemorySize(0));	7	try expect(prev + 1 == @wasmMemorySize(0));
8	}	8	}

test/stage1/behavior/while.zig+45-51

 @@ -6,8 +6,8 @@ test "while loop" {
     while (i < 4) {
         i += 1;
     }
-    expect(i == 4);
+    try expect(i == 4);
-    expect(whileLoop1() == 1);
+    try expect(whileLoop1() == 1);
 }
 fn whileLoop1() i32 {
     return whileLoop2();
 @@ -19,7 +19,7 @@ fn whileLoop2() i32 {
 }
 test "static eval while" {
-    expect(static_eval_while_number == 1);
+    try expect(static_eval_while_number == 1);
 }
 const static_eval_while_number = staticWhileLoop1();
 fn staticWhileLoop1() i32 {
 @@ -32,11 +32,11 @@ fn staticWhileLoop2() i32 {
 }
 test "continue and break" {
-    runContinueAndBreakTest();
+    try runContinueAndBreakTest();
-    expect(continue_and_break_counter == 8);
+    try expect(continue_and_break_counter == 8);
 }
 var continue_and_break_counter: i32 = 0;
-fn runContinueAndBreakTest() void {
+fn runContinueAndBreakTest() !void {
     var i: i32 = 0;
     while (true) {
         continue_and_break_counter += 2;
 @@ -46,7 +46,7 @@ fn runContinueAndBreakTest() void {
         }
         break;
     }
-    expect(i == 4);
+    try expect(i == 4);
 }
 test "return with implicit cast from while loop" {
 @@ -67,7 +67,7 @@ test "while with continue expression" {
             sum += i;
         }
     }
-    expect(sum == 40);
+    try expect(sum == 40);
 }
 test "while with else" {
 @@ -79,8 +79,8 @@ test "while with else" {
     } else {
         got_else += 1;
     }
-    expect(sum == 10);
+    try expect(sum == 10);
-    expect(got_else == 1);
+    try expect(got_else == 1);
 }
 test "while with optional as condition" {
 @@ -89,7 +89,7 @@ test "while with optional as condition" {
     while (getNumberOrNull()) |value| {
         sum += value;
     }
-    expect(sum == 45);
+    try expect(sum == 45);
 }
 test "while with optional as condition with else" {
 @@ -98,12 +98,12 @@ test "while with optional as condition with else" {
     var got_else: i32 = 0;
     while (getNumberOrNull()) |value| {
         sum += value;
-        expect(got_else == 0);
+        try expect(got_else == 0);
     } else {
         got_else += 1;
     }
-    expect(sum == 45);
+    try expect(sum == 45);
-    expect(got_else == 1);
+    try expect(got_else == 1);
 }
 test "while with error union condition" {
 @@ -113,11 +113,11 @@ test "while with error union condition" {
     while (getNumberOrErr()) |value| {
         sum += value;
     } else |err| {
-        expect(err == error.OutOfNumbers);
+        try expect(err == error.OutOfNumbers);
         got_else += 1;
     }
-    expect(sum == 45);
+    try expect(sum == 45);
-    expect(got_else == 1);
+    try expect(got_else == 1);
 }
 var numbers_left: i32 = undefined;
 @@ -137,49 +137,43 @@ fn getNumberOrNull() ?i32 {
 test "while on optional with else result follow else prong" {
     const result = while (returnNull()) |value| {
         break value;
-    } else
+    } else @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 2);
-    expect(result == 2);
 }
 test "while on optional with else result follow break prong" {
     const result = while (returnOptional(10)) |value| {
         break value;
-    } else
+    } else @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 10);
-    expect(result == 10);
 }
 test "while on error union with else result follow else prong" {
     const result = while (returnError()) |value| {
         break value;
-    } else |err|
+    } else |err| @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 2);
-    expect(result == 2);
 }
 test "while on error union with else result follow break prong" {
     const result = while (returnSuccess(10)) |value| {
         break value;
-    } else |err|
+    } else |err| @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 10);
-    expect(result == 10);
 }
 test "while on bool with else result follow else prong" {
     const result = while (returnFalse()) {
         break @as(i32, 10);
-    } else
+    } else @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 2);
-    expect(result == 2);
 }
 test "while on bool with else result follow break prong" {
     const result = while (returnTrue()) {
         break @as(i32, 10);
-    } else
+    } else @as(i32, 2);
-        @as(i32, 2);
+    try expect(result == 10);
-    expect(result == 10);
 }
 test "break from outer while loop" {
 @@ -230,60 +224,60 @@ fn returnTrue() bool {
 test "while bool 2 break statements and an else" {
     const S = struct {
-        fn entry(t: bool, f: bool) void {
+        fn entry(t: bool, f: bool) !void {
             var ok = false;
             ok = while (t) {
                 if (f) break false;
                 if (t) break true;
             } else false;
-            expect(ok);
+            try expect(ok);
         }
     };
-    S.entry(true, false);
+    try S.entry(true, false);
-    comptime S.entry(true, false);
+    comptime try S.entry(true, false);
 }
 test "while optional 2 break statements and an else" {
     const S = struct {
-        fn entry(opt_t: ?bool, f: bool) void {
+        fn entry(opt_t: ?bool, f: bool) !void {
             var ok = false;
             ok = while (opt_t) |t| {
                 if (f) break false;
                 if (t) break true;
             } else false;
-            expect(ok);
+            try expect(ok);
         }
     };
-    S.entry(true, false);
+    try S.entry(true, false);
-    comptime S.entry(true, false);
+    comptime try S.entry(true, false);
 }
 test "while error 2 break statements and an else" {
     const S = struct {
-        fn entry(opt_t: anyerror!bool, f: bool) void {
+        fn entry(opt_t: anyerror!bool, f: bool) !void {
             var ok = false;
             ok = while (opt_t) |t| {
                 if (f) break false;
                 if (t) break true;
             } else |_| false;
-            expect(ok);
+            try expect(ok);
         }
     };
-    S.entry(true, false);
+    try S.entry(true, false);
-    comptime S.entry(true, false);
+    comptime try S.entry(true, false);
 }
 test "while copies its payload" {
     const S = struct {
-        fn doTheTest() void {
+        fn doTheTest() !void {
             var tmp: ?i32 = 10;
             while (tmp) |value| {
                 // Modify the original variable
                 tmp = null;
-                expect(value == 10);
+                try expect(value == 10);
             }
         }
     };
-    S.doTheTest();
+    try S.doTheTest();
-    comptime S.doTheTest();
+    comptime try S.doTheTest();
 }

test/stage1/behavior/widening.zig+6-6

...	@@ -9,13 +9,13 @@ test "integer widening" {	...	@@ -9,13 +9,13 @@ test "integer widening" {
9	var d: u64 = c;	9	var d: u64 = c;
10	var e: u64 = d;	10	var e: u64 = d;
11	var f: u128 = e;	11	var f: u128 = e;
12	expect(f == a);	12	try expect(f == a);
13	}	13	}
14		14
15	test "implicit unsigned integer to signed integer" {	15	test "implicit unsigned integer to signed integer" {
16	var a: u8 = 250;	16	var a: u8 = 250;
17	var b: i16 = a;	17	var b: i16 = a;
18	expect(b == 250);	18	try expect(b == 250);
19	}	19	}
20		20
21	test "float widening" {	21	test "float widening" {
...	@@ -23,9 +23,9 @@ test "float widening" {	...	@@ -23,9 +23,9 @@ test "float widening" {
23	var b: f32 = a;	23	var b: f32 = a;
24	var c: f64 = b;	24	var c: f64 = b;
25	var d: f128 = c;	25	var d: f128 = c;
26	expect(a == b);	26	try expect(a == b);
27	expect(b == c);	27	try expect(b == c);
28	expect(c == d);	28	try expect(c == d);
29	}	29	}
30		30
31	test "float widening f16 to f128" {	31	test "float widening f16 to f128" {
...	@@ -35,5 +35,5 @@ test "float widening f16 to f128" {	...	@@ -35,5 +35,5 @@ test "float widening f16 to f128" {
35		35
36	var x: f16 = 12.34;	36	var x: f16 = 12.34;
37	var y: f128 = x;	37	var y: f128 = x;
38	expect(x == y);	38	try expect(x == y);
39	}	39	}

test/stage1/c_abi/main.zig+58-58

...	@@ -24,11 +24,11 @@ extern fn c_i64(i64) void;	...	@@ -24,11 +24,11 @@ extern fn c_i64(i64) void;
24	extern fn c_five_integers(i32, i32, i32, i32, i32) void;	24	extern fn c_five_integers(i32, i32, i32, i32, i32) void;
25		25
26	export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void {	26	export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void {
27	expect(a == 12);	27	expect(a == 12) catch @panic("test failure");
28	expect(b == 34);	28	expect(b == 34) catch @panic("test failure");
29	expect(c == 56);	29	expect(c == 56) catch @panic("test failure");
30	expect(d == 78);	30	expect(d == 78) catch @panic("test failure");
31	expect(e == 90);	31	expect(e == 90) catch @panic("test failure");
32	}	32	}
33		33
34	test "C ABI integers" {	34	test "C ABI integers" {
...	@@ -45,28 +45,28 @@ test "C ABI integers" {	...	@@ -45,28 +45,28 @@ test "C ABI integers" {
45	}	45	}
46		46
47	export fn zig_u8(x: u8) void {	47	export fn zig_u8(x: u8) void {
48	expect(x == 0xff);	48	expect(x == 0xff) catch @panic("test failure");
49	}	49	}
50	export fn zig_u16(x: u16) void {	50	export fn zig_u16(x: u16) void {
51	expect(x == 0xfffe);	51	expect(x == 0xfffe) catch @panic("test failure");
52	}	52	}
53	export fn zig_u32(x: u32) void {	53	export fn zig_u32(x: u32) void {
54	expect(x == 0xfffffffd);	54	expect(x == 0xfffffffd) catch @panic("test failure");
55	}	55	}
56	export fn zig_u64(x: u64) void {	56	export fn zig_u64(x: u64) void {
57	expect(x == 0xfffffffffffffffc);	57	expect(x == 0xfffffffffffffffc) catch @panic("test failure");
58	}	58	}
59	export fn zig_i8(x: i8) void {	59	export fn zig_i8(x: i8) void {
60	expect(x == -1);	60	expect(x == -1) catch @panic("test failure");
61	}	61	}
62	export fn zig_i16(x: i16) void {	62	export fn zig_i16(x: i16) void {
63	expect(x == -2);	63	expect(x == -2) catch @panic("test failure");
64	}	64	}
65	export fn zig_i32(x: i32) void {	65	export fn zig_i32(x: i32) void {
66	expect(x == -3);	66	expect(x == -3) catch @panic("test failure");
67	}	67	}
68	export fn zig_i64(x: i64) void {	68	export fn zig_i64(x: i64) void {
69	expect(x == -4);	69	expect(x == -4) catch @panic("test failure");
70	}	70	}
71		71
72	extern fn c_f32(f32) void;	72	extern fn c_f32(f32) void;
...	@@ -76,11 +76,11 @@ extern fn c_f64(f64) void;	...	@@ -76,11 +76,11 @@ extern fn c_f64(f64) void;
76	extern fn c_five_floats(f32, f32, f32, f32, f32) void;	76	extern fn c_five_floats(f32, f32, f32, f32, f32) void;
77		77
78	export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {	78	export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {
79	expect(a == 1.0);	79	expect(a == 1.0) catch @panic("test failure");
80	expect(b == 2.0);	80	expect(b == 2.0) catch @panic("test failure");
81	expect(c == 3.0);	81	expect(c == 3.0) catch @panic("test failure");
82	expect(d == 4.0);	82	expect(d == 4.0) catch @panic("test failure");
83	expect(e == 5.0);	83	expect(e == 5.0) catch @panic("test failure");
84	}	84	}
85		85
86	test "C ABI floats" {	86	test "C ABI floats" {
...	@@ -90,10 +90,10 @@ test "C ABI floats" {	...	@@ -90,10 +90,10 @@ test "C ABI floats" {
90	}	90	}
91		91
92	export fn zig_f32(x: f32) void {	92	export fn zig_f32(x: f32) void {
93	expect(x == 12.34);	93	expect(x == 12.34) catch @panic("test failure");
94	}	94	}
95	export fn zig_f64(x: f64) void {	95	export fn zig_f64(x: f64) void {
96	expect(x == 56.78);	96	expect(x == 56.78) catch @panic("test failure");
97	}	97	}
98		98
99	extern fn c_ptr(*c_void) void;	99	extern fn c_ptr(*c_void) void;
...	@@ -103,7 +103,7 @@ test "C ABI pointer" {	...	@@ -103,7 +103,7 @@ test "C ABI pointer" {
103	}	103	}
104		104
105	export fn zig_ptr(x: *c_void) void {	105	export fn zig_ptr(x: *c_void) void {
106	expect(@ptrToInt(x) == 0xdeadbeef);	106	expect(@ptrToInt(x) == 0xdeadbeef) catch @panic("test failure");
107	}	107	}
108		108
109	extern fn c_bool(bool) void;	109	extern fn c_bool(bool) void;
...	@@ -113,7 +113,7 @@ test "C ABI bool" {	...	@@ -113,7 +113,7 @@ test "C ABI bool" {
113	}	113	}
114		114
115	export fn zig_bool(x: bool) void {	115	export fn zig_bool(x: bool) void {
116	expect(x);	116	expect(x) catch @panic("test failure");
117	}	117	}
118		118
119	const BigStruct = extern struct {	119	const BigStruct = extern struct {
...	@@ -137,11 +137,11 @@ test "C ABI big struct" {	...	@@ -137,11 +137,11 @@ test "C ABI big struct" {
137	}	137	}
138		138
139	export fn zig_big_struct(x: BigStruct) void {	139	export fn zig_big_struct(x: BigStruct) void {
140	expect(x.a == 1);	140	expect(x.a == 1) catch @panic("test failure");
141	expect(x.b == 2);	141	expect(x.b == 2) catch @panic("test failure");
142	expect(x.c == 3);	142	expect(x.c == 3) catch @panic("test failure");
143	expect(x.d == 4);	143	expect(x.d == 4) catch @panic("test failure");
144	expect(x.e == 5);	144	expect(x.e == 5) catch @panic("test failure");
145	}	145	}
146		146
147	const BigUnion = extern union {	147	const BigUnion = extern union {
...	@@ -163,11 +163,11 @@ test "C ABI big union" {	...	@@ -163,11 +163,11 @@ test "C ABI big union" {
163	}	163	}
164		164
165	export fn zig_big_union(x: BigUnion) void {	165	export fn zig_big_union(x: BigUnion) void {
166	expect(x.a.a == 1);	166	expect(x.a.a == 1) catch @panic("test failure");
167	expect(x.a.b == 2);	167	expect(x.a.b == 2) catch @panic("test failure");
168	expect(x.a.c == 3);	168	expect(x.a.c == 3) catch @panic("test failure");
169	expect(x.a.d == 4);	169	expect(x.a.d == 4) catch @panic("test failure");
170	expect(x.a.e == 5);	170	expect(x.a.e == 5) catch @panic("test failure");
171	}	171	}
172		172
173	const SmallStructInts = extern struct {	173	const SmallStructInts = extern struct {
...	@@ -189,10 +189,10 @@ test "C ABI small struct of ints" {	...	@@ -189,10 +189,10 @@ test "C ABI small struct of ints" {
189	}	189	}
190		190
191	export fn zig_small_struct_ints(x: SmallStructInts) void {	191	export fn zig_small_struct_ints(x: SmallStructInts) void {
192	expect(x.a == 1);	192	expect(x.a == 1) catch @panic("test failure");
193	expect(x.b == 2);	193	expect(x.b == 2) catch @panic("test failure");
194	expect(x.c == 3);	194	expect(x.c == 3) catch @panic("test failure");
195	expect(x.d == 4);	195	expect(x.d == 4) catch @panic("test failure");
196	}	196	}
197		197
198	const SplitStructInt = extern struct {	198	const SplitStructInt = extern struct {
...	@@ -212,9 +212,9 @@ test "C ABI split struct of ints" {	...	@@ -212,9 +212,9 @@ test "C ABI split struct of ints" {
212	}	212	}
213		213
214	export fn zig_split_struct_ints(x: SplitStructInt) void {	214	export fn zig_split_struct_ints(x: SplitStructInt) void {
215	expect(x.a == 1234);	215	expect(x.a == 1234) catch @panic("test failure");
216	expect(x.b == 100);	216	expect(x.b == 100) catch @panic("test failure");
217	expect(x.c == 1337);	217	expect(x.c == 1337) catch @panic("test failure");
218	}	218	}
219		219
220	extern fn c_big_struct_both(BigStruct) BigStruct;	220	extern fn c_big_struct_both(BigStruct) BigStruct;
...	@@ -228,19 +228,19 @@ test "C ABI sret and byval together" {	...	@@ -228,19 +228,19 @@ test "C ABI sret and byval together" {
228	.e = 5,	228	.e = 5,
229	};	229	};
230	var y = c_big_struct_both(s);	230	var y = c_big_struct_both(s);
231	expect(y.a == 10);	231	try expect(y.a == 10);
232	expect(y.b == 11);	232	try expect(y.b == 11);
233	expect(y.c == 12);	233	try expect(y.c == 12);
234	expect(y.d == 13);	234	try expect(y.d == 13);
235	expect(y.e == 14);	235	try expect(y.e == 14);
236	}	236	}
237		237
238	export fn zig_big_struct_both(x: BigStruct) BigStruct {	238	export fn zig_big_struct_both(x: BigStruct) BigStruct {
239	expect(x.a == 30);	239	expect(x.a == 30) catch @panic("test failure");
240	expect(x.b == 31);	240	expect(x.b == 31) catch @panic("test failure");
241	expect(x.c == 32);	241	expect(x.c == 32) catch @panic("test failure");
242	expect(x.d == 33);	242	expect(x.d == 33) catch @panic("test failure");
243	expect(x.e == 34);	243	expect(x.e == 34) catch @panic("test failure");
244	var s = BigStruct{	244	var s = BigStruct{
245	.a = 20,	245	.a = 20,
246	.b = 21,	246	.b = 21,
...	@@ -324,15 +324,15 @@ extern fn c_ret_i32() i32;	...	@@ -324,15 +324,15 @@ extern fn c_ret_i32() i32;
324	extern fn c_ret_i64() i64;	324	extern fn c_ret_i64() i64;
325		325
326	test "C ABI integer return types" {	326	test "C ABI integer return types" {
327	expect(c_ret_bool() == true);	327	try expect(c_ret_bool() == true);
328		328
329	expect(c_ret_u8() == 0xff);	329	try expect(c_ret_u8() == 0xff);
330	expect(c_ret_u16() == 0xffff);	330	try expect(c_ret_u16() == 0xffff);
331	expect(c_ret_u32() == 0xffffffff);	331	try expect(c_ret_u32() == 0xffffffff);
332	expect(c_ret_u64() == 0xffffffffffffffff);	332	try expect(c_ret_u64() == 0xffffffffffffffff);
333		333
334	expect(c_ret_i8() == -1);	334	try expect(c_ret_i8() == -1);
335	expect(c_ret_i16() == -1);	335	try expect(c_ret_i16() == -1);
336	expect(c_ret_i32() == -1);	336	try expect(c_ret_i32() == -1);
337	expect(c_ret_i64() == -1);	337	try expect(c_ret_i64() == -1);
338	}	338	}

test/standalone/brace_expansion/main.zig+31-31

test/standalone/empty_env/main.zig+2-2

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn main() void {	3	pub fn main() !void {
4	const env_map = std.process.getEnvMap(std.testing.allocator) catch @panic("unable to get env map");	4	const env_map = std.process.getEnvMap(std.testing.allocator) catch @panic("unable to get env map");
5	std.testing.expect(env_map.count() == 0);	5	try std.testing.expect(env_map.count() == 0);
6	}	6	}

test/standalone/global_linkage/main.zig+2-2

...	@@ -4,6 +4,6 @@ extern var obj1_integer: usize;	...	@@ -4,6 +4,6 @@ extern var obj1_integer: usize;
4	extern var obj2_integer: usize;	4	extern var obj2_integer: usize;
5		5
6	test "access the external integers" {	6	test "access the external integers" {
7	std.testing.expect(obj1_integer == 421);	7	try std.testing.expect(obj1_integer == 421);
8	std.testing.expect(obj2_integer == 422);	8	try std.testing.expect(obj2_integer == 422);
9	}	9	}

test/standalone/issue_794/main.zig+1-1

...	@@ -3,5 +3,5 @@ const std = @import("std");	...	@@ -3,5 +3,5 @@ const std = @import("std");
3	const testing = std.testing;	3	const testing = std.testing;
4		4
5	test "c import" {	5	test "c import" {
6	comptime testing.expect(c.NUMBER == 1234);	6	comptime try testing.expect(c.NUMBER == 1234);
7	}	7	}

test/standalone/link_interdependent_static_c_libs/main.zig+1-1

...	@@ -4,5 +4,5 @@ const c = @cImport(@cInclude("b.h"));	...	@@ -4,5 +4,5 @@ const c = @cImport(@cInclude("b.h"));
4		4
5	test "import C sub" {	5	test "import C sub" {
6	const result = c.sub(2, 1);	6	const result = c.sub(2, 1);
7	expect(result == 1);	7	try expect(result == 1);
8	}	8	}

test/standalone/static_c_lib/foo.zig+2-2

...	@@ -4,9 +4,9 @@ const c = @cImport(@cInclude("foo.h"));	...	@@ -4,9 +4,9 @@ const c = @cImport(@cInclude("foo.h"));
4		4
5	test "C add" {	5	test "C add" {
6	const result = c.add(1, 2);	6	const result = c.add(1, 2);
7	expect(result == 3);	7	try expect(result == 3);
8	}	8	}
9		9
10	test "C extern variable" {	10	test "C extern variable" {
11	expect(c.foo == 12345);	11	try expect(c.foo == 12345);
12	}	12	}

test/standalone/use_alias/main.zig+1-1

...	@@ -6,5 +6,5 @@ test "symbol exists" {	...	@@ -6,5 +6,5 @@ test "symbol exists" {
6	.a = 1,	6	.a = 1,
7	.b = 1,	7	.b = 1,
8	};	8	};
9	expect(foo.a + foo.b == 2);	9	try expect(foo.a + foo.b == 2);
10	}	10	}

author	Andrew Kelley <andrew@ziglang.org> 2021-05-08 17:29:44-04:00
committer	GitHub <noreply@github.com> 2021-05-08 17:29:44-04:00
log	67154d233ef68d9fd63e673e63e7d66f149060a5
tree	341521e1c7cd9d3ea77726e27661b08d46b9a8dd
parent	fed1c9c3ece7b79ce7fccc6af510f1dab98401a9
parent	7437c47d55da4c73aba26327d1a140aaf6591d4a
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -249,13 +249,13 @@ test "SemanticVersion format" {	...	@@ -249,13 +249,13 @@ test "SemanticVersion format" {
249	"+justmeta",	249	"+justmeta",
250	"9.8.7+meta+meta",	250	"9.8.7+meta+meta",
251	"9.8.7-whatever+meta+meta",	251	"9.8.7-whatever+meta+meta",
252	}) \|invalid\| expectError(error.InvalidVersion, parse(invalid));	252	}) \|invalid\| try expectError(error.InvalidVersion, parse(invalid));
253		253
254	// Valid version string that may overflow.	254	// Valid version string that may overflow.
255	const big_valid = "99999999999999999999999.999999999999999999.99999999999999999";	255	const big_valid = "99999999999999999999999.999999999999999999.99999999999999999";
256	if (parse(big_valid)) \|ver\| {	256	if (parse(big_valid)) \|ver\| {
257	try std.testing.expectFmt(big_valid, "{}", .{ver});	257	try std.testing.expectFmt(big_valid, "{}", .{ver});
258	} else \|err\| expect(err == error.Overflow);	258	} else \|err\| try expect(err == error.Overflow);
259		259
260	// Invalid version string that may overflow.	260	// Invalid version string that may overflow.
261	const big_invalid = "99999999999999999999999.999999999999999999.99999999999999999----RC-SNAPSHOT.12.09.1--------------------------------..12";	261	const big_invalid = "99999999999999999999999.999999999999999999.99999999999999999----RC-SNAPSHOT.12.09.1--------------------------------..12";
...	@@ -264,22 +264,22 @@ test "SemanticVersion format" {	...	@@ -264,22 +264,22 @@ test "SemanticVersion format" {
264		264
265	test "SemanticVersion precedence" {	265	test "SemanticVersion precedence" {
266	// SemVer 2 spec 11.2 example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1.	266	// SemVer 2 spec 11.2 example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1.
267	expect(order(try parse("1.0.0"), try parse("2.0.0")) == .lt);	267	try expect(order(try parse("1.0.0"), try parse("2.0.0")) == .lt);
268	expect(order(try parse("2.0.0"), try parse("2.1.0")) == .lt);	268	try expect(order(try parse("2.0.0"), try parse("2.1.0")) == .lt);
269	expect(order(try parse("2.1.0"), try parse("2.1.1")) == .lt);	269	try expect(order(try parse("2.1.0"), try parse("2.1.1")) == .lt);
270		270
271	// SemVer 2 spec 11.3 example: 1.0.0-alpha < 1.0.0.	271	// SemVer 2 spec 11.3 example: 1.0.0-alpha < 1.0.0.
272	expect(order(try parse("1.0.0-alpha"), try parse("1.0.0")) == .lt);	272	try expect(order(try parse("1.0.0-alpha"), try parse("1.0.0")) == .lt);
273		273
274	// SemVer 2 spec 11.4 example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta <	274	// SemVer 2 spec 11.4 example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta <
275	// 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0.	275	// 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0.
276	expect(order(try parse("1.0.0-alpha"), try parse("1.0.0-alpha.1")) == .lt);	276	try expect(order(try parse("1.0.0-alpha"), try parse("1.0.0-alpha.1")) == .lt);
277	expect(order(try parse("1.0.0-alpha.1"), try parse("1.0.0-alpha.beta")) == .lt);	277	try expect(order(try parse("1.0.0-alpha.1"), try parse("1.0.0-alpha.beta")) == .lt);
278	expect(order(try parse("1.0.0-alpha.beta"), try parse("1.0.0-beta")) == .lt);	278	try expect(order(try parse("1.0.0-alpha.beta"), try parse("1.0.0-beta")) == .lt);
279	expect(order(try parse("1.0.0-beta"), try parse("1.0.0-beta.2")) == .lt);	279	try expect(order(try parse("1.0.0-beta"), try parse("1.0.0-beta.2")) == .lt);
280	expect(order(try parse("1.0.0-beta.2"), try parse("1.0.0-beta.11")) == .lt);	280	try expect(order(try parse("1.0.0-beta.2"), try parse("1.0.0-beta.11")) == .lt);
281	expect(order(try parse("1.0.0-beta.11"), try parse("1.0.0-rc.1")) == .lt);	281	try expect(order(try parse("1.0.0-beta.11"), try parse("1.0.0-rc.1")) == .lt);
282	expect(order(try parse("1.0.0-rc.1"), try parse("1.0.0")) == .lt);	282	try expect(order(try parse("1.0.0-rc.1"), try parse("1.0.0")) == .lt);
283	}	283	}
284		284
285	test "zig_version" {	285	test "zig_version" {

...	@@ -1064,63 +1064,63 @@ test "basic hash map usage" {	...	@@ -1064,63 +1064,63 @@ test "basic hash map usage" {
1064	var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);	1064	var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
1065	defer map.deinit();	1065	defer map.deinit();
1066		1066
1067	testing.expect((try map.fetchPut(1, 11)) == null);	1067	try testing.expect((try map.fetchPut(1, 11)) == null);
1068	testing.expect((try map.fetchPut(2, 22)) == null);	1068	try testing.expect((try map.fetchPut(2, 22)) == null);
1069	testing.expect((try map.fetchPut(3, 33)) == null);	1069	try testing.expect((try map.fetchPut(3, 33)) == null);
1070	testing.expect((try map.fetchPut(4, 44)) == null);	1070	try testing.expect((try map.fetchPut(4, 44)) == null);
1071		1071
1072	try map.putNoClobber(5, 55);	1072	try map.putNoClobber(5, 55);
1073	testing.expect((try map.fetchPut(5, 66)).?.value == 55);	1073	try testing.expect((try map.fetchPut(5, 66)).?.value == 55);
1074	testing.expect((try map.fetchPut(5, 55)).?.value == 66);	1074	try testing.expect((try map.fetchPut(5, 55)).?.value == 66);
1075		1075
1076	const gop1 = try map.getOrPut(5);	1076	const gop1 = try map.getOrPut(5);
1077	testing.expect(gop1.found_existing == true);	1077	try testing.expect(gop1.found_existing == true);
1078	testing.expect(gop1.entry.value == 55);	1078	try testing.expect(gop1.entry.value == 55);
1079	testing.expect(gop1.index == 4);	1079	try testing.expect(gop1.index == 4);
1080	gop1.entry.value = 77;	1080	gop1.entry.value = 77;
1081	testing.expect(map.getEntry(5).?.value == 77);	1081	try testing.expect(map.getEntry(5).?.value == 77);
1082		1082
1083	const gop2 = try map.getOrPut(99);	1083	const gop2 = try map.getOrPut(99);
1084	testing.expect(gop2.found_existing == false);	1084	try testing.expect(gop2.found_existing == false);
1085	testing.expect(gop2.index == 5);	1085	try testing.expect(gop2.index == 5);
1086	gop2.entry.value = 42;	1086	gop2.entry.value = 42;
1087	testing.expect(map.getEntry(99).?.value == 42);	1087	try testing.expect(map.getEntry(99).?.value == 42);
1088		1088
1089	const gop3 = try map.getOrPutValue(5, 5);	1089	const gop3 = try map.getOrPutValue(5, 5);
1090	testing.expect(gop3.value == 77);	1090	try testing.expect(gop3.value == 77);
1091		1091
1092	const gop4 = try map.getOrPutValue(100, 41);	1092	const gop4 = try map.getOrPutValue(100, 41);
1093	testing.expect(gop4.value == 41);	1093	try testing.expect(gop4.value == 41);
1094		1094
1095	testing.expect(map.contains(2));	1095	try testing.expect(map.contains(2));
1096	testing.expect(map.getEntry(2).?.value == 22);	1096	try testing.expect(map.getEntry(2).?.value == 22);
1097	testing.expect(map.get(2).? == 22);	1097	try testing.expect(map.get(2).? == 22);
1098		1098
1099	const rmv1 = map.swapRemove(2);	1099	const rmv1 = map.swapRemove(2);
1100	testing.expect(rmv1.?.key == 2);	1100	try testing.expect(rmv1.?.key == 2);
1101	testing.expect(rmv1.?.value == 22);	1101	try testing.expect(rmv1.?.value == 22);
1102	testing.expect(map.swapRemove(2) == null);	1102	try testing.expect(map.swapRemove(2) == null);
1103	testing.expect(map.getEntry(2) == null);	1103	try testing.expect(map.getEntry(2) == null);
1104	testing.expect(map.get(2) == null);	1104	try testing.expect(map.get(2) == null);
1105		1105
1106	// Since we've used `swapRemove` above, the index of this entry should remain unchanged.	1106	// Since we've used `swapRemove` above, the index of this entry should remain unchanged.
1107	testing.expect(map.getIndex(100).? == 1);	1107	try testing.expect(map.getIndex(100).? == 1);
1108	const gop5 = try map.getOrPut(5);	1108	const gop5 = try map.getOrPut(5);
1109	testing.expect(gop5.found_existing == true);	1109	try testing.expect(gop5.found_existing == true);
1110	testing.expect(gop5.entry.value == 77);	1110	try testing.expect(gop5.entry.value == 77);
1111	testing.expect(gop5.index == 4);	1111	try testing.expect(gop5.index == 4);
1112		1112
1113	// Whereas, if we do an `orderedRemove`, it should move the index forward one spot.	1113	// Whereas, if we do an `orderedRemove`, it should move the index forward one spot.
1114	const rmv2 = map.orderedRemove(100);	1114	const rmv2 = map.orderedRemove(100);
1115	testing.expect(rmv2.?.key == 100);	1115	try testing.expect(rmv2.?.key == 100);
1116	testing.expect(rmv2.?.value == 41);	1116	try testing.expect(rmv2.?.value == 41);
1117	testing.expect(map.orderedRemove(100) == null);	1117	try testing.expect(map.orderedRemove(100) == null);
1118	testing.expect(map.getEntry(100) == null);	1118	try testing.expect(map.getEntry(100) == null);
1119	testing.expect(map.get(100) == null);	1119	try testing.expect(map.get(100) == null);
1120	const gop6 = try map.getOrPut(5);	1120	const gop6 = try map.getOrPut(5);
1121	testing.expect(gop6.found_existing == true);	1121	try testing.expect(gop6.found_existing == true);
1122	testing.expect(gop6.entry.value == 77);	1122	try testing.expect(gop6.entry.value == 77);
1123	testing.expect(gop6.index == 3);	1123	try testing.expect(gop6.index == 3);
1124		1124
1125	map.removeAssertDiscard(3);	1125	map.removeAssertDiscard(3);
1126	}	1126	}
...	@@ -1156,11 +1156,11 @@ test "iterator hash map" {	...	@@ -1156,11 +1156,11 @@ test "iterator hash map" {
1156	while (it.next()) \|entry\| : (count += 1) {	1156	while (it.next()) \|entry\| : (count += 1) {
1157	buffer[@intCast(usize, entry.key)] = entry.value;	1157	buffer[@intCast(usize, entry.key)] = entry.value;
1158	}	1158	}
1159	testing.expect(count == 3);	1159	try testing.expect(count == 3);
1160	testing.expect(it.next() == null);	1160	try testing.expect(it.next() == null);
1161		1161
1162	for (buffer) \|v, i\| {	1162	for (buffer) \|v, i\| {
1163	testing.expect(buffer[@intCast(usize, keys[i])] == values[i]);	1163	try testing.expect(buffer[@intCast(usize, keys[i])] == values[i]);
1164	}	1164	}
1165		1165
1166	it.reset();	1166	it.reset();
...	@@ -1172,13 +1172,13 @@ test "iterator hash map" {	...	@@ -1172,13 +1172,13 @@ test "iterator hash map" {
1172	}	1172	}
1173		1173
1174	for (buffer[0..2]) \|v, i\| {	1174	for (buffer[0..2]) \|v, i\| {
1175	testing.expect(buffer[@intCast(usize, keys[i])] == values[i]);	1175	try testing.expect(buffer[@intCast(usize, keys[i])] == values[i]);
1176	}	1176	}
1177		1177
1178	it.reset();	1178	it.reset();
1179	var entry = it.next().?;	1179	var entry = it.next().?;
1180	testing.expect(entry.key == first_entry.key);	1180	try testing.expect(entry.key == first_entry.key);
1181	testing.expect(entry.value == first_entry.value);	1181	try testing.expect(entry.value == first_entry.value);
1182	}	1182	}
1183		1183
1184	test "ensure capacity" {	1184	test "ensure capacity" {
...	@@ -1187,13 +1187,13 @@ test "ensure capacity" {	...	@@ -1187,13 +1187,13 @@ test "ensure capacity" {
1187		1187
1188	try map.ensureCapacity(20);	1188	try map.ensureCapacity(20);
1189	const initial_capacity = map.capacity();	1189	const initial_capacity = map.capacity();
1190	testing.expect(initial_capacity >= 20);	1190	try testing.expect(initial_capacity >= 20);
1191	var i: i32 = 0;	1191	var i: i32 = 0;
1192	while (i < 20) : (i += 1) {	1192	while (i < 20) : (i += 1) {
1193	testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null);	1193	try testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null);
1194	}	1194	}
1195	// shouldn't resize from putAssumeCapacity	1195	// shouldn't resize from putAssumeCapacity
1196	testing.expect(initial_capacity == map.capacity());	1196	try testing.expect(initial_capacity == map.capacity());
1197	}	1197	}
1198		1198
1199	test "clone" {	1199	test "clone" {
...	@@ -1211,7 +1211,7 @@ test "clone" {	...	@@ -1211,7 +1211,7 @@ test "clone" {
1211		1211
1212	i = 0;	1212	i = 0;
1213	while (i < 10) : (i += 1) {	1213	while (i < 10) : (i += 1) {
1214	testing.expect(copy.get(i).? == i * 10);	1214	try testing.expect(copy.get(i).? == i * 10);
1215	}	1215	}
1216	}	1216	}
1217		1217
...	@@ -1223,35 +1223,35 @@ test "shrink" {	...	@@ -1223,35 +1223,35 @@ test "shrink" {
1223	const num_entries = 20;	1223	const num_entries = 20;
1224	var i: i32 = 0;	1224	var i: i32 = 0;
1225	while (i < num_entries) : (i += 1)	1225	while (i < num_entries) : (i += 1)
1226	testing.expect((try map.fetchPut(i, i * 10)) == null);	1226	try testing.expect((try map.fetchPut(i, i * 10)) == null);
1227		1227
1228	testing.expect(map.unmanaged.index_header != null);	1228	try testing.expect(map.unmanaged.index_header != null);
1229	testing.expect(map.count() == num_entries);	1229	try testing.expect(map.count() == num_entries);
1230		1230
1231	// Test `shrinkRetainingCapacity`.	1231	// Test `shrinkRetainingCapacity`.
1232	map.shrinkRetainingCapacity(17);	1232	map.shrinkRetainingCapacity(17);
1233	testing.expect(map.count() == 17);	1233	try testing.expect(map.count() == 17);
1234	testing.expect(map.capacity() == 20);	1234	try testing.expect(map.capacity() == 20);
1235	i = 0;	1235	i = 0;
1236	while (i < num_entries) : (i += 1) {	1236	while (i < num_entries) : (i += 1) {
1237	const gop = try map.getOrPut(i);	1237	const gop = try map.getOrPut(i);
1238	if (i < 17) {	1238	if (i < 17) {
1239	testing.expect(gop.found_existing == true);	1239	try testing.expect(gop.found_existing == true);
1240	testing.expect(gop.entry.value == i * 10);	1240	try testing.expect(gop.entry.value == i * 10);
1241	} else testing.expect(gop.found_existing == false);	1241	} else try testing.expect(gop.found_existing == false);
1242	}	1242	}
1243		1243
1244	// Test `shrinkAndFree`.	1244	// Test `shrinkAndFree`.
1245	map.shrinkAndFree(15);	1245	map.shrinkAndFree(15);
1246	testing.expect(map.count() == 15);	1246	try testing.expect(map.count() == 15);
1247	testing.expect(map.capacity() == 15);	1247	try testing.expect(map.capacity() == 15);
1248	i = 0;	1248	i = 0;
1249	while (i < num_entries) : (i += 1) {	1249	while (i < num_entries) : (i += 1) {
1250	const gop = try map.getOrPut(i);	1250	const gop = try map.getOrPut(i);
1251	if (i < 15) {	1251	if (i < 15) {
1252	testing.expect(gop.found_existing == true);	1252	try testing.expect(gop.found_existing == true);
1253	testing.expect(gop.entry.value == i * 10);	1253	try testing.expect(gop.entry.value == i * 10);
1254	} else testing.expect(gop.found_existing == false);	1254	} else try testing.expect(gop.found_existing == false);
1255	}	1255	}
1256	}	1256	}
1257		1257
...	@@ -1264,12 +1264,12 @@ test "pop" {	...	@@ -1264,12 +1264,12 @@ test "pop" {
1264		1264
1265	var i: i32 = 0;	1265	var i: i32 = 0;
1266	while (i < 9) : (i += 1) {	1266	while (i < 9) : (i += 1) {
1267	testing.expect((try map.fetchPut(i, i)) == null);	1267	try testing.expect((try map.fetchPut(i, i)) == null);
1268	}	1268	}
1269		1269
1270	while (i > 0) : (i -= 1) {	1270	while (i > 0) : (i -= 1) {
1271	const pop = map.pop();	1271	const pop = map.pop();
1272	testing.expect(pop.key == i - 1 and pop.value == i - 1);	1272	try testing.expect(pop.key == i - 1 and pop.value == i - 1);
1273	}	1273	}
1274	}	1274	}
1275		1275
...	@@ -1281,10 +1281,10 @@ test "reIndex" {	...	@@ -1281,10 +1281,10 @@ test "reIndex" {
1281	const num_indexed_entries = 20;	1281	const num_indexed_entries = 20;
1282	var i: i32 = 0;	1282	var i: i32 = 0;
1283	while (i < num_indexed_entries) : (i += 1)	1283	while (i < num_indexed_entries) : (i += 1)
1284	testing.expect((try map.fetchPut(i, i * 10)) == null);	1284	try testing.expect((try map.fetchPut(i, i * 10)) == null);
1285		1285
1286	// Make sure we allocated an index header.	1286	// Make sure we allocated an index header.
1287	testing.expect(map.unmanaged.index_header != null);	1287	try testing.expect(map.unmanaged.index_header != null);
1288		1288
1289	// Now write to the underlying array list directly.	1289	// Now write to the underlying array list directly.
1290	const num_unindexed_entries = 20;	1290	const num_unindexed_entries = 20;
...	@@ -1303,9 +1303,9 @@ test "reIndex" {	...	@@ -1303,9 +1303,9 @@ test "reIndex" {
1303	i = 0;	1303	i = 0;
1304	while (i < num_indexed_entries + num_unindexed_entries) : (i += 1) {	1304	while (i < num_indexed_entries + num_unindexed_entries) : (i += 1) {
1305	const gop = try map.getOrPut(i);	1305	const gop = try map.getOrPut(i);
1306	testing.expect(gop.found_existing == true);	1306	try testing.expect(gop.found_existing == true);
1307	testing.expect(gop.entry.value == i * 10);	1307	try testing.expect(gop.entry.value == i * 10);
1308	testing.expect(gop.index == i);	1308	try testing.expect(gop.index == i);
1309	}	1309	}
1310	}	1310	}
1311		1311
...	@@ -1332,9 +1332,9 @@ test "fromOwnedArrayList" {	...	@@ -1332,9 +1332,9 @@ test "fromOwnedArrayList" {
1332	i = 0;	1332	i = 0;
1333	while (i < num_entries) : (i += 1) {	1333	while (i < num_entries) : (i += 1) {
1334	const gop = try map.getOrPut(i);	1334	const gop = try map.getOrPut(i);
1335	testing.expect(gop.found_existing == true);	1335	try testing.expect(gop.found_existing == true);
1336	testing.expect(gop.entry.value == i * 10);	1336	try testing.expect(gop.entry.value == i * 10);
1337	testing.expect(gop.index == i);	1337	try testing.expect(gop.index == i);
1338	}	1338	}
1339	}	1339	}
1340		1340

...	@@ -236,11 +236,11 @@ pub const spaces = [_]u8{ ' ', '\t', '\n', '\r', control_code.VT, control_code.F	...	@@ -236,11 +236,11 @@ pub const spaces = [_]u8{ ' ', '\t', '\n', '\r', control_code.VT, control_code.F
236		236
237	test "spaces" {	237	test "spaces" {
238	const testing = std.testing;	238	const testing = std.testing;
239	for (spaces) \|space\| testing.expect(isSpace(space));	239	for (spaces) \|space\| try testing.expect(isSpace(space));
240		240
241	var i: u8 = 0;	241	var i: u8 = 0;
242	while (isASCII(i)) : (i += 1) {	242	while (isASCII(i)) : (i += 1) {
243	if (isSpace(i)) testing.expect(std.mem.indexOfScalar(u8, &spaces, i) != null);	243	if (isSpace(i)) try testing.expect(std.mem.indexOfScalar(u8, &spaces, i) != null);
244	}	244	}
245	}	245	}
246		246
...	@@ -279,13 +279,13 @@ pub fn toLower(c: u8) u8 {	...	@@ -279,13 +279,13 @@ pub fn toLower(c: u8) u8 {
279	test "ascii character classes" {	279	test "ascii character classes" {
280	const testing = std.testing;	280	const testing = std.testing;
281		281
282	testing.expect('C' == toUpper('c'));	282	try testing.expect('C' == toUpper('c'));
283	testing.expect(':' == toUpper(':'));	283	try testing.expect(':' == toUpper(':'));
284	testing.expect('\xab' == toUpper('\xab'));	284	try testing.expect('\xab' == toUpper('\xab'));
285	testing.expect('c' == toLower('C'));	285	try testing.expect('c' == toLower('C'));
286	testing.expect(isAlpha('c'));	286	try testing.expect(isAlpha('c'));
287	testing.expect(!isAlpha('5'));	287	try testing.expect(!isAlpha('5'));
288	testing.expect(isSpace(' '));	288	try testing.expect(isSpace(' '));
289	}	289	}
290		290
291	/// Allocates a lower case copy of `ascii_string`.	291	/// Allocates a lower case copy of `ascii_string`.
...	@@ -301,7 +301,7 @@ pub fn allocLowerString(allocator: *std.mem.Allocator, ascii_string: []const u8)	...	@@ -301,7 +301,7 @@ pub fn allocLowerString(allocator: *std.mem.Allocator, ascii_string: []const u8)
301	test "allocLowerString" {	301	test "allocLowerString" {
302	const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");	302	const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
303	defer std.testing.allocator.free(result);	303	defer std.testing.allocator.free(result);
304	std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+💩!", result));	304	try std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+💩!", result));
305	}	305	}
306		306
307	/// Allocates an upper case copy of `ascii_string`.	307	/// Allocates an upper case copy of `ascii_string`.
...	@@ -317,7 +317,7 @@ pub fn allocUpperString(allocator: *std.mem.Allocator, ascii_string: []const u8)	...	@@ -317,7 +317,7 @@ pub fn allocUpperString(allocator: *std.mem.Allocator, ascii_string: []const u8)
317	test "allocUpperString" {	317	test "allocUpperString" {
318	const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");	318	const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
319	defer std.testing.allocator.free(result);	319	defer std.testing.allocator.free(result);
320	std.testing.expect(std.mem.eql(u8, "ABCDEFGHIJKLMNOPQRST0234+💩!", result));	320	try std.testing.expect(std.mem.eql(u8, "ABCDEFGHIJKLMNOPQRST0234+💩!", result));
321	}	321	}
322		322
323	/// Compares strings `a` and `b` case insensitively and returns whether they are equal.	323	/// Compares strings `a` and `b` case insensitively and returns whether they are equal.
...	@@ -330,9 +330,9 @@ pub fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {	...	@@ -330,9 +330,9 @@ pub fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {
330	}	330	}
331		331
332	test "eqlIgnoreCase" {	332	test "eqlIgnoreCase" {
333	std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));	333	try std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));
334	std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));	334	try std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));
335	std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));	335	try std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));
336	}	336	}
337		337
338	pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {	338	pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
...	@@ -340,8 +340,8 @@ pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {	...	@@ -340,8 +340,8 @@ pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
340	}	340	}
341		341
342	test "ascii.startsWithIgnoreCase" {	342	test "ascii.startsWithIgnoreCase" {
343	std.testing.expect(startsWithIgnoreCase("boB", "Bo"));	343	try std.testing.expect(startsWithIgnoreCase("boB", "Bo"));
344	std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));	344	try std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));
345	}	345	}
346		346
347	pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {	347	pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
...	@@ -349,8 +349,8 @@ pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {	...	@@ -349,8 +349,8 @@ pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
349	}	349	}
350		350
351	test "ascii.endsWithIgnoreCase" {	351	test "ascii.endsWithIgnoreCase" {
352	std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));	352	try std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));
353	std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));	353	try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));
354	}	354	}
355		355
356	/// Finds `substr` in `container`, ignoring case, starting at `start_index`.	356	/// Finds `substr` in `container`, ignoring case, starting at `start_index`.
...	@@ -372,12 +372,12 @@ pub fn indexOfIgnoreCase(container: []const u8, substr: []const u8) ?usize {	...	@@ -372,12 +372,12 @@ pub fn indexOfIgnoreCase(container: []const u8, substr: []const u8) ?usize {
372	}	372	}
373		373
374	test "indexOfIgnoreCase" {	374	test "indexOfIgnoreCase" {
375	std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14);	375	try std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14);
376	std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null);	376	try std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null);
377	std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);	377	try std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);
378	std.testing.expect(indexOfIgnoreCase("foo", "fool") == null);	378	try std.testing.expect(indexOfIgnoreCase("foo", "fool") == null);
379		379
380	std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0);	380	try std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0);
381	}	381	}
382		382
383	/// Compares two slices of numbers lexicographically. O(n).	383	/// Compares two slices of numbers lexicographically. O(n).

...	@@ -318,14 +318,14 @@ pub const Base64DecoderWithIgnore = struct {	...	@@ -318,14 +318,14 @@ pub const Base64DecoderWithIgnore = struct {
318		318
319	test "base64" {	319	test "base64" {
320	@setEvalBranchQuota(8000);	320	@setEvalBranchQuota(8000);
321	testBase64() catch unreachable;	321	try testBase64();
322	comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=") catch unreachable;	322	comptime try testAllApis(standard, "comptime", "Y29tcHRpbWU=");
323	}	323	}
324		324
325	test "base64 url_safe_no_pad" {	325	test "base64 url_safe_no_pad" {
326	@setEvalBranchQuota(8000);	326	@setEvalBranchQuota(8000);
327	testBase64UrlSafeNoPad() catch unreachable;	327	try testBase64UrlSafeNoPad();
328	comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU") catch unreachable;	328	comptime try testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU");
329	}	329	}
330		330
331	fn testBase64() !void {	331	fn testBase64() !void {
...	@@ -404,7 +404,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [	...	@@ -404,7 +404,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [
404	{	404	{
405	var buffer: [0x100]u8 = undefined;	405	var buffer: [0x100]u8 = undefined;
406	const encoded = codecs.Encoder.encode(&buffer, expected_decoded);	406	const encoded = codecs.Encoder.encode(&buffer, expected_decoded);
407	testing.expectEqualSlices(u8, expected_encoded, encoded);	407	try testing.expectEqualSlices(u8, expected_encoded, encoded);
408	}	408	}
409		409
410	// Base64Decoder	410	// Base64Decoder
...	@@ -412,7 +412,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [	...	@@ -412,7 +412,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [
412	var buffer: [0x100]u8 = undefined;	412	var buffer: [0x100]u8 = undefined;
413	var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)];	413	var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)];
414	try codecs.Decoder.decode(decoded, expected_encoded);	414	try codecs.Decoder.decode(decoded, expected_encoded);
415	testing.expectEqualSlices(u8, expected_decoded, decoded);	415	try testing.expectEqualSlices(u8, expected_decoded, decoded);
416	}	416	}
417		417
418	// Base64DecoderWithIgnore	418	// Base64DecoderWithIgnore
...	@@ -421,8 +421,8 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [	...	@@ -421,8 +421,8 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [
421	var buffer: [0x100]u8 = undefined;	421	var buffer: [0x100]u8 = undefined;
422	var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)];	422	var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)];
423	var written = try decoder_ignore_nothing.decode(decoded, expected_encoded);	423	var written = try decoder_ignore_nothing.decode(decoded, expected_encoded);
424	testing.expect(written <= decoded.len);	424	try testing.expect(written <= decoded.len);
425	testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);	425	try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
426	}	426	}
427	}	427	}
428		428
...	@@ -431,7 +431,7 @@ fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded:	...	@@ -431,7 +431,7 @@ fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded:
431	var buffer: [0x100]u8 = undefined;	431	var buffer: [0x100]u8 = undefined;
432	var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)];	432	var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)];
433	var written = try decoder_ignore_space.decode(decoded, encoded);	433	var written = try decoder_ignore_space.decode(decoded, encoded);
434	testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);	434	try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]);
435	}	435	}
436		436
437	fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void {	437	fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void {

...	@@ -998,9 +998,9 @@ fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) typ	...	@@ -998,9 +998,9 @@ fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) typ
998		998
999	const testing = std.testing;	999	const testing = std.testing;
1000		1000
1001	fn testBitSet(a: anytype, b: anytype, len: usize) void {	1001	fn testBitSet(a: anytype, b: anytype, len: usize) !void {
1002	testing.expectEqual(len, a.capacity());	1002	try testing.expectEqual(len, a.capacity());
1003	testing.expectEqual(len, b.capacity());	1003	try testing.expectEqual(len, b.capacity());
1004		1004
1005	{	1005	{
1006	var i: usize = 0;	1006	var i: usize = 0;
...	@@ -1010,50 +1010,50 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {	...	@@ -1010,50 +1010,50 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {
1010	}	1010	}
1011	}	1011	}
1012		1012
1013	testing.expectEqual((len + 1) / 2, a.count());	1013	try testing.expectEqual((len + 1) / 2, a.count());
1014	testing.expectEqual((len + 3) / 4 + (len + 2) / 4, b.count());	1014	try testing.expectEqual((len + 3) / 4 + (len + 2) / 4, b.count());
1015		1015
1016	{	1016	{
1017	var iter = a.iterator(.{});	1017	var iter = a.iterator(.{});
1018	var i: usize = 0;	1018	var i: usize = 0;
1019	while (i < len) : (i += 2) {	1019	while (i < len) : (i += 2) {
1020	testing.expectEqual(@as(?usize, i), iter.next());	1020	try testing.expectEqual(@as(?usize, i), iter.next());
1021	}	1021	}
1022	testing.expectEqual(@as(?usize, null), iter.next());	1022	try testing.expectEqual(@as(?usize, null), iter.next());
1023	testing.expectEqual(@as(?usize, null), iter.next());	1023	try testing.expectEqual(@as(?usize, null), iter.next());
1024	testing.expectEqual(@as(?usize, null), iter.next());	1024	try testing.expectEqual(@as(?usize, null), iter.next());
1025	}	1025	}
1026	a.toggleAll();	1026	a.toggleAll();
1027	{	1027	{
1028	var iter = a.iterator(.{});	1028	var iter = a.iterator(.{});
1029	var i: usize = 1;	1029	var i: usize = 1;
1030	while (i < len) : (i += 2) {	1030	while (i < len) : (i += 2) {
1031	testing.expectEqual(@as(?usize, i), iter.next());	1031	try testing.expectEqual(@as(?usize, i), iter.next());
1032	}	1032	}
1033	testing.expectEqual(@as(?usize, null), iter.next());	1033	try testing.expectEqual(@as(?usize, null), iter.next());
1034	testing.expectEqual(@as(?usize, null), iter.next());	1034	try testing.expectEqual(@as(?usize, null), iter.next());
1035	testing.expectEqual(@as(?usize, null), iter.next());	1035	try testing.expectEqual(@as(?usize, null), iter.next());
1036	}	1036	}
1037		1037
1038	{	1038	{
1039	var iter = b.iterator(.{ .kind = .unset });	1039	var iter = b.iterator(.{ .kind = .unset });
1040	var i: usize = 2;	1040	var i: usize = 2;
1041	while (i < len) : (i += 4) {	1041	while (i < len) : (i += 4) {
1042	testing.expectEqual(@as(?usize, i), iter.next());	1042	try testing.expectEqual(@as(?usize, i), iter.next());
1043	if (i + 1 < len) {	1043	if (i + 1 < len) {
1044	testing.expectEqual(@as(?usize, i + 1), iter.next());	1044	try testing.expectEqual(@as(?usize, i + 1), iter.next());
1045	}	1045	}
1046	}	1046	}
1047	testing.expectEqual(@as(?usize, null), iter.next());	1047	try testing.expectEqual(@as(?usize, null), iter.next());
1048	testing.expectEqual(@as(?usize, null), iter.next());	1048	try testing.expectEqual(@as(?usize, null), iter.next());
1049	testing.expectEqual(@as(?usize, null), iter.next());	1049	try testing.expectEqual(@as(?usize, null), iter.next());
1050	}	1050	}
1051		1051
1052	{	1052	{
1053	var i: usize = 0;	1053	var i: usize = 0;
1054	while (i < len) : (i += 1) {	1054	while (i < len) : (i += 1) {
1055	testing.expectEqual(i & 1 != 0, a.isSet(i));	1055	try testing.expectEqual(i & 1 != 0, a.isSet(i));
1056	testing.expectEqual(i & 2 == 0, b.isSet(i));	1056	try testing.expectEqual(i & 2 == 0, b.isSet(i));
1057	}	1057	}
1058	}	1058	}
1059		1059
...	@@ -1061,8 +1061,8 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {	...	@@ -1061,8 +1061,8 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {
1061	{	1061	{
1062	var i: usize = 0;	1062	var i: usize = 0;
1063	while (i < len) : (i += 1) {	1063	while (i < len) : (i += 1) {
1064	testing.expectEqual(i & 1 != 0 or i & 2 == 0, a.isSet(i));	1064	try testing.expectEqual(i & 1 != 0 or i & 2 == 0, a.isSet(i));
1065	testing.expectEqual(i & 2 == 0, b.isSet(i));	1065	try testing.expectEqual(i & 2 == 0, b.isSet(i));
1066	}	1066	}
1067		1067
1068	i = len;	1068	i = len;
...	@@ -1071,27 +1071,27 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {	...	@@ -1071,27 +1071,27 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {
1071	while (i > 0) {	1071	while (i > 0) {
1072	i -= 1;	1072	i -= 1;
1073	if (i & 1 != 0 or i & 2 == 0) {	1073	if (i & 1 != 0 or i & 2 == 0) {
1074	testing.expectEqual(@as(?usize, i), set.next());	1074	try testing.expectEqual(@as(?usize, i), set.next());
1075	} else {	1075	} else {
1076	testing.expectEqual(@as(?usize, i), unset.next());	1076	try testing.expectEqual(@as(?usize, i), unset.next());
1077	}	1077	}
1078	}	1078	}
1079	testing.expectEqual(@as(?usize, null), set.next());	1079	try testing.expectEqual(@as(?usize, null), set.next());
1080	testing.expectEqual(@as(?usize, null), set.next());	1080	try testing.expectEqual(@as(?usize, null), set.next());
1081	testing.expectEqual(@as(?usize, null), set.next());	1081	try testing.expectEqual(@as(?usize, null), set.next());
1082	testing.expectEqual(@as(?usize, null), unset.next());	1082	try testing.expectEqual(@as(?usize, null), unset.next());
1083	testing.expectEqual(@as(?usize, null), unset.next());	1083	try testing.expectEqual(@as(?usize, null), unset.next());
1084	testing.expectEqual(@as(?usize, null), unset.next());	1084	try testing.expectEqual(@as(?usize, null), unset.next());
1085	}	1085	}
1086		1086
1087	a.toggleSet(b.*);	1087	a.toggleSet(b.*);
1088	{	1088	{
1089	testing.expectEqual(len / 4, a.count());	1089	try testing.expectEqual(len / 4, a.count());
1090		1090
1091	var i: usize = 0;	1091	var i: usize = 0;
1092	while (i < len) : (i += 1) {	1092	while (i < len) : (i += 1) {
1093	testing.expectEqual(i & 1 != 0 and i & 2 != 0, a.isSet(i));	1093	try testing.expectEqual(i & 1 != 0 and i & 2 != 0, a.isSet(i));
1094	testing.expectEqual(i & 2 == 0, b.isSet(i));	1094	try testing.expectEqual(i & 2 == 0, b.isSet(i));
1095	if (i & 1 == 0) {	1095	if (i & 1 == 0) {
1096	a.set(i);	1096	a.set(i);
1097	} else {	1097	} else {
...	@@ -1102,29 +1102,29 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {	...	@@ -1102,29 +1102,29 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {
1102		1102
1103	a.setIntersection(b.*);	1103	a.setIntersection(b.*);
1104	{	1104	{
1105	testing.expectEqual((len + 3) / 4, a.count());	1105	try testing.expectEqual((len + 3) / 4, a.count());
1106		1106
1107	var i: usize = 0;	1107	var i: usize = 0;
1108	while (i < len) : (i += 1) {	1108	while (i < len) : (i += 1) {
1109	testing.expectEqual(i & 1 == 0 and i & 2 == 0, a.isSet(i));	1109	try testing.expectEqual(i & 1 == 0 and i & 2 == 0, a.isSet(i));
1110	testing.expectEqual(i & 2 == 0, b.isSet(i));	1110	try testing.expectEqual(i & 2 == 0, b.isSet(i));
1111	}	1111	}
1112	}	1112	}
1113		1113
1114	a.toggleSet(a.*);	1114	a.toggleSet(a.*);
1115	{	1115	{
1116	var iter = a.iterator(.{});	1116	var iter = a.iterator(.{});
1117	testing.expectEqual(@as(?usize, null), iter.next());	1117	try testing.expectEqual(@as(?usize, null), iter.next());
1118	testing.expectEqual(@as(?usize, null), iter.next());	1118	try testing.expectEqual(@as(?usize, null), iter.next());
1119	testing.expectEqual(@as(?usize, null), iter.next());	1119	try testing.expectEqual(@as(?usize, null), iter.next());
1120	testing.expectEqual(@as(usize, 0), a.count());	1120	try testing.expectEqual(@as(usize, 0), a.count());
1121	}	1121	}
1122	{	1122	{
1123	var iter = a.iterator(.{ .direction = .reverse });	1123	var iter = a.iterator(.{ .direction = .reverse });
1124	testing.expectEqual(@as(?usize, null), iter.next());	1124	try testing.expectEqual(@as(?usize, null), iter.next());
1125	testing.expectEqual(@as(?usize, null), iter.next());	1125	try testing.expectEqual(@as(?usize, null), iter.next());
1126	testing.expectEqual(@as(?usize, null), iter.next());	1126	try testing.expectEqual(@as(?usize, null), iter.next());
1127	testing.expectEqual(@as(usize, 0), a.count());	1127	try testing.expectEqual(@as(usize, 0), a.count());
1128	}	1128	}
1129		1129
1130	const test_bits = [_]usize{	1130	const test_bits = [_]usize{
...	@@ -1139,51 +1139,51 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {	...	@@ -1139,51 +1139,51 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void {
1139		1139
1140	for (test_bits) \|i\| {	1140	for (test_bits) \|i\| {
1141	if (i < a.capacity()) {	1141	if (i < a.capacity()) {
1142	testing.expectEqual(@as(?usize, i), a.findFirstSet());	1142	try testing.expectEqual(@as(?usize, i), a.findFirstSet());
1143	testing.expectEqual(@as(?usize, i), a.toggleFirstSet());	1143	try testing.expectEqual(@as(?usize, i), a.toggleFirstSet());
1144	}	1144	}
1145	}	1145	}
1146	testing.expectEqual(@as(?usize, null), a.findFirstSet());	1146	try testing.expectEqual(@as(?usize, null), a.findFirstSet());
1147	testing.expectEqual(@as(?usize, null), a.toggleFirstSet());	1147	try testing.expectEqual(@as(?usize, null), a.toggleFirstSet());
1148	testing.expectEqual(@as(?usize, null), a.findFirstSet());	1148	try testing.expectEqual(@as(?usize, null), a.findFirstSet());
1149	testing.expectEqual(@as(?usize, null), a.toggleFirstSet());	1149	try testing.expectEqual(@as(?usize, null), a.toggleFirstSet());
1150	testing.expectEqual(@as(usize, 0), a.count());	1150	try testing.expectEqual(@as(usize, 0), a.count());
1151	}	1151	}
1152		1152
1153	fn testStaticBitSet(comptime Set: type) void {	1153	fn testStaticBitSet(comptime Set: type) !void {
1154	var a = Set.initEmpty();	1154	var a = Set.initEmpty();
1155	var b = Set.initFull();	1155	var b = Set.initFull();
1156	testing.expectEqual(@as(usize, 0), a.count());	1156	try testing.expectEqual(@as(usize, 0), a.count());
1157	testing.expectEqual(@as(usize, Set.bit_length), b.count());	1157	try testing.expectEqual(@as(usize, Set.bit_length), b.count());
1158		1158
1159	testBitSet(&a, &b, Set.bit_length);	1159	try testBitSet(&a, &b, Set.bit_length);
1160	}	1160	}
1161		1161
1162	test "IntegerBitSet" {	1162	test "IntegerBitSet" {
1163	testStaticBitSet(IntegerBitSet(0));	1163	try testStaticBitSet(IntegerBitSet(0));
1164	testStaticBitSet(IntegerBitSet(1));	1164	try testStaticBitSet(IntegerBitSet(1));
1165	testStaticBitSet(IntegerBitSet(2));	1165	try testStaticBitSet(IntegerBitSet(2));
1166	testStaticBitSet(IntegerBitSet(5));	1166	try testStaticBitSet(IntegerBitSet(5));
1167	testStaticBitSet(IntegerBitSet(8));	1167	try testStaticBitSet(IntegerBitSet(8));
1168	testStaticBitSet(IntegerBitSet(32));	1168	try testStaticBitSet(IntegerBitSet(32));
1169	testStaticBitSet(IntegerBitSet(64));	1169	try testStaticBitSet(IntegerBitSet(64));
1170	testStaticBitSet(IntegerBitSet(127));	1170	try testStaticBitSet(IntegerBitSet(127));
1171	}	1171	}
1172		1172
1173	test "ArrayBitSet" {	1173	test "ArrayBitSet" {
1174	inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) \|size\| {	1174	inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) \|size\| {
1175	testStaticBitSet(ArrayBitSet(u8, size));	1175	try testStaticBitSet(ArrayBitSet(u8, size));
1176	testStaticBitSet(ArrayBitSet(u16, size));	1176	try testStaticBitSet(ArrayBitSet(u16, size));
1177	testStaticBitSet(ArrayBitSet(u32, size));	1177	try testStaticBitSet(ArrayBitSet(u32, size));
1178	testStaticBitSet(ArrayBitSet(u64, size));	1178	try testStaticBitSet(ArrayBitSet(u64, size));
1179	testStaticBitSet(ArrayBitSet(u128, size));	1179	try testStaticBitSet(ArrayBitSet(u128, size));
1180	}	1180	}
1181	}	1181	}
1182		1182
1183	test "DynamicBitSetUnmanaged" {	1183	test "DynamicBitSetUnmanaged" {
1184	const allocator = std.testing.allocator;	1184	const allocator = std.testing.allocator;
1185	var a = try DynamicBitSetUnmanaged.initEmpty(300, allocator);	1185	var a = try DynamicBitSetUnmanaged.initEmpty(300, allocator);
1186	testing.expectEqual(@as(usize, 0), a.count());	1186	try testing.expectEqual(@as(usize, 0), a.count());
1187	a.deinit(allocator);	1187	a.deinit(allocator);
1188		1188
1189	a = try DynamicBitSetUnmanaged.initEmpty(0, allocator);	1189	a = try DynamicBitSetUnmanaged.initEmpty(0, allocator);
...	@@ -1193,10 +1193,10 @@ test "DynamicBitSetUnmanaged" {	...	@@ -1193,10 +1193,10 @@ test "DynamicBitSetUnmanaged" {
1193		1193
1194	var tmp = try a.clone(allocator);	1194	var tmp = try a.clone(allocator);
1195	defer tmp.deinit(allocator);	1195	defer tmp.deinit(allocator);
1196	testing.expectEqual(old_len, tmp.capacity());	1196	try testing.expectEqual(old_len, tmp.capacity());
1197	var i: usize = 0;	1197	var i: usize = 0;
1198	while (i < old_len) : (i += 1) {	1198	while (i < old_len) : (i += 1) {
1199	testing.expectEqual(a.isSet(i), tmp.isSet(i));	1199	try testing.expectEqual(a.isSet(i), tmp.isSet(i));
1200	}	1200	}
1201		1201
1202	a.toggleSet(a); // zero a	1202	a.toggleSet(a); // zero a
...	@@ -1206,24 +1206,24 @@ test "DynamicBitSetUnmanaged" {	...	@@ -1206,24 +1206,24 @@ test "DynamicBitSetUnmanaged" {
1206	try tmp.resize(size, false, allocator);	1206	try tmp.resize(size, false, allocator);
1207		1207
1208	if (size > old_len) {	1208	if (size > old_len) {
1209	testing.expectEqual(size - old_len, a.count());	1209	try testing.expectEqual(size - old_len, a.count());
1210	} else {	1210	} else {
1211	testing.expectEqual(@as(usize, 0), a.count());	1211	try testing.expectEqual(@as(usize, 0), a.count());
1212	}	1212	}
1213	testing.expectEqual(@as(usize, 0), tmp.count());	1213	try testing.expectEqual(@as(usize, 0), tmp.count());
1214		1214
1215	var b = try DynamicBitSetUnmanaged.initFull(size, allocator);	1215	var b = try DynamicBitSetUnmanaged.initFull(size, allocator);
1216	defer b.deinit(allocator);	1216	defer b.deinit(allocator);
1217	testing.expectEqual(@as(usize, size), b.count());	1217	try testing.expectEqual(@as(usize, size), b.count());
1218		1218
1219	testBitSet(&a, &b, size);	1219	try testBitSet(&a, &b, size);
1220	}	1220	}
1221	}	1221	}
1222		1222
1223	test "DynamicBitSet" {	1223	test "DynamicBitSet" {
1224	const allocator = std.testing.allocator;	1224	const allocator = std.testing.allocator;
1225	var a = try DynamicBitSet.initEmpty(300, allocator);	1225	var a = try DynamicBitSet.initEmpty(300, allocator);
1226	testing.expectEqual(@as(usize, 0), a.count());	1226	try testing.expectEqual(@as(usize, 0), a.count());
1227	a.deinit();	1227	a.deinit();
1228		1228
1229	a = try DynamicBitSet.initEmpty(0, allocator);	1229	a = try DynamicBitSet.initEmpty(0, allocator);
...	@@ -1233,10 +1233,10 @@ test "DynamicBitSet" {	...	@@ -1233,10 +1233,10 @@ test "DynamicBitSet" {
1233		1233
1234	var tmp = try a.clone(allocator);	1234	var tmp = try a.clone(allocator);
1235	defer tmp.deinit();	1235	defer tmp.deinit();
1236	testing.expectEqual(old_len, tmp.capacity());	1236	try testing.expectEqual(old_len, tmp.capacity());
1237	var i: usize = 0;	1237	var i: usize = 0;
1238	while (i < old_len) : (i += 1) {	1238	while (i < old_len) : (i += 1) {
1239	testing.expectEqual(a.isSet(i), tmp.isSet(i));	1239	try testing.expectEqual(a.isSet(i), tmp.isSet(i));
1240	}	1240	}
1241		1241
1242	a.toggleSet(a); // zero a	1242	a.toggleSet(a); // zero a
...	@@ -1246,24 +1246,24 @@ test "DynamicBitSet" {	...	@@ -1246,24 +1246,24 @@ test "DynamicBitSet" {
1246	try tmp.resize(size, false);	1246	try tmp.resize(size, false);
1247		1247
1248	if (size > old_len) {	1248	if (size > old_len) {
1249	testing.expectEqual(size - old_len, a.count());	1249	try testing.expectEqual(size - old_len, a.count());
1250	} else {	1250	} else {
1251	testing.expectEqual(@as(usize, 0), a.count());	1251	try testing.expectEqual(@as(usize, 0), a.count());
1252	}	1252	}
1253	testing.expectEqual(@as(usize, 0), tmp.count());	1253	try testing.expectEqual(@as(usize, 0), tmp.count());
1254		1254
1255	var b = try DynamicBitSet.initFull(size, allocator);	1255	var b = try DynamicBitSet.initFull(size, allocator);
1256	defer b.deinit();	1256	defer b.deinit();
1257	testing.expectEqual(@as(usize, size), b.count());	1257	try testing.expectEqual(@as(usize, size), b.count());
1258		1258
1259	testBitSet(&a, &b, size);	1259	try testBitSet(&a, &b, size);
1260	}	1260	}
1261	}	1261	}
1262		1262
1263	test "StaticBitSet" {	1263	test "StaticBitSet" {
1264	testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));	1264	try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));
1265	testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));	1265	try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));
1266	testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));	1266	try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));
1267	testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1));	1267	try testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1));
1268	testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500));	1268	try testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500));
1269	}	1269	}

...	@@ -94,19 +94,19 @@ test "BufMap" {	...	@@ -94,19 +94,19 @@ test "BufMap" {
94	defer bufmap.deinit();	94	defer bufmap.deinit();
95		95
96	try bufmap.set("x", "1");	96	try bufmap.set("x", "1");
97	testing.expect(mem.eql(u8, bufmap.get("x").?, "1"));	97	try testing.expect(mem.eql(u8, bufmap.get("x").?, "1"));
98	testing.expect(1 == bufmap.count());	98	try testing.expect(1 == bufmap.count());
99		99
100	try bufmap.set("x", "2");	100	try bufmap.set("x", "2");
101	testing.expect(mem.eql(u8, bufmap.get("x").?, "2"));	101	try testing.expect(mem.eql(u8, bufmap.get("x").?, "2"));
102	testing.expect(1 == bufmap.count());	102	try testing.expect(1 == bufmap.count());
103		103
104	try bufmap.set("x", "3");	104	try bufmap.set("x", "3");
105	testing.expect(mem.eql(u8, bufmap.get("x").?, "3"));	105	try testing.expect(mem.eql(u8, bufmap.get("x").?, "3"));
106	testing.expect(1 == bufmap.count());	106	try testing.expect(1 == bufmap.count());
107		107
108	bufmap.delete("x");	108	bufmap.delete("x");
109	testing.expect(0 == bufmap.count());	109	try testing.expect(0 == bufmap.count());
110		110
111	try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v1"));	111	try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v1"));
112	try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v2"));	112	try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v2"));

...	@@ -3060,19 +3060,19 @@ test "Builder.dupePkg()" {	...	@@ -3060,19 +3060,19 @@ test "Builder.dupePkg()" {
3060	const dupe_deps = dupe.dependencies.?;	3060	const dupe_deps = dupe.dependencies.?;
3061		3061
3062	// probably the same top level package details	3062	// probably the same top level package details
3063	std.testing.expectEqualStrings(pkg_top.name, dupe.name);	3063	try std.testing.expectEqualStrings(pkg_top.name, dupe.name);
3064		3064
3065	// probably the same dependencies	3065	// probably the same dependencies
3066	std.testing.expectEqual(original_deps.len, dupe_deps.len);	3066	try std.testing.expectEqual(original_deps.len, dupe_deps.len);
3067	std.testing.expectEqual(original_deps[0].name, pkg_dep.name);	3067	try std.testing.expectEqual(original_deps[0].name, pkg_dep.name);
3068		3068
3069	// could segfault otherwise if pointers in duplicated package's fields are	3069	// could segfault otherwise if pointers in duplicated package's fields are
3070	// the same as those in stack allocated package's fields	3070	// the same as those in stack allocated package's fields
3071	std.testing.expect(dupe_deps.ptr != original_deps.ptr);	3071	try std.testing.expect(dupe_deps.ptr != original_deps.ptr);
3072	std.testing.expect(dupe.name.ptr != pkg_top.name.ptr);	3072	try std.testing.expect(dupe.name.ptr != pkg_top.name.ptr);
3073	std.testing.expect(dupe.path.ptr != pkg_top.path.ptr);	3073	try std.testing.expect(dupe.path.ptr != pkg_top.path.ptr);
3074	std.testing.expect(dupe_deps[0].name.ptr != pkg_dep.name.ptr);	3074	try std.testing.expect(dupe_deps[0].name.ptr != pkg_dep.name.ptr);
3075	std.testing.expect(dupe_deps[0].path.ptr != pkg_dep.path.ptr);	3075	try std.testing.expect(dupe_deps[0].path.ptr != pkg_dep.path.ptr);
3076	}	3076	}
3077		3077
3078	test "LibExeObjStep.addBuildOption" {	3078	test "LibExeObjStep.addBuildOption" {
...	@@ -3096,7 +3096,7 @@ test "LibExeObjStep.addBuildOption" {	...	@@ -3096,7 +3096,7 @@ test "LibExeObjStep.addBuildOption" {
3096	exe.addBuildOption(?[]const u8, "optional_string", null);	3096	exe.addBuildOption(?[]const u8, "optional_string", null);
3097	exe.addBuildOption(std.SemanticVersion, "semantic_version", try std.SemanticVersion.parse("0.1.2-foo+bar"));	3097	exe.addBuildOption(std.SemanticVersion, "semantic_version", try std.SemanticVersion.parse("0.1.2-foo+bar"));
3098		3098
3099	std.testing.expectEqualStrings(	3099	try std.testing.expectEqualStrings(
3100	\\pub const option1: usize = 1;	3100	\\pub const option1: usize = 1;
3101	\\pub const option2: ?usize = null;	3101	\\pub const option2: ?usize = null;
3102	\\pub const string: []const u8 = "zigisthebest";	3102	\\pub const string: []const u8 = "zigisthebest";
...	@@ -3140,10 +3140,10 @@ test "LibExeObjStep.addPackage" {	...	@@ -3140,10 +3140,10 @@ test "LibExeObjStep.addPackage" {
3140	var exe = builder.addExecutable("not_an_executable", "/not/an/executable.zig");	3140	var exe = builder.addExecutable("not_an_executable", "/not/an/executable.zig");
3141	exe.addPackage(pkg_top);	3141	exe.addPackage(pkg_top);
3142		3142
3143	std.testing.expectEqual(@as(usize, 1), exe.packages.items.len);	3143	try std.testing.expectEqual(@as(usize, 1), exe.packages.items.len);
3144		3144
3145	const dupe = exe.packages.items[0];	3145	const dupe = exe.packages.items[0];
3146	std.testing.expectEqualStrings(pkg_top.name, dupe.name);	3146	try std.testing.expectEqualStrings(pkg_top.name, dupe.name);
3147	}	3147	}
3148		3148
3149	test {	3149	test {

...	@@ -95,7 +95,7 @@ test "ComptimeStringMap list literal of list literals" {	...	@@ -95,7 +95,7 @@ test "ComptimeStringMap list literal of list literals" {
95	.{ "samelen", .E },	95	.{ "samelen", .E },
96	});	96	});
97		97
98	testMap(map);	98	try testMap(map);
99	}	99	}
100		100
101	test "ComptimeStringMap array of structs" {	101	test "ComptimeStringMap array of structs" {
...	@@ -111,7 +111,7 @@ test "ComptimeStringMap array of structs" {	...	@@ -111,7 +111,7 @@ test "ComptimeStringMap array of structs" {
111	.{ .@"0" = "samelen", .@"1" = .E },	111	.{ .@"0" = "samelen", .@"1" = .E },
112	});	112	});
113		113
114	testMap(map);	114	try testMap(map);
115	}	115	}
116		116
117	test "ComptimeStringMap slice of structs" {	117	test "ComptimeStringMap slice of structs" {
...	@@ -128,18 +128,18 @@ test "ComptimeStringMap slice of structs" {	...	@@ -128,18 +128,18 @@ test "ComptimeStringMap slice of structs" {
128	};	128	};
129	const map = ComptimeStringMap(TestEnum, slice);	129	const map = ComptimeStringMap(TestEnum, slice);
130		130
131	testMap(map);	131	try testMap(map);
132	}	132	}
133		133
134	fn testMap(comptime map: anytype) void {	134	fn testMap(comptime map: anytype) !void {
135	std.testing.expectEqual(TestEnum.A, map.get("have").?);	135	try std.testing.expectEqual(TestEnum.A, map.get("have").?);
136	std.testing.expectEqual(TestEnum.B, map.get("nothing").?);	136	try std.testing.expectEqual(TestEnum.B, map.get("nothing").?);
137	std.testing.expect(null == map.get("missing"));	137	try std.testing.expect(null == map.get("missing"));
138	std.testing.expectEqual(TestEnum.D, map.get("these").?);	138	try std.testing.expectEqual(TestEnum.D, map.get("these").?);
139	std.testing.expectEqual(TestEnum.E, map.get("samelen").?);	139	try std.testing.expectEqual(TestEnum.E, map.get("samelen").?);
140		140
141	std.testing.expect(!map.has("missing"));	141	try std.testing.expect(!map.has("missing"));
142	std.testing.expect(map.has("these"));	142	try std.testing.expect(map.has("these"));
143	}	143	}
144		144
145	test "ComptimeStringMap void value type, slice of structs" {	145	test "ComptimeStringMap void value type, slice of structs" {
...	@@ -155,7 +155,7 @@ test "ComptimeStringMap void value type, slice of structs" {	...	@@ -155,7 +155,7 @@ test "ComptimeStringMap void value type, slice of structs" {
155	};	155	};
156	const map = ComptimeStringMap(void, slice);	156	const map = ComptimeStringMap(void, slice);
157		157
158	testSet(map);	158	try testSet(map);
159	}	159	}
160		160
161	test "ComptimeStringMap void value type, list literal of list literals" {	161	test "ComptimeStringMap void value type, list literal of list literals" {
...	@@ -167,16 +167,16 @@ test "ComptimeStringMap void value type, list literal of list literals" {	...	@@ -167,16 +167,16 @@ test "ComptimeStringMap void value type, list literal of list literals" {
167	.{"samelen"},	167	.{"samelen"},
168	});	168	});
169		169
170	testSet(map);	170	try testSet(map);
171	}	171	}
172		172
173	fn testSet(comptime map: anytype) void {	173	fn testSet(comptime map: anytype) !void {
174	std.testing.expectEqual({}, map.get("have").?);	174	try std.testing.expectEqual({}, map.get("have").?);
175	std.testing.expectEqual({}, map.get("nothing").?);	175	try std.testing.expectEqual({}, map.get("nothing").?);
176	std.testing.expect(null == map.get("missing"));	176	try std.testing.expect(null == map.get("missing"));
177	std.testing.expectEqual({}, map.get("these").?);	177	try std.testing.expectEqual({}, map.get("these").?);
178	std.testing.expectEqual({}, map.get("samelen").?);	178	try std.testing.expectEqual({}, map.get("samelen").?);
179		179
180	std.testing.expect(!map.has("missing"));	180	try std.testing.expect(!map.has("missing"));
181	std.testing.expect(map.has("these"));	181	try std.testing.expect(map.has("these"));
182	}	182	}

...	@@ -120,13 +120,13 @@ test "curve25519" {	...	@@ -120,13 +120,13 @@ test "curve25519" {
120	const p = try Curve25519.basePoint.clampedMul(s);	120	const p = try Curve25519.basePoint.clampedMul(s);
121	try p.rejectIdentity();	121	try p.rejectIdentity();
122	var buf: [128]u8 = undefined;	122	var buf: [128]u8 = undefined;
123	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E6F2A4D1C28EE5C7AD0329268255A468AD407D2672824C0C0EB30EA6EF450145");	123	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E6F2A4D1C28EE5C7AD0329268255A468AD407D2672824C0C0EB30EA6EF450145");
124	const q = try p.clampedMul(s);	124	const q = try p.clampedMul(s);
125	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "3614E119FFE55EC55B87D6B19971A9F4CBC78EFE80BEC55B96392BABCC712537");	125	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "3614E119FFE55EC55B87D6B19971A9F4CBC78EFE80BEC55B96392BABCC712537");
126		126
127	try Curve25519.rejectNonCanonical(s);	127	try Curve25519.rejectNonCanonical(s);
128	s[31] \|= 0x80;	128	s[31] \|= 0x80;
129	std.testing.expectError(error.NonCanonical, Curve25519.rejectNonCanonical(s));	129	try std.testing.expectError(error.NonCanonical, Curve25519.rejectNonCanonical(s));
130	}	130	}
131		131
132	test "curve25519 small order check" {	132	test "curve25519 small order check" {
...	@@ -155,13 +155,13 @@ test "curve25519 small order check" {	...	@@ -155,13 +155,13 @@ test "curve25519 small order check" {
155	},	155	},
156	};	156	};
157	for (small_order_ss) \|small_order_s\| {	157	for (small_order_ss) \|small_order_s\| {
158	std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(small_order_s).mul(s));	158	try std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(small_order_s).mul(s));
159	var extra = small_order_s;	159	var extra = small_order_s;
160	extra[31] ^= 0x80;	160	extra[31] ^= 0x80;
161	std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(extra).mul(s));	161	try std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(extra).mul(s));
162	var valid = small_order_s;	162	var valid = small_order_s;
163	valid[31] = 0x40;	163	valid[31] = 0x40;
164	s[0] = 0;	164	s[0] = 0;
165	std.testing.expectError(error.IdentityElement, Curve25519.fromBytes(valid).mul(s));	165	try std.testing.expectError(error.IdentityElement, Curve25519.fromBytes(valid).mul(s));
166	}	166	}
167	}	167	}

...	@@ -219,8 +219,8 @@ test "ed25519 key pair creation" {	...	@@ -219,8 +219,8 @@ test "ed25519 key pair creation" {
219	_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");	219	_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
220	const key_pair = try Ed25519.KeyPair.create(seed);	220	const key_pair = try Ed25519.KeyPair.create(seed);
221	var buf: [256]u8 = undefined;	221	var buf: [256]u8 = undefined;
222	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key)}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");	222	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key)}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
223	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key)}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");	223	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key)}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
224	}	224	}
225		225
226	test "ed25519 signature" {	226	test "ed25519 signature" {
...	@@ -230,9 +230,9 @@ test "ed25519 signature" {	...	@@ -230,9 +230,9 @@ test "ed25519 signature" {
230		230
231	const sig = try Ed25519.sign("test", key_pair, null);	231	const sig = try Ed25519.sign("test", key_pair, null);
232	var buf: [128]u8 = undefined;	232	var buf: [128]u8 = undefined;
233	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig)}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808");	233	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig)}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808");
234	try Ed25519.verify(sig, "test", key_pair.public_key);	234	try Ed25519.verify(sig, "test", key_pair.public_key);
235	std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verify(sig, "TEST", key_pair.public_key));	235	try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verify(sig, "TEST", key_pair.public_key));
236	}	236	}
237		237
238	test "ed25519 batch verification" {	238	test "ed25519 batch verification" {
...	@@ -260,7 +260,7 @@ test "ed25519 batch verification" {	...	@@ -260,7 +260,7 @@ test "ed25519 batch verification" {
260	try Ed25519.verifyBatch(2, signature_batch);	260	try Ed25519.verifyBatch(2, signature_batch);
261		261
262	signature_batch[1].sig = sig1;	262	signature_batch[1].sig = sig1;
263	std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch));	263	try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch));
264	}	264	}
265	}	265	}
266		266
...	@@ -354,7 +354,7 @@ test "ed25519 test vectors" {	...	@@ -354,7 +354,7 @@ test "ed25519 test vectors" {
354	var sig: [64]u8 = undefined;	354	var sig: [64]u8 = undefined;
355	_ = try fmt.hexToBytes(&sig, entry.sig_hex);	355	_ = try fmt.hexToBytes(&sig, entry.sig_hex);
356	if (entry.expected) \|error_type\| {	356	if (entry.expected) \|error_type\| {
357	std.testing.expectError(error_type, Ed25519.verify(sig, &msg, public_key));	357	try std.testing.expectError(error_type, Ed25519.verify(sig, &msg, public_key));
358	} else {	358	} else {
359	try Ed25519.verify(sig, &msg, public_key);	359	try Ed25519.verify(sig, &msg, public_key);
360	}	360	}

...	@@ -92,7 +92,7 @@ test "x25519 public key calculation from secret key" {	...	@@ -92,7 +92,7 @@ test "x25519 public key calculation from secret key" {
92	_ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");	92	_ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
93	_ = try fmt.hexToBytes(pk_expected[0..], "f1814f0e8ff1043d8a44d25babff3cedcae6c22c3edaa48f857ae70de2baae50");	93	_ = try fmt.hexToBytes(pk_expected[0..], "f1814f0e8ff1043d8a44d25babff3cedcae6c22c3edaa48f857ae70de2baae50");
94	const pk_calculated = try X25519.recoverPublicKey(sk);	94	const pk_calculated = try X25519.recoverPublicKey(sk);
95	std.testing.expectEqual(pk_calculated, pk_expected);	95	try std.testing.expectEqual(pk_calculated, pk_expected);
96	}	96	}
97		97
98	test "x25519 rfc7748 vector1" {	98	test "x25519 rfc7748 vector1" {
...	@@ -102,7 +102,7 @@ test "x25519 rfc7748 vector1" {	...	@@ -102,7 +102,7 @@ test "x25519 rfc7748 vector1" {
102	const expected_output = [32]u8{ 0xc3, 0xda, 0x55, 0x37, 0x9d, 0xe9, 0xc6, 0x90, 0x8e, 0x94, 0xea, 0x4d, 0xf2, 0x8d, 0x08, 0x4f, 0x32, 0xec, 0xcf, 0x03, 0x49, 0x1c, 0x71, 0xf7, 0x54, 0xb4, 0x07, 0x55, 0x77, 0xa2, 0x85, 0x52 };	102	const expected_output = [32]u8{ 0xc3, 0xda, 0x55, 0x37, 0x9d, 0xe9, 0xc6, 0x90, 0x8e, 0x94, 0xea, 0x4d, 0xf2, 0x8d, 0x08, 0x4f, 0x32, 0xec, 0xcf, 0x03, 0x49, 0x1c, 0x71, 0xf7, 0x54, 0xb4, 0x07, 0x55, 0x77, 0xa2, 0x85, 0x52 };
103		103
104	const output = try X25519.scalarmult(secret_key, public_key);	104	const output = try X25519.scalarmult(secret_key, public_key);
105	std.testing.expectEqual(output, expected_output);	105	try std.testing.expectEqual(output, expected_output);
106	}	106	}
107		107
108	test "x25519 rfc7748 vector2" {	108	test "x25519 rfc7748 vector2" {
...	@@ -112,7 +112,7 @@ test "x25519 rfc7748 vector2" {	...	@@ -112,7 +112,7 @@ test "x25519 rfc7748 vector2" {
112	const expected_output = [32]u8{ 0x95, 0xcb, 0xde, 0x94, 0x76, 0xe8, 0x90, 0x7d, 0x7a, 0xad, 0xe4, 0x5c, 0xb4, 0xb8, 0x73, 0xf8, 0x8b, 0x59, 0x5a, 0x68, 0x79, 0x9f, 0xa1, 0x52, 0xe6, 0xf8, 0xf7, 0x64, 0x7a, 0xac, 0x79, 0x57 };	112	const expected_output = [32]u8{ 0x95, 0xcb, 0xde, 0x94, 0x76, 0xe8, 0x90, 0x7d, 0x7a, 0xad, 0xe4, 0x5c, 0xb4, 0xb8, 0x73, 0xf8, 0x8b, 0x59, 0x5a, 0x68, 0x79, 0x9f, 0xa1, 0x52, 0xe6, 0xf8, 0xf7, 0x64, 0x7a, 0xac, 0x79, 0x57 };
113		113
114	const output = try X25519.scalarmult(secret_key, public_key);	114	const output = try X25519.scalarmult(secret_key, public_key);
115	std.testing.expectEqual(output, expected_output);	115	try std.testing.expectEqual(output, expected_output);
116	}	116	}
117		117
118	test "x25519 rfc7748 one iteration" {	118	test "x25519 rfc7748 one iteration" {
...	@@ -129,7 +129,7 @@ test "x25519 rfc7748 one iteration" {	...	@@ -129,7 +129,7 @@ test "x25519 rfc7748 one iteration" {
129	mem.copy(u8, k[0..], output[0..]);	129	mem.copy(u8, k[0..], output[0..]);
130	}	130	}
131		131
132	std.testing.expectEqual(k, expected_output);	132	try std.testing.expectEqual(k, expected_output);
133	}	133	}
134		134
135	test "x25519 rfc7748 1,000 iterations" {	135	test "x25519 rfc7748 1,000 iterations" {
...	@@ -151,7 +151,7 @@ test "x25519 rfc7748 1,000 iterations" {	...	@@ -151,7 +151,7 @@ test "x25519 rfc7748 1,000 iterations" {
151	mem.copy(u8, k[0..], output[0..]);	151	mem.copy(u8, k[0..], output[0..]);
152	}	152	}
153		153
154	std.testing.expectEqual(k, expected_output);	154	try std.testing.expectEqual(k, expected_output);
155	}	155	}
156		156
157	test "x25519 rfc7748 1,000,000 iterations" {	157	test "x25519 rfc7748 1,000,000 iterations" {

...	@@ -491,7 +491,7 @@ test "edwards25519 packing/unpacking" {	...	@@ -491,7 +491,7 @@ test "edwards25519 packing/unpacking" {
491	var b = Edwards25519.basePoint;	491	var b = Edwards25519.basePoint;
492	const pk = try b.mul(s);	492	const pk = try b.mul(s);
493	var buf: [128]u8 = undefined;	493	var buf: [128]u8 = undefined;
494	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&pk.toBytes())}), "074BC7E0FCBD587FDBC0969444245FADC562809C8F6E97E949AF62484B5B81A6");	494	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&pk.toBytes())}), "074BC7E0FCBD587FDBC0969444245FADC562809C8F6E97E949AF62484B5B81A6");
495		495
496	const small_order_ss: [7][32]u8 = .{	496	const small_order_ss: [7][32]u8 = .{
497	.{	497	.{
...	@@ -518,7 +518,7 @@ test "edwards25519 packing/unpacking" {	...	@@ -518,7 +518,7 @@ test "edwards25519 packing/unpacking" {
518	};	518	};
519	for (small_order_ss) \|small_order_s\| {	519	for (small_order_ss) \|small_order_s\| {
520	const small_p = try Edwards25519.fromBytes(small_order_s);	520	const small_p = try Edwards25519.fromBytes(small_order_s);
521	std.testing.expectError(error.WeakPublicKey, small_p.mul(s));	521	try std.testing.expectError(error.WeakPublicKey, small_p.mul(s));
522	}	522	}
523	}	523	}
524		524
...	@@ -531,26 +531,26 @@ test "edwards25519 point addition/substraction" {	...	@@ -531,26 +531,26 @@ test "edwards25519 point addition/substraction" {
531	const q = try Edwards25519.basePoint.clampedMul(s2);	531	const q = try Edwards25519.basePoint.clampedMul(s2);
532	const r = p.add(q).add(q).sub(q).sub(q);	532	const r = p.add(q).add(q).sub(q).sub(q);
533	try r.rejectIdentity();	533	try r.rejectIdentity();
534	std.testing.expectError(error.IdentityElement, r.sub(p).rejectIdentity());	534	try std.testing.expectError(error.IdentityElement, r.sub(p).rejectIdentity());
535	std.testing.expectError(error.IdentityElement, p.sub(p).rejectIdentity());	535	try std.testing.expectError(error.IdentityElement, p.sub(p).rejectIdentity());
536	std.testing.expectError(error.IdentityElement, p.sub(q).add(q).sub(p).rejectIdentity());	536	try std.testing.expectError(error.IdentityElement, p.sub(q).add(q).sub(p).rejectIdentity());
537	}	537	}
538		538
539	test "edwards25519 uniform-to-point" {	539	test "edwards25519 uniform-to-point" {
540	var r = [32]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };	540	var r = [32]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
541	var p = Edwards25519.fromUniform(r);	541	var p = Edwards25519.fromUniform(r);
542	htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]);	542	try htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]);
543		543
544	r[31] = 0xff;	544	r[31] = 0xff;
545	p = Edwards25519.fromUniform(r);	545	p = Edwards25519.fromUniform(r);
546	htest.assertEqual("f70718e68ef42d90ca1d936bb2d7e159be6c01d8095d39bd70487c82fe5c973a", p.toBytes()[0..]);	546	try htest.assertEqual("f70718e68ef42d90ca1d936bb2d7e159be6c01d8095d39bd70487c82fe5c973a", p.toBytes()[0..]);
547	}	547	}
548		548
549	// Test vectors from draft-irtf-cfrg-hash-to-curve-10	549	// Test vectors from draft-irtf-cfrg-hash-to-curve-10
550	test "edwards25519 hash-to-curve operation" {	550	test "edwards25519 hash-to-curve operation" {
551	var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc");	551	var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc");
552	htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895831a", p.toBytes()[0..]);	552	try htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895831a", p.toBytes()[0..]);
553		553
554	p = Edwards25519.fromString(false, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_NU_", "abc");	554	p = Edwards25519.fromString(false, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_NU_", "abc");
555	htest.assertEqual("42fa27c8f5a1ae0aa38bb59d5938e5145622ba5dedd11d11736fa2f9502d73e7", p.toBytes()[0..]);	555	try htest.assertEqual("42fa27c8f5a1ae0aa38bb59d5938e5145622ba5dedd11d11736fa2f9502d73e7", p.toBytes()[0..]);
556	}	556	}

...	@@ -175,21 +175,21 @@ pub const Ristretto255 = struct {	...	@@ -175,21 +175,21 @@ pub const Ristretto255 = struct {
175	test "ristretto255" {	175	test "ristretto255" {
176	const p = Ristretto255.basePoint;	176	const p = Ristretto255.basePoint;
177	var buf: [256]u8 = undefined;	177	var buf: [256]u8 = undefined;
178	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76");	178	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76");
179		179
180	var r: [Ristretto255.encoded_length]u8 = undefined;	180	var r: [Ristretto255.encoded_length]u8 = undefined;
181	_ = try fmt.hexToBytes(r[0..], "6a493210f7499cd17fecb510ae0cea23a110e8d5b901f8acadd3095c73a3b919");	181	_ = try fmt.hexToBytes(r[0..], "6a493210f7499cd17fecb510ae0cea23a110e8d5b901f8acadd3095c73a3b919");
182	var q = try Ristretto255.fromBytes(r);	182	var q = try Ristretto255.fromBytes(r);
183	q = q.dbl().add(p);	183	q = q.dbl().add(p);
184	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "E882B131016B52C1D3337080187CF768423EFCCBB517BB495AB812C4160FF44E");	184	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "E882B131016B52C1D3337080187CF768423EFCCBB517BB495AB812C4160FF44E");
185		185
186	const s = [_]u8{15} ++ [_]u8{0} ** 31;	186	const s = [_]u8{15} ++ [_]u8{0} ** 31;
187	const w = try p.mul(s);	187	const w = try p.mul(s);
188	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&w.toBytes())}), "E0C418F7C8D9C4CDD7395B93EA124F3AD99021BB681DFC3302A9D99A2E53E64E");	188	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&w.toBytes())}), "E0C418F7C8D9C4CDD7395B93EA124F3AD99021BB681DFC3302A9D99A2E53E64E");
189		189
190	std.testing.expect(p.dbl().dbl().dbl().dbl().equivalent(w.add(p)));	190	try std.testing.expect(p.dbl().dbl().dbl().dbl().equivalent(w.add(p)));
191		191
192	const h = [_]u8{69} 32 ++ [_]u8{42} 32;	192	const h = [_]u8{69} 32 ++ [_]u8{42} 32;
193	const ph = Ristretto255.fromUniform(h);	193	const ph = Ristretto255.fromUniform(h);
194	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&ph.toBytes())}), "DCCA54E037A4311EFBEEF413ACD21D35276518970B7A61DC88F8587B493D5E19");	194	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&ph.toBytes())}), "DCCA54E037A4311EFBEEF413ACD21D35276518970B7A61DC88F8587B493D5E19");
195	}	195	}

...	@@ -773,15 +773,15 @@ test "scalar25519" {	...	@@ -773,15 +773,15 @@ test "scalar25519" {
773	var y = x.toBytes();	773	var y = x.toBytes();
774	try rejectNonCanonical(y);	774	try rejectNonCanonical(y);
775	var buf: [128]u8 = undefined;	775	var buf: [128]u8 = undefined;
776	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&y)}), "1E979B917937F3DE71D18077F961F6CEFF01030405060708010203040506070F");	776	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&y)}), "1E979B917937F3DE71D18077F961F6CEFF01030405060708010203040506070F");
777		777
778	const reduced = reduce(field_size);	778	const reduced = reduce(field_size);
779	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&reduced)}), "0000000000000000000000000000000000000000000000000000000000000000");	779	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&reduced)}), "0000000000000000000000000000000000000000000000000000000000000000");
780	}	780	}
781		781
782	test "non-canonical scalar25519" {	782	test "non-canonical scalar25519" {
783	const too_targe: [32]u8 = .{ 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 };	783	const too_targe: [32]u8 = .{ 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 };
784	std.testing.expectError(error.NonCanonical, rejectNonCanonical(too_targe));	784	try std.testing.expectError(error.NonCanonical, rejectNonCanonical(too_targe));
785	}	785	}
786		786
787	test "mulAdd overflow check" {	787	test "mulAdd overflow check" {
...	@@ -790,5 +790,5 @@ test "mulAdd overflow check" {	...	@@ -790,5 +790,5 @@ test "mulAdd overflow check" {
790	const c: [32]u8 = [_]u8{0xff} ** 32;	790	const c: [32]u8 = [_]u8{0xff} ** 32;
791	const x = mulAdd(a, b, c);	791	const x = mulAdd(a, b, c);
792	var buf: [128]u8 = undefined;	792	var buf: [128]u8 = undefined;
793	std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&x)}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903");	793	try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&x)}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903");
794	}	794	}

...	@@ -352,16 +352,16 @@ test "Aegis128L test vector 1" {	...	@@ -352,16 +352,16 @@ test "Aegis128L test vector 1" {
352		352
353	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);	353	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
354	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);	354	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
355	testing.expectEqualSlices(u8, &m, &m2);	355	try testing.expectEqualSlices(u8, &m, &m2);
356		356
357	htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c);	357	try htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c);
358	htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag);	358	try htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag);
359		359
360	c[0] +%= 1;	360	c[0] +%= 1;
361	testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));	361	try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));
362	c[0] -%= 1;	362	c[0] -%= 1;
363	tag[0] +%= 1;	363	tag[0] +%= 1;
364	testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));	364	try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key));
365	}	365	}
366		366
367	test "Aegis128L test vector 2" {	367	test "Aegis128L test vector 2" {
...	@@ -375,10 +375,10 @@ test "Aegis128L test vector 2" {	...	@@ -375,10 +375,10 @@ test "Aegis128L test vector 2" {
375		375
376	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);	376	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
377	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);	377	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
378	testing.expectEqualSlices(u8, &m, &m2);	378	try testing.expectEqualSlices(u8, &m, &m2);
379		379
380	htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c);	380	try htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c);
381	htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag);	381	try htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag);
382	}	382	}
383		383
384	test "Aegis128L test vector 3" {	384	test "Aegis128L test vector 3" {
...	@@ -392,9 +392,9 @@ test "Aegis128L test vector 3" {	...	@@ -392,9 +392,9 @@ test "Aegis128L test vector 3" {
392		392
393	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);	393	Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key);
394	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);	394	try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key);
395	testing.expectEqualSlices(u8, &m, &m2);	395	try testing.expectEqualSlices(u8, &m, &m2);
396		396
397	htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag);	397	try htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag);
398	}	398	}
399		399
400	test "Aegis256 test vector 1" {	400	test "Aegis256 test vector 1" {
...	@@ -408,16 +408,16 @@ test "Aegis256 test vector 1" {	...	@@ -408,16 +408,16 @@ test "Aegis256 test vector 1" {
408		408
409	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);	409	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
410	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);	410	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
411	testing.expectEqualSlices(u8, &m, &m2);	411	try testing.expectEqualSlices(u8, &m, &m2);
412		412
413	htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c);	413	try htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c);
414	htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag);	414	try htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag);
415		415
416	c[0] +%= 1;	416	c[0] +%= 1;
417	testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));	417	try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));
418	c[0] -%= 1;	418	c[0] -%= 1;
419	tag[0] +%= 1;	419	tag[0] +%= 1;
420	testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));	420	try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key));
421	}	421	}
422		422
423	test "Aegis256 test vector 2" {	423	test "Aegis256 test vector 2" {
...	@@ -431,10 +431,10 @@ test "Aegis256 test vector 2" {	...	@@ -431,10 +431,10 @@ test "Aegis256 test vector 2" {
431		431
432	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);	432	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
433	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);	433	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
434	testing.expectEqualSlices(u8, &m, &m2);	434	try testing.expectEqualSlices(u8, &m, &m2);
435		435
436	htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c);	436	try htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c);
437	htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag);	437	try htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag);
438	}	438	}
439		439
440	test "Aegis256 test vector 3" {	440	test "Aegis256 test vector 3" {
...	@@ -448,7 +448,7 @@ test "Aegis256 test vector 3" {	...	@@ -448,7 +448,7 @@ test "Aegis256 test vector 3" {
448		448
449	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);	449	Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key);
450	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);	450	try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key);
451	testing.expectEqualSlices(u8, &m, &m2);	451	try testing.expectEqualSlices(u8, &m, &m2);
452		452
453	htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag);	453	try htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag);
454	}	454	}

...	@@ -48,7 +48,7 @@ test "ctr" {	...	@@ -48,7 +48,7 @@ test "ctr" {
48	var out: [exp_out.len]u8 = undefined;	48	var out: [exp_out.len]u8 = undefined;
49	var ctx = Aes128.initEnc(key);	49	var ctx = Aes128.initEnc(key);
50	ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, builtin.Endian.Big);	50	ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, builtin.Endian.Big);
51	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	51	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
52	}	52	}
53		53
54	test "encrypt" {	54	test "encrypt" {
...	@@ -61,7 +61,7 @@ test "encrypt" {	...	@@ -61,7 +61,7 @@ test "encrypt" {
61	var out: [exp_out.len]u8 = undefined;	61	var out: [exp_out.len]u8 = undefined;
62	var ctx = Aes128.initEnc(key);	62	var ctx = Aes128.initEnc(key);
63	ctx.encrypt(out[0..], in[0..]);	63	ctx.encrypt(out[0..], in[0..]);
64	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	64	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
65	}	65	}
66		66
67	// Appendix C.3	67	// Appendix C.3
...	@@ -76,7 +76,7 @@ test "encrypt" {	...	@@ -76,7 +76,7 @@ test "encrypt" {
76	var out: [exp_out.len]u8 = undefined;	76	var out: [exp_out.len]u8 = undefined;
77	var ctx = Aes256.initEnc(key);	77	var ctx = Aes256.initEnc(key);
78	ctx.encrypt(out[0..], in[0..]);	78	ctx.encrypt(out[0..], in[0..]);
79	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	79	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
80	}	80	}
81	}	81	}
82		82
...	@@ -90,7 +90,7 @@ test "decrypt" {	...	@@ -90,7 +90,7 @@ test "decrypt" {
90	var out: [exp_out.len]u8 = undefined;	90	var out: [exp_out.len]u8 = undefined;
91	var ctx = Aes128.initDec(key);	91	var ctx = Aes128.initDec(key);
92	ctx.decrypt(out[0..], in[0..]);	92	ctx.decrypt(out[0..], in[0..]);
93	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	93	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
94	}	94	}
95		95
96	// Appendix C.3	96	// Appendix C.3
...	@@ -105,7 +105,7 @@ test "decrypt" {	...	@@ -105,7 +105,7 @@ test "decrypt" {
105	var out: [exp_out.len]u8 = undefined;	105	var out: [exp_out.len]u8 = undefined;
106	var ctx = Aes256.initDec(key);	106	var ctx = Aes256.initDec(key);
107	ctx.decrypt(out[0..], in[0..]);	107	ctx.decrypt(out[0..], in[0..]);
108	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	108	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
109	}	109	}
110	}	110	}
111		111
...	@@ -123,11 +123,11 @@ test "expand 128-bit key" {	...	@@ -123,11 +123,11 @@ test "expand 128-bit key" {
123		123
124	for (enc.key_schedule.round_keys) \|round_key, i\| {	124	for (enc.key_schedule.round_keys) \|round_key, i\| {
125	_ = try std.fmt.hexToBytes(&exp, exp_enc[i]);	125	_ = try std.fmt.hexToBytes(&exp, exp_enc[i]);
126	testing.expectEqualSlices(u8, &exp, &round_key.toBytes());	126	try testing.expectEqualSlices(u8, &exp, &round_key.toBytes());
127	}	127	}
128	for (enc.key_schedule.round_keys) \|round_key, i\| {	128	for (enc.key_schedule.round_keys) \|round_key, i\| {
129	_ = try std.fmt.hexToBytes(&exp, exp_dec[i]);	129	_ = try std.fmt.hexToBytes(&exp, exp_dec[i]);
130	testing.expectEqualSlices(u8, &exp, &round_key.toBytes());	130	try testing.expectEqualSlices(u8, &exp, &round_key.toBytes());
131	}	131	}
132	}	132	}
133		133
...	@@ -145,10 +145,10 @@ test "expand 256-bit key" {	...	@@ -145,10 +145,10 @@ test "expand 256-bit key" {
145		145
146	for (enc.key_schedule.round_keys) \|round_key, i\| {	146	for (enc.key_schedule.round_keys) \|round_key, i\| {
147	_ = try std.fmt.hexToBytes(&exp, exp_enc[i]);	147	_ = try std.fmt.hexToBytes(&exp, exp_enc[i]);
148	testing.expectEqualSlices(u8, &exp, &round_key.toBytes());	148	try testing.expectEqualSlices(u8, &exp, &round_key.toBytes());
149	}	149	}
150	for (dec.key_schedule.round_keys) \|round_key, i\| {	150	for (dec.key_schedule.round_keys) \|round_key, i\| {
151	_ = try std.fmt.hexToBytes(&exp, exp_dec[i]);	151	_ = try std.fmt.hexToBytes(&exp, exp_dec[i]);
152	testing.expectEqualSlices(u8, &exp, &round_key.toBytes());	152	try testing.expectEqualSlices(u8, &exp, &round_key.toBytes());
153	}	153	}
154	}	154	}

...	@@ -118,7 +118,7 @@ test "Aes256Gcm - Empty message and no associated data" {	...	@@ -118,7 +118,7 @@ test "Aes256Gcm - Empty message and no associated data" {
118	var tag: [Aes256Gcm.tag_length]u8 = undefined;	118	var tag: [Aes256Gcm.tag_length]u8 = undefined;
119		119
120	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);	120	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);
121	htest.assertEqual("6b6ff610a16fa4cd59f1fb7903154e92", &tag);	121	try htest.assertEqual("6b6ff610a16fa4cd59f1fb7903154e92", &tag);
122	}	122	}
123		123
124	test "Aes256Gcm - Associated data only" {	124	test "Aes256Gcm - Associated data only" {
...	@@ -130,7 +130,7 @@ test "Aes256Gcm - Associated data only" {	...	@@ -130,7 +130,7 @@ test "Aes256Gcm - Associated data only" {
130	var tag: [Aes256Gcm.tag_length]u8 = undefined;	130	var tag: [Aes256Gcm.tag_length]u8 = undefined;
131		131
132	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);	132	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);
133	htest.assertEqual("262ed164c2dfb26e080a9d108dd9dd4c", &tag);	133	try htest.assertEqual("262ed164c2dfb26e080a9d108dd9dd4c", &tag);
134	}	134	}
135		135
136	test "Aes256Gcm - Message only" {	136	test "Aes256Gcm - Message only" {
...	@@ -144,10 +144,10 @@ test "Aes256Gcm - Message only" {	...	@@ -144,10 +144,10 @@ test "Aes256Gcm - Message only" {
144		144
145	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);	145	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);
146	try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key);	146	try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key);
147	testing.expectEqualSlices(u8, m[0..], m2[0..]);	147	try testing.expectEqualSlices(u8, m[0..], m2[0..]);
148		148
149	htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01d539472f7c", &c);	149	try htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01d539472f7c", &c);
150	htest.assertEqual("07cd7fc9103e2f9e9bf2dfaa319caff4", &tag);	150	try htest.assertEqual("07cd7fc9103e2f9e9bf2dfaa319caff4", &tag);
151	}	151	}
152		152
153	test "Aes256Gcm - Message and associated data" {	153	test "Aes256Gcm - Message and associated data" {
...	@@ -161,8 +161,8 @@ test "Aes256Gcm - Message and associated data" {	...	@@ -161,8 +161,8 @@ test "Aes256Gcm - Message and associated data" {
161		161
162	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);	162	Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key);
163	try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key);	163	try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key);
164	testing.expectEqualSlices(u8, m[0..], m2[0..]);	164	try testing.expectEqualSlices(u8, m[0..], m2[0..]);
165		165
166	htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01", &c);	166	try htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01", &c);
167	htest.assertEqual("64accec679d444e2373bd9f6796c0d2c", &tag);	167	try htest.assertEqual("64accec679d444e2373bd9f6796c0d2c", &tag);
168	}	168	}

...	@@ -641,7 +641,7 @@ const reference_test = ReferenceTest{	...	@@ -641,7 +641,7 @@ const reference_test = ReferenceTest{
641	},	641	},
642	};	642	};
643		643
644	fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void {	644	fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void {
645	// Save initial state	645	// Save initial state
646	const initial_state = hasher.*;	646	const initial_state = hasher.*;
647		647
...	@@ -664,7 +664,7 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void {	...	@@ -664,7 +664,7 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void {
664	// Compare to expected value	664	// Compare to expected value
665	var expected_bytes: [expected_hex.len / 2]u8 = undefined;	665	var expected_bytes: [expected_hex.len / 2]u8 = undefined;
666	_ = fmt.hexToBytes(expected_bytes[0..], expected_hex[0..]) catch unreachable;	666	_ = fmt.hexToBytes(expected_bytes[0..], expected_hex[0..]) catch unreachable;
667	testing.expectEqual(actual_bytes, expected_bytes);	667	try testing.expectEqual(actual_bytes, expected_bytes);
668		668
669	// Restore initial state	669	// Restore initial state
670	hasher.* = initial_state;	670	hasher.* = initial_state;
...	@@ -676,8 +676,8 @@ test "BLAKE3 reference test cases" {	...	@@ -676,8 +676,8 @@ test "BLAKE3 reference test cases" {
676	var derive_key = &Blake3.initKdf(reference_test.context_string, .{});	676	var derive_key = &Blake3.initKdf(reference_test.context_string, .{});
677		677
678	for (reference_test.cases) \|t\| {	678	for (reference_test.cases) \|t\| {
679	testBlake3(hash, t.input_len, t.hash.*);	679	try testBlake3(hash, t.input_len, t.hash.*);
680	testBlake3(keyed_hash, t.input_len, t.keyed_hash.*);	680	try testBlake3(keyed_hash, t.input_len, t.keyed_hash.*);
681	testBlake3(derive_key, t.input_len, t.derive_key.*);	681	try testBlake3(derive_key, t.input_len, t.derive_key.*);
682	}	682	}
683	}	683	}

...	@@ -604,9 +604,9 @@ test "chacha20 AEAD API" {	...	@@ -604,9 +604,9 @@ test "chacha20 AEAD API" {
604		604
605	aead.encrypt(c[0..], tag[0..], m, ad, nonce, key);	605	aead.encrypt(c[0..], tag[0..], m, ad, nonce, key);
606	try aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key);	606	try aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key);
607	testing.expectEqualSlices(u8, out[0..], m);	607	try testing.expectEqualSlices(u8, out[0..], m);
608	c[0] += 1;	608	c[0] += 1;
609	testing.expectError(error.AuthenticationFailed, aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key));	609	try testing.expectError(error.AuthenticationFailed, aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key));
610	}	610	}
611	}	611	}
612		612
...	@@ -644,11 +644,11 @@ test "crypto.chacha20 test vector sunscreen" {	...	@@ -644,11 +644,11 @@ test "crypto.chacha20 test vector sunscreen" {
644	};	644	};
645		645
646	ChaCha20IETF.xor(result[0..], m[0..], 1, key, nonce);	646	ChaCha20IETF.xor(result[0..], m[0..], 1, key, nonce);
647	testing.expectEqualSlices(u8, &expected_result, &result);	647	try testing.expectEqualSlices(u8, &expected_result, &result);
648		648
649	var m2: [114]u8 = undefined;	649	var m2: [114]u8 = undefined;
650	ChaCha20IETF.xor(m2[0..], result[0..], 1, key, nonce);	650	ChaCha20IETF.xor(m2[0..], result[0..], 1, key, nonce);
651	testing.expect(mem.order(u8, m, &m2) == .eq);	651	try testing.expect(mem.order(u8, m, &m2) == .eq);
652	}	652	}
653		653
654	// https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7	654	// https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
...	@@ -683,7 +683,7 @@ test "crypto.chacha20 test vector 1" {	...	@@ -683,7 +683,7 @@ test "crypto.chacha20 test vector 1" {
683	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 };	683	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 };
684		684
685	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);	685	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);
686	testing.expectEqualSlices(u8, &expected_result, &result);	686	try testing.expectEqualSlices(u8, &expected_result, &result);
687	}	687	}
688		688
689	test "crypto.chacha20 test vector 2" {	689	test "crypto.chacha20 test vector 2" {
...	@@ -717,7 +717,7 @@ test "crypto.chacha20 test vector 2" {	...	@@ -717,7 +717,7 @@ test "crypto.chacha20 test vector 2" {
717	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 };	717	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 };
718		718
719	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);	719	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);
720	testing.expectEqualSlices(u8, &expected_result, &result);	720	try testing.expectEqualSlices(u8, &expected_result, &result);
721	}	721	}
722		722
723	test "crypto.chacha20 test vector 3" {	723	test "crypto.chacha20 test vector 3" {
...	@@ -751,7 +751,7 @@ test "crypto.chacha20 test vector 3" {	...	@@ -751,7 +751,7 @@ test "crypto.chacha20 test vector 3" {
751	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 1 };	751	const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 1 };
752		752
753	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);	753	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);
754	testing.expectEqualSlices(u8, &expected_result, &result);	754	try testing.expectEqualSlices(u8, &expected_result, &result);
755	}	755	}
756		756
757	test "crypto.chacha20 test vector 4" {	757	test "crypto.chacha20 test vector 4" {
...	@@ -785,7 +785,7 @@ test "crypto.chacha20 test vector 4" {	...	@@ -785,7 +785,7 @@ test "crypto.chacha20 test vector 4" {
785	const nonce = [_]u8{ 1, 0, 0, 0, 0, 0, 0, 0 };	785	const nonce = [_]u8{ 1, 0, 0, 0, 0, 0, 0, 0 };
786		786
787	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);	787	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);
788	testing.expectEqualSlices(u8, &expected_result, &result);	788	try testing.expectEqualSlices(u8, &expected_result, &result);
789	}	789	}
790		790
791	test "crypto.chacha20 test vector 5" {	791	test "crypto.chacha20 test vector 5" {
...	@@ -857,7 +857,7 @@ test "crypto.chacha20 test vector 5" {	...	@@ -857,7 +857,7 @@ test "crypto.chacha20 test vector 5" {
857	};	857	};
858		858
859	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);	859	ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce);
860	testing.expectEqualSlices(u8, &expected_result, &result);	860	try testing.expectEqualSlices(u8, &expected_result, &result);
861	}	861	}
862		862
863	test "seal" {	863	test "seal" {
...	@@ -873,7 +873,7 @@ test "seal" {	...	@@ -873,7 +873,7 @@ test "seal" {
873		873
874	var out: [exp_out.len]u8 = undefined;	874	var out: [exp_out.len]u8 = undefined;
875	ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m, ad, nonce, key);	875	ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m, ad, nonce, key);
876	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	876	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
877	}	877	}
878	{	878	{
879	const m = [_]u8{	879	const m = [_]u8{
...	@@ -906,7 +906,7 @@ test "seal" {	...	@@ -906,7 +906,7 @@ test "seal" {
906		906
907	var out: [exp_out.len]u8 = undefined;	907	var out: [exp_out.len]u8 = undefined;
908	ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m[0..], ad[0..], nonce, key);	908	ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m[0..], ad[0..], nonce, key);
909	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	909	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
910	}	910	}
911	}	911	}
912		912
...	@@ -923,7 +923,7 @@ test "open" {	...	@@ -923,7 +923,7 @@ test "open" {
923		923
924	var out: [exp_out.len]u8 = undefined;	924	var out: [exp_out.len]u8 = undefined;
925	try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key);	925	try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key);
926	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	926	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
927	}	927	}
928	{	928	{
929	const c = [_]u8{	929	const c = [_]u8{
...	@@ -956,21 +956,21 @@ test "open" {	...	@@ -956,21 +956,21 @@ test "open" {
956		956
957	var out: [exp_out.len]u8 = undefined;	957	var out: [exp_out.len]u8 = undefined;
958	try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key);	958	try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key);
959	testing.expectEqualSlices(u8, exp_out[0..], out[0..]);	959	try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
960		960
961	// corrupting the ciphertext, data, key, or nonce should cause a failure	961	// corrupting the ciphertext, data, key, or nonce should cause a failure
962	var bad_c = c;	962	var bad_c = c;
963	bad_c[0] ^= 1;	963	bad_c[0] ^= 1;
964	testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], bad_c[0..out.len], bad_c[out.len..].*, ad[0..], nonce, key));	964	try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], bad_c[0..out.len], bad_c[out.len..].*, ad[0..], nonce, key));
965	var bad_ad = ad;	965	var bad_ad = ad;
966	bad_ad[0] ^= 1;	966	bad_ad[0] ^= 1;
967	testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, bad_ad[0..], nonce, key));	967	try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, bad_ad[0..], nonce, key));
968	var bad_key = key;	968	var bad_key = key;
969	bad_key[0] ^= 1;	969	bad_key[0] ^= 1;
970	testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], nonce, bad_key));	970	try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], nonce, bad_key));
971	var bad_nonce = nonce;	971	var bad_nonce = nonce;
972	bad_nonce[0] ^= 1;	972	bad_nonce[0] ^= 1;
973	testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], bad_nonce, key));	973	try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], bad_nonce, key));
974	}	974	}
975	}	975	}
976		976
...	@@ -982,7 +982,7 @@ test "crypto.xchacha20" {	...	@@ -982,7 +982,7 @@ test "crypto.xchacha20" {
982	var c: [m.len]u8 = undefined;	982	var c: [m.len]u8 = undefined;
983	XChaCha20IETF.xor(c[0..], m[0..], 0, key, nonce);	983	XChaCha20IETF.xor(c[0..], m[0..], 0, key, nonce);
984	var buf: [2 * c.len]u8 = undefined;	984	var buf: [2 * c.len]u8 = undefined;
985	testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "E0A1BCF939654AFDBDC1746EC49832647C19D891F0D1A81FC0C1703B4514BDEA584B512F6908C2C5E9DD18D5CBC1805DE5803FE3B9CA5F193FB8359E91FAB0C3BB40309A292EB1CF49685C65C4A3ADF4F11DB0CD2B6B67FBC174BC2E860E8F769FD3565BBFAD1C845E05A0FED9BE167C240D");	985	try testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "E0A1BCF939654AFDBDC1746EC49832647C19D891F0D1A81FC0C1703B4514BDEA584B512F6908C2C5E9DD18D5CBC1805DE5803FE3B9CA5F193FB8359E91FAB0C3BB40309A292EB1CF49685C65C4A3ADF4F11DB0CD2B6B67FBC174BC2E860E8F769FD3565BBFAD1C845E05A0FED9BE167C240D");
986	}	986	}
987	{	987	{
988	const ad = "Additional data";	988	const ad = "Additional data";
...	@@ -991,9 +991,9 @@ test "crypto.xchacha20" {	...	@@ -991,9 +991,9 @@ test "crypto.xchacha20" {
991	var out: [m.len]u8 = undefined;	991	var out: [m.len]u8 = undefined;
992	try XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key);	992	try XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key);
993	var buf: [2 * c.len]u8 = undefined;	993	var buf: [2 * c.len]u8 = undefined;
994	testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "994D2DD32333F48E53650C02C7A2ABB8E018B0836D7175AEC779F52E961780768F815C58F1AA52D211498DB89B9216763F569C9433A6BBFCEFB4D4A49387A4C5207FBB3B5A92B5941294DF30588C6740D39DC16FA1F0E634F7246CF7CDCB978E44347D89381B7A74EB7084F754B90BDE9AAF5A94B8F2A85EFD0B50692AE2D425E234");	994	try testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "994D2DD32333F48E53650C02C7A2ABB8E018B0836D7175AEC779F52E961780768F815C58F1AA52D211498DB89B9216763F569C9433A6BBFCEFB4D4A49387A4C5207FBB3B5A92B5941294DF30588C6740D39DC16FA1F0E634F7246CF7CDCB978E44347D89381B7A74EB7084F754B90BDE9AAF5A94B8F2A85EFD0B50692AE2D425E234");
995	testing.expectEqualSlices(u8, out[0..], m);	995	try testing.expectEqualSlices(u8, out[0..], m);
996	c[0] += 1;	996	c[0] += 1;
997	testing.expectError(error.AuthenticationFailed, XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key));	997	try testing.expectError(error.AuthenticationFailed, XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key));
998	}	998	}
999	}	999	}

...	@@ -205,7 +205,7 @@ test "permute" {	...	@@ -205,7 +205,7 @@ test "permute" {
205	while (i < 12) : (i += 1) {	205	while (i < 12) : (i += 1) {
206	mem.writeIntLittle(u32, expected_output[i * 4 ..][0..4], tv_output[i / 4][i % 4]);	206	mem.writeIntLittle(u32, expected_output[i * 4 ..][0..4], tv_output[i / 4][i % 4]);
207	}	207	}
208	testing.expectEqualSlices(u8, state.toSliceConst(), expected_output[0..]);	208	try testing.expectEqualSlices(u8, state.toSliceConst(), expected_output[0..]);
209	}	209	}
210		210
211	pub const Hash = struct {	211	pub const Hash = struct {
...	@@ -274,7 +274,7 @@ test "hash" {	...	@@ -274,7 +274,7 @@ test "hash" {
274	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C");	274	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C");
275	var md: [32]u8 = undefined;	275	var md: [32]u8 = undefined;
276	hash(&md, &msg, .{});	276	hash(&md, &msg, .{});
277	htest.assertEqual("1C9A03DC6A5DDC5444CFC6F4B154CFF5CF081633B2CEA4D7D0AE7CCFED5AAA44", &md);	277	try htest.assertEqual("1C9A03DC6A5DDC5444CFC6F4B154CFF5CF081633B2CEA4D7D0AE7CCFED5AAA44", &md);
278	}	278	}
279		279
280	test "hash test vector 17" {	280	test "hash test vector 17" {
...	@@ -282,7 +282,7 @@ test "hash test vector 17" {	...	@@ -282,7 +282,7 @@ test "hash test vector 17" {
282	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F");	282	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F");
283	var md: [32]u8 = undefined;	283	var md: [32]u8 = undefined;
284	hash(&md, &msg, .{});	284	hash(&md, &msg, .{});
285	htest.assertEqual("404C130AF1B9023A7908200919F690FFBB756D5176E056FFDE320016A37C7282", &md);	285	try htest.assertEqual("404C130AF1B9023A7908200919F690FFBB756D5176E056FFDE320016A37C7282", &md);
286	}	286	}
287		287
288	test "hash test vector 33" {	288	test "hash test vector 33" {
...	@@ -290,7 +290,7 @@ test "hash test vector 33" {	...	@@ -290,7 +290,7 @@ test "hash test vector 33" {
290	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F");	290	_ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F");
291	var md: [32]u8 = undefined;	291	var md: [32]u8 = undefined;
292	hash(&md, &msg, .{});	292	hash(&md, &msg, .{});
293	htest.assertEqual("A8F4FA28708BDA7EFB4C1914CA4AFA9E475B82D588D36504F87DBB0ED9AB3C4B", &md);	293	try htest.assertEqual("A8F4FA28708BDA7EFB4C1914CA4AFA9E475B82D588D36504F87DBB0ED9AB3C4B", &md);
294	}	294	}
295		295
296	pub const Aead = struct {	296	pub const Aead = struct {
...	@@ -447,12 +447,12 @@ test "cipher" {	...	@@ -447,12 +447,12 @@ test "cipher" {
447	var ct: [pt.len]u8 = undefined;	447	var ct: [pt.len]u8 = undefined;
448	var tag: [16]u8 = undefined;	448	var tag: [16]u8 = undefined;
449	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);	449	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);
450	htest.assertEqual("", &ct);	450	try htest.assertEqual("", &ct);
451	htest.assertEqual("14DA9BB7120BF58B985A8E00FDEBA15B", &tag);	451	try htest.assertEqual("14DA9BB7120BF58B985A8E00FDEBA15B", &tag);
452		452
453	var pt2: [pt.len]u8 = undefined;	453	var pt2: [pt.len]u8 = undefined;
454	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);	454	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);
455	testing.expectEqualSlices(u8, &pt, &pt2);	455	try testing.expectEqualSlices(u8, &pt, &pt2);
456	}	456	}
457	{ // test vector (34) from NIST KAT submission.	457	{ // test vector (34) from NIST KAT submission.
458	const ad: [0]u8 = undefined;	458	const ad: [0]u8 = undefined;
...	@@ -462,12 +462,12 @@ test "cipher" {	...	@@ -462,12 +462,12 @@ test "cipher" {
462	var ct: [pt.len]u8 = undefined;	462	var ct: [pt.len]u8 = undefined;
463	var tag: [16]u8 = undefined;	463	var tag: [16]u8 = undefined;
464	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);	464	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);
465	htest.assertEqual("7F", &ct);	465	try htest.assertEqual("7F", &ct);
466	htest.assertEqual("80492C317B1CD58A1EDC3A0D3E9876FC", &tag);	466	try htest.assertEqual("80492C317B1CD58A1EDC3A0D3E9876FC", &tag);
467		467
468	var pt2: [pt.len]u8 = undefined;	468	var pt2: [pt.len]u8 = undefined;
469	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);	469	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);
470	testing.expectEqualSlices(u8, &pt, &pt2);	470	try testing.expectEqualSlices(u8, &pt, &pt2);
471	}	471	}
472	{ // test vector (106) from NIST KAT submission.	472	{ // test vector (106) from NIST KAT submission.
473	var ad: [12 / 2]u8 = undefined;	473	var ad: [12 / 2]u8 = undefined;
...	@@ -478,12 +478,12 @@ test "cipher" {	...	@@ -478,12 +478,12 @@ test "cipher" {
478	var ct: [pt.len]u8 = undefined;	478	var ct: [pt.len]u8 = undefined;
479	var tag: [16]u8 = undefined;	479	var tag: [16]u8 = undefined;
480	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);	480	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);
481	htest.assertEqual("484D35", &ct);	481	try htest.assertEqual("484D35", &ct);
482	htest.assertEqual("030BBEA23B61C00CED60A923BDCF9147", &tag);	482	try htest.assertEqual("030BBEA23B61C00CED60A923BDCF9147", &tag);
483		483
484	var pt2: [pt.len]u8 = undefined;	484	var pt2: [pt.len]u8 = undefined;
485	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);	485	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);
486	testing.expectEqualSlices(u8, &pt, &pt2);	486	try testing.expectEqualSlices(u8, &pt, &pt2);
487	}	487	}
488	{ // test vector (790) from NIST KAT submission.	488	{ // test vector (790) from NIST KAT submission.
489	var ad: [60 / 2]u8 = undefined;	489	var ad: [60 / 2]u8 = undefined;
...	@@ -494,12 +494,12 @@ test "cipher" {	...	@@ -494,12 +494,12 @@ test "cipher" {
494	var ct: [pt.len]u8 = undefined;	494	var ct: [pt.len]u8 = undefined;
495	var tag: [16]u8 = undefined;	495	var tag: [16]u8 = undefined;
496	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);	496	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);
497	htest.assertEqual("6815B4A0ECDAD01596EAD87D9E690697475D234C6A13D1", &ct);	497	try htest.assertEqual("6815B4A0ECDAD01596EAD87D9E690697475D234C6A13D1", &ct);
498	htest.assertEqual("DFE23F1642508290D68245279558B2FB", &tag);	498	try htest.assertEqual("DFE23F1642508290D68245279558B2FB", &tag);
499		499
500	var pt2: [pt.len]u8 = undefined;	500	var pt2: [pt.len]u8 = undefined;
501	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);	501	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);
502	testing.expectEqualSlices(u8, &pt, &pt2);	502	try testing.expectEqualSlices(u8, &pt, &pt2);
503	}	503	}
504	{ // test vector (1057) from NIST KAT submission.	504	{ // test vector (1057) from NIST KAT submission.
505	const ad: [0]u8 = undefined;	505	const ad: [0]u8 = undefined;
...	@@ -509,11 +509,11 @@ test "cipher" {	...	@@ -509,11 +509,11 @@ test "cipher" {
509	var ct: [pt.len]u8 = undefined;	509	var ct: [pt.len]u8 = undefined;
510	var tag: [16]u8 = undefined;	510	var tag: [16]u8 = undefined;
511	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);	511	Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key);
512	htest.assertEqual("7F8A2CF4F52AA4D6B2E74105C30A2777B9D0C8AEFDD555DE35861BD3011F652F", &ct);	512	try htest.assertEqual("7F8A2CF4F52AA4D6B2E74105C30A2777B9D0C8AEFDD555DE35861BD3011F652F", &ct);
513	htest.assertEqual("7256456FA935AC34BBF55AE135F33257", &tag);	513	try htest.assertEqual("7256456FA935AC34BBF55AE135F33257", &tag);
514		514
515	var pt2: [pt.len]u8 = undefined;	515	var pt2: [pt.len]u8 = undefined;
516	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);	516	try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key);
517	testing.expectEqualSlices(u8, &pt, &pt2);	517	try testing.expectEqualSlices(u8, &pt, &pt2);
518	}	518	}
519	}	519	}

...	@@ -84,26 +84,26 @@ const htest = @import("test.zig");	...	@@ -84,26 +84,26 @@ const htest = @import("test.zig");
84	test "hmac md5" {	84	test "hmac md5" {
85	var out: [HmacMd5.mac_length]u8 = undefined;	85	var out: [HmacMd5.mac_length]u8 = undefined;
86	HmacMd5.create(out[0..], "", "");	86	HmacMd5.create(out[0..], "", "");
87	htest.assertEqual("74e6f7298a9c2d168935f58c001bad88", out[0..]);	87	try htest.assertEqual("74e6f7298a9c2d168935f58c001bad88", out[0..]);
88		88
89	HmacMd5.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");	89	HmacMd5.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");
90	htest.assertEqual("80070713463e7749b90c2dc24911e275", out[0..]);	90	try htest.assertEqual("80070713463e7749b90c2dc24911e275", out[0..]);
91	}	91	}
92		92
93	test "hmac sha1" {	93	test "hmac sha1" {
94	var out: [HmacSha1.mac_length]u8 = undefined;	94	var out: [HmacSha1.mac_length]u8 = undefined;
95	HmacSha1.create(out[0..], "", "");	95	HmacSha1.create(out[0..], "", "");
96	htest.assertEqual("fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", out[0..]);	96	try htest.assertEqual("fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", out[0..]);
97		97
98	HmacSha1.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");	98	HmacSha1.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");
99	htest.assertEqual("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", out[0..]);	99	try htest.assertEqual("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", out[0..]);
100	}	100	}
101		101
102	test "hmac sha256" {	102	test "hmac sha256" {
103	var out: [sha2.HmacSha256.mac_length]u8 = undefined;	103	var out: [sha2.HmacSha256.mac_length]u8 = undefined;
104	sha2.HmacSha256.create(out[0..], "", "");	104	sha2.HmacSha256.create(out[0..], "", "");
105	htest.assertEqual("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad", out[0..]);	105	try htest.assertEqual("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad", out[0..]);
106		106
107	sha2.HmacSha256.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");	107	sha2.HmacSha256.create(out[0..], "The quick brown fox jumps over the lazy dog", "key");
108	htest.assertEqual("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", out[0..]);	108	try htest.assertEqual("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", out[0..]);
109	}	109	}

Merge pull request #8686 from Vexu/try

...	@@ -168,7 +168,7 @@ test "RFC 6070 one iteration" {	...	@@ -168,7 +168,7 @@ test "RFC 6070 one iteration" {
168		168
169	const expected = "0c60c80f961f0e71f3a9b524af6012062fe037a6";	169	const expected = "0c60c80f961f0e71f3a9b524af6012062fe037a6";
170		170
171	htest.assertEqual(expected, dk[0..]);	171	try htest.assertEqual(expected, dk[0..]);
172	}	172	}
173		173
174	test "RFC 6070 two iterations" {	174	test "RFC 6070 two iterations" {
...	@@ -183,7 +183,7 @@ test "RFC 6070 two iterations" {	...	@@ -183,7 +183,7 @@ test "RFC 6070 two iterations" {
183		183
184	const expected = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957";	184	const expected = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957";
185		185
186	htest.assertEqual(expected, dk[0..]);	186	try htest.assertEqual(expected, dk[0..]);
187	}	187	}
188		188
189	test "RFC 6070 4096 iterations" {	189	test "RFC 6070 4096 iterations" {
...	@@ -198,7 +198,7 @@ test "RFC 6070 4096 iterations" {	...	@@ -198,7 +198,7 @@ test "RFC 6070 4096 iterations" {
198		198
199	const expected = "4b007901b765489abead49d926f721d065a429c1";	199	const expected = "4b007901b765489abead49d926f721d065a429c1";
200		200
201	htest.assertEqual(expected, dk[0..]);	201	try htest.assertEqual(expected, dk[0..]);
202	}	202	}
203		203
204	test "RFC 6070 16,777,216 iterations" {	204	test "RFC 6070 16,777,216 iterations" {
...	@@ -218,7 +218,7 @@ test "RFC 6070 16,777,216 iterations" {	...	@@ -218,7 +218,7 @@ test "RFC 6070 16,777,216 iterations" {
218		218
219	const expected = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984";	219	const expected = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984";
220		220
221	htest.assertEqual(expected, dk[0..]);	221	try htest.assertEqual(expected, dk[0..]);
222	}	222	}
223		223
224	test "RFC 6070 multi-block salt and password" {	224	test "RFC 6070 multi-block salt and password" {
...	@@ -233,7 +233,7 @@ test "RFC 6070 multi-block salt and password" {	...	@@ -233,7 +233,7 @@ test "RFC 6070 multi-block salt and password" {
233		233
234	const expected = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038";	234	const expected = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038";
235		235
236	htest.assertEqual(expected, dk[0..]);	236	try htest.assertEqual(expected, dk[0..]);
237	}	237	}
238		238
239	test "RFC 6070 embedded NUL" {	239	test "RFC 6070 embedded NUL" {
...	@@ -248,7 +248,7 @@ test "RFC 6070 embedded NUL" {	...	@@ -248,7 +248,7 @@ test "RFC 6070 embedded NUL" {
248		248
249	const expected = "56fa6aa75548099dcc37d7f03425e0c3";	249	const expected = "56fa6aa75548099dcc37d7f03425e0c3";
250		250
251	htest.assertEqual(expected, dk[0..]);	251	try htest.assertEqual(expected, dk[0..]);
252	}	252	}
253		253
254	test "Very large dk_len" {	254	test "Very large dk_len" {

...	@@ -17,7 +17,7 @@ test "p256 ECDH key exchange" {	...	@@ -17,7 +17,7 @@ test "p256 ECDH key exchange" {
17	const dhB = try P256.basePoint.mul(dhb, .Little);	17	const dhB = try P256.basePoint.mul(dhb, .Little);
18	const shareda = try dhA.mul(dhb, .Little);	18	const shareda = try dhA.mul(dhb, .Little);
19	const sharedb = try dhB.mul(dha, .Little);	19	const sharedb = try dhB.mul(dha, .Little);
20	testing.expect(shareda.equivalent(sharedb));	20	try testing.expect(shareda.equivalent(sharedb));
21	}	21	}
22		22
23	test "p256 point from affine coordinates" {	23	test "p256 point from affine coordinates" {
...	@@ -28,7 +28,7 @@ test "p256 point from affine coordinates" {	...	@@ -28,7 +28,7 @@ test "p256 point from affine coordinates" {
28	var ys: [32]u8 = undefined;	28	var ys: [32]u8 = undefined;
29	_ = try fmt.hexToBytes(&ys, yh);	29	_ = try fmt.hexToBytes(&ys, yh);
30	var p = try P256.fromSerializedAffineCoordinates(xs, ys, .Big);	30	var p = try P256.fromSerializedAffineCoordinates(xs, ys, .Big);
31	testing.expect(p.equivalent(P256.basePoint));	31	try testing.expect(p.equivalent(P256.basePoint));
32	}	32	}
33		33
34	test "p256 test vectors" {	34	test "p256 test vectors" {
...	@@ -50,7 +50,7 @@ test "p256 test vectors" {	...	@@ -50,7 +50,7 @@ test "p256 test vectors" {
50	p = p.add(P256.basePoint);	50	p = p.add(P256.basePoint);
51	var xs: [32]u8 = undefined;	51	var xs: [32]u8 = undefined;
52	_ = try fmt.hexToBytes(&xs, xh);	52	_ = try fmt.hexToBytes(&xs, xh);
53	testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs);	53	try testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs);
54	}	54	}
55	}	55	}
56		56
...	@@ -67,7 +67,7 @@ test "p256 test vectors - doubling" {	...	@@ -67,7 +67,7 @@ test "p256 test vectors - doubling" {
67	p = p.dbl();	67	p = p.dbl();
68	var xs: [32]u8 = undefined;	68	var xs: [32]u8 = undefined;
69	_ = try fmt.hexToBytes(&xs, xh);	69	_ = try fmt.hexToBytes(&xs, xh);
70	testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs);	70	try testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs);
71	}	71	}
72	}	72	}
73		73
...	@@ -75,29 +75,29 @@ test "p256 compressed sec1 encoding/decoding" {	...	@@ -75,29 +75,29 @@ test "p256 compressed sec1 encoding/decoding" {
75	const p = P256.random();	75	const p = P256.random();
76	const s = p.toCompressedSec1();	76	const s = p.toCompressedSec1();
77	const q = try P256.fromSec1(&s);	77	const q = try P256.fromSec1(&s);
78	testing.expect(p.equivalent(q));	78	try testing.expect(p.equivalent(q));
79	}	79	}
80		80
81	test "p256 uncompressed sec1 encoding/decoding" {	81	test "p256 uncompressed sec1 encoding/decoding" {
82	const p = P256.random();	82	const p = P256.random();
83	const s = p.toUncompressedSec1();	83	const s = p.toUncompressedSec1();
84	const q = try P256.fromSec1(&s);	84	const q = try P256.fromSec1(&s);
85	testing.expect(p.equivalent(q));	85	try testing.expect(p.equivalent(q));
86	}	86	}
87		87
88	test "p256 public key is the neutral element" {	88	test "p256 public key is the neutral element" {
89	const n = P256.scalar.Scalar.zero.toBytes(.Little);	89	const n = P256.scalar.Scalar.zero.toBytes(.Little);
90	const p = P256.random();	90	const p = P256.random();
91	testing.expectError(error.IdentityElement, p.mul(n, .Little));	91	try testing.expectError(error.IdentityElement, p.mul(n, .Little));
92	}	92	}
93		93
94	test "p256 public key is the neutral element (public verification)" {	94	test "p256 public key is the neutral element (public verification)" {
95	const n = P256.scalar.Scalar.zero.toBytes(.Little);	95	const n = P256.scalar.Scalar.zero.toBytes(.Little);
96	const p = P256.random();	96	const p = P256.random();
97	testing.expectError(error.IdentityElement, p.mulPublic(n, .Little));	97	try testing.expectError(error.IdentityElement, p.mulPublic(n, .Little));
98	}	98	}
99		99
100	test "p256 field element non-canonical encoding" {	100	test "p256 field element non-canonical encoding" {
101	const s = [_]u8{0xff} ** 32;	101	const s = [_]u8{0xff} ** 32;
102	testing.expectError(error.NonCanonical, P256.Fe.fromBytes(s, .Little));	102	try testing.expectError(error.NonCanonical, P256.Fe.fromBytes(s, .Little));
103	}	103	}

...	@@ -92,9 +92,9 @@ test "crypto.utils.timingSafeEql" {	...	@@ -92,9 +92,9 @@ test "crypto.utils.timingSafeEql" {
92	var b: [100]u8 = undefined;	92	var b: [100]u8 = undefined;
93	std.crypto.random.bytes(a[0..]);	93	std.crypto.random.bytes(a[0..]);
94	std.crypto.random.bytes(b[0..]);	94	std.crypto.random.bytes(b[0..]);
95	testing.expect(!timingSafeEql([100]u8, a, b));	95	try testing.expect(!timingSafeEql([100]u8, a, b));
96	mem.copy(u8, a[0..], b[0..]);	96	mem.copy(u8, a[0..], b[0..]);
97	testing.expect(timingSafeEql([100]u8, a, b));	97	try testing.expect(timingSafeEql([100]u8, a, b));
98	}	98	}
99		99
100	test "crypto.utils.timingSafeEql (vectors)" {	100	test "crypto.utils.timingSafeEql (vectors)" {
...	@@ -104,22 +104,22 @@ test "crypto.utils.timingSafeEql (vectors)" {	...	@@ -104,22 +104,22 @@ test "crypto.utils.timingSafeEql (vectors)" {
104	std.crypto.random.bytes(b[0..]);	104	std.crypto.random.bytes(b[0..]);
105	const v1: std.meta.Vector(100, u8) = a;	105	const v1: std.meta.Vector(100, u8) = a;
106	const v2: std.meta.Vector(100, u8) = b;	106	const v2: std.meta.Vector(100, u8) = b;
107	testing.expect(!timingSafeEql(std.meta.Vector(100, u8), v1, v2));	107	try testing.expect(!timingSafeEql(std.meta.Vector(100, u8), v1, v2));
108	const v3: std.meta.Vector(100, u8) = a;	108	const v3: std.meta.Vector(100, u8) = a;
109	testing.expect(timingSafeEql(std.meta.Vector(100, u8), v1, v3));	109	try testing.expect(timingSafeEql(std.meta.Vector(100, u8), v1, v3));
110	}	110	}
111		111
112	test "crypto.utils.timingSafeCompare" {	112	test "crypto.utils.timingSafeCompare" {
113	var a = [_]u8{10} ** 32;	113	var a = [_]u8{10} ** 32;
114	var b = [_]u8{10} ** 32;	114	var b = [_]u8{10} ** 32;
115	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .eq);	115	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .eq);
116	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .eq);	116	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .eq);
117	a[31] = 1;	117	a[31] = 1;
118	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .lt);	118	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .lt);
119	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt);	119	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt);
120	a[0] = 20;	120	a[0] = 20;
121	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .gt);	121	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .gt);
122	testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt);	122	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt);
123	}	123	}
124		124
125	test "crypto.utils.secureZero" {	125	test "crypto.utils.secureZero" {
...	@@ -129,5 +129,5 @@ test "crypto.utils.secureZero" {	...	@@ -129,5 +129,5 @@ test "crypto.utils.secureZero" {
129	mem.set(u8, a[0..], 0);	129	mem.set(u8, a[0..], 0);
130	secureZero(u8, b[0..]);	130	secureZero(u8, b[0..]);
131		131
132	testing.expectEqualSlices(u8, a[0..], b[0..]);	132	try testing.expectEqualSlices(u8, a[0..], b[0..]);
133	}	133	}

...	@@ -27,13 +27,13 @@ pub fn cmp(a: [:0]const u8, b: [:0]const u8) i8 {	...	@@ -27,13 +27,13 @@ pub fn cmp(a: [:0]const u8, b: [:0]const u8) i8 {
27	}	27	}
28		28
29	test "cstr fns" {	29	test "cstr fns" {
30	comptime testCStrFnsImpl();	30	comptime try testCStrFnsImpl();
31	testCStrFnsImpl();	31	try testCStrFnsImpl();
32	}	32	}
33		33
34	fn testCStrFnsImpl() void {	34	fn testCStrFnsImpl() !void {
35	testing.expect(cmp("aoeu", "aoez") == -1);	35	try testing.expect(cmp("aoeu", "aoez") == -1);
36	testing.expect(mem.len("123456789") == 9);	36	try testing.expect(mem.len("123456789") == 9);
37	}	37	}
38		38
39	/// Returns a mutable, null-terminated slice with the same length as `slice`.	39	/// Returns a mutable, null-terminated slice with the same length as `slice`.
...	@@ -48,8 +48,8 @@ pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![:0]u8 {	...	@@ -48,8 +48,8 @@ pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![:0]u8 {
48	test "addNullByte" {	48	test "addNullByte" {
49	const slice = try addNullByte(std.testing.allocator, "hello"[0..4]);	49	const slice = try addNullByte(std.testing.allocator, "hello"[0..4]);
50	defer std.testing.allocator.free(slice);	50	defer std.testing.allocator.free(slice);
51	testing.expect(slice.len == 4);	51	try testing.expect(slice.len == 4);
52	testing.expect(slice[4] == 0);	52	try testing.expect(slice[4] == 0);
53	}	53	}
54		54
55	pub const NullTerminated2DArray = struct {	55	pub const NullTerminated2DArray = struct {

...	@@ -310,25 +310,25 @@ test "std.event.Channel wraparound" {	...	@@ -310,25 +310,25 @@ test "std.event.Channel wraparound" {
310	// the buffer wraps around, make sure it doesn't crash.	310	// the buffer wraps around, make sure it doesn't crash.
311	var result: i32 = undefined;	311	var result: i32 = undefined;
312	channel.put(5);	312	channel.put(5);
313	testing.expectEqual(@as(i32, 5), channel.get());	313	try testing.expectEqual(@as(i32, 5), channel.get());
314	channel.put(6);	314	channel.put(6);
315	testing.expectEqual(@as(i32, 6), channel.get());	315	try testing.expectEqual(@as(i32, 6), channel.get());
316	channel.put(7);	316	channel.put(7);
317	testing.expectEqual(@as(i32, 7), channel.get());	317	try testing.expectEqual(@as(i32, 7), channel.get());
318	}	318	}
319	fn testChannelGetter(channel: *Channel(i32)) callconv(.Async) void {	319	fn testChannelGetter(channel: *Channel(i32)) callconv(.Async) void {
320	const value1 = channel.get();	320	const value1 = channel.get();
321	testing.expect(value1 == 1234);	321	try testing.expect(value1 == 1234);
322		322
323	const value2 = channel.get();	323	const value2 = channel.get();
324	testing.expect(value2 == 4567);	324	try testing.expect(value2 == 4567);
325		325
326	const value3 = channel.getOrNull();	326	const value3 = channel.getOrNull();
327	testing.expect(value3 == null);	327	try testing.expect(value3 == null);
328		328
329	var last_put = async testPut(channel, 4444);	329	var last_put = async testPut(channel, 4444);
330	const value4 = channel.getOrNull();	330	const value4 = channel.getOrNull();
331	testing.expect(value4.? == 4444);	331	try testing.expect(value4.? == 4444);
332	await last_put;	332	await last_put;
333	}	333	}
334	fn testChannelPutter(channel: *Channel(i32)) callconv(.Async) void {	334	fn testChannelPutter(channel: *Channel(i32)) callconv(.Async) void {

...	@@ -1655,7 +1655,7 @@ fn testEventLoop() i32 {	...	@@ -1655,7 +1655,7 @@ fn testEventLoop() i32 {
1655		1655
1656	fn testEventLoop2(h: anyframe->i32, did_it: *bool) void {	1656	fn testEventLoop2(h: anyframe->i32, did_it: *bool) void {
1657	const value = await h;	1657	const value = await h;
1658	testing.expect(value == 1234);	1658	try testing.expect(value == 1234);
1659	did_it.* = true;	1659	did_it.* = true;
1660	}	1660	}
1661		1661
...	@@ -1682,7 +1682,7 @@ test "std.event.Loop - runDetached" {	...	@@ -1682,7 +1682,7 @@ test "std.event.Loop - runDetached" {
1682	// with the previous runDetached.	1682	// with the previous runDetached.
1683	loop.run();	1683	loop.run();
1684		1684
1685	testing.expect(testRunDetachedData == 1);	1685	try testing.expect(testRunDetachedData == 1);
1686	}	1686	}
1687		1687
1688	fn testRunDetached() void {	1688	fn testRunDetached() void {
...	@@ -1705,7 +1705,7 @@ test "std.event.Loop - sleep" {	...	@@ -1705,7 +1705,7 @@ test "std.event.Loop - sleep" {
1705	for (frames) \|*frame\|	1705	for (frames) \|*frame\|
1706	await frame;	1706	await frame;
1707		1707
1708	testing.expect(sleep_count == frames.len);	1708	try testing.expect(sleep_count == frames.len);
1709	}	1709	}
1710		1710
1711	fn testSleep(wait_ns: u64, sleep_count: *usize) void {	1711	fn testSleep(wait_ns: u64, sleep_count: *usize) void {

...	@@ -402,59 +402,59 @@ test "LinearFifo(u8, .Dynamic)" {	...	@@ -402,59 +402,59 @@ test "LinearFifo(u8, .Dynamic)" {
402	defer fifo.deinit();	402	defer fifo.deinit();
403		403
404	try fifo.write("HELLO");	404	try fifo.write("HELLO");
405	testing.expectEqual(@as(usize, 5), fifo.readableLength());	405	try testing.expectEqual(@as(usize, 5), fifo.readableLength());
406	testing.expectEqualSlices(u8, "HELLO", fifo.readableSlice(0));	406	try testing.expectEqualSlices(u8, "HELLO", fifo.readableSlice(0));
407		407
408	{	408	{
409	var i: usize = 0;	409	var i: usize = 0;
410	while (i < 5) : (i += 1) {	410	while (i < 5) : (i += 1) {
411	try fifo.write(&[_]u8{fifo.peekItem(i)});	411	try fifo.write(&[_]u8{fifo.peekItem(i)});
412	}	412	}
413	testing.expectEqual(@as(usize, 10), fifo.readableLength());	413	try testing.expectEqual(@as(usize, 10), fifo.readableLength());
414	testing.expectEqualSlices(u8, "HELLOHELLO", fifo.readableSlice(0));	414	try testing.expectEqualSlices(u8, "HELLOHELLO", fifo.readableSlice(0));
415	}	415	}
416		416
417	{	417	{
418	testing.expectEqual(@as(u8, 'H'), fifo.readItem().?);	418	try testing.expectEqual(@as(u8, 'H'), fifo.readItem().?);
419	testing.expectEqual(@as(u8, 'E'), fifo.readItem().?);	419	try testing.expectEqual(@as(u8, 'E'), fifo.readItem().?);
420	testing.expectEqual(@as(u8, 'L'), fifo.readItem().?);	420	try testing.expectEqual(@as(u8, 'L'), fifo.readItem().?);
421	testing.expectEqual(@as(u8, 'L'), fifo.readItem().?);	421	try testing.expectEqual(@as(u8, 'L'), fifo.readItem().?);
422	testing.expectEqual(@as(u8, 'O'), fifo.readItem().?);	422	try testing.expectEqual(@as(u8, 'O'), fifo.readItem().?);
423	}	423	}
424	testing.expectEqual(@as(usize, 5), fifo.readableLength());	424	try testing.expectEqual(@as(usize, 5), fifo.readableLength());
425		425
426	{ // Writes that wrap around	426	{ // Writes that wrap around
427	testing.expectEqual(@as(usize, 11), fifo.writableLength());	427	try testing.expectEqual(@as(usize, 11), fifo.writableLength());
428	testing.expectEqual(@as(usize, 6), fifo.writableSlice(0).len);	428	try testing.expectEqual(@as(usize, 6), fifo.writableSlice(0).len);
429	fifo.writeAssumeCapacity("6<chars<11");	429	fifo.writeAssumeCapacity("6<chars<11");
430	testing.expectEqualSlices(u8, "HELLO6<char", fifo.readableSlice(0));	430	try testing.expectEqualSlices(u8, "HELLO6<char", fifo.readableSlice(0));
431	testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(11));	431	try testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(11));
432	testing.expectEqualSlices(u8, "11", fifo.readableSlice(13));	432	try testing.expectEqualSlices(u8, "11", fifo.readableSlice(13));
433	testing.expectEqualSlices(u8, "", fifo.readableSlice(15));	433	try testing.expectEqualSlices(u8, "", fifo.readableSlice(15));
434	fifo.discard(11);	434	fifo.discard(11);
435	testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(0));	435	try testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(0));
436	fifo.discard(4);	436	fifo.discard(4);
437	testing.expectEqual(@as(usize, 0), fifo.readableLength());	437	try testing.expectEqual(@as(usize, 0), fifo.readableLength());
438	}	438	}
439		439
440	{	440	{
441	const buf = try fifo.writableWithSize(12);	441	const buf = try fifo.writableWithSize(12);
442	testing.expectEqual(@as(usize, 12), buf.len);	442	try testing.expectEqual(@as(usize, 12), buf.len);
443	var i: u8 = 0;	443	var i: u8 = 0;
444	while (i < 10) : (i += 1) {	444	while (i < 10) : (i += 1) {
445	buf[i] = i + 'a';	445	buf[i] = i + 'a';
446	}	446	}
447	fifo.update(10);	447	fifo.update(10);
448	testing.expectEqualSlices(u8, "abcdefghij", fifo.readableSlice(0));	448	try testing.expectEqualSlices(u8, "abcdefghij", fifo.readableSlice(0));
449	}	449	}
450		450
451	{	451	{
452	try fifo.unget("prependedstring");	452	try fifo.unget("prependedstring");
453	var result: [30]u8 = undefined;	453	var result: [30]u8 = undefined;
454	testing.expectEqualSlices(u8, "prependedstringabcdefghij", result[0..fifo.read(&result)]);	454	try testing.expectEqualSlices(u8, "prependedstringabcdefghij", result[0..fifo.read(&result)]);
455	try fifo.unget("b");	455	try fifo.unget("b");
456	try fifo.unget("a");	456	try fifo.unget("a");
457	testing.expectEqualSlices(u8, "ab", result[0..fifo.read(&result)]);	457	try testing.expectEqualSlices(u8, "ab", result[0..fifo.read(&result)]);
458	}	458	}
459		459
460	fifo.shrink(0);	460	fifo.shrink(0);
...	@@ -462,17 +462,17 @@ test "LinearFifo(u8, .Dynamic)" {	...	@@ -462,17 +462,17 @@ test "LinearFifo(u8, .Dynamic)" {
462	{	462	{
463	try fifo.writer().print("{s}, {s}!", .{ "Hello", "World" });	463	try fifo.writer().print("{s}, {s}!", .{ "Hello", "World" });
464	var result: [30]u8 = undefined;	464	var result: [30]u8 = undefined;
465	testing.expectEqualSlices(u8, "Hello, World!", result[0..fifo.read(&result)]);	465	try testing.expectEqualSlices(u8, "Hello, World!", result[0..fifo.read(&result)]);
466	testing.expectEqual(@as(usize, 0), fifo.readableLength());	466	try testing.expectEqual(@as(usize, 0), fifo.readableLength());
467	}	467	}
468		468
469	{	469	{
470	try fifo.writer().writeAll("This is a test");	470	try fifo.writer().writeAll("This is a test");
471	var result: [30]u8 = undefined;	471	var result: [30]u8 = undefined;
472	testing.expectEqualSlices(u8, "This", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);	472	try testing.expectEqualSlices(u8, "This", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);
473	testing.expectEqualSlices(u8, "is", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);	473	try testing.expectEqualSlices(u8, "is", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);
474	testing.expectEqualSlices(u8, "a", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);	474	try testing.expectEqualSlices(u8, "a", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);
475	testing.expectEqualSlices(u8, "test", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);	475	try testing.expectEqualSlices(u8, "test", (try fifo.reader().readUntilDelimiterOrEof(&result, ' ')).?);
476	}	476	}
477		477
478	{	478	{
...	@@ -481,7 +481,7 @@ test "LinearFifo(u8, .Dynamic)" {	...	@@ -481,7 +481,7 @@ test "LinearFifo(u8, .Dynamic)" {
481	var out_buf: [50]u8 = undefined;	481	var out_buf: [50]u8 = undefined;
482	var out_fbs = std.io.fixedBufferStream(&out_buf);	482	var out_fbs = std.io.fixedBufferStream(&out_buf);
483	try fifo.pump(in_fbs.reader(), out_fbs.writer());	483	try fifo.pump(in_fbs.reader(), out_fbs.writer());
484	testing.expectEqualSlices(u8, in_fbs.buffer, out_fbs.getWritten());	484	try testing.expectEqualSlices(u8, in_fbs.buffer, out_fbs.getWritten());
485	}	485	}
486	}	486	}
487		487
...	@@ -498,28 +498,28 @@ test "LinearFifo" {	...	@@ -498,28 +498,28 @@ test "LinearFifo" {
498	defer fifo.deinit();	498	defer fifo.deinit();
499		499
500	try fifo.write(&[_]T{ 0, 1, 1, 0, 1 });	500	try fifo.write(&[_]T{ 0, 1, 1, 0, 1 });
501	testing.expectEqual(@as(usize, 5), fifo.readableLength());	501	try testing.expectEqual(@as(usize, 5), fifo.readableLength());
502		502
503	{	503	{
504	testing.expectEqual(@as(T, 0), fifo.readItem().?);	504	try testing.expectEqual(@as(T, 0), fifo.readItem().?);
505	testing.expectEqual(@as(T, 1), fifo.readItem().?);	505	try testing.expectEqual(@as(T, 1), fifo.readItem().?);
506	testing.expectEqual(@as(T, 1), fifo.readItem().?);	506	try testing.expectEqual(@as(T, 1), fifo.readItem().?);
507	testing.expectEqual(@as(T, 0), fifo.readItem().?);	507	try testing.expectEqual(@as(T, 0), fifo.readItem().?);
508	testing.expectEqual(@as(T, 1), fifo.readItem().?);	508	try testing.expectEqual(@as(T, 1), fifo.readItem().?);
509	testing.expectEqual(@as(usize, 0), fifo.readableLength());	509	try testing.expectEqual(@as(usize, 0), fifo.readableLength());
510	}	510	}
511		511
512	{	512	{
513	try fifo.writeItem(1);	513	try fifo.writeItem(1);
514	try fifo.writeItem(1);	514	try fifo.writeItem(1);
515	try fifo.writeItem(1);	515	try fifo.writeItem(1);
516	testing.expectEqual(@as(usize, 3), fifo.readableLength());	516	try testing.expectEqual(@as(usize, 3), fifo.readableLength());
517	}	517	}
518		518
519	{	519	{
520	var readBuf: [3]T = undefined;	520	var readBuf: [3]T = undefined;
521	const n = fifo.read(&readBuf);	521	const n = fifo.read(&readBuf);
522	testing.expectEqual(@as(usize, 3), n); // NOTE: It should be the number of items.	522	try testing.expectEqual(@as(usize, 3), n); // NOTE: It should be the number of items.
523	}	523	}
524	}	524	}
525	}	525	}

...	@@ -376,44 +376,44 @@ test "fmt.parseFloat" {	...	@@ -376,44 +376,44 @@ test "fmt.parseFloat" {
376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {	376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
377	const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);	377	const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
378		378
379	testing.expectError(error.InvalidCharacter, parseFloat(T, ""));	379	try testing.expectError(error.InvalidCharacter, parseFloat(T, ""));
380	testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));	380	try testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));
381	testing.expectError(error.InvalidCharacter, parseFloat(T, "1abc"));	381	try testing.expectError(error.InvalidCharacter, parseFloat(T, "1abc"));
382	testing.expectError(error.InvalidCharacter, parseFloat(T, "+"));	382	try testing.expectError(error.InvalidCharacter, parseFloat(T, "+"));
383	testing.expectError(error.InvalidCharacter, parseFloat(T, "-"));	383	try testing.expectError(error.InvalidCharacter, parseFloat(T, "-"));
384		384
385	expectEqual(try parseFloat(T, "0"), 0.0);	385	try expectEqual(try parseFloat(T, "0"), 0.0);
386	expectEqual(try parseFloat(T, "0"), 0.0);	386	try expectEqual(try parseFloat(T, "0"), 0.0);
387	expectEqual(try parseFloat(T, "+0"), 0.0);	387	try expectEqual(try parseFloat(T, "+0"), 0.0);
388	expectEqual(try parseFloat(T, "-0"), 0.0);	388	try expectEqual(try parseFloat(T, "-0"), 0.0);
389		389
390	expectEqual(try parseFloat(T, "0e0"), 0);	390	try expectEqual(try parseFloat(T, "0e0"), 0);
391	expectEqual(try parseFloat(T, "2e3"), 2000.0);	391	try expectEqual(try parseFloat(T, "2e3"), 2000.0);
392	expectEqual(try parseFloat(T, "1e0"), 1.0);	392	try expectEqual(try parseFloat(T, "1e0"), 1.0);
393	expectEqual(try parseFloat(T, "-2e3"), -2000.0);	393	try expectEqual(try parseFloat(T, "-2e3"), -2000.0);
394	expectEqual(try parseFloat(T, "-1e0"), -1.0);	394	try expectEqual(try parseFloat(T, "-1e0"), -1.0);
395	expectEqual(try parseFloat(T, "1.234e3"), 1234);	395	try expectEqual(try parseFloat(T, "1.234e3"), 1234);
396		396
397	expect(approxEqAbs(T, try parseFloat(T, "3.141"), 3.141, epsilon));	397	try expect(approxEqAbs(T, try parseFloat(T, "3.141"), 3.141, epsilon));
398	expect(approxEqAbs(T, try parseFloat(T, "-3.141"), -3.141, epsilon));	398	try expect(approxEqAbs(T, try parseFloat(T, "-3.141"), -3.141, epsilon));
399		399
400	expectEqual(try parseFloat(T, "1e-700"), 0);	400	try expectEqual(try parseFloat(T, "1e-700"), 0);
401	expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T));	401	try expectEqual(try parseFloat(T, "1e+700"), std.math.inf(T));
402		402
403	expectEqual(@bitCast(Z, try parseFloat(T, "nAn")), @bitCast(Z, std.math.nan(T)));	403	try expectEqual(@bitCast(Z, try parseFloat(T, "nAn")), @bitCast(Z, std.math.nan(T)));
404	expectEqual(try parseFloat(T, "inF"), std.math.inf(T));	404	try expectEqual(try parseFloat(T, "inF"), std.math.inf(T));
405	expectEqual(try parseFloat(T, "-INF"), -std.math.inf(T));	405	try expectEqual(try parseFloat(T, "-INF"), -std.math.inf(T));
406		406
407	expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T));	407	try expectEqual(try parseFloat(T, "0.4e0066999999999999999999999999999999999999999999999999999"), std.math.inf(T));
408		408
409	if (T != f16) {	409	if (T != f16) {
410	expect(approxEqAbs(T, try parseFloat(T, "1e-2"), 0.01, epsilon));	410	try expect(approxEqAbs(T, try parseFloat(T, "1e-2"), 0.01, epsilon));
411	expect(approxEqAbs(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));	411	try expect(approxEqAbs(T, try parseFloat(T, "1234e-2"), 12.34, epsilon));
412		412
413	expect(approxEqAbs(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));	413	try expect(approxEqAbs(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
414	expect(approxEqAbs(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));	414	try expect(approxEqAbs(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
415	expect(approxEqAbs(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));	415	try expect(approxEqAbs(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
416	expect(approxEqAbs(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));	416	try expect(approxEqAbs(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
417	}	417	}
418	}	418	}
419	}	419	}

...	@@ -247,17 +247,17 @@ pub fn parseHexFloat(comptime T: type, s: []const u8) !T {	...	@@ -247,17 +247,17 @@ pub fn parseHexFloat(comptime T: type, s: []const u8) !T {
247	}	247	}
248		248
249	test "special" {	249	test "special" {
250	testing.expect(math.isNan(try parseHexFloat(f32, "nAn")));	250	try testing.expect(math.isNan(try parseHexFloat(f32, "nAn")));
251	testing.expect(math.isPositiveInf(try parseHexFloat(f32, "iNf")));	251	try testing.expect(math.isPositiveInf(try parseHexFloat(f32, "iNf")));
252	testing.expect(math.isPositiveInf(try parseHexFloat(f32, "+Inf")));	252	try testing.expect(math.isPositiveInf(try parseHexFloat(f32, "+Inf")));
253	testing.expect(math.isNegativeInf(try parseHexFloat(f32, "-iNf")));	253	try testing.expect(math.isNegativeInf(try parseHexFloat(f32, "-iNf")));
254	}	254	}
255	test "zero" {	255	test "zero" {
256	testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0"));	256	try testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0"));
257	testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "-0x0"));	257	try testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "-0x0"));
258	testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0p42"));	258	try testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0p42"));
259	testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "-0x0.00000p42"));	259	try testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "-0x0.00000p42"));
260	testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0.00000p666"));	260	try testing.expectEqual(@as(f32, 0.0), try parseHexFloat(f32, "0x0.00000p666"));
261	}	261	}
262		262
263	test "f16" {	263	test "f16" {
...	@@ -279,7 +279,7 @@ test "f16" {	...	@@ -279,7 +279,7 @@ test "f16" {
279	};	279	};
280		280
281	for (cases) \|case\| {	281	for (cases) \|case\| {
282	testing.expectEqual(case.v, try parseHexFloat(f16, case.s));	282	try testing.expectEqual(case.v, try parseHexFloat(f16, case.s));
283	}	283	}
284	}	284	}
285	test "f32" {	285	test "f32" {
...	@@ -303,7 +303,7 @@ test "f32" {	...	@@ -303,7 +303,7 @@ test "f32" {
303	};	303	};
304		304
305	for (cases) \|case\| {	305	for (cases) \|case\| {
306	testing.expectEqual(case.v, try parseHexFloat(f32, case.s));	306	try testing.expectEqual(case.v, try parseHexFloat(f32, case.s));
307	}	307	}
308	}	308	}
309	test "f64" {	309	test "f64" {
...	@@ -325,7 +325,7 @@ test "f64" {	...	@@ -325,7 +325,7 @@ test "f64" {
325	};	325	};
326		326
327	for (cases) \|case\| {	327	for (cases) \|case\| {
328	testing.expectEqual(case.v, try parseHexFloat(f64, case.s));	328	try testing.expectEqual(case.v, try parseHexFloat(f64, case.s));
329	}	329	}
330	}	330	}
331	test "f128" {	331	test "f128" {
...	@@ -347,6 +347,6 @@ test "f128" {	...	@@ -347,6 +347,6 @@ test "f128" {
347	};	347	};
348		348
349	for (cases) \|case\| {	349	for (cases) \|case\| {
350	testing.expectEqual(@bitCast(u128, case.v), @bitCast(u128, try parseHexFloat(f128, case.s)));	350	try testing.expectEqual(@bitCast(u128, case.v), @bitCast(u128, try parseHexFloat(f128, case.s)));
351	}	351	}
352	}	352	}

...	@@ -99,21 +99,21 @@ pub const Adler32 = struct {	...	@@ -99,21 +99,21 @@ pub const Adler32 = struct {
99	};	99	};
100		100
101	test "adler32 sanity" {	101	test "adler32 sanity" {
102	testing.expectEqual(@as(u32, 0x620062), Adler32.hash("a"));	102	try testing.expectEqual(@as(u32, 0x620062), Adler32.hash("a"));
103	testing.expectEqual(@as(u32, 0xbc002ed), Adler32.hash("example"));	103	try testing.expectEqual(@as(u32, 0xbc002ed), Adler32.hash("example"));
104	}	104	}
105		105
106	test "adler32 long" {	106	test "adler32 long" {
107	const long1 = [_]u8{1} ** 1024;	107	const long1 = [_]u8{1} ** 1024;
108	testing.expectEqual(@as(u32, 0x06780401), Adler32.hash(long1[0..]));	108	try testing.expectEqual(@as(u32, 0x06780401), Adler32.hash(long1[0..]));
109		109
110	const long2 = [_]u8{1} ** 1025;	110	const long2 = [_]u8{1} ** 1025;
111	testing.expectEqual(@as(u32, 0x0a7a0402), Adler32.hash(long2[0..]));	111	try testing.expectEqual(@as(u32, 0x0a7a0402), Adler32.hash(long2[0..]));
112	}	112	}
113		113
114	test "adler32 very long" {	114	test "adler32 very long" {
115	const long = [_]u8{1} ** 5553;	115	const long = [_]u8{1} ** 5553;
116	testing.expectEqual(@as(u32, 0x707f15b2), Adler32.hash(long[0..]));	116	try testing.expectEqual(@as(u32, 0x707f15b2), Adler32.hash(long[0..]));
117	}	117	}
118		118
119	test "adler32 very long with variation" {	119	test "adler32 very long with variation" {
...	@@ -129,5 +129,5 @@ test "adler32 very long with variation" {	...	@@ -129,5 +129,5 @@ test "adler32 very long with variation" {
129	break :blk result;	129	break :blk result;
130	};	130	};
131		131
132	testing.expectEqual(@as(u32, 0x5af38d6e), std.hash.Adler32.hash(long[0..]));	132	try testing.expectEqual(@as(u32, 0x5af38d6e), std.hash.Adler32.hash(long[0..]));
133	}	133	}