From 59f9253d94331cedd4d0518250c8094a064f6cd2 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Tue, 4 May 2021 19:36:59 +0300 Subject: [PATCH 1/8] allow tests to fail --- lib/std/special/test_runner.zig | 15 +++-- lib/std/testing.zig | 108 +++++++++++++++++++------------- 2 files changed, 72 insertions(+), 51 deletions(-) diff --git a/lib/std/special/test_runner.zig b/lib/std/special/test_runner.zig index f5a93298b5..3c66c64b4b 100644 --- a/lib/std/special/test_runner.zig +++ b/lib/std/special/test_runner.zig @@ -23,6 +23,7 @@ pub fn main() anyerror!void { const test_fn_list = builtin.test_functions; var ok_count: usize = 0; var skip_count: usize = 0; + var fail_count: usize = 0; var progress = std.Progress{}; const root_node = progress.start("Test", test_fn_list.len) catch |err| switch (err) { // TODO still run tests in this case @@ -62,7 +63,7 @@ pub fn main() anyerror!void { .blocking => { skip_count += 1; test_node.end(); - progress.log("{s}...SKIP (async test)\n", .{test_fn.name}); + progress.log("{s}... SKIP (async test)\n", .{test_fn.name}); if (progress.terminal == null) std.debug.print("SKIP (async test)\n", .{}); continue; }, @@ -75,12 +76,14 @@ pub fn main() anyerror!void { error.SkipZigTest => { skip_count += 1; test_node.end(); - progress.log("{s}...SKIP\n", .{test_fn.name}); + progress.log("{s}... SKIP\n", .{test_fn.name}); if (progress.terminal == null) std.debug.print("SKIP\n", .{}); }, else => { - progress.log("", .{}); - return err; + fail_count += 1; + test_node.end(); + progress.log("{s}... FAIL ({s})\n", .{ test_fn.name, @errorName(err) }); + if (progress.terminal == null) std.debug.print("FAIL ({s})\n", .{@errorName(err)}); }, } } @@ -88,7 +91,7 @@ pub fn main() anyerror!void { if (ok_count == test_fn_list.len) { std.debug.print("All {d} tests passed.\n", .{ok_count}); } else { - std.debug.print("{d} passed; {d} skipped.\n", .{ ok_count, skip_count }); + std.debug.print("{d} passed; {d} skipped; {d} failed.\n", .{ ok_count, skip_count, fail_count }); } if (log_err_count != 0) { std.debug.print("{d} errors were logged.\n", .{log_err_count}); @@ -96,7 +99,7 @@ pub fn main() anyerror!void { if (leaks != 0) { std.debug.print("{d} tests leaked memory.\n", .{leaks}); } - if (leaks != 0 or log_err_count != 0) { + if (leaks != 0 or log_err_count != 0 or fail_count != 0) { std.process.exit(1); } } diff --git a/lib/std/testing.zig b/lib/std/testing.zig index ac1aa3bf6d..22df9c9b66 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -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)) - std.debug.panic("actual {}, not within absolute tolerance {} of expected {}", .{ actual, tolerance, expected }), + .Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) { + 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); - expectApproxEqAbs(neg_x, neg_y, 0.1); + try expectApproxEqAbs(pos_x, pos_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)) - std.debug.panic("actual {}, not within relative tolerance {} of expected {}", .{ actual, tolerance, expected }), + .Float => if (!math.approxEqRel(T, expected, actual, tolerance)) { + 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); - expectApproxEqRel(neg_x, neg_y, sqrt_eps_value); + try expectApproxEqRel(pos_x, pos_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 { - if (!ok) @panic("test failure"); +pub fn expect(ok: bool) !void { + 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. From fd77f2cfed81f3414c079909e079a812e23071c3 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Tue, 4 May 2021 20:47:26 +0300 Subject: [PATCH 2/8] std: update usage of std.testing --- lib/std/SemanticVersion.zig | 26 +- lib/std/Thread/AutoResetEvent.zig | 16 +- lib/std/Thread/Mutex.zig | 4 +- lib/std/Thread/ResetEvent.zig | 20 +- lib/std/Thread/StaticResetEvent.zig | 20 +- lib/std/array_hash_map.zig | 136 ++-- lib/std/array_list.zig | 232 +++--- lib/std/ascii.zig | 46 +- lib/std/atomic/bool.zig | 8 +- lib/std/atomic/int.zig | 12 +- lib/std/atomic/queue.zig | 56 +- lib/std/atomic/stack.zig | 4 +- lib/std/base64.zig | 18 +- lib/std/bit_set.zig | 178 ++--- lib/std/buf_map.zig | 14 +- lib/std/buf_set.zig | 4 +- lib/std/build.zig | 22 +- lib/std/builtin.zig | 2 +- lib/std/c/tokenizer.zig | 16 +- lib/std/child_process.zig | 4 +- lib/std/compress/deflate.zig | 2 +- lib/std/compress/gzip.zig | 18 +- lib/std/compress/zlib.zig | 18 +- lib/std/comptime_string_map.zig | 42 +- lib/std/crypto.zig | 4 +- lib/std/crypto/25519/curve25519.zig | 12 +- lib/std/crypto/25519/ed25519.zig | 12 +- lib/std/crypto/25519/edwards25519.zig | 18 +- lib/std/crypto/25519/ristretto255.zig | 10 +- lib/std/crypto/25519/scalar.zig | 8 +- lib/std/crypto/25519/x25519.zig | 16 +- lib/std/crypto/aegis.zig | 40 +- lib/std/crypto/aes.zig | 18 +- lib/std/crypto/aes_gcm.zig | 16 +- lib/std/crypto/bcrypt.zig | 4 +- lib/std/crypto/blake2.zig | 164 ++-- lib/std/crypto/blake3.zig | 10 +- lib/std/crypto/chacha20.zig | 42 +- lib/std/crypto/ghash.zig | 4 +- lib/std/crypto/gimli.zig | 38 +- lib/std/crypto/hkdf.zig | 4 +- lib/std/crypto/hmac.zig | 12 +- lib/std/crypto/isap.zig | 6 +- lib/std/crypto/md5.zig | 20 +- lib/std/crypto/pbkdf2.zig | 12 +- lib/std/crypto/pcurves/tests.zig | 18 +- lib/std/crypto/poly1305.zig | 2 +- lib/std/crypto/salsa20.zig | 6 +- lib/std/crypto/sha1.zig | 12 +- lib/std/crypto/sha2.zig | 48 +- lib/std/crypto/sha3.zig | 60 +- lib/std/crypto/siphash.zig | 6 +- lib/std/crypto/test.zig | 8 +- lib/std/crypto/utils.zig | 22 +- lib/std/cstr.zig | 14 +- lib/std/dynamic_library.zig | 2 +- lib/std/elf.zig | 2 +- lib/std/enums.zig | 538 ++++++------- lib/std/event/batch.zig | 4 +- lib/std/event/channel.zig | 14 +- lib/std/event/future.zig | 2 +- lib/std/event/group.zig | 4 +- lib/std/event/lock.zig | 2 +- lib/std/event/loop.zig | 6 +- lib/std/event/rwlock.zig | 6 +- lib/std/fifo.zig | 76 +- lib/std/fmt.zig | 154 ++-- lib/std/fmt/parse_float.zig | 58 +- lib/std/fmt/parse_hex_float.zig | 26 +- lib/std/fs/path.zig | 402 +++++----- lib/std/fs/test.zig | 104 +-- lib/std/fs/wasi.zig | 6 +- lib/std/fs/watch.zig | 6 +- lib/std/hash/adler.zig | 12 +- lib/std/hash/auto_hash.zig | 92 +-- lib/std/hash/cityhash.zig | 14 +- lib/std/hash/crc.zig | 24 +- lib/std/hash/fnv.zig | 16 +- lib/std/hash/murmur.zig | 18 +- lib/std/hash/wyhash.zig | 22 +- lib/std/hash_map.zig | 144 ++-- lib/std/heap.zig | 86 +-- lib/std/heap/general_purpose_allocator.zig | 100 +-- lib/std/heap/logging_allocator.zig | 6 +- lib/std/io/bit_reader.zig | 76 +- lib/std/io/bit_writer.zig | 12 +- lib/std/io/buffered_reader.zig | 2 +- lib/std/io/counting_reader.zig | 4 +- lib/std/io/counting_writer.zig | 2 +- lib/std/io/fixed_buffer_stream.zig | 26 +- lib/std/io/limited_reader.zig | 8 +- lib/std/io/multi_writer.zig | 4 +- lib/std/io/peek_stream.zig | 22 +- lib/std/io/reader.zig | 14 +- lib/std/io/test.zig | 64 +- lib/std/json.zig | 274 +++---- lib/std/json/test.zig | 550 +++++++------- lib/std/json/write_stream.zig | 2 +- lib/std/leb128.zig | 136 ++-- lib/std/linked_list.zig | 40 +- lib/std/math.zig | 690 ++++++++--------- lib/std/math/acos.zig | 36 +- lib/std/math/acosh.zig | 28 +- lib/std/math/asin.zig | 44 +- lib/std/math/asinh.zig | 52 +- lib/std/math/atan.zig | 40 +- lib/std/math/atan2.zig | 104 +-- lib/std/math/atanh.zig | 36 +- lib/std/math/big/int_test.zig | 422 +++++------ lib/std/math/big/rational.zig | 134 ++-- lib/std/math/cbrt.zig | 48 +- lib/std/math/ceil.zig | 54 +- lib/std/math/complex.zig | 14 +- lib/std/math/complex/abs.zig | 2 +- lib/std/math/complex/acos.zig | 4 +- lib/std/math/complex/acosh.zig | 4 +- lib/std/math/complex/arg.zig | 2 +- lib/std/math/complex/asin.zig | 4 +- lib/std/math/complex/asinh.zig | 4 +- lib/std/math/complex/atan.zig | 8 +- lib/std/math/complex/atanh.zig | 4 +- lib/std/math/complex/conj.zig | 2 +- lib/std/math/complex/cos.zig | 4 +- lib/std/math/complex/cosh.zig | 8 +- lib/std/math/complex/exp.zig | 8 +- lib/std/math/complex/log.zig | 4 +- lib/std/math/complex/pow.zig | 4 +- lib/std/math/complex/proj.zig | 2 +- lib/std/math/complex/sin.zig | 4 +- lib/std/math/complex/sinh.zig | 8 +- lib/std/math/complex/sqrt.zig | 8 +- lib/std/math/complex/tan.zig | 4 +- lib/std/math/complex/tanh.zig | 8 +- lib/std/math/copysign.zig | 40 +- lib/std/math/cos.zig | 44 +- lib/std/math/cosh.zig | 56 +- lib/std/math/exp.zig | 32 +- lib/std/math/exp2.zig | 30 +- lib/std/math/expm1.zig | 36 +- lib/std/math/fabs.zig | 48 +- lib/std/math/floor.zig | 72 +- lib/std/math/fma.zig | 32 +- lib/std/math/frexp.zig | 32 +- lib/std/math/hypot.zig | 56 +- lib/std/math/ilogb.zig | 44 +- lib/std/math/isfinite.zig | 48 +- lib/std/math/isinf.zig | 96 +-- lib/std/math/isnan.zig | 16 +- lib/std/math/isnormal.zig | 18 +- lib/std/math/ln.zig | 44 +- lib/std/math/log.zig | 24 +- lib/std/math/log10.zig | 44 +- lib/std/math/log1p.zig | 56 +- lib/std/math/log2.zig | 40 +- lib/std/math/modf.zig | 56 +- lib/std/math/pow.zig | 104 +-- lib/std/math/powi.zig | 132 ++-- lib/std/math/round.zig | 60 +- lib/std/math/scalbn.zig | 8 +- lib/std/math/signbit.zig | 24 +- lib/std/math/sin.zig | 54 +- lib/std/math/sinh.zig | 56 +- lib/std/math/sqrt.zig | 16 +- lib/std/math/tan.zig | 48 +- lib/std/math/tanh.zig | 44 +- lib/std/math/trunc.zig | 54 +- lib/std/mem.zig | 712 +++++++++--------- lib/std/meta.zig | 380 +++++----- lib/std/meta/trailer_flags.zig | 14 +- lib/std/meta/trait.zig | 282 +++---- lib/std/multi_array_list.zig | 114 +-- lib/std/net/test.zig | 48 +- lib/std/once.zig | 2 +- lib/std/os/linux/bpf.zig | 190 ++--- lib/std/os/linux/bpf/btf.zig | 2 +- lib/std/os/linux/io_uring.zig | 204 ++--- lib/std/os/linux/test.zig | 34 +- lib/std/os/test.zig | 102 +-- lib/std/os/windows.zig | 6 +- lib/std/packed_int_array.zig | 98 +-- lib/std/priority_dequeue.zig | 178 ++--- lib/std/priority_queue.zig | 140 ++-- lib/std/process.zig | 30 +- lib/std/rand.zig | 192 ++--- lib/std/rand/Isaac64.zig | 4 +- lib/std/rand/Pcg.zig | 4 +- lib/std/rand/Sfc64.zig | 4 +- lib/std/rand/Xoroshiro128.zig | 6 +- lib/std/sort.zig | 130 ++-- lib/std/special/c.zig | 54 +- .../special/compiler_rt/comparedf2_test.zig | 2 +- .../special/compiler_rt/comparesf2_test.zig | 2 +- lib/std/special/compiler_rt/divdf3_test.zig | 2 +- lib/std/special/compiler_rt/divsf3_test.zig | 2 +- lib/std/special/compiler_rt/divtf3_test.zig | 2 +- lib/std/special/compiler_rt/divti3_test.zig | 2 +- lib/std/special/compiler_rt/emutls.zig | 22 +- lib/std/special/compiler_rt/fixdfdi_test.zig | 2 +- lib/std/special/compiler_rt/fixdfsi_test.zig | 2 +- lib/std/special/compiler_rt/fixdfti_test.zig | 2 +- lib/std/special/compiler_rt/fixint_test.zig | 2 +- lib/std/special/compiler_rt/fixsfdi_test.zig | 2 +- lib/std/special/compiler_rt/fixsfsi_test.zig | 2 +- lib/std/special/compiler_rt/fixsfti_test.zig | 2 +- lib/std/special/compiler_rt/fixtfdi_test.zig | 2 +- lib/std/special/compiler_rt/fixtfsi_test.zig | 2 +- lib/std/special/compiler_rt/fixtfti_test.zig | 2 +- .../special/compiler_rt/fixunsdfdi_test.zig | 2 +- .../special/compiler_rt/fixunsdfsi_test.zig | 2 +- .../special/compiler_rt/fixunsdfti_test.zig | 2 +- .../special/compiler_rt/fixunssfdi_test.zig | 2 +- .../special/compiler_rt/fixunssfsi_test.zig | 2 +- .../special/compiler_rt/fixunssfti_test.zig | 2 +- .../special/compiler_rt/fixunstfdi_test.zig | 2 +- .../special/compiler_rt/fixunstfsi_test.zig | 2 +- .../special/compiler_rt/fixunstfti_test.zig | 2 +- .../special/compiler_rt/floatdidf_test.zig | 2 +- .../special/compiler_rt/floatdisf_test.zig | 2 +- .../special/compiler_rt/floatditf_test.zig | 2 +- lib/std/special/compiler_rt/floatsiXf.zig | 6 +- .../special/compiler_rt/floattidf_test.zig | 2 +- .../special/compiler_rt/floattisf_test.zig | 2 +- .../special/compiler_rt/floattitf_test.zig | 2 +- .../special/compiler_rt/floatundidf_test.zig | 2 +- lib/std/special/compiler_rt/floatunsidf.zig | 2 +- lib/std/special/compiler_rt/floatunsisf.zig | 2 +- .../special/compiler_rt/floatuntidf_test.zig | 2 +- .../special/compiler_rt/floatuntisf_test.zig | 2 +- .../special/compiler_rt/floatuntitf_test.zig | 2 +- lib/std/special/compiler_rt/int.zig | 16 +- lib/std/special/compiler_rt/modti3_test.zig | 2 +- lib/std/special/compiler_rt/muldi3_test.zig | 2 +- lib/std/special/compiler_rt/mulodi4_test.zig | 2 +- lib/std/special/compiler_rt/muloti4_test.zig | 2 +- lib/std/special/compiler_rt/multi3_test.zig | 2 +- .../special/compiler_rt/popcountdi2_test.zig | 2 +- .../special/compiler_rt/udivmoddi4_test.zig | 4 +- .../special/compiler_rt/udivmodti4_test.zig | 4 +- lib/std/special/init-lib/src/main.zig | 2 +- lib/std/time.zig | 8 +- lib/std/unicode.zig | 342 ++++----- lib/std/valgrind/memcheck.zig | 4 +- lib/std/wasm.zig | 18 +- lib/std/x/net/tcp.zig | 6 +- lib/std/x/os/net.zig | 6 +- lib/std/zig.zig | 38 +- lib/std/zig/cross_target.zig | 76 +- lib/std/zig/parser_test.zig | 19 +- lib/std/zig/string_literal.zig | 6 +- lib/std/zig/system/linux.zig | 4 +- lib/std/zig/system/macos.zig | 2 +- lib/std/zig/tokenizer.zig | 562 +++++++------- 252 files changed, 6144 insertions(+), 6145 deletions(-) diff --git a/lib/std/SemanticVersion.zig b/lib/std/SemanticVersion.zig index 52c3ae59df..8e748184a8 100644 --- a/lib/std/SemanticVersion.zig +++ b/lib/std/SemanticVersion.zig @@ -249,13 +249,13 @@ test "SemanticVersion format" { "+justmeta", "9.8.7+meta+meta", "9.8.7-whatever+meta+meta", - }) |invalid| expectError(error.InvalidVersion, parse(invalid)); + }) |invalid| try expectError(error.InvalidVersion, parse(invalid)); // Valid version string that may overflow. const big_valid = "99999999999999999999999.999999999999999999.99999999999999999"; if (parse(big_valid)) |ver| { try std.testing.expectFmt(big_valid, "{}", .{ver}); - } else |err| expect(err == error.Overflow); + } else |err| try expect(err == error.Overflow); // Invalid version string that may overflow. const big_invalid = "99999999999999999999999.999999999999999999.99999999999999999----RC-SNAPSHOT.12.09.1--------------------------------..12"; @@ -264,22 +264,22 @@ test "SemanticVersion format" { test "SemanticVersion precedence" { // SemVer 2 spec 11.2 example: 1.0.0 < 2.0.0 < 2.1.0 < 2.1.1. - expect(order(try parse("1.0.0"), try parse("2.0.0")) == .lt); - expect(order(try parse("2.0.0"), try parse("2.1.0")) == .lt); - expect(order(try parse("2.1.0"), try parse("2.1.1")) == .lt); + try expect(order(try parse("1.0.0"), try parse("2.0.0")) == .lt); + try expect(order(try parse("2.0.0"), try parse("2.1.0")) == .lt); + try expect(order(try parse("2.1.0"), try parse("2.1.1")) == .lt); // SemVer 2 spec 11.3 example: 1.0.0-alpha < 1.0.0. - expect(order(try parse("1.0.0-alpha"), try parse("1.0.0")) == .lt); + try expect(order(try parse("1.0.0-alpha"), try parse("1.0.0")) == .lt); // SemVer 2 spec 11.4 example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < // 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0. - expect(order(try parse("1.0.0-alpha"), try parse("1.0.0-alpha.1")) == .lt); - expect(order(try parse("1.0.0-alpha.1"), try parse("1.0.0-alpha.beta")) == .lt); - expect(order(try parse("1.0.0-alpha.beta"), try parse("1.0.0-beta")) == .lt); - expect(order(try parse("1.0.0-beta"), try parse("1.0.0-beta.2")) == .lt); - expect(order(try parse("1.0.0-beta.2"), try parse("1.0.0-beta.11")) == .lt); - expect(order(try parse("1.0.0-beta.11"), try parse("1.0.0-rc.1")) == .lt); - expect(order(try parse("1.0.0-rc.1"), try parse("1.0.0")) == .lt); + try expect(order(try parse("1.0.0-alpha"), try parse("1.0.0-alpha.1")) == .lt); + try expect(order(try parse("1.0.0-alpha.1"), try parse("1.0.0-alpha.beta")) == .lt); + try expect(order(try parse("1.0.0-alpha.beta"), try parse("1.0.0-beta")) == .lt); + try expect(order(try parse("1.0.0-beta"), try parse("1.0.0-beta.2")) == .lt); + try expect(order(try parse("1.0.0-beta.2"), try parse("1.0.0-beta.11")) == .lt); + try expect(order(try parse("1.0.0-beta.11"), try parse("1.0.0-rc.1")) == .lt); + try expect(order(try parse("1.0.0-rc.1"), try parse("1.0.0")) == .lt); } test "zig_version" { diff --git a/lib/std/Thread/AutoResetEvent.zig b/lib/std/Thread/AutoResetEvent.zig index 0726dc794a..63da2c9a30 100644 --- a/lib/std/Thread/AutoResetEvent.zig +++ b/lib/std/Thread/AutoResetEvent.zig @@ -176,7 +176,7 @@ test "basic usage" { // test local code paths { var event = AutoResetEvent{}; - testing.expectError(error.TimedOut, event.timedWait(1)); + try testing.expectError(error.TimedOut, event.timedWait(1)); event.set(); event.wait(); } @@ -192,28 +192,28 @@ test "basic usage" { const Self = @This(); - fn sender(self: *Self) void { - testing.expect(self.value == 0); + fn sender(self: *Self) !void { + try testing.expect(self.value == 0); self.value = 1; self.out.set(); self.in.wait(); - testing.expect(self.value == 2); + try testing.expect(self.value == 2); self.value = 3; self.out.set(); self.in.wait(); - testing.expect(self.value == 4); + try testing.expect(self.value == 4); } - fn receiver(self: *Self) void { + fn receiver(self: *Self) !void { self.out.wait(); - testing.expect(self.value == 1); + try testing.expect(self.value == 1); self.value = 2; self.in.set(); self.out.wait(); - testing.expect(self.value == 3); + try testing.expect(self.value == 3); self.value = 4; self.in.set(); } diff --git a/lib/std/Thread/Mutex.zig b/lib/std/Thread/Mutex.zig index e7d11954bf..cae4e282de 100644 --- a/lib/std/Thread/Mutex.zig +++ b/lib/std/Thread/Mutex.zig @@ -294,7 +294,7 @@ test "basic usage" { if (builtin.single_threaded) { worker(&context); - testing.expect(context.data == TestContext.incr_count); + try testing.expect(context.data == TestContext.incr_count); } else { const thread_count = 10; var threads: [thread_count]*std.Thread = undefined; @@ -304,7 +304,7 @@ test "basic usage" { for (threads) |t| t.wait(); - testing.expect(context.data == thread_count * TestContext.incr_count); + try testing.expect(context.data == thread_count * TestContext.incr_count); } } diff --git a/lib/std/Thread/ResetEvent.zig b/lib/std/Thread/ResetEvent.zig index 439fb0db40..f161b46aa0 100644 --- a/lib/std/Thread/ResetEvent.zig +++ b/lib/std/Thread/ResetEvent.zig @@ -204,7 +204,7 @@ test "basic usage" { event.reset(); event.set(); - testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1)); + try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1)); // test cross-thread signaling if (builtin.single_threaded) @@ -233,25 +233,25 @@ test "basic usage" { self.* = undefined; } - fn sender(self: *Self) void { + fn sender(self: *Self) !void { // update value and signal input - testing.expect(self.value == 0); + try testing.expect(self.value == 0); self.value = 1; self.in.set(); // wait for receiver to update value and signal output self.out.wait(); - testing.expect(self.value == 2); + try testing.expect(self.value == 2); // update value and signal final input self.value = 3; self.in.set(); } - fn receiver(self: *Self) void { + fn receiver(self: *Self) !void { // wait for sender to update value and signal input self.in.wait(); - assert(self.value == 1); + try testing.expect(self.value == 1); // update value and signal output self.in.reset(); @@ -260,7 +260,7 @@ test "basic usage" { // wait for sender to update value and signal final input self.in.wait(); - assert(self.value == 3); + try testing.expect(self.value == 3); } fn sleeper(self: *Self) void { @@ -272,9 +272,9 @@ test "basic usage" { fn timedWaiter(self: *Self) !void { self.in.wait(); - testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us)); + try testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us)); try self.out.timedWait(time.ns_per_ms * 100); - testing.expect(self.value == 5); + try testing.expect(self.value == 5); } }; @@ -283,7 +283,7 @@ test "basic usage" { defer context.deinit(); const receiver = try std.Thread.spawn(Context.receiver, &context); defer receiver.wait(); - context.sender(); + try context.sender(); if (false) { // I have now observed this fail on macOS, Windows, and Linux. diff --git a/lib/std/Thread/StaticResetEvent.zig b/lib/std/Thread/StaticResetEvent.zig index 07a8e50c16..96a5a765a2 100644 --- a/lib/std/Thread/StaticResetEvent.zig +++ b/lib/std/Thread/StaticResetEvent.zig @@ -320,7 +320,7 @@ test "basic usage" { event.reset(); event.set(); - testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1)); + try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1)); // test cross-thread signaling if (std.builtin.single_threaded) @@ -333,25 +333,25 @@ test "basic usage" { in: StaticResetEvent = .{}, out: StaticResetEvent = .{}, - fn sender(self: *Self) void { + fn sender(self: *Self) !void { // update value and signal input - testing.expect(self.value == 0); + try testing.expect(self.value == 0); self.value = 1; self.in.set(); // wait for receiver to update value and signal output self.out.wait(); - testing.expect(self.value == 2); + try testing.expect(self.value == 2); // update value and signal final input self.value = 3; self.in.set(); } - fn receiver(self: *Self) void { + fn receiver(self: *Self) !void { // wait for sender to update value and signal input self.in.wait(); - assert(self.value == 1); + try testing.expect(self.value == 1); // update value and signal output self.in.reset(); @@ -360,7 +360,7 @@ test "basic usage" { // wait for sender to update value and signal final input self.in.wait(); - assert(self.value == 3); + try testing.expect(self.value == 3); } fn sleeper(self: *Self) void { @@ -372,16 +372,16 @@ test "basic usage" { fn timedWaiter(self: *Self) !void { self.in.wait(); - testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us)); + try testing.expectEqual(TimedWaitResult.timed_out, self.out.timedWait(time.ns_per_us)); try self.out.timedWait(time.ns_per_ms * 100); - testing.expect(self.value == 5); + try testing.expect(self.value == 5); } }; var context = Context{}; const receiver = try std.Thread.spawn(Context.receiver, &context); defer receiver.wait(); - context.sender(); + try context.sender(); if (false) { // I have now observed this fail on macOS, Windows, and Linux. diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig index 83a061dfef..25a1aead52 100644 --- a/lib/std/array_hash_map.zig +++ b/lib/std/array_hash_map.zig @@ -1064,63 +1064,63 @@ test "basic hash map usage" { var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator); defer map.deinit(); - testing.expect((try map.fetchPut(1, 11)) == null); - testing.expect((try map.fetchPut(2, 22)) == null); - testing.expect((try map.fetchPut(3, 33)) == null); - testing.expect((try map.fetchPut(4, 44)) == null); + try testing.expect((try map.fetchPut(1, 11)) == null); + try testing.expect((try map.fetchPut(2, 22)) == null); + try testing.expect((try map.fetchPut(3, 33)) == null); + try testing.expect((try map.fetchPut(4, 44)) == null); try map.putNoClobber(5, 55); - testing.expect((try map.fetchPut(5, 66)).?.value == 55); - testing.expect((try map.fetchPut(5, 55)).?.value == 66); + try testing.expect((try map.fetchPut(5, 66)).?.value == 55); + try testing.expect((try map.fetchPut(5, 55)).?.value == 66); const gop1 = try map.getOrPut(5); - testing.expect(gop1.found_existing == true); - testing.expect(gop1.entry.value == 55); - testing.expect(gop1.index == 4); + try testing.expect(gop1.found_existing == true); + try testing.expect(gop1.entry.value == 55); + try testing.expect(gop1.index == 4); gop1.entry.value = 77; - testing.expect(map.getEntry(5).?.value == 77); + try testing.expect(map.getEntry(5).?.value == 77); const gop2 = try map.getOrPut(99); - testing.expect(gop2.found_existing == false); - testing.expect(gop2.index == 5); + try testing.expect(gop2.found_existing == false); + try testing.expect(gop2.index == 5); gop2.entry.value = 42; - testing.expect(map.getEntry(99).?.value == 42); + try testing.expect(map.getEntry(99).?.value == 42); const gop3 = try map.getOrPutValue(5, 5); - testing.expect(gop3.value == 77); + try testing.expect(gop3.value == 77); const gop4 = try map.getOrPutValue(100, 41); - testing.expect(gop4.value == 41); + try testing.expect(gop4.value == 41); - testing.expect(map.contains(2)); - testing.expect(map.getEntry(2).?.value == 22); - testing.expect(map.get(2).? == 22); + try testing.expect(map.contains(2)); + try testing.expect(map.getEntry(2).?.value == 22); + try testing.expect(map.get(2).? == 22); const rmv1 = map.swapRemove(2); - testing.expect(rmv1.?.key == 2); - testing.expect(rmv1.?.value == 22); - testing.expect(map.swapRemove(2) == null); - testing.expect(map.getEntry(2) == null); - testing.expect(map.get(2) == null); + try testing.expect(rmv1.?.key == 2); + try testing.expect(rmv1.?.value == 22); + try testing.expect(map.swapRemove(2) == null); + try testing.expect(map.getEntry(2) == null); + try testing.expect(map.get(2) == null); // Since we've used `swapRemove` above, the index of this entry should remain unchanged. - testing.expect(map.getIndex(100).? == 1); + try testing.expect(map.getIndex(100).? == 1); const gop5 = try map.getOrPut(5); - testing.expect(gop5.found_existing == true); - testing.expect(gop5.entry.value == 77); - testing.expect(gop5.index == 4); + try testing.expect(gop5.found_existing == true); + try testing.expect(gop5.entry.value == 77); + try testing.expect(gop5.index == 4); // Whereas, if we do an `orderedRemove`, it should move the index forward one spot. const rmv2 = map.orderedRemove(100); - testing.expect(rmv2.?.key == 100); - testing.expect(rmv2.?.value == 41); - testing.expect(map.orderedRemove(100) == null); - testing.expect(map.getEntry(100) == null); - testing.expect(map.get(100) == null); + try testing.expect(rmv2.?.key == 100); + try testing.expect(rmv2.?.value == 41); + try testing.expect(map.orderedRemove(100) == null); + try testing.expect(map.getEntry(100) == null); + try testing.expect(map.get(100) == null); const gop6 = try map.getOrPut(5); - testing.expect(gop6.found_existing == true); - testing.expect(gop6.entry.value == 77); - testing.expect(gop6.index == 3); + try testing.expect(gop6.found_existing == true); + try testing.expect(gop6.entry.value == 77); + try testing.expect(gop6.index == 3); map.removeAssertDiscard(3); } @@ -1156,11 +1156,11 @@ test "iterator hash map" { while (it.next()) |entry| : (count += 1) { buffer[@intCast(usize, entry.key)] = entry.value; } - testing.expect(count == 3); - testing.expect(it.next() == null); + try testing.expect(count == 3); + try testing.expect(it.next() == null); for (buffer) |v, i| { - testing.expect(buffer[@intCast(usize, keys[i])] == values[i]); + try testing.expect(buffer[@intCast(usize, keys[i])] == values[i]); } it.reset(); @@ -1172,13 +1172,13 @@ test "iterator hash map" { } for (buffer[0..2]) |v, i| { - testing.expect(buffer[@intCast(usize, keys[i])] == values[i]); + try testing.expect(buffer[@intCast(usize, keys[i])] == values[i]); } it.reset(); var entry = it.next().?; - testing.expect(entry.key == first_entry.key); - testing.expect(entry.value == first_entry.value); + try testing.expect(entry.key == first_entry.key); + try testing.expect(entry.value == first_entry.value); } test "ensure capacity" { @@ -1187,13 +1187,13 @@ test "ensure capacity" { try map.ensureCapacity(20); const initial_capacity = map.capacity(); - testing.expect(initial_capacity >= 20); + try testing.expect(initial_capacity >= 20); var i: i32 = 0; while (i < 20) : (i += 1) { - testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null); + try testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null); } // shouldn't resize from putAssumeCapacity - testing.expect(initial_capacity == map.capacity()); + try testing.expect(initial_capacity == map.capacity()); } test "clone" { @@ -1211,7 +1211,7 @@ test "clone" { i = 0; while (i < 10) : (i += 1) { - testing.expect(copy.get(i).? == i * 10); + try testing.expect(copy.get(i).? == i * 10); } } @@ -1223,35 +1223,35 @@ test "shrink" { const num_entries = 20; var i: i32 = 0; while (i < num_entries) : (i += 1) - testing.expect((try map.fetchPut(i, i * 10)) == null); + try testing.expect((try map.fetchPut(i, i * 10)) == null); - testing.expect(map.unmanaged.index_header != null); - testing.expect(map.count() == num_entries); + try testing.expect(map.unmanaged.index_header != null); + try testing.expect(map.count() == num_entries); // Test `shrinkRetainingCapacity`. map.shrinkRetainingCapacity(17); - testing.expect(map.count() == 17); - testing.expect(map.capacity() == 20); + try testing.expect(map.count() == 17); + try testing.expect(map.capacity() == 20); i = 0; while (i < num_entries) : (i += 1) { const gop = try map.getOrPut(i); if (i < 17) { - testing.expect(gop.found_existing == true); - testing.expect(gop.entry.value == i * 10); - } else testing.expect(gop.found_existing == false); + try testing.expect(gop.found_existing == true); + try testing.expect(gop.entry.value == i * 10); + } else try testing.expect(gop.found_existing == false); } // Test `shrinkAndFree`. map.shrinkAndFree(15); - testing.expect(map.count() == 15); - testing.expect(map.capacity() == 15); + try testing.expect(map.count() == 15); + try testing.expect(map.capacity() == 15); i = 0; while (i < num_entries) : (i += 1) { const gop = try map.getOrPut(i); if (i < 15) { - testing.expect(gop.found_existing == true); - testing.expect(gop.entry.value == i * 10); - } else testing.expect(gop.found_existing == false); + try testing.expect(gop.found_existing == true); + try testing.expect(gop.entry.value == i * 10); + } else try testing.expect(gop.found_existing == false); } } @@ -1264,12 +1264,12 @@ test "pop" { var i: i32 = 0; while (i < 9) : (i += 1) { - testing.expect((try map.fetchPut(i, i)) == null); + try testing.expect((try map.fetchPut(i, i)) == null); } while (i > 0) : (i -= 1) { const pop = map.pop(); - testing.expect(pop.key == i - 1 and pop.value == i - 1); + try testing.expect(pop.key == i - 1 and pop.value == i - 1); } } @@ -1281,10 +1281,10 @@ test "reIndex" { const num_indexed_entries = 20; var i: i32 = 0; while (i < num_indexed_entries) : (i += 1) - testing.expect((try map.fetchPut(i, i * 10)) == null); + try testing.expect((try map.fetchPut(i, i * 10)) == null); // Make sure we allocated an index header. - testing.expect(map.unmanaged.index_header != null); + try testing.expect(map.unmanaged.index_header != null); // Now write to the underlying array list directly. const num_unindexed_entries = 20; @@ -1303,9 +1303,9 @@ test "reIndex" { i = 0; while (i < num_indexed_entries + num_unindexed_entries) : (i += 1) { const gop = try map.getOrPut(i); - testing.expect(gop.found_existing == true); - testing.expect(gop.entry.value == i * 10); - testing.expect(gop.index == i); + try testing.expect(gop.found_existing == true); + try testing.expect(gop.entry.value == i * 10); + try testing.expect(gop.index == i); } } @@ -1332,9 +1332,9 @@ test "fromOwnedArrayList" { i = 0; while (i < num_entries) : (i += 1) { const gop = try map.getOrPut(i); - testing.expect(gop.found_existing == true); - testing.expect(gop.entry.value == i * 10); - testing.expect(gop.index == i); + try testing.expect(gop.found_existing == true); + try testing.expect(gop.entry.value == i * 10); + try testing.expect(gop.index == i); } } diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig index 7825d36ac3..94e99247c5 100644 --- a/lib/std/array_list.zig +++ b/lib/std/array_list.zig @@ -695,15 +695,15 @@ test "std.ArrayList/ArrayListUnmanaged.init" { var list = ArrayList(i32).init(testing.allocator); defer list.deinit(); - testing.expect(list.items.len == 0); - testing.expect(list.capacity == 0); + try testing.expect(list.items.len == 0); + try testing.expect(list.capacity == 0); } { var list = ArrayListUnmanaged(i32){}; - testing.expect(list.items.len == 0); - testing.expect(list.capacity == 0); + try testing.expect(list.items.len == 0); + try testing.expect(list.capacity == 0); } } @@ -712,14 +712,14 @@ test "std.ArrayList/ArrayListUnmanaged.initCapacity" { { var list = try ArrayList(i8).initCapacity(a, 200); defer list.deinit(); - testing.expect(list.items.len == 0); - testing.expect(list.capacity >= 200); + try testing.expect(list.items.len == 0); + try testing.expect(list.capacity >= 200); } { var list = try ArrayListUnmanaged(i8).initCapacity(a, 200); defer list.deinit(a); - testing.expect(list.items.len == 0); - testing.expect(list.capacity >= 200); + try testing.expect(list.items.len == 0); + try testing.expect(list.capacity >= 200); } } @@ -739,33 +739,33 @@ test "std.ArrayList/ArrayListUnmanaged.basic" { { var i: usize = 0; while (i < 10) : (i += 1) { - testing.expect(list.items[i] == @intCast(i32, i + 1)); + try testing.expect(list.items[i] == @intCast(i32, i + 1)); } } for (list.items) |v, i| { - testing.expect(v == @intCast(i32, i + 1)); + try testing.expect(v == @intCast(i32, i + 1)); } - testing.expect(list.pop() == 10); - testing.expect(list.items.len == 9); + try testing.expect(list.pop() == 10); + try testing.expect(list.items.len == 9); list.appendSlice(&[_]i32{ 1, 2, 3 }) catch unreachable; - testing.expect(list.items.len == 12); - testing.expect(list.pop() == 3); - testing.expect(list.pop() == 2); - testing.expect(list.pop() == 1); - testing.expect(list.items.len == 9); + try testing.expect(list.items.len == 12); + try testing.expect(list.pop() == 3); + try testing.expect(list.pop() == 2); + try testing.expect(list.pop() == 1); + try testing.expect(list.items.len == 9); list.appendSlice(&[_]i32{}) catch unreachable; - testing.expect(list.items.len == 9); + try testing.expect(list.items.len == 9); // can only set on indices < self.items.len list.items[7] = 33; list.items[8] = 42; - testing.expect(list.pop() == 42); - testing.expect(list.pop() == 33); + try testing.expect(list.pop() == 42); + try testing.expect(list.pop() == 33); } { var list = ArrayListUnmanaged(i32){}; @@ -781,33 +781,33 @@ test "std.ArrayList/ArrayListUnmanaged.basic" { { var i: usize = 0; while (i < 10) : (i += 1) { - testing.expect(list.items[i] == @intCast(i32, i + 1)); + try testing.expect(list.items[i] == @intCast(i32, i + 1)); } } for (list.items) |v, i| { - testing.expect(v == @intCast(i32, i + 1)); + try testing.expect(v == @intCast(i32, i + 1)); } - testing.expect(list.pop() == 10); - testing.expect(list.items.len == 9); + try testing.expect(list.pop() == 10); + try testing.expect(list.items.len == 9); list.appendSlice(a, &[_]i32{ 1, 2, 3 }) catch unreachable; - testing.expect(list.items.len == 12); - testing.expect(list.pop() == 3); - testing.expect(list.pop() == 2); - testing.expect(list.pop() == 1); - testing.expect(list.items.len == 9); + try testing.expect(list.items.len == 12); + try testing.expect(list.pop() == 3); + try testing.expect(list.pop() == 2); + try testing.expect(list.pop() == 1); + try testing.expect(list.items.len == 9); list.appendSlice(a, &[_]i32{}) catch unreachable; - testing.expect(list.items.len == 9); + try testing.expect(list.items.len == 9); // can only set on indices < self.items.len list.items[7] = 33; list.items[8] = 42; - testing.expect(list.pop() == 42); - testing.expect(list.pop() == 33); + try testing.expect(list.pop() == 42); + try testing.expect(list.pop() == 33); } } @@ -818,9 +818,9 @@ test "std.ArrayList/ArrayListUnmanaged.appendNTimes" { defer list.deinit(); try list.appendNTimes(2, 10); - testing.expectEqual(@as(usize, 10), list.items.len); + try testing.expectEqual(@as(usize, 10), list.items.len); for (list.items) |element| { - testing.expectEqual(@as(i32, 2), element); + try testing.expectEqual(@as(i32, 2), element); } } { @@ -828,9 +828,9 @@ test "std.ArrayList/ArrayListUnmanaged.appendNTimes" { defer list.deinit(a); try list.appendNTimes(a, 2, 10); - testing.expectEqual(@as(usize, 10), list.items.len); + try testing.expectEqual(@as(usize, 10), list.items.len); for (list.items) |element| { - testing.expectEqual(@as(i32, 2), element); + try testing.expectEqual(@as(i32, 2), element); } } } @@ -840,12 +840,12 @@ test "std.ArrayList/ArrayListUnmanaged.appendNTimes with failing allocator" { { var list = ArrayList(i32).init(a); defer list.deinit(); - testing.expectError(error.OutOfMemory, list.appendNTimes(2, 10)); + try testing.expectError(error.OutOfMemory, list.appendNTimes(2, 10)); } { var list = ArrayListUnmanaged(i32){}; defer list.deinit(a); - testing.expectError(error.OutOfMemory, list.appendNTimes(a, 2, 10)); + try testing.expectError(error.OutOfMemory, list.appendNTimes(a, 2, 10)); } } @@ -864,18 +864,18 @@ test "std.ArrayList/ArrayListUnmanaged.orderedRemove" { try list.append(7); //remove from middle - testing.expectEqual(@as(i32, 4), list.orderedRemove(3)); - testing.expectEqual(@as(i32, 5), list.items[3]); - testing.expectEqual(@as(usize, 6), list.items.len); + try testing.expectEqual(@as(i32, 4), list.orderedRemove(3)); + try testing.expectEqual(@as(i32, 5), list.items[3]); + try testing.expectEqual(@as(usize, 6), list.items.len); //remove from end - testing.expectEqual(@as(i32, 7), list.orderedRemove(5)); - testing.expectEqual(@as(usize, 5), list.items.len); + try testing.expectEqual(@as(i32, 7), list.orderedRemove(5)); + try testing.expectEqual(@as(usize, 5), list.items.len); //remove from front - testing.expectEqual(@as(i32, 1), list.orderedRemove(0)); - testing.expectEqual(@as(i32, 2), list.items[0]); - testing.expectEqual(@as(usize, 4), list.items.len); + try testing.expectEqual(@as(i32, 1), list.orderedRemove(0)); + try testing.expectEqual(@as(i32, 2), list.items[0]); + try testing.expectEqual(@as(usize, 4), list.items.len); } { var list = ArrayListUnmanaged(i32){}; @@ -890,18 +890,18 @@ test "std.ArrayList/ArrayListUnmanaged.orderedRemove" { try list.append(a, 7); //remove from middle - testing.expectEqual(@as(i32, 4), list.orderedRemove(3)); - testing.expectEqual(@as(i32, 5), list.items[3]); - testing.expectEqual(@as(usize, 6), list.items.len); + try testing.expectEqual(@as(i32, 4), list.orderedRemove(3)); + try testing.expectEqual(@as(i32, 5), list.items[3]); + try testing.expectEqual(@as(usize, 6), list.items.len); //remove from end - testing.expectEqual(@as(i32, 7), list.orderedRemove(5)); - testing.expectEqual(@as(usize, 5), list.items.len); + try testing.expectEqual(@as(i32, 7), list.orderedRemove(5)); + try testing.expectEqual(@as(usize, 5), list.items.len); //remove from front - testing.expectEqual(@as(i32, 1), list.orderedRemove(0)); - testing.expectEqual(@as(i32, 2), list.items[0]); - testing.expectEqual(@as(usize, 4), list.items.len); + try testing.expectEqual(@as(i32, 1), list.orderedRemove(0)); + try testing.expectEqual(@as(i32, 2), list.items[0]); + try testing.expectEqual(@as(usize, 4), list.items.len); } } @@ -920,18 +920,18 @@ test "std.ArrayList/ArrayListUnmanaged.swapRemove" { try list.append(7); //remove from middle - testing.expect(list.swapRemove(3) == 4); - testing.expect(list.items[3] == 7); - testing.expect(list.items.len == 6); + try testing.expect(list.swapRemove(3) == 4); + try testing.expect(list.items[3] == 7); + try testing.expect(list.items.len == 6); //remove from end - testing.expect(list.swapRemove(5) == 6); - testing.expect(list.items.len == 5); + try testing.expect(list.swapRemove(5) == 6); + try testing.expect(list.items.len == 5); //remove from front - testing.expect(list.swapRemove(0) == 1); - testing.expect(list.items[0] == 5); - testing.expect(list.items.len == 4); + try testing.expect(list.swapRemove(0) == 1); + try testing.expect(list.items[0] == 5); + try testing.expect(list.items.len == 4); } { var list = ArrayListUnmanaged(i32){}; @@ -946,18 +946,18 @@ test "std.ArrayList/ArrayListUnmanaged.swapRemove" { try list.append(a, 7); //remove from middle - testing.expect(list.swapRemove(3) == 4); - testing.expect(list.items[3] == 7); - testing.expect(list.items.len == 6); + try testing.expect(list.swapRemove(3) == 4); + try testing.expect(list.items[3] == 7); + try testing.expect(list.items.len == 6); //remove from end - testing.expect(list.swapRemove(5) == 6); - testing.expect(list.items.len == 5); + try testing.expect(list.swapRemove(5) == 6); + try testing.expect(list.items.len == 5); //remove from front - testing.expect(list.swapRemove(0) == 1); - testing.expect(list.items[0] == 5); - testing.expect(list.items.len == 4); + try testing.expect(list.swapRemove(0) == 1); + try testing.expect(list.items[0] == 5); + try testing.expect(list.items.len == 4); } } @@ -971,10 +971,10 @@ test "std.ArrayList/ArrayListUnmanaged.insert" { try list.append(2); try list.append(3); try list.insert(0, 5); - testing.expect(list.items[0] == 5); - testing.expect(list.items[1] == 1); - testing.expect(list.items[2] == 2); - testing.expect(list.items[3] == 3); + try testing.expect(list.items[0] == 5); + try testing.expect(list.items[1] == 1); + try testing.expect(list.items[2] == 2); + try testing.expect(list.items[3] == 3); } { var list = ArrayListUnmanaged(i32){}; @@ -984,10 +984,10 @@ test "std.ArrayList/ArrayListUnmanaged.insert" { try list.append(a, 2); try list.append(a, 3); try list.insert(a, 0, 5); - testing.expect(list.items[0] == 5); - testing.expect(list.items[1] == 1); - testing.expect(list.items[2] == 2); - testing.expect(list.items[3] == 3); + try testing.expect(list.items[0] == 5); + try testing.expect(list.items[1] == 1); + try testing.expect(list.items[2] == 2); + try testing.expect(list.items[3] == 3); } } @@ -1002,17 +1002,17 @@ test "std.ArrayList/ArrayListUnmanaged.insertSlice" { try list.append(3); try list.append(4); try list.insertSlice(1, &[_]i32{ 9, 8 }); - testing.expect(list.items[0] == 1); - testing.expect(list.items[1] == 9); - testing.expect(list.items[2] == 8); - testing.expect(list.items[3] == 2); - testing.expect(list.items[4] == 3); - testing.expect(list.items[5] == 4); + try testing.expect(list.items[0] == 1); + try testing.expect(list.items[1] == 9); + try testing.expect(list.items[2] == 8); + try testing.expect(list.items[3] == 2); + try testing.expect(list.items[4] == 3); + try testing.expect(list.items[5] == 4); const items = [_]i32{1}; try list.insertSlice(0, items[0..0]); - testing.expect(list.items.len == 6); - testing.expect(list.items[0] == 1); + try testing.expect(list.items.len == 6); + try testing.expect(list.items[0] == 1); } { var list = ArrayListUnmanaged(i32){}; @@ -1023,17 +1023,17 @@ test "std.ArrayList/ArrayListUnmanaged.insertSlice" { try list.append(a, 3); try list.append(a, 4); try list.insertSlice(a, 1, &[_]i32{ 9, 8 }); - testing.expect(list.items[0] == 1); - testing.expect(list.items[1] == 9); - testing.expect(list.items[2] == 8); - testing.expect(list.items[3] == 2); - testing.expect(list.items[4] == 3); - testing.expect(list.items[5] == 4); + try testing.expect(list.items[0] == 1); + try testing.expect(list.items[1] == 9); + try testing.expect(list.items[2] == 8); + try testing.expect(list.items[3] == 2); + try testing.expect(list.items[4] == 3); + try testing.expect(list.items[5] == 4); const items = [_]i32{1}; try list.insertSlice(a, 0, items[0..0]); - testing.expect(list.items.len == 6); - testing.expect(list.items[0] == 1); + try testing.expect(list.items.len == 6); + try testing.expect(list.items[0] == 1); } } @@ -1066,13 +1066,13 @@ test "std.ArrayList/ArrayListUnmanaged.replaceRange" { try list_lt.replaceRange(1, 2, &new); // after_range > new_items.len in function body - testing.expect(1 + 4 > new.len); + try testing.expect(1 + 4 > new.len); try list_gt.replaceRange(1, 4, &new); - testing.expectEqualSlices(i32, list_zero.items, &result_zero); - testing.expectEqualSlices(i32, list_eq.items, &result_eq); - testing.expectEqualSlices(i32, list_lt.items, &result_le); - testing.expectEqualSlices(i32, list_gt.items, &result_gt); + try testing.expectEqualSlices(i32, list_zero.items, &result_zero); + try testing.expectEqualSlices(i32, list_eq.items, &result_eq); + try testing.expectEqualSlices(i32, list_lt.items, &result_le); + try testing.expectEqualSlices(i32, list_gt.items, &result_gt); } { var list_zero = ArrayListUnmanaged(i32){}; @@ -1090,13 +1090,13 @@ test "std.ArrayList/ArrayListUnmanaged.replaceRange" { try list_lt.replaceRange(a, 1, 2, &new); // after_range > new_items.len in function body - testing.expect(1 + 4 > new.len); + try testing.expect(1 + 4 > new.len); try list_gt.replaceRange(a, 1, 4, &new); - testing.expectEqualSlices(i32, list_zero.items, &result_zero); - testing.expectEqualSlices(i32, list_eq.items, &result_eq); - testing.expectEqualSlices(i32, list_lt.items, &result_le); - testing.expectEqualSlices(i32, list_gt.items, &result_gt); + try testing.expectEqualSlices(i32, list_zero.items, &result_zero); + try testing.expectEqualSlices(i32, list_eq.items, &result_eq); + try testing.expectEqualSlices(i32, list_lt.items, &result_le); + try testing.expectEqualSlices(i32, list_gt.items, &result_gt); } } @@ -1116,13 +1116,13 @@ test "std.ArrayList/ArrayListUnmanaged: ArrayList(T) of struct T" { var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(a) }; defer root.sub_items.deinit(); try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(a) }); - testing.expect(root.sub_items.items[0].integer == 42); + try testing.expect(root.sub_items.items[0].integer == 42); } { var root = ItemUnmanaged{ .integer = 1, .sub_items = ArrayListUnmanaged(ItemUnmanaged){} }; defer root.sub_items.deinit(a); try root.sub_items.append(a, ItemUnmanaged{ .integer = 42, .sub_items = ArrayListUnmanaged(ItemUnmanaged){} }); - testing.expect(root.sub_items.items[0].integer == 42); + try testing.expect(root.sub_items.items[0].integer == 42); } } @@ -1137,7 +1137,7 @@ test "std.ArrayList(u8)/ArrayListAligned implements writer" { const y: i32 = 1234; try buffer.writer().print("x: {}\ny: {}\n", .{ x, y }); - testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items); + try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items); } { var list = ArrayListAligned(u8, 2).init(a); @@ -1149,7 +1149,7 @@ test "std.ArrayList(u8)/ArrayListAligned implements writer" { try writer.writeAll("d"); try writer.writeAll("efg"); - testing.expectEqualSlices(u8, list.items, "abcdefg"); + try testing.expectEqualSlices(u8, list.items, "abcdefg"); } } @@ -1167,7 +1167,7 @@ test "std.ArrayList/ArrayListUnmanaged.shrink still sets length on error.OutOfMe try list.append(3); list.shrinkAndFree(1); - testing.expect(list.items.len == 1); + try testing.expect(list.items.len == 1); } { var list = ArrayListUnmanaged(i32){}; @@ -1177,7 +1177,7 @@ test "std.ArrayList/ArrayListUnmanaged.shrink still sets length on error.OutOfMe try list.append(a, 3); list.shrinkAndFree(a, 1); - testing.expect(list.items.len == 1); + try testing.expect(list.items.len == 1); } } @@ -1191,7 +1191,7 @@ test "std.ArrayList/ArrayListUnmanaged.addManyAsArray" { try list.ensureCapacity(8); list.addManyAsArrayAssumeCapacity(4).* = "asdf".*; - testing.expectEqualSlices(u8, list.items, "aoeuasdf"); + try testing.expectEqualSlices(u8, list.items, "aoeuasdf"); } { var list = ArrayListUnmanaged(u8){}; @@ -1201,7 +1201,7 @@ test "std.ArrayList/ArrayListUnmanaged.addManyAsArray" { try list.ensureCapacity(a, 8); list.addManyAsArrayAssumeCapacity(4).* = "asdf".*; - testing.expectEqualSlices(u8, list.items, "aoeuasdf"); + try testing.expectEqualSlices(u8, list.items, "aoeuasdf"); } } @@ -1215,7 +1215,7 @@ test "std.ArrayList/ArrayListUnmanaged.toOwnedSliceSentinel" { const result = try list.toOwnedSliceSentinel(0); defer a.free(result); - testing.expectEqualStrings(result, mem.spanZ(result.ptr)); + try testing.expectEqualStrings(result, mem.spanZ(result.ptr)); } { var list = ArrayListUnmanaged(u8){}; @@ -1225,7 +1225,7 @@ test "std.ArrayList/ArrayListUnmanaged.toOwnedSliceSentinel" { const result = try list.toOwnedSliceSentinel(a, 0); defer a.free(result); - testing.expectEqualStrings(result, mem.spanZ(result.ptr)); + try testing.expectEqualStrings(result, mem.spanZ(result.ptr)); } } @@ -1239,7 +1239,7 @@ test "ArrayListAligned/ArrayListAlignedUnmanaged accepts unaligned slices" { try list.insertSlice(2, &.{ 4, 5, 6, 7 }); try list.replaceRange(1, 3, &.{ 8, 9 }); - testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 }); + try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 }); } { var list = std.ArrayListAlignedUnmanaged(u8, 8){}; @@ -1249,6 +1249,6 @@ test "ArrayListAligned/ArrayListAlignedUnmanaged accepts unaligned slices" { try list.insertSlice(a, 2, &.{ 4, 5, 6, 7 }); try list.replaceRange(a, 1, 3, &.{ 8, 9 }); - testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 }); + try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 }); } } diff --git a/lib/std/ascii.zig b/lib/std/ascii.zig index 09ab1094fa..ea7b61aa9e 100644 --- a/lib/std/ascii.zig +++ b/lib/std/ascii.zig @@ -236,11 +236,11 @@ pub const spaces = [_]u8{ ' ', '\t', '\n', '\r', control_code.VT, control_code.F test "spaces" { const testing = std.testing; - for (spaces) |space| testing.expect(isSpace(space)); + for (spaces) |space| try testing.expect(isSpace(space)); var i: u8 = 0; while (isASCII(i)) : (i += 1) { - if (isSpace(i)) testing.expect(std.mem.indexOfScalar(u8, &spaces, i) != null); + if (isSpace(i)) try testing.expect(std.mem.indexOfScalar(u8, &spaces, i) != null); } } @@ -279,13 +279,13 @@ pub fn toLower(c: u8) u8 { test "ascii character classes" { const testing = std.testing; - testing.expect('C' == toUpper('c')); - testing.expect(':' == toUpper(':')); - testing.expect('\xab' == toUpper('\xab')); - testing.expect('c' == toLower('C')); - testing.expect(isAlpha('c')); - testing.expect(!isAlpha('5')); - testing.expect(isSpace(' ')); + try testing.expect('C' == toUpper('c')); + try testing.expect(':' == toUpper(':')); + try testing.expect('\xab' == toUpper('\xab')); + try testing.expect('c' == toLower('C')); + try testing.expect(isAlpha('c')); + try testing.expect(!isAlpha('5')); + try testing.expect(isSpace(' ')); } /// Allocates a lower case copy of `ascii_string`. @@ -301,7 +301,7 @@ pub fn allocLowerString(allocator: *std.mem.Allocator, ascii_string: []const u8) test "allocLowerString" { const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+πŸ’©!"); defer std.testing.allocator.free(result); - std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+πŸ’©!", result)); + try std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+πŸ’©!", result)); } /// Allocates an upper case copy of `ascii_string`. @@ -317,7 +317,7 @@ pub fn allocUpperString(allocator: *std.mem.Allocator, ascii_string: []const u8) test "allocUpperString" { const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+πŸ’©!"); defer std.testing.allocator.free(result); - std.testing.expect(std.mem.eql(u8, "ABCDEFGHIJKLMNOPQRST0234+πŸ’©!", result)); + try std.testing.expect(std.mem.eql(u8, "ABCDEFGHIJKLMNOPQRST0234+πŸ’©!", result)); } /// 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 { } test "eqlIgnoreCase" { - std.testing.expect(eqlIgnoreCase("HElπŸ’©Lo!", "helπŸ’©lo!")); - std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! ")); - std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!")); + try std.testing.expect(eqlIgnoreCase("HElπŸ’©Lo!", "helπŸ’©lo!")); + try std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! ")); + try std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!")); } pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool { @@ -340,8 +340,8 @@ pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool { } test "ascii.startsWithIgnoreCase" { - std.testing.expect(startsWithIgnoreCase("boB", "Bo")); - std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack")); + try std.testing.expect(startsWithIgnoreCase("boB", "Bo")); + try std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack")); } pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool { @@ -349,8 +349,8 @@ pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool { } test "ascii.endsWithIgnoreCase" { - std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack")); - std.testing.expect(!endsWithIgnoreCase("BoB", "Bo")); + try std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack")); + try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo")); } /// Finds `substr` in `container`, ignoring case, starting at `start_index`. @@ -372,12 +372,12 @@ pub fn indexOfIgnoreCase(container: []const u8, substr: []const u8) ?usize { } test "indexOfIgnoreCase" { - std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14); - std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null); - std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0); - std.testing.expect(indexOfIgnoreCase("foo", "fool") == null); + try std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14); + try std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null); + try std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0); + try std.testing.expect(indexOfIgnoreCase("foo", "fool") == null); - std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0); + try std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0); } /// Compares two slices of numbers lexicographically. O(n). diff --git a/lib/std/atomic/bool.zig b/lib/std/atomic/bool.zig index 0cffb99d38..1c6ac8d046 100644 --- a/lib/std/atomic/bool.zig +++ b/lib/std/atomic/bool.zig @@ -47,9 +47,9 @@ pub const Bool = extern struct { test "std.atomic.Bool" { var a = Bool.init(false); - testing.expectEqual(false, a.xchg(false, .SeqCst)); - testing.expectEqual(false, a.load(.SeqCst)); + try testing.expectEqual(false, a.xchg(false, .SeqCst)); + try testing.expectEqual(false, a.load(.SeqCst)); a.store(true, .SeqCst); - testing.expectEqual(true, a.xchg(false, .SeqCst)); - testing.expectEqual(false, a.load(.SeqCst)); + try testing.expectEqual(true, a.xchg(false, .SeqCst)); + try testing.expectEqual(false, a.load(.SeqCst)); } diff --git a/lib/std/atomic/int.zig b/lib/std/atomic/int.zig index 2d1c5f80e9..3809541fe3 100644 --- a/lib/std/atomic/int.zig +++ b/lib/std/atomic/int.zig @@ -81,12 +81,12 @@ pub fn Int(comptime T: type) type { test "std.atomic.Int" { var a = Int(u8).init(0); - testing.expectEqual(@as(u8, 0), a.incr()); - testing.expectEqual(@as(u8, 1), a.load(.SeqCst)); + try testing.expectEqual(@as(u8, 0), a.incr()); + try testing.expectEqual(@as(u8, 1), a.load(.SeqCst)); a.store(42, .SeqCst); - testing.expectEqual(@as(u8, 42), a.decr()); - testing.expectEqual(@as(u8, 41), a.xchg(100)); - testing.expectEqual(@as(u8, 100), a.fetchAdd(5)); - testing.expectEqual(@as(u8, 105), a.get()); + try testing.expectEqual(@as(u8, 42), a.decr()); + try testing.expectEqual(@as(u8, 41), a.xchg(100)); + try testing.expectEqual(@as(u8, 100), a.fetchAdd(5)); + try testing.expectEqual(@as(u8, 105), a.get()); a.set(200); } diff --git a/lib/std/atomic/queue.zig b/lib/std/atomic/queue.zig index 4e427a1669..24723c90f9 100644 --- a/lib/std/atomic/queue.zig +++ b/lib/std/atomic/queue.zig @@ -195,24 +195,24 @@ test "std.atomic.Queue" { }; if (builtin.single_threaded) { - expect(context.queue.isEmpty()); + try expect(context.queue.isEmpty()); { var i: usize = 0; while (i < put_thread_count) : (i += 1) { - expect(startPuts(&context) == 0); + try expect(startPuts(&context) == 0); } } - expect(!context.queue.isEmpty()); + try expect(!context.queue.isEmpty()); context.puts_done = true; { var i: usize = 0; while (i < put_thread_count) : (i += 1) { - expect(startGets(&context) == 0); + try expect(startGets(&context) == 0); } } - expect(context.queue.isEmpty()); + try expect(context.queue.isEmpty()); } else { - expect(context.queue.isEmpty()); + try expect(context.queue.isEmpty()); var putters: [put_thread_count]*std.Thread = undefined; for (putters) |*t| { @@ -229,7 +229,7 @@ test "std.atomic.Queue" { for (getters) |t| t.wait(); - expect(context.queue.isEmpty()); + try expect(context.queue.isEmpty()); } if (context.put_sum != context.get_sum) { @@ -279,7 +279,7 @@ fn startGets(ctx: *Context) u8 { test "std.atomic.Queue single-threaded" { var queue = Queue(i32).init(); - expect(queue.isEmpty()); + try expect(queue.isEmpty()); var node_0 = Queue(i32).Node{ .data = 0, @@ -287,7 +287,7 @@ test "std.atomic.Queue single-threaded" { .prev = undefined, }; queue.put(&node_0); - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); var node_1 = Queue(i32).Node{ .data = 1, @@ -295,10 +295,10 @@ test "std.atomic.Queue single-threaded" { .prev = undefined, }; queue.put(&node_1); - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); - expect(queue.get().?.data == 0); - expect(!queue.isEmpty()); + try expect(queue.get().?.data == 0); + try expect(!queue.isEmpty()); var node_2 = Queue(i32).Node{ .data = 2, @@ -306,7 +306,7 @@ test "std.atomic.Queue single-threaded" { .prev = undefined, }; queue.put(&node_2); - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); var node_3 = Queue(i32).Node{ .data = 3, @@ -314,13 +314,13 @@ test "std.atomic.Queue single-threaded" { .prev = undefined, }; queue.put(&node_3); - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); - expect(queue.get().?.data == 1); - expect(!queue.isEmpty()); + try expect(queue.get().?.data == 1); + try expect(!queue.isEmpty()); - expect(queue.get().?.data == 2); - expect(!queue.isEmpty()); + try expect(queue.get().?.data == 2); + try expect(!queue.isEmpty()); var node_4 = Queue(i32).Node{ .data = 4, @@ -328,17 +328,17 @@ test "std.atomic.Queue single-threaded" { .prev = undefined, }; queue.put(&node_4); - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); - expect(queue.get().?.data == 3); + try expect(queue.get().?.data == 3); node_3.next = null; - expect(!queue.isEmpty()); + try expect(!queue.isEmpty()); - expect(queue.get().?.data == 4); - expect(queue.isEmpty()); + try expect(queue.get().?.data == 4); + try expect(queue.isEmpty()); - expect(queue.get() == null); - expect(queue.isEmpty()); + try expect(queue.get() == null); + try expect(queue.isEmpty()); } test "std.atomic.Queue dump" { @@ -352,7 +352,7 @@ test "std.atomic.Queue dump" { // Test empty stream fbs.reset(); try queue.dumpToStream(fbs.writer()); - expect(mem.eql(u8, buffer[0..fbs.pos], + try expect(mem.eql(u8, buffer[0..fbs.pos], \\head: (null) \\tail: (null) \\ @@ -376,7 +376,7 @@ test "std.atomic.Queue dump" { \\ (null) \\ , .{ @ptrToInt(queue.head), @ptrToInt(queue.tail) }); - expect(mem.eql(u8, buffer[0..fbs.pos], expected)); + try expect(mem.eql(u8, buffer[0..fbs.pos], expected)); // Test a stream with two elements var node_1 = Queue(i32).Node{ @@ -397,5 +397,5 @@ test "std.atomic.Queue dump" { \\ (null) \\ , .{ @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail) }); - expect(mem.eql(u8, buffer[0..fbs.pos], expected)); + try expect(mem.eql(u8, buffer[0..fbs.pos], expected)); } diff --git a/lib/std/atomic/stack.zig b/lib/std/atomic/stack.zig index 4096c27354..3a24e79d9d 100644 --- a/lib/std/atomic/stack.zig +++ b/lib/std/atomic/stack.zig @@ -110,14 +110,14 @@ test "std.atomic.stack" { { var i: usize = 0; while (i < put_thread_count) : (i += 1) { - expect(startPuts(&context) == 0); + try expect(startPuts(&context) == 0); } } context.puts_done = true; { var i: usize = 0; while (i < put_thread_count) : (i += 1) { - expect(startGets(&context) == 0); + try expect(startGets(&context) == 0); } } } else { diff --git a/lib/std/base64.zig b/lib/std/base64.zig index 4e7c9a696f..1f37f07a28 100644 --- a/lib/std/base64.zig +++ b/lib/std/base64.zig @@ -318,14 +318,14 @@ pub const Base64DecoderWithIgnore = struct { test "base64" { @setEvalBranchQuota(8000); - testBase64() catch unreachable; - comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=") catch unreachable; + try testBase64(); + comptime try testAllApis(standard, "comptime", "Y29tcHRpbWU="); } test "base64 url_safe_no_pad" { @setEvalBranchQuota(8000); - testBase64UrlSafeNoPad() catch unreachable; - comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU") catch unreachable; + try testBase64UrlSafeNoPad(); + comptime try testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU"); } fn testBase64() !void { @@ -404,7 +404,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ { var buffer: [0x100]u8 = undefined; const encoded = codecs.Encoder.encode(&buffer, expected_decoded); - testing.expectEqualSlices(u8, expected_encoded, encoded); + try testing.expectEqualSlices(u8, expected_encoded, encoded); } // Base64Decoder @@ -412,7 +412,7 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ var buffer: [0x100]u8 = undefined; var decoded = buffer[0..try codecs.Decoder.calcSizeForSlice(expected_encoded)]; try codecs.Decoder.decode(decoded, expected_encoded); - testing.expectEqualSlices(u8, expected_decoded, decoded); + try testing.expectEqualSlices(u8, expected_decoded, decoded); } // Base64DecoderWithIgnore @@ -421,8 +421,8 @@ fn testAllApis(codecs: Codecs, expected_decoded: []const u8, expected_encoded: [ var buffer: [0x100]u8 = undefined; var decoded = buffer[0..try decoder_ignore_nothing.calcSizeUpperBound(expected_encoded.len)]; var written = try decoder_ignore_nothing.decode(decoded, expected_encoded); - testing.expect(written <= decoded.len); - testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); + try testing.expect(written <= decoded.len); + try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); } } @@ -431,7 +431,7 @@ fn testDecodeIgnoreSpace(codecs: Codecs, expected_decoded: []const u8, encoded: var buffer: [0x100]u8 = undefined; var decoded = buffer[0..try decoder_ignore_space.calcSizeUpperBound(encoded.len)]; var written = try decoder_ignore_space.decode(decoded, encoded); - testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); + try testing.expectEqualSlices(u8, expected_decoded, decoded[0..written]); } fn testError(codecs: Codecs, encoded: []const u8, expected_err: anyerror) !void { diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig index 80cdd5c79c..e6a99ce250 100644 --- a/lib/std/bit_set.zig +++ b/lib/std/bit_set.zig @@ -998,9 +998,9 @@ fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) typ const testing = std.testing; -fn testBitSet(a: anytype, b: anytype, len: usize) void { - testing.expectEqual(len, a.capacity()); - testing.expectEqual(len, b.capacity()); +fn testBitSet(a: anytype, b: anytype, len: usize) !void { + try testing.expectEqual(len, a.capacity()); + try testing.expectEqual(len, b.capacity()); { var i: usize = 0; @@ -1010,50 +1010,50 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void { } } - testing.expectEqual((len + 1) / 2, a.count()); - testing.expectEqual((len + 3) / 4 + (len + 2) / 4, b.count()); + try testing.expectEqual((len + 1) / 2, a.count()); + try testing.expectEqual((len + 3) / 4 + (len + 2) / 4, b.count()); { var iter = a.iterator(.{}); var i: usize = 0; while (i < len) : (i += 2) { - testing.expectEqual(@as(?usize, i), iter.next()); + try testing.expectEqual(@as(?usize, i), iter.next()); } - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); } a.toggleAll(); { var iter = a.iterator(.{}); var i: usize = 1; while (i < len) : (i += 2) { - testing.expectEqual(@as(?usize, i), iter.next()); + try testing.expectEqual(@as(?usize, i), iter.next()); } - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); } { var iter = b.iterator(.{ .kind = .unset }); var i: usize = 2; while (i < len) : (i += 4) { - testing.expectEqual(@as(?usize, i), iter.next()); + try testing.expectEqual(@as(?usize, i), iter.next()); if (i + 1 < len) { - testing.expectEqual(@as(?usize, i + 1), iter.next()); + try testing.expectEqual(@as(?usize, i + 1), iter.next()); } } - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); } { var i: usize = 0; while (i < len) : (i += 1) { - testing.expectEqual(i & 1 != 0, a.isSet(i)); - testing.expectEqual(i & 2 == 0, b.isSet(i)); + try testing.expectEqual(i & 1 != 0, a.isSet(i)); + try testing.expectEqual(i & 2 == 0, b.isSet(i)); } } @@ -1061,8 +1061,8 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void { { var i: usize = 0; while (i < len) : (i += 1) { - testing.expectEqual(i & 1 != 0 or i & 2 == 0, a.isSet(i)); - testing.expectEqual(i & 2 == 0, b.isSet(i)); + try testing.expectEqual(i & 1 != 0 or i & 2 == 0, a.isSet(i)); + try testing.expectEqual(i & 2 == 0, b.isSet(i)); } i = len; @@ -1071,27 +1071,27 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void { while (i > 0) { i -= 1; if (i & 1 != 0 or i & 2 == 0) { - testing.expectEqual(@as(?usize, i), set.next()); + try testing.expectEqual(@as(?usize, i), set.next()); } else { - testing.expectEqual(@as(?usize, i), unset.next()); + try testing.expectEqual(@as(?usize, i), unset.next()); } } - testing.expectEqual(@as(?usize, null), set.next()); - testing.expectEqual(@as(?usize, null), set.next()); - testing.expectEqual(@as(?usize, null), set.next()); - testing.expectEqual(@as(?usize, null), unset.next()); - testing.expectEqual(@as(?usize, null), unset.next()); - testing.expectEqual(@as(?usize, null), unset.next()); + try testing.expectEqual(@as(?usize, null), set.next()); + try testing.expectEqual(@as(?usize, null), set.next()); + try testing.expectEqual(@as(?usize, null), set.next()); + try testing.expectEqual(@as(?usize, null), unset.next()); + try testing.expectEqual(@as(?usize, null), unset.next()); + try testing.expectEqual(@as(?usize, null), unset.next()); } a.toggleSet(b.*); { - testing.expectEqual(len / 4, a.count()); + try testing.expectEqual(len / 4, a.count()); var i: usize = 0; while (i < len) : (i += 1) { - testing.expectEqual(i & 1 != 0 and i & 2 != 0, a.isSet(i)); - testing.expectEqual(i & 2 == 0, b.isSet(i)); + try testing.expectEqual(i & 1 != 0 and i & 2 != 0, a.isSet(i)); + try testing.expectEqual(i & 2 == 0, b.isSet(i)); if (i & 1 == 0) { a.set(i); } else { @@ -1102,29 +1102,29 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void { a.setIntersection(b.*); { - testing.expectEqual((len + 3) / 4, a.count()); + try testing.expectEqual((len + 3) / 4, a.count()); var i: usize = 0; while (i < len) : (i += 1) { - testing.expectEqual(i & 1 == 0 and i & 2 == 0, a.isSet(i)); - testing.expectEqual(i & 2 == 0, b.isSet(i)); + try testing.expectEqual(i & 1 == 0 and i & 2 == 0, a.isSet(i)); + try testing.expectEqual(i & 2 == 0, b.isSet(i)); } } a.toggleSet(a.*); { var iter = a.iterator(.{}); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(usize, 0), a.count()); } { var iter = a.iterator(.{ .direction = .reverse }); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(?usize, null), iter.next()); - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(?usize, null), iter.next()); + try testing.expectEqual(@as(usize, 0), a.count()); } const test_bits = [_]usize{ @@ -1139,51 +1139,51 @@ fn testBitSet(a: anytype, b: anytype, len: usize) void { for (test_bits) |i| { if (i < a.capacity()) { - testing.expectEqual(@as(?usize, i), a.findFirstSet()); - testing.expectEqual(@as(?usize, i), a.toggleFirstSet()); + try testing.expectEqual(@as(?usize, i), a.findFirstSet()); + try testing.expectEqual(@as(?usize, i), a.toggleFirstSet()); } } - testing.expectEqual(@as(?usize, null), a.findFirstSet()); - testing.expectEqual(@as(?usize, null), a.toggleFirstSet()); - testing.expectEqual(@as(?usize, null), a.findFirstSet()); - testing.expectEqual(@as(?usize, null), a.toggleFirstSet()); - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(?usize, null), a.findFirstSet()); + try testing.expectEqual(@as(?usize, null), a.toggleFirstSet()); + try testing.expectEqual(@as(?usize, null), a.findFirstSet()); + try testing.expectEqual(@as(?usize, null), a.toggleFirstSet()); + try testing.expectEqual(@as(usize, 0), a.count()); } -fn testStaticBitSet(comptime Set: type) void { +fn testStaticBitSet(comptime Set: type) !void { var a = Set.initEmpty(); var b = Set.initFull(); - testing.expectEqual(@as(usize, 0), a.count()); - testing.expectEqual(@as(usize, Set.bit_length), b.count()); + try testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(usize, Set.bit_length), b.count()); - testBitSet(&a, &b, Set.bit_length); + try testBitSet(&a, &b, Set.bit_length); } test "IntegerBitSet" { - testStaticBitSet(IntegerBitSet(0)); - testStaticBitSet(IntegerBitSet(1)); - testStaticBitSet(IntegerBitSet(2)); - testStaticBitSet(IntegerBitSet(5)); - testStaticBitSet(IntegerBitSet(8)); - testStaticBitSet(IntegerBitSet(32)); - testStaticBitSet(IntegerBitSet(64)); - testStaticBitSet(IntegerBitSet(127)); + try testStaticBitSet(IntegerBitSet(0)); + try testStaticBitSet(IntegerBitSet(1)); + try testStaticBitSet(IntegerBitSet(2)); + try testStaticBitSet(IntegerBitSet(5)); + try testStaticBitSet(IntegerBitSet(8)); + try testStaticBitSet(IntegerBitSet(32)); + try testStaticBitSet(IntegerBitSet(64)); + try testStaticBitSet(IntegerBitSet(127)); } test "ArrayBitSet" { inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| { - testStaticBitSet(ArrayBitSet(u8, size)); - testStaticBitSet(ArrayBitSet(u16, size)); - testStaticBitSet(ArrayBitSet(u32, size)); - testStaticBitSet(ArrayBitSet(u64, size)); - testStaticBitSet(ArrayBitSet(u128, size)); + try testStaticBitSet(ArrayBitSet(u8, size)); + try testStaticBitSet(ArrayBitSet(u16, size)); + try testStaticBitSet(ArrayBitSet(u32, size)); + try testStaticBitSet(ArrayBitSet(u64, size)); + try testStaticBitSet(ArrayBitSet(u128, size)); } } test "DynamicBitSetUnmanaged" { const allocator = std.testing.allocator; var a = try DynamicBitSetUnmanaged.initEmpty(300, allocator); - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(usize, 0), a.count()); a.deinit(allocator); a = try DynamicBitSetUnmanaged.initEmpty(0, allocator); @@ -1193,10 +1193,10 @@ test "DynamicBitSetUnmanaged" { var tmp = try a.clone(allocator); defer tmp.deinit(allocator); - testing.expectEqual(old_len, tmp.capacity()); + try testing.expectEqual(old_len, tmp.capacity()); var i: usize = 0; while (i < old_len) : (i += 1) { - testing.expectEqual(a.isSet(i), tmp.isSet(i)); + try testing.expectEqual(a.isSet(i), tmp.isSet(i)); } a.toggleSet(a); // zero a @@ -1206,24 +1206,24 @@ test "DynamicBitSetUnmanaged" { try tmp.resize(size, false, allocator); if (size > old_len) { - testing.expectEqual(size - old_len, a.count()); + try testing.expectEqual(size - old_len, a.count()); } else { - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(usize, 0), a.count()); } - testing.expectEqual(@as(usize, 0), tmp.count()); + try testing.expectEqual(@as(usize, 0), tmp.count()); var b = try DynamicBitSetUnmanaged.initFull(size, allocator); defer b.deinit(allocator); - testing.expectEqual(@as(usize, size), b.count()); + try testing.expectEqual(@as(usize, size), b.count()); - testBitSet(&a, &b, size); + try testBitSet(&a, &b, size); } } test "DynamicBitSet" { const allocator = std.testing.allocator; var a = try DynamicBitSet.initEmpty(300, allocator); - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(usize, 0), a.count()); a.deinit(); a = try DynamicBitSet.initEmpty(0, allocator); @@ -1233,10 +1233,10 @@ test "DynamicBitSet" { var tmp = try a.clone(allocator); defer tmp.deinit(); - testing.expectEqual(old_len, tmp.capacity()); + try testing.expectEqual(old_len, tmp.capacity()); var i: usize = 0; while (i < old_len) : (i += 1) { - testing.expectEqual(a.isSet(i), tmp.isSet(i)); + try testing.expectEqual(a.isSet(i), tmp.isSet(i)); } a.toggleSet(a); // zero a @@ -1246,24 +1246,24 @@ test "DynamicBitSet" { try tmp.resize(size, false); if (size > old_len) { - testing.expectEqual(size - old_len, a.count()); + try testing.expectEqual(size - old_len, a.count()); } else { - testing.expectEqual(@as(usize, 0), a.count()); + try testing.expectEqual(@as(usize, 0), a.count()); } - testing.expectEqual(@as(usize, 0), tmp.count()); + try testing.expectEqual(@as(usize, 0), tmp.count()); var b = try DynamicBitSet.initFull(size, allocator); defer b.deinit(); - testing.expectEqual(@as(usize, size), b.count()); + try testing.expectEqual(@as(usize, size), b.count()); - testBitSet(&a, &b, size); + try testBitSet(&a, &b, size); } } test "StaticBitSet" { - testing.expectEqual(IntegerBitSet(0), StaticBitSet(0)); - testing.expectEqual(IntegerBitSet(5), StaticBitSet(5)); - testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize))); - testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1)); - testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500)); + try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0)); + try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5)); + try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize))); + try testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1)); + try testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500)); } diff --git a/lib/std/buf_map.zig b/lib/std/buf_map.zig index 29d1ac4876..4708b9c37b 100644 --- a/lib/std/buf_map.zig +++ b/lib/std/buf_map.zig @@ -94,19 +94,19 @@ test "BufMap" { defer bufmap.deinit(); try bufmap.set("x", "1"); - testing.expect(mem.eql(u8, bufmap.get("x").?, "1")); - testing.expect(1 == bufmap.count()); + try testing.expect(mem.eql(u8, bufmap.get("x").?, "1")); + try testing.expect(1 == bufmap.count()); try bufmap.set("x", "2"); - testing.expect(mem.eql(u8, bufmap.get("x").?, "2")); - testing.expect(1 == bufmap.count()); + try testing.expect(mem.eql(u8, bufmap.get("x").?, "2")); + try testing.expect(1 == bufmap.count()); try bufmap.set("x", "3"); - testing.expect(mem.eql(u8, bufmap.get("x").?, "3")); - testing.expect(1 == bufmap.count()); + try testing.expect(mem.eql(u8, bufmap.get("x").?, "3")); + try testing.expect(1 == bufmap.count()); bufmap.delete("x"); - testing.expect(0 == bufmap.count()); + try testing.expect(0 == bufmap.count()); try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v1")); try bufmap.setMove(try allocator.dupe(u8, "k"), try allocator.dupe(u8, "v2")); diff --git a/lib/std/buf_set.zig b/lib/std/buf_set.zig index e59dc9841b..5e09aa6bcb 100644 --- a/lib/std/buf_set.zig +++ b/lib/std/buf_set.zig @@ -73,9 +73,9 @@ test "BufSet" { defer bufset.deinit(); try bufset.put("x"); - testing.expect(bufset.count() == 1); + try testing.expect(bufset.count() == 1); bufset.delete("x"); - testing.expect(bufset.count() == 0); + try testing.expect(bufset.count() == 0); try bufset.put("x"); try bufset.put("y"); diff --git a/lib/std/build.zig b/lib/std/build.zig index 1811073279..1bdd97b253 100644 --- a/lib/std/build.zig +++ b/lib/std/build.zig @@ -3060,19 +3060,19 @@ test "Builder.dupePkg()" { const dupe_deps = dupe.dependencies.?; // probably the same top level package details - std.testing.expectEqualStrings(pkg_top.name, dupe.name); + try std.testing.expectEqualStrings(pkg_top.name, dupe.name); // probably the same dependencies - std.testing.expectEqual(original_deps.len, dupe_deps.len); - std.testing.expectEqual(original_deps[0].name, pkg_dep.name); + try std.testing.expectEqual(original_deps.len, dupe_deps.len); + try std.testing.expectEqual(original_deps[0].name, pkg_dep.name); // could segfault otherwise if pointers in duplicated package's fields are // the same as those in stack allocated package's fields - std.testing.expect(dupe_deps.ptr != original_deps.ptr); - std.testing.expect(dupe.name.ptr != pkg_top.name.ptr); - std.testing.expect(dupe.path.ptr != pkg_top.path.ptr); - std.testing.expect(dupe_deps[0].name.ptr != pkg_dep.name.ptr); - std.testing.expect(dupe_deps[0].path.ptr != pkg_dep.path.ptr); + try std.testing.expect(dupe_deps.ptr != original_deps.ptr); + try std.testing.expect(dupe.name.ptr != pkg_top.name.ptr); + try std.testing.expect(dupe.path.ptr != pkg_top.path.ptr); + try std.testing.expect(dupe_deps[0].name.ptr != pkg_dep.name.ptr); + try std.testing.expect(dupe_deps[0].path.ptr != pkg_dep.path.ptr); } test "LibExeObjStep.addBuildOption" { @@ -3096,7 +3096,7 @@ test "LibExeObjStep.addBuildOption" { exe.addBuildOption(?[]const u8, "optional_string", null); exe.addBuildOption(std.SemanticVersion, "semantic_version", try std.SemanticVersion.parse("0.1.2-foo+bar")); - std.testing.expectEqualStrings( + try std.testing.expectEqualStrings( \\pub const option1: usize = 1; \\pub const option2: ?usize = null; \\pub const string: []const u8 = "zigisthebest"; @@ -3140,10 +3140,10 @@ test "LibExeObjStep.addPackage" { var exe = builder.addExecutable("not_an_executable", "/not/an/executable.zig"); exe.addPackage(pkg_top); - std.testing.expectEqual(@as(usize, 1), exe.packages.items.len); + try std.testing.expectEqual(@as(usize, 1), exe.packages.items.len); const dupe = exe.packages.items[0]; - std.testing.expectEqualStrings(pkg_top.name, dupe.name); + try std.testing.expectEqualStrings(pkg_top.name, dupe.name); } test { diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 53c27f0bf5..c623719108 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -546,7 +546,7 @@ pub fn testVersionParse() !void { const f = struct { fn eql(text: []const u8, v1: u32, v2: u32, v3: u32) !void { const v = try Version.parse(text); - std.testing.expect(v.major == v1 and v.minor == v2 and v.patch == v3); + try std.testing.expect(v.major == v1 and v.minor == v2 and v.patch == v3); } fn err(text: []const u8, expected_err: anyerror) !void { diff --git a/lib/std/c/tokenizer.zig b/lib/std/c/tokenizer.zig index 4399d3dc6c..0d4c646c39 100644 --- a/lib/std/c/tokenizer.zig +++ b/lib/std/c/tokenizer.zig @@ -1310,7 +1310,7 @@ pub const Tokenizer = struct { }; test "operators" { - expectTokens( + try expectTokens( \\ ! != | || |= = == \\ ( ) { } [ ] . .. ... \\ ^ ^= + ++ += - -- -= @@ -1379,7 +1379,7 @@ test "operators" { } test "keywords" { - expectTokens( + try expectTokens( \\auto break case char const continue default do \\double else enum extern float for goto if int \\long register return short signed sizeof static @@ -1442,7 +1442,7 @@ test "keywords" { } test "preprocessor keywords" { - expectTokens( + try expectTokens( \\#include \\#define #include <1 \\#ifdef @@ -1478,7 +1478,7 @@ test "preprocessor keywords" { } test "line continuation" { - expectTokens( + try expectTokens( \\#define foo \ \\ bar \\"foo\ @@ -1509,7 +1509,7 @@ test "line continuation" { } test "string prefix" { - expectTokens( + try expectTokens( \\"foo" \\u"foo" \\u8"foo" @@ -1543,7 +1543,7 @@ test "string prefix" { } test "num suffixes" { - expectTokens( + try expectTokens( \\ 1.0f 1.0L 1.0 .0 1. \\ 0l 0lu 0ll 0llu 0 \\ 1u 1ul 1ull 1 @@ -1573,7 +1573,7 @@ test "num suffixes" { }); } -fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) void { +fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) !void { var tokenizer = Tokenizer{ .buffer = source, }; @@ -1584,5 +1584,5 @@ fn expectTokens(source: []const u8, expected_tokens: []const Token.Id) void { } } const last_token = tokenizer.next(); - std.testing.expect(last_token.id == .Eof); + try std.testing.expect(last_token.id == .Eof); } diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig index 01db179bbe..17a79d1bf9 100644 --- a/lib/std/child_process.zig +++ b/lib/std/child_process.zig @@ -1005,7 +1005,7 @@ test "createNullDelimitedEnvMap" { defer arena.deinit(); const environ = try createNullDelimitedEnvMap(&arena.allocator, &envmap); - testing.expectEqual(@as(usize, 5), environ.len); + try testing.expectEqual(@as(usize, 5), environ.len); inline for (.{ "HOME=/home/ifreund", @@ -1017,7 +1017,7 @@ test "createNullDelimitedEnvMap" { for (environ) |variable| { if (mem.eql(u8, mem.span(variable orelse continue), target)) break; } else { - testing.expect(false); // Environment variable not found + try testing.expect(false); // Environment variable not found } } } diff --git a/lib/std/compress/deflate.zig b/lib/std/compress/deflate.zig index 88b9ec8672..45ffb64b4f 100644 --- a/lib/std/compress/deflate.zig +++ b/lib/std/compress/deflate.zig @@ -669,5 +669,5 @@ test "lengths overflow" { var inflate = inflateStream(reader, &window); var buf: [1]u8 = undefined; - std.testing.expectError(error.InvalidLength, inflate.read(&buf)); + try std.testing.expectError(error.InvalidLength, inflate.read(&buf)); } diff --git a/lib/std/compress/gzip.zig b/lib/std/compress/gzip.zig index 89aa12207b..387b64f59a 100644 --- a/lib/std/compress/gzip.zig +++ b/lib/std/compress/gzip.zig @@ -172,17 +172,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void { var hash: [32]u8 = undefined; std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{}); - assertEqual(expected, &hash); + try assertEqual(expected, &hash); } // Assert `expected` == `input` where `input` is a bytestring. -pub fn assertEqual(comptime expected: []const u8, input: []const u8) void { +pub fn assertEqual(comptime expected: []const u8, input: []const u8) !void { var expected_bytes: [expected.len / 2]u8 = undefined; for (expected_bytes) |*r, i| { r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable; } - testing.expectEqualSlices(u8, &expected_bytes, input); + try testing.expectEqualSlices(u8, &expected_bytes, input); } // All the test cases are obtained by compressing the RFC1952 text @@ -198,12 +198,12 @@ test "compressed data" { test "sanity checks" { // Truncated header - testing.expectError( + try testing.expectError( error.EndOfStream, testReader(&[_]u8{ 0x1f, 0x8B }, ""), ); // Wrong CM - testing.expectError( + try testing.expectError( error.InvalidCompression, testReader(&[_]u8{ 0x1f, 0x8b, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -211,7 +211,7 @@ test "sanity checks" { }, ""), ); // Wrong checksum - testing.expectError( + try testing.expectError( error.WrongChecksum, testReader(&[_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -220,7 +220,7 @@ test "sanity checks" { }, ""), ); // Truncated checksum - testing.expectError( + try testing.expectError( error.EndOfStream, testReader(&[_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -228,7 +228,7 @@ test "sanity checks" { }, ""), ); // Wrong initial size - testing.expectError( + try testing.expectError( error.CorruptedData, testReader(&[_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -237,7 +237,7 @@ test "sanity checks" { }, ""), ); // Truncated initial size field - testing.expectError( + try testing.expectError( error.EndOfStream, testReader(&[_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, diff --git a/lib/std/compress/zlib.zig b/lib/std/compress/zlib.zig index 7ef644ef6d..0ee154bf22 100644 --- a/lib/std/compress/zlib.zig +++ b/lib/std/compress/zlib.zig @@ -109,17 +109,17 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void { var hash: [32]u8 = undefined; std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{}); - assertEqual(expected, &hash); + try assertEqual(expected, &hash); } // Assert `expected` == `input` where `input` is a bytestring. -pub fn assertEqual(comptime expected: []const u8, input: []const u8) void { +pub fn assertEqual(comptime expected: []const u8, input: []const u8) !void { var expected_bytes: [expected.len / 2]u8 = undefined; for (expected_bytes) |*r, i| { r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable; } - testing.expectEqualSlices(u8, &expected_bytes, input); + try testing.expectEqualSlices(u8, &expected_bytes, input); } // All the test cases are obtained by compressing the RFC1950 text @@ -159,32 +159,32 @@ test "don't read past deflate stream's end" { test "sanity checks" { // Truncated header - testing.expectError( + try testing.expectError( error.EndOfStream, testReader(&[_]u8{0x78}, ""), ); // Failed FCHECK check - testing.expectError( + try testing.expectError( error.BadHeader, testReader(&[_]u8{ 0x78, 0x9D }, ""), ); // Wrong CM - testing.expectError( + try testing.expectError( error.InvalidCompression, testReader(&[_]u8{ 0x79, 0x94 }, ""), ); // Wrong CINFO - testing.expectError( + try testing.expectError( error.InvalidWindowSize, testReader(&[_]u8{ 0x88, 0x98 }, ""), ); // Wrong checksum - testing.expectError( + try testing.expectError( error.WrongChecksum, testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, ""), ); // Truncated checksum - testing.expectError( + try testing.expectError( error.EndOfStream, testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00 }, ""), ); diff --git a/lib/std/comptime_string_map.zig b/lib/std/comptime_string_map.zig index 4882924ae5..1dca59e997 100644 --- a/lib/std/comptime_string_map.zig +++ b/lib/std/comptime_string_map.zig @@ -95,7 +95,7 @@ test "ComptimeStringMap list literal of list literals" { .{ "samelen", .E }, }); - testMap(map); + try testMap(map); } test "ComptimeStringMap array of structs" { @@ -111,7 +111,7 @@ test "ComptimeStringMap array of structs" { .{ .@"0" = "samelen", .@"1" = .E }, }); - testMap(map); + try testMap(map); } test "ComptimeStringMap slice of structs" { @@ -128,18 +128,18 @@ test "ComptimeStringMap slice of structs" { }; const map = ComptimeStringMap(TestEnum, slice); - testMap(map); + try testMap(map); } -fn testMap(comptime map: anytype) void { - std.testing.expectEqual(TestEnum.A, map.get("have").?); - std.testing.expectEqual(TestEnum.B, map.get("nothing").?); - std.testing.expect(null == map.get("missing")); - std.testing.expectEqual(TestEnum.D, map.get("these").?); - std.testing.expectEqual(TestEnum.E, map.get("samelen").?); +fn testMap(comptime map: anytype) !void { + try std.testing.expectEqual(TestEnum.A, map.get("have").?); + try std.testing.expectEqual(TestEnum.B, map.get("nothing").?); + try std.testing.expect(null == map.get("missing")); + try std.testing.expectEqual(TestEnum.D, map.get("these").?); + try std.testing.expectEqual(TestEnum.E, map.get("samelen").?); - std.testing.expect(!map.has("missing")); - std.testing.expect(map.has("these")); + try std.testing.expect(!map.has("missing")); + try std.testing.expect(map.has("these")); } test "ComptimeStringMap void value type, slice of structs" { @@ -155,7 +155,7 @@ test "ComptimeStringMap void value type, slice of structs" { }; const map = ComptimeStringMap(void, slice); - testSet(map); + try testSet(map); } test "ComptimeStringMap void value type, list literal of list literals" { @@ -167,16 +167,16 @@ test "ComptimeStringMap void value type, list literal of list literals" { .{"samelen"}, }); - testSet(map); + try testSet(map); } -fn testSet(comptime map: anytype) void { - std.testing.expectEqual({}, map.get("have").?); - std.testing.expectEqual({}, map.get("nothing").?); - std.testing.expect(null == map.get("missing")); - std.testing.expectEqual({}, map.get("these").?); - std.testing.expectEqual({}, map.get("samelen").?); +fn testSet(comptime map: anytype) !void { + try std.testing.expectEqual({}, map.get("have").?); + try std.testing.expectEqual({}, map.get("nothing").?); + try std.testing.expect(null == map.get("missing")); + try std.testing.expectEqual({}, map.get("these").?); + try std.testing.expectEqual({}, map.get("samelen").?); - std.testing.expect(!map.has("missing")); - std.testing.expect(map.has("these")); + try std.testing.expect(!map.has("missing")); + try std.testing.expect(map.has("these")); } diff --git a/lib/std/crypto.zig b/lib/std/crypto.zig index af23af9460..42ded1f2ea 100644 --- a/lib/std/crypto.zig +++ b/lib/std/crypto.zig @@ -188,7 +188,7 @@ test "CSPRNG" { const a = random.int(u64); const b = random.int(u64); const c = random.int(u64); - std.testing.expect(a ^ b ^ c != 0); + try std.testing.expect(a ^ b ^ c != 0); } test "issue #4532: no index out of bounds" { @@ -226,6 +226,6 @@ test "issue #4532: no index out of bounds" { h.update(block[1..]); h.final(&out2); - std.testing.expectEqual(out1, out2); + try std.testing.expectEqual(out1, out2); } } diff --git a/lib/std/crypto/25519/curve25519.zig b/lib/std/crypto/25519/curve25519.zig index 90b0e10c4f..6ebc8548c2 100644 --- a/lib/std/crypto/25519/curve25519.zig +++ b/lib/std/crypto/25519/curve25519.zig @@ -120,13 +120,13 @@ test "curve25519" { const p = try Curve25519.basePoint.clampedMul(s); try p.rejectIdentity(); var buf: [128]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E6F2A4D1C28EE5C7AD0329268255A468AD407D2672824C0C0EB30EA6EF450145"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E6F2A4D1C28EE5C7AD0329268255A468AD407D2672824C0C0EB30EA6EF450145"); const q = try p.clampedMul(s); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "3614E119FFE55EC55B87D6B19971A9F4CBC78EFE80BEC55B96392BABCC712537"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "3614E119FFE55EC55B87D6B19971A9F4CBC78EFE80BEC55B96392BABCC712537"); try Curve25519.rejectNonCanonical(s); s[31] |= 0x80; - std.testing.expectError(error.NonCanonical, Curve25519.rejectNonCanonical(s)); + try std.testing.expectError(error.NonCanonical, Curve25519.rejectNonCanonical(s)); } test "curve25519 small order check" { @@ -155,13 +155,13 @@ test "curve25519 small order check" { }, }; for (small_order_ss) |small_order_s| { - std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(small_order_s).mul(s)); + try std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(small_order_s).mul(s)); var extra = small_order_s; extra[31] ^= 0x80; - std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(extra).mul(s)); + try std.testing.expectError(error.WeakPublicKey, Curve25519.fromBytes(extra).mul(s)); var valid = small_order_s; valid[31] = 0x40; s[0] = 0; - std.testing.expectError(error.IdentityElement, Curve25519.fromBytes(valid).mul(s)); + try std.testing.expectError(error.IdentityElement, Curve25519.fromBytes(valid).mul(s)); } } diff --git a/lib/std/crypto/25519/ed25519.zig b/lib/std/crypto/25519/ed25519.zig index b48cc24b4b..b6321e8d8c 100644 --- a/lib/std/crypto/25519/ed25519.zig +++ b/lib/std/crypto/25519/ed25519.zig @@ -219,8 +219,8 @@ test "ed25519 key pair creation" { _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166"); const key_pair = try Ed25519.KeyPair.create(seed); var buf: [256]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key)}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083"); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key)}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key)}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key)}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083"); } test "ed25519 signature" { @@ -230,9 +230,9 @@ test "ed25519 signature" { const sig = try Ed25519.sign("test", key_pair, null); var buf: [128]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig)}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig)}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808"); try Ed25519.verify(sig, "test", key_pair.public_key); - std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verify(sig, "TEST", key_pair.public_key)); + try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verify(sig, "TEST", key_pair.public_key)); } test "ed25519 batch verification" { @@ -260,7 +260,7 @@ test "ed25519 batch verification" { try Ed25519.verifyBatch(2, signature_batch); signature_batch[1].sig = sig1; - std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch)); + try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch)); } } @@ -354,7 +354,7 @@ test "ed25519 test vectors" { var sig: [64]u8 = undefined; _ = try fmt.hexToBytes(&sig, entry.sig_hex); if (entry.expected) |error_type| { - std.testing.expectError(error_type, Ed25519.verify(sig, &msg, public_key)); + try std.testing.expectError(error_type, Ed25519.verify(sig, &msg, public_key)); } else { try Ed25519.verify(sig, &msg, public_key); } diff --git a/lib/std/crypto/25519/edwards25519.zig b/lib/std/crypto/25519/edwards25519.zig index 4e3d156007..e6fa9b2534 100644 --- a/lib/std/crypto/25519/edwards25519.zig +++ b/lib/std/crypto/25519/edwards25519.zig @@ -491,7 +491,7 @@ test "edwards25519 packing/unpacking" { var b = Edwards25519.basePoint; const pk = try b.mul(s); var buf: [128]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&pk.toBytes())}), "074BC7E0FCBD587FDBC0969444245FADC562809C8F6E97E949AF62484B5B81A6"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&pk.toBytes())}), "074BC7E0FCBD587FDBC0969444245FADC562809C8F6E97E949AF62484B5B81A6"); const small_order_ss: [7][32]u8 = .{ .{ @@ -518,7 +518,7 @@ test "edwards25519 packing/unpacking" { }; for (small_order_ss) |small_order_s| { const small_p = try Edwards25519.fromBytes(small_order_s); - std.testing.expectError(error.WeakPublicKey, small_p.mul(s)); + try std.testing.expectError(error.WeakPublicKey, small_p.mul(s)); } } @@ -531,26 +531,26 @@ test "edwards25519 point addition/substraction" { const q = try Edwards25519.basePoint.clampedMul(s2); const r = p.add(q).add(q).sub(q).sub(q); try r.rejectIdentity(); - std.testing.expectError(error.IdentityElement, r.sub(p).rejectIdentity()); - std.testing.expectError(error.IdentityElement, p.sub(p).rejectIdentity()); - std.testing.expectError(error.IdentityElement, p.sub(q).add(q).sub(p).rejectIdentity()); + try std.testing.expectError(error.IdentityElement, r.sub(p).rejectIdentity()); + try std.testing.expectError(error.IdentityElement, p.sub(p).rejectIdentity()); + try std.testing.expectError(error.IdentityElement, p.sub(q).add(q).sub(p).rejectIdentity()); } test "edwards25519 uniform-to-point" { 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 }; var p = Edwards25519.fromUniform(r); - htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]); + try htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]); r[31] = 0xff; p = Edwards25519.fromUniform(r); - htest.assertEqual("f70718e68ef42d90ca1d936bb2d7e159be6c01d8095d39bd70487c82fe5c973a", p.toBytes()[0..]); + try htest.assertEqual("f70718e68ef42d90ca1d936bb2d7e159be6c01d8095d39bd70487c82fe5c973a", p.toBytes()[0..]); } // Test vectors from draft-irtf-cfrg-hash-to-curve-10 test "edwards25519 hash-to-curve operation" { var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc"); - htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895831a", p.toBytes()[0..]); + try htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895831a", p.toBytes()[0..]); p = Edwards25519.fromString(false, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_NU_", "abc"); - htest.assertEqual("42fa27c8f5a1ae0aa38bb59d5938e5145622ba5dedd11d11736fa2f9502d73e7", p.toBytes()[0..]); + try htest.assertEqual("42fa27c8f5a1ae0aa38bb59d5938e5145622ba5dedd11d11736fa2f9502d73e7", p.toBytes()[0..]); } diff --git a/lib/std/crypto/25519/ristretto255.zig b/lib/std/crypto/25519/ristretto255.zig index 50f1580a80..c17461e40a 100644 --- a/lib/std/crypto/25519/ristretto255.zig +++ b/lib/std/crypto/25519/ristretto255.zig @@ -175,21 +175,21 @@ pub const Ristretto255 = struct { test "ristretto255" { const p = Ristretto255.basePoint; var buf: [256]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76"); var r: [Ristretto255.encoded_length]u8 = undefined; _ = try fmt.hexToBytes(r[0..], "6a493210f7499cd17fecb510ae0cea23a110e8d5b901f8acadd3095c73a3b919"); var q = try Ristretto255.fromBytes(r); q = q.dbl().add(p); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "E882B131016B52C1D3337080187CF768423EFCCBB517BB495AB812C4160FF44E"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&q.toBytes())}), "E882B131016B52C1D3337080187CF768423EFCCBB517BB495AB812C4160FF44E"); const s = [_]u8{15} ++ [_]u8{0} ** 31; const w = try p.mul(s); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&w.toBytes())}), "E0C418F7C8D9C4CDD7395B93EA124F3AD99021BB681DFC3302A9D99A2E53E64E"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&w.toBytes())}), "E0C418F7C8D9C4CDD7395B93EA124F3AD99021BB681DFC3302A9D99A2E53E64E"); - std.testing.expect(p.dbl().dbl().dbl().dbl().equivalent(w.add(p))); + try std.testing.expect(p.dbl().dbl().dbl().dbl().equivalent(w.add(p))); const h = [_]u8{69} ** 32 ++ [_]u8{42} ** 32; const ph = Ristretto255.fromUniform(h); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&ph.toBytes())}), "DCCA54E037A4311EFBEEF413ACD21D35276518970B7A61DC88F8587B493D5E19"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&ph.toBytes())}), "DCCA54E037A4311EFBEEF413ACD21D35276518970B7A61DC88F8587B493D5E19"); } diff --git a/lib/std/crypto/25519/scalar.zig b/lib/std/crypto/25519/scalar.zig index e8564ff577..e89c6d6f2a 100644 --- a/lib/std/crypto/25519/scalar.zig +++ b/lib/std/crypto/25519/scalar.zig @@ -773,15 +773,15 @@ test "scalar25519" { var y = x.toBytes(); try rejectNonCanonical(y); var buf: [128]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&y)}), "1E979B917937F3DE71D18077F961F6CEFF01030405060708010203040506070F"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&y)}), "1E979B917937F3DE71D18077F961F6CEFF01030405060708010203040506070F"); const reduced = reduce(field_size); - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&reduced)}), "0000000000000000000000000000000000000000000000000000000000000000"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&reduced)}), "0000000000000000000000000000000000000000000000000000000000000000"); } test "non-canonical scalar25519" { 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 }; - std.testing.expectError(error.NonCanonical, rejectNonCanonical(too_targe)); + try std.testing.expectError(error.NonCanonical, rejectNonCanonical(too_targe)); } test "mulAdd overflow check" { @@ -790,5 +790,5 @@ test "mulAdd overflow check" { const c: [32]u8 = [_]u8{0xff} ** 32; const x = mulAdd(a, b, c); var buf: [128]u8 = undefined; - std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&x)}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903"); + try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&x)}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903"); } diff --git a/lib/std/crypto/25519/x25519.zig b/lib/std/crypto/25519/x25519.zig index 07b1dc7a86..5109fd7c2a 100644 --- a/lib/std/crypto/25519/x25519.zig +++ b/lib/std/crypto/25519/x25519.zig @@ -92,7 +92,7 @@ test "x25519 public key calculation from secret key" { _ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166"); _ = try fmt.hexToBytes(pk_expected[0..], "f1814f0e8ff1043d8a44d25babff3cedcae6c22c3edaa48f857ae70de2baae50"); const pk_calculated = try X25519.recoverPublicKey(sk); - std.testing.expectEqual(pk_calculated, pk_expected); + try std.testing.expectEqual(pk_calculated, pk_expected); } test "x25519 rfc7748 vector1" { @@ -102,7 +102,7 @@ test "x25519 rfc7748 vector1" { 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 }; const output = try X25519.scalarmult(secret_key, public_key); - std.testing.expectEqual(output, expected_output); + try std.testing.expectEqual(output, expected_output); } test "x25519 rfc7748 vector2" { @@ -112,7 +112,7 @@ test "x25519 rfc7748 vector2" { 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 }; const output = try X25519.scalarmult(secret_key, public_key); - std.testing.expectEqual(output, expected_output); + try std.testing.expectEqual(output, expected_output); } test "x25519 rfc7748 one iteration" { @@ -129,7 +129,7 @@ test "x25519 rfc7748 one iteration" { mem.copy(u8, k[0..], output[0..]); } - std.testing.expectEqual(k, expected_output); + try std.testing.expectEqual(k, expected_output); } test "x25519 rfc7748 1,000 iterations" { @@ -151,7 +151,7 @@ test "x25519 rfc7748 1,000 iterations" { mem.copy(u8, k[0..], output[0..]); } - std.testing.expectEqual(k, expected_output); + try std.testing.expectEqual(k, expected_output); } test "x25519 rfc7748 1,000,000 iterations" { @@ -172,12 +172,12 @@ test "x25519 rfc7748 1,000,000 iterations" { mem.copy(u8, k[0..], output[0..]); } - std.testing.expectEqual(k[0..], expected_output); + try std.testing.expectEqual(k[0..], expected_output); } test "edwards25519 -> curve25519 map" { const ed_kp = try crypto.sign.Ed25519.KeyPair.create([_]u8{0x42} ** 32); const mont_kp = try X25519.KeyPair.fromEd25519(ed_kp); - htest.assertEqual("90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e", &mont_kp.secret_key); - htest.assertEqual("cc4f2cdb695dd766f34118eb67b98652fed1d8bc49c330b119bbfa8a64989378", &mont_kp.public_key); + try htest.assertEqual("90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e", &mont_kp.secret_key); + try htest.assertEqual("cc4f2cdb695dd766f34118eb67b98652fed1d8bc49c330b119bbfa8a64989378", &mont_kp.public_key); } diff --git a/lib/std/crypto/aegis.zig b/lib/std/crypto/aegis.zig index 59dcf04dac..a9418c6ca6 100644 --- a/lib/std/crypto/aegis.zig +++ b/lib/std/crypto/aegis.zig @@ -352,16 +352,16 @@ test "Aegis128L test vector 1" { Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c); - htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag); + try htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c); + try htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag); c[0] +%= 1; - testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key)); + try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key)); c[0] -%= 1; tag[0] +%= 1; - testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key)); + try testing.expectError(error.AuthenticationFailed, Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key)); } test "Aegis128L test vector 2" { @@ -375,10 +375,10 @@ test "Aegis128L test vector 2" { Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c); - htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag); + try htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c); + try htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag); } test "Aegis128L test vector 3" { @@ -392,9 +392,9 @@ test "Aegis128L test vector 3" { Aegis128L.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis128L.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag); + try htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag); } test "Aegis256 test vector 1" { @@ -408,16 +408,16 @@ test "Aegis256 test vector 1" { Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c); - htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag); + try htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c); + try htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag); c[0] +%= 1; - testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key)); + try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key)); c[0] -%= 1; tag[0] +%= 1; - testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key)); + try testing.expectError(error.AuthenticationFailed, Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key)); } test "Aegis256 test vector 2" { @@ -431,10 +431,10 @@ test "Aegis256 test vector 2" { Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c); - htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag); + try htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c); + try htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag); } test "Aegis256 test vector 3" { @@ -448,7 +448,7 @@ test "Aegis256 test vector 3" { Aegis256.encrypt(&c, &tag, &m, &ad, nonce, key); try Aegis256.decrypt(&m2, &c, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &m, &m2); + try testing.expectEqualSlices(u8, &m, &m2); - htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag); + try htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag); } diff --git a/lib/std/crypto/aes.zig b/lib/std/crypto/aes.zig index 2a81492c8a..b24a3bf921 100644 --- a/lib/std/crypto/aes.zig +++ b/lib/std/crypto/aes.zig @@ -48,7 +48,7 @@ test "ctr" { var out: [exp_out.len]u8 = undefined; var ctx = Aes128.initEnc(key); ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, builtin.Endian.Big); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } test "encrypt" { @@ -61,7 +61,7 @@ test "encrypt" { var out: [exp_out.len]u8 = undefined; var ctx = Aes128.initEnc(key); ctx.encrypt(out[0..], in[0..]); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } // Appendix C.3 @@ -76,7 +76,7 @@ test "encrypt" { var out: [exp_out.len]u8 = undefined; var ctx = Aes256.initEnc(key); ctx.encrypt(out[0..], in[0..]); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } } @@ -90,7 +90,7 @@ test "decrypt" { var out: [exp_out.len]u8 = undefined; var ctx = Aes128.initDec(key); ctx.decrypt(out[0..], in[0..]); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } // Appendix C.3 @@ -105,7 +105,7 @@ test "decrypt" { var out: [exp_out.len]u8 = undefined; var ctx = Aes256.initDec(key); ctx.decrypt(out[0..], in[0..]); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } } @@ -123,11 +123,11 @@ test "expand 128-bit key" { for (enc.key_schedule.round_keys) |round_key, i| { _ = try std.fmt.hexToBytes(&exp, exp_enc[i]); - testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); + try testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); } for (enc.key_schedule.round_keys) |round_key, i| { _ = try std.fmt.hexToBytes(&exp, exp_dec[i]); - testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); + try testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); } } @@ -145,10 +145,10 @@ test "expand 256-bit key" { for (enc.key_schedule.round_keys) |round_key, i| { _ = try std.fmt.hexToBytes(&exp, exp_enc[i]); - testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); + try testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); } for (dec.key_schedule.round_keys) |round_key, i| { _ = try std.fmt.hexToBytes(&exp, exp_dec[i]); - testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); + try testing.expectEqualSlices(u8, &exp, &round_key.toBytes()); } } diff --git a/lib/std/crypto/aes_gcm.zig b/lib/std/crypto/aes_gcm.zig index 70746af073..cc2a423f70 100644 --- a/lib/std/crypto/aes_gcm.zig +++ b/lib/std/crypto/aes_gcm.zig @@ -118,7 +118,7 @@ test "Aes256Gcm - Empty message and no associated data" { var tag: [Aes256Gcm.tag_length]u8 = undefined; Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key); - htest.assertEqual("6b6ff610a16fa4cd59f1fb7903154e92", &tag); + try htest.assertEqual("6b6ff610a16fa4cd59f1fb7903154e92", &tag); } test "Aes256Gcm - Associated data only" { @@ -130,7 +130,7 @@ test "Aes256Gcm - Associated data only" { var tag: [Aes256Gcm.tag_length]u8 = undefined; Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key); - htest.assertEqual("262ed164c2dfb26e080a9d108dd9dd4c", &tag); + try htest.assertEqual("262ed164c2dfb26e080a9d108dd9dd4c", &tag); } test "Aes256Gcm - Message only" { @@ -144,10 +144,10 @@ test "Aes256Gcm - Message only" { Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key); try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key); - testing.expectEqualSlices(u8, m[0..], m2[0..]); + try testing.expectEqualSlices(u8, m[0..], m2[0..]); - htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01d539472f7c", &c); - htest.assertEqual("07cd7fc9103e2f9e9bf2dfaa319caff4", &tag); + try htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01d539472f7c", &c); + try htest.assertEqual("07cd7fc9103e2f9e9bf2dfaa319caff4", &tag); } test "Aes256Gcm - Message and associated data" { @@ -161,8 +161,8 @@ test "Aes256Gcm - Message and associated data" { Aes256Gcm.encrypt(&c, &tag, m, ad, nonce, key); try Aes256Gcm.decrypt(&m2, &c, tag, ad, nonce, key); - testing.expectEqualSlices(u8, m[0..], m2[0..]); + try testing.expectEqualSlices(u8, m[0..], m2[0..]); - htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01", &c); - htest.assertEqual("64accec679d444e2373bd9f6796c0d2c", &tag); + try htest.assertEqual("5ca1642d90009fea33d01f78cf6eefaf01", &c); + try htest.assertEqual("64accec679d444e2373bd9f6796c0d2c", &tag); } diff --git a/lib/std/crypto/bcrypt.zig b/lib/std/crypto/bcrypt.zig index 51fb144b2f..c1ad239e90 100644 --- a/lib/std/crypto/bcrypt.zig +++ b/lib/std/crypto/bcrypt.zig @@ -281,13 +281,13 @@ test "bcrypt codec" { Codec.encode(salt_str[0..], salt[0..]); var salt2: [salt_length]u8 = undefined; try Codec.decode(salt2[0..], salt_str[0..]); - testing.expectEqualSlices(u8, salt[0..], salt2[0..]); + try testing.expectEqualSlices(u8, salt[0..], salt2[0..]); } test "bcrypt" { const s = try strHash("password", 5); try strVerify(s, "password"); - testing.expectError(error.PasswordVerificationFailed, strVerify(s, "invalid password")); + try testing.expectError(error.PasswordVerificationFailed, strVerify(s, "invalid password")); const long_s = try strHash("password" ** 100, 5); try strVerify(long_s, "password" ** 100); diff --git a/lib/std/crypto/blake2.zig b/lib/std/crypto/blake2.zig index 4203a99459..e0b9eff5b9 100644 --- a/lib/std/crypto/blake2.zig +++ b/lib/std/crypto/blake2.zig @@ -194,16 +194,16 @@ pub fn Blake2s(comptime out_bits: usize) type { test "blake2s160 single" { const h1 = "354c9c33f735962418bdacb9479873429c34916f"; - htest.assertEqualHash(Blake2s160, h1, ""); + try htest.assertEqualHash(Blake2s160, h1, ""); const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17"; - htest.assertEqualHash(Blake2s160, h2, "abc"); + try htest.assertEqualHash(Blake2s160, h2, "abc"); const h3 = "5a604fec9713c369e84b0ed68daed7d7504ef240"; - htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0"; - htest.assertEqualHash(Blake2s160, h4, "a" ** 32 ++ "b" ** 32); + try htest.assertEqualHash(Blake2s160, h4, "a" ** 32 ++ "b" ** 32); } test "blake2s160 streaming" { @@ -213,21 +213,21 @@ test "blake2s160 streaming" { const h1 = "354c9c33f735962418bdacb9479873429c34916f"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "5ae3b99be29b01834c3b508521ede60438f8de17"; h = Blake2s160.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2s160.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0"; @@ -235,12 +235,12 @@ test "blake2s160 streaming" { h.update("a" ** 32); h.update("b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2s160.init(.{}); h.update("a" ** 32 ++ "b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); const h4 = "4667fd60791a7fe41f939bca646b4529e296bd68"; @@ -248,12 +248,12 @@ test "blake2s160 streaming" { h.update("a" ** 32); h.update("b" ** 32); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); h = Blake2s160.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 }); h.update("a" ** 32 ++ "b" ** 32); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); } test "comptime blake2s160" { @@ -265,28 +265,28 @@ test "comptime blake2s160" { const h1 = "2c56ad9d0b2c8b474aafa93ab307db2f0940105f"; - htest.assertEqualHash(Blake2s160, h1, block[0..]); + try htest.assertEqualHash(Blake2s160, h1, block[0..]); var h = Blake2s160.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } test "blake2s224 single" { const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4"; - htest.assertEqualHash(Blake2s224, h1, ""); + try htest.assertEqualHash(Blake2s224, h1, ""); const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55"; - htest.assertEqualHash(Blake2s224, h2, "abc"); + try htest.assertEqualHash(Blake2s224, h2, "abc"); const h3 = "e4e5cb6c7cae41982b397bf7b7d2d9d1949823ae78435326e8db4912"; - htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01"; - htest.assertEqualHash(Blake2s224, h4, "a" ** 32 ++ "b" ** 32); + try htest.assertEqualHash(Blake2s224, h4, "a" ** 32 ++ "b" ** 32); } test "blake2s224 streaming" { @@ -296,21 +296,21 @@ test "blake2s224 streaming" { const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "0b033fc226df7abde29f67a05d3dc62cf271ef3dfea4d387407fbd55"; h = Blake2s224.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2s224.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01"; @@ -318,12 +318,12 @@ test "blake2s224 streaming" { h.update("a" ** 32); h.update("b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2s224.init(.{}); h.update("a" ** 32 ++ "b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); const h4 = "a4d6a9d253441b80e5dfd60a04db169ffab77aec56a2855c402828c3"; @@ -331,12 +331,12 @@ test "blake2s224 streaming" { h.update("a" ** 32); h.update("b" ** 32); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); h = Blake2s224.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 }); h.update("a" ** 32 ++ "b" ** 32); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); } test "comptime blake2s224" { @@ -347,28 +347,28 @@ test "comptime blake2s224" { const h1 = "86b7611563293f8c73627df7a6d6ba25ca0548c2a6481f7d116ee576"; - htest.assertEqualHash(Blake2s224, h1, block[0..]); + try htest.assertEqualHash(Blake2s224, h1, block[0..]); var h = Blake2s224.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } test "blake2s256 single" { const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"; - htest.assertEqualHash(Blake2s256, h1, ""); + try htest.assertEqualHash(Blake2s256, h1, ""); const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"; - htest.assertEqualHash(Blake2s256, h2, "abc"); + try htest.assertEqualHash(Blake2s256, h2, "abc"); const h3 = "606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812"; - htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977"; - htest.assertEqualHash(Blake2s256, h4, "a" ** 32 ++ "b" ** 32); + try htest.assertEqualHash(Blake2s256, h4, "a" ** 32 ++ "b" ** 32); } test "blake2s256 streaming" { @@ -378,21 +378,21 @@ test "blake2s256 streaming" { const h1 = "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"; h = Blake2s256.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2s256.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977"; @@ -400,12 +400,12 @@ test "blake2s256 streaming" { h.update("a" ** 32); h.update("b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2s256.init(.{}); h.update("a" ** 32 ++ "b" ** 32); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); } test "blake2s256 keyed" { @@ -415,20 +415,20 @@ test "blake2s256 keyed" { const key = "secret_key"; Blake2s256.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key }); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); var h = Blake2s256.init(.{ .key = key }); h.update("a" ** 64 ++ "b" ** 64); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); h = Blake2s256.init(.{ .key = key }); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } test "comptime blake2s256" { @@ -439,13 +439,13 @@ test "comptime blake2s256" { const h1 = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3"; - htest.assertEqualHash(Blake2s256, h1, block[0..]); + try htest.assertEqualHash(Blake2s256, h1, block[0..]); var h = Blake2s256.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } @@ -617,16 +617,16 @@ pub fn Blake2b(comptime out_bits: usize) type { test "blake2b160 single" { const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2"; - htest.assertEqualHash(Blake2b160, h1, ""); + try htest.assertEqualHash(Blake2b160, h1, ""); const h2 = "384264f676f39536840523f284921cdc68b6846b"; - htest.assertEqualHash(Blake2b160, h2, "abc"); + try htest.assertEqualHash(Blake2b160, h2, "abc"); const h3 = "3c523ed102ab45a37d54f5610d5a983162fde84f"; - htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "43758f5de1740f651f1ae39de92260fe8bd5a11f"; - htest.assertEqualHash(Blake2b160, h4, "a" ** 64 ++ "b" ** 64); + try htest.assertEqualHash(Blake2b160, h4, "a" ** 64 ++ "b" ** 64); } test "blake2b160 streaming" { @@ -636,40 +636,40 @@ test "blake2b160 streaming" { const h1 = "3345524abf6bbe1809449224b5972c41790b6cf2"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "384264f676f39536840523f284921cdc68b6846b"; h = Blake2b160.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2b160.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "43758f5de1740f651f1ae39de92260fe8bd5a11f"; h = Blake2b160.init(.{}); h.update("a" ** 64 ++ "b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2b160.init(.{}); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2b160.init(.{}); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); const h4 = "72328f8a8200663752fc302d372b5dd9b49dd8dc"; @@ -677,13 +677,13 @@ test "blake2b160 streaming" { h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); h = Blake2b160.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 }); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); } test "comptime blake2b160" { @@ -694,28 +694,28 @@ test "comptime blake2b160" { const h1 = "8d26f158f564e3293b42f5e3d34263cb173aa9c9"; - htest.assertEqualHash(Blake2b160, h1, block[0..]); + try htest.assertEqualHash(Blake2b160, h1, block[0..]); var h = Blake2b160.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } test "blake2b384 single" { const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100"; - htest.assertEqualHash(Blake2b384, h1, ""); + try htest.assertEqualHash(Blake2b384, h1, ""); const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4"; - htest.assertEqualHash(Blake2b384, h2, "abc"); + try htest.assertEqualHash(Blake2b384, h2, "abc"); const h3 = "b7c81b228b6bd912930e8f0b5387989691c1cee1e65aade4da3b86a3c9f678fc8018f6ed9e2906720c8d2a3aeda9c03d"; - htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c"; - htest.assertEqualHash(Blake2b384, h4, "a" ** 64 ++ "b" ** 64); + try htest.assertEqualHash(Blake2b384, h4, "a" ** 64 ++ "b" ** 64); } test "blake2b384 streaming" { @@ -725,40 +725,40 @@ test "blake2b384 streaming" { const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "6f56a82c8e7ef526dfe182eb5212f7db9df1317e57815dbda46083fc30f54ee6c66ba83be64b302d7cba6ce15bb556f4"; h = Blake2b384.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2b384.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c"; h = Blake2b384.init(.{}); h.update("a" ** 64 ++ "b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2b384.init(.{}); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2b384.init(.{}); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); const h4 = "934c48fcb197031c71f583d92f98703510805e72142e0b46f5752d1e971bc86c355d556035613ff7a4154b4de09dac5c"; @@ -766,13 +766,13 @@ test "blake2b384 streaming" { h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); h = Blake2b384.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 }); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h4, out[0..]); + try htest.assertEqual(h4, out[0..]); } test "comptime blake2b384" { @@ -783,28 +783,28 @@ test "comptime blake2b384" { const h1 = "e8aa1931ea0422e4446fecdd25c16cf35c240b10cb4659dd5c776eddcaa4d922397a589404b46eb2e53d78132d05fd7d"; - htest.assertEqualHash(Blake2b384, h1, block[0..]); + try htest.assertEqualHash(Blake2b384, h1, block[0..]); var h = Blake2b384.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } test "blake2b512 single" { const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce"; - htest.assertEqualHash(Blake2b512, h1, ""); + try htest.assertEqualHash(Blake2b512, h1, ""); const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923"; - htest.assertEqualHash(Blake2b512, h2, "abc"); + try htest.assertEqualHash(Blake2b512, h2, "abc"); const h3 = "a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918"; - htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog"); + try htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog"); const h4 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920"; - htest.assertEqualHash(Blake2b512, h4, "a" ** 64 ++ "b" ** 64); + try htest.assertEqualHash(Blake2b512, h4, "a" ** 64 ++ "b" ** 64); } test "blake2b512 streaming" { @@ -814,34 +814,34 @@ test "blake2b512 streaming" { const h1 = "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923"; h = Blake2b512.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Blake2b512.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); const h3 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920"; h = Blake2b512.init(.{}); h.update("a" ** 64 ++ "b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); h = Blake2b512.init(.{}); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h3, out[0..]); + try htest.assertEqual(h3, out[0..]); } test "blake2b512 keyed" { @@ -851,20 +851,20 @@ test "blake2b512 keyed" { const key = "secret_key"; Blake2b512.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key }); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); var h = Blake2b512.init(.{ .key = key }); h.update("a" ** 64 ++ "b" ** 64); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); h = Blake2b512.init(.{ .key = key }); h.update("a" ** 64); h.update("b" ** 64); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } test "comptime blake2b512" { @@ -875,12 +875,12 @@ test "comptime blake2b512" { const h1 = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf798e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41"; - htest.assertEqualHash(Blake2b512, h1, block[0..]); + try htest.assertEqualHash(Blake2b512, h1, block[0..]); var h = Blake2b512.init(.{}); h.update(&block); h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); } } diff --git a/lib/std/crypto/blake3.zig b/lib/std/crypto/blake3.zig index a10c50b074..e6b5e42f47 100644 --- a/lib/std/crypto/blake3.zig +++ b/lib/std/crypto/blake3.zig @@ -641,7 +641,7 @@ const reference_test = ReferenceTest{ }, }; -fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void { +fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void { // Save initial state const initial_state = hasher.*; @@ -664,7 +664,7 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void { // Compare to expected value var expected_bytes: [expected_hex.len / 2]u8 = undefined; _ = fmt.hexToBytes(expected_bytes[0..], expected_hex[0..]) catch unreachable; - testing.expectEqual(actual_bytes, expected_bytes); + try testing.expectEqual(actual_bytes, expected_bytes); // Restore initial state hasher.* = initial_state; @@ -676,8 +676,8 @@ test "BLAKE3 reference test cases" { var derive_key = &Blake3.initKdf(reference_test.context_string, .{}); for (reference_test.cases) |t| { - testBlake3(hash, t.input_len, t.hash.*); - testBlake3(keyed_hash, t.input_len, t.keyed_hash.*); - testBlake3(derive_key, t.input_len, t.derive_key.*); + try testBlake3(hash, t.input_len, t.hash.*); + try testBlake3(keyed_hash, t.input_len, t.keyed_hash.*); + try testBlake3(derive_key, t.input_len, t.derive_key.*); } } diff --git a/lib/std/crypto/chacha20.zig b/lib/std/crypto/chacha20.zig index ea9eafd356..b007d52353 100644 --- a/lib/std/crypto/chacha20.zig +++ b/lib/std/crypto/chacha20.zig @@ -604,9 +604,9 @@ test "chacha20 AEAD API" { aead.encrypt(c[0..], tag[0..], m, ad, nonce, key); try aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key); - testing.expectEqualSlices(u8, out[0..], m); + try testing.expectEqualSlices(u8, out[0..], m); c[0] += 1; - testing.expectError(error.AuthenticationFailed, aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key)); + try testing.expectError(error.AuthenticationFailed, aead.decrypt(out[0..], c[0..], tag, ad[0..], nonce, key)); } } @@ -644,11 +644,11 @@ test "crypto.chacha20 test vector sunscreen" { }; ChaCha20IETF.xor(result[0..], m[0..], 1, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); var m2: [114]u8 = undefined; ChaCha20IETF.xor(m2[0..], result[0..], 1, key, nonce); - testing.expect(mem.order(u8, m, &m2) == .eq); + try testing.expect(mem.order(u8, m, &m2) == .eq); } // https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7 @@ -683,7 +683,7 @@ test "crypto.chacha20 test vector 1" { const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 }; ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); } test "crypto.chacha20 test vector 2" { @@ -717,7 +717,7 @@ test "crypto.chacha20 test vector 2" { const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0 }; ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); } test "crypto.chacha20 test vector 3" { @@ -751,7 +751,7 @@ test "crypto.chacha20 test vector 3" { const nonce = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 1 }; ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); } test "crypto.chacha20 test vector 4" { @@ -785,7 +785,7 @@ test "crypto.chacha20 test vector 4" { const nonce = [_]u8{ 1, 0, 0, 0, 0, 0, 0, 0 }; ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); } test "crypto.chacha20 test vector 5" { @@ -857,7 +857,7 @@ test "crypto.chacha20 test vector 5" { }; ChaCha20With64BitNonce.xor(result[0..], m[0..], 0, key, nonce); - testing.expectEqualSlices(u8, &expected_result, &result); + try testing.expectEqualSlices(u8, &expected_result, &result); } test "seal" { @@ -873,7 +873,7 @@ test "seal" { var out: [exp_out.len]u8 = undefined; ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m, ad, nonce, key); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } { const m = [_]u8{ @@ -906,7 +906,7 @@ test "seal" { var out: [exp_out.len]u8 = undefined; ChaCha20Poly1305.encrypt(out[0..m.len], out[m.len..], m[0..], ad[0..], nonce, key); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } } @@ -923,7 +923,7 @@ test "open" { var out: [exp_out.len]u8 = undefined; try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); } { const c = [_]u8{ @@ -956,21 +956,21 @@ test "open" { var out: [exp_out.len]u8 = undefined; try ChaCha20Poly1305.decrypt(out[0..], c[0..exp_out.len], c[exp_out.len..].*, ad[0..], nonce, key); - testing.expectEqualSlices(u8, exp_out[0..], out[0..]); + try testing.expectEqualSlices(u8, exp_out[0..], out[0..]); // corrupting the ciphertext, data, key, or nonce should cause a failure var bad_c = c; bad_c[0] ^= 1; - testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], bad_c[0..out.len], bad_c[out.len..].*, ad[0..], nonce, key)); + try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], bad_c[0..out.len], bad_c[out.len..].*, ad[0..], nonce, key)); var bad_ad = ad; bad_ad[0] ^= 1; - testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, bad_ad[0..], nonce, key)); + try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, bad_ad[0..], nonce, key)); var bad_key = key; bad_key[0] ^= 1; - testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], nonce, bad_key)); + try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], nonce, bad_key)); var bad_nonce = nonce; bad_nonce[0] ^= 1; - testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], bad_nonce, key)); + try testing.expectError(error.AuthenticationFailed, ChaCha20Poly1305.decrypt(out[0..], c[0..out.len], c[out.len..].*, ad[0..], bad_nonce, key)); } } @@ -982,7 +982,7 @@ test "crypto.xchacha20" { var c: [m.len]u8 = undefined; XChaCha20IETF.xor(c[0..], m[0..], 0, key, nonce); var buf: [2 * c.len]u8 = undefined; - testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "E0A1BCF939654AFDBDC1746EC49832647C19D891F0D1A81FC0C1703B4514BDEA584B512F6908C2C5E9DD18D5CBC1805DE5803FE3B9CA5F193FB8359E91FAB0C3BB40309A292EB1CF49685C65C4A3ADF4F11DB0CD2B6B67FBC174BC2E860E8F769FD3565BBFAD1C845E05A0FED9BE167C240D"); + try testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "E0A1BCF939654AFDBDC1746EC49832647C19D891F0D1A81FC0C1703B4514BDEA584B512F6908C2C5E9DD18D5CBC1805DE5803FE3B9CA5F193FB8359E91FAB0C3BB40309A292EB1CF49685C65C4A3ADF4F11DB0CD2B6B67FBC174BC2E860E8F769FD3565BBFAD1C845E05A0FED9BE167C240D"); } { const ad = "Additional data"; @@ -991,9 +991,9 @@ test "crypto.xchacha20" { var out: [m.len]u8 = undefined; try XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key); var buf: [2 * c.len]u8 = undefined; - testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "994D2DD32333F48E53650C02C7A2ABB8E018B0836D7175AEC779F52E961780768F815C58F1AA52D211498DB89B9216763F569C9433A6BBFCEFB4D4A49387A4C5207FBB3B5A92B5941294DF30588C6740D39DC16FA1F0E634F7246CF7CDCB978E44347D89381B7A74EB7084F754B90BDE9AAF5A94B8F2A85EFD0B50692AE2D425E234"); - testing.expectEqualSlices(u8, out[0..], m); + try testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&c)}), "994D2DD32333F48E53650C02C7A2ABB8E018B0836D7175AEC779F52E961780768F815C58F1AA52D211498DB89B9216763F569C9433A6BBFCEFB4D4A49387A4C5207FBB3B5A92B5941294DF30588C6740D39DC16FA1F0E634F7246CF7CDCB978E44347D89381B7A74EB7084F754B90BDE9AAF5A94B8F2A85EFD0B50692AE2D425E234"); + try testing.expectEqualSlices(u8, out[0..], m); c[0] += 1; - testing.expectError(error.AuthenticationFailed, XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key)); + try testing.expectError(error.AuthenticationFailed, XChaCha20Poly1305.decrypt(out[0..], c[0..m.len], c[m.len..].*, ad, nonce, key)); } } diff --git a/lib/std/crypto/ghash.zig b/lib/std/crypto/ghash.zig index ffc9ef41ae..e5eb3fc496 100644 --- a/lib/std/crypto/ghash.zig +++ b/lib/std/crypto/ghash.zig @@ -326,11 +326,11 @@ test "ghash" { st.update(&m); var out: [16]u8 = undefined; st.final(&out); - htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out); + try htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out); st = Ghash.init(&key); st.update(m[0..100]); st.update(m[100..]); st.final(&out); - htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out); + try htest.assertEqual("889295fa746e8b174bf4ec80a65dea41", &out); } diff --git a/lib/std/crypto/gimli.zig b/lib/std/crypto/gimli.zig index fb67c25343..0485769193 100644 --- a/lib/std/crypto/gimli.zig +++ b/lib/std/crypto/gimli.zig @@ -205,7 +205,7 @@ test "permute" { while (i < 12) : (i += 1) { mem.writeIntLittle(u32, expected_output[i * 4 ..][0..4], tv_output[i / 4][i % 4]); } - testing.expectEqualSlices(u8, state.toSliceConst(), expected_output[0..]); + try testing.expectEqualSlices(u8, state.toSliceConst(), expected_output[0..]); } pub const Hash = struct { @@ -274,7 +274,7 @@ test "hash" { _ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C"); var md: [32]u8 = undefined; hash(&md, &msg, .{}); - htest.assertEqual("1C9A03DC6A5DDC5444CFC6F4B154CFF5CF081633B2CEA4D7D0AE7CCFED5AAA44", &md); + try htest.assertEqual("1C9A03DC6A5DDC5444CFC6F4B154CFF5CF081633B2CEA4D7D0AE7CCFED5AAA44", &md); } test "hash test vector 17" { @@ -282,7 +282,7 @@ test "hash test vector 17" { _ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F"); var md: [32]u8 = undefined; hash(&md, &msg, .{}); - htest.assertEqual("404C130AF1B9023A7908200919F690FFBB756D5176E056FFDE320016A37C7282", &md); + try htest.assertEqual("404C130AF1B9023A7908200919F690FFBB756D5176E056FFDE320016A37C7282", &md); } test "hash test vector 33" { @@ -290,7 +290,7 @@ test "hash test vector 33" { _ = try std.fmt.hexToBytes(&msg, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"); var md: [32]u8 = undefined; hash(&md, &msg, .{}); - htest.assertEqual("A8F4FA28708BDA7EFB4C1914CA4AFA9E475B82D588D36504F87DBB0ED9AB3C4B", &md); + try htest.assertEqual("A8F4FA28708BDA7EFB4C1914CA4AFA9E475B82D588D36504F87DBB0ED9AB3C4B", &md); } pub const Aead = struct { @@ -447,12 +447,12 @@ test "cipher" { var ct: [pt.len]u8 = undefined; var tag: [16]u8 = undefined; Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key); - htest.assertEqual("", &ct); - htest.assertEqual("14DA9BB7120BF58B985A8E00FDEBA15B", &tag); + try htest.assertEqual("", &ct); + try htest.assertEqual("14DA9BB7120BF58B985A8E00FDEBA15B", &tag); var pt2: [pt.len]u8 = undefined; try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &pt, &pt2); + try testing.expectEqualSlices(u8, &pt, &pt2); } { // test vector (34) from NIST KAT submission. const ad: [0]u8 = undefined; @@ -462,12 +462,12 @@ test "cipher" { var ct: [pt.len]u8 = undefined; var tag: [16]u8 = undefined; Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key); - htest.assertEqual("7F", &ct); - htest.assertEqual("80492C317B1CD58A1EDC3A0D3E9876FC", &tag); + try htest.assertEqual("7F", &ct); + try htest.assertEqual("80492C317B1CD58A1EDC3A0D3E9876FC", &tag); var pt2: [pt.len]u8 = undefined; try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &pt, &pt2); + try testing.expectEqualSlices(u8, &pt, &pt2); } { // test vector (106) from NIST KAT submission. var ad: [12 / 2]u8 = undefined; @@ -478,12 +478,12 @@ test "cipher" { var ct: [pt.len]u8 = undefined; var tag: [16]u8 = undefined; Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key); - htest.assertEqual("484D35", &ct); - htest.assertEqual("030BBEA23B61C00CED60A923BDCF9147", &tag); + try htest.assertEqual("484D35", &ct); + try htest.assertEqual("030BBEA23B61C00CED60A923BDCF9147", &tag); var pt2: [pt.len]u8 = undefined; try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &pt, &pt2); + try testing.expectEqualSlices(u8, &pt, &pt2); } { // test vector (790) from NIST KAT submission. var ad: [60 / 2]u8 = undefined; @@ -494,12 +494,12 @@ test "cipher" { var ct: [pt.len]u8 = undefined; var tag: [16]u8 = undefined; Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key); - htest.assertEqual("6815B4A0ECDAD01596EAD87D9E690697475D234C6A13D1", &ct); - htest.assertEqual("DFE23F1642508290D68245279558B2FB", &tag); + try htest.assertEqual("6815B4A0ECDAD01596EAD87D9E690697475D234C6A13D1", &ct); + try htest.assertEqual("DFE23F1642508290D68245279558B2FB", &tag); var pt2: [pt.len]u8 = undefined; try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &pt, &pt2); + try testing.expectEqualSlices(u8, &pt, &pt2); } { // test vector (1057) from NIST KAT submission. const ad: [0]u8 = undefined; @@ -509,11 +509,11 @@ test "cipher" { var ct: [pt.len]u8 = undefined; var tag: [16]u8 = undefined; Aead.encrypt(&ct, &tag, &pt, &ad, nonce, key); - htest.assertEqual("7F8A2CF4F52AA4D6B2E74105C30A2777B9D0C8AEFDD555DE35861BD3011F652F", &ct); - htest.assertEqual("7256456FA935AC34BBF55AE135F33257", &tag); + try htest.assertEqual("7F8A2CF4F52AA4D6B2E74105C30A2777B9D0C8AEFDD555DE35861BD3011F652F", &ct); + try htest.assertEqual("7256456FA935AC34BBF55AE135F33257", &tag); var pt2: [pt.len]u8 = undefined; try Aead.decrypt(&pt2, &ct, tag, &ad, nonce, key); - testing.expectEqualSlices(u8, &pt, &pt2); + try testing.expectEqualSlices(u8, &pt, &pt2); } } diff --git a/lib/std/crypto/hkdf.zig b/lib/std/crypto/hkdf.zig index c0f919ef82..81c541231d 100644 --- a/lib/std/crypto/hkdf.zig +++ b/lib/std/crypto/hkdf.zig @@ -65,8 +65,8 @@ test "Hkdf" { const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 }; const kdf = HkdfSha256; const prk = kdf.extract(&salt, &ikm); - htest.assertEqual("077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5", &prk); + try htest.assertEqual("077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5", &prk); var out: [42]u8 = undefined; kdf.expand(&out, &context, prk); - htest.assertEqual("3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865", &out); + try htest.assertEqual("3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865", &out); } diff --git a/lib/std/crypto/hmac.zig b/lib/std/crypto/hmac.zig index 7f29c62941..12c4a53e0f 100644 --- a/lib/std/crypto/hmac.zig +++ b/lib/std/crypto/hmac.zig @@ -84,26 +84,26 @@ const htest = @import("test.zig"); test "hmac md5" { var out: [HmacMd5.mac_length]u8 = undefined; HmacMd5.create(out[0..], "", ""); - htest.assertEqual("74e6f7298a9c2d168935f58c001bad88", out[0..]); + try htest.assertEqual("74e6f7298a9c2d168935f58c001bad88", out[0..]); HmacMd5.create(out[0..], "The quick brown fox jumps over the lazy dog", "key"); - htest.assertEqual("80070713463e7749b90c2dc24911e275", out[0..]); + try htest.assertEqual("80070713463e7749b90c2dc24911e275", out[0..]); } test "hmac sha1" { var out: [HmacSha1.mac_length]u8 = undefined; HmacSha1.create(out[0..], "", ""); - htest.assertEqual("fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", out[0..]); + try htest.assertEqual("fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", out[0..]); HmacSha1.create(out[0..], "The quick brown fox jumps over the lazy dog", "key"); - htest.assertEqual("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", out[0..]); + try htest.assertEqual("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", out[0..]); } test "hmac sha256" { var out: [sha2.HmacSha256.mac_length]u8 = undefined; sha2.HmacSha256.create(out[0..], "", ""); - htest.assertEqual("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad", out[0..]); + try htest.assertEqual("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad", out[0..]); sha2.HmacSha256.create(out[0..], "The quick brown fox jumps over the lazy dog", "key"); - htest.assertEqual("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", out[0..]); + try htest.assertEqual("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", out[0..]); } diff --git a/lib/std/crypto/isap.zig b/lib/std/crypto/isap.zig index 6deb4977bb..c7706df1df 100644 --- a/lib/std/crypto/isap.zig +++ b/lib/std/crypto/isap.zig @@ -240,8 +240,8 @@ test "ISAP" { var msg = "test"; var c: [msg.len]u8 = undefined; IsapA128A.encrypt(c[0..], &tag, msg[0..], ad, n, k); - testing.expect(mem.eql(u8, &[_]u8{ 0x8f, 0x68, 0x03, 0x8d }, c[0..])); - testing.expect(mem.eql(u8, &[_]u8{ 0x6c, 0x25, 0xe8, 0xe2, 0xe1, 0x1f, 0x38, 0xe9, 0x80, 0x75, 0xde, 0xd5, 0x2d, 0xb2, 0x31, 0x82 }, tag[0..])); + try testing.expect(mem.eql(u8, &[_]u8{ 0x8f, 0x68, 0x03, 0x8d }, c[0..])); + 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..])); try IsapA128A.decrypt(c[0..], c[0..], tag, ad, n, k); - testing.expect(mem.eql(u8, msg, c[0..])); + try testing.expect(mem.eql(u8, msg, c[0..])); } diff --git a/lib/std/crypto/md5.zig b/lib/std/crypto/md5.zig index 78454ce3c1..d4109eed8a 100644 --- a/lib/std/crypto/md5.zig +++ b/lib/std/crypto/md5.zig @@ -241,13 +241,13 @@ pub const Md5 = struct { const htest = @import("test.zig"); test "md5 single" { - htest.assertEqualHash(Md5, "d41d8cd98f00b204e9800998ecf8427e", ""); - htest.assertEqualHash(Md5, "0cc175b9c0f1b6a831c399e269772661", "a"); - htest.assertEqualHash(Md5, "900150983cd24fb0d6963f7d28e17f72", "abc"); - htest.assertEqualHash(Md5, "f96b697d7cb7938d525a2f31aaf161d0", "message digest"); - htest.assertEqualHash(Md5, "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz"); - htest.assertEqualHash(Md5, "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"); - htest.assertEqualHash(Md5, "57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890"); + try htest.assertEqualHash(Md5, "d41d8cd98f00b204e9800998ecf8427e", ""); + try htest.assertEqualHash(Md5, "0cc175b9c0f1b6a831c399e269772661", "a"); + try htest.assertEqualHash(Md5, "900150983cd24fb0d6963f7d28e17f72", "abc"); + try htest.assertEqualHash(Md5, "f96b697d7cb7938d525a2f31aaf161d0", "message digest"); + try htest.assertEqualHash(Md5, "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz"); + try htest.assertEqualHash(Md5, "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"); + try htest.assertEqualHash(Md5, "57edf4a22be3c955ac49da2e2107b67a", "12345678901234567890123456789012345678901234567890123456789012345678901234567890"); } test "md5 streaming" { @@ -255,12 +255,12 @@ test "md5 streaming" { var out: [16]u8 = undefined; h.final(out[0..]); - htest.assertEqual("d41d8cd98f00b204e9800998ecf8427e", out[0..]); + try htest.assertEqual("d41d8cd98f00b204e9800998ecf8427e", out[0..]); h = Md5.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]); + try htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]); h = Md5.init(.{}); h.update("a"); @@ -268,7 +268,7 @@ test "md5 streaming" { h.update("c"); h.final(out[0..]); - htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]); + try htest.assertEqual("900150983cd24fb0d6963f7d28e17f72", out[0..]); } test "md5 aligned final" { diff --git a/lib/std/crypto/pbkdf2.zig b/lib/std/crypto/pbkdf2.zig index f93a5235af..b3e2a32bf3 100644 --- a/lib/std/crypto/pbkdf2.zig +++ b/lib/std/crypto/pbkdf2.zig @@ -168,7 +168,7 @@ test "RFC 6070 one iteration" { const expected = "0c60c80f961f0e71f3a9b524af6012062fe037a6"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "RFC 6070 two iterations" { @@ -183,7 +183,7 @@ test "RFC 6070 two iterations" { const expected = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "RFC 6070 4096 iterations" { @@ -198,7 +198,7 @@ test "RFC 6070 4096 iterations" { const expected = "4b007901b765489abead49d926f721d065a429c1"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "RFC 6070 16,777,216 iterations" { @@ -218,7 +218,7 @@ test "RFC 6070 16,777,216 iterations" { const expected = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "RFC 6070 multi-block salt and password" { @@ -233,7 +233,7 @@ test "RFC 6070 multi-block salt and password" { const expected = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "RFC 6070 embedded NUL" { @@ -248,7 +248,7 @@ test "RFC 6070 embedded NUL" { const expected = "56fa6aa75548099dcc37d7f03425e0c3"; - htest.assertEqual(expected, dk[0..]); + try htest.assertEqual(expected, dk[0..]); } test "Very large dk_len" { diff --git a/lib/std/crypto/pcurves/tests.zig b/lib/std/crypto/pcurves/tests.zig index 4e8e08a7fe..6d9682abf1 100644 --- a/lib/std/crypto/pcurves/tests.zig +++ b/lib/std/crypto/pcurves/tests.zig @@ -17,7 +17,7 @@ test "p256 ECDH key exchange" { const dhB = try P256.basePoint.mul(dhb, .Little); const shareda = try dhA.mul(dhb, .Little); const sharedb = try dhB.mul(dha, .Little); - testing.expect(shareda.equivalent(sharedb)); + try testing.expect(shareda.equivalent(sharedb)); } test "p256 point from affine coordinates" { @@ -28,7 +28,7 @@ test "p256 point from affine coordinates" { var ys: [32]u8 = undefined; _ = try fmt.hexToBytes(&ys, yh); var p = try P256.fromSerializedAffineCoordinates(xs, ys, .Big); - testing.expect(p.equivalent(P256.basePoint)); + try testing.expect(p.equivalent(P256.basePoint)); } test "p256 test vectors" { @@ -50,7 +50,7 @@ test "p256 test vectors" { p = p.add(P256.basePoint); var xs: [32]u8 = undefined; _ = try fmt.hexToBytes(&xs, xh); - testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs); + try testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs); } } @@ -67,7 +67,7 @@ test "p256 test vectors - doubling" { p = p.dbl(); var xs: [32]u8 = undefined; _ = try fmt.hexToBytes(&xs, xh); - testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs); + try testing.expectEqualSlices(u8, &x.toBytes(.Big), &xs); } } @@ -75,29 +75,29 @@ test "p256 compressed sec1 encoding/decoding" { const p = P256.random(); const s = p.toCompressedSec1(); const q = try P256.fromSec1(&s); - testing.expect(p.equivalent(q)); + try testing.expect(p.equivalent(q)); } test "p256 uncompressed sec1 encoding/decoding" { const p = P256.random(); const s = p.toUncompressedSec1(); const q = try P256.fromSec1(&s); - testing.expect(p.equivalent(q)); + try testing.expect(p.equivalent(q)); } test "p256 public key is the neutral element" { const n = P256.scalar.Scalar.zero.toBytes(.Little); const p = P256.random(); - testing.expectError(error.IdentityElement, p.mul(n, .Little)); + try testing.expectError(error.IdentityElement, p.mul(n, .Little)); } test "p256 public key is the neutral element (public verification)" { const n = P256.scalar.Scalar.zero.toBytes(.Little); const p = P256.random(); - testing.expectError(error.IdentityElement, p.mulPublic(n, .Little)); + try testing.expectError(error.IdentityElement, p.mulPublic(n, .Little)); } test "p256 field element non-canonical encoding" { const s = [_]u8{0xff} ** 32; - testing.expectError(error.NonCanonical, P256.Fe.fromBytes(s, .Little)); + try testing.expectError(error.NonCanonical, P256.Fe.fromBytes(s, .Little)); } diff --git a/lib/std/crypto/poly1305.zig b/lib/std/crypto/poly1305.zig index 375cf0a3cb..e93afac859 100644 --- a/lib/std/crypto/poly1305.zig +++ b/lib/std/crypto/poly1305.zig @@ -216,5 +216,5 @@ test "poly1305 rfc7439 vector1" { var mac: [16]u8 = undefined; Poly1305.create(mac[0..], msg, key); - std.testing.expectEqualSlices(u8, expected_mac, &mac); + try std.testing.expectEqualSlices(u8, expected_mac, &mac); } diff --git a/lib/std/crypto/salsa20.zig b/lib/std/crypto/salsa20.zig index 2a06944adc..8a800c8a40 100644 --- a/lib/std/crypto/salsa20.zig +++ b/lib/std/crypto/salsa20.zig @@ -561,11 +561,11 @@ test "(x)salsa20" { var c: [msg.len]u8 = undefined; Salsa20.xor(&c, msg[0..], 0, key, nonce); - htest.assertEqual("30ff9933aa6534ff5207142593cd1fca4b23bdd8", c[0..]); + try htest.assertEqual("30ff9933aa6534ff5207142593cd1fca4b23bdd8", c[0..]); const extended_nonce = [_]u8{0x42} ** 24; XSalsa20.xor(&c, msg[0..], 0, key, extended_nonce); - htest.assertEqual("b4ab7d82e750ec07644fa3281bce6cd91d4243f9", c[0..]); + try htest.assertEqual("b4ab7d82e750ec07644fa3281bce6cd91d4243f9", c[0..]); } test "xsalsa20poly1305" { @@ -628,5 +628,5 @@ test "secretbox twoblocks" { const msg = [_]u8{'a'} ** 97; var ciphertext: [msg.len + SecretBox.tag_length]u8 = undefined; SecretBox.seal(&ciphertext, &msg, nonce, key); - htest.assertEqual("b05760e217288ba079caa2fd57fd3701784974ffcfda20fe523b89211ad8af065a6eb37cdb29d51aca5bd75dafdd21d18b044c54bb7c526cf576c94ee8900f911ceab0147e82b667a28c52d58ceb29554ff45471224d37b03256b01c119b89ff6d36855de8138d103386dbc9d971f52261", &ciphertext); + try htest.assertEqual("b05760e217288ba079caa2fd57fd3701784974ffcfda20fe523b89211ad8af065a6eb37cdb29d51aca5bd75dafdd21d18b044c54bb7c526cf576c94ee8900f911ceab0147e82b667a28c52d58ceb29554ff45471224d37b03256b01c119b89ff6d36855de8138d103386dbc9d971f52261", &ciphertext); } diff --git a/lib/std/crypto/sha1.zig b/lib/std/crypto/sha1.zig index ac699f0ef1..6bf6b469e2 100644 --- a/lib/std/crypto/sha1.zig +++ b/lib/std/crypto/sha1.zig @@ -265,9 +265,9 @@ pub const Sha1 = struct { const htest = @import("test.zig"); test "sha1 single" { - htest.assertEqualHash(Sha1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", ""); - htest.assertEqualHash(Sha1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc"); - htest.assertEqualHash(Sha1, "a49b2446a02c645bf419f995b67091253a04a259", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha1, "da39a3ee5e6b4b0d3255bfef95601890afd80709", ""); + try htest.assertEqualHash(Sha1, "a9993e364706816aba3e25717850c26c9cd0d89d", "abc"); + try htest.assertEqualHash(Sha1, "a49b2446a02c645bf419f995b67091253a04a259", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha1 streaming" { @@ -275,19 +275,19 @@ test "sha1 streaming" { var out: [20]u8 = undefined; h.final(&out); - htest.assertEqual("da39a3ee5e6b4b0d3255bfef95601890afd80709", out[0..]); + try htest.assertEqual("da39a3ee5e6b4b0d3255bfef95601890afd80709", out[0..]); h = Sha1.init(.{}); h.update("abc"); h.final(&out); - htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]); + try htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]); h = Sha1.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(&out); - htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]); + try htest.assertEqual("a9993e364706816aba3e25717850c26c9cd0d89d", out[0..]); } test "sha1 aligned final" { diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig index 5a37004e8c..ece2a3abfb 100644 --- a/lib/std/crypto/sha2.zig +++ b/lib/std/crypto/sha2.zig @@ -285,9 +285,9 @@ fn Sha2x32(comptime params: Sha2Params32) type { } test "sha224 single" { - htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", ""); - htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc"); - htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", ""); + try htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc"); + try htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha224 streaming" { @@ -295,25 +295,25 @@ test "sha224 streaming" { var out: [28]u8 = undefined; h.final(out[0..]); - htest.assertEqual("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", out[0..]); + try htest.assertEqual("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", out[0..]); h = Sha224.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]); + try htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]); h = Sha224.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]); + try htest.assertEqual("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", out[0..]); } test "sha256 single" { - htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", ""); - htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc"); - htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", ""); + try htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc"); + try htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha256 streaming" { @@ -321,19 +321,19 @@ test "sha256 streaming" { var out: [32]u8 = undefined; h.final(out[0..]); - htest.assertEqual("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", out[0..]); + try htest.assertEqual("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", out[0..]); h = Sha256.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]); + try htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]); h = Sha256.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]); + try htest.assertEqual("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", out[0..]); } test "sha256 aligned final" { @@ -675,13 +675,13 @@ fn Sha2x64(comptime params: Sha2Params64) type { test "sha384 single" { const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"; - htest.assertEqualHash(Sha384, h1, ""); + try htest.assertEqualHash(Sha384, h1, ""); const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7"; - htest.assertEqualHash(Sha384, h2, "abc"); + try htest.assertEqualHash(Sha384, h2, "abc"); const h3 = "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039"; - htest.assertEqualHash(Sha384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha384 streaming" { @@ -690,32 +690,32 @@ test "sha384 streaming" { const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7"; h = Sha384.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Sha384.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); } test "sha512 single" { const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"; - htest.assertEqualHash(Sha512, h1, ""); + try htest.assertEqualHash(Sha512, h1, ""); const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"; - htest.assertEqualHash(Sha512, h2, "abc"); + try htest.assertEqualHash(Sha512, h2, "abc"); const h3 = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"; - htest.assertEqualHash(Sha512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha512 streaming" { @@ -724,21 +724,21 @@ test "sha512 streaming" { const h1 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"; h = Sha512.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Sha512.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); } test "sha512 aligned final" { diff --git a/lib/std/crypto/sha3.zig b/lib/std/crypto/sha3.zig index d68821133e..d642d631e0 100644 --- a/lib/std/crypto/sha3.zig +++ b/lib/std/crypto/sha3.zig @@ -169,9 +169,9 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void { } test "sha3-224 single" { - htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", ""); - htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc"); - htest.assertEqualHash(Sha3_224, "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", ""); + try htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc"); + try htest.assertEqualHash(Sha3_224, "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha3-224 streaming" { @@ -179,25 +179,25 @@ test "sha3-224 streaming" { var out: [28]u8 = undefined; h.final(out[0..]); - htest.assertEqual("6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", out[0..]); + try htest.assertEqual("6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", out[0..]); h = Sha3_224.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]); + try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]); h = Sha3_224.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]); + try htest.assertEqual("e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", out[0..]); } test "sha3-256 single" { - htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", ""); - htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc"); - htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", ""); + try htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc"); + try htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha3-256 streaming" { @@ -205,19 +205,19 @@ test "sha3-256 streaming" { var out: [32]u8 = undefined; h.final(out[0..]); - htest.assertEqual("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", out[0..]); + try htest.assertEqual("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", out[0..]); h = Sha3_256.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]); + try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]); h = Sha3_256.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]); + try htest.assertEqual("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", out[0..]); } test "sha3-256 aligned final" { @@ -231,11 +231,11 @@ test "sha3-256 aligned final" { test "sha3-384 single" { const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004"; - htest.assertEqualHash(Sha3_384, h1, ""); + try htest.assertEqualHash(Sha3_384, h1, ""); const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25"; - htest.assertEqualHash(Sha3_384, h2, "abc"); + try htest.assertEqualHash(Sha3_384, h2, "abc"); const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7"; - htest.assertEqualHash(Sha3_384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha3_384, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha3-384 streaming" { @@ -244,29 +244,29 @@ test "sha3-384 streaming" { const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25"; h = Sha3_384.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Sha3_384.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); } test "sha3-512 single" { const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"; - htest.assertEqualHash(Sha3_512, h1, ""); + try htest.assertEqualHash(Sha3_512, h1, ""); const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0"; - htest.assertEqualHash(Sha3_512, h2, "abc"); + try htest.assertEqualHash(Sha3_512, h2, "abc"); const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185"; - htest.assertEqualHash(Sha3_512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Sha3_512, h3, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "sha3-512 streaming" { @@ -275,20 +275,20 @@ test "sha3-512 streaming" { const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"; h.final(out[0..]); - htest.assertEqual(h1, out[0..]); + try htest.assertEqual(h1, out[0..]); const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0"; h = Sha3_512.init(.{}); h.update("abc"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); h = Sha3_512.init(.{}); h.update("a"); h.update("b"); h.update("c"); h.final(out[0..]); - htest.assertEqual(h2, out[0..]); + try htest.assertEqual(h2, out[0..]); } test "sha3-512 aligned final" { @@ -301,13 +301,13 @@ test "sha3-512 aligned final" { } test "keccak-256 single" { - htest.assertEqualHash(Keccak_256, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", ""); - htest.assertEqualHash(Keccak_256, "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", "abc"); - htest.assertEqualHash(Keccak_256, "f519747ed599024f3882238e5ab43960132572b7345fbeb9a90769dafd21ad67", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Keccak_256, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", ""); + try htest.assertEqualHash(Keccak_256, "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", "abc"); + try htest.assertEqualHash(Keccak_256, "f519747ed599024f3882238e5ab43960132572b7345fbeb9a90769dafd21ad67", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } test "keccak-512 single" { - htest.assertEqualHash(Keccak_512, "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", ""); - htest.assertEqualHash(Keccak_512, "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc"); - htest.assertEqualHash(Keccak_512, "ac2fb35251825d3aa48468a9948c0a91b8256f6d97d8fa4160faff2dd9dfcc24f3f1db7a983dad13d53439ccac0b37e24037e7b95f80f59f37a2f683c4ba4682", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); + try htest.assertEqualHash(Keccak_512, "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e", ""); + try htest.assertEqualHash(Keccak_512, "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", "abc"); + try htest.assertEqualHash(Keccak_512, "ac2fb35251825d3aa48468a9948c0a91b8256f6d97d8fa4160faff2dd9dfcc24f3f1db7a983dad13d53439ccac0b37e24037e7b95f80f59f37a2f683c4ba4682", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"); } diff --git a/lib/std/crypto/siphash.zig b/lib/std/crypto/siphash.zig index 67bb2a329a..3bed5d1086 100644 --- a/lib/std/crypto/siphash.zig +++ b/lib/std/crypto/siphash.zig @@ -319,7 +319,7 @@ test "siphash64-2-4 sanity" { var out: [siphash.mac_length]u8 = undefined; siphash.create(&out, buffer[0..i], test_key); - testing.expectEqual(out, vector); + try testing.expectEqual(out, vector); } } @@ -399,7 +399,7 @@ test "siphash128-2-4 sanity" { var out: [siphash.mac_length]u8 = undefined; siphash.create(&out, buffer[0..i], test_key[0..]); - testing.expectEqual(out, vector); + try testing.expectEqual(out, vector); } } @@ -423,6 +423,6 @@ test "iterative non-divisible update" { } const iterative_hash = siphash.finalInt(); - std.testing.expectEqual(iterative_hash, non_iterative_hash); + try std.testing.expectEqual(iterative_hash, non_iterative_hash); } } diff --git a/lib/std/crypto/test.zig b/lib/std/crypto/test.zig index cab07c50ec..b517fbecb1 100644 --- a/lib/std/crypto/test.zig +++ b/lib/std/crypto/test.zig @@ -8,19 +8,19 @@ const testing = std.testing; const fmt = std.fmt; // Hash using the specified hasher `H` asserting `expected == H(input)`. -pub fn assertEqualHash(comptime Hasher: anytype, comptime expected_hex: *const [Hasher.digest_length * 2:0]u8, input: []const u8) void { +pub fn assertEqualHash(comptime Hasher: anytype, comptime expected_hex: *const [Hasher.digest_length * 2:0]u8, input: []const u8) !void { var h: [Hasher.digest_length]u8 = undefined; Hasher.hash(input, &h, .{}); - assertEqual(expected_hex, &h); + try assertEqual(expected_hex, &h); } // Assert `expected` == hex(`input`) where `input` is a bytestring -pub fn assertEqual(comptime expected_hex: [:0]const u8, input: []const u8) void { +pub fn assertEqual(comptime expected_hex: [:0]const u8, input: []const u8) !void { var expected_bytes: [expected_hex.len / 2]u8 = undefined; for (expected_bytes) |*r, i| { r.* = fmt.parseInt(u8, expected_hex[2 * i .. 2 * i + 2], 16) catch unreachable; } - testing.expectEqualSlices(u8, &expected_bytes, input); + try testing.expectEqualSlices(u8, &expected_bytes, input); } diff --git a/lib/std/crypto/utils.zig b/lib/std/crypto/utils.zig index ca86601bf9..4c2a44b967 100644 --- a/lib/std/crypto/utils.zig +++ b/lib/std/crypto/utils.zig @@ -92,9 +92,9 @@ test "crypto.utils.timingSafeEql" { var b: [100]u8 = undefined; std.crypto.random.bytes(a[0..]); std.crypto.random.bytes(b[0..]); - testing.expect(!timingSafeEql([100]u8, a, b)); + try testing.expect(!timingSafeEql([100]u8, a, b)); mem.copy(u8, a[0..], b[0..]); - testing.expect(timingSafeEql([100]u8, a, b)); + try testing.expect(timingSafeEql([100]u8, a, b)); } test "crypto.utils.timingSafeEql (vectors)" { @@ -104,22 +104,22 @@ test "crypto.utils.timingSafeEql (vectors)" { std.crypto.random.bytes(b[0..]); const v1: std.meta.Vector(100, u8) = a; const v2: std.meta.Vector(100, u8) = b; - testing.expect(!timingSafeEql(std.meta.Vector(100, u8), v1, v2)); + try testing.expect(!timingSafeEql(std.meta.Vector(100, u8), v1, v2)); const v3: std.meta.Vector(100, u8) = a; - testing.expect(timingSafeEql(std.meta.Vector(100, u8), v1, v3)); + try testing.expect(timingSafeEql(std.meta.Vector(100, u8), v1, v3)); } test "crypto.utils.timingSafeCompare" { var a = [_]u8{10} ** 32; var b = [_]u8{10} ** 32; - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .eq); - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .eq); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .eq); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .eq); a[31] = 1; - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .lt); - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .lt); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt); a[0] = 20; - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .gt); - testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Big), .gt); + try testing.expectEqual(timingSafeCompare(u8, &a, &b, .Little), .lt); } test "crypto.utils.secureZero" { @@ -129,5 +129,5 @@ test "crypto.utils.secureZero" { mem.set(u8, a[0..], 0); secureZero(u8, b[0..]); - testing.expectEqualSlices(u8, a[0..], b[0..]); + try testing.expectEqualSlices(u8, a[0..], b[0..]); } diff --git a/lib/std/cstr.zig b/lib/std/cstr.zig index 33f32ae892..d8b8cf455b 100644 --- a/lib/std/cstr.zig +++ b/lib/std/cstr.zig @@ -27,13 +27,13 @@ pub fn cmp(a: [*:0]const u8, b: [*:0]const u8) i8 { } test "cstr fns" { - comptime testCStrFnsImpl(); - testCStrFnsImpl(); + comptime try testCStrFnsImpl(); + try testCStrFnsImpl(); } -fn testCStrFnsImpl() void { - testing.expect(cmp("aoeu", "aoez") == -1); - testing.expect(mem.len("123456789") == 9); +fn testCStrFnsImpl() !void { + try testing.expect(cmp("aoeu", "aoez") == -1); + try testing.expect(mem.len("123456789") == 9); } /// 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 { test "addNullByte" { const slice = try addNullByte(std.testing.allocator, "hello"[0..4]); defer std.testing.allocator.free(slice); - testing.expect(slice.len == 4); - testing.expect(slice[4] == 0); + try testing.expect(slice.len == 4); + try testing.expect(slice[4] == 0); } pub const NullTerminated2DArray = struct { diff --git a/lib/std/dynamic_library.zig b/lib/std/dynamic_library.zig index 98c59d4105..d39b367a02 100644 --- a/lib/std/dynamic_library.zig +++ b/lib/std/dynamic_library.zig @@ -408,7 +408,7 @@ test "dynamic_library" { }; const dynlib = DynLib.open(libname) catch |err| { - testing.expect(err == error.FileNotFound); + try testing.expect(err == error.FileNotFound); return; }; } diff --git a/lib/std/elf.zig b/lib/std/elf.zig index 36382ecc42..6a17f7228d 100644 --- a/lib/std/elf.zig +++ b/lib/std/elf.zig @@ -565,7 +565,7 @@ test "bswapAllFields" { .ch_addralign = 0x12124242, }; bswapAllFields(Elf32_Chdr, &s); - std.testing.expectEqual(Elf32_Chdr{ + try std.testing.expectEqual(Elf32_Chdr{ .ch_type = 0x34123412, .ch_size = 0x78567856, .ch_addralign = 0x42421212, diff --git a/lib/std/enums.zig b/lib/std/enums.zig index a868bdeb26..f0131f4c8a 100644 --- a/lib/std/enums.zig +++ b/lib/std/enums.zig @@ -56,10 +56,10 @@ test "std.enums.valuesFromFields" { .{ .name = "a", .value = undefined }, .{ .name = "d", .value = undefined }, }); - testing.expectEqual(E.b, fields[0]); - testing.expectEqual(E.a, fields[1]); - testing.expectEqual(E.d, fields[2]); // a == d - testing.expectEqual(E.d, fields[3]); + try testing.expectEqual(E.b, fields[0]); + try testing.expectEqual(E.a, fields[1]); + try testing.expectEqual(E.d, fields[2]); // a == d + try testing.expectEqual(E.d, fields[3]); } /// Returns the set of all named values in the given enum, in @@ -70,7 +70,7 @@ pub fn values(comptime E: type) []const E { test "std.enum.values" { const E = extern enum { a, b, c, d = 0 }; - testing.expectEqualSlices(E, &.{ .a, .b, .c, .d }, values(E)); + try testing.expectEqualSlices(E, &.{ .a, .b, .c, .d }, values(E)); } /// Returns the set of all unique named values in the given enum, in @@ -82,10 +82,10 @@ pub fn uniqueValues(comptime E: type) []const E { test "std.enum.uniqueValues" { const E = extern enum { a, b, c, d = 0, e, f = 3 }; - testing.expectEqualSlices(E, &.{ .a, .b, .c, .f }, uniqueValues(E)); + try testing.expectEqualSlices(E, &.{ .a, .b, .c, .f }, uniqueValues(E)); const F = enum { a, b, c }; - testing.expectEqualSlices(F, &.{ .a, .b, .c }, uniqueValues(F)); + try testing.expectEqualSlices(F, &.{ .a, .b, .c }, uniqueValues(F)); } /// Returns the set of all unique field values in the given enum, in @@ -179,10 +179,10 @@ test "std.enums.directEnumArray" { .c = true, }); - testing.expectEqual([7]bool, @TypeOf(array)); - testing.expectEqual(true, array[4]); - testing.expectEqual(false, array[6]); - testing.expectEqual(true, array[2]); + try testing.expectEqual([7]bool, @TypeOf(array)); + try testing.expectEqual(true, array[4]); + try testing.expectEqual(false, array[6]); + try testing.expectEqual(true, array[2]); } /// Initializes an array of Data which can be indexed by @@ -220,10 +220,10 @@ test "std.enums.directEnumArrayDefault" { .b = runtime_false, }); - testing.expectEqual([7]bool, @TypeOf(array)); - testing.expectEqual(true, array[4]); - testing.expectEqual(false, array[6]); - testing.expectEqual(false, array[2]); + try testing.expectEqual([7]bool, @TypeOf(array)); + try testing.expectEqual(true, array[4]); + try testing.expectEqual(false, array[6]); + try testing.expectEqual(false, array[2]); } /// Cast an enum literal, value, or string to the enum value of type E @@ -250,23 +250,23 @@ pub fn nameCast(comptime E: type, comptime value: anytype) E { test "std.enums.nameCast" { const A = enum { a = 0, b = 1 }; const B = enum { a = 1, b = 0 }; - testing.expectEqual(A.a, nameCast(A, .a)); - testing.expectEqual(A.a, nameCast(A, A.a)); - testing.expectEqual(A.a, nameCast(A, B.a)); - testing.expectEqual(A.a, nameCast(A, "a")); - testing.expectEqual(A.a, nameCast(A, @as(*const [1]u8, "a"))); - testing.expectEqual(A.a, nameCast(A, @as([:0]const u8, "a"))); - testing.expectEqual(A.a, nameCast(A, @as([]const u8, "a"))); + try testing.expectEqual(A.a, nameCast(A, .a)); + try testing.expectEqual(A.a, nameCast(A, A.a)); + try testing.expectEqual(A.a, nameCast(A, B.a)); + try testing.expectEqual(A.a, nameCast(A, "a")); + try testing.expectEqual(A.a, nameCast(A, @as(*const [1]u8, "a"))); + try testing.expectEqual(A.a, nameCast(A, @as([:0]const u8, "a"))); + try testing.expectEqual(A.a, nameCast(A, @as([]const u8, "a"))); - testing.expectEqual(B.a, nameCast(B, .a)); - testing.expectEqual(B.a, nameCast(B, A.a)); - testing.expectEqual(B.a, nameCast(B, B.a)); - testing.expectEqual(B.a, nameCast(B, "a")); + try testing.expectEqual(B.a, nameCast(B, .a)); + try testing.expectEqual(B.a, nameCast(B, A.a)); + try testing.expectEqual(B.a, nameCast(B, B.a)); + try testing.expectEqual(B.a, nameCast(B, "a")); - testing.expectEqual(B.b, nameCast(B, .b)); - testing.expectEqual(B.b, nameCast(B, A.b)); - testing.expectEqual(B.b, nameCast(B, B.b)); - testing.expectEqual(B.b, nameCast(B, "b")); + try testing.expectEqual(B.b, nameCast(B, .b)); + try testing.expectEqual(B.b, nameCast(B, A.b)); + try testing.expectEqual(B.b, nameCast(B, B.b)); + try testing.expectEqual(B.b, nameCast(B, "b")); } /// A set of enum elements, backed by a bitfield. If the enum @@ -851,202 +851,202 @@ test "std.enums.EnumIndexer dense zeroed" { const E = enum { b = 1, a = 0, c = 2 }; const Indexer = EnumIndexer(E); ensureIndexer(Indexer); - testing.expectEqual(E, Indexer.Key); - testing.expectEqual(@as(usize, 3), Indexer.count); + try testing.expectEqual(E, Indexer.Key); + try testing.expectEqual(@as(usize, 3), Indexer.count); - testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); - testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); - testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); + try testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); + try testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); + try testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); - testing.expectEqual(E.a, Indexer.keyForIndex(0)); - testing.expectEqual(E.b, Indexer.keyForIndex(1)); - testing.expectEqual(E.c, Indexer.keyForIndex(2)); + try testing.expectEqual(E.a, Indexer.keyForIndex(0)); + try testing.expectEqual(E.b, Indexer.keyForIndex(1)); + try testing.expectEqual(E.c, Indexer.keyForIndex(2)); } test "std.enums.EnumIndexer dense positive" { const E = enum(u4) { c = 6, a = 4, b = 5 }; const Indexer = EnumIndexer(E); ensureIndexer(Indexer); - testing.expectEqual(E, Indexer.Key); - testing.expectEqual(@as(usize, 3), Indexer.count); + try testing.expectEqual(E, Indexer.Key); + try testing.expectEqual(@as(usize, 3), Indexer.count); - testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); - testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); - testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); + try testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); + try testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); + try testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); - testing.expectEqual(E.a, Indexer.keyForIndex(0)); - testing.expectEqual(E.b, Indexer.keyForIndex(1)); - testing.expectEqual(E.c, Indexer.keyForIndex(2)); + try testing.expectEqual(E.a, Indexer.keyForIndex(0)); + try testing.expectEqual(E.b, Indexer.keyForIndex(1)); + try testing.expectEqual(E.c, Indexer.keyForIndex(2)); } test "std.enums.EnumIndexer dense negative" { const E = enum(i4) { a = -6, c = -4, b = -5 }; const Indexer = EnumIndexer(E); ensureIndexer(Indexer); - testing.expectEqual(E, Indexer.Key); - testing.expectEqual(@as(usize, 3), Indexer.count); + try testing.expectEqual(E, Indexer.Key); + try testing.expectEqual(@as(usize, 3), Indexer.count); - testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); - testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); - testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); + try testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); + try testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); + try testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); - testing.expectEqual(E.a, Indexer.keyForIndex(0)); - testing.expectEqual(E.b, Indexer.keyForIndex(1)); - testing.expectEqual(E.c, Indexer.keyForIndex(2)); + try testing.expectEqual(E.a, Indexer.keyForIndex(0)); + try testing.expectEqual(E.b, Indexer.keyForIndex(1)); + try testing.expectEqual(E.c, Indexer.keyForIndex(2)); } test "std.enums.EnumIndexer sparse" { const E = enum(i4) { a = -2, c = 6, b = 4 }; const Indexer = EnumIndexer(E); ensureIndexer(Indexer); - testing.expectEqual(E, Indexer.Key); - testing.expectEqual(@as(usize, 3), Indexer.count); + try testing.expectEqual(E, Indexer.Key); + try testing.expectEqual(@as(usize, 3), Indexer.count); - testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); - testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); - testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); + try testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); + try testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); + try testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); - testing.expectEqual(E.a, Indexer.keyForIndex(0)); - testing.expectEqual(E.b, Indexer.keyForIndex(1)); - testing.expectEqual(E.c, Indexer.keyForIndex(2)); + try testing.expectEqual(E.a, Indexer.keyForIndex(0)); + try testing.expectEqual(E.b, Indexer.keyForIndex(1)); + try testing.expectEqual(E.c, Indexer.keyForIndex(2)); } test "std.enums.EnumIndexer repeats" { const E = extern enum { a = -2, c = 6, b = 4, b2 = 4 }; const Indexer = EnumIndexer(E); ensureIndexer(Indexer); - testing.expectEqual(E, Indexer.Key); - testing.expectEqual(@as(usize, 3), Indexer.count); + try testing.expectEqual(E, Indexer.Key); + try testing.expectEqual(@as(usize, 3), Indexer.count); - testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); - testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); - testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); + try testing.expectEqual(@as(usize, 0), Indexer.indexOf(.a)); + try testing.expectEqual(@as(usize, 1), Indexer.indexOf(.b)); + try testing.expectEqual(@as(usize, 2), Indexer.indexOf(.c)); - testing.expectEqual(E.a, Indexer.keyForIndex(0)); - testing.expectEqual(E.b, Indexer.keyForIndex(1)); - testing.expectEqual(E.c, Indexer.keyForIndex(2)); + try testing.expectEqual(E.a, Indexer.keyForIndex(0)); + try testing.expectEqual(E.b, Indexer.keyForIndex(1)); + try testing.expectEqual(E.c, Indexer.keyForIndex(2)); } test "std.enums.EnumSet" { const E = extern enum { a, b, c, d, e = 0 }; const Set = EnumSet(E); - testing.expectEqual(E, Set.Key); - testing.expectEqual(EnumIndexer(E), Set.Indexer); - testing.expectEqual(@as(usize, 4), Set.len); + try testing.expectEqual(E, Set.Key); + try testing.expectEqual(EnumIndexer(E), Set.Indexer); + try testing.expectEqual(@as(usize, 4), Set.len); // Empty sets const empty = Set{}; - comptime testing.expect(empty.count() == 0); + comptime try testing.expect(empty.count() == 0); var empty_b = Set.init(.{}); - testing.expect(empty_b.count() == 0); + try testing.expect(empty_b.count() == 0); const empty_c = comptime Set.init(.{}); - comptime testing.expect(empty_c.count() == 0); + comptime try testing.expect(empty_c.count() == 0); const full = Set.initFull(); - testing.expect(full.count() == Set.len); + try testing.expect(full.count() == Set.len); const full_b = comptime Set.initFull(); - comptime testing.expect(full_b.count() == Set.len); + comptime try testing.expect(full_b.count() == Set.len); - testing.expectEqual(false, empty.contains(.a)); - testing.expectEqual(false, empty.contains(.b)); - testing.expectEqual(false, empty.contains(.c)); - testing.expectEqual(false, empty.contains(.d)); - testing.expectEqual(false, empty.contains(.e)); + try testing.expectEqual(false, empty.contains(.a)); + try testing.expectEqual(false, empty.contains(.b)); + try testing.expectEqual(false, empty.contains(.c)); + try testing.expectEqual(false, empty.contains(.d)); + try testing.expectEqual(false, empty.contains(.e)); { var iter = empty_b.iterator(); - testing.expectEqual(@as(?E, null), iter.next()); + try testing.expectEqual(@as(?E, null), iter.next()); } var mut = Set.init(.{ .a = true, .c = true, }); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(false, mut.contains(.b)); - testing.expectEqual(true, mut.contains(.c)); - testing.expectEqual(false, mut.contains(.d)); - testing.expectEqual(true, mut.contains(.e)); // aliases a + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(false, mut.contains(.b)); + try testing.expectEqual(true, mut.contains(.c)); + try testing.expectEqual(false, mut.contains(.d)); + try testing.expectEqual(true, mut.contains(.e)); // aliases a { var it = mut.iterator(); - testing.expectEqual(@as(?E, .a), it.next()); - testing.expectEqual(@as(?E, .c), it.next()); - testing.expectEqual(@as(?E, null), it.next()); + try testing.expectEqual(@as(?E, .a), it.next()); + try testing.expectEqual(@as(?E, .c), it.next()); + try testing.expectEqual(@as(?E, null), it.next()); } mut.toggleAll(); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(false, mut.contains(.a)); - testing.expectEqual(true, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(true, mut.contains(.d)); - testing.expectEqual(false, mut.contains(.e)); // aliases a + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(false, mut.contains(.a)); + try testing.expectEqual(true, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(true, mut.contains(.d)); + try testing.expectEqual(false, mut.contains(.e)); // aliases a { var it = mut.iterator(); - testing.expectEqual(@as(?E, .b), it.next()); - testing.expectEqual(@as(?E, .d), it.next()); - testing.expectEqual(@as(?E, null), it.next()); + try testing.expectEqual(@as(?E, .b), it.next()); + try testing.expectEqual(@as(?E, .d), it.next()); + try testing.expectEqual(@as(?E, null), it.next()); } mut.toggleSet(Set.init(.{ .a = true, .b = true })); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(false, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(true, mut.contains(.d)); - testing.expectEqual(true, mut.contains(.e)); // aliases a + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(false, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(true, mut.contains(.d)); + try testing.expectEqual(true, mut.contains(.e)); // aliases a mut.setUnion(Set.init(.{ .a = true, .b = true })); - testing.expectEqual(@as(usize, 3), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(true, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(true, mut.contains(.d)); + try testing.expectEqual(@as(usize, 3), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(true, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(true, mut.contains(.d)); mut.remove(.c); mut.remove(.b); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(false, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(true, mut.contains(.d)); + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(false, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(true, mut.contains(.d)); mut.setIntersection(Set.init(.{ .a = true, .b = true })); - testing.expectEqual(@as(usize, 1), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(false, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(false, mut.contains(.d)); + try testing.expectEqual(@as(usize, 1), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(false, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(false, mut.contains(.d)); mut.insert(.a); mut.insert(.b); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(true, mut.contains(.a)); - testing.expectEqual(true, mut.contains(.b)); - testing.expectEqual(false, mut.contains(.c)); - testing.expectEqual(false, mut.contains(.d)); + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(true, mut.contains(.a)); + try testing.expectEqual(true, mut.contains(.b)); + try testing.expectEqual(false, mut.contains(.c)); + try testing.expectEqual(false, mut.contains(.d)); mut.setPresent(.a, false); mut.toggle(.b); mut.toggle(.c); mut.setPresent(.d, true); - testing.expectEqual(@as(usize, 2), mut.count()); - testing.expectEqual(false, mut.contains(.a)); - testing.expectEqual(false, mut.contains(.b)); - testing.expectEqual(true, mut.contains(.c)); - testing.expectEqual(true, mut.contains(.d)); + try testing.expectEqual(@as(usize, 2), mut.count()); + try testing.expectEqual(false, mut.contains(.a)); + try testing.expectEqual(false, mut.contains(.b)); + try testing.expectEqual(true, mut.contains(.c)); + try testing.expectEqual(true, mut.contains(.d)); } test "std.enums.EnumArray void" { const E = extern enum { a, b, c, d, e = 0 }; const ArrayVoid = EnumArray(E, void); - testing.expectEqual(E, ArrayVoid.Key); - testing.expectEqual(EnumIndexer(E), ArrayVoid.Indexer); - testing.expectEqual(void, ArrayVoid.Value); - testing.expectEqual(@as(usize, 4), ArrayVoid.len); + try testing.expectEqual(E, ArrayVoid.Key); + try testing.expectEqual(EnumIndexer(E), ArrayVoid.Indexer); + try testing.expectEqual(void, ArrayVoid.Value); + try testing.expectEqual(@as(usize, 4), ArrayVoid.len); const undef = ArrayVoid.initUndefined(); var inst = ArrayVoid.initFill({}); @@ -1059,113 +1059,113 @@ test "std.enums.EnumArray void" { inst.set(.a, {}); var it = inst.iterator(); - testing.expectEqual(E.a, it.next().?.key); - testing.expectEqual(E.b, it.next().?.key); - testing.expectEqual(E.c, it.next().?.key); - testing.expectEqual(E.d, it.next().?.key); - testing.expect(it.next() == null); + try testing.expectEqual(E.a, it.next().?.key); + try testing.expectEqual(E.b, it.next().?.key); + try testing.expectEqual(E.c, it.next().?.key); + try testing.expectEqual(E.d, it.next().?.key); + try testing.expect(it.next() == null); } test "std.enums.EnumArray sized" { const E = extern enum { a, b, c, d, e = 0 }; const Array = EnumArray(E, usize); - testing.expectEqual(E, Array.Key); - testing.expectEqual(EnumIndexer(E), Array.Indexer); - testing.expectEqual(usize, Array.Value); - testing.expectEqual(@as(usize, 4), Array.len); + try testing.expectEqual(E, Array.Key); + try testing.expectEqual(EnumIndexer(E), Array.Indexer); + try testing.expectEqual(usize, Array.Value); + try testing.expectEqual(@as(usize, 4), Array.len); const undef = Array.initUndefined(); var inst = Array.initFill(5); const inst2 = Array.init(.{ .a = 1, .b = 2, .c = 3, .d = 4 }); const inst3 = Array.initDefault(6, .{ .b = 4, .c = 2 }); - testing.expectEqual(@as(usize, 5), inst.get(.a)); - testing.expectEqual(@as(usize, 5), inst.get(.b)); - testing.expectEqual(@as(usize, 5), inst.get(.c)); - testing.expectEqual(@as(usize, 5), inst.get(.d)); + try testing.expectEqual(@as(usize, 5), inst.get(.a)); + try testing.expectEqual(@as(usize, 5), inst.get(.b)); + try testing.expectEqual(@as(usize, 5), inst.get(.c)); + try testing.expectEqual(@as(usize, 5), inst.get(.d)); - testing.expectEqual(@as(usize, 1), inst2.get(.a)); - testing.expectEqual(@as(usize, 2), inst2.get(.b)); - testing.expectEqual(@as(usize, 3), inst2.get(.c)); - testing.expectEqual(@as(usize, 4), inst2.get(.d)); + try testing.expectEqual(@as(usize, 1), inst2.get(.a)); + try testing.expectEqual(@as(usize, 2), inst2.get(.b)); + try testing.expectEqual(@as(usize, 3), inst2.get(.c)); + try testing.expectEqual(@as(usize, 4), inst2.get(.d)); - testing.expectEqual(@as(usize, 6), inst3.get(.a)); - testing.expectEqual(@as(usize, 4), inst3.get(.b)); - testing.expectEqual(@as(usize, 2), inst3.get(.c)); - testing.expectEqual(@as(usize, 6), inst3.get(.d)); + try testing.expectEqual(@as(usize, 6), inst3.get(.a)); + try testing.expectEqual(@as(usize, 4), inst3.get(.b)); + try testing.expectEqual(@as(usize, 2), inst3.get(.c)); + try testing.expectEqual(@as(usize, 6), inst3.get(.d)); - testing.expectEqual(&inst.values[0], inst.getPtr(.a)); - testing.expectEqual(&inst.values[1], inst.getPtr(.b)); - testing.expectEqual(&inst.values[2], inst.getPtr(.c)); - testing.expectEqual(&inst.values[3], inst.getPtr(.d)); + try testing.expectEqual(&inst.values[0], inst.getPtr(.a)); + try testing.expectEqual(&inst.values[1], inst.getPtr(.b)); + try testing.expectEqual(&inst.values[2], inst.getPtr(.c)); + try testing.expectEqual(&inst.values[3], inst.getPtr(.d)); - testing.expectEqual(@as(*const usize, &inst.values[0]), inst.getPtrConst(.a)); - testing.expectEqual(@as(*const usize, &inst.values[1]), inst.getPtrConst(.b)); - testing.expectEqual(@as(*const usize, &inst.values[2]), inst.getPtrConst(.c)); - testing.expectEqual(@as(*const usize, &inst.values[3]), inst.getPtrConst(.d)); + try testing.expectEqual(@as(*const usize, &inst.values[0]), inst.getPtrConst(.a)); + try testing.expectEqual(@as(*const usize, &inst.values[1]), inst.getPtrConst(.b)); + try testing.expectEqual(@as(*const usize, &inst.values[2]), inst.getPtrConst(.c)); + try testing.expectEqual(@as(*const usize, &inst.values[3]), inst.getPtrConst(.d)); inst.set(.c, 8); - testing.expectEqual(@as(usize, 5), inst.get(.a)); - testing.expectEqual(@as(usize, 5), inst.get(.b)); - testing.expectEqual(@as(usize, 8), inst.get(.c)); - testing.expectEqual(@as(usize, 5), inst.get(.d)); + try testing.expectEqual(@as(usize, 5), inst.get(.a)); + try testing.expectEqual(@as(usize, 5), inst.get(.b)); + try testing.expectEqual(@as(usize, 8), inst.get(.c)); + try testing.expectEqual(@as(usize, 5), inst.get(.d)); var it = inst.iterator(); const Entry = Array.Entry; - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .a, .value = &inst.values[0], }), it.next()); - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .b, .value = &inst.values[1], }), it.next()); - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .c, .value = &inst.values[2], }), it.next()); - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .d, .value = &inst.values[3], }), it.next()); - testing.expectEqual(@as(?Entry, null), it.next()); + try testing.expectEqual(@as(?Entry, null), it.next()); } test "std.enums.EnumMap void" { const E = extern enum { a, b, c, d, e = 0 }; const Map = EnumMap(E, void); - testing.expectEqual(E, Map.Key); - testing.expectEqual(EnumIndexer(E), Map.Indexer); - testing.expectEqual(void, Map.Value); - testing.expectEqual(@as(usize, 4), Map.len); + try testing.expectEqual(E, Map.Key); + try testing.expectEqual(EnumIndexer(E), Map.Indexer); + try testing.expectEqual(void, Map.Value); + try testing.expectEqual(@as(usize, 4), Map.len); const b = Map.initFull({}); - testing.expectEqual(@as(usize, 4), b.count()); + try testing.expectEqual(@as(usize, 4), b.count()); const c = Map.initFullWith(.{ .a = {}, .b = {}, .c = {}, .d = {} }); - testing.expectEqual(@as(usize, 4), c.count()); + try testing.expectEqual(@as(usize, 4), c.count()); const d = Map.initFullWithDefault({}, .{ .b = {} }); - testing.expectEqual(@as(usize, 4), d.count()); + try testing.expectEqual(@as(usize, 4), d.count()); var a = Map.init(.{ .b = {}, .d = {} }); - testing.expectEqual(@as(usize, 2), a.count()); - testing.expectEqual(false, a.contains(.a)); - testing.expectEqual(true, a.contains(.b)); - testing.expectEqual(false, a.contains(.c)); - testing.expectEqual(true, a.contains(.d)); - testing.expect(a.get(.a) == null); - testing.expect(a.get(.b) != null); - testing.expect(a.get(.c) == null); - testing.expect(a.get(.d) != null); - testing.expect(a.getPtr(.a) == null); - testing.expect(a.getPtr(.b) != null); - testing.expect(a.getPtr(.c) == null); - testing.expect(a.getPtr(.d) != null); - testing.expect(a.getPtrConst(.a) == null); - testing.expect(a.getPtrConst(.b) != null); - testing.expect(a.getPtrConst(.c) == null); - testing.expect(a.getPtrConst(.d) != null); + try testing.expectEqual(@as(usize, 2), a.count()); + try testing.expectEqual(false, a.contains(.a)); + try testing.expectEqual(true, a.contains(.b)); + try testing.expectEqual(false, a.contains(.c)); + try testing.expectEqual(true, a.contains(.d)); + try testing.expect(a.get(.a) == null); + try testing.expect(a.get(.b) != null); + try testing.expect(a.get(.c) == null); + try testing.expect(a.get(.d) != null); + try testing.expect(a.getPtr(.a) == null); + try testing.expect(a.getPtr(.b) != null); + try testing.expect(a.getPtr(.c) == null); + try testing.expect(a.getPtr(.d) != null); + try testing.expect(a.getPtrConst(.a) == null); + try testing.expect(a.getPtrConst(.b) != null); + try testing.expect(a.getPtrConst(.c) == null); + try testing.expect(a.getPtrConst(.d) != null); _ = a.getPtrAssertContains(.b); _ = a.getAssertContains(.d); @@ -1174,115 +1174,115 @@ test "std.enums.EnumMap void" { a.putUninitialized(.c).* = {}; a.putUninitialized(.c).* = {}; - testing.expectEqual(@as(usize, 4), a.count()); - testing.expect(a.get(.a) != null); - testing.expect(a.get(.b) != null); - testing.expect(a.get(.c) != null); - testing.expect(a.get(.d) != null); + try testing.expectEqual(@as(usize, 4), a.count()); + try testing.expect(a.get(.a) != null); + try testing.expect(a.get(.b) != null); + try testing.expect(a.get(.c) != null); + try testing.expect(a.get(.d) != null); a.remove(.a); _ = a.fetchRemove(.c); var iter = a.iterator(); const Entry = Map.Entry; - testing.expectEqual(E.b, iter.next().?.key); - testing.expectEqual(E.d, iter.next().?.key); - testing.expect(iter.next() == null); + try testing.expectEqual(E.b, iter.next().?.key); + try testing.expectEqual(E.d, iter.next().?.key); + try testing.expect(iter.next() == null); } test "std.enums.EnumMap sized" { const E = extern enum { a, b, c, d, e = 0 }; const Map = EnumMap(E, usize); - testing.expectEqual(E, Map.Key); - testing.expectEqual(EnumIndexer(E), Map.Indexer); - testing.expectEqual(usize, Map.Value); - testing.expectEqual(@as(usize, 4), Map.len); + try testing.expectEqual(E, Map.Key); + try testing.expectEqual(EnumIndexer(E), Map.Indexer); + try testing.expectEqual(usize, Map.Value); + try testing.expectEqual(@as(usize, 4), Map.len); const b = Map.initFull(5); - testing.expectEqual(@as(usize, 4), b.count()); - testing.expect(b.contains(.a)); - testing.expect(b.contains(.b)); - testing.expect(b.contains(.c)); - testing.expect(b.contains(.d)); - testing.expectEqual(@as(?usize, 5), b.get(.a)); - testing.expectEqual(@as(?usize, 5), b.get(.b)); - testing.expectEqual(@as(?usize, 5), b.get(.c)); - testing.expectEqual(@as(?usize, 5), b.get(.d)); + try testing.expectEqual(@as(usize, 4), b.count()); + try testing.expect(b.contains(.a)); + try testing.expect(b.contains(.b)); + try testing.expect(b.contains(.c)); + try testing.expect(b.contains(.d)); + try testing.expectEqual(@as(?usize, 5), b.get(.a)); + try testing.expectEqual(@as(?usize, 5), b.get(.b)); + try testing.expectEqual(@as(?usize, 5), b.get(.c)); + try testing.expectEqual(@as(?usize, 5), b.get(.d)); const c = Map.initFullWith(.{ .a = 1, .b = 2, .c = 3, .d = 4 }); - testing.expectEqual(@as(usize, 4), c.count()); - testing.expect(c.contains(.a)); - testing.expect(c.contains(.b)); - testing.expect(c.contains(.c)); - testing.expect(c.contains(.d)); - testing.expectEqual(@as(?usize, 1), c.get(.a)); - testing.expectEqual(@as(?usize, 2), c.get(.b)); - testing.expectEqual(@as(?usize, 3), c.get(.c)); - testing.expectEqual(@as(?usize, 4), c.get(.d)); + try testing.expectEqual(@as(usize, 4), c.count()); + try testing.expect(c.contains(.a)); + try testing.expect(c.contains(.b)); + try testing.expect(c.contains(.c)); + try testing.expect(c.contains(.d)); + try testing.expectEqual(@as(?usize, 1), c.get(.a)); + try testing.expectEqual(@as(?usize, 2), c.get(.b)); + try testing.expectEqual(@as(?usize, 3), c.get(.c)); + try testing.expectEqual(@as(?usize, 4), c.get(.d)); const d = Map.initFullWithDefault(6, .{ .b = 2, .c = 4 }); - testing.expectEqual(@as(usize, 4), d.count()); - testing.expect(d.contains(.a)); - testing.expect(d.contains(.b)); - testing.expect(d.contains(.c)); - testing.expect(d.contains(.d)); - testing.expectEqual(@as(?usize, 6), d.get(.a)); - testing.expectEqual(@as(?usize, 2), d.get(.b)); - testing.expectEqual(@as(?usize, 4), d.get(.c)); - testing.expectEqual(@as(?usize, 6), d.get(.d)); + try testing.expectEqual(@as(usize, 4), d.count()); + try testing.expect(d.contains(.a)); + try testing.expect(d.contains(.b)); + try testing.expect(d.contains(.c)); + try testing.expect(d.contains(.d)); + try testing.expectEqual(@as(?usize, 6), d.get(.a)); + try testing.expectEqual(@as(?usize, 2), d.get(.b)); + try testing.expectEqual(@as(?usize, 4), d.get(.c)); + try testing.expectEqual(@as(?usize, 6), d.get(.d)); var a = Map.init(.{ .b = 2, .d = 4 }); - testing.expectEqual(@as(usize, 2), a.count()); - testing.expectEqual(false, a.contains(.a)); - testing.expectEqual(true, a.contains(.b)); - testing.expectEqual(false, a.contains(.c)); - testing.expectEqual(true, a.contains(.d)); + try testing.expectEqual(@as(usize, 2), a.count()); + try testing.expectEqual(false, a.contains(.a)); + try testing.expectEqual(true, a.contains(.b)); + try testing.expectEqual(false, a.contains(.c)); + try testing.expectEqual(true, a.contains(.d)); - testing.expectEqual(@as(?usize, null), a.get(.a)); - testing.expectEqual(@as(?usize, 2), a.get(.b)); - testing.expectEqual(@as(?usize, null), a.get(.c)); - testing.expectEqual(@as(?usize, 4), a.get(.d)); + try testing.expectEqual(@as(?usize, null), a.get(.a)); + try testing.expectEqual(@as(?usize, 2), a.get(.b)); + try testing.expectEqual(@as(?usize, null), a.get(.c)); + try testing.expectEqual(@as(?usize, 4), a.get(.d)); - testing.expectEqual(@as(?*usize, null), a.getPtr(.a)); - testing.expectEqual(@as(?*usize, &a.values[1]), a.getPtr(.b)); - testing.expectEqual(@as(?*usize, null), a.getPtr(.c)); - testing.expectEqual(@as(?*usize, &a.values[3]), a.getPtr(.d)); + try testing.expectEqual(@as(?*usize, null), a.getPtr(.a)); + try testing.expectEqual(@as(?*usize, &a.values[1]), a.getPtr(.b)); + try testing.expectEqual(@as(?*usize, null), a.getPtr(.c)); + try testing.expectEqual(@as(?*usize, &a.values[3]), a.getPtr(.d)); - testing.expectEqual(@as(?*const usize, null), a.getPtrConst(.a)); - testing.expectEqual(@as(?*const usize, &a.values[1]), a.getPtrConst(.b)); - testing.expectEqual(@as(?*const usize, null), a.getPtrConst(.c)); - testing.expectEqual(@as(?*const usize, &a.values[3]), a.getPtrConst(.d)); + try testing.expectEqual(@as(?*const usize, null), a.getPtrConst(.a)); + try testing.expectEqual(@as(?*const usize, &a.values[1]), a.getPtrConst(.b)); + try testing.expectEqual(@as(?*const usize, null), a.getPtrConst(.c)); + try testing.expectEqual(@as(?*const usize, &a.values[3]), a.getPtrConst(.d)); - testing.expectEqual(@as(*const usize, &a.values[1]), a.getPtrAssertContains(.b)); - testing.expectEqual(@as(*const usize, &a.values[3]), a.getPtrAssertContains(.d)); - testing.expectEqual(@as(usize, 2), a.getAssertContains(.b)); - testing.expectEqual(@as(usize, 4), a.getAssertContains(.d)); + try testing.expectEqual(@as(*const usize, &a.values[1]), a.getPtrAssertContains(.b)); + try testing.expectEqual(@as(*const usize, &a.values[3]), a.getPtrAssertContains(.d)); + try testing.expectEqual(@as(usize, 2), a.getAssertContains(.b)); + try testing.expectEqual(@as(usize, 4), a.getAssertContains(.d)); a.put(.a, 3); a.put(.a, 5); a.putUninitialized(.c).* = 7; a.putUninitialized(.c).* = 9; - testing.expectEqual(@as(usize, 4), a.count()); - testing.expectEqual(@as(?usize, 5), a.get(.a)); - testing.expectEqual(@as(?usize, 2), a.get(.b)); - testing.expectEqual(@as(?usize, 9), a.get(.c)); - testing.expectEqual(@as(?usize, 4), a.get(.d)); + try testing.expectEqual(@as(usize, 4), a.count()); + try testing.expectEqual(@as(?usize, 5), a.get(.a)); + try testing.expectEqual(@as(?usize, 2), a.get(.b)); + try testing.expectEqual(@as(?usize, 9), a.get(.c)); + try testing.expectEqual(@as(?usize, 4), a.get(.d)); a.remove(.a); - testing.expectEqual(@as(?usize, null), a.fetchRemove(.a)); - testing.expectEqual(@as(?usize, 9), a.fetchRemove(.c)); + try testing.expectEqual(@as(?usize, null), a.fetchRemove(.a)); + try testing.expectEqual(@as(?usize, 9), a.fetchRemove(.c)); a.remove(.c); var iter = a.iterator(); const Entry = Map.Entry; - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .b, .value = &a.values[1], }), iter.next()); - testing.expectEqual(@as(?Entry, Entry{ + try testing.expectEqual(@as(?Entry, Entry{ .key = .d, .value = &a.values[3], }), iter.next()); - testing.expectEqual(@as(?Entry, null), iter.next()); + try testing.expectEqual(@as(?Entry, null), iter.next()); } diff --git a/lib/std/event/batch.zig b/lib/std/event/batch.zig index 5368c5336d..af7f293cff 100644 --- a/lib/std/event/batch.zig +++ b/lib/std/event/batch.zig @@ -119,12 +119,12 @@ test "std.event.Batch" { batch.add(&async sleepALittle(&count)); batch.add(&async increaseByTen(&count)); batch.wait(); - testing.expect(count == 11); + try testing.expect(count == 11); var another = Batch(anyerror!void, 2, .auto_async).init(); another.add(&async somethingElse()); another.add(&async doSomethingThatFails()); - testing.expectError(error.ItBroke, another.wait()); + try testing.expectError(error.ItBroke, another.wait()); } fn sleepALittle(count: *usize) void { diff --git a/lib/std/event/channel.zig b/lib/std/event/channel.zig index 2711488705..a069985aeb 100644 --- a/lib/std/event/channel.zig +++ b/lib/std/event/channel.zig @@ -310,25 +310,25 @@ test "std.event.Channel wraparound" { // the buffer wraps around, make sure it doesn't crash. var result: i32 = undefined; channel.put(5); - testing.expectEqual(@as(i32, 5), channel.get()); + try testing.expectEqual(@as(i32, 5), channel.get()); channel.put(6); - testing.expectEqual(@as(i32, 6), channel.get()); + try testing.expectEqual(@as(i32, 6), channel.get()); channel.put(7); - testing.expectEqual(@as(i32, 7), channel.get()); + try testing.expectEqual(@as(i32, 7), channel.get()); } fn testChannelGetter(channel: *Channel(i32)) callconv(.Async) void { const value1 = channel.get(); - testing.expect(value1 == 1234); + try testing.expect(value1 == 1234); const value2 = channel.get(); - testing.expect(value2 == 4567); + try testing.expect(value2 == 4567); const value3 = channel.getOrNull(); - testing.expect(value3 == null); + try testing.expect(value3 == null); var last_put = async testPut(channel, 4444); const value4 = channel.getOrNull(); - testing.expect(value4.? == 4444); + try testing.expect(value4.? == 4444); await last_put; } fn testChannelPutter(channel: *Channel(i32)) callconv(.Async) void { diff --git a/lib/std/event/future.zig b/lib/std/event/future.zig index 30a2e46ec5..a081ec0c0f 100644 --- a/lib/std/event/future.zig +++ b/lib/std/event/future.zig @@ -107,7 +107,7 @@ fn testFuture() void { const result = (await a) + (await b); - testing.expect(result == 12); + try testing.expect(result == 12); } fn waitOnFuture(future: *Future(i32)) i32 { diff --git a/lib/std/event/group.zig b/lib/std/event/group.zig index b052c15704..e6e608ac57 100644 --- a/lib/std/event/group.zig +++ b/lib/std/event/group.zig @@ -140,14 +140,14 @@ fn testGroup(allocator: *Allocator) callconv(.Async) void { var increase_by_ten_frame = async increaseByTen(&count); group.add(&increase_by_ten_frame) catch @panic("memory"); group.wait(); - testing.expect(count == 11); + try testing.expect(count == 11); var another = Group(anyerror!void).init(allocator); var something_else_frame = async somethingElse(); another.add(&something_else_frame) catch @panic("memory"); var something_that_fails_frame = async doSomethingThatFails(); another.add(&something_that_fails_frame) catch @panic("memory"); - testing.expectError(error.ItBroke, another.wait()); + try testing.expectError(error.ItBroke, another.wait()); } fn sleepALittle(count: *usize) callconv(.Async) void { std.time.sleep(1 * std.time.ns_per_ms); diff --git a/lib/std/event/lock.zig b/lib/std/event/lock.zig index d48c6c1520..fd59bd49c4 100644 --- a/lib/std/event/lock.zig +++ b/lib/std/event/lock.zig @@ -136,7 +136,7 @@ test "std.event.Lock" { testLock(&lock); const expected_result = [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len; - testing.expectEqualSlices(i32, &expected_result, &shared_test_data); + try testing.expectEqualSlices(i32, &expected_result, &shared_test_data); } fn testLock(lock: *Lock) void { var handle1 = async lockRunner(lock); diff --git a/lib/std/event/loop.zig b/lib/std/event/loop.zig index 878cea4aa6..279d26490e 100644 --- a/lib/std/event/loop.zig +++ b/lib/std/event/loop.zig @@ -1655,7 +1655,7 @@ fn testEventLoop() i32 { fn testEventLoop2(h: anyframe->i32, did_it: *bool) void { const value = await h; - testing.expect(value == 1234); + try testing.expect(value == 1234); did_it.* = true; } @@ -1682,7 +1682,7 @@ test "std.event.Loop - runDetached" { // with the previous runDetached. loop.run(); - testing.expect(testRunDetachedData == 1); + try testing.expect(testRunDetachedData == 1); } fn testRunDetached() void { @@ -1705,7 +1705,7 @@ test "std.event.Loop - sleep" { for (frames) |*frame| await frame; - testing.expect(sleep_count == frames.len); + try testing.expect(sleep_count == frames.len); } fn testSleep(wait_ns: u64, sleep_count: *usize) void { diff --git a/lib/std/event/rwlock.zig b/lib/std/event/rwlock.zig index 04b45ee308..46e14472bf 100644 --- a/lib/std/event/rwlock.zig +++ b/lib/std/event/rwlock.zig @@ -228,7 +228,7 @@ test "std.event.RwLock" { const handle = testLock(std.heap.page_allocator, &lock); const expected_result = [1]i32{shared_it_count * @intCast(i32, shared_test_data.len)} ** shared_test_data.len; - testing.expectEqualSlices(i32, expected_result, shared_test_data); + try testing.expectEqualSlices(i32, expected_result, shared_test_data); } fn testLock(allocator: *Allocator, lock: *RwLock) callconv(.Async) void { var read_nodes: [100]Loop.NextTickNode = undefined; @@ -290,7 +290,7 @@ fn readRunner(lock: *RwLock) callconv(.Async) void { const handle = await lock_promise; defer handle.release(); - testing.expect(shared_test_index == 0); - testing.expect(shared_test_data[i] == @intCast(i32, shared_count)); + try testing.expect(shared_test_index == 0); + try testing.expect(shared_test_data[i] == @intCast(i32, shared_count)); } } diff --git a/lib/std/fifo.zig b/lib/std/fifo.zig index b0771bba16..8377fd13b5 100644 --- a/lib/std/fifo.zig +++ b/lib/std/fifo.zig @@ -402,59 +402,59 @@ test "LinearFifo(u8, .Dynamic)" { defer fifo.deinit(); try fifo.write("HELLO"); - testing.expectEqual(@as(usize, 5), fifo.readableLength()); - testing.expectEqualSlices(u8, "HELLO", fifo.readableSlice(0)); + try testing.expectEqual(@as(usize, 5), fifo.readableLength()); + try testing.expectEqualSlices(u8, "HELLO", fifo.readableSlice(0)); { var i: usize = 0; while (i < 5) : (i += 1) { try fifo.write(&[_]u8{fifo.peekItem(i)}); } - testing.expectEqual(@as(usize, 10), fifo.readableLength()); - testing.expectEqualSlices(u8, "HELLOHELLO", fifo.readableSlice(0)); + try testing.expectEqual(@as(usize, 10), fifo.readableLength()); + try testing.expectEqualSlices(u8, "HELLOHELLO", fifo.readableSlice(0)); } { - testing.expectEqual(@as(u8, 'H'), fifo.readItem().?); - testing.expectEqual(@as(u8, 'E'), fifo.readItem().?); - testing.expectEqual(@as(u8, 'L'), fifo.readItem().?); - testing.expectEqual(@as(u8, 'L'), fifo.readItem().?); - testing.expectEqual(@as(u8, 'O'), fifo.readItem().?); + try testing.expectEqual(@as(u8, 'H'), fifo.readItem().?); + try testing.expectEqual(@as(u8, 'E'), fifo.readItem().?); + try testing.expectEqual(@as(u8, 'L'), fifo.readItem().?); + try testing.expectEqual(@as(u8, 'L'), fifo.readItem().?); + try testing.expectEqual(@as(u8, 'O'), fifo.readItem().?); } - testing.expectEqual(@as(usize, 5), fifo.readableLength()); + try testing.expectEqual(@as(usize, 5), fifo.readableLength()); { // Writes that wrap around - testing.expectEqual(@as(usize, 11), fifo.writableLength()); - testing.expectEqual(@as(usize, 6), fifo.writableSlice(0).len); + try testing.expectEqual(@as(usize, 11), fifo.writableLength()); + try testing.expectEqual(@as(usize, 6), fifo.writableSlice(0).len); fifo.writeAssumeCapacity("6 file_size const buf2 = try file.readToEndAlloc(testing.allocator, 1024); defer testing.allocator.free(buf2); - testing.expectEqual(write_buf.len, buf2.len); - testing.expect(std.mem.eql(u8, write_buf, buf2)); + try testing.expectEqual(write_buf.len, buf2.len); + try testing.expect(std.mem.eql(u8, write_buf, buf2)); try file.seekTo(0); // max_bytes == file_size const buf3 = try file.readToEndAlloc(testing.allocator, write_buf.len); defer testing.allocator.free(buf3); - testing.expectEqual(write_buf.len, buf3.len); - testing.expect(std.mem.eql(u8, write_buf, buf3)); + try testing.expectEqual(write_buf.len, buf3.len); + try testing.expect(std.mem.eql(u8, write_buf, buf3)); try file.seekTo(0); // max_bytes < file_size - testing.expectError(error.FileTooBig, file.readToEndAlloc(testing.allocator, write_buf.len - 1)); + try testing.expectError(error.FileTooBig, file.readToEndAlloc(testing.allocator, write_buf.len - 1)); } test "directory operations on files" { @@ -257,22 +257,22 @@ test "directory operations on files" { var file = try tmp_dir.dir.createFile(test_file_name, .{ .read = true }); file.close(); - testing.expectError(error.PathAlreadyExists, tmp_dir.dir.makeDir(test_file_name)); - testing.expectError(error.NotDir, tmp_dir.dir.openDir(test_file_name, .{})); - testing.expectError(error.NotDir, tmp_dir.dir.deleteDir(test_file_name)); + try testing.expectError(error.PathAlreadyExists, tmp_dir.dir.makeDir(test_file_name)); + try testing.expectError(error.NotDir, tmp_dir.dir.openDir(test_file_name, .{})); + try testing.expectError(error.NotDir, tmp_dir.dir.deleteDir(test_file_name)); if (builtin.os.tag != .wasi and builtin.os.tag != .freebsd and builtin.os.tag != .openbsd) { const absolute_path = try tmp_dir.dir.realpathAlloc(testing.allocator, test_file_name); defer testing.allocator.free(absolute_path); - testing.expectError(error.PathAlreadyExists, fs.makeDirAbsolute(absolute_path)); - testing.expectError(error.NotDir, fs.deleteDirAbsolute(absolute_path)); + try testing.expectError(error.PathAlreadyExists, fs.makeDirAbsolute(absolute_path)); + try testing.expectError(error.NotDir, fs.deleteDirAbsolute(absolute_path)); } // ensure the file still exists and is a file as a sanity check file = try tmp_dir.dir.openFile(test_file_name, .{}); const stat = try file.stat(); - testing.expect(stat.kind == .File); + try testing.expect(stat.kind == .File); file.close(); } @@ -287,23 +287,23 @@ test "file operations on directories" { try tmp_dir.dir.makeDir(test_dir_name); - testing.expectError(error.IsDir, tmp_dir.dir.createFile(test_dir_name, .{})); - testing.expectError(error.IsDir, tmp_dir.dir.deleteFile(test_dir_name)); + try testing.expectError(error.IsDir, tmp_dir.dir.createFile(test_dir_name, .{})); + try testing.expectError(error.IsDir, tmp_dir.dir.deleteFile(test_dir_name)); // Currently, WASI will return error.Unexpected (via ENOTCAPABLE) when attempting fd_read on a directory handle. // TODO: Re-enable on WASI once https://github.com/bytecodealliance/wasmtime/issues/1935 is resolved. if (builtin.os.tag != .wasi) { - testing.expectError(error.IsDir, tmp_dir.dir.readFileAlloc(testing.allocator, test_dir_name, std.math.maxInt(usize))); + try testing.expectError(error.IsDir, tmp_dir.dir.readFileAlloc(testing.allocator, test_dir_name, std.math.maxInt(usize))); } // Note: The `.write = true` is necessary to ensure the error occurs on all platforms. // TODO: Add a read-only test as well, see https://github.com/ziglang/zig/issues/5732 - testing.expectError(error.IsDir, tmp_dir.dir.openFile(test_dir_name, .{ .write = true })); + try testing.expectError(error.IsDir, tmp_dir.dir.openFile(test_dir_name, .{ .write = true })); if (builtin.os.tag != .wasi and builtin.os.tag != .freebsd and builtin.os.tag != .openbsd) { const absolute_path = try tmp_dir.dir.realpathAlloc(testing.allocator, test_dir_name); defer testing.allocator.free(absolute_path); - testing.expectError(error.IsDir, fs.createFileAbsolute(absolute_path, .{})); - testing.expectError(error.IsDir, fs.deleteFileAbsolute(absolute_path)); + try testing.expectError(error.IsDir, fs.createFileAbsolute(absolute_path, .{})); + try testing.expectError(error.IsDir, fs.deleteFileAbsolute(absolute_path)); } // ensure the directory still exists as a sanity check @@ -316,7 +316,7 @@ test "deleteDir" { defer tmp_dir.cleanup(); // deleting a non-existent directory - testing.expectError(error.FileNotFound, tmp_dir.dir.deleteDir("test_dir")); + try testing.expectError(error.FileNotFound, tmp_dir.dir.deleteDir("test_dir")); var dir = try tmp_dir.dir.makeOpenPath("test_dir", .{}); var file = try dir.createFile("test_file", .{}); @@ -326,7 +326,7 @@ test "deleteDir" { // deleting a non-empty directory // TODO: Re-enable this check on Windows, see https://github.com/ziglang/zig/issues/5537 if (builtin.os.tag != .windows) { - testing.expectError(error.DirNotEmpty, tmp_dir.dir.deleteDir("test_dir")); + try testing.expectError(error.DirNotEmpty, tmp_dir.dir.deleteDir("test_dir")); } dir = try tmp_dir.dir.openDir("test_dir", .{}); @@ -341,7 +341,7 @@ test "Dir.rename files" { var tmp_dir = tmpDir(.{}); defer tmp_dir.cleanup(); - testing.expectError(error.FileNotFound, tmp_dir.dir.rename("missing_file_name", "something_else")); + try testing.expectError(error.FileNotFound, tmp_dir.dir.rename("missing_file_name", "something_else")); // Renaming files const test_file_name = "test_file"; @@ -351,7 +351,7 @@ test "Dir.rename files" { try tmp_dir.dir.rename(test_file_name, renamed_test_file_name); // Ensure the file was renamed - testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(test_file_name, .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(test_file_name, .{})); file = try tmp_dir.dir.openFile(renamed_test_file_name, .{}); file.close(); @@ -363,7 +363,7 @@ test "Dir.rename files" { existing_file.close(); try tmp_dir.dir.rename(renamed_test_file_name, "existing_file"); - testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(renamed_test_file_name, .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(renamed_test_file_name, .{})); file = try tmp_dir.dir.openFile("existing_file", .{}); file.close(); } @@ -380,7 +380,7 @@ test "Dir.rename directories" { try tmp_dir.dir.rename("test_dir", "test_dir_renamed"); // Ensure the directory was renamed - testing.expectError(error.FileNotFound, tmp_dir.dir.openDir("test_dir", .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openDir("test_dir", .{})); var dir = try tmp_dir.dir.openDir("test_dir_renamed", .{}); // Put a file in the directory @@ -391,7 +391,7 @@ test "Dir.rename directories" { try tmp_dir.dir.rename("test_dir_renamed", "test_dir_renamed_again"); // Ensure the directory was renamed and the file still exists in it - testing.expectError(error.FileNotFound, tmp_dir.dir.openDir("test_dir_renamed", .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openDir("test_dir_renamed", .{})); dir = try tmp_dir.dir.openDir("test_dir_renamed_again", .{}); file = try dir.openFile("test_file", .{}); file.close(); @@ -402,7 +402,7 @@ test "Dir.rename directories" { file = try target_dir.createFile("filler", .{ .read = true }); file.close(); - testing.expectError(error.PathAlreadyExists, tmp_dir.dir.rename("test_dir_renamed_again", "non_empty_target_dir")); + try testing.expectError(error.PathAlreadyExists, tmp_dir.dir.rename("test_dir_renamed_again", "non_empty_target_dir")); // Ensure the directory was not renamed dir = try tmp_dir.dir.openDir("test_dir_renamed_again", .{}); @@ -421,8 +421,8 @@ test "Dir.rename file <-> dir" { var file = try tmp_dir.dir.createFile("test_file", .{ .read = true }); file.close(); try tmp_dir.dir.makeDir("test_dir"); - testing.expectError(error.IsDir, tmp_dir.dir.rename("test_file", "test_dir")); - testing.expectError(error.NotDir, tmp_dir.dir.rename("test_dir", "test_file")); + try testing.expectError(error.IsDir, tmp_dir.dir.rename("test_file", "test_dir")); + try testing.expectError(error.NotDir, tmp_dir.dir.rename("test_dir", "test_file")); } test "rename" { @@ -440,7 +440,7 @@ test "rename" { try fs.rename(tmp_dir1.dir, test_file_name, tmp_dir2.dir, renamed_test_file_name); // ensure the file was renamed - testing.expectError(error.FileNotFound, tmp_dir1.dir.openFile(test_file_name, .{})); + try testing.expectError(error.FileNotFound, tmp_dir1.dir.openFile(test_file_name, .{})); file = try tmp_dir2.dir.openFile(renamed_test_file_name, .{}); file.close(); } @@ -461,7 +461,7 @@ test "renameAbsolute" { break :blk try fs.realpathAlloc(&arena.allocator, relative_path); }; - testing.expectError(error.FileNotFound, fs.renameAbsolute( + try testing.expectError(error.FileNotFound, fs.renameAbsolute( try fs.path.join(allocator, &[_][]const u8{ base_path, "missing_file_name" }), try fs.path.join(allocator, &[_][]const u8{ base_path, "something_else" }), )); @@ -477,10 +477,10 @@ test "renameAbsolute" { ); // ensure the file was renamed - testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(test_file_name, .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(test_file_name, .{})); file = try tmp_dir.dir.openFile(renamed_test_file_name, .{}); const stat = try file.stat(); - testing.expect(stat.kind == .File); + try testing.expect(stat.kind == .File); file.close(); // Renaming directories @@ -493,7 +493,7 @@ test "renameAbsolute" { ); // ensure the directory was renamed - testing.expectError(error.FileNotFound, tmp_dir.dir.openDir(test_dir_name, .{})); + try testing.expectError(error.FileNotFound, tmp_dir.dir.openDir(test_dir_name, .{})); var dir = try tmp_dir.dir.openDir(renamed_test_dir_name, .{}); dir.close(); } @@ -516,7 +516,7 @@ test "makePath, put some files in it, deleteTree" { if (tmp.dir.openDir("os_test_tmp", .{})) |dir| { @panic("expected error"); } else |err| { - testing.expect(err == error.FileNotFound); + try testing.expect(err == error.FileNotFound); } } @@ -530,7 +530,7 @@ test "access file" { if (tmp.dir.access("os_test_tmp" ++ fs.path.sep_str ++ "file.txt", .{})) |ok| { @panic("expected error"); } else |err| { - testing.expect(err == error.FileNotFound); + try testing.expect(err == error.FileNotFound); } try tmp.dir.writeFile("os_test_tmp" ++ fs.path.sep_str ++ "file.txt", ""); @@ -600,7 +600,7 @@ test "sendfile" { .header_count = 2, }); const amt = try dest_file.preadAll(&written_buf, 0); - testing.expect(mem.eql(u8, written_buf[0..amt], "header1\nsecond header\nine1\nsecontrailer1\nsecond trailer\n")); + try testing.expect(mem.eql(u8, written_buf[0..amt], "header1\nsecond header\nine1\nsecontrailer1\nsecond trailer\n")); } test "copyRangeAll" { @@ -626,7 +626,7 @@ test "copyRangeAll" { _ = try src_file.copyRangeAll(0, dest_file, 0, data.len); const amt = try dest_file.preadAll(&written_buf, 0); - testing.expect(mem.eql(u8, written_buf[0..amt], data)); + try testing.expect(mem.eql(u8, written_buf[0..amt], data)); } test "fs.copyFile" { @@ -655,7 +655,7 @@ fn expectFileContents(dir: Dir, file_path: []const u8, data: []const u8) !void { const contents = try dir.readFileAlloc(testing.allocator, file_path, 1000); defer testing.allocator.free(contents); - testing.expectEqualSlices(u8, data, contents); + try testing.expectEqualSlices(u8, data, contents); } test "AtomicFile" { @@ -676,7 +676,7 @@ test "AtomicFile" { } const content = try tmp.dir.readFileAlloc(testing.allocator, test_out_file, 9999); defer testing.allocator.free(content); - testing.expect(mem.eql(u8, content, test_content)); + try testing.expect(mem.eql(u8, content, test_content)); try tmp.dir.deleteFile(test_out_file); } @@ -685,7 +685,7 @@ test "realpath" { if (builtin.os.tag == .wasi) return error.SkipZigTest; var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined; - testing.expectError(error.FileNotFound, fs.realpath("definitely_bogus_does_not_exist1234", &buf)); + try testing.expectError(error.FileNotFound, fs.realpath("definitely_bogus_does_not_exist1234", &buf)); } test "open file with exclusive nonblocking lock twice" { @@ -700,7 +700,7 @@ test "open file with exclusive nonblocking lock twice" { defer file1.close(); const file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true }); - testing.expectError(error.WouldBlock, file2); + try testing.expectError(error.WouldBlock, file2); } test "open file with shared and exclusive nonblocking lock" { @@ -715,7 +715,7 @@ test "open file with shared and exclusive nonblocking lock" { defer file1.close(); const file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true }); - testing.expectError(error.WouldBlock, file2); + try testing.expectError(error.WouldBlock, file2); } test "open file with exclusive and shared nonblocking lock" { @@ -730,7 +730,7 @@ test "open file with exclusive and shared nonblocking lock" { defer file1.close(); const file2 = tmp.dir.createFile(filename, .{ .lock = .Shared, .lock_nonblocking = true }); - testing.expectError(error.WouldBlock, file2); + try testing.expectError(error.WouldBlock, file2); } test "open file with exclusive lock twice, make sure it waits" { @@ -790,7 +790,7 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" { const file2 = fs.createFileAbsolute(filename, .{ .lock = .Exclusive, .lock_nonblocking = true }); file1.close(); - testing.expectError(error.WouldBlock, file2); + try testing.expectError(error.WouldBlock, file2); try fs.deleteFileAbsolute(filename); } @@ -830,6 +830,6 @@ test "walker" { try fs.path.join(allocator, &[_][]const u8{ expected_dir_name, name }); var entry = (try walker.next()).?; - testing.expectEqualStrings(expected_dir_name, try fs.path.relative(allocator, tmp_path, entry.path)); + try testing.expectEqualStrings(expected_dir_name, try fs.path.relative(allocator, tmp_path, entry.path)); } } diff --git a/lib/std/fs/wasi.zig b/lib/std/fs/wasi.zig index cf5431f994..17208a0245 100644 --- a/lib/std/fs/wasi.zig +++ b/lib/std/fs/wasi.zig @@ -174,8 +174,8 @@ test "extracting WASI preopens" { try preopens.populate(); - std.testing.expectEqual(@as(usize, 1), preopens.asSlice().len); + try std.testing.expectEqual(@as(usize, 1), preopens.asSlice().len); const preopen = preopens.find(PreopenType{ .Dir = "." }) orelse unreachable; - std.testing.expect(preopen.@"type".eql(PreopenType{ .Dir = "." })); - std.testing.expectEqual(@as(usize, 3), preopen.fd); + try std.testing.expect(preopen.@"type".eql(PreopenType{ .Dir = "." })); + try std.testing.expectEqual(@as(usize, 3), preopen.fd); } diff --git a/lib/std/fs/watch.zig b/lib/std/fs/watch.zig index 1c7cb68b32..09bd21ab33 100644 --- a/lib/std/fs/watch.zig +++ b/lib/std/fs/watch.zig @@ -662,13 +662,13 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void { const read_contents = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024); defer allocator.free(read_contents); - testing.expectEqualSlices(u8, contents, read_contents); + try testing.expectEqualSlices(u8, contents, read_contents); // now watch the file var watch = try Watch(void).init(allocator, 0); defer watch.deinit(); - testing.expect((try watch.addFile(file_path, {})) == null); + try testing.expect((try watch.addFile(file_path, {})) == null); var ev = async watch.channel.get(); var ev_consumed = false; @@ -698,7 +698,7 @@ fn testWriteWatchWriteDelete(allocator: *Allocator) !void { const contents_updated = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024); defer allocator.free(contents_updated); - testing.expectEqualSlices(u8, + try testing.expectEqualSlices(u8, \\line 1 \\lorem ipsum , contents_updated); diff --git a/lib/std/hash/adler.zig b/lib/std/hash/adler.zig index 9cd85ba7cf..61408e82ee 100644 --- a/lib/std/hash/adler.zig +++ b/lib/std/hash/adler.zig @@ -99,21 +99,21 @@ pub const Adler32 = struct { }; test "adler32 sanity" { - testing.expectEqual(@as(u32, 0x620062), Adler32.hash("a")); - testing.expectEqual(@as(u32, 0xbc002ed), Adler32.hash("example")); + try testing.expectEqual(@as(u32, 0x620062), Adler32.hash("a")); + try testing.expectEqual(@as(u32, 0xbc002ed), Adler32.hash("example")); } test "adler32 long" { const long1 = [_]u8{1} ** 1024; - testing.expectEqual(@as(u32, 0x06780401), Adler32.hash(long1[0..])); + try testing.expectEqual(@as(u32, 0x06780401), Adler32.hash(long1[0..])); const long2 = [_]u8{1} ** 1025; - testing.expectEqual(@as(u32, 0x0a7a0402), Adler32.hash(long2[0..])); + try testing.expectEqual(@as(u32, 0x0a7a0402), Adler32.hash(long2[0..])); } test "adler32 very long" { const long = [_]u8{1} ** 5553; - testing.expectEqual(@as(u32, 0x707f15b2), Adler32.hash(long[0..])); + try testing.expectEqual(@as(u32, 0x707f15b2), Adler32.hash(long[0..])); } test "adler32 very long with variation" { @@ -129,5 +129,5 @@ test "adler32 very long with variation" { break :blk result; }; - testing.expectEqual(@as(u32, 0x5af38d6e), std.hash.Adler32.hash(long[0..])); + try testing.expectEqual(@as(u32, 0x5af38d6e), std.hash.Adler32.hash(long[0..])); } diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig index e053e87efb..efe02fb8ff 100644 --- a/lib/std/hash/auto_hash.zig +++ b/lib/std/hash/auto_hash.zig @@ -239,18 +239,18 @@ fn testHashDeepRecursive(key: anytype) u64 { test "typeContainsSlice" { comptime { - testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo))); + try testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo))); - testing.expect(typeContainsSlice([]const u8)); - testing.expect(!typeContainsSlice(u8)); + try testing.expect(typeContainsSlice([]const u8)); + try testing.expect(!typeContainsSlice(u8)); const A = struct { x: []const u8 }; const B = struct { a: A }; const C = struct { b: B }; const D = struct { x: u8 }; - testing.expect(typeContainsSlice(A)); - testing.expect(typeContainsSlice(B)); - testing.expect(typeContainsSlice(C)); - testing.expect(!typeContainsSlice(D)); + try testing.expect(typeContainsSlice(A)); + try testing.expect(typeContainsSlice(B)); + try testing.expect(typeContainsSlice(C)); + try testing.expect(!typeContainsSlice(D)); } } @@ -261,17 +261,17 @@ test "hash pointer" { const c = &array[2]; const d = a; - testing.expect(testHashShallow(a) == testHashShallow(d)); - testing.expect(testHashShallow(a) != testHashShallow(c)); - testing.expect(testHashShallow(a) != testHashShallow(b)); + try testing.expect(testHashShallow(a) == testHashShallow(d)); + try testing.expect(testHashShallow(a) != testHashShallow(c)); + try testing.expect(testHashShallow(a) != testHashShallow(b)); - testing.expect(testHashDeep(a) == testHashDeep(a)); - testing.expect(testHashDeep(a) == testHashDeep(c)); - testing.expect(testHashDeep(a) == testHashDeep(b)); + try testing.expect(testHashDeep(a) == testHashDeep(a)); + try testing.expect(testHashDeep(a) == testHashDeep(c)); + try testing.expect(testHashDeep(a) == testHashDeep(b)); - testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(a)); - testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(c)); - testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(b)); + try testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(a)); + try testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(c)); + try testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(b)); } test "hash slice shallow" { @@ -286,10 +286,10 @@ test "hash slice shallow" { const a = array1[runtime_zero..]; const b = array2[runtime_zero..]; const c = array1[runtime_zero..3]; - testing.expect(testHashShallow(a) == testHashShallow(a)); - testing.expect(testHashShallow(a) != testHashShallow(array1)); - testing.expect(testHashShallow(a) != testHashShallow(b)); - testing.expect(testHashShallow(a) != testHashShallow(c)); + try testing.expect(testHashShallow(a) == testHashShallow(a)); + try testing.expect(testHashShallow(a) != testHashShallow(array1)); + try testing.expect(testHashShallow(a) != testHashShallow(b)); + try testing.expect(testHashShallow(a) != testHashShallow(c)); } test "hash slice deep" { @@ -302,10 +302,10 @@ test "hash slice deep" { const a = array1[0..]; const b = array2[0..]; const c = array1[0..3]; - testing.expect(testHashDeep(a) == testHashDeep(a)); - testing.expect(testHashDeep(a) == testHashDeep(array1)); - testing.expect(testHashDeep(a) == testHashDeep(b)); - testing.expect(testHashDeep(a) != testHashDeep(c)); + try testing.expect(testHashDeep(a) == testHashDeep(a)); + try testing.expect(testHashDeep(a) == testHashDeep(array1)); + try testing.expect(testHashDeep(a) == testHashDeep(b)); + try testing.expect(testHashDeep(a) != testHashDeep(c)); } test "hash struct deep" { @@ -331,28 +331,28 @@ test "hash struct deep" { defer allocator.destroy(bar.c); defer allocator.destroy(baz.c); - testing.expect(testHashDeep(foo) == testHashDeep(bar)); - testing.expect(testHashDeep(foo) != testHashDeep(baz)); - testing.expect(testHashDeep(bar) != testHashDeep(baz)); + try testing.expect(testHashDeep(foo) == testHashDeep(bar)); + try testing.expect(testHashDeep(foo) != testHashDeep(baz)); + try testing.expect(testHashDeep(bar) != testHashDeep(baz)); var hasher = Wyhash.init(0); const h = testHashDeep(foo); autoHash(&hasher, foo.a); autoHash(&hasher, foo.b); autoHash(&hasher, foo.c.*); - testing.expectEqual(h, hasher.final()); + try testing.expectEqual(h, hasher.final()); const h2 = testHashDeepRecursive(&foo); - testing.expect(h2 != testHashDeep(&foo)); - testing.expect(h2 == testHashDeep(foo)); + try testing.expect(h2 != testHashDeep(&foo)); + try testing.expect(h2 == testHashDeep(foo)); } test "testHash optional" { const a: ?u32 = 123; const b: ?u32 = null; - testing.expectEqual(testHash(a), testHash(@as(u32, 123))); - testing.expect(testHash(a) != testHash(b)); - testing.expectEqual(testHash(b), 0); + try testing.expectEqual(testHash(a), testHash(@as(u32, 123))); + try testing.expect(testHash(a) != testHash(b)); + try testing.expectEqual(testHash(b), 0); } test "testHash array" { @@ -362,7 +362,7 @@ test "testHash array" { autoHash(&hasher, @as(u32, 1)); autoHash(&hasher, @as(u32, 2)); autoHash(&hasher, @as(u32, 3)); - testing.expectEqual(h, hasher.final()); + try testing.expectEqual(h, hasher.final()); } test "testHash struct" { @@ -377,7 +377,7 @@ test "testHash struct" { autoHash(&hasher, @as(u32, 1)); autoHash(&hasher, @as(u32, 2)); autoHash(&hasher, @as(u32, 3)); - testing.expectEqual(h, hasher.final()); + try testing.expectEqual(h, hasher.final()); } test "testHash union" { @@ -390,12 +390,12 @@ test "testHash union" { const a = Foo{ .A = 18 }; var b = Foo{ .B = true }; const c = Foo{ .C = 18 }; - testing.expect(testHash(a) == testHash(a)); - testing.expect(testHash(a) != testHash(b)); - testing.expect(testHash(a) != testHash(c)); + try testing.expect(testHash(a) == testHash(a)); + try testing.expect(testHash(a) != testHash(b)); + try testing.expect(testHash(a) != testHash(c)); b = Foo{ .A = 18 }; - testing.expect(testHash(a) == testHash(b)); + try testing.expect(testHash(a) == testHash(b)); } test "testHash vector" { @@ -404,13 +404,13 @@ test "testHash vector" { const a: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 4 }; const b: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 5 }; - testing.expect(testHash(a) == testHash(a)); - testing.expect(testHash(a) != testHash(b)); + try testing.expect(testHash(a) == testHash(a)); + try testing.expect(testHash(a) != testHash(b)); const c: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 4 }; const d: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 5 }; - testing.expect(testHash(c) == testHash(c)); - testing.expect(testHash(c) != testHash(d)); + try testing.expect(testHash(c) == testHash(c)); + try testing.expect(testHash(c) != testHash(d)); } test "testHash error union" { @@ -422,7 +422,7 @@ test "testHash error union" { }; const f = Foo{}; const g: Errors!Foo = Errors.Test; - testing.expect(testHash(f) != testHash(g)); - testing.expect(testHash(f) == testHash(Foo{})); - testing.expect(testHash(g) == testHash(Errors.Test)); + try testing.expect(testHash(f) != testHash(g)); + try testing.expect(testHash(f) == testHash(Foo{})); + try testing.expect(testHash(g) == testHash(Errors.Test)); } diff --git a/lib/std/hash/cityhash.zig b/lib/std/hash/cityhash.zig index d7f2f1a9eb..9767800e7b 100644 --- a/lib/std/hash/cityhash.zig +++ b/lib/std/hash/cityhash.zig @@ -381,14 +381,14 @@ fn CityHash32hashIgnoreSeed(str: []const u8, seed: u32) u32 { test "cityhash32" { const Test = struct { - fn doTest() void { + fn doTest() !void { // Note: SMHasher doesn't provide a 32bit version of the algorithm. // Note: The implementation was verified against the Google Abseil version. - std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81); - std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81); + try std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81); + try std.testing.expectEqual(SMHasherTest(CityHash32hashIgnoreSeed), 0x68254F81); } }; - Test.doTest(); + try Test.doTest(); // TODO This is uncommented to prevent OOM on the CI server. Re-enable this test // case once we ship stage2. //@setEvalBranchQuota(50000); @@ -397,13 +397,13 @@ test "cityhash32" { test "cityhash64" { const Test = struct { - fn doTest() void { + fn doTest() !void { // Note: This is not compliant with the SMHasher implementation of CityHash64! // Note: The implementation was verified against the Google Abseil version. - std.testing.expectEqual(SMHasherTest(CityHash64.hashWithSeed), 0x5FABC5C5); + try std.testing.expectEqual(SMHasherTest(CityHash64.hashWithSeed), 0x5FABC5C5); } }; - Test.doTest(); + try Test.doTest(); // TODO This is uncommented to prevent OOM on the CI server. Re-enable this test // case once we ship stage2. //@setEvalBranchQuota(50000); diff --git a/lib/std/hash/crc.zig b/lib/std/hash/crc.zig index a2d6ed429c..391438f463 100644 --- a/lib/std/hash/crc.zig +++ b/lib/std/hash/crc.zig @@ -109,9 +109,9 @@ test "crc32 ieee" { const Crc32Ieee = Crc32WithPoly(.IEEE); - testing.expect(Crc32Ieee.hash("") == 0x00000000); - testing.expect(Crc32Ieee.hash("a") == 0xe8b7be43); - testing.expect(Crc32Ieee.hash("abc") == 0x352441c2); + try testing.expect(Crc32Ieee.hash("") == 0x00000000); + try testing.expect(Crc32Ieee.hash("a") == 0xe8b7be43); + try testing.expect(Crc32Ieee.hash("abc") == 0x352441c2); } test "crc32 castagnoli" { @@ -119,9 +119,9 @@ test "crc32 castagnoli" { const Crc32Castagnoli = Crc32WithPoly(.Castagnoli); - testing.expect(Crc32Castagnoli.hash("") == 0x00000000); - testing.expect(Crc32Castagnoli.hash("a") == 0xc1d04330); - testing.expect(Crc32Castagnoli.hash("abc") == 0x364b3fb7); + try testing.expect(Crc32Castagnoli.hash("") == 0x00000000); + try testing.expect(Crc32Castagnoli.hash("a") == 0xc1d04330); + try testing.expect(Crc32Castagnoli.hash("abc") == 0x364b3fb7); } // half-byte lookup table implementation. @@ -177,9 +177,9 @@ test "small crc32 ieee" { const Crc32Ieee = Crc32SmallWithPoly(.IEEE); - testing.expect(Crc32Ieee.hash("") == 0x00000000); - testing.expect(Crc32Ieee.hash("a") == 0xe8b7be43); - testing.expect(Crc32Ieee.hash("abc") == 0x352441c2); + try testing.expect(Crc32Ieee.hash("") == 0x00000000); + try testing.expect(Crc32Ieee.hash("a") == 0xe8b7be43); + try testing.expect(Crc32Ieee.hash("abc") == 0x352441c2); } test "small crc32 castagnoli" { @@ -187,7 +187,7 @@ test "small crc32 castagnoli" { const Crc32Castagnoli = Crc32SmallWithPoly(.Castagnoli); - testing.expect(Crc32Castagnoli.hash("") == 0x00000000); - testing.expect(Crc32Castagnoli.hash("a") == 0xc1d04330); - testing.expect(Crc32Castagnoli.hash("abc") == 0x364b3fb7); + try testing.expect(Crc32Castagnoli.hash("") == 0x00000000); + try testing.expect(Crc32Castagnoli.hash("a") == 0xc1d04330); + try testing.expect(Crc32Castagnoli.hash("abc") == 0x364b3fb7); } diff --git a/lib/std/hash/fnv.zig b/lib/std/hash/fnv.zig index 99e3bd482d..7dadf5488f 100644 --- a/lib/std/hash/fnv.zig +++ b/lib/std/hash/fnv.zig @@ -46,18 +46,18 @@ fn Fnv1a(comptime T: type, comptime prime: T, comptime offset: T) type { } test "fnv1a-32" { - testing.expect(Fnv1a_32.hash("") == 0x811c9dc5); - testing.expect(Fnv1a_32.hash("a") == 0xe40c292c); - testing.expect(Fnv1a_32.hash("foobar") == 0xbf9cf968); + try testing.expect(Fnv1a_32.hash("") == 0x811c9dc5); + try testing.expect(Fnv1a_32.hash("a") == 0xe40c292c); + try testing.expect(Fnv1a_32.hash("foobar") == 0xbf9cf968); } test "fnv1a-64" { - testing.expect(Fnv1a_64.hash("") == 0xcbf29ce484222325); - testing.expect(Fnv1a_64.hash("a") == 0xaf63dc4c8601ec8c); - testing.expect(Fnv1a_64.hash("foobar") == 0x85944171f73967e8); + try testing.expect(Fnv1a_64.hash("") == 0xcbf29ce484222325); + try testing.expect(Fnv1a_64.hash("a") == 0xaf63dc4c8601ec8c); + try testing.expect(Fnv1a_64.hash("foobar") == 0x85944171f73967e8); } test "fnv1a-128" { - testing.expect(Fnv1a_128.hash("") == 0x6c62272e07bb014262b821756295c58d); - testing.expect(Fnv1a_128.hash("a") == 0xd228cb696f1a8caf78912b704e4a8964); + try testing.expect(Fnv1a_128.hash("") == 0x6c62272e07bb014262b821756295c58d); + try testing.expect(Fnv1a_128.hash("a") == 0xd228cb696f1a8caf78912b704e4a8964); } diff --git a/lib/std/hash/murmur.zig b/lib/std/hash/murmur.zig index 65dd523396..61e4791387 100644 --- a/lib/std/hash/murmur.zig +++ b/lib/std/hash/murmur.zig @@ -308,7 +308,7 @@ fn SMHasherTest(comptime hash_fn: anytype, comptime hashbits: u32) u32 { } test "murmur2_32" { - testing.expectEqual(SMHasherTest(Murmur2_32.hashWithSeed, 32), 0x27864C1E); + try testing.expectEqual(SMHasherTest(Murmur2_32.hashWithSeed, 32), 0x27864C1E); var v0: u32 = 0x12345678; var v1: u64 = 0x1234567812345678; var v0le: u32 = v0; @@ -317,12 +317,12 @@ test "murmur2_32" { v0le = @byteSwap(u32, v0le); v1le = @byteSwap(u64, v1le); } - testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_32.hashUint32(v0)); - testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_32.hashUint64(v1)); + try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_32.hashUint32(v0)); + try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_32.hashUint64(v1)); } test "murmur2_64" { - std.testing.expectEqual(SMHasherTest(Murmur2_64.hashWithSeed, 64), 0x1F0D3804); + try std.testing.expectEqual(SMHasherTest(Murmur2_64.hashWithSeed, 64), 0x1F0D3804); var v0: u32 = 0x12345678; var v1: u64 = 0x1234567812345678; var v0le: u32 = v0; @@ -331,12 +331,12 @@ test "murmur2_64" { v0le = @byteSwap(u32, v0le); v1le = @byteSwap(u64, v1le); } - testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_64.hashUint32(v0)); - testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_64.hashUint64(v1)); + try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_64.hashUint32(v0)); + try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_64.hashUint64(v1)); } test "murmur3_32" { - std.testing.expectEqual(SMHasherTest(Murmur3_32.hashWithSeed, 32), 0xB0F57EE3); + try std.testing.expectEqual(SMHasherTest(Murmur3_32.hashWithSeed, 32), 0xB0F57EE3); var v0: u32 = 0x12345678; var v1: u64 = 0x1234567812345678; var v0le: u32 = v0; @@ -345,6 +345,6 @@ test "murmur3_32" { v0le = @byteSwap(u32, v0le); v1le = @byteSwap(u64, v1le); } - testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur3_32.hashUint32(v0)); - testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur3_32.hashUint64(v1)); + try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur3_32.hashUint32(v0)); + try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur3_32.hashUint64(v1)); } diff --git a/lib/std/hash/wyhash.zig b/lib/std/hash/wyhash.zig index 45530eccff..4b9afe6355 100644 --- a/lib/std/hash/wyhash.zig +++ b/lib/std/hash/wyhash.zig @@ -183,13 +183,13 @@ const expectEqual = std.testing.expectEqual; test "test vectors" { const hash = Wyhash.hash; - expectEqual(hash(0, ""), 0x0); - expectEqual(hash(1, "a"), 0xbed235177f41d328); - expectEqual(hash(2, "abc"), 0xbe348debe59b27c3); - expectEqual(hash(3, "message digest"), 0x37320f657213a290); - expectEqual(hash(4, "abcdefghijklmnopqrstuvwxyz"), 0xd0b270e1d8a7019c); - expectEqual(hash(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 0x602a1894d3bbfe7f); - expectEqual(hash(6, "12345678901234567890123456789012345678901234567890123456789012345678901234567890"), 0x829e9c148b75970e); + try expectEqual(hash(0, ""), 0x0); + try expectEqual(hash(1, "a"), 0xbed235177f41d328); + try expectEqual(hash(2, "abc"), 0xbe348debe59b27c3); + try expectEqual(hash(3, "message digest"), 0x37320f657213a290); + try expectEqual(hash(4, "abcdefghijklmnopqrstuvwxyz"), 0xd0b270e1d8a7019c); + try expectEqual(hash(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 0x602a1894d3bbfe7f); + try expectEqual(hash(6, "12345678901234567890123456789012345678901234567890123456789012345678901234567890"), 0x829e9c148b75970e); } test "test vectors streaming" { @@ -197,19 +197,19 @@ test "test vectors streaming" { for ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") |e| { wh.update(mem.asBytes(&e)); } - expectEqual(wh.final(), 0x602a1894d3bbfe7f); + try expectEqual(wh.final(), 0x602a1894d3bbfe7f); const pattern = "1234567890"; const count = 8; const result = 0x829e9c148b75970e; - expectEqual(Wyhash.hash(6, pattern ** 8), result); + try expectEqual(Wyhash.hash(6, pattern ** 8), result); wh = Wyhash.init(6); var i: u32 = 0; while (i < count) : (i += 1) { wh.update(pattern); } - expectEqual(wh.final(), result); + try expectEqual(wh.final(), result); } test "iterative non-divisible update" { @@ -231,6 +231,6 @@ test "iterative non-divisible update" { } const iterative_hash = wy.final(); - std.testing.expectEqual(iterative_hash, non_iterative_hash); + try std.testing.expectEqual(iterative_hash, non_iterative_hash); } } diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig index b74144d08b..0523ad7376 100644 --- a/lib/std/hash_map.zig +++ b/lib/std/hash_map.zig @@ -824,15 +824,15 @@ test "std.hash_map basic usage" { while (it.next()) |kv| { sum += kv.key; } - expect(sum == total); + try expect(sum == total); i = 0; sum = 0; while (i < count) : (i += 1) { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); sum += map.get(i).?; } - expectEqual(total, sum); + try expectEqual(total, sum); } test "std.hash_map ensureCapacity" { @@ -841,13 +841,13 @@ test "std.hash_map ensureCapacity" { try map.ensureCapacity(20); const initial_capacity = map.capacity(); - testing.expect(initial_capacity >= 20); + try testing.expect(initial_capacity >= 20); var i: i32 = 0; while (i < 20) : (i += 1) { - testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null); + try testing.expect(map.fetchPutAssumeCapacity(i, i + 10) == null); } // shouldn't resize from putAssumeCapacity - testing.expect(initial_capacity == map.capacity()); + try testing.expect(initial_capacity == map.capacity()); } test "std.hash_map ensureCapacity with tombstones" { @@ -870,22 +870,22 @@ test "std.hash_map clearRetainingCapacity" { map.clearRetainingCapacity(); try map.put(1, 1); - expectEqual(map.get(1).?, 1); - expectEqual(map.count(), 1); + try expectEqual(map.get(1).?, 1); + try expectEqual(map.count(), 1); map.clearRetainingCapacity(); map.putAssumeCapacity(1, 1); - expectEqual(map.get(1).?, 1); - expectEqual(map.count(), 1); + try expectEqual(map.get(1).?, 1); + try expectEqual(map.count(), 1); const cap = map.capacity(); - expect(cap > 0); + try expect(cap > 0); map.clearRetainingCapacity(); map.clearRetainingCapacity(); - expectEqual(map.count(), 0); - expectEqual(map.capacity(), cap); - expect(!map.contains(1)); + try expectEqual(map.count(), 0); + try expectEqual(map.capacity(), cap); + try expect(!map.contains(1)); } test "std.hash_map grow" { @@ -898,19 +898,19 @@ test "std.hash_map grow" { while (i < growTo) : (i += 1) { try map.put(i, i); } - expectEqual(map.count(), growTo); + try expectEqual(map.count(), growTo); i = 0; var it = map.iterator(); while (it.next()) |kv| { - expectEqual(kv.key, kv.value); + try expectEqual(kv.key, kv.value); i += 1; } - expectEqual(i, growTo); + try expectEqual(i, growTo); i = 0; while (i < growTo) : (i += 1) { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); } } @@ -921,7 +921,7 @@ test "std.hash_map clone" { var a = try map.clone(); defer a.deinit(); - expectEqual(a.count(), 0); + try expectEqual(a.count(), 0); try a.put(1, 1); try a.put(2, 2); @@ -930,10 +930,10 @@ test "std.hash_map clone" { var b = try a.clone(); defer b.deinit(); - expectEqual(b.count(), 3); - expectEqual(b.get(1), 1); - expectEqual(b.get(2), 2); - expectEqual(b.get(3), 3); + try expectEqual(b.count(), 3); + try expectEqual(b.get(1), 1); + try expectEqual(b.get(2), 2); + try expectEqual(b.get(3), 3); } test "std.hash_map ensureCapacity with existing elements" { @@ -941,12 +941,12 @@ test "std.hash_map ensureCapacity with existing elements" { defer map.deinit(); try map.put(0, 0); - expectEqual(map.count(), 1); - expectEqual(map.capacity(), @TypeOf(map).Unmanaged.minimal_capacity); + try expectEqual(map.count(), 1); + try expectEqual(map.capacity(), @TypeOf(map).Unmanaged.minimal_capacity); try map.ensureCapacity(65); - expectEqual(map.count(), 1); - expectEqual(map.capacity(), 128); + try expectEqual(map.count(), 1); + try expectEqual(map.capacity(), 128); } test "std.hash_map ensureCapacity satisfies max load factor" { @@ -954,7 +954,7 @@ test "std.hash_map ensureCapacity satisfies max load factor" { defer map.deinit(); try map.ensureCapacity(127); - expectEqual(map.capacity(), 256); + try expectEqual(map.capacity(), 256); } test "std.hash_map remove" { @@ -972,19 +972,19 @@ test "std.hash_map remove" { _ = map.remove(i); } } - expectEqual(map.count(), 10); + try expectEqual(map.count(), 10); var it = map.iterator(); while (it.next()) |kv| { - expectEqual(kv.key, kv.value); - expect(kv.key % 3 != 0); + try expectEqual(kv.key, kv.value); + try expect(kv.key % 3 != 0); } i = 0; while (i < 16) : (i += 1) { if (i % 3 == 0) { - expect(!map.contains(i)); + try expect(!map.contains(i)); } else { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); } } } @@ -1001,14 +1001,14 @@ test "std.hash_map reverse removes" { i = 16; while (i > 0) : (i -= 1) { _ = map.remove(i - 1); - expect(!map.contains(i - 1)); + try expect(!map.contains(i - 1)); var j: u32 = 0; while (j < i - 1) : (j += 1) { - expectEqual(map.get(j).?, j); + try expectEqual(map.get(j).?, j); } } - expectEqual(map.count(), 0); + try expectEqual(map.count(), 0); } test "std.hash_map multiple removes on same metadata" { @@ -1024,17 +1024,17 @@ test "std.hash_map multiple removes on same metadata" { _ = map.remove(15); _ = map.remove(14); _ = map.remove(13); - expect(!map.contains(7)); - expect(!map.contains(15)); - expect(!map.contains(14)); - expect(!map.contains(13)); + try expect(!map.contains(7)); + try expect(!map.contains(15)); + try expect(!map.contains(14)); + try expect(!map.contains(13)); i = 0; while (i < 13) : (i += 1) { if (i == 7) { - expect(!map.contains(i)); + try expect(!map.contains(i)); } else { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); } } @@ -1044,7 +1044,7 @@ test "std.hash_map multiple removes on same metadata" { try map.put(7, 7); i = 0; while (i < 16) : (i += 1) { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); } } @@ -1070,12 +1070,12 @@ test "std.hash_map put and remove loop in random order" { for (keys.items) |key| { try map.put(key, key); } - expectEqual(map.count(), size); + try expectEqual(map.count(), size); for (keys.items) |key| { _ = map.remove(key); } - expectEqual(map.count(), 0); + try expectEqual(map.count(), 0); } } @@ -1119,7 +1119,7 @@ test "std.hash_map put" { i = 0; while (i < 16) : (i += 1) { - expectEqual(map.get(i).?, i); + try expectEqual(map.get(i).?, i); } i = 0; @@ -1129,7 +1129,7 @@ test "std.hash_map put" { i = 0; while (i < 16) : (i += 1) { - expectEqual(map.get(i).?, i * 16 + 1); + try expectEqual(map.get(i).?, i * 16 + 1); } } @@ -1148,7 +1148,7 @@ test "std.hash_map putAssumeCapacity" { while (i < 20) : (i += 1) { sum += map.get(i).?; } - expectEqual(sum, 190); + try expectEqual(sum, 190); i = 0; while (i < 20) : (i += 1) { @@ -1160,7 +1160,7 @@ test "std.hash_map putAssumeCapacity" { while (i < 20) : (i += 1) { sum += map.get(i).?; } - expectEqual(sum, 20); + try expectEqual(sum, 20); } test "std.hash_map getOrPut" { @@ -1183,49 +1183,49 @@ test "std.hash_map getOrPut" { sum += map.get(i).?; } - expectEqual(sum, 30); + try expectEqual(sum, 30); } test "std.hash_map basic hash map usage" { var map = AutoHashMap(i32, i32).init(std.testing.allocator); defer map.deinit(); - testing.expect((try map.fetchPut(1, 11)) == null); - testing.expect((try map.fetchPut(2, 22)) == null); - testing.expect((try map.fetchPut(3, 33)) == null); - testing.expect((try map.fetchPut(4, 44)) == null); + try testing.expect((try map.fetchPut(1, 11)) == null); + try testing.expect((try map.fetchPut(2, 22)) == null); + try testing.expect((try map.fetchPut(3, 33)) == null); + try testing.expect((try map.fetchPut(4, 44)) == null); try map.putNoClobber(5, 55); - testing.expect((try map.fetchPut(5, 66)).?.value == 55); - testing.expect((try map.fetchPut(5, 55)).?.value == 66); + try testing.expect((try map.fetchPut(5, 66)).?.value == 55); + try testing.expect((try map.fetchPut(5, 55)).?.value == 66); const gop1 = try map.getOrPut(5); - testing.expect(gop1.found_existing == true); - testing.expect(gop1.entry.value == 55); + try testing.expect(gop1.found_existing == true); + try testing.expect(gop1.entry.value == 55); gop1.entry.value = 77; - testing.expect(map.getEntry(5).?.value == 77); + try testing.expect(map.getEntry(5).?.value == 77); const gop2 = try map.getOrPut(99); - testing.expect(gop2.found_existing == false); + try testing.expect(gop2.found_existing == false); gop2.entry.value = 42; - testing.expect(map.getEntry(99).?.value == 42); + try testing.expect(map.getEntry(99).?.value == 42); const gop3 = try map.getOrPutValue(5, 5); - testing.expect(gop3.value == 77); + try testing.expect(gop3.value == 77); const gop4 = try map.getOrPutValue(100, 41); - testing.expect(gop4.value == 41); + try testing.expect(gop4.value == 41); - testing.expect(map.contains(2)); - testing.expect(map.getEntry(2).?.value == 22); - testing.expect(map.get(2).? == 22); + try testing.expect(map.contains(2)); + try testing.expect(map.getEntry(2).?.value == 22); + try testing.expect(map.get(2).? == 22); const rmv1 = map.remove(2); - testing.expect(rmv1.?.key == 2); - testing.expect(rmv1.?.value == 22); - testing.expect(map.remove(2) == null); - testing.expect(map.getEntry(2) == null); - testing.expect(map.get(2) == null); + try testing.expect(rmv1.?.key == 2); + try testing.expect(rmv1.?.value == 22); + try testing.expect(map.remove(2) == null); + try testing.expect(map.getEntry(2) == null); + try testing.expect(map.get(2) == null); map.removeAssertDiscard(3); } @@ -1244,6 +1244,6 @@ test "std.hash_map clone" { i = 0; while (i < 10) : (i += 1) { - testing.expect(copy.get(i).? == i * 10); + try testing.expect(copy.get(i).? == i * 10); } } diff --git a/lib/std/heap.zig b/lib/std/heap.zig index 3e1a24beea..9e86c78f69 100644 --- a/lib/std/heap.zig +++ b/lib/std/heap.zig @@ -858,16 +858,16 @@ test "WasmPageAllocator internals" { if (comptime std.Target.current.isWasm()) { const conventional_memsize = WasmPageAllocator.conventional.totalPages() * mem.page_size; const initial = try page_allocator.alloc(u8, mem.page_size); - testing.expect(@ptrToInt(initial.ptr) < conventional_memsize); // If this isn't conventional, the rest of these tests don't make sense. Also we have a serious memory leak in the test suite. + try testing.expect(@ptrToInt(initial.ptr) < conventional_memsize); // If this isn't conventional, the rest of these tests don't make sense. Also we have a serious memory leak in the test suite. var inplace = try page_allocator.realloc(initial, 1); - testing.expectEqual(initial.ptr, inplace.ptr); + try testing.expectEqual(initial.ptr, inplace.ptr); inplace = try page_allocator.realloc(inplace, 4); - testing.expectEqual(initial.ptr, inplace.ptr); + try testing.expectEqual(initial.ptr, inplace.ptr); page_allocator.free(inplace); const reuse = try page_allocator.alloc(u8, 1); - testing.expectEqual(initial.ptr, reuse.ptr); + try testing.expectEqual(initial.ptr, reuse.ptr); page_allocator.free(reuse); // This segment may span conventional and extended which has really complex rules so we're just ignoring it for now. @@ -875,18 +875,18 @@ test "WasmPageAllocator internals" { page_allocator.free(padding); const extended = try page_allocator.alloc(u8, conventional_memsize); - testing.expect(@ptrToInt(extended.ptr) >= conventional_memsize); + try testing.expect(@ptrToInt(extended.ptr) >= conventional_memsize); const use_small = try page_allocator.alloc(u8, 1); - testing.expectEqual(initial.ptr, use_small.ptr); + try testing.expectEqual(initial.ptr, use_small.ptr); page_allocator.free(use_small); inplace = try page_allocator.realloc(extended, 1); - testing.expectEqual(extended.ptr, inplace.ptr); + try testing.expectEqual(extended.ptr, inplace.ptr); page_allocator.free(inplace); const reuse_extended = try page_allocator.alloc(u8, conventional_memsize); - testing.expectEqual(extended.ptr, reuse_extended.ptr); + try testing.expectEqual(extended.ptr, reuse_extended.ptr); page_allocator.free(reuse_extended); } } @@ -959,15 +959,15 @@ test "FixedBufferAllocator.reset" { var x = try fba.allocator.create(u64); x.* = X; - testing.expectError(error.OutOfMemory, fba.allocator.create(u64)); + try testing.expectError(error.OutOfMemory, fba.allocator.create(u64)); fba.reset(); var y = try fba.allocator.create(u64); y.* = Y; // we expect Y to have overwritten X. - testing.expect(x.* == y.*); - testing.expect(y.* == Y); + try testing.expect(x.* == y.*); + try testing.expect(y.* == Y); } test "StackFallbackAllocator" { @@ -987,11 +987,11 @@ test "FixedBufferAllocator Reuse memory on realloc" { var fixed_buffer_allocator = FixedBufferAllocator.init(small_fixed_buffer[0..]); var slice0 = try fixed_buffer_allocator.allocator.alloc(u8, 5); - testing.expect(slice0.len == 5); + try testing.expect(slice0.len == 5); var slice1 = try fixed_buffer_allocator.allocator.realloc(slice0, 10); - testing.expect(slice1.ptr == slice0.ptr); - testing.expect(slice1.len == 10); - testing.expectError(error.OutOfMemory, fixed_buffer_allocator.allocator.realloc(slice1, 11)); + try testing.expect(slice1.ptr == slice0.ptr); + try testing.expect(slice1.len == 10); + try testing.expectError(error.OutOfMemory, fixed_buffer_allocator.allocator.realloc(slice1, 11)); } // check that we don't re-use the memory if it's not the most recent block { @@ -1002,10 +1002,10 @@ test "FixedBufferAllocator Reuse memory on realloc" { slice0[1] = 2; var slice1 = try fixed_buffer_allocator.allocator.alloc(u8, 2); var slice2 = try fixed_buffer_allocator.allocator.realloc(slice0, 4); - testing.expect(slice0.ptr != slice2.ptr); - testing.expect(slice1.ptr != slice2.ptr); - testing.expect(slice2[0] == 1); - testing.expect(slice2[1] == 2); + try testing.expect(slice0.ptr != slice2.ptr); + try testing.expect(slice1.ptr != slice2.ptr); + try testing.expect(slice2[0] == 1); + try testing.expect(slice2[1] == 2); } } @@ -1024,28 +1024,28 @@ pub fn testAllocator(base_allocator: *mem.Allocator) !void { const allocator = &validationAllocator.allocator; var slice = try allocator.alloc(*i32, 100); - testing.expect(slice.len == 100); + try testing.expect(slice.len == 100); for (slice) |*item, i| { item.* = try allocator.create(i32); item.*.* = @intCast(i32, i); } slice = try allocator.realloc(slice, 20000); - testing.expect(slice.len == 20000); + try testing.expect(slice.len == 20000); for (slice[0..100]) |item, i| { - testing.expect(item.* == @intCast(i32, i)); + try testing.expect(item.* == @intCast(i32, i)); allocator.destroy(item); } slice = allocator.shrink(slice, 50); - testing.expect(slice.len == 50); + try testing.expect(slice.len == 50); slice = allocator.shrink(slice, 25); - testing.expect(slice.len == 25); + try testing.expect(slice.len == 25); slice = allocator.shrink(slice, 0); - testing.expect(slice.len == 0); + try testing.expect(slice.len == 0); slice = try allocator.realloc(slice, 10); - testing.expect(slice.len == 10); + try testing.expect(slice.len == 10); allocator.free(slice); @@ -1058,7 +1058,7 @@ pub fn testAllocator(base_allocator: *mem.Allocator) !void { allocator.destroy(zero_bit_ptr); const oversize = try allocator.allocAdvanced(u32, null, 5, .at_least); - testing.expect(oversize.len >= 5); + try testing.expect(oversize.len >= 5); for (oversize) |*item| { item.* = 0xDEADBEEF; } @@ -1073,29 +1073,29 @@ pub fn testAllocatorAligned(base_allocator: *mem.Allocator) !void { inline for ([_]u29{ 1, 2, 4, 8, 16, 32, 64 }) |alignment| { // initial var slice = try allocator.alignedAlloc(u8, alignment, 10); - testing.expect(slice.len == 10); + try testing.expect(slice.len == 10); // grow slice = try allocator.realloc(slice, 100); - testing.expect(slice.len == 100); + try testing.expect(slice.len == 100); // shrink slice = allocator.shrink(slice, 10); - testing.expect(slice.len == 10); + try testing.expect(slice.len == 10); // go to zero slice = allocator.shrink(slice, 0); - testing.expect(slice.len == 0); + try testing.expect(slice.len == 0); // realloc from zero slice = try allocator.realloc(slice, 100); - testing.expect(slice.len == 100); + try testing.expect(slice.len == 100); // shrink with shrink slice = allocator.shrink(slice, 10); - testing.expect(slice.len == 10); + try testing.expect(slice.len == 10); // shrink to zero slice = allocator.shrink(slice, 0); - testing.expect(slice.len == 0); + try testing.expect(slice.len == 0); } } -pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) mem.Allocator.Error!void { +pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) !void { var validationAllocator = mem.validationWrap(base_allocator); const allocator = &validationAllocator.allocator; @@ -1110,24 +1110,24 @@ pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) mem.Allocator _ = @shlWithOverflow(usize, ~@as(usize, 0), @as(USizeShift, @ctz(u29, large_align)), &align_mask); var slice = try allocator.alignedAlloc(u8, large_align, 500); - testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); + try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); slice = allocator.shrink(slice, 100); - testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); + try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); slice = try allocator.realloc(slice, 5000); - testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); + try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); slice = allocator.shrink(slice, 10); - testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); + try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); slice = try allocator.realloc(slice, 20000); - testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); + try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr)); allocator.free(slice); } -pub fn testAllocatorAlignedShrink(base_allocator: *mem.Allocator) mem.Allocator.Error!void { +pub fn testAllocatorAlignedShrink(base_allocator: *mem.Allocator) !void { var validationAllocator = mem.validationWrap(base_allocator); const allocator = &validationAllocator.allocator; @@ -1155,8 +1155,8 @@ pub fn testAllocatorAlignedShrink(base_allocator: *mem.Allocator) mem.Allocator. // realloc to a smaller size but with a larger alignment slice = try allocator.reallocAdvanced(slice, mem.page_size * 32, alloc_size / 2, .exact); - testing.expect(slice[0] == 0x12); - testing.expect(slice[60] == 0x34); + try testing.expect(slice[0] == 0x12); + try testing.expect(slice[60] == 0x34); } test "heap" { diff --git a/lib/std/heap/general_purpose_allocator.zig b/lib/std/heap/general_purpose_allocator.zig index c731f22d66..b2980aae9f 100644 --- a/lib/std/heap/general_purpose_allocator.zig +++ b/lib/std/heap/general_purpose_allocator.zig @@ -692,7 +692,7 @@ const test_config = Config{}; test "small allocations - free in same order" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var list = std.ArrayList(*u64).init(std.testing.allocator); @@ -711,7 +711,7 @@ test "small allocations - free in same order" { test "small allocations - free in reverse order" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var list = std.ArrayList(*u64).init(std.testing.allocator); @@ -730,7 +730,7 @@ test "small allocations - free in reverse order" { test "large allocations" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; const ptr1 = try allocator.alloc(u64, 42768); @@ -743,7 +743,7 @@ test "large allocations" { test "realloc" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alignedAlloc(u8, @alignOf(u32), 1); @@ -753,19 +753,19 @@ test "realloc" { // This reallocation should keep its pointer address. const old_slice = slice; slice = try allocator.realloc(slice, 2); - std.testing.expect(old_slice.ptr == slice.ptr); - std.testing.expect(slice[0] == 0x12); + try std.testing.expect(old_slice.ptr == slice.ptr); + try std.testing.expect(slice[0] == 0x12); slice[1] = 0x34; // This requires upgrading to a larger size class slice = try allocator.realloc(slice, 17); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[1] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[1] == 0x34); } test "shrink" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alloc(u8, 20); @@ -776,19 +776,19 @@ test "shrink" { slice = allocator.shrink(slice, 17); for (slice) |b| { - std.testing.expect(b == 0x11); + try std.testing.expect(b == 0x11); } slice = allocator.shrink(slice, 16); for (slice) |b| { - std.testing.expect(b == 0x11); + try std.testing.expect(b == 0x11); } } test "large object - grow" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice1 = try allocator.alloc(u8, page_size * 2 - 20); @@ -796,17 +796,17 @@ test "large object - grow" { const old = slice1; slice1 = try allocator.realloc(slice1, page_size * 2 - 10); - std.testing.expect(slice1.ptr == old.ptr); + try std.testing.expect(slice1.ptr == old.ptr); slice1 = try allocator.realloc(slice1, page_size * 2); - std.testing.expect(slice1.ptr == old.ptr); + try std.testing.expect(slice1.ptr == old.ptr); slice1 = try allocator.realloc(slice1, page_size * 2 + 1); } test "realloc small object to large object" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alloc(u8, 70); @@ -817,13 +817,13 @@ test "realloc small object to large object" { // This requires upgrading to a large object const large_object_size = page_size * 2 + 50; slice = try allocator.realloc(slice, large_object_size); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[60] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[60] == 0x34); } test "shrink large object to large object" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alloc(u8, page_size * 2 + 50); @@ -832,21 +832,21 @@ test "shrink large object to large object" { slice[60] = 0x34; slice = try allocator.resize(slice, page_size * 2 + 1); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[60] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[60] == 0x34); slice = allocator.shrink(slice, page_size * 2 + 1); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[60] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[60] == 0x34); slice = try allocator.realloc(slice, page_size * 2); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[60] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[60] == 0x34); } test "shrink large object to large object with larger alignment" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var debug_buffer: [1000]u8 = undefined; @@ -875,13 +875,13 @@ test "shrink large object to large object with larger alignment" { slice[60] = 0x34; slice = try allocator.reallocAdvanced(slice, big_alignment, alloc_size / 2, .exact); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[60] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[60] == 0x34); } test "realloc large object to small object" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alloc(u8, page_size * 2 + 50); @@ -890,8 +890,8 @@ test "realloc large object to small object" { slice[16] = 0x34; slice = try allocator.realloc(slice, 19); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[16] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[16] == 0x34); } test "overrideable mutexes" { @@ -899,7 +899,7 @@ test "overrideable mutexes" { .backing_allocator = std.testing.allocator, .mutex = std.Thread.Mutex{}, }; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; const ptr = try allocator.create(i32); @@ -908,7 +908,7 @@ test "overrideable mutexes" { test "non-page-allocator backing allocator" { var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = std.testing.allocator }; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; const ptr = try allocator.create(i32); @@ -917,7 +917,7 @@ test "non-page-allocator backing allocator" { test "realloc large object to larger alignment" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var debug_buffer: [1000]u8 = undefined; @@ -943,22 +943,22 @@ test "realloc large object to larger alignment" { slice[16] = 0x34; slice = try allocator.reallocAdvanced(slice, 32, page_size * 2 + 100, .exact); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[16] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[16] == 0x34); slice = try allocator.reallocAdvanced(slice, 32, page_size * 2 + 25, .exact); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[16] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[16] == 0x34); slice = try allocator.reallocAdvanced(slice, big_alignment, page_size * 2 + 100, .exact); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[16] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[16] == 0x34); } test "large object shrinks to small but allocation fails during shrink" { var failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, 3); var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = &failing_allocator.allocator }; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; var slice = try allocator.alloc(u8, page_size * 2 + 50); @@ -969,13 +969,13 @@ test "large object shrinks to small but allocation fails during shrink" { // Next allocation will fail in the backing allocator of the GeneralPurposeAllocator slice = allocator.shrink(slice, 4); - std.testing.expect(slice[0] == 0x12); - std.testing.expect(slice[3] == 0x34); + try std.testing.expect(slice[0] == 0x12); + try std.testing.expect(slice[3] == 0x34); } test "objects of size 1024 and 2048" { var gpa = GeneralPurposeAllocator(test_config){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; const slice = try allocator.alloc(u8, 1025); @@ -987,26 +987,26 @@ test "objects of size 1024 and 2048" { test "setting a memory cap" { var gpa = GeneralPurposeAllocator(.{ .enable_memory_limit = true }){}; - defer std.testing.expect(!gpa.deinit()); + defer std.testing.expect(!gpa.deinit()) catch @panic("leak"); const allocator = &gpa.allocator; gpa.setRequestedMemoryLimit(1010); const small = try allocator.create(i32); - std.testing.expect(gpa.total_requested_bytes == 4); + try std.testing.expect(gpa.total_requested_bytes == 4); const big = try allocator.alloc(u8, 1000); - std.testing.expect(gpa.total_requested_bytes == 1004); + try std.testing.expect(gpa.total_requested_bytes == 1004); - std.testing.expectError(error.OutOfMemory, allocator.create(u64)); + try std.testing.expectError(error.OutOfMemory, allocator.create(u64)); allocator.destroy(small); - std.testing.expect(gpa.total_requested_bytes == 1000); + try std.testing.expect(gpa.total_requested_bytes == 1000); allocator.free(big); - std.testing.expect(gpa.total_requested_bytes == 0); + try std.testing.expect(gpa.total_requested_bytes == 0); const exact = try allocator.alloc(u8, 1010); - std.testing.expect(gpa.total_requested_bytes == 1010); + try std.testing.expect(gpa.total_requested_bytes == 1010); allocator.free(exact); } diff --git a/lib/std/heap/logging_allocator.zig b/lib/std/heap/logging_allocator.zig index 7885571ab3..ac301425bb 100644 --- a/lib/std/heap/logging_allocator.zig +++ b/lib/std/heap/logging_allocator.zig @@ -93,11 +93,11 @@ test "LoggingAllocator" { var a = try allocator.alloc(u8, 10); a = allocator.shrink(a, 5); - std.testing.expect(a.len == 5); - std.testing.expectError(error.OutOfMemory, allocator.resize(a, 20)); + try std.testing.expect(a.len == 5); + try std.testing.expectError(error.OutOfMemory, allocator.resize(a, 20)); allocator.free(a); - std.testing.expectEqualSlices(u8, + try std.testing.expectEqualSlices(u8, \\alloc : 10 success! \\shrink: 10 to 5 \\expand: 5 to 20 failure! diff --git a/lib/std/io/bit_reader.zig b/lib/std/io/bit_reader.zig index 213cd2b503..6d3f47fe95 100644 --- a/lib/std/io/bit_reader.zig +++ b/lib/std/io/bit_reader.zig @@ -185,64 +185,64 @@ test "api coverage" { const expect = testing.expect; const expectError = testing.expectError; - expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits)); - expect(out_bits == 1); - expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits)); - expect(out_bits == 2); - expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits)); - expect(out_bits == 3); - expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits)); - expect(out_bits == 4); - expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits)); - expect(out_bits == 5); - expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits)); - expect(out_bits == 1); + try expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits)); + try expect(out_bits == 1); + try expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits)); + try expect(out_bits == 2); + try expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits)); + try expect(out_bits == 3); + try expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits)); + try expect(out_bits == 4); + try expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits)); + try expect(out_bits == 5); + try expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits)); + try expect(out_bits == 1); mem_in_be.pos = 0; bit_stream_be.bit_count = 0; - expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits)); - expect(out_bits == 15); + try expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits)); + try expect(out_bits == 15); mem_in_be.pos = 0; bit_stream_be.bit_count = 0; - expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits)); - expect(out_bits == 16); + try expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits)); + try expect(out_bits == 16); _ = try bit_stream_be.readBits(u0, 0, &out_bits); - expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits)); - expect(out_bits == 0); - expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1)); + try expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits)); + try expect(out_bits == 0); + try expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1)); var mem_in_le = io.fixedBufferStream(&mem_le); var bit_stream_le = bitReader(.Little, mem_in_le.reader()); - expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits)); - expect(out_bits == 1); - expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits)); - expect(out_bits == 2); - expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits)); - expect(out_bits == 3); - expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits)); - expect(out_bits == 4); - expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits)); - expect(out_bits == 5); - expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits)); - expect(out_bits == 1); + try expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits)); + try expect(out_bits == 1); + try expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits)); + try expect(out_bits == 2); + try expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits)); + try expect(out_bits == 3); + try expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits)); + try expect(out_bits == 4); + try expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits)); + try expect(out_bits == 5); + try expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits)); + try expect(out_bits == 1); mem_in_le.pos = 0; bit_stream_le.bit_count = 0; - expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits)); - expect(out_bits == 15); + try expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits)); + try expect(out_bits == 15); mem_in_le.pos = 0; bit_stream_le.bit_count = 0; - expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits)); - expect(out_bits == 16); + try expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits)); + try expect(out_bits == 16); _ = try bit_stream_le.readBits(u0, 0, &out_bits); - expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits)); - expect(out_bits == 0); - expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1)); + try expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits)); + try expect(out_bits == 0); + try expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1)); } diff --git a/lib/std/io/bit_writer.zig b/lib/std/io/bit_writer.zig index 3ad2b75efb..67e72ef3dc 100644 --- a/lib/std/io/bit_writer.zig +++ b/lib/std/io/bit_writer.zig @@ -163,17 +163,17 @@ test "api coverage" { try bit_stream_be.writeBits(@as(u9, 5), 5); try bit_stream_be.writeBits(@as(u1, 1), 1); - testing.expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001011); + try testing.expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001011); mem_out_be.pos = 0; try bit_stream_be.writeBits(@as(u15, 0b110011010000101), 15); try bit_stream_be.flushBits(); - testing.expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001010); + try testing.expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001010); mem_out_be.pos = 0; try bit_stream_be.writeBits(@as(u32, 0b110011010000101), 16); - testing.expect(mem_be[0] == 0b01100110 and mem_be[1] == 0b10000101); + try testing.expect(mem_be[0] == 0b01100110 and mem_be[1] == 0b10000101); try bit_stream_be.writeBits(@as(u0, 0), 0); @@ -187,16 +187,16 @@ test "api coverage" { try bit_stream_le.writeBits(@as(u9, 5), 5); try bit_stream_le.writeBits(@as(u1, 1), 1); - testing.expect(mem_le[0] == 0b00011101 and mem_le[1] == 0b10010101); + try testing.expect(mem_le[0] == 0b00011101 and mem_le[1] == 0b10010101); mem_out_le.pos = 0; try bit_stream_le.writeBits(@as(u15, 0b110011010000101), 15); try bit_stream_le.flushBits(); - testing.expect(mem_le[0] == 0b10000101 and mem_le[1] == 0b01100110); + try testing.expect(mem_le[0] == 0b10000101 and mem_le[1] == 0b01100110); mem_out_le.pos = 0; try bit_stream_le.writeBits(@as(u32, 0b1100110100001011), 16); - testing.expect(mem_le[0] == 0b00001011 and mem_le[1] == 0b11001101); + try testing.expect(mem_le[0] == 0b00001011 and mem_le[1] == 0b11001101); try bit_stream_le.writeBits(@as(u0, 0), 0); } diff --git a/lib/std/io/buffered_reader.zig b/lib/std/io/buffered_reader.zig index 5fda7f2741..16e6480037 100644 --- a/lib/std/io/buffered_reader.zig +++ b/lib/std/io/buffered_reader.zig @@ -87,5 +87,5 @@ test "io.BufferedReader" { const res = try stream.readAllAlloc(testing.allocator, str.len + 1); defer testing.allocator.free(res); - testing.expectEqualSlices(u8, str, res); + try testing.expectEqualSlices(u8, str, res); } diff --git a/lib/std/io/counting_reader.zig b/lib/std/io/counting_reader.zig index 1369155a73..3b06555deb 100644 --- a/lib/std/io/counting_reader.zig +++ b/lib/std/io/counting_reader.zig @@ -41,8 +41,8 @@ test "io.CountingReader" { //read and discard all bytes while (stream.readByte()) |_| {} else |err| { - testing.expect(err == error.EndOfStream); + try testing.expect(err == error.EndOfStream); } - testing.expect(counting_stream.bytes_read == bytes.len); + try testing.expect(counting_stream.bytes_read == bytes.len); } diff --git a/lib/std/io/counting_writer.zig b/lib/std/io/counting_writer.zig index f68c257486..28eddc1303 100644 --- a/lib/std/io/counting_writer.zig +++ b/lib/std/io/counting_writer.zig @@ -40,5 +40,5 @@ test "io.CountingWriter" { const bytes = "yay" ** 100; stream.writeAll(bytes) catch unreachable; - testing.expect(counting_stream.bytes_written == bytes.len); + try testing.expect(counting_stream.bytes_written == bytes.len); } diff --git a/lib/std/io/fixed_buffer_stream.zig b/lib/std/io/fixed_buffer_stream.zig index f86fd5a8d8..c154c221bf 100644 --- a/lib/std/io/fixed_buffer_stream.zig +++ b/lib/std/io/fixed_buffer_stream.zig @@ -134,7 +134,7 @@ test "FixedBufferStream output" { const stream = fbs.writer(); try stream.print("{s}{s}!", .{ "Hello", "World" }); - testing.expectEqualSlices(u8, "HelloWorld!", fbs.getWritten()); + try testing.expectEqualSlices(u8, "HelloWorld!", fbs.getWritten()); } test "FixedBufferStream output 2" { @@ -142,19 +142,19 @@ test "FixedBufferStream output 2" { var fbs = fixedBufferStream(&buffer); try fbs.writer().writeAll("Hello"); - testing.expect(mem.eql(u8, fbs.getWritten(), "Hello")); + try testing.expect(mem.eql(u8, fbs.getWritten(), "Hello")); try fbs.writer().writeAll("world"); - testing.expect(mem.eql(u8, fbs.getWritten(), "Helloworld")); + try testing.expect(mem.eql(u8, fbs.getWritten(), "Helloworld")); - testing.expectError(error.NoSpaceLeft, fbs.writer().writeAll("!")); - testing.expect(mem.eql(u8, fbs.getWritten(), "Helloworld")); + try testing.expectError(error.NoSpaceLeft, fbs.writer().writeAll("!")); + try testing.expect(mem.eql(u8, fbs.getWritten(), "Helloworld")); fbs.reset(); - testing.expect(fbs.getWritten().len == 0); + try testing.expect(fbs.getWritten().len == 0); - testing.expectError(error.NoSpaceLeft, fbs.writer().writeAll("Hello world!")); - testing.expect(mem.eql(u8, fbs.getWritten(), "Hello worl")); + try testing.expectError(error.NoSpaceLeft, fbs.writer().writeAll("Hello world!")); + try testing.expect(mem.eql(u8, fbs.getWritten(), "Hello worl")); } test "FixedBufferStream input" { @@ -164,13 +164,13 @@ test "FixedBufferStream input" { var dest: [4]u8 = undefined; var read = try fbs.reader().read(dest[0..4]); - testing.expect(read == 4); - testing.expect(mem.eql(u8, dest[0..4], bytes[0..4])); + try testing.expect(read == 4); + try testing.expect(mem.eql(u8, dest[0..4], bytes[0..4])); read = try fbs.reader().read(dest[0..4]); - testing.expect(read == 3); - testing.expect(mem.eql(u8, dest[0..3], bytes[4..7])); + try testing.expect(read == 3); + try testing.expect(mem.eql(u8, dest[0..3], bytes[4..7])); read = try fbs.reader().read(dest[0..4]); - testing.expect(read == 0); + try testing.expect(read == 0); } diff --git a/lib/std/io/limited_reader.zig b/lib/std/io/limited_reader.zig index 734558b1e6..1647d5aac3 100644 --- a/lib/std/io/limited_reader.zig +++ b/lib/std/io/limited_reader.zig @@ -43,8 +43,8 @@ test "basic usage" { var early_stream = limitedReader(fbs.reader(), 3); var buf: [5]u8 = undefined; - testing.expectEqual(@as(usize, 3), try early_stream.reader().read(&buf)); - testing.expectEqualSlices(u8, data[0..3], buf[0..3]); - testing.expectEqual(@as(usize, 0), try early_stream.reader().read(&buf)); - testing.expectError(error.EndOfStream, early_stream.reader().skipBytes(10, .{})); + try testing.expectEqual(@as(usize, 3), try early_stream.reader().read(&buf)); + try testing.expectEqualSlices(u8, data[0..3], buf[0..3]); + try testing.expectEqual(@as(usize, 0), try early_stream.reader().read(&buf)); + try testing.expectError(error.EndOfStream, early_stream.reader().skipBytes(10, .{})); } diff --git a/lib/std/io/multi_writer.zig b/lib/std/io/multi_writer.zig index 639dd3cd18..9676212bbd 100644 --- a/lib/std/io/multi_writer.zig +++ b/lib/std/io/multi_writer.zig @@ -52,6 +52,6 @@ test "MultiWriter" { var fbs2 = io.fixedBufferStream(&buf2); var stream = multiWriter(.{ fbs1.writer(), fbs2.writer() }); try stream.writer().print("HI", .{}); - testing.expectEqualSlices(u8, "HI", fbs1.getWritten()); - testing.expectEqualSlices(u8, "HI", fbs2.getWritten()); + try testing.expectEqualSlices(u8, "HI", fbs1.getWritten()); + try testing.expectEqualSlices(u8, "HI", fbs2.getWritten()); } diff --git a/lib/std/io/peek_stream.zig b/lib/std/io/peek_stream.zig index b431b0184d..f3b8ba6645 100644 --- a/lib/std/io/peek_stream.zig +++ b/lib/std/io/peek_stream.zig @@ -94,24 +94,24 @@ test "PeekStream" { try ps.putBackByte(10); var read = try ps.reader().read(dest[0..4]); - testing.expect(read == 4); - testing.expect(dest[0] == 10); - testing.expect(dest[1] == 9); - testing.expect(mem.eql(u8, dest[2..4], bytes[0..2])); + try testing.expect(read == 4); + try testing.expect(dest[0] == 10); + try testing.expect(dest[1] == 9); + try testing.expect(mem.eql(u8, dest[2..4], bytes[0..2])); read = try ps.reader().read(dest[0..4]); - testing.expect(read == 4); - testing.expect(mem.eql(u8, dest[0..4], bytes[2..6])); + try testing.expect(read == 4); + try testing.expect(mem.eql(u8, dest[0..4], bytes[2..6])); read = try ps.reader().read(dest[0..4]); - testing.expect(read == 2); - testing.expect(mem.eql(u8, dest[0..2], bytes[6..8])); + try testing.expect(read == 2); + try testing.expect(mem.eql(u8, dest[0..2], bytes[6..8])); try ps.putBackByte(11); try ps.putBackByte(12); read = try ps.reader().read(dest[0..4]); - testing.expect(read == 2); - testing.expect(dest[0] == 12); - testing.expect(dest[1] == 11); + try testing.expect(read == 2); + try testing.expect(dest[0] == 12); + try testing.expect(dest[1] == 11); } diff --git a/lib/std/io/reader.zig b/lib/std/io/reader.zig index 916e2155fa..920b82e420 100644 --- a/lib/std/io/reader.zig +++ b/lib/std/io/reader.zig @@ -329,26 +329,26 @@ pub fn Reader( test "Reader" { var buf = "a\x02".*; const reader = std.io.fixedBufferStream(&buf).reader(); - testing.expect((try reader.readByte()) == 'a'); - testing.expect((try reader.readEnum(enum(u8) { + try testing.expect((try reader.readByte()) == 'a'); + try testing.expect((try reader.readEnum(enum(u8) { a = 0, b = 99, c = 2, d = 3, }, undefined)) == .c); - testing.expectError(error.EndOfStream, reader.readByte()); + try testing.expectError(error.EndOfStream, reader.readByte()); } test "Reader.isBytes" { const reader = std.io.fixedBufferStream("foobar").reader(); - testing.expectEqual(true, try reader.isBytes("foo")); - testing.expectEqual(false, try reader.isBytes("qux")); + try testing.expectEqual(true, try reader.isBytes("foo")); + try testing.expectEqual(false, try reader.isBytes("qux")); } test "Reader.skipBytes" { const reader = std.io.fixedBufferStream("foobar").reader(); try reader.skipBytes(3, .{}); - testing.expect(try reader.isBytes("bar")); + try testing.expect(try reader.isBytes("bar")); try reader.skipBytes(0, .{}); - testing.expectError(error.EndOfStream, reader.skipBytes(1, .{})); + try testing.expectError(error.EndOfStream, reader.skipBytes(1, .{})); } diff --git a/lib/std/io/test.zig b/lib/std/io/test.zig index 9fdef0de1d..5d204767b3 100644 --- a/lib/std/io/test.zig +++ b/lib/std/io/test.zig @@ -40,7 +40,7 @@ test "write a file, read it, then delete it" { { // Make sure the exclusive flag is honored. - expectError(File.OpenError.PathAlreadyExists, tmp.dir.createFile(tmp_file_name, .{ .exclusive = true })); + try expectError(File.OpenError.PathAlreadyExists, tmp.dir.createFile(tmp_file_name, .{ .exclusive = true })); } { @@ -49,16 +49,16 @@ test "write a file, read it, then delete it" { const file_size = try file.getEndPos(); const expected_file_size: u64 = "begin".len + data.len + "end".len; - expectEqual(expected_file_size, file_size); + try expectEqual(expected_file_size, file_size); var buf_stream = io.bufferedReader(file.reader()); const st = buf_stream.reader(); const contents = try st.readAllAlloc(std.testing.allocator, 2 * 1024); defer std.testing.allocator.free(contents); - expect(mem.eql(u8, contents[0.."begin".len], "begin")); - expect(mem.eql(u8, contents["begin".len .. contents.len - "end".len], &data)); - expect(mem.eql(u8, contents[contents.len - "end".len ..], "end")); + try expect(mem.eql(u8, contents[0.."begin".len], "begin")); + try expect(mem.eql(u8, contents["begin".len .. contents.len - "end".len], &data)); + try expect(mem.eql(u8, contents[contents.len - "end".len ..], "end")); } try tmp.dir.deleteFile(tmp_file_name); } @@ -90,20 +90,20 @@ test "BitStreams with File Stream" { var out_bits: usize = undefined; - expect(1 == try bit_stream.readBits(u2, 1, &out_bits)); - expect(out_bits == 1); - expect(2 == try bit_stream.readBits(u5, 2, &out_bits)); - expect(out_bits == 2); - expect(3 == try bit_stream.readBits(u128, 3, &out_bits)); - expect(out_bits == 3); - expect(4 == try bit_stream.readBits(u8, 4, &out_bits)); - expect(out_bits == 4); - expect(5 == try bit_stream.readBits(u9, 5, &out_bits)); - expect(out_bits == 5); - expect(1 == try bit_stream.readBits(u1, 1, &out_bits)); - expect(out_bits == 1); + try expect(1 == try bit_stream.readBits(u2, 1, &out_bits)); + try expect(out_bits == 1); + try expect(2 == try bit_stream.readBits(u5, 2, &out_bits)); + try expect(out_bits == 2); + try expect(3 == try bit_stream.readBits(u128, 3, &out_bits)); + try expect(out_bits == 3); + try expect(4 == try bit_stream.readBits(u8, 4, &out_bits)); + try expect(out_bits == 4); + try expect(5 == try bit_stream.readBits(u9, 5, &out_bits)); + try expect(out_bits == 5); + try expect(1 == try bit_stream.readBits(u1, 1, &out_bits)); + try expect(out_bits == 1); - expectError(error.EndOfStream, bit_stream.readBitsNoEof(u1, 1)); + try expectError(error.EndOfStream, bit_stream.readBitsNoEof(u1, 1)); } try tmp.dir.deleteFile(tmp_file_name); } @@ -123,16 +123,16 @@ test "File seek ops" { // Seek to the end try file.seekFromEnd(0); - expect((try file.getPos()) == try file.getEndPos()); + try expect((try file.getPos()) == try file.getEndPos()); // Negative delta try file.seekBy(-4096); - expect((try file.getPos()) == 4096); + try expect((try file.getPos()) == 4096); // Positive delta try file.seekBy(10); - expect((try file.getPos()) == 4106); + try expect((try file.getPos()) == 4106); // Absolute position try file.seekTo(1234); - expect((try file.getPos()) == 1234); + try expect((try file.getPos()) == 1234); } test "setEndPos" { @@ -147,18 +147,18 @@ test "setEndPos" { } // Verify that the file size changes and the file offset is not moved - std.testing.expect((try file.getEndPos()) == 0); - std.testing.expect((try file.getPos()) == 0); + try std.testing.expect((try file.getEndPos()) == 0); + try std.testing.expect((try file.getPos()) == 0); try file.setEndPos(8192); - std.testing.expect((try file.getEndPos()) == 8192); - std.testing.expect((try file.getPos()) == 0); + try std.testing.expect((try file.getEndPos()) == 8192); + try std.testing.expect((try file.getPos()) == 0); try file.seekTo(100); try file.setEndPos(4096); - std.testing.expect((try file.getEndPos()) == 4096); - std.testing.expect((try file.getPos()) == 100); + try std.testing.expect((try file.getEndPos()) == 4096); + try std.testing.expect((try file.getPos()) == 100); try file.setEndPos(0); - std.testing.expect((try file.getEndPos()) == 0); - std.testing.expect((try file.getPos()) == 100); + try std.testing.expect((try file.getEndPos()) == 0); + try std.testing.expect((try file.getPos()) == 100); } test "updateTimes" { @@ -178,6 +178,6 @@ test "updateTimes" { stat_old.mtime - 5 * std.time.ns_per_s, ); var stat_new = try file.stat(); - expect(stat_new.atime < stat_old.atime); - expect(stat_new.mtime < stat_old.mtime); + try expect(stat_new.atime < stat_old.atime); + try expect(stat_new.mtime < stat_old.mtime); } diff --git a/lib/std/json.zig b/lib/std/json.zig index 7596631ea2..665992c2f8 100644 --- a/lib/std/json.zig +++ b/lib/std/json.zig @@ -79,18 +79,18 @@ fn encodesTo(decoded: []const u8, encoded: []const u8) bool { test "encodesTo" { // same - testing.expectEqual(true, encodesTo("false", "false")); + try testing.expectEqual(true, encodesTo("false", "false")); // totally different - testing.expectEqual(false, encodesTo("false", "true")); + try testing.expectEqual(false, encodesTo("false", "true")); // different lengths - testing.expectEqual(false, encodesTo("false", "other")); + try testing.expectEqual(false, encodesTo("false", "other")); // with escape - testing.expectEqual(true, encodesTo("\\", "\\\\")); - testing.expectEqual(true, encodesTo("with\nescape", "with\\nescape")); + try testing.expectEqual(true, encodesTo("\\", "\\\\")); + try testing.expectEqual(true, encodesTo("with\nescape", "with\\nescape")); // with unicode - testing.expectEqual(true, encodesTo("Δ…", "\\u0105")); - testing.expectEqual(true, encodesTo("πŸ˜‚", "\\ud83d\\ude02")); - testing.expectEqual(true, encodesTo("withΔ…unicodeπŸ˜‚", "with\\u0105unicode\\ud83d\\ude02")); + try testing.expectEqual(true, encodesTo("Δ…", "\\u0105")); + try testing.expectEqual(true, encodesTo("πŸ˜‚", "\\ud83d\\ude02")); + try testing.expectEqual(true, encodesTo("withΔ…unicodeπŸ˜‚", "with\\u0105unicode\\ud83d\\ude02")); } /// A single token slice into the parent string. @@ -1138,9 +1138,9 @@ pub const TokenStream = struct { } }; -fn checkNext(p: *TokenStream, id: std.meta.Tag(Token)) void { +fn checkNext(p: *TokenStream, id: std.meta.Tag(Token)) !void { const token = (p.next() catch unreachable).?; - debug.assert(std.meta.activeTag(token) == id); + try testing.expect(std.meta.activeTag(token) == id); } test "json.token" { @@ -1163,46 +1163,46 @@ test "json.token" { var p = TokenStream.init(s); - checkNext(&p, .ObjectBegin); - checkNext(&p, .String); // Image - checkNext(&p, .ObjectBegin); - checkNext(&p, .String); // Width - checkNext(&p, .Number); - checkNext(&p, .String); // Height - checkNext(&p, .Number); - checkNext(&p, .String); // Title - checkNext(&p, .String); - checkNext(&p, .String); // Thumbnail - checkNext(&p, .ObjectBegin); - checkNext(&p, .String); // Url - checkNext(&p, .String); - checkNext(&p, .String); // Height - checkNext(&p, .Number); - checkNext(&p, .String); // Width - checkNext(&p, .Number); - checkNext(&p, .ObjectEnd); - checkNext(&p, .String); // Animated - checkNext(&p, .False); - checkNext(&p, .String); // IDs - checkNext(&p, .ArrayBegin); - checkNext(&p, .Number); - checkNext(&p, .Number); - checkNext(&p, .Number); - checkNext(&p, .Number); - checkNext(&p, .ArrayEnd); - checkNext(&p, .ObjectEnd); - checkNext(&p, .ObjectEnd); + try checkNext(&p, .ObjectBegin); + try checkNext(&p, .String); // Image + try checkNext(&p, .ObjectBegin); + try checkNext(&p, .String); // Width + try checkNext(&p, .Number); + try checkNext(&p, .String); // Height + try checkNext(&p, .Number); + try checkNext(&p, .String); // Title + try checkNext(&p, .String); + try checkNext(&p, .String); // Thumbnail + try checkNext(&p, .ObjectBegin); + try checkNext(&p, .String); // Url + try checkNext(&p, .String); + try checkNext(&p, .String); // Height + try checkNext(&p, .Number); + try checkNext(&p, .String); // Width + try checkNext(&p, .Number); + try checkNext(&p, .ObjectEnd); + try checkNext(&p, .String); // Animated + try checkNext(&p, .False); + try checkNext(&p, .String); // IDs + try checkNext(&p, .ArrayBegin); + try checkNext(&p, .Number); + try checkNext(&p, .Number); + try checkNext(&p, .Number); + try checkNext(&p, .Number); + try checkNext(&p, .ArrayEnd); + try checkNext(&p, .ObjectEnd); + try checkNext(&p, .ObjectEnd); - testing.expect((try p.next()) == null); + try testing.expect((try p.next()) == null); } test "json.token mismatched close" { var p = TokenStream.init("[102, 111, 111 }"); - checkNext(&p, .ArrayBegin); - checkNext(&p, .Number); - checkNext(&p, .Number); - checkNext(&p, .Number); - testing.expectError(error.UnexpectedClosingBrace, p.next()); + try checkNext(&p, .ArrayBegin); + try checkNext(&p, .Number); + try checkNext(&p, .Number); + try checkNext(&p, .Number); + try testing.expectError(error.UnexpectedClosingBrace, p.next()); } /// Validate a JSON string. This does not limit number precision so a decoder may not necessarily @@ -1223,12 +1223,12 @@ pub fn validate(s: []const u8) bool { } test "json.validate" { - testing.expectEqual(true, validate("{}")); - testing.expectEqual(true, validate("[]")); - testing.expectEqual(true, validate("[{[[[[{}]]]]}]")); - testing.expectEqual(false, validate("{]")); - testing.expectEqual(false, validate("[}")); - testing.expectEqual(false, validate("{{{{[]}}}]")); + try testing.expectEqual(true, validate("{}")); + try testing.expectEqual(true, validate("[]")); + try testing.expectEqual(true, validate("[{[[[[{}]]]]}]")); + try testing.expectEqual(false, validate("{]")); + try testing.expectEqual(false, validate("[}")); + try testing.expectEqual(false, validate("{{{{[]}}}]")); } const Allocator = std.mem.Allocator; @@ -1326,37 +1326,37 @@ test "Value.jsonStringify" { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try @as(Value, .Null).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "null"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "null"); } { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try (Value{ .Bool = true }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "true"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "true"); } { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try (Value{ .Integer = 42 }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "42"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "42"); } { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try (Value{ .NumberString = "43" }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "43"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "43"); } { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try (Value{ .Float = 42 }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "4.2e+01"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "4.2e+01"); } { var buffer: [10]u8 = undefined; var fbs = std.io.fixedBufferStream(&buffer); try (Value{ .String = "weeee" }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "\"weeee\""); + try testing.expectEqualSlices(u8, fbs.getWritten(), "\"weeee\""); } { var buffer: [10]u8 = undefined; @@ -1369,7 +1369,7 @@ test "Value.jsonStringify" { try (Value{ .Array = Array.fromOwnedSlice(undefined, &vals), }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "[1,2,3]"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "[1,2,3]"); } { var buffer: [10]u8 = undefined; @@ -1378,7 +1378,7 @@ test "Value.jsonStringify" { defer obj.deinit(); try obj.putNoClobber("a", .{ .String = "b" }); try (Value{ .Object = obj }).jsonStringify(.{}, fbs.writer()); - testing.expectEqualSlices(u8, fbs.getWritten(), "{\"a\":\"b\"}"); + try testing.expectEqualSlices(u8, fbs.getWritten(), "{\"a\":\"b\"}"); } } @@ -1751,17 +1751,17 @@ pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void { } test "parse" { - testing.expectEqual(false, try parse(bool, &TokenStream.init("false"), ParseOptions{})); - testing.expectEqual(true, try parse(bool, &TokenStream.init("true"), ParseOptions{})); - testing.expectEqual(@as(u1, 1), try parse(u1, &TokenStream.init("1"), ParseOptions{})); - testing.expectError(error.Overflow, parse(u1, &TokenStream.init("50"), ParseOptions{})); - testing.expectEqual(@as(u64, 42), try parse(u64, &TokenStream.init("42"), ParseOptions{})); - testing.expectEqual(@as(f64, 42), try parse(f64, &TokenStream.init("42.0"), ParseOptions{})); - testing.expectEqual(@as(?bool, null), try parse(?bool, &TokenStream.init("null"), ParseOptions{})); - testing.expectEqual(@as(?bool, true), try parse(?bool, &TokenStream.init("true"), ParseOptions{})); + try testing.expectEqual(false, try parse(bool, &TokenStream.init("false"), ParseOptions{})); + try testing.expectEqual(true, try parse(bool, &TokenStream.init("true"), ParseOptions{})); + try testing.expectEqual(@as(u1, 1), try parse(u1, &TokenStream.init("1"), ParseOptions{})); + try testing.expectError(error.Overflow, parse(u1, &TokenStream.init("50"), ParseOptions{})); + try testing.expectEqual(@as(u64, 42), try parse(u64, &TokenStream.init("42"), ParseOptions{})); + try testing.expectEqual(@as(f64, 42), try parse(f64, &TokenStream.init("42.0"), ParseOptions{})); + try testing.expectEqual(@as(?bool, null), try parse(?bool, &TokenStream.init("null"), ParseOptions{})); + try testing.expectEqual(@as(?bool, true), try parse(?bool, &TokenStream.init("true"), ParseOptions{})); - testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("\"foo\""), ParseOptions{})); - testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("[102, 111, 111]"), ParseOptions{})); + try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("\"foo\""), ParseOptions{})); + try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("[102, 111, 111]"), ParseOptions{})); } test "parse into enum" { @@ -1770,31 +1770,31 @@ test "parse into enum" { Bar, @"with\\escape", }; - testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("\"Foo\""), ParseOptions{})); - testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("42"), ParseOptions{})); - testing.expectEqual(@as(T, .@"with\\escape"), try parse(T, &TokenStream.init("\"with\\\\escape\""), ParseOptions{})); - testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("5"), ParseOptions{})); - testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("\"Qux\""), ParseOptions{})); + try testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("\"Foo\""), ParseOptions{})); + try testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("42"), ParseOptions{})); + try testing.expectEqual(@as(T, .@"with\\escape"), try parse(T, &TokenStream.init("\"with\\\\escape\""), ParseOptions{})); + try testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("5"), ParseOptions{})); + try testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("\"Qux\""), ParseOptions{})); } test "parse into that allocates a slice" { - testing.expectError(error.AllocatorRequired, parse([]u8, &TokenStream.init("\"foo\""), ParseOptions{})); + try testing.expectError(error.AllocatorRequired, parse([]u8, &TokenStream.init("\"foo\""), ParseOptions{})); const options = ParseOptions{ .allocator = testing.allocator }; { const r = try parse([]u8, &TokenStream.init("\"foo\""), options); defer parseFree([]u8, r, options); - testing.expectEqualSlices(u8, "foo", r); + try testing.expectEqualSlices(u8, "foo", r); } { const r = try parse([]u8, &TokenStream.init("[102, 111, 111]"), options); defer parseFree([]u8, r, options); - testing.expectEqualSlices(u8, "foo", r); + try testing.expectEqualSlices(u8, "foo", r); } { const r = try parse([]u8, &TokenStream.init("\"with\\\\escape\""), options); defer parseFree([]u8, r, options); - testing.expectEqualSlices(u8, "with\\escape", r); + try testing.expectEqualSlices(u8, "with\\escape", r); } } @@ -1805,7 +1805,7 @@ test "parse into tagged union" { float: f64, string: []const u8, }; - testing.expectEqual(T{ .float = 1.5 }, try parse(T, &TokenStream.init("1.5"), ParseOptions{})); + try testing.expectEqual(T{ .float = 1.5 }, try parse(T, &TokenStream.init("1.5"), ParseOptions{})); } { // failing allocations should be bubbled up instantly without trying next member @@ -1816,7 +1816,7 @@ test "parse into tagged union" { string: []const u8, array: [3]u8, }; - testing.expectError(error.OutOfMemory, parse(T, &TokenStream.init("[1,2,3]"), options)); + try testing.expectError(error.OutOfMemory, parse(T, &TokenStream.init("[1,2,3]"), options)); } { @@ -1825,7 +1825,7 @@ test "parse into tagged union" { x: u8, y: u8, }; - testing.expectEqual(T{ .x = 42 }, try parse(T, &TokenStream.init("42"), ParseOptions{})); + try testing.expectEqual(T{ .x = 42 }, try parse(T, &TokenStream.init("42"), ParseOptions{})); } { // needs to back out when first union member doesn't match @@ -1833,7 +1833,7 @@ test "parse into tagged union" { A: struct { x: u32 }, B: struct { y: u32 }, }; - testing.expectEqual(T{ .B = .{ .y = 42 } }, try parse(T, &TokenStream.init("{\"y\":42}"), ParseOptions{})); + try testing.expectEqual(T{ .B = .{ .y = 42 } }, try parse(T, &TokenStream.init("{\"y\":42}"), ParseOptions{})); } } @@ -1843,7 +1843,7 @@ test "parse union bubbles up AllocatorRequired" { string: []const u8, int: i32, }; - testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("42"), ParseOptions{})); + try testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("42"), ParseOptions{})); } { // string member not first in union (and matching) @@ -1852,7 +1852,7 @@ test "parse union bubbles up AllocatorRequired" { float: f64, string: []const u8, }; - testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("\"foo\""), ParseOptions{})); + try testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("\"foo\""), ParseOptions{})); } } @@ -1866,11 +1866,11 @@ test "parseFree descends into tagged union" { }; // use a string with unicode escape so we know result can't be a reference to global constant const r = try parse(T, &TokenStream.init("\"with\\u0105unicode\""), options); - testing.expectEqual(std.meta.Tag(T).string, @as(std.meta.Tag(T), r)); - testing.expectEqualSlices(u8, "withΔ…unicode", r.string); - testing.expectEqual(@as(usize, 0), fail_alloc.deallocations); + try testing.expectEqual(std.meta.Tag(T).string, @as(std.meta.Tag(T), r)); + try testing.expectEqualSlices(u8, "withΔ…unicode", r.string); + try testing.expectEqual(@as(usize, 0), fail_alloc.deallocations); parseFree(T, r, options); - testing.expectEqual(@as(usize, 1), fail_alloc.deallocations); + try testing.expectEqual(@as(usize, 1), fail_alloc.deallocations); } test "parse with comptime field" { @@ -1879,7 +1879,7 @@ test "parse with comptime field" { comptime a: i32 = 0, b: bool, }; - testing.expectEqual(T{ .a = 0, .b = true }, try parse(T, &TokenStream.init( + try testing.expectEqual(T{ .a = 0, .b = true }, try parse(T, &TokenStream.init( \\{ \\ "a": 0, \\ "b": true @@ -1912,7 +1912,7 @@ test "parse with comptime field" { test "parse into struct with no fields" { const T = struct {}; - testing.expectEqual(T{}, try parse(T, &TokenStream.init("{}"), ParseOptions{})); + try testing.expectEqual(T{}, try parse(T, &TokenStream.init("{}"), ParseOptions{})); } test "parse into struct with misc fields" { @@ -1968,24 +1968,24 @@ test "parse into struct with misc fields" { \\} ), options); defer parseFree(T, r, options); - testing.expectEqual(@as(i64, 420), r.int); - testing.expectEqual(@as(f64, 3.14), r.float); - testing.expectEqual(true, r.@"with\\escape"); - testing.expectEqual(false, r.@"withΔ…unicodeπŸ˜‚"); - testing.expectEqualSlices(u8, "zig", r.language); - testing.expectEqual(@as(?bool, null), r.optional); - testing.expectEqual(@as(i32, 42), r.default_field); - testing.expectEqual(@as(f64, 66.6), r.static_array[0]); - testing.expectEqual(@as(f64, 420.420), r.static_array[1]); - testing.expectEqual(@as(f64, 69.69), r.static_array[2]); - testing.expectEqual(@as(usize, 3), r.dynamic_array.len); - testing.expectEqual(@as(f64, 66.6), r.dynamic_array[0]); - testing.expectEqual(@as(f64, 420.420), r.dynamic_array[1]); - testing.expectEqual(@as(f64, 69.69), r.dynamic_array[2]); - testing.expectEqualSlices(u8, r.complex.nested, "zig"); - testing.expectEqualSlices(u8, "zig", r.veryComplex[0].foo); - testing.expectEqualSlices(u8, "rocks", r.veryComplex[1].foo); - testing.expectEqual(T.Union{ .float = 100000 }, r.a_union); + try testing.expectEqual(@as(i64, 420), r.int); + try testing.expectEqual(@as(f64, 3.14), r.float); + try testing.expectEqual(true, r.@"with\\escape"); + try testing.expectEqual(false, r.@"withΔ…unicodeπŸ˜‚"); + try testing.expectEqualSlices(u8, "zig", r.language); + try testing.expectEqual(@as(?bool, null), r.optional); + try testing.expectEqual(@as(i32, 42), r.default_field); + try testing.expectEqual(@as(f64, 66.6), r.static_array[0]); + try testing.expectEqual(@as(f64, 420.420), r.static_array[1]); + try testing.expectEqual(@as(f64, 69.69), r.static_array[2]); + try testing.expectEqual(@as(usize, 3), r.dynamic_array.len); + try testing.expectEqual(@as(f64, 66.6), r.dynamic_array[0]); + try testing.expectEqual(@as(f64, 420.420), r.dynamic_array[1]); + try testing.expectEqual(@as(f64, 69.69), r.dynamic_array[2]); + try testing.expectEqualSlices(u8, r.complex.nested, "zig"); + try testing.expectEqualSlices(u8, "zig", r.veryComplex[0].foo); + try testing.expectEqualSlices(u8, "rocks", r.veryComplex[1].foo); + try testing.expectEqual(T.Union{ .float = 100000 }, r.a_union); } /// A non-stream JSON parser which constructs a tree of Value's. @@ -2320,28 +2320,28 @@ test "json.parser.dynamic" { var image = root.Object.get("Image").?; const width = image.Object.get("Width").?; - testing.expect(width.Integer == 800); + try testing.expect(width.Integer == 800); const height = image.Object.get("Height").?; - testing.expect(height.Integer == 600); + try testing.expect(height.Integer == 600); const title = image.Object.get("Title").?; - testing.expect(mem.eql(u8, title.String, "View from 15th Floor")); + try testing.expect(mem.eql(u8, title.String, "View from 15th Floor")); const animated = image.Object.get("Animated").?; - testing.expect(animated.Bool == false); + try testing.expect(animated.Bool == false); const array_of_object = image.Object.get("ArrayOfObject").?; - testing.expect(array_of_object.Array.items.len == 1); + try testing.expect(array_of_object.Array.items.len == 1); const obj0 = array_of_object.Array.items[0].Object.get("n").?; - testing.expect(mem.eql(u8, obj0.String, "m")); + try testing.expect(mem.eql(u8, obj0.String, "m")); const double = image.Object.get("double").?; - testing.expect(double.Float == 1.3412); + try testing.expect(double.Float == 1.3412); const large_int = image.Object.get("LargeInt").?; - testing.expect(mem.eql(u8, large_int.NumberString, "18446744073709551615")); + try testing.expect(mem.eql(u8, large_int.NumberString, "18446744073709551615")); } test "import more json tests" { @@ -2388,12 +2388,12 @@ test "write json then parse it" { var tree = try parser.parse(fixed_buffer_stream.getWritten()); defer tree.deinit(); - testing.expect(tree.root.Object.get("f").?.Bool == false); - testing.expect(tree.root.Object.get("t").?.Bool == true); - testing.expect(tree.root.Object.get("int").?.Integer == 1234); - testing.expect(tree.root.Object.get("array").?.Array.items[0].Null == {}); - testing.expect(tree.root.Object.get("array").?.Array.items[1].Float == 12.34); - testing.expect(mem.eql(u8, tree.root.Object.get("str").?.String, "hello")); + try testing.expect(tree.root.Object.get("f").?.Bool == false); + try testing.expect(tree.root.Object.get("t").?.Bool == true); + try testing.expect(tree.root.Object.get("int").?.Integer == 1234); + try testing.expect(tree.root.Object.get("array").?.Array.items[0].Null == {}); + try testing.expect(tree.root.Object.get("array").?.Array.items[1].Float == 12.34); + try testing.expect(mem.eql(u8, tree.root.Object.get("str").?.String, "hello")); } fn test_parse(arena_allocator: *std.mem.Allocator, json_str: []const u8) !Value { @@ -2404,7 +2404,7 @@ fn test_parse(arena_allocator: *std.mem.Allocator, json_str: []const u8) !Value test "parsing empty string gives appropriate error" { var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena_allocator.deinit(); - testing.expectError(error.UnexpectedEndOfJson, test_parse(&arena_allocator.allocator, "")); + try testing.expectError(error.UnexpectedEndOfJson, test_parse(&arena_allocator.allocator, "")); } test "integer after float has proper type" { @@ -2416,7 +2416,7 @@ test "integer after float has proper type" { \\ "ints": [1, 2, 3] \\} ); - std.testing.expect(json.Object.get("ints").?.Array.items[0] == .Integer); + try std.testing.expect(json.Object.get("ints").?.Array.items[0] == .Integer); } test "escaped characters" { @@ -2439,16 +2439,16 @@ test "escaped characters" { const obj = (try test_parse(&arena_allocator.allocator, input)).Object; - testing.expectEqualSlices(u8, obj.get("backslash").?.String, "\\"); - testing.expectEqualSlices(u8, obj.get("forwardslash").?.String, "/"); - testing.expectEqualSlices(u8, obj.get("newline").?.String, "\n"); - testing.expectEqualSlices(u8, obj.get("carriagereturn").?.String, "\r"); - testing.expectEqualSlices(u8, obj.get("tab").?.String, "\t"); - testing.expectEqualSlices(u8, obj.get("formfeed").?.String, "\x0C"); - testing.expectEqualSlices(u8, obj.get("backspace").?.String, "\x08"); - testing.expectEqualSlices(u8, obj.get("doublequote").?.String, "\""); - testing.expectEqualSlices(u8, obj.get("unicode").?.String, "Δ…"); - testing.expectEqualSlices(u8, obj.get("surrogatepair").?.String, "πŸ˜‚"); + try testing.expectEqualSlices(u8, obj.get("backslash").?.String, "\\"); + try testing.expectEqualSlices(u8, obj.get("forwardslash").?.String, "/"); + try testing.expectEqualSlices(u8, obj.get("newline").?.String, "\n"); + try testing.expectEqualSlices(u8, obj.get("carriagereturn").?.String, "\r"); + try testing.expectEqualSlices(u8, obj.get("tab").?.String, "\t"); + try testing.expectEqualSlices(u8, obj.get("formfeed").?.String, "\x0C"); + try testing.expectEqualSlices(u8, obj.get("backspace").?.String, "\x08"); + try testing.expectEqualSlices(u8, obj.get("doublequote").?.String, "\""); + try testing.expectEqualSlices(u8, obj.get("unicode").?.String, "Δ…"); + try testing.expectEqualSlices(u8, obj.get("surrogatepair").?.String, "πŸ˜‚"); } test "string copy option" { @@ -2471,7 +2471,7 @@ test "string copy option" { const obj_copy = tree_copy.root.Object; for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| { - testing.expectEqualSlices(u8, obj_nocopy.get(field_name).?.String, obj_copy.get(field_name).?.String); + try testing.expectEqualSlices(u8, obj_nocopy.get(field_name).?.String, obj_copy.get(field_name).?.String); } const nocopy_addr = &obj_nocopy.get("noescape").?.String[0]; @@ -2479,12 +2479,12 @@ test "string copy option" { var found_nocopy = false; for (input) |_, index| { - testing.expect(copy_addr != &input[index]); + try testing.expect(copy_addr != &input[index]); if (nocopy_addr == &input[index]) { found_nocopy = true; } } - testing.expect(found_nocopy); + try testing.expect(found_nocopy); } pub const StringifyOptions = struct { diff --git a/lib/std/json/test.zig b/lib/std/json/test.zig index b0d873c910..e37ba72113 100644 --- a/lib/std/json/test.zig +++ b/lib/std/json/test.zig @@ -21,37 +21,37 @@ fn testNonStreaming(s: []const u8) !void { } fn ok(s: []const u8) !void { - testing.expect(json.validate(s)); + try testing.expect(json.validate(s)); try testNonStreaming(s); } -fn err(s: []const u8) void { - testing.expect(!json.validate(s)); +fn err(s: []const u8) !void { + try testing.expect(!json.validate(s)); - testing.expect(std.meta.isError(testNonStreaming(s))); + try testing.expect(std.meta.isError(testNonStreaming(s))); } -fn utf8Error(s: []const u8) void { - testing.expect(!json.validate(s)); +fn utf8Error(s: []const u8) !void { + try testing.expect(!json.validate(s)); - testing.expectError(error.InvalidUtf8Byte, testNonStreaming(s)); + try testing.expectError(error.InvalidUtf8Byte, testNonStreaming(s)); } -fn any(s: []const u8) void { +fn any(s: []const u8) !void { _ = json.validate(s); testNonStreaming(s) catch {}; } -fn anyStreamingErrNonStreaming(s: []const u8) void { +fn anyStreamingErrNonStreaming(s: []const u8) !void { _ = json.validate(s); - testing.expect(std.meta.isError(testNonStreaming(s))); + try testing.expect(std.meta.isError(testNonStreaming(s))); } fn roundTrip(s: []const u8) !void { - testing.expect(json.validate(s)); + try testing.expect(json.validate(s)); var p = json.Parser.init(testing.allocator, false); defer p.deinit(); @@ -63,7 +63,7 @@ fn roundTrip(s: []const u8) !void { var fbs = std.io.fixedBufferStream(&buf); try tree.root.jsonStringify(.{}, fbs.writer()); - testing.expectEqualStrings(s, fbs.getWritten()); + try testing.expectEqualStrings(s, fbs.getWritten()); } //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -642,109 +642,109 @@ test "y_structure_whitespace_array" { //////////////////////////////////////////////////////////////////////////////////////////////////// test "n_array_1_true_without_comma" { - err( + try err( \\[1 true] ); } test "n_array_a_invalid_utf8" { - err( + try err( \\[aΓ₯] ); } test "n_array_colon_instead_of_comma" { - err( + try err( \\["": 1] ); } test "n_array_comma_after_close" { - err( + try err( \\[""], ); } test "n_array_comma_and_number" { - err( + try err( \\[,1] ); } test "n_array_double_comma" { - err( + try err( \\[1,,2] ); } test "n_array_double_extra_comma" { - err( + try err( \\["x",,] ); } test "n_array_extra_close" { - err( + try err( \\["x"]] ); } test "n_array_extra_comma" { - err( + try err( \\["",] ); } test "n_array_incomplete_invalid_value" { - err( + try err( \\[x ); } test "n_array_incomplete" { - err( + try err( \\["x" ); } test "n_array_inner_array_no_comma" { - err( + try err( \\[3[4]] ); } test "n_array_invalid_utf8" { - err( + try err( \\[ΓΏ] ); } test "n_array_items_separated_by_semicolon" { - err( + try err( \\[1:2] ); } test "n_array_just_comma" { - err( + try err( \\[,] ); } test "n_array_just_minus" { - err( + try err( \\[-] ); } test "n_array_missing_value" { - err( + try err( \\[ , ""] ); } test "n_array_newlines_unclosed" { - err( + try err( \\["a", \\4 \\,1, @@ -752,41 +752,41 @@ test "n_array_newlines_unclosed" { } test "n_array_number_and_comma" { - err( + try err( \\[1,] ); } test "n_array_number_and_several_commas" { - err( + try err( \\[1,,] ); } test "n_array_spaces_vertical_tab_formfeed" { - err("[\"\x0aa\"\\f]"); + try err("[\"\x0aa\"\\f]"); } test "n_array_star_inside" { - err( + try err( \\[*] ); } test "n_array_unclosed" { - err( + try err( \\["" ); } test "n_array_unclosed_trailing_comma" { - err( + try err( \\[1, ); } test "n_array_unclosed_with_new_lines" { - err( + try err( \\[1, \\1 \\,1 @@ -794,956 +794,956 @@ test "n_array_unclosed_with_new_lines" { } test "n_array_unclosed_with_object_inside" { - err( + try err( \\[{} ); } test "n_incomplete_false" { - err( + try err( \\[fals] ); } test "n_incomplete_null" { - err( + try err( \\[nul] ); } test "n_incomplete_true" { - err( + try err( \\[tru] ); } test "n_multidigit_number_then_00" { - err("123\x00"); + try err("123\x00"); } test "n_number_0.1.2" { - err( + try err( \\[0.1.2] ); } test "n_number_-01" { - err( + try err( \\[-01] ); } test "n_number_0.3e" { - err( + try err( \\[0.3e] ); } test "n_number_0.3e+" { - err( + try err( \\[0.3e+] ); } test "n_number_0_capital_E" { - err( + try err( \\[0E] ); } test "n_number_0_capital_E+" { - err( + try err( \\[0E+] ); } test "n_number_0.e1" { - err( + try err( \\[0.e1] ); } test "n_number_0e" { - err( + try err( \\[0e] ); } test "n_number_0e+" { - err( + try err( \\[0e+] ); } test "n_number_1_000" { - err( + try err( \\[1 000.0] ); } test "n_number_1.0e-" { - err( + try err( \\[1.0e-] ); } test "n_number_1.0e" { - err( + try err( \\[1.0e] ); } test "n_number_1.0e+" { - err( + try err( \\[1.0e+] ); } test "n_number_-1.0." { - err( + try err( \\[-1.0.] ); } test "n_number_1eE2" { - err( + try err( \\[1eE2] ); } test "n_number_.-1" { - err( + try err( \\[.-1] ); } test "n_number_+1" { - err( + try err( \\[+1] ); } test "n_number_.2e-3" { - err( + try err( \\[.2e-3] ); } test "n_number_2.e-3" { - err( + try err( \\[2.e-3] ); } test "n_number_2.e+3" { - err( + try err( \\[2.e+3] ); } test "n_number_2.e3" { - err( + try err( \\[2.e3] ); } test "n_number_-2." { - err( + try err( \\[-2.] ); } test "n_number_9.e+" { - err( + try err( \\[9.e+] ); } test "n_number_expression" { - err( + try err( \\[1+2] ); } test "n_number_hex_1_digit" { - err( + try err( \\[0x1] ); } test "n_number_hex_2_digits" { - err( + try err( \\[0x42] ); } test "n_number_infinity" { - err( + try err( \\[Infinity] ); } test "n_number_+Inf" { - err( + try err( \\[+Inf] ); } test "n_number_Inf" { - err( + try err( \\[Inf] ); } test "n_number_invalid+-" { - err( + try err( \\[0e+-1] ); } test "n_number_invalid-negative-real" { - err( + try err( \\[-123.123foo] ); } test "n_number_invalid-utf-8-in-bigger-int" { - err( + try err( \\[123Γ₯] ); } test "n_number_invalid-utf-8-in-exponent" { - err( + try err( \\[1e1Γ₯] ); } test "n_number_invalid-utf-8-in-int" { - err( + try err( \\[0Γ₯] ); } test "n_number_++" { - err( + try err( \\[++1234] ); } test "n_number_minus_infinity" { - err( + try err( \\[-Infinity] ); } test "n_number_minus_sign_with_trailing_garbage" { - err( + try err( \\[-foo] ); } test "n_number_minus_space_1" { - err( + try err( \\[- 1] ); } test "n_number_-NaN" { - err( + try err( \\[-NaN] ); } test "n_number_NaN" { - err( + try err( \\[NaN] ); } test "n_number_neg_int_starting_with_zero" { - err( + try err( \\[-012] ); } test "n_number_neg_real_without_int_part" { - err( + try err( \\[-.123] ); } test "n_number_neg_with_garbage_at_end" { - err( + try err( \\[-1x] ); } test "n_number_real_garbage_after_e" { - err( + try err( \\[1ea] ); } test "n_number_real_with_invalid_utf8_after_e" { - err( + try err( \\[1eΓ₯] ); } test "n_number_real_without_fractional_part" { - err( + try err( \\[1.] ); } test "n_number_starting_with_dot" { - err( + try err( \\[.123] ); } test "n_number_U+FF11_fullwidth_digit_one" { - err( + try err( \\[Γ―ΒΌΒ‘] ); } test "n_number_with_alpha_char" { - err( + try err( \\[1.8011670033376514H-308] ); } test "n_number_with_alpha" { - err( + try err( \\[1.2a-3] ); } test "n_number_with_leading_zero" { - err( + try err( \\[012] ); } test "n_object_bad_value" { - err( + try err( \\["x", truth] ); } test "n_object_bracket_key" { - err( + try err( \\{[: "x"} ); } test "n_object_comma_instead_of_colon" { - err( + try err( \\{"x", null} ); } test "n_object_double_colon" { - err( + try err( \\{"x"::"b"} ); } test "n_object_emoji" { - err( + try err( \\{Γ°ΒŸΒ‡Β¨Γ°ΒŸΒ‡Β­} ); } test "n_object_garbage_at_end" { - err( + try err( \\{"a":"a" 123} ); } test "n_object_key_with_single_quotes" { - err( + try err( \\{key: 'value'} ); } test "n_object_lone_continuation_byte_in_key_and_trailing_comma" { - err( + try err( \\{"ΒΉ":"0",} ); } test "n_object_missing_colon" { - err( + try err( \\{"a" b} ); } test "n_object_missing_key" { - err( + try err( \\{:"b"} ); } test "n_object_missing_semicolon" { - err( + try err( \\{"a" "b"} ); } test "n_object_missing_value" { - err( + try err( \\{"a": ); } test "n_object_no-colon" { - err( + try err( \\{"a" ); } test "n_object_non_string_key_but_huge_number_instead" { - err( + try err( \\{9999E9999:1} ); } test "n_object_non_string_key" { - err( + try err( \\{1:1} ); } test "n_object_repeated_null_null" { - err( + try err( \\{null:null,null:null} ); } test "n_object_several_trailing_commas" { - err( + try err( \\{"id":0,,,,,} ); } test "n_object_single_quote" { - err( + try err( \\{'a':0} ); } test "n_object_trailing_comma" { - err( + try err( \\{"id":0,} ); } test "n_object_trailing_comment" { - err( + try err( \\{"a":"b"}/**/ ); } test "n_object_trailing_comment_open" { - err( + try err( \\{"a":"b"}/**// ); } test "n_object_trailing_comment_slash_open_incomplete" { - err( + try err( \\{"a":"b"}/ ); } test "n_object_trailing_comment_slash_open" { - err( + try err( \\{"a":"b"}// ); } test "n_object_two_commas_in_a_row" { - err( + try err( \\{"a":"b",,"c":"d"} ); } test "n_object_unquoted_key" { - err( + try err( \\{a: "b"} ); } test "n_object_unterminated-value" { - err( + try err( \\{"a":"a ); } test "n_object_with_single_string" { - err( + try err( \\{ "foo" : "bar", "a" } ); } test "n_object_with_trailing_garbage" { - err( + try err( \\{"a":"b"}# ); } test "n_single_space" { - err(" "); + try err(" "); } test "n_string_1_surrogate_then_escape" { - err( + try err( \\["\uD800\"] ); } test "n_string_1_surrogate_then_escape_u1" { - err( + try err( \\["\uD800\u1"] ); } test "n_string_1_surrogate_then_escape_u1x" { - err( + try err( \\["\uD800\u1x"] ); } test "n_string_1_surrogate_then_escape_u" { - err( + try err( \\["\uD800\u"] ); } test "n_string_accentuated_char_no_quotes" { - err( + try err( \\[é] ); } test "n_string_backslash_00" { - err("[\"\x00\"]"); + try err("[\"\x00\"]"); } test "n_string_escaped_backslash_bad" { - err( + try err( \\["\\\"] ); } test "n_string_escaped_ctrl_char_tab" { - err("\x5b\x22\x5c\x09\x22\x5d"); + try err("\x5b\x22\x5c\x09\x22\x5d"); } test "n_string_escaped_emoji" { - err("[\"\x5c\xc3\xb0\xc2\x9f\xc2\x8c\xc2\x80\"]"); + try err("[\"\x5c\xc3\xb0\xc2\x9f\xc2\x8c\xc2\x80\"]"); } test "n_string_escape_x" { - err( + try err( \\["\x00"] ); } test "n_string_incomplete_escaped_character" { - err( + try err( \\["\u00A"] ); } test "n_string_incomplete_escape" { - err( + try err( \\["\"] ); } test "n_string_incomplete_surrogate_escape_invalid" { - err( + try err( \\["\uD800\uD800\x"] ); } test "n_string_incomplete_surrogate" { - err( + try err( \\["\uD834\uDd"] ); } test "n_string_invalid_backslash_esc" { - err( + try err( \\["\a"] ); } test "n_string_invalid_unicode_escape" { - err( + try err( \\["\uqqqq"] ); } test "n_string_invalid_utf8_after_escape" { - err("[\"\\\x75\xc3\xa5\"]"); + try err("[\"\\\x75\xc3\xa5\"]"); } test "n_string_invalid-utf-8-in-escape" { - err( + try err( \\["\uΓ₯"] ); } test "n_string_leading_uescaped_thinspace" { - err( + try err( \\[\u0020"asd"] ); } test "n_string_no_quotes_with_bad_escape" { - err( + try err( \\[\n] ); } test "n_string_single_doublequote" { - err( + try err( \\" ); } test "n_string_single_quote" { - err( + try err( \\['single quote'] ); } test "n_string_single_string_no_double_quotes" { - err( + try err( \\abc ); } test "n_string_start_escape_unclosed" { - err( + try err( \\["\ ); } test "n_string_unescaped_crtl_char" { - err("[\"a\x00a\"]"); + try err("[\"a\x00a\"]"); } test "n_string_unescaped_newline" { - err( + try err( \\["new \\line"] ); } test "n_string_unescaped_tab" { - err("[\"\t\"]"); + try err("[\"\t\"]"); } test "n_string_unicode_CapitalU" { - err( + try err( \\"\UA66D" ); } test "n_string_with_trailing_garbage" { - err( + try err( \\""x ); } test "n_structure_100000_opening_arrays" { - err("[" ** 100000); + try err("[" ** 100000); } test "n_structure_angle_bracket_." { - err( + try err( \\<.> ); } test "n_structure_angle_bracket_null" { - err( + try err( \\[] ); } test "n_structure_array_trailing_garbage" { - err( + try err( \\[1]x ); } test "n_structure_array_with_extra_array_close" { - err( + try err( \\[1]] ); } test "n_structure_array_with_unclosed_string" { - err( + try err( \\["asd] ); } test "n_structure_ascii-unicode-identifier" { - err( + try err( \\aΓƒΒ₯ ); } test "n_structure_capitalized_True" { - err( + try err( \\[True] ); } test "n_structure_close_unopened_array" { - err( + try err( \\1] ); } test "n_structure_comma_instead_of_closing_brace" { - err( + try err( \\{"x": true, ); } test "n_structure_double_array" { - err( + try err( \\[][] ); } test "n_structure_end_array" { - err( + try err( \\] ); } test "n_structure_incomplete_UTF8_BOM" { - err( + try err( \\Γ―Β»{} ); } test "n_structure_lone-invalid-utf-8" { - err( + try err( \\Γ₯ ); } test "n_structure_lone-open-bracket" { - err( + try err( \\[ ); } test "n_structure_no_data" { - err( + try err( \\ ); } test "n_structure_null-byte-outside-string" { - err("[\x00]"); + try err("[\x00]"); } test "n_structure_number_with_trailing_garbage" { - err( + try err( \\2@ ); } test "n_structure_object_followed_by_closing_object" { - err( + try err( \\{}} ); } test "n_structure_object_unclosed_no_value" { - err( + try err( \\{"": ); } test "n_structure_object_with_comment" { - err( + try err( \\{"a":/*comment*/"b"} ); } test "n_structure_object_with_trailing_garbage" { - err( + try err( \\{"a": true} "x" ); } test "n_structure_open_array_apostrophe" { - err( + try err( \\[' ); } test "n_structure_open_array_comma" { - err( + try err( \\[, ); } test "n_structure_open_array_object" { - err("[{\"\":" ** 50000); + try err("[{\"\":" ** 50000); } test "n_structure_open_array_open_object" { - err( + try err( \\[{ ); } test "n_structure_open_array_open_string" { - err( + try err( \\["a ); } test "n_structure_open_array_string" { - err( + try err( \\["a" ); } test "n_structure_open_object_close_array" { - err( + try err( \\{] ); } test "n_structure_open_object_comma" { - err( + try err( \\{, ); } test "n_structure_open_object" { - err( + try err( \\{ ); } test "n_structure_open_object_open_array" { - err( + try err( \\{[ ); } test "n_structure_open_object_open_string" { - err( + try err( \\{"a ); } test "n_structure_open_object_string_with_apostrophes" { - err( + try err( \\{'a' ); } test "n_structure_open_open" { - err( + try err( \\["\{["\{["\{["\{ ); } test "n_structure_single_eacute" { - err( + try err( \\Γ© ); } test "n_structure_single_star" { - err( + try err( \\* ); } test "n_structure_trailing_#" { - err( + try err( \\{"a":"b"}#{} ); } test "n_structure_U+2060_word_joined" { - err( + try err( \\[ҁ ] ); } test "n_structure_uescaped_LF_before_string" { - err( + try err( \\[\u000A""] ); } test "n_structure_unclosed_array" { - err( + try err( \\[1 ); } test "n_structure_unclosed_array_partial_null" { - err( + try err( \\[ false, nul ); } test "n_structure_unclosed_array_unfinished_false" { - err( + try err( \\[ true, fals ); } test "n_structure_unclosed_array_unfinished_true" { - err( + try err( \\[ false, tru ); } test "n_structure_unclosed_object" { - err( + try err( \\{"asd":"asd" ); } test "n_structure_unicode-identifier" { - err( + try err( \\ΓƒΒ₯ ); } test "n_structure_UTF8_BOM_no_data" { - err( + try err( \\ ); } test "n_structure_whitespace_formfeed" { - err("[\x0c]"); + try err("[\x0c]"); } test "n_structure_whitespace_U+2060_word_joiner" { - err( + try err( \\[ҁ ] ); } @@ -1751,255 +1751,255 @@ test "n_structure_whitespace_U+2060_word_joiner" { //////////////////////////////////////////////////////////////////////////////////////////////////// test "i_number_double_huge_neg_exp" { - any( + try any( \\[123.456e-789] ); } test "i_number_huge_exp" { - any( + try any( \\[0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006] ); } test "i_number_neg_int_huge_exp" { - any( + try any( \\[-1e+9999] ); } test "i_number_pos_double_huge_exp" { - any( + try any( \\[1.5e+9999] ); } test "i_number_real_neg_overflow" { - any( + try any( \\[-123123e100000] ); } test "i_number_real_pos_overflow" { - any( + try any( \\[123123e100000] ); } test "i_number_real_underflow" { - any( + try any( \\[123e-10000000] ); } test "i_number_too_big_neg_int" { - any( + try any( \\[-123123123123123123123123123123] ); } test "i_number_too_big_pos_int" { - any( + try any( \\[100000000000000000000] ); } test "i_number_very_big_negative_int" { - any( + try any( \\[-237462374673276894279832749832423479823246327846] ); } test "i_object_key_lone_2nd_surrogate" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\{"\uDFAA":0} ); } test "i_string_1st_surrogate_but_2nd_missing" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uDADA"] ); } test "i_string_1st_valid_surrogate_2nd_invalid" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uD888\u1234"] ); } test "i_string_incomplete_surrogate_and_escape_valid" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uD800\n"] ); } test "i_string_incomplete_surrogate_pair" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uDd1ea"] ); } test "i_string_incomplete_surrogates_escape_valid" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uD800\uD800\n"] ); } test "i_string_invalid_lonely_surrogate" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\ud800"] ); } test "i_string_invalid_surrogate" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\ud800abc"] ); } test "i_string_invalid_utf-8" { - any( + try any( \\["ΓΏ"] ); } test "i_string_inverted_surrogates_U+1D11E" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uDd1e\uD834"] ); } test "i_string_iso_latin_1" { - any( + try any( \\["Γ©"] ); } test "i_string_lone_second_surrogate" { - anyStreamingErrNonStreaming( + try anyStreamingErrNonStreaming( \\["\uDFAA"] ); } test "i_string_lone_utf8_continuation_byte" { - any( + try any( \\[""] ); } test "i_string_not_in_unicode_range" { - any( + try any( \\["ô¿¿¿"] ); } test "i_string_overlong_sequence_2_bytes" { - any( + try any( \\["À¯"] ); } test "i_string_overlong_sequence_6_bytes" { - any( + try any( \\["üƒ¿¿¿¿"] ); } test "i_string_overlong_sequence_6_bytes_null" { - any( + try any( \\["ü€€€€€"] ); } test "i_string_truncated-utf-8" { - any( + try any( \\["Γ ΓΏ"] ); } test "i_string_utf16BE_no_BOM" { - any("\x00\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d"); + try any("\x00\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d"); } test "i_string_utf16LE_no_BOM" { - any("\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00"); + try any("\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00"); } test "i_string_UTF-16LE_with_BOM" { - any("\xc3\xbf\xc3\xbe\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00"); + try any("\xc3\xbf\xc3\xbe\x5b\x00\x22\x00\xc3\xa9\x00\x22\x00\x5d\x00"); } test "i_string_UTF-8_invalid_sequence" { - any( + try any( \\["æ—Β₯Γ‘ΒˆΓΊ"] ); } test "i_string_UTF8_surrogate_U+D800" { - any( + try any( \\["Γ­Β Β€"] ); } test "i_structure_500_nested_arrays" { - any(("[" ** 500) ++ ("]" ** 500)); + try any(("[" ** 500) ++ ("]" ** 500)); } test "i_structure_UTF-8_BOM_empty_object" { - any( + try any( \\{} ); } test "truncated UTF-8 sequence" { - utf8Error("\"\xc2\""); - utf8Error("\"\xdf\""); - utf8Error("\"\xed\xa0\""); - utf8Error("\"\xf0\x80\""); - utf8Error("\"\xf0\x80\x80\""); + try utf8Error("\"\xc2\""); + try utf8Error("\"\xdf\""); + try utf8Error("\"\xed\xa0\""); + try utf8Error("\"\xf0\x80\""); + try utf8Error("\"\xf0\x80\x80\""); } test "invalid continuation byte" { - utf8Error("\"\xc2\x00\""); - utf8Error("\"\xc2\x7f\""); - utf8Error("\"\xc2\xc0\""); - utf8Error("\"\xc3\xc1\""); - utf8Error("\"\xc4\xf5\""); - utf8Error("\"\xc5\xff\""); - utf8Error("\"\xe4\x80\x00\""); - utf8Error("\"\xe5\x80\x10\""); - utf8Error("\"\xe6\x80\xc0\""); - utf8Error("\"\xe7\x80\xf5\""); - utf8Error("\"\xe8\x00\x80\""); - utf8Error("\"\xf2\x00\x80\x80\""); - utf8Error("\"\xf0\x80\x00\x80\""); - utf8Error("\"\xf1\x80\xc0\x80\""); - utf8Error("\"\xf2\x80\x80\x00\""); - utf8Error("\"\xf3\x80\x80\xc0\""); - utf8Error("\"\xf4\x80\x80\xf5\""); + try utf8Error("\"\xc2\x00\""); + try utf8Error("\"\xc2\x7f\""); + try utf8Error("\"\xc2\xc0\""); + try utf8Error("\"\xc3\xc1\""); + try utf8Error("\"\xc4\xf5\""); + try utf8Error("\"\xc5\xff\""); + try utf8Error("\"\xe4\x80\x00\""); + try utf8Error("\"\xe5\x80\x10\""); + try utf8Error("\"\xe6\x80\xc0\""); + try utf8Error("\"\xe7\x80\xf5\""); + try utf8Error("\"\xe8\x00\x80\""); + try utf8Error("\"\xf2\x00\x80\x80\""); + try utf8Error("\"\xf0\x80\x00\x80\""); + try utf8Error("\"\xf1\x80\xc0\x80\""); + try utf8Error("\"\xf2\x80\x80\x00\""); + try utf8Error("\"\xf3\x80\x80\xc0\""); + try utf8Error("\"\xf4\x80\x80\xf5\""); } test "disallowed overlong form" { - utf8Error("\"\xc0\x80\""); - utf8Error("\"\xc0\x90\""); - utf8Error("\"\xc1\x80\""); - utf8Error("\"\xc1\x90\""); - utf8Error("\"\xe0\x80\x80\""); - utf8Error("\"\xf0\x80\x80\x80\""); + try utf8Error("\"\xc0\x80\""); + try utf8Error("\"\xc0\x90\""); + try utf8Error("\"\xc1\x80\""); + try utf8Error("\"\xc1\x90\""); + try utf8Error("\"\xe0\x80\x80\""); + try utf8Error("\"\xf0\x80\x80\x80\""); } test "out of UTF-16 range" { - utf8Error("\"\xf4\x90\x80\x80\""); - utf8Error("\"\xf5\x80\x80\x80\""); - utf8Error("\"\xf6\x80\x80\x80\""); - utf8Error("\"\xf7\x80\x80\x80\""); - utf8Error("\"\xf8\x80\x80\x80\""); - utf8Error("\"\xf9\x80\x80\x80\""); - utf8Error("\"\xfa\x80\x80\x80\""); - utf8Error("\"\xfb\x80\x80\x80\""); - utf8Error("\"\xfc\x80\x80\x80\""); - utf8Error("\"\xfd\x80\x80\x80\""); - utf8Error("\"\xfe\x80\x80\x80\""); - utf8Error("\"\xff\x80\x80\x80\""); + try utf8Error("\"\xf4\x90\x80\x80\""); + try utf8Error("\"\xf5\x80\x80\x80\""); + try utf8Error("\"\xf6\x80\x80\x80\""); + try utf8Error("\"\xf7\x80\x80\x80\""); + try utf8Error("\"\xf8\x80\x80\x80\""); + try utf8Error("\"\xf9\x80\x80\x80\""); + try utf8Error("\"\xfa\x80\x80\x80\""); + try utf8Error("\"\xfb\x80\x80\x80\""); + try utf8Error("\"\xfc\x80\x80\x80\""); + try utf8Error("\"\xfd\x80\x80\x80\""); + try utf8Error("\"\xfe\x80\x80\x80\""); + try utf8Error("\"\xff\x80\x80\x80\""); } diff --git a/lib/std/json/write_stream.zig b/lib/std/json/write_stream.zig index 1cff0ed2b7..c9169be755 100644 --- a/lib/std/json/write_stream.zig +++ b/lib/std/json/write_stream.zig @@ -288,7 +288,7 @@ test "json write stream" { \\ "float": 3.5e+00 \\} ; - std.testing.expect(std.mem.eql(u8, expected, result)); + try std.testing.expect(std.mem.eql(u8, expected, result)); } fn getJsonObject(allocator: *std.mem.Allocator) !std.json.Value { diff --git a/lib/std/leb128.zig b/lib/std/leb128.zig index 90a329545f..b1f56e21ab 100644 --- a/lib/std/leb128.zig +++ b/lib/std/leb128.zig @@ -152,22 +152,22 @@ test "writeUnsignedFixed" { { var buf: [4]u8 = undefined; writeUnsignedFixed(4, &buf, 0); - testing.expect((try test_read_uleb128(u64, &buf)) == 0); + try testing.expect((try test_read_uleb128(u64, &buf)) == 0); } { var buf: [4]u8 = undefined; writeUnsignedFixed(4, &buf, 1); - testing.expect((try test_read_uleb128(u64, &buf)) == 1); + try testing.expect((try test_read_uleb128(u64, &buf)) == 1); } { var buf: [4]u8 = undefined; writeUnsignedFixed(4, &buf, 1000); - testing.expect((try test_read_uleb128(u64, &buf)) == 1000); + try testing.expect((try test_read_uleb128(u64, &buf)) == 1000); } { var buf: [4]u8 = undefined; writeUnsignedFixed(4, &buf, 10000000); - testing.expect((try test_read_uleb128(u64, &buf)) == 10000000); + try testing.expect((try test_read_uleb128(u64, &buf)) == 10000000); } } @@ -212,44 +212,44 @@ fn test_read_uleb128_seq(comptime T: type, comptime N: usize, encoded: []const u test "deserialize signed LEB128" { // Truncated - testing.expectError(error.EndOfStream, test_read_stream_ileb128(i64, "\x80")); + try testing.expectError(error.EndOfStream, test_read_stream_ileb128(i64, "\x80")); // Overflow - testing.expectError(error.Overflow, test_read_ileb128(i8, "\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_ileb128(i16, "\x80\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_ileb128(i32, "\x80\x80\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_ileb128(i8, "\xff\x7e")); + try testing.expectError(error.Overflow, test_read_ileb128(i8, "\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_ileb128(i16, "\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_ileb128(i32, "\x80\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_ileb128(i8, "\xff\x7e")); // Decode SLEB128 - testing.expect((try test_read_ileb128(i64, "\x00")) == 0); - testing.expect((try test_read_ileb128(i64, "\x01")) == 1); - testing.expect((try test_read_ileb128(i64, "\x3f")) == 63); - testing.expect((try test_read_ileb128(i64, "\x40")) == -64); - testing.expect((try test_read_ileb128(i64, "\x41")) == -63); - testing.expect((try test_read_ileb128(i64, "\x7f")) == -1); - testing.expect((try test_read_ileb128(i64, "\x80\x01")) == 128); - testing.expect((try test_read_ileb128(i64, "\x81\x01")) == 129); - testing.expect((try test_read_ileb128(i64, "\xff\x7e")) == -129); - testing.expect((try test_read_ileb128(i64, "\x80\x7f")) == -128); - testing.expect((try test_read_ileb128(i64, "\x81\x7f")) == -127); - testing.expect((try test_read_ileb128(i64, "\xc0\x00")) == 64); - testing.expect((try test_read_ileb128(i64, "\xc7\x9f\x7f")) == -12345); - testing.expect((try test_read_ileb128(i8, "\xff\x7f")) == -1); - testing.expect((try test_read_ileb128(i16, "\xff\xff\x7f")) == -1); - testing.expect((try test_read_ileb128(i32, "\xff\xff\xff\xff\x7f")) == -1); - testing.expect((try test_read_ileb128(i32, "\x80\x80\x80\x80\x08")) == -0x80000000); - testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01")) == @bitCast(i64, @intCast(u64, 0x8000000000000000))); - testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x40")) == -0x4000000000000000); - testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7f")) == -0x8000000000000000); + try testing.expect((try test_read_ileb128(i64, "\x00")) == 0); + try testing.expect((try test_read_ileb128(i64, "\x01")) == 1); + try testing.expect((try test_read_ileb128(i64, "\x3f")) == 63); + try testing.expect((try test_read_ileb128(i64, "\x40")) == -64); + try testing.expect((try test_read_ileb128(i64, "\x41")) == -63); + try testing.expect((try test_read_ileb128(i64, "\x7f")) == -1); + try testing.expect((try test_read_ileb128(i64, "\x80\x01")) == 128); + try testing.expect((try test_read_ileb128(i64, "\x81\x01")) == 129); + try testing.expect((try test_read_ileb128(i64, "\xff\x7e")) == -129); + try testing.expect((try test_read_ileb128(i64, "\x80\x7f")) == -128); + try testing.expect((try test_read_ileb128(i64, "\x81\x7f")) == -127); + try testing.expect((try test_read_ileb128(i64, "\xc0\x00")) == 64); + try testing.expect((try test_read_ileb128(i64, "\xc7\x9f\x7f")) == -12345); + try testing.expect((try test_read_ileb128(i8, "\xff\x7f")) == -1); + try testing.expect((try test_read_ileb128(i16, "\xff\xff\x7f")) == -1); + try testing.expect((try test_read_ileb128(i32, "\xff\xff\xff\xff\x7f")) == -1); + try testing.expect((try test_read_ileb128(i32, "\x80\x80\x80\x80\x08")) == -0x80000000); + try testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01")) == @bitCast(i64, @intCast(u64, 0x8000000000000000))); + try testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x40")) == -0x4000000000000000); + try testing.expect((try test_read_ileb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7f")) == -0x8000000000000000); // Decode unnormalized SLEB128 with extra padding bytes. - testing.expect((try test_read_ileb128(i64, "\x80\x00")) == 0); - testing.expect((try test_read_ileb128(i64, "\x80\x80\x00")) == 0); - testing.expect((try test_read_ileb128(i64, "\xff\x00")) == 0x7f); - testing.expect((try test_read_ileb128(i64, "\xff\x80\x00")) == 0x7f); - testing.expect((try test_read_ileb128(i64, "\x80\x81\x00")) == 0x80); - testing.expect((try test_read_ileb128(i64, "\x80\x81\x80\x00")) == 0x80); + try testing.expect((try test_read_ileb128(i64, "\x80\x00")) == 0); + try testing.expect((try test_read_ileb128(i64, "\x80\x80\x00")) == 0); + try testing.expect((try test_read_ileb128(i64, "\xff\x00")) == 0x7f); + try testing.expect((try test_read_ileb128(i64, "\xff\x80\x00")) == 0x7f); + try testing.expect((try test_read_ileb128(i64, "\x80\x81\x00")) == 0x80); + try testing.expect((try test_read_ileb128(i64, "\x80\x81\x80\x00")) == 0x80); // Decode sequence of SLEB128 values try test_read_ileb128_seq(i64, 4, "\x81\x01\x3f\x80\x7f\x80\x80\x80\x00"); @@ -257,39 +257,39 @@ test "deserialize signed LEB128" { test "deserialize unsigned LEB128" { // Truncated - testing.expectError(error.EndOfStream, test_read_stream_uleb128(u64, "\x80")); + try testing.expectError(error.EndOfStream, test_read_stream_uleb128(u64, "\x80")); // Overflow - testing.expectError(error.Overflow, test_read_uleb128(u8, "\x80\x02")); - testing.expectError(error.Overflow, test_read_uleb128(u8, "\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_uleb128(u16, "\x80\x80\x84")); - testing.expectError(error.Overflow, test_read_uleb128(u16, "\x80\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_uleb128(u32, "\x80\x80\x80\x80\x90")); - testing.expectError(error.Overflow, test_read_uleb128(u32, "\x80\x80\x80\x80\x40")); - testing.expectError(error.Overflow, test_read_uleb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_uleb128(u8, "\x80\x02")); + try testing.expectError(error.Overflow, test_read_uleb128(u8, "\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_uleb128(u16, "\x80\x80\x84")); + try testing.expectError(error.Overflow, test_read_uleb128(u16, "\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_uleb128(u32, "\x80\x80\x80\x80\x90")); + try testing.expectError(error.Overflow, test_read_uleb128(u32, "\x80\x80\x80\x80\x40")); + try testing.expectError(error.Overflow, test_read_uleb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40")); // Decode ULEB128 - testing.expect((try test_read_uleb128(u64, "\x00")) == 0); - testing.expect((try test_read_uleb128(u64, "\x01")) == 1); - testing.expect((try test_read_uleb128(u64, "\x3f")) == 63); - testing.expect((try test_read_uleb128(u64, "\x40")) == 64); - testing.expect((try test_read_uleb128(u64, "\x7f")) == 0x7f); - testing.expect((try test_read_uleb128(u64, "\x80\x01")) == 0x80); - testing.expect((try test_read_uleb128(u64, "\x81\x01")) == 0x81); - testing.expect((try test_read_uleb128(u64, "\x90\x01")) == 0x90); - testing.expect((try test_read_uleb128(u64, "\xff\x01")) == 0xff); - testing.expect((try test_read_uleb128(u64, "\x80\x02")) == 0x100); - testing.expect((try test_read_uleb128(u64, "\x81\x02")) == 0x101); - testing.expect((try test_read_uleb128(u64, "\x80\xc1\x80\x80\x10")) == 4294975616); - testing.expect((try test_read_uleb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01")) == 0x8000000000000000); + try testing.expect((try test_read_uleb128(u64, "\x00")) == 0); + try testing.expect((try test_read_uleb128(u64, "\x01")) == 1); + try testing.expect((try test_read_uleb128(u64, "\x3f")) == 63); + try testing.expect((try test_read_uleb128(u64, "\x40")) == 64); + try testing.expect((try test_read_uleb128(u64, "\x7f")) == 0x7f); + try testing.expect((try test_read_uleb128(u64, "\x80\x01")) == 0x80); + try testing.expect((try test_read_uleb128(u64, "\x81\x01")) == 0x81); + try testing.expect((try test_read_uleb128(u64, "\x90\x01")) == 0x90); + try testing.expect((try test_read_uleb128(u64, "\xff\x01")) == 0xff); + try testing.expect((try test_read_uleb128(u64, "\x80\x02")) == 0x100); + try testing.expect((try test_read_uleb128(u64, "\x81\x02")) == 0x101); + try testing.expect((try test_read_uleb128(u64, "\x80\xc1\x80\x80\x10")) == 4294975616); + try testing.expect((try test_read_uleb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01")) == 0x8000000000000000); // Decode ULEB128 with extra padding bytes - testing.expect((try test_read_uleb128(u64, "\x80\x00")) == 0); - testing.expect((try test_read_uleb128(u64, "\x80\x80\x00")) == 0); - testing.expect((try test_read_uleb128(u64, "\xff\x00")) == 0x7f); - testing.expect((try test_read_uleb128(u64, "\xff\x80\x00")) == 0x7f); - testing.expect((try test_read_uleb128(u64, "\x80\x81\x00")) == 0x80); - testing.expect((try test_read_uleb128(u64, "\x80\x81\x80\x00")) == 0x80); + try testing.expect((try test_read_uleb128(u64, "\x80\x00")) == 0); + try testing.expect((try test_read_uleb128(u64, "\x80\x80\x00")) == 0); + try testing.expect((try test_read_uleb128(u64, "\xff\x00")) == 0x7f); + try testing.expect((try test_read_uleb128(u64, "\xff\x80\x00")) == 0x7f); + try testing.expect((try test_read_uleb128(u64, "\x80\x81\x00")) == 0x80); + try testing.expect((try test_read_uleb128(u64, "\x80\x81\x80\x00")) == 0x80); // Decode sequence of ULEB128 values try test_read_uleb128_seq(u64, 4, "\x81\x01\x3f\x80\x7f\x80\x80\x80\x00"); @@ -326,19 +326,19 @@ fn test_write_leb128(value: anytype) !void { // stream write try writeStream(fbs.writer(), value); const w1_pos = fbs.pos; - testing.expect(w1_pos == bytes_needed); + try testing.expect(w1_pos == bytes_needed); // stream read fbs.pos = 0; const sr = try readStream(T, fbs.reader()); - testing.expect(fbs.pos == w1_pos); - testing.expect(sr == value); + try testing.expect(fbs.pos == w1_pos); + try testing.expect(sr == value); // bigger type stream read fbs.pos = 0; const bsr = try readStream(B, fbs.reader()); - testing.expect(fbs.pos == w1_pos); - testing.expect(bsr == value); + try testing.expect(fbs.pos == w1_pos); + try testing.expect(bsr == value); } test "serialize unsigned LEB128" { diff --git a/lib/std/linked_list.zig b/lib/std/linked_list.zig index 2a6b58c8c9..49006343c5 100644 --- a/lib/std/linked_list.zig +++ b/lib/std/linked_list.zig @@ -123,7 +123,7 @@ test "basic SinglyLinkedList test" { const L = SinglyLinkedList(u32); var list = L{}; - testing.expect(list.len() == 0); + try testing.expect(list.len() == 0); var one = L.Node{ .data = 1 }; var two = L.Node{ .data = 2 }; @@ -137,14 +137,14 @@ test "basic SinglyLinkedList test" { two.insertAfter(&three); // {1, 2, 3, 5} three.insertAfter(&four); // {1, 2, 3, 4, 5} - testing.expect(list.len() == 5); + try testing.expect(list.len() == 5); // Traverse forwards. { var it = list.first; var index: u32 = 1; while (it) |node| : (it = node.next) { - testing.expect(node.data == index); + try testing.expect(node.data == index); index += 1; } } @@ -153,9 +153,9 @@ test "basic SinglyLinkedList test" { _ = list.remove(&five); // {2, 3, 4} _ = two.removeNext(); // {2, 4} - testing.expect(list.first.?.data == 2); - testing.expect(list.first.?.next.?.data == 4); - testing.expect(list.first.?.next.?.next == null); + try testing.expect(list.first.?.data == 2); + try testing.expect(list.first.?.next.?.data == 4); + try testing.expect(list.first.?.next.?.next == null); } /// A tail queue is headed by a pair of pointers, one to the head of the @@ -344,7 +344,7 @@ test "basic TailQueue test" { var it = list.first; var index: u32 = 1; while (it) |node| : (it = node.next) { - testing.expect(node.data == index); + try testing.expect(node.data == index); index += 1; } } @@ -354,7 +354,7 @@ test "basic TailQueue test" { var it = list.last; var index: u32 = 1; while (it) |node| : (it = node.prev) { - testing.expect(node.data == (6 - index)); + try testing.expect(node.data == (6 - index)); index += 1; } } @@ -363,9 +363,9 @@ test "basic TailQueue test" { var last = list.pop(); // {2, 3, 4} list.remove(&three); // {2, 4} - testing.expect(list.first.?.data == 2); - testing.expect(list.last.?.data == 4); - testing.expect(list.len == 2); + try testing.expect(list.first.?.data == 2); + try testing.expect(list.last.?.data == 4); + try testing.expect(list.len == 2); } test "TailQueue concatenation" { @@ -387,18 +387,18 @@ test "TailQueue concatenation" { list1.concatByMoving(&list2); - testing.expect(list1.last == &five); - testing.expect(list1.len == 5); - testing.expect(list2.first == null); - testing.expect(list2.last == null); - testing.expect(list2.len == 0); + try testing.expect(list1.last == &five); + try testing.expect(list1.len == 5); + try testing.expect(list2.first == null); + try testing.expect(list2.last == null); + try testing.expect(list2.len == 0); // Traverse forwards. { var it = list1.first; var index: u32 = 1; while (it) |node| : (it = node.next) { - testing.expect(node.data == index); + try testing.expect(node.data == index); index += 1; } } @@ -408,7 +408,7 @@ test "TailQueue concatenation" { var it = list1.last; var index: u32 = 1; while (it) |node| : (it = node.prev) { - testing.expect(node.data == (6 - index)); + try testing.expect(node.data == (6 - index)); index += 1; } } @@ -421,7 +421,7 @@ test "TailQueue concatenation" { var it = list2.first; var index: u32 = 1; while (it) |node| : (it = node.next) { - testing.expect(node.data == index); + try testing.expect(node.data == index); index += 1; } } @@ -431,7 +431,7 @@ test "TailQueue concatenation" { var it = list2.last; var index: u32 = 1; while (it) |node| : (it = node.prev) { - testing.expect(node.data == (6 - index)); + try testing.expect(node.data == (6 - index)); index += 1; } } diff --git a/lib/std/math.zig b/lib/std/math.zig index 558f541c00..c0881c92ae 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -177,20 +177,20 @@ test "approxEqAbs and approxEqRel" { else => unreachable, }; - testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value)); - testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value)); - testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value)); - testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value)); - testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value)); - testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value)); - testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value)); - testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value)); - testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value)); - testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value)); - testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value)); - testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value)); - testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2)); - testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2)); + try testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value)); + try testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value)); + try testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value)); + try testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value)); + try testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value)); + try testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value)); + try testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value)); + try testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value)); + try testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value)); + try testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value)); + try testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value)); + try testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value)); + try testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2)); + try testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2)); } } @@ -349,34 +349,34 @@ pub fn min(x: anytype, y: anytype) Min(@TypeOf(x), @TypeOf(y)) { } test "math.min" { - testing.expect(min(@as(i32, -1), @as(i32, 2)) == -1); + try testing.expect(min(@as(i32, -1), @as(i32, 2)) == -1); { var a: u16 = 999; var b: u32 = 10; var result = min(a, b); - testing.expect(@TypeOf(result) == u16); - testing.expect(result == 10); + try testing.expect(@TypeOf(result) == u16); + try testing.expect(result == 10); } { var a: f64 = 10.34; var b: f32 = 999.12; var result = min(a, b); - testing.expect(@TypeOf(result) == f64); - testing.expect(result == 10.34); + try testing.expect(@TypeOf(result) == f64); + try testing.expect(result == 10.34); } { var a: i8 = -127; var b: i16 = -200; var result = min(a, b); - testing.expect(@TypeOf(result) == i16); - testing.expect(result == -200); + try testing.expect(@TypeOf(result) == i16); + try testing.expect(result == -200); } { const a = 10.34; var b: f32 = 999.12; var result = min(a, b); - testing.expect(@TypeOf(result) == f32); - testing.expect(result == 10.34); + try testing.expect(@TypeOf(result) == f32); + try testing.expect(result == 10.34); } } @@ -385,7 +385,7 @@ pub fn max(x: anytype, y: anytype) @TypeOf(x, y) { } test "math.max" { - testing.expect(max(@as(i32, -1), @as(i32, 2)) == 2); + try testing.expect(max(@as(i32, -1), @as(i32, 2)) == 2); } pub fn clamp(val: anytype, lower: anytype, upper: anytype) @TypeOf(val, lower, upper) { @@ -394,19 +394,19 @@ pub fn clamp(val: anytype, lower: anytype, upper: anytype) @TypeOf(val, lower, u } test "math.clamp" { // Within range - testing.expect(std.math.clamp(@as(i32, -1), @as(i32, -4), @as(i32, 7)) == -1); + try testing.expect(std.math.clamp(@as(i32, -1), @as(i32, -4), @as(i32, 7)) == -1); // Below - testing.expect(std.math.clamp(@as(i32, -5), @as(i32, -4), @as(i32, 7)) == -4); + try testing.expect(std.math.clamp(@as(i32, -5), @as(i32, -4), @as(i32, 7)) == -4); // Above - testing.expect(std.math.clamp(@as(i32, 8), @as(i32, -4), @as(i32, 7)) == 7); + try testing.expect(std.math.clamp(@as(i32, 8), @as(i32, -4), @as(i32, 7)) == 7); // Floating point - testing.expect(std.math.clamp(@as(f32, 1.1), @as(f32, 0.0), @as(f32, 1.0)) == 1.0); - testing.expect(std.math.clamp(@as(f32, -127.5), @as(f32, -200), @as(f32, -100)) == -127.5); + try testing.expect(std.math.clamp(@as(f32, 1.1), @as(f32, 0.0), @as(f32, 1.0)) == 1.0); + try testing.expect(std.math.clamp(@as(f32, -127.5), @as(f32, -200), @as(f32, -100)) == -127.5); // Mix of comptime and non-comptime var i: i32 = 1; - testing.expect(std.math.clamp(i, 0, 1) == 1); + try testing.expect(std.math.clamp(i, 0, 1) == 1); } pub fn mul(comptime T: type, a: T, b: T) (error{Overflow}!T) { @@ -461,17 +461,17 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T { } test "math.shl" { - testing.expect(shl(u8, 0b11111111, @as(usize, 3)) == 0b11111000); - testing.expect(shl(u8, 0b11111111, @as(usize, 8)) == 0); - testing.expect(shl(u8, 0b11111111, @as(usize, 9)) == 0); - testing.expect(shl(u8, 0b11111111, @as(isize, -2)) == 0b00111111); - testing.expect(shl(u8, 0b11111111, 3) == 0b11111000); - testing.expect(shl(u8, 0b11111111, 8) == 0); - testing.expect(shl(u8, 0b11111111, 9) == 0); - testing.expect(shl(u8, 0b11111111, -2) == 0b00111111); - testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(usize, 1))[0] == @as(u32, 42) << 1); - testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(isize, -1))[0] == @as(u32, 42) >> 1); - testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, 33)[0] == 0); + try testing.expect(shl(u8, 0b11111111, @as(usize, 3)) == 0b11111000); + try testing.expect(shl(u8, 0b11111111, @as(usize, 8)) == 0); + try testing.expect(shl(u8, 0b11111111, @as(usize, 9)) == 0); + try testing.expect(shl(u8, 0b11111111, @as(isize, -2)) == 0b00111111); + try testing.expect(shl(u8, 0b11111111, 3) == 0b11111000); + try testing.expect(shl(u8, 0b11111111, 8) == 0); + try testing.expect(shl(u8, 0b11111111, 9) == 0); + try testing.expect(shl(u8, 0b11111111, -2) == 0b00111111); + try testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(usize, 1))[0] == @as(u32, 42) << 1); + try testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(isize, -1))[0] == @as(u32, 42) >> 1); + try testing.expect(shl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, 33)[0] == 0); } /// Shifts right. Overflowed bits are truncated. @@ -501,17 +501,17 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T { } test "math.shr" { - testing.expect(shr(u8, 0b11111111, @as(usize, 3)) == 0b00011111); - testing.expect(shr(u8, 0b11111111, @as(usize, 8)) == 0); - testing.expect(shr(u8, 0b11111111, @as(usize, 9)) == 0); - testing.expect(shr(u8, 0b11111111, @as(isize, -2)) == 0b11111100); - testing.expect(shr(u8, 0b11111111, 3) == 0b00011111); - testing.expect(shr(u8, 0b11111111, 8) == 0); - testing.expect(shr(u8, 0b11111111, 9) == 0); - testing.expect(shr(u8, 0b11111111, -2) == 0b11111100); - testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(usize, 1))[0] == @as(u32, 42) >> 1); - testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(isize, -1))[0] == @as(u32, 42) << 1); - testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, 33)[0] == 0); + try testing.expect(shr(u8, 0b11111111, @as(usize, 3)) == 0b00011111); + try testing.expect(shr(u8, 0b11111111, @as(usize, 8)) == 0); + try testing.expect(shr(u8, 0b11111111, @as(usize, 9)) == 0); + try testing.expect(shr(u8, 0b11111111, @as(isize, -2)) == 0b11111100); + try testing.expect(shr(u8, 0b11111111, 3) == 0b00011111); + try testing.expect(shr(u8, 0b11111111, 8) == 0); + try testing.expect(shr(u8, 0b11111111, 9) == 0); + try testing.expect(shr(u8, 0b11111111, -2) == 0b11111100); + try testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(usize, 1))[0] == @as(u32, 42) >> 1); + try testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, @as(isize, -1))[0] == @as(u32, 42) << 1); + try testing.expect(shr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){42}, 33)[0] == 0); } /// Rotates right. Only unsigned values can be rotated. @@ -533,13 +533,13 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T { } test "math.rotr" { - testing.expect(rotr(u8, 0b00000001, @as(usize, 0)) == 0b00000001); - testing.expect(rotr(u8, 0b00000001, @as(usize, 9)) == 0b10000000); - testing.expect(rotr(u8, 0b00000001, @as(usize, 8)) == 0b00000001); - testing.expect(rotr(u8, 0b00000001, @as(usize, 4)) == 0b00010000); - testing.expect(rotr(u8, 0b00000001, @as(isize, -1)) == 0b00000010); - testing.expect(rotr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1}, @as(usize, 1))[0] == @as(u32, 1) << 31); - testing.expect(rotr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1}, @as(isize, -1))[0] == @as(u32, 1) << 1); + try testing.expect(rotr(u8, 0b00000001, @as(usize, 0)) == 0b00000001); + try testing.expect(rotr(u8, 0b00000001, @as(usize, 9)) == 0b10000000); + try testing.expect(rotr(u8, 0b00000001, @as(usize, 8)) == 0b00000001); + try testing.expect(rotr(u8, 0b00000001, @as(usize, 4)) == 0b00010000); + try testing.expect(rotr(u8, 0b00000001, @as(isize, -1)) == 0b00000010); + try testing.expect(rotr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1}, @as(usize, 1))[0] == @as(u32, 1) << 31); + try testing.expect(rotr(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1}, @as(isize, -1))[0] == @as(u32, 1) << 1); } /// Rotates left. Only unsigned values can be rotated. @@ -561,13 +561,13 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T { } test "math.rotl" { - testing.expect(rotl(u8, 0b00000001, @as(usize, 0)) == 0b00000001); - testing.expect(rotl(u8, 0b00000001, @as(usize, 9)) == 0b00000010); - testing.expect(rotl(u8, 0b00000001, @as(usize, 8)) == 0b00000001); - testing.expect(rotl(u8, 0b00000001, @as(usize, 4)) == 0b00010000); - testing.expect(rotl(u8, 0b00000001, @as(isize, -1)) == 0b10000000); - testing.expect(rotl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1 << 31}, @as(usize, 1))[0] == 1); - testing.expect(rotl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1 << 31}, @as(isize, -1))[0] == @as(u32, 1) << 30); + try testing.expect(rotl(u8, 0b00000001, @as(usize, 0)) == 0b00000001); + try testing.expect(rotl(u8, 0b00000001, @as(usize, 9)) == 0b00000010); + try testing.expect(rotl(u8, 0b00000001, @as(usize, 8)) == 0b00000001); + try testing.expect(rotl(u8, 0b00000001, @as(usize, 4)) == 0b00010000); + try testing.expect(rotl(u8, 0b00000001, @as(isize, -1)) == 0b10000000); + try testing.expect(rotl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1 << 31}, @as(usize, 1))[0] == 1); + try testing.expect(rotl(std.meta.Vector(1, u32), std.meta.Vector(1, u32){1 << 31}, @as(isize, -1))[0] == @as(u32, 1) << 30); } pub fn Log2Int(comptime T: type) type { @@ -598,62 +598,62 @@ pub fn IntFittingRange(comptime from: comptime_int, comptime to: comptime_int) t } test "math.IntFittingRange" { - testing.expect(IntFittingRange(0, 0) == u0); - testing.expect(IntFittingRange(0, 1) == u1); - testing.expect(IntFittingRange(0, 2) == u2); - testing.expect(IntFittingRange(0, 3) == u2); - testing.expect(IntFittingRange(0, 4) == u3); - testing.expect(IntFittingRange(0, 7) == u3); - testing.expect(IntFittingRange(0, 8) == u4); - testing.expect(IntFittingRange(0, 9) == u4); - testing.expect(IntFittingRange(0, 15) == u4); - testing.expect(IntFittingRange(0, 16) == u5); - testing.expect(IntFittingRange(0, 17) == u5); - testing.expect(IntFittingRange(0, 4095) == u12); - testing.expect(IntFittingRange(2000, 4095) == u12); - testing.expect(IntFittingRange(0, 4096) == u13); - testing.expect(IntFittingRange(2000, 4096) == u13); - testing.expect(IntFittingRange(0, 4097) == u13); - testing.expect(IntFittingRange(2000, 4097) == u13); - testing.expect(IntFittingRange(0, 123456789123456798123456789) == u87); - testing.expect(IntFittingRange(0, 123456789123456798123456789123456789123456798123456789) == u177); + try testing.expect(IntFittingRange(0, 0) == u0); + try testing.expect(IntFittingRange(0, 1) == u1); + try testing.expect(IntFittingRange(0, 2) == u2); + try testing.expect(IntFittingRange(0, 3) == u2); + try testing.expect(IntFittingRange(0, 4) == u3); + try testing.expect(IntFittingRange(0, 7) == u3); + try testing.expect(IntFittingRange(0, 8) == u4); + try testing.expect(IntFittingRange(0, 9) == u4); + try testing.expect(IntFittingRange(0, 15) == u4); + try testing.expect(IntFittingRange(0, 16) == u5); + try testing.expect(IntFittingRange(0, 17) == u5); + try testing.expect(IntFittingRange(0, 4095) == u12); + try testing.expect(IntFittingRange(2000, 4095) == u12); + try testing.expect(IntFittingRange(0, 4096) == u13); + try testing.expect(IntFittingRange(2000, 4096) == u13); + try testing.expect(IntFittingRange(0, 4097) == u13); + try testing.expect(IntFittingRange(2000, 4097) == u13); + try testing.expect(IntFittingRange(0, 123456789123456798123456789) == u87); + try testing.expect(IntFittingRange(0, 123456789123456798123456789123456789123456798123456789) == u177); - testing.expect(IntFittingRange(-1, -1) == i1); - testing.expect(IntFittingRange(-1, 0) == i1); - testing.expect(IntFittingRange(-1, 1) == i2); - testing.expect(IntFittingRange(-2, -2) == i2); - testing.expect(IntFittingRange(-2, -1) == i2); - testing.expect(IntFittingRange(-2, 0) == i2); - testing.expect(IntFittingRange(-2, 1) == i2); - testing.expect(IntFittingRange(-2, 2) == i3); - testing.expect(IntFittingRange(-1, 2) == i3); - testing.expect(IntFittingRange(-1, 3) == i3); - testing.expect(IntFittingRange(-1, 4) == i4); - testing.expect(IntFittingRange(-1, 7) == i4); - testing.expect(IntFittingRange(-1, 8) == i5); - testing.expect(IntFittingRange(-1, 9) == i5); - testing.expect(IntFittingRange(-1, 15) == i5); - testing.expect(IntFittingRange(-1, 16) == i6); - testing.expect(IntFittingRange(-1, 17) == i6); - testing.expect(IntFittingRange(-1, 4095) == i13); - testing.expect(IntFittingRange(-4096, 4095) == i13); - testing.expect(IntFittingRange(-1, 4096) == i14); - testing.expect(IntFittingRange(-4097, 4095) == i14); - testing.expect(IntFittingRange(-1, 4097) == i14); - testing.expect(IntFittingRange(-1, 123456789123456798123456789) == i88); - testing.expect(IntFittingRange(-1, 123456789123456798123456789123456789123456798123456789) == i178); + try testing.expect(IntFittingRange(-1, -1) == i1); + try testing.expect(IntFittingRange(-1, 0) == i1); + try testing.expect(IntFittingRange(-1, 1) == i2); + try testing.expect(IntFittingRange(-2, -2) == i2); + try testing.expect(IntFittingRange(-2, -1) == i2); + try testing.expect(IntFittingRange(-2, 0) == i2); + try testing.expect(IntFittingRange(-2, 1) == i2); + try testing.expect(IntFittingRange(-2, 2) == i3); + try testing.expect(IntFittingRange(-1, 2) == i3); + try testing.expect(IntFittingRange(-1, 3) == i3); + try testing.expect(IntFittingRange(-1, 4) == i4); + try testing.expect(IntFittingRange(-1, 7) == i4); + try testing.expect(IntFittingRange(-1, 8) == i5); + try testing.expect(IntFittingRange(-1, 9) == i5); + try testing.expect(IntFittingRange(-1, 15) == i5); + try testing.expect(IntFittingRange(-1, 16) == i6); + try testing.expect(IntFittingRange(-1, 17) == i6); + try testing.expect(IntFittingRange(-1, 4095) == i13); + try testing.expect(IntFittingRange(-4096, 4095) == i13); + try testing.expect(IntFittingRange(-1, 4096) == i14); + try testing.expect(IntFittingRange(-4097, 4095) == i14); + try testing.expect(IntFittingRange(-1, 4097) == i14); + try testing.expect(IntFittingRange(-1, 123456789123456798123456789) == i88); + try testing.expect(IntFittingRange(-1, 123456789123456798123456789123456789123456798123456789) == i178); } test "math overflow functions" { - testOverflow(); - comptime testOverflow(); + try testOverflow(); + comptime try testOverflow(); } -fn testOverflow() void { - testing.expect((mul(i32, 3, 4) catch unreachable) == 12); - testing.expect((add(i32, 3, 4) catch unreachable) == 7); - testing.expect((sub(i32, 3, 4) catch unreachable) == -1); - testing.expect((shlExact(i32, 0b11, 4) catch unreachable) == 0b110000); +fn testOverflow() !void { + try testing.expect((mul(i32, 3, 4) catch unreachable) == 12); + try testing.expect((add(i32, 3, 4) catch unreachable) == 7); + try testing.expect((sub(i32, 3, 4) catch unreachable) == -1); + try testing.expect((shlExact(i32, 0b11, 4) catch unreachable) == 0b110000); } pub fn absInt(x: anytype) !@TypeOf(x) { @@ -670,23 +670,23 @@ pub fn absInt(x: anytype) !@TypeOf(x) { } test "math.absInt" { - testAbsInt(); - comptime testAbsInt(); + try testAbsInt(); + comptime try testAbsInt(); } -fn testAbsInt() void { - testing.expect((absInt(@as(i32, -10)) catch unreachable) == 10); - testing.expect((absInt(@as(i32, 10)) catch unreachable) == 10); +fn testAbsInt() !void { + try testing.expect((absInt(@as(i32, -10)) catch unreachable) == 10); + try testing.expect((absInt(@as(i32, 10)) catch unreachable) == 10); } pub const absFloat = fabs; test "math.absFloat" { - testAbsFloat(); - comptime testAbsFloat(); + try testAbsFloat(); + comptime try testAbsFloat(); } -fn testAbsFloat() void { - testing.expect(absFloat(@as(f32, -10.05)) == 10.05); - testing.expect(absFloat(@as(f32, 10.05)) == 10.05); +fn testAbsFloat() !void { + try testing.expect(absFloat(@as(f32, -10.05)) == 10.05); + try testing.expect(absFloat(@as(f32, 10.05)) == 10.05); } pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T { @@ -697,17 +697,17 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T { } test "math.divTrunc" { - testDivTrunc(); - comptime testDivTrunc(); + try testDivTrunc(); + comptime try testDivTrunc(); } -fn testDivTrunc() void { - testing.expect((divTrunc(i32, 5, 3) catch unreachable) == 1); - testing.expect((divTrunc(i32, -5, 3) catch unreachable) == -1); - testing.expectError(error.DivisionByZero, divTrunc(i8, -5, 0)); - testing.expectError(error.Overflow, divTrunc(i8, -128, -1)); +fn testDivTrunc() !void { + try testing.expect((divTrunc(i32, 5, 3) catch unreachable) == 1); + try testing.expect((divTrunc(i32, -5, 3) catch unreachable) == -1); + try testing.expectError(error.DivisionByZero, divTrunc(i8, -5, 0)); + try testing.expectError(error.Overflow, divTrunc(i8, -128, -1)); - testing.expect((divTrunc(f32, 5.0, 3.0) catch unreachable) == 1.0); - testing.expect((divTrunc(f32, -5.0, 3.0) catch unreachable) == -1.0); + try testing.expect((divTrunc(f32, 5.0, 3.0) catch unreachable) == 1.0); + try testing.expect((divTrunc(f32, -5.0, 3.0) catch unreachable) == -1.0); } pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T { @@ -718,17 +718,17 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T { } test "math.divFloor" { - testDivFloor(); - comptime testDivFloor(); + try testDivFloor(); + comptime try testDivFloor(); } -fn testDivFloor() void { - testing.expect((divFloor(i32, 5, 3) catch unreachable) == 1); - testing.expect((divFloor(i32, -5, 3) catch unreachable) == -2); - testing.expectError(error.DivisionByZero, divFloor(i8, -5, 0)); - testing.expectError(error.Overflow, divFloor(i8, -128, -1)); +fn testDivFloor() !void { + try testing.expect((divFloor(i32, 5, 3) catch unreachable) == 1); + try testing.expect((divFloor(i32, -5, 3) catch unreachable) == -2); + try testing.expectError(error.DivisionByZero, divFloor(i8, -5, 0)); + try testing.expectError(error.Overflow, divFloor(i8, -128, -1)); - testing.expect((divFloor(f32, 5.0, 3.0) catch unreachable) == 1.0); - testing.expect((divFloor(f32, -5.0, 3.0) catch unreachable) == -2.0); + try testing.expect((divFloor(f32, 5.0, 3.0) catch unreachable) == 1.0); + try testing.expect((divFloor(f32, -5.0, 3.0) catch unreachable) == -2.0); } pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T { @@ -752,36 +752,36 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T { } test "math.divCeil" { - testDivCeil(); - comptime testDivCeil(); + try testDivCeil(); + comptime try testDivCeil(); } -fn testDivCeil() void { - testing.expectEqual(@as(i32, 2), divCeil(i32, 5, 3) catch unreachable); - testing.expectEqual(@as(i32, -1), divCeil(i32, -5, 3) catch unreachable); - testing.expectEqual(@as(i32, -1), divCeil(i32, 5, -3) catch unreachable); - testing.expectEqual(@as(i32, 2), divCeil(i32, -5, -3) catch unreachable); - testing.expectEqual(@as(i32, 0), divCeil(i32, 0, 5) catch unreachable); - testing.expectEqual(@as(u32, 0), divCeil(u32, 0, 5) catch unreachable); - testing.expectError(error.DivisionByZero, divCeil(i8, -5, 0)); - testing.expectError(error.Overflow, divCeil(i8, -128, -1)); +fn testDivCeil() !void { + try testing.expectEqual(@as(i32, 2), divCeil(i32, 5, 3) catch unreachable); + try testing.expectEqual(@as(i32, -1), divCeil(i32, -5, 3) catch unreachable); + try testing.expectEqual(@as(i32, -1), divCeil(i32, 5, -3) catch unreachable); + try testing.expectEqual(@as(i32, 2), divCeil(i32, -5, -3) catch unreachable); + try testing.expectEqual(@as(i32, 0), divCeil(i32, 0, 5) catch unreachable); + try testing.expectEqual(@as(u32, 0), divCeil(u32, 0, 5) catch unreachable); + try testing.expectError(error.DivisionByZero, divCeil(i8, -5, 0)); + try testing.expectError(error.Overflow, divCeil(i8, -128, -1)); - testing.expectEqual(@as(f32, 0.0), divCeil(f32, 0.0, 5.0) catch unreachable); - testing.expectEqual(@as(f32, 2.0), divCeil(f32, 5.0, 3.0) catch unreachable); - testing.expectEqual(@as(f32, -1.0), divCeil(f32, -5.0, 3.0) catch unreachable); - testing.expectEqual(@as(f32, -1.0), divCeil(f32, 5.0, -3.0) catch unreachable); - testing.expectEqual(@as(f32, 2.0), divCeil(f32, -5.0, -3.0) catch unreachable); + try testing.expectEqual(@as(f32, 0.0), divCeil(f32, 0.0, 5.0) catch unreachable); + try testing.expectEqual(@as(f32, 2.0), divCeil(f32, 5.0, 3.0) catch unreachable); + try testing.expectEqual(@as(f32, -1.0), divCeil(f32, -5.0, 3.0) catch unreachable); + try testing.expectEqual(@as(f32, -1.0), divCeil(f32, 5.0, -3.0) catch unreachable); + try testing.expectEqual(@as(f32, 2.0), divCeil(f32, -5.0, -3.0) catch unreachable); - testing.expectEqual(6, divCeil(comptime_int, 23, 4) catch unreachable); - testing.expectEqual(-5, divCeil(comptime_int, -23, 4) catch unreachable); - testing.expectEqual(-5, divCeil(comptime_int, 23, -4) catch unreachable); - testing.expectEqual(6, divCeil(comptime_int, -23, -4) catch unreachable); - testing.expectError(error.DivisionByZero, divCeil(comptime_int, 23, 0)); + try testing.expectEqual(6, divCeil(comptime_int, 23, 4) catch unreachable); + try testing.expectEqual(-5, divCeil(comptime_int, -23, 4) catch unreachable); + try testing.expectEqual(-5, divCeil(comptime_int, 23, -4) catch unreachable); + try testing.expectEqual(6, divCeil(comptime_int, -23, -4) catch unreachable); + try testing.expectError(error.DivisionByZero, divCeil(comptime_int, 23, 0)); - testing.expectEqual(6.0, divCeil(comptime_float, 23.0, 4.0) catch unreachable); - testing.expectEqual(-5.0, divCeil(comptime_float, -23.0, 4.0) catch unreachable); - testing.expectEqual(-5.0, divCeil(comptime_float, 23.0, -4.0) catch unreachable); - testing.expectEqual(6.0, divCeil(comptime_float, -23.0, -4.0) catch unreachable); - testing.expectError(error.DivisionByZero, divCeil(comptime_float, 23.0, 0.0)); + try testing.expectEqual(6.0, divCeil(comptime_float, 23.0, 4.0) catch unreachable); + try testing.expectEqual(-5.0, divCeil(comptime_float, -23.0, 4.0) catch unreachable); + try testing.expectEqual(-5.0, divCeil(comptime_float, 23.0, -4.0) catch unreachable); + try testing.expectEqual(6.0, divCeil(comptime_float, -23.0, -4.0) catch unreachable); + try testing.expectError(error.DivisionByZero, divCeil(comptime_float, 23.0, 0.0)); } pub fn divExact(comptime T: type, numerator: T, denominator: T) !T { @@ -794,19 +794,19 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T { } test "math.divExact" { - testDivExact(); - comptime testDivExact(); + try testDivExact(); + comptime try testDivExact(); } -fn testDivExact() void { - testing.expect((divExact(i32, 10, 5) catch unreachable) == 2); - testing.expect((divExact(i32, -10, 5) catch unreachable) == -2); - testing.expectError(error.DivisionByZero, divExact(i8, -5, 0)); - testing.expectError(error.Overflow, divExact(i8, -128, -1)); - testing.expectError(error.UnexpectedRemainder, divExact(i32, 5, 2)); +fn testDivExact() !void { + try testing.expect((divExact(i32, 10, 5) catch unreachable) == 2); + try testing.expect((divExact(i32, -10, 5) catch unreachable) == -2); + try testing.expectError(error.DivisionByZero, divExact(i8, -5, 0)); + try testing.expectError(error.Overflow, divExact(i8, -128, -1)); + try testing.expectError(error.UnexpectedRemainder, divExact(i32, 5, 2)); - testing.expect((divExact(f32, 10.0, 5.0) catch unreachable) == 2.0); - testing.expect((divExact(f32, -10.0, 5.0) catch unreachable) == -2.0); - testing.expectError(error.UnexpectedRemainder, divExact(f32, 5.0, 2.0)); + try testing.expect((divExact(f32, 10.0, 5.0) catch unreachable) == 2.0); + try testing.expect((divExact(f32, -10.0, 5.0) catch unreachable) == -2.0); + try testing.expectError(error.UnexpectedRemainder, divExact(f32, 5.0, 2.0)); } pub fn mod(comptime T: type, numerator: T, denominator: T) !T { @@ -817,19 +817,19 @@ pub fn mod(comptime T: type, numerator: T, denominator: T) !T { } test "math.mod" { - testMod(); - comptime testMod(); + try testMod(); + comptime try testMod(); } -fn testMod() void { - testing.expect((mod(i32, -5, 3) catch unreachable) == 1); - testing.expect((mod(i32, 5, 3) catch unreachable) == 2); - testing.expectError(error.NegativeDenominator, mod(i32, 10, -1)); - testing.expectError(error.DivisionByZero, mod(i32, 10, 0)); +fn testMod() !void { + try testing.expect((mod(i32, -5, 3) catch unreachable) == 1); + try testing.expect((mod(i32, 5, 3) catch unreachable) == 2); + try testing.expectError(error.NegativeDenominator, mod(i32, 10, -1)); + try testing.expectError(error.DivisionByZero, mod(i32, 10, 0)); - testing.expect((mod(f32, -5, 3) catch unreachable) == 1); - testing.expect((mod(f32, 5, 3) catch unreachable) == 2); - testing.expectError(error.NegativeDenominator, mod(f32, 10, -1)); - testing.expectError(error.DivisionByZero, mod(f32, 10, 0)); + try testing.expect((mod(f32, -5, 3) catch unreachable) == 1); + try testing.expect((mod(f32, 5, 3) catch unreachable) == 2); + try testing.expectError(error.NegativeDenominator, mod(f32, 10, -1)); + try testing.expectError(error.DivisionByZero, mod(f32, 10, 0)); } pub fn rem(comptime T: type, numerator: T, denominator: T) !T { @@ -840,19 +840,19 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T { } test "math.rem" { - testRem(); - comptime testRem(); + try testRem(); + comptime try testRem(); } -fn testRem() void { - testing.expect((rem(i32, -5, 3) catch unreachable) == -2); - testing.expect((rem(i32, 5, 3) catch unreachable) == 2); - testing.expectError(error.NegativeDenominator, rem(i32, 10, -1)); - testing.expectError(error.DivisionByZero, rem(i32, 10, 0)); +fn testRem() !void { + try testing.expect((rem(i32, -5, 3) catch unreachable) == -2); + try testing.expect((rem(i32, 5, 3) catch unreachable) == 2); + try testing.expectError(error.NegativeDenominator, rem(i32, 10, -1)); + try testing.expectError(error.DivisionByZero, rem(i32, 10, 0)); - testing.expect((rem(f32, -5, 3) catch unreachable) == -2); - testing.expect((rem(f32, 5, 3) catch unreachable) == 2); - testing.expectError(error.NegativeDenominator, rem(f32, 10, -1)); - testing.expectError(error.DivisionByZero, rem(f32, 10, 0)); + try testing.expect((rem(f32, -5, 3) catch unreachable) == -2); + try testing.expect((rem(f32, 5, 3) catch unreachable) == 2); + try testing.expectError(error.NegativeDenominator, rem(f32, 10, -1)); + try testing.expectError(error.DivisionByZero, rem(f32, 10, 0)); } /// Returns the absolute value of the integer parameter. @@ -883,11 +883,11 @@ pub fn absCast(x: anytype) switch (@typeInfo(@TypeOf(x))) { } test "math.absCast" { - testing.expectEqual(@as(u1, 1), absCast(@as(i1, -1))); - testing.expectEqual(@as(u32, 999), absCast(@as(i32, -999))); - testing.expectEqual(@as(u32, 999), absCast(@as(i32, 999))); - testing.expectEqual(@as(u32, -minInt(i32)), absCast(@as(i32, minInt(i32)))); - testing.expectEqual(999, absCast(-999)); + try testing.expectEqual(@as(u1, 1), absCast(@as(i1, -1))); + try testing.expectEqual(@as(u32, 999), absCast(@as(i32, -999))); + try testing.expectEqual(@as(u32, 999), absCast(@as(i32, 999))); + try testing.expectEqual(@as(u32, -minInt(i32)), absCast(@as(i32, minInt(i32)))); + try testing.expectEqual(999, absCast(-999)); } /// Returns the negation of the integer parameter. @@ -904,13 +904,13 @@ pub fn negateCast(x: anytype) !std.meta.Int(.signed, std.meta.bitCount(@TypeOf(x } test "math.negateCast" { - testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999); - testing.expect(@TypeOf(negateCast(@as(u32, 999)) catch unreachable) == i32); + try testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999); + try testing.expect(@TypeOf(negateCast(@as(u32, 999)) catch unreachable) == i32); - testing.expect((negateCast(@as(u32, -minInt(i32))) catch unreachable) == minInt(i32)); - testing.expect(@TypeOf(negateCast(@as(u32, -minInt(i32))) catch unreachable) == i32); + try testing.expect((negateCast(@as(u32, -minInt(i32))) catch unreachable) == minInt(i32)); + try testing.expect(@TypeOf(negateCast(@as(u32, -minInt(i32))) catch unreachable) == i32); - testing.expectError(error.Overflow, negateCast(@as(u32, maxInt(i32) + 10))); + try testing.expectError(error.Overflow, negateCast(@as(u32, maxInt(i32) + 10))); } /// Cast an integer to a different integer type. If the value doesn't fit, @@ -929,13 +929,13 @@ pub fn cast(comptime T: type, x: anytype) (error{Overflow}!T) { } test "math.cast" { - testing.expectError(error.Overflow, cast(u8, @as(u32, 300))); - testing.expectError(error.Overflow, cast(i8, @as(i32, -200))); - testing.expectError(error.Overflow, cast(u8, @as(i8, -1))); - testing.expectError(error.Overflow, cast(u64, @as(i8, -1))); + try testing.expectError(error.Overflow, cast(u8, @as(u32, 300))); + try testing.expectError(error.Overflow, cast(i8, @as(i32, -200))); + try testing.expectError(error.Overflow, cast(u8, @as(i8, -1))); + try testing.expectError(error.Overflow, cast(u64, @as(i8, -1))); - testing.expect((try cast(u8, @as(u32, 255))) == @as(u8, 255)); - testing.expect(@TypeOf(try cast(u8, @as(u32, 255))) == u8); + try testing.expect((try cast(u8, @as(u32, 255))) == @as(u8, 255)); + try testing.expect(@TypeOf(try cast(u8, @as(u32, 255))) == u8); } pub const AlignCastError = error{UnalignedMemory}; @@ -966,17 +966,17 @@ pub fn floorPowerOfTwo(comptime T: type, value: T) T { } test "math.floorPowerOfTwo" { - testFloorPowerOfTwo(); - comptime testFloorPowerOfTwo(); + try testFloorPowerOfTwo(); + comptime try testFloorPowerOfTwo(); } -fn testFloorPowerOfTwo() void { - testing.expect(floorPowerOfTwo(u32, 63) == 32); - testing.expect(floorPowerOfTwo(u32, 64) == 64); - testing.expect(floorPowerOfTwo(u32, 65) == 64); - testing.expect(floorPowerOfTwo(u4, 7) == 4); - testing.expect(floorPowerOfTwo(u4, 8) == 8); - testing.expect(floorPowerOfTwo(u4, 9) == 8); +fn testFloorPowerOfTwo() !void { + try testing.expect(floorPowerOfTwo(u32, 63) == 32); + try testing.expect(floorPowerOfTwo(u32, 64) == 64); + try testing.expect(floorPowerOfTwo(u32, 65) == 64); + try testing.expect(floorPowerOfTwo(u4, 7) == 4); + try testing.expect(floorPowerOfTwo(u4, 8) == 8); + try testing.expect(floorPowerOfTwo(u4, 9) == 8); } /// Returns the next power of two (if the value is not already a power of two). @@ -1012,20 +1012,20 @@ pub fn ceilPowerOfTwoAssert(comptime T: type, value: T) T { } test "math.ceilPowerOfTwoPromote" { - testCeilPowerOfTwoPromote(); - comptime testCeilPowerOfTwoPromote(); + try testCeilPowerOfTwoPromote(); + comptime try testCeilPowerOfTwoPromote(); } -fn testCeilPowerOfTwoPromote() void { - testing.expectEqual(@as(u33, 1), ceilPowerOfTwoPromote(u32, 1)); - testing.expectEqual(@as(u33, 2), ceilPowerOfTwoPromote(u32, 2)); - testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 63)); - testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 64)); - testing.expectEqual(@as(u33, 128), ceilPowerOfTwoPromote(u32, 65)); - testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 7)); - testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 8)); - testing.expectEqual(@as(u6, 16), ceilPowerOfTwoPromote(u5, 9)); - testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9)); +fn testCeilPowerOfTwoPromote() !void { + try testing.expectEqual(@as(u33, 1), ceilPowerOfTwoPromote(u32, 1)); + try testing.expectEqual(@as(u33, 2), ceilPowerOfTwoPromote(u32, 2)); + try testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 63)); + try testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 64)); + try testing.expectEqual(@as(u33, 128), ceilPowerOfTwoPromote(u32, 65)); + try testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 7)); + try testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 8)); + try testing.expectEqual(@as(u6, 16), ceilPowerOfTwoPromote(u5, 9)); + try testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9)); } test "math.ceilPowerOfTwo" { @@ -1034,15 +1034,15 @@ test "math.ceilPowerOfTwo" { } fn testCeilPowerOfTwo() !void { - testing.expectEqual(@as(u32, 1), try ceilPowerOfTwo(u32, 1)); - testing.expectEqual(@as(u32, 2), try ceilPowerOfTwo(u32, 2)); - testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 63)); - testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 64)); - testing.expectEqual(@as(u32, 128), try ceilPowerOfTwo(u32, 65)); - testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 7)); - testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 8)); - testing.expectEqual(@as(u5, 16), try ceilPowerOfTwo(u5, 9)); - testing.expectError(error.Overflow, ceilPowerOfTwo(u4, 9)); + try testing.expectEqual(@as(u32, 1), try ceilPowerOfTwo(u32, 1)); + try testing.expectEqual(@as(u32, 2), try ceilPowerOfTwo(u32, 2)); + try testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 63)); + try testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 64)); + try testing.expectEqual(@as(u32, 128), try ceilPowerOfTwo(u32, 65)); + try testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 7)); + try testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 8)); + try testing.expectEqual(@as(u5, 16), try ceilPowerOfTwo(u5, 9)); + try testing.expectError(error.Overflow, ceilPowerOfTwo(u4, 9)); } pub fn log2_int(comptime T: type, x: T) Log2Int(T) { @@ -1059,16 +1059,16 @@ pub fn log2_int_ceil(comptime T: type, x: T) Log2Int(T) { } test "std.math.log2_int_ceil" { - testing.expect(log2_int_ceil(u32, 1) == 0); - testing.expect(log2_int_ceil(u32, 2) == 1); - testing.expect(log2_int_ceil(u32, 3) == 2); - testing.expect(log2_int_ceil(u32, 4) == 2); - testing.expect(log2_int_ceil(u32, 5) == 3); - testing.expect(log2_int_ceil(u32, 6) == 3); - testing.expect(log2_int_ceil(u32, 7) == 3); - testing.expect(log2_int_ceil(u32, 8) == 3); - testing.expect(log2_int_ceil(u32, 9) == 4); - testing.expect(log2_int_ceil(u32, 10) == 4); + try testing.expect(log2_int_ceil(u32, 1) == 0); + try testing.expect(log2_int_ceil(u32, 2) == 1); + try testing.expect(log2_int_ceil(u32, 3) == 2); + try testing.expect(log2_int_ceil(u32, 4) == 2); + try testing.expect(log2_int_ceil(u32, 5) == 3); + try testing.expect(log2_int_ceil(u32, 6) == 3); + try testing.expect(log2_int_ceil(u32, 7) == 3); + try testing.expect(log2_int_ceil(u32, 8) == 3); + try testing.expect(log2_int_ceil(u32, 9) == 4); + try testing.expect(log2_int_ceil(u32, 10) == 4); } ///Cast a value to a different type. If the value doesn't fit in, or can't be perfectly represented by, @@ -1112,15 +1112,15 @@ pub fn lossyCast(comptime T: type, value: anytype) T { } test "math.lossyCast" { - testing.expect(lossyCast(i16, 70000.0) == @as(i16, 32767)); - testing.expect(lossyCast(u32, @as(i16, -255)) == @as(u32, 0)); - testing.expect(lossyCast(i9, @as(u32, 200)) == @as(i9, 200)); + try testing.expect(lossyCast(i16, 70000.0) == @as(i16, 32767)); + try testing.expect(lossyCast(u32, @as(i16, -255)) == @as(u32, 0)); + try testing.expect(lossyCast(i9, @as(u32, 200)) == @as(i9, 200)); } test "math.f64_min" { const f64_min_u64 = 0x0010000000000000; const fmin: f64 = f64_min; - testing.expect(@bitCast(u64, fmin) == f64_min_u64); + try testing.expect(@bitCast(u64, fmin) == f64_min_u64); } pub fn maxInt(comptime T: type) comptime_int { @@ -1139,45 +1139,45 @@ pub fn minInt(comptime T: type) comptime_int { } test "minInt and maxInt" { - testing.expect(maxInt(u0) == 0); - testing.expect(maxInt(u1) == 1); - testing.expect(maxInt(u8) == 255); - testing.expect(maxInt(u16) == 65535); - testing.expect(maxInt(u32) == 4294967295); - testing.expect(maxInt(u64) == 18446744073709551615); - testing.expect(maxInt(u128) == 340282366920938463463374607431768211455); + try testing.expect(maxInt(u0) == 0); + try testing.expect(maxInt(u1) == 1); + try testing.expect(maxInt(u8) == 255); + try testing.expect(maxInt(u16) == 65535); + try testing.expect(maxInt(u32) == 4294967295); + try testing.expect(maxInt(u64) == 18446744073709551615); + try testing.expect(maxInt(u128) == 340282366920938463463374607431768211455); - testing.expect(maxInt(i0) == 0); - testing.expect(maxInt(i1) == 0); - testing.expect(maxInt(i8) == 127); - testing.expect(maxInt(i16) == 32767); - testing.expect(maxInt(i32) == 2147483647); - testing.expect(maxInt(i63) == 4611686018427387903); - testing.expect(maxInt(i64) == 9223372036854775807); - testing.expect(maxInt(i128) == 170141183460469231731687303715884105727); + try testing.expect(maxInt(i0) == 0); + try testing.expect(maxInt(i1) == 0); + try testing.expect(maxInt(i8) == 127); + try testing.expect(maxInt(i16) == 32767); + try testing.expect(maxInt(i32) == 2147483647); + try testing.expect(maxInt(i63) == 4611686018427387903); + try testing.expect(maxInt(i64) == 9223372036854775807); + try testing.expect(maxInt(i128) == 170141183460469231731687303715884105727); - testing.expect(minInt(u0) == 0); - testing.expect(minInt(u1) == 0); - testing.expect(minInt(u8) == 0); - testing.expect(minInt(u16) == 0); - testing.expect(minInt(u32) == 0); - testing.expect(minInt(u63) == 0); - testing.expect(minInt(u64) == 0); - testing.expect(minInt(u128) == 0); + try testing.expect(minInt(u0) == 0); + try testing.expect(minInt(u1) == 0); + try testing.expect(minInt(u8) == 0); + try testing.expect(minInt(u16) == 0); + try testing.expect(minInt(u32) == 0); + try testing.expect(minInt(u63) == 0); + try testing.expect(minInt(u64) == 0); + try testing.expect(minInt(u128) == 0); - testing.expect(minInt(i0) == 0); - testing.expect(minInt(i1) == -1); - testing.expect(minInt(i8) == -128); - testing.expect(minInt(i16) == -32768); - testing.expect(minInt(i32) == -2147483648); - testing.expect(minInt(i63) == -4611686018427387904); - testing.expect(minInt(i64) == -9223372036854775808); - testing.expect(minInt(i128) == -170141183460469231731687303715884105728); + try testing.expect(minInt(i0) == 0); + try testing.expect(minInt(i1) == -1); + try testing.expect(minInt(i8) == -128); + try testing.expect(minInt(i16) == -32768); + try testing.expect(minInt(i32) == -2147483648); + try testing.expect(minInt(i63) == -4611686018427387904); + try testing.expect(minInt(i64) == -9223372036854775808); + try testing.expect(minInt(i128) == -170141183460469231731687303715884105728); } test "max value type" { const x: u32 = maxInt(i32); - testing.expect(x == 2147483647); + try testing.expect(x == 2147483647); } pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(@typeInfo(T).Int.signedness, @typeInfo(T).Int.bits * 2) { @@ -1186,9 +1186,9 @@ pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(@typeInfo(T).Int.signe } test "math.mulWide" { - testing.expect(mulWide(u8, 5, 5) == 25); - testing.expect(mulWide(i8, 5, -5) == -25); - testing.expect(mulWide(u8, 100, 100) == 10000); + try testing.expect(mulWide(u8, 5, 5) == 25); + try testing.expect(mulWide(i8, 5, -5) == -25); + try testing.expect(mulWide(u8, 100, 100) == 10000); } /// See also `CompareOperator`. @@ -1284,51 +1284,51 @@ pub fn compare(a: anytype, op: CompareOperator, b: anytype) bool { } test "compare between signed and unsigned" { - testing.expect(compare(@as(i8, -1), .lt, @as(u8, 255))); - testing.expect(compare(@as(i8, 2), .gt, @as(u8, 1))); - testing.expect(!compare(@as(i8, -1), .gte, @as(u8, 255))); - testing.expect(compare(@as(u8, 255), .gt, @as(i8, -1))); - testing.expect(!compare(@as(u8, 255), .lte, @as(i8, -1))); - testing.expect(compare(@as(i8, -1), .lt, @as(u9, 255))); - testing.expect(!compare(@as(i8, -1), .gte, @as(u9, 255))); - testing.expect(compare(@as(u9, 255), .gt, @as(i8, -1))); - testing.expect(!compare(@as(u9, 255), .lte, @as(i8, -1))); - testing.expect(compare(@as(i9, -1), .lt, @as(u8, 255))); - testing.expect(!compare(@as(i9, -1), .gte, @as(u8, 255))); - testing.expect(compare(@as(u8, 255), .gt, @as(i9, -1))); - testing.expect(!compare(@as(u8, 255), .lte, @as(i9, -1))); - testing.expect(compare(@as(u8, 1), .lt, @as(u8, 2))); - testing.expect(@bitCast(u8, @as(i8, -1)) == @as(u8, 255)); - testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1))); - testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1))); + try testing.expect(compare(@as(i8, -1), .lt, @as(u8, 255))); + try testing.expect(compare(@as(i8, 2), .gt, @as(u8, 1))); + try testing.expect(!compare(@as(i8, -1), .gte, @as(u8, 255))); + try testing.expect(compare(@as(u8, 255), .gt, @as(i8, -1))); + try testing.expect(!compare(@as(u8, 255), .lte, @as(i8, -1))); + try testing.expect(compare(@as(i8, -1), .lt, @as(u9, 255))); + try testing.expect(!compare(@as(i8, -1), .gte, @as(u9, 255))); + try testing.expect(compare(@as(u9, 255), .gt, @as(i8, -1))); + try testing.expect(!compare(@as(u9, 255), .lte, @as(i8, -1))); + try testing.expect(compare(@as(i9, -1), .lt, @as(u8, 255))); + try testing.expect(!compare(@as(i9, -1), .gte, @as(u8, 255))); + try testing.expect(compare(@as(u8, 255), .gt, @as(i9, -1))); + try testing.expect(!compare(@as(u8, 255), .lte, @as(i9, -1))); + try testing.expect(compare(@as(u8, 1), .lt, @as(u8, 2))); + try testing.expect(@bitCast(u8, @as(i8, -1)) == @as(u8, 255)); + try testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1))); + try testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1))); } test "order" { - testing.expect(order(0, 0) == .eq); - testing.expect(order(1, 0) == .gt); - testing.expect(order(-1, 0) == .lt); + try testing.expect(order(0, 0) == .eq); + try testing.expect(order(1, 0) == .gt); + try testing.expect(order(-1, 0) == .lt); } test "order.invert" { - testing.expect(Order.invert(order(0, 0)) == .eq); - testing.expect(Order.invert(order(1, 0)) == .lt); - testing.expect(Order.invert(order(-1, 0)) == .gt); + try testing.expect(Order.invert(order(0, 0)) == .eq); + try testing.expect(Order.invert(order(1, 0)) == .lt); + try testing.expect(Order.invert(order(-1, 0)) == .gt); } test "order.compare" { - testing.expect(order(-1, 0).compare(.lt)); - testing.expect(order(-1, 0).compare(.lte)); - testing.expect(order(0, 0).compare(.lte)); - testing.expect(order(0, 0).compare(.eq)); - testing.expect(order(0, 0).compare(.gte)); - testing.expect(order(1, 0).compare(.gte)); - testing.expect(order(1, 0).compare(.gt)); - testing.expect(order(1, 0).compare(.neq)); + try testing.expect(order(-1, 0).compare(.lt)); + try testing.expect(order(-1, 0).compare(.lte)); + try testing.expect(order(0, 0).compare(.lte)); + try testing.expect(order(0, 0).compare(.eq)); + try testing.expect(order(0, 0).compare(.gte)); + try testing.expect(order(1, 0).compare(.gte)); + try testing.expect(order(1, 0).compare(.gt)); + try testing.expect(order(1, 0).compare(.neq)); } test "math.comptime" { comptime const v = sin(@as(f32, 1)) + ln(@as(f32, 5)); - testing.expect(v == sin(@as(f32, 1)) + ln(@as(f32, 5))); + try testing.expect(v == sin(@as(f32, 1)) + ln(@as(f32, 5))); } /// Returns a mask of all ones if value is true, @@ -1354,26 +1354,26 @@ pub fn boolMask(comptime MaskInt: type, value: bool) callconv(.Inline) MaskInt { test "boolMask" { const runTest = struct { - fn runTest() void { - testing.expectEqual(@as(u1, 0), boolMask(u1, false)); - testing.expectEqual(@as(u1, 1), boolMask(u1, true)); + fn runTest() !void { + try testing.expectEqual(@as(u1, 0), boolMask(u1, false)); + try testing.expectEqual(@as(u1, 1), boolMask(u1, true)); - testing.expectEqual(@as(i1, 0), boolMask(i1, false)); - testing.expectEqual(@as(i1, -1), boolMask(i1, true)); + try testing.expectEqual(@as(i1, 0), boolMask(i1, false)); + try testing.expectEqual(@as(i1, -1), boolMask(i1, true)); - testing.expectEqual(@as(u13, 0), boolMask(u13, false)); - testing.expectEqual(@as(u13, 0x1FFF), boolMask(u13, true)); + try testing.expectEqual(@as(u13, 0), boolMask(u13, false)); + try testing.expectEqual(@as(u13, 0x1FFF), boolMask(u13, true)); - testing.expectEqual(@as(i13, 0), boolMask(i13, false)); - testing.expectEqual(@as(i13, -1), boolMask(i13, true)); + try testing.expectEqual(@as(i13, 0), boolMask(i13, false)); + try testing.expectEqual(@as(i13, -1), boolMask(i13, true)); - testing.expectEqual(@as(u32, 0), boolMask(u32, false)); - testing.expectEqual(@as(u32, 0xFFFF_FFFF), boolMask(u32, true)); + try testing.expectEqual(@as(u32, 0), boolMask(u32, false)); + try testing.expectEqual(@as(u32, 0xFFFF_FFFF), boolMask(u32, true)); - testing.expectEqual(@as(i32, 0), boolMask(i32, false)); - testing.expectEqual(@as(i32, -1), boolMask(i32, true)); + try testing.expectEqual(@as(i32, 0), boolMask(i32, false)); + try testing.expectEqual(@as(i32, -1), boolMask(i32, true)); } }.runTest; - runTest(); - comptime runTest(); + try runTest(); + comptime try runTest(); } diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig index 7f3d4bfe9b..5e3a289691 100644 --- a/lib/std/math/acos.zig +++ b/lib/std/math/acos.zig @@ -154,38 +154,38 @@ fn acos64(x: f64) f64 { } test "math.acos" { - expect(acos(@as(f32, 0.0)) == acos32(0.0)); - expect(acos(@as(f64, 0.0)) == acos64(0.0)); + try expect(acos(@as(f32, 0.0)) == acos32(0.0)); + try expect(acos(@as(f64, 0.0)) == acos64(0.0)); } test "math.acos32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon)); - expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon)); - expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon)); - expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon)); - expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon)); - expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon)); + try expect(math.approxEqAbs(f32, acos32(0.0), 1.570796, epsilon)); + try expect(math.approxEqAbs(f32, acos32(0.2), 1.369438, epsilon)); + try expect(math.approxEqAbs(f32, acos32(0.3434), 1.220262, epsilon)); + try expect(math.approxEqAbs(f32, acos32(0.5), 1.047198, epsilon)); + try expect(math.approxEqAbs(f32, acos32(0.8923), 0.468382, epsilon)); + try expect(math.approxEqAbs(f32, acos32(-0.2), 1.772154, epsilon)); } test "math.acos64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon)); - expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon)); - expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon)); - expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon)); - expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon)); - expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon)); + try expect(math.approxEqAbs(f64, acos64(0.0), 1.570796, epsilon)); + try expect(math.approxEqAbs(f64, acos64(0.2), 1.369438, epsilon)); + try expect(math.approxEqAbs(f64, acos64(0.3434), 1.220262, epsilon)); + try expect(math.approxEqAbs(f64, acos64(0.5), 1.047198, epsilon)); + try expect(math.approxEqAbs(f64, acos64(0.8923), 0.468382, epsilon)); + try expect(math.approxEqAbs(f64, acos64(-0.2), 1.772154, epsilon)); } test "math.acos32.special" { - expect(math.isNan(acos32(-2))); - expect(math.isNan(acos32(1.5))); + try expect(math.isNan(acos32(-2))); + try expect(math.isNan(acos32(1.5))); } test "math.acos64.special" { - expect(math.isNan(acos64(-2))); - expect(math.isNan(acos64(1.5))); + try expect(math.isNan(acos64(-2))); + try expect(math.isNan(acos64(1.5))); } diff --git a/lib/std/math/acosh.zig b/lib/std/math/acosh.zig index 0993989d47..078e7f5e6e 100644 --- a/lib/std/math/acosh.zig +++ b/lib/std/math/acosh.zig @@ -66,34 +66,34 @@ fn acosh64(x: f64) f64 { } test "math.acosh" { - expect(acosh(@as(f32, 1.5)) == acosh32(1.5)); - expect(acosh(@as(f64, 1.5)) == acosh64(1.5)); + try expect(acosh(@as(f32, 1.5)) == acosh32(1.5)); + try expect(acosh(@as(f64, 1.5)) == acosh64(1.5)); } test "math.acosh32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon)); - expect(math.approxEqAbs(f32, acosh32(37.45), 4.315976, epsilon)); - expect(math.approxEqAbs(f32, acosh32(89.123), 5.183133, epsilon)); - expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon)); + try expect(math.approxEqAbs(f32, acosh32(1.5), 0.962424, epsilon)); + try expect(math.approxEqAbs(f32, acosh32(37.45), 4.315976, epsilon)); + try expect(math.approxEqAbs(f32, acosh32(89.123), 5.183133, epsilon)); + try expect(math.approxEqAbs(f32, acosh32(123123.234375), 12.414088, epsilon)); } test "math.acosh64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon)); - expect(math.approxEqAbs(f64, acosh64(37.45), 4.315976, epsilon)); - expect(math.approxEqAbs(f64, acosh64(89.123), 5.183133, epsilon)); - expect(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon)); + try expect(math.approxEqAbs(f64, acosh64(1.5), 0.962424, epsilon)); + try expect(math.approxEqAbs(f64, acosh64(37.45), 4.315976, epsilon)); + try expect(math.approxEqAbs(f64, acosh64(89.123), 5.183133, epsilon)); + try expect(math.approxEqAbs(f64, acosh64(123123.234375), 12.414088, epsilon)); } test "math.acosh32.special" { - expect(math.isNan(acosh32(math.nan(f32)))); - expect(math.isSignalNan(acosh32(0.5))); + try expect(math.isNan(acosh32(math.nan(f32)))); + try expect(math.isSignalNan(acosh32(0.5))); } test "math.acosh64.special" { - expect(math.isNan(acosh64(math.nan(f64)))); - expect(math.isSignalNan(acosh64(0.5))); + try expect(math.isNan(acosh64(math.nan(f64)))); + try expect(math.isSignalNan(acosh64(0.5))); } diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig index c4fca95c10..16560a12cd 100644 --- a/lib/std/math/asin.zig +++ b/lib/std/math/asin.zig @@ -147,42 +147,42 @@ fn asin64(x: f64) f64 { } test "math.asin" { - expect(asin(@as(f32, 0.0)) == asin32(0.0)); - expect(asin(@as(f64, 0.0)) == asin64(0.0)); + try expect(asin(@as(f32, 0.0)) == asin32(0.0)); + try expect(asin(@as(f64, 0.0)) == asin64(0.0)); } test "math.asin32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon)); - expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon)); - expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon)); - expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon)); - expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon)); + try expect(math.approxEqAbs(f32, asin32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, asin32(0.2), 0.201358, epsilon)); + try expect(math.approxEqAbs(f32, asin32(-0.2), -0.201358, epsilon)); + try expect(math.approxEqAbs(f32, asin32(0.3434), 0.350535, epsilon)); + try expect(math.approxEqAbs(f32, asin32(0.5), 0.523599, epsilon)); + try expect(math.approxEqAbs(f32, asin32(0.8923), 1.102415, epsilon)); } test "math.asin64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon)); - expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon)); - expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon)); - expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon)); - expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon)); + try expect(math.approxEqAbs(f64, asin64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, asin64(0.2), 0.201358, epsilon)); + try expect(math.approxEqAbs(f64, asin64(-0.2), -0.201358, epsilon)); + try expect(math.approxEqAbs(f64, asin64(0.3434), 0.350535, epsilon)); + try expect(math.approxEqAbs(f64, asin64(0.5), 0.523599, epsilon)); + try expect(math.approxEqAbs(f64, asin64(0.8923), 1.102415, epsilon)); } test "math.asin32.special" { - expect(asin32(0.0) == 0.0); - expect(asin32(-0.0) == -0.0); - expect(math.isNan(asin32(-2))); - expect(math.isNan(asin32(1.5))); + try expect(asin32(0.0) == 0.0); + try expect(asin32(-0.0) == -0.0); + try expect(math.isNan(asin32(-2))); + try expect(math.isNan(asin32(1.5))); } test "math.asin64.special" { - expect(asin64(0.0) == 0.0); - expect(asin64(-0.0) == -0.0); - expect(math.isNan(asin64(-2))); - expect(math.isNan(asin64(1.5))); + try expect(asin64(0.0) == 0.0); + try expect(asin64(-0.0) == -0.0); + try expect(math.isNan(asin64(-2))); + try expect(math.isNan(asin64(1.5))); } diff --git a/lib/std/math/asinh.zig b/lib/std/math/asinh.zig index a2c8ee3583..2855a73eb8 100644 --- a/lib/std/math/asinh.zig +++ b/lib/std/math/asinh.zig @@ -94,46 +94,46 @@ fn asinh64(x: f64) f64 { } test "math.asinh" { - expect(asinh(@as(f32, 0.0)) == asinh32(0.0)); - expect(asinh(@as(f64, 0.0)) == asinh64(0.0)); + try expect(asinh(@as(f32, 0.0)) == asinh32(0.0)); + try expect(asinh(@as(f64, 0.0)) == asinh64(0.0)); } test "math.asinh32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, asinh32(0.2), 0.198690, epsilon)); - expect(math.approxEqAbs(f32, asinh32(0.8923), 0.803133, epsilon)); - expect(math.approxEqAbs(f32, asinh32(1.5), 1.194763, epsilon)); - expect(math.approxEqAbs(f32, asinh32(37.45), 4.316332, epsilon)); - expect(math.approxEqAbs(f32, asinh32(89.123), 5.183196, epsilon)); - expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(0.2), 0.198690, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(0.8923), 0.803133, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(1.5), 1.194763, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(37.45), 4.316332, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(89.123), 5.183196, epsilon)); + try expect(math.approxEqAbs(f32, asinh32(123123.234375), 12.414088, epsilon)); } test "math.asinh64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, asinh64(0.2), 0.198690, epsilon)); - expect(math.approxEqAbs(f64, asinh64(0.8923), 0.803133, epsilon)); - expect(math.approxEqAbs(f64, asinh64(1.5), 1.194763, epsilon)); - expect(math.approxEqAbs(f64, asinh64(37.45), 4.316332, epsilon)); - expect(math.approxEqAbs(f64, asinh64(89.123), 5.183196, epsilon)); - expect(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(0.2), 0.198690, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(0.8923), 0.803133, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(1.5), 1.194763, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(37.45), 4.316332, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(89.123), 5.183196, epsilon)); + try expect(math.approxEqAbs(f64, asinh64(123123.234375), 12.414088, epsilon)); } test "math.asinh32.special" { - expect(asinh32(0.0) == 0.0); - expect(asinh32(-0.0) == -0.0); - expect(math.isPositiveInf(asinh32(math.inf(f32)))); - expect(math.isNegativeInf(asinh32(-math.inf(f32)))); - expect(math.isNan(asinh32(math.nan(f32)))); + try expect(asinh32(0.0) == 0.0); + try expect(asinh32(-0.0) == -0.0); + try expect(math.isPositiveInf(asinh32(math.inf(f32)))); + try expect(math.isNegativeInf(asinh32(-math.inf(f32)))); + try expect(math.isNan(asinh32(math.nan(f32)))); } test "math.asinh64.special" { - expect(asinh64(0.0) == 0.0); - expect(asinh64(-0.0) == -0.0); - expect(math.isPositiveInf(asinh64(math.inf(f64)))); - expect(math.isNegativeInf(asinh64(-math.inf(f64)))); - expect(math.isNan(asinh64(math.nan(f64)))); + try expect(asinh64(0.0) == 0.0); + try expect(asinh64(-0.0) == -0.0); + try expect(math.isPositiveInf(asinh64(math.inf(f64)))); + try expect(math.isNegativeInf(asinh64(-math.inf(f64)))); + try expect(math.isNan(asinh64(math.nan(f64)))); } diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig index 59dda307cc..bbfaa22b13 100644 --- a/lib/std/math/atan.zig +++ b/lib/std/math/atan.zig @@ -217,44 +217,44 @@ fn atan64(x_: f64) f64 { } test "math.atan" { - expect(@bitCast(u32, atan(@as(f32, 0.2))) == @bitCast(u32, atan32(0.2))); - expect(atan(@as(f64, 0.2)) == atan64(0.2)); + try expect(@bitCast(u32, atan(@as(f32, 0.2))) == @bitCast(u32, atan32(0.2))); + try expect(atan(@as(f64, 0.2)) == atan64(0.2)); } test "math.atan32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon)); - expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon)); - expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon)); - expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon)); - expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon)); + try expect(math.approxEqAbs(f32, atan32(0.2), 0.197396, epsilon)); + try expect(math.approxEqAbs(f32, atan32(-0.2), -0.197396, epsilon)); + try expect(math.approxEqAbs(f32, atan32(0.3434), 0.330783, epsilon)); + try expect(math.approxEqAbs(f32, atan32(0.8923), 0.728545, epsilon)); + try expect(math.approxEqAbs(f32, atan32(1.5), 0.982794, epsilon)); } test "math.atan64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon)); - expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon)); - expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon)); - expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon)); - expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon)); + try expect(math.approxEqAbs(f64, atan64(0.2), 0.197396, epsilon)); + try expect(math.approxEqAbs(f64, atan64(-0.2), -0.197396, epsilon)); + try expect(math.approxEqAbs(f64, atan64(0.3434), 0.330783, epsilon)); + try expect(math.approxEqAbs(f64, atan64(0.8923), 0.728545, epsilon)); + try expect(math.approxEqAbs(f64, atan64(1.5), 0.982794, epsilon)); } test "math.atan32.special" { const epsilon = 0.000001; - expect(atan32(0.0) == 0.0); - expect(atan32(-0.0) == -0.0); - expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon)); + try expect(atan32(0.0) == 0.0); + try expect(atan32(-0.0) == -0.0); + try expect(math.approxEqAbs(f32, atan32(math.inf(f32)), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan32(-math.inf(f32)), -math.pi / 2.0, epsilon)); } test "math.atan64.special" { const epsilon = 0.000001; - expect(atan64(0.0) == 0.0); - expect(atan64(-0.0) == -0.0); - expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon)); + try expect(atan64(0.0) == 0.0); + try expect(atan64(-0.0) == -0.0); + try expect(math.approxEqAbs(f64, atan64(math.inf(f64)), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan64(-math.inf(f64)), -math.pi / 2.0, epsilon)); } diff --git a/lib/std/math/atan2.zig b/lib/std/math/atan2.zig index 3ecabe9e31..21f6b95b8b 100644 --- a/lib/std/math/atan2.zig +++ b/lib/std/math/atan2.zig @@ -217,78 +217,78 @@ fn atan2_64(y: f64, x: f64) f64 { } test "math.atan2" { - expect(atan2(f32, 0.2, 0.21) == atan2_32(0.2, 0.21)); - expect(atan2(f64, 0.2, 0.21) == atan2_64(0.2, 0.21)); + try expect(atan2(f32, 0.2, 0.21) == atan2_32(0.2, 0.21)); + try expect(atan2(f64, 0.2, 0.21) == atan2_64(0.2, 0.21)); } test "math.atan2_32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(0.2, 0.2), 0.785398, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(0.2, -0.2), 2.356194, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(0.34, -0.4), 2.437099, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(0.0, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(0.2, 0.2), 0.785398, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-0.2, 0.2), -0.785398, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(0.2, -0.2), 2.356194, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-0.2, -0.2), -2.356194, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(0.34, -0.4), 2.437099, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(0.34, 1.243), 0.267001, epsilon)); } test "math.atan2_64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(0.2, 0.2), 0.785398, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(0.2, -0.2), 2.356194, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(0.34, -0.4), 2.437099, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(0.0, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(0.2, 0.2), 0.785398, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-0.2, 0.2), -0.785398, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(0.2, -0.2), 2.356194, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-0.2, -0.2), -2.356194, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(0.34, -0.4), 2.437099, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(0.34, 1.243), 0.267001, epsilon)); } test "math.atan2_32.special" { const epsilon = 0.000001; - expect(math.isNan(atan2_32(1.0, math.nan(f32)))); - expect(math.isNan(atan2_32(math.nan(f32), 1.0))); - expect(atan2_32(0.0, 5.0) == 0.0); - expect(atan2_32(-0.0, 5.0) == -0.0); - expect(math.approxEqAbs(f32, atan2_32(0.0, -5.0), math.pi, epsilon)); + try expect(math.isNan(atan2_32(1.0, math.nan(f32)))); + try expect(math.isNan(atan2_32(math.nan(f32), 1.0))); + try expect(atan2_32(0.0, 5.0) == 0.0); + try expect(atan2_32(-0.0, 5.0) == -0.0); + try expect(math.approxEqAbs(f32, atan2_32(0.0, -5.0), math.pi, epsilon)); //expect(math.approxEqAbs(f32, atan2_32(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero? - expect(math.approxEqAbs(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon)); - expect(atan2_32(1.0, math.inf(f32)) == 0.0); - expect(math.approxEqAbs(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-1.0, -0.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), math.inf(f32)), math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), math.inf(f32)), -math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), -math.inf(f32)), 3.0 * math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), -math.inf(f32)), -3.0 * math.pi / 4.0, epsilon)); + try expect(atan2_32(1.0, math.inf(f32)) == 0.0); + try expect(math.approxEqAbs(f32, atan2_32(1.0, -math.inf(f32)), math.pi, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-1.0, -math.inf(f32)), -math.pi, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(math.inf(f32), 1.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f32, atan2_32(-math.inf(f32), 1.0), -math.pi / 2.0, epsilon)); } test "math.atan2_64.special" { const epsilon = 0.000001; - expect(math.isNan(atan2_64(1.0, math.nan(f64)))); - expect(math.isNan(atan2_64(math.nan(f64), 1.0))); - expect(atan2_64(0.0, 5.0) == 0.0); - expect(atan2_64(-0.0, 5.0) == -0.0); - expect(math.approxEqAbs(f64, atan2_64(0.0, -5.0), math.pi, epsilon)); + try expect(math.isNan(atan2_64(1.0, math.nan(f64)))); + try expect(math.isNan(atan2_64(math.nan(f64), 1.0))); + try expect(atan2_64(0.0, 5.0) == 0.0); + try expect(atan2_64(-0.0, 5.0) == -0.0); + try expect(math.approxEqAbs(f64, atan2_64(0.0, -5.0), math.pi, epsilon)); //expect(math.approxEqAbs(f64, atan2_64(-0.0, -5.0), -math.pi, .{.rel=0,.abs=epsilon})); TODO support negative zero? - expect(math.approxEqAbs(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon)); - expect(atan2_64(1.0, math.inf(f64)) == 0.0); - expect(math.approxEqAbs(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon)); - expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-1.0, -0.0), -math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), math.inf(f64)), math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), math.inf(f64)), -math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), -math.inf(f64)), 3.0 * math.pi / 4.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), -math.inf(f64)), -3.0 * math.pi / 4.0, epsilon)); + try expect(atan2_64(1.0, math.inf(f64)) == 0.0); + try expect(math.approxEqAbs(f64, atan2_64(1.0, -math.inf(f64)), math.pi, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-1.0, -math.inf(f64)), -math.pi, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(math.inf(f64), 1.0), math.pi / 2.0, epsilon)); + try expect(math.approxEqAbs(f64, atan2_64(-math.inf(f64), 1.0), -math.pi / 2.0, epsilon)); } diff --git a/lib/std/math/atanh.zig b/lib/std/math/atanh.zig index 87d92a9fa5..68824cea7a 100644 --- a/lib/std/math/atanh.zig +++ b/lib/std/math/atanh.zig @@ -89,38 +89,38 @@ fn atanh_64(x: f64) f64 { } test "math.atanh" { - expect(atanh(@as(f32, 0.0)) == atanh_32(0.0)); - expect(atanh(@as(f64, 0.0)) == atanh_64(0.0)); + try expect(atanh(@as(f32, 0.0)) == atanh_32(0.0)); + try expect(atanh(@as(f64, 0.0)) == atanh_64(0.0)); } test "math.atanh_32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, atanh_32(0.2), 0.202733, epsilon)); - expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon)); + try expect(math.approxEqAbs(f32, atanh_32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, atanh_32(0.2), 0.202733, epsilon)); + try expect(math.approxEqAbs(f32, atanh_32(0.8923), 1.433099, epsilon)); } test "math.atanh_64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, atanh_64(0.2), 0.202733, epsilon)); - expect(math.approxEqAbs(f64, atanh_64(0.8923), 1.433099, epsilon)); + try expect(math.approxEqAbs(f64, atanh_64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, atanh_64(0.2), 0.202733, epsilon)); + try expect(math.approxEqAbs(f64, atanh_64(0.8923), 1.433099, epsilon)); } test "math.atanh32.special" { - expect(math.isPositiveInf(atanh_32(1))); - expect(math.isNegativeInf(atanh_32(-1))); - expect(math.isSignalNan(atanh_32(1.5))); - expect(math.isSignalNan(atanh_32(-1.5))); - expect(math.isNan(atanh_32(math.nan(f32)))); + try expect(math.isPositiveInf(atanh_32(1))); + try expect(math.isNegativeInf(atanh_32(-1))); + try expect(math.isSignalNan(atanh_32(1.5))); + try expect(math.isSignalNan(atanh_32(-1.5))); + try expect(math.isNan(atanh_32(math.nan(f32)))); } test "math.atanh64.special" { - expect(math.isPositiveInf(atanh_64(1))); - expect(math.isNegativeInf(atanh_64(-1))); - expect(math.isSignalNan(atanh_64(1.5))); - expect(math.isSignalNan(atanh_64(-1.5))); - expect(math.isNan(atanh_64(math.nan(f64)))); + try expect(math.isPositiveInf(atanh_64(1))); + try expect(math.isNegativeInf(atanh_64(-1))); + try expect(math.isSignalNan(atanh_64(1.5))); + try expect(math.isSignalNan(atanh_64(-1.5))); + try expect(math.isNan(atanh_64(math.nan(f64)))); } diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig index 179e55ff69..93291bf217 100644 --- a/lib/std/math/big/int_test.zig +++ b/lib/std/math/big/int_test.zig @@ -30,7 +30,7 @@ test "big.int comptime_int set" { const result = @as(Limb, s & maxInt(Limb)); s >>= @typeInfo(Limb).Int.bits / 2; s >>= @typeInfo(Limb).Int.bits / 2; - testing.expect(a.limbs[i] == result); + try testing.expect(a.limbs[i] == result); } } @@ -38,37 +38,37 @@ test "big.int comptime_int set negative" { var a = try Managed.initSet(testing.allocator, -10); defer a.deinit(); - testing.expect(a.limbs[0] == 10); - testing.expect(a.isPositive() == false); + try testing.expect(a.limbs[0] == 10); + try testing.expect(a.isPositive() == false); } test "big.int int set unaligned small" { var a = try Managed.initSet(testing.allocator, @as(u7, 45)); defer a.deinit(); - testing.expect(a.limbs[0] == 45); - testing.expect(a.isPositive() == true); + try testing.expect(a.limbs[0] == 45); + try testing.expect(a.isPositive() == true); } test "big.int comptime_int to" { var a = try Managed.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab); defer a.deinit(); - testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab); + try testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab); } test "big.int sub-limb to" { var a = try Managed.initSet(testing.allocator, 10); defer a.deinit(); - testing.expect((try a.to(u8)) == 10); + try testing.expect((try a.to(u8)) == 10); } test "big.int to target too small error" { var a = try Managed.initSet(testing.allocator, 0xffffffff); defer a.deinit(); - testing.expectError(error.TargetTooSmall, a.to(u8)); + try testing.expectError(error.TargetTooSmall, a.to(u8)); } test "big.int normalize" { @@ -81,22 +81,22 @@ test "big.int normalize" { a.limbs[2] = 3; a.limbs[3] = 0; a.normalize(4); - testing.expect(a.len() == 3); + try testing.expect(a.len() == 3); a.limbs[0] = 1; a.limbs[1] = 2; a.limbs[2] = 3; a.normalize(3); - testing.expect(a.len() == 3); + try testing.expect(a.len() == 3); a.limbs[0] = 0; a.limbs[1] = 0; a.normalize(2); - testing.expect(a.len() == 1); + try testing.expect(a.len() == 1); a.limbs[0] = 0; a.normalize(1); - testing.expect(a.len() == 1); + try testing.expect(a.len() == 1); } test "big.int normalize multi" { @@ -109,24 +109,24 @@ test "big.int normalize multi" { a.limbs[2] = 0; a.limbs[3] = 0; a.normalize(4); - testing.expect(a.len() == 2); + try testing.expect(a.len() == 2); a.limbs[0] = 1; a.limbs[1] = 2; a.limbs[2] = 3; a.normalize(3); - testing.expect(a.len() == 3); + try testing.expect(a.len() == 3); a.limbs[0] = 0; a.limbs[1] = 0; a.limbs[2] = 0; a.limbs[3] = 0; a.normalize(4); - testing.expect(a.len() == 1); + try testing.expect(a.len() == 1); a.limbs[0] = 0; a.normalize(1); - testing.expect(a.len() == 1); + try testing.expect(a.len() == 1); } test "big.int parity" { @@ -134,12 +134,12 @@ test "big.int parity" { defer a.deinit(); try a.set(0); - testing.expect(a.isEven()); - testing.expect(!a.isOdd()); + try testing.expect(a.isEven()); + try testing.expect(!a.isOdd()); try a.set(7); - testing.expect(!a.isEven()); - testing.expect(a.isOdd()); + try testing.expect(!a.isEven()); + try testing.expect(a.isOdd()); } test "big.int bitcount + sizeInBaseUpperBound" { @@ -147,27 +147,27 @@ test "big.int bitcount + sizeInBaseUpperBound" { defer a.deinit(); try a.set(0b100); - testing.expect(a.bitCountAbs() == 3); - testing.expect(a.sizeInBaseUpperBound(2) >= 3); - testing.expect(a.sizeInBaseUpperBound(10) >= 1); + try testing.expect(a.bitCountAbs() == 3); + try testing.expect(a.sizeInBaseUpperBound(2) >= 3); + try testing.expect(a.sizeInBaseUpperBound(10) >= 1); a.negate(); - testing.expect(a.bitCountAbs() == 3); - testing.expect(a.sizeInBaseUpperBound(2) >= 4); - testing.expect(a.sizeInBaseUpperBound(10) >= 2); + try testing.expect(a.bitCountAbs() == 3); + try testing.expect(a.sizeInBaseUpperBound(2) >= 4); + try testing.expect(a.sizeInBaseUpperBound(10) >= 2); try a.set(0xffffffff); - testing.expect(a.bitCountAbs() == 32); - testing.expect(a.sizeInBaseUpperBound(2) >= 32); - testing.expect(a.sizeInBaseUpperBound(10) >= 10); + try testing.expect(a.bitCountAbs() == 32); + try testing.expect(a.sizeInBaseUpperBound(2) >= 32); + try testing.expect(a.sizeInBaseUpperBound(10) >= 10); try a.shiftLeft(a, 5000); - testing.expect(a.bitCountAbs() == 5032); - testing.expect(a.sizeInBaseUpperBound(2) >= 5032); + try testing.expect(a.bitCountAbs() == 5032); + try testing.expect(a.sizeInBaseUpperBound(2) >= 5032); a.setSign(false); - testing.expect(a.bitCountAbs() == 5032); - testing.expect(a.sizeInBaseUpperBound(2) >= 5033); + try testing.expect(a.bitCountAbs() == 5032); + try testing.expect(a.sizeInBaseUpperBound(2) >= 5033); } test "big.int bitcount/to" { @@ -175,30 +175,30 @@ test "big.int bitcount/to" { defer a.deinit(); try a.set(0); - testing.expect(a.bitCountTwosComp() == 0); + try testing.expect(a.bitCountTwosComp() == 0); - testing.expect((try a.to(u0)) == 0); - testing.expect((try a.to(i0)) == 0); + try testing.expect((try a.to(u0)) == 0); + try testing.expect((try a.to(i0)) == 0); try a.set(-1); - testing.expect(a.bitCountTwosComp() == 1); - testing.expect((try a.to(i1)) == -1); + try testing.expect(a.bitCountTwosComp() == 1); + try testing.expect((try a.to(i1)) == -1); try a.set(-8); - testing.expect(a.bitCountTwosComp() == 4); - testing.expect((try a.to(i4)) == -8); + try testing.expect(a.bitCountTwosComp() == 4); + try testing.expect((try a.to(i4)) == -8); try a.set(127); - testing.expect(a.bitCountTwosComp() == 7); - testing.expect((try a.to(u7)) == 127); + try testing.expect(a.bitCountTwosComp() == 7); + try testing.expect((try a.to(u7)) == 127); try a.set(-128); - testing.expect(a.bitCountTwosComp() == 8); - testing.expect((try a.to(i8)) == -128); + try testing.expect(a.bitCountTwosComp() == 8); + try testing.expect((try a.to(i8)) == -128); try a.set(-129); - testing.expect(a.bitCountTwosComp() == 9); - testing.expect((try a.to(i9)) == -129); + try testing.expect(a.bitCountTwosComp() == 9); + try testing.expect((try a.to(i9)) == -129); } test "big.int fits" { @@ -206,27 +206,27 @@ test "big.int fits" { defer a.deinit(); try a.set(0); - testing.expect(a.fits(u0)); - testing.expect(a.fits(i0)); + try testing.expect(a.fits(u0)); + try testing.expect(a.fits(i0)); try a.set(255); - testing.expect(!a.fits(u0)); - testing.expect(!a.fits(u1)); - testing.expect(!a.fits(i8)); - testing.expect(a.fits(u8)); - testing.expect(a.fits(u9)); - testing.expect(a.fits(i9)); + try testing.expect(!a.fits(u0)); + try testing.expect(!a.fits(u1)); + try testing.expect(!a.fits(i8)); + try testing.expect(a.fits(u8)); + try testing.expect(a.fits(u9)); + try testing.expect(a.fits(i9)); try a.set(-128); - testing.expect(!a.fits(i7)); - testing.expect(a.fits(i8)); - testing.expect(a.fits(i9)); - testing.expect(!a.fits(u9)); + try testing.expect(!a.fits(i7)); + try testing.expect(a.fits(i8)); + try testing.expect(a.fits(i9)); + try testing.expect(!a.fits(u9)); try a.set(0x1ffffffffeeeeeeee); - testing.expect(!a.fits(u32)); - testing.expect(!a.fits(u64)); - testing.expect(a.fits(u65)); + try testing.expect(!a.fits(u32)); + try testing.expect(!a.fits(u64)); + try testing.expect(a.fits(u65)); } test "big.int string set" { @@ -234,7 +234,7 @@ test "big.int string set" { defer a.deinit(); try a.setString(10, "120317241209124781241290847124"); - testing.expect((try a.to(u128)) == 120317241209124781241290847124); + try testing.expect((try a.to(u128)) == 120317241209124781241290847124); } test "big.int string negative" { @@ -242,7 +242,7 @@ test "big.int string negative" { defer a.deinit(); try a.setString(10, "-1023"); - testing.expect((try a.to(i32)) == -1023); + try testing.expect((try a.to(i32)) == -1023); } test "big.int string set number with underscores" { @@ -250,7 +250,7 @@ test "big.int string set number with underscores" { defer a.deinit(); try a.setString(10, "__1_2_0_3_1_7_2_4_1_2_0_____9_1__2__4_7_8_1_2_4_1_2_9_0_8_4_7_1_2_4___"); - testing.expect((try a.to(u128)) == 120317241209124781241290847124); + try testing.expect((try a.to(u128)) == 120317241209124781241290847124); } test "big.int string set case insensitive number" { @@ -258,19 +258,19 @@ test "big.int string set case insensitive number" { defer a.deinit(); try a.setString(16, "aB_cD_eF"); - testing.expect((try a.to(u32)) == 0xabcdef); + try testing.expect((try a.to(u32)) == 0xabcdef); } test "big.int string set bad char error" { var a = try Managed.init(testing.allocator); defer a.deinit(); - testing.expectError(error.InvalidCharacter, a.setString(10, "x")); + try testing.expectError(error.InvalidCharacter, a.setString(10, "x")); } test "big.int string set bad base error" { var a = try Managed.init(testing.allocator); defer a.deinit(); - testing.expectError(error.InvalidBase, a.setString(45, "10")); + try testing.expectError(error.InvalidBase, a.setString(45, "10")); } test "big.int string to" { @@ -281,14 +281,14 @@ test "big.int string to" { defer testing.allocator.free(as); const es = "120317241209124781241290847124"; - testing.expect(mem.eql(u8, as, es)); + try testing.expect(mem.eql(u8, as, es)); } test "big.int string to base base error" { var a = try Managed.initSet(testing.allocator, 0xffffffff); defer a.deinit(); - testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45, false)); + try testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45, false)); } test "big.int string to base 2" { @@ -299,7 +299,7 @@ test "big.int string to base 2" { defer testing.allocator.free(as); const es = "-1011"; - testing.expect(mem.eql(u8, as, es)); + try testing.expect(mem.eql(u8, as, es)); } test "big.int string to base 16" { @@ -310,7 +310,7 @@ test "big.int string to base 16" { defer testing.allocator.free(as); const es = "efffffff00000001eeeeeeefaaaaaaab"; - testing.expect(mem.eql(u8, as, es)); + try testing.expect(mem.eql(u8, as, es)); } test "big.int neg string to" { @@ -321,7 +321,7 @@ test "big.int neg string to" { defer testing.allocator.free(as); const es = "-123907434"; - testing.expect(mem.eql(u8, as, es)); + try testing.expect(mem.eql(u8, as, es)); } test "big.int zero string to" { @@ -332,7 +332,7 @@ test "big.int zero string to" { defer testing.allocator.free(as); const es = "0"; - testing.expect(mem.eql(u8, as, es)); + try testing.expect(mem.eql(u8, as, es)); } test "big.int clone" { @@ -341,12 +341,12 @@ test "big.int clone" { var b = try a.clone(); defer b.deinit(); - testing.expect((try a.to(u32)) == 1234); - testing.expect((try b.to(u32)) == 1234); + try testing.expect((try a.to(u32)) == 1234); + try testing.expect((try b.to(u32)) == 1234); try a.set(77); - testing.expect((try a.to(u32)) == 77); - testing.expect((try b.to(u32)) == 1234); + try testing.expect((try a.to(u32)) == 77); + try testing.expect((try b.to(u32)) == 1234); } test "big.int swap" { @@ -355,20 +355,20 @@ test "big.int swap" { var b = try Managed.initSet(testing.allocator, 5678); defer b.deinit(); - testing.expect((try a.to(u32)) == 1234); - testing.expect((try b.to(u32)) == 5678); + try testing.expect((try a.to(u32)) == 1234); + try testing.expect((try b.to(u32)) == 5678); a.swap(&b); - testing.expect((try a.to(u32)) == 5678); - testing.expect((try b.to(u32)) == 1234); + try testing.expect((try a.to(u32)) == 5678); + try testing.expect((try b.to(u32)) == 1234); } test "big.int to negative" { var a = try Managed.initSet(testing.allocator, -10); defer a.deinit(); - testing.expect((try a.to(i32)) == -10); + try testing.expect((try a.to(i32)) == -10); } test "big.int compare" { @@ -377,8 +377,8 @@ test "big.int compare" { var b = try Managed.initSet(testing.allocator, 10); defer b.deinit(); - testing.expect(a.orderAbs(b) == .gt); - testing.expect(a.order(b) == .lt); + try testing.expect(a.orderAbs(b) == .gt); + try testing.expect(a.order(b) == .lt); } test "big.int compare similar" { @@ -387,8 +387,8 @@ test "big.int compare similar" { var b = try Managed.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef); defer b.deinit(); - testing.expect(a.orderAbs(b) == .lt); - testing.expect(b.orderAbs(a) == .gt); + try testing.expect(a.orderAbs(b) == .lt); + try testing.expect(b.orderAbs(a) == .gt); } test "big.int compare different limb size" { @@ -397,8 +397,8 @@ test "big.int compare different limb size" { var b = try Managed.initSet(testing.allocator, 1); defer b.deinit(); - testing.expect(a.orderAbs(b) == .gt); - testing.expect(b.orderAbs(a) == .lt); + try testing.expect(a.orderAbs(b) == .gt); + try testing.expect(b.orderAbs(a) == .lt); } test "big.int compare multi-limb" { @@ -407,8 +407,8 @@ test "big.int compare multi-limb" { var b = try Managed.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee); defer b.deinit(); - testing.expect(a.orderAbs(b) == .gt); - testing.expect(a.order(b) == .lt); + try testing.expect(a.orderAbs(b) == .gt); + try testing.expect(a.order(b) == .lt); } test "big.int equality" { @@ -417,8 +417,8 @@ test "big.int equality" { var b = try Managed.initSet(testing.allocator, -0xffffffff1); defer b.deinit(); - testing.expect(a.eqAbs(b)); - testing.expect(!a.eq(b)); + try testing.expect(a.eqAbs(b)); + try testing.expect(!a.eq(b)); } test "big.int abs" { @@ -426,10 +426,10 @@ test "big.int abs" { defer a.deinit(); a.abs(); - testing.expect((try a.to(u32)) == 5); + try testing.expect((try a.to(u32)) == 5); a.abs(); - testing.expect((try a.to(u32)) == 5); + try testing.expect((try a.to(u32)) == 5); } test "big.int negate" { @@ -437,10 +437,10 @@ test "big.int negate" { defer a.deinit(); a.negate(); - testing.expect((try a.to(i32)) == -5); + try testing.expect((try a.to(i32)) == -5); a.negate(); - testing.expect((try a.to(i32)) == 5); + try testing.expect((try a.to(i32)) == 5); } test "big.int add single-single" { @@ -453,7 +453,7 @@ test "big.int add single-single" { defer c.deinit(); try c.add(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 55); + try testing.expect((try c.to(u32)) == 55); } test "big.int add multi-single" { @@ -466,10 +466,10 @@ test "big.int add multi-single" { defer c.deinit(); try c.add(a.toConst(), b.toConst()); - testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); + try testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); try c.add(b.toConst(), a.toConst()); - testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); + try testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); } test "big.int add multi-multi" { @@ -484,7 +484,7 @@ test "big.int add multi-multi" { defer c.deinit(); try c.add(a.toConst(), b.toConst()); - testing.expect((try c.to(u128)) == op1 + op2); + try testing.expect((try c.to(u128)) == op1 + op2); } test "big.int add zero-zero" { @@ -497,7 +497,7 @@ test "big.int add zero-zero" { defer c.deinit(); try c.add(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 0); + try testing.expect((try c.to(u32)) == 0); } test "big.int add alias multi-limb nonzero-zero" { @@ -509,7 +509,7 @@ test "big.int add alias multi-limb nonzero-zero" { try a.add(a.toConst(), b.toConst()); - testing.expect((try a.to(u128)) == op1); + try testing.expect((try a.to(u128)) == op1); } test "big.int add sign" { @@ -526,16 +526,16 @@ test "big.int add sign" { defer neg_two.deinit(); try a.add(one.toConst(), two.toConst()); - testing.expect((try a.to(i32)) == 3); + try testing.expect((try a.to(i32)) == 3); try a.add(neg_one.toConst(), two.toConst()); - testing.expect((try a.to(i32)) == 1); + try testing.expect((try a.to(i32)) == 1); try a.add(one.toConst(), neg_two.toConst()); - testing.expect((try a.to(i32)) == -1); + try testing.expect((try a.to(i32)) == -1); try a.add(neg_one.toConst(), neg_two.toConst()); - testing.expect((try a.to(i32)) == -3); + try testing.expect((try a.to(i32)) == -3); } test "big.int sub single-single" { @@ -548,7 +548,7 @@ test "big.int sub single-single" { defer c.deinit(); try c.sub(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 45); + try testing.expect((try c.to(u32)) == 45); } test "big.int sub multi-single" { @@ -561,7 +561,7 @@ test "big.int sub multi-single" { defer c.deinit(); try c.sub(a.toConst(), b.toConst()); - testing.expect((try c.to(Limb)) == maxInt(Limb)); + try testing.expect((try c.to(Limb)) == maxInt(Limb)); } test "big.int sub multi-multi" { @@ -577,7 +577,7 @@ test "big.int sub multi-multi" { defer c.deinit(); try c.sub(a.toConst(), b.toConst()); - testing.expect((try c.to(u128)) == op1 - op2); + try testing.expect((try c.to(u128)) == op1 - op2); } test "big.int sub equal" { @@ -590,7 +590,7 @@ test "big.int sub equal" { defer c.deinit(); try c.sub(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 0); + try testing.expect((try c.to(u32)) == 0); } test "big.int sub sign" { @@ -607,19 +607,19 @@ test "big.int sub sign" { defer neg_two.deinit(); try a.sub(one.toConst(), two.toConst()); - testing.expect((try a.to(i32)) == -1); + try testing.expect((try a.to(i32)) == -1); try a.sub(neg_one.toConst(), two.toConst()); - testing.expect((try a.to(i32)) == -3); + try testing.expect((try a.to(i32)) == -3); try a.sub(one.toConst(), neg_two.toConst()); - testing.expect((try a.to(i32)) == 3); + try testing.expect((try a.to(i32)) == 3); try a.sub(neg_one.toConst(), neg_two.toConst()); - testing.expect((try a.to(i32)) == 1); + try testing.expect((try a.to(i32)) == 1); try a.sub(neg_two.toConst(), neg_one.toConst()); - testing.expect((try a.to(i32)) == -1); + try testing.expect((try a.to(i32)) == -1); } test "big.int mul single-single" { @@ -632,7 +632,7 @@ test "big.int mul single-single" { defer c.deinit(); try c.mul(a.toConst(), b.toConst()); - testing.expect((try c.to(u64)) == 250); + try testing.expect((try c.to(u64)) == 250); } test "big.int mul multi-single" { @@ -645,7 +645,7 @@ test "big.int mul multi-single" { defer c.deinit(); try c.mul(a.toConst(), b.toConst()); - testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb)); + try testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb)); } test "big.int mul multi-multi" { @@ -660,7 +660,7 @@ test "big.int mul multi-multi" { defer c.deinit(); try c.mul(a.toConst(), b.toConst()); - testing.expect((try c.to(u256)) == op1 * op2); + try testing.expect((try c.to(u256)) == op1 * op2); } test "big.int mul alias r with a" { @@ -671,7 +671,7 @@ test "big.int mul alias r with a" { try a.mul(a.toConst(), b.toConst()); - testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb)); + try testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb)); } test "big.int mul alias r with b" { @@ -682,7 +682,7 @@ test "big.int mul alias r with b" { try a.mul(b.toConst(), a.toConst()); - testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb)); + try testing.expect((try a.to(DoubleLimb)) == 2 * maxInt(Limb)); } test "big.int mul alias r with a and b" { @@ -691,7 +691,7 @@ test "big.int mul alias r with a and b" { try a.mul(a.toConst(), a.toConst()); - testing.expect((try a.to(DoubleLimb)) == maxInt(Limb) * maxInt(Limb)); + try testing.expect((try a.to(DoubleLimb)) == maxInt(Limb) * maxInt(Limb)); } test "big.int mul a*0" { @@ -704,7 +704,7 @@ test "big.int mul a*0" { defer c.deinit(); try c.mul(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 0); + try testing.expect((try c.to(u32)) == 0); } test "big.int mul 0*0" { @@ -717,7 +717,7 @@ test "big.int mul 0*0" { defer c.deinit(); try c.mul(a.toConst(), b.toConst()); - testing.expect((try c.to(u32)) == 0); + try testing.expect((try c.to(u32)) == 0); } test "big.int mul large" { @@ -738,7 +738,7 @@ test "big.int mul large" { try b.mul(a.toConst(), a.toConst()); try c.sqr(a.toConst()); - testing.expect(b.eq(c)); + try testing.expect(b.eq(c)); } test "big.int div single-single no rem" { @@ -753,8 +753,8 @@ test "big.int div single-single no rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u32)) == 10); - testing.expect((try r.to(u32)) == 0); + try testing.expect((try q.to(u32)) == 10); + try testing.expect((try r.to(u32)) == 0); } test "big.int div single-single with rem" { @@ -769,8 +769,8 @@ test "big.int div single-single with rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u32)) == 9); - testing.expect((try r.to(u32)) == 4); + try testing.expect((try q.to(u32)) == 9); + try testing.expect((try r.to(u32)) == 4); } test "big.int div multi-single no rem" { @@ -788,8 +788,8 @@ test "big.int div multi-single no rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u64)) == op1 / op2); - testing.expect((try r.to(u64)) == 0); + try testing.expect((try q.to(u64)) == op1 / op2); + try testing.expect((try r.to(u64)) == 0); } test "big.int div multi-single with rem" { @@ -807,8 +807,8 @@ test "big.int div multi-single with rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u64)) == op1 / op2); - testing.expect((try r.to(u64)) == 3); + try testing.expect((try q.to(u64)) == op1 / op2); + try testing.expect((try r.to(u64)) == 3); } test "big.int div multi>2-single" { @@ -826,8 +826,8 @@ test "big.int div multi>2-single" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == op1 / op2); - testing.expect((try r.to(u32)) == 0x3e4e); + try testing.expect((try q.to(u128)) == op1 / op2); + try testing.expect((try r.to(u32)) == 0x3e4e); } test "big.int div single-single q < r" { @@ -842,8 +842,8 @@ test "big.int div single-single q < r" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u64)) == 0); - testing.expect((try r.to(u64)) == 0x0078f432); + try testing.expect((try q.to(u64)) == 0); + try testing.expect((try r.to(u64)) == 0x0078f432); } test "big.int div single-single q == r" { @@ -858,8 +858,8 @@ test "big.int div single-single q == r" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u64)) == 1); - testing.expect((try r.to(u64)) == 0); + try testing.expect((try q.to(u64)) == 1); + try testing.expect((try r.to(u64)) == 0); } test "big.int div q=0 alias" { @@ -870,8 +870,8 @@ test "big.int div q=0 alias" { try Managed.divTrunc(&a, &b, a.toConst(), b.toConst()); - testing.expect((try a.to(u64)) == 0); - testing.expect((try b.to(u64)) == 3); + try testing.expect((try a.to(u64)) == 0); + try testing.expect((try b.to(u64)) == 3); } test "big.int div multi-multi q < r" { @@ -888,8 +888,8 @@ test "big.int div multi-multi q < r" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0); - testing.expect((try r.to(u128)) == op1); + try testing.expect((try q.to(u128)) == 0); + try testing.expect((try r.to(u128)) == op1); } test "big.int div trunc single-single +/+" { @@ -912,8 +912,8 @@ test "big.int div trunc single-single +/+" { const eq = @divTrunc(u, v); const er = @mod(u, v); - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div trunc single-single -/+" { @@ -936,8 +936,8 @@ test "big.int div trunc single-single -/+" { const eq = -1; const er = -2; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div trunc single-single +/-" { @@ -960,8 +960,8 @@ test "big.int div trunc single-single +/-" { const eq = -1; const er = 2; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div trunc single-single -/-" { @@ -984,8 +984,8 @@ test "big.int div trunc single-single -/-" { const eq = 1; const er = -2; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div floor single-single +/+" { @@ -1008,8 +1008,8 @@ test "big.int div floor single-single +/+" { const eq = 1; const er = 2; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div floor single-single -/+" { @@ -1032,8 +1032,8 @@ test "big.int div floor single-single -/+" { const eq = -2; const er = 1; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div floor single-single +/-" { @@ -1056,8 +1056,8 @@ test "big.int div floor single-single +/-" { const eq = -2; const er = -1; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div floor single-single -/-" { @@ -1080,8 +1080,8 @@ test "big.int div floor single-single -/-" { const eq = 1; const er = -2; - testing.expect((try q.to(i32)) == eq); - testing.expect((try r.to(i32)) == er); + try testing.expect((try q.to(i32)) == eq); + try testing.expect((try r.to(i32)) == er); } test "big.int div multi-multi with rem" { @@ -1096,8 +1096,8 @@ test "big.int div multi-multi with rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); - testing.expect((try r.to(u128)) == 0x28de0acacd806823638); + try testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); + try testing.expect((try r.to(u128)) == 0x28de0acacd806823638); } test "big.int div multi-multi no rem" { @@ -1112,8 +1112,8 @@ test "big.int div multi-multi no rem" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); - testing.expect((try r.to(u128)) == 0); + try testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); + try testing.expect((try r.to(u128)) == 0); } test "big.int div multi-multi (2 branch)" { @@ -1128,8 +1128,8 @@ test "big.int div multi-multi (2 branch)" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0x10000000000000000); - testing.expect((try r.to(u128)) == 0x44444443444444431111111111111111); + try testing.expect((try q.to(u128)) == 0x10000000000000000); + try testing.expect((try r.to(u128)) == 0x44444443444444431111111111111111); } test "big.int div multi-multi (3.1/3.3 branch)" { @@ -1144,8 +1144,8 @@ test "big.int div multi-multi (3.1/3.3 branch)" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0xfffffffffffffffffff); - testing.expect((try r.to(u256)) == 0x1111111111111111111110b12222222222222222282); + try testing.expect((try q.to(u128)) == 0xfffffffffffffffffff); + try testing.expect((try r.to(u256)) == 0x1111111111111111111110b12222222222222222282); } test "big.int div multi-single zero-limb trailing" { @@ -1162,8 +1162,8 @@ test "big.int div multi-single zero-limb trailing" { var expected = try Managed.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000); defer expected.deinit(); - testing.expect(q.eq(expected)); - testing.expect(r.eqZero()); + try testing.expect(q.eq(expected)); + try testing.expect(r.eqZero()); } test "big.int div multi-multi zero-limb trailing (with rem)" { @@ -1178,11 +1178,11 @@ test "big.int div multi-multi zero-limb trailing (with rem)" { defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0x10000000000000000); + try testing.expect((try q.to(u128)) == 0x10000000000000000); const rs = try r.toString(testing.allocator, 16, false); defer testing.allocator.free(rs); - testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000")); + try testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000")); } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" { @@ -1197,11 +1197,11 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li defer r.deinit(); try Managed.divTrunc(&q, &r, a.toConst(), b.toConst()); - testing.expect((try q.to(u128)) == 0x1); + try testing.expect((try q.to(u128)) == 0x1); const rs = try r.toString(testing.allocator, 16, false); defer testing.allocator.free(rs); - testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000")); + try testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000")); } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" { @@ -1218,11 +1218,11 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li const qs = try q.toString(testing.allocator, 16, false); defer testing.allocator.free(qs); - testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f")); + try testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f")); const rs = try r.toString(testing.allocator, 16, false); defer testing.allocator.free(rs); - testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000")); + try testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000")); } test "big.int div multi-multi fuzz case #1" { @@ -1242,11 +1242,11 @@ test "big.int div multi-multi fuzz case #1" { const qs = try q.toString(testing.allocator, 16, false); defer testing.allocator.free(qs); - testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1")); + try testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1")); const rs = try r.toString(testing.allocator, 16, false); defer testing.allocator.free(rs); - testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1")); + try testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1")); } test "big.int div multi-multi fuzz case #2" { @@ -1266,11 +1266,11 @@ test "big.int div multi-multi fuzz case #2" { const qs = try q.toString(testing.allocator, 16, false); defer testing.allocator.free(qs); - testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4")); + try testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4")); const rs = try r.toString(testing.allocator, 16, false); defer testing.allocator.free(rs); - testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000")); + try testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000")); } test "big.int shift-right single" { @@ -1278,7 +1278,7 @@ test "big.int shift-right single" { defer a.deinit(); try a.shiftRight(a, 16); - testing.expect((try a.to(u32)) == 0xffff); + try testing.expect((try a.to(u32)) == 0xffff); } test "big.int shift-right multi" { @@ -1286,13 +1286,13 @@ test "big.int shift-right multi" { defer a.deinit(); try a.shiftRight(a, 67); - testing.expect((try a.to(u64)) == 0x1fffe0001dddc222); + try testing.expect((try a.to(u64)) == 0x1fffe0001dddc222); try a.set(0xffff0000eeee1111dddd2222cccc3333); try a.shiftRight(a, 63); try a.shiftRight(a, 63); try a.shiftRight(a, 2); - testing.expect(a.eqZero()); + try testing.expect(a.eqZero()); } test "big.int shift-left single" { @@ -1300,7 +1300,7 @@ test "big.int shift-left single" { defer a.deinit(); try a.shiftLeft(a, 16); - testing.expect((try a.to(u64)) == 0xffff0000); + try testing.expect((try a.to(u64)) == 0xffff0000); } test "big.int shift-left multi" { @@ -1308,7 +1308,7 @@ test "big.int shift-left multi" { defer a.deinit(); try a.shiftLeft(a, 67); - testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000); + try testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000); } test "big.int shift-right negative" { @@ -1318,12 +1318,12 @@ test "big.int shift-right negative" { var arg = try Managed.initSet(testing.allocator, -20); defer arg.deinit(); try a.shiftRight(arg, 2); - testing.expect((try a.to(i32)) == -20 >> 2); + try testing.expect((try a.to(i32)) == -20 >> 2); var arg2 = try Managed.initSet(testing.allocator, -5); defer arg2.deinit(); try a.shiftRight(arg2, 10); - testing.expect((try a.to(i32)) == -5 >> 10); + try testing.expect((try a.to(i32)) == -5 >> 10); } test "big.int shift-left negative" { @@ -1333,7 +1333,7 @@ test "big.int shift-left negative" { var arg = try Managed.initSet(testing.allocator, -10); defer arg.deinit(); try a.shiftRight(arg, 1232); - testing.expect((try a.to(i32)) == -10 >> 1232); + try testing.expect((try a.to(i32)) == -10 >> 1232); } test "big.int bitwise and simple" { @@ -1344,7 +1344,7 @@ test "big.int bitwise and simple" { try a.bitAnd(a, b); - testing.expect((try a.to(u64)) == 0xeeeeeeee00000000); + try testing.expect((try a.to(u64)) == 0xeeeeeeee00000000); } test "big.int bitwise and multi-limb" { @@ -1355,7 +1355,7 @@ test "big.int bitwise and multi-limb" { try a.bitAnd(a, b); - testing.expect((try a.to(u128)) == 0); + try testing.expect((try a.to(u128)) == 0); } test "big.int bitwise xor simple" { @@ -1366,7 +1366,7 @@ test "big.int bitwise xor simple" { try a.bitXor(a, b); - testing.expect((try a.to(u64)) == 0x1111111133333333); + try testing.expect((try a.to(u64)) == 0x1111111133333333); } test "big.int bitwise xor multi-limb" { @@ -1377,7 +1377,7 @@ test "big.int bitwise xor multi-limb" { try a.bitXor(a, b); - testing.expect((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) ^ maxInt(Limb)); + try testing.expect((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) ^ maxInt(Limb)); } test "big.int bitwise or simple" { @@ -1388,7 +1388,7 @@ test "big.int bitwise or simple" { try a.bitOr(a, b); - testing.expect((try a.to(u64)) == 0xffffffff33333333); + try testing.expect((try a.to(u64)) == 0xffffffff33333333); } test "big.int bitwise or multi-limb" { @@ -1400,7 +1400,7 @@ test "big.int bitwise or multi-limb" { try a.bitOr(a, b); // TODO: big.int.cpp or is wrong on multi-limb. - testing.expect((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) + maxInt(Limb)); + try testing.expect((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) + maxInt(Limb)); } test "big.int var args" { @@ -1410,15 +1410,15 @@ test "big.int var args" { var b = try Managed.initSet(testing.allocator, 6); defer b.deinit(); try a.add(a.toConst(), b.toConst()); - testing.expect((try a.to(u64)) == 11); + try testing.expect((try a.to(u64)) == 11); var c = try Managed.initSet(testing.allocator, 11); defer c.deinit(); - testing.expect(a.order(c) == .eq); + try testing.expect(a.order(c) == .eq); var d = try Managed.initSet(testing.allocator, 14); defer d.deinit(); - testing.expect(a.order(d) != .gt); + try testing.expect(a.order(d) != .gt); } test "big.int gcd non-one small" { @@ -1431,7 +1431,7 @@ test "big.int gcd non-one small" { try r.gcd(a, b); - testing.expect((try r.to(u32)) == 1); + try testing.expect((try r.to(u32)) == 1); } test "big.int gcd non-one small" { @@ -1444,7 +1444,7 @@ test "big.int gcd non-one small" { try r.gcd(a, b); - testing.expect((try r.to(u32)) == 38); + try testing.expect((try r.to(u32)) == 38); } test "big.int gcd non-one large" { @@ -1457,7 +1457,7 @@ test "big.int gcd non-one large" { try r.gcd(a, b); - testing.expect((try r.to(u32)) == 4369); + try testing.expect((try r.to(u32)) == 4369); } test "big.int gcd large multi-limb result" { @@ -1471,7 +1471,7 @@ test "big.int gcd large multi-limb result" { try r.gcd(a, b); const answer = (try r.to(u256)); - testing.expect(answer == 0xf000000ff00000fff0000ffff000fffff00ffffff1); + try testing.expect(answer == 0xf000000ff00000fff0000ffff000fffff00ffffff1); } test "big.int gcd one large" { @@ -1484,7 +1484,7 @@ test "big.int gcd one large" { try r.gcd(a, b); - testing.expect((try r.to(u64)) == 1); + try testing.expect((try r.to(u64)) == 1); } test "big.int mutable to managed" { @@ -1495,7 +1495,7 @@ test "big.int mutable to managed" { var a = Mutable.init(limbs_buf, 0xdeadbeef); var a_managed = a.toManaged(allocator); - testing.expect(a.toConst().eq(a_managed.toConst())); + try testing.expect(a.toConst().eq(a_managed.toConst())); } test "big.int const to managed" { @@ -1505,7 +1505,7 @@ test "big.int const to managed" { var b = try a.toConst().toManaged(testing.allocator); defer b.deinit(); - testing.expect(a.toConst().eq(b.toConst())); + try testing.expect(a.toConst().eq(b.toConst())); } test "big.int pow" { @@ -1514,10 +1514,10 @@ test "big.int pow" { defer a.deinit(); try a.pow(a.toConst(), 3); - testing.expectEqual(@as(i32, -27), try a.to(i32)); + try testing.expectEqual(@as(i32, -27), try a.to(i32)); try a.pow(a.toConst(), 4); - testing.expectEqual(@as(i32, 531441), try a.to(i32)); + try testing.expectEqual(@as(i32, 531441), try a.to(i32)); } { var a = try Managed.initSet(testing.allocator, 10); @@ -1531,11 +1531,11 @@ test "big.int pow" { // y and a are aliased try a.pow(a.toConst(), 123); - testing.expect(a.eq(y)); + try testing.expect(a.eq(y)); const ys = try y.toString(testing.allocator, 16, false); defer testing.allocator.free(ys); - testing.expectEqualSlices( + try testing.expectEqualSlices( u8, "183425a5f872f126e00a5ad62c839075cd6846c6fb0230887c7ad7a9dc530fcb" ++ "4933f60e8000000000000000000000000000000", @@ -1548,17 +1548,17 @@ test "big.int pow" { defer a.deinit(); try a.pow(a.toConst(), 100); - testing.expectEqual(@as(i32, 0), try a.to(i32)); + try testing.expectEqual(@as(i32, 0), try a.to(i32)); try a.set(1); try a.pow(a.toConst(), 0); - testing.expectEqual(@as(i32, 1), try a.to(i32)); + try testing.expectEqual(@as(i32, 1), try a.to(i32)); try a.pow(a.toConst(), 100); - testing.expectEqual(@as(i32, 1), try a.to(i32)); + try testing.expectEqual(@as(i32, 1), try a.to(i32)); try a.set(-1); try a.pow(a.toConst(), 15); - testing.expectEqual(@as(i32, -1), try a.to(i32)); + try testing.expectEqual(@as(i32, -1), try a.to(i32)); try a.pow(a.toConst(), 16); - testing.expectEqual(@as(i32, 1), try a.to(i32)); + try testing.expectEqual(@as(i32, 1), try a.to(i32)); } } diff --git a/lib/std/math/big/rational.zig b/lib/std/math/big/rational.zig index 2299205e7b..987889feca 100644 --- a/lib/std/math/big/rational.zig +++ b/lib/std/math/big/rational.zig @@ -473,7 +473,7 @@ pub const Rational = struct { }; fn extractLowBits(a: Int, comptime T: type) T { - testing.expect(@typeInfo(T) == .Int); + debug.assert(@typeInfo(T) == .Int); const t_bits = @typeInfo(T).Int.bits; const limb_bits = @typeInfo(Limb).Int.bits; @@ -498,19 +498,19 @@ test "big.rational extractLowBits" { defer a.deinit(); const a1 = extractLowBits(a, u8); - testing.expect(a1 == 0x21); + try testing.expect(a1 == 0x21); const a2 = extractLowBits(a, u16); - testing.expect(a2 == 0x4321); + try testing.expect(a2 == 0x4321); const a3 = extractLowBits(a, u32); - testing.expect(a3 == 0x87654321); + try testing.expect(a3 == 0x87654321); const a4 = extractLowBits(a, u64); - testing.expect(a4 == 0x1234567887654321); + try testing.expect(a4 == 0x1234567887654321); const a5 = extractLowBits(a, u128); - testing.expect(a5 == 0x11112222333344441234567887654321); + try testing.expect(a5 == 0x11112222333344441234567887654321); } test "big.rational set" { @@ -518,28 +518,28 @@ test "big.rational set" { defer a.deinit(); try a.setInt(5); - testing.expect((try a.p.to(u32)) == 5); - testing.expect((try a.q.to(u32)) == 1); + try testing.expect((try a.p.to(u32)) == 5); + try testing.expect((try a.q.to(u32)) == 1); try a.setRatio(7, 3); - testing.expect((try a.p.to(u32)) == 7); - testing.expect((try a.q.to(u32)) == 3); + try testing.expect((try a.p.to(u32)) == 7); + try testing.expect((try a.q.to(u32)) == 3); try a.setRatio(9, 3); - testing.expect((try a.p.to(i32)) == 3); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == 3); + try testing.expect((try a.q.to(i32)) == 1); try a.setRatio(-9, 3); - testing.expect((try a.p.to(i32)) == -3); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == -3); + try testing.expect((try a.q.to(i32)) == 1); try a.setRatio(9, -3); - testing.expect((try a.p.to(i32)) == -3); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == -3); + try testing.expect((try a.q.to(i32)) == 1); try a.setRatio(-9, -3); - testing.expect((try a.p.to(i32)) == 3); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == 3); + try testing.expect((try a.q.to(i32)) == 1); } test "big.rational setFloat" { @@ -547,24 +547,24 @@ test "big.rational setFloat" { defer a.deinit(); try a.setFloat(f64, 2.5); - testing.expect((try a.p.to(i32)) == 5); - testing.expect((try a.q.to(i32)) == 2); + try testing.expect((try a.p.to(i32)) == 5); + try testing.expect((try a.q.to(i32)) == 2); try a.setFloat(f32, -2.5); - testing.expect((try a.p.to(i32)) == -5); - testing.expect((try a.q.to(i32)) == 2); + try testing.expect((try a.p.to(i32)) == -5); + try testing.expect((try a.q.to(i32)) == 2); try a.setFloat(f32, 3.141593); // = 3.14159297943115234375 - testing.expect((try a.p.to(u32)) == 3294199); - testing.expect((try a.q.to(u32)) == 1048576); + try testing.expect((try a.p.to(u32)) == 3294199); + try testing.expect((try a.q.to(u32)) == 1048576); try a.setFloat(f64, 72.141593120712409172417410926841290461290467124); // = 72.1415931207124145885245525278151035308837890625 - testing.expect((try a.p.to(u128)) == 5076513310880537); - testing.expect((try a.q.to(u128)) == 70368744177664); + try testing.expect((try a.p.to(u128)) == 5076513310880537); + try testing.expect((try a.q.to(u128)) == 70368744177664); } test "big.rational setFloatString" { @@ -574,8 +574,8 @@ test "big.rational setFloatString" { try a.setFloatString("72.14159312071241458852455252781510353"); // = 72.1415931207124145885245525278151035308837890625 - testing.expect((try a.p.to(u128)) == 7214159312071241458852455252781510353); - testing.expect((try a.q.to(u128)) == 100000000000000000000000000000000000); + try testing.expect((try a.p.to(u128)) == 7214159312071241458852455252781510353); + try testing.expect((try a.q.to(u128)) == 100000000000000000000000000000000000); } test "big.rational toFloat" { @@ -584,11 +584,11 @@ test "big.rational toFloat" { // = 3.14159297943115234375 try a.setRatio(3294199, 1048576); - testing.expect((try a.toFloat(f64)) == 3.14159297943115234375); + try testing.expect((try a.toFloat(f64)) == 3.14159297943115234375); // = 72.1415931207124145885245525278151035308837890625 try a.setRatio(5076513310880537, 70368744177664); - testing.expect((try a.toFloat(f64)) == 72.141593120712409172417410926841290461290467124); + try testing.expect((try a.toFloat(f64)) == 72.141593120712409172417410926841290461290467124); } test "big.rational set/to Float round-trip" { @@ -599,7 +599,7 @@ test "big.rational set/to Float round-trip" { while (i < 512) : (i += 1) { const r = prng.random.float(f64); try a.setFloat(f64, r); - testing.expect((try a.toFloat(f64)) == r); + try testing.expect((try a.toFloat(f64)) == r); } } @@ -611,8 +611,8 @@ test "big.rational copy" { defer b.deinit(); try a.copyInt(b); - testing.expect((try a.p.to(u32)) == 5); - testing.expect((try a.q.to(u32)) == 1); + try testing.expect((try a.p.to(u32)) == 5); + try testing.expect((try a.q.to(u32)) == 1); var c = try Int.initSet(testing.allocator, 7); defer c.deinit(); @@ -620,8 +620,8 @@ test "big.rational copy" { defer d.deinit(); try a.copyRatio(c, d); - testing.expect((try a.p.to(u32)) == 7); - testing.expect((try a.q.to(u32)) == 3); + try testing.expect((try a.p.to(u32)) == 7); + try testing.expect((try a.q.to(u32)) == 3); var e = try Int.initSet(testing.allocator, 9); defer e.deinit(); @@ -629,8 +629,8 @@ test "big.rational copy" { defer f.deinit(); try a.copyRatio(e, f); - testing.expect((try a.p.to(u32)) == 3); - testing.expect((try a.q.to(u32)) == 1); + try testing.expect((try a.p.to(u32)) == 3); + try testing.expect((try a.q.to(u32)) == 1); } test "big.rational negate" { @@ -638,16 +638,16 @@ test "big.rational negate" { defer a.deinit(); try a.setInt(-50); - testing.expect((try a.p.to(i32)) == -50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == -50); + try testing.expect((try a.q.to(i32)) == 1); a.negate(); - testing.expect((try a.p.to(i32)) == 50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == 50); + try testing.expect((try a.q.to(i32)) == 1); a.negate(); - testing.expect((try a.p.to(i32)) == -50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == -50); + try testing.expect((try a.q.to(i32)) == 1); } test "big.rational abs" { @@ -655,16 +655,16 @@ test "big.rational abs" { defer a.deinit(); try a.setInt(-50); - testing.expect((try a.p.to(i32)) == -50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == -50); + try testing.expect((try a.q.to(i32)) == 1); a.abs(); - testing.expect((try a.p.to(i32)) == 50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == 50); + try testing.expect((try a.q.to(i32)) == 1); a.abs(); - testing.expect((try a.p.to(i32)) == 50); - testing.expect((try a.q.to(i32)) == 1); + try testing.expect((try a.p.to(i32)) == 50); + try testing.expect((try a.q.to(i32)) == 1); } test "big.rational swap" { @@ -676,19 +676,19 @@ test "big.rational swap" { try a.setRatio(50, 23); try b.setRatio(17, 3); - testing.expect((try a.p.to(u32)) == 50); - testing.expect((try a.q.to(u32)) == 23); + try testing.expect((try a.p.to(u32)) == 50); + try testing.expect((try a.q.to(u32)) == 23); - testing.expect((try b.p.to(u32)) == 17); - testing.expect((try b.q.to(u32)) == 3); + try testing.expect((try b.p.to(u32)) == 17); + try testing.expect((try b.q.to(u32)) == 3); a.swap(&b); - testing.expect((try a.p.to(u32)) == 17); - testing.expect((try a.q.to(u32)) == 3); + try testing.expect((try a.p.to(u32)) == 17); + try testing.expect((try a.q.to(u32)) == 3); - testing.expect((try b.p.to(u32)) == 50); - testing.expect((try b.q.to(u32)) == 23); + try testing.expect((try b.p.to(u32)) == 50); + try testing.expect((try b.q.to(u32)) == 23); } test "big.rational order" { @@ -699,11 +699,11 @@ test "big.rational order" { try a.setRatio(500, 231); try b.setRatio(18903, 8584); - testing.expect((try a.order(b)) == .lt); + try testing.expect((try a.order(b)) == .lt); try a.setRatio(890, 10); try b.setRatio(89, 1); - testing.expect((try a.order(b)) == .eq); + try testing.expect((try a.order(b)) == .eq); } test "big.rational add single-limb" { @@ -714,11 +714,11 @@ test "big.rational add single-limb" { try a.setRatio(500, 231); try b.setRatio(18903, 8584); - testing.expect((try a.order(b)) == .lt); + try testing.expect((try a.order(b)) == .lt); try a.setRatio(890, 10); try b.setRatio(89, 1); - testing.expect((try a.order(b)) == .eq); + try testing.expect((try a.order(b)) == .eq); } test "big.rational add" { @@ -734,7 +734,7 @@ test "big.rational add" { try a.add(a, b); try r.setRatio(984786924199, 290395044174); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); } test "big.rational sub" { @@ -750,7 +750,7 @@ test "big.rational sub" { try a.sub(a, b); try r.setRatio(979040510045, 290395044174); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); } test "big.rational mul" { @@ -766,7 +766,7 @@ test "big.rational mul" { try a.mul(a, b); try r.setRatio(571481443, 17082061422); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); } test "big.rational div" { @@ -782,7 +782,7 @@ test "big.rational div" { try a.div(a, b); try r.setRatio(75531824394, 221015929); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); } test "big.rational div" { @@ -795,11 +795,11 @@ test "big.rational div" { a.invert(); try r.setRatio(23341, 78923); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); try a.setRatio(-78923, 23341); a.invert(); try r.setRatio(-23341, 78923); - testing.expect((try a.order(r)) == .eq); + try testing.expect((try a.order(r)) == .eq); } diff --git a/lib/std/math/cbrt.zig b/lib/std/math/cbrt.zig index a876e0a9d1..504657894d 100644 --- a/lib/std/math/cbrt.zig +++ b/lib/std/math/cbrt.zig @@ -125,44 +125,44 @@ fn cbrt64(x: f64) f64 { } test "math.cbrt" { - expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0)); - expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0)); + try expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0)); + try expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0)); } test "math.cbrt32" { const epsilon = 0.000001; - expect(cbrt32(0.0) == 0.0); - expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon)); - expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon)); - expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon)); - expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon)); - expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon)); + try expect(cbrt32(0.0) == 0.0); + try expect(math.approxEqAbs(f32, cbrt32(0.2), 0.584804, epsilon)); + try expect(math.approxEqAbs(f32, cbrt32(0.8923), 0.962728, epsilon)); + try expect(math.approxEqAbs(f32, cbrt32(1.5), 1.144714, epsilon)); + try expect(math.approxEqAbs(f32, cbrt32(37.45), 3.345676, epsilon)); + try expect(math.approxEqAbs(f32, cbrt32(123123.234375), 49.748501, epsilon)); } test "math.cbrt64" { const epsilon = 0.000001; - expect(cbrt64(0.0) == 0.0); - expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon)); - expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon)); - expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon)); - expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon)); - expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon)); + try expect(cbrt64(0.0) == 0.0); + try expect(math.approxEqAbs(f64, cbrt64(0.2), 0.584804, epsilon)); + try expect(math.approxEqAbs(f64, cbrt64(0.8923), 0.962728, epsilon)); + try expect(math.approxEqAbs(f64, cbrt64(1.5), 1.144714, epsilon)); + try expect(math.approxEqAbs(f64, cbrt64(37.45), 3.345676, epsilon)); + try expect(math.approxEqAbs(f64, cbrt64(123123.234375), 49.748501, epsilon)); } test "math.cbrt.special" { - expect(cbrt32(0.0) == 0.0); - expect(cbrt32(-0.0) == -0.0); - expect(math.isPositiveInf(cbrt32(math.inf(f32)))); - expect(math.isNegativeInf(cbrt32(-math.inf(f32)))); - expect(math.isNan(cbrt32(math.nan(f32)))); + try expect(cbrt32(0.0) == 0.0); + try expect(cbrt32(-0.0) == -0.0); + try expect(math.isPositiveInf(cbrt32(math.inf(f32)))); + try expect(math.isNegativeInf(cbrt32(-math.inf(f32)))); + try expect(math.isNan(cbrt32(math.nan(f32)))); } test "math.cbrt64.special" { - expect(cbrt64(0.0) == 0.0); - expect(cbrt64(-0.0) == -0.0); - expect(math.isPositiveInf(cbrt64(math.inf(f64)))); - expect(math.isNegativeInf(cbrt64(-math.inf(f64)))); - expect(math.isNan(cbrt64(math.nan(f64)))); + try expect(cbrt64(0.0) == 0.0); + try expect(cbrt64(-0.0) == -0.0); + try expect(math.isPositiveInf(cbrt64(math.inf(f64)))); + try expect(math.isNegativeInf(cbrt64(-math.inf(f64)))); + try expect(math.isNan(cbrt64(math.nan(f64)))); } diff --git a/lib/std/math/ceil.zig b/lib/std/math/ceil.zig index d313475717..7b516c77c6 100644 --- a/lib/std/math/ceil.zig +++ b/lib/std/math/ceil.zig @@ -120,49 +120,49 @@ fn ceil128(x: f128) f128 { } test "math.ceil" { - expect(ceil(@as(f32, 0.0)) == ceil32(0.0)); - expect(ceil(@as(f64, 0.0)) == ceil64(0.0)); - expect(ceil(@as(f128, 0.0)) == ceil128(0.0)); + try expect(ceil(@as(f32, 0.0)) == ceil32(0.0)); + try expect(ceil(@as(f64, 0.0)) == ceil64(0.0)); + try expect(ceil(@as(f128, 0.0)) == ceil128(0.0)); } test "math.ceil32" { - expect(ceil32(1.3) == 2.0); - expect(ceil32(-1.3) == -1.0); - expect(ceil32(0.2) == 1.0); + try expect(ceil32(1.3) == 2.0); + try expect(ceil32(-1.3) == -1.0); + try expect(ceil32(0.2) == 1.0); } test "math.ceil64" { - expect(ceil64(1.3) == 2.0); - expect(ceil64(-1.3) == -1.0); - expect(ceil64(0.2) == 1.0); + try expect(ceil64(1.3) == 2.0); + try expect(ceil64(-1.3) == -1.0); + try expect(ceil64(0.2) == 1.0); } test "math.ceil128" { - expect(ceil128(1.3) == 2.0); - expect(ceil128(-1.3) == -1.0); - expect(ceil128(0.2) == 1.0); + try expect(ceil128(1.3) == 2.0); + try expect(ceil128(-1.3) == -1.0); + try expect(ceil128(0.2) == 1.0); } test "math.ceil32.special" { - expect(ceil32(0.0) == 0.0); - expect(ceil32(-0.0) == -0.0); - expect(math.isPositiveInf(ceil32(math.inf(f32)))); - expect(math.isNegativeInf(ceil32(-math.inf(f32)))); - expect(math.isNan(ceil32(math.nan(f32)))); + try expect(ceil32(0.0) == 0.0); + try expect(ceil32(-0.0) == -0.0); + try expect(math.isPositiveInf(ceil32(math.inf(f32)))); + try expect(math.isNegativeInf(ceil32(-math.inf(f32)))); + try expect(math.isNan(ceil32(math.nan(f32)))); } test "math.ceil64.special" { - expect(ceil64(0.0) == 0.0); - expect(ceil64(-0.0) == -0.0); - expect(math.isPositiveInf(ceil64(math.inf(f64)))); - expect(math.isNegativeInf(ceil64(-math.inf(f64)))); - expect(math.isNan(ceil64(math.nan(f64)))); + try expect(ceil64(0.0) == 0.0); + try expect(ceil64(-0.0) == -0.0); + try expect(math.isPositiveInf(ceil64(math.inf(f64)))); + try expect(math.isNegativeInf(ceil64(-math.inf(f64)))); + try expect(math.isNan(ceil64(math.nan(f64)))); } test "math.ceil128.special" { - expect(ceil128(0.0) == 0.0); - expect(ceil128(-0.0) == -0.0); - expect(math.isPositiveInf(ceil128(math.inf(f128)))); - expect(math.isNegativeInf(ceil128(-math.inf(f128)))); - expect(math.isNan(ceil128(math.nan(f128)))); + try expect(ceil128(0.0) == 0.0); + try expect(ceil128(-0.0) == -0.0); + try expect(math.isPositiveInf(ceil128(math.inf(f128)))); + try expect(math.isNegativeInf(ceil128(-math.inf(f128)))); + try expect(math.isNan(ceil128(math.nan(f128)))); } diff --git a/lib/std/math/complex.zig b/lib/std/math/complex.zig index e046ed9fa9..abac923cdd 100644 --- a/lib/std/math/complex.zig +++ b/lib/std/math/complex.zig @@ -114,7 +114,7 @@ test "complex.add" { const b = Complex(f32).new(2, 7); const c = a.add(b); - testing.expect(c.re == 7 and c.im == 10); + try testing.expect(c.re == 7 and c.im == 10); } test "complex.sub" { @@ -122,7 +122,7 @@ test "complex.sub" { const b = Complex(f32).new(2, 7); const c = a.sub(b); - testing.expect(c.re == 3 and c.im == -4); + try testing.expect(c.re == 3 and c.im == -4); } test "complex.mul" { @@ -130,7 +130,7 @@ test "complex.mul" { const b = Complex(f32).new(2, 7); const c = a.mul(b); - testing.expect(c.re == -11 and c.im == 41); + try testing.expect(c.re == -11 and c.im == 41); } test "complex.div" { @@ -138,7 +138,7 @@ test "complex.div" { const b = Complex(f32).new(2, 7); const c = a.div(b); - testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and + try testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon)); } @@ -146,14 +146,14 @@ test "complex.conjugate" { const a = Complex(f32).new(5, 3); const c = a.conjugate(); - testing.expect(c.re == 5 and c.im == -3); + try testing.expect(c.re == 5 and c.im == -3); } test "complex.reciprocal" { const a = Complex(f32).new(5, 3); const c = a.reciprocal(); - testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and + try testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon)); } @@ -161,7 +161,7 @@ test "complex.magnitude" { const a = Complex(f32).new(5, 3); const c = a.magnitude(); - testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); + try testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); } test "complex.cmath" { diff --git a/lib/std/math/complex/abs.zig b/lib/std/math/complex/abs.zig index 609cdba5a7..a2678d21db 100644 --- a/lib/std/math/complex/abs.zig +++ b/lib/std/math/complex/abs.zig @@ -20,5 +20,5 @@ const epsilon = 0.0001; test "complex.cabs" { const a = Complex(f32).new(5, 3); const c = abs(a); - testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); + try testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon)); } diff --git a/lib/std/math/complex/acos.zig b/lib/std/math/complex/acos.zig index b7c43e9381..72abea47fe 100644 --- a/lib/std/math/complex/acos.zig +++ b/lib/std/math/complex/acos.zig @@ -22,6 +22,6 @@ test "complex.cacos" { const a = Complex(f32).new(5, 3); const c = acos(a); - testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 0.546975, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, -2.452914, epsilon)); } diff --git a/lib/std/math/complex/acosh.zig b/lib/std/math/complex/acosh.zig index d7d596e084..4f76dea01a 100644 --- a/lib/std/math/complex/acosh.zig +++ b/lib/std/math/complex/acosh.zig @@ -22,6 +22,6 @@ test "complex.cacosh" { const a = Complex(f32).new(5, 3); const c = acosh(a); - testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 2.452914, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 0.546975, epsilon)); } diff --git a/lib/std/math/complex/arg.zig b/lib/std/math/complex/arg.zig index 7c3b00bd5d..c583b9e360 100644 --- a/lib/std/math/complex/arg.zig +++ b/lib/std/math/complex/arg.zig @@ -20,5 +20,5 @@ const epsilon = 0.0001; test "complex.carg" { const a = Complex(f32).new(5, 3); const c = arg(a); - testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon)); + try testing.expect(math.approxEqAbs(f32, c, 0.540420, epsilon)); } diff --git a/lib/std/math/complex/asin.zig b/lib/std/math/complex/asin.zig index 0ed352b3b7..7ce200fae2 100644 --- a/lib/std/math/complex/asin.zig +++ b/lib/std/math/complex/asin.zig @@ -28,6 +28,6 @@ test "complex.casin" { const a = Complex(f32).new(5, 3); const c = asin(a); - testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 1.023822, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 2.452914, epsilon)); } diff --git a/lib/std/math/complex/asinh.zig b/lib/std/math/complex/asinh.zig index 762a601fbf..821218acf7 100644 --- a/lib/std/math/complex/asinh.zig +++ b/lib/std/math/complex/asinh.zig @@ -23,6 +23,6 @@ test "complex.casinh" { const a = Complex(f32).new(5, 3); const c = asinh(a); - testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 2.459831, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 0.533999, epsilon)); } diff --git a/lib/std/math/complex/atan.zig b/lib/std/math/complex/atan.zig index af40c05a81..d9a95c8dc1 100644 --- a/lib/std/math/complex/atan.zig +++ b/lib/std/math/complex/atan.zig @@ -130,14 +130,14 @@ test "complex.catan32" { const a = Complex(f32).new(5, 3); const c = atan(a); - testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 1.423679, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 0.086569, epsilon)); } test "complex.catan64" { const a = Complex(f64).new(5, 3); const c = atan(a); - testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, 1.423679, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, 0.086569, epsilon)); } diff --git a/lib/std/math/complex/atanh.zig b/lib/std/math/complex/atanh.zig index 2c3708f57f..420f401f17 100644 --- a/lib/std/math/complex/atanh.zig +++ b/lib/std/math/complex/atanh.zig @@ -23,6 +23,6 @@ test "complex.catanh" { const a = Complex(f32).new(5, 3); const c = atanh(a); - testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 0.146947, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 1.480870, epsilon)); } diff --git a/lib/std/math/complex/conj.zig b/lib/std/math/complex/conj.zig index b79c7de6ca..960295830a 100644 --- a/lib/std/math/complex/conj.zig +++ b/lib/std/math/complex/conj.zig @@ -19,5 +19,5 @@ test "complex.conj" { const a = Complex(f32).new(5, 3); const c = a.conjugate(); - testing.expect(c.re == 5 and c.im == -3); + try testing.expect(c.re == 5 and c.im == -3); } diff --git a/lib/std/math/complex/cos.zig b/lib/std/math/complex/cos.zig index 66fd5b9b7b..2de3735d12 100644 --- a/lib/std/math/complex/cos.zig +++ b/lib/std/math/complex/cos.zig @@ -22,6 +22,6 @@ test "complex.ccos" { const a = Complex(f32).new(5, 3); const c = cos(a); - testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 2.855815, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 9.606383, epsilon)); } diff --git a/lib/std/math/complex/cosh.zig b/lib/std/math/complex/cosh.zig index e43cd1d665..2514e72bdb 100644 --- a/lib/std/math/complex/cosh.zig +++ b/lib/std/math/complex/cosh.zig @@ -165,14 +165,14 @@ test "complex.ccosh32" { const a = Complex(f32).new(5, 3); const c = cosh(a); - testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, -73.467300, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 10.471557, epsilon)); } test "complex.ccosh64" { const a = Complex(f64).new(5, 3); const c = cosh(a); - testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, -73.467300, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, 10.471557, epsilon)); } diff --git a/lib/std/math/complex/exp.zig b/lib/std/math/complex/exp.zig index eb738a6d88..a7eb3d51b5 100644 --- a/lib/std/math/complex/exp.zig +++ b/lib/std/math/complex/exp.zig @@ -131,14 +131,14 @@ test "complex.cexp32" { const a = Complex(f32).new(5, 3); const c = exp(a); - testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, -146.927917, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 20.944065, epsilon)); } test "complex.cexp64" { const a = Complex(f64).new(5, 3); const c = exp(a); - testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, -146.927917, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, 20.944065, epsilon)); } diff --git a/lib/std/math/complex/log.zig b/lib/std/math/complex/log.zig index 90124af2eb..7f8f649953 100644 --- a/lib/std/math/complex/log.zig +++ b/lib/std/math/complex/log.zig @@ -24,6 +24,6 @@ test "complex.clog" { const a = Complex(f32).new(5, 3); const c = log(a); - testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 1.763180, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 0.540419, epsilon)); } diff --git a/lib/std/math/complex/pow.zig b/lib/std/math/complex/pow.zig index a6589262cd..0d3a45e6d2 100644 --- a/lib/std/math/complex/pow.zig +++ b/lib/std/math/complex/pow.zig @@ -23,6 +23,6 @@ test "complex.cpow" { const b = Complex(f32).new(2.3, -1.3); const c = pow(Complex(f32), a, b); - testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 58.049110, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, -101.003433, epsilon)); } diff --git a/lib/std/math/complex/proj.zig b/lib/std/math/complex/proj.zig index 42886d8263..260816481b 100644 --- a/lib/std/math/complex/proj.zig +++ b/lib/std/math/complex/proj.zig @@ -26,5 +26,5 @@ test "complex.cproj" { const a = Complex(f32).new(5, 3); const c = proj(a); - testing.expect(c.re == 5 and c.im == 3); + try testing.expect(c.re == 5 and c.im == 3); } diff --git a/lib/std/math/complex/sin.zig b/lib/std/math/complex/sin.zig index 4288dbb1a1..68551b8596 100644 --- a/lib/std/math/complex/sin.zig +++ b/lib/std/math/complex/sin.zig @@ -23,6 +23,6 @@ test "complex.csin" { const a = Complex(f32).new(5, 3); const c = sin(a); - testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, -9.654126, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 2.841692, epsilon)); } diff --git a/lib/std/math/complex/sinh.zig b/lib/std/math/complex/sinh.zig index 2861d99f9a..ea09f8e17d 100644 --- a/lib/std/math/complex/sinh.zig +++ b/lib/std/math/complex/sinh.zig @@ -164,14 +164,14 @@ test "complex.csinh32" { const a = Complex(f32).new(5, 3); const c = sinh(a); - testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, -73.460617, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 10.472508, epsilon)); } test "complex.csinh64" { const a = Complex(f64).new(5, 3); const c = sinh(a); - testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, -73.460617, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, 10.472508, epsilon)); } diff --git a/lib/std/math/complex/sqrt.zig b/lib/std/math/complex/sqrt.zig index e03ed221eb..25c486f838 100644 --- a/lib/std/math/complex/sqrt.zig +++ b/lib/std/math/complex/sqrt.zig @@ -138,14 +138,14 @@ test "complex.csqrt32" { const a = Complex(f32).new(5, 3); const c = sqrt(a); - testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 2.327117, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 0.644574, epsilon)); } test "complex.csqrt64" { const a = Complex(f64).new(5, 3); const c = sqrt(a); - testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, 2.3271175190399496, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, 0.6445742373246469, epsilon)); } diff --git a/lib/std/math/complex/tan.zig b/lib/std/math/complex/tan.zig index 04d900bd99..ca9d4ce7e9 100644 --- a/lib/std/math/complex/tan.zig +++ b/lib/std/math/complex/tan.zig @@ -23,6 +23,6 @@ test "complex.ctan" { const a = Complex(f32).new(5, 3); const c = tan(a); - testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, -0.002708233, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, 1.004165, epsilon)); } diff --git a/lib/std/math/complex/tanh.zig b/lib/std/math/complex/tanh.zig index 19fda8d82f..096bdaac06 100644 --- a/lib/std/math/complex/tanh.zig +++ b/lib/std/math/complex/tanh.zig @@ -113,14 +113,14 @@ test "complex.ctanh32" { const a = Complex(f32).new(5, 3); const c = tanh(a); - testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon)); - testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.re, 0.999913, epsilon)); + try testing.expect(math.approxEqAbs(f32, c.im, -0.000025, epsilon)); } test "complex.ctanh64" { const a = Complex(f64).new(5, 3); const c = tanh(a); - testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon)); - testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.re, 0.999913, epsilon)); + try testing.expect(math.approxEqAbs(f64, c.im, -0.000025, epsilon)); } diff --git a/lib/std/math/copysign.zig b/lib/std/math/copysign.zig index 7861cda8eb..47065fedad 100644 --- a/lib/std/math/copysign.zig +++ b/lib/std/math/copysign.zig @@ -62,36 +62,36 @@ fn copysign128(x: f128, y: f128) f128 { } test "math.copysign" { - expect(copysign(f16, 1.0, 1.0) == copysign16(1.0, 1.0)); - expect(copysign(f32, 1.0, 1.0) == copysign32(1.0, 1.0)); - expect(copysign(f64, 1.0, 1.0) == copysign64(1.0, 1.0)); - expect(copysign(f128, 1.0, 1.0) == copysign128(1.0, 1.0)); + try expect(copysign(f16, 1.0, 1.0) == copysign16(1.0, 1.0)); + try expect(copysign(f32, 1.0, 1.0) == copysign32(1.0, 1.0)); + try expect(copysign(f64, 1.0, 1.0) == copysign64(1.0, 1.0)); + try expect(copysign(f128, 1.0, 1.0) == copysign128(1.0, 1.0)); } test "math.copysign16" { - expect(copysign16(5.0, 1.0) == 5.0); - expect(copysign16(5.0, -1.0) == -5.0); - expect(copysign16(-5.0, -1.0) == -5.0); - expect(copysign16(-5.0, 1.0) == 5.0); + try expect(copysign16(5.0, 1.0) == 5.0); + try expect(copysign16(5.0, -1.0) == -5.0); + try expect(copysign16(-5.0, -1.0) == -5.0); + try expect(copysign16(-5.0, 1.0) == 5.0); } test "math.copysign32" { - expect(copysign32(5.0, 1.0) == 5.0); - expect(copysign32(5.0, -1.0) == -5.0); - expect(copysign32(-5.0, -1.0) == -5.0); - expect(copysign32(-5.0, 1.0) == 5.0); + try expect(copysign32(5.0, 1.0) == 5.0); + try expect(copysign32(5.0, -1.0) == -5.0); + try expect(copysign32(-5.0, -1.0) == -5.0); + try expect(copysign32(-5.0, 1.0) == 5.0); } test "math.copysign64" { - expect(copysign64(5.0, 1.0) == 5.0); - expect(copysign64(5.0, -1.0) == -5.0); - expect(copysign64(-5.0, -1.0) == -5.0); - expect(copysign64(-5.0, 1.0) == 5.0); + try expect(copysign64(5.0, 1.0) == 5.0); + try expect(copysign64(5.0, -1.0) == -5.0); + try expect(copysign64(-5.0, -1.0) == -5.0); + try expect(copysign64(-5.0, 1.0) == 5.0); } test "math.copysign128" { - expect(copysign128(5.0, 1.0) == 5.0); - expect(copysign128(5.0, -1.0) == -5.0); - expect(copysign128(-5.0, -1.0) == -5.0); - expect(copysign128(-5.0, 1.0) == 5.0); + try expect(copysign128(5.0, 1.0) == 5.0); + try expect(copysign128(5.0, -1.0) == -5.0); + try expect(copysign128(-5.0, -1.0) == -5.0); + try expect(copysign128(-5.0, 1.0) == 5.0); } diff --git a/lib/std/math/cos.zig b/lib/std/math/cos.zig index 21804a8e5e..de5efacb8d 100644 --- a/lib/std/math/cos.zig +++ b/lib/std/math/cos.zig @@ -88,42 +88,42 @@ fn cos_(comptime T: type, x_: T) T { } test "math.cos" { - expect(cos(@as(f32, 0.0)) == cos_(f32, 0.0)); - expect(cos(@as(f64, 0.0)) == cos_(f64, 0.0)); + try expect(cos(@as(f32, 0.0)) == cos_(f32, 0.0)); + try expect(cos(@as(f64, 0.0)) == cos_(f64, 0.0)); } test "math.cos32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, cos_(f32, 0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, 0.2), 0.980067, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, 0.8923), 0.627623, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, 1.5), 0.070737, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, -1.5), 0.070737, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, 37.45), 0.969132, epsilon)); - expect(math.approxEqAbs(f32, cos_(f32, 89.123), 0.400798, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 0.2), 0.980067, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 0.8923), 0.627623, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 1.5), 0.070737, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, -1.5), 0.070737, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 37.45), 0.969132, epsilon)); + try expect(math.approxEqAbs(f32, cos_(f32, 89.123), 0.400798, epsilon)); } test "math.cos64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, cos_(f64, 0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, 0.2), 0.980067, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, 0.8923), 0.627623, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, 1.5), 0.070737, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, -1.5), 0.070737, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, 37.45), 0.969132, epsilon)); - expect(math.approxEqAbs(f64, cos_(f64, 89.123), 0.40080, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 0.2), 0.980067, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 0.8923), 0.627623, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 1.5), 0.070737, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, -1.5), 0.070737, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 37.45), 0.969132, epsilon)); + try expect(math.approxEqAbs(f64, cos_(f64, 89.123), 0.40080, epsilon)); } test "math.cos32.special" { - expect(math.isNan(cos_(f32, math.inf(f32)))); - expect(math.isNan(cos_(f32, -math.inf(f32)))); - expect(math.isNan(cos_(f32, math.nan(f32)))); + try expect(math.isNan(cos_(f32, math.inf(f32)))); + try expect(math.isNan(cos_(f32, -math.inf(f32)))); + try expect(math.isNan(cos_(f32, math.nan(f32)))); } test "math.cos64.special" { - expect(math.isNan(cos_(f64, math.inf(f64)))); - expect(math.isNan(cos_(f64, -math.inf(f64)))); - expect(math.isNan(cos_(f64, math.nan(f64)))); + try expect(math.isNan(cos_(f64, math.inf(f64)))); + try expect(math.isNan(cos_(f64, -math.inf(f64)))); + try expect(math.isNan(cos_(f64, math.nan(f64)))); } diff --git a/lib/std/math/cosh.zig b/lib/std/math/cosh.zig index 25d22057ef..b78c72a882 100644 --- a/lib/std/math/cosh.zig +++ b/lib/std/math/cosh.zig @@ -93,48 +93,48 @@ fn cosh64(x: f64) f64 { } test "math.cosh" { - expect(cosh(@as(f32, 1.5)) == cosh32(1.5)); - expect(cosh(@as(f64, 1.5)) == cosh64(1.5)); + try expect(cosh(@as(f32, 1.5)) == cosh32(1.5)); + try expect(cosh(@as(f64, 1.5)) == cosh64(1.5)); } test "math.cosh32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f32, cosh32(0.2), 1.020067, epsilon)); - expect(math.approxEqAbs(f32, cosh32(0.8923), 1.425225, epsilon)); - expect(math.approxEqAbs(f32, cosh32(1.5), 2.352410, epsilon)); - expect(math.approxEqAbs(f32, cosh32(-0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f32, cosh32(-0.2), 1.020067, epsilon)); - expect(math.approxEqAbs(f32, cosh32(-0.8923), 1.425225, epsilon)); - expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(0.2), 1.020067, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(0.8923), 1.425225, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(1.5), 2.352410, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(-0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(-0.2), 1.020067, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(-0.8923), 1.425225, epsilon)); + try expect(math.approxEqAbs(f32, cosh32(-1.5), 2.352410, epsilon)); } test "math.cosh64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f64, cosh64(0.2), 1.020067, epsilon)); - expect(math.approxEqAbs(f64, cosh64(0.8923), 1.425225, epsilon)); - expect(math.approxEqAbs(f64, cosh64(1.5), 2.352410, epsilon)); - expect(math.approxEqAbs(f64, cosh64(-0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f64, cosh64(-0.2), 1.020067, epsilon)); - expect(math.approxEqAbs(f64, cosh64(-0.8923), 1.425225, epsilon)); - expect(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(0.2), 1.020067, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(0.8923), 1.425225, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(1.5), 2.352410, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(-0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(-0.2), 1.020067, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(-0.8923), 1.425225, epsilon)); + try expect(math.approxEqAbs(f64, cosh64(-1.5), 2.352410, epsilon)); } test "math.cosh32.special" { - expect(cosh32(0.0) == 1.0); - expect(cosh32(-0.0) == 1.0); - expect(math.isPositiveInf(cosh32(math.inf(f32)))); - expect(math.isPositiveInf(cosh32(-math.inf(f32)))); - expect(math.isNan(cosh32(math.nan(f32)))); + try expect(cosh32(0.0) == 1.0); + try expect(cosh32(-0.0) == 1.0); + try expect(math.isPositiveInf(cosh32(math.inf(f32)))); + try expect(math.isPositiveInf(cosh32(-math.inf(f32)))); + try expect(math.isNan(cosh32(math.nan(f32)))); } test "math.cosh64.special" { - expect(cosh64(0.0) == 1.0); - expect(cosh64(-0.0) == 1.0); - expect(math.isPositiveInf(cosh64(math.inf(f64)))); - expect(math.isPositiveInf(cosh64(-math.inf(f64)))); - expect(math.isNan(cosh64(math.nan(f64)))); + try expect(cosh64(0.0) == 1.0); + try expect(cosh64(-0.0) == 1.0); + try expect(math.isPositiveInf(cosh64(math.inf(f64)))); + try expect(math.isPositiveInf(cosh64(-math.inf(f64)))); + try expect(math.isNan(cosh64(math.nan(f64)))); } diff --git a/lib/std/math/exp.zig b/lib/std/math/exp.zig index 1156cc6c5a..43da387e46 100644 --- a/lib/std/math/exp.zig +++ b/lib/std/math/exp.zig @@ -187,36 +187,36 @@ fn exp64(x_: f64) f64 { } test "math.exp" { - expect(exp(@as(f32, 0.0)) == exp32(0.0)); - expect(exp(@as(f64, 0.0)) == exp64(0.0)); + try expect(exp(@as(f32, 0.0)) == exp32(0.0)); + try expect(exp(@as(f64, 0.0)) == exp64(0.0)); } test "math.exp32" { const epsilon = 0.000001; - expect(exp32(0.0) == 1.0); - expect(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon)); - expect(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon)); - expect(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon)); + try expect(exp32(0.0) == 1.0); + try expect(math.approxEqAbs(f32, exp32(0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, exp32(0.2), 1.221403, epsilon)); + try expect(math.approxEqAbs(f32, exp32(0.8923), 2.440737, epsilon)); + try expect(math.approxEqAbs(f32, exp32(1.5), 4.481689, epsilon)); } test "math.exp64" { const epsilon = 0.000001; - expect(exp64(0.0) == 1.0); - expect(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon)); - expect(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon)); - expect(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon)); - expect(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon)); + try expect(exp64(0.0) == 1.0); + try expect(math.approxEqAbs(f64, exp64(0.0), 1.0, epsilon)); + try expect(math.approxEqAbs(f64, exp64(0.2), 1.221403, epsilon)); + try expect(math.approxEqAbs(f64, exp64(0.8923), 2.440737, epsilon)); + try expect(math.approxEqAbs(f64, exp64(1.5), 4.481689, epsilon)); } test "math.exp32.special" { - expect(math.isPositiveInf(exp32(math.inf(f32)))); - expect(math.isNan(exp32(math.nan(f32)))); + try expect(math.isPositiveInf(exp32(math.inf(f32)))); + try expect(math.isNan(exp32(math.nan(f32)))); } test "math.exp64.special" { - expect(math.isPositiveInf(exp64(math.inf(f64)))); - expect(math.isNan(exp64(math.nan(f64)))); + try expect(math.isPositiveInf(exp64(math.inf(f64)))); + try expect(math.isNan(exp64(math.nan(f64)))); } diff --git a/lib/std/math/exp2.zig b/lib/std/math/exp2.zig index 155d10c7f1..e01c997dd7 100644 --- a/lib/std/math/exp2.zig +++ b/lib/std/math/exp2.zig @@ -426,35 +426,35 @@ fn exp2_64(x: f64) f64 { } test "math.exp2" { - expect(exp2(@as(f32, 0.8923)) == exp2_32(0.8923)); - expect(exp2(@as(f64, 0.8923)) == exp2_64(0.8923)); + try expect(exp2(@as(f32, 0.8923)) == exp2_32(0.8923)); + try expect(exp2(@as(f64, 0.8923)) == exp2_64(0.8923)); } test "math.exp2_32" { const epsilon = 0.000001; - expect(exp2_32(0.0) == 1.0); - expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon)); - expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon)); - expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon)); - expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon)); + try expect(exp2_32(0.0) == 1.0); + try expect(math.approxEqAbs(f32, exp2_32(0.2), 1.148698, epsilon)); + try expect(math.approxEqAbs(f32, exp2_32(0.8923), 1.856133, epsilon)); + try expect(math.approxEqAbs(f32, exp2_32(1.5), 2.828427, epsilon)); + try expect(math.approxEqAbs(f32, exp2_32(37.45), 187747237888, epsilon)); } test "math.exp2_64" { const epsilon = 0.000001; - expect(exp2_64(0.0) == 1.0); - expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon)); - expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon)); - expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon)); + try expect(exp2_64(0.0) == 1.0); + try expect(math.approxEqAbs(f64, exp2_64(0.2), 1.148698, epsilon)); + try expect(math.approxEqAbs(f64, exp2_64(0.8923), 1.856133, epsilon)); + try expect(math.approxEqAbs(f64, exp2_64(1.5), 2.828427, epsilon)); } test "math.exp2_32.special" { - expect(math.isPositiveInf(exp2_32(math.inf(f32)))); - expect(math.isNan(exp2_32(math.nan(f32)))); + try expect(math.isPositiveInf(exp2_32(math.inf(f32)))); + try expect(math.isNan(exp2_32(math.nan(f32)))); } test "math.exp2_64.special" { - expect(math.isPositiveInf(exp2_64(math.inf(f64)))); - expect(math.isNan(exp2_64(math.nan(f64)))); + try expect(math.isPositiveInf(exp2_64(math.inf(f64)))); + try expect(math.isNan(exp2_64(math.nan(f64)))); } diff --git a/lib/std/math/expm1.zig b/lib/std/math/expm1.zig index 8389b01eb9..7563194880 100644 --- a/lib/std/math/expm1.zig +++ b/lib/std/math/expm1.zig @@ -292,42 +292,42 @@ fn expm1_64(x_: f64) f64 { } test "math.exp1m" { - expect(expm1(@as(f32, 0.0)) == expm1_32(0.0)); - expect(expm1(@as(f64, 0.0)) == expm1_64(0.0)); + try expect(expm1(@as(f32, 0.0)) == expm1_32(0.0)); + try expect(expm1(@as(f64, 0.0)) == expm1_64(0.0)); } test "math.expm1_32" { const epsilon = 0.000001; - expect(expm1_32(0.0) == 0.0); - expect(math.approxEqAbs(f32, expm1_32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, expm1_32(0.2), 0.221403, epsilon)); - expect(math.approxEqAbs(f32, expm1_32(0.8923), 1.440737, epsilon)); - expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon)); + try expect(expm1_32(0.0) == 0.0); + try expect(math.approxEqAbs(f32, expm1_32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, expm1_32(0.2), 0.221403, epsilon)); + try expect(math.approxEqAbs(f32, expm1_32(0.8923), 1.440737, epsilon)); + try expect(math.approxEqAbs(f32, expm1_32(1.5), 3.481689, epsilon)); } test "math.expm1_64" { const epsilon = 0.000001; - expect(expm1_64(0.0) == 0.0); - expect(math.approxEqAbs(f64, expm1_64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, expm1_64(0.2), 0.221403, epsilon)); - expect(math.approxEqAbs(f64, expm1_64(0.8923), 1.440737, epsilon)); - expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon)); + try expect(expm1_64(0.0) == 0.0); + try expect(math.approxEqAbs(f64, expm1_64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, expm1_64(0.2), 0.221403, epsilon)); + try expect(math.approxEqAbs(f64, expm1_64(0.8923), 1.440737, epsilon)); + try expect(math.approxEqAbs(f64, expm1_64(1.5), 3.481689, epsilon)); } test "math.expm1_32.special" { const epsilon = 0.000001; - expect(math.isPositiveInf(expm1_32(math.inf(f32)))); - expect(expm1_32(-math.inf(f32)) == -1.0); - expect(math.isNan(expm1_32(math.nan(f32)))); + try expect(math.isPositiveInf(expm1_32(math.inf(f32)))); + try expect(expm1_32(-math.inf(f32)) == -1.0); + try expect(math.isNan(expm1_32(math.nan(f32)))); } test "math.expm1_64.special" { const epsilon = 0.000001; - expect(math.isPositiveInf(expm1_64(math.inf(f64)))); - expect(expm1_64(-math.inf(f64)) == -1.0); - expect(math.isNan(expm1_64(math.nan(f64)))); + try expect(math.isPositiveInf(expm1_64(math.inf(f64)))); + try expect(expm1_64(-math.inf(f64)) == -1.0); + try expect(math.isNan(expm1_64(math.nan(f64)))); } diff --git a/lib/std/math/fabs.zig b/lib/std/math/fabs.zig index d59d185b99..0b3c800b12 100644 --- a/lib/std/math/fabs.zig +++ b/lib/std/math/fabs.zig @@ -55,52 +55,52 @@ fn fabs128(x: f128) f128 { } test "math.fabs" { - expect(fabs(@as(f16, 1.0)) == fabs16(1.0)); - expect(fabs(@as(f32, 1.0)) == fabs32(1.0)); - expect(fabs(@as(f64, 1.0)) == fabs64(1.0)); - expect(fabs(@as(f128, 1.0)) == fabs128(1.0)); + try expect(fabs(@as(f16, 1.0)) == fabs16(1.0)); + try expect(fabs(@as(f32, 1.0)) == fabs32(1.0)); + try expect(fabs(@as(f64, 1.0)) == fabs64(1.0)); + try expect(fabs(@as(f128, 1.0)) == fabs128(1.0)); } test "math.fabs16" { - expect(fabs16(1.0) == 1.0); - expect(fabs16(-1.0) == 1.0); + try expect(fabs16(1.0) == 1.0); + try expect(fabs16(-1.0) == 1.0); } test "math.fabs32" { - expect(fabs32(1.0) == 1.0); - expect(fabs32(-1.0) == 1.0); + try expect(fabs32(1.0) == 1.0); + try expect(fabs32(-1.0) == 1.0); } test "math.fabs64" { - expect(fabs64(1.0) == 1.0); - expect(fabs64(-1.0) == 1.0); + try expect(fabs64(1.0) == 1.0); + try expect(fabs64(-1.0) == 1.0); } test "math.fabs128" { - expect(fabs128(1.0) == 1.0); - expect(fabs128(-1.0) == 1.0); + try expect(fabs128(1.0) == 1.0); + try expect(fabs128(-1.0) == 1.0); } test "math.fabs16.special" { - expect(math.isPositiveInf(fabs(math.inf(f16)))); - expect(math.isPositiveInf(fabs(-math.inf(f16)))); - expect(math.isNan(fabs(math.nan(f16)))); + try expect(math.isPositiveInf(fabs(math.inf(f16)))); + try expect(math.isPositiveInf(fabs(-math.inf(f16)))); + try expect(math.isNan(fabs(math.nan(f16)))); } test "math.fabs32.special" { - expect(math.isPositiveInf(fabs(math.inf(f32)))); - expect(math.isPositiveInf(fabs(-math.inf(f32)))); - expect(math.isNan(fabs(math.nan(f32)))); + try expect(math.isPositiveInf(fabs(math.inf(f32)))); + try expect(math.isPositiveInf(fabs(-math.inf(f32)))); + try expect(math.isNan(fabs(math.nan(f32)))); } test "math.fabs64.special" { - expect(math.isPositiveInf(fabs(math.inf(f64)))); - expect(math.isPositiveInf(fabs(-math.inf(f64)))); - expect(math.isNan(fabs(math.nan(f64)))); + try expect(math.isPositiveInf(fabs(math.inf(f64)))); + try expect(math.isPositiveInf(fabs(-math.inf(f64)))); + try expect(math.isNan(fabs(math.nan(f64)))); } test "math.fabs128.special" { - expect(math.isPositiveInf(fabs(math.inf(f128)))); - expect(math.isPositiveInf(fabs(-math.inf(f128)))); - expect(math.isNan(fabs(math.nan(f128)))); + try expect(math.isPositiveInf(fabs(math.inf(f128)))); + try expect(math.isPositiveInf(fabs(-math.inf(f128)))); + try expect(math.isNan(fabs(math.nan(f128)))); } diff --git a/lib/std/math/floor.zig b/lib/std/math/floor.zig index 6e0b99f47c..ea70ce3969 100644 --- a/lib/std/math/floor.zig +++ b/lib/std/math/floor.zig @@ -156,64 +156,64 @@ fn floor128(x: f128) f128 { } test "math.floor" { - expect(floor(@as(f16, 1.3)) == floor16(1.3)); - expect(floor(@as(f32, 1.3)) == floor32(1.3)); - expect(floor(@as(f64, 1.3)) == floor64(1.3)); - expect(floor(@as(f128, 1.3)) == floor128(1.3)); + try expect(floor(@as(f16, 1.3)) == floor16(1.3)); + try expect(floor(@as(f32, 1.3)) == floor32(1.3)); + try expect(floor(@as(f64, 1.3)) == floor64(1.3)); + try expect(floor(@as(f128, 1.3)) == floor128(1.3)); } test "math.floor16" { - expect(floor16(1.3) == 1.0); - expect(floor16(-1.3) == -2.0); - expect(floor16(0.2) == 0.0); + try expect(floor16(1.3) == 1.0); + try expect(floor16(-1.3) == -2.0); + try expect(floor16(0.2) == 0.0); } test "math.floor32" { - expect(floor32(1.3) == 1.0); - expect(floor32(-1.3) == -2.0); - expect(floor32(0.2) == 0.0); + try expect(floor32(1.3) == 1.0); + try expect(floor32(-1.3) == -2.0); + try expect(floor32(0.2) == 0.0); } test "math.floor64" { - expect(floor64(1.3) == 1.0); - expect(floor64(-1.3) == -2.0); - expect(floor64(0.2) == 0.0); + try expect(floor64(1.3) == 1.0); + try expect(floor64(-1.3) == -2.0); + try expect(floor64(0.2) == 0.0); } test "math.floor128" { - expect(floor128(1.3) == 1.0); - expect(floor128(-1.3) == -2.0); - expect(floor128(0.2) == 0.0); + try expect(floor128(1.3) == 1.0); + try expect(floor128(-1.3) == -2.0); + try expect(floor128(0.2) == 0.0); } test "math.floor16.special" { - expect(floor16(0.0) == 0.0); - expect(floor16(-0.0) == -0.0); - expect(math.isPositiveInf(floor16(math.inf(f16)))); - expect(math.isNegativeInf(floor16(-math.inf(f16)))); - expect(math.isNan(floor16(math.nan(f16)))); + try expect(floor16(0.0) == 0.0); + try expect(floor16(-0.0) == -0.0); + try expect(math.isPositiveInf(floor16(math.inf(f16)))); + try expect(math.isNegativeInf(floor16(-math.inf(f16)))); + try expect(math.isNan(floor16(math.nan(f16)))); } test "math.floor32.special" { - expect(floor32(0.0) == 0.0); - expect(floor32(-0.0) == -0.0); - expect(math.isPositiveInf(floor32(math.inf(f32)))); - expect(math.isNegativeInf(floor32(-math.inf(f32)))); - expect(math.isNan(floor32(math.nan(f32)))); + try expect(floor32(0.0) == 0.0); + try expect(floor32(-0.0) == -0.0); + try expect(math.isPositiveInf(floor32(math.inf(f32)))); + try expect(math.isNegativeInf(floor32(-math.inf(f32)))); + try expect(math.isNan(floor32(math.nan(f32)))); } test "math.floor64.special" { - expect(floor64(0.0) == 0.0); - expect(floor64(-0.0) == -0.0); - expect(math.isPositiveInf(floor64(math.inf(f64)))); - expect(math.isNegativeInf(floor64(-math.inf(f64)))); - expect(math.isNan(floor64(math.nan(f64)))); + try expect(floor64(0.0) == 0.0); + try expect(floor64(-0.0) == -0.0); + try expect(math.isPositiveInf(floor64(math.inf(f64)))); + try expect(math.isNegativeInf(floor64(-math.inf(f64)))); + try expect(math.isNan(floor64(math.nan(f64)))); } test "math.floor128.special" { - expect(floor128(0.0) == 0.0); - expect(floor128(-0.0) == -0.0); - expect(math.isPositiveInf(floor128(math.inf(f128)))); - expect(math.isNegativeInf(floor128(-math.inf(f128)))); - expect(math.isNan(floor128(math.nan(f128)))); + try expect(floor128(0.0) == 0.0); + try expect(floor128(-0.0) == -0.0); + try expect(math.isPositiveInf(floor128(math.inf(f128)))); + try expect(math.isNegativeInf(floor128(-math.inf(f128)))); + try expect(math.isNan(floor128(math.nan(f128)))); } diff --git a/lib/std/math/fma.zig b/lib/std/math/fma.zig index 1b04e1aa18..0bc3271e36 100644 --- a/lib/std/math/fma.zig +++ b/lib/std/math/fma.zig @@ -148,30 +148,30 @@ fn add_and_denorm(a: f64, b: f64, scale: i32) f64 { } test "math.fma" { - expect(fma(f32, 0.0, 1.0, 1.0) == fma32(0.0, 1.0, 1.0)); - expect(fma(f64, 0.0, 1.0, 1.0) == fma64(0.0, 1.0, 1.0)); + try expect(fma(f32, 0.0, 1.0, 1.0) == fma32(0.0, 1.0, 1.0)); + try expect(fma(f64, 0.0, 1.0, 1.0) == fma64(0.0, 1.0, 1.0)); } test "math.fma32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon)); - expect(math.approxEqAbs(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon)); - expect(math.approxEqAbs(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon)); - expect(math.approxEqAbs(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon)); - expect(math.approxEqAbs(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon)); - expect(math.approxEqAbs(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon)); - expect(math.approxEqAbs(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); + try expect(math.approxEqAbs(f32, fma32(0.0, 5.0, 9.124), 9.124, epsilon)); + try expect(math.approxEqAbs(f32, fma32(0.2, 5.0, 9.124), 10.124, epsilon)); + try expect(math.approxEqAbs(f32, fma32(0.8923, 5.0, 9.124), 13.5855, epsilon)); + try expect(math.approxEqAbs(f32, fma32(1.5, 5.0, 9.124), 16.624, epsilon)); + try expect(math.approxEqAbs(f32, fma32(37.45, 5.0, 9.124), 196.374004, epsilon)); + try expect(math.approxEqAbs(f32, fma32(89.123, 5.0, 9.124), 454.739005, epsilon)); + try expect(math.approxEqAbs(f32, fma32(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); } test "math.fma64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon)); - expect(math.approxEqAbs(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon)); - expect(math.approxEqAbs(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon)); - expect(math.approxEqAbs(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon)); - expect(math.approxEqAbs(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon)); - expect(math.approxEqAbs(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon)); - expect(math.approxEqAbs(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); + try expect(math.approxEqAbs(f64, fma64(0.0, 5.0, 9.124), 9.124, epsilon)); + try expect(math.approxEqAbs(f64, fma64(0.2, 5.0, 9.124), 10.124, epsilon)); + try expect(math.approxEqAbs(f64, fma64(0.8923, 5.0, 9.124), 13.5855, epsilon)); + try expect(math.approxEqAbs(f64, fma64(1.5, 5.0, 9.124), 16.624, epsilon)); + try expect(math.approxEqAbs(f64, fma64(37.45, 5.0, 9.124), 196.374, epsilon)); + try expect(math.approxEqAbs(f64, fma64(89.123, 5.0, 9.124), 454.739, epsilon)); + try expect(math.approxEqAbs(f64, fma64(123123.234375, 5.0, 9.124), 615625.295875, epsilon)); } diff --git a/lib/std/math/frexp.zig b/lib/std/math/frexp.zig index 5f7bafb494..4f3a03b0bc 100644 --- a/lib/std/math/frexp.zig +++ b/lib/std/math/frexp.zig @@ -115,11 +115,11 @@ fn frexp64(x: f64) frexp64_result { test "math.frexp" { const a = frexp(@as(f32, 1.3)); const b = frexp32(1.3); - expect(a.significand == b.significand and a.exponent == b.exponent); + try expect(a.significand == b.significand and a.exponent == b.exponent); const c = frexp(@as(f64, 1.3)); const d = frexp64(1.3); - expect(c.significand == d.significand and c.exponent == d.exponent); + try expect(c.significand == d.significand and c.exponent == d.exponent); } test "math.frexp32" { @@ -127,10 +127,10 @@ test "math.frexp32" { var r: frexp32_result = undefined; r = frexp32(1.3); - expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1); + try expect(math.approxEqAbs(f32, r.significand, 0.65, epsilon) and r.exponent == 1); r = frexp32(78.0234); - expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7); + try expect(math.approxEqAbs(f32, r.significand, 0.609558, epsilon) and r.exponent == 7); } test "math.frexp64" { @@ -138,46 +138,46 @@ test "math.frexp64" { var r: frexp64_result = undefined; r = frexp64(1.3); - expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1); + try expect(math.approxEqAbs(f64, r.significand, 0.65, epsilon) and r.exponent == 1); r = frexp64(78.0234); - expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7); + try expect(math.approxEqAbs(f64, r.significand, 0.609558, epsilon) and r.exponent == 7); } test "math.frexp32.special" { var r: frexp32_result = undefined; r = frexp32(0.0); - expect(r.significand == 0.0 and r.exponent == 0); + try expect(r.significand == 0.0 and r.exponent == 0); r = frexp32(-0.0); - expect(r.significand == -0.0 and r.exponent == 0); + try expect(r.significand == -0.0 and r.exponent == 0); r = frexp32(math.inf(f32)); - expect(math.isPositiveInf(r.significand) and r.exponent == 0); + try expect(math.isPositiveInf(r.significand) and r.exponent == 0); r = frexp32(-math.inf(f32)); - expect(math.isNegativeInf(r.significand) and r.exponent == 0); + try expect(math.isNegativeInf(r.significand) and r.exponent == 0); r = frexp32(math.nan(f32)); - expect(math.isNan(r.significand)); + try expect(math.isNan(r.significand)); } test "math.frexp64.special" { var r: frexp64_result = undefined; r = frexp64(0.0); - expect(r.significand == 0.0 and r.exponent == 0); + try expect(r.significand == 0.0 and r.exponent == 0); r = frexp64(-0.0); - expect(r.significand == -0.0 and r.exponent == 0); + try expect(r.significand == -0.0 and r.exponent == 0); r = frexp64(math.inf(f64)); - expect(math.isPositiveInf(r.significand) and r.exponent == 0); + try expect(math.isPositiveInf(r.significand) and r.exponent == 0); r = frexp64(-math.inf(f64)); - expect(math.isNegativeInf(r.significand) and r.exponent == 0); + try expect(math.isNegativeInf(r.significand) and r.exponent == 0); r = frexp64(math.nan(f64)); - expect(math.isNan(r.significand)); + try expect(math.isNan(r.significand)); } diff --git a/lib/std/math/hypot.zig b/lib/std/math/hypot.zig index 78aef476f9..61f172aa6a 100644 --- a/lib/std/math/hypot.zig +++ b/lib/std/math/hypot.zig @@ -126,48 +126,48 @@ fn hypot64(x: f64, y: f64) f64 { } test "math.hypot" { - expect(hypot(f32, 0.0, -1.2) == hypot32(0.0, -1.2)); - expect(hypot(f64, 0.0, -1.2) == hypot64(0.0, -1.2)); + try expect(hypot(f32, 0.0, -1.2) == hypot32(0.0, -1.2)); + try expect(hypot(f64, 0.0, -1.2) == hypot64(0.0, -1.2)); } test "math.hypot32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon)); - expect(math.approxEqAbs(f32, hypot32(0.2, -0.34), 0.394462, epsilon)); - expect(math.approxEqAbs(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon)); - expect(math.approxEqAbs(f32, hypot32(1.5, 5.25), 5.460083, epsilon)); - expect(math.approxEqAbs(f32, hypot32(37.45, 159.835), 164.163742, epsilon)); - expect(math.approxEqAbs(f32, hypot32(89.123, 382.028905), 392.286865, epsilon)); - expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(0.0, -1.2), 1.2, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(0.2, -0.34), 0.394462, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(0.8923, 2.636890), 2.783772, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(1.5, 5.25), 5.460083, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(37.45, 159.835), 164.163742, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(89.123, 382.028905), 392.286865, epsilon)); + try expect(math.approxEqAbs(f32, hypot32(123123.234375, 529428.707813), 543556.875, epsilon)); } test "math.hypot64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon)); - expect(math.approxEqAbs(f64, hypot64(0.2, -0.34), 0.394462, epsilon)); - expect(math.approxEqAbs(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon)); - expect(math.approxEqAbs(f64, hypot64(1.5, 5.25), 5.460082, epsilon)); - expect(math.approxEqAbs(f64, hypot64(37.45, 159.835), 164.163728, epsilon)); - expect(math.approxEqAbs(f64, hypot64(89.123, 382.028905), 392.286876, epsilon)); - expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(0.0, -1.2), 1.2, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(0.2, -0.34), 0.394462, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(0.8923, 2.636890), 2.783772, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(1.5, 5.25), 5.460082, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(37.45, 159.835), 164.163728, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(89.123, 382.028905), 392.286876, epsilon)); + try expect(math.approxEqAbs(f64, hypot64(123123.234375, 529428.707813), 543556.885247, epsilon)); } test "math.hypot32.special" { - expect(math.isPositiveInf(hypot32(math.inf(f32), 0.0))); - expect(math.isPositiveInf(hypot32(-math.inf(f32), 0.0))); - expect(math.isPositiveInf(hypot32(0.0, math.inf(f32)))); - expect(math.isPositiveInf(hypot32(0.0, -math.inf(f32)))); - expect(math.isNan(hypot32(math.nan(f32), 0.0))); - expect(math.isNan(hypot32(0.0, math.nan(f32)))); + try expect(math.isPositiveInf(hypot32(math.inf(f32), 0.0))); + try expect(math.isPositiveInf(hypot32(-math.inf(f32), 0.0))); + try expect(math.isPositiveInf(hypot32(0.0, math.inf(f32)))); + try expect(math.isPositiveInf(hypot32(0.0, -math.inf(f32)))); + try expect(math.isNan(hypot32(math.nan(f32), 0.0))); + try expect(math.isNan(hypot32(0.0, math.nan(f32)))); } test "math.hypot64.special" { - expect(math.isPositiveInf(hypot64(math.inf(f64), 0.0))); - expect(math.isPositiveInf(hypot64(-math.inf(f64), 0.0))); - expect(math.isPositiveInf(hypot64(0.0, math.inf(f64)))); - expect(math.isPositiveInf(hypot64(0.0, -math.inf(f64)))); - expect(math.isNan(hypot64(math.nan(f64), 0.0))); - expect(math.isNan(hypot64(0.0, math.nan(f64)))); + try expect(math.isPositiveInf(hypot64(math.inf(f64), 0.0))); + try expect(math.isPositiveInf(hypot64(-math.inf(f64), 0.0))); + try expect(math.isPositiveInf(hypot64(0.0, math.inf(f64)))); + try expect(math.isPositiveInf(hypot64(0.0, -math.inf(f64)))); + try expect(math.isNan(hypot64(math.nan(f64), 0.0))); + try expect(math.isNan(hypot64(0.0, math.nan(f64)))); } diff --git a/lib/std/math/ilogb.zig b/lib/std/math/ilogb.zig index e43012b831..deafeda7ce 100644 --- a/lib/std/math/ilogb.zig +++ b/lib/std/math/ilogb.zig @@ -106,38 +106,38 @@ fn ilogb64(x: f64) i32 { } test "math.ilogb" { - expect(ilogb(@as(f32, 0.2)) == ilogb32(0.2)); - expect(ilogb(@as(f64, 0.2)) == ilogb64(0.2)); + try expect(ilogb(@as(f32, 0.2)) == ilogb32(0.2)); + try expect(ilogb(@as(f64, 0.2)) == ilogb64(0.2)); } test "math.ilogb32" { - expect(ilogb32(0.0) == fp_ilogb0); - expect(ilogb32(0.5) == -1); - expect(ilogb32(0.8923) == -1); - expect(ilogb32(10.0) == 3); - expect(ilogb32(-123984) == 16); - expect(ilogb32(2398.23) == 11); + try expect(ilogb32(0.0) == fp_ilogb0); + try expect(ilogb32(0.5) == -1); + try expect(ilogb32(0.8923) == -1); + try expect(ilogb32(10.0) == 3); + try expect(ilogb32(-123984) == 16); + try expect(ilogb32(2398.23) == 11); } test "math.ilogb64" { - expect(ilogb64(0.0) == fp_ilogb0); - expect(ilogb64(0.5) == -1); - expect(ilogb64(0.8923) == -1); - expect(ilogb64(10.0) == 3); - expect(ilogb64(-123984) == 16); - expect(ilogb64(2398.23) == 11); + try expect(ilogb64(0.0) == fp_ilogb0); + try expect(ilogb64(0.5) == -1); + try expect(ilogb64(0.8923) == -1); + try expect(ilogb64(10.0) == 3); + try expect(ilogb64(-123984) == 16); + try expect(ilogb64(2398.23) == 11); } test "math.ilogb32.special" { - expect(ilogb32(math.inf(f32)) == maxInt(i32)); - expect(ilogb32(-math.inf(f32)) == maxInt(i32)); - expect(ilogb32(0.0) == minInt(i32)); - expect(ilogb32(math.nan(f32)) == maxInt(i32)); + try expect(ilogb32(math.inf(f32)) == maxInt(i32)); + try expect(ilogb32(-math.inf(f32)) == maxInt(i32)); + try expect(ilogb32(0.0) == minInt(i32)); + try expect(ilogb32(math.nan(f32)) == maxInt(i32)); } test "math.ilogb64.special" { - expect(ilogb64(math.inf(f64)) == maxInt(i32)); - expect(ilogb64(-math.inf(f64)) == maxInt(i32)); - expect(ilogb64(0.0) == minInt(i32)); - expect(ilogb64(math.nan(f64)) == maxInt(i32)); + try expect(ilogb64(math.inf(f64)) == maxInt(i32)); + try expect(ilogb64(-math.inf(f64)) == maxInt(i32)); + try expect(ilogb64(0.0) == minInt(i32)); + try expect(ilogb64(math.nan(f64)) == maxInt(i32)); } diff --git a/lib/std/math/isfinite.zig b/lib/std/math/isfinite.zig index 11a352b042..68aec258b0 100644 --- a/lib/std/math/isfinite.zig +++ b/lib/std/math/isfinite.zig @@ -35,30 +35,30 @@ pub fn isFinite(x: anytype) bool { } test "math.isFinite" { - expect(isFinite(@as(f16, 0.0))); - expect(isFinite(@as(f16, -0.0))); - expect(isFinite(@as(f32, 0.0))); - expect(isFinite(@as(f32, -0.0))); - expect(isFinite(@as(f64, 0.0))); - expect(isFinite(@as(f64, -0.0))); - expect(isFinite(@as(f128, 0.0))); - expect(isFinite(@as(f128, -0.0))); + try expect(isFinite(@as(f16, 0.0))); + try expect(isFinite(@as(f16, -0.0))); + try expect(isFinite(@as(f32, 0.0))); + try expect(isFinite(@as(f32, -0.0))); + try expect(isFinite(@as(f64, 0.0))); + try expect(isFinite(@as(f64, -0.0))); + try expect(isFinite(@as(f128, 0.0))); + try expect(isFinite(@as(f128, -0.0))); - expect(!isFinite(math.inf(f16))); - expect(!isFinite(-math.inf(f16))); - expect(!isFinite(math.inf(f32))); - expect(!isFinite(-math.inf(f32))); - expect(!isFinite(math.inf(f64))); - expect(!isFinite(-math.inf(f64))); - expect(!isFinite(math.inf(f128))); - expect(!isFinite(-math.inf(f128))); + try expect(!isFinite(math.inf(f16))); + try expect(!isFinite(-math.inf(f16))); + try expect(!isFinite(math.inf(f32))); + try expect(!isFinite(-math.inf(f32))); + try expect(!isFinite(math.inf(f64))); + try expect(!isFinite(-math.inf(f64))); + try expect(!isFinite(math.inf(f128))); + try expect(!isFinite(-math.inf(f128))); - expect(!isFinite(math.nan(f16))); - expect(!isFinite(-math.nan(f16))); - expect(!isFinite(math.nan(f32))); - expect(!isFinite(-math.nan(f32))); - expect(!isFinite(math.nan(f64))); - expect(!isFinite(-math.nan(f64))); - expect(!isFinite(math.nan(f128))); - expect(!isFinite(-math.nan(f128))); + try expect(!isFinite(math.nan(f16))); + try expect(!isFinite(-math.nan(f16))); + try expect(!isFinite(math.nan(f32))); + try expect(!isFinite(-math.nan(f32))); + try expect(!isFinite(math.nan(f64))); + try expect(!isFinite(-math.nan(f64))); + try expect(!isFinite(math.nan(f128))); + try expect(!isFinite(-math.nan(f128))); } diff --git a/lib/std/math/isinf.zig b/lib/std/math/isinf.zig index b7c3199f15..792e6b38f3 100644 --- a/lib/std/math/isinf.zig +++ b/lib/std/math/isinf.zig @@ -79,58 +79,58 @@ pub fn isNegativeInf(x: anytype) bool { } test "math.isInf" { - expect(!isInf(@as(f16, 0.0))); - expect(!isInf(@as(f16, -0.0))); - expect(!isInf(@as(f32, 0.0))); - expect(!isInf(@as(f32, -0.0))); - expect(!isInf(@as(f64, 0.0))); - expect(!isInf(@as(f64, -0.0))); - expect(!isInf(@as(f128, 0.0))); - expect(!isInf(@as(f128, -0.0))); - expect(isInf(math.inf(f16))); - expect(isInf(-math.inf(f16))); - expect(isInf(math.inf(f32))); - expect(isInf(-math.inf(f32))); - expect(isInf(math.inf(f64))); - expect(isInf(-math.inf(f64))); - expect(isInf(math.inf(f128))); - expect(isInf(-math.inf(f128))); + try expect(!isInf(@as(f16, 0.0))); + try expect(!isInf(@as(f16, -0.0))); + try expect(!isInf(@as(f32, 0.0))); + try expect(!isInf(@as(f32, -0.0))); + try expect(!isInf(@as(f64, 0.0))); + try expect(!isInf(@as(f64, -0.0))); + try expect(!isInf(@as(f128, 0.0))); + try expect(!isInf(@as(f128, -0.0))); + try expect(isInf(math.inf(f16))); + try expect(isInf(-math.inf(f16))); + try expect(isInf(math.inf(f32))); + try expect(isInf(-math.inf(f32))); + try expect(isInf(math.inf(f64))); + try expect(isInf(-math.inf(f64))); + try expect(isInf(math.inf(f128))); + try expect(isInf(-math.inf(f128))); } test "math.isPositiveInf" { - expect(!isPositiveInf(@as(f16, 0.0))); - expect(!isPositiveInf(@as(f16, -0.0))); - expect(!isPositiveInf(@as(f32, 0.0))); - expect(!isPositiveInf(@as(f32, -0.0))); - expect(!isPositiveInf(@as(f64, 0.0))); - expect(!isPositiveInf(@as(f64, -0.0))); - expect(!isPositiveInf(@as(f128, 0.0))); - expect(!isPositiveInf(@as(f128, -0.0))); - expect(isPositiveInf(math.inf(f16))); - expect(!isPositiveInf(-math.inf(f16))); - expect(isPositiveInf(math.inf(f32))); - expect(!isPositiveInf(-math.inf(f32))); - expect(isPositiveInf(math.inf(f64))); - expect(!isPositiveInf(-math.inf(f64))); - expect(isPositiveInf(math.inf(f128))); - expect(!isPositiveInf(-math.inf(f128))); + try expect(!isPositiveInf(@as(f16, 0.0))); + try expect(!isPositiveInf(@as(f16, -0.0))); + try expect(!isPositiveInf(@as(f32, 0.0))); + try expect(!isPositiveInf(@as(f32, -0.0))); + try expect(!isPositiveInf(@as(f64, 0.0))); + try expect(!isPositiveInf(@as(f64, -0.0))); + try expect(!isPositiveInf(@as(f128, 0.0))); + try expect(!isPositiveInf(@as(f128, -0.0))); + try expect(isPositiveInf(math.inf(f16))); + try expect(!isPositiveInf(-math.inf(f16))); + try expect(isPositiveInf(math.inf(f32))); + try expect(!isPositiveInf(-math.inf(f32))); + try expect(isPositiveInf(math.inf(f64))); + try expect(!isPositiveInf(-math.inf(f64))); + try expect(isPositiveInf(math.inf(f128))); + try expect(!isPositiveInf(-math.inf(f128))); } test "math.isNegativeInf" { - expect(!isNegativeInf(@as(f16, 0.0))); - expect(!isNegativeInf(@as(f16, -0.0))); - expect(!isNegativeInf(@as(f32, 0.0))); - expect(!isNegativeInf(@as(f32, -0.0))); - expect(!isNegativeInf(@as(f64, 0.0))); - expect(!isNegativeInf(@as(f64, -0.0))); - expect(!isNegativeInf(@as(f128, 0.0))); - expect(!isNegativeInf(@as(f128, -0.0))); - expect(!isNegativeInf(math.inf(f16))); - expect(isNegativeInf(-math.inf(f16))); - expect(!isNegativeInf(math.inf(f32))); - expect(isNegativeInf(-math.inf(f32))); - expect(!isNegativeInf(math.inf(f64))); - expect(isNegativeInf(-math.inf(f64))); - expect(!isNegativeInf(math.inf(f128))); - expect(isNegativeInf(-math.inf(f128))); + try expect(!isNegativeInf(@as(f16, 0.0))); + try expect(!isNegativeInf(@as(f16, -0.0))); + try expect(!isNegativeInf(@as(f32, 0.0))); + try expect(!isNegativeInf(@as(f32, -0.0))); + try expect(!isNegativeInf(@as(f64, 0.0))); + try expect(!isNegativeInf(@as(f64, -0.0))); + try expect(!isNegativeInf(@as(f128, 0.0))); + try expect(!isNegativeInf(@as(f128, -0.0))); + try expect(!isNegativeInf(math.inf(f16))); + try expect(isNegativeInf(-math.inf(f16))); + try expect(!isNegativeInf(math.inf(f32))); + try expect(isNegativeInf(-math.inf(f32))); + try expect(!isNegativeInf(math.inf(f64))); + try expect(isNegativeInf(-math.inf(f64))); + try expect(!isNegativeInf(math.inf(f128))); + try expect(isNegativeInf(-math.inf(f128))); } diff --git a/lib/std/math/isnan.zig b/lib/std/math/isnan.zig index 498d181118..cf598322e5 100644 --- a/lib/std/math/isnan.zig +++ b/lib/std/math/isnan.zig @@ -21,12 +21,12 @@ pub fn isSignalNan(x: anytype) bool { } test "math.isNan" { - expect(isNan(math.nan(f16))); - expect(isNan(math.nan(f32))); - expect(isNan(math.nan(f64))); - expect(isNan(math.nan(f128))); - expect(!isNan(@as(f16, 1.0))); - expect(!isNan(@as(f32, 1.0))); - expect(!isNan(@as(f64, 1.0))); - expect(!isNan(@as(f128, 1.0))); + try expect(isNan(math.nan(f16))); + try expect(isNan(math.nan(f32))); + try expect(isNan(math.nan(f64))); + try expect(isNan(math.nan(f128))); + try expect(!isNan(@as(f16, 1.0))); + try expect(!isNan(@as(f32, 1.0))); + try expect(!isNan(@as(f64, 1.0))); + try expect(!isNan(@as(f128, 1.0))); } diff --git a/lib/std/math/isnormal.zig b/lib/std/math/isnormal.zig index 6317535203..b10a6e2286 100644 --- a/lib/std/math/isnormal.zig +++ b/lib/std/math/isnormal.zig @@ -31,13 +31,13 @@ pub fn isNormal(x: anytype) bool { } test "math.isNormal" { - expect(!isNormal(math.nan(f16))); - expect(!isNormal(math.nan(f32))); - expect(!isNormal(math.nan(f64))); - expect(!isNormal(@as(f16, 0))); - expect(!isNormal(@as(f32, 0))); - expect(!isNormal(@as(f64, 0))); - expect(isNormal(@as(f16, 1.0))); - expect(isNormal(@as(f32, 1.0))); - expect(isNormal(@as(f64, 1.0))); + try expect(!isNormal(math.nan(f16))); + try expect(!isNormal(math.nan(f32))); + try expect(!isNormal(math.nan(f64))); + try expect(!isNormal(@as(f16, 0))); + try expect(!isNormal(@as(f32, 0))); + try expect(!isNormal(@as(f64, 0))); + try expect(isNormal(@as(f16, 1.0))); + try expect(isNormal(@as(f32, 1.0))); + try expect(isNormal(@as(f64, 1.0))); } diff --git a/lib/std/math/ln.zig b/lib/std/math/ln.zig index ce7cb3d882..f85571fe34 100644 --- a/lib/std/math/ln.zig +++ b/lib/std/math/ln.zig @@ -153,42 +153,42 @@ pub fn ln_64(x_: f64) f64 { } test "math.ln" { - expect(ln(@as(f32, 0.2)) == ln_32(0.2)); - expect(ln(@as(f64, 0.2)) == ln_64(0.2)); + try expect(ln(@as(f32, 0.2)) == ln_32(0.2)); + try expect(ln(@as(f64, 0.2)) == ln_64(0.2)); } test "math.ln32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon)); - expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon)); - expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon)); - expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon)); - expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon)); - expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(0.2), -1.609438, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(0.8923), -0.113953, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(1.5), 0.405465, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(37.45), 3.623007, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(89.123), 4.490017, epsilon)); + try expect(math.approxEqAbs(f32, ln_32(123123.234375), 11.720941, epsilon)); } test "math.ln64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon)); - expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon)); - expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon)); - expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon)); - expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon)); - expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(0.2), -1.609438, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(0.8923), -0.113953, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(1.5), 0.405465, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(37.45), 3.623007, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(89.123), 4.490017, epsilon)); + try expect(math.approxEqAbs(f64, ln_64(123123.234375), 11.720941, epsilon)); } test "math.ln32.special" { - expect(math.isPositiveInf(ln_32(math.inf(f32)))); - expect(math.isNegativeInf(ln_32(0.0))); - expect(math.isNan(ln_32(-1.0))); - expect(math.isNan(ln_32(math.nan(f32)))); + try expect(math.isPositiveInf(ln_32(math.inf(f32)))); + try expect(math.isNegativeInf(ln_32(0.0))); + try expect(math.isNan(ln_32(-1.0))); + try expect(math.isNan(ln_32(math.nan(f32)))); } test "math.ln64.special" { - expect(math.isPositiveInf(ln_64(math.inf(f64)))); - expect(math.isNegativeInf(ln_64(0.0))); - expect(math.isNan(ln_64(-1.0))); - expect(math.isNan(ln_64(math.nan(f64)))); + try expect(math.isPositiveInf(ln_64(math.inf(f64)))); + try expect(math.isNegativeInf(ln_64(0.0))); + try expect(math.isNan(ln_64(-1.0))); + try expect(math.isNan(ln_64(math.nan(f64)))); } diff --git a/lib/std/math/log.zig b/lib/std/math/log.zig index 1a8101e67a..bf170aa95b 100644 --- a/lib/std/math/log.zig +++ b/lib/std/math/log.zig @@ -53,25 +53,25 @@ pub fn log(comptime T: type, base: T, x: T) T { } test "math.log integer" { - expect(log(u8, 2, 0x1) == 0); - expect(log(u8, 2, 0x2) == 1); - expect(log(u16, 2, 0x72) == 6); - expect(log(u32, 2, 0xFFFFFF) == 23); - expect(log(u64, 2, 0x7FF0123456789ABC) == 62); + try expect(log(u8, 2, 0x1) == 0); + try expect(log(u8, 2, 0x2) == 1); + try expect(log(u16, 2, 0x72) == 6); + try expect(log(u32, 2, 0xFFFFFF) == 23); + try expect(log(u64, 2, 0x7FF0123456789ABC) == 62); } test "math.log float" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon)); - expect(math.approxEqAbs(f32, log(f32, 89, 0.23947), -0.318432, epsilon)); - expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon)); + try expect(math.approxEqAbs(f32, log(f32, 6, 0.23947), -0.797723, epsilon)); + try expect(math.approxEqAbs(f32, log(f32, 89, 0.23947), -0.318432, epsilon)); + try expect(math.approxEqAbs(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon)); } test "math.log float_special" { - expect(log(f32, 2, 0.2301974) == math.log2(@as(f32, 0.2301974))); - expect(log(f32, 10, 0.2301974) == math.log10(@as(f32, 0.2301974))); + try expect(log(f32, 2, 0.2301974) == math.log2(@as(f32, 0.2301974))); + try expect(log(f32, 10, 0.2301974) == math.log10(@as(f32, 0.2301974))); - expect(log(f64, 2, 213.23019799993) == math.log2(@as(f64, 213.23019799993))); - expect(log(f64, 10, 213.23019799993) == math.log10(@as(f64, 213.23019799993))); + try expect(log(f64, 2, 213.23019799993) == math.log2(@as(f64, 213.23019799993))); + try expect(log(f64, 10, 213.23019799993) == math.log10(@as(f64, 213.23019799993))); } diff --git a/lib/std/math/log10.zig b/lib/std/math/log10.zig index a8211a7270..56e4afbab6 100644 --- a/lib/std/math/log10.zig +++ b/lib/std/math/log10.zig @@ -181,42 +181,42 @@ pub fn log10_64(x_: f64) f64 { } test "math.log10" { - testing.expect(log10(@as(f32, 0.2)) == log10_32(0.2)); - testing.expect(log10(@as(f64, 0.2)) == log10_64(0.2)); + try testing.expect(log10(@as(f32, 0.2)) == log10_32(0.2)); + try testing.expect(log10(@as(f64, 0.2)) == log10_64(0.2)); } test "math.log10_32" { const epsilon = 0.000001; - testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon)); - testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon)); - testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon)); - testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon)); - testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon)); - testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(0.2), -0.698970, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(0.8923), -0.049489, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(1.5), 0.176091, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(37.45), 1.573452, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(89.123), 1.94999, epsilon)); + try testing.expect(math.approxEqAbs(f32, log10_32(123123.234375), 5.09034, epsilon)); } test "math.log10_64" { const epsilon = 0.000001; - testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon)); - testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon)); - testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon)); - testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon)); - testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon)); - testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(0.2), -0.698970, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(0.8923), -0.049489, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(1.5), 0.176091, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(37.45), 1.573452, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(89.123), 1.94999, epsilon)); + try testing.expect(math.approxEqAbs(f64, log10_64(123123.234375), 5.09034, epsilon)); } test "math.log10_32.special" { - testing.expect(math.isPositiveInf(log10_32(math.inf(f32)))); - testing.expect(math.isNegativeInf(log10_32(0.0))); - testing.expect(math.isNan(log10_32(-1.0))); - testing.expect(math.isNan(log10_32(math.nan(f32)))); + try testing.expect(math.isPositiveInf(log10_32(math.inf(f32)))); + try testing.expect(math.isNegativeInf(log10_32(0.0))); + try testing.expect(math.isNan(log10_32(-1.0))); + try testing.expect(math.isNan(log10_32(math.nan(f32)))); } test "math.log10_64.special" { - testing.expect(math.isPositiveInf(log10_64(math.inf(f64)))); - testing.expect(math.isNegativeInf(log10_64(0.0))); - testing.expect(math.isNan(log10_64(-1.0))); - testing.expect(math.isNan(log10_64(math.nan(f64)))); + try testing.expect(math.isPositiveInf(log10_64(math.inf(f64)))); + try testing.expect(math.isNegativeInf(log10_64(0.0))); + try testing.expect(math.isNan(log10_64(-1.0))); + try testing.expect(math.isNan(log10_64(math.nan(f64)))); } diff --git a/lib/std/math/log1p.zig b/lib/std/math/log1p.zig index 4eaee2c43f..6c03d7b263 100644 --- a/lib/std/math/log1p.zig +++ b/lib/std/math/log1p.zig @@ -188,48 +188,48 @@ fn log1p_64(x: f64) f64 { } test "math.log1p" { - expect(log1p(@as(f32, 0.0)) == log1p_32(0.0)); - expect(log1p(@as(f64, 0.0)) == log1p_64(0.0)); + try expect(log1p(@as(f32, 0.0)) == log1p_32(0.0)); + try expect(log1p(@as(f64, 0.0)) == log1p_64(0.0)); } test "math.log1p_32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(0.2), 0.182322, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(0.8923), 0.637793, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(1.5), 0.916291, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(37.45), 3.649359, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(89.123), 4.501175, epsilon)); - expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(0.2), 0.182322, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(0.8923), 0.637793, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(1.5), 0.916291, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(37.45), 3.649359, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(89.123), 4.501175, epsilon)); + try expect(math.approxEqAbs(f32, log1p_32(123123.234375), 11.720949, epsilon)); } test "math.log1p_64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(0.2), 0.182322, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(0.8923), 0.637793, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(1.5), 0.916291, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(37.45), 3.649359, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(89.123), 4.501175, epsilon)); - expect(math.approxEqAbs(f64, log1p_64(123123.234375), 11.720949, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(0.2), 0.182322, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(0.8923), 0.637793, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(1.5), 0.916291, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(37.45), 3.649359, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(89.123), 4.501175, epsilon)); + try expect(math.approxEqAbs(f64, log1p_64(123123.234375), 11.720949, epsilon)); } test "math.log1p_32.special" { - expect(math.isPositiveInf(log1p_32(math.inf(f32)))); - expect(log1p_32(0.0) == 0.0); - expect(log1p_32(-0.0) == -0.0); - expect(math.isNegativeInf(log1p_32(-1.0))); - expect(math.isNan(log1p_32(-2.0))); - expect(math.isNan(log1p_32(math.nan(f32)))); + try expect(math.isPositiveInf(log1p_32(math.inf(f32)))); + try expect(log1p_32(0.0) == 0.0); + try expect(log1p_32(-0.0) == -0.0); + try expect(math.isNegativeInf(log1p_32(-1.0))); + try expect(math.isNan(log1p_32(-2.0))); + try expect(math.isNan(log1p_32(math.nan(f32)))); } test "math.log1p_64.special" { - expect(math.isPositiveInf(log1p_64(math.inf(f64)))); - expect(log1p_64(0.0) == 0.0); - expect(log1p_64(-0.0) == -0.0); - expect(math.isNegativeInf(log1p_64(-1.0))); - expect(math.isNan(log1p_64(-2.0))); - expect(math.isNan(log1p_64(math.nan(f64)))); + try expect(math.isPositiveInf(log1p_64(math.inf(f64)))); + try expect(log1p_64(0.0) == 0.0); + try expect(log1p_64(-0.0) == -0.0); + try expect(math.isNegativeInf(log1p_64(-1.0))); + try expect(math.isNan(log1p_64(-2.0))); + try expect(math.isNan(log1p_64(math.nan(f64)))); } diff --git a/lib/std/math/log2.zig b/lib/std/math/log2.zig index 76bc79407c..1a42404fea 100644 --- a/lib/std/math/log2.zig +++ b/lib/std/math/log2.zig @@ -179,40 +179,40 @@ pub fn log2_64(x_: f64) f64 { } test "math.log2" { - expect(log2(@as(f32, 0.2)) == log2_32(0.2)); - expect(log2(@as(f64, 0.2)) == log2_64(0.2)); + try expect(log2(@as(f32, 0.2)) == log2_32(0.2)); + try expect(log2(@as(f64, 0.2)) == log2_64(0.2)); } test "math.log2_32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon)); - expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon)); - expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon)); - expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon)); - expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon)); + try expect(math.approxEqAbs(f32, log2_32(0.2), -2.321928, epsilon)); + try expect(math.approxEqAbs(f32, log2_32(0.8923), -0.164399, epsilon)); + try expect(math.approxEqAbs(f32, log2_32(1.5), 0.584962, epsilon)); + try expect(math.approxEqAbs(f32, log2_32(37.45), 5.226894, epsilon)); + try expect(math.approxEqAbs(f32, log2_32(123123.234375), 16.909744, epsilon)); } test "math.log2_64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon)); - expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon)); - expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon)); - expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon)); - expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon)); + try expect(math.approxEqAbs(f64, log2_64(0.2), -2.321928, epsilon)); + try expect(math.approxEqAbs(f64, log2_64(0.8923), -0.164399, epsilon)); + try expect(math.approxEqAbs(f64, log2_64(1.5), 0.584962, epsilon)); + try expect(math.approxEqAbs(f64, log2_64(37.45), 5.226894, epsilon)); + try expect(math.approxEqAbs(f64, log2_64(123123.234375), 16.909744, epsilon)); } test "math.log2_32.special" { - expect(math.isPositiveInf(log2_32(math.inf(f32)))); - expect(math.isNegativeInf(log2_32(0.0))); - expect(math.isNan(log2_32(-1.0))); - expect(math.isNan(log2_32(math.nan(f32)))); + try expect(math.isPositiveInf(log2_32(math.inf(f32)))); + try expect(math.isNegativeInf(log2_32(0.0))); + try expect(math.isNan(log2_32(-1.0))); + try expect(math.isNan(log2_32(math.nan(f32)))); } test "math.log2_64.special" { - expect(math.isPositiveInf(log2_64(math.inf(f64)))); - expect(math.isNegativeInf(log2_64(0.0))); - expect(math.isNan(log2_64(-1.0))); - expect(math.isNan(log2_64(math.nan(f64)))); + try expect(math.isPositiveInf(log2_64(math.inf(f64)))); + try expect(math.isNegativeInf(log2_64(0.0))); + try expect(math.isNan(log2_64(-1.0))); + try expect(math.isNan(log2_64(math.nan(f64)))); } diff --git a/lib/std/math/modf.zig b/lib/std/math/modf.zig index 390b3e4f49..6eef6fdd37 100644 --- a/lib/std/math/modf.zig +++ b/lib/std/math/modf.zig @@ -131,11 +131,11 @@ test "math.modf" { const a = modf(@as(f32, 1.0)); const b = modf32(1.0); // NOTE: No struct comparison on generic return type function? non-named, makes sense, but still. - expect(a.ipart == b.ipart and a.fpart == b.fpart); + try expect(a.ipart == b.ipart and a.fpart == b.fpart); const c = modf(@as(f64, 1.0)); const d = modf64(1.0); - expect(a.ipart == b.ipart and a.fpart == b.fpart); + try expect(a.ipart == b.ipart and a.fpart == b.fpart); } test "math.modf32" { @@ -143,24 +143,24 @@ test "math.modf32" { var r: modf32_result = undefined; r = modf32(1.0); - expect(math.approxEqAbs(f32, r.ipart, 1.0, epsilon)); - expect(math.approxEqAbs(f32, r.fpart, 0.0, epsilon)); + try expect(math.approxEqAbs(f32, r.ipart, 1.0, epsilon)); + try expect(math.approxEqAbs(f32, r.fpart, 0.0, epsilon)); r = modf32(2.545); - expect(math.approxEqAbs(f32, r.ipart, 2.0, epsilon)); - expect(math.approxEqAbs(f32, r.fpart, 0.545, epsilon)); + try expect(math.approxEqAbs(f32, r.ipart, 2.0, epsilon)); + try expect(math.approxEqAbs(f32, r.fpart, 0.545, epsilon)); r = modf32(3.978123); - expect(math.approxEqAbs(f32, r.ipart, 3.0, epsilon)); - expect(math.approxEqAbs(f32, r.fpart, 0.978123, epsilon)); + try expect(math.approxEqAbs(f32, r.ipart, 3.0, epsilon)); + try expect(math.approxEqAbs(f32, r.fpart, 0.978123, epsilon)); r = modf32(43874.3); - expect(math.approxEqAbs(f32, r.ipart, 43874, epsilon)); - expect(math.approxEqAbs(f32, r.fpart, 0.300781, epsilon)); + try expect(math.approxEqAbs(f32, r.ipart, 43874, epsilon)); + try expect(math.approxEqAbs(f32, r.fpart, 0.300781, epsilon)); r = modf32(1234.340780); - expect(math.approxEqAbs(f32, r.ipart, 1234, epsilon)); - expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon)); + try expect(math.approxEqAbs(f32, r.ipart, 1234, epsilon)); + try expect(math.approxEqAbs(f32, r.fpart, 0.340820, epsilon)); } test "math.modf64" { @@ -168,48 +168,48 @@ test "math.modf64" { var r: modf64_result = undefined; r = modf64(1.0); - expect(math.approxEqAbs(f64, r.ipart, 1.0, epsilon)); - expect(math.approxEqAbs(f64, r.fpart, 0.0, epsilon)); + try expect(math.approxEqAbs(f64, r.ipart, 1.0, epsilon)); + try expect(math.approxEqAbs(f64, r.fpart, 0.0, epsilon)); r = modf64(2.545); - expect(math.approxEqAbs(f64, r.ipart, 2.0, epsilon)); - expect(math.approxEqAbs(f64, r.fpart, 0.545, epsilon)); + try expect(math.approxEqAbs(f64, r.ipart, 2.0, epsilon)); + try expect(math.approxEqAbs(f64, r.fpart, 0.545, epsilon)); r = modf64(3.978123); - expect(math.approxEqAbs(f64, r.ipart, 3.0, epsilon)); - expect(math.approxEqAbs(f64, r.fpart, 0.978123, epsilon)); + try expect(math.approxEqAbs(f64, r.ipart, 3.0, epsilon)); + try expect(math.approxEqAbs(f64, r.fpart, 0.978123, epsilon)); r = modf64(43874.3); - expect(math.approxEqAbs(f64, r.ipart, 43874, epsilon)); - expect(math.approxEqAbs(f64, r.fpart, 0.3, epsilon)); + try expect(math.approxEqAbs(f64, r.ipart, 43874, epsilon)); + try expect(math.approxEqAbs(f64, r.fpart, 0.3, epsilon)); r = modf64(1234.340780); - expect(math.approxEqAbs(f64, r.ipart, 1234, epsilon)); - expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon)); + try expect(math.approxEqAbs(f64, r.ipart, 1234, epsilon)); + try expect(math.approxEqAbs(f64, r.fpart, 0.340780, epsilon)); } test "math.modf32.special" { var r: modf32_result = undefined; r = modf32(math.inf(f32)); - expect(math.isPositiveInf(r.ipart) and math.isNan(r.fpart)); + try expect(math.isPositiveInf(r.ipart) and math.isNan(r.fpart)); r = modf32(-math.inf(f32)); - expect(math.isNegativeInf(r.ipart) and math.isNan(r.fpart)); + try expect(math.isNegativeInf(r.ipart) and math.isNan(r.fpart)); r = modf32(math.nan(f32)); - expect(math.isNan(r.ipart) and math.isNan(r.fpart)); + try expect(math.isNan(r.ipart) and math.isNan(r.fpart)); } test "math.modf64.special" { var r: modf64_result = undefined; r = modf64(math.inf(f64)); - expect(math.isPositiveInf(r.ipart) and math.isNan(r.fpart)); + try expect(math.isPositiveInf(r.ipart) and math.isNan(r.fpart)); r = modf64(-math.inf(f64)); - expect(math.isNegativeInf(r.ipart) and math.isNan(r.fpart)); + try expect(math.isNegativeInf(r.ipart) and math.isNan(r.fpart)); r = modf64(math.nan(f64)); - expect(math.isNan(r.ipart) and math.isNan(r.fpart)); + try expect(math.isNan(r.ipart) and math.isNan(r.fpart)); } diff --git a/lib/std/math/pow.zig b/lib/std/math/pow.zig index 5c49c95865..686724761c 100644 --- a/lib/std/math/pow.zig +++ b/lib/std/math/pow.zig @@ -191,67 +191,67 @@ fn isOddInteger(x: f64) bool { test "math.pow" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, pow(f32, 0.0, 3.3), 0.0, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 0.0, 3.3), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 0.8923, 3.3), 0.686572, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 0.2, 3.3), 0.004936, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 1.5, 3.3), 3.811546, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 37.45, 3.3), 155736.703125, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, 89.123, 3.3), 2722489.5, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 0.0, 3.3), 0.0, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon)); - expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 0.0, 3.3), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 0.8923, 3.3), 0.686572, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 0.2, 3.3), 0.004936, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 1.5, 3.3), 3.811546, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 37.45, 3.3), 155736.7160616, epsilon)); + try expect(math.approxEqAbs(f64, pow(f64, 89.123, 3.3), 2722490.231436, epsilon)); } test "math.pow.special" { const epsilon = 0.000001; - expect(pow(f32, 4, 0.0) == 1.0); - expect(pow(f32, 7, -0.0) == 1.0); - expect(pow(f32, 45, 1.0) == 45); - expect(pow(f32, -45, 1.0) == -45); - expect(math.isNan(pow(f32, math.nan(f32), 5.0))); - expect(math.isPositiveInf(pow(f32, -math.inf(f32), 0.5))); - expect(math.isPositiveInf(pow(f32, -0, -0.5))); - expect(pow(f32, -0, 0.5) == 0); - expect(math.isNan(pow(f32, 5.0, math.nan(f32)))); - expect(math.isPositiveInf(pow(f32, 0.0, -1.0))); + try expect(pow(f32, 4, 0.0) == 1.0); + try expect(pow(f32, 7, -0.0) == 1.0); + try expect(pow(f32, 45, 1.0) == 45); + try expect(pow(f32, -45, 1.0) == -45); + try expect(math.isNan(pow(f32, math.nan(f32), 5.0))); + try expect(math.isPositiveInf(pow(f32, -math.inf(f32), 0.5))); + try expect(math.isPositiveInf(pow(f32, -0, -0.5))); + try expect(pow(f32, -0, 0.5) == 0); + try expect(math.isNan(pow(f32, 5.0, math.nan(f32)))); + try expect(math.isPositiveInf(pow(f32, 0.0, -1.0))); //expect(math.isNegativeInf(pow(f32, -0.0, -3.0))); TODO is this required? - expect(math.isPositiveInf(pow(f32, 0.0, -math.inf(f32)))); - expect(math.isPositiveInf(pow(f32, -0.0, -math.inf(f32)))); - expect(pow(f32, 0.0, math.inf(f32)) == 0.0); - expect(pow(f32, -0.0, math.inf(f32)) == 0.0); - expect(math.isPositiveInf(pow(f32, 0.0, -2.0))); - expect(math.isPositiveInf(pow(f32, -0.0, -2.0))); - expect(pow(f32, 0.0, 1.0) == 0.0); - expect(pow(f32, -0.0, 1.0) == -0.0); - expect(pow(f32, 0.0, 2.0) == 0.0); - expect(pow(f32, -0.0, 2.0) == 0.0); - expect(math.approxEqAbs(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon)); - expect(math.approxEqAbs(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon)); - expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32)))); - expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32)))); - expect(pow(f32, 1.2, -math.inf(f32)) == 0.0); - expect(pow(f32, -1.2, -math.inf(f32)) == 0.0); - expect(pow(f32, 0.2, math.inf(f32)) == 0.0); - expect(pow(f32, -0.2, math.inf(f32)) == 0.0); - expect(math.isPositiveInf(pow(f32, 0.2, -math.inf(f32)))); - expect(math.isPositiveInf(pow(f32, -0.2, -math.inf(f32)))); - expect(math.isPositiveInf(pow(f32, math.inf(f32), 1.0))); - expect(pow(f32, math.inf(f32), -1.0) == 0.0); + try expect(math.isPositiveInf(pow(f32, 0.0, -math.inf(f32)))); + try expect(math.isPositiveInf(pow(f32, -0.0, -math.inf(f32)))); + try expect(pow(f32, 0.0, math.inf(f32)) == 0.0); + try expect(pow(f32, -0.0, math.inf(f32)) == 0.0); + try expect(math.isPositiveInf(pow(f32, 0.0, -2.0))); + try expect(math.isPositiveInf(pow(f32, -0.0, -2.0))); + try expect(pow(f32, 0.0, 1.0) == 0.0); + try expect(pow(f32, -0.0, 1.0) == -0.0); + try expect(pow(f32, 0.0, 2.0) == 0.0); + try expect(pow(f32, -0.0, 2.0) == 0.0); + try expect(math.approxEqAbs(f32, pow(f32, -1.0, math.inf(f32)), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, pow(f32, -1.0, -math.inf(f32)), 1.0, epsilon)); + try expect(math.isPositiveInf(pow(f32, 1.2, math.inf(f32)))); + try expect(math.isPositiveInf(pow(f32, -1.2, math.inf(f32)))); + try expect(pow(f32, 1.2, -math.inf(f32)) == 0.0); + try expect(pow(f32, -1.2, -math.inf(f32)) == 0.0); + try expect(pow(f32, 0.2, math.inf(f32)) == 0.0); + try expect(pow(f32, -0.2, math.inf(f32)) == 0.0); + try expect(math.isPositiveInf(pow(f32, 0.2, -math.inf(f32)))); + try expect(math.isPositiveInf(pow(f32, -0.2, -math.inf(f32)))); + try expect(math.isPositiveInf(pow(f32, math.inf(f32), 1.0))); + try expect(pow(f32, math.inf(f32), -1.0) == 0.0); //expect(pow(f32, -math.inf(f32), 5.0) == pow(f32, -0.0, -5.0)); TODO support negative 0? - expect(pow(f32, -math.inf(f32), -5.2) == pow(f32, -0.0, 5.2)); - expect(math.isNan(pow(f32, -1.0, 1.2))); - expect(math.isNan(pow(f32, -12.4, 78.5))); + try expect(pow(f32, -math.inf(f32), -5.2) == pow(f32, -0.0, 5.2)); + try expect(math.isNan(pow(f32, -1.0, 1.2))); + try expect(math.isNan(pow(f32, -12.4, 78.5))); } test "math.pow.overflow" { - expect(math.isPositiveInf(pow(f64, 2, 1 << 32))); - expect(pow(f64, 2, -(1 << 32)) == 0); - expect(math.isNegativeInf(pow(f64, -2, (1 << 32) + 1))); - expect(pow(f64, 0.5, 1 << 45) == 0); - expect(math.isPositiveInf(pow(f64, 0.5, -(1 << 45)))); + try expect(math.isPositiveInf(pow(f64, 2, 1 << 32))); + try expect(pow(f64, 2, -(1 << 32)) == 0); + try expect(math.isNegativeInf(pow(f64, -2, (1 << 32) + 1))); + try expect(pow(f64, 0.5, 1 << 45) == 0); + try expect(math.isPositiveInf(pow(f64, 0.5, -(1 << 45)))); } diff --git a/lib/std/math/powi.zig b/lib/std/math/powi.zig index e415b74d87..3643a119ba 100644 --- a/lib/std/math/powi.zig +++ b/lib/std/math/powi.zig @@ -112,82 +112,82 @@ pub fn powi(comptime T: type, x: T, y: T) (error{ } test "math.powi" { - testing.expectError(error.Underflow, powi(i8, -66, 6)); - testing.expectError(error.Underflow, powi(i16, -13, 13)); - testing.expectError(error.Underflow, powi(i32, -32, 21)); - testing.expectError(error.Underflow, powi(i64, -24, 61)); - testing.expectError(error.Underflow, powi(i17, -15, 15)); - testing.expectError(error.Underflow, powi(i42, -6, 40)); + try testing.expectError(error.Underflow, powi(i8, -66, 6)); + try testing.expectError(error.Underflow, powi(i16, -13, 13)); + try testing.expectError(error.Underflow, powi(i32, -32, 21)); + try testing.expectError(error.Underflow, powi(i64, -24, 61)); + try testing.expectError(error.Underflow, powi(i17, -15, 15)); + try testing.expectError(error.Underflow, powi(i42, -6, 40)); - testing.expect((try powi(i8, -5, 3)) == -125); - testing.expect((try powi(i16, -16, 3)) == -4096); - testing.expect((try powi(i32, -91, 3)) == -753571); - testing.expect((try powi(i64, -36, 6)) == 2176782336); - testing.expect((try powi(i17, -2, 15)) == -32768); - testing.expect((try powi(i42, -5, 7)) == -78125); + try testing.expect((try powi(i8, -5, 3)) == -125); + try testing.expect((try powi(i16, -16, 3)) == -4096); + try testing.expect((try powi(i32, -91, 3)) == -753571); + try testing.expect((try powi(i64, -36, 6)) == 2176782336); + try testing.expect((try powi(i17, -2, 15)) == -32768); + try testing.expect((try powi(i42, -5, 7)) == -78125); - testing.expect((try powi(u8, 6, 2)) == 36); - testing.expect((try powi(u16, 5, 4)) == 625); - testing.expect((try powi(u32, 12, 6)) == 2985984); - testing.expect((try powi(u64, 34, 2)) == 1156); - testing.expect((try powi(u17, 16, 3)) == 4096); - testing.expect((try powi(u42, 34, 6)) == 1544804416); + try testing.expect((try powi(u8, 6, 2)) == 36); + try testing.expect((try powi(u16, 5, 4)) == 625); + try testing.expect((try powi(u32, 12, 6)) == 2985984); + try testing.expect((try powi(u64, 34, 2)) == 1156); + try testing.expect((try powi(u17, 16, 3)) == 4096); + try testing.expect((try powi(u42, 34, 6)) == 1544804416); - testing.expectError(error.Overflow, powi(i8, 120, 7)); - testing.expectError(error.Overflow, powi(i16, 73, 15)); - testing.expectError(error.Overflow, powi(i32, 23, 31)); - testing.expectError(error.Overflow, powi(i64, 68, 61)); - testing.expectError(error.Overflow, powi(i17, 15, 15)); - testing.expectError(error.Overflow, powi(i42, 121312, 41)); + try testing.expectError(error.Overflow, powi(i8, 120, 7)); + try testing.expectError(error.Overflow, powi(i16, 73, 15)); + try testing.expectError(error.Overflow, powi(i32, 23, 31)); + try testing.expectError(error.Overflow, powi(i64, 68, 61)); + try testing.expectError(error.Overflow, powi(i17, 15, 15)); + try testing.expectError(error.Overflow, powi(i42, 121312, 41)); - testing.expectError(error.Overflow, powi(u8, 123, 7)); - testing.expectError(error.Overflow, powi(u16, 2313, 15)); - testing.expectError(error.Overflow, powi(u32, 8968, 31)); - testing.expectError(error.Overflow, powi(u64, 2342, 63)); - testing.expectError(error.Overflow, powi(u17, 2723, 16)); - testing.expectError(error.Overflow, powi(u42, 8234, 41)); + try testing.expectError(error.Overflow, powi(u8, 123, 7)); + try testing.expectError(error.Overflow, powi(u16, 2313, 15)); + try testing.expectError(error.Overflow, powi(u32, 8968, 31)); + try testing.expectError(error.Overflow, powi(u64, 2342, 63)); + try testing.expectError(error.Overflow, powi(u17, 2723, 16)); + try testing.expectError(error.Overflow, powi(u42, 8234, 41)); } test "math.powi.special" { - testing.expectError(error.Underflow, powi(i8, -2, 8)); - testing.expectError(error.Underflow, powi(i16, -2, 16)); - testing.expectError(error.Underflow, powi(i32, -2, 32)); - testing.expectError(error.Underflow, powi(i64, -2, 64)); - testing.expectError(error.Underflow, powi(i17, -2, 17)); - testing.expectError(error.Underflow, powi(i42, -2, 42)); + try testing.expectError(error.Underflow, powi(i8, -2, 8)); + try testing.expectError(error.Underflow, powi(i16, -2, 16)); + try testing.expectError(error.Underflow, powi(i32, -2, 32)); + try testing.expectError(error.Underflow, powi(i64, -2, 64)); + try testing.expectError(error.Underflow, powi(i17, -2, 17)); + try testing.expectError(error.Underflow, powi(i42, -2, 42)); - testing.expect((try powi(i8, -1, 3)) == -1); - testing.expect((try powi(i16, -1, 2)) == 1); - testing.expect((try powi(i32, -1, 16)) == 1); - testing.expect((try powi(i64, -1, 6)) == 1); - testing.expect((try powi(i17, -1, 15)) == -1); - testing.expect((try powi(i42, -1, 7)) == -1); + try testing.expect((try powi(i8, -1, 3)) == -1); + try testing.expect((try powi(i16, -1, 2)) == 1); + try testing.expect((try powi(i32, -1, 16)) == 1); + try testing.expect((try powi(i64, -1, 6)) == 1); + try testing.expect((try powi(i17, -1, 15)) == -1); + try testing.expect((try powi(i42, -1, 7)) == -1); - testing.expect((try powi(u8, 1, 2)) == 1); - testing.expect((try powi(u16, 1, 4)) == 1); - testing.expect((try powi(u32, 1, 6)) == 1); - testing.expect((try powi(u64, 1, 2)) == 1); - testing.expect((try powi(u17, 1, 3)) == 1); - testing.expect((try powi(u42, 1, 6)) == 1); + try testing.expect((try powi(u8, 1, 2)) == 1); + try testing.expect((try powi(u16, 1, 4)) == 1); + try testing.expect((try powi(u32, 1, 6)) == 1); + try testing.expect((try powi(u64, 1, 2)) == 1); + try testing.expect((try powi(u17, 1, 3)) == 1); + try testing.expect((try powi(u42, 1, 6)) == 1); - testing.expectError(error.Overflow, powi(i8, 2, 7)); - testing.expectError(error.Overflow, powi(i16, 2, 15)); - testing.expectError(error.Overflow, powi(i32, 2, 31)); - testing.expectError(error.Overflow, powi(i64, 2, 63)); - testing.expectError(error.Overflow, powi(i17, 2, 16)); - testing.expectError(error.Overflow, powi(i42, 2, 41)); + try testing.expectError(error.Overflow, powi(i8, 2, 7)); + try testing.expectError(error.Overflow, powi(i16, 2, 15)); + try testing.expectError(error.Overflow, powi(i32, 2, 31)); + try testing.expectError(error.Overflow, powi(i64, 2, 63)); + try testing.expectError(error.Overflow, powi(i17, 2, 16)); + try testing.expectError(error.Overflow, powi(i42, 2, 41)); - testing.expectError(error.Overflow, powi(u8, 2, 8)); - testing.expectError(error.Overflow, powi(u16, 2, 16)); - testing.expectError(error.Overflow, powi(u32, 2, 32)); - testing.expectError(error.Overflow, powi(u64, 2, 64)); - testing.expectError(error.Overflow, powi(u17, 2, 17)); - testing.expectError(error.Overflow, powi(u42, 2, 42)); + try testing.expectError(error.Overflow, powi(u8, 2, 8)); + try testing.expectError(error.Overflow, powi(u16, 2, 16)); + try testing.expectError(error.Overflow, powi(u32, 2, 32)); + try testing.expectError(error.Overflow, powi(u64, 2, 64)); + try testing.expectError(error.Overflow, powi(u17, 2, 17)); + try testing.expectError(error.Overflow, powi(u42, 2, 42)); - testing.expect((try powi(u8, 6, 0)) == 1); - testing.expect((try powi(u16, 5, 0)) == 1); - testing.expect((try powi(u32, 12, 0)) == 1); - testing.expect((try powi(u64, 34, 0)) == 1); - testing.expect((try powi(u17, 16, 0)) == 1); - testing.expect((try powi(u42, 34, 0)) == 1); + try testing.expect((try powi(u8, 6, 0)) == 1); + try testing.expect((try powi(u16, 5, 0)) == 1); + try testing.expect((try powi(u32, 12, 0)) == 1); + try testing.expect((try powi(u64, 34, 0)) == 1); + try testing.expect((try powi(u17, 16, 0)) == 1); + try testing.expect((try powi(u42, 34, 0)) == 1); } diff --git a/lib/std/math/round.zig b/lib/std/math/round.zig index 9167bcfc82..3e3ea2cdc8 100644 --- a/lib/std/math/round.zig +++ b/lib/std/math/round.zig @@ -130,52 +130,52 @@ fn round128(x_: f128) f128 { } test "math.round" { - expect(round(@as(f32, 1.3)) == round32(1.3)); - expect(round(@as(f64, 1.3)) == round64(1.3)); - expect(round(@as(f128, 1.3)) == round128(1.3)); + try expect(round(@as(f32, 1.3)) == round32(1.3)); + try expect(round(@as(f64, 1.3)) == round64(1.3)); + try expect(round(@as(f128, 1.3)) == round128(1.3)); } test "math.round32" { - expect(round32(1.3) == 1.0); - expect(round32(-1.3) == -1.0); - expect(round32(0.2) == 0.0); - expect(round32(1.8) == 2.0); + try expect(round32(1.3) == 1.0); + try expect(round32(-1.3) == -1.0); + try expect(round32(0.2) == 0.0); + try expect(round32(1.8) == 2.0); } test "math.round64" { - expect(round64(1.3) == 1.0); - expect(round64(-1.3) == -1.0); - expect(round64(0.2) == 0.0); - expect(round64(1.8) == 2.0); + try expect(round64(1.3) == 1.0); + try expect(round64(-1.3) == -1.0); + try expect(round64(0.2) == 0.0); + try expect(round64(1.8) == 2.0); } test "math.round128" { - expect(round128(1.3) == 1.0); - expect(round128(-1.3) == -1.0); - expect(round128(0.2) == 0.0); - expect(round128(1.8) == 2.0); + try expect(round128(1.3) == 1.0); + try expect(round128(-1.3) == -1.0); + try expect(round128(0.2) == 0.0); + try expect(round128(1.8) == 2.0); } test "math.round32.special" { - expect(round32(0.0) == 0.0); - expect(round32(-0.0) == -0.0); - expect(math.isPositiveInf(round32(math.inf(f32)))); - expect(math.isNegativeInf(round32(-math.inf(f32)))); - expect(math.isNan(round32(math.nan(f32)))); + try expect(round32(0.0) == 0.0); + try expect(round32(-0.0) == -0.0); + try expect(math.isPositiveInf(round32(math.inf(f32)))); + try expect(math.isNegativeInf(round32(-math.inf(f32)))); + try expect(math.isNan(round32(math.nan(f32)))); } test "math.round64.special" { - expect(round64(0.0) == 0.0); - expect(round64(-0.0) == -0.0); - expect(math.isPositiveInf(round64(math.inf(f64)))); - expect(math.isNegativeInf(round64(-math.inf(f64)))); - expect(math.isNan(round64(math.nan(f64)))); + try expect(round64(0.0) == 0.0); + try expect(round64(-0.0) == -0.0); + try expect(math.isPositiveInf(round64(math.inf(f64)))); + try expect(math.isNegativeInf(round64(-math.inf(f64)))); + try expect(math.isNan(round64(math.nan(f64)))); } test "math.round128.special" { - expect(round128(0.0) == 0.0); - expect(round128(-0.0) == -0.0); - expect(math.isPositiveInf(round128(math.inf(f128)))); - expect(math.isNegativeInf(round128(-math.inf(f128)))); - expect(math.isNan(round128(math.nan(f128)))); + try expect(round128(0.0) == 0.0); + try expect(round128(-0.0) == -0.0); + try expect(math.isPositiveInf(round128(math.inf(f128)))); + try expect(math.isNegativeInf(round128(-math.inf(f128)))); + try expect(math.isNan(round128(math.nan(f128)))); } diff --git a/lib/std/math/scalbn.zig b/lib/std/math/scalbn.zig index cf8ff9003d..49aea08931 100644 --- a/lib/std/math/scalbn.zig +++ b/lib/std/math/scalbn.zig @@ -84,14 +84,14 @@ fn scalbn64(x: f64, n_: i32) f64 { } test "math.scalbn" { - expect(scalbn(@as(f32, 1.5), 4) == scalbn32(1.5, 4)); - expect(scalbn(@as(f64, 1.5), 4) == scalbn64(1.5, 4)); + try expect(scalbn(@as(f32, 1.5), 4) == scalbn32(1.5, 4)); + try expect(scalbn(@as(f64, 1.5), 4) == scalbn64(1.5, 4)); } test "math.scalbn32" { - expect(scalbn32(1.5, 4) == 24.0); + try expect(scalbn32(1.5, 4) == 24.0); } test "math.scalbn64" { - expect(scalbn64(1.5, 4) == 24.0); + try expect(scalbn64(1.5, 4) == 24.0); } diff --git a/lib/std/math/signbit.zig b/lib/std/math/signbit.zig index 08963b3d94..a1f2f127d4 100644 --- a/lib/std/math/signbit.zig +++ b/lib/std/math/signbit.zig @@ -40,28 +40,28 @@ fn signbit128(x: f128) bool { } test "math.signbit" { - expect(signbit(@as(f16, 4.0)) == signbit16(4.0)); - expect(signbit(@as(f32, 4.0)) == signbit32(4.0)); - expect(signbit(@as(f64, 4.0)) == signbit64(4.0)); - expect(signbit(@as(f128, 4.0)) == signbit128(4.0)); + try expect(signbit(@as(f16, 4.0)) == signbit16(4.0)); + try expect(signbit(@as(f32, 4.0)) == signbit32(4.0)); + try expect(signbit(@as(f64, 4.0)) == signbit64(4.0)); + try expect(signbit(@as(f128, 4.0)) == signbit128(4.0)); } test "math.signbit16" { - expect(!signbit16(4.0)); - expect(signbit16(-3.0)); + try expect(!signbit16(4.0)); + try expect(signbit16(-3.0)); } test "math.signbit32" { - expect(!signbit32(4.0)); - expect(signbit32(-3.0)); + try expect(!signbit32(4.0)); + try expect(signbit32(-3.0)); } test "math.signbit64" { - expect(!signbit64(4.0)); - expect(signbit64(-3.0)); + try expect(!signbit64(4.0)); + try expect(signbit64(-3.0)); } test "math.signbit128" { - expect(!signbit128(4.0)); - expect(signbit128(-3.0)); + try expect(!signbit128(4.0)); + try expect(signbit128(-3.0)); } diff --git a/lib/std/math/sin.zig b/lib/std/math/sin.zig index d051e3f88a..544d55bd53 100644 --- a/lib/std/math/sin.zig +++ b/lib/std/math/sin.zig @@ -89,47 +89,47 @@ fn sin_(comptime T: type, x_: T) T { } test "math.sin" { - expect(sin(@as(f32, 0.0)) == sin_(f32, 0.0)); - expect(sin(@as(f64, 0.0)) == sin_(f64, 0.0)); - expect(comptime (math.sin(@as(f64, 2))) == math.sin(@as(f64, 2))); + try expect(sin(@as(f32, 0.0)) == sin_(f32, 0.0)); + try expect(sin(@as(f64, 0.0)) == sin_(f64, 0.0)); + try expect(comptime (math.sin(@as(f64, 2))) == math.sin(@as(f64, 2))); } test "math.sin32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, sin_(f32, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, 0.2), 0.198669, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, 0.8923), 0.778517, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, 1.5), 0.997495, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, -1.5), -0.997495, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, 37.45), -0.246544, epsilon)); - expect(math.approxEqAbs(f32, sin_(f32, 89.123), 0.916166, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 0.2), 0.198669, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 0.8923), 0.778517, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 1.5), 0.997495, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, -1.5), -0.997495, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 37.45), -0.246544, epsilon)); + try expect(math.approxEqAbs(f32, sin_(f32, 89.123), 0.916166, epsilon)); } test "math.sin64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, sin_(f64, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, 0.2), 0.198669, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, 0.8923), 0.778517, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, 1.5), 0.997495, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, -1.5), -0.997495, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, 37.45), -0.246543, epsilon)); - expect(math.approxEqAbs(f64, sin_(f64, 89.123), 0.916166, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 0.2), 0.198669, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 0.8923), 0.778517, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 1.5), 0.997495, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, -1.5), -0.997495, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 37.45), -0.246543, epsilon)); + try expect(math.approxEqAbs(f64, sin_(f64, 89.123), 0.916166, epsilon)); } test "math.sin32.special" { - expect(sin_(f32, 0.0) == 0.0); - expect(sin_(f32, -0.0) == -0.0); - expect(math.isNan(sin_(f32, math.inf(f32)))); - expect(math.isNan(sin_(f32, -math.inf(f32)))); - expect(math.isNan(sin_(f32, math.nan(f32)))); + try expect(sin_(f32, 0.0) == 0.0); + try expect(sin_(f32, -0.0) == -0.0); + try expect(math.isNan(sin_(f32, math.inf(f32)))); + try expect(math.isNan(sin_(f32, -math.inf(f32)))); + try expect(math.isNan(sin_(f32, math.nan(f32)))); } test "math.sin64.special" { - expect(sin_(f64, 0.0) == 0.0); - expect(sin_(f64, -0.0) == -0.0); - expect(math.isNan(sin_(f64, math.inf(f64)))); - expect(math.isNan(sin_(f64, -math.inf(f64)))); - expect(math.isNan(sin_(f64, math.nan(f64)))); + try expect(sin_(f64, 0.0) == 0.0); + try expect(sin_(f64, -0.0) == -0.0); + try expect(math.isNan(sin_(f64, math.inf(f64)))); + try expect(math.isNan(sin_(f64, -math.inf(f64)))); + try expect(math.isNan(sin_(f64, math.nan(f64)))); } diff --git a/lib/std/math/sinh.zig b/lib/std/math/sinh.zig index 16329a9108..4161afca63 100644 --- a/lib/std/math/sinh.zig +++ b/lib/std/math/sinh.zig @@ -98,48 +98,48 @@ fn sinh64(x: f64) f64 { } test "math.sinh" { - expect(sinh(@as(f32, 1.5)) == sinh32(1.5)); - expect(sinh(@as(f64, 1.5)) == sinh64(1.5)); + try expect(sinh(@as(f32, 1.5)) == sinh32(1.5)); + try expect(sinh(@as(f64, 1.5)) == sinh64(1.5)); } test "math.sinh32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, sinh32(0.2), 0.201336, epsilon)); - expect(math.approxEqAbs(f32, sinh32(0.8923), 1.015512, epsilon)); - expect(math.approxEqAbs(f32, sinh32(1.5), 2.129279, epsilon)); - expect(math.approxEqAbs(f32, sinh32(-0.0), -0.0, epsilon)); - expect(math.approxEqAbs(f32, sinh32(-0.2), -0.201336, epsilon)); - expect(math.approxEqAbs(f32, sinh32(-0.8923), -1.015512, epsilon)); - expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(0.2), 0.201336, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(0.8923), 1.015512, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(1.5), 2.129279, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(-0.0), -0.0, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(-0.2), -0.201336, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(-0.8923), -1.015512, epsilon)); + try expect(math.approxEqAbs(f32, sinh32(-1.5), -2.129279, epsilon)); } test "math.sinh64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, sinh64(0.2), 0.201336, epsilon)); - expect(math.approxEqAbs(f64, sinh64(0.8923), 1.015512, epsilon)); - expect(math.approxEqAbs(f64, sinh64(1.5), 2.129279, epsilon)); - expect(math.approxEqAbs(f64, sinh64(-0.0), -0.0, epsilon)); - expect(math.approxEqAbs(f64, sinh64(-0.2), -0.201336, epsilon)); - expect(math.approxEqAbs(f64, sinh64(-0.8923), -1.015512, epsilon)); - expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(0.2), 0.201336, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(0.8923), 1.015512, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(1.5), 2.129279, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(-0.0), -0.0, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(-0.2), -0.201336, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(-0.8923), -1.015512, epsilon)); + try expect(math.approxEqAbs(f64, sinh64(-1.5), -2.129279, epsilon)); } test "math.sinh32.special" { - expect(sinh32(0.0) == 0.0); - expect(sinh32(-0.0) == -0.0); - expect(math.isPositiveInf(sinh32(math.inf(f32)))); - expect(math.isNegativeInf(sinh32(-math.inf(f32)))); - expect(math.isNan(sinh32(math.nan(f32)))); + try expect(sinh32(0.0) == 0.0); + try expect(sinh32(-0.0) == -0.0); + try expect(math.isPositiveInf(sinh32(math.inf(f32)))); + try expect(math.isNegativeInf(sinh32(-math.inf(f32)))); + try expect(math.isNan(sinh32(math.nan(f32)))); } test "math.sinh64.special" { - expect(sinh64(0.0) == 0.0); - expect(sinh64(-0.0) == -0.0); - expect(math.isPositiveInf(sinh64(math.inf(f64)))); - expect(math.isNegativeInf(sinh64(-math.inf(f64)))); - expect(math.isNan(sinh64(math.nan(f64)))); + try expect(sinh64(0.0) == 0.0); + try expect(sinh64(-0.0) == -0.0); + try expect(math.isPositiveInf(sinh64(math.inf(f64)))); + try expect(math.isNegativeInf(sinh64(-math.inf(f64)))); + try expect(math.isNan(sinh64(math.nan(f64)))); } diff --git a/lib/std/math/sqrt.zig b/lib/std/math/sqrt.zig index 4f32581270..e9bbe40295 100644 --- a/lib/std/math/sqrt.zig +++ b/lib/std/math/sqrt.zig @@ -69,14 +69,14 @@ fn sqrt_int(comptime T: type, value: T) Sqrt(T) { } test "math.sqrt_int" { - expect(sqrt_int(u0, 0) == 0); - expect(sqrt_int(u1, 1) == 1); - expect(sqrt_int(u32, 3) == 1); - expect(sqrt_int(u32, 4) == 2); - expect(sqrt_int(u32, 5) == 2); - expect(sqrt_int(u32, 8) == 2); - expect(sqrt_int(u32, 9) == 3); - expect(sqrt_int(u32, 10) == 3); + try expect(sqrt_int(u0, 0) == 0); + try expect(sqrt_int(u1, 1) == 1); + try expect(sqrt_int(u32, 3) == 1); + try expect(sqrt_int(u32, 4) == 2); + try expect(sqrt_int(u32, 5) == 2); + try expect(sqrt_int(u32, 8) == 2); + try expect(sqrt_int(u32, 9) == 3); + try expect(sqrt_int(u32, 10) == 3); } /// Returns the return type `sqrt` will return given an operand of type `T`. diff --git a/lib/std/math/tan.zig b/lib/std/math/tan.zig index d0e8a0d4f8..0db96e34a4 100644 --- a/lib/std/math/tan.zig +++ b/lib/std/math/tan.zig @@ -80,44 +80,44 @@ fn tan_(comptime T: type, x_: T) T { } test "math.tan" { - expect(tan(@as(f32, 0.0)) == tan_(f32, 0.0)); - expect(tan(@as(f64, 0.0)) == tan_(f64, 0.0)); + try expect(tan(@as(f32, 0.0)) == tan_(f32, 0.0)); + try expect(tan(@as(f64, 0.0)) == tan_(f64, 0.0)); } test "math.tan32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, tan_(f32, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, tan_(f32, 0.2), 0.202710, epsilon)); - expect(math.approxEqAbs(f32, tan_(f32, 0.8923), 1.240422, epsilon)); - expect(math.approxEqAbs(f32, tan_(f32, 1.5), 14.101420, epsilon)); - expect(math.approxEqAbs(f32, tan_(f32, 37.45), -0.254397, epsilon)); - expect(math.approxEqAbs(f32, tan_(f32, 89.123), 2.285852, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 0.2), 0.202710, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 0.8923), 1.240422, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 1.5), 14.101420, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 37.45), -0.254397, epsilon)); + try expect(math.approxEqAbs(f32, tan_(f32, 89.123), 2.285852, epsilon)); } test "math.tan64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, tan_(f64, 0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, tan_(f64, 0.2), 0.202710, epsilon)); - expect(math.approxEqAbs(f64, tan_(f64, 0.8923), 1.240422, epsilon)); - expect(math.approxEqAbs(f64, tan_(f64, 1.5), 14.101420, epsilon)); - expect(math.approxEqAbs(f64, tan_(f64, 37.45), -0.254397, epsilon)); - expect(math.approxEqAbs(f64, tan_(f64, 89.123), 2.2858376, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 0.2), 0.202710, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 0.8923), 1.240422, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 1.5), 14.101420, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 37.45), -0.254397, epsilon)); + try expect(math.approxEqAbs(f64, tan_(f64, 89.123), 2.2858376, epsilon)); } test "math.tan32.special" { - expect(tan_(f32, 0.0) == 0.0); - expect(tan_(f32, -0.0) == -0.0); - expect(math.isNan(tan_(f32, math.inf(f32)))); - expect(math.isNan(tan_(f32, -math.inf(f32)))); - expect(math.isNan(tan_(f32, math.nan(f32)))); + try expect(tan_(f32, 0.0) == 0.0); + try expect(tan_(f32, -0.0) == -0.0); + try expect(math.isNan(tan_(f32, math.inf(f32)))); + try expect(math.isNan(tan_(f32, -math.inf(f32)))); + try expect(math.isNan(tan_(f32, math.nan(f32)))); } test "math.tan64.special" { - expect(tan_(f64, 0.0) == 0.0); - expect(tan_(f64, -0.0) == -0.0); - expect(math.isNan(tan_(f64, math.inf(f64)))); - expect(math.isNan(tan_(f64, -math.inf(f64)))); - expect(math.isNan(tan_(f64, math.nan(f64)))); + try expect(tan_(f64, 0.0) == 0.0); + try expect(tan_(f64, -0.0) == -0.0); + try expect(math.isNan(tan_(f64, math.inf(f64)))); + try expect(math.isNan(tan_(f64, -math.inf(f64)))); + try expect(math.isNan(tan_(f64, math.nan(f64)))); } diff --git a/lib/std/math/tanh.zig b/lib/std/math/tanh.zig index c53f03122b..e8d57d7f14 100644 --- a/lib/std/math/tanh.zig +++ b/lib/std/math/tanh.zig @@ -124,42 +124,42 @@ fn tanh64(x: f64) f64 { } test "math.tanh" { - expect(tanh(@as(f32, 1.5)) == tanh32(1.5)); - expect(tanh(@as(f64, 1.5)) == tanh64(1.5)); + try expect(tanh(@as(f32, 1.5)) == tanh32(1.5)); + try expect(tanh(@as(f64, 1.5)) == tanh64(1.5)); } test "math.tanh32" { const epsilon = 0.000001; - expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f32, tanh32(0.2), 0.197375, epsilon)); - expect(math.approxEqAbs(f32, tanh32(0.8923), 0.712528, epsilon)); - expect(math.approxEqAbs(f32, tanh32(1.5), 0.905148, epsilon)); - expect(math.approxEqAbs(f32, tanh32(37.45), 1.0, epsilon)); + try expect(math.approxEqAbs(f32, tanh32(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f32, tanh32(0.2), 0.197375, epsilon)); + try expect(math.approxEqAbs(f32, tanh32(0.8923), 0.712528, epsilon)); + try expect(math.approxEqAbs(f32, tanh32(1.5), 0.905148, epsilon)); + try expect(math.approxEqAbs(f32, tanh32(37.45), 1.0, epsilon)); } test "math.tanh64" { const epsilon = 0.000001; - expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon)); - expect(math.approxEqAbs(f64, tanh64(0.2), 0.197375, epsilon)); - expect(math.approxEqAbs(f64, tanh64(0.8923), 0.712528, epsilon)); - expect(math.approxEqAbs(f64, tanh64(1.5), 0.905148, epsilon)); - expect(math.approxEqAbs(f64, tanh64(37.45), 1.0, epsilon)); + try expect(math.approxEqAbs(f64, tanh64(0.0), 0.0, epsilon)); + try expect(math.approxEqAbs(f64, tanh64(0.2), 0.197375, epsilon)); + try expect(math.approxEqAbs(f64, tanh64(0.8923), 0.712528, epsilon)); + try expect(math.approxEqAbs(f64, tanh64(1.5), 0.905148, epsilon)); + try expect(math.approxEqAbs(f64, tanh64(37.45), 1.0, epsilon)); } test "math.tanh32.special" { - expect(tanh32(0.0) == 0.0); - expect(tanh32(-0.0) == -0.0); - expect(tanh32(math.inf(f32)) == 1.0); - expect(tanh32(-math.inf(f32)) == -1.0); - expect(math.isNan(tanh32(math.nan(f32)))); + try expect(tanh32(0.0) == 0.0); + try expect(tanh32(-0.0) == -0.0); + try expect(tanh32(math.inf(f32)) == 1.0); + try expect(tanh32(-math.inf(f32)) == -1.0); + try expect(math.isNan(tanh32(math.nan(f32)))); } test "math.tanh64.special" { - expect(tanh64(0.0) == 0.0); - expect(tanh64(-0.0) == -0.0); - expect(tanh64(math.inf(f64)) == 1.0); - expect(tanh64(-math.inf(f64)) == -1.0); - expect(math.isNan(tanh64(math.nan(f64)))); + try expect(tanh64(0.0) == 0.0); + try expect(tanh64(-0.0) == -0.0); + try expect(tanh64(math.inf(f64)) == 1.0); + try expect(tanh64(-math.inf(f64)) == -1.0); + try expect(math.isNan(tanh64(math.nan(f64)))); } diff --git a/lib/std/math/trunc.zig b/lib/std/math/trunc.zig index 69c300efee..0d83dc608d 100644 --- a/lib/std/math/trunc.zig +++ b/lib/std/math/trunc.zig @@ -94,49 +94,49 @@ fn trunc128(x: f128) f128 { } test "math.trunc" { - expect(trunc(@as(f32, 1.3)) == trunc32(1.3)); - expect(trunc(@as(f64, 1.3)) == trunc64(1.3)); - expect(trunc(@as(f128, 1.3)) == trunc128(1.3)); + try expect(trunc(@as(f32, 1.3)) == trunc32(1.3)); + try expect(trunc(@as(f64, 1.3)) == trunc64(1.3)); + try expect(trunc(@as(f128, 1.3)) == trunc128(1.3)); } test "math.trunc32" { - expect(trunc32(1.3) == 1.0); - expect(trunc32(-1.3) == -1.0); - expect(trunc32(0.2) == 0.0); + try expect(trunc32(1.3) == 1.0); + try expect(trunc32(-1.3) == -1.0); + try expect(trunc32(0.2) == 0.0); } test "math.trunc64" { - expect(trunc64(1.3) == 1.0); - expect(trunc64(-1.3) == -1.0); - expect(trunc64(0.2) == 0.0); + try expect(trunc64(1.3) == 1.0); + try expect(trunc64(-1.3) == -1.0); + try expect(trunc64(0.2) == 0.0); } test "math.trunc128" { - expect(trunc128(1.3) == 1.0); - expect(trunc128(-1.3) == -1.0); - expect(trunc128(0.2) == 0.0); + try expect(trunc128(1.3) == 1.0); + try expect(trunc128(-1.3) == -1.0); + try expect(trunc128(0.2) == 0.0); } test "math.trunc32.special" { - expect(trunc32(0.0) == 0.0); // 0x3F800000 - expect(trunc32(-0.0) == -0.0); - expect(math.isPositiveInf(trunc32(math.inf(f32)))); - expect(math.isNegativeInf(trunc32(-math.inf(f32)))); - expect(math.isNan(trunc32(math.nan(f32)))); + try expect(trunc32(0.0) == 0.0); // 0x3F800000 + try expect(trunc32(-0.0) == -0.0); + try expect(math.isPositiveInf(trunc32(math.inf(f32)))); + try expect(math.isNegativeInf(trunc32(-math.inf(f32)))); + try expect(math.isNan(trunc32(math.nan(f32)))); } test "math.trunc64.special" { - expect(trunc64(0.0) == 0.0); - expect(trunc64(-0.0) == -0.0); - expect(math.isPositiveInf(trunc64(math.inf(f64)))); - expect(math.isNegativeInf(trunc64(-math.inf(f64)))); - expect(math.isNan(trunc64(math.nan(f64)))); + try expect(trunc64(0.0) == 0.0); + try expect(trunc64(-0.0) == -0.0); + try expect(math.isPositiveInf(trunc64(math.inf(f64)))); + try expect(math.isNegativeInf(trunc64(-math.inf(f64)))); + try expect(math.isNan(trunc64(math.nan(f64)))); } test "math.trunc128.special" { - expect(trunc128(0.0) == 0.0); - expect(trunc128(-0.0) == -0.0); - expect(math.isPositiveInf(trunc128(math.inf(f128)))); - expect(math.isNegativeInf(trunc128(-math.inf(f128)))); - expect(math.isNan(trunc128(math.nan(f128)))); + try expect(trunc128(0.0) == 0.0); + try expect(trunc128(-0.0) == -0.0); + try expect(math.isPositiveInf(trunc128(math.inf(f128)))); + try expect(math.isNegativeInf(trunc128(-math.inf(f128)))); + try expect(math.isNan(trunc128(math.nan(f128)))); } diff --git a/lib/std/mem.zig b/lib/std/mem.zig index 274da3b8f1..df91adddb2 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -142,8 +142,8 @@ fn failAllocatorAlloc(self: *Allocator, n: usize, alignment: u29, len_align: u29 } test "mem.Allocator basics" { - testing.expectError(error.OutOfMemory, failAllocator.alloc(u8, 1)); - testing.expectError(error.OutOfMemory, failAllocator.allocSentinel(u8, 1, 0)); + try testing.expectError(error.OutOfMemory, failAllocator.alloc(u8, 1)); + try testing.expectError(error.OutOfMemory, failAllocator.allocSentinel(u8, 1, 0)); } /// Copy all of source into dest at position 0. @@ -276,8 +276,8 @@ test "mem.zeroes" { var a = zeroes(C_struct); a.y += 10; - testing.expect(a.x == 0); - testing.expect(a.y == 10); + try testing.expect(a.x == 0); + try testing.expect(a.y == 10); const ZigStruct = struct { integral_types: struct { @@ -314,32 +314,32 @@ test "mem.zeroes" { }; const b = zeroes(ZigStruct); - testing.expectEqual(@as(i8, 0), b.integral_types.integer_0); - testing.expectEqual(@as(i8, 0), b.integral_types.integer_8); - testing.expectEqual(@as(i16, 0), b.integral_types.integer_16); - testing.expectEqual(@as(i32, 0), b.integral_types.integer_32); - testing.expectEqual(@as(i64, 0), b.integral_types.integer_64); - testing.expectEqual(@as(i128, 0), b.integral_types.integer_128); - testing.expectEqual(@as(u8, 0), b.integral_types.unsigned_0); - testing.expectEqual(@as(u8, 0), b.integral_types.unsigned_8); - testing.expectEqual(@as(u16, 0), b.integral_types.unsigned_16); - testing.expectEqual(@as(u32, 0), b.integral_types.unsigned_32); - testing.expectEqual(@as(u64, 0), b.integral_types.unsigned_64); - testing.expectEqual(@as(u128, 0), b.integral_types.unsigned_128); - testing.expectEqual(@as(f32, 0), b.integral_types.float_32); - testing.expectEqual(@as(f64, 0), b.integral_types.float_64); - testing.expectEqual(@as(?*u8, null), b.pointers.optional); - testing.expectEqual(@as([*c]u8, null), b.pointers.c_pointer); - testing.expectEqual(@as([]u8, &[_]u8{}), b.pointers.slice); + try testing.expectEqual(@as(i8, 0), b.integral_types.integer_0); + try testing.expectEqual(@as(i8, 0), b.integral_types.integer_8); + try testing.expectEqual(@as(i16, 0), b.integral_types.integer_16); + try testing.expectEqual(@as(i32, 0), b.integral_types.integer_32); + try testing.expectEqual(@as(i64, 0), b.integral_types.integer_64); + try testing.expectEqual(@as(i128, 0), b.integral_types.integer_128); + try testing.expectEqual(@as(u8, 0), b.integral_types.unsigned_0); + try testing.expectEqual(@as(u8, 0), b.integral_types.unsigned_8); + try testing.expectEqual(@as(u16, 0), b.integral_types.unsigned_16); + try testing.expectEqual(@as(u32, 0), b.integral_types.unsigned_32); + try testing.expectEqual(@as(u64, 0), b.integral_types.unsigned_64); + try testing.expectEqual(@as(u128, 0), b.integral_types.unsigned_128); + try testing.expectEqual(@as(f32, 0), b.integral_types.float_32); + try testing.expectEqual(@as(f64, 0), b.integral_types.float_64); + try testing.expectEqual(@as(?*u8, null), b.pointers.optional); + try testing.expectEqual(@as([*c]u8, null), b.pointers.c_pointer); + try testing.expectEqual(@as([]u8, &[_]u8{}), b.pointers.slice); for (b.array) |e| { - testing.expectEqual(@as(u32, 0), e); + try testing.expectEqual(@as(u32, 0), e); } - testing.expectEqual(@splat(2, @as(u32, 0)), b.vector_u32); - testing.expectEqual(@splat(2, @as(f32, 0.0)), b.vector_f32); - testing.expectEqual(@splat(2, @as(bool, false)), b.vector_bool); - testing.expectEqual(@as(?u8, null), b.optional_int); + try testing.expectEqual(@splat(2, @as(u32, 0)), b.vector_u32); + try testing.expectEqual(@splat(2, @as(f32, 0.0)), b.vector_f32); + try testing.expectEqual(@splat(2, @as(bool, false)), b.vector_bool); + try testing.expectEqual(@as(?u8, null), b.optional_int); for (b.sentinel) |e| { - testing.expectEqual(@as(u8, 0), e); + try testing.expectEqual(@as(u8, 0), e); } const C_union = extern union { @@ -348,7 +348,7 @@ test "mem.zeroes" { }; var c = zeroes(C_union); - testing.expectEqual(@as(u8, 0), c.a); + try testing.expectEqual(@as(u8, 0), c.a); } /// Initializes all fields of the struct with their default value, or zero values if no default value is present. @@ -421,7 +421,7 @@ test "zeroInit" { .a = 42, }); - testing.expectEqual(S{ + try testing.expectEqual(S{ .a = 42, .b = null, .c = .{ @@ -439,7 +439,7 @@ test "zeroInit" { }; const c = zeroInit(Color, .{ 255, 255 }); - testing.expectEqual(Color{ + try testing.expectEqual(Color{ .r = 255, .g = 255, .b = 0, @@ -462,11 +462,11 @@ pub fn order(comptime T: type, lhs: []const T, rhs: []const T) math.Order { } test "order" { - testing.expect(order(u8, "abcd", "bee") == .lt); - testing.expect(order(u8, "abc", "abc") == .eq); - testing.expect(order(u8, "abc", "abc0") == .lt); - testing.expect(order(u8, "", "") == .eq); - testing.expect(order(u8, "", "a") == .lt); + try testing.expect(order(u8, "abcd", "bee") == .lt); + try testing.expect(order(u8, "abc", "abc") == .eq); + try testing.expect(order(u8, "abc", "abc0") == .lt); + try testing.expect(order(u8, "", "") == .eq); + try testing.expect(order(u8, "", "a") == .lt); } /// Returns true if lhs < rhs, false otherwise @@ -475,11 +475,11 @@ pub fn lessThan(comptime T: type, lhs: []const T, rhs: []const T) bool { } test "mem.lessThan" { - testing.expect(lessThan(u8, "abcd", "bee")); - testing.expect(!lessThan(u8, "abc", "abc")); - testing.expect(lessThan(u8, "abc", "abc0")); - testing.expect(!lessThan(u8, "", "")); - testing.expect(lessThan(u8, "", "a")); + try testing.expect(lessThan(u8, "abcd", "bee")); + try testing.expect(!lessThan(u8, "abc", "abc")); + try testing.expect(lessThan(u8, "abc", "abc0")); + try testing.expect(!lessThan(u8, "", "")); + try testing.expect(lessThan(u8, "", "a")); } /// Compares two slices and returns whether they are equal. @@ -504,11 +504,11 @@ pub fn indexOfDiff(comptime T: type, a: []const T, b: []const T) ?usize { } test "indexOfDiff" { - testing.expectEqual(indexOfDiff(u8, "one", "one"), null); - testing.expectEqual(indexOfDiff(u8, "one two", "one"), 3); - testing.expectEqual(indexOfDiff(u8, "one", "one two"), 3); - testing.expectEqual(indexOfDiff(u8, "one twx", "one two"), 6); - testing.expectEqual(indexOfDiff(u8, "xne", "one"), 0); + try testing.expectEqual(indexOfDiff(u8, "one", "one"), null); + try testing.expectEqual(indexOfDiff(u8, "one two", "one"), 3); + try testing.expectEqual(indexOfDiff(u8, "one", "one two"), 3); + try testing.expectEqual(indexOfDiff(u8, "one twx", "one two"), 6); + try testing.expectEqual(indexOfDiff(u8, "xne", "one"), 0); } pub const toSliceConst = @compileError("deprecated; use std.mem.spanZ"); @@ -548,26 +548,26 @@ pub fn Span(comptime T: type) type { } test "Span" { - testing.expect(Span(*[5]u16) == []u16); - testing.expect(Span(?*[5]u16) == ?[]u16); - testing.expect(Span(*const [5]u16) == []const u16); - testing.expect(Span(?*const [5]u16) == ?[]const u16); - testing.expect(Span([]u16) == []u16); - testing.expect(Span(?[]u16) == ?[]u16); - testing.expect(Span([]const u8) == []const u8); - testing.expect(Span(?[]const u8) == ?[]const u8); - testing.expect(Span([:1]u16) == [:1]u16); - testing.expect(Span(?[:1]u16) == ?[:1]u16); - testing.expect(Span([:1]const u8) == [:1]const u8); - testing.expect(Span(?[:1]const u8) == ?[:1]const u8); - testing.expect(Span([*:1]u16) == [:1]u16); - testing.expect(Span(?[*:1]u16) == ?[:1]u16); - testing.expect(Span([*:1]const u8) == [:1]const u8); - testing.expect(Span(?[*:1]const u8) == ?[:1]const u8); - testing.expect(Span([*c]u16) == [:0]u16); - testing.expect(Span(?[*c]u16) == ?[:0]u16); - testing.expect(Span([*c]const u8) == [:0]const u8); - testing.expect(Span(?[*c]const u8) == ?[:0]const u8); + try testing.expect(Span(*[5]u16) == []u16); + try testing.expect(Span(?*[5]u16) == ?[]u16); + try testing.expect(Span(*const [5]u16) == []const u16); + try testing.expect(Span(?*const [5]u16) == ?[]const u16); + try testing.expect(Span([]u16) == []u16); + try testing.expect(Span(?[]u16) == ?[]u16); + try testing.expect(Span([]const u8) == []const u8); + try testing.expect(Span(?[]const u8) == ?[]const u8); + try testing.expect(Span([:1]u16) == [:1]u16); + try testing.expect(Span(?[:1]u16) == ?[:1]u16); + try testing.expect(Span([:1]const u8) == [:1]const u8); + try testing.expect(Span(?[:1]const u8) == ?[:1]const u8); + try testing.expect(Span([*:1]u16) == [:1]u16); + try testing.expect(Span(?[*:1]u16) == ?[:1]u16); + try testing.expect(Span([*:1]const u8) == [:1]const u8); + try testing.expect(Span(?[*:1]const u8) == ?[:1]const u8); + try testing.expect(Span([*c]u16) == [:0]u16); + try testing.expect(Span(?[*c]u16) == ?[:0]u16); + try testing.expect(Span([*c]const u8) == [:0]const u8); + try testing.expect(Span(?[*c]const u8) == ?[:0]const u8); } /// Takes a pointer to an array, a sentinel-terminated pointer, or a slice, and @@ -597,9 +597,9 @@ pub fn span(ptr: anytype) Span(@TypeOf(ptr)) { test "span" { var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 }; const ptr = @as([*:3]u16, array[0..2 :3]); - testing.expect(eql(u16, span(ptr), &[_]u16{ 1, 2 })); - testing.expect(eql(u16, span(&array), &[_]u16{ 1, 2, 3, 4, 5 })); - testing.expectEqual(@as(?[:0]u16, null), span(@as(?[*:0]u16, null))); + try testing.expect(eql(u16, span(ptr), &[_]u16{ 1, 2 })); + try testing.expect(eql(u16, span(&array), &[_]u16{ 1, 2, 3, 4, 5 })); + try testing.expectEqual(@as(?[:0]u16, null), span(@as(?[*:0]u16, null))); } /// Same as `span`, except when there is both a sentinel and an array @@ -625,9 +625,9 @@ pub fn spanZ(ptr: anytype) Span(@TypeOf(ptr)) { test "spanZ" { var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 }; const ptr = @as([*:3]u16, array[0..2 :3]); - testing.expect(eql(u16, spanZ(ptr), &[_]u16{ 1, 2 })); - testing.expect(eql(u16, spanZ(&array), &[_]u16{ 1, 2, 3, 4, 5 })); - testing.expectEqual(@as(?[:0]u16, null), spanZ(@as(?[*:0]u16, null))); + try testing.expect(eql(u16, spanZ(ptr), &[_]u16{ 1, 2 })); + try testing.expect(eql(u16, spanZ(&array), &[_]u16{ 1, 2, 3, 4, 5 })); + try testing.expectEqual(@as(?[:0]u16, null), spanZ(@as(?[*:0]u16, null))); } /// Takes a pointer to an array, an array, a vector, a sentinel-terminated pointer, @@ -661,30 +661,30 @@ pub fn len(value: anytype) usize { } test "len" { - testing.expect(len("aoeu") == 4); + try testing.expect(len("aoeu") == 4); { var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 }; - testing.expect(len(&array) == 5); - testing.expect(len(array[0..3]) == 3); + try testing.expect(len(&array) == 5); + try testing.expect(len(array[0..3]) == 3); array[2] = 0; const ptr = @as([*:0]u16, array[0..2 :0]); - testing.expect(len(ptr) == 2); + try testing.expect(len(ptr) == 2); } { var array: [5:0]u16 = [_:0]u16{ 1, 2, 3, 4, 5 }; - testing.expect(len(&array) == 5); + try testing.expect(len(&array) == 5); array[2] = 0; - testing.expect(len(&array) == 5); + try testing.expect(len(&array) == 5); } { const vector: meta.Vector(2, u32) = [2]u32{ 1, 2 }; - testing.expect(len(vector) == 2); + try testing.expect(len(vector) == 2); } { const tuple = .{ 1, 2 }; - testing.expect(len(tuple) == 2); - testing.expect(tuple[0] == 1); + try testing.expect(len(tuple) == 2); + try testing.expect(tuple[0] == 1); } } @@ -725,21 +725,21 @@ pub fn lenZ(ptr: anytype) usize { } test "lenZ" { - testing.expect(lenZ("aoeu") == 4); + try testing.expect(lenZ("aoeu") == 4); { var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 }; - testing.expect(lenZ(&array) == 5); - testing.expect(lenZ(array[0..3]) == 3); + try testing.expect(lenZ(&array) == 5); + try testing.expect(lenZ(array[0..3]) == 3); array[2] = 0; const ptr = @as([*:0]u16, array[0..2 :0]); - testing.expect(lenZ(ptr) == 2); + try testing.expect(lenZ(ptr) == 2); } { var array: [5:0]u16 = [_:0]u16{ 1, 2, 3, 4, 5 }; - testing.expect(lenZ(&array) == 5); + try testing.expect(lenZ(&array) == 5); array[2] = 0; - testing.expect(lenZ(&array) == 2); + try testing.expect(lenZ(&array) == 2); } } @@ -793,10 +793,10 @@ pub fn trim(comptime T: type, slice: []const T, values_to_strip: []const T) []co } test "mem.trim" { - testing.expectEqualSlices(u8, "foo\n ", trimLeft(u8, " foo\n ", " \n")); - testing.expectEqualSlices(u8, " foo", trimRight(u8, " foo\n ", " \n")); - testing.expectEqualSlices(u8, "foo", trim(u8, " foo\n ", " \n")); - testing.expectEqualSlices(u8, "foo", trim(u8, "foo", " \n")); + try testing.expectEqualSlices(u8, "foo\n ", trimLeft(u8, " foo\n ", " \n")); + try testing.expectEqualSlices(u8, " foo", trimRight(u8, " foo\n ", " \n")); + try testing.expectEqualSlices(u8, "foo", trim(u8, " foo\n ", " \n")); + try testing.expectEqualSlices(u8, "foo", trim(u8, "foo", " \n")); } /// Linear search for the index of a scalar value inside a slice. @@ -951,28 +951,28 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee } test "mem.indexOf" { - testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8); - testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8); - testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "two two") == null); - testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "two two") == null); + try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8); + try testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8); + try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "two two") == null); + try testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "two two") == null); - testing.expect(indexOf(u8, "one two three four five six seven eight nine ten", "").? == 0); - testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten", "").? == 48); + try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten", "").? == 0); + try testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten", "").? == 48); - testing.expect(indexOf(u8, "one two three four", "four").? == 14); - testing.expect(lastIndexOf(u8, "one two three two four", "two").? == 14); - testing.expect(indexOf(u8, "one two three four", "gour") == null); - testing.expect(lastIndexOf(u8, "one two three four", "gour") == null); - testing.expect(indexOf(u8, "foo", "foo").? == 0); - testing.expect(lastIndexOf(u8, "foo", "foo").? == 0); - testing.expect(indexOf(u8, "foo", "fool") == null); - testing.expect(lastIndexOf(u8, "foo", "lfoo") == null); - testing.expect(lastIndexOf(u8, "foo", "fool") == null); + try testing.expect(indexOf(u8, "one two three four", "four").? == 14); + try testing.expect(lastIndexOf(u8, "one two three two four", "two").? == 14); + try testing.expect(indexOf(u8, "one two three four", "gour") == null); + try testing.expect(lastIndexOf(u8, "one two three four", "gour") == null); + try testing.expect(indexOf(u8, "foo", "foo").? == 0); + try testing.expect(lastIndexOf(u8, "foo", "foo").? == 0); + try testing.expect(indexOf(u8, "foo", "fool") == null); + try testing.expect(lastIndexOf(u8, "foo", "lfoo") == null); + try testing.expect(lastIndexOf(u8, "foo", "fool") == null); - testing.expect(indexOf(u8, "foo foo", "foo").? == 0); - testing.expect(lastIndexOf(u8, "foo foo", "foo").? == 4); - testing.expect(lastIndexOfAny(u8, "boo, cat", "abo").? == 6); - testing.expect(lastIndexOfScalar(u8, "boo", 'o').? == 2); + try testing.expect(indexOf(u8, "foo foo", "foo").? == 0); + try testing.expect(lastIndexOf(u8, "foo foo", "foo").? == 4); + try testing.expect(lastIndexOfAny(u8, "boo, cat", "abo").? == 6); + try testing.expect(lastIndexOfScalar(u8, "boo", 'o').? == 2); } /// Returns the number of needles inside the haystack @@ -992,17 +992,17 @@ pub fn count(comptime T: type, haystack: []const T, needle: []const T) usize { } test "mem.count" { - testing.expect(count(u8, "", "h") == 0); - testing.expect(count(u8, "h", "h") == 1); - testing.expect(count(u8, "hh", "h") == 2); - testing.expect(count(u8, "world!", "hello") == 0); - testing.expect(count(u8, "hello world!", "hello") == 1); - testing.expect(count(u8, " abcabc abc", "abc") == 3); - testing.expect(count(u8, "udexdcbvbruhasdrw", "bruh") == 1); - testing.expect(count(u8, "foo bar", "o bar") == 1); - testing.expect(count(u8, "foofoofoo", "foo") == 3); - testing.expect(count(u8, "fffffff", "ff") == 3); - testing.expect(count(u8, "owowowu", "owowu") == 1); + try testing.expect(count(u8, "", "h") == 0); + try testing.expect(count(u8, "h", "h") == 1); + try testing.expect(count(u8, "hh", "h") == 2); + try testing.expect(count(u8, "world!", "hello") == 0); + try testing.expect(count(u8, "hello world!", "hello") == 1); + try testing.expect(count(u8, " abcabc abc", "abc") == 3); + try testing.expect(count(u8, "udexdcbvbruhasdrw", "bruh") == 1); + try testing.expect(count(u8, "foo bar", "o bar") == 1); + try testing.expect(count(u8, "foofoofoo", "foo") == 3); + try testing.expect(count(u8, "fffffff", "ff") == 3); + try testing.expect(count(u8, "owowowu", "owowu") == 1); } /// Returns true if the haystack contains expected_count or more needles @@ -1024,19 +1024,19 @@ pub fn containsAtLeast(comptime T: type, haystack: []const T, expected_count: us } test "mem.containsAtLeast" { - testing.expect(containsAtLeast(u8, "aa", 0, "a")); - testing.expect(containsAtLeast(u8, "aa", 1, "a")); - testing.expect(containsAtLeast(u8, "aa", 2, "a")); - testing.expect(!containsAtLeast(u8, "aa", 3, "a")); + try testing.expect(containsAtLeast(u8, "aa", 0, "a")); + try testing.expect(containsAtLeast(u8, "aa", 1, "a")); + try testing.expect(containsAtLeast(u8, "aa", 2, "a")); + try testing.expect(!containsAtLeast(u8, "aa", 3, "a")); - testing.expect(containsAtLeast(u8, "radaradar", 1, "radar")); - testing.expect(!containsAtLeast(u8, "radaradar", 2, "radar")); + try testing.expect(containsAtLeast(u8, "radaradar", 1, "radar")); + try testing.expect(!containsAtLeast(u8, "radaradar", 2, "radar")); - testing.expect(containsAtLeast(u8, "radarradaradarradar", 3, "radar")); - testing.expect(!containsAtLeast(u8, "radarradaradarradar", 4, "radar")); + try testing.expect(containsAtLeast(u8, "radarradaradarradar", 3, "radar")); + try testing.expect(!containsAtLeast(u8, "radarradaradarradar", 4, "radar")); - testing.expect(containsAtLeast(u8, " radar radar ", 2, "radar")); - testing.expect(!containsAtLeast(u8, " radar radar ", 3, "radar")); + try testing.expect(containsAtLeast(u8, " radar radar ", 2, "radar")); + try testing.expect(!containsAtLeast(u8, " radar radar ", 3, "radar")); } /// Reads an integer from memory with size equal to bytes.len. @@ -1141,34 +1141,34 @@ test "comptime read/write int" { var bytes: [2]u8 = undefined; writeIntLittle(u16, &bytes, 0x1234); const result = readIntBig(u16, &bytes); - testing.expect(result == 0x3412); + try testing.expect(result == 0x3412); } comptime { var bytes: [2]u8 = undefined; writeIntBig(u16, &bytes, 0x1234); const result = readIntLittle(u16, &bytes); - testing.expect(result == 0x3412); + try testing.expect(result == 0x3412); } } test "readIntBig and readIntLittle" { - testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0); - testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0); + try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0); + try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0); - testing.expect(readIntSliceBig(u8, &[_]u8{0x32}) == 0x32); - testing.expect(readIntSliceLittle(u8, &[_]u8{0x12}) == 0x12); + try testing.expect(readIntSliceBig(u8, &[_]u8{0x32}) == 0x32); + try testing.expect(readIntSliceLittle(u8, &[_]u8{0x12}) == 0x12); - testing.expect(readIntSliceBig(u16, &[_]u8{ 0x12, 0x34 }) == 0x1234); - testing.expect(readIntSliceLittle(u16, &[_]u8{ 0x12, 0x34 }) == 0x3412); + try testing.expect(readIntSliceBig(u16, &[_]u8{ 0x12, 0x34 }) == 0x1234); + try testing.expect(readIntSliceLittle(u16, &[_]u8{ 0x12, 0x34 }) == 0x3412); - testing.expect(readIntSliceBig(u72, &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }) == 0x123456789abcdef024); - testing.expect(readIntSliceLittle(u72, &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }) == 0xfedcba9876543210ec); + try testing.expect(readIntSliceBig(u72, &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 }) == 0x123456789abcdef024); + try testing.expect(readIntSliceLittle(u72, &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe }) == 0xfedcba9876543210ec); - testing.expect(readIntSliceBig(i8, &[_]u8{0xff}) == -1); - testing.expect(readIntSliceLittle(i8, &[_]u8{0xfe}) == -2); + try testing.expect(readIntSliceBig(i8, &[_]u8{0xff}) == -1); + try testing.expect(readIntSliceLittle(i8, &[_]u8{0xfe}) == -2); - testing.expect(readIntSliceBig(i16, &[_]u8{ 0xff, 0xfd }) == -3); - testing.expect(readIntSliceLittle(i16, &[_]u8{ 0xfc, 0xff }) == -4); + try testing.expect(readIntSliceBig(i16, &[_]u8{ 0xff, 0xfd }) == -3); + try testing.expect(readIntSliceLittle(i16, &[_]u8{ 0xfc, 0xff }) == -4); } /// Writes an integer to memory, storing it in twos-complement. @@ -1283,34 +1283,34 @@ test "writeIntBig and writeIntLittle" { var buf9: [9]u8 = undefined; writeIntBig(u0, &buf0, 0x0); - testing.expect(eql(u8, buf0[0..], &[_]u8{})); + try testing.expect(eql(u8, buf0[0..], &[_]u8{})); writeIntLittle(u0, &buf0, 0x0); - testing.expect(eql(u8, buf0[0..], &[_]u8{})); + try testing.expect(eql(u8, buf0[0..], &[_]u8{})); writeIntBig(u8, &buf1, 0x12); - testing.expect(eql(u8, buf1[0..], &[_]u8{0x12})); + try testing.expect(eql(u8, buf1[0..], &[_]u8{0x12})); writeIntLittle(u8, &buf1, 0x34); - testing.expect(eql(u8, buf1[0..], &[_]u8{0x34})); + try testing.expect(eql(u8, buf1[0..], &[_]u8{0x34})); writeIntBig(u16, &buf2, 0x1234); - testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x12, 0x34 })); + try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x12, 0x34 })); writeIntLittle(u16, &buf2, 0x5678); - testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x78, 0x56 })); + try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0x78, 0x56 })); writeIntBig(u72, &buf9, 0x123456789abcdef024); - testing.expect(eql(u8, buf9[0..], &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 })); + try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x24 })); writeIntLittle(u72, &buf9, 0xfedcba9876543210ec); - testing.expect(eql(u8, buf9[0..], &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe })); + try testing.expect(eql(u8, buf9[0..], &[_]u8{ 0xec, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe })); writeIntBig(i8, &buf1, -1); - testing.expect(eql(u8, buf1[0..], &[_]u8{0xff})); + try testing.expect(eql(u8, buf1[0..], &[_]u8{0xff})); writeIntLittle(i8, &buf1, -2); - testing.expect(eql(u8, buf1[0..], &[_]u8{0xfe})); + try testing.expect(eql(u8, buf1[0..], &[_]u8{0xfe})); writeIntBig(i16, &buf2, -3); - testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xff, 0xfd })); + try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xff, 0xfd })); writeIntLittle(i16, &buf2, -4); - testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xfc, 0xff })); + try testing.expect(eql(u8, buf2[0..], &[_]u8{ 0xfc, 0xff })); } /// Returns an iterator that iterates over the slices of `buffer` that are not @@ -1331,60 +1331,60 @@ pub fn tokenize(buffer: []const u8, delimiter_bytes: []const u8) TokenIterator { test "mem.tokenize" { var it = tokenize(" abc def ghi ", " "); - testing.expect(eql(u8, it.next().?, "abc")); - testing.expect(eql(u8, it.next().?, "def")); - testing.expect(eql(u8, it.next().?, "ghi")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "abc")); + try testing.expect(eql(u8, it.next().?, "def")); + try testing.expect(eql(u8, it.next().?, "ghi")); + try testing.expect(it.next() == null); it = tokenize("..\\bob", "\\"); - testing.expect(eql(u8, it.next().?, "..")); - testing.expect(eql(u8, "..", "..\\bob"[0..it.index])); - testing.expect(eql(u8, it.next().?, "bob")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "..")); + try testing.expect(eql(u8, "..", "..\\bob"[0..it.index])); + try testing.expect(eql(u8, it.next().?, "bob")); + try testing.expect(it.next() == null); it = tokenize("//a/b", "/"); - testing.expect(eql(u8, it.next().?, "a")); - testing.expect(eql(u8, it.next().?, "b")); - testing.expect(eql(u8, "//a/b", "//a/b"[0..it.index])); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "a")); + try testing.expect(eql(u8, it.next().?, "b")); + try testing.expect(eql(u8, "//a/b", "//a/b"[0..it.index])); + try testing.expect(it.next() == null); it = tokenize("|", "|"); - testing.expect(it.next() == null); + try testing.expect(it.next() == null); it = tokenize("", "|"); - testing.expect(it.next() == null); + try testing.expect(it.next() == null); it = tokenize("hello", ""); - testing.expect(eql(u8, it.next().?, "hello")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "hello")); + try testing.expect(it.next() == null); it = tokenize("hello", " "); - testing.expect(eql(u8, it.next().?, "hello")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "hello")); + try testing.expect(it.next() == null); } test "mem.tokenize (multibyte)" { var it = tokenize("a|b,c/d e", " /,|"); - testing.expect(eql(u8, it.next().?, "a")); - testing.expect(eql(u8, it.next().?, "b")); - testing.expect(eql(u8, it.next().?, "c")); - testing.expect(eql(u8, it.next().?, "d")); - testing.expect(eql(u8, it.next().?, "e")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "a")); + try testing.expect(eql(u8, it.next().?, "b")); + try testing.expect(eql(u8, it.next().?, "c")); + try testing.expect(eql(u8, it.next().?, "d")); + try testing.expect(eql(u8, it.next().?, "e")); + try testing.expect(it.next() == null); } test "mem.tokenize (reset)" { var it = tokenize(" abc def ghi ", " "); - testing.expect(eql(u8, it.next().?, "abc")); - testing.expect(eql(u8, it.next().?, "def")); - testing.expect(eql(u8, it.next().?, "ghi")); + try testing.expect(eql(u8, it.next().?, "abc")); + try testing.expect(eql(u8, it.next().?, "def")); + try testing.expect(eql(u8, it.next().?, "ghi")); it.reset(); - testing.expect(eql(u8, it.next().?, "abc")); - testing.expect(eql(u8, it.next().?, "def")); - testing.expect(eql(u8, it.next().?, "ghi")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "abc")); + try testing.expect(eql(u8, it.next().?, "def")); + try testing.expect(eql(u8, it.next().?, "ghi")); + try testing.expect(it.next() == null); } /// Returns an iterator that iterates over the slices of `buffer` that @@ -1408,34 +1408,34 @@ pub const separate = @compileError("deprecated: renamed to split (behavior remai test "mem.split" { var it = split("abc|def||ghi", "|"); - testing.expect(eql(u8, it.next().?, "abc")); - testing.expect(eql(u8, it.next().?, "def")); - testing.expect(eql(u8, it.next().?, "")); - testing.expect(eql(u8, it.next().?, "ghi")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "abc")); + try testing.expect(eql(u8, it.next().?, "def")); + try testing.expect(eql(u8, it.next().?, "")); + try testing.expect(eql(u8, it.next().?, "ghi")); + try testing.expect(it.next() == null); it = split("", "|"); - testing.expect(eql(u8, it.next().?, "")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "")); + try testing.expect(it.next() == null); it = split("|", "|"); - testing.expect(eql(u8, it.next().?, "")); - testing.expect(eql(u8, it.next().?, "")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "")); + try testing.expect(eql(u8, it.next().?, "")); + try testing.expect(it.next() == null); it = split("hello", " "); - testing.expect(eql(u8, it.next().?, "hello")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "hello")); + try testing.expect(it.next() == null); } test "mem.split (multibyte)" { var it = split("a, b ,, c, d, e", ", "); - testing.expect(eql(u8, it.next().?, "a")); - testing.expect(eql(u8, it.next().?, "b ,")); - testing.expect(eql(u8, it.next().?, "c")); - testing.expect(eql(u8, it.next().?, "d")); - testing.expect(eql(u8, it.next().?, "e")); - testing.expect(it.next() == null); + try testing.expect(eql(u8, it.next().?, "a")); + try testing.expect(eql(u8, it.next().?, "b ,")); + try testing.expect(eql(u8, it.next().?, "c")); + try testing.expect(eql(u8, it.next().?, "d")); + try testing.expect(eql(u8, it.next().?, "e")); + try testing.expect(it.next() == null); } pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool { @@ -1443,8 +1443,8 @@ pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool } test "mem.startsWith" { - testing.expect(startsWith(u8, "Bob", "Bo")); - testing.expect(!startsWith(u8, "Needle in haystack", "haystack")); + try testing.expect(startsWith(u8, "Bob", "Bo")); + try testing.expect(!startsWith(u8, "Needle in haystack", "haystack")); } pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool { @@ -1452,8 +1452,8 @@ pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool { } test "mem.endsWith" { - testing.expect(endsWith(u8, "Needle in haystack", "haystack")); - testing.expect(!endsWith(u8, "Bob", "Bo")); + try testing.expect(endsWith(u8, "Needle in haystack", "haystack")); + try testing.expect(!endsWith(u8, "Bob", "Bo")); } pub const TokenIterator = struct { @@ -1571,22 +1571,22 @@ test "mem.join" { { const str = try join(testing.allocator, ",", &[_][]const u8{}); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "")); + try testing.expect(eql(u8, str, "")); } { const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "b", "c" }); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a,b,c")); + try testing.expect(eql(u8, str, "a,b,c")); } { const str = try join(testing.allocator, ",", &[_][]const u8{"a"}); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a")); + try testing.expect(eql(u8, str, "a")); } { const str = try join(testing.allocator, ",", &[_][]const u8{ "a", "", "b", "", "c" }); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a,,b,,c")); + try testing.expect(eql(u8, str, "a,,b,,c")); } } @@ -1594,26 +1594,26 @@ test "mem.joinZ" { { const str = try joinZ(testing.allocator, ",", &[_][]const u8{}); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "")); - testing.expectEqual(str[str.len], 0); + try testing.expect(eql(u8, str, "")); + try testing.expectEqual(str[str.len], 0); } { const str = try joinZ(testing.allocator, ",", &[_][]const u8{ "a", "b", "c" }); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a,b,c")); - testing.expectEqual(str[str.len], 0); + try testing.expect(eql(u8, str, "a,b,c")); + try testing.expectEqual(str[str.len], 0); } { const str = try joinZ(testing.allocator, ",", &[_][]const u8{"a"}); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a")); - testing.expectEqual(str[str.len], 0); + try testing.expect(eql(u8, str, "a")); + try testing.expectEqual(str[str.len], 0); } { const str = try joinZ(testing.allocator, ",", &[_][]const u8{ "a", "", "b", "", "c" }); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "a,,b,,c")); - testing.expectEqual(str[str.len], 0); + try testing.expect(eql(u8, str, "a,,b,,c")); + try testing.expectEqual(str[str.len], 0); } } @@ -1646,7 +1646,7 @@ test "concat" { { const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" }); defer testing.allocator.free(str); - testing.expect(eql(u8, str, "abcdefghi")); + try testing.expect(eql(u8, str, "abcdefghi")); } { const str = try concat(testing.allocator, u32, &[_][]const u32{ @@ -1656,21 +1656,21 @@ test "concat" { &[_]u32{5}, }); defer testing.allocator.free(str); - testing.expect(eql(u32, str, &[_]u32{ 0, 1, 2, 3, 4, 5 })); + try testing.expect(eql(u32, str, &[_]u32{ 0, 1, 2, 3, 4, 5 })); } } test "testStringEquality" { - testing.expect(eql(u8, "abcd", "abcd")); - testing.expect(!eql(u8, "abcdef", "abZdef")); - testing.expect(!eql(u8, "abcdefg", "abcdef")); + try testing.expect(eql(u8, "abcd", "abcd")); + try testing.expect(!eql(u8, "abcdef", "abZdef")); + try testing.expect(!eql(u8, "abcdefg", "abcdef")); } test "testReadInt" { - testReadIntImpl(); - comptime testReadIntImpl(); + try testReadIntImpl(); + comptime try testReadIntImpl(); } -fn testReadIntImpl() void { +fn testReadIntImpl() !void { { const bytes = [_]u8{ 0x12, @@ -1678,12 +1678,12 @@ fn testReadIntImpl() void { 0x56, 0x78, }; - testing.expect(readInt(u32, &bytes, builtin.Endian.Big) == 0x12345678); - testing.expect(readIntBig(u32, &bytes) == 0x12345678); - testing.expect(readIntBig(i32, &bytes) == 0x12345678); - testing.expect(readInt(u32, &bytes, builtin.Endian.Little) == 0x78563412); - testing.expect(readIntLittle(u32, &bytes) == 0x78563412); - testing.expect(readIntLittle(i32, &bytes) == 0x78563412); + try testing.expect(readInt(u32, &bytes, builtin.Endian.Big) == 0x12345678); + try testing.expect(readIntBig(u32, &bytes) == 0x12345678); + try testing.expect(readIntBig(i32, &bytes) == 0x12345678); + try testing.expect(readInt(u32, &bytes, builtin.Endian.Little) == 0x78563412); + try testing.expect(readIntLittle(u32, &bytes) == 0x78563412); + try testing.expect(readIntLittle(i32, &bytes) == 0x78563412); } { const buf = [_]u8{ @@ -1693,7 +1693,7 @@ fn testReadIntImpl() void { 0x34, }; const answer = readInt(u32, &buf, builtin.Endian.Big); - testing.expect(answer == 0x00001234); + try testing.expect(answer == 0x00001234); } { const buf = [_]u8{ @@ -1703,41 +1703,41 @@ fn testReadIntImpl() void { 0x00, }; const answer = readInt(u32, &buf, builtin.Endian.Little); - testing.expect(answer == 0x00003412); + try testing.expect(answer == 0x00003412); } { const bytes = [_]u8{ 0xff, 0xfe, }; - testing.expect(readIntBig(u16, &bytes) == 0xfffe); - testing.expect(readIntBig(i16, &bytes) == -0x0002); - testing.expect(readIntLittle(u16, &bytes) == 0xfeff); - testing.expect(readIntLittle(i16, &bytes) == -0x0101); + try testing.expect(readIntBig(u16, &bytes) == 0xfffe); + try testing.expect(readIntBig(i16, &bytes) == -0x0002); + try testing.expect(readIntLittle(u16, &bytes) == 0xfeff); + try testing.expect(readIntLittle(i16, &bytes) == -0x0101); } } test "writeIntSlice" { - testWriteIntImpl(); - comptime testWriteIntImpl(); + try testWriteIntImpl(); + comptime try testWriteIntImpl(); } -fn testWriteIntImpl() void { +fn testWriteIntImpl() !void { var bytes: [8]u8 = undefined; writeIntSlice(u0, bytes[0..], 0, builtin.Endian.Big); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, })); writeIntSlice(u0, bytes[0..], 0, builtin.Endian.Little); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, })); writeIntSlice(u64, bytes[0..], 0x12345678CAFEBABE, builtin.Endian.Big); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x12, 0x34, 0x56, @@ -1749,7 +1749,7 @@ fn testWriteIntImpl() void { })); writeIntSlice(u64, bytes[0..], 0xBEBAFECA78563412, builtin.Endian.Little); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x12, 0x34, 0x56, @@ -1761,7 +1761,7 @@ fn testWriteIntImpl() void { })); writeIntSlice(u32, bytes[0..], 0x12345678, builtin.Endian.Big); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x00, 0x00, 0x00, @@ -1773,7 +1773,7 @@ fn testWriteIntImpl() void { })); writeIntSlice(u32, bytes[0..], 0x78563412, builtin.Endian.Little); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x12, 0x34, 0x56, @@ -1785,7 +1785,7 @@ fn testWriteIntImpl() void { })); writeIntSlice(u16, bytes[0..], 0x1234, builtin.Endian.Big); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x00, 0x00, 0x00, @@ -1797,7 +1797,7 @@ fn testWriteIntImpl() void { })); writeIntSlice(u16, bytes[0..], 0x1234, builtin.Endian.Little); - testing.expect(eql(u8, &bytes, &[_]u8{ + try testing.expect(eql(u8, &bytes, &[_]u8{ 0x34, 0x12, 0x00, @@ -1820,7 +1820,7 @@ pub fn min(comptime T: type, slice: []const T) T { } test "mem.min" { - testing.expect(min(u8, "abcdefg") == 'a'); + try testing.expect(min(u8, "abcdefg") == 'a'); } /// Returns the largest number in a slice. O(n). @@ -1834,7 +1834,7 @@ pub fn max(comptime T: type, slice: []const T) T { } test "mem.max" { - testing.expect(max(u8, "abcdefg") == 'g'); + try testing.expect(max(u8, "abcdefg") == 'g'); } pub fn swap(comptime T: type, a: *T, b: *T) void { @@ -1856,7 +1856,7 @@ test "reverse" { var arr = [_]i32{ 5, 3, 1, 2, 4 }; reverse(i32, arr[0..]); - testing.expect(eql(i32, &arr, &[_]i32{ 4, 2, 1, 3, 5 })); + try testing.expect(eql(i32, &arr, &[_]i32{ 4, 2, 1, 3, 5 })); } /// In-place rotation of the values in an array ([0 1 2 3] becomes [1 2 3 0] if we rotate by 1) @@ -1871,7 +1871,7 @@ test "rotate" { var arr = [_]i32{ 5, 3, 1, 2, 4 }; rotate(i32, arr[0..], 2); - testing.expect(eql(i32, &arr, &[_]i32{ 1, 2, 4, 5, 3 })); + try testing.expect(eql(i32, &arr, &[_]i32{ 1, 2, 4, 5, 3 })); } /// Replace needle with replacement as many times as possible, writing to an output buffer which is assumed to be of @@ -1904,31 +1904,31 @@ test "replace" { var output: [29]u8 = undefined; var replacements = replace(u8, "All your base are belong to us", "base", "Zig", output[0..]); var expected: []const u8 = "All your Zig are belong to us"; - testing.expect(replacements == 1); - testing.expectEqualStrings(expected, output[0..expected.len]); + try testing.expect(replacements == 1); + try testing.expectEqualStrings(expected, output[0..expected.len]); replacements = replace(u8, "Favor reading code over writing code.", "code", "", output[0..]); expected = "Favor reading over writing ."; - testing.expect(replacements == 2); - testing.expectEqualStrings(expected, output[0..expected.len]); + try testing.expect(replacements == 2); + try testing.expectEqualStrings(expected, output[0..expected.len]); // Empty needle is not allowed but input may be empty. replacements = replace(u8, "", "x", "y", output[0..0]); expected = ""; - testing.expect(replacements == 0); - testing.expectEqualStrings(expected, output[0..expected.len]); + try testing.expect(replacements == 0); + try testing.expectEqualStrings(expected, output[0..expected.len]); // Adjacent replacements. replacements = replace(u8, "\\n\\n", "\\n", "\n", output[0..]); expected = "\n\n"; - testing.expect(replacements == 2); - testing.expectEqualStrings(expected, output[0..expected.len]); + try testing.expect(replacements == 2); + try testing.expectEqualStrings(expected, output[0..expected.len]); replacements = replace(u8, "abbba", "b", "cd", output[0..]); expected = "acdcdcda"; - testing.expect(replacements == 3); - testing.expectEqualStrings(expected, output[0..expected.len]); + try testing.expect(replacements == 3); + try testing.expectEqualStrings(expected, output[0..expected.len]); } /// Calculate the size needed in an output buffer to perform a replacement. @@ -1952,16 +1952,16 @@ pub fn replacementSize(comptime T: type, input: []const T, needle: []const T, re } test "replacementSize" { - testing.expect(replacementSize(u8, "All your base are belong to us", "base", "Zig") == 29); - testing.expect(replacementSize(u8, "Favor reading code over writing code.", "code", "") == 29); - testing.expect(replacementSize(u8, "Only one obvious way to do things.", "things.", "things in Zig.") == 41); + try testing.expect(replacementSize(u8, "All your base are belong to us", "base", "Zig") == 29); + try testing.expect(replacementSize(u8, "Favor reading code over writing code.", "code", "") == 29); + try testing.expect(replacementSize(u8, "Only one obvious way to do things.", "things.", "things in Zig.") == 41); // Empty needle is not allowed but input may be empty. - testing.expect(replacementSize(u8, "", "x", "y") == 0); + try testing.expect(replacementSize(u8, "", "x", "y") == 0); // Adjacent replacements. - testing.expect(replacementSize(u8, "\\n\\n", "\\n", "\n") == 2); - testing.expect(replacementSize(u8, "abbba", "b", "cd") == 8); + try testing.expect(replacementSize(u8, "\\n\\n", "\\n", "\n") == 2); + try testing.expect(replacementSize(u8, "abbba", "b", "cd") == 8); } /// Perform a replacement on an allocated buffer of pre-determined size. Caller must free returned memory. @@ -1976,11 +1976,11 @@ test "replaceOwned" { const base_replace = replaceOwned(u8, allocator, "All your base are belong to us", "base", "Zig") catch unreachable; defer allocator.free(base_replace); - testing.expect(eql(u8, base_replace, "All your Zig are belong to us")); + try testing.expect(eql(u8, base_replace, "All your Zig are belong to us")); const zen_replace = replaceOwned(u8, allocator, "Favor reading code over writing code.", " code", "") catch unreachable; defer allocator.free(zen_replace); - testing.expect(eql(u8, zen_replace, "Favor reading over writing.")); + try testing.expect(eql(u8, zen_replace, "Favor reading over writing.")); } /// Converts a little-endian integer to host endianness. @@ -2068,12 +2068,12 @@ test "asBytes" { .Little => "\xEF\xBE\xAD\xDE", }; - testing.expect(eql(u8, asBytes(&deadbeef), deadbeef_bytes)); + try testing.expect(eql(u8, asBytes(&deadbeef), deadbeef_bytes)); var codeface = @as(u32, 0xC0DEFACE); for (asBytes(&codeface).*) |*b| b.* = 0; - testing.expect(codeface == 0); + try testing.expect(codeface == 0); const S = packed struct { a: u8, @@ -2088,11 +2088,11 @@ test "asBytes" { .c = 0xDE, .d = 0xA1, }; - testing.expect(eql(u8, asBytes(&inst), "\xBE\xEF\xDE\xA1")); + try testing.expect(eql(u8, asBytes(&inst), "\xBE\xEF\xDE\xA1")); const ZST = struct {}; const zero = ZST{}; - testing.expect(eql(u8, asBytes(&zero), "")); + try testing.expect(eql(u8, asBytes(&zero), "")); } test "asBytes preserves pointer attributes" { @@ -2103,10 +2103,10 @@ test "asBytes preserves pointer attributes" { const in = @typeInfo(@TypeOf(inPtr)).Pointer; const out = @typeInfo(@TypeOf(outSlice)).Pointer; - testing.expectEqual(in.is_const, out.is_const); - testing.expectEqual(in.is_volatile, out.is_volatile); - testing.expectEqual(in.is_allowzero, out.is_allowzero); - testing.expectEqual(in.alignment, out.alignment); + try testing.expectEqual(in.is_const, out.is_const); + try testing.expectEqual(in.is_volatile, out.is_volatile); + try testing.expectEqual(in.is_allowzero, out.is_allowzero); + try testing.expectEqual(in.alignment, out.alignment); } /// Given any value, returns a copy of its bytes in an array. @@ -2117,14 +2117,14 @@ pub fn toBytes(value: anytype) [@sizeOf(@TypeOf(value))]u8 { test "toBytes" { var my_bytes = toBytes(@as(u32, 0x12345678)); switch (builtin.endian) { - .Big => testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")), - .Little => testing.expect(eql(u8, &my_bytes, "\x78\x56\x34\x12")), + .Big => try testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")), + .Little => try testing.expect(eql(u8, &my_bytes, "\x78\x56\x34\x12")), } my_bytes[0] = '\x99'; switch (builtin.endian) { - .Big => testing.expect(eql(u8, &my_bytes, "\x99\x34\x56\x78")), - .Little => testing.expect(eql(u8, &my_bytes, "\x99\x56\x34\x12")), + .Big => try testing.expect(eql(u8, &my_bytes, "\x99\x34\x56\x78")), + .Little => try testing.expect(eql(u8, &my_bytes, "\x99\x56\x34\x12")), } } @@ -2154,17 +2154,17 @@ test "bytesAsValue" { .Little => "\xEF\xBE\xAD\xDE", }; - testing.expect(deadbeef == bytesAsValue(u32, deadbeef_bytes).*); + try testing.expect(deadbeef == bytesAsValue(u32, deadbeef_bytes).*); var codeface_bytes: [4]u8 = switch (builtin.endian) { .Big => "\xC0\xDE\xFA\xCE", .Little => "\xCE\xFA\xDE\xC0", }.*; var codeface = bytesAsValue(u32, &codeface_bytes); - testing.expect(codeface.* == 0xC0DEFACE); + try testing.expect(codeface.* == 0xC0DEFACE); codeface.* = 0; for (codeface_bytes) |b| - testing.expect(b == 0); + try testing.expect(b == 0); const S = packed struct { a: u8, @@ -2181,7 +2181,7 @@ test "bytesAsValue" { }; const inst_bytes = "\xBE\xEF\xDE\xA1"; const inst2 = bytesAsValue(S, inst_bytes); - testing.expect(meta.eql(inst, inst2.*)); + try testing.expect(meta.eql(inst, inst2.*)); } test "bytesAsValue preserves pointer attributes" { @@ -2192,10 +2192,10 @@ test "bytesAsValue preserves pointer attributes" { const in = @typeInfo(@TypeOf(inSlice)).Pointer; const out = @typeInfo(@TypeOf(outPtr)).Pointer; - testing.expectEqual(in.is_const, out.is_const); - testing.expectEqual(in.is_volatile, out.is_volatile); - testing.expectEqual(in.is_allowzero, out.is_allowzero); - testing.expectEqual(in.alignment, out.alignment); + try testing.expectEqual(in.is_const, out.is_const); + try testing.expectEqual(in.is_volatile, out.is_volatile); + try testing.expectEqual(in.is_allowzero, out.is_allowzero); + try testing.expectEqual(in.alignment, out.alignment); } /// Given a pointer to an array of bytes, returns a value of the specified type backed by a @@ -2210,7 +2210,7 @@ test "bytesToValue" { }; const deadbeef = bytesToValue(u32, deadbeef_bytes); - testing.expect(deadbeef == @as(u32, 0xDEADBEEF)); + try testing.expect(deadbeef == @as(u32, 0xDEADBEEF)); } fn BytesAsSliceReturnType(comptime T: type, comptime bytesType: type) type { @@ -2243,17 +2243,17 @@ test "bytesAsSlice" { { const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF }; const slice = bytesAsSlice(u16, bytes[0..]); - testing.expect(slice.len == 2); - testing.expect(bigToNative(u16, slice[0]) == 0xDEAD); - testing.expect(bigToNative(u16, slice[1]) == 0xBEEF); + try testing.expect(slice.len == 2); + try testing.expect(bigToNative(u16, slice[0]) == 0xDEAD); + try testing.expect(bigToNative(u16, slice[1]) == 0xBEEF); } { const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF }; var runtime_zero: usize = 0; const slice = bytesAsSlice(u16, bytes[runtime_zero..]); - testing.expect(slice.len == 2); - testing.expect(bigToNative(u16, slice[0]) == 0xDEAD); - testing.expect(bigToNative(u16, slice[1]) == 0xBEEF); + try testing.expect(slice.len == 2); + try testing.expect(bigToNative(u16, slice[0]) == 0xDEAD); + try testing.expect(bigToNative(u16, slice[1]) == 0xBEEF); } } @@ -2261,13 +2261,13 @@ test "bytesAsSlice keeps pointer alignment" { { var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 }; const numbers = bytesAsSlice(u32, bytes[0..]); - comptime testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); + comptime try testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); } { var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 }; var runtime_zero: usize = 0; const numbers = bytesAsSlice(u32, bytes[runtime_zero..]); - comptime testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); + comptime try testing.expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32); } } @@ -2278,7 +2278,7 @@ test "bytesAsSlice on a packed struct" { var b = [1]u8{9}; var f = bytesAsSlice(F, &b); - testing.expect(f[0].a == 9); + try testing.expect(f[0].a == 9); } test "bytesAsSlice with specified alignment" { @@ -2289,7 +2289,7 @@ test "bytesAsSlice with specified alignment" { 0x33, }; const slice: []u32 = std.mem.bytesAsSlice(u32, bytes[0..]); - testing.expect(slice[0] == 0x33333333); + try testing.expect(slice[0] == 0x33333333); } test "bytesAsSlice preserves pointer attributes" { @@ -2300,10 +2300,10 @@ test "bytesAsSlice preserves pointer attributes" { const in = @typeInfo(@TypeOf(inSlice)).Pointer; const out = @typeInfo(@TypeOf(outSlice)).Pointer; - testing.expectEqual(in.is_const, out.is_const); - testing.expectEqual(in.is_volatile, out.is_volatile); - testing.expectEqual(in.is_allowzero, out.is_allowzero); - testing.expectEqual(in.alignment, out.alignment); + try testing.expectEqual(in.is_const, out.is_const); + try testing.expectEqual(in.is_volatile, out.is_volatile); + try testing.expectEqual(in.is_allowzero, out.is_allowzero); + try testing.expectEqual(in.alignment, out.alignment); } fn SliceAsBytesReturnType(comptime sliceType: type) type { @@ -2332,8 +2332,8 @@ pub fn sliceAsBytes(slice: anytype) SliceAsBytesReturnType(@TypeOf(slice)) { test "sliceAsBytes" { const bytes = [_]u16{ 0xDEAD, 0xBEEF }; const slice = sliceAsBytes(bytes[0..]); - testing.expect(slice.len == 4); - testing.expect(eql(u8, slice, switch (builtin.endian) { + try testing.expect(slice.len == 4); + try testing.expect(eql(u8, slice, switch (builtin.endian) { .Big => "\xDE\xAD\xBE\xEF", .Little => "\xAD\xDE\xEF\xBE", })); @@ -2342,7 +2342,7 @@ test "sliceAsBytes" { test "sliceAsBytes with sentinel slice" { const empty_string: [:0]const u8 = ""; const bytes = sliceAsBytes(empty_string); - testing.expect(bytes.len == 0); + try testing.expect(bytes.len == 0); } test "sliceAsBytes packed struct at runtime and comptime" { @@ -2351,49 +2351,49 @@ test "sliceAsBytes packed struct at runtime and comptime" { b: u4, }; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var foo: Foo = undefined; var slice = sliceAsBytes(@as(*[1]Foo, &foo)[0..1]); slice[0] = 0x13; switch (builtin.endian) { .Big => { - testing.expect(foo.a == 0x1); - testing.expect(foo.b == 0x3); + try testing.expect(foo.a == 0x1); + try testing.expect(foo.b == 0x3); }, .Little => { - testing.expect(foo.a == 0x3); - testing.expect(foo.b == 0x1); + try testing.expect(foo.a == 0x3); + try testing.expect(foo.b == 0x1); }, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "sliceAsBytes and bytesAsSlice back" { - testing.expect(@sizeOf(i32) == 4); + try testing.expect(@sizeOf(i32) == 4); var big_thing_array = [_]i32{ 1, 2, 3, 4 }; const big_thing_slice: []i32 = big_thing_array[0..]; const bytes = sliceAsBytes(big_thing_slice); - testing.expect(bytes.len == 4 * 4); + try testing.expect(bytes.len == 4 * 4); bytes[4] = 0; bytes[5] = 0; bytes[6] = 0; bytes[7] = 0; - testing.expect(big_thing_slice[1] == 0); + try testing.expect(big_thing_slice[1] == 0); const big_thing_again = bytesAsSlice(i32, bytes); - testing.expect(big_thing_again[2] == 3); + try testing.expect(big_thing_again[2] == 3); big_thing_again[2] = -1; - testing.expect(bytes[8] == math.maxInt(u8)); - testing.expect(bytes[9] == math.maxInt(u8)); - testing.expect(bytes[10] == math.maxInt(u8)); - testing.expect(bytes[11] == math.maxInt(u8)); + try testing.expect(bytes[8] == math.maxInt(u8)); + try testing.expect(bytes[9] == math.maxInt(u8)); + try testing.expect(bytes[10] == math.maxInt(u8)); + try testing.expect(bytes[11] == math.maxInt(u8)); } test "sliceAsBytes preserves pointer attributes" { @@ -2404,10 +2404,10 @@ test "sliceAsBytes preserves pointer attributes" { const in = @typeInfo(@TypeOf(inSlice)).Pointer; const out = @typeInfo(@TypeOf(outSlice)).Pointer; - testing.expectEqual(in.is_const, out.is_const); - testing.expectEqual(in.is_volatile, out.is_volatile); - testing.expectEqual(in.is_allowzero, out.is_allowzero); - testing.expectEqual(in.alignment, out.alignment); + try testing.expectEqual(in.is_const, out.is_const); + try testing.expectEqual(in.is_volatile, out.is_volatile); + try testing.expectEqual(in.is_allowzero, out.is_allowzero); + try testing.expectEqual(in.alignment, out.alignment); } /// Round an address up to the nearest aligned address @@ -2434,18 +2434,18 @@ pub fn doNotOptimizeAway(val: anytype) void { } test "alignForward" { - testing.expect(alignForward(1, 1) == 1); - testing.expect(alignForward(2, 1) == 2); - testing.expect(alignForward(1, 2) == 2); - testing.expect(alignForward(2, 2) == 2); - testing.expect(alignForward(3, 2) == 4); - testing.expect(alignForward(4, 2) == 4); - testing.expect(alignForward(7, 8) == 8); - testing.expect(alignForward(8, 8) == 8); - testing.expect(alignForward(9, 8) == 16); - testing.expect(alignForward(15, 8) == 16); - testing.expect(alignForward(16, 8) == 16); - testing.expect(alignForward(17, 8) == 24); + try testing.expect(alignForward(1, 1) == 1); + try testing.expect(alignForward(2, 1) == 2); + try testing.expect(alignForward(1, 2) == 2); + try testing.expect(alignForward(2, 2) == 2); + try testing.expect(alignForward(3, 2) == 4); + try testing.expect(alignForward(4, 2) == 4); + try testing.expect(alignForward(7, 8) == 8); + try testing.expect(alignForward(8, 8) == 8); + try testing.expect(alignForward(9, 8) == 16); + try testing.expect(alignForward(15, 8) == 16); + try testing.expect(alignForward(16, 8) == 16); + try testing.expect(alignForward(17, 8) == 24); } /// Round an address up to the previous aligned address @@ -2497,19 +2497,19 @@ pub fn isAlignedGeneric(comptime T: type, addr: T, alignment: T) bool { } test "isAligned" { - testing.expect(isAligned(0, 4)); - testing.expect(isAligned(1, 1)); - testing.expect(isAligned(2, 1)); - testing.expect(isAligned(2, 2)); - testing.expect(!isAligned(2, 4)); - testing.expect(isAligned(3, 1)); - testing.expect(!isAligned(3, 2)); - testing.expect(!isAligned(3, 4)); - testing.expect(isAligned(4, 4)); - testing.expect(isAligned(4, 2)); - testing.expect(isAligned(4, 1)); - testing.expect(!isAligned(4, 8)); - testing.expect(!isAligned(4, 16)); + try testing.expect(isAligned(0, 4)); + try testing.expect(isAligned(1, 1)); + try testing.expect(isAligned(2, 1)); + try testing.expect(isAligned(2, 2)); + try testing.expect(!isAligned(2, 4)); + try testing.expect(isAligned(3, 1)); + try testing.expect(!isAligned(3, 2)); + try testing.expect(!isAligned(3, 4)); + try testing.expect(isAligned(4, 4)); + try testing.expect(isAligned(4, 2)); + try testing.expect(isAligned(4, 1)); + try testing.expect(!isAligned(4, 8)); + try testing.expect(!isAligned(4, 16)); } test "freeing empty string with null-terminated sentinel" { diff --git a/lib/std/meta.zig b/lib/std/meta.zig index 600f3d3c5d..391b7259e3 100644 --- a/lib/std/meta.zig +++ b/lib/std/meta.zig @@ -47,16 +47,16 @@ test "std.meta.tagName" { var u2a = U2{ .C = 0 }; var u2b = U2{ .D = 0 }; - testing.expect(mem.eql(u8, tagName(E1.A), "A")); - testing.expect(mem.eql(u8, tagName(E1.B), "B")); - testing.expect(mem.eql(u8, tagName(E2.C), "C")); - testing.expect(mem.eql(u8, tagName(E2.D), "D")); - testing.expect(mem.eql(u8, tagName(error.E), "E")); - testing.expect(mem.eql(u8, tagName(error.F), "F")); - testing.expect(mem.eql(u8, tagName(u1g), "G")); - testing.expect(mem.eql(u8, tagName(u1h), "H")); - testing.expect(mem.eql(u8, tagName(u2a), "C")); - testing.expect(mem.eql(u8, tagName(u2b), "D")); + try testing.expect(mem.eql(u8, tagName(E1.A), "A")); + try testing.expect(mem.eql(u8, tagName(E1.B), "B")); + try testing.expect(mem.eql(u8, tagName(E2.C), "C")); + try testing.expect(mem.eql(u8, tagName(E2.D), "D")); + try testing.expect(mem.eql(u8, tagName(error.E), "E")); + try testing.expect(mem.eql(u8, tagName(error.F), "F")); + try testing.expect(mem.eql(u8, tagName(u1g), "G")); + try testing.expect(mem.eql(u8, tagName(u1h), "H")); + try testing.expect(mem.eql(u8, tagName(u2a), "C")); + try testing.expect(mem.eql(u8, tagName(u2b), "D")); } pub fn stringToEnum(comptime T: type, str: []const u8) ?T { @@ -98,9 +98,9 @@ test "std.meta.stringToEnum" { A, B, }; - testing.expect(E1.A == stringToEnum(E1, "A").?); - testing.expect(E1.B == stringToEnum(E1, "B").?); - testing.expect(null == stringToEnum(E1, "C")); + try testing.expect(E1.A == stringToEnum(E1, "A").?); + try testing.expect(E1.B == stringToEnum(E1, "B").?); + try testing.expect(null == stringToEnum(E1, "C")); } pub fn bitCount(comptime T: type) comptime_int { @@ -113,8 +113,8 @@ pub fn bitCount(comptime T: type) comptime_int { } test "std.meta.bitCount" { - testing.expect(bitCount(u8) == 8); - testing.expect(bitCount(f32) == 32); + try testing.expect(bitCount(u8) == 8); + try testing.expect(bitCount(f32) == 32); } /// Returns the alignment of type T. @@ -135,13 +135,13 @@ pub fn alignment(comptime T: type) comptime_int { } test "std.meta.alignment" { - testing.expect(alignment(u8) == 1); - testing.expect(alignment(*align(1) u8) == 1); - testing.expect(alignment(*align(2) u8) == 2); - testing.expect(alignment([]align(1) u8) == 1); - testing.expect(alignment([]align(2) u8) == 2); - testing.expect(alignment(fn () void) > 0); - testing.expect(alignment(fn () align(128) void) == 128); + try testing.expect(alignment(u8) == 1); + try testing.expect(alignment(*align(1) u8) == 1); + try testing.expect(alignment(*align(2) u8) == 2); + try testing.expect(alignment([]align(1) u8) == 1); + try testing.expect(alignment([]align(2) u8) == 2); + try testing.expect(alignment(fn () void) > 0); + try testing.expect(alignment(fn () align(128) void) == 128); } pub fn Child(comptime T: type) type { @@ -155,11 +155,11 @@ pub fn Child(comptime T: type) type { } test "std.meta.Child" { - testing.expect(Child([1]u8) == u8); - testing.expect(Child(*u8) == u8); - testing.expect(Child([]u8) == u8); - testing.expect(Child(?u8) == u8); - testing.expect(Child(Vector(2, u8)) == u8); + try testing.expect(Child([1]u8) == u8); + try testing.expect(Child(*u8) == u8); + try testing.expect(Child([]u8) == u8); + try testing.expect(Child(?u8) == u8); + try testing.expect(Child(Vector(2, u8)) == u8); } /// Given a "memory span" type, returns the "element type". @@ -188,13 +188,13 @@ pub fn Elem(comptime T: type) type { } test "std.meta.Elem" { - testing.expect(Elem([1]u8) == u8); - testing.expect(Elem([*]u8) == u8); - testing.expect(Elem([]u8) == u8); - testing.expect(Elem(*[10]u8) == u8); - testing.expect(Elem(Vector(2, u8)) == u8); - testing.expect(Elem(*Vector(2, u8)) == u8); - testing.expect(Elem(?[*]u8) == u8); + try testing.expect(Elem([1]u8) == u8); + try testing.expect(Elem([*]u8) == u8); + try testing.expect(Elem([]u8) == u8); + try testing.expect(Elem(*[10]u8) == u8); + try testing.expect(Elem(Vector(2, u8)) == u8); + try testing.expect(Elem(*Vector(2, u8)) == u8); + try testing.expect(Elem(?[*]u8) == u8); } /// Given a type which can have a sentinel e.g. `[:0]u8`, returns the sentinel value, @@ -219,20 +219,20 @@ pub fn sentinel(comptime T: type) ?Elem(T) { } test "std.meta.sentinel" { - testSentinel(); - comptime testSentinel(); + try testSentinel(); + comptime try testSentinel(); } -fn testSentinel() void { - testing.expectEqual(@as(u8, 0), sentinel([:0]u8).?); - testing.expectEqual(@as(u8, 0), sentinel([*:0]u8).?); - testing.expectEqual(@as(u8, 0), sentinel([5:0]u8).?); - testing.expectEqual(@as(u8, 0), sentinel(*const [5:0]u8).?); +fn testSentinel() !void { + try testing.expectEqual(@as(u8, 0), sentinel([:0]u8).?); + try testing.expectEqual(@as(u8, 0), sentinel([*:0]u8).?); + try testing.expectEqual(@as(u8, 0), sentinel([5:0]u8).?); + try testing.expectEqual(@as(u8, 0), sentinel(*const [5:0]u8).?); - testing.expect(sentinel([]u8) == null); - testing.expect(sentinel([*]u8) == null); - testing.expect(sentinel([5]u8) == null); - testing.expect(sentinel(*const [5]u8) == null); + try testing.expect(sentinel([]u8) == null); + try testing.expect(sentinel([*]u8) == null); + try testing.expect(sentinel([5]u8) == null); + try testing.expect(sentinel(*const [5]u8) == null); } /// Given a "memory span" type, returns the same type except with the given sentinel value. @@ -322,17 +322,17 @@ pub fn assumeSentinel(p: anytype, comptime sentinel_val: Elem(@TypeOf(p))) Senti } test "std.meta.assumeSentinel" { - testing.expect([*:0]u8 == @TypeOf(assumeSentinel(@as([*]u8, undefined), 0))); - testing.expect([:0]u8 == @TypeOf(assumeSentinel(@as([]u8, undefined), 0))); - testing.expect([*:0]const u8 == @TypeOf(assumeSentinel(@as([*]const u8, undefined), 0))); - testing.expect([:0]const u8 == @TypeOf(assumeSentinel(@as([]const u8, undefined), 0))); - testing.expect([*:0]u16 == @TypeOf(assumeSentinel(@as([*]u16, undefined), 0))); - testing.expect([:0]const u16 == @TypeOf(assumeSentinel(@as([]const u16, undefined), 0))); - testing.expect([*:3]u8 == @TypeOf(assumeSentinel(@as([*:1]u8, undefined), 3))); - testing.expect([:null]?[*]u8 == @TypeOf(assumeSentinel(@as([]?[*]u8, undefined), null))); - testing.expect([*:null]?[*]u8 == @TypeOf(assumeSentinel(@as([*]?[*]u8, undefined), null))); - testing.expect(*[10:0]u8 == @TypeOf(assumeSentinel(@as(*[10]u8, undefined), 0))); - testing.expect(?[*:0]u8 == @TypeOf(assumeSentinel(@as(?[*]u8, undefined), 0))); + try testing.expect([*:0]u8 == @TypeOf(assumeSentinel(@as([*]u8, undefined), 0))); + try testing.expect([:0]u8 == @TypeOf(assumeSentinel(@as([]u8, undefined), 0))); + try testing.expect([*:0]const u8 == @TypeOf(assumeSentinel(@as([*]const u8, undefined), 0))); + try testing.expect([:0]const u8 == @TypeOf(assumeSentinel(@as([]const u8, undefined), 0))); + try testing.expect([*:0]u16 == @TypeOf(assumeSentinel(@as([*]u16, undefined), 0))); + try testing.expect([:0]const u16 == @TypeOf(assumeSentinel(@as([]const u16, undefined), 0))); + try testing.expect([*:3]u8 == @TypeOf(assumeSentinel(@as([*:1]u8, undefined), 3))); + try testing.expect([:null]?[*]u8 == @TypeOf(assumeSentinel(@as([]?[*]u8, undefined), null))); + try testing.expect([*:null]?[*]u8 == @TypeOf(assumeSentinel(@as([*]?[*]u8, undefined), null))); + try testing.expect(*[10:0]u8 == @TypeOf(assumeSentinel(@as(*[10]u8, undefined), 0))); + try testing.expect(?[*:0]u8 == @TypeOf(assumeSentinel(@as(?[*]u8, undefined), 0))); } pub fn containerLayout(comptime T: type) TypeInfo.ContainerLayout { @@ -367,15 +367,15 @@ test "std.meta.containerLayout" { a: u8, }; - testing.expect(containerLayout(E1) == .Auto); - testing.expect(containerLayout(E2) == .Packed); - testing.expect(containerLayout(E3) == .Extern); - testing.expect(containerLayout(S1) == .Auto); - testing.expect(containerLayout(S2) == .Packed); - testing.expect(containerLayout(S3) == .Extern); - testing.expect(containerLayout(U1) == .Auto); - testing.expect(containerLayout(U2) == .Packed); - testing.expect(containerLayout(U3) == .Extern); + try testing.expect(containerLayout(E1) == .Auto); + try testing.expect(containerLayout(E2) == .Packed); + try testing.expect(containerLayout(E3) == .Extern); + try testing.expect(containerLayout(S1) == .Auto); + try testing.expect(containerLayout(S2) == .Packed); + try testing.expect(containerLayout(S3) == .Extern); + try testing.expect(containerLayout(U1) == .Auto); + try testing.expect(containerLayout(U2) == .Packed); + try testing.expect(containerLayout(U3) == .Extern); } pub fn declarations(comptime T: type) []const TypeInfo.Declaration { @@ -414,8 +414,8 @@ test "std.meta.declarations" { }; inline for (decls) |decl| { - testing.expect(decl.len == 1); - testing.expect(comptime mem.eql(u8, decl[0].name, "a")); + try testing.expect(decl.len == 1); + try testing.expect(comptime mem.eql(u8, decl[0].name, "a")); } } @@ -450,8 +450,8 @@ test "std.meta.declarationInfo" { }; inline for (infos) |info| { - testing.expect(comptime mem.eql(u8, info.name, "a")); - testing.expect(!info.is_pub); + try testing.expect(comptime mem.eql(u8, info.name, "a")); + try testing.expect(!info.is_pub); } } @@ -488,16 +488,16 @@ test "std.meta.fields" { const sf = comptime fields(S1); const uf = comptime fields(U1); - testing.expect(e1f.len == 1); - testing.expect(e2f.len == 1); - testing.expect(sf.len == 1); - testing.expect(uf.len == 1); - testing.expect(mem.eql(u8, e1f[0].name, "A")); - testing.expect(mem.eql(u8, e2f[0].name, "A")); - testing.expect(mem.eql(u8, sf[0].name, "a")); - testing.expect(mem.eql(u8, uf[0].name, "a")); - testing.expect(comptime sf[0].field_type == u8); - testing.expect(comptime uf[0].field_type == u8); + try testing.expect(e1f.len == 1); + try testing.expect(e2f.len == 1); + try testing.expect(sf.len == 1); + try testing.expect(uf.len == 1); + try testing.expect(mem.eql(u8, e1f[0].name, "A")); + try testing.expect(mem.eql(u8, e2f[0].name, "A")); + try testing.expect(mem.eql(u8, sf[0].name, "a")); + try testing.expect(mem.eql(u8, uf[0].name, "a")); + try testing.expect(comptime sf[0].field_type == u8); + try testing.expect(comptime uf[0].field_type == u8); } pub fn fieldInfo(comptime T: type, comptime field: FieldEnum(T)) switch (@typeInfo(T)) { @@ -527,12 +527,12 @@ test "std.meta.fieldInfo" { const sf = fieldInfo(S1, .a); const uf = fieldInfo(U1, .a); - testing.expect(mem.eql(u8, e1f.name, "A")); - testing.expect(mem.eql(u8, e2f.name, "A")); - testing.expect(mem.eql(u8, sf.name, "a")); - testing.expect(mem.eql(u8, uf.name, "a")); - testing.expect(comptime sf.field_type == u8); - testing.expect(comptime uf.field_type == u8); + try testing.expect(mem.eql(u8, e1f.name, "A")); + try testing.expect(mem.eql(u8, e2f.name, "A")); + try testing.expect(mem.eql(u8, sf.name, "a")); + try testing.expect(mem.eql(u8, uf.name, "a")); + try testing.expect(comptime sf.field_type == u8); + try testing.expect(comptime uf.field_type == u8); } pub fn fieldNames(comptime T: type) *const [fields(T).len][]const u8 { @@ -562,16 +562,16 @@ test "std.meta.fieldNames" { const s1names = fieldNames(S1); const u1names = fieldNames(U1); - testing.expect(e1names.len == 2); - testing.expectEqualSlices(u8, e1names[0], "A"); - testing.expectEqualSlices(u8, e1names[1], "B"); - testing.expect(e2names.len == 1); - testing.expectEqualSlices(u8, e2names[0], "A"); - testing.expect(s1names.len == 1); - testing.expectEqualSlices(u8, s1names[0], "a"); - testing.expect(u1names.len == 2); - testing.expectEqualSlices(u8, u1names[0], "a"); - testing.expectEqualSlices(u8, u1names[1], "b"); + try testing.expect(e1names.len == 2); + try testing.expectEqualSlices(u8, e1names[0], "A"); + try testing.expectEqualSlices(u8, e1names[1], "B"); + try testing.expect(e2names.len == 1); + try testing.expectEqualSlices(u8, e2names[0], "A"); + try testing.expect(s1names.len == 1); + try testing.expectEqualSlices(u8, s1names[0], "a"); + try testing.expect(u1names.len == 2); + try testing.expectEqualSlices(u8, u1names[0], "a"); + try testing.expectEqualSlices(u8, u1names[1], "b"); } pub fn FieldEnum(comptime T: type) type { @@ -595,20 +595,20 @@ pub fn FieldEnum(comptime T: type) type { }); } -fn expectEqualEnum(expected: anytype, actual: @TypeOf(expected)) void { +fn expectEqualEnum(expected: anytype, actual: @TypeOf(expected)) !void { // TODO: https://github.com/ziglang/zig/issues/7419 // testing.expectEqual(@typeInfo(expected).Enum, @typeInfo(actual).Enum); - testing.expectEqual(@typeInfo(expected).Enum.layout, @typeInfo(actual).Enum.layout); - testing.expectEqual(@typeInfo(expected).Enum.tag_type, @typeInfo(actual).Enum.tag_type); - comptime testing.expectEqualSlices(std.builtin.TypeInfo.EnumField, @typeInfo(expected).Enum.fields, @typeInfo(actual).Enum.fields); - comptime testing.expectEqualSlices(std.builtin.TypeInfo.Declaration, @typeInfo(expected).Enum.decls, @typeInfo(actual).Enum.decls); - testing.expectEqual(@typeInfo(expected).Enum.is_exhaustive, @typeInfo(actual).Enum.is_exhaustive); + try testing.expectEqual(@typeInfo(expected).Enum.layout, @typeInfo(actual).Enum.layout); + try testing.expectEqual(@typeInfo(expected).Enum.tag_type, @typeInfo(actual).Enum.tag_type); + comptime try testing.expectEqualSlices(std.builtin.TypeInfo.EnumField, @typeInfo(expected).Enum.fields, @typeInfo(actual).Enum.fields); + comptime try testing.expectEqualSlices(std.builtin.TypeInfo.Declaration, @typeInfo(expected).Enum.decls, @typeInfo(actual).Enum.decls); + try testing.expectEqual(@typeInfo(expected).Enum.is_exhaustive, @typeInfo(actual).Enum.is_exhaustive); } test "std.meta.FieldEnum" { - expectEqualEnum(enum { a }, FieldEnum(struct { a: u8 })); - expectEqualEnum(enum { a, b, c }, FieldEnum(struct { a: u8, b: void, c: f32 })); - expectEqualEnum(enum { a, b, c }, FieldEnum(union { a: u8, b: void, c: f32 })); + try expectEqualEnum(enum { a }, FieldEnum(struct { a: u8 })); + try expectEqualEnum(enum { a, b, c }, FieldEnum(struct { a: u8, b: void, c: f32 })); + try expectEqualEnum(enum { a, b, c }, FieldEnum(union { a: u8, b: void, c: f32 })); } // Deprecated: use Tag @@ -632,8 +632,8 @@ test "std.meta.Tag" { D: u16, }; - testing.expect(Tag(E) == u8); - testing.expect(Tag(U) == E); + try testing.expect(Tag(E) == u8); + try testing.expect(Tag(U) == E); } ///Returns the active tag of a tagged union @@ -654,10 +654,10 @@ test "std.meta.activeTag" { }; var u = U{ .Int = 32 }; - testing.expect(activeTag(u) == UE.Int); + try testing.expect(activeTag(u) == UE.Int); u = U{ .Float = 112.9876 }; - testing.expect(activeTag(u) == UE.Float); + try testing.expect(activeTag(u) == UE.Float); } const TagPayloadType = TagPayload; @@ -665,7 +665,7 @@ const TagPayloadType = TagPayload; ///Given a tagged union type, and an enum, return the type of the union /// field corresponding to the enum tag. pub fn TagPayload(comptime U: type, tag: Tag(U)) type { - testing.expect(trait.is(.Union)(U)); + try testing.expect(trait.is(.Union)(U)); const info = @typeInfo(U).Union; const tag_info = @typeInfo(Tag(U)).Enum; @@ -687,7 +687,7 @@ test "std.meta.TagPayload" { }; const MovedEvent = TagPayload(Event, Event.Moved); var e: Event = undefined; - testing.expect(MovedEvent == @TypeOf(e.Moved)); + try testing.expect(MovedEvent == @TypeOf(e.Moved)); } /// Compares two of any type for equality. Containers are compared on a field-by-field basis, @@ -787,19 +787,19 @@ test "std.meta.eql" { const u_2 = U{ .s = s_1 }; const u_3 = U{ .f = 24 }; - testing.expect(eql(s_1, s_3)); - testing.expect(eql(&s_1, &s_1)); - testing.expect(!eql(&s_1, &s_3)); - testing.expect(eql(u_1, u_3)); - testing.expect(!eql(u_1, u_2)); + try testing.expect(eql(s_1, s_3)); + try testing.expect(eql(&s_1, &s_1)); + try testing.expect(!eql(&s_1, &s_3)); + try testing.expect(eql(u_1, u_3)); + try testing.expect(!eql(u_1, u_2)); var a1 = "abcdef".*; var a2 = "abcdef".*; var a3 = "ghijkl".*; - testing.expect(eql(a1, a2)); - testing.expect(!eql(a1, a3)); - testing.expect(!eql(a1[0..], a2[0..])); + try testing.expect(eql(a1, a2)); + try testing.expect(!eql(a1, a3)); + try testing.expect(!eql(a1[0..], a2[0..])); const EU = struct { fn tst(err: bool) !u8 { @@ -808,16 +808,16 @@ test "std.meta.eql" { } }; - testing.expect(eql(EU.tst(true), EU.tst(true))); - testing.expect(eql(EU.tst(false), EU.tst(false))); - testing.expect(!eql(EU.tst(false), EU.tst(true))); + try testing.expect(eql(EU.tst(true), EU.tst(true))); + try testing.expect(eql(EU.tst(false), EU.tst(false))); + try testing.expect(!eql(EU.tst(false), EU.tst(true))); var v1 = @splat(4, @as(u32, 1)); var v2 = @splat(4, @as(u32, 1)); var v3 = @splat(4, @as(u32, 2)); - testing.expect(eql(v1, v2)); - testing.expect(!eql(v1, v3)); + try testing.expect(eql(v1, v2)); + try testing.expect(!eql(v1, v3)); } test "intToEnum with error return" { @@ -831,9 +831,9 @@ test "intToEnum with error return" { var zero: u8 = 0; var one: u16 = 1; - testing.expect(intToEnum(E1, zero) catch unreachable == E1.A); - testing.expect(intToEnum(E2, one) catch unreachable == E2.B); - testing.expectError(error.InvalidEnumTag, intToEnum(E1, one)); + try testing.expect(intToEnum(E1, zero) catch unreachable == E1.A); + try testing.expect(intToEnum(E2, one) catch unreachable == E2.B); + try testing.expectError(error.InvalidEnumTag, intToEnum(E1, one)); } pub const IntToEnumError = error{InvalidEnumTag}; @@ -1008,27 +1008,27 @@ test "std.meta.cast" { var i = @as(i64, 10); - testing.expect(cast(*u8, 16) == @intToPtr(*u8, 16)); - testing.expect(cast(*u64, &i).* == @as(u64, 10)); - testing.expect(cast(*i64, @as(?*align(1) i64, &i)) == &i); + try testing.expect(cast(*u8, 16) == @intToPtr(*u8, 16)); + try testing.expect(cast(*u64, &i).* == @as(u64, 10)); + try testing.expect(cast(*i64, @as(?*align(1) i64, &i)) == &i); - testing.expect(cast(?*u8, 2) == @intToPtr(*u8, 2)); - testing.expect(cast(?*i64, @as(*align(1) i64, &i)) == &i); - testing.expect(cast(?*i64, @as(?*align(1) i64, &i)) == &i); + try testing.expect(cast(?*u8, 2) == @intToPtr(*u8, 2)); + try testing.expect(cast(?*i64, @as(*align(1) i64, &i)) == &i); + try testing.expect(cast(?*i64, @as(?*align(1) i64, &i)) == &i); - testing.expect(cast(E, 1) == .One); + try testing.expect(cast(E, 1) == .One); - testing.expectEqual(@as(u32, 4), cast(u32, @intToPtr(*u32, 4))); - testing.expectEqual(@as(u32, 4), cast(u32, @intToPtr(?*u32, 4))); - testing.expectEqual(@as(u32, 10), cast(u32, @as(u64, 10))); - testing.expectEqual(@as(u8, 2), cast(u8, E.Two)); + try testing.expectEqual(@as(u32, 4), cast(u32, @intToPtr(*u32, 4))); + try testing.expectEqual(@as(u32, 4), cast(u32, @intToPtr(?*u32, 4))); + try testing.expectEqual(@as(u32, 10), cast(u32, @as(u64, 10))); + try testing.expectEqual(@as(u8, 2), cast(u8, E.Two)); - testing.expectEqual(@bitCast(i32, @as(u32, 0x8000_0000)), cast(i32, @as(u32, 0x8000_0000))); + try testing.expectEqual(@bitCast(i32, @as(u32, 0x8000_0000)), cast(i32, @as(u32, 0x8000_0000))); - testing.expectEqual(@intToPtr(*u8, 2), cast(*u8, @intToPtr(*const u8, 2))); - testing.expectEqual(@intToPtr(*u8, 2), cast(*u8, @intToPtr(*volatile u8, 2))); + try testing.expectEqual(@intToPtr(*u8, 2), cast(*u8, @intToPtr(*const u8, 2))); + try testing.expectEqual(@intToPtr(*u8, 2), cast(*u8, @intToPtr(*volatile u8, 2))); - testing.expectEqual(@intToPtr(?*c_void, 2), cast(?*c_void, @intToPtr(*u8, 2))); + try testing.expectEqual(@intToPtr(?*c_void, 2), cast(?*c_void, @intToPtr(*u8, 2))); const C_ENUM = extern enum(c_int) { A = 0, @@ -1036,10 +1036,10 @@ test "std.meta.cast" { C, _, }; - testing.expectEqual(cast(C_ENUM, @as(i64, -1)), @intToEnum(C_ENUM, -1)); - testing.expectEqual(cast(C_ENUM, @as(i8, 1)), .B); - testing.expectEqual(cast(C_ENUM, @as(u64, 1)), .B); - testing.expectEqual(cast(C_ENUM, @as(u64, 42)), @intToEnum(C_ENUM, 42)); + try testing.expectEqual(cast(C_ENUM, @as(i64, -1)), @intToEnum(C_ENUM, -1)); + try testing.expectEqual(cast(C_ENUM, @as(i8, 1)), .B); + try testing.expectEqual(cast(C_ENUM, @as(u64, 1)), .B); + try testing.expectEqual(cast(C_ENUM, @as(u64, 42)), @intToEnum(C_ENUM, 42)); } /// Given a value returns its size as C's sizeof operator would. @@ -1118,43 +1118,43 @@ test "sizeof" { const ptr_size = @sizeOf(*c_void); - testing.expect(sizeof(u32) == 4); - testing.expect(sizeof(@as(u32, 2)) == 4); - testing.expect(sizeof(2) == @sizeOf(c_int)); + try testing.expect(sizeof(u32) == 4); + try testing.expect(sizeof(@as(u32, 2)) == 4); + try testing.expect(sizeof(2) == @sizeOf(c_int)); - testing.expect(sizeof(2.0) == @sizeOf(f64)); + try testing.expect(sizeof(2.0) == @sizeOf(f64)); - testing.expect(sizeof(E) == @sizeOf(c_int)); - testing.expect(sizeof(E.One) == @sizeOf(c_int)); + try testing.expect(sizeof(E) == @sizeOf(c_int)); + try testing.expect(sizeof(E.One) == @sizeOf(c_int)); - testing.expect(sizeof(S) == 4); + try testing.expect(sizeof(S) == 4); - testing.expect(sizeof([_]u32{ 4, 5, 6 }) == 12); - testing.expect(sizeof([3]u32) == 12); - testing.expect(sizeof([3:0]u32) == 16); - testing.expect(sizeof(&[_]u32{ 4, 5, 6 }) == ptr_size); + try testing.expect(sizeof([_]u32{ 4, 5, 6 }) == 12); + try testing.expect(sizeof([3]u32) == 12); + try testing.expect(sizeof([3:0]u32) == 16); + try testing.expect(sizeof(&[_]u32{ 4, 5, 6 }) == ptr_size); - testing.expect(sizeof(*u32) == ptr_size); - testing.expect(sizeof([*]u32) == ptr_size); - testing.expect(sizeof([*c]u32) == ptr_size); - testing.expect(sizeof(?*u32) == ptr_size); - testing.expect(sizeof(?[*]u32) == ptr_size); - testing.expect(sizeof(*c_void) == ptr_size); - testing.expect(sizeof(*void) == ptr_size); - testing.expect(sizeof(null) == ptr_size); + try testing.expect(sizeof(*u32) == ptr_size); + try testing.expect(sizeof([*]u32) == ptr_size); + try testing.expect(sizeof([*c]u32) == ptr_size); + try testing.expect(sizeof(?*u32) == ptr_size); + try testing.expect(sizeof(?[*]u32) == ptr_size); + try testing.expect(sizeof(*c_void) == ptr_size); + try testing.expect(sizeof(*void) == ptr_size); + try testing.expect(sizeof(null) == ptr_size); - testing.expect(sizeof("foobar") == 7); - testing.expect(sizeof(&[_:0]u16{ 'f', 'o', 'o', 'b', 'a', 'r' }) == 14); - testing.expect(sizeof(*const [4:0]u8) == 5); - testing.expect(sizeof(*[4:0]u8) == ptr_size); - testing.expect(sizeof([*]const [4:0]u8) == ptr_size); - testing.expect(sizeof(*const *const [4:0]u8) == ptr_size); - testing.expect(sizeof(*const [4]u8) == ptr_size); + try testing.expect(sizeof("foobar") == 7); + try testing.expect(sizeof(&[_:0]u16{ 'f', 'o', 'o', 'b', 'a', 'r' }) == 14); + try testing.expect(sizeof(*const [4:0]u8) == 5); + try testing.expect(sizeof(*[4:0]u8) == ptr_size); + try testing.expect(sizeof([*]const [4:0]u8) == ptr_size); + try testing.expect(sizeof(*const *const [4:0]u8) == ptr_size); + try testing.expect(sizeof(*const [4]u8) == ptr_size); - testing.expect(sizeof(sizeof) == @sizeOf(@TypeOf(sizeof))); + try testing.expect(sizeof(sizeof) == @sizeOf(@TypeOf(sizeof))); - testing.expect(sizeof(void) == 1); - testing.expect(sizeof(c_void) == 1); + try testing.expect(sizeof(void) == 1); + try testing.expect(sizeof(c_void) == 1); } pub const CIntLiteralRadix = enum { decimal, octal, hexadecimal }; @@ -1193,7 +1193,7 @@ pub fn promoteIntLiteral( test "promoteIntLiteral" { const signed_hex = promoteIntLiteral(c_int, math.maxInt(c_int) + 1, .hexadecimal); - testing.expectEqual(c_uint, @TypeOf(signed_hex)); + try testing.expectEqual(c_uint, @TypeOf(signed_hex)); if (math.maxInt(c_longlong) == math.maxInt(c_int)) return; @@ -1201,11 +1201,11 @@ test "promoteIntLiteral" { const unsigned = promoteIntLiteral(c_uint, math.maxInt(c_uint) + 1, .hexadecimal); if (math.maxInt(c_long) > math.maxInt(c_int)) { - testing.expectEqual(c_long, @TypeOf(signed_decimal)); - testing.expectEqual(c_ulong, @TypeOf(unsigned)); + try testing.expectEqual(c_long, @TypeOf(signed_decimal)); + try testing.expectEqual(c_ulong, @TypeOf(unsigned)); } else { - testing.expectEqual(c_longlong, @TypeOf(signed_decimal)); - testing.expectEqual(c_ulonglong, @TypeOf(unsigned)); + try testing.expectEqual(c_longlong, @TypeOf(signed_decimal)); + try testing.expectEqual(c_ulonglong, @TypeOf(unsigned)); } } @@ -1347,17 +1347,17 @@ pub fn shuffleVectorIndex(comptime this_index: c_int, comptime source_vector_len test "shuffleVectorIndex" { const vector_len: usize = 4; - testing.expect(shuffleVectorIndex(-1, vector_len) == 0); + try testing.expect(shuffleVectorIndex(-1, vector_len) == 0); - testing.expect(shuffleVectorIndex(0, vector_len) == 0); - testing.expect(shuffleVectorIndex(1, vector_len) == 1); - testing.expect(shuffleVectorIndex(2, vector_len) == 2); - testing.expect(shuffleVectorIndex(3, vector_len) == 3); + try testing.expect(shuffleVectorIndex(0, vector_len) == 0); + try testing.expect(shuffleVectorIndex(1, vector_len) == 1); + try testing.expect(shuffleVectorIndex(2, vector_len) == 2); + try testing.expect(shuffleVectorIndex(3, vector_len) == 3); - testing.expect(shuffleVectorIndex(4, vector_len) == -1); - testing.expect(shuffleVectorIndex(5, vector_len) == -2); - testing.expect(shuffleVectorIndex(6, vector_len) == -3); - testing.expect(shuffleVectorIndex(7, vector_len) == -4); + try testing.expect(shuffleVectorIndex(4, vector_len) == -1); + try testing.expect(shuffleVectorIndex(5, vector_len) == -2); + try testing.expect(shuffleVectorIndex(6, vector_len) == -3); + try testing.expect(shuffleVectorIndex(7, vector_len) == -4); } /// Returns whether `error_union` contains an error. @@ -1366,6 +1366,6 @@ pub fn isError(error_union: anytype) bool { } test "isError" { - std.testing.expect(isError(math.absInt(@as(i8, -128)))); - std.testing.expect(!isError(math.absInt(@as(i8, -127)))); + try std.testing.expect(isError(math.absInt(@as(i8, -128)))); + try std.testing.expect(!isError(math.absInt(@as(i8, -127)))); } diff --git a/lib/std/meta/trailer_flags.zig b/lib/std/meta/trailer_flags.zig index 1697e9fe43..94f2043b00 100644 --- a/lib/std/meta/trailer_flags.zig +++ b/lib/std/meta/trailer_flags.zig @@ -146,7 +146,7 @@ test "TrailerFlags" { b: bool, c: u64, }); - testing.expectEqual(u2, meta.Tag(Flags.FieldEnum)); + try testing.expectEqual(u2, meta.Tag(Flags.FieldEnum)); var flags = Flags.init(.{ .b = true, @@ -158,16 +158,16 @@ test "TrailerFlags" { flags.set(slice.ptr, .b, false); flags.set(slice.ptr, .c, 12345678); - testing.expect(flags.get(slice.ptr, .a) == null); - testing.expect(!flags.get(slice.ptr, .b).?); - testing.expect(flags.get(slice.ptr, .c).? == 12345678); + try testing.expect(flags.get(slice.ptr, .a) == null); + try testing.expect(!flags.get(slice.ptr, .b).?); + try testing.expect(flags.get(slice.ptr, .c).? == 12345678); flags.setMany(slice.ptr, .{ .b = true, .c = 5678, }); - testing.expect(flags.get(slice.ptr, .a) == null); - testing.expect(flags.get(slice.ptr, .b).?); - testing.expect(flags.get(slice.ptr, .c).? == 5678); + try testing.expect(flags.get(slice.ptr, .a) == null); + try testing.expect(flags.get(slice.ptr, .b).?); + try testing.expect(flags.get(slice.ptr, .c).? == 5678); } diff --git a/lib/std/meta/trait.zig b/lib/std/meta/trait.zig index 481bfe212b..2bf2e6a0a5 100644 --- a/lib/std/meta/trait.zig +++ b/lib/std/meta/trait.zig @@ -45,8 +45,8 @@ test "std.meta.trait.multiTrait" { hasField("x"), hasField("y"), }); - testing.expect(isVector(Vector2)); - testing.expect(!isVector(u8)); + try testing.expect(isVector(Vector2)); + try testing.expect(!isVector(u8)); } pub fn hasFn(comptime name: []const u8) TraitFn { @@ -66,9 +66,9 @@ test "std.meta.trait.hasFn" { pub fn useless() void {} }; - testing.expect(hasFn("useless")(TestStruct)); - testing.expect(!hasFn("append")(TestStruct)); - testing.expect(!hasFn("useless")(u8)); + try testing.expect(hasFn("useless")(TestStruct)); + try testing.expect(!hasFn("append")(TestStruct)); + try testing.expect(!hasFn("useless")(u8)); } pub fn hasField(comptime name: []const u8) TraitFn { @@ -96,11 +96,11 @@ test "std.meta.trait.hasField" { value: u32, }; - testing.expect(hasField("value")(TestStruct)); - testing.expect(!hasField("value")(*TestStruct)); - testing.expect(!hasField("x")(TestStruct)); - testing.expect(!hasField("x")(**TestStruct)); - testing.expect(!hasField("value")(u8)); + try testing.expect(hasField("value")(TestStruct)); + try testing.expect(!hasField("value")(*TestStruct)); + try testing.expect(!hasField("x")(TestStruct)); + try testing.expect(!hasField("x")(**TestStruct)); + try testing.expect(!hasField("value")(u8)); } pub fn is(comptime id: builtin.TypeId) TraitFn { @@ -113,11 +113,11 @@ pub fn is(comptime id: builtin.TypeId) TraitFn { } test "std.meta.trait.is" { - testing.expect(is(.Int)(u8)); - testing.expect(!is(.Int)(f32)); - testing.expect(is(.Pointer)(*u8)); - testing.expect(is(.Void)(void)); - testing.expect(!is(.Optional)(anyerror)); + try testing.expect(is(.Int)(u8)); + try testing.expect(!is(.Int)(f32)); + try testing.expect(is(.Pointer)(*u8)); + try testing.expect(is(.Void)(void)); + try testing.expect(!is(.Optional)(anyerror)); } pub fn isPtrTo(comptime id: builtin.TypeId) TraitFn { @@ -131,9 +131,9 @@ pub fn isPtrTo(comptime id: builtin.TypeId) TraitFn { } test "std.meta.trait.isPtrTo" { - testing.expect(!isPtrTo(.Struct)(struct {})); - testing.expect(isPtrTo(.Struct)(*struct {})); - testing.expect(!isPtrTo(.Struct)(**struct {})); + try testing.expect(!isPtrTo(.Struct)(struct {})); + try testing.expect(isPtrTo(.Struct)(*struct {})); + try testing.expect(!isPtrTo(.Struct)(**struct {})); } pub fn isSliceOf(comptime id: builtin.TypeId) TraitFn { @@ -147,9 +147,9 @@ pub fn isSliceOf(comptime id: builtin.TypeId) TraitFn { } test "std.meta.trait.isSliceOf" { - testing.expect(!isSliceOf(.Struct)(struct {})); - testing.expect(isSliceOf(.Struct)([]struct {})); - testing.expect(!isSliceOf(.Struct)([][]struct {})); + try testing.expect(!isSliceOf(.Struct)(struct {})); + try testing.expect(isSliceOf(.Struct)([]struct {})); + try testing.expect(!isSliceOf(.Struct)([][]struct {})); } ///////////Strait trait Fns @@ -170,9 +170,9 @@ test "std.meta.trait.isExtern" { const TestExStruct = extern struct {}; const TestStruct = struct {}; - testing.expect(isExtern(TestExStruct)); - testing.expect(!isExtern(TestStruct)); - testing.expect(!isExtern(u8)); + try testing.expect(isExtern(TestExStruct)); + try testing.expect(!isExtern(TestStruct)); + try testing.expect(!isExtern(u8)); } pub fn isPacked(comptime T: type) bool { @@ -188,9 +188,9 @@ test "std.meta.trait.isPacked" { const TestPStruct = packed struct {}; const TestStruct = struct {}; - testing.expect(isPacked(TestPStruct)); - testing.expect(!isPacked(TestStruct)); - testing.expect(!isPacked(u8)); + try testing.expect(isPacked(TestPStruct)); + try testing.expect(!isPacked(TestStruct)); + try testing.expect(!isPacked(u8)); } pub fn isUnsignedInt(comptime T: type) bool { @@ -201,10 +201,10 @@ pub fn isUnsignedInt(comptime T: type) bool { } test "isUnsignedInt" { - testing.expect(isUnsignedInt(u32) == true); - testing.expect(isUnsignedInt(comptime_int) == false); - testing.expect(isUnsignedInt(i64) == false); - testing.expect(isUnsignedInt(f64) == false); + try testing.expect(isUnsignedInt(u32) == true); + try testing.expect(isUnsignedInt(comptime_int) == false); + try testing.expect(isUnsignedInt(i64) == false); + try testing.expect(isUnsignedInt(f64) == false); } pub fn isSignedInt(comptime T: type) bool { @@ -216,10 +216,10 @@ pub fn isSignedInt(comptime T: type) bool { } test "isSignedInt" { - testing.expect(isSignedInt(u32) == false); - testing.expect(isSignedInt(comptime_int) == true); - testing.expect(isSignedInt(i64) == true); - testing.expect(isSignedInt(f64) == false); + try testing.expect(isSignedInt(u32) == false); + try testing.expect(isSignedInt(comptime_int) == true); + try testing.expect(isSignedInt(i64) == true); + try testing.expect(isSignedInt(f64) == false); } pub fn isSingleItemPtr(comptime T: type) bool { @@ -231,10 +231,10 @@ pub fn isSingleItemPtr(comptime T: type) bool { test "std.meta.trait.isSingleItemPtr" { const array = [_]u8{0} ** 10; - comptime testing.expect(isSingleItemPtr(@TypeOf(&array[0]))); - comptime testing.expect(!isSingleItemPtr(@TypeOf(array))); + comptime try testing.expect(isSingleItemPtr(@TypeOf(&array[0]))); + comptime try testing.expect(!isSingleItemPtr(@TypeOf(array))); var runtime_zero: usize = 0; - testing.expect(!isSingleItemPtr(@TypeOf(array[runtime_zero..1]))); + try testing.expect(!isSingleItemPtr(@TypeOf(array[runtime_zero..1]))); } pub fn isManyItemPtr(comptime T: type) bool { @@ -247,9 +247,9 @@ pub fn isManyItemPtr(comptime T: type) bool { test "std.meta.trait.isManyItemPtr" { const array = [_]u8{0} ** 10; const mip = @ptrCast([*]const u8, &array[0]); - testing.expect(isManyItemPtr(@TypeOf(mip))); - testing.expect(!isManyItemPtr(@TypeOf(array))); - testing.expect(!isManyItemPtr(@TypeOf(array[0..1]))); + try testing.expect(isManyItemPtr(@TypeOf(mip))); + try testing.expect(!isManyItemPtr(@TypeOf(array))); + try testing.expect(!isManyItemPtr(@TypeOf(array[0..1]))); } pub fn isSlice(comptime T: type) bool { @@ -262,9 +262,9 @@ pub fn isSlice(comptime T: type) bool { test "std.meta.trait.isSlice" { const array = [_]u8{0} ** 10; var runtime_zero: usize = 0; - testing.expect(isSlice(@TypeOf(array[runtime_zero..]))); - testing.expect(!isSlice(@TypeOf(array))); - testing.expect(!isSlice(@TypeOf(&array[0]))); + try testing.expect(isSlice(@TypeOf(array[runtime_zero..]))); + try testing.expect(!isSlice(@TypeOf(array))); + try testing.expect(!isSlice(@TypeOf(&array[0]))); } pub fn isIndexable(comptime T: type) bool { @@ -283,12 +283,12 @@ test "std.meta.trait.isIndexable" { const vector: meta.Vector(2, u32) = [_]u32{0} ** 2; const tuple = .{ 1, 2, 3 }; - testing.expect(isIndexable(@TypeOf(array))); - testing.expect(isIndexable(@TypeOf(&array))); - testing.expect(isIndexable(@TypeOf(slice))); - testing.expect(!isIndexable(meta.Child(@TypeOf(slice)))); - testing.expect(isIndexable(@TypeOf(vector))); - testing.expect(isIndexable(@TypeOf(tuple))); + try testing.expect(isIndexable(@TypeOf(array))); + try testing.expect(isIndexable(@TypeOf(&array))); + try testing.expect(isIndexable(@TypeOf(slice))); + try testing.expect(!isIndexable(meta.Child(@TypeOf(slice)))); + try testing.expect(isIndexable(@TypeOf(vector))); + try testing.expect(isIndexable(@TypeOf(tuple))); } pub fn isNumber(comptime T: type) bool { @@ -317,13 +317,13 @@ test "std.meta.trait.isNumber" { number: u8, }; - testing.expect(isNumber(u32)); - testing.expect(isNumber(f32)); - testing.expect(isNumber(u64)); - testing.expect(isNumber(@TypeOf(102))); - testing.expect(isNumber(@TypeOf(102.123))); - testing.expect(!isNumber([]u8)); - testing.expect(!isNumber(NotANumber)); + try testing.expect(isNumber(u32)); + try testing.expect(isNumber(f32)); + try testing.expect(isNumber(u64)); + try testing.expect(isNumber(@TypeOf(102))); + try testing.expect(isNumber(@TypeOf(102.123))); + try testing.expect(!isNumber([]u8)); + try testing.expect(!isNumber(NotANumber)); } pub fn isIntegral(comptime T: type) bool { @@ -334,12 +334,12 @@ pub fn isIntegral(comptime T: type) bool { } test "isIntegral" { - testing.expect(isIntegral(u32)); - testing.expect(!isIntegral(f32)); - testing.expect(isIntegral(@TypeOf(102))); - testing.expect(!isIntegral(@TypeOf(102.123))); - testing.expect(!isIntegral(*u8)); - testing.expect(!isIntegral([]u8)); + try testing.expect(isIntegral(u32)); + try testing.expect(!isIntegral(f32)); + try testing.expect(isIntegral(@TypeOf(102))); + try testing.expect(!isIntegral(@TypeOf(102.123))); + try testing.expect(!isIntegral(*u8)); + try testing.expect(!isIntegral([]u8)); } pub fn isFloat(comptime T: type) bool { @@ -350,12 +350,12 @@ pub fn isFloat(comptime T: type) bool { } test "isFloat" { - testing.expect(!isFloat(u32)); - testing.expect(isFloat(f32)); - testing.expect(!isFloat(@TypeOf(102))); - testing.expect(isFloat(@TypeOf(102.123))); - testing.expect(!isFloat(*f64)); - testing.expect(!isFloat([]f32)); + try testing.expect(!isFloat(u32)); + try testing.expect(isFloat(f32)); + try testing.expect(!isFloat(@TypeOf(102))); + try testing.expect(isFloat(@TypeOf(102.123))); + try testing.expect(!isFloat(*f64)); + try testing.expect(!isFloat([]f32)); } pub fn isConstPtr(comptime T: type) bool { @@ -366,10 +366,10 @@ pub fn isConstPtr(comptime T: type) bool { test "std.meta.trait.isConstPtr" { var t = @as(u8, 0); const c = @as(u8, 0); - testing.expect(isConstPtr(*const @TypeOf(t))); - testing.expect(isConstPtr(@TypeOf(&c))); - testing.expect(!isConstPtr(*@TypeOf(t))); - testing.expect(!isConstPtr(@TypeOf(6))); + try testing.expect(isConstPtr(*const @TypeOf(t))); + try testing.expect(isConstPtr(@TypeOf(&c))); + try testing.expect(!isConstPtr(*@TypeOf(t))); + try testing.expect(!isConstPtr(@TypeOf(6))); } pub fn isContainer(comptime T: type) bool { @@ -389,10 +389,10 @@ test "std.meta.trait.isContainer" { B, }; - testing.expect(isContainer(TestStruct)); - testing.expect(isContainer(TestUnion)); - testing.expect(isContainer(TestEnum)); - testing.expect(!isContainer(u8)); + try testing.expect(isContainer(TestStruct)); + try testing.expect(isContainer(TestUnion)); + try testing.expect(isContainer(TestEnum)); + try testing.expect(!isContainer(u8)); } pub fn isTuple(comptime T: type) bool { @@ -403,9 +403,9 @@ test "std.meta.trait.isTuple" { const t1 = struct {}; const t2 = .{ .a = 0 }; const t3 = .{ 1, 2, 3 }; - testing.expect(!isTuple(t1)); - testing.expect(!isTuple(@TypeOf(t2))); - testing.expect(isTuple(@TypeOf(t3))); + try testing.expect(!isTuple(t1)); + try testing.expect(!isTuple(@TypeOf(t2))); + try testing.expect(isTuple(@TypeOf(t3))); } /// Returns true if the passed type will coerce to []const u8. @@ -449,41 +449,41 @@ pub fn isZigString(comptime T: type) bool { } test "std.meta.trait.isZigString" { - testing.expect(isZigString([]const u8)); - testing.expect(isZigString([]u8)); - testing.expect(isZigString([:0]const u8)); - testing.expect(isZigString([:0]u8)); - testing.expect(isZigString([:5]const u8)); - testing.expect(isZigString([:5]u8)); - testing.expect(isZigString(*const [0]u8)); - testing.expect(isZigString(*[0]u8)); - testing.expect(isZigString(*const [0:0]u8)); - testing.expect(isZigString(*[0:0]u8)); - testing.expect(isZigString(*const [0:5]u8)); - testing.expect(isZigString(*[0:5]u8)); - testing.expect(isZigString(*const [10]u8)); - testing.expect(isZigString(*[10]u8)); - testing.expect(isZigString(*const [10:0]u8)); - testing.expect(isZigString(*[10:0]u8)); - testing.expect(isZigString(*const [10:5]u8)); - testing.expect(isZigString(*[10:5]u8)); + try testing.expect(isZigString([]const u8)); + try testing.expect(isZigString([]u8)); + try testing.expect(isZigString([:0]const u8)); + try testing.expect(isZigString([:0]u8)); + try testing.expect(isZigString([:5]const u8)); + try testing.expect(isZigString([:5]u8)); + try testing.expect(isZigString(*const [0]u8)); + try testing.expect(isZigString(*[0]u8)); + try testing.expect(isZigString(*const [0:0]u8)); + try testing.expect(isZigString(*[0:0]u8)); + try testing.expect(isZigString(*const [0:5]u8)); + try testing.expect(isZigString(*[0:5]u8)); + try testing.expect(isZigString(*const [10]u8)); + try testing.expect(isZigString(*[10]u8)); + try testing.expect(isZigString(*const [10:0]u8)); + try testing.expect(isZigString(*[10:0]u8)); + try testing.expect(isZigString(*const [10:5]u8)); + try testing.expect(isZigString(*[10:5]u8)); - testing.expect(!isZigString(u8)); - testing.expect(!isZigString([4]u8)); - testing.expect(!isZigString([4:0]u8)); - testing.expect(!isZigString([*]const u8)); - testing.expect(!isZigString([*]const [4]u8)); - testing.expect(!isZigString([*c]const u8)); - testing.expect(!isZigString([*c]const [4]u8)); - testing.expect(!isZigString([*:0]const u8)); - testing.expect(!isZigString([*:0]const u8)); - testing.expect(!isZigString(*[]const u8)); - testing.expect(!isZigString(?[]const u8)); - testing.expect(!isZigString(?*const [4]u8)); - testing.expect(!isZigString([]allowzero u8)); - testing.expect(!isZigString([]volatile u8)); - testing.expect(!isZigString(*allowzero [4]u8)); - testing.expect(!isZigString(*volatile [4]u8)); + try testing.expect(!isZigString(u8)); + try testing.expect(!isZigString([4]u8)); + try testing.expect(!isZigString([4:0]u8)); + try testing.expect(!isZigString([*]const u8)); + try testing.expect(!isZigString([*]const [4]u8)); + try testing.expect(!isZigString([*c]const u8)); + try testing.expect(!isZigString([*c]const [4]u8)); + try testing.expect(!isZigString([*:0]const u8)); + try testing.expect(!isZigString([*:0]const u8)); + try testing.expect(!isZigString(*[]const u8)); + try testing.expect(!isZigString(?[]const u8)); + try testing.expect(!isZigString(?*const [4]u8)); + try testing.expect(!isZigString([]allowzero u8)); + try testing.expect(!isZigString([]volatile u8)); + try testing.expect(!isZigString(*allowzero [4]u8)); + try testing.expect(!isZigString(*volatile [4]u8)); } pub fn hasDecls(comptime T: type, comptime names: anytype) bool { @@ -505,11 +505,11 @@ test "std.meta.trait.hasDecls" { const tuple = .{ "a", "b", "c" }; - testing.expect(!hasDecls(TestStruct1, .{"a"})); - testing.expect(hasDecls(TestStruct2, .{ "a", "b" })); - testing.expect(hasDecls(TestStruct2, .{ "a", "b", "useless" })); - testing.expect(!hasDecls(TestStruct2, .{ "a", "b", "c" })); - testing.expect(!hasDecls(TestStruct2, tuple)); + try testing.expect(!hasDecls(TestStruct1, .{"a"})); + try testing.expect(hasDecls(TestStruct2, .{ "a", "b" })); + try testing.expect(hasDecls(TestStruct2, .{ "a", "b", "useless" })); + try testing.expect(!hasDecls(TestStruct2, .{ "a", "b", "c" })); + try testing.expect(!hasDecls(TestStruct2, tuple)); } pub fn hasFields(comptime T: type, comptime names: anytype) bool { @@ -531,11 +531,11 @@ test "std.meta.trait.hasFields" { const tuple = .{ "a", "b", "c" }; - testing.expect(!hasFields(TestStruct1, .{"a"})); - testing.expect(hasFields(TestStruct2, .{ "a", "b" })); - testing.expect(hasFields(TestStruct2, .{ "a", "b", "c" })); - testing.expect(hasFields(TestStruct2, tuple)); - testing.expect(!hasFields(TestStruct2, .{ "a", "b", "useless" })); + try testing.expect(!hasFields(TestStruct1, .{"a"})); + try testing.expect(hasFields(TestStruct2, .{ "a", "b" })); + try testing.expect(hasFields(TestStruct2, .{ "a", "b", "c" })); + try testing.expect(hasFields(TestStruct2, tuple)); + try testing.expect(!hasFields(TestStruct2, .{ "a", "b", "useless" })); } pub fn hasFunctions(comptime T: type, comptime names: anytype) bool { @@ -555,10 +555,10 @@ test "std.meta.trait.hasFunctions" { const tuple = .{ "a", "b", "c" }; - testing.expect(!hasFunctions(TestStruct1, .{"a"})); - testing.expect(hasFunctions(TestStruct2, .{ "a", "b" })); - testing.expect(!hasFunctions(TestStruct2, .{ "a", "b", "c" })); - testing.expect(!hasFunctions(TestStruct2, tuple)); + try testing.expect(!hasFunctions(TestStruct1, .{"a"})); + try testing.expect(hasFunctions(TestStruct2, .{ "a", "b" })); + try testing.expect(!hasFunctions(TestStruct2, .{ "a", "b", "c" })); + try testing.expect(!hasFunctions(TestStruct2, tuple)); } /// True if every value of the type `T` has a unique bit pattern representing it. @@ -606,65 +606,65 @@ test "std.meta.trait.hasUniqueRepresentation" { b: u32, }; - testing.expect(hasUniqueRepresentation(TestStruct1)); + try testing.expect(hasUniqueRepresentation(TestStruct1)); const TestStruct2 = struct { a: u32, b: u16, }; - testing.expect(!hasUniqueRepresentation(TestStruct2)); + try testing.expect(!hasUniqueRepresentation(TestStruct2)); const TestStruct3 = struct { a: u32, b: u32, }; - testing.expect(hasUniqueRepresentation(TestStruct3)); + try testing.expect(hasUniqueRepresentation(TestStruct3)); const TestStruct4 = struct { a: []const u8 }; - testing.expect(!hasUniqueRepresentation(TestStruct4)); + try testing.expect(!hasUniqueRepresentation(TestStruct4)); const TestStruct5 = struct { a: TestStruct4 }; - testing.expect(!hasUniqueRepresentation(TestStruct5)); + try testing.expect(!hasUniqueRepresentation(TestStruct5)); const TestUnion1 = packed union { a: u32, b: u16, }; - testing.expect(!hasUniqueRepresentation(TestUnion1)); + try testing.expect(!hasUniqueRepresentation(TestUnion1)); const TestUnion2 = extern union { a: u32, b: u16, }; - testing.expect(!hasUniqueRepresentation(TestUnion2)); + try testing.expect(!hasUniqueRepresentation(TestUnion2)); const TestUnion3 = union { a: u32, b: u16, }; - testing.expect(!hasUniqueRepresentation(TestUnion3)); + try testing.expect(!hasUniqueRepresentation(TestUnion3)); const TestUnion4 = union(enum) { a: u32, b: u16, }; - testing.expect(!hasUniqueRepresentation(TestUnion4)); + try testing.expect(!hasUniqueRepresentation(TestUnion4)); inline for ([_]type{ i0, u8, i16, u32, i64 }) |T| { - testing.expect(hasUniqueRepresentation(T)); + try testing.expect(hasUniqueRepresentation(T)); } inline for ([_]type{ i1, u9, i17, u33, i24 }) |T| { - testing.expect(!hasUniqueRepresentation(T)); + try testing.expect(!hasUniqueRepresentation(T)); } - testing.expect(!hasUniqueRepresentation([]u8)); - testing.expect(!hasUniqueRepresentation([]const u8)); + try testing.expect(!hasUniqueRepresentation([]u8)); + try testing.expect(!hasUniqueRepresentation([]const u8)); } diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig index f4d89d198c..394acee2c3 100644 --- a/lib/std/multi_array_list.zig +++ b/lib/std/multi_array_list.zig @@ -303,7 +303,7 @@ test "basic usage" { var list = MultiArrayList(Foo){}; defer list.deinit(ally); - testing.expectEqual(@as(usize, 0), list.items(.a).len); + try testing.expectEqual(@as(usize, 0), list.items(.a).len); try list.ensureCapacity(ally, 2); @@ -319,12 +319,12 @@ test "basic usage" { .c = 'b', }); - testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2 }); - testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b' }); + try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2 }); + try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b' }); - testing.expectEqual(@as(usize, 2), list.items(.b).len); - testing.expectEqualStrings("foobar", list.items(.b)[0]); - testing.expectEqualStrings("zigzag", list.items(.b)[1]); + try testing.expectEqual(@as(usize, 2), list.items(.b).len); + try testing.expectEqualStrings("foobar", list.items(.b)[0]); + try testing.expectEqualStrings("zigzag", list.items(.b)[1]); try list.append(ally, .{ .a = 3, @@ -332,13 +332,13 @@ test "basic usage" { .c = 'c', }); - testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 }); - testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' }); + try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 }); + try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' }); - testing.expectEqual(@as(usize, 3), list.items(.b).len); - testing.expectEqualStrings("foobar", list.items(.b)[0]); - testing.expectEqualStrings("zigzag", list.items(.b)[1]); - testing.expectEqualStrings("fizzbuzz", list.items(.b)[2]); + try testing.expectEqual(@as(usize, 3), list.items(.b).len); + try testing.expectEqualStrings("foobar", list.items(.b)[0]); + try testing.expectEqualStrings("zigzag", list.items(.b)[1]); + try testing.expectEqualStrings("fizzbuzz", list.items(.b)[2]); // Add 6 more things to force a capacity increase. var i: usize = 0; @@ -350,12 +350,12 @@ test "basic usage" { }); } - testing.expectEqualSlices( + try testing.expectEqualSlices( u32, &[_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, list.items(.a), ); - testing.expectEqualSlices( + try testing.expectEqualSlices( u8, &[_]u8{ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i' }, list.items(.c), @@ -363,13 +363,13 @@ test "basic usage" { list.shrinkAndFree(ally, 3); - testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 }); - testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' }); + try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 }); + try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' }); - testing.expectEqual(@as(usize, 3), list.items(.b).len); - testing.expectEqualStrings("foobar", list.items(.b)[0]); - testing.expectEqualStrings("zigzag", list.items(.b)[1]); - testing.expectEqualStrings("fizzbuzz", list.items(.b)[2]); + try testing.expectEqual(@as(usize, 3), list.items(.b).len); + try testing.expectEqualStrings("foobar", list.items(.b)[0]); + try testing.expectEqualStrings("zigzag", list.items(.b)[1]); + try testing.expectEqualStrings("fizzbuzz", list.items(.b)[2]); } // This was observed to fail on aarch64 with LLVM 11, when the capacityInBytes @@ -418,37 +418,37 @@ test "regression test for @reduce bug" { try list.append(ally, .{ .tag = .eof, .start = 123 }); const tags = list.items(.tag); - testing.expectEqual(tags[1], .identifier); - testing.expectEqual(tags[2], .equal); - testing.expectEqual(tags[3], .builtin); - testing.expectEqual(tags[4], .l_paren); - testing.expectEqual(tags[5], .string_literal); - testing.expectEqual(tags[6], .r_paren); - testing.expectEqual(tags[7], .semicolon); - testing.expectEqual(tags[8], .keyword_pub); - testing.expectEqual(tags[9], .keyword_fn); - testing.expectEqual(tags[10], .identifier); - testing.expectEqual(tags[11], .l_paren); - testing.expectEqual(tags[12], .r_paren); - testing.expectEqual(tags[13], .identifier); - testing.expectEqual(tags[14], .bang); - testing.expectEqual(tags[15], .identifier); - testing.expectEqual(tags[16], .l_brace); - testing.expectEqual(tags[17], .identifier); - testing.expectEqual(tags[18], .period); - testing.expectEqual(tags[19], .identifier); - testing.expectEqual(tags[20], .period); - testing.expectEqual(tags[21], .identifier); - testing.expectEqual(tags[22], .l_paren); - testing.expectEqual(tags[23], .string_literal); - testing.expectEqual(tags[24], .comma); - testing.expectEqual(tags[25], .period); - testing.expectEqual(tags[26], .l_brace); - testing.expectEqual(tags[27], .r_brace); - testing.expectEqual(tags[28], .r_paren); - testing.expectEqual(tags[29], .semicolon); - testing.expectEqual(tags[30], .r_brace); - testing.expectEqual(tags[31], .eof); + try testing.expectEqual(tags[1], .identifier); + try testing.expectEqual(tags[2], .equal); + try testing.expectEqual(tags[3], .builtin); + try testing.expectEqual(tags[4], .l_paren); + try testing.expectEqual(tags[5], .string_literal); + try testing.expectEqual(tags[6], .r_paren); + try testing.expectEqual(tags[7], .semicolon); + try testing.expectEqual(tags[8], .keyword_pub); + try testing.expectEqual(tags[9], .keyword_fn); + try testing.expectEqual(tags[10], .identifier); + try testing.expectEqual(tags[11], .l_paren); + try testing.expectEqual(tags[12], .r_paren); + try testing.expectEqual(tags[13], .identifier); + try testing.expectEqual(tags[14], .bang); + try testing.expectEqual(tags[15], .identifier); + try testing.expectEqual(tags[16], .l_brace); + try testing.expectEqual(tags[17], .identifier); + try testing.expectEqual(tags[18], .period); + try testing.expectEqual(tags[19], .identifier); + try testing.expectEqual(tags[20], .period); + try testing.expectEqual(tags[21], .identifier); + try testing.expectEqual(tags[22], .l_paren); + try testing.expectEqual(tags[23], .string_literal); + try testing.expectEqual(tags[24], .comma); + try testing.expectEqual(tags[25], .period); + try testing.expectEqual(tags[26], .l_brace); + try testing.expectEqual(tags[27], .r_brace); + try testing.expectEqual(tags[28], .r_paren); + try testing.expectEqual(tags[29], .semicolon); + try testing.expectEqual(tags[30], .r_brace); + try testing.expectEqual(tags[31], .eof); } test "ensure capacity on empty list" { @@ -466,15 +466,15 @@ test "ensure capacity on empty list" { list.appendAssumeCapacity(.{ .a = 1, .b = 2 }); list.appendAssumeCapacity(.{ .a = 3, .b = 4 }); - testing.expectEqualSlices(u32, &[_]u32{ 1, 3 }, list.items(.a)); - testing.expectEqualSlices(u8, &[_]u8{ 2, 4 }, list.items(.b)); + try testing.expectEqualSlices(u32, &[_]u32{ 1, 3 }, list.items(.a)); + try testing.expectEqualSlices(u8, &[_]u8{ 2, 4 }, list.items(.b)); list.len = 0; list.appendAssumeCapacity(.{ .a = 5, .b = 6 }); list.appendAssumeCapacity(.{ .a = 7, .b = 8 }); - testing.expectEqualSlices(u32, &[_]u32{ 5, 7 }, list.items(.a)); - testing.expectEqualSlices(u8, &[_]u8{ 6, 8 }, list.items(.b)); + try testing.expectEqualSlices(u32, &[_]u32{ 5, 7 }, list.items(.a)); + try testing.expectEqualSlices(u8, &[_]u8{ 6, 8 }, list.items(.b)); list.len = 0; try list.ensureCapacity(ally, 16); @@ -482,6 +482,6 @@ test "ensure capacity on empty list" { list.appendAssumeCapacity(.{ .a = 9, .b = 10 }); list.appendAssumeCapacity(.{ .a = 11, .b = 12 }); - testing.expectEqualSlices(u32, &[_]u32{ 9, 11 }, list.items(.a)); - testing.expectEqualSlices(u8, &[_]u8{ 10, 12 }, list.items(.b)); + try testing.expectEqualSlices(u32, &[_]u32{ 9, 11 }, list.items(.a)); + try testing.expectEqualSlices(u8, &[_]u8{ 10, 12 }, list.items(.b)); } diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig index 4470d17aeb..c2596b733c 100644 --- a/lib/std/net/test.zig +++ b/lib/std/net/test.zig @@ -38,26 +38,26 @@ test "parse and render IPv6 addresses" { for (ips) |ip, i| { var addr = net.Address.parseIp6(ip, 0) catch unreachable; var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; - std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3])); + try std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3])); if (std.builtin.os.tag == .linux) { var addr_via_resolve = net.Address.resolveIp6(ip, 0) catch unreachable; var newResolvedIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr_via_resolve}) catch unreachable; - std.testing.expect(std.mem.eql(u8, printed[i], newResolvedIp[1 .. newResolvedIp.len - 3])); + try std.testing.expect(std.mem.eql(u8, printed[i], newResolvedIp[1 .. newResolvedIp.len - 3])); } } - testing.expectError(error.InvalidCharacter, net.Address.parseIp6(":::", 0)); - testing.expectError(error.Overflow, net.Address.parseIp6("FF001::FB", 0)); - testing.expectError(error.InvalidCharacter, net.Address.parseIp6("FF01::Fb:zig", 0)); - testing.expectError(error.InvalidEnd, net.Address.parseIp6("FF01:0:0:0:0:0:0:FB:", 0)); - testing.expectError(error.Incomplete, net.Address.parseIp6("FF01:", 0)); - testing.expectError(error.InvalidIpv4Mapping, net.Address.parseIp6("::123.123.123.123", 0)); + try testing.expectError(error.InvalidCharacter, net.Address.parseIp6(":::", 0)); + try testing.expectError(error.Overflow, net.Address.parseIp6("FF001::FB", 0)); + try testing.expectError(error.InvalidCharacter, net.Address.parseIp6("FF01::Fb:zig", 0)); + try testing.expectError(error.InvalidEnd, net.Address.parseIp6("FF01:0:0:0:0:0:0:FB:", 0)); + try testing.expectError(error.Incomplete, net.Address.parseIp6("FF01:", 0)); + try testing.expectError(error.InvalidIpv4Mapping, net.Address.parseIp6("::123.123.123.123", 0)); // TODO Make this test pass on other operating systems. if (std.builtin.os.tag == .linux) { - testing.expectError(error.Incomplete, net.Address.resolveIp6("ff01::fb%", 0)); - testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%wlp3s0s0s0s0s0s0s0s0", 0)); - testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%12345678901234", 0)); + try testing.expectError(error.Incomplete, net.Address.resolveIp6("ff01::fb%", 0)); + try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%wlp3s0s0s0s0s0s0s0s0", 0)); + try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%12345678901234", 0)); } } @@ -68,7 +68,7 @@ test "invalid but parseable IPv6 scope ids" { return error.SkipZigTest; } - testing.expectError(error.InterfaceNotFound, net.Address.resolveIp6("ff01::fb%123s45678901234", 0)); + try testing.expectError(error.InterfaceNotFound, net.Address.resolveIp6("ff01::fb%123s45678901234", 0)); } test "parse and render IPv4 addresses" { @@ -84,14 +84,14 @@ test "parse and render IPv4 addresses" { }) |ip| { var addr = net.Address.parseIp4(ip, 0) catch unreachable; var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; - std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2])); + try std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2])); } - testing.expectError(error.Overflow, net.Address.parseIp4("256.0.0.1", 0)); - testing.expectError(error.InvalidCharacter, net.Address.parseIp4("x.0.0.1", 0)); - testing.expectError(error.InvalidEnd, net.Address.parseIp4("127.0.0.1.1", 0)); - testing.expectError(error.Incomplete, net.Address.parseIp4("127.0.0.", 0)); - testing.expectError(error.InvalidCharacter, net.Address.parseIp4("100..0.1", 0)); + try testing.expectError(error.Overflow, net.Address.parseIp4("256.0.0.1", 0)); + try testing.expectError(error.InvalidCharacter, net.Address.parseIp4("x.0.0.1", 0)); + try testing.expectError(error.InvalidEnd, net.Address.parseIp4("127.0.0.1.1", 0)); + try testing.expectError(error.Incomplete, net.Address.parseIp4("127.0.0.", 0)); + try testing.expectError(error.InvalidCharacter, net.Address.parseIp4("100..0.1", 0)); } test "resolve DNS" { @@ -169,8 +169,8 @@ test "listen on a port, send bytes, receive bytes" { var buf: [16]u8 = undefined; const n = try client.stream.reader().read(&buf); - testing.expectEqual(@as(usize, 12), n); - testing.expectEqualSlices(u8, "Hello world!", buf[0..n]); + try testing.expectEqual(@as(usize, 12), n); + try testing.expectEqualSlices(u8, "Hello world!", buf[0..n]); } test "listen on a port, send bytes, receive bytes" { @@ -230,7 +230,7 @@ fn testClientToHost(allocator: *mem.Allocator, name: []const u8, port: u16) anye var buf: [100]u8 = undefined; const len = try connection.read(&buf); const msg = buf[0..len]; - testing.expect(mem.eql(u8, msg, "hello from server\n")); + try testing.expect(mem.eql(u8, msg, "hello from server\n")); } fn testClient(addr: net.Address) anyerror!void { @@ -242,7 +242,7 @@ fn testClient(addr: net.Address) anyerror!void { var buf: [100]u8 = undefined; const len = try socket_file.read(&buf); const msg = buf[0..len]; - testing.expect(mem.eql(u8, msg, "hello from server\n")); + try testing.expect(mem.eql(u8, msg, "hello from server\n")); } fn testServer(server: *net.StreamServer) anyerror!void { @@ -293,6 +293,6 @@ test "listen on a unix socket, send bytes, receive bytes" { var buf: [16]u8 = undefined; const n = try client.stream.reader().read(&buf); - testing.expectEqual(@as(usize, 12), n); - testing.expectEqualSlices(u8, "Hello world!", buf[0..n]); + try testing.expectEqual(@as(usize, 12), n); + try testing.expectEqualSlices(u8, "Hello world!", buf[0..n]); } diff --git a/lib/std/once.zig b/lib/std/once.zig index 79d273b86a..c56e572570 100644 --- a/lib/std/once.zig +++ b/lib/std/once.zig @@ -67,5 +67,5 @@ test "Once executes its function just once" { } } - testing.expectEqual(@as(i32, 1), global_number); + try testing.expectEqual(@as(i32, 1), global_number); } diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig index 0d7e0a19ed..8c1500740b 100644 --- a/lib/std/os/linux/bpf.zig +++ b/lib/std/os/linux/bpf.zig @@ -737,11 +737,11 @@ pub const Insn = packed struct { }; test "insn bitsize" { - expectEqual(@bitSizeOf(Insn), 64); + try expectEqual(@bitSizeOf(Insn), 64); } -fn expect_opcode(code: u8, insn: Insn) void { - expectEqual(code, insn.code); +fn expect_opcode(code: u8, insn: Insn) !void { + try expectEqual(code, insn.code); } // The opcodes were grabbed from https://github.com/iovisor/bpf-docs/blob/master/eBPF.md @@ -750,108 +750,108 @@ test "opcodes" { // loading 64-bit immediates (imm is only 32 bits wide) // alu instructions - expect_opcode(0x07, Insn.add(.r1, 0)); - expect_opcode(0x0f, Insn.add(.r1, .r2)); - expect_opcode(0x17, Insn.sub(.r1, 0)); - expect_opcode(0x1f, Insn.sub(.r1, .r2)); - expect_opcode(0x27, Insn.mul(.r1, 0)); - expect_opcode(0x2f, Insn.mul(.r1, .r2)); - expect_opcode(0x37, Insn.div(.r1, 0)); - expect_opcode(0x3f, Insn.div(.r1, .r2)); - expect_opcode(0x47, Insn.alu_or(.r1, 0)); - expect_opcode(0x4f, Insn.alu_or(.r1, .r2)); - expect_opcode(0x57, Insn.alu_and(.r1, 0)); - expect_opcode(0x5f, Insn.alu_and(.r1, .r2)); - expect_opcode(0x67, Insn.lsh(.r1, 0)); - expect_opcode(0x6f, Insn.lsh(.r1, .r2)); - expect_opcode(0x77, Insn.rsh(.r1, 0)); - expect_opcode(0x7f, Insn.rsh(.r1, .r2)); - expect_opcode(0x87, Insn.neg(.r1)); - expect_opcode(0x97, Insn.mod(.r1, 0)); - expect_opcode(0x9f, Insn.mod(.r1, .r2)); - expect_opcode(0xa7, Insn.xor(.r1, 0)); - expect_opcode(0xaf, Insn.xor(.r1, .r2)); - expect_opcode(0xb7, Insn.mov(.r1, 0)); - expect_opcode(0xbf, Insn.mov(.r1, .r2)); - expect_opcode(0xc7, Insn.arsh(.r1, 0)); - expect_opcode(0xcf, Insn.arsh(.r1, .r2)); + try expect_opcode(0x07, Insn.add(.r1, 0)); + try expect_opcode(0x0f, Insn.add(.r1, .r2)); + try expect_opcode(0x17, Insn.sub(.r1, 0)); + try expect_opcode(0x1f, Insn.sub(.r1, .r2)); + try expect_opcode(0x27, Insn.mul(.r1, 0)); + try expect_opcode(0x2f, Insn.mul(.r1, .r2)); + try expect_opcode(0x37, Insn.div(.r1, 0)); + try expect_opcode(0x3f, Insn.div(.r1, .r2)); + try expect_opcode(0x47, Insn.alu_or(.r1, 0)); + try expect_opcode(0x4f, Insn.alu_or(.r1, .r2)); + try expect_opcode(0x57, Insn.alu_and(.r1, 0)); + try expect_opcode(0x5f, Insn.alu_and(.r1, .r2)); + try expect_opcode(0x67, Insn.lsh(.r1, 0)); + try expect_opcode(0x6f, Insn.lsh(.r1, .r2)); + try expect_opcode(0x77, Insn.rsh(.r1, 0)); + try expect_opcode(0x7f, Insn.rsh(.r1, .r2)); + try expect_opcode(0x87, Insn.neg(.r1)); + try expect_opcode(0x97, Insn.mod(.r1, 0)); + try expect_opcode(0x9f, Insn.mod(.r1, .r2)); + try expect_opcode(0xa7, Insn.xor(.r1, 0)); + try expect_opcode(0xaf, Insn.xor(.r1, .r2)); + try expect_opcode(0xb7, Insn.mov(.r1, 0)); + try expect_opcode(0xbf, Insn.mov(.r1, .r2)); + try expect_opcode(0xc7, Insn.arsh(.r1, 0)); + try expect_opcode(0xcf, Insn.arsh(.r1, .r2)); // atomic instructions: might be more of these not documented in the wild - expect_opcode(0xdb, Insn.xadd(.r1, .r2)); + try expect_opcode(0xdb, Insn.xadd(.r1, .r2)); // TODO: byteswap instructions - expect_opcode(0xd4, Insn.le(.half_word, .r1)); - expectEqual(@intCast(i32, 16), Insn.le(.half_word, .r1).imm); - expect_opcode(0xd4, Insn.le(.word, .r1)); - expectEqual(@intCast(i32, 32), Insn.le(.word, .r1).imm); - expect_opcode(0xd4, Insn.le(.double_word, .r1)); - expectEqual(@intCast(i32, 64), Insn.le(.double_word, .r1).imm); - expect_opcode(0xdc, Insn.be(.half_word, .r1)); - expectEqual(@intCast(i32, 16), Insn.be(.half_word, .r1).imm); - expect_opcode(0xdc, Insn.be(.word, .r1)); - expectEqual(@intCast(i32, 32), Insn.be(.word, .r1).imm); - expect_opcode(0xdc, Insn.be(.double_word, .r1)); - expectEqual(@intCast(i32, 64), Insn.be(.double_word, .r1).imm); + try expect_opcode(0xd4, Insn.le(.half_word, .r1)); + try expectEqual(@intCast(i32, 16), Insn.le(.half_word, .r1).imm); + try expect_opcode(0xd4, Insn.le(.word, .r1)); + try expectEqual(@intCast(i32, 32), Insn.le(.word, .r1).imm); + try expect_opcode(0xd4, Insn.le(.double_word, .r1)); + try expectEqual(@intCast(i32, 64), Insn.le(.double_word, .r1).imm); + try expect_opcode(0xdc, Insn.be(.half_word, .r1)); + try expectEqual(@intCast(i32, 16), Insn.be(.half_word, .r1).imm); + try expect_opcode(0xdc, Insn.be(.word, .r1)); + try expectEqual(@intCast(i32, 32), Insn.be(.word, .r1).imm); + try expect_opcode(0xdc, Insn.be(.double_word, .r1)); + try expectEqual(@intCast(i32, 64), Insn.be(.double_word, .r1).imm); // memory instructions - expect_opcode(0x18, Insn.ld_dw1(.r1, 0)); - expect_opcode(0x00, Insn.ld_dw2(0)); + try expect_opcode(0x18, Insn.ld_dw1(.r1, 0)); + try expect_opcode(0x00, Insn.ld_dw2(0)); // loading a map fd - expect_opcode(0x18, Insn.ld_map_fd1(.r1, 0)); - expectEqual(@intCast(u4, PSEUDO_MAP_FD), Insn.ld_map_fd1(.r1, 0).src); - expect_opcode(0x00, Insn.ld_map_fd2(0)); + try expect_opcode(0x18, Insn.ld_map_fd1(.r1, 0)); + try expectEqual(@intCast(u4, PSEUDO_MAP_FD), Insn.ld_map_fd1(.r1, 0).src); + try expect_opcode(0x00, Insn.ld_map_fd2(0)); - expect_opcode(0x38, Insn.ld_abs(.double_word, .r1, .r2, 0)); - expect_opcode(0x20, Insn.ld_abs(.word, .r1, .r2, 0)); - expect_opcode(0x28, Insn.ld_abs(.half_word, .r1, .r2, 0)); - expect_opcode(0x30, Insn.ld_abs(.byte, .r1, .r2, 0)); + try expect_opcode(0x38, Insn.ld_abs(.double_word, .r1, .r2, 0)); + try expect_opcode(0x20, Insn.ld_abs(.word, .r1, .r2, 0)); + try expect_opcode(0x28, Insn.ld_abs(.half_word, .r1, .r2, 0)); + try expect_opcode(0x30, Insn.ld_abs(.byte, .r1, .r2, 0)); - expect_opcode(0x58, Insn.ld_ind(.double_word, .r1, .r2, 0)); - expect_opcode(0x40, Insn.ld_ind(.word, .r1, .r2, 0)); - expect_opcode(0x48, Insn.ld_ind(.half_word, .r1, .r2, 0)); - expect_opcode(0x50, Insn.ld_ind(.byte, .r1, .r2, 0)); + try expect_opcode(0x58, Insn.ld_ind(.double_word, .r1, .r2, 0)); + try expect_opcode(0x40, Insn.ld_ind(.word, .r1, .r2, 0)); + try expect_opcode(0x48, Insn.ld_ind(.half_word, .r1, .r2, 0)); + try expect_opcode(0x50, Insn.ld_ind(.byte, .r1, .r2, 0)); - expect_opcode(0x79, Insn.ldx(.double_word, .r1, .r2, 0)); - expect_opcode(0x61, Insn.ldx(.word, .r1, .r2, 0)); - expect_opcode(0x69, Insn.ldx(.half_word, .r1, .r2, 0)); - expect_opcode(0x71, Insn.ldx(.byte, .r1, .r2, 0)); + try expect_opcode(0x79, Insn.ldx(.double_word, .r1, .r2, 0)); + try expect_opcode(0x61, Insn.ldx(.word, .r1, .r2, 0)); + try expect_opcode(0x69, Insn.ldx(.half_word, .r1, .r2, 0)); + try expect_opcode(0x71, Insn.ldx(.byte, .r1, .r2, 0)); - expect_opcode(0x62, Insn.st(.word, .r1, 0, 0)); - expect_opcode(0x6a, Insn.st(.half_word, .r1, 0, 0)); - expect_opcode(0x72, Insn.st(.byte, .r1, 0, 0)); + try expect_opcode(0x62, Insn.st(.word, .r1, 0, 0)); + try expect_opcode(0x6a, Insn.st(.half_word, .r1, 0, 0)); + try expect_opcode(0x72, Insn.st(.byte, .r1, 0, 0)); - expect_opcode(0x63, Insn.stx(.word, .r1, 0, .r2)); - expect_opcode(0x6b, Insn.stx(.half_word, .r1, 0, .r2)); - expect_opcode(0x73, Insn.stx(.byte, .r1, 0, .r2)); - expect_opcode(0x7b, Insn.stx(.double_word, .r1, 0, .r2)); + try expect_opcode(0x63, Insn.stx(.word, .r1, 0, .r2)); + try expect_opcode(0x6b, Insn.stx(.half_word, .r1, 0, .r2)); + try expect_opcode(0x73, Insn.stx(.byte, .r1, 0, .r2)); + try expect_opcode(0x7b, Insn.stx(.double_word, .r1, 0, .r2)); // branch instructions - expect_opcode(0x05, Insn.ja(0)); - expect_opcode(0x15, Insn.jeq(.r1, 0, 0)); - expect_opcode(0x1d, Insn.jeq(.r1, .r2, 0)); - expect_opcode(0x25, Insn.jgt(.r1, 0, 0)); - expect_opcode(0x2d, Insn.jgt(.r1, .r2, 0)); - expect_opcode(0x35, Insn.jge(.r1, 0, 0)); - expect_opcode(0x3d, Insn.jge(.r1, .r2, 0)); - expect_opcode(0xa5, Insn.jlt(.r1, 0, 0)); - expect_opcode(0xad, Insn.jlt(.r1, .r2, 0)); - expect_opcode(0xb5, Insn.jle(.r1, 0, 0)); - expect_opcode(0xbd, Insn.jle(.r1, .r2, 0)); - expect_opcode(0x45, Insn.jset(.r1, 0, 0)); - expect_opcode(0x4d, Insn.jset(.r1, .r2, 0)); - expect_opcode(0x55, Insn.jne(.r1, 0, 0)); - expect_opcode(0x5d, Insn.jne(.r1, .r2, 0)); - expect_opcode(0x65, Insn.jsgt(.r1, 0, 0)); - expect_opcode(0x6d, Insn.jsgt(.r1, .r2, 0)); - expect_opcode(0x75, Insn.jsge(.r1, 0, 0)); - expect_opcode(0x7d, Insn.jsge(.r1, .r2, 0)); - expect_opcode(0xc5, Insn.jslt(.r1, 0, 0)); - expect_opcode(0xcd, Insn.jslt(.r1, .r2, 0)); - expect_opcode(0xd5, Insn.jsle(.r1, 0, 0)); - expect_opcode(0xdd, Insn.jsle(.r1, .r2, 0)); - expect_opcode(0x85, Insn.call(.unspec)); - expect_opcode(0x95, Insn.exit()); + try expect_opcode(0x05, Insn.ja(0)); + try expect_opcode(0x15, Insn.jeq(.r1, 0, 0)); + try expect_opcode(0x1d, Insn.jeq(.r1, .r2, 0)); + try expect_opcode(0x25, Insn.jgt(.r1, 0, 0)); + try expect_opcode(0x2d, Insn.jgt(.r1, .r2, 0)); + try expect_opcode(0x35, Insn.jge(.r1, 0, 0)); + try expect_opcode(0x3d, Insn.jge(.r1, .r2, 0)); + try expect_opcode(0xa5, Insn.jlt(.r1, 0, 0)); + try expect_opcode(0xad, Insn.jlt(.r1, .r2, 0)); + try expect_opcode(0xb5, Insn.jle(.r1, 0, 0)); + try expect_opcode(0xbd, Insn.jle(.r1, .r2, 0)); + try expect_opcode(0x45, Insn.jset(.r1, 0, 0)); + try expect_opcode(0x4d, Insn.jset(.r1, .r2, 0)); + try expect_opcode(0x55, Insn.jne(.r1, 0, 0)); + try expect_opcode(0x5d, Insn.jne(.r1, .r2, 0)); + try expect_opcode(0x65, Insn.jsgt(.r1, 0, 0)); + try expect_opcode(0x6d, Insn.jsgt(.r1, .r2, 0)); + try expect_opcode(0x75, Insn.jsge(.r1, 0, 0)); + try expect_opcode(0x7d, Insn.jsge(.r1, .r2, 0)); + try expect_opcode(0xc5, Insn.jslt(.r1, 0, 0)); + try expect_opcode(0xcd, Insn.jslt(.r1, .r2, 0)); + try expect_opcode(0xd5, Insn.jsle(.r1, 0, 0)); + try expect_opcode(0xdd, Insn.jsle(.r1, .r2, 0)); + try expect_opcode(0x85, Insn.call(.unspec)); + try expect_opcode(0x95, Insn.exit()); } pub const Cmd = extern enum(usize) { @@ -1596,7 +1596,7 @@ test "map lookup, update, and delete" { var value = std.mem.zeroes([value_size]u8); // fails looking up value that doesn't exist - expectError(error.NotFound, map_lookup_elem(map, &key, &value)); + try expectError(error.NotFound, map_lookup_elem(map, &key, &value)); // succeed at updating and looking up element try map_update_elem(map, &key, &value, 0); @@ -1604,14 +1604,14 @@ test "map lookup, update, and delete" { // fails inserting more than max entries const second_key = [key_size]u8{ 0, 0, 0, 1 }; - expectError(error.ReachedMaxEntries, map_update_elem(map, &second_key, &value, 0)); + try expectError(error.ReachedMaxEntries, map_update_elem(map, &second_key, &value, 0)); // succeed at deleting an existing elem try map_delete_elem(map, &key); - expectError(error.NotFound, map_lookup_elem(map, &key, &value)); + try expectError(error.NotFound, map_lookup_elem(map, &key, &value)); // fail at deleting a non-existing elem - expectError(error.NotFound, map_delete_elem(map, &key)); + try expectError(error.NotFound, map_delete_elem(map, &key)); } pub fn prog_load( @@ -1662,5 +1662,5 @@ test "prog_load" { const prog = try prog_load(.socket_filter, &good_prog, null, "MIT", 0); defer std.os.close(prog); - expectError(error.UnsafeProgram, prog_load(.socket_filter, &bad_prog, null, "MIT", 0)); + try expectError(error.UnsafeProgram, prog_load(.socket_filter, &bad_prog, null, "MIT", 0)); } diff --git a/lib/std/os/linux/bpf/btf.zig b/lib/std/os/linux/bpf/btf.zig index 9ba3a0f942..d8a0cb57a9 100644 --- a/lib/std/os/linux/bpf/btf.zig +++ b/lib/std/os/linux/bpf/btf.zig @@ -92,7 +92,7 @@ pub const IntInfo = packed struct { }; test "IntInfo is 32 bits" { - std.testing.expectEqual(@bitSizeOf(IntInfo), 32); + try std.testing.expectEqual(@bitSizeOf(IntInfo), 32); } /// Enum kind is followed by this struct diff --git a/lib/std/os/linux/io_uring.zig b/lib/std/os/linux/io_uring.zig index fc5af34696..ca80a381f5 100644 --- a/lib/std/os/linux/io_uring.zig +++ b/lib/std/os/linux/io_uring.zig @@ -937,16 +937,16 @@ pub fn io_uring_prep_fallocate( test "structs/offsets/entries" { if (builtin.os.tag != .linux) return error.SkipZigTest; - testing.expectEqual(@as(usize, 120), @sizeOf(io_uring_params)); - testing.expectEqual(@as(usize, 64), @sizeOf(io_uring_sqe)); - testing.expectEqual(@as(usize, 16), @sizeOf(io_uring_cqe)); + try testing.expectEqual(@as(usize, 120), @sizeOf(io_uring_params)); + try testing.expectEqual(@as(usize, 64), @sizeOf(io_uring_sqe)); + try testing.expectEqual(@as(usize, 16), @sizeOf(io_uring_cqe)); - testing.expectEqual(0, linux.IORING_OFF_SQ_RING); - testing.expectEqual(0x8000000, linux.IORING_OFF_CQ_RING); - testing.expectEqual(0x10000000, linux.IORING_OFF_SQES); + try testing.expectEqual(0, linux.IORING_OFF_SQ_RING); + try testing.expectEqual(0x8000000, linux.IORING_OFF_CQ_RING); + try testing.expectEqual(0x10000000, linux.IORING_OFF_SQES); - testing.expectError(error.EntriesZero, IO_Uring.init(0, 0)); - testing.expectError(error.EntriesNotPowerOfTwo, IO_Uring.init(3, 0)); + try testing.expectError(error.EntriesZero, IO_Uring.init(0, 0)); + try testing.expectError(error.EntriesNotPowerOfTwo, IO_Uring.init(3, 0)); } test "nop" { @@ -959,11 +959,11 @@ test "nop" { }; defer { ring.deinit(); - testing.expectEqual(@as(os.fd_t, -1), ring.fd); + testing.expectEqual(@as(os.fd_t, -1), ring.fd) catch @panic("test failed"); } const sqe = try ring.nop(0xaaaaaaaa); - testing.expectEqual(io_uring_sqe{ + try testing.expectEqual(io_uring_sqe{ .opcode = .NOP, .flags = 0, .ioprio = 0, @@ -979,40 +979,40 @@ test "nop" { .__pad2 = [2]u64{ 0, 0 }, }, sqe.*); - testing.expectEqual(@as(u32, 0), ring.sq.sqe_head); - testing.expectEqual(@as(u32, 1), ring.sq.sqe_tail); - testing.expectEqual(@as(u32, 0), ring.sq.tail.*); - testing.expectEqual(@as(u32, 0), ring.cq.head.*); - testing.expectEqual(@as(u32, 1), ring.sq_ready()); - testing.expectEqual(@as(u32, 0), ring.cq_ready()); + try testing.expectEqual(@as(u32, 0), ring.sq.sqe_head); + try testing.expectEqual(@as(u32, 1), ring.sq.sqe_tail); + try testing.expectEqual(@as(u32, 0), ring.sq.tail.*); + try testing.expectEqual(@as(u32, 0), ring.cq.head.*); + try testing.expectEqual(@as(u32, 1), ring.sq_ready()); + try testing.expectEqual(@as(u32, 0), ring.cq_ready()); - testing.expectEqual(@as(u32, 1), try ring.submit()); - testing.expectEqual(@as(u32, 1), ring.sq.sqe_head); - testing.expectEqual(@as(u32, 1), ring.sq.sqe_tail); - testing.expectEqual(@as(u32, 1), ring.sq.tail.*); - testing.expectEqual(@as(u32, 0), ring.cq.head.*); - testing.expectEqual(@as(u32, 0), ring.sq_ready()); + try testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(@as(u32, 1), ring.sq.sqe_head); + try testing.expectEqual(@as(u32, 1), ring.sq.sqe_tail); + try testing.expectEqual(@as(u32, 1), ring.sq.tail.*); + try testing.expectEqual(@as(u32, 0), ring.cq.head.*); + try testing.expectEqual(@as(u32, 0), ring.sq_ready()); - testing.expectEqual(io_uring_cqe{ + try testing.expectEqual(io_uring_cqe{ .user_data = 0xaaaaaaaa, .res = 0, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqual(@as(u32, 1), ring.cq.head.*); - testing.expectEqual(@as(u32, 0), ring.cq_ready()); + try testing.expectEqual(@as(u32, 1), ring.cq.head.*); + try testing.expectEqual(@as(u32, 0), ring.cq_ready()); const sqe_barrier = try ring.nop(0xbbbbbbbb); sqe_barrier.flags |= linux.IOSQE_IO_DRAIN; - testing.expectEqual(@as(u32, 1), try ring.submit()); - testing.expectEqual(io_uring_cqe{ + try testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(io_uring_cqe{ .user_data = 0xbbbbbbbb, .res = 0, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqual(@as(u32, 2), ring.sq.sqe_head); - testing.expectEqual(@as(u32, 2), ring.sq.sqe_tail); - testing.expectEqual(@as(u32, 2), ring.sq.tail.*); - testing.expectEqual(@as(u32, 2), ring.cq.head.*); + try testing.expectEqual(@as(u32, 2), ring.sq.sqe_head); + try testing.expectEqual(@as(u32, 2), ring.sq.sqe_tail); + try testing.expectEqual(@as(u32, 2), ring.sq.tail.*); + try testing.expectEqual(@as(u32, 2), ring.cq.head.*); } test "readv" { @@ -1042,17 +1042,17 @@ test "readv" { var buffer = [_]u8{42} ** 128; var iovecs = [_]os.iovec{os.iovec{ .iov_base = &buffer, .iov_len = buffer.len }}; const sqe = try ring.readv(0xcccccccc, fd_index, iovecs[0..], 0); - testing.expectEqual(linux.IORING_OP.READV, sqe.opcode); + try testing.expectEqual(linux.IORING_OP.READV, sqe.opcode); sqe.flags |= linux.IOSQE_FIXED_FILE; - testing.expectError(error.SubmissionQueueFull, ring.nop(0)); - testing.expectEqual(@as(u32, 1), try ring.submit()); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectError(error.SubmissionQueueFull, ring.nop(0)); + try testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xcccccccc, .res = buffer.len, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqualSlices(u8, &([_]u8{0} ** buffer.len), buffer[0..]); + try testing.expectEqualSlices(u8, &([_]u8{0} ** buffer.len), buffer[0..]); try ring.unregister_files(); } @@ -1083,46 +1083,46 @@ test "writev/fsync/readv" { }; const sqe_writev = try ring.writev(0xdddddddd, fd, iovecs_write[0..], 17); - testing.expectEqual(linux.IORING_OP.WRITEV, sqe_writev.opcode); - testing.expectEqual(@as(u64, 17), sqe_writev.off); + try testing.expectEqual(linux.IORING_OP.WRITEV, sqe_writev.opcode); + try testing.expectEqual(@as(u64, 17), sqe_writev.off); sqe_writev.flags |= linux.IOSQE_IO_LINK; const sqe_fsync = try ring.fsync(0xeeeeeeee, fd, 0); - testing.expectEqual(linux.IORING_OP.FSYNC, sqe_fsync.opcode); - testing.expectEqual(fd, sqe_fsync.fd); + try testing.expectEqual(linux.IORING_OP.FSYNC, sqe_fsync.opcode); + try testing.expectEqual(fd, sqe_fsync.fd); sqe_fsync.flags |= linux.IOSQE_IO_LINK; const sqe_readv = try ring.readv(0xffffffff, fd, iovecs_read[0..], 17); - testing.expectEqual(linux.IORING_OP.READV, sqe_readv.opcode); - testing.expectEqual(@as(u64, 17), sqe_readv.off); + try testing.expectEqual(linux.IORING_OP.READV, sqe_readv.opcode); + try testing.expectEqual(@as(u64, 17), sqe_readv.off); - testing.expectEqual(@as(u32, 3), ring.sq_ready()); - testing.expectEqual(@as(u32, 3), try ring.submit_and_wait(3)); - testing.expectEqual(@as(u32, 0), ring.sq_ready()); - testing.expectEqual(@as(u32, 3), ring.cq_ready()); + try testing.expectEqual(@as(u32, 3), ring.sq_ready()); + try testing.expectEqual(@as(u32, 3), try ring.submit_and_wait(3)); + try testing.expectEqual(@as(u32, 0), ring.sq_ready()); + try testing.expectEqual(@as(u32, 3), ring.cq_ready()); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xdddddddd, .res = buffer_write.len, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqual(@as(u32, 2), ring.cq_ready()); + try testing.expectEqual(@as(u32, 2), ring.cq_ready()); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xeeeeeeee, .res = 0, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqual(@as(u32, 1), ring.cq_ready()); + try testing.expectEqual(@as(u32, 1), ring.cq_ready()); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xffffffff, .res = buffer_read.len, .flags = 0, }, try ring.copy_cqe()); - testing.expectEqual(@as(u32, 0), ring.cq_ready()); + try testing.expectEqual(@as(u32, 0), ring.cq_ready()); - testing.expectEqualSlices(u8, buffer_write[0..], buffer_read[0..]); + try testing.expectEqualSlices(u8, buffer_write[0..], buffer_read[0..]); } test "write/read" { @@ -1144,13 +1144,13 @@ test "write/read" { const buffer_write = [_]u8{97} ** 20; var buffer_read = [_]u8{98} ** 20; const sqe_write = try ring.write(0x11111111, fd, buffer_write[0..], 10); - testing.expectEqual(linux.IORING_OP.WRITE, sqe_write.opcode); - testing.expectEqual(@as(u64, 10), sqe_write.off); + try testing.expectEqual(linux.IORING_OP.WRITE, sqe_write.opcode); + try testing.expectEqual(@as(u64, 10), sqe_write.off); sqe_write.flags |= linux.IOSQE_IO_LINK; const sqe_read = try ring.read(0x22222222, fd, buffer_read[0..], 10); - testing.expectEqual(linux.IORING_OP.READ, sqe_read.opcode); - testing.expectEqual(@as(u64, 10), sqe_read.off); - testing.expectEqual(@as(u32, 2), try ring.submit()); + try testing.expectEqual(linux.IORING_OP.READ, sqe_read.opcode); + try testing.expectEqual(@as(u64, 10), sqe_read.off); + try testing.expectEqual(@as(u32, 2), try ring.submit()); const cqe_write = try ring.copy_cqe(); const cqe_read = try ring.copy_cqe(); @@ -1158,17 +1158,17 @@ test "write/read" { // https://lwn.net/Articles/809820/ if (cqe_write.res == -linux.EINVAL) return error.SkipZigTest; if (cqe_read.res == -linux.EINVAL) return error.SkipZigTest; - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x11111111, .res = buffer_write.len, .flags = 0, }, cqe_write); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x22222222, .res = buffer_read.len, .flags = 0, }, cqe_read); - testing.expectEqualSlices(u8, buffer_write[0..], buffer_read[0..]); + try testing.expectEqualSlices(u8, buffer_write[0..], buffer_read[0..]); } test "openat" { @@ -1187,7 +1187,7 @@ test "openat" { const flags: u32 = os.O_CLOEXEC | os.O_RDWR | os.O_CREAT; const mode: os.mode_t = 0o666; const sqe_openat = try ring.openat(0x33333333, linux.AT_FDCWD, path, flags, mode); - testing.expectEqual(io_uring_sqe{ + try testing.expectEqual(io_uring_sqe{ .opcode = .OPENAT, .flags = 0, .ioprio = 0, @@ -1202,10 +1202,10 @@ test "openat" { .splice_fd_in = 0, .__pad2 = [2]u64{ 0, 0 }, }, sqe_openat.*); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(@as(u32, 1), try ring.submit()); const cqe_openat = try ring.copy_cqe(); - testing.expectEqual(@as(u64, 0x33333333), cqe_openat.user_data); + try testing.expectEqual(@as(u64, 0x33333333), cqe_openat.user_data); if (cqe_openat.res == -linux.EINVAL) return error.SkipZigTest; // AT_FDCWD is not fully supported before kernel 5.6: // See https://lore.kernel.org/io-uring/20200207155039.12819-1-axboe@kernel.dk/T/ @@ -1214,8 +1214,8 @@ test "openat" { return error.SkipZigTest; } if (cqe_openat.res <= 0) std.debug.print("\ncqe_openat.res={}\n", .{cqe_openat.res}); - testing.expect(cqe_openat.res > 0); - testing.expectEqual(@as(u32, 0), cqe_openat.flags); + try testing.expect(cqe_openat.res > 0); + try testing.expectEqual(@as(u32, 0), cqe_openat.flags); os.close(cqe_openat.res); } @@ -1236,13 +1236,13 @@ test "close" { defer std.fs.cwd().deleteFile(path) catch {}; const sqe_close = try ring.close(0x44444444, file.handle); - testing.expectEqual(linux.IORING_OP.CLOSE, sqe_close.opcode); - testing.expectEqual(file.handle, sqe_close.fd); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(linux.IORING_OP.CLOSE, sqe_close.opcode); + try testing.expectEqual(file.handle, sqe_close.fd); + try testing.expectEqual(@as(u32, 1), try ring.submit()); const cqe_close = try ring.copy_cqe(); if (cqe_close.res == -linux.EINVAL) return error.SkipZigTest; - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x44444444, .res = 0, .flags = 0, @@ -1273,12 +1273,12 @@ test "accept/connect/send/recv" { var accept_addr: os.sockaddr = undefined; var accept_addr_len: os.socklen_t = @sizeOf(@TypeOf(accept_addr)); const accept = try ring.accept(0xaaaaaaaa, server, &accept_addr, &accept_addr_len, 0); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(@as(u32, 1), try ring.submit()); const client = try os.socket(address.any.family, os.SOCK_STREAM | os.SOCK_CLOEXEC, 0); defer os.close(client); const connect = try ring.connect(0xcccccccc, client, &address.any, address.getOsSockLen()); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(@as(u32, 1), try ring.submit()); var cqe_accept = try ring.copy_cqe(); if (cqe_accept.res == -linux.EINVAL) return error.SkipZigTest; @@ -1293,11 +1293,11 @@ test "accept/connect/send/recv" { cqe_connect = a; } - testing.expectEqual(@as(u64, 0xaaaaaaaa), cqe_accept.user_data); + try testing.expectEqual(@as(u64, 0xaaaaaaaa), cqe_accept.user_data); if (cqe_accept.res <= 0) std.debug.print("\ncqe_accept.res={}\n", .{cqe_accept.res}); - testing.expect(cqe_accept.res > 0); - testing.expectEqual(@as(u32, 0), cqe_accept.flags); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expect(cqe_accept.res > 0); + try testing.expectEqual(@as(u32, 0), cqe_accept.flags); + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xcccccccc, .res = 0, .flags = 0, @@ -1306,11 +1306,11 @@ test "accept/connect/send/recv" { const send = try ring.send(0xeeeeeeee, client, buffer_send[0..], 0); send.flags |= linux.IOSQE_IO_LINK; const recv = try ring.recv(0xffffffff, cqe_accept.res, buffer_recv[0..], 0); - testing.expectEqual(@as(u32, 2), try ring.submit()); + try testing.expectEqual(@as(u32, 2), try ring.submit()); const cqe_send = try ring.copy_cqe(); if (cqe_send.res == -linux.EINVAL) return error.SkipZigTest; - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xeeeeeeee, .res = buffer_send.len, .flags = 0, @@ -1318,13 +1318,13 @@ test "accept/connect/send/recv" { const cqe_recv = try ring.copy_cqe(); if (cqe_recv.res == -linux.EINVAL) return error.SkipZigTest; - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xffffffff, .res = buffer_recv.len, .flags = 0, }, cqe_recv); - testing.expectEqualSlices(u8, buffer_send[0..buffer_recv.len], buffer_recv[0..]); + try testing.expectEqualSlices(u8, buffer_send[0..buffer_recv.len], buffer_recv[0..]); } test "timeout (after a relative time)" { @@ -1343,12 +1343,12 @@ test "timeout (after a relative time)" { const started = std.time.milliTimestamp(); const sqe = try ring.timeout(0x55555555, &ts, 0, 0); - testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe.opcode); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe.opcode); + try testing.expectEqual(@as(u32, 1), try ring.submit()); const cqe = try ring.copy_cqe(); const stopped = std.time.milliTimestamp(); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x55555555, .res = -linux.ETIME, .flags = 0, @@ -1371,20 +1371,20 @@ test "timeout (after a number of completions)" { const ts = os.__kernel_timespec{ .tv_sec = 3, .tv_nsec = 0 }; const count_completions: u64 = 1; const sqe_timeout = try ring.timeout(0x66666666, &ts, count_completions, 0); - testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe_timeout.opcode); - testing.expectEqual(count_completions, sqe_timeout.off); + try testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe_timeout.opcode); + try testing.expectEqual(count_completions, sqe_timeout.off); _ = try ring.nop(0x77777777); - testing.expectEqual(@as(u32, 2), try ring.submit()); + try testing.expectEqual(@as(u32, 2), try ring.submit()); const cqe_nop = try ring.copy_cqe(); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x77777777, .res = 0, .flags = 0, }, cqe_nop); const cqe_timeout = try ring.copy_cqe(); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x66666666, .res = 0, .flags = 0, @@ -1403,15 +1403,15 @@ test "timeout_remove" { const ts = os.__kernel_timespec{ .tv_sec = 3, .tv_nsec = 0 }; const sqe_timeout = try ring.timeout(0x88888888, &ts, 0, 0); - testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe_timeout.opcode); - testing.expectEqual(@as(u64, 0x88888888), sqe_timeout.user_data); + try testing.expectEqual(linux.IORING_OP.TIMEOUT, sqe_timeout.opcode); + try testing.expectEqual(@as(u64, 0x88888888), sqe_timeout.user_data); const sqe_timeout_remove = try ring.timeout_remove(0x99999999, 0x88888888, 0); - testing.expectEqual(linux.IORING_OP.TIMEOUT_REMOVE, sqe_timeout_remove.opcode); - testing.expectEqual(@as(u64, 0x88888888), sqe_timeout_remove.addr); - testing.expectEqual(@as(u64, 0x99999999), sqe_timeout_remove.user_data); + try testing.expectEqual(linux.IORING_OP.TIMEOUT_REMOVE, sqe_timeout_remove.opcode); + try testing.expectEqual(@as(u64, 0x88888888), sqe_timeout_remove.addr); + try testing.expectEqual(@as(u64, 0x99999999), sqe_timeout_remove.user_data); - testing.expectEqual(@as(u32, 2), try ring.submit()); + try testing.expectEqual(@as(u32, 2), try ring.submit()); const cqe_timeout = try ring.copy_cqe(); // IORING_OP_TIMEOUT_REMOVE is not supported by this kernel version: @@ -1424,14 +1424,14 @@ test "timeout_remove" { { return error.SkipZigTest; } - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x88888888, .res = -linux.ECANCELED, .flags = 0, }, cqe_timeout); const cqe_timeout_remove = try ring.copy_cqe(); - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x99999999, .res = 0, .flags = 0, @@ -1453,13 +1453,13 @@ test "fallocate" { defer file.close(); defer std.fs.cwd().deleteFile(path) catch {}; - testing.expectEqual(@as(u64, 0), (try file.stat()).size); + try testing.expectEqual(@as(u64, 0), (try file.stat()).size); const len: u64 = 65536; const sqe = try ring.fallocate(0xaaaaaaaa, file.handle, 0, 0, len); - testing.expectEqual(linux.IORING_OP.FALLOCATE, sqe.opcode); - testing.expectEqual(file.handle, sqe.fd); - testing.expectEqual(@as(u32, 1), try ring.submit()); + try testing.expectEqual(linux.IORING_OP.FALLOCATE, sqe.opcode); + try testing.expectEqual(file.handle, sqe.fd); + try testing.expectEqual(@as(u32, 1), try ring.submit()); const cqe = try ring.copy_cqe(); switch (-cqe.res) { @@ -1473,11 +1473,11 @@ test "fallocate" { linux.EOPNOTSUPP => return error.SkipZigTest, else => |errno| std.debug.panic("unhandled errno: {}", .{errno}), } - testing.expectEqual(linux.io_uring_cqe{ + try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xaaaaaaaa, .res = 0, .flags = 0, }, cqe); - testing.expectEqual(len, (try file.stat()).size); + try testing.expectEqual(len, (try file.stat()).size); } diff --git a/lib/std/os/linux/test.zig b/lib/std/os/linux/test.zig index 039678e405..5a37713247 100644 --- a/lib/std/os/linux/test.zig +++ b/lib/std/os/linux/test.zig @@ -18,7 +18,7 @@ test "fallocate" { defer file.close(); defer fs.cwd().deleteFile(path) catch {}; - expect((try file.stat()).size == 0); + try expect((try file.stat()).size == 0); const len: u64 = 65536; switch (linux.getErrno(linux.fallocate(file.handle, 0, 0, len))) { @@ -28,20 +28,20 @@ test "fallocate" { else => |errno| std.debug.panic("unhandled errno: {}", .{errno}), } - expect((try file.stat()).size == len); + try expect((try file.stat()).size == len); } test "getpid" { - expect(linux.getpid() != 0); + try expect(linux.getpid() != 0); } test "timer" { const epoll_fd = linux.epoll_create(); var err: usize = linux.getErrno(epoll_fd); - expect(err == 0); + try expect(err == 0); const timer_fd = linux.timerfd_create(linux.CLOCK_MONOTONIC, 0); - expect(linux.getErrno(timer_fd) == 0); + try expect(linux.getErrno(timer_fd) == 0); const time_interval = linux.timespec{ .tv_sec = 0, @@ -54,7 +54,7 @@ test "timer" { }; err = linux.timerfd_settime(@intCast(i32, timer_fd), 0, &new_time, null); - expect(err == 0); + try expect(err == 0); var event = linux.epoll_event{ .events = linux.EPOLLIN | linux.EPOLLOUT | linux.EPOLLET, @@ -62,7 +62,7 @@ test "timer" { }; err = linux.epoll_ctl(@intCast(i32, epoll_fd), linux.EPOLL_CTL_ADD, @intCast(i32, timer_fd), &event); - expect(err == 0); + try expect(err == 0); const events_one: linux.epoll_event = undefined; var events = [_]linux.epoll_event{events_one} ** 8; @@ -93,18 +93,18 @@ test "statx" { else => unreachable, } - expect(stat_buf.mode == statx_buf.mode); - expect(@bitCast(u32, stat_buf.uid) == statx_buf.uid); - expect(@bitCast(u32, stat_buf.gid) == statx_buf.gid); - expect(@bitCast(u64, @as(i64, stat_buf.size)) == statx_buf.size); - expect(@bitCast(u64, @as(i64, stat_buf.blksize)) == statx_buf.blksize); - expect(@bitCast(u64, @as(i64, stat_buf.blocks)) == statx_buf.blocks); + try expect(stat_buf.mode == statx_buf.mode); + try expect(@bitCast(u32, stat_buf.uid) == statx_buf.uid); + try expect(@bitCast(u32, stat_buf.gid) == statx_buf.gid); + try expect(@bitCast(u64, @as(i64, stat_buf.size)) == statx_buf.size); + try expect(@bitCast(u64, @as(i64, stat_buf.blksize)) == statx_buf.blksize); + try expect(@bitCast(u64, @as(i64, stat_buf.blocks)) == statx_buf.blocks); } test "user and group ids" { if (builtin.link_libc) return error.SkipZigTest; - expectEqual(linux.getauxval(elf.AT_UID), linux.getuid()); - expectEqual(linux.getauxval(elf.AT_GID), linux.getgid()); - expectEqual(linux.getauxval(elf.AT_EUID), linux.geteuid()); - expectEqual(linux.getauxval(elf.AT_EGID), linux.getegid()); + try expectEqual(linux.getauxval(elf.AT_UID), linux.getuid()); + try expectEqual(linux.getauxval(elf.AT_GID), linux.getgid()); + try expectEqual(linux.getauxval(elf.AT_EUID), linux.geteuid()); + try expectEqual(linux.getauxval(elf.AT_EGID), linux.getegid()); } diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig index f0f0a7c988..dfdb7dc363 100644 --- a/lib/std/os/test.zig +++ b/lib/std/os/test.zig @@ -37,7 +37,7 @@ test "chdir smoke test" { try os.chdir(old_cwd); var new_cwd_buf: [fs.MAX_PATH_BYTES]u8 = undefined; const new_cwd = try os.getcwd(new_cwd_buf[0..]); - expect(mem.eql(u8, old_cwd, new_cwd)); + try expect(mem.eql(u8, old_cwd, new_cwd)); } { // Next, change current working directory to one level above @@ -45,7 +45,7 @@ test "chdir smoke test" { try os.chdir(parent); var new_cwd_buf: [fs.MAX_PATH_BYTES]u8 = undefined; const new_cwd = try os.getcwd(new_cwd_buf[0..]); - expect(mem.eql(u8, parent, new_cwd)); + try expect(mem.eql(u8, parent, new_cwd)); } } @@ -77,7 +77,7 @@ test "open smoke test" { // Try this again with the same flags. This op should fail with error.PathAlreadyExists. file_path = try fs.path.join(&arena.allocator, &[_][]const u8{ base_path, "some_file" }); - expectError(error.PathAlreadyExists, os.open(file_path, os.O_RDWR | os.O_CREAT | os.O_EXCL, mode)); + try expectError(error.PathAlreadyExists, os.open(file_path, os.O_RDWR | os.O_CREAT | os.O_EXCL, mode)); // Try opening without `O_EXCL` flag. file_path = try fs.path.join(&arena.allocator, &[_][]const u8{ base_path, "some_file" }); @@ -86,7 +86,7 @@ test "open smoke test" { // Try opening as a directory which should fail. file_path = try fs.path.join(&arena.allocator, &[_][]const u8{ base_path, "some_file" }); - expectError(error.NotDir, os.open(file_path, os.O_RDWR | os.O_DIRECTORY, mode)); + try expectError(error.NotDir, os.open(file_path, os.O_RDWR | os.O_DIRECTORY, mode)); // Create some directory file_path = try fs.path.join(&arena.allocator, &[_][]const u8{ base_path, "some_dir" }); @@ -99,7 +99,7 @@ test "open smoke test" { // Try opening as file which should fail. file_path = try fs.path.join(&arena.allocator, &[_][]const u8{ base_path, "some_dir" }); - expectError(error.IsDir, os.open(file_path, os.O_RDWR, mode)); + try expectError(error.IsDir, os.open(file_path, os.O_RDWR, mode)); } test "openat smoke test" { @@ -118,14 +118,14 @@ test "openat smoke test" { os.close(fd); // Try this again with the same flags. This op should fail with error.PathAlreadyExists. - expectError(error.PathAlreadyExists, os.openat(tmp.dir.fd, "some_file", os.O_RDWR | os.O_CREAT | os.O_EXCL, mode)); + try expectError(error.PathAlreadyExists, os.openat(tmp.dir.fd, "some_file", os.O_RDWR | os.O_CREAT | os.O_EXCL, mode)); // Try opening without `O_EXCL` flag. fd = try os.openat(tmp.dir.fd, "some_file", os.O_RDWR | os.O_CREAT, mode); os.close(fd); // Try opening as a directory which should fail. - expectError(error.NotDir, os.openat(tmp.dir.fd, "some_file", os.O_RDWR | os.O_DIRECTORY, mode)); + try expectError(error.NotDir, os.openat(tmp.dir.fd, "some_file", os.O_RDWR | os.O_DIRECTORY, mode)); // Create some directory try os.mkdirat(tmp.dir.fd, "some_dir", mode); @@ -135,7 +135,7 @@ test "openat smoke test" { os.close(fd); // Try opening as file which should fail. - expectError(error.IsDir, os.openat(tmp.dir.fd, "some_dir", os.O_RDWR, mode)); + try expectError(error.IsDir, os.openat(tmp.dir.fd, "some_dir", os.O_RDWR, mode)); } test "symlink with relative paths" { @@ -169,7 +169,7 @@ test "symlink with relative paths" { var buffer: [fs.MAX_PATH_BYTES]u8 = undefined; const given = try os.readlink("symlinked", buffer[0..]); - expect(mem.eql(u8, "file.txt", given)); + try expect(mem.eql(u8, "file.txt", given)); try cwd.deleteFile("file.txt"); try cwd.deleteFile("symlinked"); @@ -186,7 +186,7 @@ test "readlink on Windows" { fn testReadlink(target_path: []const u8, symlink_path: []const u8) !void { var buffer: [fs.MAX_PATH_BYTES]u8 = undefined; const given = try os.readlink(symlink_path, buffer[0..]); - expect(mem.eql(u8, target_path, given)); + try expect(mem.eql(u8, target_path, given)); } test "link with relative paths" { @@ -209,15 +209,15 @@ test "link with relative paths" { const estat = try os.fstat(efd.handle); const nstat = try os.fstat(nfd.handle); - testing.expectEqual(estat.ino, nstat.ino); - testing.expectEqual(@as(usize, 2), nstat.nlink); + try testing.expectEqual(estat.ino, nstat.ino); + try testing.expectEqual(@as(usize, 2), nstat.nlink); } try os.unlink("new.txt"); { const estat = try os.fstat(efd.handle); - testing.expectEqual(@as(usize, 1), estat.nlink); + try testing.expectEqual(@as(usize, 1), estat.nlink); } try cwd.deleteFile("example.txt"); @@ -244,15 +244,15 @@ test "linkat with different directories" { const estat = try os.fstat(efd.handle); const nstat = try os.fstat(nfd.handle); - testing.expectEqual(estat.ino, nstat.ino); - testing.expectEqual(@as(usize, 2), nstat.nlink); + try testing.expectEqual(estat.ino, nstat.ino); + try testing.expectEqual(@as(usize, 2), nstat.nlink); } try os.unlinkat(tmp.dir.fd, "new.txt", 0); { const estat = try os.fstat(efd.handle); - testing.expectEqual(@as(usize, 1), estat.nlink); + try testing.expectEqual(@as(usize, 1), estat.nlink); } try cwd.deleteFile("example.txt"); @@ -281,7 +281,7 @@ test "fstatat" { // now repeat but using `fstatat` instead const flags = if (builtin.os.tag == .wasi) 0x0 else os.AT_SYMLINK_NOFOLLOW; const statat = try os.fstatat(tmp.dir.fd, "file.txt", flags); - expectEqual(stat, statat); + try expectEqual(stat, statat); } test "readlinkat" { @@ -310,7 +310,7 @@ test "readlinkat" { // read the link var buffer: [fs.MAX_PATH_BYTES]u8 = undefined; const read_link = try os.readlinkat(tmp.dir.fd, "link", buffer[0..]); - expect(mem.eql(u8, "file.txt", read_link)); + try expect(mem.eql(u8, "file.txt", read_link)); } fn testThreadIdFn(thread_id: *Thread.Id) void { @@ -325,13 +325,13 @@ test "std.Thread.getCurrentId" { const thread_id = thread.handle(); thread.wait(); if (Thread.use_pthreads) { - expect(thread_current_id == thread_id); + try expect(thread_current_id == thread_id); } else if (builtin.os.tag == .windows) { - expect(Thread.getCurrentId() != thread_current_id); + try expect(Thread.getCurrentId() != thread_current_id); } else { // If the thread completes very quickly, then thread_id can be 0. See the // documentation comments for `std.Thread.handle`. - expect(thread_id == 0 or thread_current_id == thread_id); + try expect(thread_id == 0 or thread_current_id == thread_id); } } @@ -350,7 +350,7 @@ test "spawn threads" { thread3.wait(); thread4.wait(); - expect(shared_ctx == 4); + try expect(shared_ctx == 4); } fn start1(ctx: void) u8 { @@ -366,23 +366,23 @@ test "cpu count" { if (builtin.os.tag == .wasi) return error.SkipZigTest; const cpu_count = try Thread.cpuCount(); - expect(cpu_count >= 1); + try expect(cpu_count >= 1); } test "thread local storage" { if (builtin.single_threaded) return error.SkipZigTest; const thread1 = try Thread.spawn(testTls, {}); const thread2 = try Thread.spawn(testTls, {}); - testTls({}); + try testTls({}); thread1.wait(); thread2.wait(); } threadlocal var x: i32 = 1234; -fn testTls(context: void) void { - if (x != 1234) @panic("bad start value"); +fn testTls(context: void) !void { + if (x != 1234) return error.TlsBadStartValue; x += 1; - if (x != 1235) @panic("bad end value"); + if (x != 1235) return error.TlsBadEndValue; } test "getrandom" { @@ -392,7 +392,7 @@ test "getrandom" { try os.getrandom(&buf_b); // If this test fails the chance is significantly higher that there is a bug than // that two sets of 50 bytes were equal. - expect(!mem.eql(u8, &buf_a, &buf_b)); + try expect(!mem.eql(u8, &buf_a, &buf_b)); } test "getcwd" { @@ -411,7 +411,7 @@ test "sigaltstack" { // Setting a stack size less than MINSIGSTKSZ returns ENOMEM st.ss_flags = 0; st.ss_size = 1; - testing.expectError(error.SizeTooSmall, os.sigaltstack(&st, null)); + try testing.expectError(error.SizeTooSmall, os.sigaltstack(&st, null)); } // If the type is not available use void to avoid erroring out when `iter_fn` is @@ -462,7 +462,7 @@ test "dl_iterate_phdr" { var counter: usize = 0; try os.dl_iterate_phdr(&counter, IterFnError, iter_fn); - expect(counter != 0); + try expect(counter != 0); } test "gethostname" { @@ -471,7 +471,7 @@ test "gethostname" { var buf: [os.HOST_NAME_MAX]u8 = undefined; const hostname = try os.gethostname(&buf); - expect(hostname.len != 0); + try expect(hostname.len != 0); } test "pipe" { @@ -479,10 +479,10 @@ test "pipe" { return error.SkipZigTest; var fds = try os.pipe(); - expect((try os.write(fds[1], "hello")) == 5); + try expect((try os.write(fds[1], "hello")) == 5); var buf: [16]u8 = undefined; - expect((try os.read(fds[0], buf[0..])) == 5); - testing.expectEqualSlices(u8, buf[0..5], "hello"); + try expect((try os.read(fds[0], buf[0..])) == 5); + try testing.expectEqualSlices(u8, buf[0..5], "hello"); os.close(fds[1]); os.close(fds[0]); } @@ -501,13 +501,13 @@ test "memfd_create" { else => |e| return e, }; defer std.os.close(fd); - expect((try std.os.write(fd, "test")) == 4); + try expect((try std.os.write(fd, "test")) == 4); try std.os.lseek_SET(fd, 0); var buf: [10]u8 = undefined; const bytes_read = try std.os.read(fd, &buf); - expect(bytes_read == 4); - expect(mem.eql(u8, buf[0..4], "test")); + try expect(bytes_read == 4); + try expect(mem.eql(u8, buf[0..4], "test")); } test "mmap" { @@ -529,14 +529,14 @@ test "mmap" { ); defer os.munmap(data); - testing.expectEqual(@as(usize, 1234), data.len); + try testing.expectEqual(@as(usize, 1234), data.len); // By definition the data returned by mmap is zero-filled - testing.expect(mem.eql(u8, data, &[_]u8{0x00} ** 1234)); + try testing.expect(mem.eql(u8, data, &[_]u8{0x00} ** 1234)); // Make sure the memory is writeable as requested std.mem.set(u8, data, 0x55); - testing.expect(mem.eql(u8, data, &[_]u8{0x55} ** 1234)); + try testing.expect(mem.eql(u8, data, &[_]u8{0x55} ** 1234)); } const test_out_file = "os_tmp_test"; @@ -576,7 +576,7 @@ test "mmap" { var i: u32 = 0; while (i < alloc_size / @sizeOf(u32)) : (i += 1) { - testing.expectEqual(i, try stream.readIntNative(u32)); + try testing.expectEqual(i, try stream.readIntNative(u32)); } } @@ -600,7 +600,7 @@ test "mmap" { var i: u32 = alloc_size / 2 / @sizeOf(u32); while (i < alloc_size / @sizeOf(u32)) : (i += 1) { - testing.expectEqual(i, try stream.readIntNative(u32)); + try testing.expectEqual(i, try stream.readIntNative(u32)); } } @@ -609,9 +609,9 @@ test "mmap" { test "getenv" { if (builtin.os.tag == .windows) { - expect(os.getenvW(&[_:0]u16{ 'B', 'O', 'G', 'U', 'S', 0x11, 0x22, 0x33, 0x44, 0x55 }) == null); + try expect(os.getenvW(&[_:0]u16{ 'B', 'O', 'G', 'U', 'S', 0x11, 0x22, 0x33, 0x44, 0x55 }) == null); } else { - expect(os.getenvZ("BOGUSDOESNOTEXISTENVVAR") == null); + try expect(os.getenvZ("BOGUSDOESNOTEXISTENVVAR") == null); } } @@ -633,17 +633,17 @@ test "fcntl" { // Note: The test assumes createFile opens the file with O_CLOEXEC { const flags = try os.fcntl(file.handle, os.F_GETFD, 0); - expect((flags & os.FD_CLOEXEC) != 0); + try expect((flags & os.FD_CLOEXEC) != 0); } { _ = try os.fcntl(file.handle, os.F_SETFD, 0); const flags = try os.fcntl(file.handle, os.F_GETFD, 0); - expect((flags & os.FD_CLOEXEC) == 0); + try expect((flags & os.FD_CLOEXEC) == 0); } { _ = try os.fcntl(file.handle, os.F_SETFD, os.FD_CLOEXEC); const flags = try os.fcntl(file.handle, os.F_GETFD, 0); - expect((flags & os.FD_CLOEXEC) != 0); + try expect((flags & os.FD_CLOEXEC) != 0); } } @@ -748,12 +748,12 @@ test "sigaction" { os.sigaction(os.SIGUSR1, &sa, null); // Check that we can read it back correctly. os.sigaction(os.SIGUSR1, null, &old_sa); - testing.expectEqual(S.handler, old_sa.handler.sigaction.?); - testing.expect((old_sa.flags & os.SA_SIGINFO) != 0); + try testing.expectEqual(S.handler, old_sa.handler.sigaction.?); + try testing.expect((old_sa.flags & os.SA_SIGINFO) != 0); // Invoke the handler. try os.raise(os.SIGUSR1); - testing.expect(signal_test_failed == false); + try testing.expect(signal_test_failed == false); // Check if the handler has been correctly reset to SIG_DFL os.sigaction(os.SIGUSR1, null, &old_sa); - testing.expectEqual(os.SIG_DFL, old_sa.handler.sigaction); + try testing.expectEqual(os.SIG_DFL, old_sa.handler.sigaction); } diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig index 1791fec956..86d1012319 100644 --- a/lib/std/os/windows.zig +++ b/lib/std/os/windows.zig @@ -997,7 +997,7 @@ test "QueryObjectName" { var result_path = try QueryObjectName(handle, &out_buffer); const required_len_in_u16 = result_path.len + @divExact(@ptrToInt(result_path.ptr) - @ptrToInt(&out_buffer), 2) + 1; //insufficient size - std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1])); + try std.testing.expectError(error.NameTooLong, QueryObjectName(handle, out_buffer[0 .. required_len_in_u16 - 1])); //exactly-sufficient size _ = try QueryObjectName(handle, out_buffer[0..required_len_in_u16]); } @@ -1155,8 +1155,8 @@ test "GetFinalPathNameByHandle" { const required_len_in_u16 = nt_path.len + @divExact(@ptrToInt(nt_path.ptr) - @ptrToInt(&buffer), 2) + 1; //check with insufficient size - std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1])); - std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1])); + try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0 .. required_len_in_u16 - 1])); + try std.testing.expectError(error.NameTooLong, GetFinalPathNameByHandle(handle, .{ .volume_name = .Dos }, buffer[0 .. required_len_in_u16 - 1])); //check with exactly-sufficient size _ = try GetFinalPathNameByHandle(handle, .{ .volume_name = .Nt }, buffer[0..required_len_in_u16]); diff --git a/lib/std/packed_int_array.zig b/lib/std/packed_int_array.zig index c53d6f0505..830fe29d5c 100644 --- a/lib/std/packed_int_array.zig +++ b/lib/std/packed_int_array.zig @@ -353,7 +353,7 @@ test "PackedIntArray" { const PackedArray = PackedIntArray(I, int_count); const expected_bytes = ((bits * int_count) + 7) / 8; - testing.expect(@sizeOf(PackedArray) == expected_bytes); + try testing.expect(@sizeOf(PackedArray) == expected_bytes); var data = @as(PackedArray, undefined); @@ -370,7 +370,7 @@ test "PackedIntArray" { count = 0; while (i < data.len()) : (i += 1) { const val = data.get(i); - testing.expect(val == count); + try testing.expect(val == count); if (bits > 0) count +%= 1; } } @@ -427,7 +427,7 @@ test "PackedIntSlice" { count = 0; while (i < data.len()) : (i += 1) { const val = data.get(i); - testing.expect(val == count); + try testing.expect(val == count); if (bits > 0) count +%= 1; } } @@ -454,48 +454,48 @@ test "PackedIntSlice of PackedInt(Array/Slice)" { //slice of array var packed_slice = packed_array.slice(2, 5); - testing.expect(packed_slice.len() == 3); + try testing.expect(packed_slice.len() == 3); const ps_bit_count = (bits * packed_slice.len()) + packed_slice.bit_offset; const ps_expected_bytes = (ps_bit_count + 7) / 8; - testing.expect(packed_slice.bytes.len == ps_expected_bytes); - testing.expect(packed_slice.get(0) == 2 % limit); - testing.expect(packed_slice.get(1) == 3 % limit); - testing.expect(packed_slice.get(2) == 4 % limit); + try testing.expect(packed_slice.bytes.len == ps_expected_bytes); + try testing.expect(packed_slice.get(0) == 2 % limit); + try testing.expect(packed_slice.get(1) == 3 % limit); + try testing.expect(packed_slice.get(2) == 4 % limit); packed_slice.set(1, 7 % limit); - testing.expect(packed_slice.get(1) == 7 % limit); + try testing.expect(packed_slice.get(1) == 7 % limit); //write through slice - testing.expect(packed_array.get(3) == 7 % limit); + try testing.expect(packed_array.get(3) == 7 % limit); //slice of a slice const packed_slice_two = packed_slice.slice(0, 3); - testing.expect(packed_slice_two.len() == 3); + try testing.expect(packed_slice_two.len() == 3); const ps2_bit_count = (bits * packed_slice_two.len()) + packed_slice_two.bit_offset; const ps2_expected_bytes = (ps2_bit_count + 7) / 8; - testing.expect(packed_slice_two.bytes.len == ps2_expected_bytes); - testing.expect(packed_slice_two.get(1) == 7 % limit); - testing.expect(packed_slice_two.get(2) == 4 % limit); + try testing.expect(packed_slice_two.bytes.len == ps2_expected_bytes); + try testing.expect(packed_slice_two.get(1) == 7 % limit); + try testing.expect(packed_slice_two.get(2) == 4 % limit); //size one case const packed_slice_three = packed_slice_two.slice(1, 2); - testing.expect(packed_slice_three.len() == 1); + try testing.expect(packed_slice_three.len() == 1); const ps3_bit_count = (bits * packed_slice_three.len()) + packed_slice_three.bit_offset; const ps3_expected_bytes = (ps3_bit_count + 7) / 8; - testing.expect(packed_slice_three.bytes.len == ps3_expected_bytes); - testing.expect(packed_slice_three.get(0) == 7 % limit); + try testing.expect(packed_slice_three.bytes.len == ps3_expected_bytes); + try testing.expect(packed_slice_three.get(0) == 7 % limit); //empty slice case const packed_slice_empty = packed_slice.slice(0, 0); - testing.expect(packed_slice_empty.len() == 0); - testing.expect(packed_slice_empty.bytes.len == 0); + try testing.expect(packed_slice_empty.len() == 0); + try testing.expect(packed_slice_empty.bytes.len == 0); //slicing at byte boundaries const packed_slice_edge = packed_array.slice(8, 16); - testing.expect(packed_slice_edge.len() == 8); + try testing.expect(packed_slice_edge.len() == 8); const pse_bit_count = (bits * packed_slice_edge.len()) + packed_slice_edge.bit_offset; const pse_expected_bytes = (pse_bit_count + 7) / 8; - testing.expect(packed_slice_edge.bytes.len == pse_expected_bytes); - testing.expect(packed_slice_edge.bit_offset == 0); + try testing.expect(packed_slice_edge.bytes.len == pse_expected_bytes); + try testing.expect(packed_slice_edge.bit_offset == 0); } } @@ -543,7 +543,7 @@ test "PackedInt(Array/Slice) sliceCast" { .Big => 0b01, .Little => 0b10, }; - testing.expect(packed_slice_cast_2.get(i) == val); + try testing.expect(packed_slice_cast_2.get(i) == val); } i = 0; while (i < packed_slice_cast_4.len()) : (i += 1) { @@ -551,12 +551,12 @@ test "PackedInt(Array/Slice) sliceCast" { .Big => 0b0101, .Little => 0b1010, }; - testing.expect(packed_slice_cast_4.get(i) == val); + try testing.expect(packed_slice_cast_4.get(i) == val); } i = 0; while (i < packed_slice_cast_9.len()) : (i += 1) { const val = 0b010101010; - testing.expect(packed_slice_cast_9.get(i) == val); + try testing.expect(packed_slice_cast_9.get(i) == val); packed_slice_cast_9.set(i, 0b111000111); } i = 0; @@ -565,7 +565,7 @@ test "PackedInt(Array/Slice) sliceCast" { .Big => if (i % 2 == 0) @as(u3, 0b111) else @as(u3, 0b000), .Little => if (i % 2 == 0) @as(u3, 0b111) else @as(u3, 0b000), }; - testing.expect(packed_slice_cast_3.get(i) == val); + try testing.expect(packed_slice_cast_3.get(i) == val); } } @@ -575,58 +575,58 @@ test "PackedInt(Array/Slice)Endian" { { const PackedArrayBe = PackedIntArrayEndian(u4, .Big, 8); var packed_array_be = PackedArrayBe.init([_]u4{ 0, 1, 2, 3, 4, 5, 6, 7 }); - testing.expect(packed_array_be.bytes[0] == 0b00000001); - testing.expect(packed_array_be.bytes[1] == 0b00100011); + try testing.expect(packed_array_be.bytes[0] == 0b00000001); + try testing.expect(packed_array_be.bytes[1] == 0b00100011); var i = @as(usize, 0); while (i < packed_array_be.len()) : (i += 1) { - testing.expect(packed_array_be.get(i) == i); + try testing.expect(packed_array_be.get(i) == i); } var packed_slice_le = packed_array_be.sliceCastEndian(u4, .Little); i = 0; while (i < packed_slice_le.len()) : (i += 1) { const val = if (i % 2 == 0) i + 1 else i - 1; - testing.expect(packed_slice_le.get(i) == val); + try testing.expect(packed_slice_le.get(i) == val); } var packed_slice_le_shift = packed_array_be.slice(1, 5).sliceCastEndian(u4, .Little); i = 0; while (i < packed_slice_le_shift.len()) : (i += 1) { const val = if (i % 2 == 0) i else i + 2; - testing.expect(packed_slice_le_shift.get(i) == val); + try testing.expect(packed_slice_le_shift.get(i) == val); } } { const PackedArrayBe = PackedIntArrayEndian(u11, .Big, 8); var packed_array_be = PackedArrayBe.init([_]u11{ 0, 1, 2, 3, 4, 5, 6, 7 }); - testing.expect(packed_array_be.bytes[0] == 0b00000000); - testing.expect(packed_array_be.bytes[1] == 0b00000000); - testing.expect(packed_array_be.bytes[2] == 0b00000100); - testing.expect(packed_array_be.bytes[3] == 0b00000001); - testing.expect(packed_array_be.bytes[4] == 0b00000000); + try testing.expect(packed_array_be.bytes[0] == 0b00000000); + try testing.expect(packed_array_be.bytes[1] == 0b00000000); + try testing.expect(packed_array_be.bytes[2] == 0b00000100); + try testing.expect(packed_array_be.bytes[3] == 0b00000001); + try testing.expect(packed_array_be.bytes[4] == 0b00000000); var i = @as(usize, 0); while (i < packed_array_be.len()) : (i += 1) { - testing.expect(packed_array_be.get(i) == i); + try testing.expect(packed_array_be.get(i) == i); } var packed_slice_le = packed_array_be.sliceCastEndian(u11, .Little); - testing.expect(packed_slice_le.get(0) == 0b00000000000); - testing.expect(packed_slice_le.get(1) == 0b00010000000); - testing.expect(packed_slice_le.get(2) == 0b00000000100); - testing.expect(packed_slice_le.get(3) == 0b00000000000); - testing.expect(packed_slice_le.get(4) == 0b00010000011); - testing.expect(packed_slice_le.get(5) == 0b00000000010); - testing.expect(packed_slice_le.get(6) == 0b10000010000); - testing.expect(packed_slice_le.get(7) == 0b00000111001); + try testing.expect(packed_slice_le.get(0) == 0b00000000000); + try testing.expect(packed_slice_le.get(1) == 0b00010000000); + try testing.expect(packed_slice_le.get(2) == 0b00000000100); + try testing.expect(packed_slice_le.get(3) == 0b00000000000); + try testing.expect(packed_slice_le.get(4) == 0b00010000011); + try testing.expect(packed_slice_le.get(5) == 0b00000000010); + try testing.expect(packed_slice_le.get(6) == 0b10000010000); + try testing.expect(packed_slice_le.get(7) == 0b00000111001); var packed_slice_le_shift = packed_array_be.slice(1, 5).sliceCastEndian(u11, .Little); - testing.expect(packed_slice_le_shift.get(0) == 0b00010000000); - testing.expect(packed_slice_le_shift.get(1) == 0b00000000100); - testing.expect(packed_slice_le_shift.get(2) == 0b00000000000); - testing.expect(packed_slice_le_shift.get(3) == 0b00010000011); + try testing.expect(packed_slice_le_shift.get(0) == 0b00010000000); + try testing.expect(packed_slice_le_shift.get(1) == 0b00000000100); + try testing.expect(packed_slice_le_shift.get(2) == 0b00000000000); + try testing.expect(packed_slice_le_shift.get(3) == 0b00010000011); } } diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 6894dcc997..f0f8d7f6f7 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -482,12 +482,12 @@ test "std.PriorityDequeue: add and remove min" { try queue.add(25); try queue.add(13); - expectEqual(@as(u32, 7), queue.removeMin()); - expectEqual(@as(u32, 12), queue.removeMin()); - expectEqual(@as(u32, 13), queue.removeMin()); - expectEqual(@as(u32, 23), queue.removeMin()); - expectEqual(@as(u32, 25), queue.removeMin()); - expectEqual(@as(u32, 54), queue.removeMin()); + try expectEqual(@as(u32, 7), queue.removeMin()); + try expectEqual(@as(u32, 12), queue.removeMin()); + try expectEqual(@as(u32, 13), queue.removeMin()); + try expectEqual(@as(u32, 23), queue.removeMin()); + try expectEqual(@as(u32, 25), queue.removeMin()); + try expectEqual(@as(u32, 54), queue.removeMin()); } test "std.PriorityDequeue: add and remove min structs" { @@ -508,12 +508,12 @@ test "std.PriorityDequeue: add and remove min structs" { try queue.add(.{ .size = 25 }); try queue.add(.{ .size = 13 }); - expectEqual(@as(u32, 7), queue.removeMin().size); - expectEqual(@as(u32, 12), queue.removeMin().size); - expectEqual(@as(u32, 13), queue.removeMin().size); - expectEqual(@as(u32, 23), queue.removeMin().size); - expectEqual(@as(u32, 25), queue.removeMin().size); - expectEqual(@as(u32, 54), queue.removeMin().size); + try expectEqual(@as(u32, 7), queue.removeMin().size); + try expectEqual(@as(u32, 12), queue.removeMin().size); + try expectEqual(@as(u32, 13), queue.removeMin().size); + try expectEqual(@as(u32, 23), queue.removeMin().size); + try expectEqual(@as(u32, 25), queue.removeMin().size); + try expectEqual(@as(u32, 54), queue.removeMin().size); } test "std.PriorityDequeue: add and remove max" { @@ -527,12 +527,12 @@ test "std.PriorityDequeue: add and remove max" { try queue.add(25); try queue.add(13); - expectEqual(@as(u32, 54), queue.removeMax()); - expectEqual(@as(u32, 25), queue.removeMax()); - expectEqual(@as(u32, 23), queue.removeMax()); - expectEqual(@as(u32, 13), queue.removeMax()); - expectEqual(@as(u32, 12), queue.removeMax()); - expectEqual(@as(u32, 7), queue.removeMax()); + try expectEqual(@as(u32, 54), queue.removeMax()); + try expectEqual(@as(u32, 25), queue.removeMax()); + try expectEqual(@as(u32, 23), queue.removeMax()); + try expectEqual(@as(u32, 13), queue.removeMax()); + try expectEqual(@as(u32, 12), queue.removeMax()); + try expectEqual(@as(u32, 7), queue.removeMax()); } test "std.PriorityDequeue: add and remove same min" { @@ -546,12 +546,12 @@ test "std.PriorityDequeue: add and remove same min" { try queue.add(1); try queue.add(1); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 2), queue.removeMin()); - expectEqual(@as(u32, 2), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 2), queue.removeMin()); + try expectEqual(@as(u32, 2), queue.removeMin()); } test "std.PriorityDequeue: add and remove same max" { @@ -565,20 +565,20 @@ test "std.PriorityDequeue: add and remove same max" { try queue.add(1); try queue.add(1); - expectEqual(@as(u32, 2), queue.removeMax()); - expectEqual(@as(u32, 2), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); } test "std.PriorityDequeue: removeOrNull empty" { var queue = PDQ.init(testing.allocator, lessThanComparison); defer queue.deinit(); - expect(queue.removeMinOrNull() == null); - expect(queue.removeMaxOrNull() == null); + try expect(queue.removeMinOrNull() == null); + try expect(queue.removeMaxOrNull() == null); } test "std.PriorityDequeue: edge case 3 elements" { @@ -589,9 +589,9 @@ test "std.PriorityDequeue: edge case 3 elements" { try queue.add(3); try queue.add(2); - expectEqual(@as(u32, 2), queue.removeMin()); - expectEqual(@as(u32, 3), queue.removeMin()); - expectEqual(@as(u32, 9), queue.removeMin()); + try expectEqual(@as(u32, 2), queue.removeMin()); + try expectEqual(@as(u32, 3), queue.removeMin()); + try expectEqual(@as(u32, 9), queue.removeMin()); } test "std.PriorityDequeue: edge case 3 elements max" { @@ -602,37 +602,37 @@ test "std.PriorityDequeue: edge case 3 elements max" { try queue.add(3); try queue.add(2); - expectEqual(@as(u32, 9), queue.removeMax()); - expectEqual(@as(u32, 3), queue.removeMax()); - expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 9), queue.removeMax()); + try expectEqual(@as(u32, 3), queue.removeMax()); + try expectEqual(@as(u32, 2), queue.removeMax()); } test "std.PriorityDequeue: peekMin" { var queue = PDQ.init(testing.allocator, lessThanComparison); defer queue.deinit(); - expect(queue.peekMin() == null); + try expect(queue.peekMin() == null); try queue.add(9); try queue.add(3); try queue.add(2); - expect(queue.peekMin().? == 2); - expect(queue.peekMin().? == 2); + try expect(queue.peekMin().? == 2); + try expect(queue.peekMin().? == 2); } test "std.PriorityDequeue: peekMax" { var queue = PDQ.init(testing.allocator, lessThanComparison); defer queue.deinit(); - expect(queue.peekMin() == null); + try expect(queue.peekMin() == null); try queue.add(9); try queue.add(3); try queue.add(2); - expect(queue.peekMax().? == 9); - expect(queue.peekMax().? == 9); + try expect(queue.peekMax().? == 9); + try expect(queue.peekMax().? == 9); } test "std.PriorityDequeue: sift up with odd indices" { @@ -645,7 +645,7 @@ test "std.PriorityDequeue: sift up with odd indices" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.removeMin()); + try expectEqual(e, queue.removeMin()); } } @@ -659,7 +659,7 @@ test "std.PriorityDequeue: sift up with odd indices" { const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; for (sorted_items) |e| { - expectEqual(e, queue.removeMax()); + try expectEqual(e, queue.removeMax()); } } @@ -671,7 +671,7 @@ test "std.PriorityDequeue: addSlice min" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.removeMin()); + try expectEqual(e, queue.removeMin()); } } @@ -683,7 +683,7 @@ test "std.PriorityDequeue: addSlice max" { const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; for (sorted_items) |e| { - expectEqual(e, queue.removeMax()); + try expectEqual(e, queue.removeMax()); } } @@ -692,8 +692,8 @@ test "std.PriorityDequeue: fromOwnedSlice trivial case 0" { const queue_items = try testing.allocator.dupe(u32, &items); var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]); defer queue.deinit(); - expectEqual(@as(usize, 0), queue.len); - expect(queue.removeMinOrNull() == null); + try expectEqual(@as(usize, 0), queue.len); + try expect(queue.removeMinOrNull() == null); } test "std.PriorityDequeue: fromOwnedSlice trivial case 1" { @@ -702,9 +702,9 @@ test "std.PriorityDequeue: fromOwnedSlice trivial case 1" { var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]); defer queue.deinit(); - expectEqual(@as(usize, 1), queue.len); - expectEqual(items[0], queue.removeMin()); - expect(queue.removeMinOrNull() == null); + try expectEqual(@as(usize, 1), queue.len); + try expectEqual(items[0], queue.removeMin()); + try expect(queue.removeMinOrNull() == null); } test "std.PriorityDequeue: fromOwnedSlice" { @@ -715,7 +715,7 @@ test "std.PriorityDequeue: fromOwnedSlice" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.removeMin()); + try expectEqual(e, queue.removeMin()); } } @@ -729,9 +729,9 @@ test "std.PriorityDequeue: update min queue" { try queue.update(55, 5); try queue.update(44, 4); try queue.update(11, 1); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 4), queue.removeMin()); - expectEqual(@as(u32, 5), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 4), queue.removeMin()); + try expectEqual(@as(u32, 5), queue.removeMin()); } test "std.PriorityDequeue: update same min queue" { @@ -744,10 +744,10 @@ test "std.PriorityDequeue: update same min queue" { try queue.add(2); try queue.update(1, 5); try queue.update(2, 4); - expectEqual(@as(u32, 1), queue.removeMin()); - expectEqual(@as(u32, 2), queue.removeMin()); - expectEqual(@as(u32, 4), queue.removeMin()); - expectEqual(@as(u32, 5), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.removeMin()); + try expectEqual(@as(u32, 2), queue.removeMin()); + try expectEqual(@as(u32, 4), queue.removeMin()); + try expectEqual(@as(u32, 5), queue.removeMin()); } test "std.PriorityDequeue: update max queue" { @@ -761,9 +761,9 @@ test "std.PriorityDequeue: update max queue" { try queue.update(44, 1); try queue.update(11, 4); - expectEqual(@as(u32, 5), queue.removeMax()); - expectEqual(@as(u32, 4), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 5), queue.removeMax()); + try expectEqual(@as(u32, 4), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); } test "std.PriorityDequeue: update same max queue" { @@ -776,10 +776,10 @@ test "std.PriorityDequeue: update same max queue" { try queue.add(2); try queue.update(1, 5); try queue.update(2, 4); - expectEqual(@as(u32, 5), queue.removeMax()); - expectEqual(@as(u32, 4), queue.removeMax()); - expectEqual(@as(u32, 2), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 5), queue.removeMax()); + try expectEqual(@as(u32, 4), queue.removeMax()); + try expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); } test "std.PriorityDequeue: iterator" { @@ -801,7 +801,7 @@ test "std.PriorityDequeue: iterator" { _ = map.remove(e); } - expectEqual(@as(usize, 0), map.count()); + try expectEqual(@as(usize, 0), map.count()); } test "std.PriorityDequeue: remove at index" { @@ -821,10 +821,10 @@ test "std.PriorityDequeue: remove at index" { idx += 1; } else unreachable; - expectEqual(queue.removeIndex(two_idx), 2); - expectEqual(queue.removeMin(), 1); - expectEqual(queue.removeMin(), 3); - expectEqual(queue.removeMinOrNull(), null); + try expectEqual(queue.removeIndex(two_idx), 2); + try expectEqual(queue.removeMin(), 1); + try expectEqual(queue.removeMin(), 3); + try expectEqual(queue.removeMinOrNull(), null); } test "std.PriorityDequeue: iterator while empty" { @@ -833,7 +833,7 @@ test "std.PriorityDequeue: iterator while empty" { var it = queue.iterator(); - expectEqual(it.next(), null); + try expectEqual(it.next(), null); } test "std.PriorityDequeue: shrinkRetainingCapacity and shrinkAndFree" { @@ -841,26 +841,26 @@ test "std.PriorityDequeue: shrinkRetainingCapacity and shrinkAndFree" { defer queue.deinit(); try queue.ensureCapacity(4); - expect(queue.capacity() >= 4); + try expect(queue.capacity() >= 4); try queue.add(1); try queue.add(2); try queue.add(3); - expect(queue.capacity() >= 4); - expectEqual(@as(usize, 3), queue.len); + try expect(queue.capacity() >= 4); + try expectEqual(@as(usize, 3), queue.len); queue.shrinkRetainingCapacity(3); - expect(queue.capacity() >= 4); - expectEqual(@as(usize, 3), queue.len); + try expect(queue.capacity() >= 4); + try expectEqual(@as(usize, 3), queue.len); queue.shrinkAndFree(3); - expectEqual(@as(usize, 3), queue.capacity()); - expectEqual(@as(usize, 3), queue.len); + try expectEqual(@as(usize, 3), queue.capacity()); + try expectEqual(@as(usize, 3), queue.len); - expectEqual(@as(u32, 3), queue.removeMax()); - expectEqual(@as(u32, 2), queue.removeMax()); - expectEqual(@as(u32, 1), queue.removeMax()); - expect(queue.removeMaxOrNull() == null); + try expectEqual(@as(u32, 3), queue.removeMax()); + try expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 1), queue.removeMax()); + try expect(queue.removeMaxOrNull() == null); } test "std.PriorityDequeue: fuzz testing min" { @@ -885,7 +885,7 @@ fn fuzzTestMin(rng: *std.rand.Random, comptime queue_size: usize) !void { var last_removed: ?u32 = null; while (queue.removeMinOrNull()) |next| { if (last_removed) |last| { - expect(last <= next); + try expect(last <= next); } last_removed = next; } @@ -913,7 +913,7 @@ fn fuzzTestMax(rng: *std.rand.Random, queue_size: usize) !void { var last_removed: ?u32 = null; while (queue.removeMaxOrNull()) |next| { if (last_removed) |last| { - expect(last >= next); + try expect(last >= next); } last_removed = next; } @@ -945,13 +945,13 @@ fn fuzzTestMinMax(rng: *std.rand.Random, queue_size: usize) !void { if (i % 2 == 0) { const next = queue.removeMin(); if (last_min) |last| { - expect(last <= next); + try expect(last <= next); } last_min = next; } else { const next = queue.removeMax(); if (last_max) |last| { - expect(last >= next); + try expect(last >= next); } last_max = next; } diff --git a/lib/std/priority_queue.zig b/lib/std/priority_queue.zig index 2685a7105e..621af4e97f 100644 --- a/lib/std/priority_queue.zig +++ b/lib/std/priority_queue.zig @@ -290,12 +290,12 @@ test "std.PriorityQueue: add and remove min heap" { try queue.add(23); try queue.add(25); try queue.add(13); - expectEqual(@as(u32, 7), queue.remove()); - expectEqual(@as(u32, 12), queue.remove()); - expectEqual(@as(u32, 13), queue.remove()); - expectEqual(@as(u32, 23), queue.remove()); - expectEqual(@as(u32, 25), queue.remove()); - expectEqual(@as(u32, 54), queue.remove()); + try expectEqual(@as(u32, 7), queue.remove()); + try expectEqual(@as(u32, 12), queue.remove()); + try expectEqual(@as(u32, 13), queue.remove()); + try expectEqual(@as(u32, 23), queue.remove()); + try expectEqual(@as(u32, 25), queue.remove()); + try expectEqual(@as(u32, 54), queue.remove()); } test "std.PriorityQueue: add and remove same min heap" { @@ -308,19 +308,19 @@ test "std.PriorityQueue: add and remove same min heap" { try queue.add(2); try queue.add(1); try queue.add(1); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); } test "std.PriorityQueue: removeOrNull on empty" { var queue = PQ.init(testing.allocator, lessThan); defer queue.deinit(); - expect(queue.removeOrNull() == null); + try expect(queue.removeOrNull() == null); } test "std.PriorityQueue: edge case 3 elements" { @@ -330,21 +330,21 @@ test "std.PriorityQueue: edge case 3 elements" { try queue.add(9); try queue.add(3); try queue.add(2); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 3), queue.remove()); - expectEqual(@as(u32, 9), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 3), queue.remove()); + try expectEqual(@as(u32, 9), queue.remove()); } test "std.PriorityQueue: peek" { var queue = PQ.init(testing.allocator, lessThan); defer queue.deinit(); - expect(queue.peek() == null); + try expect(queue.peek() == null); try queue.add(9); try queue.add(3); try queue.add(2); - expectEqual(@as(u32, 2), queue.peek().?); - expectEqual(@as(u32, 2), queue.peek().?); + try expectEqual(@as(u32, 2), queue.peek().?); + try expectEqual(@as(u32, 2), queue.peek().?); } test "std.PriorityQueue: sift up with odd indices" { @@ -357,7 +357,7 @@ test "std.PriorityQueue: sift up with odd indices" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.remove()); + try expectEqual(e, queue.remove()); } } @@ -369,7 +369,7 @@ test "std.PriorityQueue: addSlice" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.remove()); + try expectEqual(e, queue.remove()); } } @@ -378,8 +378,8 @@ test "std.PriorityQueue: fromOwnedSlice trivial case 0" { const queue_items = try testing.allocator.dupe(u32, &items); var queue = PQ.fromOwnedSlice(testing.allocator, lessThan, queue_items[0..]); defer queue.deinit(); - expectEqual(@as(usize, 0), queue.len); - expect(queue.removeOrNull() == null); + try expectEqual(@as(usize, 0), queue.len); + try expect(queue.removeOrNull() == null); } test "std.PriorityQueue: fromOwnedSlice trivial case 1" { @@ -388,9 +388,9 @@ test "std.PriorityQueue: fromOwnedSlice trivial case 1" { var queue = PQ.fromOwnedSlice(testing.allocator, lessThan, queue_items[0..]); defer queue.deinit(); - expectEqual(@as(usize, 1), queue.len); - expectEqual(items[0], queue.remove()); - expect(queue.removeOrNull() == null); + try expectEqual(@as(usize, 1), queue.len); + try expectEqual(items[0], queue.remove()); + try expect(queue.removeOrNull() == null); } test "std.PriorityQueue: fromOwnedSlice" { @@ -401,7 +401,7 @@ test "std.PriorityQueue: fromOwnedSlice" { const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; for (sorted_items) |e| { - expectEqual(e, queue.remove()); + try expectEqual(e, queue.remove()); } } @@ -415,12 +415,12 @@ test "std.PriorityQueue: add and remove max heap" { try queue.add(23); try queue.add(25); try queue.add(13); - expectEqual(@as(u32, 54), queue.remove()); - expectEqual(@as(u32, 25), queue.remove()); - expectEqual(@as(u32, 23), queue.remove()); - expectEqual(@as(u32, 13), queue.remove()); - expectEqual(@as(u32, 12), queue.remove()); - expectEqual(@as(u32, 7), queue.remove()); + try expectEqual(@as(u32, 54), queue.remove()); + try expectEqual(@as(u32, 25), queue.remove()); + try expectEqual(@as(u32, 23), queue.remove()); + try expectEqual(@as(u32, 13), queue.remove()); + try expectEqual(@as(u32, 12), queue.remove()); + try expectEqual(@as(u32, 7), queue.remove()); } test "std.PriorityQueue: add and remove same max heap" { @@ -433,12 +433,12 @@ test "std.PriorityQueue: add and remove same max heap" { try queue.add(2); try queue.add(1); try queue.add(1); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); } test "std.PriorityQueue: iterator" { @@ -460,7 +460,7 @@ test "std.PriorityQueue: iterator" { _ = map.remove(e); } - expectEqual(@as(usize, 0), map.count()); + try expectEqual(@as(usize, 0), map.count()); } test "std.PriorityQueue: remove at index" { @@ -480,10 +480,10 @@ test "std.PriorityQueue: remove at index" { idx += 1; } else unreachable; - expectEqual(queue.removeIndex(two_idx), 2); - expectEqual(queue.remove(), 1); - expectEqual(queue.remove(), 3); - expectEqual(queue.removeOrNull(), null); + try expectEqual(queue.removeIndex(two_idx), 2); + try expectEqual(queue.remove(), 1); + try expectEqual(queue.remove(), 3); + try expectEqual(queue.removeOrNull(), null); } test "std.PriorityQueue: iterator while empty" { @@ -492,7 +492,7 @@ test "std.PriorityQueue: iterator while empty" { var it = queue.iterator(); - expectEqual(it.next(), null); + try expectEqual(it.next(), null); } test "std.PriorityQueue: shrinkRetainingCapacity and shrinkAndFree" { @@ -500,26 +500,26 @@ test "std.PriorityQueue: shrinkRetainingCapacity and shrinkAndFree" { defer queue.deinit(); try queue.ensureCapacity(4); - expect(queue.capacity() >= 4); + try expect(queue.capacity() >= 4); try queue.add(1); try queue.add(2); try queue.add(3); - expect(queue.capacity() >= 4); - expectEqual(@as(usize, 3), queue.len); + try expect(queue.capacity() >= 4); + try expectEqual(@as(usize, 3), queue.len); queue.shrinkRetainingCapacity(3); - expect(queue.capacity() >= 4); - expectEqual(@as(usize, 3), queue.len); + try expect(queue.capacity() >= 4); + try expectEqual(@as(usize, 3), queue.len); queue.shrinkAndFree(3); - expectEqual(@as(usize, 3), queue.capacity()); - expectEqual(@as(usize, 3), queue.len); + try expectEqual(@as(usize, 3), queue.capacity()); + try expectEqual(@as(usize, 3), queue.len); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 3), queue.remove()); - expect(queue.removeOrNull() == null); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 3), queue.remove()); + try expect(queue.removeOrNull() == null); } test "std.PriorityQueue: update min heap" { @@ -532,9 +532,9 @@ test "std.PriorityQueue: update min heap" { try queue.update(55, 5); try queue.update(44, 4); try queue.update(11, 1); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 4), queue.remove()); - expectEqual(@as(u32, 5), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 4), queue.remove()); + try expectEqual(@as(u32, 5), queue.remove()); } test "std.PriorityQueue: update same min heap" { @@ -547,10 +547,10 @@ test "std.PriorityQueue: update same min heap" { try queue.add(2); try queue.update(1, 5); try queue.update(2, 4); - expectEqual(@as(u32, 1), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 4), queue.remove()); - expectEqual(@as(u32, 5), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 4), queue.remove()); + try expectEqual(@as(u32, 5), queue.remove()); } test "std.PriorityQueue: update max heap" { @@ -563,9 +563,9 @@ test "std.PriorityQueue: update max heap" { try queue.update(55, 5); try queue.update(44, 1); try queue.update(11, 4); - expectEqual(@as(u32, 5), queue.remove()); - expectEqual(@as(u32, 4), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 5), queue.remove()); + try expectEqual(@as(u32, 4), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); } test "std.PriorityQueue: update same max heap" { @@ -578,8 +578,8 @@ test "std.PriorityQueue: update same max heap" { try queue.add(2); try queue.update(1, 5); try queue.update(2, 4); - expectEqual(@as(u32, 5), queue.remove()); - expectEqual(@as(u32, 4), queue.remove()); - expectEqual(@as(u32, 2), queue.remove()); - expectEqual(@as(u32, 1), queue.remove()); + try expectEqual(@as(u32, 5), queue.remove()); + try expectEqual(@as(u32, 4), queue.remove()); + try expectEqual(@as(u32, 2), queue.remove()); + try expectEqual(@as(u32, 1), queue.remove()); } diff --git a/lib/std/process.zig b/lib/std/process.zig index 3ad73db420..8b49e84a8c 100644 --- a/lib/std/process.zig +++ b/lib/std/process.zig @@ -181,7 +181,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned test "os.getEnvVarOwned" { var ga = std.testing.allocator; - testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV")); + try testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV")); } pub const ArgIteratorPosix = struct { @@ -516,10 +516,10 @@ test "args iterator" { }; const given_suffix = std.fs.path.basename(prog_name); - testing.expect(mem.eql(u8, expected_suffix, given_suffix)); - testing.expect(it.skip()); // Skip over zig_exe_path, passed to the test runner - testing.expect(it.next(ga) == null); - testing.expect(!it.skip()); + try testing.expect(mem.eql(u8, expected_suffix, given_suffix)); + try testing.expect(it.skip()); // Skip over zig_exe_path, passed to the test runner + try testing.expect(it.next(ga) == null); + try testing.expect(!it.skip()); } /// Caller must call argsFree on result. @@ -575,14 +575,14 @@ pub fn argsFree(allocator: *mem.Allocator, args_alloc: []const [:0]u8) void { test "windows arg parsing" { const utf16Literal = std.unicode.utf8ToUtf16LeStringLiteral; - testWindowsCmdLine(utf16Literal("a b\tc d"), &[_][]const u8{ "a", "b", "c", "d" }); - testWindowsCmdLine(utf16Literal("\"abc\" d e"), &[_][]const u8{ "abc", "d", "e" }); - testWindowsCmdLine(utf16Literal("a\\\\\\b d\"e f\"g h"), &[_][]const u8{ "a\\\\\\b", "de fg", "h" }); - testWindowsCmdLine(utf16Literal("a\\\\\\\"b c d"), &[_][]const u8{ "a\\\"b", "c", "d" }); - testWindowsCmdLine(utf16Literal("a\\\\\\\\\"b c\" d e"), &[_][]const u8{ "a\\\\b c", "d", "e" }); - testWindowsCmdLine(utf16Literal("a b\tc \"d f"), &[_][]const u8{ "a", "b", "c", "d f" }); + try testWindowsCmdLine(utf16Literal("a b\tc d"), &[_][]const u8{ "a", "b", "c", "d" }); + try testWindowsCmdLine(utf16Literal("\"abc\" d e"), &[_][]const u8{ "abc", "d", "e" }); + try testWindowsCmdLine(utf16Literal("a\\\\\\b d\"e f\"g h"), &[_][]const u8{ "a\\\\\\b", "de fg", "h" }); + try testWindowsCmdLine(utf16Literal("a\\\\\\\"b c d"), &[_][]const u8{ "a\\\"b", "c", "d" }); + try testWindowsCmdLine(utf16Literal("a\\\\\\\\\"b c\" d e"), &[_][]const u8{ "a\\\\b c", "d", "e" }); + try testWindowsCmdLine(utf16Literal("a b\tc \"d f"), &[_][]const u8{ "a", "b", "c", "d f" }); - testWindowsCmdLine(utf16Literal("\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\""), &[_][]const u8{ + try testWindowsCmdLine(utf16Literal("\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\""), &[_][]const u8{ ".\\..\\zig-cache\\build", "bin\\zig.exe", ".\\..", @@ -591,14 +591,14 @@ test "windows arg parsing" { }); } -fn testWindowsCmdLine(input_cmd_line: [*]const u16, expected_args: []const []const u8) void { +fn testWindowsCmdLine(input_cmd_line: [*]const u16, expected_args: []const []const u8) !void { var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line); for (expected_args) |expected_arg| { const arg = it.next(std.testing.allocator).? catch unreachable; defer std.testing.allocator.free(arg); - testing.expectEqualStrings(expected_arg, arg); + try testing.expectEqualStrings(expected_arg, arg); } - testing.expect(it.next(std.testing.allocator) == null); + try testing.expect(it.next(std.testing.allocator) == null); } pub const UserInfo = struct { diff --git a/lib/std/rand.zig b/lib/std/rand.zig index d0d400b5b0..653015b907 100644 --- a/lib/std/rand.zig +++ b/lib/std/rand.zig @@ -319,139 +319,139 @@ const SequentialPrng = struct { }; test "Random int" { - testRandomInt(); - comptime testRandomInt(); + try testRandomInt(); + comptime try testRandomInt(); } -fn testRandomInt() void { +fn testRandomInt() !void { var r = SequentialPrng.init(); - expect(r.random.int(u0) == 0); + try expect(r.random.int(u0) == 0); r.next_value = 0; - expect(r.random.int(u1) == 0); - expect(r.random.int(u1) == 1); - expect(r.random.int(u2) == 2); - expect(r.random.int(u2) == 3); - expect(r.random.int(u2) == 0); + try expect(r.random.int(u1) == 0); + try expect(r.random.int(u1) == 1); + try expect(r.random.int(u2) == 2); + try expect(r.random.int(u2) == 3); + try expect(r.random.int(u2) == 0); r.next_value = 0xff; - expect(r.random.int(u8) == 0xff); + try expect(r.random.int(u8) == 0xff); r.next_value = 0x11; - expect(r.random.int(u8) == 0x11); + try expect(r.random.int(u8) == 0x11); r.next_value = 0xff; - expect(r.random.int(u32) == 0xffffffff); + try expect(r.random.int(u32) == 0xffffffff); r.next_value = 0x11; - expect(r.random.int(u32) == 0x11111111); + try expect(r.random.int(u32) == 0x11111111); r.next_value = 0xff; - expect(r.random.int(i32) == -1); + try expect(r.random.int(i32) == -1); r.next_value = 0x11; - expect(r.random.int(i32) == 0x11111111); + try expect(r.random.int(i32) == 0x11111111); r.next_value = 0xff; - expect(r.random.int(i8) == -1); + try expect(r.random.int(i8) == -1); r.next_value = 0x11; - expect(r.random.int(i8) == 0x11); + try expect(r.random.int(i8) == 0x11); r.next_value = 0xff; - expect(r.random.int(u33) == 0x1ffffffff); + try expect(r.random.int(u33) == 0x1ffffffff); r.next_value = 0xff; - expect(r.random.int(i1) == -1); + try expect(r.random.int(i1) == -1); r.next_value = 0xff; - expect(r.random.int(i2) == -1); + try expect(r.random.int(i2) == -1); r.next_value = 0xff; - expect(r.random.int(i33) == -1); + try expect(r.random.int(i33) == -1); } test "Random boolean" { - testRandomBoolean(); - comptime testRandomBoolean(); + try testRandomBoolean(); + comptime try testRandomBoolean(); } -fn testRandomBoolean() void { +fn testRandomBoolean() !void { var r = SequentialPrng.init(); - expect(r.random.boolean() == false); - expect(r.random.boolean() == true); - expect(r.random.boolean() == false); - expect(r.random.boolean() == true); + try expect(r.random.boolean() == false); + try expect(r.random.boolean() == true); + try expect(r.random.boolean() == false); + try expect(r.random.boolean() == true); } test "Random intLessThan" { @setEvalBranchQuota(10000); - testRandomIntLessThan(); - comptime testRandomIntLessThan(); + try testRandomIntLessThan(); + comptime try testRandomIntLessThan(); } -fn testRandomIntLessThan() void { +fn testRandomIntLessThan() !void { var r = SequentialPrng.init(); r.next_value = 0xff; - expect(r.random.uintLessThan(u8, 4) == 3); - expect(r.next_value == 0); - expect(r.random.uintLessThan(u8, 4) == 0); - expect(r.next_value == 1); + try expect(r.random.uintLessThan(u8, 4) == 3); + try expect(r.next_value == 0); + try expect(r.random.uintLessThan(u8, 4) == 0); + try expect(r.next_value == 1); r.next_value = 0; - expect(r.random.uintLessThan(u64, 32) == 0); + try expect(r.random.uintLessThan(u64, 32) == 0); // trigger the bias rejection code path r.next_value = 0; - expect(r.random.uintLessThan(u8, 3) == 0); + try expect(r.random.uintLessThan(u8, 3) == 0); // verify we incremented twice - expect(r.next_value == 2); + try expect(r.next_value == 2); r.next_value = 0xff; - expect(r.random.intRangeLessThan(u8, 0, 0x80) == 0x7f); + try expect(r.random.intRangeLessThan(u8, 0, 0x80) == 0x7f); r.next_value = 0xff; - expect(r.random.intRangeLessThan(u8, 0x7f, 0xff) == 0xfe); + try expect(r.random.intRangeLessThan(u8, 0x7f, 0xff) == 0xfe); r.next_value = 0xff; - expect(r.random.intRangeLessThan(i8, 0, 0x40) == 0x3f); + try expect(r.random.intRangeLessThan(i8, 0, 0x40) == 0x3f); r.next_value = 0xff; - expect(r.random.intRangeLessThan(i8, -0x40, 0x40) == 0x3f); + try expect(r.random.intRangeLessThan(i8, -0x40, 0x40) == 0x3f); r.next_value = 0xff; - expect(r.random.intRangeLessThan(i8, -0x80, 0) == -1); + try expect(r.random.intRangeLessThan(i8, -0x80, 0) == -1); r.next_value = 0xff; - expect(r.random.intRangeLessThan(i3, -4, 0) == -1); + try expect(r.random.intRangeLessThan(i3, -4, 0) == -1); r.next_value = 0xff; - expect(r.random.intRangeLessThan(i3, -2, 2) == 1); + try expect(r.random.intRangeLessThan(i3, -2, 2) == 1); } test "Random intAtMost" { @setEvalBranchQuota(10000); - testRandomIntAtMost(); - comptime testRandomIntAtMost(); + try testRandomIntAtMost(); + comptime try testRandomIntAtMost(); } -fn testRandomIntAtMost() void { +fn testRandomIntAtMost() !void { var r = SequentialPrng.init(); r.next_value = 0xff; - expect(r.random.uintAtMost(u8, 3) == 3); - expect(r.next_value == 0); - expect(r.random.uintAtMost(u8, 3) == 0); + try expect(r.random.uintAtMost(u8, 3) == 3); + try expect(r.next_value == 0); + try expect(r.random.uintAtMost(u8, 3) == 0); // trigger the bias rejection code path r.next_value = 0; - expect(r.random.uintAtMost(u8, 2) == 0); + try expect(r.random.uintAtMost(u8, 2) == 0); // verify we incremented twice - expect(r.next_value == 2); + try expect(r.next_value == 2); r.next_value = 0xff; - expect(r.random.intRangeAtMost(u8, 0, 0x7f) == 0x7f); + try expect(r.random.intRangeAtMost(u8, 0, 0x7f) == 0x7f); r.next_value = 0xff; - expect(r.random.intRangeAtMost(u8, 0x7f, 0xfe) == 0xfe); + try expect(r.random.intRangeAtMost(u8, 0x7f, 0xfe) == 0xfe); r.next_value = 0xff; - expect(r.random.intRangeAtMost(i8, 0, 0x3f) == 0x3f); + try expect(r.random.intRangeAtMost(i8, 0, 0x3f) == 0x3f); r.next_value = 0xff; - expect(r.random.intRangeAtMost(i8, -0x40, 0x3f) == 0x3f); + try expect(r.random.intRangeAtMost(i8, -0x40, 0x3f) == 0x3f); r.next_value = 0xff; - expect(r.random.intRangeAtMost(i8, -0x80, -1) == -1); + try expect(r.random.intRangeAtMost(i8, -0x80, -1) == -1); r.next_value = 0xff; - expect(r.random.intRangeAtMost(i3, -4, -1) == -1); + try expect(r.random.intRangeAtMost(i3, -4, -1) == -1); r.next_value = 0xff; - expect(r.random.intRangeAtMost(i3, -2, 1) == 1); + try expect(r.random.intRangeAtMost(i3, -2, 1) == 1); - expect(r.random.uintAtMost(u0, 0) == 0); + try expect(r.random.uintAtMost(u0, 0) == 0); } test "Random Biased" { @@ -459,30 +459,30 @@ test "Random Biased" { // Not thoroughly checking the logic here. // Just want to execute all the paths with different types. - expect(r.random.uintLessThanBiased(u1, 1) == 0); - expect(r.random.uintLessThanBiased(u32, 10) < 10); - expect(r.random.uintLessThanBiased(u64, 20) < 20); + try expect(r.random.uintLessThanBiased(u1, 1) == 0); + try expect(r.random.uintLessThanBiased(u32, 10) < 10); + try expect(r.random.uintLessThanBiased(u64, 20) < 20); - expect(r.random.uintAtMostBiased(u0, 0) == 0); - expect(r.random.uintAtMostBiased(u1, 0) <= 0); - expect(r.random.uintAtMostBiased(u32, 10) <= 10); - expect(r.random.uintAtMostBiased(u64, 20) <= 20); + try expect(r.random.uintAtMostBiased(u0, 0) == 0); + try expect(r.random.uintAtMostBiased(u1, 0) <= 0); + try expect(r.random.uintAtMostBiased(u32, 10) <= 10); + try expect(r.random.uintAtMostBiased(u64, 20) <= 20); - expect(r.random.intRangeLessThanBiased(u1, 0, 1) == 0); - expect(r.random.intRangeLessThanBiased(i1, -1, 0) == -1); - expect(r.random.intRangeLessThanBiased(u32, 10, 20) >= 10); - expect(r.random.intRangeLessThanBiased(i32, 10, 20) >= 10); - expect(r.random.intRangeLessThanBiased(u64, 20, 40) >= 20); - expect(r.random.intRangeLessThanBiased(i64, 20, 40) >= 20); + try expect(r.random.intRangeLessThanBiased(u1, 0, 1) == 0); + try expect(r.random.intRangeLessThanBiased(i1, -1, 0) == -1); + try expect(r.random.intRangeLessThanBiased(u32, 10, 20) >= 10); + try expect(r.random.intRangeLessThanBiased(i32, 10, 20) >= 10); + try expect(r.random.intRangeLessThanBiased(u64, 20, 40) >= 20); + try expect(r.random.intRangeLessThanBiased(i64, 20, 40) >= 20); // uncomment for broken module error: //expect(r.random.intRangeAtMostBiased(u0, 0, 0) == 0); - expect(r.random.intRangeAtMostBiased(u1, 0, 1) >= 0); - expect(r.random.intRangeAtMostBiased(i1, -1, 0) >= -1); - expect(r.random.intRangeAtMostBiased(u32, 10, 20) >= 10); - expect(r.random.intRangeAtMostBiased(i32, 10, 20) >= 10); - expect(r.random.intRangeAtMostBiased(u64, 20, 40) >= 20); - expect(r.random.intRangeAtMostBiased(i64, 20, 40) >= 20); + try expect(r.random.intRangeAtMostBiased(u1, 0, 1) >= 0); + try expect(r.random.intRangeAtMostBiased(i1, -1, 0) >= -1); + try expect(r.random.intRangeAtMostBiased(u32, 10, 20) >= 10); + try expect(r.random.intRangeAtMostBiased(i32, 10, 20) >= 10); + try expect(r.random.intRangeAtMostBiased(u64, 20, 40) >= 20); + try expect(r.random.intRangeAtMostBiased(i64, 20, 40) >= 20); } // Generator to extend 64-bit seed values into longer sequences. @@ -519,7 +519,7 @@ test "splitmix64 sequence" { }; for (seq) |s| { - expect(s == r.next()); + try expect(s == r.next()); } } @@ -530,12 +530,12 @@ test "Random float" { var i: usize = 0; while (i < 1000) : (i += 1) { const val1 = prng.random.float(f32); - expect(val1 >= 0.0); - expect(val1 < 1.0); + try expect(val1 >= 0.0); + try expect(val1 < 1.0); const val2 = prng.random.float(f64); - expect(val2 >= 0.0); - expect(val2 < 1.0); + try expect(val2 >= 0.0); + try expect(val2 < 1.0); } } @@ -549,12 +549,12 @@ test "Random shuffle" { while (i < 1000) : (i += 1) { prng.random.shuffle(u8, seq[0..]); seen[seq[0]] = true; - expect(sumArray(seq[0..]) == 10); + try expect(sumArray(seq[0..]) == 10); } // we should see every entry at the head at least once for (seen) |e| { - expect(e == true); + try expect(e == true); } } @@ -567,17 +567,17 @@ fn sumArray(s: []const u8) u32 { test "Random range" { var prng = DefaultPrng.init(0); - testRange(&prng.random, -4, 3); - testRange(&prng.random, -4, -1); - testRange(&prng.random, 10, 14); - testRange(&prng.random, -0x80, 0x7f); + try testRange(&prng.random, -4, 3); + try testRange(&prng.random, -4, -1); + try testRange(&prng.random, 10, 14); + try testRange(&prng.random, -0x80, 0x7f); } -fn testRange(r: *Random, start: i8, end: i8) void { - testRangeBias(r, start, end, true); - testRangeBias(r, start, end, false); +fn testRange(r: *Random, start: i8, end: i8) !void { + try testRangeBias(r, start, end, true); + try testRangeBias(r, start, end, false); } -fn testRangeBias(r: *Random, start: i8, end: i8, biased: bool) void { +fn testRangeBias(r: *Random, start: i8, end: i8, biased: bool) !void { const count = @intCast(usize, @as(i32, end) - @as(i32, start)); var values_buffer = [_]bool{false} ** 0x100; const values = values_buffer[0..count]; @@ -599,7 +599,7 @@ test "CSPRNG" { const a = csprng.random.int(u64); const b = csprng.random.int(u64); const c = csprng.random.int(u64); - expect(a ^ b ^ c != 0); + try expect(a ^ b ^ c != 0); } test { diff --git a/lib/std/rand/Isaac64.zig b/lib/std/rand/Isaac64.zig index 7efba9b5bc..ec505b0bf6 100644 --- a/lib/std/rand/Isaac64.zig +++ b/lib/std/rand/Isaac64.zig @@ -205,7 +205,7 @@ test "isaac64 sequence" { }; for (seq) |s| { - std.testing.expect(s == r.next()); + try std.testing.expect(s == r.next()); } } @@ -237,6 +237,6 @@ test "isaac64 fill" { var buf1: [7]u8 = undefined; std.mem.writeIntLittle(u64, &buf0, s); Isaac64.fill(&r.random, &buf1); - std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); + try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); } } diff --git a/lib/std/rand/Pcg.zig b/lib/std/rand/Pcg.zig index 87df0521f2..8f468b5ea3 100644 --- a/lib/std/rand/Pcg.zig +++ b/lib/std/rand/Pcg.zig @@ -96,7 +96,7 @@ test "pcg sequence" { }; for (seq) |s| { - std.testing.expect(s == r.next()); + try std.testing.expect(s == r.next()); } } @@ -120,6 +120,6 @@ test "pcg fill" { var buf1: [3]u8 = undefined; std.mem.writeIntLittle(u32, &buf0, s); Pcg.fill(&r.random, &buf1); - std.testing.expect(std.mem.eql(u8, buf0[0..3], buf1[0..])); + try std.testing.expect(std.mem.eql(u8, buf0[0..3], buf1[0..])); } } diff --git a/lib/std/rand/Sfc64.zig b/lib/std/rand/Sfc64.zig index 67eb684f60..1966a59ceb 100644 --- a/lib/std/rand/Sfc64.zig +++ b/lib/std/rand/Sfc64.zig @@ -103,7 +103,7 @@ test "Sfc64 sequence" { }; for (seq) |s| { - std.testing.expectEqual(s, r.next()); + try std.testing.expectEqual(s, r.next()); } } @@ -135,6 +135,6 @@ test "Sfc64 fill" { var buf1: [7]u8 = undefined; std.mem.writeIntLittle(u64, &buf0, s); Sfc64.fill(&r.random, &buf1); - std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); + try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); } } diff --git a/lib/std/rand/Xoroshiro128.zig b/lib/std/rand/Xoroshiro128.zig index 04980cea41..4b507cec74 100644 --- a/lib/std/rand/Xoroshiro128.zig +++ b/lib/std/rand/Xoroshiro128.zig @@ -113,7 +113,7 @@ test "xoroshiro sequence" { }; for (seq1) |s| { - std.testing.expect(s == r.next()); + try std.testing.expect(s == r.next()); } r.jump(); @@ -128,7 +128,7 @@ test "xoroshiro sequence" { }; for (seq2) |s| { - std.testing.expect(s == r.next()); + try std.testing.expect(s == r.next()); } } @@ -151,6 +151,6 @@ test "xoroshiro fill" { var buf1: [7]u8 = undefined; std.mem.writeIntLittle(u64, &buf0, s); Xoroshiro128.fill(&r.random, &buf1); - std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); + try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..])); } } diff --git a/lib/std/sort.zig b/lib/std/sort.zig index b30fb6ae57..8c330fbff5 100644 --- a/lib/std/sort.zig +++ b/lib/std/sort.zig @@ -43,35 +43,35 @@ test "binarySearch" { return math.order(lhs, rhs); } }; - testing.expectEqual( + try testing.expectEqual( @as(?usize, null), binarySearch(u32, 1, &[_]u32{}, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, 0), binarySearch(u32, 1, &[_]u32{1}, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, null), binarySearch(u32, 1, &[_]u32{0}, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, null), binarySearch(u32, 0, &[_]u32{1}, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, 4), binarySearch(u32, 5, &[_]u32{ 1, 2, 3, 4, 5 }, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, 0), binarySearch(u32, 2, &[_]u32{ 2, 4, 8, 16, 32, 64 }, {}, S.order_u32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, 1), binarySearch(i32, -4, &[_]i32{ -7, -4, 0, 9, 10 }, {}, S.order_i32), ); - testing.expectEqual( + try testing.expectEqual( @as(?usize, 3), binarySearch(i32, 98, &[_]i32{ -100, -25, 2, 98, 99, 100 }, {}, S.order_i32), ); @@ -1152,10 +1152,10 @@ pub fn desc(comptime T: type) fn (void, T, T) bool { } test "stable sort" { - testStableSort(); - comptime testStableSort(); + try testStableSort(); + comptime try testStableSort(); } -fn testStableSort() void { +fn testStableSort() !void { var expected = [_]IdAndValue{ IdAndValue{ .id = 0, .value = 0 }, IdAndValue{ .id = 1, .value = 0 }, @@ -1194,8 +1194,8 @@ fn testStableSort() void { for (cases) |*case| { insertionSort(IdAndValue, (case.*)[0..], {}, cmpByValue); for (case.*) |item, i| { - testing.expect(item.id == expected[i].id); - testing.expect(item.value == expected[i].value); + try testing.expect(item.id == expected[i].id); + try testing.expect(item.value == expected[i].value); } } } @@ -1245,7 +1245,7 @@ test "sort" { const slice = buf[0..case[0].len]; mem.copy(u8, slice, case[0]); sort(u8, slice, {}, asc_u8); - testing.expect(mem.eql(u8, slice, case[1])); + try testing.expect(mem.eql(u8, slice, case[1])); } const i32cases = [_][]const []const i32{ @@ -1280,7 +1280,7 @@ test "sort" { const slice = buf[0..case[0].len]; mem.copy(i32, slice, case[0]); sort(i32, slice, {}, asc_i32); - testing.expect(mem.eql(i32, slice, case[1])); + try testing.expect(mem.eql(i32, slice, case[1])); } } @@ -1317,7 +1317,7 @@ test "sort descending" { const slice = buf[0..case[0].len]; mem.copy(i32, slice, case[0]); sort(i32, slice, {}, desc_i32); - testing.expect(mem.eql(i32, slice, case[1])); + try testing.expect(mem.eql(i32, slice, case[1])); } } @@ -1325,7 +1325,7 @@ test "another sort case" { var arr = [_]i32{ 5, 3, 1, 2, 4 }; sort(i32, arr[0..], {}, asc_i32); - testing.expect(mem.eql(i32, &arr, &[_]i32{ 1, 2, 3, 4, 5 })); + try testing.expect(mem.eql(i32, &arr, &[_]i32{ 1, 2, 3, 4, 5 })); } test "sort fuzz testing" { @@ -1353,9 +1353,9 @@ fn fuzzTest(rng: *std.rand.Random) !void { var index: usize = 1; while (index < array.len) : (index += 1) { if (array[index].value == array[index - 1].value) { - testing.expect(array[index].id > array[index - 1].id); + try testing.expect(array[index].id > array[index - 1].id); } else { - testing.expect(array[index].value > array[index - 1].value); + try testing.expect(array[index].value > array[index - 1].value); } } } @@ -1383,13 +1383,13 @@ pub fn argMin( } test "argMin" { - testing.expectEqual(@as(?usize, null), argMin(i32, &[_]i32{}, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{1}, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 3), argMin(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 3), argMin(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); + try testing.expectEqual(@as(?usize, null), argMin(i32, &[_]i32{}, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{1}, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 3), argMin(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 3), argMin(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); } pub fn min( @@ -1403,13 +1403,13 @@ pub fn min( } test "min" { - testing.expectEqual(@as(?i32, null), min(i32, &[_]i32{}, {}, asc_i32)); - testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{1}, {}, asc_i32)); - testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 2), min(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, -10), min(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 7), min(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); + try testing.expectEqual(@as(?i32, null), min(i32, &[_]i32{}, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{1}, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 2), min(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, -10), min(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 7), min(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); } pub fn argMax( @@ -1435,13 +1435,13 @@ pub fn argMax( } test "argMax" { - testing.expectEqual(@as(?usize, null), argMax(i32, &[_]i32{}, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{1}, {}, asc_i32)); - testing.expectEqual(@as(?usize, 4), argMax(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 2), argMax(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); - testing.expectEqual(@as(?usize, 1), argMax(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); + try testing.expectEqual(@as(?usize, null), argMax(i32, &[_]i32{}, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{1}, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 4), argMax(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 2), argMax(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); + try testing.expectEqual(@as(?usize, 1), argMax(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); } pub fn max( @@ -1455,13 +1455,13 @@ pub fn max( } test "max" { - testing.expectEqual(@as(?i32, null), max(i32, &[_]i32{}, {}, asc_i32)); - testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{1}, {}, asc_i32)); - testing.expectEqual(@as(?i32, 5), max(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 9), max(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 10), max(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); - testing.expectEqual(@as(?i32, 3), max(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); + try testing.expectEqual(@as(?i32, null), max(i32, &[_]i32{}, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{1}, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 5), max(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 9), max(i32, &[_]i32{ 9, 3, 8, 2, 5 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 10), max(i32, &[_]i32{ -10, 1, 10 }, {}, asc_i32)); + try testing.expectEqual(@as(?i32, 3), max(i32, &[_]i32{ 6, 3, 5, 7, 6 }, {}, desc_i32)); } pub fn isSorted( @@ -1481,28 +1481,28 @@ pub fn isSorted( } test "isSorted" { - testing.expect(isSorted(i32, &[_]i32{}, {}, asc_i32)); - testing.expect(isSorted(i32, &[_]i32{10}, {}, asc_i32)); - testing.expect(isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); - testing.expect(isSorted(i32, &[_]i32{ -10, 1, 1, 1, 10 }, {}, asc_i32)); + try testing.expect(isSorted(i32, &[_]i32{}, {}, asc_i32)); + try testing.expect(isSorted(i32, &[_]i32{10}, {}, asc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ -10, 1, 1, 1, 10 }, {}, asc_i32)); - testing.expect(isSorted(i32, &[_]i32{}, {}, desc_i32)); - testing.expect(isSorted(i32, &[_]i32{-20}, {}, desc_i32)); - testing.expect(isSorted(i32, &[_]i32{ 3, 2, 1, 0, -1 }, {}, desc_i32)); - testing.expect(isSorted(i32, &[_]i32{ 10, -10 }, {}, desc_i32)); + try testing.expect(isSorted(i32, &[_]i32{}, {}, desc_i32)); + try testing.expect(isSorted(i32, &[_]i32{-20}, {}, desc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ 3, 2, 1, 0, -1 }, {}, desc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ 10, -10 }, {}, desc_i32)); - testing.expect(isSorted(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); - testing.expect(isSorted(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, desc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, asc_i32)); + try testing.expect(isSorted(i32, &[_]i32{ 1, 1, 1, 1, 1 }, {}, desc_i32)); - testing.expectEqual(false, isSorted(i32, &[_]i32{ 5, 4, 3, 2, 1 }, {}, asc_i32)); - testing.expectEqual(false, isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, desc_i32)); + try testing.expectEqual(false, isSorted(i32, &[_]i32{ 5, 4, 3, 2, 1 }, {}, asc_i32)); + try testing.expectEqual(false, isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, desc_i32)); - testing.expect(isSorted(u8, "abcd", {}, asc_u8)); - testing.expect(isSorted(u8, "zyxw", {}, desc_u8)); + try testing.expect(isSorted(u8, "abcd", {}, asc_u8)); + try testing.expect(isSorted(u8, "zyxw", {}, desc_u8)); - testing.expectEqual(false, isSorted(u8, "abcd", {}, desc_u8)); - testing.expectEqual(false, isSorted(u8, "zyxw", {}, asc_u8)); + try testing.expectEqual(false, isSorted(u8, "abcd", {}, desc_u8)); + try testing.expectEqual(false, isSorted(u8, "zyxw", {}, asc_u8)); - testing.expect(isSorted(u8, "ffff", {}, asc_u8)); - testing.expect(isSorted(u8, "ffff", {}, desc_u8)); + try testing.expect(isSorted(u8, "ffff", {}, asc_u8)); + try testing.expect(isSorted(u8, "ffff", {}, desc_u8)); } diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig index 29feae830f..49d679210b 100644 --- a/lib/std/special/c.zig +++ b/lib/std/special/c.zig @@ -161,10 +161,10 @@ fn strerror(errnum: c_int) callconv(.C) [*:0]const u8 { } test "strncmp" { - std.testing.expect(strncmp("a", "b", 1) == -1); - std.testing.expect(strncmp("a", "c", 1) == -2); - std.testing.expect(strncmp("b", "a", 1) == 1); - std.testing.expect(strncmp("\xff", "\x02", 1) == 253); + try std.testing.expect(strncmp("a", "b", 1) == -1); + try std.testing.expect(strncmp("a", "c", 1) == -2); + try std.testing.expect(strncmp("b", "a", 1) == 1); + try std.testing.expect(strncmp("\xff", "\x02", 1) == 253); } // Avoid dragging in the runtime safety mechanisms into this .o file, @@ -245,9 +245,9 @@ test "memcmp" { const arr2 = &[_]u8{ 1, 0, 1 }; const arr3 = &[_]u8{ 1, 2, 1 }; - std.testing.expect(memcmp(base_arr[0..], arr1[0..], base_arr.len) == 0); - std.testing.expect(memcmp(base_arr[0..], arr2[0..], base_arr.len) > 0); - std.testing.expect(memcmp(base_arr[0..], arr3[0..], base_arr.len) < 0); + try std.testing.expect(memcmp(base_arr[0..], arr1[0..], base_arr.len) == 0); + try std.testing.expect(memcmp(base_arr[0..], arr2[0..], base_arr.len) > 0); + try std.testing.expect(memcmp(base_arr[0..], arr3[0..], base_arr.len) < 0); } export fn bcmp(vl: [*]allowzero const u8, vr: [*]allowzero const u8, n: usize) callconv(.C) isize { @@ -269,9 +269,9 @@ test "bcmp" { const arr2 = &[_]u8{ 1, 0, 1 }; const arr3 = &[_]u8{ 1, 2, 1 }; - std.testing.expect(bcmp(base_arr[0..], arr1[0..], base_arr.len) == 0); - std.testing.expect(bcmp(base_arr[0..], arr2[0..], base_arr.len) != 0); - std.testing.expect(bcmp(base_arr[0..], arr3[0..], base_arr.len) != 0); + try std.testing.expect(bcmp(base_arr[0..], arr1[0..], base_arr.len) == 0); + try std.testing.expect(bcmp(base_arr[0..], arr2[0..], base_arr.len) != 0); + try std.testing.expect(bcmp(base_arr[0..], arr3[0..], base_arr.len) != 0); } comptime { @@ -865,11 +865,11 @@ test "fmod, fmodf" { const nan_val = math.nan(T); const inf_val = math.inf(T); - std.testing.expect(isNan(generic_fmod(T, nan_val, 1.0))); - std.testing.expect(isNan(generic_fmod(T, 1.0, nan_val))); - std.testing.expect(isNan(generic_fmod(T, inf_val, 1.0))); - std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0))); - std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0))); + try std.testing.expect(isNan(generic_fmod(T, nan_val, 1.0))); + try std.testing.expect(isNan(generic_fmod(T, 1.0, nan_val))); + try std.testing.expect(isNan(generic_fmod(T, inf_val, 1.0))); + try std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0))); + try std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0))); std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0)); std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0)); @@ -901,7 +901,7 @@ test "fmin, fminf" { inline for ([_]type{ f32, f64 }) |T| { const nan_val = math.nan(T); - std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val))); + try std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val))); std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0)); std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val)); @@ -930,7 +930,7 @@ test "fmax, fmaxf" { inline for ([_]type{ f32, f64 }) |T| { const nan_val = math.nan(T); - std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val))); + try std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val))); std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0)); std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val)); @@ -1094,11 +1094,11 @@ test "sqrt" { } test "sqrt special" { - std.testing.expect(std.math.isPositiveInf(sqrt(std.math.inf(f64)))); - std.testing.expect(sqrt(0.0) == 0.0); - std.testing.expect(sqrt(-0.0) == -0.0); - std.testing.expect(isNan(sqrt(-1.0))); - std.testing.expect(isNan(sqrt(std.math.nan(f64)))); + try std.testing.expect(std.math.isPositiveInf(sqrt(std.math.inf(f64)))); + try std.testing.expect(sqrt(0.0) == 0.0); + try std.testing.expect(sqrt(-0.0) == -0.0); + try std.testing.expect(isNan(sqrt(-1.0))); + try std.testing.expect(isNan(sqrt(std.math.nan(f64)))); } export fn sqrtf(x: f32) f32 { @@ -1199,9 +1199,9 @@ test "sqrtf" { } test "sqrtf special" { - std.testing.expect(std.math.isPositiveInf(sqrtf(std.math.inf(f32)))); - std.testing.expect(sqrtf(0.0) == 0.0); - std.testing.expect(sqrtf(-0.0) == -0.0); - std.testing.expect(isNan(sqrtf(-1.0))); - std.testing.expect(isNan(sqrtf(std.math.nan(f32)))); + try std.testing.expect(std.math.isPositiveInf(sqrtf(std.math.inf(f32)))); + try std.testing.expect(sqrtf(0.0) == 0.0); + try std.testing.expect(sqrtf(-0.0) == -0.0); + try std.testing.expect(isNan(sqrtf(-1.0))); + try std.testing.expect(isNan(sqrtf(std.math.nan(f32)))); } diff --git a/lib/std/special/compiler_rt/comparedf2_test.zig b/lib/std/special/compiler_rt/comparedf2_test.zig index f5e8cfe372..b0916c10ae 100644 --- a/lib/std/special/compiler_rt/comparedf2_test.zig +++ b/lib/std/special/compiler_rt/comparedf2_test.zig @@ -101,6 +101,6 @@ const test_vectors = init: { test "compare f64" { for (test_vectors) |vector, i| { - std.testing.expect(test__cmpdf2(vector)); + try std.testing.expect(test__cmpdf2(vector)); } } diff --git a/lib/std/special/compiler_rt/comparesf2_test.zig b/lib/std/special/compiler_rt/comparesf2_test.zig index 0a1f5e74f6..9719873f62 100644 --- a/lib/std/special/compiler_rt/comparesf2_test.zig +++ b/lib/std/special/compiler_rt/comparesf2_test.zig @@ -101,6 +101,6 @@ const test_vectors = init: { test "compare f32" { for (test_vectors) |vector, i| { - std.testing.expect(test__cmpsf2(vector)); + try std.testing.expect(test__cmpsf2(vector)); } } diff --git a/lib/std/special/compiler_rt/divdf3_test.zig b/lib/std/special/compiler_rt/divdf3_test.zig index 8bdecc7c6a..0bced93de5 100644 --- a/lib/std/special/compiler_rt/divdf3_test.zig +++ b/lib/std/special/compiler_rt/divdf3_test.zig @@ -30,7 +30,7 @@ fn compareResultD(result: f64, expected: u64) bool { fn test__divdf3(a: f64, b: f64, expected: u64) void { const x = __divdf3(a, b); const ret = compareResultD(x, expected); - testing.expect(ret == true); + try testing.expect(ret == true); } test "divdf3" { diff --git a/lib/std/special/compiler_rt/divsf3_test.zig b/lib/std/special/compiler_rt/divsf3_test.zig index a14e8e9163..b7bf220d8b 100644 --- a/lib/std/special/compiler_rt/divsf3_test.zig +++ b/lib/std/special/compiler_rt/divsf3_test.zig @@ -30,7 +30,7 @@ fn compareResultF(result: f32, expected: u32) bool { fn test__divsf3(a: f32, b: f32, expected: u32) void { const x = __divsf3(a, b); const ret = compareResultF(x, expected); - testing.expect(ret == true); + try testing.expect(ret == true); } test "divsf3" { diff --git a/lib/std/special/compiler_rt/divtf3_test.zig b/lib/std/special/compiler_rt/divtf3_test.zig index 98910e9994..325be493cd 100644 --- a/lib/std/special/compiler_rt/divtf3_test.zig +++ b/lib/std/special/compiler_rt/divtf3_test.zig @@ -31,7 +31,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool { fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void { const x = __divtf3(a, b); const ret = compareResultLD(x, expectedHi, expectedLo); - testing.expect(ret == true); + try testing.expect(ret == true); } test "divtf3" { diff --git a/lib/std/special/compiler_rt/divti3_test.zig b/lib/std/special/compiler_rt/divti3_test.zig index a20be340c6..61aab97475 100644 --- a/lib/std/special/compiler_rt/divti3_test.zig +++ b/lib/std/special/compiler_rt/divti3_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__divti3(a: i128, b: i128, expected: i128) void { const x = __divti3(a, b); - testing.expect(x == expected); + try testing.expect(x == expected); } test "divti3" { diff --git a/lib/std/special/compiler_rt/emutls.zig b/lib/std/special/compiler_rt/emutls.zig index 2b0fba5b34..8871afe00b 100644 --- a/lib/std/special/compiler_rt/emutls.zig +++ b/lib/std/special/compiler_rt/emutls.zig @@ -339,12 +339,12 @@ test "simple_allocator" { test "__emutls_get_address zeroed" { var ctl = emutls_control.init(usize, null); - expect(ctl.object.index == 0); + try expect(ctl.object.index == 0); // retrieve a variable from ctl var x = @ptrCast(*usize, @alignCast(@alignOf(usize), __emutls_get_address(&ctl))); - expect(ctl.object.index != 0); // index has been allocated for this ctl - expect(x.* == 0); // storage has been zeroed + try expect(ctl.object.index != 0); // index has been allocated for this ctl + try expect(x.* == 0); // storage has been zeroed // modify the storage x.* = 1234; @@ -352,26 +352,26 @@ test "__emutls_get_address zeroed" { // retrieve a variable from ctl (same ctl) var y = @ptrCast(*usize, @alignCast(@alignOf(usize), __emutls_get_address(&ctl))); - expect(y.* == 1234); // same content that x.* - expect(x == y); // same pointer + try expect(y.* == 1234); // same content that x.* + try expect(x == y); // same pointer } test "__emutls_get_address with default_value" { var value: usize = 5678; // default value var ctl = emutls_control.init(usize, &value); - expect(ctl.object.index == 0); + try expect(ctl.object.index == 0); var x: *usize = @ptrCast(*usize, @alignCast(@alignOf(usize), __emutls_get_address(&ctl))); - expect(ctl.object.index != 0); - expect(x.* == 5678); // storage initialized with default value + try expect(ctl.object.index != 0); + try expect(x.* == 5678); // storage initialized with default value // modify the storage x.* = 9012; - expect(value == 5678); // the default value didn't change + try expect(value == 5678); // the default value didn't change var y = @ptrCast(*usize, @alignCast(@alignOf(usize), __emutls_get_address(&ctl))); - expect(y.* == 9012); // the modified storage persists + try expect(y.* == 9012); // the modified storage persists } test "test default_value with differents sizes" { @@ -380,7 +380,7 @@ test "test default_value with differents sizes" { var def: T = value; var ctl = emutls_control.init(T, &def); var x = ctl.get_typed_pointer(T); - expect(x.* == value); + try expect(x.* == value); } }._testType; diff --git a/lib/std/special/compiler_rt/fixdfdi_test.zig b/lib/std/special/compiler_rt/fixdfdi_test.zig index f085bdf665..cc638e1e50 100644 --- a/lib/std/special/compiler_rt/fixdfdi_test.zig +++ b/lib/std/special/compiler_rt/fixdfdi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixdfdi(a: f64, expected: i64) void { const x = __fixdfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixdfdi" { diff --git a/lib/std/special/compiler_rt/fixdfsi_test.zig b/lib/std/special/compiler_rt/fixdfsi_test.zig index 1445149546..e1425f8d5e 100644 --- a/lib/std/special/compiler_rt/fixdfsi_test.zig +++ b/lib/std/special/compiler_rt/fixdfsi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixdfsi(a: f64, expected: i32) void { const x = __fixdfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixdfsi" { diff --git a/lib/std/special/compiler_rt/fixdfti_test.zig b/lib/std/special/compiler_rt/fixdfti_test.zig index 3b5bac4b4e..99a0b90bf6 100644 --- a/lib/std/special/compiler_rt/fixdfti_test.zig +++ b/lib/std/special/compiler_rt/fixdfti_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixdfti(a: f64, expected: i128) void { const x = __fixdfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixdfti" { diff --git a/lib/std/special/compiler_rt/fixint_test.zig b/lib/std/special/compiler_rt/fixint_test.zig index 139546c52b..10237bca77 100644 --- a/lib/std/special/compiler_rt/fixint_test.zig +++ b/lib/std/special/compiler_rt/fixint_test.zig @@ -14,7 +14,7 @@ const fixint = @import("fixint.zig").fixint; fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void { const x = fixint(fp_t, fixint_t, a); //warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixint.i1" { diff --git a/lib/std/special/compiler_rt/fixsfdi_test.zig b/lib/std/special/compiler_rt/fixsfdi_test.zig index 7c13d83da5..50410411ca 100644 --- a/lib/std/special/compiler_rt/fixsfdi_test.zig +++ b/lib/std/special/compiler_rt/fixsfdi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixsfdi(a: f32, expected: i64) void { const x = __fixsfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixsfdi" { diff --git a/lib/std/special/compiler_rt/fixsfsi_test.zig b/lib/std/special/compiler_rt/fixsfsi_test.zig index 07c080470d..ac01e884ce 100644 --- a/lib/std/special/compiler_rt/fixsfsi_test.zig +++ b/lib/std/special/compiler_rt/fixsfsi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixsfsi(a: f32, expected: i32) void { const x = __fixsfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixsfsi" { diff --git a/lib/std/special/compiler_rt/fixsfti_test.zig b/lib/std/special/compiler_rt/fixsfti_test.zig index dbc30c5404..f99a92b03c 100644 --- a/lib/std/special/compiler_rt/fixsfti_test.zig +++ b/lib/std/special/compiler_rt/fixsfti_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixsfti(a: f32, expected: i128) void { const x = __fixsfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixsfti" { diff --git a/lib/std/special/compiler_rt/fixtfdi_test.zig b/lib/std/special/compiler_rt/fixtfdi_test.zig index dfc08f84a3..c5079379bf 100644 --- a/lib/std/special/compiler_rt/fixtfdi_test.zig +++ b/lib/std/special/compiler_rt/fixtfdi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixtfdi(a: f128, expected: i64) void { const x = __fixtfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixtfdi" { diff --git a/lib/std/special/compiler_rt/fixtfsi_test.zig b/lib/std/special/compiler_rt/fixtfsi_test.zig index e5605a3936..1e21944aa8 100644 --- a/lib/std/special/compiler_rt/fixtfsi_test.zig +++ b/lib/std/special/compiler_rt/fixtfsi_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixtfsi(a: f128, expected: i32) void { const x = __fixtfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixtfsi" { diff --git a/lib/std/special/compiler_rt/fixtfti_test.zig b/lib/std/special/compiler_rt/fixtfti_test.zig index b01e3af9f9..ef2b02e96c 100644 --- a/lib/std/special/compiler_rt/fixtfti_test.zig +++ b/lib/std/special/compiler_rt/fixtfti_test.zig @@ -12,7 +12,7 @@ const warn = std.debug.warn; fn test__fixtfti(a: f128, expected: i128) void { const x = __fixtfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)}); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixtfti" { diff --git a/lib/std/special/compiler_rt/fixunsdfdi_test.zig b/lib/std/special/compiler_rt/fixunsdfdi_test.zig index b7bbe42fb9..6a9f302a54 100644 --- a/lib/std/special/compiler_rt/fixunsdfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfdi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunsdfdi(a: f64, expected: u64) void { const x = __fixunsdfdi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunsdfdi" { diff --git a/lib/std/special/compiler_rt/fixunsdfsi_test.zig b/lib/std/special/compiler_rt/fixunsdfsi_test.zig index a083f97f0b..dc71b11312 100644 --- a/lib/std/special/compiler_rt/fixunsdfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfsi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunsdfsi(a: f64, expected: u32) void { const x = __fixunsdfsi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunsdfsi" { diff --git a/lib/std/special/compiler_rt/fixunsdfti_test.zig b/lib/std/special/compiler_rt/fixunsdfti_test.zig index dbfeb0fc4b..6cecc1619e 100644 --- a/lib/std/special/compiler_rt/fixunsdfti_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfti_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunsdfti(a: f64, expected: u128) void { const x = __fixunsdfti(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunsdfti" { diff --git a/lib/std/special/compiler_rt/fixunssfdi_test.zig b/lib/std/special/compiler_rt/fixunssfdi_test.zig index d5e04292cb..0b5ca1a18f 100644 --- a/lib/std/special/compiler_rt/fixunssfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunssfdi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunssfdi(a: f32, expected: u64) void { const x = __fixunssfdi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunssfdi" { diff --git a/lib/std/special/compiler_rt/fixunssfsi_test.zig b/lib/std/special/compiler_rt/fixunssfsi_test.zig index c30c1d6804..608dd59ff5 100644 --- a/lib/std/special/compiler_rt/fixunssfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunssfsi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunssfsi(a: f32, expected: u32) void { const x = __fixunssfsi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunssfsi" { diff --git a/lib/std/special/compiler_rt/fixunssfti_test.zig b/lib/std/special/compiler_rt/fixunssfti_test.zig index b148f5a35a..5ba5b98d63 100644 --- a/lib/std/special/compiler_rt/fixunssfti_test.zig +++ b/lib/std/special/compiler_rt/fixunssfti_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunssfti(a: f32, expected: u128) void { const x = __fixunssfti(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunssfti" { diff --git a/lib/std/special/compiler_rt/fixunstfdi_test.zig b/lib/std/special/compiler_rt/fixunstfdi_test.zig index b0297d4a2f..3d832b35d0 100644 --- a/lib/std/special/compiler_rt/fixunstfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunstfdi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunstfdi(a: f128, expected: u64) void { const x = __fixunstfdi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "fixunstfdi" { diff --git a/lib/std/special/compiler_rt/fixunstfsi_test.zig b/lib/std/special/compiler_rt/fixunstfsi_test.zig index f1cb9f6de7..e2aa597d9c 100644 --- a/lib/std/special/compiler_rt/fixunstfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunstfsi_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunstfsi(a: f128, expected: u32) void { const x = __fixunstfsi(a); - testing.expect(x == expected); + try testing.expect(x == expected); } const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); diff --git a/lib/std/special/compiler_rt/fixunstfti_test.zig b/lib/std/special/compiler_rt/fixunstfti_test.zig index fcbf9d3b25..bc3ee0be24 100644 --- a/lib/std/special/compiler_rt/fixunstfti_test.zig +++ b/lib/std/special/compiler_rt/fixunstfti_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__fixunstfti(a: f128, expected: u128) void { const x = __fixunstfti(a); - testing.expect(x == expected); + try testing.expect(x == expected); } const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); diff --git a/lib/std/special/compiler_rt/floatdidf_test.zig b/lib/std/special/compiler_rt/floatdidf_test.zig index 41b851a306..85d79bff3c 100644 --- a/lib/std/special/compiler_rt/floatdidf_test.zig +++ b/lib/std/special/compiler_rt/floatdidf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatdidf(a: i64, expected: f64) void { const r = __floatdidf(a); - testing.expect(r == expected); + try testing.expect(r == expected); } test "floatdidf" { diff --git a/lib/std/special/compiler_rt/floatdisf_test.zig b/lib/std/special/compiler_rt/floatdisf_test.zig index 845dc7b1ae..c16481b3dd 100644 --- a/lib/std/special/compiler_rt/floatdisf_test.zig +++ b/lib/std/special/compiler_rt/floatdisf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatdisf(a: i64, expected: f32) void { const x = __floatdisf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floatdisf" { diff --git a/lib/std/special/compiler_rt/floatditf_test.zig b/lib/std/special/compiler_rt/floatditf_test.zig index 13796efd69..82df9158e0 100644 --- a/lib/std/special/compiler_rt/floatditf_test.zig +++ b/lib/std/special/compiler_rt/floatditf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatditf(a: i64, expected: f128) void { const x = __floatditf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floatditf" { diff --git a/lib/std/special/compiler_rt/floatsiXf.zig b/lib/std/special/compiler_rt/floatsiXf.zig index 50fcdd748b..3f36f8dea0 100644 --- a/lib/std/special/compiler_rt/floatsiXf.zig +++ b/lib/std/special/compiler_rt/floatsiXf.zig @@ -86,17 +86,17 @@ pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 { fn test_one_floatsitf(a: i32, expected: u128) void { const r = __floatsitf(a); - std.testing.expect(@bitCast(u128, r) == expected); + try std.testing.expect(@bitCast(u128, r) == expected); } fn test_one_floatsidf(a: i32, expected: u64) void { const r = __floatsidf(a); - std.testing.expect(@bitCast(u64, r) == expected); + try std.testing.expect(@bitCast(u64, r) == expected); } fn test_one_floatsisf(a: i32, expected: u32) void { const r = __floatsisf(a); - std.testing.expect(@bitCast(u32, r) == expected); + try std.testing.expect(@bitCast(u32, r) == expected); } test "floatsidf" { diff --git a/lib/std/special/compiler_rt/floattidf_test.zig b/lib/std/special/compiler_rt/floattidf_test.zig index ab6311c9ff..0523b2a59b 100644 --- a/lib/std/special/compiler_rt/floattidf_test.zig +++ b/lib/std/special/compiler_rt/floattidf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floattidf(a: i128, expected: f64) void { const x = __floattidf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floattidf" { diff --git a/lib/std/special/compiler_rt/floattisf_test.zig b/lib/std/special/compiler_rt/floattisf_test.zig index 2458e4bb76..88f0989f18 100644 --- a/lib/std/special/compiler_rt/floattisf_test.zig +++ b/lib/std/special/compiler_rt/floattisf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floattisf(a: i128, expected: f32) void { const x = __floattisf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floattisf" { diff --git a/lib/std/special/compiler_rt/floattitf_test.zig b/lib/std/special/compiler_rt/floattitf_test.zig index 3310875ecc..0650665e4f 100644 --- a/lib/std/special/compiler_rt/floattitf_test.zig +++ b/lib/std/special/compiler_rt/floattitf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floattitf(a: i128, expected: f128) void { const x = __floattitf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floattitf" { diff --git a/lib/std/special/compiler_rt/floatundidf_test.zig b/lib/std/special/compiler_rt/floatundidf_test.zig index a0e18c4f5a..5c92d74106 100644 --- a/lib/std/special/compiler_rt/floatundidf_test.zig +++ b/lib/std/special/compiler_rt/floatundidf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatundidf(a: u64, expected: f64) void { const r = __floatundidf(a); - testing.expect(r == expected); + try testing.expect(r == expected); } test "floatundidf" { diff --git a/lib/std/special/compiler_rt/floatunsidf.zig b/lib/std/special/compiler_rt/floatunsidf.zig index 1b700b001d..c97cc6ae47 100644 --- a/lib/std/special/compiler_rt/floatunsidf.zig +++ b/lib/std/special/compiler_rt/floatunsidf.zig @@ -30,7 +30,7 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 { fn test_one_floatunsidf(a: u32, expected: u64) void { const r = __floatunsidf(a); - std.testing.expect(@bitCast(u64, r) == expected); + try std.testing.expect(@bitCast(u64, r) == expected); } test "floatsidf" { diff --git a/lib/std/special/compiler_rt/floatunsisf.zig b/lib/std/special/compiler_rt/floatunsisf.zig index 1a0ef47b5c..d707217671 100644 --- a/lib/std/special/compiler_rt/floatunsisf.zig +++ b/lib/std/special/compiler_rt/floatunsisf.zig @@ -50,7 +50,7 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 { fn test_one_floatunsisf(a: u32, expected: u32) void { const r = __floatunsisf(a); - std.testing.expect(@bitCast(u32, r) == expected); + try std.testing.expect(@bitCast(u32, r) == expected); } test "floatunsisf" { diff --git a/lib/std/special/compiler_rt/floatuntidf_test.zig b/lib/std/special/compiler_rt/floatuntidf_test.zig index 427c7a08f2..53f32d0fd7 100644 --- a/lib/std/special/compiler_rt/floatuntidf_test.zig +++ b/lib/std/special/compiler_rt/floatuntidf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatuntidf(a: u128, expected: f64) void { const x = __floatuntidf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floatuntidf" { diff --git a/lib/std/special/compiler_rt/floatuntisf_test.zig b/lib/std/special/compiler_rt/floatuntisf_test.zig index 78d45dc5e0..464118fe3b 100644 --- a/lib/std/special/compiler_rt/floatuntisf_test.zig +++ b/lib/std/special/compiler_rt/floatuntisf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatuntisf(a: u128, expected: f32) void { const x = __floatuntisf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floatuntisf" { diff --git a/lib/std/special/compiler_rt/floatuntitf_test.zig b/lib/std/special/compiler_rt/floatuntitf_test.zig index fd57be51e6..80f7eec96b 100644 --- a/lib/std/special/compiler_rt/floatuntitf_test.zig +++ b/lib/std/special/compiler_rt/floatuntitf_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__floatuntitf(a: u128, expected: f128) void { const x = __floatuntitf(a); - testing.expect(x == expected); + try testing.expect(x == expected); } test "floatuntitf" { diff --git a/lib/std/special/compiler_rt/int.zig b/lib/std/special/compiler_rt/int.zig index b852139516..1e519252a3 100644 --- a/lib/std/special/compiler_rt/int.zig +++ b/lib/std/special/compiler_rt/int.zig @@ -64,7 +64,7 @@ test "test_divdi3" { fn test_one_divdi3(a: i64, b: i64, expected_q: i64) void { const q: i64 = __divdi3(a, b); - testing.expect(q == expected_q); + try testing.expect(q == expected_q); } pub fn __moddi3(a: i64, b: i64) callconv(.C) i64 { @@ -104,7 +104,7 @@ test "test_moddi3" { fn test_one_moddi3(a: i64, b: i64, expected_r: i64) void { const r: i64 = __moddi3(a, b); - testing.expect(r == expected_r); + try testing.expect(r == expected_r); } pub fn __udivdi3(a: u64, b: u64) callconv(.C) u64 { @@ -130,7 +130,7 @@ test "test_umoddi3" { fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) void { const r = __umoddi3(a, b); - testing.expect(r == expected_r); + try testing.expect(r == expected_r); } pub fn __divmodsi4(a: i32, b: i32, rem: *i32) callconv(.C) i32 { @@ -166,7 +166,7 @@ test "test_divmodsi4" { fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) void { var r: i32 = undefined; const q: i32 = __divmodsi4(a, b, &r); - testing.expect(q == expected_q and r == expected_r); + try testing.expect(q == expected_q and r == expected_r); } pub fn __udivmodsi4(a: u32, b: u32, rem: *u32) callconv(.C) u32 { @@ -213,7 +213,7 @@ test "test_divsi3" { fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void { const q: i32 = __divsi3(a, b); - testing.expect(q == expected_q); + try testing.expect(q == expected_q); } pub fn __udivsi3(n: u32, d: u32) callconv(.C) u32 { @@ -400,7 +400,7 @@ test "test_udivsi3" { fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) void { const q: u32 = __udivsi3(a, b); - testing.expect(q == expected_q); + try testing.expect(q == expected_q); } pub fn __modsi3(n: i32, d: i32) callconv(.C) i32 { @@ -431,7 +431,7 @@ test "test_modsi3" { fn test_one_modsi3(a: i32, b: i32, expected_r: i32) void { const r: i32 = __modsi3(a, b); - testing.expect(r == expected_r); + try testing.expect(r == expected_r); } pub fn __umodsi3(n: u32, d: u32) callconv(.C) u32 { @@ -583,7 +583,7 @@ test "test_umodsi3" { fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) void { const r: u32 = __umodsi3(a, b); - testing.expect(r == expected_r); + try testing.expect(r == expected_r); } pub fn __mulsi3(a: i32, b: i32) callconv(.C) i32 { diff --git a/lib/std/special/compiler_rt/modti3_test.zig b/lib/std/special/compiler_rt/modti3_test.zig index 644c9027b7..e3d670ef13 100644 --- a/lib/std/special/compiler_rt/modti3_test.zig +++ b/lib/std/special/compiler_rt/modti3_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__modti3(a: i128, b: i128, expected: i128) void { const x = __modti3(a, b); - testing.expect(x == expected); + try testing.expect(x == expected); } test "modti3" { diff --git a/lib/std/special/compiler_rt/muldi3_test.zig b/lib/std/special/compiler_rt/muldi3_test.zig index 78023f514b..3bf3e7626f 100644 --- a/lib/std/special/compiler_rt/muldi3_test.zig +++ b/lib/std/special/compiler_rt/muldi3_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__muldi3(a: i64, b: i64, expected: i64) void { const x = __muldi3(a, b); - testing.expect(x == expected); + try testing.expect(x == expected); } test "muldi3" { diff --git a/lib/std/special/compiler_rt/mulodi4_test.zig b/lib/std/special/compiler_rt/mulodi4_test.zig index 7d7658e192..26082cf74e 100644 --- a/lib/std/special/compiler_rt/mulodi4_test.zig +++ b/lib/std/special/compiler_rt/mulodi4_test.zig @@ -9,7 +9,7 @@ const testing = @import("std").testing; fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) void { var overflow: c_int = undefined; const x = __mulodi4(a, b, &overflow); - testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); + try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); } test "mulodi4" { diff --git a/lib/std/special/compiler_rt/muloti4_test.zig b/lib/std/special/compiler_rt/muloti4_test.zig index 83722df6a5..7ff0650145 100644 --- a/lib/std/special/compiler_rt/muloti4_test.zig +++ b/lib/std/special/compiler_rt/muloti4_test.zig @@ -9,7 +9,7 @@ const testing = @import("std").testing; fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void { var overflow: c_int = undefined; const x = __muloti4(a, b, &overflow); - testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); + try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); } test "muloti4" { diff --git a/lib/std/special/compiler_rt/multi3_test.zig b/lib/std/special/compiler_rt/multi3_test.zig index 674cf1cb9b..b5c5bd3836 100644 --- a/lib/std/special/compiler_rt/multi3_test.zig +++ b/lib/std/special/compiler_rt/multi3_test.zig @@ -8,7 +8,7 @@ const testing = @import("std").testing; fn test__multi3(a: i128, b: i128, expected: i128) void { const x = __multi3(a, b); - testing.expect(x == expected); + try testing.expect(x == expected); } test "multi3" { diff --git a/lib/std/special/compiler_rt/popcountdi2_test.zig b/lib/std/special/compiler_rt/popcountdi2_test.zig index d0665bf278..3cb7d00c97 100644 --- a/lib/std/special/compiler_rt/popcountdi2_test.zig +++ b/lib/std/special/compiler_rt/popcountdi2_test.zig @@ -18,7 +18,7 @@ fn naive_popcount(a_param: i64) i32 { fn test__popcountdi2(a: i64) void { const x = __popcountdi2(a); const expected = naive_popcount(a); - testing.expect(expected == x); + try testing.expect(expected == x); } test "popcountdi2" { diff --git a/lib/std/special/compiler_rt/udivmoddi4_test.zig b/lib/std/special/compiler_rt/udivmoddi4_test.zig index d3f39a0589..e652afa316 100644 --- a/lib/std/special/compiler_rt/udivmoddi4_test.zig +++ b/lib/std/special/compiler_rt/udivmoddi4_test.zig @@ -11,8 +11,8 @@ const testing = @import("std").testing; fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void { var r: u64 = undefined; const q = __udivmoddi4(a, b, &r); - testing.expect(q == expected_q); - testing.expect(r == expected_r); + try testing.expect(q == expected_q); + try testing.expect(r == expected_r); } test "udivmoddi4" { diff --git a/lib/std/special/compiler_rt/udivmodti4_test.zig b/lib/std/special/compiler_rt/udivmodti4_test.zig index 667b27f0aa..2ada7eda09 100644 --- a/lib/std/special/compiler_rt/udivmodti4_test.zig +++ b/lib/std/special/compiler_rt/udivmodti4_test.zig @@ -11,8 +11,8 @@ const testing = @import("std").testing; fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void { var r: u128 = undefined; const q = __udivmodti4(a, b, &r); - testing.expect(q == expected_q); - testing.expect(r == expected_r); + try testing.expect(q == expected_q); + try testing.expect(r == expected_r); } test "udivmodti4" { diff --git a/lib/std/special/init-lib/src/main.zig b/lib/std/special/init-lib/src/main.zig index 747bb08573..ecfeade1a3 100644 --- a/lib/std/special/init-lib/src/main.zig +++ b/lib/std/special/init-lib/src/main.zig @@ -6,5 +6,5 @@ export fn add(a: i32, b: i32) i32 { } test "basic add functionality" { - testing.expect(add(3, 7) == 10); + try testing.expect(add(3, 7) == 10); } diff --git a/lib/std/time.zig b/lib/std/time.zig index f0118d2642..99304af46a 100644 --- a/lib/std/time.zig +++ b/lib/std/time.zig @@ -271,7 +271,7 @@ test "timestamp" { sleep(ns_per_ms); const time_1 = milliTimestamp(); const interval = time_1 - time_0; - testing.expect(interval > 0); + try testing.expect(interval > 0); // Tests should not depend on timings: skip test if outside margin. if (!(interval < margin)) return error.SkipZigTest; } @@ -282,13 +282,13 @@ test "Timer" { var timer = try Timer.start(); sleep(10 * ns_per_ms); const time_0 = timer.read(); - testing.expect(time_0 > 0); + try testing.expect(time_0 > 0); // Tests should not depend on timings: skip test if outside margin. if (!(time_0 < margin)) return error.SkipZigTest; const time_1 = timer.lap(); - testing.expect(time_1 >= time_0); + try testing.expect(time_1 >= time_0); timer.reset(); - testing.expect(timer.read() < time_1); + try testing.expect(timer.read() < time_1); } diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig index 9eed0f466f..ca666097bb 100644 --- a/lib/std/unicode.zig +++ b/lib/std/unicode.zig @@ -336,224 +336,224 @@ pub const Utf16LeIterator = struct { }; test "utf8 encode" { - comptime testUtf8Encode() catch unreachable; + comptime try testUtf8Encode(); try testUtf8Encode(); } fn testUtf8Encode() !void { // A few taken from wikipedia a few taken elsewhere var array: [4]u8 = undefined; - testing.expect((try utf8Encode(try utf8Decode("€"), array[0..])) == 3); - testing.expect(array[0] == 0b11100010); - testing.expect(array[1] == 0b10000010); - testing.expect(array[2] == 0b10101100); + try testing.expect((try utf8Encode(try utf8Decode("€"), array[0..])) == 3); + try testing.expect(array[0] == 0b11100010); + try testing.expect(array[1] == 0b10000010); + try testing.expect(array[2] == 0b10101100); - testing.expect((try utf8Encode(try utf8Decode("$"), array[0..])) == 1); - testing.expect(array[0] == 0b00100100); + try testing.expect((try utf8Encode(try utf8Decode("$"), array[0..])) == 1); + try testing.expect(array[0] == 0b00100100); - testing.expect((try utf8Encode(try utf8Decode("Β’"), array[0..])) == 2); - testing.expect(array[0] == 0b11000010); - testing.expect(array[1] == 0b10100010); + try testing.expect((try utf8Encode(try utf8Decode("Β’"), array[0..])) == 2); + try testing.expect(array[0] == 0b11000010); + try testing.expect(array[1] == 0b10100010); - testing.expect((try utf8Encode(try utf8Decode("𐍈"), array[0..])) == 4); - testing.expect(array[0] == 0b11110000); - testing.expect(array[1] == 0b10010000); - testing.expect(array[2] == 0b10001101); - testing.expect(array[3] == 0b10001000); + try testing.expect((try utf8Encode(try utf8Decode("𐍈"), array[0..])) == 4); + try testing.expect(array[0] == 0b11110000); + try testing.expect(array[1] == 0b10010000); + try testing.expect(array[2] == 0b10001101); + try testing.expect(array[3] == 0b10001000); } test "utf8 encode error" { - comptime testUtf8EncodeError(); - testUtf8EncodeError(); + comptime try testUtf8EncodeError(); + try testUtf8EncodeError(); } -fn testUtf8EncodeError() void { +fn testUtf8EncodeError() !void { var array: [4]u8 = undefined; - testErrorEncode(0xd800, array[0..], error.Utf8CannotEncodeSurrogateHalf); - testErrorEncode(0xdfff, array[0..], error.Utf8CannotEncodeSurrogateHalf); - testErrorEncode(0x110000, array[0..], error.CodepointTooLarge); - testErrorEncode(0x1fffff, array[0..], error.CodepointTooLarge); + try testErrorEncode(0xd800, array[0..], error.Utf8CannotEncodeSurrogateHalf); + try testErrorEncode(0xdfff, array[0..], error.Utf8CannotEncodeSurrogateHalf); + try testErrorEncode(0x110000, array[0..], error.CodepointTooLarge); + try testErrorEncode(0x1fffff, array[0..], error.CodepointTooLarge); } -fn testErrorEncode(codePoint: u21, array: []u8, expectedErr: anyerror) void { - testing.expectError(expectedErr, utf8Encode(codePoint, array)); +fn testErrorEncode(codePoint: u21, array: []u8, expectedErr: anyerror) !void { + try testing.expectError(expectedErr, utf8Encode(codePoint, array)); } test "utf8 iterator on ascii" { - comptime testUtf8IteratorOnAscii(); - testUtf8IteratorOnAscii(); + comptime try testUtf8IteratorOnAscii(); + try testUtf8IteratorOnAscii(); } -fn testUtf8IteratorOnAscii() void { +fn testUtf8IteratorOnAscii() !void { const s = Utf8View.initComptime("abc"); var it1 = s.iterator(); - testing.expect(std.mem.eql(u8, "a", it1.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "b", it1.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "c", it1.nextCodepointSlice().?)); - testing.expect(it1.nextCodepointSlice() == null); + try testing.expect(std.mem.eql(u8, "a", it1.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "b", it1.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "c", it1.nextCodepointSlice().?)); + try testing.expect(it1.nextCodepointSlice() == null); var it2 = s.iterator(); - testing.expect(it2.nextCodepoint().? == 'a'); - testing.expect(it2.nextCodepoint().? == 'b'); - testing.expect(it2.nextCodepoint().? == 'c'); - testing.expect(it2.nextCodepoint() == null); + try testing.expect(it2.nextCodepoint().? == 'a'); + try testing.expect(it2.nextCodepoint().? == 'b'); + try testing.expect(it2.nextCodepoint().? == 'c'); + try testing.expect(it2.nextCodepoint() == null); } test "utf8 view bad" { - comptime testUtf8ViewBad(); - testUtf8ViewBad(); + comptime try testUtf8ViewBad(); + try testUtf8ViewBad(); } -fn testUtf8ViewBad() void { +fn testUtf8ViewBad() !void { // Compile-time error. // const s3 = Utf8View.initComptime("\xfe\xf2"); - testing.expectError(error.InvalidUtf8, Utf8View.init("hel\xadlo")); + try testing.expectError(error.InvalidUtf8, Utf8View.init("hel\xadlo")); } test "utf8 view ok" { - comptime testUtf8ViewOk(); - testUtf8ViewOk(); + comptime try testUtf8ViewOk(); + try testUtf8ViewOk(); } -fn testUtf8ViewOk() void { +fn testUtf8ViewOk() !void { const s = Utf8View.initComptime("東京市"); var it1 = s.iterator(); - testing.expect(std.mem.eql(u8, "東", it1.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "δΊ¬", it1.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "εΈ‚", it1.nextCodepointSlice().?)); - testing.expect(it1.nextCodepointSlice() == null); + try testing.expect(std.mem.eql(u8, "東", it1.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "δΊ¬", it1.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "εΈ‚", it1.nextCodepointSlice().?)); + try testing.expect(it1.nextCodepointSlice() == null); var it2 = s.iterator(); - testing.expect(it2.nextCodepoint().? == 0x6771); - testing.expect(it2.nextCodepoint().? == 0x4eac); - testing.expect(it2.nextCodepoint().? == 0x5e02); - testing.expect(it2.nextCodepoint() == null); + try testing.expect(it2.nextCodepoint().? == 0x6771); + try testing.expect(it2.nextCodepoint().? == 0x4eac); + try testing.expect(it2.nextCodepoint().? == 0x5e02); + try testing.expect(it2.nextCodepoint() == null); } test "bad utf8 slice" { - comptime testBadUtf8Slice(); - testBadUtf8Slice(); + comptime try testBadUtf8Slice(); + try testBadUtf8Slice(); } -fn testBadUtf8Slice() void { - testing.expect(utf8ValidateSlice("abc")); - testing.expect(!utf8ValidateSlice("abc\xc0")); - testing.expect(!utf8ValidateSlice("abc\xc0abc")); - testing.expect(utf8ValidateSlice("abc\xdf\xbf")); +fn testBadUtf8Slice() !void { + try testing.expect(utf8ValidateSlice("abc")); + try testing.expect(!utf8ValidateSlice("abc\xc0")); + try testing.expect(!utf8ValidateSlice("abc\xc0abc")); + try testing.expect(utf8ValidateSlice("abc\xdf\xbf")); } test "valid utf8" { - comptime testValidUtf8(); - testValidUtf8(); + comptime try testValidUtf8(); + try testValidUtf8(); } -fn testValidUtf8() void { - testValid("\x00", 0x0); - testValid("\x20", 0x20); - testValid("\x7f", 0x7f); - testValid("\xc2\x80", 0x80); - testValid("\xdf\xbf", 0x7ff); - testValid("\xe0\xa0\x80", 0x800); - testValid("\xe1\x80\x80", 0x1000); - testValid("\xef\xbf\xbf", 0xffff); - testValid("\xf0\x90\x80\x80", 0x10000); - testValid("\xf1\x80\x80\x80", 0x40000); - testValid("\xf3\xbf\xbf\xbf", 0xfffff); - testValid("\xf4\x8f\xbf\xbf", 0x10ffff); +fn testValidUtf8() !void { + try testValid("\x00", 0x0); + try testValid("\x20", 0x20); + try testValid("\x7f", 0x7f); + try testValid("\xc2\x80", 0x80); + try testValid("\xdf\xbf", 0x7ff); + try testValid("\xe0\xa0\x80", 0x800); + try testValid("\xe1\x80\x80", 0x1000); + try testValid("\xef\xbf\xbf", 0xffff); + try testValid("\xf0\x90\x80\x80", 0x10000); + try testValid("\xf1\x80\x80\x80", 0x40000); + try testValid("\xf3\xbf\xbf\xbf", 0xfffff); + try testValid("\xf4\x8f\xbf\xbf", 0x10ffff); } test "invalid utf8 continuation bytes" { - comptime testInvalidUtf8ContinuationBytes(); - testInvalidUtf8ContinuationBytes(); + comptime try testInvalidUtf8ContinuationBytes(); + try testInvalidUtf8ContinuationBytes(); } -fn testInvalidUtf8ContinuationBytes() void { +fn testInvalidUtf8ContinuationBytes() !void { // unexpected continuation - testError("\x80", error.Utf8InvalidStartByte); - testError("\xbf", error.Utf8InvalidStartByte); + try testError("\x80", error.Utf8InvalidStartByte); + try testError("\xbf", error.Utf8InvalidStartByte); // too many leading 1's - testError("\xf8", error.Utf8InvalidStartByte); - testError("\xff", error.Utf8InvalidStartByte); + try testError("\xf8", error.Utf8InvalidStartByte); + try testError("\xff", error.Utf8InvalidStartByte); // expected continuation for 2 byte sequences - testError("\xc2", error.UnexpectedEof); - testError("\xc2\x00", error.Utf8ExpectedContinuation); - testError("\xc2\xc0", error.Utf8ExpectedContinuation); + try testError("\xc2", error.UnexpectedEof); + try testError("\xc2\x00", error.Utf8ExpectedContinuation); + try testError("\xc2\xc0", error.Utf8ExpectedContinuation); // expected continuation for 3 byte sequences - testError("\xe0", error.UnexpectedEof); - testError("\xe0\x00", error.UnexpectedEof); - testError("\xe0\xc0", error.UnexpectedEof); - testError("\xe0\xa0", error.UnexpectedEof); - testError("\xe0\xa0\x00", error.Utf8ExpectedContinuation); - testError("\xe0\xa0\xc0", error.Utf8ExpectedContinuation); + try testError("\xe0", error.UnexpectedEof); + try testError("\xe0\x00", error.UnexpectedEof); + try testError("\xe0\xc0", error.UnexpectedEof); + try testError("\xe0\xa0", error.UnexpectedEof); + try testError("\xe0\xa0\x00", error.Utf8ExpectedContinuation); + try testError("\xe0\xa0\xc0", error.Utf8ExpectedContinuation); // expected continuation for 4 byte sequences - testError("\xf0", error.UnexpectedEof); - testError("\xf0\x00", error.UnexpectedEof); - testError("\xf0\xc0", error.UnexpectedEof); - testError("\xf0\x90\x00", error.UnexpectedEof); - testError("\xf0\x90\xc0", error.UnexpectedEof); - testError("\xf0\x90\x80\x00", error.Utf8ExpectedContinuation); - testError("\xf0\x90\x80\xc0", error.Utf8ExpectedContinuation); + try testError("\xf0", error.UnexpectedEof); + try testError("\xf0\x00", error.UnexpectedEof); + try testError("\xf0\xc0", error.UnexpectedEof); + try testError("\xf0\x90\x00", error.UnexpectedEof); + try testError("\xf0\x90\xc0", error.UnexpectedEof); + try testError("\xf0\x90\x80\x00", error.Utf8ExpectedContinuation); + try testError("\xf0\x90\x80\xc0", error.Utf8ExpectedContinuation); } test "overlong utf8 codepoint" { - comptime testOverlongUtf8Codepoint(); - testOverlongUtf8Codepoint(); + comptime try testOverlongUtf8Codepoint(); + try testOverlongUtf8Codepoint(); } -fn testOverlongUtf8Codepoint() void { - testError("\xc0\x80", error.Utf8OverlongEncoding); - testError("\xc1\xbf", error.Utf8OverlongEncoding); - testError("\xe0\x80\x80", error.Utf8OverlongEncoding); - testError("\xe0\x9f\xbf", error.Utf8OverlongEncoding); - testError("\xf0\x80\x80\x80", error.Utf8OverlongEncoding); - testError("\xf0\x8f\xbf\xbf", error.Utf8OverlongEncoding); +fn testOverlongUtf8Codepoint() !void { + try testError("\xc0\x80", error.Utf8OverlongEncoding); + try testError("\xc1\xbf", error.Utf8OverlongEncoding); + try testError("\xe0\x80\x80", error.Utf8OverlongEncoding); + try testError("\xe0\x9f\xbf", error.Utf8OverlongEncoding); + try testError("\xf0\x80\x80\x80", error.Utf8OverlongEncoding); + try testError("\xf0\x8f\xbf\xbf", error.Utf8OverlongEncoding); } test "misc invalid utf8" { - comptime testMiscInvalidUtf8(); - testMiscInvalidUtf8(); + comptime try testMiscInvalidUtf8(); + try testMiscInvalidUtf8(); } -fn testMiscInvalidUtf8() void { +fn testMiscInvalidUtf8() !void { // codepoint out of bounds - testError("\xf4\x90\x80\x80", error.Utf8CodepointTooLarge); - testError("\xf7\xbf\xbf\xbf", error.Utf8CodepointTooLarge); + try testError("\xf4\x90\x80\x80", error.Utf8CodepointTooLarge); + try testError("\xf7\xbf\xbf\xbf", error.Utf8CodepointTooLarge); // surrogate halves - testValid("\xed\x9f\xbf", 0xd7ff); - testError("\xed\xa0\x80", error.Utf8EncodesSurrogateHalf); - testError("\xed\xbf\xbf", error.Utf8EncodesSurrogateHalf); - testValid("\xee\x80\x80", 0xe000); + try testValid("\xed\x9f\xbf", 0xd7ff); + try testError("\xed\xa0\x80", error.Utf8EncodesSurrogateHalf); + try testError("\xed\xbf\xbf", error.Utf8EncodesSurrogateHalf); + try testValid("\xee\x80\x80", 0xe000); } test "utf8 iterator peeking" { - comptime testUtf8Peeking(); - testUtf8Peeking(); + comptime try testUtf8Peeking(); + try testUtf8Peeking(); } -fn testUtf8Peeking() void { +fn testUtf8Peeking() !void { const s = Utf8View.initComptime("noΓ«l"); var it = s.iterator(); - testing.expect(std.mem.eql(u8, "n", it.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "n", it.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "o", it.peek(1))); - testing.expect(std.mem.eql(u8, "oΓ«", it.peek(2))); - testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(3))); - testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(4))); - testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(10))); + try testing.expect(std.mem.eql(u8, "o", it.peek(1))); + try testing.expect(std.mem.eql(u8, "oΓ«", it.peek(2))); + try testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(3))); + try testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(4))); + try testing.expect(std.mem.eql(u8, "oΓ«l", it.peek(10))); - testing.expect(std.mem.eql(u8, "o", it.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "Γ«", it.nextCodepointSlice().?)); - testing.expect(std.mem.eql(u8, "l", it.nextCodepointSlice().?)); - testing.expect(it.nextCodepointSlice() == null); + try testing.expect(std.mem.eql(u8, "o", it.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "Γ«", it.nextCodepointSlice().?)); + try testing.expect(std.mem.eql(u8, "l", it.nextCodepointSlice().?)); + try testing.expect(it.nextCodepointSlice() == null); - testing.expect(std.mem.eql(u8, &[_]u8{}, it.peek(1))); + try testing.expect(std.mem.eql(u8, &[_]u8{}, it.peek(1))); } -fn testError(bytes: []const u8, expected_err: anyerror) void { - testing.expectError(expected_err, testDecode(bytes)); +fn testError(bytes: []const u8, expected_err: anyerror) !void { + try testing.expectError(expected_err, testDecode(bytes)); } -fn testValid(bytes: []const u8, expected_codepoint: u21) void { - testing.expect((testDecode(bytes) catch unreachable) == expected_codepoint); +fn testValid(bytes: []const u8, expected_codepoint: u21) !void { + try testing.expect((testDecode(bytes) catch unreachable) == expected_codepoint); } fn testDecode(bytes: []const u8) !u21 { const length = try utf8ByteSequenceLength(bytes[0]); if (bytes.len < length) return error.UnexpectedEof; - testing.expect(bytes.len == length); + try testing.expect(bytes.len == length); return utf8Decode(bytes); } @@ -615,7 +615,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 'a'); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "Aa")); + try testing.expect(mem.eql(u8, utf8, "Aa")); } { @@ -623,7 +623,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xffff); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf")); + try testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf")); } { @@ -632,7 +632,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xe000); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80")); + try testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80")); } { @@ -641,7 +641,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80")); + try testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80")); } { @@ -650,7 +650,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdfff); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf")); + try testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf")); } { @@ -658,7 +658,7 @@ test "utf16leToUtf8" { mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00); const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le); defer std.testing.allocator.free(utf8); - testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80")); + try testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80")); } } @@ -717,13 +717,13 @@ test "utf8ToUtf16Le" { var utf16le: [2]u16 = [_]u16{0} ** 2; { const length = try utf8ToUtf16Le(utf16le[0..], "𐐷"); - testing.expectEqual(@as(usize, 2), length); - testing.expectEqualSlices(u8, "\x01\xd8\x37\xdc", mem.sliceAsBytes(utf16le[0..])); + try testing.expectEqual(@as(usize, 2), length); + try testing.expectEqualSlices(u8, "\x01\xd8\x37\xdc", mem.sliceAsBytes(utf16le[0..])); } { const length = try utf8ToUtf16Le(utf16le[0..], "\u{10FFFF}"); - testing.expectEqual(@as(usize, 2), length); - testing.expectEqualSlices(u8, "\xff\xdb\xff\xdf", mem.sliceAsBytes(utf16le[0..])); + try testing.expectEqual(@as(usize, 2), length); + try testing.expectEqualSlices(u8, "\xff\xdb\xff\xdf", mem.sliceAsBytes(utf16le[0..])); } } @@ -731,14 +731,14 @@ test "utf8ToUtf16LeWithNull" { { const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "𐐷"); defer testing.allocator.free(utf16); - testing.expectEqualSlices(u8, "\x01\xd8\x37\xdc", mem.sliceAsBytes(utf16[0..])); - testing.expect(utf16[2] == 0); + try testing.expectEqualSlices(u8, "\x01\xd8\x37\xdc", mem.sliceAsBytes(utf16[0..])); + try testing.expect(utf16[2] == 0); } { const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "\u{10FFFF}"); defer testing.allocator.free(utf16); - testing.expectEqualSlices(u8, "\xff\xdb\xff\xdf", mem.sliceAsBytes(utf16[0..])); - testing.expect(utf16[2] == 0); + try testing.expectEqualSlices(u8, "\xff\xdb\xff\xdf", mem.sliceAsBytes(utf16[0..])); + try testing.expect(utf16[2] == 0); } } @@ -776,8 +776,8 @@ test "utf8ToUtf16LeStringLiteral" { mem.nativeToLittle(u16, 0x41), }; const utf16 = utf8ToUtf16LeStringLiteral("A"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[1] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[1] == 0); } { const bytes = [_:0]u16{ @@ -785,32 +785,32 @@ test "utf8ToUtf16LeStringLiteral" { mem.nativeToLittle(u16, 0xDC37), }; const utf16 = utf8ToUtf16LeStringLiteral("𐐷"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[2] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[2] == 0); } { const bytes = [_:0]u16{ mem.nativeToLittle(u16, 0x02FF), }; const utf16 = utf8ToUtf16LeStringLiteral("\u{02FF}"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[1] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[1] == 0); } { const bytes = [_:0]u16{ mem.nativeToLittle(u16, 0x7FF), }; const utf16 = utf8ToUtf16LeStringLiteral("\u{7FF}"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[1] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[1] == 0); } { const bytes = [_:0]u16{ mem.nativeToLittle(u16, 0x801), }; const utf16 = utf8ToUtf16LeStringLiteral("\u{801}"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[1] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[1] == 0); } { const bytes = [_:0]u16{ @@ -818,35 +818,35 @@ test "utf8ToUtf16LeStringLiteral" { mem.nativeToLittle(u16, 0xDFFF), }; const utf16 = utf8ToUtf16LeStringLiteral("\u{10FFFF}"); - testing.expectEqualSlices(u16, &bytes, utf16); - testing.expect(utf16[2] == 0); + try testing.expectEqualSlices(u16, &bytes, utf16); + try testing.expect(utf16[2] == 0); } } fn testUtf8CountCodepoints() !void { - testing.expectEqual(@as(usize, 10), try utf8CountCodepoints("abcdefghij")); - testing.expectEqual(@as(usize, 10), try utf8CountCodepoints("Γ€Γ₯éëþüúíóâ")); - testing.expectEqual(@as(usize, 5), try utf8CountCodepoints("こんにけは")); + try testing.expectEqual(@as(usize, 10), try utf8CountCodepoints("abcdefghij")); + try testing.expectEqual(@as(usize, 10), try utf8CountCodepoints("Γ€Γ₯éëþüúíóâ")); + try testing.expectEqual(@as(usize, 5), try utf8CountCodepoints("こんにけは")); // testing.expectError(error.Utf8EncodesSurrogateHalf, utf8CountCodepoints("\xED\xA0\x80")); } test "utf8 count codepoints" { try testUtf8CountCodepoints(); - comptime testUtf8CountCodepoints() catch unreachable; + comptime try testUtf8CountCodepoints(); } fn testUtf8ValidCodepoint() !void { - testing.expect(utf8ValidCodepoint('e')); - testing.expect(utf8ValidCodepoint('Γ«')); - testing.expect(utf8ValidCodepoint('は')); - testing.expect(utf8ValidCodepoint(0xe000)); - testing.expect(utf8ValidCodepoint(0x10ffff)); - testing.expect(!utf8ValidCodepoint(0xd800)); - testing.expect(!utf8ValidCodepoint(0xdfff)); - testing.expect(!utf8ValidCodepoint(0x110000)); + try testing.expect(utf8ValidCodepoint('e')); + try testing.expect(utf8ValidCodepoint('Γ«')); + try testing.expect(utf8ValidCodepoint('は')); + try testing.expect(utf8ValidCodepoint(0xe000)); + try testing.expect(utf8ValidCodepoint(0x10ffff)); + try testing.expect(!utf8ValidCodepoint(0xd800)); + try testing.expect(!utf8ValidCodepoint(0xdfff)); + try testing.expect(!utf8ValidCodepoint(0x110000)); } test "utf8 valid codepoint" { try testUtf8ValidCodepoint(); - comptime testUtf8ValidCodepoint() catch unreachable; + comptime try testUtf8ValidCodepoint(); } diff --git a/lib/std/valgrind/memcheck.zig b/lib/std/valgrind/memcheck.zig index 3226beec53..8262e39fe9 100644 --- a/lib/std/valgrind/memcheck.zig +++ b/lib/std/valgrind/memcheck.zig @@ -149,7 +149,7 @@ pub fn countLeaks() CountResult { } test "countLeaks" { - testing.expectEqual( + try testing.expectEqual( @as(CountResult, .{ .leaked = 0, .dubious = 0, @@ -179,7 +179,7 @@ pub fn countLeakBlocks() CountResult { } test "countLeakBlocks" { - testing.expectEqual( + try testing.expectEqual( @as(CountResult, .{ .leaked = 0, .dubious = 0, diff --git a/lib/std/wasm.zig b/lib/std/wasm.zig index ad6b947f67..8922b3c83e 100644 --- a/lib/std/wasm.zig +++ b/lib/std/wasm.zig @@ -200,11 +200,11 @@ test "Wasm - opcodes" { const local_get = opcode(.local_get); const i64_extend32_s = opcode(.i64_extend32_s); - testing.expectEqual(@as(u16, 0x41), i32_const); - testing.expectEqual(@as(u16, 0x0B), end); - testing.expectEqual(@as(u16, 0x1A), drop); - testing.expectEqual(@as(u16, 0x20), local_get); - testing.expectEqual(@as(u16, 0xC4), i64_extend32_s); + try testing.expectEqual(@as(u16, 0x41), i32_const); + try testing.expectEqual(@as(u16, 0x0B), end); + try testing.expectEqual(@as(u16, 0x1A), drop); + try testing.expectEqual(@as(u16, 0x20), local_get); + try testing.expectEqual(@as(u16, 0xC4), i64_extend32_s); } /// Enum representing all Wasm value types as per spec: @@ -227,10 +227,10 @@ test "Wasm - valtypes" { const _f32 = valtype(.f32); const _f64 = valtype(.f64); - testing.expectEqual(@as(u8, 0x7F), _i32); - testing.expectEqual(@as(u8, 0x7E), _i64); - testing.expectEqual(@as(u8, 0x7D), _f32); - testing.expectEqual(@as(u8, 0x7C), _f64); + try testing.expectEqual(@as(u8, 0x7F), _i32); + try testing.expectEqual(@as(u8, 0x7E), _i64); + try testing.expectEqual(@as(u8, 0x7D), _f32); + try testing.expectEqual(@as(u8, 0x7C), _f64); } /// Wasm module sections as per spec: diff --git a/lib/std/x/net/tcp.zig b/lib/std/x/net/tcp.zig index a4cc4a288c..0740e3ab4f 100644 --- a/lib/std/x/net/tcp.zig +++ b/lib/std/x/net/tcp.zig @@ -322,7 +322,7 @@ test "tcp/client: set read timeout of 1 millisecond on blocking client" { defer conn.deinit(); var buf: [1]u8 = undefined; - testing.expectError(error.WouldBlock, client.read(&buf)); + try testing.expectError(error.WouldBlock, client.read(&buf)); } test "tcp/listener: bind to unspecified ipv4 address" { @@ -335,7 +335,7 @@ test "tcp/listener: bind to unspecified ipv4 address" { try listener.listen(128); const address = try listener.getLocalAddress(); - testing.expect(address == .ipv4); + try testing.expect(address == .ipv4); } test "tcp/listener: bind to unspecified ipv6 address" { @@ -348,5 +348,5 @@ test "tcp/listener: bind to unspecified ipv6 address" { try listener.listen(128); const address = try listener.getLocalAddress(); - testing.expect(address == .ipv6); + try testing.expect(address == .ipv6); } diff --git a/lib/std/x/os/net.zig b/lib/std/x/os/net.zig index a8d9f095d3..7cd400cc0a 100644 --- a/lib/std/x/os/net.zig +++ b/lib/std/x/os/net.zig @@ -499,12 +499,12 @@ test { test "ip: convert to and from ipv6" { try testing.expectFmt("::7f00:1", "{}", .{IPv4.localhost.toIPv6()}); - testing.expect(!IPv4.localhost.toIPv6().mapsToIPv4()); + try testing.expect(!IPv4.localhost.toIPv6().mapsToIPv4()); try testing.expectFmt("::ffff:127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6()}); - testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4()); + try testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4()); - testing.expect(IPv4.localhost.toIPv6().toIPv4() == null); + try testing.expect(IPv4.localhost.toIPv6().toIPv4() == null); try testing.expectFmt("127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6().toIPv4()}); } diff --git a/lib/std/zig.zig b/lib/std/zig.zig index a06249dd4f..daf440c796 100644 --- a/lib/std/zig.zig +++ b/lib/std/zig.zig @@ -253,26 +253,26 @@ pub fn parseCharLiteral( test "parseCharLiteral" { var bad_index: usize = undefined; - std.testing.expectEqual(try parseCharLiteral("'a'", &bad_index), 'a'); - std.testing.expectEqual(try parseCharLiteral("'Γ€'", &bad_index), 'Γ€'); - std.testing.expectEqual(try parseCharLiteral("'\\x00'", &bad_index), 0); - std.testing.expectEqual(try parseCharLiteral("'\\x4f'", &bad_index), 0x4f); - std.testing.expectEqual(try parseCharLiteral("'\\x4F'", &bad_index), 0x4f); - std.testing.expectEqual(try parseCharLiteral("'ぁ'", &bad_index), 0x3041); - std.testing.expectEqual(try parseCharLiteral("'\\u{0}'", &bad_index), 0); - std.testing.expectEqual(try parseCharLiteral("'\\u{3041}'", &bad_index), 0x3041); - std.testing.expectEqual(try parseCharLiteral("'\\u{7f}'", &bad_index), 0x7f); - std.testing.expectEqual(try parseCharLiteral("'\\u{7FFF}'", &bad_index), 0x7FFF); + try std.testing.expectEqual(try parseCharLiteral("'a'", &bad_index), 'a'); + try std.testing.expectEqual(try parseCharLiteral("'Γ€'", &bad_index), 'Γ€'); + try std.testing.expectEqual(try parseCharLiteral("'\\x00'", &bad_index), 0); + try std.testing.expectEqual(try parseCharLiteral("'\\x4f'", &bad_index), 0x4f); + try std.testing.expectEqual(try parseCharLiteral("'\\x4F'", &bad_index), 0x4f); + try std.testing.expectEqual(try parseCharLiteral("'ぁ'", &bad_index), 0x3041); + try std.testing.expectEqual(try parseCharLiteral("'\\u{0}'", &bad_index), 0); + try std.testing.expectEqual(try parseCharLiteral("'\\u{3041}'", &bad_index), 0x3041); + try std.testing.expectEqual(try parseCharLiteral("'\\u{7f}'", &bad_index), 0x7f); + try std.testing.expectEqual(try parseCharLiteral("'\\u{7FFF}'", &bad_index), 0x7FFF); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x0'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x000'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\y'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\uFFFF'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{}'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFFFF}'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF'", &bad_index)); - std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF}x'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x0'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x000'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\y'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\uFFFF'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{}'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFFFF}'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF'", &bad_index)); + try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF}x'", &bad_index)); } test { diff --git a/lib/std/zig/cross_target.zig b/lib/std/zig/cross_target.zig index 8d6f63f5e3..bf62a49ef6 100644 --- a/lib/std/zig/cross_target.zig +++ b/lib/std/zig/cross_target.zig @@ -800,7 +800,7 @@ test "CrossTarget.parse" { .{@tagName(std.Target.current.abi)}, ) catch unreachable; - std.testing.expectEqualSlices(u8, triple, text); + try std.testing.expectEqualSlices(u8, triple, text); } { const cross_target = try CrossTarget.parse(.{ @@ -808,18 +808,18 @@ test "CrossTarget.parse" { .cpu_features = "native", }); - std.testing.expect(cross_target.cpu_arch.? == .aarch64); - std.testing.expect(cross_target.cpu_model == .native); + try std.testing.expect(cross_target.cpu_arch.? == .aarch64); + try std.testing.expect(cross_target.cpu_model == .native); } { const cross_target = try CrossTarget.parse(.{ .arch_os_abi = "native" }); - std.testing.expect(cross_target.cpu_arch == null); - std.testing.expect(cross_target.isNative()); + try std.testing.expect(cross_target.cpu_arch == null); + try std.testing.expect(cross_target.isNative()); const text = try cross_target.zigTriple(std.testing.allocator); defer std.testing.allocator.free(text); - std.testing.expectEqualSlices(u8, "native", text); + try std.testing.expectEqualSlices(u8, "native", text); } { const cross_target = try CrossTarget.parse(.{ @@ -828,23 +828,23 @@ test "CrossTarget.parse" { }); const target = cross_target.toTarget(); - std.testing.expect(target.os.tag == .linux); - std.testing.expect(target.abi == .gnu); - std.testing.expect(target.cpu.arch == .x86_64); - std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .sse)); - std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .avx)); - std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .cx8)); - std.testing.expect(Target.x86.featureSetHas(target.cpu.features, .cmov)); - std.testing.expect(Target.x86.featureSetHas(target.cpu.features, .fxsr)); + try std.testing.expect(target.os.tag == .linux); + try std.testing.expect(target.abi == .gnu); + try std.testing.expect(target.cpu.arch == .x86_64); + try std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .sse)); + try std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .avx)); + try std.testing.expect(!Target.x86.featureSetHas(target.cpu.features, .cx8)); + try std.testing.expect(Target.x86.featureSetHas(target.cpu.features, .cmov)); + try std.testing.expect(Target.x86.featureSetHas(target.cpu.features, .fxsr)); - std.testing.expect(Target.x86.featureSetHasAny(target.cpu.features, .{ .sse, .avx, .cmov })); - std.testing.expect(!Target.x86.featureSetHasAny(target.cpu.features, .{ .sse, .avx })); - std.testing.expect(Target.x86.featureSetHasAll(target.cpu.features, .{ .mmx, .x87 })); - std.testing.expect(!Target.x86.featureSetHasAll(target.cpu.features, .{ .mmx, .x87, .sse })); + try std.testing.expect(Target.x86.featureSetHasAny(target.cpu.features, .{ .sse, .avx, .cmov })); + try std.testing.expect(!Target.x86.featureSetHasAny(target.cpu.features, .{ .sse, .avx })); + try std.testing.expect(Target.x86.featureSetHasAll(target.cpu.features, .{ .mmx, .x87 })); + try std.testing.expect(!Target.x86.featureSetHasAll(target.cpu.features, .{ .mmx, .x87, .sse })); const text = try cross_target.zigTriple(std.testing.allocator); defer std.testing.allocator.free(text); - std.testing.expectEqualSlices(u8, "x86_64-linux-gnu", text); + try std.testing.expectEqualSlices(u8, "x86_64-linux-gnu", text); } { const cross_target = try CrossTarget.parse(.{ @@ -853,15 +853,15 @@ test "CrossTarget.parse" { }); const target = cross_target.toTarget(); - std.testing.expect(target.os.tag == .linux); - std.testing.expect(target.abi == .musleabihf); - std.testing.expect(target.cpu.arch == .arm); - std.testing.expect(target.cpu.model == &Target.arm.cpu.generic); - std.testing.expect(Target.arm.featureSetHas(target.cpu.features, .v8a)); + try std.testing.expect(target.os.tag == .linux); + try std.testing.expect(target.abi == .musleabihf); + try std.testing.expect(target.cpu.arch == .arm); + try std.testing.expect(target.cpu.model == &Target.arm.cpu.generic); + try std.testing.expect(Target.arm.featureSetHas(target.cpu.features, .v8a)); const text = try cross_target.zigTriple(std.testing.allocator); defer std.testing.allocator.free(text); - std.testing.expectEqualSlices(u8, "arm-linux-musleabihf", text); + try std.testing.expectEqualSlices(u8, "arm-linux-musleabihf", text); } { const cross_target = try CrossTarget.parse(.{ @@ -870,21 +870,21 @@ test "CrossTarget.parse" { }); const target = cross_target.toTarget(); - std.testing.expect(target.cpu.arch == .aarch64); - std.testing.expect(target.os.tag == .linux); - std.testing.expect(target.os.version_range.linux.range.min.major == 3); - std.testing.expect(target.os.version_range.linux.range.min.minor == 10); - std.testing.expect(target.os.version_range.linux.range.min.patch == 0); - std.testing.expect(target.os.version_range.linux.range.max.major == 4); - std.testing.expect(target.os.version_range.linux.range.max.minor == 4); - std.testing.expect(target.os.version_range.linux.range.max.patch == 1); - std.testing.expect(target.os.version_range.linux.glibc.major == 2); - std.testing.expect(target.os.version_range.linux.glibc.minor == 27); - std.testing.expect(target.os.version_range.linux.glibc.patch == 0); - std.testing.expect(target.abi == .gnu); + try std.testing.expect(target.cpu.arch == .aarch64); + try std.testing.expect(target.os.tag == .linux); + try std.testing.expect(target.os.version_range.linux.range.min.major == 3); + try std.testing.expect(target.os.version_range.linux.range.min.minor == 10); + try std.testing.expect(target.os.version_range.linux.range.min.patch == 0); + try std.testing.expect(target.os.version_range.linux.range.max.major == 4); + try std.testing.expect(target.os.version_range.linux.range.max.minor == 4); + try std.testing.expect(target.os.version_range.linux.range.max.patch == 1); + try std.testing.expect(target.os.version_range.linux.glibc.major == 2); + try std.testing.expect(target.os.version_range.linux.glibc.minor == 27); + try std.testing.expect(target.os.version_range.linux.glibc.patch == 0); + try std.testing.expect(target.abi == .gnu); const text = try cross_target.zigTriple(std.testing.allocator); defer std.testing.allocator.free(text); - std.testing.expectEqualSlices(u8, "aarch64-linux.3.10...4.4.1-gnu.2.27", text); + try std.testing.expectEqualSlices(u8, "aarch64-linux.3.10...4.4.1-gnu.2.27", text); } } diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig index fe119a5d27..9cc350b1ad 100644 --- a/lib/std/zig/parser_test.zig +++ b/lib/std/zig/parser_test.zig @@ -988,7 +988,7 @@ test "zig fmt: while else err prong with no block" { \\ const result = while (returnError()) |value| { \\ break value; \\ } else |err| @as(i32, 2); - \\ expect(result == 2); + \\ try expect(result == 2); \\} \\ ); @@ -5135,7 +5135,7 @@ test "recovery: missing while rbrace" { const std = @import("std"); const mem = std.mem; -const warn = std.debug.warn; +const print = std.debug.print; const io = std.io; const maxInt = std.math.maxInt; @@ -5177,13 +5177,13 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void { var failing_allocator = std.testing.FailingAllocator.init(&fixed_allocator.allocator, maxInt(usize)); var anything_changed: bool = undefined; const result_source = try testParse(source, &failing_allocator.allocator, &anything_changed); - std.testing.expectEqualStrings(expected_source, result_source); + try std.testing.expectEqualStrings(expected_source, result_source); const changes_expected = source.ptr != expected_source.ptr; if (anything_changed != changes_expected) { - warn("std.zig.render returned {} instead of {}\n", .{ anything_changed, changes_expected }); + print("std.zig.render returned {} instead of {}\n", .{ anything_changed, changes_expected }); return error.TestFailed; } - std.testing.expect(anything_changed == changes_expected); + try std.testing.expect(anything_changed == changes_expected); failing_allocator.allocator.free(result_source); break :x failing_allocator.index; }; @@ -5198,7 +5198,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void { } else |err| switch (err) { error.OutOfMemory => { if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) { - warn( + print( "\nfail_index: {d}/{d}\nallocated bytes: {d}\nfreed bytes: {d}\nallocations: {d}\ndeallocations: {d}\n", .{ fail_index, @@ -5212,8 +5212,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void { return error.MemoryLeakDetected; } }, - error.ParseError => @panic("test failed"), - else => @panic("test failed"), + else => return err, } } } @@ -5227,8 +5226,8 @@ fn testError(source: []const u8, expected_errors: []const Error) !void { var tree = try std.zig.parse(std.testing.allocator, source); defer tree.deinit(std.testing.allocator); - std.testing.expectEqual(expected_errors.len, tree.errors.len); + try std.testing.expectEqual(expected_errors.len, tree.errors.len); for (expected_errors) |expected, i| { - std.testing.expectEqual(expected, tree.errors[i].tag); + try std.testing.expectEqual(expected, tree.errors[i].tag); } } diff --git a/lib/std/zig/string_literal.zig b/lib/std/zig/string_literal.zig index e1fa799954..992affc829 100644 --- a/lib/std/zig/string_literal.zig +++ b/lib/std/zig/string_literal.zig @@ -153,7 +153,7 @@ test "parse" { var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(fixed_buf_mem[0..]); var alloc = &fixed_buf_alloc.allocator; - expect(eql(u8, "foo", try parseAlloc(alloc, "\"foo\""))); - expect(eql(u8, "foo", try parseAlloc(alloc, "\"f\x6f\x6f\""))); - expect(eql(u8, "fπŸ’―", try parseAlloc(alloc, "\"f\u{1f4af}\""))); + try expect(eql(u8, "foo", try parseAlloc(alloc, "\"foo\""))); + try expect(eql(u8, "foo", try parseAlloc(alloc, "\"f\x6f\x6f\""))); + try expect(eql(u8, "fπŸ’―", try parseAlloc(alloc, "\"f\u{1f4af}\""))); } diff --git a/lib/std/zig/system/linux.zig b/lib/std/zig/system/linux.zig index c2cf7b009d..e7737dfd70 100644 --- a/lib/std/zig/system/linux.zig +++ b/lib/std/zig/system/linux.zig @@ -414,8 +414,8 @@ fn testParser( ) !void { var fbs = io.fixedBufferStream(input); const result = try parser.parse(arch, fbs.reader()); - testing.expectEqual(expected_model, result.?.model); - testing.expect(expected_model.features.eql(result.?.features)); + try testing.expectEqual(expected_model, result.?.model); + try testing.expect(expected_model.features.eql(result.?.features)); } // The generic implementation of a /proc/cpuinfo parser. diff --git a/lib/std/zig/system/macos.zig b/lib/std/zig/system/macos.zig index abe844d2c4..be892b4834 100644 --- a/lib/std/zig/system/macos.zig +++ b/lib/std/zig/system/macos.zig @@ -402,7 +402,7 @@ fn testVersionEquality(expected: std.builtin.Version, got: std.builtin.Version) var b_got: [64]u8 = undefined; const s_got: []const u8 = try std.fmt.bufPrint(b_got[0..], "{}", .{got}); - testing.expectEqualStrings(s_expected, s_got); + try testing.expectEqualStrings(s_expected, s_got); } /// Detect SDK path on Darwin. diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig index 88feabd021..edb6b5ffc3 100644 --- a/lib/std/zig/tokenizer.zig +++ b/lib/std/zig/tokenizer.zig @@ -1503,11 +1503,11 @@ pub const Tokenizer = struct { }; test "tokenizer" { - testTokenize("test", &.{.keyword_test}); + try testTokenize("test", &.{.keyword_test}); } test "line comment followed by top-level comptime" { - testTokenize( + try testTokenize( \\// line comment \\comptime {} \\ @@ -1519,7 +1519,7 @@ test "line comment followed by top-level comptime" { } test "tokenizer - unknown length pointer and then c pointer" { - testTokenize( + try testTokenize( \\[*]u8 \\[*c]u8 , &.{ @@ -1536,72 +1536,72 @@ test "tokenizer - unknown length pointer and then c pointer" { } test "tokenizer - code point literal with hex escape" { - testTokenize( + try testTokenize( \\'\x1b' , &.{.char_literal}); - testTokenize( + try testTokenize( \\'\x1' , &.{ .invalid, .invalid }); } test "tokenizer - code point literal with unicode escapes" { // Valid unicode escapes - testTokenize( + try testTokenize( \\'\u{3}' , &.{.char_literal}); - testTokenize( + try testTokenize( \\'\u{01}' , &.{.char_literal}); - testTokenize( + try testTokenize( \\'\u{2a}' , &.{.char_literal}); - testTokenize( + try testTokenize( \\'\u{3f9}' , &.{.char_literal}); - testTokenize( + try testTokenize( \\'\u{6E09aBc1523}' , &.{.char_literal}); - testTokenize( + try testTokenize( \\"\u{440}" , &.{.string_literal}); // Invalid unicode escapes - testTokenize( + try testTokenize( \\'\u' , &.{.invalid}); - testTokenize( + try testTokenize( \\'\u{{' , &.{ .invalid, .invalid }); - testTokenize( + try testTokenize( \\'\u{}' , &.{ .invalid, .invalid }); - testTokenize( + try testTokenize( \\'\u{s}' , &.{ .invalid, .invalid }); - testTokenize( + try testTokenize( \\'\u{2z}' , &.{ .invalid, .invalid }); - testTokenize( + try testTokenize( \\'\u{4a' , &.{.invalid}); // Test old-style unicode literals - testTokenize( + try testTokenize( \\'\u0333' , &.{ .invalid, .invalid }); - testTokenize( + try testTokenize( \\'\U0333' , &.{ .invalid, .integer_literal, .invalid }); } test "tokenizer - code point literal with unicode code point" { - testTokenize( + try testTokenize( \\'πŸ’©' , &.{.char_literal}); } test "tokenizer - float literal e exponent" { - testTokenize("a = 4.94065645841246544177e-324;\n", &.{ + try testTokenize("a = 4.94065645841246544177e-324;\n", &.{ .identifier, .equal, .float_literal, @@ -1610,7 +1610,7 @@ test "tokenizer - float literal e exponent" { } test "tokenizer - float literal p exponent" { - testTokenize("a = 0x1.a827999fcef32p+1022;\n", &.{ + try testTokenize("a = 0x1.a827999fcef32p+1022;\n", &.{ .identifier, .equal, .float_literal, @@ -1619,84 +1619,84 @@ test "tokenizer - float literal p exponent" { } test "tokenizer - chars" { - testTokenize("'c'", &.{.char_literal}); + try testTokenize("'c'", &.{.char_literal}); } test "tokenizer - invalid token characters" { - testTokenize("#", &.{.invalid}); - testTokenize("`", &.{.invalid}); - testTokenize("'c", &.{.invalid}); - testTokenize("'", &.{.invalid}); - testTokenize("''", &.{ .invalid, .invalid }); + try testTokenize("#", &.{.invalid}); + try testTokenize("`", &.{.invalid}); + try testTokenize("'c", &.{.invalid}); + try testTokenize("'", &.{.invalid}); + try testTokenize("''", &.{ .invalid, .invalid }); } test "tokenizer - invalid literal/comment characters" { - testTokenize("\"\x00\"", &.{ + try testTokenize("\"\x00\"", &.{ .string_literal, .invalid, }); - testTokenize("//\x00", &.{ + try testTokenize("//\x00", &.{ .invalid, }); - testTokenize("//\x1f", &.{ + try testTokenize("//\x1f", &.{ .invalid, }); - testTokenize("//\x7f", &.{ + try testTokenize("//\x7f", &.{ .invalid, }); } test "tokenizer - utf8" { - testTokenize("//\xc2\x80", &.{}); - testTokenize("//\xf4\x8f\xbf\xbf", &.{}); + try testTokenize("//\xc2\x80", &.{}); + try testTokenize("//\xf4\x8f\xbf\xbf", &.{}); } test "tokenizer - invalid utf8" { - testTokenize("//\x80", &.{ + try testTokenize("//\x80", &.{ .invalid, }); - testTokenize("//\xbf", &.{ + try testTokenize("//\xbf", &.{ .invalid, }); - testTokenize("//\xf8", &.{ + try testTokenize("//\xf8", &.{ .invalid, }); - testTokenize("//\xff", &.{ + try testTokenize("//\xff", &.{ .invalid, }); - testTokenize("//\xc2\xc0", &.{ + try testTokenize("//\xc2\xc0", &.{ .invalid, }); - testTokenize("//\xe0", &.{ + try testTokenize("//\xe0", &.{ .invalid, }); - testTokenize("//\xf0", &.{ + try testTokenize("//\xf0", &.{ .invalid, }); - testTokenize("//\xf0\x90\x80\xc0", &.{ + try testTokenize("//\xf0\x90\x80\xc0", &.{ .invalid, }); } test "tokenizer - illegal unicode codepoints" { // unicode newline characters.U+0085, U+2028, U+2029 - testTokenize("//\xc2\x84", &.{}); - testTokenize("//\xc2\x85", &.{ + try testTokenize("//\xc2\x84", &.{}); + try testTokenize("//\xc2\x85", &.{ .invalid, }); - testTokenize("//\xc2\x86", &.{}); - testTokenize("//\xe2\x80\xa7", &.{}); - testTokenize("//\xe2\x80\xa8", &.{ + try testTokenize("//\xc2\x86", &.{}); + try testTokenize("//\xe2\x80\xa7", &.{}); + try testTokenize("//\xe2\x80\xa8", &.{ .invalid, }); - testTokenize("//\xe2\x80\xa9", &.{ + try testTokenize("//\xe2\x80\xa9", &.{ .invalid, }); - testTokenize("//\xe2\x80\xaa", &.{}); + try testTokenize("//\xe2\x80\xaa", &.{}); } test "tokenizer - string identifier and builtin fns" { - testTokenize( + try testTokenize( \\const @"if" = @import("std"); , &.{ .keyword_const, @@ -1711,7 +1711,7 @@ test "tokenizer - string identifier and builtin fns" { } test "tokenizer - multiline string literal with literal tab" { - testTokenize( + try testTokenize( \\\\foo bar , &.{ .multiline_string_literal_line, @@ -1719,7 +1719,7 @@ test "tokenizer - multiline string literal with literal tab" { } test "tokenizer - comments with literal tab" { - testTokenize( + try testTokenize( \\//foo bar \\//!foo bar \\///foo bar @@ -1735,25 +1735,25 @@ test "tokenizer - comments with literal tab" { } test "tokenizer - pipe and then invalid" { - testTokenize("||=", &.{ + try testTokenize("||=", &.{ .pipe_pipe, .equal, }); } test "tokenizer - line comment and doc comment" { - testTokenize("//", &.{}); - testTokenize("// a / b", &.{}); - testTokenize("// /", &.{}); - testTokenize("/// a", &.{.doc_comment}); - testTokenize("///", &.{.doc_comment}); - testTokenize("////", &.{}); - testTokenize("//!", &.{.container_doc_comment}); - testTokenize("//!!", &.{.container_doc_comment}); + try testTokenize("//", &.{}); + try testTokenize("// a / b", &.{}); + try testTokenize("// /", &.{}); + try testTokenize("/// a", &.{.doc_comment}); + try testTokenize("///", &.{.doc_comment}); + try testTokenize("////", &.{}); + try testTokenize("//!", &.{.container_doc_comment}); + try testTokenize("//!!", &.{.container_doc_comment}); } test "tokenizer - line comment followed by identifier" { - testTokenize( + try testTokenize( \\ Unexpected, \\ // another \\ Another, @@ -1766,14 +1766,14 @@ test "tokenizer - line comment followed by identifier" { } test "tokenizer - UTF-8 BOM is recognized and skipped" { - testTokenize("\xEF\xBB\xBFa;\n", &.{ + try testTokenize("\xEF\xBB\xBFa;\n", &.{ .identifier, .semicolon, }); } test "correctly parse pointer assignment" { - testTokenize("b.*=3;\n", &.{ + try testTokenize("b.*=3;\n", &.{ .identifier, .period_asterisk, .equal, @@ -1783,14 +1783,14 @@ test "correctly parse pointer assignment" { } test "correctly parse pointer dereference followed by asterisk" { - testTokenize("\"b\".* ** 10", &.{ + try testTokenize("\"b\".* ** 10", &.{ .string_literal, .period_asterisk, .asterisk_asterisk, .integer_literal, }); - testTokenize("(\"b\".*)** 10", &.{ + try testTokenize("(\"b\".*)** 10", &.{ .l_paren, .string_literal, .period_asterisk, @@ -1799,7 +1799,7 @@ test "correctly parse pointer dereference followed by asterisk" { .integer_literal, }); - testTokenize("\"b\".*** 10", &.{ + try testTokenize("\"b\".*** 10", &.{ .string_literal, .invalid_periodasterisks, .asterisk_asterisk, @@ -1808,245 +1808,245 @@ test "correctly parse pointer dereference followed by asterisk" { } test "tokenizer - range literals" { - testTokenize("0...9", &.{ .integer_literal, .ellipsis3, .integer_literal }); - testTokenize("'0'...'9'", &.{ .char_literal, .ellipsis3, .char_literal }); - testTokenize("0x00...0x09", &.{ .integer_literal, .ellipsis3, .integer_literal }); - testTokenize("0b00...0b11", &.{ .integer_literal, .ellipsis3, .integer_literal }); - testTokenize("0o00...0o11", &.{ .integer_literal, .ellipsis3, .integer_literal }); + try testTokenize("0...9", &.{ .integer_literal, .ellipsis3, .integer_literal }); + try testTokenize("'0'...'9'", &.{ .char_literal, .ellipsis3, .char_literal }); + try testTokenize("0x00...0x09", &.{ .integer_literal, .ellipsis3, .integer_literal }); + try testTokenize("0b00...0b11", &.{ .integer_literal, .ellipsis3, .integer_literal }); + try testTokenize("0o00...0o11", &.{ .integer_literal, .ellipsis3, .integer_literal }); } test "tokenizer - number literals decimal" { - testTokenize("0", &.{.integer_literal}); - testTokenize("1", &.{.integer_literal}); - testTokenize("2", &.{.integer_literal}); - testTokenize("3", &.{.integer_literal}); - testTokenize("4", &.{.integer_literal}); - testTokenize("5", &.{.integer_literal}); - testTokenize("6", &.{.integer_literal}); - testTokenize("7", &.{.integer_literal}); - testTokenize("8", &.{.integer_literal}); - testTokenize("9", &.{.integer_literal}); - testTokenize("1..", &.{ .integer_literal, .ellipsis2 }); - testTokenize("0a", &.{ .invalid, .identifier }); - testTokenize("9b", &.{ .invalid, .identifier }); - testTokenize("1z", &.{ .invalid, .identifier }); - testTokenize("1z_1", &.{ .invalid, .identifier }); - testTokenize("9z3", &.{ .invalid, .identifier }); + try testTokenize("0", &.{.integer_literal}); + try testTokenize("1", &.{.integer_literal}); + try testTokenize("2", &.{.integer_literal}); + try testTokenize("3", &.{.integer_literal}); + try testTokenize("4", &.{.integer_literal}); + try testTokenize("5", &.{.integer_literal}); + try testTokenize("6", &.{.integer_literal}); + try testTokenize("7", &.{.integer_literal}); + try testTokenize("8", &.{.integer_literal}); + try testTokenize("9", &.{.integer_literal}); + try testTokenize("1..", &.{ .integer_literal, .ellipsis2 }); + try testTokenize("0a", &.{ .invalid, .identifier }); + try testTokenize("9b", &.{ .invalid, .identifier }); + try testTokenize("1z", &.{ .invalid, .identifier }); + try testTokenize("1z_1", &.{ .invalid, .identifier }); + try testTokenize("9z3", &.{ .invalid, .identifier }); - testTokenize("0_0", &.{.integer_literal}); - testTokenize("0001", &.{.integer_literal}); - testTokenize("01234567890", &.{.integer_literal}); - testTokenize("012_345_6789_0", &.{.integer_literal}); - testTokenize("0_1_2_3_4_5_6_7_8_9_0", &.{.integer_literal}); + try testTokenize("0_0", &.{.integer_literal}); + try testTokenize("0001", &.{.integer_literal}); + try testTokenize("01234567890", &.{.integer_literal}); + try testTokenize("012_345_6789_0", &.{.integer_literal}); + try testTokenize("0_1_2_3_4_5_6_7_8_9_0", &.{.integer_literal}); - testTokenize("00_", &.{.invalid}); - testTokenize("0_0_", &.{.invalid}); - testTokenize("0__0", &.{ .invalid, .identifier }); - testTokenize("0_0f", &.{ .invalid, .identifier }); - testTokenize("0_0_f", &.{ .invalid, .identifier }); - testTokenize("0_0_f_00", &.{ .invalid, .identifier }); - testTokenize("1_,", &.{ .invalid, .comma }); + try testTokenize("00_", &.{.invalid}); + try testTokenize("0_0_", &.{.invalid}); + try testTokenize("0__0", &.{ .invalid, .identifier }); + try testTokenize("0_0f", &.{ .invalid, .identifier }); + try testTokenize("0_0_f", &.{ .invalid, .identifier }); + try testTokenize("0_0_f_00", &.{ .invalid, .identifier }); + try testTokenize("1_,", &.{ .invalid, .comma }); - testTokenize("1.", &.{.float_literal}); - testTokenize("0.0", &.{.float_literal}); - testTokenize("1.0", &.{.float_literal}); - testTokenize("10.0", &.{.float_literal}); - testTokenize("0e0", &.{.float_literal}); - testTokenize("1e0", &.{.float_literal}); - testTokenize("1e100", &.{.float_literal}); - testTokenize("1.e100", &.{.float_literal}); - testTokenize("1.0e100", &.{.float_literal}); - testTokenize("1.0e+100", &.{.float_literal}); - testTokenize("1.0e-100", &.{.float_literal}); - testTokenize("1_0_0_0.0_0_0_0_0_1e1_0_0_0", &.{.float_literal}); - testTokenize("1.+", &.{ .float_literal, .plus }); + try testTokenize("1.", &.{.float_literal}); + try testTokenize("0.0", &.{.float_literal}); + try testTokenize("1.0", &.{.float_literal}); + try testTokenize("10.0", &.{.float_literal}); + try testTokenize("0e0", &.{.float_literal}); + try testTokenize("1e0", &.{.float_literal}); + try testTokenize("1e100", &.{.float_literal}); + try testTokenize("1.e100", &.{.float_literal}); + try testTokenize("1.0e100", &.{.float_literal}); + try testTokenize("1.0e+100", &.{.float_literal}); + try testTokenize("1.0e-100", &.{.float_literal}); + try testTokenize("1_0_0_0.0_0_0_0_0_1e1_0_0_0", &.{.float_literal}); + try testTokenize("1.+", &.{ .float_literal, .plus }); - testTokenize("1e", &.{.invalid}); - testTokenize("1.0e1f0", &.{ .invalid, .identifier }); - testTokenize("1.0p100", &.{ .invalid, .identifier }); - testTokenize("1.0p-100", &.{ .invalid, .identifier, .minus, .integer_literal }); - testTokenize("1.0p1f0", &.{ .invalid, .identifier }); - testTokenize("1.0_,", &.{ .invalid, .comma }); - testTokenize("1_.0", &.{ .invalid, .period, .integer_literal }); - testTokenize("1._", &.{ .invalid, .identifier }); - testTokenize("1.a", &.{ .invalid, .identifier }); - testTokenize("1.z", &.{ .invalid, .identifier }); - testTokenize("1._0", &.{ .invalid, .identifier }); - testTokenize("1._+", &.{ .invalid, .identifier, .plus }); - testTokenize("1._e", &.{ .invalid, .identifier }); - testTokenize("1.0e", &.{.invalid}); - testTokenize("1.0e,", &.{ .invalid, .comma }); - testTokenize("1.0e_", &.{ .invalid, .identifier }); - testTokenize("1.0e+_", &.{ .invalid, .identifier }); - testTokenize("1.0e-_", &.{ .invalid, .identifier }); - testTokenize("1.0e0_+", &.{ .invalid, .plus }); + try testTokenize("1e", &.{.invalid}); + try testTokenize("1.0e1f0", &.{ .invalid, .identifier }); + try testTokenize("1.0p100", &.{ .invalid, .identifier }); + try testTokenize("1.0p-100", &.{ .invalid, .identifier, .minus, .integer_literal }); + try testTokenize("1.0p1f0", &.{ .invalid, .identifier }); + try testTokenize("1.0_,", &.{ .invalid, .comma }); + try testTokenize("1_.0", &.{ .invalid, .period, .integer_literal }); + try testTokenize("1._", &.{ .invalid, .identifier }); + try testTokenize("1.a", &.{ .invalid, .identifier }); + try testTokenize("1.z", &.{ .invalid, .identifier }); + try testTokenize("1._0", &.{ .invalid, .identifier }); + try testTokenize("1._+", &.{ .invalid, .identifier, .plus }); + try testTokenize("1._e", &.{ .invalid, .identifier }); + try testTokenize("1.0e", &.{.invalid}); + try testTokenize("1.0e,", &.{ .invalid, .comma }); + try testTokenize("1.0e_", &.{ .invalid, .identifier }); + try testTokenize("1.0e+_", &.{ .invalid, .identifier }); + try testTokenize("1.0e-_", &.{ .invalid, .identifier }); + try testTokenize("1.0e0_+", &.{ .invalid, .plus }); } test "tokenizer - number literals binary" { - testTokenize("0b0", &.{.integer_literal}); - testTokenize("0b1", &.{.integer_literal}); - testTokenize("0b2", &.{ .invalid, .integer_literal }); - testTokenize("0b3", &.{ .invalid, .integer_literal }); - testTokenize("0b4", &.{ .invalid, .integer_literal }); - testTokenize("0b5", &.{ .invalid, .integer_literal }); - testTokenize("0b6", &.{ .invalid, .integer_literal }); - testTokenize("0b7", &.{ .invalid, .integer_literal }); - testTokenize("0b8", &.{ .invalid, .integer_literal }); - testTokenize("0b9", &.{ .invalid, .integer_literal }); - testTokenize("0ba", &.{ .invalid, .identifier }); - testTokenize("0bb", &.{ .invalid, .identifier }); - testTokenize("0bc", &.{ .invalid, .identifier }); - testTokenize("0bd", &.{ .invalid, .identifier }); - testTokenize("0be", &.{ .invalid, .identifier }); - testTokenize("0bf", &.{ .invalid, .identifier }); - testTokenize("0bz", &.{ .invalid, .identifier }); + try testTokenize("0b0", &.{.integer_literal}); + try testTokenize("0b1", &.{.integer_literal}); + try testTokenize("0b2", &.{ .invalid, .integer_literal }); + try testTokenize("0b3", &.{ .invalid, .integer_literal }); + try testTokenize("0b4", &.{ .invalid, .integer_literal }); + try testTokenize("0b5", &.{ .invalid, .integer_literal }); + try testTokenize("0b6", &.{ .invalid, .integer_literal }); + try testTokenize("0b7", &.{ .invalid, .integer_literal }); + try testTokenize("0b8", &.{ .invalid, .integer_literal }); + try testTokenize("0b9", &.{ .invalid, .integer_literal }); + try testTokenize("0ba", &.{ .invalid, .identifier }); + try testTokenize("0bb", &.{ .invalid, .identifier }); + try testTokenize("0bc", &.{ .invalid, .identifier }); + try testTokenize("0bd", &.{ .invalid, .identifier }); + try testTokenize("0be", &.{ .invalid, .identifier }); + try testTokenize("0bf", &.{ .invalid, .identifier }); + try testTokenize("0bz", &.{ .invalid, .identifier }); - testTokenize("0b0000_0000", &.{.integer_literal}); - testTokenize("0b1111_1111", &.{.integer_literal}); - testTokenize("0b10_10_10_10", &.{.integer_literal}); - testTokenize("0b0_1_0_1_0_1_0_1", &.{.integer_literal}); - testTokenize("0b1.", &.{ .integer_literal, .period }); - testTokenize("0b1.0", &.{ .integer_literal, .period, .integer_literal }); + try testTokenize("0b0000_0000", &.{.integer_literal}); + try testTokenize("0b1111_1111", &.{.integer_literal}); + try testTokenize("0b10_10_10_10", &.{.integer_literal}); + try testTokenize("0b0_1_0_1_0_1_0_1", &.{.integer_literal}); + try testTokenize("0b1.", &.{ .integer_literal, .period }); + try testTokenize("0b1.0", &.{ .integer_literal, .period, .integer_literal }); - testTokenize("0B0", &.{ .invalid, .identifier }); - testTokenize("0b_", &.{ .invalid, .identifier }); - testTokenize("0b_0", &.{ .invalid, .identifier }); - testTokenize("0b1_", &.{.invalid}); - testTokenize("0b0__1", &.{ .invalid, .identifier }); - testTokenize("0b0_1_", &.{.invalid}); - testTokenize("0b1e", &.{ .invalid, .identifier }); - testTokenize("0b1p", &.{ .invalid, .identifier }); - testTokenize("0b1e0", &.{ .invalid, .identifier }); - testTokenize("0b1p0", &.{ .invalid, .identifier }); - testTokenize("0b1_,", &.{ .invalid, .comma }); + try testTokenize("0B0", &.{ .invalid, .identifier }); + try testTokenize("0b_", &.{ .invalid, .identifier }); + try testTokenize("0b_0", &.{ .invalid, .identifier }); + try testTokenize("0b1_", &.{.invalid}); + try testTokenize("0b0__1", &.{ .invalid, .identifier }); + try testTokenize("0b0_1_", &.{.invalid}); + try testTokenize("0b1e", &.{ .invalid, .identifier }); + try testTokenize("0b1p", &.{ .invalid, .identifier }); + try testTokenize("0b1e0", &.{ .invalid, .identifier }); + try testTokenize("0b1p0", &.{ .invalid, .identifier }); + try testTokenize("0b1_,", &.{ .invalid, .comma }); } test "tokenizer - number literals octal" { - testTokenize("0o0", &.{.integer_literal}); - testTokenize("0o1", &.{.integer_literal}); - testTokenize("0o2", &.{.integer_literal}); - testTokenize("0o3", &.{.integer_literal}); - testTokenize("0o4", &.{.integer_literal}); - testTokenize("0o5", &.{.integer_literal}); - testTokenize("0o6", &.{.integer_literal}); - testTokenize("0o7", &.{.integer_literal}); - testTokenize("0o8", &.{ .invalid, .integer_literal }); - testTokenize("0o9", &.{ .invalid, .integer_literal }); - testTokenize("0oa", &.{ .invalid, .identifier }); - testTokenize("0ob", &.{ .invalid, .identifier }); - testTokenize("0oc", &.{ .invalid, .identifier }); - testTokenize("0od", &.{ .invalid, .identifier }); - testTokenize("0oe", &.{ .invalid, .identifier }); - testTokenize("0of", &.{ .invalid, .identifier }); - testTokenize("0oz", &.{ .invalid, .identifier }); + try testTokenize("0o0", &.{.integer_literal}); + try testTokenize("0o1", &.{.integer_literal}); + try testTokenize("0o2", &.{.integer_literal}); + try testTokenize("0o3", &.{.integer_literal}); + try testTokenize("0o4", &.{.integer_literal}); + try testTokenize("0o5", &.{.integer_literal}); + try testTokenize("0o6", &.{.integer_literal}); + try testTokenize("0o7", &.{.integer_literal}); + try testTokenize("0o8", &.{ .invalid, .integer_literal }); + try testTokenize("0o9", &.{ .invalid, .integer_literal }); + try testTokenize("0oa", &.{ .invalid, .identifier }); + try testTokenize("0ob", &.{ .invalid, .identifier }); + try testTokenize("0oc", &.{ .invalid, .identifier }); + try testTokenize("0od", &.{ .invalid, .identifier }); + try testTokenize("0oe", &.{ .invalid, .identifier }); + try testTokenize("0of", &.{ .invalid, .identifier }); + try testTokenize("0oz", &.{ .invalid, .identifier }); - testTokenize("0o01234567", &.{.integer_literal}); - testTokenize("0o0123_4567", &.{.integer_literal}); - testTokenize("0o01_23_45_67", &.{.integer_literal}); - testTokenize("0o0_1_2_3_4_5_6_7", &.{.integer_literal}); - testTokenize("0o7.", &.{ .integer_literal, .period }); - testTokenize("0o7.0", &.{ .integer_literal, .period, .integer_literal }); + try testTokenize("0o01234567", &.{.integer_literal}); + try testTokenize("0o0123_4567", &.{.integer_literal}); + try testTokenize("0o01_23_45_67", &.{.integer_literal}); + try testTokenize("0o0_1_2_3_4_5_6_7", &.{.integer_literal}); + try testTokenize("0o7.", &.{ .integer_literal, .period }); + try testTokenize("0o7.0", &.{ .integer_literal, .period, .integer_literal }); - testTokenize("0O0", &.{ .invalid, .identifier }); - testTokenize("0o_", &.{ .invalid, .identifier }); - testTokenize("0o_0", &.{ .invalid, .identifier }); - testTokenize("0o1_", &.{.invalid}); - testTokenize("0o0__1", &.{ .invalid, .identifier }); - testTokenize("0o0_1_", &.{.invalid}); - testTokenize("0o1e", &.{ .invalid, .identifier }); - testTokenize("0o1p", &.{ .invalid, .identifier }); - testTokenize("0o1e0", &.{ .invalid, .identifier }); - testTokenize("0o1p0", &.{ .invalid, .identifier }); - testTokenize("0o_,", &.{ .invalid, .identifier, .comma }); + try testTokenize("0O0", &.{ .invalid, .identifier }); + try testTokenize("0o_", &.{ .invalid, .identifier }); + try testTokenize("0o_0", &.{ .invalid, .identifier }); + try testTokenize("0o1_", &.{.invalid}); + try testTokenize("0o0__1", &.{ .invalid, .identifier }); + try testTokenize("0o0_1_", &.{.invalid}); + try testTokenize("0o1e", &.{ .invalid, .identifier }); + try testTokenize("0o1p", &.{ .invalid, .identifier }); + try testTokenize("0o1e0", &.{ .invalid, .identifier }); + try testTokenize("0o1p0", &.{ .invalid, .identifier }); + try testTokenize("0o_,", &.{ .invalid, .identifier, .comma }); } test "tokenizer - number literals hexadeciaml" { - testTokenize("0x0", &.{.integer_literal}); - testTokenize("0x1", &.{.integer_literal}); - testTokenize("0x2", &.{.integer_literal}); - testTokenize("0x3", &.{.integer_literal}); - testTokenize("0x4", &.{.integer_literal}); - testTokenize("0x5", &.{.integer_literal}); - testTokenize("0x6", &.{.integer_literal}); - testTokenize("0x7", &.{.integer_literal}); - testTokenize("0x8", &.{.integer_literal}); - testTokenize("0x9", &.{.integer_literal}); - testTokenize("0xa", &.{.integer_literal}); - testTokenize("0xb", &.{.integer_literal}); - testTokenize("0xc", &.{.integer_literal}); - testTokenize("0xd", &.{.integer_literal}); - testTokenize("0xe", &.{.integer_literal}); - testTokenize("0xf", &.{.integer_literal}); - testTokenize("0xA", &.{.integer_literal}); - testTokenize("0xB", &.{.integer_literal}); - testTokenize("0xC", &.{.integer_literal}); - testTokenize("0xD", &.{.integer_literal}); - testTokenize("0xE", &.{.integer_literal}); - testTokenize("0xF", &.{.integer_literal}); - testTokenize("0x0z", &.{ .invalid, .identifier }); - testTokenize("0xz", &.{ .invalid, .identifier }); + try testTokenize("0x0", &.{.integer_literal}); + try testTokenize("0x1", &.{.integer_literal}); + try testTokenize("0x2", &.{.integer_literal}); + try testTokenize("0x3", &.{.integer_literal}); + try testTokenize("0x4", &.{.integer_literal}); + try testTokenize("0x5", &.{.integer_literal}); + try testTokenize("0x6", &.{.integer_literal}); + try testTokenize("0x7", &.{.integer_literal}); + try testTokenize("0x8", &.{.integer_literal}); + try testTokenize("0x9", &.{.integer_literal}); + try testTokenize("0xa", &.{.integer_literal}); + try testTokenize("0xb", &.{.integer_literal}); + try testTokenize("0xc", &.{.integer_literal}); + try testTokenize("0xd", &.{.integer_literal}); + try testTokenize("0xe", &.{.integer_literal}); + try testTokenize("0xf", &.{.integer_literal}); + try testTokenize("0xA", &.{.integer_literal}); + try testTokenize("0xB", &.{.integer_literal}); + try testTokenize("0xC", &.{.integer_literal}); + try testTokenize("0xD", &.{.integer_literal}); + try testTokenize("0xE", &.{.integer_literal}); + try testTokenize("0xF", &.{.integer_literal}); + try testTokenize("0x0z", &.{ .invalid, .identifier }); + try testTokenize("0xz", &.{ .invalid, .identifier }); - testTokenize("0x0123456789ABCDEF", &.{.integer_literal}); - testTokenize("0x0123_4567_89AB_CDEF", &.{.integer_literal}); - testTokenize("0x01_23_45_67_89AB_CDE_F", &.{.integer_literal}); - testTokenize("0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F", &.{.integer_literal}); + try testTokenize("0x0123456789ABCDEF", &.{.integer_literal}); + try testTokenize("0x0123_4567_89AB_CDEF", &.{.integer_literal}); + try testTokenize("0x01_23_45_67_89AB_CDE_F", &.{.integer_literal}); + try testTokenize("0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F", &.{.integer_literal}); - testTokenize("0X0", &.{ .invalid, .identifier }); - testTokenize("0x_", &.{ .invalid, .identifier }); - testTokenize("0x_1", &.{ .invalid, .identifier }); - testTokenize("0x1_", &.{.invalid}); - testTokenize("0x0__1", &.{ .invalid, .identifier }); - testTokenize("0x0_1_", &.{.invalid}); - testTokenize("0x_,", &.{ .invalid, .identifier, .comma }); + try testTokenize("0X0", &.{ .invalid, .identifier }); + try testTokenize("0x_", &.{ .invalid, .identifier }); + try testTokenize("0x_1", &.{ .invalid, .identifier }); + try testTokenize("0x1_", &.{.invalid}); + try testTokenize("0x0__1", &.{ .invalid, .identifier }); + try testTokenize("0x0_1_", &.{.invalid}); + try testTokenize("0x_,", &.{ .invalid, .identifier, .comma }); - testTokenize("0x1.", &.{.float_literal}); - testTokenize("0x1.0", &.{.float_literal}); - testTokenize("0xF.", &.{.float_literal}); - testTokenize("0xF.0", &.{.float_literal}); - testTokenize("0xF.F", &.{.float_literal}); - testTokenize("0xF.Fp0", &.{.float_literal}); - testTokenize("0xF.FP0", &.{.float_literal}); - testTokenize("0x1p0", &.{.float_literal}); - testTokenize("0xfp0", &.{.float_literal}); - testTokenize("0x1.+0xF.", &.{ .float_literal, .plus, .float_literal }); + try testTokenize("0x1.", &.{.float_literal}); + try testTokenize("0x1.0", &.{.float_literal}); + try testTokenize("0xF.", &.{.float_literal}); + try testTokenize("0xF.0", &.{.float_literal}); + try testTokenize("0xF.F", &.{.float_literal}); + try testTokenize("0xF.Fp0", &.{.float_literal}); + try testTokenize("0xF.FP0", &.{.float_literal}); + try testTokenize("0x1p0", &.{.float_literal}); + try testTokenize("0xfp0", &.{.float_literal}); + try testTokenize("0x1.+0xF.", &.{ .float_literal, .plus, .float_literal }); - testTokenize("0x0123456.789ABCDEF", &.{.float_literal}); - testTokenize("0x0_123_456.789_ABC_DEF", &.{.float_literal}); - testTokenize("0x0_1_2_3_4_5_6.7_8_9_A_B_C_D_E_F", &.{.float_literal}); - testTokenize("0x0p0", &.{.float_literal}); - testTokenize("0x0.0p0", &.{.float_literal}); - testTokenize("0xff.ffp10", &.{.float_literal}); - testTokenize("0xff.ffP10", &.{.float_literal}); - testTokenize("0xff.p10", &.{.float_literal}); - testTokenize("0xffp10", &.{.float_literal}); - testTokenize("0xff_ff.ff_ffp1_0_0_0", &.{.float_literal}); - testTokenize("0xf_f_f_f.f_f_f_fp+1_000", &.{.float_literal}); - testTokenize("0xf_f_f_f.f_f_f_fp-1_00_0", &.{.float_literal}); + try testTokenize("0x0123456.789ABCDEF", &.{.float_literal}); + try testTokenize("0x0_123_456.789_ABC_DEF", &.{.float_literal}); + try testTokenize("0x0_1_2_3_4_5_6.7_8_9_A_B_C_D_E_F", &.{.float_literal}); + try testTokenize("0x0p0", &.{.float_literal}); + try testTokenize("0x0.0p0", &.{.float_literal}); + try testTokenize("0xff.ffp10", &.{.float_literal}); + try testTokenize("0xff.ffP10", &.{.float_literal}); + try testTokenize("0xff.p10", &.{.float_literal}); + try testTokenize("0xffp10", &.{.float_literal}); + try testTokenize("0xff_ff.ff_ffp1_0_0_0", &.{.float_literal}); + try testTokenize("0xf_f_f_f.f_f_f_fp+1_000", &.{.float_literal}); + try testTokenize("0xf_f_f_f.f_f_f_fp-1_00_0", &.{.float_literal}); - testTokenize("0x1e", &.{.integer_literal}); - testTokenize("0x1e0", &.{.integer_literal}); - testTokenize("0x1p", &.{.invalid}); - testTokenize("0xfp0z1", &.{ .invalid, .identifier }); - testTokenize("0xff.ffpff", &.{ .invalid, .identifier }); - testTokenize("0x0.p", &.{.invalid}); - testTokenize("0x0.z", &.{ .invalid, .identifier }); - testTokenize("0x0._", &.{ .invalid, .identifier }); - testTokenize("0x0_.0", &.{ .invalid, .period, .integer_literal }); - testTokenize("0x0_.0.0", &.{ .invalid, .period, .float_literal }); - testTokenize("0x0._0", &.{ .invalid, .identifier }); - testTokenize("0x0.0_", &.{.invalid}); - testTokenize("0x0_p0", &.{ .invalid, .identifier }); - testTokenize("0x0_.p0", &.{ .invalid, .period, .identifier }); - testTokenize("0x0._p0", &.{ .invalid, .identifier }); - testTokenize("0x0.0_p0", &.{ .invalid, .identifier }); - testTokenize("0x0._0p0", &.{ .invalid, .identifier }); - testTokenize("0x0.0p_0", &.{ .invalid, .identifier }); - testTokenize("0x0.0p+_0", &.{ .invalid, .identifier }); - testTokenize("0x0.0p-_0", &.{ .invalid, .identifier }); - testTokenize("0x0.0p0_", &.{ .invalid, .eof }); + try testTokenize("0x1e", &.{.integer_literal}); + try testTokenize("0x1e0", &.{.integer_literal}); + try testTokenize("0x1p", &.{.invalid}); + try testTokenize("0xfp0z1", &.{ .invalid, .identifier }); + try testTokenize("0xff.ffpff", &.{ .invalid, .identifier }); + try testTokenize("0x0.p", &.{.invalid}); + try testTokenize("0x0.z", &.{ .invalid, .identifier }); + try testTokenize("0x0._", &.{ .invalid, .identifier }); + try testTokenize("0x0_.0", &.{ .invalid, .period, .integer_literal }); + try testTokenize("0x0_.0.0", &.{ .invalid, .period, .float_literal }); + try testTokenize("0x0._0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0_", &.{.invalid}); + try testTokenize("0x0_p0", &.{ .invalid, .identifier }); + try testTokenize("0x0_.p0", &.{ .invalid, .period, .identifier }); + try testTokenize("0x0._p0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0_p0", &.{ .invalid, .identifier }); + try testTokenize("0x0._0p0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0p_0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0p+_0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0p-_0", &.{ .invalid, .identifier }); + try testTokenize("0x0.0p0_", &.{ .invalid, .eof }); } -fn testTokenize(source: []const u8, expected_tokens: []const Token.Tag) void { +fn testTokenize(source: []const u8, expected_tokens: []const Token.Tag) !void { var tokenizer = Tokenizer.init(source); for (expected_tokens) |expected_token_id| { const token = tokenizer.next(); @@ -2055,6 +2055,6 @@ fn testTokenize(source: []const u8, expected_tokens: []const Token.Tag) void { } } const last_token = tokenizer.next(); - std.testing.expect(last_token.tag == .eof); - std.testing.expect(last_token.loc.start == source.len); + try std.testing.expect(last_token.tag == .eof); + try std.testing.expect(last_token.loc.start == source.len); } From 0a38f61d58018ce856ce058efb655ff0199228d2 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Tue, 4 May 2021 21:23:22 +0300 Subject: [PATCH 3/8] update usage of std.testing in behavior and standalone tests --- test/cli.zig | 28 +- test/compile_errors.zig | 2 +- test/stack_traces.zig | 34 +- test/stage1/behavior/align.zig | 132 ++-- test/stage1/behavior/alignof.zig | 28 +- test/stage1/behavior/array.zig | 282 +++---- test/stage1/behavior/asm.zig | 2 +- test/stage1/behavior/async_fn.zig | 330 ++++----- test/stage1/behavior/atomics.zig | 138 ++-- test/stage1/behavior/await_struct.zig | 4 +- test/stage1/behavior/bit_shifting.zig | 28 +- test/stage1/behavior/bitcast.zig | 104 +-- test/stage1/behavior/bitreverse.zig | 78 +- test/stage1/behavior/bool.zig | 22 +- test/stage1/behavior/bugs/1025.zig | 2 +- test/stage1/behavior/bugs/1076.zig | 10 +- test/stage1/behavior/bugs/1120.zig | 2 +- test/stage1/behavior/bugs/1277.zig | 2 +- test/stage1/behavior/bugs/1310.zig | 2 +- test/stage1/behavior/bugs/1322.zig | 4 +- test/stage1/behavior/bugs/1381.zig | 2 +- test/stage1/behavior/bugs/1421.zig | 2 +- test/stage1/behavior/bugs/1442.zig | 2 +- test/stage1/behavior/bugs/1486.zig | 4 +- test/stage1/behavior/bugs/1607.zig | 8 +- test/stage1/behavior/bugs/1735.zig | 2 +- test/stage1/behavior/bugs/1741.zig | 2 +- test/stage1/behavior/bugs/1851.zig | 18 +- test/stage1/behavior/bugs/2006.zig | 4 +- test/stage1/behavior/bugs/2114.zig | 14 +- test/stage1/behavior/bugs/2889.zig | 2 +- test/stage1/behavior/bugs/3007.zig | 2 +- test/stage1/behavior/bugs/3046.zig | 2 +- test/stage1/behavior/bugs/3112.zig | 2 +- test/stage1/behavior/bugs/3384.zig | 12 +- test/stage1/behavior/bugs/394.zig | 2 +- test/stage1/behavior/bugs/421.zig | 8 +- test/stage1/behavior/bugs/4328.zig | 28 +- test/stage1/behavior/bugs/4560.zig | 6 +- test/stage1/behavior/bugs/4769_a.zig | 2 +- test/stage1/behavior/bugs/4769_b.zig | 2 +- test/stage1/behavior/bugs/5398.zig | 6 +- test/stage1/behavior/bugs/5413.zig | 4 +- test/stage1/behavior/bugs/5474.zig | 18 +- test/stage1/behavior/bugs/624.zig | 2 +- test/stage1/behavior/bugs/6456.zig | 8 +- test/stage1/behavior/bugs/655.zig | 8 +- test/stage1/behavior/bugs/656.zig | 6 +- test/stage1/behavior/bugs/679.zig | 2 +- test/stage1/behavior/bugs/6850.zig | 2 +- test/stage1/behavior/bugs/7047.zig | 4 +- test/stage1/behavior/bugs/718.zig | 8 +- test/stage1/behavior/bugs/726.zig | 4 +- test/stage1/behavior/bugs/920.zig | 2 +- test/stage1/behavior/byteswap.zig | 66 +- test/stage1/behavior/byval_arg_var.zig | 2 +- test/stage1/behavior/call.zig | 38 +- test/stage1/behavior/cast.zig | 452 +++++------ test/stage1/behavior/const_slice_child.zig | 16 +- test/stage1/behavior/defer.zig | 40 +- test/stage1/behavior/enum.zig | 224 +++--- test/stage1/behavior/enum_with_members.zig | 8 +- test/stage1/behavior/error.zig | 120 +-- test/stage1/behavior/eval.zig | 238 +++--- test/stage1/behavior/field_parent_ptr.zig | 24 +- test/stage1/behavior/floatop.zig | 322 ++++---- test/stage1/behavior/fn.zig | 82 +- test/stage1/behavior/fn_delegation.zig | 8 +- .../behavior/fn_in_struct_in_comptime.zig | 2 +- test/stage1/behavior/for.zig | 56 +- test/stage1/behavior/generics.zig | 50 +- test/stage1/behavior/hasdecl.zig | 12 +- test/stage1/behavior/hasfield.zig | 24 +- test/stage1/behavior/if.zig | 28 +- test/stage1/behavior/import.zig | 6 +- .../behavior/incomplete_struct_param_tld.zig | 2 +- test/stage1/behavior/inttoptr.zig | 4 - test/stage1/behavior/ir_block_deps.zig | 4 +- test/stage1/behavior/math.zig | 700 +++++++++--------- test/stage1/behavior/misc.zig | 214 +++--- test/stage1/behavior/muladd.zig | 14 +- .../namespace_depends_on_compile_var.zig | 4 +- test/stage1/behavior/null.zig | 48 +- test/stage1/behavior/optional.zig | 102 +-- test/stage1/behavior/pointers.zig | 216 +++--- test/stage1/behavior/popcount.zig | 24 +- test/stage1/behavior/ptrcast.zig | 24 +- test/stage1/behavior/pub_enum.zig | 8 +- ...ef_var_in_if_after_if_2nd_switch_prong.zig | 20 +- test/stage1/behavior/reflection.zig | 34 +- test/stage1/behavior/shuffle.zig | 20 +- test/stage1/behavior/sizeof_and_typeof.zig | 150 ++-- test/stage1/behavior/slice.zig | 238 +++--- test/stage1/behavior/src.zig | 16 +- test/stage1/behavior/struct.zig | 380 +++++----- .../struct_contains_null_ptr_itself.zig | 2 +- .../struct_contains_slice_of_itself.zig | 24 +- test/stage1/behavior/switch.zig | 208 +++--- .../stage1/behavior/switch_prong_err_enum.zig | 4 +- .../behavior/switch_prong_implicit_cast.zig | 2 +- test/stage1/behavior/this.zig | 6 +- test/stage1/behavior/translate_c_macros.zig | 8 +- test/stage1/behavior/truncate.zig | 12 +- test/stage1/behavior/try.zig | 14 +- test/stage1/behavior/tuple.zig | 88 +-- test/stage1/behavior/type.zig | 168 ++--- test/stage1/behavior/type_info.zig | 374 +++++----- test/stage1/behavior/typename.zig | 2 +- test/stage1/behavior/undefined.zig | 26 +- test/stage1/behavior/union.zig | 284 +++---- test/stage1/behavior/usingnamespace.zig | 6 +- test/stage1/behavior/var_args.zig | 34 +- test/stage1/behavior/vector.zig | 532 ++++++------- test/stage1/behavior/void.zig | 6 +- test/stage1/behavior/wasm.zig | 4 +- test/stage1/behavior/while.zig | 96 ++- test/stage1/behavior/widening.zig | 12 +- test/stage1/c_abi/main.zig | 116 +-- test/standalone/brace_expansion/main.zig | 56 +- test/standalone/empty_env/main.zig | 4 +- test/standalone/global_linkage/main.zig | 4 +- test/standalone/issue_794/main.zig | 2 +- .../main.zig | 2 +- test/standalone/static_c_lib/foo.zig | 4 +- test/standalone/use_alias/main.zig | 2 +- 125 files changed, 3783 insertions(+), 3793 deletions(-) diff --git a/test/cli.zig b/test/cli.zig index dedea67a59..a00d76d5e7 100644 --- a/test/cli.zig +++ b/test/cli.zig @@ -29,7 +29,7 @@ pub fn main() !void { const dir_path = try fs.path.join(a, &[_][]const u8{ cache_root, "clitest" }); defer fs.cwd().deleteTree(dir_path) catch {}; - + const TestFn = fn ([]const u8, []const u8) anyerror!void; const test_fns = [_]TestFn{ testZigInitLib, @@ -94,13 +94,13 @@ fn exec(cwd: []const u8, expect_0: bool, argv: []const []const u8) !ChildProcess fn testZigInitLib(zig_exe: []const u8, dir_path: []const u8) !void { _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-lib" }); const test_result = try exec(dir_path, true, &[_][]const u8{ zig_exe, "build", "test" }); - testing.expectStringEndsWith(test_result.stderr, "All 1 tests passed.\n"); + try testing.expectStringEndsWith(test_result.stderr, "All 1 tests passed.\n"); } fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void { _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-exe" }); const run_result = try exec(dir_path, true, &[_][]const u8{ zig_exe, "build", "run" }); - testing.expectEqualStrings("info: All your codebase are belong to us.\n", run_result.stderr); + try testing.expectEqualStrings("info: All your codebase are belong to us.\n", run_result.stderr); } fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void { @@ -136,9 +136,9 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void { _ = try exec(dir_path, true, args.items); const out_asm = try std.fs.cwd().readFileAlloc(a, example_s_path, std.math.maxInt(usize)); - testing.expect(std.mem.indexOf(u8, out_asm, "square:") != null); - testing.expect(std.mem.indexOf(u8, out_asm, "mov\teax, edi") != null); - testing.expect(std.mem.indexOf(u8, out_asm, "imul\teax, edi") != null); + try testing.expect(std.mem.indexOf(u8, out_asm, "square:") != null); + try testing.expect(std.mem.indexOf(u8, out_asm, "mov\teax, edi") != null); + try testing.expect(std.mem.indexOf(u8, out_asm, "imul\teax, edi") != null); } fn testMissingOutputPath(zig_exe: []const u8, dir_path: []const u8) !void { @@ -149,7 +149,7 @@ fn testMissingOutputPath(zig_exe: []const u8, dir_path: []const u8) !void { const result = try exec(dir_path, false, &[_][]const u8{ zig_exe, "build-exe", source_path, output_arg }); const s = std.fs.path.sep_str; const expected: []const u8 = "error: unable to open output directory 'does" ++ s ++ "not" ++ s ++ "exist': FileNotFound\n"; - testing.expectEqualStrings(expected, result.stderr); + try testing.expectEqualStrings(expected, result.stderr); } fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void { @@ -162,20 +162,20 @@ fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void { const run_result1 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", fmt1_zig_path }); // stderr should be file path + \n - testing.expect(std.mem.startsWith(u8, run_result1.stdout, fmt1_zig_path)); - testing.expect(run_result1.stdout.len == fmt1_zig_path.len + 1 and run_result1.stdout[run_result1.stdout.len - 1] == '\n'); + try testing.expect(std.mem.startsWith(u8, run_result1.stdout, fmt1_zig_path)); + try testing.expect(run_result1.stdout.len == fmt1_zig_path.len + 1 and run_result1.stdout[run_result1.stdout.len - 1] == '\n'); const fmt2_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt2.zig" }); try fs.cwd().writeFile(fmt2_zig_path, unformatted_code); const run_result2 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path }); // running it on the dir, only the new file should be changed - testing.expect(std.mem.startsWith(u8, run_result2.stdout, fmt2_zig_path)); - testing.expect(run_result2.stdout.len == fmt2_zig_path.len + 1 and run_result2.stdout[run_result2.stdout.len - 1] == '\n'); + try testing.expect(std.mem.startsWith(u8, run_result2.stdout, fmt2_zig_path)); + try testing.expect(run_result2.stdout.len == fmt2_zig_path.len + 1 and run_result2.stdout[run_result2.stdout.len - 1] == '\n'); const run_result3 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path }); // both files have been formatted, nothing should change now - testing.expect(run_result3.stdout.len == 0); + try testing.expect(run_result3.stdout.len == 0); // Check UTF-16 decoding const fmt4_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt4.zig" }); @@ -183,6 +183,6 @@ fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void { try fs.cwd().writeFile(fmt4_zig_path, unformatted_code_utf16); const run_result4 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path }); - testing.expect(std.mem.startsWith(u8, run_result4.stdout, fmt4_zig_path)); - testing.expect(run_result4.stdout.len == fmt4_zig_path.len + 1 and run_result4.stdout[run_result4.stdout.len - 1] == '\n'); + try testing.expect(std.mem.startsWith(u8, run_result4.stdout, fmt4_zig_path)); + try testing.expect(run_result4.stdout.len == fmt4_zig_path.len + 1 and run_result4.stdout[run_result4.stdout.len - 1] == '\n'); } diff --git a/test/compile_errors.zig b/test/compile_errors.zig index 5b36027248..a1a9fbf460 100644 --- a/test/compile_errors.zig +++ b/test/compile_errors.zig @@ -230,7 +230,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { cases.add("array in c exported function", \\export fn zig_array(x: [10]u8) void { - \\ expect(std.mem.eql(u8, &x, "1234567890")); + \\try expect(std.mem.eql(u8, &x, "1234567890")); \\} \\ \\export fn zig_return_array() [10]u8 { diff --git a/test/stack_traces.zig b/test/stack_traces.zig index cb2cf94b70..4b2d6bebfd 100644 --- a/test/stack_traces.zig +++ b/test/stack_traces.zig @@ -5,13 +5,13 @@ const tests = @import("tests.zig"); pub fn addCases(cases: *tests.StackTracesContext) void { cases.addCase(.{ .name = "return", - .source = + .source = \\pub fn main() !void { \\ return error.TheSkyIsFalling; \\} , .Debug = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:2:5: [address] in main (test) \\ return error.TheSkyIsFalling; @@ -23,7 +23,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { .exclude_os = .{ .windows, // segfault }, - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:2:5: [address] in [function] \\ return error.TheSkyIsFalling; @@ -32,13 +32,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void { , }, .ReleaseFast = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , }, .ReleaseSmall = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , @@ -47,7 +47,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { cases.addCase(.{ .name = "try return", - .source = + .source = \\fn foo() !void { \\ return error.TheSkyIsFalling; \\} @@ -57,7 +57,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { \\} , .Debug = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:2:5: [address] in foo (test) \\ return error.TheSkyIsFalling; @@ -72,7 +72,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { .exclude_os = .{ .windows, // segfault }, - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:2:5: [address] in [function] \\ return error.TheSkyIsFalling; @@ -84,13 +84,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void { , }, .ReleaseFast = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , }, .ReleaseSmall = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , @@ -99,7 +99,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { cases.addCase(.{ .name = "try try return return", - .source = + .source = \\fn foo() !void { \\ try bar(); \\} @@ -117,7 +117,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { \\} , .Debug = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:10:5: [address] in make_error (test) \\ return error.TheSkyIsFalling; @@ -138,7 +138,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { .exclude_os = .{ .windows, // segfault }, - .expect = + .expect = \\error: TheSkyIsFalling \\source.zig:10:5: [address] in [function] \\ return error.TheSkyIsFalling; @@ -156,13 +156,13 @@ pub fn addCases(cases: *tests.StackTracesContext) void { , }, .ReleaseFast = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , }, .ReleaseSmall = .{ - .expect = + .expect = \\error: TheSkyIsFalling \\ , @@ -174,7 +174,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { .windows, }, .name = "dumpCurrentStackTrace", - .source = + .source = \\const std = @import("std"); \\ \\fn bar() void { @@ -189,7 +189,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { \\} , .Debug = .{ - .expect = + .expect = \\source.zig:7:8: [address] in foo (test) \\ bar(); \\ ^ diff --git a/test/stage1/behavior/align.zig b/test/stage1/behavior/align.zig index 38f5df0176..30a460e324 100644 --- a/test/stage1/behavior/align.zig +++ b/test/stage1/behavior/align.zig @@ -5,16 +5,16 @@ const builtin = @import("builtin"); var foo: u8 align(4) = 100; test "global variable alignment" { - comptime expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); - comptime expect(@TypeOf(&foo) == *align(4) u8); + comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); + comptime try expect(@TypeOf(&foo) == *align(4) u8); { const slice = @as(*[1]u8, &foo)[0..]; - comptime expect(@TypeOf(slice) == *align(4) [1]u8); + comptime try expect(@TypeOf(slice) == *align(4) [1]u8); } { var runtime_zero: usize = 0; const slice = @as(*[1]u8, &foo)[runtime_zero..]; - comptime expect(@TypeOf(slice) == []align(4) u8); + comptime try expect(@TypeOf(slice) == []align(4) u8); } } @@ -28,9 +28,9 @@ test "function alignment" { // function alignment is a compile error on wasm32/wasm64 if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; - expect(derp() == 1234); - expect(@TypeOf(noop1) == fn () align(1) void); - expect(@TypeOf(noop4) == fn () align(4) void); + try expect(derp() == 1234); + try expect(@TypeOf(noop1) == fn () align(1) void); + try expect(@TypeOf(noop4) == fn () align(4) void); noop1(); noop4(); } @@ -41,7 +41,7 @@ var baz: packed struct { } = undefined; test "packed struct alignment" { - expect(@TypeOf(&baz.b) == *align(1) u32); + try expect(@TypeOf(&baz.b) == *align(1) u32); } const blah: packed struct { @@ -51,17 +51,17 @@ const blah: packed struct { } = undefined; test "bit field alignment" { - expect(@TypeOf(&blah.b) == *align(1:3:1) const u3); + try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3); } test "default alignment allows unspecified in type syntax" { - expect(*u32 == *align(@alignOf(u32)) u32); + try expect(*u32 == *align(@alignOf(u32)) u32); } test "implicitly decreasing pointer alignment" { const a: u32 align(4) = 3; const b: u32 align(8) = 4; - expect(addUnaligned(&a, &b) == 7); + try expect(addUnaligned(&a, &b) == 7); } fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 { @@ -71,16 +71,16 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 { test "implicitly decreasing slice alignment" { const a: u32 align(4) = 3; const b: u32 align(8) = 4; - expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7); + try expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7); } fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 { return a[0] + b[0]; } test "specifying alignment allows pointer cast" { - testBytesAlign(0x33); + try testBytesAlign(0x33); } -fn testBytesAlign(b: u8) void { +fn testBytesAlign(b: u8) !void { var bytes align(4) = [_]u8{ b, b, @@ -88,13 +88,13 @@ fn testBytesAlign(b: u8) void { b, }; const ptr = @ptrCast(*u32, &bytes[0]); - expect(ptr.* == 0x33333333); + try expect(ptr.* == 0x33333333); } test "@alignCast pointers" { var x: u32 align(4) = 1; expectsOnly1(&x); - expect(x == 2); + try expect(x == 2); } fn expectsOnly1(x: *align(1) u32) void { expects4(@alignCast(4, x)); @@ -110,7 +110,7 @@ test "@alignCast slices" { }; const slice = array[0..]; sliceExpectsOnly1(slice); - expect(slice[0] == 2); + try expect(slice[0] == 2); } fn sliceExpectsOnly1(slice: []align(1) u32) void { sliceExpects4(@alignCast(4, slice)); @@ -123,12 +123,12 @@ test "implicitly decreasing fn alignment" { // function alignment is a compile error on wasm32/wasm64 if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; - testImplicitlyDecreaseFnAlign(alignedSmall, 1234); - testImplicitlyDecreaseFnAlign(alignedBig, 5678); + try testImplicitlyDecreaseFnAlign(alignedSmall, 1234); + try testImplicitlyDecreaseFnAlign(alignedBig, 5678); } -fn testImplicitlyDecreaseFnAlign(ptr: fn () align(1) i32, answer: i32) void { - expect(ptr() == answer); +fn testImplicitlyDecreaseFnAlign(ptr: fn () align(1) i32, answer: i32) !void { + try expect(ptr() == answer); } fn alignedSmall() align(8) i32 { @@ -143,7 +143,7 @@ test "@alignCast functions" { if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; if (builtin.arch == .thumb) return error.SkipZigTest; - expect(fnExpectsOnly1(simple4) == 0x19); + try expect(fnExpectsOnly1(simple4) == 0x19); } fn fnExpectsOnly1(ptr: fn () align(1) i32) i32 { return fnExpects4(@alignCast(4, ptr)); @@ -160,9 +160,9 @@ test "generic function with align param" { if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; if (builtin.arch == .thumb) return error.SkipZigTest; - expect(whyWouldYouEverDoThis(1) == 0x1); - expect(whyWouldYouEverDoThis(4) == 0x1); - expect(whyWouldYouEverDoThis(8) == 0x1); + try expect(whyWouldYouEverDoThis(1) == 0x1); + try expect(whyWouldYouEverDoThis(4) == 0x1); + try expect(whyWouldYouEverDoThis(8) == 0x1); } fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 { @@ -172,49 +172,49 @@ fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 { test "@ptrCast preserves alignment of bigger source" { var x: u32 align(16) = 1234; const ptr = @ptrCast(*u8, &x); - expect(@TypeOf(ptr) == *align(16) u8); + try expect(@TypeOf(ptr) == *align(16) u8); } test "runtime known array index has best alignment possible" { // take full advantage of over-alignment var array align(4) = [_]u8{ 1, 2, 3, 4 }; - expect(@TypeOf(&array[0]) == *align(4) u8); - expect(@TypeOf(&array[1]) == *u8); - expect(@TypeOf(&array[2]) == *align(2) u8); - expect(@TypeOf(&array[3]) == *u8); + try expect(@TypeOf(&array[0]) == *align(4) u8); + try expect(@TypeOf(&array[1]) == *u8); + try expect(@TypeOf(&array[2]) == *align(2) u8); + try expect(@TypeOf(&array[3]) == *u8); // because align is too small but we still figure out to use 2 var bigger align(2) = [_]u64{ 1, 2, 3, 4 }; - expect(@TypeOf(&bigger[0]) == *align(2) u64); - expect(@TypeOf(&bigger[1]) == *align(2) u64); - expect(@TypeOf(&bigger[2]) == *align(2) u64); - expect(@TypeOf(&bigger[3]) == *align(2) u64); + try expect(@TypeOf(&bigger[0]) == *align(2) u64); + try expect(@TypeOf(&bigger[1]) == *align(2) u64); + try expect(@TypeOf(&bigger[2]) == *align(2) u64); + try expect(@TypeOf(&bigger[3]) == *align(2) u64); // because pointer is align 2 and u32 align % 2 == 0 we can assume align 2 var smaller align(2) = [_]u32{ 1, 2, 3, 4 }; var runtime_zero: usize = 0; - comptime expect(@TypeOf(smaller[runtime_zero..]) == []align(2) u32); - comptime expect(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32); - testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32); - testIndex(smaller[runtime_zero..].ptr, 1, *align(2) u32); - testIndex(smaller[runtime_zero..].ptr, 2, *align(2) u32); - testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32); + comptime try expect(@TypeOf(smaller[runtime_zero..]) == []align(2) u32); + comptime try expect(@TypeOf(smaller[runtime_zero..].ptr) == [*]align(2) u32); + try testIndex(smaller[runtime_zero..].ptr, 0, *align(2) u32); + try testIndex(smaller[runtime_zero..].ptr, 1, *align(2) u32); + try testIndex(smaller[runtime_zero..].ptr, 2, *align(2) u32); + try testIndex(smaller[runtime_zero..].ptr, 3, *align(2) u32); // has to use ABI alignment because index known at runtime only - testIndex2(array[runtime_zero..].ptr, 0, *u8); - testIndex2(array[runtime_zero..].ptr, 1, *u8); - testIndex2(array[runtime_zero..].ptr, 2, *u8); - testIndex2(array[runtime_zero..].ptr, 3, *u8); + try testIndex2(array[runtime_zero..].ptr, 0, *u8); + try testIndex2(array[runtime_zero..].ptr, 1, *u8); + try testIndex2(array[runtime_zero..].ptr, 2, *u8); + try testIndex2(array[runtime_zero..].ptr, 3, *u8); } -fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) void { - comptime expect(@TypeOf(&smaller[index]) == T); +fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void { + comptime try expect(@TypeOf(&smaller[index]) == T); } -fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) void { - comptime expect(@TypeOf(&ptr[index]) == T); +fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void { + comptime try expect(@TypeOf(&ptr[index]) == T); } test "alignstack" { - expect(fnWithAlignedStack() == 1234); + try expect(fnWithAlignedStack() == 1234); } fn fnWithAlignedStack() i32 { @@ -223,7 +223,7 @@ fn fnWithAlignedStack() i32 { } test "alignment of structs" { - expect(@alignOf(struct { + try expect(@alignOf(struct { a: i32, b: *i32, }) == @alignOf(usize)); @@ -239,37 +239,37 @@ test "alignment of function with c calling convention" { fn nothing() callconv(.C) void {} test "return error union with 128-bit integer" { - expect(3 == try give()); + try expect(3 == try give()); } fn give() anyerror!u128 { return 3; } test "alignment of >= 128-bit integer type" { - expect(@alignOf(u128) == 16); - expect(@alignOf(u129) == 16); + try expect(@alignOf(u128) == 16); + try expect(@alignOf(u129) == 16); } test "alignment of struct with 128-bit field" { - expect(@alignOf(struct { + try expect(@alignOf(struct { x: u128, }) == 16); comptime { - expect(@alignOf(struct { + try expect(@alignOf(struct { x: u128, }) == 16); } } test "size of extern struct with 128-bit field" { - expect(@sizeOf(extern struct { + try expect(@sizeOf(extern struct { x: u128, y: u8, }) == 32); comptime { - expect(@sizeOf(extern struct { + try expect(@sizeOf(extern struct { x: u128, y: u8, }) == 32); @@ -286,8 +286,8 @@ test "read 128-bit field from default aligned struct in stack memory" { .nevermind = 1, .badguy = 12, }; - expect((@ptrToInt(&default_aligned.badguy) % 16) == 0); - expect(12 == default_aligned.badguy); + try expect((@ptrToInt(&default_aligned.badguy) % 16) == 0); + try expect(12 == default_aligned.badguy); } var default_aligned_global = DefaultAligned{ @@ -296,8 +296,8 @@ var default_aligned_global = DefaultAligned{ }; test "read 128-bit field from default aligned struct in global memory" { - expect((@ptrToInt(&default_aligned_global.badguy) % 16) == 0); - expect(12 == default_aligned_global.badguy); + try expect((@ptrToInt(&default_aligned_global.badguy) % 16) == 0); + try expect(12 == default_aligned_global.badguy); } test "struct field explicit alignment" { @@ -310,9 +310,9 @@ test "struct field explicit alignment" { var node: S.Node = undefined; node.massive_byte = 100; - expect(node.massive_byte == 100); - comptime expect(@TypeOf(&node.massive_byte) == *align(64) u8); - expect(@ptrToInt(&node.massive_byte) % 64 == 0); + try expect(node.massive_byte == 100); + comptime try expect(@TypeOf(&node.massive_byte) == *align(64) u8); + try expect(@ptrToInt(&node.massive_byte) % 64 == 0); } test "align(@alignOf(T)) T does not force resolution of T" { @@ -334,7 +334,7 @@ test "align(@alignOf(T)) T does not force resolution of T" { var ok = false; }; _ = async S.doTheTest(); - expect(S.ok); + try expect(S.ok); } test "align(N) on functions" { @@ -342,7 +342,7 @@ test "align(N) on functions" { if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; if (builtin.arch == .thumb) return error.SkipZigTest; - expect((@ptrToInt(overaligned_fn) & (0x1000 - 1)) == 0); + try expect((@ptrToInt(overaligned_fn) & (0x1000 - 1)) == 0); } fn overaligned_fn() align(0x1000) i32 { return 42; diff --git a/test/stage1/behavior/alignof.zig b/test/stage1/behavior/alignof.zig index 96114ed560..775c831cff 100644 --- a/test/stage1/behavior/alignof.zig +++ b/test/stage1/behavior/alignof.zig @@ -10,29 +10,29 @@ const Foo = struct { }; test "@alignOf(T) before referencing T" { - comptime expect(@alignOf(Foo) != maxInt(usize)); + comptime try expect(@alignOf(Foo) != maxInt(usize)); if (builtin.arch == builtin.Arch.x86_64) { - comptime expect(@alignOf(Foo) == 4); + comptime try expect(@alignOf(Foo) == 4); } } test "comparison of @alignOf(T) against zero" { { const T = struct { x: u32 }; - expect(!(@alignOf(T) == 0)); - expect(@alignOf(T) != 0); - expect(!(@alignOf(T) < 0)); - expect(!(@alignOf(T) <= 0)); - expect(@alignOf(T) > 0); - expect(@alignOf(T) >= 0); + try expect(!(@alignOf(T) == 0)); + try expect(@alignOf(T) != 0); + try expect(!(@alignOf(T) < 0)); + try expect(!(@alignOf(T) <= 0)); + try expect(@alignOf(T) > 0); + try expect(@alignOf(T) >= 0); } { const T = struct {}; - expect(@alignOf(T) == 0); - expect(!(@alignOf(T) != 0)); - expect(!(@alignOf(T) < 0)); - expect(@alignOf(T) <= 0); - expect(!(@alignOf(T) > 0)); - expect(@alignOf(T) >= 0); + try expect(@alignOf(T) == 0); + try expect(!(@alignOf(T) != 0)); + try expect(!(@alignOf(T) < 0)); + try expect(@alignOf(T) <= 0); + try expect(!(@alignOf(T) > 0)); + try expect(@alignOf(T) >= 0); } } diff --git a/test/stage1/behavior/array.zig b/test/stage1/behavior/array.zig index 39ccc72960..84a2cdb36c 100644 --- a/test/stage1/behavior/array.zig +++ b/test/stage1/behavior/array.zig @@ -21,8 +21,8 @@ test "arrays" { i += 1; } - expect(accumulator == 15); - expect(getArrayLen(&array) == 5); + try expect(accumulator == 15); + try expect(getArrayLen(&array) == 5); } fn getArrayLen(a: []const u32) usize { return a.len; @@ -30,37 +30,37 @@ fn getArrayLen(a: []const u32) usize { test "array with sentinels" { const S = struct { - fn doTheTest(is_ct: bool) void { + fn doTheTest(is_ct: bool) !void { if (is_ct) { var zero_sized: [0:0xde]u8 = [_:0xde]u8{}; // Disabled at runtime because of // https://github.com/ziglang/zig/issues/4372 - expectEqual(@as(u8, 0xde), zero_sized[0]); + try expectEqual(@as(u8, 0xde), zero_sized[0]); var reinterpreted = @ptrCast(*[1]u8, &zero_sized); - expectEqual(@as(u8, 0xde), reinterpreted[0]); + try expectEqual(@as(u8, 0xde), reinterpreted[0]); } var arr: [3:0x55]u8 = undefined; // Make sure the sentinel pointer is pointing after the last element if (!is_ct) { const sentinel_ptr = @ptrToInt(&arr[3]); const last_elem_ptr = @ptrToInt(&arr[2]); - expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr); + try expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr); } // Make sure the sentinel is writeable arr[3] = 0x55; } }; - S.doTheTest(false); - comptime S.doTheTest(true); + try S.doTheTest(false); + comptime try S.doTheTest(true); } test "void arrays" { var array: [4]void = undefined; array[0] = void{}; array[1] = array[2]; - expect(@sizeOf(@TypeOf(array)) == 0); - expect(array.len == 4); + try expect(@sizeOf(@TypeOf(array)) == 0); + try expect(array.len == 4); } test "array literal" { @@ -71,12 +71,12 @@ test "array literal" { 1, }; - expect(hex_mult.len == 4); - expect(hex_mult[1] == 256); + try expect(hex_mult.len == 4); + try expect(hex_mult[1] == 256); } test "array dot len const expr" { - expect(comptime x: { + try expect(comptime x: { break :x some_array.len == 4; }); } @@ -100,11 +100,11 @@ test "nested arrays" { "thing", }; for (array_of_strings) |s, i| { - if (i == 0) expect(mem.eql(u8, s, "hello")); - if (i == 1) expect(mem.eql(u8, s, "this")); - if (i == 2) expect(mem.eql(u8, s, "is")); - if (i == 3) expect(mem.eql(u8, s, "my")); - if (i == 4) expect(mem.eql(u8, s, "thing")); + if (i == 0) try expect(mem.eql(u8, s, "hello")); + if (i == 1) try expect(mem.eql(u8, s, "this")); + if (i == 2) try expect(mem.eql(u8, s, "is")); + if (i == 3) try expect(mem.eql(u8, s, "my")); + if (i == 4) try expect(mem.eql(u8, s, "thing")); } } @@ -122,9 +122,9 @@ test "set global var array via slice embedded in struct" { s.a[1].b = 2; s.a[2].b = 3; - expect(s_array[0].b == 1); - expect(s_array[1].b == 2); - expect(s_array[2].b == 3); + try expect(s_array[0].b == 1); + try expect(s_array[1].b == 2); + try expect(s_array[2].b == 3); } test "array literal with specified size" { @@ -132,34 +132,34 @@ test "array literal with specified size" { 1, 2, }; - expect(array[0] == 1); - expect(array[1] == 2); + try expect(array[0] == 1); + try expect(array[1] == 2); } test "array len field" { var arr = [4]u8{ 0, 0, 0, 0 }; var ptr = &arr; - expect(arr.len == 4); - comptime expect(arr.len == 4); - expect(ptr.len == 4); - comptime expect(ptr.len == 4); + try expect(arr.len == 4); + comptime try expect(arr.len == 4); + try expect(ptr.len == 4); + comptime try expect(ptr.len == 4); } test "single-item pointer to array indexing and slicing" { - testSingleItemPtrArrayIndexSlice(); - comptime testSingleItemPtrArrayIndexSlice(); + try testSingleItemPtrArrayIndexSlice(); + comptime try testSingleItemPtrArrayIndexSlice(); } -fn testSingleItemPtrArrayIndexSlice() void { +fn testSingleItemPtrArrayIndexSlice() !void { { var array: [4]u8 = "aaaa".*; doSomeMangling(&array); - expect(mem.eql(u8, "azya", &array)); + try expect(mem.eql(u8, "azya", &array)); } { var array = "aaaa".*; doSomeMangling(&array); - expect(mem.eql(u8, "azya", &array)); + try expect(mem.eql(u8, "azya", &array)); } } @@ -169,15 +169,15 @@ fn doSomeMangling(array: *[4]u8) void { } test "implicit cast single-item pointer" { - testImplicitCastSingleItemPtr(); - comptime testImplicitCastSingleItemPtr(); + try testImplicitCastSingleItemPtr(); + comptime try testImplicitCastSingleItemPtr(); } -fn testImplicitCastSingleItemPtr() void { +fn testImplicitCastSingleItemPtr() !void { var byte: u8 = 100; const slice = @as(*[1]u8, &byte)[0..]; slice[0] += 1; - expect(byte == 101); + try expect(byte == 101); } fn testArrayByValAtComptime(b: [2]u8) u8 { @@ -192,7 +192,7 @@ test "comptime evalutating function that takes array by value" { test "implicit comptime in array type size" { var arr: [plusOne(10)]bool = undefined; - expect(arr.len == 11); + try expect(arr.len == 11); } fn plusOne(x: u32) u32 { @@ -202,52 +202,52 @@ fn plusOne(x: u32) u32 { test "runtime initialize array elem and then implicit cast to slice" { var two: i32 = 2; const x: []const i32 = &[_]i32{two}; - expect(x[0] == 2); + try expect(x[0] == 2); } test "array literal as argument to function" { const S = struct { - fn entry(two: i32) void { - foo(&[_]i32{ + fn entry(two: i32) !void { + try foo(&[_]i32{ 1, 2, 3, }); - foo(&[_]i32{ + try foo(&[_]i32{ 1, two, 3, }); - foo2(true, &[_]i32{ + try foo2(true, &[_]i32{ 1, 2, 3, }); - foo2(true, &[_]i32{ + try foo2(true, &[_]i32{ 1, two, 3, }); } - fn foo(x: []const i32) void { - expect(x[0] == 1); - expect(x[1] == 2); - expect(x[2] == 3); + fn foo(x: []const i32) !void { + try expect(x[0] == 1); + try expect(x[1] == 2); + try expect(x[2] == 3); } - fn foo2(trash: bool, x: []const i32) void { - expect(trash); - expect(x[0] == 1); - expect(x[1] == 2); - expect(x[2] == 3); + fn foo2(trash: bool, x: []const i32) !void { + try expect(trash); + try expect(x[0] == 1); + try expect(x[1] == 2); + try expect(x[2] == 3); } }; - S.entry(2); - comptime S.entry(2); + try S.entry(2); + comptime try S.entry(2); } test "double nested array to const slice cast in array literal" { const S = struct { - fn entry(two: i32) void { + fn entry(two: i32) !void { const cases = [_][]const []const i32{ &[_][]const i32{&[_]i32{1}}, &[_][]const i32{&[_]i32{ 2, 3 }}, @@ -256,18 +256,18 @@ test "double nested array to const slice cast in array literal" { &[_]i32{ 5, 6, 7 }, }, }; - check(&cases); + try check(&cases); const cases2 = [_][]const i32{ &[_]i32{1}, &[_]i32{ two, 3 }, }; - expect(cases2.len == 2); - expect(cases2[0].len == 1); - expect(cases2[0][0] == 1); - expect(cases2[1].len == 2); - expect(cases2[1][0] == 2); - expect(cases2[1][1] == 3); + try expect(cases2.len == 2); + try expect(cases2[0].len == 1); + try expect(cases2[0][0] == 1); + try expect(cases2[1].len == 2); + try expect(cases2[1][0] == 2); + try expect(cases2[1][1] == 3); const cases3 = [_][]const []const i32{ &[_][]const i32{&[_]i32{1}}, @@ -277,37 +277,37 @@ test "double nested array to const slice cast in array literal" { &[_]i32{ 5, 6, 7 }, }, }; - check(&cases3); + try check(&cases3); } - fn check(cases: []const []const []const i32) void { - expect(cases.len == 3); - expect(cases[0].len == 1); - expect(cases[0][0].len == 1); - expect(cases[0][0][0] == 1); - expect(cases[1].len == 1); - expect(cases[1][0].len == 2); - expect(cases[1][0][0] == 2); - expect(cases[1][0][1] == 3); - expect(cases[2].len == 2); - expect(cases[2][0].len == 1); - expect(cases[2][0][0] == 4); - expect(cases[2][1].len == 3); - expect(cases[2][1][0] == 5); - expect(cases[2][1][1] == 6); - expect(cases[2][1][2] == 7); + fn check(cases: []const []const []const i32) !void { + try expect(cases.len == 3); + try expect(cases[0].len == 1); + try expect(cases[0][0].len == 1); + try expect(cases[0][0][0] == 1); + try expect(cases[1].len == 1); + try expect(cases[1][0].len == 2); + try expect(cases[1][0][0] == 2); + try expect(cases[1][0][1] == 3); + try expect(cases[2].len == 2); + try expect(cases[2][0].len == 1); + try expect(cases[2][0][0] == 4); + try expect(cases[2][1].len == 3); + try expect(cases[2][1][0] == 5); + try expect(cases[2][1][1] == 6); + try expect(cases[2][1][2] == 7); } }; - S.entry(2); - comptime S.entry(2); + try S.entry(2); + comptime try S.entry(2); } test "read/write through global variable array of struct fields initialized via array mult" { const S = struct { - fn doTheTest() void { - expect(storage[0].term == 1); + fn doTheTest() !void { + try expect(storage[0].term == 1); storage[0] = MyStruct{ .term = 123 }; - expect(storage[0].term == 123); + try expect(storage[0].term == 123); } pub const MyStruct = struct { @@ -316,34 +316,34 @@ test "read/write through global variable array of struct fields initialized via var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1; }; - S.doTheTest(); + try S.doTheTest(); } test "implicit cast zero sized array ptr to slice" { { var b = "".*; const c: []const u8 = &b; - expect(c.len == 0); + try expect(c.len == 0); } { var b: [0]u8 = "".*; const c: []const u8 = &b; - expect(c.len == 0); + try expect(c.len == 0); } } test "anonymous list literal syntax" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array: [4]u8 = .{ 1, 2, 3, 4 }; - expect(array[0] == 1); - expect(array[1] == 2); - expect(array[2] == 3); - expect(array[3] == 4); + try expect(array[0] == 1); + try expect(array[1] == 2); + try expect(array[2] == 3); + try expect(array[3] == 4); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "anonymous literal in array" { @@ -352,51 +352,51 @@ test "anonymous literal in array" { a: usize = 2, b: usize = 4, }; - fn doTheTest() void { + fn doTheTest() !void { var array: [2]Foo = .{ .{ .a = 3 }, .{ .b = 3 }, }; - expect(array[0].a == 3); - expect(array[0].b == 4); - expect(array[1].a == 2); - expect(array[1].b == 3); + try expect(array[0].a == 3); + try expect(array[0].b == 4); + try expect(array[1].a == 2); + try expect(array[1].b == 3); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "access the null element of a null terminated array" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' }; - expect(array[4] == 0); + try expect(array[4] == 0); var len: usize = 4; - expect(array[len] == 0); + try expect(array[len] == 0); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "type deduction for array subscript expression" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array = [_]u8{ 0x55, 0xAA }; var v0 = true; - expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]); + try expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]); var v1 = false; - expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]); + try expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "sentinel element count towards the ABI size calculation" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const T = packed struct { fill_pre: u8 = 0x55, data: [0:0]u8 = undefined, @@ -404,14 +404,14 @@ test "sentinel element count towards the ABI size calculation" { }; var x = T{}; var as_slice = mem.asBytes(&x); - expectEqual(@as(usize, 3), as_slice.len); - expectEqual(@as(u8, 0x55), as_slice[0]); - expectEqual(@as(u8, 0xAA), as_slice[2]); + try expectEqual(@as(usize, 3), as_slice.len); + try expectEqual(@as(u8, 0x55), as_slice[0]); + try expectEqual(@as(u8, 0xAA), as_slice[2]); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "zero-sized array with recursive type definition" { @@ -429,61 +429,61 @@ test "zero-sized array with recursive type definition" { }; var t: S = .{ .list = .{ .s = undefined } }; - expectEqual(@as(usize, 0), t.list.x); + try expectEqual(@as(usize, 0), t.list.x); } test "type coercion of anon struct literal to array" { const S = struct { - const U = union{ + const U = union { a: u32, b: bool, c: []const u8, }; - fn doTheTest() void { + fn doTheTest() !void { var x1: u8 = 42; const t1 = .{ x1, 56, 54 }; var arr1: [3]u8 = t1; - expect(arr1[0] == 42); - expect(arr1[1] == 56); - expect(arr1[2] == 54); - + try expect(arr1[0] == 42); + try expect(arr1[1] == 56); + try expect(arr1[2] == 54); + var x2: U = .{ .a = 42 }; const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } }; var arr2: [3]U = t2; - expect(arr2[0].a == 42); - expect(arr2[1].b == true); - expect(mem.eql(u8, arr2[2].c, "hello")); + try expect(arr2[0].a == 42); + try expect(arr2[1].b == true); + try expect(mem.eql(u8, arr2[2].c, "hello")); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "type coercion of pointer to anon struct literal to pointer to array" { const S = struct { - const U = union{ + const U = union { a: u32, b: bool, c: []const u8, }; - fn doTheTest() void { + fn doTheTest() !void { var x1: u8 = 42; const t1 = &.{ x1, 56, 54 }; - var arr1: *const[3]u8 = t1; - expect(arr1[0] == 42); - expect(arr1[1] == 56); - expect(arr1[2] == 54); - + var arr1: *const [3]u8 = t1; + try expect(arr1[0] == 42); + try expect(arr1[1] == 56); + try expect(arr1[2] == 54); + var x2: U = .{ .a = 42 }; const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } }; var arr2: *const [3]U = t2; - expect(arr2[0].a == 42); - expect(arr2[1].b == true); - expect(mem.eql(u8, arr2[2].c, "hello")); + try expect(arr2[0].a == 42); + try expect(arr2[1].b == true); + try expect(mem.eql(u8, arr2[2].c, "hello")); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/asm.zig b/test/stage1/behavior/asm.zig index ade774910d..c9bffa806d 100644 --- a/test/stage1/behavior/asm.zig +++ b/test/stage1/behavior/asm.zig @@ -15,7 +15,7 @@ comptime { test "module level assembly" { if (is_x86_64_linux) { - expect(this_is_my_alias() == 1234); + try expect(this_is_my_alias() == 1234); } } diff --git a/test/stage1/behavior/async_fn.zig b/test/stage1/behavior/async_fn.zig index 09db0eeb29..d222f378bb 100644 --- a/test/stage1/behavior/async_fn.zig +++ b/test/stage1/behavior/async_fn.zig @@ -9,12 +9,12 @@ var global_x: i32 = 1; test "simple coroutine suspend and resume" { var frame = async simpleAsyncFn(); - expect(global_x == 2); + try expect(global_x == 2); resume frame; - expect(global_x == 3); + try expect(global_x == 3); const af: anyframe->void = &frame; resume frame; - expect(global_x == 4); + try expect(global_x == 4); } fn simpleAsyncFn() void { global_x += 1; @@ -28,9 +28,9 @@ var global_y: i32 = 1; test "pass parameter to coroutine" { var p = async simpleAsyncFnWithArg(2); - expect(global_y == 3); + try expect(global_y == 3); resume p; - expect(global_y == 5); + try expect(global_y == 5); } fn simpleAsyncFnWithArg(delta: i32) void { global_y += delta; @@ -42,10 +42,10 @@ test "suspend at end of function" { const S = struct { var x: i32 = 1; - fn doTheTest() void { - expect(x == 1); + fn doTheTest() !void { + try expect(x == 1); const p = async suspendAtEnd(); - expect(x == 2); + try expect(x == 2); } fn suspendAtEnd() void { @@ -53,23 +53,23 @@ test "suspend at end of function" { suspend {} } }; - S.doTheTest(); + try S.doTheTest(); } test "local variable in async function" { const S = struct { var x: i32 = 0; - fn doTheTest() void { - expect(x == 0); + fn doTheTest() !void { + try expect(x == 0); var p = async add(1, 2); - expect(x == 0); + try expect(x == 0); resume p; - expect(x == 0); + try expect(x == 0); resume p; - expect(x == 0); + try expect(x == 0); resume p; - expect(x == 3); + try expect(x == 3); } fn add(a: i32, b: i32) void { @@ -82,7 +82,7 @@ test "local variable in async function" { x = accum; } }; - S.doTheTest(); + try S.doTheTest(); } test "calling an inferred async function" { @@ -90,11 +90,11 @@ test "calling an inferred async function" { var x: i32 = 1; var other_frame: *@Frame(other) = undefined; - fn doTheTest() void { + fn doTheTest() !void { _ = async first(); - expect(x == 1); + try expect(x == 1); resume other_frame.*; - expect(x == 2); + try expect(x == 2); } fn first() void { @@ -106,7 +106,7 @@ test "calling an inferred async function" { x += 1; } }; - S.doTheTest(); + try S.doTheTest(); } test "@frameSize" { @@ -114,16 +114,16 @@ test "@frameSize" { return error.SkipZigTest; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { { var ptr = @ptrCast(fn (i32) callconv(.Async) void, other); const size = @frameSize(ptr); - expect(size == @sizeOf(@Frame(other))); + try expect(size == @sizeOf(@Frame(other))); } { var ptr = @ptrCast(fn () callconv(.Async) void, first); const size = @frameSize(ptr); - expect(size == @sizeOf(@Frame(first))); + try expect(size == @sizeOf(@Frame(first))); } } @@ -135,20 +135,20 @@ test "@frameSize" { suspend {} } }; - S.doTheTest(); + try S.doTheTest(); } test "coroutine suspend, resume" { const S = struct { var frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { _ = async amain(); seq('d'); resume frame; seq('h'); - expect(std.mem.eql(u8, &points, "abcdefgh")); + try expect(std.mem.eql(u8, &points, "abcdefgh")); } fn amain() void { @@ -176,27 +176,27 @@ test "coroutine suspend, resume" { index += 1; } }; - S.doTheTest(); + try S.doTheTest(); } test "coroutine suspend with block" { const p = async testSuspendBlock(); - expect(!global_result); + try expect(!global_result); resume a_promise; - expect(global_result); + try expect(global_result); } var a_promise: anyframe = undefined; var global_result = false; fn testSuspendBlock() callconv(.Async) void { suspend { - comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock)); + comptime expect(@TypeOf(@frame()) == *@Frame(testSuspendBlock)) catch unreachable; a_promise = @frame(); } // Test to make sure that @frame() works as advertised (issue #1296) // var our_handle: anyframe = @frame(); - expect(a_promise == @as(anyframe, @frame())); + expect(a_promise == @as(anyframe, @frame())) catch @panic("test failed"); global_result = true; } @@ -210,8 +210,8 @@ test "coroutine await" { await_seq('f'); resume await_a_promise; await_seq('i'); - expect(await_final_result == 1234); - expect(std.mem.eql(u8, &await_points, "abcdefghi")); + try expect(await_final_result == 1234); + try expect(std.mem.eql(u8, &await_points, "abcdefghi")); } fn await_amain() callconv(.Async) void { await_seq('b'); @@ -244,8 +244,8 @@ test "coroutine await early return" { early_seq('a'); var p = async early_amain(); early_seq('f'); - expect(early_final_result == 1234); - expect(std.mem.eql(u8, &early_points, "abcdef")); + try expect(early_final_result == 1234); + try expect(std.mem.eql(u8, &early_points, "abcdef")); } fn early_amain() callconv(.Async) void { early_seq('b'); @@ -276,7 +276,7 @@ test "async function with dot syntax" { } }; const p = async S.foo(); - expect(S.y == 2); + try expect(S.y == 2); } test "async fn pointer in a struct field" { @@ -287,12 +287,12 @@ test "async fn pointer in a struct field" { var foo = Foo{ .bar = simpleAsyncFn2 }; var bytes: [64]u8 align(16) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); - comptime expect(@TypeOf(f) == anyframe->void); - expect(data == 2); + comptime try expect(@TypeOf(f) == anyframe->void); + try expect(data == 2); resume f; - expect(data == 4); + try expect(data == 4); _ = async doTheAwait(f); - expect(data == 4); + try expect(data == 4); } fn doTheAwait(f: anyframe->void) void { @@ -323,22 +323,22 @@ test "@asyncCall with return type" { var bytes: [150]u8 align(16) = undefined; var aresult: i32 = 0; _ = @asyncCall(&bytes, &aresult, foo.bar, .{}); - expect(aresult == 0); + try expect(aresult == 0); resume Foo.global_frame; - expect(aresult == 1234); + try expect(aresult == 1234); } test "async fn with inferred error set" { const S = struct { var global_frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { var frame: [1]@Frame(middle) = undefined; var fn_ptr = middle; var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined; _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{}); resume global_frame; - std.testing.expectError(error.Fail, result); + try std.testing.expectError(error.Fail, result); } fn middle() callconv(.Async) !void { var f = async middle2(); @@ -355,7 +355,7 @@ test "async fn with inferred error set" { return error.Fail; } }; - S.doTheTest(); + try S.doTheTest(); } test "error return trace across suspend points - early return" { @@ -383,9 +383,9 @@ fn suspendThenFail() callconv(.Async) anyerror!void { } fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void { (await p) catch |e| { - std.testing.expect(e == error.Fail); + std.testing.expect(e == error.Fail) catch @panic("test failure"); if (@errorReturnTrace()) |trace| { - expect(trace.index == 1); + expect(trace.index == 1) catch @panic("test failure"); } else switch (builtin.mode) { .Debug, .ReleaseSafe => @panic("expected return trace"), .ReleaseFast, .ReleaseSmall => {}, @@ -396,7 +396,7 @@ fn printTrace(p: anyframe->(anyerror!void)) callconv(.Async) void { test "break from suspend" { var my_result: i32 = 1; const p = async testBreakFromSuspend(&my_result); - std.testing.expect(my_result == 2); + try std.testing.expect(my_result == 2); } fn testBreakFromSuspend(my_result: *i32) callconv(.Async) void { suspend { @@ -415,11 +415,11 @@ test "heap allocated async function frame" { const frame = try std.testing.allocator.create(@Frame(someFunc)); defer std.testing.allocator.destroy(frame); - expect(x == 42); + try expect(x == 42); frame.* = async someFunc(); - expect(x == 43); + try expect(x == 43); resume frame; - expect(x == 44); + try expect(x == 44); } fn someFunc() void { @@ -436,15 +436,15 @@ test "async function call return value" { var frame: anyframe = undefined; var pt = Point{ .x = 10, .y = 11 }; - fn doTheTest() void { - expectEqual(pt.x, 10); - expectEqual(pt.y, 11); + fn doTheTest() !void { + try expectEqual(pt.x, 10); + try expectEqual(pt.y, 11); _ = async first(); - expectEqual(pt.x, 10); - expectEqual(pt.y, 11); + try expectEqual(pt.x, 10); + try expectEqual(pt.y, 11); resume frame; - expectEqual(pt.x, 1); - expectEqual(pt.y, 2); + try expectEqual(pt.x, 1); + try expectEqual(pt.y, 2); } fn first() void { @@ -469,23 +469,23 @@ test "async function call return value" { y: i32, }; }; - S.doTheTest(); + try S.doTheTest(); } test "suspension points inside branching control flow" { const S = struct { var result: i32 = 10; - fn doTheTest() void { - expect(10 == result); + fn doTheTest() !void { + try expect(10 == result); var frame = async func(true); - expect(10 == result); + try expect(10 == result); resume frame; - expect(11 == result); + try expect(11 == result); resume frame; - expect(12 == result); + try expect(12 == result); resume frame; - expect(13 == result); + try expect(13 == result); } fn func(b: bool) void { @@ -495,7 +495,7 @@ test "suspension points inside branching control flow" { } } }; - S.doTheTest(); + try S.doTheTest(); } test "call async function which has struct return type" { @@ -509,8 +509,8 @@ test "call async function which has struct return type" { fn atest() void { const result = func(); - expect(result.x == 5); - expect(result.y == 6); + expect(result.x == 5) catch @panic("test failed"); + expect(result.y == 6) catch @panic("test failed"); } const Point = struct { @@ -536,27 +536,27 @@ test "pass string literal to async function" { var frame: anyframe = undefined; var ok: bool = false; - fn doTheTest() void { + fn doTheTest() !void { _ = async hello("hello"); resume frame; - expect(ok); + try expect(ok); } fn hello(msg: []const u8) void { frame = @frame(); suspend {} - expectEqualStrings("hello", msg); + expectEqualStrings("hello", msg) catch @panic("test failed"); ok = true; } }; - S.doTheTest(); + try S.doTheTest(); } test "await inside an errdefer" { const S = struct { var frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { _ = async amainWrap(); resume frame; } @@ -572,7 +572,7 @@ test "await inside an errdefer" { suspend {} } }; - S.doTheTest(); + try S.doTheTest(); } test "try in an async function with error union and non-zero-bit payload" { @@ -580,14 +580,14 @@ test "try in an async function with error union and non-zero-bit payload" { var frame: anyframe = undefined; var ok = false; - fn doTheTest() void { + fn doTheTest() !void { _ = async amain(); resume frame; - expect(ok); + try expect(ok); } fn amain() void { - std.testing.expectError(error.Bad, theProblem()); + std.testing.expectError(error.Bad, theProblem()) catch @panic("test failed"); ok = true; } @@ -602,7 +602,7 @@ test "try in an async function with error union and non-zero-bit payload" { return error.Bad; } }; - S.doTheTest(); + try S.doTheTest(); } test "returning a const error from async function" { @@ -610,10 +610,10 @@ test "returning a const error from async function" { var frame: anyframe = undefined; var ok = false; - fn doTheTest() void { + fn doTheTest() !void { _ = async amain(); resume frame; - expect(ok); + try expect(ok); } fn amain() !void { @@ -630,7 +630,7 @@ test "returning a const error from async function" { return error.OutOfMemory; } }; - S.doTheTest(); + try S.doTheTest(); } test "async/await typical usage" { @@ -663,11 +663,11 @@ fn testAsyncAwaitTypicalUsage( } fn amainWrap() void { if (amain()) |_| { - expect(!simulate_fail_download); - expect(!simulate_fail_file); + expect(!simulate_fail_download) catch @panic("test failure"); + expect(!simulate_fail_file) catch @panic("test failure"); } else |e| switch (e) { - error.NoResponse => expect(simulate_fail_download), - error.FileNotFound => expect(simulate_fail_file), + error.NoResponse => expect(simulate_fail_download) catch @panic("test failure"), + error.FileNotFound => expect(simulate_fail_file) catch @panic("test failure"), else => @panic("test failure"), } } @@ -694,8 +694,8 @@ fn testAsyncAwaitTypicalUsage( const file_text = try await file_frame; defer allocator.free(file_text); - expect(std.mem.eql(u8, "expected download text", download_text)); - expect(std.mem.eql(u8, "expected file text", file_text)); + try expect(std.mem.eql(u8, "expected download text", download_text)); + try expect(std.mem.eql(u8, "expected file text", file_text)); } var global_download_frame: anyframe = undefined; @@ -728,13 +728,13 @@ fn testAsyncAwaitTypicalUsage( test "alignment of local variables in async functions" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var y: u8 = 123; var x: u8 align(128) = 1; - expect(@ptrToInt(&x) % 128 == 0); + try expect(@ptrToInt(&x) % 128 == 0); } }; - S.doTheTest(); + try S.doTheTest(); } test "no reason to resolve frame still works" { @@ -746,10 +746,10 @@ fn simpleNothing() void { test "async call a generic function" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var f = async func(i32, 2); const result = await f; - expect(result == 3); + try expect(result == 3); } fn func(comptime T: type, inc: T) T { @@ -766,8 +766,8 @@ test "async call a generic function" { test "return from suspend block" { const S = struct { - fn doTheTest() void { - expect(func() == 1234); + fn doTheTest() !void { + expect(func() == 1234) catch @panic("test failure"); } fn func() i32 { suspend { @@ -808,7 +808,7 @@ test "struct parameter to async function is copied to the frame" { var pt = Point{ .x = 1, .y = 2 }; f.* = async foo(pt); var result = await f; - expect(result == 1); + expect(result == 1) catch @panic("test failure"); } fn foo(point: Point) i32 { @@ -833,7 +833,7 @@ test "cast fn to async fn when it is inferred to be async" { var result: i32 = undefined; const f = @asyncCall(&buf, &result, ptr, .{}); _ = await f; - expect(result == 1234); + expect(result == 1234) catch @panic("test failure"); ok = true; } @@ -846,7 +846,7 @@ test "cast fn to async fn when it is inferred to be async" { }; _ = async S.doTheTest(); resume S.frame; - expect(S.ok); + try expect(S.ok); } test "cast fn to async fn when it is inferred to be async, awaited directly" { @@ -860,7 +860,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" { var buf: [100]u8 align(16) = undefined; var result: i32 = undefined; _ = await @asyncCall(&buf, &result, ptr, .{}); - expect(result == 1234); + expect(result == 1234) catch @panic("test failure"); ok = true; } @@ -873,7 +873,7 @@ test "cast fn to async fn when it is inferred to be async, awaited directly" { }; _ = async S.doTheTest(); resume S.frame; - expect(S.ok); + try expect(S.ok); } test "await does not force async if callee is blocking" { @@ -883,12 +883,12 @@ test "await does not force async if callee is blocking" { } }; var x = async S.simple(); - expect(await x == 1234); + try expect(await x == 1234); } test "recursive async function" { - expect(recursiveAsyncFunctionTest(false).doTheTest() == 55); - expect(recursiveAsyncFunctionTest(true).doTheTest() == 55); + try expect(recursiveAsyncFunctionTest(false).doTheTest() == 55); + try expect(recursiveAsyncFunctionTest(true).doTheTest() == 55); } fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type { @@ -952,12 +952,12 @@ test "@asyncCall with comptime-known function, but not awaited directly" { const S = struct { var global_frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { var frame: [1]@Frame(middle) = undefined; var result: @typeInfo(@typeInfo(@TypeOf(middle)).Fn.return_type.?).ErrorUnion.error_set!void = undefined; _ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{}); resume global_frame; - std.testing.expectError(error.Fail, result); + try std.testing.expectError(error.Fail, result); } fn middle() callconv(.Async) !void { var f = async middle2(); @@ -974,7 +974,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" { return error.Fail; } }; - S.doTheTest(); + try S.doTheTest(); } test "@asyncCall with actual frame instead of byte buffer" { @@ -988,7 +988,7 @@ test "@asyncCall with actual frame instead of byte buffer" { var result: i32 = undefined; const ptr = @asyncCall(&frame, &result, S.func, .{}); resume ptr; - expect(result == 1234); + try expect(result == 1234); } test "@asyncCall using the result location inside the frame" { @@ -1010,19 +1010,19 @@ test "@asyncCall using the result location inside the frame" { var foo = Foo{ .bar = S.simple2 }; var bytes: [64]u8 align(16) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); - comptime expect(@TypeOf(f) == anyframe->i32); - expect(data == 2); + comptime try expect(@TypeOf(f) == anyframe->i32); + try expect(data == 2); resume f; - expect(data == 4); + try expect(data == 4); _ = async S.getAnswer(f, &data); - expect(data == 1234); + try expect(data == 1234); } test "@TypeOf an async function call of generic fn with error union type" { const S = struct { fn func(comptime x: anytype) anyerror!i32 { const T = @TypeOf(async func(x)); - comptime expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child); + comptime try expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child); return undefined; } }; @@ -1051,7 +1051,7 @@ test "using @TypeOf on a generic function call" { }; _ = async S.amain(@as(u32, 1)); resume S.global_frame; - expect(S.global_ok); + try expect(S.global_ok); } test "recursive call of await @asyncCall with struct return type" { @@ -1084,17 +1084,17 @@ test "recursive call of await @asyncCall with struct return type" { var frame: @TypeOf(async S.amain(@as(u32, 1))) = undefined; _ = @asyncCall(&frame, &res, S.amain, .{@as(u32, 1)}); resume S.global_frame; - expect(S.global_ok); - expect(res.x == 1); - expect(res.y == 2); - expect(res.z == 3); + try expect(S.global_ok); + try expect(res.x == 1); + try expect(res.y == 2); + try expect(res.z == 3); } test "nosuspend function call" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const result = nosuspend add(50, 100); - expect(result == 150); + try expect(result == 150); } fn add(a: i32, b: i32) i32 { if (a > 100) { @@ -1103,7 +1103,7 @@ test "nosuspend function call" { return a + b; } }; - S.doTheTest(); + try S.doTheTest(); } test "await used in expression and awaiting fn with no suspend but async calling convention" { @@ -1113,7 +1113,7 @@ test "await used in expression and awaiting fn with no suspend but async calling var f2 = async add(3, 4); const sum = (await f1) + (await f2); - expect(sum == 10); + expect(sum == 10) catch @panic("test failure"); } fn add(a: i32, b: i32) callconv(.Async) i32 { return a + b; @@ -1128,7 +1128,7 @@ test "await used in expression after a fn call" { var f1 = async add(3, 4); var sum: i32 = 0; sum = foo() + await f1; - expect(sum == 8); + expect(sum == 8) catch @panic("test failure"); } fn add(a: i32, b: i32) callconv(.Async) i32 { return a + b; @@ -1145,7 +1145,7 @@ test "async fn call used in expression after a fn call" { fn atest() void { var sum: i32 = 0; sum = foo() + add(3, 4); - expect(sum == 8); + expect(sum == 8) catch @panic("test failure"); } fn add(a: i32, b: i32) callconv(.Async) i32 { return a + b; @@ -1167,7 +1167,7 @@ test "suspend in for loop" { } fn atest() void { - expect(func(&[_]u8{ 1, 2, 3 }) == 6); + expect(func(&[_]u8{ 1, 2, 3 }) == 6) catch @panic("test failure"); } fn func(stuff: []const u8) u32 { global_frame = @frame(); @@ -1193,8 +1193,8 @@ test "suspend in while loop" { } fn atest() void { - expect(optional(6) == 6); - expect(errunion(6) == 6); + expect(optional(6) == 6) catch @panic("test failure"); + expect(errunion(6) == 6) catch @panic("test failure"); } fn optional(stuff: ?u32) u32 { global_frame = @frame(); @@ -1223,8 +1223,8 @@ test "correctly spill when returning the error union result of another async fn" const S = struct { var global_frame: anyframe = undefined; - fn doTheTest() void { - expect((atest() catch unreachable) == 1234); + fn doTheTest() !void { + expect((atest() catch unreachable) == 1234) catch @panic("test failure"); } fn atest() !i32 { @@ -1246,11 +1246,11 @@ test "spill target expr in a for loop" { const S = struct { var global_frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { var foo = Foo{ .slice = &[_]i32{ 1, 2 }, }; - expect(atest(&foo) == 3); + expect(atest(&foo) == 3) catch @panic("test failure"); } const Foo = struct { @@ -1277,11 +1277,11 @@ test "spill target expr in a for loop, with a var decl in the loop body" { const S = struct { var global_frame: anyframe = undefined; - fn doTheTest() void { + fn doTheTest() !void { var foo = Foo{ .slice = &[_]i32{ 1, 2 }, }; - expect(atest(&foo) == 3); + expect(atest(&foo) == 3) catch @panic("test failure"); } const Foo = struct { @@ -1319,7 +1319,7 @@ test "async call with @call" { fn atest() void { var frame = @call(.{ .modifier = .async_kw }, afoo, .{}); const res = await frame; - expect(res == 42); + expect(res == 42) catch @panic("test failure"); } fn afoo() i32 { suspend { @@ -1348,7 +1348,7 @@ test "async function passed 0-bit arg after non-0-bit arg" { }; _ = async S.foo(); resume S.global_frame; - expect(S.global_int == 1); + try expect(S.global_int == 1); } test "async function passed align(16) arg after align(8) arg" { @@ -1362,7 +1362,7 @@ test "async function passed align(16) arg after align(8) arg" { } fn bar(x: u64, args: anytype) anyerror!void { - expect(x == 10); + try expect(x == 10); global_frame = @frame(); suspend {} global_int = args[0]; @@ -1370,7 +1370,7 @@ test "async function passed align(16) arg after align(8) arg" { }; _ = async S.foo(); resume S.global_frame; - expect(S.global_int == 99); + try expect(S.global_int == 99); } test "async function call resolves target fn frame, comptime func" { @@ -1392,7 +1392,7 @@ test "async function call resolves target fn frame, comptime func" { }; _ = async S.foo(); resume S.global_frame; - expect(S.global_int == 10); + try expect(S.global_int == 10); } test "async function call resolves target fn frame, runtime func" { @@ -1415,7 +1415,7 @@ test "async function call resolves target fn frame, runtime func" { }; _ = async S.foo(); resume S.global_frame; - expect(S.global_int == 10); + try expect(S.global_int == 10); } test "properly spill optional payload capture value" { @@ -1439,7 +1439,7 @@ test "properly spill optional payload capture value" { }; _ = async S.foo(); resume S.global_frame; - expect(S.global_int == 1237); + try expect(S.global_int == 1237); } test "handle defer interfering with return value spill" { @@ -1449,16 +1449,16 @@ test "handle defer interfering with return value spill" { var finished = false; var baz_happened = false; - fn doTheTest() void { + fn doTheTest() !void { _ = async testFoo(); resume global_frame1; resume global_frame2; - expect(baz_happened); - expect(finished); + try expect(baz_happened); + try expect(finished); } fn testFoo() void { - expectError(error.Bad, foo()); + expectError(error.Bad, foo()) catch @panic("test failure"); finished = true; } @@ -1479,7 +1479,7 @@ test "handle defer interfering with return value spill" { baz_happened = true; } }; - S.doTheTest(); + try S.doTheTest(); } test "take address of temporary async frame" { @@ -1487,14 +1487,14 @@ test "take address of temporary async frame" { var global_frame: anyframe = undefined; var finished = false; - fn doTheTest() void { + fn doTheTest() !void { _ = async asyncDoTheTest(); resume global_frame; - expect(finished); + try expect(finished); } fn asyncDoTheTest() void { - expect(finishIt(&async foo(10)) == 1245); + expect(finishIt(&async foo(10)) == 1245) catch @panic("test failure"); finished = true; } @@ -1508,16 +1508,16 @@ test "take address of temporary async frame" { return (await frame) + 1; } }; - S.doTheTest(); + try S.doTheTest(); } test "nosuspend await" { const S = struct { var finished = false; - fn doTheTest() void { + fn doTheTest() !void { var frame = async foo(false); - expect(nosuspend await frame == 42); + try expect(nosuspend await frame == 42); finished = true; } @@ -1528,8 +1528,8 @@ test "nosuspend await" { return 42; } }; - S.doTheTest(); - expect(S.finished); + try S.doTheTest(); + try expect(S.finished); } test "nosuspend on function calls" { @@ -1544,8 +1544,8 @@ test "nosuspend on function calls" { return S0{}; } }; - expectEqual(@as(i32, 42), nosuspend S1.c().b); - expectEqual(@as(i32, 42), (try nosuspend S1.d()).b); + try expectEqual(@as(i32, 42), nosuspend S1.c().b); + try expectEqual(@as(i32, 42), (try nosuspend S1.d()).b); } test "nosuspend on async function calls" { @@ -1561,9 +1561,9 @@ test "nosuspend on async function calls" { } }; var frame_c = nosuspend async S1.c(); - expectEqual(@as(i32, 42), (await frame_c).b); + try expectEqual(@as(i32, 42), (await frame_c).b); var frame_d = nosuspend async S1.d(); - expectEqual(@as(i32, 42), (try await frame_d).b); + try expectEqual(@as(i32, 42), (try await frame_d).b); } // test "resume nosuspend async function calls" { @@ -1582,10 +1582,10 @@ test "nosuspend on async function calls" { // }; // var frame_c = nosuspend async S1.c(); // resume frame_c; -// expectEqual(@as(i32, 42), (await frame_c).b); +// try expectEqual(@as(i32, 42), (await frame_c).b); // var frame_d = nosuspend async S1.d(); // resume frame_d; -// expectEqual(@as(i32, 42), (try await frame_d).b); +// try expectEqual(@as(i32, 42), (try await frame_d).b); // } test "nosuspend resume async function calls" { @@ -1604,10 +1604,10 @@ test "nosuspend resume async function calls" { }; var frame_c = async S1.c(); nosuspend resume frame_c; - expectEqual(@as(i32, 42), (await frame_c).b); + try expectEqual(@as(i32, 42), (await frame_c).b); var frame_d = async S1.d(); nosuspend resume frame_d; - expectEqual(@as(i32, 42), (try await frame_d).b); + try expectEqual(@as(i32, 42), (try await frame_d).b); } test "avoid forcing frame alignment resolution implicit cast to *c_void" { @@ -1623,7 +1623,7 @@ test "avoid forcing frame alignment resolution implicit cast to *c_void" { }; var frame = async S.foo(); resume @ptrCast(anyframe->bool, @alignCast(@alignOf(@Frame(S.foo)), S.x)); - expect(nosuspend await frame); + try expect(nosuspend await frame); } test "@asyncCall with pass-by-value arguments" { @@ -1638,9 +1638,9 @@ test "@asyncCall with pass-by-value arguments" { pub fn f(_fill0: u64, s: ST, _fill1: u64, a: AT, _fill2: u64) callconv(.Async) void { // Check that the array and struct arguments passed by value don't // end up overflowing the adjacent fields in the frame structure. - expectEqual(F0, _fill0); - expectEqual(F1, _fill1); - expectEqual(F2, _fill2); + expectEqual(F0, _fill0) catch @panic("test failure"); + expectEqual(F1, _fill1) catch @panic("test failure"); + expectEqual(F2, _fill2) catch @panic("test failure"); } }; @@ -1664,8 +1664,8 @@ test "@asyncCall with arguments having non-standard alignment" { pub fn f(_fill0: u32, s: struct { x: u64 align(16) }, _fill1: u64) callconv(.Async) void { // The compiler inserts extra alignment for s, check that the // generated code picks the right slot for fill1. - expectEqual(F0, _fill0); - expectEqual(F1, _fill1); + expectEqual(F0, _fill0) catch @panic("test failure"); + expectEqual(F1, _fill1) catch @panic("test failure"); } }; diff --git a/test/stage1/behavior/atomics.zig b/test/stage1/behavior/atomics.zig index d49ca730e6..74a161b6fc 100644 --- a/test/stage1/behavior/atomics.zig +++ b/test/stage1/behavior/atomics.zig @@ -4,25 +4,25 @@ const expectEqual = std.testing.expectEqual; const builtin = @import("builtin"); test "cmpxchg" { - testCmpxchg(); - comptime testCmpxchg(); + try testCmpxchg(); + comptime try testCmpxchg(); } -fn testCmpxchg() void { +fn testCmpxchg() !void { var x: i32 = 1234; if (@cmpxchgWeak(i32, &x, 99, 5678, .SeqCst, .SeqCst)) |x1| { - expect(x1 == 1234); + try expect(x1 == 1234); } else { @panic("cmpxchg should have failed"); } while (@cmpxchgWeak(i32, &x, 1234, 5678, .SeqCst, .SeqCst)) |x1| { - expect(x1 == 1234); + try expect(x1 == 1234); } - expect(x == 5678); + try expect(x == 5678); - expect(@cmpxchgStrong(i32, &x, 5678, 42, .SeqCst, .SeqCst) == null); - expect(x == 42); + try expect(@cmpxchgStrong(i32, &x, 5678, 42, .SeqCst, .SeqCst) == null); + try expect(x == 42); } test "fence" { @@ -33,25 +33,25 @@ test "fence" { test "atomicrmw and atomicload" { var data: u8 = 200; - testAtomicRmw(&data); - expect(data == 42); - testAtomicLoad(&data); + try testAtomicRmw(&data); + try expect(data == 42); + try testAtomicLoad(&data); } -fn testAtomicRmw(ptr: *u8) void { +fn testAtomicRmw(ptr: *u8) !void { const prev_value = @atomicRmw(u8, ptr, .Xchg, 42, .SeqCst); - expect(prev_value == 200); + try expect(prev_value == 200); comptime { var x: i32 = 1234; const y: i32 = 12345; - expect(@atomicLoad(i32, &x, .SeqCst) == 1234); - expect(@atomicLoad(i32, &y, .SeqCst) == 12345); + try expect(@atomicLoad(i32, &x, .SeqCst) == 1234); + try expect(@atomicLoad(i32, &y, .SeqCst) == 12345); } } -fn testAtomicLoad(ptr: *u8) void { +fn testAtomicLoad(ptr: *u8) !void { const x = @atomicLoad(u8, ptr, .SeqCst); - expect(x == 42); + try expect(x == 42); } test "cmpxchg with ptr" { @@ -60,18 +60,18 @@ test "cmpxchg with ptr" { var data3: i32 = 9101; var x: *i32 = &data1; if (@cmpxchgWeak(*i32, &x, &data2, &data3, .SeqCst, .SeqCst)) |x1| { - expect(x1 == &data1); + try expect(x1 == &data1); } else { @panic("cmpxchg should have failed"); } while (@cmpxchgWeak(*i32, &x, &data1, &data3, .SeqCst, .SeqCst)) |x1| { - expect(x1 == &data1); + try expect(x1 == &data1); } - expect(x == &data3); + try expect(x == &data3); - expect(@cmpxchgStrong(*i32, &x, &data3, &data2, .SeqCst, .SeqCst) == null); - expect(x == &data2); + try expect(@cmpxchgStrong(*i32, &x, &data3, &data2, .SeqCst, .SeqCst) == null); + try expect(x == &data2); } // TODO this test is disabled until this issue is resolved: @@ -81,18 +81,18 @@ test "cmpxchg with ptr" { //test "128-bit cmpxchg" { // var x: u128 align(16) = 1234; // TODO: https://github.com/ziglang/zig/issues/2987 // if (@cmpxchgWeak(u128, &x, 99, 5678, .SeqCst, .SeqCst)) |x1| { -// expect(x1 == 1234); +// try expect(x1 == 1234); // } else { // @panic("cmpxchg should have failed"); // } // // while (@cmpxchgWeak(u128, &x, 1234, 5678, .SeqCst, .SeqCst)) |x1| { -// expect(x1 == 1234); +// try expect(x1 == 1234); // } -// expect(x == 5678); +// try expect(x == 5678); // -// expect(@cmpxchgStrong(u128, &x, 5678, 42, .SeqCst, .SeqCst) == null); -// expect(x == 42); +// try expect(@cmpxchgStrong(u128, &x, 5678, 42, .SeqCst, .SeqCst) == null); +// try expect(x == 42); //} test "cmpxchg with ignored result" { @@ -101,14 +101,14 @@ test "cmpxchg with ignored result" { _ = @cmpxchgStrong(i32, &x, 1234, 5678, .Monotonic, .Monotonic); - expectEqual(@as(i32, 5678), x); + try expectEqual(@as(i32, 5678), x); } var a_global_variable = @as(u32, 1234); test "cmpxchg on a global variable" { _ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .Acquire, .Monotonic); - expectEqual(@as(u32, 42), a_global_variable); + try expectEqual(@as(u32, 42), a_global_variable); } test "atomic load and rmw with enum" { @@ -119,33 +119,33 @@ test "atomic load and rmw with enum" { }; var x = Value.a; - expect(@atomicLoad(Value, &x, .SeqCst) != .b); + try expect(@atomicLoad(Value, &x, .SeqCst) != .b); _ = @atomicRmw(Value, &x, .Xchg, .c, .SeqCst); - expect(@atomicLoad(Value, &x, .SeqCst) == .c); - expect(@atomicLoad(Value, &x, .SeqCst) != .a); - expect(@atomicLoad(Value, &x, .SeqCst) != .b); + try expect(@atomicLoad(Value, &x, .SeqCst) == .c); + try expect(@atomicLoad(Value, &x, .SeqCst) != .a); + try expect(@atomicLoad(Value, &x, .SeqCst) != .b); } test "atomic store" { var x: u32 = 0; @atomicStore(u32, &x, 1, .SeqCst); - expect(@atomicLoad(u32, &x, .SeqCst) == 1); + try expect(@atomicLoad(u32, &x, .SeqCst) == 1); @atomicStore(u32, &x, 12345678, .SeqCst); - expect(@atomicLoad(u32, &x, .SeqCst) == 12345678); + try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678); } test "atomic store comptime" { - comptime testAtomicStore(); - testAtomicStore(); + comptime try testAtomicStore(); + try testAtomicStore(); } -fn testAtomicStore() void { +fn testAtomicStore() !void { var x: u32 = 0; @atomicStore(u32, &x, 1, .SeqCst); - expect(@atomicLoad(u32, &x, .SeqCst) == 1); + try expect(@atomicLoad(u32, &x, .SeqCst) == 1); @atomicStore(u32, &x, 12345678, .SeqCst); - expect(@atomicLoad(u32, &x, .SeqCst) == 12345678); + try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678); } test "atomicrmw with floats" { @@ -154,66 +154,66 @@ test "atomicrmw with floats" { .aarch64, .arm, .thumb, .riscv64 => return error.SkipZigTest, else => {}, } - testAtomicRmwFloat(); - comptime testAtomicRmwFloat(); + try testAtomicRmwFloat(); + comptime try testAtomicRmwFloat(); } -fn testAtomicRmwFloat() void { +fn testAtomicRmwFloat() !void { var x: f32 = 0; - expect(x == 0); + try expect(x == 0); _ = @atomicRmw(f32, &x, .Xchg, 1, .SeqCst); - expect(x == 1); + try expect(x == 1); _ = @atomicRmw(f32, &x, .Add, 5, .SeqCst); - expect(x == 6); + try expect(x == 6); _ = @atomicRmw(f32, &x, .Sub, 2, .SeqCst); - expect(x == 4); + try expect(x == 4); } test "atomicrmw with ints" { - testAtomicRmwInt(); - comptime testAtomicRmwInt(); + try testAtomicRmwInt(); + comptime try testAtomicRmwInt(); } -fn testAtomicRmwInt() void { +fn testAtomicRmwInt() !void { var x: u8 = 1; var res = @atomicRmw(u8, &x, .Xchg, 3, .SeqCst); - expect(x == 3 and res == 1); + try expect(x == 3 and res == 1); _ = @atomicRmw(u8, &x, .Add, 3, .SeqCst); - expect(x == 6); + try expect(x == 6); _ = @atomicRmw(u8, &x, .Sub, 1, .SeqCst); - expect(x == 5); + try expect(x == 5); _ = @atomicRmw(u8, &x, .And, 4, .SeqCst); - expect(x == 4); + try expect(x == 4); _ = @atomicRmw(u8, &x, .Nand, 4, .SeqCst); - expect(x == 0xfb); + try expect(x == 0xfb); _ = @atomicRmw(u8, &x, .Or, 6, .SeqCst); - expect(x == 0xff); + try expect(x == 0xff); _ = @atomicRmw(u8, &x, .Xor, 2, .SeqCst); - expect(x == 0xfd); + try expect(x == 0xfd); _ = @atomicRmw(u8, &x, .Max, 1, .SeqCst); - expect(x == 0xfd); + try expect(x == 0xfd); _ = @atomicRmw(u8, &x, .Min, 1, .SeqCst); - expect(x == 1); + try expect(x == 1); } test "atomics with different types" { - testAtomicsWithType(bool, true, false); + try testAtomicsWithType(bool, true, false); inline for (.{ u1, i5, u15 }) |T| { var x: T = 0; - testAtomicsWithType(T, 0, 1); + try testAtomicsWithType(T, 0, 1); } - testAtomicsWithType(u0, 0, 0); - testAtomicsWithType(i0, 0, 0); + try testAtomicsWithType(u0, 0, 0); + try testAtomicsWithType(i0, 0, 0); } -fn testAtomicsWithType(comptime T: type, a: T, b: T) void { +fn testAtomicsWithType(comptime T: type, a: T, b: T) !void { var x: T = b; @atomicStore(T, &x, a, .SeqCst); - expect(x == a); - expect(@atomicLoad(T, &x, .SeqCst) == a); - expect(@atomicRmw(T, &x, .Xchg, b, .SeqCst) == a); - expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst) == null); + try expect(x == a); + try expect(@atomicLoad(T, &x, .SeqCst) == a); + try expect(@atomicRmw(T, &x, .Xchg, b, .SeqCst) == a); + try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst) == null); if (@sizeOf(T) != 0) - expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst).? == a); + try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst).? == a); } diff --git a/test/stage1/behavior/await_struct.zig b/test/stage1/behavior/await_struct.zig index 328f8f87fd..9e01aecc8c 100644 --- a/test/stage1/behavior/await_struct.zig +++ b/test/stage1/behavior/await_struct.zig @@ -15,8 +15,8 @@ test "coroutine await struct" { await_seq('f'); resume await_a_promise; await_seq('i'); - expect(await_final_result.x == 1234); - expect(std.mem.eql(u8, &await_points, "abcdefghi")); + try expect(await_final_result.x == 1234); + try expect(std.mem.eql(u8, &await_points, "abcdefghi")); } fn await_amain() callconv(.Async) void { await_seq('b'); diff --git a/test/stage1/behavior/bit_shifting.zig b/test/stage1/behavior/bit_shifting.zig index 746d598237..a58026e88d 100644 --- a/test/stage1/behavior/bit_shifting.zig +++ b/test/stage1/behavior/bit_shifting.zig @@ -3,8 +3,8 @@ const expect = std.testing.expect; fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type { const key_bits = @typeInfo(Key).Int.bits; - expect(Key == std.meta.Int(.unsigned, key_bits)); - expect(key_bits >= mask_bit_count); + std.debug.assert(Key == std.meta.Int(.unsigned, key_bits)); + std.debug.assert(key_bits >= mask_bit_count); const shard_key_bits = mask_bit_count; const ShardKey = std.meta.Int(.unsigned, mask_bit_count); const shift_amount = key_bits - shard_key_bits; @@ -61,31 +61,31 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt test "sharded table" { // realistic 16-way sharding - testShardedTable(u32, 4, 8); + try testShardedTable(u32, 4, 8); - testShardedTable(u5, 0, 32); // ShardKey == u0 - testShardedTable(u5, 2, 32); - testShardedTable(u5, 5, 32); + try testShardedTable(u5, 0, 32); // ShardKey == u0 + try testShardedTable(u5, 2, 32); + try testShardedTable(u5, 5, 32); - testShardedTable(u1, 0, 2); - testShardedTable(u1, 1, 2); // this does u1 >> u0 + try testShardedTable(u1, 0, 2); + try testShardedTable(u1, 1, 2); // this does u1 >> u0 - testShardedTable(u0, 0, 1); + try testShardedTable(u0, 0, 1); } -fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime node_count: comptime_int) void { +fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime node_count: comptime_int) !void { const Table = ShardedTable(Key, mask_bit_count, void); var table = Table.create(); var node_buffer: [node_count]Table.Node = undefined; for (node_buffer) |*node, i| { const key = @intCast(Key, i); - expect(table.get(key) == null); + try expect(table.get(key) == null); node.init(key, {}); table.put(node); } for (node_buffer) |*node, i| { - expect(table.get(@intCast(Key, i)) == node); + try expect(table.get(@intCast(Key, i)) == node); } } @@ -93,9 +93,9 @@ fn testShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, c test "comptime shr of BigInt" { comptime { var n0 = 0xdeadbeef0000000000000000; - std.debug.assert(n0 >> 64 == 0xdeadbeef); + try expect(n0 >> 64 == 0xdeadbeef); var n1 = 17908056155735594659; - std.debug.assert(n1 >> 64 == 0); + try expect(n1 >> 64 == 0); } } diff --git a/test/stage1/behavior/bitcast.zig b/test/stage1/behavior/bitcast.zig index 2a86044dc1..a725d5cc8b 100644 --- a/test/stage1/behavior/bitcast.zig +++ b/test/stage1/behavior/bitcast.zig @@ -5,13 +5,13 @@ const expectEqual = std.testing.expectEqual; const maxInt = std.math.maxInt; test "@bitCast i32 -> u32" { - testBitCast_i32_u32(); - comptime testBitCast_i32_u32(); + try testBitCast_i32_u32(); + comptime try testBitCast_i32_u32(); } -fn testBitCast_i32_u32() void { - expect(conv(-1) == maxInt(u32)); - expect(conv2(maxInt(u32)) == -1); +fn testBitCast_i32_u32() !void { + try expect(conv(-1) == maxInt(u32)); + try expect(conv2(maxInt(u32)) == -1); } fn conv(x: i32) u32 { @@ -26,15 +26,15 @@ test "@bitCast extern enum to its integer type" { A, B, - fn testBitCastExternEnum() void { + fn testBitCastExternEnum() !void { var SOCK_DGRAM = @This().B; var sock_dgram = @bitCast(c_int, SOCK_DGRAM); - expect(sock_dgram == 1); + try expect(sock_dgram == 1); } }; - SOCK.testBitCastExternEnum(); - comptime SOCK.testBitCastExternEnum(); + try SOCK.testBitCastExternEnum(); + comptime try SOCK.testBitCastExternEnum(); } test "@bitCast packed structs at runtime and comptime" { @@ -47,25 +47,25 @@ test "@bitCast packed structs at runtime and comptime" { quarter4: u4, }; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var full = Full{ .number = 0x1234 }; var two_halves = @bitCast(Divided, full); switch (builtin.endian) { builtin.Endian.Big => { - expect(two_halves.half1 == 0x12); - expect(two_halves.quarter3 == 0x3); - expect(two_halves.quarter4 == 0x4); + try expect(two_halves.half1 == 0x12); + try expect(two_halves.quarter3 == 0x3); + try expect(two_halves.quarter4 == 0x4); }, builtin.Endian.Little => { - expect(two_halves.half1 == 0x34); - expect(two_halves.quarter3 == 0x2); - expect(two_halves.quarter4 == 0x1); + try expect(two_halves.half1 == 0x34); + try expect(two_halves.quarter3 == 0x2); + try expect(two_halves.quarter4 == 0x1); }, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "@bitCast extern structs at runtime and comptime" { @@ -77,23 +77,23 @@ test "@bitCast extern structs at runtime and comptime" { half2: u8, }; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var full = Full{ .number = 0x1234 }; var two_halves = @bitCast(TwoHalves, full); switch (builtin.endian) { builtin.Endian.Big => { - expect(two_halves.half1 == 0x12); - expect(two_halves.half2 == 0x34); + try expect(two_halves.half1 == 0x12); + try expect(two_halves.half2 == 0x34); }, builtin.Endian.Little => { - expect(two_halves.half1 == 0x34); - expect(two_halves.half2 == 0x12); + try expect(two_halves.half1 == 0x34); + try expect(two_halves.half2 == 0x12); }, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "bitcast packed struct to integer and back" { @@ -102,35 +102,35 @@ test "bitcast packed struct to integer and back" { level: u7, }; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var move = LevelUpMove{ .move_id = 1, .level = 2 }; var v = @bitCast(u16, move); var back_to_a_move = @bitCast(LevelUpMove, v); - expect(back_to_a_move.move_id == 1); - expect(back_to_a_move.level == 2); + try expect(back_to_a_move.move_id == 1); + try expect(back_to_a_move.level == 2); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "implicit cast to error union by returning" { const S = struct { - fn entry() void { - expect((func(-1) catch unreachable) == maxInt(u64)); + fn entry() !void { + try expect((func(-1) catch unreachable) == maxInt(u64)); } pub fn func(sz: i64) anyerror!u64 { return @bitCast(u64, sz); } }; - S.entry(); - comptime S.entry(); + try S.entry(); + comptime try S.entry(); } // issue #3010: compiler segfault test "bitcast literal [4]u8 param to u32" { const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 }); - expect(ip == maxInt(u32)); + try expect(ip == maxInt(u32)); } test "bitcast packed struct literal to byte" { @@ -138,14 +138,14 @@ test "bitcast packed struct literal to byte" { value: u8, }; const casted = @bitCast(u8, Foo{ .value = 0xF }); - expect(casted == 0xf); + try expect(casted == 0xf); } test "comptime bitcast used in expression has the correct type" { const Foo = packed struct { value: u8, }; - expect(@bitCast(u8, Foo{ .value = 0xF }) == 0xf); + try expect(@bitCast(u8, Foo{ .value = 0xF }) == 0xf); } test "bitcast result to _" { @@ -154,43 +154,43 @@ test "bitcast result to _" { test "nested bitcast" { const S = struct { - fn moo(x: isize) void { - @import("std").testing.expectEqual(@intCast(isize, 42), x); + fn moo(x: isize) !void { + try @import("std").testing.expectEqual(@intCast(isize, 42), x); } - fn foo(x: isize) void { - @This().moo( + fn foo(x: isize) !void { + try @This().moo( @bitCast(isize, if (x != 0) @bitCast(usize, x) else @bitCast(usize, x)), ); } }; - S.foo(42); - comptime S.foo(42); + try S.foo(42); + comptime try S.foo(42); } test "bitcast passed as tuple element" { const S = struct { - fn foo(args: anytype) void { - comptime expect(@TypeOf(args[0]) == f32); - expect(args[0] == 12.34); + fn foo(args: anytype) !void { + comptime try expect(@TypeOf(args[0]) == f32); + try expect(args[0] == 12.34); } }; - S.foo(.{@bitCast(f32, @as(u32, 0x414570A4))}); + try S.foo(.{@bitCast(f32, @as(u32, 0x414570A4))}); } test "triple level result location with bitcast sandwich passed as tuple element" { const S = struct { - fn foo(args: anytype) void { - comptime expect(@TypeOf(args[0]) == f64); - expect(args[0] > 12.33 and args[0] < 12.35); + fn foo(args: anytype) !void { + comptime try expect(@TypeOf(args[0]) == f64); + try expect(args[0] > 12.33 and args[0] < 12.35); } }; - S.foo(.{@as(f64, @bitCast(f32, @as(u32, 0x414570A4)))}); + try S.foo(.{@as(f64, @bitCast(f32, @as(u32, 0x414570A4)))}); } test "bitcast generates a temporary value" { var y = @as(u16, 0x55AA); const x = @bitCast(u16, @bitCast([2]u8, y)); - expectEqual(y, x); + try expectEqual(y, x); } diff --git a/test/stage1/behavior/bitreverse.zig b/test/stage1/behavior/bitreverse.zig index 8de2d5d2ca..14a7d1cdbe 100644 --- a/test/stage1/behavior/bitreverse.zig +++ b/test/stage1/behavior/bitreverse.zig @@ -3,67 +3,67 @@ const expect = std.testing.expect; const minInt = std.math.minInt; test "@bitReverse" { - comptime testBitReverse(); - testBitReverse(); + comptime try testBitReverse(); + try testBitReverse(); } -fn testBitReverse() void { +fn testBitReverse() !void { // using comptime_ints, unsigned - expect(@bitReverse(u0, 0) == 0); - expect(@bitReverse(u5, 0x12) == 0x9); - expect(@bitReverse(u8, 0x12) == 0x48); - expect(@bitReverse(u16, 0x1234) == 0x2c48); - expect(@bitReverse(u24, 0x123456) == 0x6a2c48); - expect(@bitReverse(u32, 0x12345678) == 0x1e6a2c48); - expect(@bitReverse(u40, 0x123456789a) == 0x591e6a2c48); - expect(@bitReverse(u48, 0x123456789abc) == 0x3d591e6a2c48); - expect(@bitReverse(u56, 0x123456789abcde) == 0x7b3d591e6a2c48); - expect(@bitReverse(u64, 0x123456789abcdef1) == 0x8f7b3d591e6a2c48); - expect(@bitReverse(u128, 0x123456789abcdef11121314151617181) == 0x818e868a828c84888f7b3d591e6a2c48); + try expect(@bitReverse(u0, 0) == 0); + try expect(@bitReverse(u5, 0x12) == 0x9); + try expect(@bitReverse(u8, 0x12) == 0x48); + try expect(@bitReverse(u16, 0x1234) == 0x2c48); + try expect(@bitReverse(u24, 0x123456) == 0x6a2c48); + try expect(@bitReverse(u32, 0x12345678) == 0x1e6a2c48); + try expect(@bitReverse(u40, 0x123456789a) == 0x591e6a2c48); + try expect(@bitReverse(u48, 0x123456789abc) == 0x3d591e6a2c48); + try expect(@bitReverse(u56, 0x123456789abcde) == 0x7b3d591e6a2c48); + try expect(@bitReverse(u64, 0x123456789abcdef1) == 0x8f7b3d591e6a2c48); + try expect(@bitReverse(u128, 0x123456789abcdef11121314151617181) == 0x818e868a828c84888f7b3d591e6a2c48); // using runtime uints, unsigned var num0: u0 = 0; - expect(@bitReverse(u0, num0) == 0); + try expect(@bitReverse(u0, num0) == 0); var num5: u5 = 0x12; - expect(@bitReverse(u5, num5) == 0x9); + try expect(@bitReverse(u5, num5) == 0x9); var num8: u8 = 0x12; - expect(@bitReverse(u8, num8) == 0x48); + try expect(@bitReverse(u8, num8) == 0x48); var num16: u16 = 0x1234; - expect(@bitReverse(u16, num16) == 0x2c48); + try expect(@bitReverse(u16, num16) == 0x2c48); var num24: u24 = 0x123456; - expect(@bitReverse(u24, num24) == 0x6a2c48); + try expect(@bitReverse(u24, num24) == 0x6a2c48); var num32: u32 = 0x12345678; - expect(@bitReverse(u32, num32) == 0x1e6a2c48); + try expect(@bitReverse(u32, num32) == 0x1e6a2c48); var num40: u40 = 0x123456789a; - expect(@bitReverse(u40, num40) == 0x591e6a2c48); + try expect(@bitReverse(u40, num40) == 0x591e6a2c48); var num48: u48 = 0x123456789abc; - expect(@bitReverse(u48, num48) == 0x3d591e6a2c48); + try expect(@bitReverse(u48, num48) == 0x3d591e6a2c48); var num56: u56 = 0x123456789abcde; - expect(@bitReverse(u56, num56) == 0x7b3d591e6a2c48); + try expect(@bitReverse(u56, num56) == 0x7b3d591e6a2c48); var num64: u64 = 0x123456789abcdef1; - expect(@bitReverse(u64, num64) == 0x8f7b3d591e6a2c48); + try expect(@bitReverse(u64, num64) == 0x8f7b3d591e6a2c48); var num128: u128 = 0x123456789abcdef11121314151617181; - expect(@bitReverse(u128, num128) == 0x818e868a828c84888f7b3d591e6a2c48); + try expect(@bitReverse(u128, num128) == 0x818e868a828c84888f7b3d591e6a2c48); // using comptime_ints, signed, positive - expect(@bitReverse(u8, @as(u8, 0)) == 0); - expect(@bitReverse(i8, @bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49))); - expect(@bitReverse(i16, @bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48))); - expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48))); - expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48))); - expect(@bitReverse(i40, @bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48))); - expect(@bitReverse(i48, @bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48))); - expect(@bitReverse(i56, @bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48))); - expect(@bitReverse(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48))); - expect(@bitReverse(i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48))); + try expect(@bitReverse(u8, @as(u8, 0)) == 0); + try expect(@bitReverse(i8, @bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49))); + try expect(@bitReverse(i16, @bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48))); + try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48))); + try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48))); + try expect(@bitReverse(i40, @bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48))); + try expect(@bitReverse(i48, @bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48))); + try expect(@bitReverse(i56, @bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48))); + try expect(@bitReverse(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48))); + try expect(@bitReverse(i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48))); // using signed, negative. Compare to runtime ints returned from llvm. var neg8: i8 = -18; - expect(@bitReverse(i8, @as(i8, -18)) == @bitReverse(i8, neg8)); + try expect(@bitReverse(i8, @as(i8, -18)) == @bitReverse(i8, neg8)); var neg16: i16 = -32694; - expect(@bitReverse(i16, @as(i16, -32694)) == @bitReverse(i16, neg16)); + try expect(@bitReverse(i16, @as(i16, -32694)) == @bitReverse(i16, neg16)); var neg24: i24 = -6773785; - expect(@bitReverse(i24, @as(i24, -6773785)) == @bitReverse(i24, neg24)); + try expect(@bitReverse(i24, @as(i24, -6773785)) == @bitReverse(i24, neg24)); var neg32: i32 = -16773785; - expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32)); + try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32)); } diff --git a/test/stage1/behavior/bool.zig b/test/stage1/behavior/bool.zig index ef9383244e..dfa02a6bfd 100644 --- a/test/stage1/behavior/bool.zig +++ b/test/stage1/behavior/bool.zig @@ -1,25 +1,25 @@ const expect = @import("std").testing.expect; test "bool literals" { - expect(true); - expect(!false); + try expect(true); + try expect(!false); } test "cast bool to int" { const t = true; const f = false; - expect(@boolToInt(t) == @as(u32, 1)); - expect(@boolToInt(f) == @as(u32, 0)); - nonConstCastBoolToInt(t, f); + try expect(@boolToInt(t) == @as(u32, 1)); + try expect(@boolToInt(f) == @as(u32, 0)); + try nonConstCastBoolToInt(t, f); } -fn nonConstCastBoolToInt(t: bool, f: bool) void { - expect(@boolToInt(t) == @as(u32, 1)); - expect(@boolToInt(f) == @as(u32, 0)); +fn nonConstCastBoolToInt(t: bool, f: bool) !void { + try expect(@boolToInt(t) == @as(u32, 1)); + try expect(@boolToInt(f) == @as(u32, 0)); } test "bool cmp" { - expect(testBoolCmp(true, false) == false); + try expect(testBoolCmp(true, false) == false); } fn testBoolCmp(a: bool, b: bool) bool { return a == b; @@ -30,6 +30,6 @@ const global_t = true; const not_global_f = !global_f; const not_global_t = !global_t; test "compile time bool not" { - expect(not_global_f); - expect(!not_global_t); + try expect(not_global_f); + try expect(!not_global_t); } diff --git a/test/stage1/behavior/bugs/1025.zig b/test/stage1/behavior/bugs/1025.zig index 66e1a2be54..69ee77eea1 100644 --- a/test/stage1/behavior/bugs/1025.zig +++ b/test/stage1/behavior/bugs/1025.zig @@ -8,5 +8,5 @@ fn getA() A { test "bug 1025" { const a = getA(); - @import("std").testing.expect(a.B == u8); + try @import("std").testing.expect(a.B == u8); } diff --git a/test/stage1/behavior/bugs/1076.zig b/test/stage1/behavior/bugs/1076.zig index fa3caf0df8..ab7d468a7b 100644 --- a/test/stage1/behavior/bugs/1076.zig +++ b/test/stage1/behavior/bugs/1076.zig @@ -3,21 +3,21 @@ const mem = std.mem; const expect = std.testing.expect; test "comptime code should not modify constant data" { - testCastPtrOfArrayToSliceAndPtr(); - comptime testCastPtrOfArrayToSliceAndPtr(); + try testCastPtrOfArrayToSliceAndPtr(); + comptime try testCastPtrOfArrayToSliceAndPtr(); } -fn testCastPtrOfArrayToSliceAndPtr() void { +fn testCastPtrOfArrayToSliceAndPtr() !void { { var array = "aoeu".*; const x: [*]u8 = &array; x[0] += 1; - expect(mem.eql(u8, array[0..], "boeu")); + try expect(mem.eql(u8, array[0..], "boeu")); } { var array: [4]u8 = "aoeu".*; const x: [*]u8 = &array; x[0] += 1; - expect(mem.eql(u8, array[0..], "boeu")); + try expect(mem.eql(u8, array[0..], "boeu")); } } diff --git a/test/stage1/behavior/bugs/1120.zig b/test/stage1/behavior/bugs/1120.zig index dda46e8e1c..cb68f87e8d 100644 --- a/test/stage1/behavior/bugs/1120.zig +++ b/test/stage1/behavior/bugs/1120.zig @@ -19,5 +19,5 @@ test "bug 1120" { 1 => &b.a, else => unreachable, }; - expect(ptr.* == 2); + try expect(ptr.* == 2); } diff --git a/test/stage1/behavior/bugs/1277.zig b/test/stage1/behavior/bugs/1277.zig index 3aa1db2ea0..18e3592a80 100644 --- a/test/stage1/behavior/bugs/1277.zig +++ b/test/stage1/behavior/bugs/1277.zig @@ -11,5 +11,5 @@ fn f() i32 { } test "don't emit an LLVM global for a const function when it's in an optional in a struct" { - std.testing.expect(s.f.?() == 1234); + try std.testing.expect(s.f.?() == 1234); } diff --git a/test/stage1/behavior/bugs/1310.zig b/test/stage1/behavior/bugs/1310.zig index 788cba5756..a291b217ec 100644 --- a/test/stage1/behavior/bugs/1310.zig +++ b/test/stage1/behavior/bugs/1310.zig @@ -20,5 +20,5 @@ fn agent_callback(_vm: [*]VM, options: [*]u8) callconv(.C) i32 { } test "fixed" { - expect(agent_callback(undefined, undefined) == 11); + try expect(agent_callback(undefined, undefined) == 11); } diff --git a/test/stage1/behavior/bugs/1322.zig b/test/stage1/behavior/bugs/1322.zig index 02ead6afff..e0220a1719 100644 --- a/test/stage1/behavior/bugs/1322.zig +++ b/test/stage1/behavior/bugs/1322.zig @@ -13,7 +13,7 @@ const C = struct {}; test "tagged union with all void fields but a meaningful tag" { var a: A = A{ .b = B{ .c = C{} } }; - std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).c); + try std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).c); a = A{ .b = B.None }; - std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).None); + try std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).None); } diff --git a/test/stage1/behavior/bugs/1381.zig b/test/stage1/behavior/bugs/1381.zig index 1d44593990..6a63e8cc5b 100644 --- a/test/stage1/behavior/bugs/1381.zig +++ b/test/stage1/behavior/bugs/1381.zig @@ -17,5 +17,5 @@ test "union that needs padding bytes inside an array" { }; const a = as[0].B; - std.testing.expect(a.D == 1); + try std.testing.expect(a.D == 1); } diff --git a/test/stage1/behavior/bugs/1421.zig b/test/stage1/behavior/bugs/1421.zig index da0ba41680..449ff17cc8 100644 --- a/test/stage1/behavior/bugs/1421.zig +++ b/test/stage1/behavior/bugs/1421.zig @@ -10,5 +10,5 @@ const S = struct { test "functions with return type required to be comptime are generic" { const ti = S.method(); - expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct); + try expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct); } diff --git a/test/stage1/behavior/bugs/1442.zig b/test/stage1/behavior/bugs/1442.zig index d5ea3f66fe..5298d34acb 100644 --- a/test/stage1/behavior/bugs/1442.zig +++ b/test/stage1/behavior/bugs/1442.zig @@ -7,5 +7,5 @@ const Union = union(enum) { test "const error union field alignment" { var union_or_err: anyerror!Union = Union{ .Color = 1234 }; - std.testing.expect((union_or_err catch unreachable).Color == 1234); + try std.testing.expect((union_or_err catch unreachable).Color == 1234); } diff --git a/test/stage1/behavior/bugs/1486.zig b/test/stage1/behavior/bugs/1486.zig index 1b8e5ca4a1..cae181a3b9 100644 --- a/test/stage1/behavior/bugs/1486.zig +++ b/test/stage1/behavior/bugs/1486.zig @@ -5,6 +5,6 @@ var global: u64 = 123; test "constant pointer to global variable causes runtime load" { global = 1234; - expect(&global == ptr); - expect(ptr.* == 1234); + try expect(&global == ptr); + try expect(ptr.* == 1234); } diff --git a/test/stage1/behavior/bugs/1607.zig b/test/stage1/behavior/bugs/1607.zig index ffc1aa85dc..a60905b070 100644 --- a/test/stage1/behavior/bugs/1607.zig +++ b/test/stage1/behavior/bugs/1607.zig @@ -3,13 +3,13 @@ const testing = std.testing; const a = [_]u8{ 1, 2, 3 }; -fn checkAddress(s: []const u8) void { +fn checkAddress(s: []const u8) !void { for (s) |*i, j| { - testing.expect(i == &a[j]); + try testing.expect(i == &a[j]); } } test "slices pointing at the same address as global array." { - checkAddress(&a); - comptime checkAddress(&a); + try checkAddress(&a); + comptime try checkAddress(&a); } diff --git a/test/stage1/behavior/bugs/1735.zig b/test/stage1/behavior/bugs/1735.zig index e757b5157c..f3aa6eb9ec 100644 --- a/test/stage1/behavior/bugs/1735.zig +++ b/test/stage1/behavior/bugs/1735.zig @@ -42,5 +42,5 @@ const a = struct { test "intialization" { var t = a.init(); - std.testing.expect(t.foo.len == 0); + try std.testing.expect(t.foo.len == 0); } diff --git a/test/stage1/behavior/bugs/1741.zig b/test/stage1/behavior/bugs/1741.zig index 9882536d38..8873de9b49 100644 --- a/test/stage1/behavior/bugs/1741.zig +++ b/test/stage1/behavior/bugs/1741.zig @@ -2,5 +2,5 @@ const std = @import("std"); test "fixed" { const x: f32 align(128) = 12.34; - std.testing.expect(@ptrToInt(&x) % 128 == 0); + try std.testing.expect(@ptrToInt(&x) % 128 == 0); } diff --git a/test/stage1/behavior/bugs/1851.zig b/test/stage1/behavior/bugs/1851.zig index d6cf17651d..58b23d71d6 100644 --- a/test/stage1/behavior/bugs/1851.zig +++ b/test/stage1/behavior/bugs/1851.zig @@ -2,25 +2,25 @@ const std = @import("std"); const expect = std.testing.expect; test "allocation and looping over 3-byte integer" { - expect(@sizeOf(u24) == 4); - expect(@sizeOf([1]u24) == 4); - expect(@alignOf(u24) == 4); - expect(@alignOf([1]u24) == 4); + try expect(@sizeOf(u24) == 4); + try expect(@sizeOf([1]u24) == 4); + try expect(@alignOf(u24) == 4); + try expect(@alignOf([1]u24) == 4); var x = try std.testing.allocator.alloc(u24, 2); defer std.testing.allocator.free(x); - expect(x.len == 2); + try expect(x.len == 2); x[0] = 0xFFFFFF; x[1] = 0xFFFFFF; const bytes = std.mem.sliceAsBytes(x); - expect(@TypeOf(bytes) == []align(4) u8); - expect(bytes.len == 8); + try expect(@TypeOf(bytes) == []align(4) u8); + try expect(bytes.len == 8); for (bytes) |*b| { b.* = 0x00; } - expect(x[0] == 0x00); - expect(x[1] == 0x00); + try expect(x[0] == 0x00); + try expect(x[1] == 0x00); } diff --git a/test/stage1/behavior/bugs/2006.zig b/test/stage1/behavior/bugs/2006.zig index dad78a9ba0..86dab326e0 100644 --- a/test/stage1/behavior/bugs/2006.zig +++ b/test/stage1/behavior/bugs/2006.zig @@ -7,6 +7,6 @@ const S = struct { test "bug 2006" { var a: S = undefined; a = S{ .p = undefined }; - expect(@sizeOf(S) != 0); - expect(@sizeOf(*void) == 0); + try expect(@sizeOf(S) != 0); + try expect(@sizeOf(*void) == 0); } diff --git a/test/stage1/behavior/bugs/2114.zig b/test/stage1/behavior/bugs/2114.zig index 1034a256d3..1fc7016f44 100644 --- a/test/stage1/behavior/bugs/2114.zig +++ b/test/stage1/behavior/bugs/2114.zig @@ -7,13 +7,13 @@ fn ctz(x: anytype) usize { } test "fixed" { - testClz(); - comptime testClz(); + try testClz(); + comptime try testClz(); } -fn testClz() void { - expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126); - expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000)); - expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127); - expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127); +fn testClz() !void { + try expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126); + try expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000)); + try expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127); + try expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127); } diff --git a/test/stage1/behavior/bugs/2889.zig b/test/stage1/behavior/bugs/2889.zig index 4991b56510..473f6c615d 100644 --- a/test/stage1/behavior/bugs/2889.zig +++ b/test/stage1/behavior/bugs/2889.zig @@ -27,5 +27,5 @@ fn parseNote() ?i32 { test "fixed" { const result = parseNote(); - std.testing.expect(result.? == 9); + try std.testing.expect(result.? == 9); } diff --git a/test/stage1/behavior/bugs/3007.zig b/test/stage1/behavior/bugs/3007.zig index b723ebc097..c08be3676a 100644 --- a/test/stage1/behavior/bugs/3007.zig +++ b/test/stage1/behavior/bugs/3007.zig @@ -19,5 +19,5 @@ fn get_foo() Foo.FooError!*Foo { test "fixed" { default_foo = get_foo() catch null; // This Line - std.testing.expect(!default_foo.?.free); + try std.testing.expect(!default_foo.?.free); } diff --git a/test/stage1/behavior/bugs/3046.zig b/test/stage1/behavior/bugs/3046.zig index b62474f9ba..8ff95f3b96 100644 --- a/test/stage1/behavior/bugs/3046.zig +++ b/test/stage1/behavior/bugs/3046.zig @@ -15,5 +15,5 @@ test "fixed" { some_struct = SomeStruct{ .field = couldFail() catch |_| @as(i32, 0), }; - expect(some_struct.field == 1); + try expect(some_struct.field == 1); } diff --git a/test/stage1/behavior/bugs/3112.zig b/test/stage1/behavior/bugs/3112.zig index 1dfe359d4a..68e86c7fcb 100644 --- a/test/stage1/behavior/bugs/3112.zig +++ b/test/stage1/behavior/bugs/3112.zig @@ -7,7 +7,7 @@ const State = struct { }; fn prev(p: ?State) void { - expect(p == null); + expect(p == null) catch @panic("test failure"); } test "zig test crash" { diff --git a/test/stage1/behavior/bugs/3384.zig b/test/stage1/behavior/bugs/3384.zig index 789b0be516..c45aae5180 100644 --- a/test/stage1/behavior/bugs/3384.zig +++ b/test/stage1/behavior/bugs/3384.zig @@ -2,10 +2,10 @@ const std = @import("std"); const expect = std.testing.expect; test "resolve array slice using builtin" { - expect(@hasDecl(@This(), "std") == true); - expect(@hasDecl(@This(), "std"[0..0]) == false); - expect(@hasDecl(@This(), "std"[0..1]) == false); - expect(@hasDecl(@This(), "std"[0..2]) == false); - expect(@hasDecl(@This(), "std"[0..3]) == true); - expect(@hasDecl(@This(), "std"[0..]) == true); + try expect(@hasDecl(@This(), "std") == true); + try expect(@hasDecl(@This(), "std"[0..0]) == false); + try expect(@hasDecl(@This(), "std"[0..1]) == false); + try expect(@hasDecl(@This(), "std"[0..2]) == false); + try expect(@hasDecl(@This(), "std"[0..3]) == true); + try expect(@hasDecl(@This(), "std"[0..]) == true); } diff --git a/test/stage1/behavior/bugs/394.zig b/test/stage1/behavior/bugs/394.zig index b1f0b6b605..55fec53ea1 100644 --- a/test/stage1/behavior/bugs/394.zig +++ b/test/stage1/behavior/bugs/394.zig @@ -14,5 +14,5 @@ test "bug 394 fixed" { .x = 3, .y = E{ .B = 1 }, }; - expect(x.x == 3); + try expect(x.x == 3); } diff --git a/test/stage1/behavior/bugs/421.zig b/test/stage1/behavior/bugs/421.zig index 748cb3a62d..2da4728067 100644 --- a/test/stage1/behavior/bugs/421.zig +++ b/test/stage1/behavior/bugs/421.zig @@ -1,12 +1,12 @@ const expect = @import("std").testing.expect; test "bitCast to array" { - comptime testBitCastArray(); - testBitCastArray(); + comptime try testBitCastArray(); + try testBitCastArray(); } -fn testBitCastArray() void { - expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef); +fn testBitCastArray() !void { + try expect(extractOne64(0x0123456789abcdef0123456789abcdef) == 0x0123456789abcdef); } fn extractOne64(a: u128) u64 { diff --git a/test/stage1/behavior/bugs/4328.zig b/test/stage1/behavior/bugs/4328.zig index 98ab7bd155..76c3e788fd 100644 --- a/test/stage1/behavior/bugs/4328.zig +++ b/test/stage1/behavior/bugs/4328.zig @@ -25,14 +25,14 @@ test "Extern function calls in @TypeOf" { return 1; } - fn doTheTest() void { - expectEqual(c_int, @TypeOf(test_fn_1(0, 42))); - expectEqual(c_short, @TypeOf(test_fn_2(0))); + fn doTheTest() !void { + try expectEqual(c_int, @TypeOf(test_fn_1(0, 42))); + try expectEqual(c_short, @TypeOf(test_fn_2(0))); } }; - Test.doTheTest(); - comptime Test.doTheTest(); + try Test.doTheTest(); + comptime try Test.doTheTest(); } test "Peer resolution of extern function calls in @TypeOf" { @@ -41,13 +41,13 @@ test "Peer resolution of extern function calls in @TypeOf" { return 0; } - fn doTheTest() void { - expectEqual(c_long, @TypeOf(test_fn())); + fn doTheTest() !void { + try expectEqual(c_long, @TypeOf(test_fn())); } }; - Test.doTheTest(); - comptime Test.doTheTest(); + try Test.doTheTest(); + comptime try Test.doTheTest(); } test "Extern function calls, dereferences and field access in @TypeOf" { @@ -60,12 +60,12 @@ test "Extern function calls, dereferences and field access in @TypeOf" { return 255; } - fn doTheTest() void { - expectEqual(FILE, @TypeOf(test_fn_1(0))); - expectEqual(u8, @TypeOf(test_fn_2(0))); + fn doTheTest() !void { + try expectEqual(FILE, @TypeOf(test_fn_1(0))); + try expectEqual(u8, @TypeOf(test_fn_2(0))); } }; - Test.doTheTest(); - comptime Test.doTheTest(); + try Test.doTheTest(); + comptime try Test.doTheTest(); } diff --git a/test/stage1/behavior/bugs/4560.zig b/test/stage1/behavior/bugs/4560.zig index 6821527894..682d3f2125 100644 --- a/test/stage1/behavior/bugs/4560.zig +++ b/test/stage1/behavior/bugs/4560.zig @@ -8,9 +8,9 @@ test "fixed" { .max_distance_from_start_index = 456, }, }; - std.testing.expect(s.a == 1); - std.testing.expect(s.b.size == 123); - std.testing.expect(s.b.max_distance_from_start_index == 456); + try std.testing.expect(s.a == 1); + try std.testing.expect(s.b.size == 123); + try std.testing.expect(s.b.max_distance_from_start_index == 456); } const S = struct { diff --git a/test/stage1/behavior/bugs/4769_a.zig b/test/stage1/behavior/bugs/4769_a.zig index ab0c01417a..8337712ea5 100644 --- a/test/stage1/behavior/bugs/4769_a.zig +++ b/test/stage1/behavior/bugs/4769_a.zig @@ -1 +1 @@ -// \ No newline at end of file +// diff --git a/test/stage1/behavior/bugs/4769_b.zig b/test/stage1/behavior/bugs/4769_b.zig index 23b2513f17..9d0f028e57 100644 --- a/test/stage1/behavior/bugs/4769_b.zig +++ b/test/stage1/behavior/bugs/4769_b.zig @@ -1 +1 @@ -//! \ No newline at end of file +//! diff --git a/test/stage1/behavior/bugs/5398.zig b/test/stage1/behavior/bugs/5398.zig index fdfd0b3698..4921c05703 100644 --- a/test/stage1/behavior/bugs/5398.zig +++ b/test/stage1/behavior/bugs/5398.zig @@ -25,7 +25,7 @@ test "assignment of field with padding" { .emits_shadows = false, }, }; - testing.expectEqual(false, renderable.material.transparent); - testing.expectEqual(false, renderable.material.emits_shadows); - testing.expectEqual(true, renderable.material.render_color); + try testing.expectEqual(false, renderable.material.transparent); + try testing.expectEqual(false, renderable.material.emits_shadows); + try testing.expectEqual(true, renderable.material.render_color); } diff --git a/test/stage1/behavior/bugs/5413.zig b/test/stage1/behavior/bugs/5413.zig index 5ef533a761..fab8e043aa 100644 --- a/test/stage1/behavior/bugs/5413.zig +++ b/test/stage1/behavior/bugs/5413.zig @@ -1,6 +1,6 @@ const expect = @import("std").testing.expect; test "Peer type resolution with string literals and unknown length u8 pointers" { - expect(@TypeOf("", "a", @as([*:0]const u8, "")) == [*:0]const u8); - expect(@TypeOf(@as([*:0]const u8, "baz"), "foo", "bar") == [*:0]const u8); + try expect(@TypeOf("", "a", @as([*:0]const u8, "")) == [*:0]const u8); + try expect(@TypeOf(@as([*:0]const u8, "baz"), "foo", "bar") == [*:0]const u8); } diff --git a/test/stage1/behavior/bugs/5474.zig b/test/stage1/behavior/bugs/5474.zig index 88ce96095e..8a0180a799 100644 --- a/test/stage1/behavior/bugs/5474.zig +++ b/test/stage1/behavior/bugs/5474.zig @@ -25,33 +25,33 @@ const Box2 = struct { }; }; -fn doTest() void { +fn doTest() !void { // var { var box0: Box0 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == false); + try std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == false); var box1: Box1 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == false); + try std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == false); var box2: Box2 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == false); + try std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == false); } // const { const box0: Box0 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == true); + try std.testing.expect(@typeInfo(@TypeOf(box0.items[0..])).Pointer.is_const == true); const box1: Box1 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == true); + try std.testing.expect(@typeInfo(@TypeOf(box1.items[0..])).Pointer.is_const == true); const box2: Box2 = .{ .items = undefined }; - std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == true); + try std.testing.expect(@typeInfo(@TypeOf(box2.items[0..])).Pointer.is_const == true); } } test "pointer-to-array constness for zero-size elements" { - doTest(); - comptime doTest(); + try doTest(); + comptime try doTest(); } diff --git a/test/stage1/behavior/bugs/624.zig b/test/stage1/behavior/bugs/624.zig index 1eee889a0d..4d52aad693 100644 --- a/test/stage1/behavior/bugs/624.zig +++ b/test/stage1/behavior/bugs/624.zig @@ -19,5 +19,5 @@ fn MemoryPool(comptime T: type) type { test "foo" { var allocator = ContextAllocator{ .n = 10 }; - expect(allocator.n == 10); + try expect(allocator.n == 10); } diff --git a/test/stage1/behavior/bugs/6456.zig b/test/stage1/behavior/bugs/6456.zig index 001e25ec49..8b01b80be8 100644 --- a/test/stage1/behavior/bugs/6456.zig +++ b/test/stage1/behavior/bugs/6456.zig @@ -35,9 +35,9 @@ test "issue 6456" { }); const gen_fields = @typeInfo(T).Struct.fields; - testing.expectEqual(3, gen_fields.len); - testing.expectEqualStrings("f1", gen_fields[0].name); - testing.expectEqualStrings("f2", gen_fields[1].name); - testing.expectEqualStrings("f3", gen_fields[2].name); + try testing.expectEqual(3, gen_fields.len); + try testing.expectEqualStrings("f1", gen_fields[0].name); + try testing.expectEqualStrings("f2", gen_fields[1].name); + try testing.expectEqualStrings("f3", gen_fields[2].name); } } diff --git a/test/stage1/behavior/bugs/655.zig b/test/stage1/behavior/bugs/655.zig index 3d1bccb183..9ec9f01e69 100644 --- a/test/stage1/behavior/bugs/655.zig +++ b/test/stage1/behavior/bugs/655.zig @@ -3,10 +3,10 @@ const other_file = @import("655_other_file.zig"); test "function with *const parameter with type dereferenced by namespace" { const x: other_file.Integer = 1234; - comptime std.testing.expect(@TypeOf(&x) == *const other_file.Integer); - foo(&x); + comptime try std.testing.expect(@TypeOf(&x) == *const other_file.Integer); + try foo(&x); } -fn foo(x: *const other_file.Integer) void { - std.testing.expect(x.* == 1234); +fn foo(x: *const other_file.Integer) !void { + try std.testing.expect(x.* == 1234); } diff --git a/test/stage1/behavior/bugs/656.zig b/test/stage1/behavior/bugs/656.zig index 159ec52d43..178d655f93 100644 --- a/test/stage1/behavior/bugs/656.zig +++ b/test/stage1/behavior/bugs/656.zig @@ -10,10 +10,10 @@ const Value = struct { }; test "optional if after an if in a switch prong of a switch with 2 prongs in an else" { - foo(false, true); + try foo(false, true); } -fn foo(a: bool, b: bool) void { +fn foo(a: bool, b: bool) !void { var prefix_op = PrefixOp{ .AddrOf = Value{ .align_expr = 1234 }, }; @@ -22,7 +22,7 @@ fn foo(a: bool, b: bool) void { PrefixOp.AddrOf => |addr_of_info| { if (b) {} if (addr_of_info.align_expr) |align_expr| { - expect(align_expr == 1234); + try expect(align_expr == 1234); } }, PrefixOp.Return => {}, diff --git a/test/stage1/behavior/bugs/679.zig b/test/stage1/behavior/bugs/679.zig index 20b2b7b02a..9b402defca 100644 --- a/test/stage1/behavior/bugs/679.zig +++ b/test/stage1/behavior/bugs/679.zig @@ -13,5 +13,5 @@ const Element = struct { test "false dependency loop in struct definition" { const listType = ElementList; var x: listType = 42; - expect(x == 42); + try expect(x == 42); } diff --git a/test/stage1/behavior/bugs/6850.zig b/test/stage1/behavior/bugs/6850.zig index 6759ba79ca..1eb1cd0a24 100644 --- a/test/stage1/behavior/bugs/6850.zig +++ b/test/stage1/behavior/bugs/6850.zig @@ -4,7 +4,7 @@ test "lazy sizeof comparison with zero" { const Empty = struct {}; const T = *Empty; - std.testing.expect(hasNoBits(T)); + try std.testing.expect(hasNoBits(T)); } fn hasNoBits(comptime T: type) bool { diff --git a/test/stage1/behavior/bugs/7047.zig b/test/stage1/behavior/bugs/7047.zig index 0704e97b48..a60a7d2bbb 100644 --- a/test/stage1/behavior/bugs/7047.zig +++ b/test/stage1/behavior/bugs/7047.zig @@ -15,8 +15,8 @@ fn S(comptime query: U) type { test "compiler doesn't consider equal unions with different 'type' payload" { const s1 = S(U{ .T = u32 }).tag(); - std.testing.expectEqual(u32, s1); + try std.testing.expectEqual(u32, s1); const s2 = S(U{ .T = u64 }).tag(); - std.testing.expectEqual(u64, s2); + try std.testing.expectEqual(u64, s2); } diff --git a/test/stage1/behavior/bugs/718.zig b/test/stage1/behavior/bugs/718.zig index b5a57b8944..078c3604ee 100644 --- a/test/stage1/behavior/bugs/718.zig +++ b/test/stage1/behavior/bugs/718.zig @@ -10,8 +10,8 @@ const Keys = struct { var keys: Keys = undefined; test "zero keys with @memset" { @memset(@ptrCast([*]u8, &keys), 0, @sizeOf(@TypeOf(keys))); - expect(!keys.up); - expect(!keys.down); - expect(!keys.left); - expect(!keys.right); + try expect(!keys.up); + try expect(!keys.down); + try expect(!keys.left); + try expect(!keys.right); } diff --git a/test/stage1/behavior/bugs/726.zig b/test/stage1/behavior/bugs/726.zig index 632d3b1511..364d209e3b 100644 --- a/test/stage1/behavior/bugs/726.zig +++ b/test/stage1/behavior/bugs/726.zig @@ -3,7 +3,7 @@ const expect = @import("std").testing.expect; test "@ptrCast from const to nullable" { const c: u8 = 4; var x: ?*const u8 = @ptrCast(?*const u8, &c); - expect(x.?.* == 4); + try expect(x.?.* == 4); } test "@ptrCast from var in empty struct to nullable" { @@ -11,5 +11,5 @@ test "@ptrCast from var in empty struct to nullable" { var c: u8 = 4; }; var x: ?*const u8 = @ptrCast(?*const u8, &container.c); - expect(x.?.* == 4); + try expect(x.?.* == 4); } diff --git a/test/stage1/behavior/bugs/920.zig b/test/stage1/behavior/bugs/920.zig index 72854956a1..b148fce578 100644 --- a/test/stage1/behavior/bugs/920.zig +++ b/test/stage1/behavior/bugs/920.zig @@ -60,6 +60,6 @@ test "bug 920 fixed" { }; for (NormalDist1.f) |_, i| { - std.testing.expectEqual(NormalDist1.f[i], NormalDist.f[i]); + try std.testing.expectEqual(NormalDist1.f[i], NormalDist.f[i]); } } diff --git a/test/stage1/behavior/byteswap.zig b/test/stage1/behavior/byteswap.zig index c6d658a8a2..5afb9be0ec 100644 --- a/test/stage1/behavior/byteswap.zig +++ b/test/stage1/behavior/byteswap.zig @@ -3,39 +3,39 @@ const expect = std.testing.expect; test "@byteSwap integers" { const ByteSwapIntTest = struct { - fn run() void { - t(u0, 0, 0); - t(u8, 0x12, 0x12); - t(u16, 0x1234, 0x3412); - t(u24, 0x123456, 0x563412); - t(u32, 0x12345678, 0x78563412); - t(u40, 0x123456789a, 0x9a78563412); - t(i48, 0x123456789abc, @bitCast(i48, @as(u48, 0xbc9a78563412))); - t(u56, 0x123456789abcde, 0xdebc9a78563412); - t(u64, 0x123456789abcdef1, 0xf1debc9a78563412); - t(u128, 0x123456789abcdef11121314151617181, 0x8171615141312111f1debc9a78563412); + fn run() !void { + try t(u0, 0, 0); + try t(u8, 0x12, 0x12); + try t(u16, 0x1234, 0x3412); + try t(u24, 0x123456, 0x563412); + try t(u32, 0x12345678, 0x78563412); + try t(u40, 0x123456789a, 0x9a78563412); + try t(i48, 0x123456789abc, @bitCast(i48, @as(u48, 0xbc9a78563412))); + try t(u56, 0x123456789abcde, 0xdebc9a78563412); + try t(u64, 0x123456789abcdef1, 0xf1debc9a78563412); + try t(u128, 0x123456789abcdef11121314151617181, 0x8171615141312111f1debc9a78563412); - t(u0, @as(u0, 0), 0); - t(i8, @as(i8, -50), -50); - t(i16, @bitCast(i16, @as(u16, 0x1234)), @bitCast(i16, @as(u16, 0x3412))); - t(i24, @bitCast(i24, @as(u24, 0x123456)), @bitCast(i24, @as(u24, 0x563412))); - t(i32, @bitCast(i32, @as(u32, 0x12345678)), @bitCast(i32, @as(u32, 0x78563412))); - t(u40, @bitCast(i40, @as(u40, 0x123456789a)), @as(u40, 0x9a78563412)); - t(i48, @bitCast(i48, @as(u48, 0x123456789abc)), @bitCast(i48, @as(u48, 0xbc9a78563412))); - t(i56, @bitCast(i56, @as(u56, 0x123456789abcde)), @bitCast(i56, @as(u56, 0xdebc9a78563412))); - t(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1)), @bitCast(i64, @as(u64, 0xf1debc9a78563412))); - t( + try t(u0, @as(u0, 0), 0); + try t(i8, @as(i8, -50), -50); + try t(i16, @bitCast(i16, @as(u16, 0x1234)), @bitCast(i16, @as(u16, 0x3412))); + try t(i24, @bitCast(i24, @as(u24, 0x123456)), @bitCast(i24, @as(u24, 0x563412))); + try t(i32, @bitCast(i32, @as(u32, 0x12345678)), @bitCast(i32, @as(u32, 0x78563412))); + try t(u40, @bitCast(i40, @as(u40, 0x123456789a)), @as(u40, 0x9a78563412)); + try t(i48, @bitCast(i48, @as(u48, 0x123456789abc)), @bitCast(i48, @as(u48, 0xbc9a78563412))); + try t(i56, @bitCast(i56, @as(u56, 0x123456789abcde)), @bitCast(i56, @as(u56, 0xdebc9a78563412))); + try t(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1)), @bitCast(i64, @as(u64, 0xf1debc9a78563412))); + try t( i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181)), @bitCast(i128, @as(u128, 0x8171615141312111f1debc9a78563412)), ); } - fn t(comptime I: type, input: I, expected_output: I) void { - std.testing.expectEqual(expected_output, @byteSwap(I, input)); + fn t(comptime I: type, input: I, expected_output: I) !void { + try std.testing.expectEqual(expected_output, @byteSwap(I, input)); } }; - comptime ByteSwapIntTest.run(); - ByteSwapIntTest.run(); + comptime try ByteSwapIntTest.run(); + try ByteSwapIntTest.run(); } test "@byteSwap vectors" { @@ -46,10 +46,10 @@ test "@byteSwap vectors" { if (std.Target.current.cpu.arch == .mipsel or std.Target.current.cpu.arch == .mips) return error.SkipZigTest; const ByteSwapVectorTest = struct { - fn run() void { - t(u8, 2, [_]u8{ 0x12, 0x13 }, [_]u8{ 0x12, 0x13 }); - t(u16, 2, [_]u16{ 0x1234, 0x2345 }, [_]u16{ 0x3412, 0x4523 }); - t(u24, 2, [_]u24{ 0x123456, 0x234567 }, [_]u24{ 0x563412, 0x674523 }); + fn run() !void { + try t(u8, 2, [_]u8{ 0x12, 0x13 }, [_]u8{ 0x12, 0x13 }); + try t(u16, 2, [_]u16{ 0x1234, 0x2345 }, [_]u16{ 0x3412, 0x4523 }); + try t(u24, 2, [_]u24{ 0x123456, 0x234567 }, [_]u24{ 0x563412, 0x674523 }); } fn t( @@ -57,12 +57,12 @@ test "@byteSwap vectors" { comptime n: comptime_int, input: std.meta.Vector(n, I), expected_vector: std.meta.Vector(n, I), - ) void { + ) !void { const actual_output: [n]I = @byteSwap(I, input); const expected_output: [n]I = expected_vector; - std.testing.expectEqual(expected_output, actual_output); + try std.testing.expectEqual(expected_output, actual_output); } }; - comptime ByteSwapVectorTest.run(); - ByteSwapVectorTest.run(); + comptime try ByteSwapVectorTest.run(); + try ByteSwapVectorTest.run(); } diff --git a/test/stage1/behavior/byval_arg_var.zig b/test/stage1/behavior/byval_arg_var.zig index ec3d18a532..a46a9ed0b2 100644 --- a/test/stage1/behavior/byval_arg_var.zig +++ b/test/stage1/behavior/byval_arg_var.zig @@ -6,7 +6,7 @@ test "pass string literal byvalue to a generic var param" { start(); blowUpStack(10); - std.testing.expect(std.mem.eql(u8, result, "string literal")); + try std.testing.expect(std.mem.eql(u8, result, "string literal")); } fn start() void { diff --git a/test/stage1/behavior/call.zig b/test/stage1/behavior/call.zig index 4d05a83a39..f036c3c7c3 100644 --- a/test/stage1/behavior/call.zig +++ b/test/stage1/behavior/call.zig @@ -8,25 +8,25 @@ test "basic invocations" { return 1234; } }.foo; - expect(@call(.{}, foo, .{}) == 1234); + try expect(@call(.{}, foo, .{}) == 1234); comptime { // modifiers that allow comptime calls - expect(@call(.{}, foo, .{}) == 1234); - expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234); - expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234); - expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234); + try expect(@call(.{}, foo, .{}) == 1234); + try expect(@call(.{ .modifier = .no_async }, foo, .{}) == 1234); + try expect(@call(.{ .modifier = .always_tail }, foo, .{}) == 1234); + try expect(@call(.{ .modifier = .always_inline }, foo, .{}) == 1234); } { // comptime call without comptime keyword const result = @call(.{ .modifier = .compile_time }, foo, .{}) == 1234; - comptime expect(result); + comptime try expect(result); } { // call of non comptime-known function var alias_foo = foo; - expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234); - expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234); - expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234); + try expect(@call(.{ .modifier = .no_async }, alias_foo, .{}) == 1234); + try expect(@call(.{ .modifier = .never_tail }, alias_foo, .{}) == 1234); + try expect(@call(.{ .modifier = .never_inline }, alias_foo, .{}) == 1234); } } @@ -38,20 +38,20 @@ test "tuple parameters" { }.add; var a: i32 = 12; var b: i32 = 34; - expect(@call(.{}, add, .{ a, 34 }) == 46); - expect(@call(.{}, add, .{ 12, b }) == 46); - expect(@call(.{}, add, .{ a, b }) == 46); - expect(@call(.{}, add, .{ 12, 34 }) == 46); - comptime expect(@call(.{}, add, .{ 12, 34 }) == 46); + try expect(@call(.{}, add, .{ a, 34 }) == 46); + try expect(@call(.{}, add, .{ 12, b }) == 46); + try expect(@call(.{}, add, .{ a, b }) == 46); + try expect(@call(.{}, add, .{ 12, 34 }) == 46); + comptime try expect(@call(.{}, add, .{ 12, 34 }) == 46); { const separate_args0 = .{ a, b }; const separate_args1 = .{ a, 34 }; const separate_args2 = .{ 12, 34 }; const separate_args3 = .{ 12, b }; - expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46); - expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46); - expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46); - expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46); + try expect(@call(.{ .modifier = .always_inline }, add, separate_args0) == 46); + try expect(@call(.{ .modifier = .always_inline }, add, separate_args1) == 46); + try expect(@call(.{ .modifier = .always_inline }, add, separate_args2) == 46); + try expect(@call(.{ .modifier = .always_inline }, add, separate_args3) == 46); } } @@ -70,5 +70,5 @@ test "comptime call with bound function as parameter" { }; var inst: S = undefined; - expectEqual(?i32, S.ReturnType(inst.call_me_maybe)); + try expectEqual(?i32, S.ReturnType(inst.call_me_maybe)); } diff --git a/test/stage1/behavior/cast.zig b/test/stage1/behavior/cast.zig index 94ba2636b7..ead02e1de2 100644 --- a/test/stage1/behavior/cast.zig +++ b/test/stage1/behavior/cast.zig @@ -8,12 +8,12 @@ test "int to ptr cast" { const x = @as(usize, 13); const y = @intToPtr(*u8, x); const z = @ptrToInt(y); - expect(z == 13); + try expect(z == 13); } test "integer literal to pointer cast" { const vga_mem = @intToPtr(*u16, 0xB8000); - expect(@ptrToInt(vga_mem) == 0xB8000); + try expect(@ptrToInt(vga_mem) == 0xB8000); } test "pointer reinterpret const float to int" { @@ -23,9 +23,9 @@ test "pointer reinterpret const float to int" { const int_ptr = @ptrCast(*const i32, float_ptr); const int_val = int_ptr.*; if (std.builtin.endian == .Little) - expect(int_val == 0x33333303) + try expect(int_val == 0x33333303) else - expect(int_val == 0x3fe33333); + try expect(int_val == 0x3fe33333); } test "implicitly cast indirect pointer to maybe-indirect pointer" { @@ -49,62 +49,62 @@ test "implicitly cast indirect pointer to maybe-indirect pointer" { const p = &s; const q = &p; const r = &q; - expect(42 == S.constConst(q)); - expect(42 == S.maybeConstConst(q)); - expect(42 == S.constConstConst(r)); - expect(42 == S.maybeConstConstConst(r)); + try expect(42 == S.constConst(q)); + try expect(42 == S.maybeConstConst(q)); + try expect(42 == S.constConstConst(r)); + try expect(42 == S.maybeConstConstConst(r)); } test "explicit cast from integer to error type" { - testCastIntToErr(error.ItBroke); - comptime testCastIntToErr(error.ItBroke); + try testCastIntToErr(error.ItBroke); + comptime try testCastIntToErr(error.ItBroke); } -fn testCastIntToErr(err: anyerror) void { +fn testCastIntToErr(err: anyerror) !void { const x = @errorToInt(err); const y = @intToError(x); - expect(error.ItBroke == y); + try expect(error.ItBroke == y); } test "peer resolve arrays of different size to const slice" { - expect(mem.eql(u8, boolToStr(true), "true")); - expect(mem.eql(u8, boolToStr(false), "false")); - comptime expect(mem.eql(u8, boolToStr(true), "true")); - comptime expect(mem.eql(u8, boolToStr(false), "false")); + try expect(mem.eql(u8, boolToStr(true), "true")); + try expect(mem.eql(u8, boolToStr(false), "false")); + comptime try expect(mem.eql(u8, boolToStr(true), "true")); + 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); - comptime testPeerResolveArrayConstSlice(true); + try 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")); - expect(mem.eql(u8, value2, "zz")); + try expect(mem.eql(u8, value1, "aoeu")); + try expect(mem.eql(u8, value2, "zz")); } test "implicitly cast from T to anyerror!?T" { - castToOptionalTypeError(1); - comptime castToOptionalTypeError(1); + try castToOptionalTypeError(1); + comptime try castToOptionalTypeError(1); } const A = struct { a: i32, }; -fn castToOptionalTypeError(z: i32) void { +fn castToOptionalTypeError(z: i32) !void { const x = @as(i32, 1); const y: anyerror!?i32 = x; - expect((try y).? == 1); + try expect((try y).? == 1); const f = z; const g: anyerror!?i32 = f; const a = A{ .a = z }; const b: anyerror!?A = a; - expect((b catch unreachable).?.a == 1); + try expect((b catch unreachable).?.a == 1); } test "implicitly cast from int to anyerror!?T" { @@ -119,7 +119,7 @@ fn implicitIntLitToOptional() void { test "return null from fn() anyerror!?&T" { const a = returnNullFromOptionalTypeErrorRef(); const b = returnNullLitFromOptionalTypeErrorRef(); - expect((try a) == null and (try b) == null); + try expect((try a) == null and (try b) == null); } fn returnNullFromOptionalTypeErrorRef() anyerror!?*A { const a: ?*A = null; @@ -130,11 +130,11 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A { } test "peer type resolution: ?T and T" { - expect(peerTypeTAndOptionalT(true, false).? == 0); - expect(peerTypeTAndOptionalT(false, false).? == 3); + try expect(peerTypeTAndOptionalT(true, false).? == 0); + try expect(peerTypeTAndOptionalT(false, false).? == 3); comptime { - expect(peerTypeTAndOptionalT(true, false).? == 0); - expect(peerTypeTAndOptionalT(false, false).? == 3); + try expect(peerTypeTAndOptionalT(true, false).? == 0); + try expect(peerTypeTAndOptionalT(false, false).? == 3); } } fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize { @@ -146,11 +146,11 @@ fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize { } test "peer type resolution: [0]u8 and []const u8" { - expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); - expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); + try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); + try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); comptime { - expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); - expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); + try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); + try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); } } fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 { @@ -162,8 +162,8 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 { } test "implicitly cast from [N]T to ?[]const T" { - expect(mem.eql(u8, castToOptionalSlice().?, "hi")); - comptime expect(mem.eql(u8, castToOptionalSlice().?, "hi")); + try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); + comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); } fn castToOptionalSlice() ?[]const u8 { @@ -171,12 +171,12 @@ fn castToOptionalSlice() ?[]const u8 { } test "implicitly cast from [0]T to anyerror![]T" { - testCastZeroArrayToErrSliceMut(); - comptime testCastZeroArrayToErrSliceMut(); + try testCastZeroArrayToErrSliceMut(); + comptime try testCastZeroArrayToErrSliceMut(); } -fn testCastZeroArrayToErrSliceMut() void { - expect((gimmeErrOrSlice() catch unreachable).len == 0); +fn testCastZeroArrayToErrSliceMut() !void { + try expect((gimmeErrOrSlice() catch unreachable).len == 0); } fn gimmeErrOrSlice() anyerror![]u8 { @@ -189,19 +189,19 @@ 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); - expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); } { var data: [2]u8 = "hi".*; const slice = data[0..]; - expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); - expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); } } }; try S.doTheTest(); - try comptime S.doTheTest(); + comptime try S.doTheTest(); } fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { if (a) { @@ -212,43 +212,43 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { } test "resolve undefined with integer" { - testResolveUndefWithInt(true, 1234); - comptime testResolveUndefWithInt(true, 1234); + try testResolveUndefWithInt(true, 1234); + comptime try testResolveUndefWithInt(true, 1234); } -fn testResolveUndefWithInt(b: bool, x: i32) void { +fn testResolveUndefWithInt(b: bool, x: i32) !void { const value = if (b) x else undefined; if (b) { - expect(value == x); + try expect(value == x); } } test "implicit cast from &const [N]T to []const T" { - testCastConstArrayRefToConstSlice(); - comptime testCastConstArrayRefToConstSlice(); + try testCastConstArrayRefToConstSlice(); + comptime try testCastConstArrayRefToConstSlice(); } -fn testCastConstArrayRefToConstSlice() void { +fn testCastConstArrayRefToConstSlice() !void { { const blah = "aoeu".*; const const_array_ref = &blah; - expect(@TypeOf(const_array_ref) == *const [4:0]u8); + try expect(@TypeOf(const_array_ref) == *const [4:0]u8); const slice: []const u8 = const_array_ref; - expect(mem.eql(u8, slice, "aoeu")); + try expect(mem.eql(u8, slice, "aoeu")); } { const blah: [4]u8 = "aoeu".*; const const_array_ref = &blah; - expect(@TypeOf(const_array_ref) == *const [4]u8); + try expect(@TypeOf(const_array_ref) == *const [4]u8); const slice: []const u8 = const_array_ref; - expect(mem.eql(u8, slice, "aoeu")); + try expect(mem.eql(u8, slice, "aoeu")); } } test "peer type resolution: error and [N]T" { - expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); - comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); - expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); - comptime expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); + try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); + comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); + try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); + comptime try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); } fn testPeerErrorAndArray(x: u8) anyerror![]const u8 { @@ -266,35 +266,35 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 { } test "@floatToInt" { - testFloatToInts(); - comptime testFloatToInts(); + try testFloatToInts(); + comptime try testFloatToInts(); } -fn testFloatToInts() void { +fn testFloatToInts() !void { const x = @as(i32, 1e4); - expect(x == 10000); + try expect(x == 10000); const y = @floatToInt(i32, @as(f32, 1e4)); - expect(y == 10000); - expectFloatToInt(f16, 255.1, u8, 255); - expectFloatToInt(f16, 127.2, i8, 127); - expectFloatToInt(f16, -128.2, i8, -128); - expectFloatToInt(f32, 255.1, u8, 255); - expectFloatToInt(f32, 127.2, i8, 127); - expectFloatToInt(f32, -128.2, i8, -128); - expectFloatToInt(comptime_int, 1234, i16, 1234); + try expect(y == 10000); + try expectFloatToInt(f16, 255.1, u8, 255); + try expectFloatToInt(f16, 127.2, i8, 127); + try expectFloatToInt(f16, -128.2, i8, -128); + try expectFloatToInt(f32, 255.1, u8, 255); + try expectFloatToInt(f32, 127.2, i8, 127); + try expectFloatToInt(f32, -128.2, i8, -128); + try expectFloatToInt(comptime_int, 1234, i16, 1234); } -fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) void { - expect(@floatToInt(I, f) == i); +fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void { + try expect(@floatToInt(I, f) == i); } test "cast u128 to f128 and back" { - comptime testCast128(); - testCast128(); + comptime try testCast128(); + try testCast128(); } -fn testCast128() void { - expect(cast128Int(cast128Float(0x7fff0000000000000000000000000000)) == 0x7fff0000000000000000000000000000); +fn testCast128() !void { + try expect(cast128Int(cast128Float(0x7fff0000000000000000000000000000)) == 0x7fff0000000000000000000000000000); } fn cast128Int(x: f128) u128 { @@ -306,69 +306,69 @@ fn cast128Float(x: u128) f128 { } test "single-item pointer of array to slice and to unknown length pointer" { - testCastPtrOfArrayToSliceAndPtr(); - comptime testCastPtrOfArrayToSliceAndPtr(); + try testCastPtrOfArrayToSliceAndPtr(); + comptime try testCastPtrOfArrayToSliceAndPtr(); } -fn testCastPtrOfArrayToSliceAndPtr() void { +fn testCastPtrOfArrayToSliceAndPtr() !void { { var array = "aoeu".*; const x: [*]u8 = &array; x[0] += 1; - expect(mem.eql(u8, array[0..], "boeu")); + try expect(mem.eql(u8, array[0..], "boeu")); const y: []u8 = &array; y[0] += 1; - expect(mem.eql(u8, array[0..], "coeu")); + try expect(mem.eql(u8, array[0..], "coeu")); } { var array: [4]u8 = "aoeu".*; const x: [*]u8 = &array; x[0] += 1; - expect(mem.eql(u8, array[0..], "boeu")); + try expect(mem.eql(u8, array[0..], "boeu")); const y: []u8 = &array; y[0] += 1; - expect(mem.eql(u8, array[0..], "coeu")); + try expect(mem.eql(u8, array[0..], "coeu")); } } 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")); } test "@intCast comptime_int" { const result = @intCast(i32, 1234); - expect(@TypeOf(result) == i32); - expect(result == 1234); + try expect(@TypeOf(result) == i32); + try expect(result == 1234); } test "@floatCast comptime_int and comptime_float" { { const result = @floatCast(f16, 1234); - expect(@TypeOf(result) == f16); - expect(result == 1234.0); + try expect(@TypeOf(result) == f16); + try expect(result == 1234.0); } { const result = @floatCast(f16, 1234.0); - expect(@TypeOf(result) == f16); - expect(result == 1234.0); + try expect(@TypeOf(result) == f16); + try expect(result == 1234.0); } { const result = @floatCast(f32, 1234); - expect(@TypeOf(result) == f32); - expect(result == 1234.0); + try expect(@TypeOf(result) == f32); + try expect(result == 1234.0); } { const result = @floatCast(f32, 1234.0); - expect(@TypeOf(result) == f32); - expect(result == 1234.0); + try expect(@TypeOf(result) == f32); + try expect(result == 1234.0); } } test "vector casts" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { // Upcast (implicit, equivalent to @intCast) var up0: Vector(2, u8) = [_]u8{ 0x55, 0xaa }; var up1 = @as(Vector(2, u16), up0); @@ -380,55 +380,55 @@ test "vector casts" { var down2 = @intCast(Vector(2, u16), down0); var down3 = @intCast(Vector(2, u8), down0); - expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa })); - expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa })); - expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa })); + try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa })); + try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa })); + try expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa })); - expect(mem.eql(u32, &@as([2]u32, down1), &[2]u32{ 0x55, 0xaa })); - expect(mem.eql(u16, &@as([2]u16, down2), &[2]u16{ 0x55, 0xaa })); - expect(mem.eql(u8, &@as([2]u8, down3), &[2]u8{ 0x55, 0xaa })); + try expect(mem.eql(u32, &@as([2]u32, down1), &[2]u32{ 0x55, 0xaa })); + try expect(mem.eql(u16, &@as([2]u16, down2), &[2]u16{ 0x55, 0xaa })); + try expect(mem.eql(u8, &@as([2]u8, down3), &[2]u8{ 0x55, 0xaa })); } - fn doTheTestFloat() void { + fn doTheTestFloat() !void { var vec = @splat(2, @as(f32, 1234.0)); var wider: Vector(2, f64) = vec; - expect(wider[0] == 1234.0); - expect(wider[1] == 1234.0); + try expect(wider[0] == 1234.0); + try expect(wider[1] == 1234.0); } }; - S.doTheTest(); - comptime S.doTheTest(); - S.doTheTestFloat(); - comptime S.doTheTestFloat(); + try S.doTheTest(); + comptime try S.doTheTest(); + try S.doTheTestFloat(); + comptime try S.doTheTestFloat(); } test "comptime_int @intToFloat" { { const result = @intToFloat(f16, 1234); - expect(@TypeOf(result) == f16); - expect(result == 1234.0); + try expect(@TypeOf(result) == f16); + try expect(result == 1234.0); } { const result = @intToFloat(f32, 1234); - expect(@TypeOf(result) == f32); - expect(result == 1234.0); + try expect(@TypeOf(result) == f32); + try expect(result == 1234.0); } { const result = @intToFloat(f64, 1234); - expect(@TypeOf(result) == f64); - expect(result == 1234.0); + try expect(@TypeOf(result) == f64); + try expect(result == 1234.0); } { const result = @intToFloat(f128, 1234); - expect(@TypeOf(result) == f128); - expect(result == 1234.0); + try expect(@TypeOf(result) == f128); + try expect(result == 1234.0); } // big comptime_int (> 64 bits) to f128 conversion { const result = @intToFloat(f128, 0x1_0000_0000_0000_0000); - expect(@TypeOf(result) == f128); - expect(result == 0x1_0000_0000_0000_0000.0); + try expect(@TypeOf(result) == f128); + try expect(result == 0x1_0000_0000_0000_0000.0); } } @@ -436,25 +436,25 @@ test "@intCast i32 to u7" { var x: u128 = maxInt(u128); var y: i32 = 120; var z = x >> @intCast(u7, y); - expect(z == 0xff); + try expect(z == 0xff); } test "@floatCast cast down" { { var double: f64 = 0.001534; var single = @floatCast(f32, double); - expect(single == 0.001534); + try expect(single == 0.001534); } { const double: f64 = 0.001534; const single = @floatCast(f32, double); - expect(single == 0.001534); + try expect(single == 0.001534); } } test "implicit cast undefined to optional" { - expect(MakeType(void).getNull() == null); - expect(MakeType(void).getNonNull() != null); + try expect(MakeType(void).getNull() == null); + try expect(MakeType(void).getNonNull() != null); } fn MakeType(comptime T: type) type { @@ -474,26 +474,26 @@ test "implicit cast from *[N]T to ?[*]T" { var y: [4]u16 = [4]u16{ 0, 1, 2, 3 }; x = &y; - expect(std.mem.eql(u16, x.?[0..4], y[0..4])); + try expect(std.mem.eql(u16, x.?[0..4], y[0..4])); x.?[0] = 8; y[3] = 6; - expect(std.mem.eql(u16, x.?[0..4], y[0..4])); + try expect(std.mem.eql(u16, x.?[0..4], y[0..4])); } test "implicit cast from *[N]T to [*c]T" { var x: [4]u16 = [4]u16{ 0, 1, 2, 3 }; var y: [*c]u16 = &x; - expect(std.mem.eql(u16, x[0..4], y[0..4])); + try expect(std.mem.eql(u16, x[0..4], y[0..4])); x[0] = 8; y[3] = 6; - expect(std.mem.eql(u16, x[0..4], y[0..4])); + try expect(std.mem.eql(u16, x[0..4], y[0..4])); } test "implicit cast from *T to ?*c_void" { var a: u8 = 1; incrementVoidPtrValue(&a); - std.testing.expect(a == 2); + try std.testing.expect(a == 2); } fn incrementVoidPtrValue(value: ?*c_void) void { @@ -504,7 +504,7 @@ test "implicit cast from [*]T to ?*c_void" { var a = [_]u8{ 3, 2, 1 }; var runtime_zero: usize = 0; incrementVoidPtrArray(a[runtime_zero..].ptr, 3); - expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 })); + try expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 })); } fn incrementVoidPtrArray(array: ?*c_void, len: usize) void { @@ -521,34 +521,34 @@ test "*usize to *void" { } test "compile time int to ptr of function" { - foobar(FUNCTION_CONSTANT); + try foobar(FUNCTION_CONSTANT); } pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize)); pub const PFN_void = fn (*c_void) callconv(.C) void; -fn foobar(func: PFN_void) void { - std.testing.expect(@ptrToInt(func) == maxInt(usize)); +fn foobar(func: PFN_void) !void { + try std.testing.expect(@ptrToInt(func) == maxInt(usize)); } test "implicit ptr to *c_void" { var a: u32 = 1; var ptr: *align(@alignOf(u32)) c_void = &a; var b: *u32 = @ptrCast(*u32, ptr); - expect(b.* == 1); + try expect(b.* == 1); var ptr2: ?*align(@alignOf(u32)) c_void = &a; var c: *u32 = @ptrCast(*u32, ptr2.?); - expect(c.* == 1); + try expect(c.* == 1); } test "@intCast to comptime_int" { - expect(@intCast(comptime_int, 0) == 0); + try expect(@intCast(comptime_int, 0) == 0); } test "implicit cast comptime numbers to any type when the value fits" { const a: u64 = 255; var b: u8 = a; - expect(b == 255); + try expect(b == 255); } 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" { A, }; const x = @intToEnum(E, 0); - expect(x == E.A); + try expect(x == E.A); } test "@intToEnum runtime to an extern enum with duplicate values" { @@ -566,33 +566,33 @@ test "@intToEnum runtime to an extern enum with duplicate values" { }; var a: u8 = 1; var x = @intToEnum(E, a); - expect(x == E.A); - expect(x == E.B); + try expect(x == E.A); + try expect(x == E.B); } test "@intCast to u0 and use the result" { const S = struct { - fn doTheTest(zero: u1, one: u1, bigzero: i32) void { - expect((one << @intCast(u0, bigzero)) == 1); - expect((zero << @intCast(u0, bigzero)) == 0); + fn doTheTest(zero: u1, one: u1, bigzero: i32) !void { + try expect((one << @intCast(u0, bigzero)) == 1); + try expect((zero << @intCast(u0, bigzero)) == 0); } }; - S.doTheTest(0, 1, 0); - comptime S.doTheTest(0, 1, 0); + try S.doTheTest(0, 1, 0); + comptime try S.doTheTest(0, 1, 0); } test "peer type resolution: unreachable, null, slice" { const S = struct { - fn doTheTest(num: usize, word: []const u8) void { + fn doTheTest(num: usize, word: []const u8) !void { const result = switch (num) { 0 => null, 1 => word, else => unreachable, }; - expect(mem.eql(u8, result.?, "hi")); + try expect(mem.eql(u8, result.?, "hi")); } }; - S.doTheTest(1, "hi"); + try S.doTheTest(1, "hi"); } test "peer type resolution: unreachable, error set, unreachable" { @@ -615,17 +615,17 @@ test "peer type resolution: unreachable, error set, unreachable" { error.FileDescriptorIncompatibleWithEpoll => unreachable, error.Unexpected => unreachable, }; - expect(transformed_err == error.SystemResources); + try expect(transformed_err == error.SystemResources); } test "implicit cast comptime_int to comptime_float" { - comptime expect(@as(comptime_float, 10) == @as(f32, 10)); - expect(2 == 2.0); + comptime try expect(@as(comptime_float, 10) == @as(f32, 10)); + try expect(2 == 2.0); } test "implicit cast *[0]T to E![]const u8" { var x = @as(anyerror![]const u8, &[0]u8{}); - expect((x catch unreachable).len == 0); + try expect((x catch unreachable).len == 0); } test "peer cast *[0]T to E![]const T" { @@ -633,7 +633,7 @@ test "peer cast *[0]T to E![]const T" { var buf: anyerror![]const u8 = buffer[0..]; var b = false; var y = if (b) &[0]u8{} else buf; - expect(mem.eql(u8, "abcde", y catch unreachable)); + try expect(mem.eql(u8, "abcde", y catch unreachable)); } test "peer cast *[0]T to []const T" { @@ -641,25 +641,25 @@ test "peer cast *[0]T to []const T" { var buf: []const u8 = buffer[0..]; var b = false; var y = if (b) &[0]u8{} else buf; - expect(mem.eql(u8, "abcde", y)); + try expect(mem.eql(u8, "abcde", y)); } var global_array: [4]u8 = undefined; test "cast from array reference to fn" { const f = @ptrCast(fn () callconv(.C) void, &global_array); - expect(@ptrToInt(f) == @ptrToInt(&global_array)); + try expect(@ptrToInt(f) == @ptrToInt(&global_array)); } test "*const [N]null u8 to ?[]const u8" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var a = "Hello"; var b: ?[]const u8 = a; - expect(mem.eql(u8, b.?, "Hello")); + try expect(mem.eql(u8, b.?, "Hello")); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "peer resolution of string literals" { @@ -671,54 +671,54 @@ test "peer resolution of string literals" { d, }; - fn doTheTest(e: E) void { + fn doTheTest(e: E) !void { const cmd = switch (e) { .a => "one", .b => "two", .c => "three", .d => "four", }; - expect(mem.eql(u8, cmd, "two")); + try expect(mem.eql(u8, cmd, "two")); } }; - S.doTheTest(.b); - comptime S.doTheTest(.b); + try S.doTheTest(.b); + comptime try S.doTheTest(.b); } test "type coercion related to sentinel-termination" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { // [:x]T to []T { var array = [4:0]i32{ 1, 2, 3, 4 }; var slice: [:0]i32 = &array; var dest: []i32 = slice; - expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 })); + try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 })); } // [*:x]T to [*]T { var array = [4:99]i32{ 1, 2, 3, 4 }; var dest: [*]i32 = &array; - expect(dest[0] == 1); - expect(dest[1] == 2); - expect(dest[2] == 3); - expect(dest[3] == 4); - expect(dest[4] == 99); + try expect(dest[0] == 1); + try expect(dest[1] == 2); + try expect(dest[2] == 3); + try expect(dest[3] == 4); + try expect(dest[4] == 99); } // [N:x]T to [N]T { var array = [4:0]i32{ 1, 2, 3, 4 }; var dest: [4]i32 = array; - expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 })); + try expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 })); } // *[N:x]T to *[N]T { var array = [4:0]i32{ 1, 2, 3, 4 }; var dest: *[4]i32 = &array; - expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 })); + try expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 })); } // [:x]T to [*:x]T @@ -726,24 +726,24 @@ test "type coercion related to sentinel-termination" { var array = [4:0]i32{ 1, 2, 3, 4 }; var slice: [:0]i32 = &array; var dest: [*:0]i32 = slice; - expect(dest[0] == 1); - expect(dest[1] == 2); - expect(dest[2] == 3); - expect(dest[3] == 4); - expect(dest[4] == 0); + try expect(dest[0] == 1); + try expect(dest[1] == 2); + try expect(dest[2] == 3); + try expect(dest[3] == 4); + try expect(dest[4] == 0); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "cast i8 fn call peers to i32 result" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var cond = true; const value: i32 = if (cond) smallBoi() else bigBoi(); - expect(value == 123); + try expect(value == 123); } fn smallBoi() i8 { return 123; @@ -752,21 +752,21 @@ test "cast i8 fn call peers to i32 result" { return 1234; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "return u8 coercing into ?u32 return type" { const S = struct { - fn doTheTest() void { - expect(foo(123).? == 123); + fn doTheTest() !void { + try expect(foo(123).? == 123); } fn foo(arg: u8) ?u32 { return arg; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "peer result null and comptime_int" { @@ -782,17 +782,17 @@ test "peer result null and comptime_int" { } }; - expect(S.blah(0) == null); - comptime expect(S.blah(0) == null); - expect(S.blah(10).? == 1); - comptime expect(S.blah(10).? == 1); - expect(S.blah(-10).? == -1); - comptime expect(S.blah(-10).? == -1); + try expect(S.blah(0) == null); + comptime try expect(S.blah(0) == null); + try expect(S.blah(10).? == 1); + comptime try expect(S.blah(10).? == 1); + try expect(S.blah(-10).? == -1); + comptime try expect(S.blah(-10).? == -1); } test "peer type resolution implicit cast to return type" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { for ("hello") |c| _ = f(c); } fn f(c: u8) []const u8 { @@ -803,13 +803,13 @@ test "peer type resolution implicit cast to return type" { }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "peer type resolution implicit cast to variable type" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var x: []const u8 = undefined; for ("hello") |c| x = switch (c) { 'h', 'e' => &[_]u8{c}, // should cast to slice @@ -818,14 +818,14 @@ test "peer type resolution implicit cast to variable type" { }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "variable initialization uses result locations properly with regards to the type" { var b = true; const x: i32 = if (b) 1 else 2; - expect(x == 1); + try expect(x == 1); } 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" { fn foo(arg: [*]c_ushort) u16 { return arg[0]; } - fn doTheTest() void { + fn doTheTest() !void { var x = [_]u16{ 4, 2, 1, 3 }; - expect(foo(@ptrCast([*]u16, &x)) == 4); + try expect(foo(@ptrCast([*]u16, &x)) == 4); } }; - S.doTheTest(); + try S.doTheTest(); } var global_struct: struct { f0: usize } = undefined; test "assignment to optional pointer result loc" { var foo: struct { ptr: ?*c_void } = .{ .ptr = &global_struct }; - expect(foo.ptr.? == @ptrCast(*c_void, &global_struct)); + try expect(foo.ptr.? == @ptrCast(*c_void, &global_struct)); } test "peer type resolve string lit with sentinel-terminated mutable slice" { var array: [4:0]u8 = undefined; array[4] = 0; // TODO remove this when #4372 is solved var slice: [:0]u8 = array[0..4 :0]; - comptime expect(@TypeOf(slice, "hi") == [:0]const u8); - comptime expect(@TypeOf("hi", slice) == [:0]const u8); + comptime try expect(@TypeOf(slice, "hi") == [:0]const u8); + comptime try expect(@TypeOf("hi", slice) == [:0]const u8); } test "peer type unsigned int to signed" { @@ -875,15 +875,15 @@ test "peer type unsigned int to signed" { var x: u8 = 7; var y: i32 = -5; var a = w + y + x; - comptime expect(@TypeOf(a) == i32); - expect(a == 7); + comptime try expect(@TypeOf(a) == i32); + try expect(a == 7); } test "peer type resolve array pointers, one of them const" { var array1: [4]u8 = undefined; const array2: [5]u8 = undefined; - comptime expect(@TypeOf(&array1, &array2) == []const u8); - comptime expect(@TypeOf(&array2, &array1) == []const u8); + comptime try expect(@TypeOf(&array1, &array2) == []const u8); + comptime try expect(@TypeOf(&array2, &array1) == []const u8); } test "peer type resolve array pointer and unknown pointer" { @@ -892,35 +892,35 @@ test "peer type resolve array pointer and unknown pointer" { var const_ptr: [*]const u8 = undefined; var ptr: [*]u8 = undefined; - comptime expect(@TypeOf(&array, ptr) == [*]u8); - comptime expect(@TypeOf(ptr, &array) == [*]u8); + comptime try expect(@TypeOf(&array, ptr) == [*]u8); + comptime try expect(@TypeOf(ptr, &array) == [*]u8); - comptime expect(@TypeOf(&const_array, ptr) == [*]const u8); - comptime expect(@TypeOf(ptr, &const_array) == [*]const u8); + comptime try expect(@TypeOf(&const_array, ptr) == [*]const u8); + comptime try expect(@TypeOf(ptr, &const_array) == [*]const u8); - comptime expect(@TypeOf(&array, const_ptr) == [*]const u8); - comptime expect(@TypeOf(const_ptr, &array) == [*]const u8); + comptime try expect(@TypeOf(&array, const_ptr) == [*]const u8); + comptime try expect(@TypeOf(const_ptr, &array) == [*]const u8); - comptime expect(@TypeOf(&const_array, const_ptr) == [*]const u8); - comptime expect(@TypeOf(const_ptr, &const_array) == [*]const u8); + comptime try expect(@TypeOf(&const_array, const_ptr) == [*]const u8); + comptime try expect(@TypeOf(const_ptr, &const_array) == [*]const u8); } test "comptime float casts" { const a = @intToFloat(comptime_float, 1); - expect(a == 1); - expect(@TypeOf(a) == comptime_float); + try expect(a == 1); + try expect(@TypeOf(a) == comptime_float); const b = @floatToInt(comptime_int, 2); - expect(b == 2); - expect(@TypeOf(b) == comptime_int); + try expect(b == 2); + try expect(@TypeOf(b) == comptime_int); } test "cast from ?[*]T to ??[*]T" { const a: ??[*]u8 = @as(?[*]u8, null); - expect(a != null and a.? == null); + try expect(a != null and a.? == null); } test "cast between *[N]void and []void" { var a: [4]void = undefined; var b: []void = &a; - expect(b.len == 4); + try expect(b.len == 4); } diff --git a/test/stage1/behavior/const_slice_child.zig b/test/stage1/behavior/const_slice_child.zig index 92e5121026..0fa9d71ee6 100644 --- a/test/stage1/behavior/const_slice_child.zig +++ b/test/stage1/behavior/const_slice_child.zig @@ -12,24 +12,24 @@ test "const slice child" { "three", }; argv = &strs; - bar(strs.len); + try bar(strs.len); } -fn foo(args: [][]const u8) void { - expect(args.len == 3); - expect(streql(args[0], "one")); - expect(streql(args[1], "two")); - expect(streql(args[2], "three")); +fn foo(args: [][]const u8) !void { + try expect(args.len == 3); + try expect(streql(args[0], "one")); + try expect(streql(args[1], "two")); + try expect(streql(args[2], "three")); } -fn bar(argc: usize) void { +fn bar(argc: usize) !void { const args = testing.allocator.alloc([]const u8, argc) catch unreachable; defer testing.allocator.free(args); for (args) |_, i| { const ptr = argv[i]; args[i] = ptr[0..strlen(ptr)]; } - foo(args); + try foo(args); } fn strlen(ptr: [*]const u8) usize { diff --git a/test/stage1/behavior/defer.zig b/test/stage1/behavior/defer.zig index 6bfeb485cc..53ce188928 100644 --- a/test/stage1/behavior/defer.zig +++ b/test/stage1/behavior/defer.zig @@ -24,18 +24,18 @@ fn runSomeErrorDefers(x: bool) !bool { } test "mixing normal and error defers" { - expect(runSomeErrorDefers(true) catch unreachable); - expect(result[0] == 'c'); - expect(result[1] == 'a'); + try expect(runSomeErrorDefers(true) catch unreachable); + try expect(result[0] == 'c'); + try expect(result[1] == 'a'); const ok = runSomeErrorDefers(false) catch |err| x: { - expect(err == error.FalseNotAllowed); + try expect(err == error.FalseNotAllowed); break :x true; }; - expect(ok); - expect(result[0] == 'c'); - expect(result[1] == 'b'); - expect(result[2] == 'a'); + try expect(ok); + try expect(result[0] == 'c'); + try expect(result[1] == 'b'); + try expect(result[2] == 'a'); } test "break and continue inside loop inside defer expression" { @@ -50,7 +50,7 @@ fn testBreakContInDefer(x: usize) void { if (i < 5) continue; if (i == 5) break; } - expect(i == 5); + expect(i == 5) catch @panic("test failure"); } } @@ -62,11 +62,11 @@ test "defer and labeled break" { break :blk; } - expect(i == 1); + try expect(i == 1); } test "errdefer does not apply to fn inside fn" { - if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| expect(e == error.Bad); + if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad); } fn testNestedFnErrDefer() anyerror!void { @@ -82,8 +82,8 @@ fn testNestedFnErrDefer() anyerror!void { test "return variable while defer expression in scope to modify it" { const S = struct { - fn doTheTest() void { - expect(notNull().? == 1); + fn doTheTest() !void { + try expect(notNull().? == 1); } fn notNull() ?u8 { @@ -93,22 +93,22 @@ test "return variable while defer expression in scope to modify it" { } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "errdefer with payload" { const S = struct { fn foo() !i32 { errdefer |a| { - expectEqual(error.One, a); + expectEqual(error.One, a) catch @panic("test failure"); } return error.One; } - fn doTheTest() void { - expectError(error.One, foo()); + fn doTheTest() !void { + try expectError(error.One, foo()); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/enum.zig b/test/stage1/behavior/enum.zig index ecb95be8f5..0ab4e50b24 100644 --- a/test/stage1/behavior/enum.zig +++ b/test/stage1/behavior/enum.zig @@ -29,41 +29,41 @@ test "non-exhaustive enum" { b, _, }; - fn doTheTest(y: u8) void { + fn doTheTest(y: u8) !void { var e: E = .b; - expect(switch (e) { + try expect(switch (e) { .a => false, .b => true, _ => false, }); e = @intToEnum(E, 12); - expect(switch (e) { + try expect(switch (e) { .a => false, .b => false, _ => true, }); - expect(switch (e) { + try expect(switch (e) { .a => false, .b => false, else => true, }); e = .b; - expect(switch (e) { + try expect(switch (e) { .a => false, else => true, }); - expect(@typeInfo(E).Enum.fields.len == 2); + try expect(@typeInfo(E).Enum.fields.len == 2); e = @intToEnum(E, 12); - expect(@enumToInt(e) == 12); + try expect(@enumToInt(e) == 12); e = @intToEnum(E, y); - expect(@enumToInt(e) == 52); - expect(@typeInfo(E).Enum.is_exhaustive == false); + try expect(@enumToInt(e) == 52); + try expect(@typeInfo(E).Enum.is_exhaustive == false); } }; - S.doTheTest(52); - comptime S.doTheTest(52); + try S.doTheTest(52); + comptime try S.doTheTest(52); } test "empty non-exhaustive enum" { @@ -71,19 +71,19 @@ test "empty non-exhaustive enum" { const E = enum(u8) { _, }; - fn doTheTest(y: u8) void { + fn doTheTest(y: u8) !void { var e = @intToEnum(E, y); - expect(switch (e) { + try expect(switch (e) { _ => true, }); - expect(@enumToInt(e) == y); + try expect(@enumToInt(e) == y); - expect(@typeInfo(E).Enum.fields.len == 0); - expect(@typeInfo(E).Enum.is_exhaustive == false); + try expect(@typeInfo(E).Enum.fields.len == 0); + try expect(@typeInfo(E).Enum.is_exhaustive == false); } }; - S.doTheTest(42); - comptime S.doTheTest(42); + try S.doTheTest(42); + comptime try S.doTheTest(42); } test "single field non-exhaustive enum" { @@ -92,35 +92,35 @@ test "single field non-exhaustive enum" { a, _, }; - fn doTheTest(y: u8) void { + fn doTheTest(y: u8) !void { var e: E = .a; - expect(switch (e) { + try expect(switch (e) { .a => true, _ => false, }); e = @intToEnum(E, 12); - expect(switch (e) { + try expect(switch (e) { .a => false, _ => true, }); - expect(switch (e) { + try expect(switch (e) { .a => false, else => true, }); e = .a; - expect(switch (e) { + try expect(switch (e) { .a => true, else => false, }); - expect(@enumToInt(@intToEnum(E, y)) == y); - expect(@typeInfo(E).Enum.fields.len == 1); - expect(@typeInfo(E).Enum.is_exhaustive == false); + try expect(@enumToInt(@intToEnum(E, y)) == y); + try expect(@typeInfo(E).Enum.fields.len == 1); + try expect(@typeInfo(E).Enum.is_exhaustive == false); } }; - S.doTheTest(23); - comptime S.doTheTest(23); + try S.doTheTest(23); + comptime try S.doTheTest(23); } test "enum type" { @@ -133,16 +133,16 @@ test "enum type" { }; const bar = Bar.B; - expect(bar == Bar.B); - expect(@typeInfo(Foo).Union.fields.len == 3); - expect(@typeInfo(Bar).Enum.fields.len == 4); - expect(@sizeOf(Foo) == @sizeOf(FooNoVoid)); - expect(@sizeOf(Bar) == 1); + try expect(bar == Bar.B); + try expect(@typeInfo(Foo).Union.fields.len == 3); + try expect(@typeInfo(Bar).Enum.fields.len == 4); + try expect(@sizeOf(Foo) == @sizeOf(FooNoVoid)); + try expect(@sizeOf(Bar) == 1); } test "enum as return value" { switch (returnAnInt(13)) { - Foo.One => |value| expect(value == 13), + Foo.One => |value| try expect(value == 13), else => unreachable, } } @@ -206,22 +206,22 @@ const Number = enum { }; test "enum to int" { - shouldEqual(Number.Zero, 0); - shouldEqual(Number.One, 1); - shouldEqual(Number.Two, 2); - shouldEqual(Number.Three, 3); - shouldEqual(Number.Four, 4); + try shouldEqual(Number.Zero, 0); + try shouldEqual(Number.One, 1); + try shouldEqual(Number.Two, 2); + try shouldEqual(Number.Three, 3); + try shouldEqual(Number.Four, 4); } -fn shouldEqual(n: Number, expected: u3) void { - expect(@enumToInt(n) == expected); +fn shouldEqual(n: Number, expected: u3) !void { + try expect(@enumToInt(n) == expected); } test "int to enum" { - testIntToEnumEval(3); + try testIntToEnumEval(3); } -fn testIntToEnumEval(x: i32) void { - expect(@intToEnum(IntToEnumNumber, @intCast(u3, x)) == IntToEnumNumber.Three); +fn testIntToEnumEval(x: i32) !void { + try expect(@intToEnum(IntToEnumNumber, @intCast(u3, x)) == IntToEnumNumber.Three); } const IntToEnumNumber = enum { Zero, @@ -232,18 +232,18 @@ const IntToEnumNumber = enum { }; test "@tagName" { - expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); - comptime expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); + try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); + comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); } test "@tagName extern enum with duplicates" { - expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A")); - comptime expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A")); + try expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A")); + comptime try expect(mem.eql(u8, testEnumTagNameBare(ExternDuplicates.B), "A")); } test "@tagName non-exhaustive enum" { - expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); - comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); + try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); + comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); } fn testEnumTagNameBare(n: anytype) []const u8 { @@ -269,8 +269,8 @@ const NonExhaustive = enum(u8) { test "enum alignment" { comptime { - expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8)); - expect(@alignOf(AlignTestEnum) >= @alignOf(u64)); + try expect(@alignOf(AlignTestEnum) >= @alignOf([9]u8)); + try expect(@alignOf(AlignTestEnum) >= @alignOf(u64)); } } @@ -806,10 +806,10 @@ const ValueCount257 = enum { test "enum sizes" { comptime { - expect(@sizeOf(ValueCount1) == 0); - expect(@sizeOf(ValueCount2) == 1); - expect(@sizeOf(ValueCount256) == 1); - expect(@sizeOf(ValueCount257) == 2); + try expect(@sizeOf(ValueCount1) == 0); + try expect(@sizeOf(ValueCount2) == 1); + try expect(@sizeOf(ValueCount256) == 1); + try expect(@sizeOf(ValueCount257) == 2); } } @@ -828,12 +828,12 @@ test "set enum tag type" { { var x = Small.One; x = Small.Two; - comptime expect(Tag(Small) == u2); + comptime try expect(Tag(Small) == u2); } { var x = Small2.One; x = Small2.Two; - comptime expect(Tag(Small2) == u2); + comptime try expect(Tag(Small2) == u2); } } @@ -880,17 +880,17 @@ const bit_field_1 = BitFieldOfEnums{ test "bit field access with enum fields" { var data = bit_field_1; - expect(getA(&data) == A.Two); - expect(getB(&data) == B.Three3); - expect(getC(&data) == C.Four4); - comptime expect(@sizeOf(BitFieldOfEnums) == 1); + try expect(getA(&data) == A.Two); + try expect(getB(&data) == B.Three3); + try expect(getC(&data) == C.Four4); + comptime try expect(@sizeOf(BitFieldOfEnums) == 1); data.b = B.Four3; - expect(data.b == B.Four3); + try expect(data.b == B.Four3); data.a = A.Three; - expect(data.a == A.Three); - expect(data.b == B.Four3); + try expect(data.a == A.Three); + try expect(data.b == B.Four3); } fn getA(data: *const BitFieldOfEnums) A { @@ -906,12 +906,12 @@ fn getC(data: *const BitFieldOfEnums) C { } test "casting enum to its tag type" { - testCastEnumTag(Small2.Two); - comptime testCastEnumTag(Small2.Two); + try testCastEnumTag(Small2.Two); + comptime try testCastEnumTag(Small2.Two); } -fn testCastEnumTag(value: Small2) void { - expect(@enumToInt(value) == 1); +fn testCastEnumTag(value: Small2) !void { + try expect(@enumToInt(value) == 1); } const MultipleChoice = enum(u32) { @@ -922,13 +922,13 @@ const MultipleChoice = enum(u32) { }; test "enum with specified tag values" { - testEnumWithSpecifiedTagValues(MultipleChoice.C); - comptime testEnumWithSpecifiedTagValues(MultipleChoice.C); + try testEnumWithSpecifiedTagValues(MultipleChoice.C); + comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C); } -fn testEnumWithSpecifiedTagValues(x: MultipleChoice) void { - expect(@enumToInt(x) == 60); - expect(1234 == switch (x) { +fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void { + try expect(@enumToInt(x) == 60); + try expect(1234 == switch (x) { MultipleChoice.A => 1, MultipleChoice.B => 2, MultipleChoice.C => @as(u32, 1234), @@ -949,13 +949,13 @@ const MultipleChoice2 = enum(u32) { }; test "enum with specified and unspecified tag values" { - testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); - comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); + try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); + comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); } -fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void { - expect(@enumToInt(x) == 1000); - expect(1234 == switch (x) { +fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { + try expect(@enumToInt(x) == 1000); + try expect(1234 == switch (x) { MultipleChoice2.A => 1, MultipleChoice2.B => 2, MultipleChoice2.C => 3, @@ -969,8 +969,8 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void { } test "cast integer literal to enum" { - expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1); - expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B); + try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1); + try expect(@intToEnum(MultipleChoice2, 40) == MultipleChoice2.B); } const EnumWithOneMember = enum { @@ -1008,14 +1008,14 @@ const EnumWithTagValues = enum(u4) { D = 1 << 3, }; test "enum with tag values don't require parens" { - expect(@enumToInt(EnumWithTagValues.C) == 0b0100); + try expect(@enumToInt(EnumWithTagValues.C) == 0b0100); } test "enum with 1 field but explicit tag type should still have the tag type" { const Enum = enum(u8) { B = 2, }; - comptime @import("std").testing.expect(@sizeOf(Enum) == @sizeOf(u8)); + comptime try expect(@sizeOf(Enum) == @sizeOf(u8)); } test "empty extern enum with members" { @@ -1024,7 +1024,7 @@ test "empty extern enum with members" { B, C, }; - expect(@sizeOf(E) == @sizeOf(c_int)); + try expect(@sizeOf(E) == @sizeOf(c_int)); } test "tag name with assigned enum values" { @@ -1033,7 +1033,7 @@ test "tag name with assigned enum values" { B = 0, }; var b = LocalFoo.B; - expect(mem.eql(u8, @tagName(b), "B")); + try expect(mem.eql(u8, @tagName(b), "B")); } test "enum literal equality" { @@ -1041,8 +1041,8 @@ test "enum literal equality" { const y = .ok; const z = .hi; - expect(x != y); - expect(x == z); + try expect(x != y); + try expect(x == z); } test "enum literal cast to enum" { @@ -1054,7 +1054,7 @@ test "enum literal cast to enum" { var color1: Color = .Auto; var color2 = Color.Auto; - expect(color1 == color2); + try expect(color1 == color2); } test "peer type resolution with enum literal" { @@ -1063,8 +1063,8 @@ test "peer type resolution with enum literal" { two, }; - expect(Items.two == .two); - expect(.two == Items.two); + try expect(Items.two == .two); + try expect(.two == Items.two); } test "enum literal in array literal" { @@ -1078,8 +1078,8 @@ test "enum literal in array literal" { .two, }; - expect(array[0] == .one); - expect(array[1] == .two); + try expect(array[0] == .one); + try expect(array[1] == .two); } test "signed integer as enum tag" { @@ -1089,9 +1089,9 @@ test "signed integer as enum tag" { A2 = 1, }; - expect(@enumToInt(SignedEnum.A0) == -1); - expect(@enumToInt(SignedEnum.A1) == 0); - expect(@enumToInt(SignedEnum.A2) == 1); + try expect(@enumToInt(SignedEnum.A0) == -1); + try expect(@enumToInt(SignedEnum.A1) == 0); + try expect(@enumToInt(SignedEnum.A2) == 1); } test "enum value allocation" { @@ -1101,9 +1101,9 @@ test "enum value allocation" { A2, }; - expect(@enumToInt(LargeEnum.A0) == 0x80000000); - expect(@enumToInt(LargeEnum.A1) == 0x80000001); - expect(@enumToInt(LargeEnum.A2) == 0x80000002); + try expect(@enumToInt(LargeEnum.A0) == 0x80000000); + try expect(@enumToInt(LargeEnum.A1) == 0x80000001); + try expect(@enumToInt(LargeEnum.A2) == 0x80000002); } test "enum literal casting to tagged union" { @@ -1130,32 +1130,32 @@ test "enum with one member and custom tag type" { const E = enum(u2) { One, }; - expect(@enumToInt(E.One) == 0); + try expect(@enumToInt(E.One) == 0); const E2 = enum(u2) { One = 2, }; - expect(@enumToInt(E2.One) == 2); + try expect(@enumToInt(E2.One) == 2); } test "enum literal casting to optional" { var bar: ?Bar = undefined; bar = .B; - expect(bar.? == Bar.B); + try expect(bar.? == Bar.B); } test "enum literal casting to error union with payload enum" { var bar: error{B}!Bar = undefined; bar = .B; // should never cast to the error set - expect((try bar) == Bar.B); + try expect((try bar) == Bar.B); } test "enum with one member and u1 tag type @enumToInt" { const Enum = enum(u1) { Test, }; - expect(@enumToInt(Enum.Test) == 0); + try expect(@enumToInt(Enum.Test) == 0); } test "enum with comptime_int tag type" { @@ -1164,19 +1164,19 @@ test "enum with comptime_int tag type" { Two = 2, Three = 1, }; - comptime expect(Tag(Enum) == comptime_int); + comptime try expect(Tag(Enum) == comptime_int); } test "enum with one member default to u0 tag type" { const E0 = enum { X, }; - comptime expect(Tag(E0) == u0); + comptime try expect(Tag(E0) == u0); } test "tagName on enum literals" { - expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); - comptime expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); + try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); + comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); } test "method call on an enum" { @@ -1193,12 +1193,12 @@ test "method call on an enum" { return self.* == .two and foo == bool; } }; - fn doTheTest() void { + fn doTheTest() !void { var e = E.two; - expect(e.method()); - expect(e.generic_method(bool)); + try expect(e.method()); + try expect(e.generic_method(bool)); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/enum_with_members.zig b/test/stage1/behavior/enum_with_members.zig index 08b195494b..cfbf85812d 100644 --- a/test/stage1/behavior/enum_with_members.zig +++ b/test/stage1/behavior/enum_with_members.zig @@ -19,9 +19,9 @@ test "enum with members" { const b = ET{ .UINT = 42 }; var buf: [20]u8 = undefined; - expect((a.print(buf[0..]) catch unreachable) == 3); - expect(mem.eql(u8, buf[0..3], "-42")); + try expect((a.print(buf[0..]) catch unreachable) == 3); + try expect(mem.eql(u8, buf[0..3], "-42")); - expect((b.print(buf[0..]) catch unreachable) == 2); - expect(mem.eql(u8, buf[0..2], "42")); + try expect((b.print(buf[0..]) catch unreachable) == 2); + try expect(mem.eql(u8, buf[0..2], "42")); } diff --git a/test/stage1/behavior/error.zig b/test/stage1/behavior/error.zig index 529b89d1e2..e5129f180d 100644 --- a/test/stage1/behavior/error.zig +++ b/test/stage1/behavior/error.zig @@ -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")); - expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName")); + try expect(mem.eql(u8, @errorName(error.AnError), "AnError")); + 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); - expect(b == 10); + try expect(a == 3); + 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(); - comptime testErrorUnionType(); + try testErrorUnionType(); + comptime try testErrorUnionType(); } -fn testErrorUnionType() void { +fn testErrorUnionType() !void { const x: anyerror!i32 = 1234; - if (x) |value| expect(value == 1234) else |_| unreachable; - expect(@typeInfo(@TypeOf(x)) == .ErrorUnion); - expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet); - expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror); + if (x) |value| try expect(value == 1234) else |_| unreachable; + try expect(@typeInfo(@TypeOf(x)) == .ErrorUnion); + try expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet); + try expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror); } test "error set type" { - testErrorSetType(); - comptime testErrorSetType(); + try testErrorSetType(); + comptime try testErrorSetType(); } const MyErrSet = error{ @@ -98,21 +98,21 @@ const MyErrSet = error{ FileNotFound, }; -fn testErrorSetType() void { - expect(@typeInfo(MyErrSet).ErrorSet.?.len == 2); +fn testErrorSetType() !void { + 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); - comptime testExplicitErrorSetCast(Set1.A); + try 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); - comptime testComptimeTestErrorEmptySet(1234); + try testComptimeTestErrorEmptySet(1234); + comptime try testComptimeTestErrorEmptySet(1234); } const EmptyErrorSet = error{}; -fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) void { - if (x) |v| expect(v == 1234) else |err| @compileError("bad"); +fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void { + 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); - expectError(error.Failure, S.errorable2()); - expectError(error.Other, S.errorable3()); + try expect((try S.errorable()) == 1234); + try expectError(error.Failure, S.errorable2()); + try expectError(error.Other, S.errorable3()); comptime { - expect((try S.errorable()) == 1234); - expectError(error.Failure, S.errorable2()); - expectError(error.Other, S.errorable3()); + try expect((try S.errorable()) == 1234); + try expectError(error.Failure, S.errorable2()); + 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()); - comptime expectError(error.Failure, S.errorable()); + try 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); - comptime expect(S.returnsOptErrSet() == null); + try 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 { - expectError(error.Bad, func()); + fn entry() !void { + try expectError(error.Bad, func()); } fn fail() anyerror!Foo { return error.Wrong; @@ -358,16 +358,16 @@ test "nested catch" { field: i32, }; }; - S.entry(); - comptime S.entry(); + try 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(); - comptime S.doTheTest(); + try 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, {})); -} \ No newline at end of file +} diff --git a/test/stage1/behavior/eval.zig b/test/stage1/behavior/eval.zig index 38dd12c59d..580ad3509c 100644 --- a/test/stage1/behavior/eval.zig +++ b/test/stage1/behavior/eval.zig @@ -4,7 +4,7 @@ const expectEqual = std.testing.expectEqual; const builtin = @import("builtin"); test "compile time recursion" { - expect(some_data.len == 21); + try expect(some_data.len == 21); } var some_data: [@intCast(usize, fibonacci(7))]u8 = undefined; fn fibonacci(x: i32) i32 { @@ -17,7 +17,7 @@ fn unwrapAndAddOne(blah: ?i32) i32 { } const should_be_1235 = unwrapAndAddOne(1234); test "static add one" { - expect(should_be_1235 == 1235); + try expect(should_be_1235 == 1235); } test "inlined loop" { @@ -25,7 +25,7 @@ test "inlined loop" { comptime var sum = 0; inline while (i <= 5) : (i += 1) sum += i; - expect(sum == 15); + try expect(sum == 15); } fn gimme1or2(comptime a: bool) i32 { @@ -35,12 +35,12 @@ fn gimme1or2(comptime a: bool) i32 { return z; } test "inline variable gets result of const if" { - expect(gimme1or2(true) == 1); - expect(gimme1or2(false) == 2); + try expect(gimme1or2(true) == 1); + try expect(gimme1or2(false) == 2); } test "static function evaluation" { - expect(statically_added_number == 3); + try expect(statically_added_number == 3); } const statically_added_number = staticAdd(1, 2); fn staticAdd(a: i32, b: i32) i32 { @@ -48,8 +48,8 @@ fn staticAdd(a: i32, b: i32) i32 { } test "const expr eval on single expr blocks" { - expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); - comptime expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); + try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); + comptime try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3); } fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { @@ -65,10 +65,10 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { } test "statically initialized list" { - expect(static_point_list[0].x == 1); - expect(static_point_list[0].y == 2); - expect(static_point_list[1].x == 3); - expect(static_point_list[1].y == 4); + try expect(static_point_list[0].x == 1); + try expect(static_point_list[0].y == 2); + try expect(static_point_list[1].x == 3); + try expect(static_point_list[1].y == 4); } const Point = struct { x: i32, @@ -86,8 +86,8 @@ fn makePoint(x: i32, y: i32) Point { } test "static eval list init" { - expect(static_vec3.data[2] == 1.0); - expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); + try expect(static_vec3.data[2] == 1.0); + try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); } const static_vec3 = vec3(0.0, 0.0, 1.0); pub const Vec3 = struct { @@ -105,12 +105,12 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 { test "constant expressions" { var array: [array_size]u8 = undefined; - expect(@sizeOf(@TypeOf(array)) == 20); + try expect(@sizeOf(@TypeOf(array)) == 20); } const array_size: u8 = 20; test "constant struct with negation" { - expect(vertices[0].x == -0.6); + try expect(vertices[0].x == -0.6); } const Vertex = struct { x: f32, @@ -145,7 +145,7 @@ const vertices = [_]Vertex{ test "statically initialized struct" { st_init_str_foo.x += 1; - expect(st_init_str_foo.x == 14); + try expect(st_init_str_foo.x == 14); } const StInitStrFoo = struct { x: i32, @@ -158,7 +158,7 @@ var st_init_str_foo = StInitStrFoo{ test "statically initalized array literal" { const y: [4]u8 = st_init_arr_lit_x; - expect(y[3] == 4); + try expect(y[3] == 4); } const st_init_arr_lit_x = [_]u8{ 1, @@ -170,15 +170,15 @@ const st_init_arr_lit_x = [_]u8{ test "const slice" { comptime { const a = "1234567890"; - expect(a.len == 10); + try expect(a.len == 10); const b = a[1..2]; - expect(b.len == 1); - expect(b[0] == '2'); + try expect(b.len == 1); + try expect(b[0] == '2'); } } test "try to trick eval with runtime if" { - expect(testTryToTrickEvalWithRuntimeIf(true) == 10); + try expect(testTryToTrickEvalWithRuntimeIf(true) == 10); } fn testTryToTrickEvalWithRuntimeIf(b: bool) usize { @@ -198,7 +198,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio const result = if (i == 0) [1]i32{2} else runtime; } comptime { - expect(i == 2); + try expect(i == 2); } } @@ -215,16 +215,16 @@ fn letsTryToCompareBools(a: bool, b: bool) bool { return max(bool, a, b); } test "inlined block and runtime block phi" { - expect(letsTryToCompareBools(true, true)); - expect(letsTryToCompareBools(true, false)); - expect(letsTryToCompareBools(false, true)); - expect(!letsTryToCompareBools(false, false)); + try expect(letsTryToCompareBools(true, true)); + try expect(letsTryToCompareBools(true, false)); + try expect(letsTryToCompareBools(false, true)); + try expect(!letsTryToCompareBools(false, false)); comptime { - expect(letsTryToCompareBools(true, true)); - expect(letsTryToCompareBools(true, false)); - expect(letsTryToCompareBools(false, true)); - expect(!letsTryToCompareBools(false, false)); + try expect(letsTryToCompareBools(true, true)); + try expect(letsTryToCompareBools(true, false)); + try expect(letsTryToCompareBools(false, true)); + try expect(!letsTryToCompareBools(false, false)); } } @@ -269,14 +269,14 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 { } test "comptime iterate over fn ptr list" { - expect(performFn('t', 1) == 6); - expect(performFn('o', 0) == 1); - expect(performFn('w', 99) == 99); + try expect(performFn('t', 1) == 6); + try expect(performFn('o', 0) == 1); + try expect(performFn('w', 99) == 99); } test "eval @setRuntimeSafety at compile-time" { const result = comptime fnWithSetRuntimeSafety(); - expect(result == 1234); + try expect(result == 1234); } fn fnWithSetRuntimeSafety() i32 { @@ -286,7 +286,7 @@ fn fnWithSetRuntimeSafety() i32 { test "eval @setFloatMode at compile-time" { const result = comptime fnWithFloatMode(); - expect(result == 1234.0); + try expect(result == 1234.0); } fn fnWithFloatMode() f32 { @@ -307,15 +307,15 @@ var simple_struct = SimpleStruct{ .field = 1234 }; const bound_fn = simple_struct.method; test "call method on bound fn referring to var instance" { - expect(bound_fn() == 1237); + try expect(bound_fn() == 1237); } test "ptr to local array argument at comptime" { comptime { var bytes: [10]u8 = undefined; modifySomeBytes(bytes[0..]); - expect(bytes[0] == 'a'); - expect(bytes[9] == 'b'); + try expect(bytes[0] == 'a'); + try expect(bytes[9] == 'b'); } } @@ -343,9 +343,9 @@ fn testCompTimeUIntComparisons(x: u32) void { } test "const ptr to variable data changes at runtime" { - expect(foo_ref.name[0] == 'a'); + try expect(foo_ref.name[0] == 'a'); foo_ref.name = "b"; - expect(foo_ref.name[0] == 'b'); + try expect(foo_ref.name[0] == 'b'); } const Foo = struct { @@ -356,8 +356,8 @@ var foo_contents = Foo{ .name = "a" }; const foo_ref = &foo_contents; test "create global array with for loop" { - expect(global_array[5] == 5 * 5); - expect(global_array[9] == 9 * 9); + try expect(global_array[5] == 5 * 5); + try expect(global_array[9] == 9 * 9); } const global_array = x: { @@ -372,18 +372,18 @@ test "compile-time downcast when the bits fit" { comptime { const spartan_count: u16 = 255; const byte = @intCast(u8, spartan_count); - expect(byte == 255); + try expect(byte == 255); } } const hi1 = "hi"; const hi2 = hi1; test "const global shares pointer with other same one" { - assertEqualPtrs(&hi1[0], &hi2[0]); - comptime expect(&hi1[0] == &hi2[0]); + try assertEqualPtrs(&hi1[0], &hi2[0]); + comptime try expect(&hi1[0] == &hi2[0]); } -fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) void { - expect(ptr1 == ptr2); +fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void { + try expect(ptr1 == ptr2); } test "@setEvalBranchQuota" { @@ -395,29 +395,29 @@ test "@setEvalBranchQuota" { while (i < 1001) : (i += 1) { sum += i; } - expect(sum == 500500); + try expect(sum == 500500); } } test "float literal at compile time not lossy" { - expect(16777216.0 + 1.0 == 16777217.0); - expect(9007199254740992.0 + 1.0 == 9007199254740993.0); + try expect(16777216.0 + 1.0 == 16777217.0); + try expect(9007199254740992.0 + 1.0 == 9007199254740993.0); } test "f32 at compile time is lossy" { - expect(@as(f32, 1 << 24) + 1 == 1 << 24); + try expect(@as(f32, 1 << 24) + 1 == 1 << 24); } test "f64 at compile time is lossy" { - expect(@as(f64, 1 << 53) + 1 == 1 << 53); + try expect(@as(f64, 1 << 53) + 1 == 1 << 53); } test "f128 at compile time is lossy" { - expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0); + try expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0); } comptime { - expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192); + try expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192); } pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { @@ -429,15 +429,15 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { test "string literal used as comptime slice is memoized" { const a = "link"; const b = "link"; - comptime expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node); - comptime expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node); + comptime try expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node); + comptime try expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node); } test "comptime slice of undefined pointer of length 0" { const slice1 = @as([*]i32, undefined)[0..0]; - expect(slice1.len == 0); + try expect(slice1.len == 0); const slice2 = @as([*]i32, undefined)[100..100]; - expect(slice2.len == 0); + try expect(slice2.len == 0); } fn copyWithPartialInline(s: []u32, b: []u8) void { @@ -459,16 +459,16 @@ test "binary math operator in partially inlined function" { r.* = @intCast(u8, i + 1); copyWithPartialInline(s[0..], b[0..]); - expect(s[0] == 0x1020304); - expect(s[1] == 0x5060708); - expect(s[2] == 0x90a0b0c); - expect(s[3] == 0xd0e0f10); + try expect(s[0] == 0x1020304); + try expect(s[1] == 0x5060708); + try expect(s[2] == 0x90a0b0c); + try expect(s[3] == 0xd0e0f10); } test "comptime function with the same args is memoized" { comptime { - expect(MakeType(i32) == MakeType(i32)); - expect(MakeType(i32) != MakeType(f64)); + try expect(MakeType(i32) == MakeType(i32)); + try expect(MakeType(i32) != MakeType(f64)); } } @@ -484,7 +484,7 @@ test "comptime function with mutable pointer is not memoized" { const ptr = &x; increment(ptr); increment(ptr); - expect(x == 3); + try expect(x == 3); } } @@ -510,14 +510,14 @@ fn doesAlotT(comptime T: type, value: usize) T { } test "@setEvalBranchQuota at same scope as generic function call" { - expect(doesAlotT(u32, 2) == 2); + try expect(doesAlotT(u32, 2) == 2); } test "comptime slice of slice preserves comptime var" { comptime { var buff: [10]u8 = undefined; buff[0..][0..][0] = 1; - expect(buff[0..][0..][0] == 1); + try expect(buff[0..][0..][0] == 1); } } @@ -526,7 +526,7 @@ test "comptime slice of pointer preserves comptime var" { var buff: [10]u8 = undefined; var a = @ptrCast([*]u8, &buff); a[0..1][0] = 1; - expect(buff[0..][0..][0] == 1); + try expect(buff[0..][0..][0] == 1); } } @@ -540,9 +540,9 @@ const SingleFieldStruct = struct { test "const ptr to comptime mutable data is not memoized" { comptime { var foo = SingleFieldStruct{ .x = 1 }; - expect(foo.read_x() == 1); + try expect(foo.read_x() == 1); foo.x = 2; - expect(foo.read_x() == 2); + try expect(foo.read_x() == 2); } } @@ -551,7 +551,7 @@ test "array concat of slices gives slice" { var a: []const u8 = "aoeu"; var b: []const u8 = "asdf"; const c = a ++ b; - expect(std.mem.eql(u8, c, "aoeuasdf")); + try expect(std.mem.eql(u8, c, "aoeuasdf")); } } @@ -568,14 +568,14 @@ test "comptime shlWithOverflow" { break :amt amt; }; - expect(ct_shifted == rt_shifted); + try expect(ct_shifted == rt_shifted); } test "runtime 128 bit integer division" { var a: u128 = 152313999999999991610955792383; var b: u128 = 10000000000000000000; var c = a / b; - expect(c == 15231399999); + try expect(c == 15231399999); } pub const Info = struct { @@ -588,20 +588,20 @@ test "comptime modification of const struct field" { comptime { var res = diamond_info; res.version = 1; - expect(diamond_info.version == 0); - expect(res.version == 1); + try expect(diamond_info.version == 0); + try expect(res.version == 1); } } test "pointer to type" { comptime { var T: type = i32; - expect(T == i32); + try expect(T == i32); var ptr = &T; - expect(@TypeOf(ptr) == *type); + try expect(@TypeOf(ptr) == *type); ptr.* = f32; - expect(T == f32); - expect(*T == *f32); + try expect(T == f32); + try expect(*T == *f32); } } @@ -610,17 +610,17 @@ test "slice of type" { var types_array = [_]type{ i32, f64, type }; for (types_array) |T, i| { switch (i) { - 0 => expect(T == i32), - 1 => expect(T == f64), - 2 => expect(T == type), + 0 => try expect(T == i32), + 1 => try expect(T == f64), + 2 => try expect(T == type), else => unreachable, } } for (types_array[0..]) |T, i| { switch (i) { - 0 => expect(T == i32), - 1 => expect(T == f64), - 2 => expect(T == type), + 0 => try expect(T == i32), + 1 => try expect(T == f64), + 2 => try expect(T == type), else => unreachable, } } @@ -637,7 +637,7 @@ fn wrap(comptime T: type) Wrapper { test "function which returns struct with type field causes implicit comptime" { const ty = wrap(i32).T; - expect(ty == i32); + try expect(ty == i32); } 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" { const s = S{ .a = 2 }; var b = s.b(); - expect(b == 2); + try expect(b == 2); } test "@tagName of @typeInfo" { const str = @tagName(@typeInfo(u8)); - expect(std.mem.eql(u8, str, "Int")); + try expect(std.mem.eql(u8, str, "Int")); } test "setting backward branch quota just before a generic fn call" { @@ -670,15 +670,15 @@ fn loopNTimes(comptime n: usize) void { } test "variable inside inline loop that has different types on different iterations" { - testVarInsideInlineLoop(.{ true, @as(u32, 42) }); + try testVarInsideInlineLoop(.{ true, @as(u32, 42) }); } -fn testVarInsideInlineLoop(args: anytype) void { +fn testVarInsideInlineLoop(args: anytype) !void { comptime var i = 0; inline while (i < args.len) : (i += 1) { const x = args[i]; - if (i == 0) expect(x); - if (i == 1) expect(x == 42); + if (i == 0) try expect(x); + if (i == 1) try expect(x == 42); } } @@ -688,7 +688,7 @@ test "inline for with same type but different values" { var a: T = undefined; res += a.len; } - expect(res == 5); + try expect(res == 5); } test "refer to the type of a generic function" { @@ -702,13 +702,13 @@ fn doNothingWithType(comptime T: type) void {} test "zero extend from u0 to u1" { var zero_u0: u0 = 0; var zero_u1: u1 = zero_u0; - expect(zero_u1 == 0); + try expect(zero_u1 == 0); } test "bit shift a u1" { var x: u1 = 1; var y = x << 0; - expect(y == 1); + try expect(y == 1); } test "comptime pointer cast array and then slice" { @@ -720,8 +720,8 @@ test "comptime pointer cast array and then slice" { const ptrB: [*]const u8 = &array; const sliceB: []const u8 = ptrB[0..2]; - expect(sliceA[1] == 2); - expect(sliceB[1] == 2); + try expect(sliceA[1] == 2); + try expect(sliceB[1] == 2); } test "slice bounds in comptime concatenation" { @@ -730,46 +730,46 @@ test "slice bounds in comptime concatenation" { break :blk b[8..9]; }; const str = "" ++ bs; - expect(str.len == 1); - expect(std.mem.eql(u8, str, "1")); + try expect(str.len == 1); + try expect(std.mem.eql(u8, str, "1")); const str2 = bs ++ ""; - expect(str2.len == 1); - expect(std.mem.eql(u8, str2, "1")); + try expect(str2.len == 1); + try expect(std.mem.eql(u8, str2, "1")); } test "comptime bitwise operators" { comptime { - expect(3 & 1 == 1); - expect(3 & -1 == 3); - expect(-3 & -1 == -3); - expect(3 | -1 == -1); - expect(-3 | -1 == -1); - expect(3 ^ -1 == -4); - expect(-3 ^ -1 == 2); - expect(~@as(i8, -1) == 0); - expect(~@as(i128, -1) == 0); - expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611); - expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615); - expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff); + try expect(3 & 1 == 1); + try expect(3 & -1 == 3); + try expect(-3 & -1 == -3); + try expect(3 | -1 == -1); + try expect(-3 | -1 == -1); + try expect(3 ^ -1 == -4); + try expect(-3 ^ -1 == 2); + try expect(~@as(i8, -1) == 0); + try expect(~@as(i128, -1) == 0); + try expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611); + try expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615); + try expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff); } } test "*align(1) u16 is the same as *align(1:0:2) u16" { comptime { - expect(*align(1:0:2) u16 == *align(1) u16); - expect(*align(2:0:2) u16 == *u16); + try expect(*align(1:0:2) u16 == *align(1) u16); + try expect(*align(2:0:2) u16 == *u16); } } test "array concatenation forces comptime" { var a = oneItem(3) ++ oneItem(4); - expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 })); + try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 })); } test "array multiplication forces comptime" { var a = oneItem(3) ** scalar(2); - expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 })); + try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 })); } fn oneItem(x: i32) [1]i32 { @@ -791,7 +791,7 @@ test "comptime assign int to optional int" { var x: ?i32 = null; x = 2; x.? *= 10; - expectEqual(20, x.?); + try expectEqual(20, x.?); } } diff --git a/test/stage1/behavior/field_parent_ptr.zig b/test/stage1/behavior/field_parent_ptr.zig index 6026a49d12..addb7942ad 100644 --- a/test/stage1/behavior/field_parent_ptr.zig +++ b/test/stage1/behavior/field_parent_ptr.zig @@ -1,13 +1,13 @@ const expect = @import("std").testing.expect; test "@fieldParentPtr non-first field" { - testParentFieldPtr(&foo.c); - comptime testParentFieldPtr(&foo.c); + try testParentFieldPtr(&foo.c); + comptime try testParentFieldPtr(&foo.c); } test "@fieldParentPtr first field" { - testParentFieldPtrFirst(&foo.a); - comptime testParentFieldPtrFirst(&foo.a); + try testParentFieldPtrFirst(&foo.a); + comptime try testParentFieldPtrFirst(&foo.a); } const Foo = struct { @@ -24,18 +24,18 @@ const foo = Foo{ .d = -10, }; -fn testParentFieldPtr(c: *const i32) void { - expect(c == &foo.c); +fn testParentFieldPtr(c: *const i32) !void { + try expect(c == &foo.c); const base = @fieldParentPtr(Foo, "c", c); - expect(base == &foo); - expect(&base.c == c); + try expect(base == &foo); + try expect(&base.c == c); } -fn testParentFieldPtrFirst(a: *const bool) void { - expect(a == &foo.a); +fn testParentFieldPtrFirst(a: *const bool) !void { + try expect(a == &foo.a); const base = @fieldParentPtr(Foo, "a", a); - expect(base == &foo); - expect(&base.a == a); + try expect(base == &foo); + try expect(&base.a == a); } diff --git a/test/stage1/behavior/floatop.zig b/test/stage1/behavior/floatop.zig index 9f2e45ed26..ec8641340f 100644 --- a/test/stage1/behavior/floatop.zig +++ b/test/stage1/behavior/floatop.zig @@ -8,441 +8,441 @@ const Vector = std.meta.Vector; const epsilon = 0.000001; test "@sqrt" { - comptime testSqrt(); - testSqrt(); + comptime try testSqrt(); + try testSqrt(); } -fn testSqrt() void { +fn testSqrt() !void { { var a: f16 = 4; - expect(@sqrt(a) == 2); + try expect(@sqrt(a) == 2); } { var a: f32 = 9; - expect(@sqrt(a) == 3); + try expect(@sqrt(a) == 3); var b: f32 = 1.1; - expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon)); + try expect(math.approxEqAbs(f32, @sqrt(b), 1.0488088481701516, epsilon)); } { var a: f64 = 25; - expect(@sqrt(a) == 5); + try expect(@sqrt(a) == 5); } { const a: comptime_float = 25.0; - expect(@sqrt(a) == 5.0); + try expect(@sqrt(a) == 5.0); } // TODO https://github.com/ziglang/zig/issues/4026 //{ // var a: f128 = 49; - // expect(@sqrt(a) == 7); + //try expect(@sqrt(a) == 7); //} { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; var result = @sqrt(v); - expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon)); } } test "more @sqrt f16 tests" { // TODO these are not all passing at comptime - expect(@sqrt(@as(f16, 0.0)) == 0.0); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon)); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon)); - expect(@sqrt(@as(f16, 4.0)) == 2.0); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon)); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon)); - expect(@sqrt(@as(f16, 64.0)) == 8.0); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon)); - expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon)); + try expect(@sqrt(@as(f16, 0.0)) == 0.0); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 2.0)), 1.414214, epsilon)); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 3.6)), 1.897367, epsilon)); + try expect(@sqrt(@as(f16, 4.0)) == 2.0); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 7.539840)), 2.745877, epsilon)); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 19.230934)), 4.385309, epsilon)); + try expect(@sqrt(@as(f16, 64.0)) == 8.0); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 64.1)), 8.006248, epsilon)); + try expect(math.approxEqAbs(f16, @sqrt(@as(f16, 8942.230469)), 94.563370, epsilon)); // special cases - expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16))))); - expect(@sqrt(@as(f16, 0.0)) == 0.0); - expect(@sqrt(@as(f16, -0.0)) == -0.0); - expect(math.isNan(@sqrt(@as(f16, -1.0)))); - expect(math.isNan(@sqrt(@as(f16, math.nan(f16))))); + try expect(math.isPositiveInf(@sqrt(@as(f16, math.inf(f16))))); + try expect(@sqrt(@as(f16, 0.0)) == 0.0); + try expect(@sqrt(@as(f16, -0.0)) == -0.0); + try expect(math.isNan(@sqrt(@as(f16, -1.0)))); + try expect(math.isNan(@sqrt(@as(f16, math.nan(f16))))); } test "@sin" { - comptime testSin(); - testSin(); + comptime try testSin(); + try testSin(); } -fn testSin() void { +fn testSin() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 0; - expect(@sin(a) == 0); + try expect(@sin(a) == 0); } { var a: f32 = 0; - expect(@sin(a) == 0); + try expect(@sin(a) == 0); } { var a: f64 = 0; - expect(@sin(a) == 0); + try expect(@sin(a) == 0); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; var result = @sin(v); - expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon)); } } test "@cos" { - comptime testCos(); - testCos(); + comptime try testCos(); + try testCos(); } -fn testCos() void { +fn testCos() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 0; - expect(@cos(a) == 1); + try expect(@cos(a) == 1); } { var a: f32 = 0; - expect(@cos(a) == 1); + try expect(@cos(a) == 1); } { var a: f64 = 0; - expect(@cos(a) == 1); + try expect(@cos(a) == 1); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; var result = @cos(v); - expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon)); } } test "@exp" { - comptime testExp(); - testExp(); + comptime try testExp(); + try testExp(); } -fn testExp() void { +fn testExp() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 0; - expect(@exp(a) == 1); + try expect(@exp(a) == 1); } { var a: f32 = 0; - expect(@exp(a) == 1); + try expect(@exp(a) == 1); } { var a: f64 = 0; - expect(@exp(a) == 1); + try expect(@exp(a) == 1); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; var result = @exp(v); - expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon)); } } test "@exp2" { - comptime testExp2(); - testExp2(); + comptime try testExp2(); + try testExp2(); } -fn testExp2() void { +fn testExp2() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 2; - expect(@exp2(a) == 4); + try expect(@exp2(a) == 4); } { var a: f32 = 2; - expect(@exp2(a) == 4); + try expect(@exp2(a) == 4); } { var a: f64 = 2; - expect(@exp2(a) == 4); + try expect(@exp2(a) == 4); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; var result = @exp2(v); - expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon)); } } test "@log" { // Old musl (and glibc?), and our current math.ln implementation do not return 1 // so also accept those values. - comptime testLog(); - testLog(); + comptime try testLog(); + try testLog(); } -fn testLog() void { +fn testLog() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = e; - expect(math.approxEqAbs(f16, @log(a), 1, epsilon)); + try expect(math.approxEqAbs(f16, @log(a), 1, epsilon)); } { var a: f32 = e; - expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff))); + try expect(@log(a) == 1 or @log(a) == @bitCast(f32, @as(u32, 0x3f7fffff))); } { var a: f64 = e; - expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000))); + try expect(@log(a) == 1 or @log(a) == @bitCast(f64, @as(u64, 0x3ff0000000000000))); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; var result = @log(v); - expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @log(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @log(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @log(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @log(@as(f32, 0.4)), result[3], epsilon)); } } test "@log2" { - comptime testLog2(); - testLog2(); + comptime try testLog2(); + try testLog2(); } -fn testLog2() void { +fn testLog2() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 4; - expect(@log2(a) == 2); + try expect(@log2(a) == 2); } { var a: f32 = 4; - expect(@log2(a) == 2); + try expect(@log2(a) == 2); } { var a: f64 = 4; - expect(@log2(a) == 2); + try expect(@log2(a) == 2); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; var result = @log2(v); - expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @log2(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @log2(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @log2(@as(f32, 0.4)), result[3], epsilon)); } } test "@log10" { - comptime testLog10(); - testLog10(); + comptime try testLog10(); + try testLog10(); } -fn testLog10() void { +fn testLog10() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 100; - expect(@log10(a) == 2); + try expect(@log10(a) == 2); } { var a: f32 = 100; - expect(@log10(a) == 2); + try expect(@log10(a) == 2); } { var a: f64 = 1000; - expect(@log10(a) == 3); + try expect(@log10(a) == 3); } { var v: Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; var result = @log10(v); - expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @log10(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @log10(@as(f32, 2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @log10(@as(f32, 0.4)), result[3], epsilon)); } } test "@fabs" { - comptime testFabs(); - testFabs(); + comptime try testFabs(); + try testFabs(); } -fn testFabs() void { +fn testFabs() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = -2.5; var b: f16 = 2.5; - expect(@fabs(a) == 2.5); - expect(@fabs(b) == 2.5); + try expect(@fabs(a) == 2.5); + try expect(@fabs(b) == 2.5); } { var a: f32 = -2.5; var b: f32 = 2.5; - expect(@fabs(a) == 2.5); - expect(@fabs(b) == 2.5); + try expect(@fabs(a) == 2.5); + try expect(@fabs(b) == 2.5); } { var a: f64 = -2.5; var b: f64 = 2.5; - expect(@fabs(a) == 2.5); - expect(@fabs(b) == 2.5); + try expect(@fabs(a) == 2.5); + try expect(@fabs(b) == 2.5); } { var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; var result = @fabs(v); - expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @fabs(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @fabs(@as(f32, -2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @fabs(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon)); } } test "@floor" { - comptime testFloor(); - testFloor(); + comptime try testFloor(); + try testFloor(); } -fn testFloor() void { +fn testFloor() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 2.1; - expect(@floor(a) == 2); + try expect(@floor(a) == 2); } { var a: f32 = 2.1; - expect(@floor(a) == 2); + try expect(@floor(a) == 2); } { var a: f64 = 3.5; - expect(@floor(a) == 3); + try expect(@floor(a) == 3); } { var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; var result = @floor(v); - expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon)); } } test "@ceil" { - comptime testCeil(); - testCeil(); + comptime try testCeil(); + try testCeil(); } -fn testCeil() void { +fn testCeil() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 2.1; - expect(@ceil(a) == 3); + try expect(@ceil(a) == 3); } { var a: f32 = 2.1; - expect(@ceil(a) == 3); + try expect(@ceil(a) == 3); } { var a: f64 = 3.5; - expect(@ceil(a) == 4); + try expect(@ceil(a) == 4); } { var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; var result = @ceil(v); - expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon)); } } test "@trunc" { - comptime testTrunc(); - testTrunc(); + comptime try testTrunc(); + try testTrunc(); } -fn testTrunc() void { +fn testTrunc() !void { // TODO test f128, and c_longdouble // https://github.com/ziglang/zig/issues/4026 { var a: f16 = 2.1; - expect(@trunc(a) == 2); + try expect(@trunc(a) == 2); } { var a: f32 = 2.1; - expect(@trunc(a) == 2); + try expect(@trunc(a) == 2); } { var a: f64 = -3.5; - expect(@trunc(a) == -3); + try expect(@trunc(a) == -3); } { var v: Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; var result = @trunc(v); - expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon)); - expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon)); - expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon)); - expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon)); + try expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon)); + try expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon)); + try expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon)); + try expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon)); } } test "floating point comparisons" { - testFloatComparisons(); - comptime testFloatComparisons(); + try testFloatComparisons(); + comptime try testFloatComparisons(); } -fn testFloatComparisons() void { +fn testFloatComparisons() !void { inline for ([_]type{ f16, f32, f64, f128 }) |ty| { // No decimal part { const x: ty = 1.0; - expect(x == 1); - expect(x != 0); - expect(x > 0); - expect(x < 2); - expect(x >= 1); - expect(x <= 1); + try expect(x == 1); + try expect(x != 0); + try expect(x > 0); + try expect(x < 2); + try expect(x >= 1); + try expect(x <= 1); } // Non-zero decimal part { const x: ty = 1.5; - expect(x != 1); - expect(x != 2); - expect(x > 1); - expect(x < 2); - expect(x >= 1); - expect(x <= 2); + try expect(x != 1); + try expect(x != 2); + try expect(x > 1); + try expect(x < 2); + try expect(x >= 1); + try expect(x <= 2); } } } test "different sized float comparisons" { - testDifferentSizedFloatComparisons(); - comptime testDifferentSizedFloatComparisons(); + try testDifferentSizedFloatComparisons(); + comptime try testDifferentSizedFloatComparisons(); } -fn testDifferentSizedFloatComparisons() void { +fn testDifferentSizedFloatComparisons() !void { var a: f16 = 1; var b: f64 = 2; - expect(a < b); + try expect(a < b); } // 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 { // // https://github.com/ziglang/zig/issues/4026 // { // var a: f32 = 2.1; -// expect(@nearbyint(a) == 2); +// try expect(@nearbyint(a) == 2); // } // { // var a: f64 = -3.75; -// expect(@nearbyint(a) == -4); +// try expect(@nearbyint(a) == -4); // } //} diff --git a/test/stage1/behavior/fn.zig b/test/stage1/behavior/fn.zig index a1e726c565..f6d9bce3fe 100644 --- a/test/stage1/behavior/fn.zig +++ b/test/stage1/behavior/fn.zig @@ -4,7 +4,7 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "params" { - expect(testParamsAdd(22, 11) == 33); + try expect(testParamsAdd(22, 11) == 33); } fn testParamsAdd(a: i32, b: i32) i32 { return a + b; @@ -19,37 +19,37 @@ fn testLocVars(b: i32) void { } test "void parameters" { - voidFun(1, void{}, 2, {}); + try voidFun(1, void{}, 2, {}); } -fn voidFun(a: i32, b: void, c: i32, d: void) void { +fn voidFun(a: i32, b: void, c: i32, d: void) !void { const v = b; const vv: void = if (a == 1) v else {}; - expect(a + c == 3); + try expect(a + c == 3); return vv; } test "mutable local variables" { var zero: i32 = 0; - expect(zero == 0); + try expect(zero == 0); var i = @as(i32, 0); while (i != 3) { i += 1; } - expect(i == 3); + try expect(i == 3); } test "separate block scopes" { { const no_conflict: i32 = 5; - expect(no_conflict == 5); + try expect(no_conflict == 5); } const c = x: { const no_conflict = @as(i32, 10); break :x no_conflict; }; - expect(c == 10); + try expect(c == 10); } test "call function with empty string" { @@ -62,7 +62,7 @@ fn @"weird function name"() i32 { return 1234; } test "weird function name" { - expect(@"weird function name"() == 1234); + try expect(@"weird function name"() == 1234); } test "implicit cast function unreachable return" { @@ -83,7 +83,7 @@ test "function pointers" { fn4, }; for (fns) |f, i| { - expect(f() == @intCast(u32, i) + 5); + try expect(f() == @intCast(u32, i) + 5); } } fn fn1() u32 { @@ -100,12 +100,12 @@ fn fn4() u32 { } test "number literal as an argument" { - numberLiteralArg(3); - comptime numberLiteralArg(3); + try numberLiteralArg(3); + comptime try numberLiteralArg(3); } -fn numberLiteralArg(a: anytype) void { - expect(a == 3); +fn numberLiteralArg(a: anytype) !void { + try expect(a == 3); } test "assign inline fn to const variable" { @@ -116,7 +116,7 @@ test "assign inline fn to const variable" { fn inlineFn() callconv(.Inline) void {} test "pass by non-copying value" { - expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3); + try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3); } const Point = struct { @@ -129,17 +129,17 @@ fn addPointCoords(pt: Point) i32 { } test "pass by non-copying value through var arg" { - expect(addPointCoordsVar(Point{ .x = 1, .y = 2 }) == 3); + try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3); } -fn addPointCoordsVar(pt: anytype) i32 { - comptime expect(@TypeOf(pt) == Point); +fn addPointCoordsVar(pt: anytype) !i32 { + comptime try expect(@TypeOf(pt) == Point); return pt.x + pt.y; } test "pass by non-copying value as method" { var pt = Point2{ .x = 1, .y = 2 }; - expect(pt.addPointCoords() == 3); + try expect(pt.addPointCoords() == 3); } const Point2 = struct { @@ -153,7 +153,7 @@ const Point2 = struct { test "pass by non-copying value as method, which is generic" { var pt = Point3{ .x = 1, .y = 2 }; - expect(pt.addPointCoords(i32) == 3); + try expect(pt.addPointCoords(i32) == 3); } const Point3 = struct { @@ -168,7 +168,7 @@ const Point3 = struct { test "pass by non-copying value as method, at comptime" { comptime { var pt = Point2{ .x = 1, .y = 2 }; - expect(pt.addPointCoords() == 3); + try expect(pt.addPointCoords() == 3); } } @@ -184,7 +184,7 @@ fn outer(y: u32) fn (u32) u32 { test "return inner function which references comptime variable of outer function" { var func = outer(10); - expect(func(3) == 7); + try expect(func(3) == 7); } test "extern struct with stdcallcc fn pointer" { @@ -198,16 +198,16 @@ test "extern struct with stdcallcc fn pointer" { var s: S = undefined; s.ptr = S.foo; - expect(s.ptr() == 1234); + try expect(s.ptr() == 1234); } test "implicit cast fn call result to optional in field result" { const S = struct { - fn entry() void { + fn entry() !void { var x = Foo{ .field = optionalPtr(), }; - expect(x.field.?.* == 999); + try expect(x.field.?.* == 999); } const glob: i32 = 999; @@ -220,8 +220,8 @@ test "implicit cast fn call result to optional in field result" { field: ?*const i32, }; }; - S.entry(); - comptime S.entry(); + try S.entry(); + comptime try S.entry(); } 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" { test "function call with anon list literal" { const S = struct { - fn doTheTest() void { - consumeVec(.{ 9, 8, 7 }); + fn doTheTest() !void { + try consumeVec(.{ 9, 8, 7 }); } - fn consumeVec(vec: [3]f32) void { - expect(vec[0] == 9); - expect(vec[1] == 8); - expect(vec[2] == 7); + fn consumeVec(vec: [3]f32) !void { + try expect(vec[0] == 9); + try expect(vec[1] == 8); + try expect(vec[2] == 7); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "ability to give comptime types and non comptime types to same parameter" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var x: i32 = 1; - expect(foo(x) == 10); - expect(foo(i32) == 20); + try expect(foo(x) == 10); + try expect(foo(i32) == 20); } fn foo(arg: anytype) i32 { @@ -272,8 +272,8 @@ test "ability to give comptime types and non comptime types to same parameter" { return 9 + arg; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "function with inferred error set but returning no error" { @@ -282,5 +282,5 @@ test "function with inferred error set but returning no error" { }; const return_ty = @typeInfo(@TypeOf(S.foo)).Fn.return_type.?; - expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len); + try expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len); } diff --git a/test/stage1/behavior/fn_delegation.zig b/test/stage1/behavior/fn_delegation.zig index 57006805c8..72a72c0bdd 100644 --- a/test/stage1/behavior/fn_delegation.zig +++ b/test/stage1/behavior/fn_delegation.zig @@ -32,8 +32,8 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 { test "fn delegation" { const foo = Foo{}; - expect(foo.one() == 11); - expect(foo.two() == 12); - expect(foo.three() == 13); - expect(foo.four() == 14); + try expect(foo.one() == 11); + try expect(foo.two() == 12); + try expect(foo.three() == 13); + try expect(foo.four() == 14); } diff --git a/test/stage1/behavior/fn_in_struct_in_comptime.zig b/test/stage1/behavior/fn_in_struct_in_comptime.zig index 030693ac59..ee8e98ad1c 100644 --- a/test/stage1/behavior/fn_in_struct_in_comptime.zig +++ b/test/stage1/behavior/fn_in_struct_in_comptime.zig @@ -13,5 +13,5 @@ fn get_foo() fn (*u8) usize { test "define a function in an anonymous struct in comptime" { const foo = get_foo(); - expect(foo(@intToPtr(*u8, 12345)) == 12345); + try expect(foo(@intToPtr(*u8, 12345)) == 12345); } diff --git a/test/stage1/behavior/for.zig b/test/stage1/behavior/for.zig index c49c73802d..9f08d41246 100644 --- a/test/stage1/behavior/for.zig +++ b/test/stage1/behavior/for.zig @@ -27,12 +27,12 @@ test "for loop with pointer elem var" { var target: [source.len]u8 = undefined; mem.copy(u8, target[0..], source); mangleString(target[0..]); - expect(mem.eql(u8, &target, "bcdefgh")); + try expect(mem.eql(u8, &target, "bcdefgh")); for (source) |*c, i| - expect(@TypeOf(c) == *const u8); + try expect(@TypeOf(c) == *const u8); for (target) |*c, i| - expect(@TypeOf(c) == *u8); + try expect(@TypeOf(c) == *u8); } fn mangleString(s: []u8) void { @@ -75,15 +75,15 @@ test "basic for loop" { buf_index += 1; } - expect(mem.eql(u8, buffer[0..buf_index], &expected_result)); + try expect(mem.eql(u8, buffer[0..buf_index], &expected_result)); } test "break from outer for loop" { - testBreakOuter(); - comptime testBreakOuter(); + try testBreakOuter(); + comptime try testBreakOuter(); } -fn testBreakOuter() void { +fn testBreakOuter() !void { var array = "aoeu"; var count: usize = 0; outer: for (array) |_| { @@ -92,15 +92,15 @@ fn testBreakOuter() void { break :outer; } } - expect(count == 1); + try expect(count == 1); } test "continue outer for loop" { - testContinueOuter(); - comptime testContinueOuter(); + try testContinueOuter(); + comptime try testContinueOuter(); } -fn testContinueOuter() void { +fn testContinueOuter() !void { var array = "aoeu"; var counter: usize = 0; outer: for (array) |_| { @@ -109,28 +109,28 @@ fn testContinueOuter() void { continue :outer; } } - expect(counter == array.len); + try expect(counter == array.len); } test "2 break statements and an else" { const S = struct { - fn entry(t: bool, f: bool) void { + fn entry(t: bool, f: bool) !void { var buf: [10]u8 = undefined; var ok = false; ok = for (buf) |item| { if (f) break false; if (t) break true; } else false; - expect(ok); + try expect(ok); } }; - S.entry(true, false); - comptime S.entry(true, false); + try S.entry(true, false); + comptime try S.entry(true, false); } test "for with null and T peer types and inferred result location type" { const S = struct { - fn doTheTest(slice: []const u8) void { + fn doTheTest(slice: []const u8) !void { if (for (slice) |item| { if (item == 10) { break item; @@ -140,33 +140,33 @@ test "for with null and T peer types and inferred result location type" { } } }; - S.doTheTest(&[_]u8{ 1, 2 }); - comptime S.doTheTest(&[_]u8{ 1, 2 }); + try S.doTheTest(&[_]u8{ 1, 2 }); + comptime try S.doTheTest(&[_]u8{ 1, 2 }); } test "for copies its payload" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var x = [_]usize{ 1, 2, 3 }; for (x) |value, i| { // Modify the original array x[i] += 99; - expectEqual(value, i + 1); + try expectEqual(value, i + 1); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "for on slice with allowzero ptr" { const S = struct { - fn doTheTest(slice: []const u8) void { + fn doTheTest(slice: []const u8) !void { var ptr = @ptrCast([*]allowzero const u8, slice.ptr)[0..slice.len]; - for (ptr) |x, i| expect(x == i + 1); - for (ptr) |*x, i| expect(x.* == i + 1); + for (ptr) |x, i| try expect(x == i + 1); + for (ptr) |*x, i| try expect(x.* == i + 1); } }; - S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); - comptime S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); + try S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); + comptime try S.doTheTest(&[_]u8{ 1, 2, 3, 4 }); } diff --git a/test/stage1/behavior/generics.zig b/test/stage1/behavior/generics.zig index ee6496bcaa..2a4fabde45 100644 --- a/test/stage1/behavior/generics.zig +++ b/test/stage1/behavior/generics.zig @@ -4,9 +4,9 @@ const expect = testing.expect; const expectEqual = testing.expectEqual; test "simple generic fn" { - expect(max(i32, 3, -1) == 3); - expect(max(f32, 0.123, 0.456) == 0.456); - expect(add(2, 3) == 5); + try expect(max(i32, 3, -1) == 3); + try expect(max(f32, 0.123, 0.456) == 0.456); + try expect(add(2, 3) == 5); } fn max(comptime T: type, a: T, b: T) T { @@ -19,7 +19,7 @@ fn add(comptime a: i32, b: i32) i32 { const the_max = max(u32, 1234, 5678); test "compile time generic eval" { - expect(the_max == 5678); + try expect(the_max == 5678); } fn gimmeTheBigOne(a: u32, b: u32) u32 { @@ -35,19 +35,19 @@ fn sameButWithFloats(a: f64, b: f64) f64 { } test "fn with comptime args" { - expect(gimmeTheBigOne(1234, 5678) == 5678); - expect(shouldCallSameInstance(34, 12) == 34); - expect(sameButWithFloats(0.43, 0.49) == 0.49); + try expect(gimmeTheBigOne(1234, 5678) == 5678); + try expect(shouldCallSameInstance(34, 12) == 34); + try expect(sameButWithFloats(0.43, 0.49) == 0.49); } test "var params" { - expect(max_i32(12, 34) == 34); - expect(max_f64(1.2, 3.4) == 3.4); + try expect(max_i32(12, 34) == 34); + try expect(max_f64(1.2, 3.4) == 3.4); } comptime { - expect(max_i32(12, 34) == 34); - expect(max_f64(1.2, 3.4) == 3.4); + try expect(max_i32(12, 34) == 34); + try expect(max_f64(1.2, 3.4) == 3.4); } fn max_var(a: anytype, b: anytype) @TypeOf(a + b) { @@ -79,8 +79,8 @@ test "function with return type type" { var list2: List(i32) = undefined; list.length = 10; list2.length = 10; - expect(list.prealloc_items.len == 8); - expect(list2.prealloc_items.len == 8); + try expect(list.prealloc_items.len == 8); + try expect(list2.prealloc_items.len == 8); } test "generic struct" { @@ -92,9 +92,9 @@ test "generic struct" { .value = true, .next = null, }; - expect(a1.value == 13); - expect(a1.value == a1.getVal()); - expect(b1.getVal()); + try expect(a1.value == 13); + try expect(a1.value == a1.getVal()); + try expect(b1.getVal()); } fn GenNode(comptime T: type) type { return struct { @@ -107,7 +107,7 @@ fn GenNode(comptime T: type) type { } test "const decls in struct" { - expect(GenericDataThing(3).count_plus_one == 4); + try expect(GenericDataThing(3).count_plus_one == 4); } fn GenericDataThing(comptime count: isize) type { return struct { @@ -116,15 +116,15 @@ fn GenericDataThing(comptime count: isize) type { } test "use generic param in generic param" { - expect(aGenericFn(i32, 3, 4) == 7); + try expect(aGenericFn(i32, 3, 4) == 7); } fn aGenericFn(comptime T: type, comptime a: T, b: T) T { return a + b; } test "generic fn with implicit cast" { - expect(getFirstByte(u8, &[_]u8{13}) == 13); - expect(getFirstByte(u16, &[_]u16{ + try expect(getFirstByte(u8, &[_]u8{13}) == 13); + try expect(getFirstByte(u16, &[_]u16{ 0, 13, }) == 0); @@ -149,21 +149,21 @@ fn foo2(arg: anytype) bool { } test "array of generic fns" { - expect(foos[0](true)); - expect(!foos[1](true)); + try expect(foos[0](true)); + try expect(!foos[1](true)); } test "generic fn keeps non-generic parameter types" { const A = 128; const S = struct { - fn f(comptime T: type, s: []T) void { - expect(A != @typeInfo(@TypeOf(s)).Pointer.alignment); + fn f(comptime T: type, s: []T) !void { + try expect(A != @typeInfo(@TypeOf(s)).Pointer.alignment); } }; // The compiler monomorphizes `S.f` for `T=u8` on its first use, check that // `x` type not affect `s` parameter type. var x: [16]u8 align(A) = undefined; - S.f(u8, &x); + try S.f(u8, &x); } diff --git a/test/stage1/behavior/hasdecl.zig b/test/stage1/behavior/hasdecl.zig index f3bb9887fe..381e79760c 100644 --- a/test/stage1/behavior/hasdecl.zig +++ b/test/stage1/behavior/hasdecl.zig @@ -11,11 +11,11 @@ const Bar = struct { }; test "@hasDecl" { - expect(@hasDecl(Foo, "public_thing")); - expect(!@hasDecl(Foo, "private_thing")); - expect(!@hasDecl(Foo, "no_thing")); + try expect(@hasDecl(Foo, "public_thing")); + try expect(!@hasDecl(Foo, "private_thing")); + try expect(!@hasDecl(Foo, "no_thing")); - expect(@hasDecl(Bar, "hi")); - expect(@hasDecl(Bar, "blah")); - expect(!@hasDecl(Bar, "nope")); + try expect(@hasDecl(Bar, "hi")); + try expect(@hasDecl(Bar, "blah")); + try expect(!@hasDecl(Bar, "nope")); } diff --git a/test/stage1/behavior/hasfield.zig b/test/stage1/behavior/hasfield.zig index c179fedd56..81026273c0 100644 --- a/test/stage1/behavior/hasfield.zig +++ b/test/stage1/behavior/hasfield.zig @@ -8,10 +8,10 @@ test "@hasField" { pub const nope = 1; }; - expect(@hasField(struc, "a") == true); - expect(@hasField(struc, "b") == true); - expect(@hasField(struc, "non-existant") == false); - expect(@hasField(struc, "nope") == false); + try expect(@hasField(struc, "a") == true); + try expect(@hasField(struc, "b") == true); + try expect(@hasField(struc, "non-existant") == false); + try expect(@hasField(struc, "nope") == false); const unin = union { a: u64, @@ -19,10 +19,10 @@ test "@hasField" { pub const nope = 1; }; - expect(@hasField(unin, "a") == true); - expect(@hasField(unin, "b") == true); - expect(@hasField(unin, "non-existant") == false); - expect(@hasField(unin, "nope") == false); + try expect(@hasField(unin, "a") == true); + try expect(@hasField(unin, "b") == true); + try expect(@hasField(unin, "non-existant") == false); + try expect(@hasField(unin, "nope") == false); const enm = enum { a, @@ -30,8 +30,8 @@ test "@hasField" { pub const nope = 1; }; - expect(@hasField(enm, "a") == true); - expect(@hasField(enm, "b") == true); - expect(@hasField(enm, "non-existant") == false); - expect(@hasField(enm, "nope") == false); + try expect(@hasField(enm, "a") == true); + try expect(@hasField(enm, "b") == true); + try expect(@hasField(enm, "non-existant") == false); + try expect(@hasField(enm, "nope") == false); } diff --git a/test/stage1/behavior/if.zig b/test/stage1/behavior/if.zig index de8a29c76d..1951a9262a 100644 --- a/test/stage1/behavior/if.zig +++ b/test/stage1/behavior/if.zig @@ -26,7 +26,7 @@ fn firstEqlThird(a: i32, b: i32, c: i32) void { } test "else if expression" { - expect(elseIfExpressionF(1) == 1); + try expect(elseIfExpressionF(1) == 1); } fn elseIfExpressionF(c: u8) u8 { if (c == 0) { @@ -44,14 +44,14 @@ var global_with_err: anyerror!u32 = error.SomeError; test "unwrap mutable global var" { if (global_with_val) |v| { - expect(v == 0); + try expect(v == 0); } else |e| { unreachable; } if (global_with_err) |_| { unreachable; } else |e| { - expect(e == error.SomeError); + try expect(e == error.SomeError); } } @@ -63,7 +63,7 @@ test "labeled break inside comptime if inside runtime if" { break :blk @as(i32, 42); }; } - expect(answer == 42); + try expect(answer == 42); } test "const result loc, runtime if cond, else unreachable" { @@ -74,36 +74,36 @@ test "const result loc, runtime if cond, else unreachable" { var t = true; const x = if (t) Num.Two else unreachable; - expect(x == .Two); + try expect(x == .Two); } test "if prongs cast to expected type instead of peer type resolution" { const S = struct { - fn doTheTest(f: bool) void { + fn doTheTest(f: bool) !void { var x: i32 = 0; x = if (f) 1 else 2; - expect(x == 2); + try expect(x == 2); var b = true; const y: i32 = if (b) 1 else 2; - expect(y == 1); + try expect(y == 1); } }; - S.doTheTest(false); - comptime S.doTheTest(false); + try S.doTheTest(false); + comptime try S.doTheTest(false); } test "while copies its payload" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var tmp: ?i32 = 10; if (tmp) |value| { // Modify the original variable tmp = null; - expectEqual(@as(i32, 10), value); + try expectEqual(@as(i32, 10), value); } else unreachable; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/import.zig b/test/stage1/behavior/import.zig index 30655554bf..2b037637da 100644 --- a/test/stage1/behavior/import.zig +++ b/test/stage1/behavior/import.zig @@ -3,18 +3,18 @@ const expectEqual = @import("std").testing.expectEqual; const a_namespace = @import("import/a_namespace.zig"); test "call fn via namespace lookup" { - expectEqual(@as(i32, 1234), a_namespace.foo()); + try expectEqual(@as(i32, 1234), a_namespace.foo()); } test "importing the same thing gives the same import" { - expect(@import("std") == @import("std")); + try expect(@import("std") == @import("std")); } test "import in non-toplevel scope" { const S = struct { usingnamespace @import("import/a_namespace.zig"); }; - expectEqual(@as(i32, 1234), S.foo()); + try expectEqual(@as(i32, 1234), S.foo()); } test "import empty file" { diff --git a/test/stage1/behavior/incomplete_struct_param_tld.zig b/test/stage1/behavior/incomplete_struct_param_tld.zig index 77a3dfd221..a1e0672c7b 100644 --- a/test/stage1/behavior/incomplete_struct_param_tld.zig +++ b/test/stage1/behavior/incomplete_struct_param_tld.zig @@ -26,5 +26,5 @@ test "incomplete struct param top level declaration" { .c = C{ .x = 13 }, }, }; - expect(foo(a) == 13); + try expect(foo(a) == 13); } diff --git a/test/stage1/behavior/inttoptr.zig b/test/stage1/behavior/inttoptr.zig index b1780f93d6..de6e8e3a1e 100644 --- a/test/stage1/behavior/inttoptr.zig +++ b/test/stage1/behavior/inttoptr.zig @@ -1,7 +1,3 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const expect = std.testing.expect; - test "casting random address to function pointer" { randomAddressToFunction(); comptime randomAddressToFunction(); diff --git a/test/stage1/behavior/ir_block_deps.zig b/test/stage1/behavior/ir_block_deps.zig index 821079df79..aacb7b7658 100644 --- a/test/stage1/behavior/ir_block_deps.zig +++ b/test/stage1/behavior/ir_block_deps.zig @@ -16,6 +16,6 @@ fn getErrInt() anyerror!i32 { } test "ir block deps" { - expect((foo(1) catch unreachable) == 0); - expect((foo(2) catch unreachable) == 0); + try expect((foo(1) catch unreachable) == 0); + try expect((foo(2) catch unreachable) == 0); } diff --git a/test/stage1/behavior/math.zig b/test/stage1/behavior/math.zig index 32f4842702..e615c36551 100644 --- a/test/stage1/behavior/math.zig +++ b/test/stage1/behavior/math.zig @@ -7,71 +7,71 @@ const minInt = std.math.minInt; const mem = std.mem; test "division" { - testDivision(); - comptime testDivision(); + try testDivision(); + comptime try testDivision(); } -fn testDivision() void { - expect(div(u32, 13, 3) == 4); - expect(div(f16, 1.0, 2.0) == 0.5); - expect(div(f32, 1.0, 2.0) == 0.5); +fn testDivision() !void { + try expect(div(u32, 13, 3) == 4); + try expect(div(f16, 1.0, 2.0) == 0.5); + try expect(div(f32, 1.0, 2.0) == 0.5); - expect(divExact(u32, 55, 11) == 5); - expect(divExact(i32, -55, 11) == -5); - expect(divExact(f16, 55.0, 11.0) == 5.0); - expect(divExact(f16, -55.0, 11.0) == -5.0); - expect(divExact(f32, 55.0, 11.0) == 5.0); - expect(divExact(f32, -55.0, 11.0) == -5.0); + try expect(divExact(u32, 55, 11) == 5); + try expect(divExact(i32, -55, 11) == -5); + try expect(divExact(f16, 55.0, 11.0) == 5.0); + try expect(divExact(f16, -55.0, 11.0) == -5.0); + try expect(divExact(f32, 55.0, 11.0) == 5.0); + try expect(divExact(f32, -55.0, 11.0) == -5.0); - expect(divFloor(i32, 5, 3) == 1); - expect(divFloor(i32, -5, 3) == -2); - expect(divFloor(f16, 5.0, 3.0) == 1.0); - expect(divFloor(f16, -5.0, 3.0) == -2.0); - expect(divFloor(f32, 5.0, 3.0) == 1.0); - expect(divFloor(f32, -5.0, 3.0) == -2.0); - expect(divFloor(i32, -0x80000000, -2) == 0x40000000); - expect(divFloor(i32, 0, -0x80000000) == 0); - expect(divFloor(i32, -0x40000001, 0x40000000) == -2); - expect(divFloor(i32, -0x80000000, 1) == -0x80000000); - expect(divFloor(i32, 10, 12) == 0); - expect(divFloor(i32, -14, 12) == -2); - expect(divFloor(i32, -2, 12) == -1); + try expect(divFloor(i32, 5, 3) == 1); + try expect(divFloor(i32, -5, 3) == -2); + try expect(divFloor(f16, 5.0, 3.0) == 1.0); + try expect(divFloor(f16, -5.0, 3.0) == -2.0); + try expect(divFloor(f32, 5.0, 3.0) == 1.0); + try expect(divFloor(f32, -5.0, 3.0) == -2.0); + try expect(divFloor(i32, -0x80000000, -2) == 0x40000000); + try expect(divFloor(i32, 0, -0x80000000) == 0); + try expect(divFloor(i32, -0x40000001, 0x40000000) == -2); + try expect(divFloor(i32, -0x80000000, 1) == -0x80000000); + try expect(divFloor(i32, 10, 12) == 0); + try expect(divFloor(i32, -14, 12) == -2); + try expect(divFloor(i32, -2, 12) == -1); - expect(divTrunc(i32, 5, 3) == 1); - expect(divTrunc(i32, -5, 3) == -1); - expect(divTrunc(f16, 5.0, 3.0) == 1.0); - expect(divTrunc(f16, -5.0, 3.0) == -1.0); - expect(divTrunc(f32, 5.0, 3.0) == 1.0); - expect(divTrunc(f32, -5.0, 3.0) == -1.0); - expect(divTrunc(f64, 5.0, 3.0) == 1.0); - expect(divTrunc(f64, -5.0, 3.0) == -1.0); - expect(divTrunc(i32, 10, 12) == 0); - expect(divTrunc(i32, -14, 12) == -1); - expect(divTrunc(i32, -2, 12) == 0); + try expect(divTrunc(i32, 5, 3) == 1); + try expect(divTrunc(i32, -5, 3) == -1); + try expect(divTrunc(f16, 5.0, 3.0) == 1.0); + try expect(divTrunc(f16, -5.0, 3.0) == -1.0); + try expect(divTrunc(f32, 5.0, 3.0) == 1.0); + try expect(divTrunc(f32, -5.0, 3.0) == -1.0); + try expect(divTrunc(f64, 5.0, 3.0) == 1.0); + try expect(divTrunc(f64, -5.0, 3.0) == -1.0); + try expect(divTrunc(i32, 10, 12) == 0); + try expect(divTrunc(i32, -14, 12) == -1); + try expect(divTrunc(i32, -2, 12) == 0); - expect(mod(i32, 10, 12) == 10); - expect(mod(i32, -14, 12) == 10); - expect(mod(i32, -2, 12) == 10); + try expect(mod(i32, 10, 12) == 10); + try expect(mod(i32, -14, 12) == 10); + try expect(mod(i32, -2, 12) == 10); comptime { - expect( + try expect( 1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600, ); - expect( + try expect( @rem(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -177254337427586449086438229241342047632117600, ); - expect( + try expect( 1194735857077236777412821811143690633098347576 / 508740759824825164163191790951174292733114988 == 2, ); - expect( + try expect( @divTrunc(-1194735857077236777412821811143690633098347576, 508740759824825164163191790951174292733114988) == -2, ); - expect( + try expect( @divTrunc(1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == -2, ); - expect( + try expect( @divTrunc(-1194735857077236777412821811143690633098347576, -508740759824825164163191790951174292733114988) == 2, ); - expect( + try expect( 4126227191251978491697987544882340798050766755606969681711 % 10 == 1, ); } @@ -94,9 +94,9 @@ fn mod(comptime T: type, a: T, b: T) T { test "@addWithOverflow" { var result: u8 = undefined; - expect(@addWithOverflow(u8, 250, 100, &result)); - expect(!@addWithOverflow(u8, 100, 150, &result)); - expect(result == 250); + try expect(@addWithOverflow(u8, 250, 100, &result)); + try expect(!@addWithOverflow(u8, 100, 150, &result)); + try expect(result == 250); } // TODO test mulWithOverflow @@ -104,31 +104,31 @@ test "@addWithOverflow" { test "@shlWithOverflow" { var result: u16 = undefined; - expect(@shlWithOverflow(u16, 0b0010111111111111, 3, &result)); - expect(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result)); - expect(result == 0b1011111111111100); + try expect(@shlWithOverflow(u16, 0b0010111111111111, 3, &result)); + try expect(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result)); + try expect(result == 0b1011111111111100); } test "@*WithOverflow with u0 values" { var result: u0 = undefined; - expect(!@addWithOverflow(u0, 0, 0, &result)); - expect(!@subWithOverflow(u0, 0, 0, &result)); - expect(!@mulWithOverflow(u0, 0, 0, &result)); - expect(!@shlWithOverflow(u0, 0, 0, &result)); + try expect(!@addWithOverflow(u0, 0, 0, &result)); + try expect(!@subWithOverflow(u0, 0, 0, &result)); + try expect(!@mulWithOverflow(u0, 0, 0, &result)); + try expect(!@shlWithOverflow(u0, 0, 0, &result)); } test "@clz" { - testClz(); - comptime testClz(); + try testClz(); + comptime try testClz(); } -fn testClz() void { - expect(clz(u8, 0b10001010) == 0); - expect(clz(u8, 0b00001010) == 4); - expect(clz(u8, 0b00011010) == 3); - expect(clz(u8, 0b00000000) == 8); - expect(clz(u128, 0xffffffffffffffff) == 64); - expect(clz(u128, 0x10000000000000000) == 63); +fn testClz() !void { + try expect(clz(u8, 0b10001010) == 0); + try expect(clz(u8, 0b00001010) == 4); + try expect(clz(u8, 0b00011010) == 3); + try expect(clz(u8, 0b00000000) == 8); + try expect(clz(u128, 0xffffffffffffffff) == 64); + try expect(clz(u128, 0x10000000000000000) == 63); } fn clz(comptime T: type, x: T) usize { @@ -136,15 +136,15 @@ fn clz(comptime T: type, x: T) usize { } test "@ctz" { - testCtz(); - comptime testCtz(); + try testCtz(); + comptime try testCtz(); } -fn testCtz() void { - expect(ctz(u8, 0b10100000) == 5); - expect(ctz(u8, 0b10001010) == 1); - expect(ctz(u8, 0b00000000) == 8); - expect(ctz(u16, 0b00000000) == 16); +fn testCtz() !void { + try expect(ctz(u8, 0b10100000) == 5); + try expect(ctz(u8, 0b10001010) == 1); + try expect(ctz(u8, 0b00000000) == 8); + try expect(ctz(u16, 0b00000000) == 16); } fn ctz(comptime T: type, x: T) usize { @@ -154,109 +154,109 @@ fn ctz(comptime T: type, x: T) usize { test "assignment operators" { var i: u32 = 0; i += 5; - expect(i == 5); + try expect(i == 5); i -= 2; - expect(i == 3); + try expect(i == 3); i *= 20; - expect(i == 60); + try expect(i == 60); i /= 3; - expect(i == 20); + try expect(i == 20); i %= 11; - expect(i == 9); + try expect(i == 9); i <<= 1; - expect(i == 18); + try expect(i == 18); i >>= 2; - expect(i == 4); + try expect(i == 4); i = 6; i &= 5; - expect(i == 4); + try expect(i == 4); i ^= 6; - expect(i == 2); + try expect(i == 2); i = 6; i |= 3; - expect(i == 7); + try expect(i == 7); } test "three expr in a row" { - testThreeExprInARow(false, true); - comptime testThreeExprInARow(false, true); + try testThreeExprInARow(false, true); + comptime try testThreeExprInARow(false, true); } -fn testThreeExprInARow(f: bool, t: bool) void { - assertFalse(f or f or f); - assertFalse(t and t and f); - assertFalse(1 | 2 | 4 != 7); - assertFalse(3 ^ 6 ^ 8 != 13); - assertFalse(7 & 14 & 28 != 4); - assertFalse(9 << 1 << 2 != 9 << 3); - assertFalse(90 >> 1 >> 2 != 90 >> 3); - assertFalse(100 - 1 + 1000 != 1099); - assertFalse(5 * 4 / 2 % 3 != 1); - assertFalse(@as(i32, @as(i32, 5)) != 5); - assertFalse(!!false); - assertFalse(@as(i32, 7) != --(@as(i32, 7))); +fn testThreeExprInARow(f: bool, t: bool) !void { + try assertFalse(f or f or f); + try assertFalse(t and t and f); + try assertFalse(1 | 2 | 4 != 7); + try assertFalse(3 ^ 6 ^ 8 != 13); + try assertFalse(7 & 14 & 28 != 4); + try assertFalse(9 << 1 << 2 != 9 << 3); + try assertFalse(90 >> 1 >> 2 != 90 >> 3); + try assertFalse(100 - 1 + 1000 != 1099); + try assertFalse(5 * 4 / 2 % 3 != 1); + try assertFalse(@as(i32, @as(i32, 5)) != 5); + try assertFalse(!!false); + try assertFalse(@as(i32, 7) != --(@as(i32, 7))); } -fn assertFalse(b: bool) void { - expect(!b); +fn assertFalse(b: bool) !void { + try expect(!b); } test "const number literal" { const one = 1; const eleven = ten + one; - expect(eleven == 11); + try expect(eleven == 11); } const ten = 10; test "unsigned wrapping" { - testUnsignedWrappingEval(maxInt(u32)); - comptime testUnsignedWrappingEval(maxInt(u32)); + try testUnsignedWrappingEval(maxInt(u32)); + comptime try testUnsignedWrappingEval(maxInt(u32)); } -fn testUnsignedWrappingEval(x: u32) void { +fn testUnsignedWrappingEval(x: u32) !void { const zero = x +% 1; - expect(zero == 0); + try expect(zero == 0); const orig = zero -% 1; - expect(orig == maxInt(u32)); + try expect(orig == maxInt(u32)); } test "signed wrapping" { - testSignedWrappingEval(maxInt(i32)); - comptime testSignedWrappingEval(maxInt(i32)); + try testSignedWrappingEval(maxInt(i32)); + comptime try testSignedWrappingEval(maxInt(i32)); } -fn testSignedWrappingEval(x: i32) void { +fn testSignedWrappingEval(x: i32) !void { 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)); } test "signed negation wrapping" { - testSignedNegationWrappingEval(minInt(i16)); - comptime testSignedNegationWrappingEval(minInt(i16)); + try testSignedNegationWrappingEval(minInt(i16)); + comptime try testSignedNegationWrappingEval(minInt(i16)); } -fn testSignedNegationWrappingEval(x: i16) void { - expect(x == -32768); +fn testSignedNegationWrappingEval(x: i16) !void { + try expect(x == -32768); const neg = -%x; - expect(neg == -32768); + try expect(neg == -32768); } test "unsigned negation wrapping" { - testUnsignedNegationWrappingEval(1); - comptime testUnsignedNegationWrappingEval(1); + try testUnsignedNegationWrappingEval(1); + comptime try testUnsignedNegationWrappingEval(1); } -fn testUnsignedNegationWrappingEval(x: u16) void { - expect(x == 1); +fn testUnsignedNegationWrappingEval(x: u16) !void { + try expect(x == 1); const neg = -%x; - expect(neg == maxInt(u16)); + try expect(neg == maxInt(u16)); } test "unsigned 64-bit division" { - test_u64_div(); - comptime test_u64_div(); + try test_u64_div(); + comptime try test_u64_div(); } -fn test_u64_div() void { +fn test_u64_div() !void { const result = divWithResult(1152921504606846976, 34359738365); - expect(result.quotient == 33554432); - expect(result.remainder == 100663296); + try expect(result.quotient == 33554432); + try expect(result.remainder == 100663296); } fn divWithResult(a: u64, b: u64) DivResult { return DivResult{ @@ -270,62 +270,62 @@ const DivResult = struct { }; test "binary not" { - expect(comptime x: { + try expect(comptime x: { break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101; }); - expect(comptime x: { + try expect(comptime x: { break :x ~@as(u64, 2147483647) == 18446744071562067968; }); - testBinaryNot(0b1010101010101010); + try testBinaryNot(0b1010101010101010); } -fn testBinaryNot(x: u16) void { - expect(~x == 0b0101010101010101); +fn testBinaryNot(x: u16) !void { + try expect(~x == 0b0101010101010101); } test "small int addition" { var x: u2 = 0; - expect(x == 0); + try expect(x == 0); x += 1; - expect(x == 1); + try expect(x == 1); x += 1; - expect(x == 2); + try expect(x == 2); x += 1; - expect(x == 3); + try expect(x == 3); var result: @TypeOf(x) = 3; - expect(@addWithOverflow(@TypeOf(x), x, 1, &result)); + try expect(@addWithOverflow(@TypeOf(x), x, 1, &result)); - expect(result == 0); + try expect(result == 0); } test "float equality" { const x: f64 = 0.012; const y: f64 = x + 1.0; - testFloatEqualityImpl(x, y); - comptime testFloatEqualityImpl(x, y); + try testFloatEqualityImpl(x, y); + comptime try testFloatEqualityImpl(x, y); } -fn testFloatEqualityImpl(x: f64, y: f64) void { +fn testFloatEqualityImpl(x: f64, y: f64) !void { const y2 = x + 1.0; - expect(y == y2); + try expect(y == y2); } test "allow signed integer division/remainder when values are comptime known and positive or exact" { - expect(5 / 3 == 1); - expect(-5 / -3 == 1); - expect(-6 / 3 == -2); + try expect(5 / 3 == 1); + try expect(-5 / -3 == 1); + try expect(-6 / 3 == -2); - expect(5 % 3 == 2); - expect(-6 % 3 == 0); + try expect(5 % 3 == 2); + try expect(-6 % 3 == 0); } test "hex float literal parsing" { - comptime expect(0x1.0 == 1.0); + comptime try expect(0x1.0 == 1.0); } test "quad hex float literal parsing in range" { @@ -340,29 +340,29 @@ test "quad hex float literal parsing accurate" { // implied 1 is dropped, with an exponent of 0 (0x3fff) after biasing. const expected: u128 = 0x3fff1111222233334444555566667777; - expect(@bitCast(u128, a) == expected); + try expect(@bitCast(u128, a) == expected); // non-normalized const b: f128 = 0x11.111222233334444555566667777p-4; - expect(@bitCast(u128, b) == expected); + try expect(@bitCast(u128, b) == expected); const S = struct { - fn doTheTest() void { + fn doTheTest() !void { { var f: f128 = 0x1.2eab345678439abcdefea56782346p+5; - expect(@bitCast(u128, f) == 0x40042eab345678439abcdefea5678234); + try expect(@bitCast(u128, f) == 0x40042eab345678439abcdefea5678234); } { var f: f128 = 0x1.edcb34a235253948765432134674fp-1; - expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134674); + try expect(@bitCast(u128, f) == 0x3ffeedcb34a235253948765432134674); } { var f: f128 = 0x1.353e45674d89abacc3a2ebf3ff4ffp-50; - expect(@bitCast(u128, f) == 0x3fcd353e45674d89abacc3a2ebf3ff50); + try expect(@bitCast(u128, f) == 0x3fcd353e45674d89abacc3a2ebf3ff50); } { var f: f128 = 0x1.ed8764648369535adf4be3214567fp-9; - expect(@bitCast(u128, f) == 0x3ff6ed8764648369535adf4be3214568); + try expect(@bitCast(u128, f) == 0x3ff6ed8764648369535adf4be3214568); } const exp2ft = [_]f64{ 0x1.6a09e667f3bcdp-1, @@ -417,40 +417,40 @@ test "quad hex float literal parsing accurate" { }; for (exp2ft) |x, i| { - expect(@bitCast(u64, x) == answers[i]); + try expect(@bitCast(u64, x) == answers[i]); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "underscore separator parsing" { - expect(0_0_0_0 == 0); - expect(1_234_567 == 1234567); - expect(001_234_567 == 1234567); - expect(0_0_1_2_3_4_5_6_7 == 1234567); + try expect(0_0_0_0 == 0); + try expect(1_234_567 == 1234567); + try expect(001_234_567 == 1234567); + try expect(0_0_1_2_3_4_5_6_7 == 1234567); - expect(0b0_0_0_0 == 0); - expect(0b1010_1010 == 0b10101010); - expect(0b0000_1010_1010 == 0b10101010); - expect(0b1_0_1_0_1_0_1_0 == 0b10101010); + try expect(0b0_0_0_0 == 0); + try expect(0b1010_1010 == 0b10101010); + try expect(0b0000_1010_1010 == 0b10101010); + try expect(0b1_0_1_0_1_0_1_0 == 0b10101010); - expect(0o0_0_0_0 == 0); - expect(0o1010_1010 == 0o10101010); - expect(0o0000_1010_1010 == 0o10101010); - expect(0o1_0_1_0_1_0_1_0 == 0o10101010); + try expect(0o0_0_0_0 == 0); + try expect(0o1010_1010 == 0o10101010); + try expect(0o0000_1010_1010 == 0o10101010); + try expect(0o1_0_1_0_1_0_1_0 == 0o10101010); - expect(0x0_0_0_0 == 0); - expect(0x1010_1010 == 0x10101010); - expect(0x0000_1010_1010 == 0x10101010); - expect(0x1_0_1_0_1_0_1_0 == 0x10101010); + try expect(0x0_0_0_0 == 0); + try expect(0x1010_1010 == 0x10101010); + try expect(0x0000_1010_1010 == 0x10101010); + try expect(0x1_0_1_0_1_0_1_0 == 0x10101010); - expect(123_456.789_000e1_0 == 123456.789000e10); - expect(0_1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10); + try expect(123_456.789_000e1_0 == 123456.789000e10); + try expect(0_1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10); - expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10); - 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); + try expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10); + 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); } test "hex float literal within range" { @@ -460,73 +460,73 @@ test "hex float literal within range" { } test "truncating shift left" { - testShlTrunc(maxInt(u16)); - comptime testShlTrunc(maxInt(u16)); + try testShlTrunc(maxInt(u16)); + comptime try testShlTrunc(maxInt(u16)); } -fn testShlTrunc(x: u16) void { +fn testShlTrunc(x: u16) !void { const shifted = x << 1; - expect(shifted == 65534); + try expect(shifted == 65534); } test "truncating shift right" { - testShrTrunc(maxInt(u16)); - comptime testShrTrunc(maxInt(u16)); + try testShrTrunc(maxInt(u16)); + comptime try testShrTrunc(maxInt(u16)); } -fn testShrTrunc(x: u16) void { +fn testShrTrunc(x: u16) !void { const shifted = x >> 1; - expect(shifted == 32767); + try expect(shifted == 32767); } test "exact shift left" { - testShlExact(0b00110101); - comptime testShlExact(0b00110101); + try testShlExact(0b00110101); + comptime try testShlExact(0b00110101); } -fn testShlExact(x: u8) void { +fn testShlExact(x: u8) !void { const shifted = @shlExact(x, 2); - expect(shifted == 0b11010100); + try expect(shifted == 0b11010100); } test "exact shift right" { - testShrExact(0b10110100); - comptime testShrExact(0b10110100); + try testShrExact(0b10110100); + comptime try testShrExact(0b10110100); } -fn testShrExact(x: u8) void { +fn testShrExact(x: u8) !void { const shifted = @shrExact(x, 2); - expect(shifted == 0b00101101); + try expect(shifted == 0b00101101); } test "shift left/right on u0 operand" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var x: u0 = 0; var y: u0 = 0; - expectEqual(@as(u0, 0), x << 0); - expectEqual(@as(u0, 0), x >> 0); - expectEqual(@as(u0, 0), x << y); - expectEqual(@as(u0, 0), x >> y); - expectEqual(@as(u0, 0), @shlExact(x, 0)); - expectEqual(@as(u0, 0), @shrExact(x, 0)); - expectEqual(@as(u0, 0), @shlExact(x, y)); - expectEqual(@as(u0, 0), @shrExact(x, y)); + try expectEqual(@as(u0, 0), x << 0); + try expectEqual(@as(u0, 0), x >> 0); + try expectEqual(@as(u0, 0), x << y); + try expectEqual(@as(u0, 0), x >> y); + try expectEqual(@as(u0, 0), @shlExact(x, 0)); + try expectEqual(@as(u0, 0), @shrExact(x, 0)); + try expectEqual(@as(u0, 0), @shlExact(x, y)); + try expectEqual(@as(u0, 0), @shrExact(x, y)); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "comptime_int addition" { comptime { - expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950); - expect(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380); + try expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950); + try expect(594491908217841670578297176641415611445982232488944558774612 + 390603545391089362063884922208143568023166603618446395589768 == 985095453608931032642182098849559179469148836107390954364380); } } test "comptime_int multiplication" { comptime { - expect( + try expect( 45960427431263824329884196484953148229 * 128339149605334697009938835852565949723 == 5898522172026096622534201617172456926982464453350084962781392314016180490567, ); - expect( + try expect( 594491908217841670578297176641415611445982232488944558774612 * 390603545391089362063884922208143568023166603618446395589768 == 232210647056203049913662402532976186578842425262306016094292237500303028346593132411865381225871291702600263463125370016, ); } @@ -534,7 +534,7 @@ test "comptime_int multiplication" { test "comptime_int shifting" { comptime { - expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000); + try expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000); } } @@ -542,16 +542,16 @@ test "comptime_int multi-limb shift and mask" { comptime { var a = 0xefffffffa0000001eeeeeeefaaaaaaab; - expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab); + try expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab); a >>= 32; - expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef); + try expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef); a >>= 32; - expect(@as(u32, a & 0xffffffff) == 0xa0000001); + try expect(@as(u32, a & 0xffffffff) == 0xa0000001); a >>= 32; - expect(@as(u32, a & 0xffffffff) == 0xefffffff); + try expect(@as(u32, a & 0xffffffff) == 0xefffffff); a >>= 32; - expect(a == 0); + try expect(a == 0); } } @@ -559,227 +559,227 @@ test "comptime_int multi-limb partial shift right" { comptime { var a = 0x1ffffffffeeeeeeee; a >>= 16; - expect(a == 0x1ffffffffeeee); + try expect(a == 0x1ffffffffeeee); } } test "xor" { - test_xor(); - comptime test_xor(); + try test_xor(); + comptime try test_xor(); } -fn test_xor() void { - expect(0xFF ^ 0x00 == 0xFF); - expect(0xF0 ^ 0x0F == 0xFF); - expect(0xFF ^ 0xF0 == 0x0F); - expect(0xFF ^ 0x0F == 0xF0); - expect(0xFF ^ 0xFF == 0x00); +fn test_xor() !void { + try expect(0xFF ^ 0x00 == 0xFF); + try expect(0xF0 ^ 0x0F == 0xFF); + try expect(0xFF ^ 0xF0 == 0x0F); + try expect(0xFF ^ 0x0F == 0xF0); + try expect(0xFF ^ 0xFF == 0x00); } test "comptime_int xor" { comptime { - expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x0000000000000000FFFFFFFFFFFFFFFF); - expect(0x0000000000000000FFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFF0000000000000000); - expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000000000000000000000000000); - expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0x00000000FFFFFFFF00000000FFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000FFFFFFFF00000000FFFFFFFF); - expect(0x00000000FFFFFFFF00000000FFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFF00000000FFFFFFFF00000000); + try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0x00000000000000000000000000000000 == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0x0000000000000000FFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try expect(0xFFFFFFFFFFFFFFFF0000000000000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x0000000000000000FFFFFFFFFFFFFFFF); + try expect(0x0000000000000000FFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFFFFFFFFFF0000000000000000); + try expect(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000000000000000000000000000); + try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0x00000000FFFFFFFF00000000FFFFFFFF == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try expect(0xFFFFFFFF00000000FFFFFFFF00000000 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0x00000000FFFFFFFF00000000FFFFFFFF); + try expect(0x00000000FFFFFFFF00000000FFFFFFFF ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0xFFFFFFFF00000000FFFFFFFF00000000); } } test "f128" { - test_f128(); - comptime test_f128(); + try test_f128(); + comptime try test_f128(); } fn make_f128(x: f128) f128 { return x; } -fn test_f128() void { - expect(@sizeOf(f128) == 16); - expect(make_f128(1.0) == 1.0); - expect(make_f128(1.0) != 1.1); - expect(make_f128(1.0) > 0.9); - expect(make_f128(1.0) >= 0.9); - expect(make_f128(1.0) >= 1.0); - should_not_be_zero(1.0); +fn test_f128() !void { + try expect(@sizeOf(f128) == 16); + try expect(make_f128(1.0) == 1.0); + try expect(make_f128(1.0) != 1.1); + try expect(make_f128(1.0) > 0.9); + try expect(make_f128(1.0) >= 0.9); + try expect(make_f128(1.0) >= 1.0); + try should_not_be_zero(1.0); } -fn should_not_be_zero(x: f128) void { - expect(x != 0.0); +fn should_not_be_zero(x: f128) !void { + try expect(x != 0.0); } test "comptime float rem int" { comptime { var x = @as(f32, 1) % 2; - expect(x == 1.0); + try expect(x == 1.0); } } test "remainder division" { - comptime remdiv(f16); - comptime remdiv(f32); - comptime remdiv(f64); - comptime remdiv(f128); - remdiv(f16); - remdiv(f64); - remdiv(f128); + comptime try remdiv(f16); + comptime try remdiv(f32); + comptime try remdiv(f64); + comptime try remdiv(f128); + try remdiv(f16); + try remdiv(f64); + try remdiv(f128); } -fn remdiv(comptime T: type) void { - expect(@as(T, 1) == @as(T, 1) % @as(T, 2)); - expect(@as(T, 1) == @as(T, 7) % @as(T, 3)); +fn remdiv(comptime T: type) !void { + try expect(@as(T, 1) == @as(T, 1) % @as(T, 2)); + try expect(@as(T, 1) == @as(T, 7) % @as(T, 3)); } test "@sqrt" { - testSqrt(f64, 12.0); - comptime testSqrt(f64, 12.0); - testSqrt(f32, 13.0); - comptime testSqrt(f32, 13.0); - testSqrt(f16, 13.0); - comptime testSqrt(f16, 13.0); + try testSqrt(f64, 12.0); + comptime try testSqrt(f64, 12.0); + try testSqrt(f32, 13.0); + comptime try testSqrt(f32, 13.0); + try testSqrt(f16, 13.0); + comptime try testSqrt(f16, 13.0); const x = 14.0; const y = x * x; const z = @sqrt(y); - comptime expect(z == x); + comptime try expect(z == x); } -fn testSqrt(comptime T: type, x: T) void { - expect(@sqrt(x * x) == x); +fn testSqrt(comptime T: type, x: T) !void { + try expect(@sqrt(x * x) == x); } test "@fabs" { - testFabs(f128, 12.0); - comptime testFabs(f128, 12.0); - testFabs(f64, 12.0); - comptime testFabs(f64, 12.0); - testFabs(f32, 12.0); - comptime testFabs(f32, 12.0); - testFabs(f16, 12.0); - comptime testFabs(f16, 12.0); + try testFabs(f128, 12.0); + comptime try testFabs(f128, 12.0); + try testFabs(f64, 12.0); + comptime try testFabs(f64, 12.0); + try testFabs(f32, 12.0); + comptime try testFabs(f32, 12.0); + try testFabs(f16, 12.0); + comptime try testFabs(f16, 12.0); const x = 14.0; const y = -x; const z = @fabs(y); - comptime expectEqual(x, z); + comptime try expectEqual(x, z); } -fn testFabs(comptime T: type, x: T) void { +fn testFabs(comptime T: type, x: T) !void { const y = -x; const z = @fabs(y); - expectEqual(x, z); + try expectEqual(x, z); } test "@floor" { // FIXME: Generates a floorl function call // testFloor(f128, 12.0); - comptime testFloor(f128, 12.0); - testFloor(f64, 12.0); - comptime testFloor(f64, 12.0); - testFloor(f32, 12.0); - comptime testFloor(f32, 12.0); - testFloor(f16, 12.0); - comptime testFloor(f16, 12.0); + comptime try testFloor(f128, 12.0); + try testFloor(f64, 12.0); + comptime try testFloor(f64, 12.0); + try testFloor(f32, 12.0); + comptime try testFloor(f32, 12.0); + try testFloor(f16, 12.0); + comptime try testFloor(f16, 12.0); const x = 14.0; const y = x + 0.7; const z = @floor(y); - comptime expectEqual(x, z); + comptime try expectEqual(x, z); } -fn testFloor(comptime T: type, x: T) void { +fn testFloor(comptime T: type, x: T) !void { const y = x + 0.6; const z = @floor(y); - expectEqual(x, z); + try expectEqual(x, z); } test "@ceil" { // FIXME: Generates a ceill function call //testCeil(f128, 12.0); - comptime testCeil(f128, 12.0); - testCeil(f64, 12.0); - comptime testCeil(f64, 12.0); - testCeil(f32, 12.0); - comptime testCeil(f32, 12.0); - testCeil(f16, 12.0); - comptime testCeil(f16, 12.0); + comptime try testCeil(f128, 12.0); + try testCeil(f64, 12.0); + comptime try testCeil(f64, 12.0); + try testCeil(f32, 12.0); + comptime try testCeil(f32, 12.0); + try testCeil(f16, 12.0); + comptime try testCeil(f16, 12.0); const x = 14.0; const y = x - 0.7; const z = @ceil(y); - comptime expectEqual(x, z); + comptime try expectEqual(x, z); } -fn testCeil(comptime T: type, x: T) void { +fn testCeil(comptime T: type, x: T) !void { const y = x - 0.8; const z = @ceil(y); - expectEqual(x, z); + try expectEqual(x, z); } test "@trunc" { // FIXME: Generates a truncl function call //testTrunc(f128, 12.0); - comptime testTrunc(f128, 12.0); - testTrunc(f64, 12.0); - comptime testTrunc(f64, 12.0); - testTrunc(f32, 12.0); - comptime testTrunc(f32, 12.0); - testTrunc(f16, 12.0); - comptime testTrunc(f16, 12.0); + comptime try testTrunc(f128, 12.0); + try testTrunc(f64, 12.0); + comptime try testTrunc(f64, 12.0); + try testTrunc(f32, 12.0); + comptime try testTrunc(f32, 12.0); + try testTrunc(f16, 12.0); + comptime try testTrunc(f16, 12.0); const x = 14.0; const y = x + 0.7; const z = @trunc(y); - comptime expectEqual(x, z); + comptime try expectEqual(x, z); } -fn testTrunc(comptime T: type, x: T) void { +fn testTrunc(comptime T: type, x: T) !void { { const y = x + 0.8; const z = @trunc(y); - expectEqual(x, z); + try expectEqual(x, z); } { const y = -x - 0.8; const z = @trunc(y); - expectEqual(-x, z); + try expectEqual(-x, z); } } test "@round" { // FIXME: Generates a roundl function call //testRound(f128, 12.0); - comptime testRound(f128, 12.0); - testRound(f64, 12.0); - comptime testRound(f64, 12.0); - testRound(f32, 12.0); - comptime testRound(f32, 12.0); - testRound(f16, 12.0); - comptime testRound(f16, 12.0); + comptime try testRound(f128, 12.0); + try testRound(f64, 12.0); + comptime try testRound(f64, 12.0); + try testRound(f32, 12.0); + comptime try testRound(f32, 12.0); + try testRound(f16, 12.0); + comptime try testRound(f16, 12.0); const x = 14.0; const y = x + 0.4; const z = @round(y); - comptime expectEqual(x, z); + comptime try expectEqual(x, z); } -fn testRound(comptime T: type, x: T) void { +fn testRound(comptime T: type, x: T) !void { const y = x - 0.5; const z = @round(y); - expectEqual(x, z); + try expectEqual(x, z); } test "comptime_int param and return" { const a = comptimeAdd(35361831660712422535336160538497375248, 101752735581729509668353361206450473702); - expect(a == 137114567242441932203689521744947848950); + try expect(a == 137114567242441932203689521744947848950); const b = comptimeAdd(594491908217841670578297176641415611445982232488944558774612, 390603545391089362063884922208143568023166603618446395589768); - expect(b == 985095453608931032642182098849559179469148836107390954364380); + try expect(b == 985095453608931032642182098849559179469148836107390954364380); } 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 test "vector integer addition" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var a: std.meta.Vector(4, i32) = [_]i32{ 1, 2, 3, 4 }; var b: std.meta.Vector(4, i32) = [_]i32{ 5, 6, 7, 8 }; var result = a + b; var result_array: [4]i32 = result; const expected = [_]i32{ 6, 8, 10, 12 }; - expectEqualSlices(i32, &expected, &result_array); + try expectEqualSlices(i32, &expected, &result_array); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "NaN comparison" { - testNanEqNan(f16); - testNanEqNan(f32); - testNanEqNan(f64); - testNanEqNan(f128); - comptime testNanEqNan(f16); - comptime testNanEqNan(f32); - comptime testNanEqNan(f64); - comptime testNanEqNan(f128); + try testNanEqNan(f16); + try testNanEqNan(f32); + try testNanEqNan(f64); + try testNanEqNan(f128); + comptime try testNanEqNan(f16); + comptime try testNanEqNan(f32); + comptime try testNanEqNan(f64); + comptime try testNanEqNan(f128); } -fn testNanEqNan(comptime F: type) void { +fn testNanEqNan(comptime F: type) !void { var nan1 = std.math.nan(F); var nan2 = std.math.nan(F); - expect(nan1 != nan2); - expect(!(nan1 == nan2)); - expect(!(nan1 > nan2)); - expect(!(nan1 >= nan2)); - expect(!(nan1 < nan2)); - expect(!(nan1 <= nan2)); + try expect(nan1 != nan2); + try expect(!(nan1 == nan2)); + try expect(!(nan1 > nan2)); + try expect(!(nan1 >= nan2)); + try expect(!(nan1 < nan2)); + try expect(!(nan1 <= nan2)); } test "128-bit multiplication" { var a: i128 = 3; var b: i128 = 2; var c = a * b; - expect(c == 6); + try expect(c == 6); } test "vector comparison" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var a: std.meta.Vector(6, i32) = [_]i32{ 1, 3, -1, 5, 7, 9 }; var b: std.meta.Vector(6, i32) = [_]i32{ -1, 3, 0, 6, 10, -10 }; - expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false })); - expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false })); - expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false })); - expect(mem.eql(bool, &@as([6]bool, a != b), &[_]bool{ true, false, true, true, true, true })); - expect(mem.eql(bool, &@as([6]bool, a > b), &[_]bool{ true, false, false, false, false, true })); - expect(mem.eql(bool, &@as([6]bool, a >= b), &[_]bool{ true, true, false, false, false, true })); + try expect(mem.eql(bool, &@as([6]bool, a < b), &[_]bool{ false, false, true, true, true, false })); + try expect(mem.eql(bool, &@as([6]bool, a <= b), &[_]bool{ false, true, true, true, true, false })); + try expect(mem.eql(bool, &@as([6]bool, a == b), &[_]bool{ false, true, false, false, false, false })); + try expect(mem.eql(bool, &@as([6]bool, a != b), &[_]bool{ true, false, true, true, true, true })); + try expect(mem.eql(bool, &@as([6]bool, a > b), &[_]bool{ true, false, false, false, false, true })); + try expect(mem.eql(bool, &@as([6]bool, a >= b), &[_]bool{ true, true, false, false, false, true })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "compare undefined literal with comptime_int" { var x = undefined == 1; // x is now undefined with type bool x = true; - expect(x); + try expect(x); } test "signed zeros are represented properly" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { inline for ([_]type{ f16, f32, f64, f128 }) |T| { const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits); var as_fp_val = -@as(T, 0.0); var as_uint_val = @bitCast(ST, as_fp_val); // Ensure the sign bit is set. - expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1); + try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/misc.zig b/test/stage1/behavior/misc.zig index 850622c5ba..0300afcdea 100644 --- a/test/stage1/behavior/misc.zig +++ b/test/stage1/behavior/misc.zig @@ -25,18 +25,18 @@ test "call disabled extern fn" { } test "short circuit" { - testShortCircuit(false, true); - comptime testShortCircuit(false, true); + try testShortCircuit(false, true); + comptime try testShortCircuit(false, true); } -fn testShortCircuit(f: bool, t: bool) void { +fn testShortCircuit(f: bool, t: bool) !void { var hit_1 = f; var hit_2 = f; var hit_3 = f; var hit_4 = f; if (t or x: { - expect(f); + try expect(f); break :x f; }) { hit_1 = t; @@ -45,31 +45,31 @@ fn testShortCircuit(f: bool, t: bool) void { hit_2 = t; break :x f; }) { - expect(f); + try expect(f); } if (t and x: { hit_3 = t; break :x f; }) { - expect(f); + try expect(f); } if (f and x: { - expect(f); + try expect(f); break :x f; }) { - expect(f); + try expect(f); } else { hit_4 = t; } - expect(hit_1); - expect(hit_2); - expect(hit_3); - expect(hit_4); + try expect(hit_1); + try expect(hit_2); + try expect(hit_3); + try expect(hit_4); } test "truncate" { - expect(testTruncate(0x10fd) == 0xfd); + try expect(testTruncate(0x10fd) == 0xfd); } fn testTruncate(x: u32) u8 { return @truncate(u8, x); @@ -80,16 +80,16 @@ fn first4KeysOfHomeRow() []const u8 { } test "return string from function" { - expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu")); + try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu")); } const g1: i32 = 1233 + 1; var g2: i32 = 0; test "global variables" { - expect(g2 == 0); + try expect(g2 == 0); g2 = g1; - expect(g2 == 1234); + try expect(g2 == 1234); } test "memcpy and memset intrinsics" { @@ -106,7 +106,7 @@ test "builtin static eval" { const x: i32 = comptime x: { break :x 1 + 2 + 3; }; - expect(x == comptime 6); + try expect(x == comptime 6); } test "slicing" { @@ -127,7 +127,7 @@ test "slicing" { test "constant equal function pointers" { const alias = emptyFn; - expect(comptime x: { + try expect(comptime x: { break :x emptyFn == alias; }); } @@ -135,25 +135,25 @@ test "constant equal function pointers" { fn emptyFn() void {} test "hex escape" { - expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello")); + try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello")); } test "string concatenation" { - expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); + try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED")); } test "array mult operator" { - expect(mem.eql(u8, "ab" ** 5, "ababababab")); + try expect(mem.eql(u8, "ab" ** 5, "ababababab")); } test "string escapes" { - expect(mem.eql(u8, "\"", "\x22")); - expect(mem.eql(u8, "\'", "\x27")); - expect(mem.eql(u8, "\n", "\x0a")); - expect(mem.eql(u8, "\r", "\x0d")); - expect(mem.eql(u8, "\t", "\x09")); - expect(mem.eql(u8, "\\", "\x5c")); - expect(mem.eql(u8, "\u{1234}\u{069}\u{1}", "\xe1\x88\xb4\x69\x01")); + try expect(mem.eql(u8, "\"", "\x22")); + try expect(mem.eql(u8, "\'", "\x27")); + try expect(mem.eql(u8, "\n", "\x0a")); + try expect(mem.eql(u8, "\r", "\x0d")); + try expect(mem.eql(u8, "\t", "\x09")); + try expect(mem.eql(u8, "\\", "\x5c")); + try expect(mem.eql(u8, "\u{1234}\u{069}\u{1}", "\xe1\x88\xb4\x69\x01")); } test "multiline string" { @@ -163,7 +163,7 @@ test "multiline string" { \\three ; const s2 = "one\ntwo)\nthree"; - expect(mem.eql(u8, s1, s2)); + try expect(mem.eql(u8, s1, s2)); } test "multiline string comments at start" { @@ -173,7 +173,7 @@ test "multiline string comments at start" { \\three ; const s2 = "two)\nthree"; - expect(mem.eql(u8, s1, s2)); + try expect(mem.eql(u8, s1, s2)); } test "multiline string comments at end" { @@ -183,7 +183,7 @@ test "multiline string comments at end" { //\\three ; const s2 = "one\ntwo)"; - expect(mem.eql(u8, s1, s2)); + try expect(mem.eql(u8, s1, s2)); } test "multiline string comments in middle" { @@ -193,7 +193,7 @@ test "multiline string comments in middle" { \\three ; const s2 = "one\nthree"; - expect(mem.eql(u8, s1, s2)); + try expect(mem.eql(u8, s1, s2)); } test "multiline string comments at multiple places" { @@ -205,7 +205,7 @@ test "multiline string comments at multiple places" { \\five ; const s2 = "one\nthree\nfive"; - expect(mem.eql(u8, s1, s2)); + try expect(mem.eql(u8, s1, s2)); } test "multiline C string" { @@ -215,11 +215,11 @@ test "multiline C string" { \\three ; const s2 = "one\ntwo)\nthree"; - expect(std.cstr.cmp(s1, s2) == 0); + try expect(std.cstr.cmp(s1, s2) == 0); } test "type equality" { - expect(*const u8 != *u8); + try expect(*const u8 != *u8); } const global_a: i32 = 1234; @@ -227,7 +227,7 @@ const global_b: *const i32 = &global_a; const global_c: *const f32 = @ptrCast(*const f32, global_b); test "compile time global reinterpret" { const d = @ptrCast(*const i32, global_c); - expect(d.* == 1234); + try expect(d.* == 1234); } test "explicit cast maybe pointers" { @@ -253,8 +253,8 @@ test "cast undefined" { fn testCastUndefined(x: []const u8) void {} test "cast small unsigned to larger signed" { - expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200)); - expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999)); + try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200)); + try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999)); } fn castSmallUnsignedToLargerSigned1(x: u8) i16 { return x; @@ -264,7 +264,7 @@ fn castSmallUnsignedToLargerSigned2(x: u16) i64 { } test "implicit cast after unreachable" { - expect(outer() == 1234); + try expect(outer() == 1234); } fn inner() i32 { return 1234; @@ -279,13 +279,13 @@ test "pointer dereferencing" { y.* += 1; - expect(x == 4); - expect(y.* == 4); + try expect(x == 4); + try expect(y.* == 4); } test "call result of if else expression" { - expect(mem.eql(u8, f2(true), "a")); - expect(mem.eql(u8, f2(false), "b")); + try expect(mem.eql(u8, f2(true), "a")); + try expect(mem.eql(u8, f2(false), "b")); } fn f2(x: bool) []const u8 { return (if (x) fA else fB)(); @@ -305,8 +305,8 @@ test "const expression eval handling of variables" { } test "constant enum initialization with differing sizes" { - test3_1(test3_foo); - test3_2(test3_bar); + try test3_1(test3_foo); + try test3_2(test3_bar); } const Test3Foo = union(enum) { One: void, @@ -324,41 +324,41 @@ const test3_foo = Test3Foo{ }, }; const test3_bar = Test3Foo{ .Two = 13 }; -fn test3_1(f: Test3Foo) void { +fn test3_1(f: Test3Foo) !void { switch (f) { Test3Foo.Three => |pt| { - expect(pt.x == 3); - expect(pt.y == 4); + try expect(pt.x == 3); + try expect(pt.y == 4); }, else => unreachable, } } -fn test3_2(f: Test3Foo) void { +fn test3_2(f: Test3Foo) !void { switch (f) { Test3Foo.Two => |x| { - expect(x == 13); + try expect(x == 13); }, else => unreachable, } } test "character literals" { - expect('\'' == single_quote); + try expect('\'' == single_quote); } const single_quote = '\''; test "take address of parameter" { - testTakeAddressOfParameter(12.34); + try testTakeAddressOfParameter(12.34); } -fn testTakeAddressOfParameter(f: f32) void { +fn testTakeAddressOfParameter(f: f32) !void { const f_ptr = &f; - expect(f_ptr.* == 12.34); + try expect(f_ptr.* == 12.34); } test "pointer comparison" { const a = @as([]const u8, "a"); const b = &a; - expect(ptrEql(b, b)); + try expect(ptrEql(b, b)); } fn ptrEql(a: *const []const u8, b: *const []const u8) bool { return a == b; @@ -368,19 +368,19 @@ test "string concatenation" { const a = "OK" ++ " IT " ++ "WORKED"; const b = "OK IT WORKED"; - comptime expect(@TypeOf(a) == *const [12:0]u8); - comptime expect(@TypeOf(b) == *const [12:0]u8); + comptime try expect(@TypeOf(a) == *const [12:0]u8); + comptime try expect(@TypeOf(b) == *const [12:0]u8); const len = mem.len(b); const len_with_null = len + 1; { var i: u32 = 0; while (i < len_with_null) : (i += 1) { - expect(a[i] == b[i]); + try expect(a[i] == b[i]); } } - expect(a[len] == 0); - expect(b[len] == 0); + try expect(a[len] == 0); + try expect(b[len] == 0); } test "pointer to void return type" { @@ -397,7 +397,7 @@ fn testPointerToVoidReturnType2() *const void { test "non const ptr to aliased type" { const int = i32; - expect(?*int == ?*i32); + try expect(?*int == ?*i32); } test "array 2D const double ptr" { @@ -405,13 +405,13 @@ test "array 2D const double ptr" { [_]f32{1.0}, [_]f32{2.0}, }; - testArray2DConstDoublePtr(&rect_2d_vertexes[0][0]); + try testArray2DConstDoublePtr(&rect_2d_vertexes[0][0]); } -fn testArray2DConstDoublePtr(ptr: *const f32) void { +fn testArray2DConstDoublePtr(ptr: *const f32) !void { const ptr2 = @ptrCast([*]const f32, ptr); - expect(ptr2[0] == 1.0); - expect(ptr2[1] == 2.0); + try expect(ptr2[0] == 1.0); + try expect(ptr2[1] == 2.0); } const AStruct = struct { @@ -439,13 +439,13 @@ test "@typeName" { Unused, }; comptime { - expect(mem.eql(u8, @typeName(i64), "i64")); - expect(mem.eql(u8, @typeName(*usize), "*usize")); + try expect(mem.eql(u8, @typeName(i64), "i64")); + try expect(mem.eql(u8, @typeName(*usize), "*usize")); // https://github.com/ziglang/zig/issues/675 - expect(mem.eql(u8, "behavior.misc.TypeFromFn(u8)", @typeName(TypeFromFn(u8)))); - expect(mem.eql(u8, @typeName(Struct), "Struct")); - expect(mem.eql(u8, @typeName(Union), "Union")); - expect(mem.eql(u8, @typeName(Enum), "Enum")); + try expect(mem.eql(u8, "behavior.misc.TypeFromFn(u8)", @typeName(TypeFromFn(u8)))); + try expect(mem.eql(u8, @typeName(Struct), "Struct")); + try expect(mem.eql(u8, @typeName(Union), "Union")); + try expect(mem.eql(u8, @typeName(Enum), "Enum")); } } @@ -455,14 +455,14 @@ fn TypeFromFn(comptime T: type) type { test "double implicit cast in same expression" { var x = @as(i32, @as(u16, nine())); - expect(x == 9); + try expect(x == 9); } fn nine() u8 { return 9; } test "global variable initialized to global variable array element" { - expect(global_ptr == &gdt[0]); + try expect(global_ptr == &gdt[0]); } const GDTEntry = struct { field: i32, @@ -483,9 +483,9 @@ export fn writeToVRam() void { const OpaqueA = opaque {}; const OpaqueB = opaque {}; test "opaque types" { - expect(*OpaqueA != *OpaqueB); - expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA")); - expect(mem.eql(u8, @typeName(OpaqueB), "OpaqueB")); + try expect(*OpaqueA != *OpaqueB); + try expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA")); + try expect(mem.eql(u8, @typeName(OpaqueB), "OpaqueB")); } test "variable is allowed to be a pointer to an opaque type" { @@ -525,7 +525,7 @@ fn fnThatClosesOverLocalConst() type { test "function closes over local const" { const x = fnThatClosesOverLocalConst().g(); - expect(x == 1); + try expect(x == 1); } test "cold function" { @@ -562,21 +562,21 @@ export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion, c: Pack test "slicing zero length array" { const s1 = ""[0..]; const s2 = ([_]u32{})[0..]; - expect(s1.len == 0); - expect(s2.len == 0); - expect(mem.eql(u8, s1, "")); - expect(mem.eql(u32, s2, &[_]u32{})); + try expect(s1.len == 0); + try expect(s2.len == 0); + try expect(mem.eql(u8, s1, "")); + try expect(mem.eql(u32, s2, &[_]u32{})); } const addr1 = @ptrCast(*const u8, emptyFn); test "comptime cast fn to ptr" { const addr2 = @ptrCast(*const u8, emptyFn); - comptime expect(addr1 == addr2); + comptime try expect(addr1 == addr2); } test "equality compare fn ptrs" { var a = emptyFn; - expect(a == a); + try expect(a == a); } test "self reference through fn ptr field" { @@ -591,34 +591,34 @@ test "self reference through fn ptr field" { }; var a: S.A = undefined; a.f = S.foo; - expect(a.f(a) == 12); + try expect(a.f(a) == 12); } test "volatile load and store" { var number: i32 = 1234; const ptr = @as(*volatile i32, &number); ptr.* += 1; - expect(ptr.* == 1235); + try expect(ptr.* == 1235); } test "slice string literal has correct type" { comptime { - expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8); + try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8); const array = [_]i32{ 1, 2, 3, 4 }; - expect(@TypeOf(array[0..]) == *const [4]i32); + try expect(@TypeOf(array[0..]) == *const [4]i32); } var runtime_zero: usize = 0; - comptime expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8); + comptime try expect(@TypeOf("aoeu"[runtime_zero..]) == [:0]const u8); const array = [_]i32{ 1, 2, 3, 4 }; - comptime expect(@TypeOf(array[runtime_zero..]) == []const i32); + comptime try expect(@TypeOf(array[runtime_zero..]) == []const i32); } test "struct inside function" { - testStructInFn(); - comptime testStructInFn(); + try testStructInFn(); + comptime try testStructInFn(); } -fn testStructInFn() void { +fn testStructInFn() !void { const BlockKind = u32; const Block = struct { @@ -629,11 +629,11 @@ fn testStructInFn() void { block.kind += 1; - expect(block.kind == 1235); + try expect(block.kind == 1235); } test "fn call returning scalar optional in equality expression" { - expect(getNull() == null); + try expect(getNull() == null); } fn getNull() ?*i32 { @@ -645,16 +645,16 @@ test "thread local variable" { threadlocal var t: i32 = 1234; }; S.t += 1; - expect(S.t == 1235); + try expect(S.t == 1235); } test "unicode escape in character literal" { var a: u24 = '\u{01f4a9}'; - expect(a == 128169); + try expect(a == 128169); } test "unicode character in character literal" { - expect('πŸ’©' == 128169); + try expect('πŸ’©' == 128169); } 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 entries: []u32, }; var foo = E{ .entries = &[_]u32{} }; - expect(foo.entries.len == 0); + try expect(foo.entries.len == 0); } var global_foo: *i32 = undefined; @@ -677,7 +677,7 @@ test "global variable assignment with optional unwrapping with var initialized t global_foo = S.foo() orelse { @panic("bad"); }; - expect(global_foo.* == 1234); + try expect(global_foo.* == 1234); } 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 bleh: i32, }; }; - expect(S.doTheTest(0) == 1234); - expect(S.doTheTest(1) == 1234); + try expect(S.doTheTest(0) == 1234); + try expect(S.doTheTest(1) == 1234); } test "nested optional field in struct" { @@ -710,7 +710,7 @@ test "nested optional field in struct" { var s = S1{ .x = S2{ .y = 127 }, }; - expect(s.x.?.y == 127); + try expect(s.x.?.y == 127); } fn maybe(x: bool) anyerror!?u32 { @@ -722,7 +722,7 @@ fn maybe(x: bool) anyerror!?u32 { test "result location is optional inside error union" { const x = maybe(true) catch unreachable; - expect(x.? == 42); + try expect(x.? == 42); } threadlocal var buffer: [11]u8 = undefined; @@ -730,7 +730,7 @@ threadlocal var buffer: [11]u8 = undefined; test "pointer to thread local array" { const s = "Hello world"; std.mem.copy(u8, buffer[0..], s); - std.testing.expectEqualSlices(u8, buffer[0..], s); + try std.testing.expectEqualSlices(u8, buffer[0..], s); } test "auto created variables have correct alignment" { @@ -742,15 +742,15 @@ test "auto created variables have correct alignment" { return 0; } }; - expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); - comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); + try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); + comptime try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); } extern var opaque_extern_var: opaque {}; var var_to_export: u32 = 42; test "extern variable with non-pointer opaque type" { @export(var_to_export, .{ .name = "opaque_extern_var" }); - expect(@ptrCast(*align(1) u32, &opaque_extern_var).* == 42); + try expect(@ptrCast(*align(1) u32, &opaque_extern_var).* == 42); } test "lazy typeInfo value as generic parameter" { diff --git a/test/stage1/behavior/muladd.zig b/test/stage1/behavior/muladd.zig index d507f503f5..87fbf57fd3 100644 --- a/test/stage1/behavior/muladd.zig +++ b/test/stage1/behavior/muladd.zig @@ -1,34 +1,34 @@ const expect = @import("std").testing.expect; test "@mulAdd" { - comptime testMulAdd(); - testMulAdd(); + comptime try testMulAdd(); + try testMulAdd(); } -fn testMulAdd() void { +fn testMulAdd() !void { { var a: f16 = 5.5; var b: f16 = 2.5; var c: f16 = 6.25; - expect(@mulAdd(f16, a, b, c) == 20); + try expect(@mulAdd(f16, a, b, c) == 20); } { var a: f32 = 5.5; var b: f32 = 2.5; var c: f32 = 6.25; - expect(@mulAdd(f32, a, b, c) == 20); + try expect(@mulAdd(f32, a, b, c) == 20); } { var a: f64 = 5.5; var b: f64 = 2.5; var c: f64 = 6.25; - expect(@mulAdd(f64, a, b, c) == 20); + try expect(@mulAdd(f64, a, b, c) == 20); } // Awaits implementation in libm.zig //{ // var a: f16 = 5.5; // var b: f128 = 2.5; // var c: f128 = 6.25; - // expect(@mulAdd(f128, a, b, c) == 20); + //try expect(@mulAdd(f128, a, b, c) == 20); //} } diff --git a/test/stage1/behavior/namespace_depends_on_compile_var.zig b/test/stage1/behavior/namespace_depends_on_compile_var.zig index 8c5c19d733..3e8cab3528 100644 --- a/test/stage1/behavior/namespace_depends_on_compile_var.zig +++ b/test/stage1/behavior/namespace_depends_on_compile_var.zig @@ -3,9 +3,9 @@ const expect = std.testing.expect; test "namespace depends on compile var" { if (some_namespace.a_bool) { - expect(some_namespace.a_bool); + try expect(some_namespace.a_bool); } else { - expect(!some_namespace.a_bool); + try expect(!some_namespace.a_bool); } } const some_namespace = switch (std.builtin.os.tag) { diff --git a/test/stage1/behavior/null.zig b/test/stage1/behavior/null.zig index 8c9b86b260..45401f621a 100644 --- a/test/stage1/behavior/null.zig +++ b/test/stage1/behavior/null.zig @@ -17,13 +17,13 @@ test "optional type" { const z = next_x orelse 1234; - expect(z == 1234); + try expect(z == 1234); const final_x: ?i32 = 13; const num = final_x orelse unreachable; - expect(num == 13); + try expect(num == 13); } 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" { b.* = false; } - expect(maybe_bool.? == false); + try expect(maybe_bool.? == false); } test "rhs maybe unwrap return" { @@ -42,14 +42,14 @@ test "rhs maybe unwrap return" { } test "maybe return" { - maybeReturnImpl(); - comptime maybeReturnImpl(); + try maybeReturnImpl(); + comptime try maybeReturnImpl(); } -fn maybeReturnImpl() void { - expect(foo(1235).?); +fn maybeReturnImpl() !void { + try expect(foo(1235).?); if (foo(null) != null) unreachable; - expect(!foo(1234).?); + try expect(!foo(1234).?); } fn foo(x: ?i32) ?bool { @@ -58,7 +58,7 @@ fn foo(x: ?i32) ?bool { } test "if var maybe pointer" { - expect(shouldBeAPlus1(Particle{ + try expect(shouldBeAPlus1(Particle{ .a = 14, .b = 1, .c = 1, @@ -84,10 +84,10 @@ const Particle = struct { test "null literal outside function" { const is_null = here_is_a_null_literal.context == null; - expect(is_null); + try expect(is_null); const is_non_null = here_is_a_null_literal.context != null; - expect(!is_non_null); + try expect(!is_non_null); } const SillyStruct = struct { context: ?i32, @@ -95,21 +95,21 @@ const SillyStruct = struct { const here_is_a_null_literal = SillyStruct{ .context = null }; test "test null runtime" { - testTestNullRuntime(null); + try testTestNullRuntime(null); } -fn testTestNullRuntime(x: ?i32) void { - expect(x == null); - expect(!(x != null)); +fn testTestNullRuntime(x: ?i32) !void { + try expect(x == null); + try expect(!(x != null)); } test "optional void" { - optionalVoidImpl(); - comptime optionalVoidImpl(); + try optionalVoidImpl(); + comptime try optionalVoidImpl(); } -fn optionalVoidImpl() void { - expect(bar(null) == null); - expect(bar({}) != null); +fn optionalVoidImpl() !void { + try expect(bar(null) == null); + try expect(bar({}) != null); } fn bar(x: ?void) ?void { @@ -133,7 +133,7 @@ test "unwrap optional which is field of global var" { } struct_with_optional.field = 1234; if (struct_with_optional.field) |payload| { - expect(payload == 1234); + try expect(payload == 1234); } else { unreachable; } @@ -141,13 +141,13 @@ test "unwrap optional which is field of global var" { test "null with default unwrap" { const x: i32 = null orelse 1; - expect(x == 1); + try expect(x == 1); } test "optional types" { comptime { const opt_type_struct = StructWithOptionalType{ .t = u8 }; - expect(opt_type_struct.t != null and opt_type_struct.t.? == u8); + try expect(opt_type_struct.t != null and opt_type_struct.t.? == u8); } } @@ -158,5 +158,5 @@ const StructWithOptionalType = struct { test "optional pointer to 0 bit type null value at runtime" { const EmptyStruct = struct {}; var x: ?*EmptyStruct = null; - expect(x == null); + try expect(x == null); } diff --git a/test/stage1/behavior/optional.zig b/test/stage1/behavior/optional.zig index 1dc33eb8ea..75b4311159 100644 --- a/test/stage1/behavior/optional.zig +++ b/test/stage1/behavior/optional.zig @@ -8,28 +8,28 @@ pub const EmptyStruct = struct {}; test "optional pointer to size zero struct" { var e = EmptyStruct{}; var o: ?*EmptyStruct = &e; - expect(o != null); + try expect(o != null); } test "equality compare nullable pointers" { - testNullPtrsEql(); - comptime testNullPtrsEql(); + try testNullPtrsEql(); + comptime try testNullPtrsEql(); } -fn testNullPtrsEql() void { +fn testNullPtrsEql() !void { var number: i32 = 1234; var x: ?*i32 = null; var y: ?*i32 = null; - expect(x == y); + try expect(x == y); y = &number; - expect(x != y); - expect(x != &number); - expect(&number != x); + try expect(x != y); + try expect(x != &number); + try expect(&number != x); x = &number; - expect(x == y); - expect(x == &number); - expect(&number == x); + try expect(x == y); + try expect(x == &number); + try expect(&number == x); } test "address of unwrap optional" { @@ -46,23 +46,23 @@ test "address of unwrap optional" { }; S.global = S.Foo{ .a = 1234 }; const foo = S.getFoo() catch unreachable; - expect(foo.a == 1234); + try expect(foo.a == 1234); } test "equality compare optional with non-optional" { - test_cmp_optional_non_optional(); - comptime test_cmp_optional_non_optional(); + try test_cmp_optional_non_optional(); + comptime try test_cmp_optional_non_optional(); } -fn test_cmp_optional_non_optional() void { +fn test_cmp_optional_non_optional() !void { var ten: i32 = 10; var opt_ten: ?i32 = 10; var five: i32 = 5; var int_n: ?i32 = null; - expect(int_n != ten); - expect(opt_ten == ten); - expect(opt_ten != five); + try expect(int_n != ten); + try expect(opt_ten == ten); + try expect(opt_ten != five); // test evaluation is always lexical // ensure that the optional isn't always computed before the non-optional @@ -71,14 +71,14 @@ fn test_cmp_optional_non_optional() void { mutable_state += 1; break :blk1 @as(?f64, 10.0); } != blk2: { - expect(mutable_state == 1); + try expect(mutable_state == 1); break :blk2 @as(f64, 5.0); }; _ = blk1: { mutable_state += 1; break :blk1 @as(f64, 10.0); } != blk2: { - expect(mutable_state == 2); + try expect(mutable_state == 2); break :blk2 @as(?f64, 5.0); }; } @@ -94,15 +94,15 @@ test "passing an optional integer as a parameter" { return x.? == 1234; } }; - expect(S.entry()); - comptime expect(S.entry()); + try expect(S.entry()); + comptime try expect(S.entry()); } test "unwrap function call with optional pointer return value" { const S = struct { - fn entry() void { - expect(foo().?.* == 1234); - expect(bar() == null); + fn entry() !void { + try expect(foo().?.* == 1234); + try expect(bar() == null); } const global: i32 = 1234; fn foo() ?*const i32 { @@ -112,14 +112,14 @@ test "unwrap function call with optional pointer return value" { return null; } }; - S.entry(); - comptime S.entry(); + try S.entry(); + comptime try S.entry(); } test "nested orelse" { const S = struct { - fn entry() void { - expect(func() == null); + fn entry() !void { + try expect(func() == null); } fn maybe() ?Foo { return null; @@ -134,8 +134,8 @@ test "nested orelse" { field: i32, }; }; - S.entry(); - comptime S.entry(); + try S.entry(); + comptime try S.entry(); } test "self-referential struct through a slice of optional" { @@ -154,7 +154,7 @@ test "self-referential struct through a slice of optional" { }; var n = S.Node.new(); - expect(n.data == null); + try expect(n.data == null); } test "assigning to an unwrapped optional field in an inline loop" { @@ -173,14 +173,14 @@ test "coerce an anon struct literal to optional struct" { const Struct = struct { field: u32, }; - export fn doTheTest() void { + fn doTheTest() !void { var maybe_dims: ?Struct = null; maybe_dims = .{ .field = 1 }; - expect(maybe_dims.?.field == 1); + try expect(maybe_dims.?.field == 1); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "optional with void type" { @@ -188,15 +188,15 @@ test "optional with void type" { x: ?void, }; var x = Foo{ .x = null }; - expect(x.x == null); + try expect(x.x == null); } test "0-bit child type coerced to optional return ptr result location" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var y = Foo{}; var z = y.thing(); - expect(z != null); + try expect(z != null); } const Foo = struct { @@ -209,17 +209,17 @@ test "0-bit child type coerced to optional return ptr result location" { } }; }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "0-bit child type coerced to optional" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var it: Foo = .{ .list = undefined, }; - expect(it.foo() != null); + try expect(it.foo() != null); } const Empty = struct {}; @@ -232,8 +232,8 @@ test "0-bit child type coerced to optional" { } }; }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "array of optional unaligned types" { @@ -255,15 +255,15 @@ test "array of optional unaligned types" { // The index must be a runtime value var i: usize = 0; - expectEqual(Enum.one, values[i].?.Num); + try expectEqual(Enum.one, values[i].?.Num); i += 1; - expectEqual(Enum.two, values[i].?.Num); + try expectEqual(Enum.two, values[i].?.Num); i += 1; - expectEqual(Enum.three, values[i].?.Num); + try expectEqual(Enum.three, values[i].?.Num); i += 1; - expectEqual(Enum.one, values[i].?.Num); + try expectEqual(Enum.one, values[i].?.Num); i += 1; - expectEqual(Enum.two, values[i].?.Num); + try expectEqual(Enum.two, values[i].?.Num); i += 1; - expectEqual(Enum.three, values[i].?.Num); + try expectEqual(Enum.three, values[i].?.Num); } diff --git a/test/stage1/behavior/pointers.zig b/test/stage1/behavior/pointers.zig index a4f619b538..a078e58ab5 100644 --- a/test/stage1/behavior/pointers.zig +++ b/test/stage1/behavior/pointers.zig @@ -4,15 +4,15 @@ const expect = testing.expect; const expectError = testing.expectError; test "dereference pointer" { - comptime testDerefPtr(); - testDerefPtr(); + comptime try testDerefPtr(); + try testDerefPtr(); } -fn testDerefPtr() void { +fn testDerefPtr() !void { var x: i32 = 1234; var y = &x; y.* += 1; - expect(x == 1235); + try expect(x == 1235); } const Foo1 = struct { @@ -20,41 +20,41 @@ const Foo1 = struct { }; test "dereference pointer again" { - testDerefPtrOneVal(); - comptime testDerefPtrOneVal(); + try testDerefPtrOneVal(); + comptime try testDerefPtrOneVal(); } -fn testDerefPtrOneVal() void { +fn testDerefPtrOneVal() !void { // Foo1 satisfies the OnePossibleValueYes criteria const x = &Foo1{ .x = {} }; const y = x.*; - expect(@TypeOf(y.x) == void); + try expect(@TypeOf(y.x) == void); } test "pointer arithmetic" { var ptr: [*]const u8 = "abcd"; - expect(ptr[0] == 'a'); + try expect(ptr[0] == 'a'); ptr += 1; - expect(ptr[0] == 'b'); + try expect(ptr[0] == 'b'); ptr += 1; - expect(ptr[0] == 'c'); + try expect(ptr[0] == 'c'); ptr += 1; - expect(ptr[0] == 'd'); + try expect(ptr[0] == 'd'); ptr += 1; - expect(ptr[0] == 0); + try expect(ptr[0] == 0); ptr -= 1; - expect(ptr[0] == 'd'); + try expect(ptr[0] == 'd'); ptr -= 1; - expect(ptr[0] == 'c'); + try expect(ptr[0] == 'c'); ptr -= 1; - expect(ptr[0] == 'b'); + try expect(ptr[0] == 'b'); ptr -= 1; - expect(ptr[0] == 'a'); + try expect(ptr[0] == 'a'); } test "double pointer parsing" { - comptime expect(PtrOf(PtrOf(i32)) == **i32); + comptime try expect(PtrOf(PtrOf(i32)) == **i32); } fn PtrOf(comptime T: type) type { @@ -72,33 +72,33 @@ test "implicit cast single item pointer to C pointer and back" { var x: [*c]u8 = &y; var z: *u8 = x; z.* += 1; - expect(y == 12); + try expect(y == 12); } test "C pointer comparison and arithmetic" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var one: usize = 1; var ptr1: [*c]u32 = 0; var ptr2 = ptr1 + 10; - expect(ptr1 == 0); - expect(ptr1 >= 0); - expect(ptr1 <= 0); + try expect(ptr1 == 0); + try expect(ptr1 >= 0); + try expect(ptr1 <= 0); // expect(ptr1 < 1); // expect(ptr1 < one); // expect(1 > ptr1); // expect(one > ptr1); - expect(ptr1 < ptr2); - expect(ptr2 > ptr1); - expect(ptr2 >= 40); - expect(ptr2 == 40); - expect(ptr2 <= 40); + try expect(ptr1 < ptr2); + try expect(ptr2 > ptr1); + try expect(ptr2 >= 40); + try expect(ptr2 == 40); + try expect(ptr2 <= 40); ptr2 -= 10; - expect(ptr1 == ptr2); + try expect(ptr1 == ptr2); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "peer type resolution with C pointers" { @@ -110,10 +110,10 @@ test "peer type resolution with C pointers" { var x2 = if (t) ptr_many else ptr_c; var x3 = if (t) ptr_c else ptr_one; var x4 = if (t) ptr_c else ptr_many; - expect(@TypeOf(x1) == [*c]u8); - expect(@TypeOf(x2) == [*c]u8); - expect(@TypeOf(x3) == [*c]u8); - expect(@TypeOf(x4) == [*c]u8); + try expect(@TypeOf(x1) == [*c]u8); + try expect(@TypeOf(x2) == [*c]u8); + try expect(@TypeOf(x3) == [*c]u8); + try expect(@TypeOf(x4) == [*c]u8); } 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" { const opt_many_ptr: ?[*]const u8 = slice.ptr; var ptr_opt_many_ptr = &opt_many_ptr; var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr; - expect(c_ptr.*.* == 'a'); + try expect(c_ptr.*.* == 'a'); ptr_opt_many_ptr = c_ptr; - expect(ptr_opt_many_ptr.*.?[1] == 'o'); + try expect(ptr_opt_many_ptr.*.?[1] == 'o'); } test "implicit cast error unions with non-optional to optional pointer" { const S = struct { - fn doTheTest() void { - expectError(error.Fail, foo()); + fn doTheTest() !void { + try expectError(error.Fail, foo()); } fn foo() anyerror!?*u8 { return bar() orelse error.Fail; @@ -138,111 +138,111 @@ test "implicit cast error unions with non-optional to optional pointer" { return null; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "initialize const optional C pointer to null" { const a: ?[*c]i32 = null; - expect(a == null); - comptime expect(a == null); + try expect(a == null); + comptime try expect(a == null); } test "compare equality of optional and non-optional pointer" { const a = @intToPtr(*const usize, 0x12345678); const b = @intToPtr(?*usize, 0x12345678); - expect(a == b); - expect(b == a); + try expect(a == b); + try expect(b == a); } test "allowzero pointer and slice" { var ptr = @intToPtr([*]allowzero i32, 0); var opt_ptr: ?[*]allowzero i32 = ptr; - expect(opt_ptr != null); - expect(@ptrToInt(ptr) == 0); + try expect(opt_ptr != null); + try expect(@ptrToInt(ptr) == 0); var runtime_zero: usize = 0; var slice = ptr[runtime_zero..10]; - comptime expect(@TypeOf(slice) == []allowzero i32); - expect(@ptrToInt(&slice[5]) == 20); + comptime try expect(@TypeOf(slice) == []allowzero i32); + try expect(@ptrToInt(&slice[5]) == 20); - comptime expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero); - comptime expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero); + comptime try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero); + comptime try expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero); } test "assign null directly to C pointer and test null equality" { var x: [*c]i32 = null; - expect(x == null); - expect(null == x); - expect(!(x != null)); - expect(!(null != x)); + try expect(x == null); + try expect(null == x); + try expect(!(x != null)); + try expect(!(null != x)); if (x) |same_x| { @panic("fail"); } var otherx: i32 = undefined; - expect((x orelse &otherx) == &otherx); + try expect((x orelse &otherx) == &otherx); const y: [*c]i32 = null; - comptime expect(y == null); - comptime expect(null == y); - comptime expect(!(y != null)); - comptime expect(!(null != y)); + comptime try expect(y == null); + comptime try expect(null == y); + comptime try expect(!(y != null)); + comptime try expect(!(null != y)); if (y) |same_y| @panic("fail"); const othery: i32 = undefined; - comptime expect((y orelse &othery) == &othery); + comptime try expect((y orelse &othery) == &othery); var n: i32 = 1234; var x1: [*c]i32 = &n; - expect(!(x1 == null)); - expect(!(null == x1)); - expect(x1 != null); - expect(null != x1); - expect(x1.?.* == 1234); + try expect(!(x1 == null)); + try expect(!(null == x1)); + try expect(x1 != null); + try expect(null != x1); + try expect(x1.?.* == 1234); if (x1) |same_x1| { - expect(same_x1.* == 1234); + try expect(same_x1.* == 1234); } else { @panic("fail"); } - expect((x1 orelse &otherx) == x1); + try expect((x1 orelse &otherx) == x1); const nc: i32 = 1234; const y1: [*c]const i32 = &nc; - comptime expect(!(y1 == null)); - comptime expect(!(null == y1)); - comptime expect(y1 != null); - comptime expect(null != y1); - comptime expect(y1.?.* == 1234); + comptime try expect(!(y1 == null)); + comptime try expect(!(null == y1)); + comptime try expect(y1 != null); + comptime try expect(null != y1); + comptime try expect(y1.?.* == 1234); if (y1) |same_y1| { - expect(same_y1.* == 1234); + try expect(same_y1.* == 1234); } else { @compileError("fail"); } - comptime expect((y1 orelse &othery) == y1); + comptime try expect((y1 orelse &othery) == y1); } test "null terminated pointer" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' }; var zero_ptr: [*:0]const u8 = @ptrCast([*:0]const u8, &array_with_zero); var no_zero_ptr: [*]const u8 = zero_ptr; var zero_ptr_again = @ptrCast([*:0]const u8, no_zero_ptr); - expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello")); + try expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello")); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "allow any sentinel" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 }; var ptr: [*:std.math.minInt(i32)]i32 = &array; - expect(ptr[4] == std.math.minInt(i32)); + try expect(ptr[4] == std.math.minInt(i32)); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "pointer sentinel with enums" { @@ -253,42 +253,42 @@ test "pointer sentinel with enums" { sentinel, }; - fn doTheTest() void { + fn doTheTest() !void { var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one }; - expect(ptr[4] == .sentinel); // TODO this should be comptime expect, see #3731 + try expect(ptr[4] == .sentinel); // TODO this should be comptime try expect, see #3731 } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "pointer sentinel with optional element" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 }; - expect(ptr[4] == null); // TODO this should be comptime expect, see #3731 + try expect(ptr[4] == null); // TODO this should be comptime try expect, see #3731 } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "pointer sentinel with +inf" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const inf = std.math.inf_f32; var ptr: [*:inf]const f32 = &[_:inf]f32{ 1.1, 2.2, 3.3, 4.4 }; - expect(ptr[4] == inf); // TODO this should be comptime expect, see #3731 + try expect(ptr[4] == inf); // TODO this should be comptime try expect, see #3731 } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "pointer to array at fixed address" { const array = @intToPtr(*volatile [1]u32, 0x10); // Silly check just to reference `array` - expect(@ptrToInt(&array[0]) == 0x10); + try expect(@ptrToInt(&array[0]) == 0x10); } test "pointer arithmetic affects the alignment" { @@ -296,28 +296,28 @@ test "pointer arithmetic affects the alignment" { var ptr: [*]align(8) u32 = undefined; var x: usize = 1; - expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8); + try expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8); const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4 - expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4); + try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4); const ptr2 = ptr + 4; // 4 * 4 = 16 -> lcd(16,8) = 8 - expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8); + try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8); const ptr3 = ptr + 0; // no-op - expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8); + try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8); const ptr4 = ptr + x; // runtime-known addend - expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4); + try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4); } { var ptr: [*]align(8) [3]u8 = undefined; var x: usize = 1; const ptr1 = ptr + 17; // 3 * 17 = 51 - expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1); + try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1); const ptr2 = ptr + x; // runtime-known addend - expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1); + try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1); const ptr3 = ptr + 8; // 3 * 8 = 24 -> lcd(8,24) = 8 - expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8); + try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8); const ptr4 = ptr + 4; // 3 * 4 = 12 -> lcd(8,12) = 4 - expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4); + try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4); } } @@ -325,15 +325,15 @@ test "@ptrToInt on null optional at comptime" { { const pointer = @intToPtr(?*u8, 0x000); const x = @ptrToInt(pointer); - comptime expect(0 == @ptrToInt(pointer)); + comptime try expect(0 == @ptrToInt(pointer)); } { const pointer = @intToPtr(?*u8, 0xf00); - comptime expect(0xf00 == @ptrToInt(pointer)); + comptime try expect(0xf00 == @ptrToInt(pointer)); } } test "indexing array with sentinel returns correct type" { var s: [:0]const u8 = "abc"; - testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0]))); + try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0]))); } diff --git a/test/stage1/behavior/popcount.zig b/test/stage1/behavior/popcount.zig index 884a7bdb6d..99a1849d80 100644 --- a/test/stage1/behavior/popcount.zig +++ b/test/stage1/behavior/popcount.zig @@ -1,43 +1,43 @@ const expect = @import("std").testing.expect; test "@popCount" { - comptime testPopCount(); - testPopCount(); + comptime try testPopCount(); + try testPopCount(); } -fn testPopCount() void { +fn testPopCount() !void { { var x: u32 = 0xffffffff; - expect(@popCount(u32, x) == 32); + try expect(@popCount(u32, x) == 32); } { var x: u5 = 0x1f; - expect(@popCount(u5, x) == 5); + try expect(@popCount(u5, x) == 5); } { var x: u32 = 0xaa; - expect(@popCount(u32, x) == 4); + try expect(@popCount(u32, x) == 4); } { var x: u32 = 0xaaaaaaaa; - expect(@popCount(u32, x) == 16); + try expect(@popCount(u32, x) == 16); } { var x: u32 = 0xaaaaaaaa; - expect(@popCount(u32, x) == 16); + try expect(@popCount(u32, x) == 16); } { var x: i16 = -1; - expect(@popCount(i16, x) == 16); + try expect(@popCount(i16, x) == 16); } { var x: i8 = -120; - expect(@popCount(i8, x) == 2); + try expect(@popCount(i8, x) == 2); } comptime { - expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2); + try expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2); } comptime { - expect(@popCount(i128, 0b11111111000110001100010000100001000011000011100101010001) == 24); + try expect(@popCount(i128, 0b11111111000110001100010000100001000011000011100101010001) == 24); } } diff --git a/test/stage1/behavior/ptrcast.zig b/test/stage1/behavior/ptrcast.zig index 26e9545248..6c67dd504b 100644 --- a/test/stage1/behavior/ptrcast.zig +++ b/test/stage1/behavior/ptrcast.zig @@ -3,25 +3,25 @@ const builtin = std.builtin; const expect = std.testing.expect; test "reinterpret bytes as integer with nonzero offset" { - testReinterpretBytesAsInteger(); - comptime testReinterpretBytesAsInteger(); + try testReinterpretBytesAsInteger(); + comptime try testReinterpretBytesAsInteger(); } -fn testReinterpretBytesAsInteger() void { +fn testReinterpretBytesAsInteger() !void { const bytes = "\x12\x34\x56\x78\xab"; const expected = switch (builtin.endian) { builtin.Endian.Little => 0xab785634, builtin.Endian.Big => 0x345678ab, }; - expect(@ptrCast(*align(1) const u32, bytes[1..5]).* == expected); + try expect(@ptrCast(*align(1) const u32, bytes[1..5]).* == expected); } test "reinterpret bytes of an array into an extern struct" { - testReinterpretBytesAsExternStruct(); - comptime testReinterpretBytesAsExternStruct(); + try testReinterpretBytesAsExternStruct(); + comptime try testReinterpretBytesAsExternStruct(); } -fn testReinterpretBytesAsExternStruct() void { +fn testReinterpretBytesAsExternStruct() !void { var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 }; const S = extern struct { @@ -32,15 +32,15 @@ fn testReinterpretBytesAsExternStruct() void { var ptr = @ptrCast(*const S, &bytes); var val = ptr.c; - expect(val == 5); + try expect(val == 5); } test "reinterpret struct field at comptime" { const numNative = comptime Bytes.init(0x12345678); if (builtin.endian != .Little) { - expect(std.mem.eql(u8, &[_]u8{ 0x12, 0x34, 0x56, 0x78 }, &numNative.bytes)); + try expect(std.mem.eql(u8, &[_]u8{ 0x12, 0x34, 0x56, 0x78 }, &numNative.bytes)); } else { - expect(std.mem.eql(u8, &[_]u8{ 0x78, 0x56, 0x34, 0x12 }, &numNative.bytes)); + try expect(std.mem.eql(u8, &[_]u8{ 0x78, 0x56, 0x34, 0x12 }, &numNative.bytes)); } } @@ -59,7 +59,7 @@ test "comptime ptrcast keeps larger alignment" { comptime { const a: u32 = 1234; const p = @ptrCast([*]const u8, &a); - std.debug.assert(@TypeOf(p) == [*]align(@alignOf(u32)) const u8); + try expect(@TypeOf(p) == [*]align(@alignOf(u32)) const u8); } } @@ -68,5 +68,5 @@ test "implicit optional pointer to optional c_void pointer" { var x: ?[*]u8 = &buf; var y: ?*c_void = x; var z = @ptrCast(*[4]u8, y); - expect(std.mem.eql(u8, z, "aoeu")); + try expect(std.mem.eql(u8, z, "aoeu")); } diff --git a/test/stage1/behavior/pub_enum.zig b/test/stage1/behavior/pub_enum.zig index 0613df94d9..d2e887b12e 100644 --- a/test/stage1/behavior/pub_enum.zig +++ b/test/stage1/behavior/pub_enum.zig @@ -2,12 +2,12 @@ const other = @import("pub_enum/other.zig"); const expect = @import("std").testing.expect; test "pub enum" { - pubEnumTest(other.APubEnum.Two); + try pubEnumTest(other.APubEnum.Two); } -fn pubEnumTest(foo: other.APubEnum) void { - expect(foo == other.APubEnum.Two); +fn pubEnumTest(foo: other.APubEnum) !void { + try expect(foo == other.APubEnum.Two); } test "cast with imported symbol" { - expect(@as(other.size_t, 42) == 42); + try expect(@as(other.size_t, 42) == 42); } diff --git a/test/stage1/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig b/test/stage1/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig index 2c1cf06268..488bc1a232 100644 --- a/test/stage1/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig +++ b/test/stage1/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig @@ -3,12 +3,12 @@ const mem = @import("std").mem; var ok: bool = false; test "reference a variable in an if after an if in the 2nd switch prong" { - foo(true, Num.Two, false, "aoeu"); - expect(!ok); - foo(false, Num.One, false, "aoeu"); - expect(!ok); - foo(true, Num.One, false, "aoeu"); - expect(ok); + try foo(true, Num.Two, false, "aoeu"); + try expect(!ok); + try foo(false, Num.One, false, "aoeu"); + try expect(!ok); + try foo(true, Num.One, false, "aoeu"); + try expect(ok); } const Num = enum { @@ -16,7 +16,7 @@ const Num = enum { Two, }; -fn foo(c: bool, k: Num, c2: bool, b: []const u8) void { +fn foo(c: bool, k: Num, c2: bool, b: []const u8) !void { switch (k) { Num.Two => {}, Num.One => { @@ -25,13 +25,13 @@ fn foo(c: bool, k: Num, c2: bool, b: []const u8) void { if (c2) {} - a(output_path); + try a(output_path); } }, } } -fn a(x: []const u8) void { - expect(mem.eql(u8, x, "aoeu")); +fn a(x: []const u8) !void { + try expect(mem.eql(u8, x, "aoeu")); ok = true; } diff --git a/test/stage1/behavior/reflection.zig b/test/stage1/behavior/reflection.zig index 6d1c341713..3e5e4087c4 100644 --- a/test/stage1/behavior/reflection.zig +++ b/test/stage1/behavior/reflection.zig @@ -5,12 +5,12 @@ const reflection = @This(); test "reflection: function return type, var args, and param types" { comptime { const info = @typeInfo(@TypeOf(dummy)).Fn; - expect(info.return_type.? == i32); - expect(!info.is_var_args); - expect(info.args.len == 3); - expect(info.args[0].arg_type.? == bool); - expect(info.args[1].arg_type.? == i32); - expect(info.args[2].arg_type.? == f32); + try expect(info.return_type.? == i32); + try expect(!info.is_var_args); + try expect(info.args.len == 3); + try expect(info.args[0].arg_type.? == bool); + try expect(info.args[1].arg_type.? == i32); + try expect(info.args[2].arg_type.? == f32); } } @@ -25,18 +25,18 @@ test "reflection: @field" { .three = void{}, }; - expect(f.one == f.one); - expect(@field(f, "o" ++ "ne") == f.one); - expect(@field(f, "t" ++ "wo") == f.two); - expect(@field(f, "th" ++ "ree") == f.three); - expect(@field(Foo, "const" ++ "ant") == Foo.constant); - expect(@field(Bar, "O" ++ "ne") == Bar.One); - expect(@field(Bar, "T" ++ "wo") == Bar.Two); - expect(@field(Bar, "Th" ++ "ree") == Bar.Three); - expect(@field(Bar, "F" ++ "our") == Bar.Four); - expect(@field(reflection, "dum" ++ "my")(true, 1, 2) == dummy(true, 1, 2)); + try expect(f.one == f.one); + try expect(@field(f, "o" ++ "ne") == f.one); + try expect(@field(f, "t" ++ "wo") == f.two); + try expect(@field(f, "th" ++ "ree") == f.three); + try expect(@field(Foo, "const" ++ "ant") == Foo.constant); + try expect(@field(Bar, "O" ++ "ne") == Bar.One); + try expect(@field(Bar, "T" ++ "wo") == Bar.Two); + try expect(@field(Bar, "Th" ++ "ree") == Bar.Three); + try expect(@field(Bar, "F" ++ "our") == Bar.Four); + try expect(@field(reflection, "dum" ++ "my")(true, 1, 2) == dummy(true, 1, 2)); @field(f, "o" ++ "ne") = 4; - expect(f.one == 4); + try expect(f.one == 4); } const Foo = struct { diff --git a/test/stage1/behavior/shuffle.zig b/test/stage1/behavior/shuffle.zig index 3b6412b386..e839b7eddc 100644 --- a/test/stage1/behavior/shuffle.zig +++ b/test/stage1/behavior/shuffle.zig @@ -9,33 +9,33 @@ test "@shuffle" { if (builtin.os.tag == .wasi) return error.SkipZigTest; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 }; var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 }; const mask: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) }; var res = @shuffle(i32, v, x, mask); - expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 })); + try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 })); // Implicit cast from array (of mask) res = @shuffle(i32, v, x, [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) }); - expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 })); + try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 40, 4 })); // Undefined const mask2: Vector(4, i32) = [4]i32{ 3, 1, 2, 0 }; res = @shuffle(i32, v, undefined, mask2); - expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 40, -2, 30, 2147483647 })); + try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 40, -2, 30, 2147483647 })); // Upcasting of b var v2: Vector(2, i32) = [2]i32{ 2147483647, undefined }; const mask3: Vector(4, i32) = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 }; res = @shuffle(i32, x, v2, mask3); - expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 2147483647, 4 })); + try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, 2147483647, 4 })); // Upcasting of a var v3: Vector(2, i32) = [2]i32{ 2147483647, -2 }; const mask4: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) }; res = @shuffle(i32, v3, x, mask4); - expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 })); + try expect(mem.eql(i32, &@as([4]i32, res), &[4]i32{ 2147483647, 3, -2, 4 })); // bool // Disabled because of #3317 @@ -44,7 +44,7 @@ test "@shuffle" { var v4: Vector(2, bool) = [2]bool{ true, false }; const mask5: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 }; var res2 = @shuffle(bool, x2, v4, mask5); - expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false })); + try expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false })); } // TODO re-enable when LLVM codegen is fixed @@ -54,10 +54,10 @@ test "@shuffle" { var v4: Vector(2, bool) = [2]bool{ true, false }; const mask5: Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 }; var res2 = @shuffle(bool, x2, v4, mask5); - expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false })); + try expect(mem.eql(bool, &@as([4]bool, res2), &[4]bool{ false, false, true, false })); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/sizeof_and_typeof.zig b/test/stage1/behavior/sizeof_and_typeof.zig index 54efe9cb35..ae5e760f59 100644 --- a/test/stage1/behavior/sizeof_and_typeof.zig +++ b/test/stage1/behavior/sizeof_and_typeof.zig @@ -5,7 +5,7 @@ const expectEqual = std.testing.expectEqual; test "@sizeOf and @TypeOf" { const y: @TypeOf(x) = 120; - expect(@sizeOf(@TypeOf(y)) == 2); + try expect(@sizeOf(@TypeOf(y)) == 2); } const x: u16 = 13; const z: @TypeOf(x) = 19; @@ -36,27 +36,27 @@ const P = packed struct { test "@byteOffsetOf" { // Packed structs have fixed memory layout - expect(@byteOffsetOf(P, "a") == 0); - expect(@byteOffsetOf(P, "b") == 1); - expect(@byteOffsetOf(P, "c") == 5); - expect(@byteOffsetOf(P, "d") == 6); - expect(@byteOffsetOf(P, "e") == 6); - expect(@byteOffsetOf(P, "f") == 7); - expect(@byteOffsetOf(P, "g") == 9); - expect(@byteOffsetOf(P, "h") == 11); - expect(@byteOffsetOf(P, "i") == 12); + try expect(@byteOffsetOf(P, "a") == 0); + try expect(@byteOffsetOf(P, "b") == 1); + try expect(@byteOffsetOf(P, "c") == 5); + try expect(@byteOffsetOf(P, "d") == 6); + try expect(@byteOffsetOf(P, "e") == 6); + try expect(@byteOffsetOf(P, "f") == 7); + try expect(@byteOffsetOf(P, "g") == 9); + try expect(@byteOffsetOf(P, "h") == 11); + try expect(@byteOffsetOf(P, "i") == 12); // Normal struct fields can be moved/padded var a: A = undefined; - expect(@ptrToInt(&a.a) - @ptrToInt(&a) == @byteOffsetOf(A, "a")); - expect(@ptrToInt(&a.b) - @ptrToInt(&a) == @byteOffsetOf(A, "b")); - expect(@ptrToInt(&a.c) - @ptrToInt(&a) == @byteOffsetOf(A, "c")); - expect(@ptrToInt(&a.d) - @ptrToInt(&a) == @byteOffsetOf(A, "d")); - expect(@ptrToInt(&a.e) - @ptrToInt(&a) == @byteOffsetOf(A, "e")); - expect(@ptrToInt(&a.f) - @ptrToInt(&a) == @byteOffsetOf(A, "f")); - expect(@ptrToInt(&a.g) - @ptrToInt(&a) == @byteOffsetOf(A, "g")); - expect(@ptrToInt(&a.h) - @ptrToInt(&a) == @byteOffsetOf(A, "h")); - expect(@ptrToInt(&a.i) - @ptrToInt(&a) == @byteOffsetOf(A, "i")); + try expect(@ptrToInt(&a.a) - @ptrToInt(&a) == @byteOffsetOf(A, "a")); + try expect(@ptrToInt(&a.b) - @ptrToInt(&a) == @byteOffsetOf(A, "b")); + try expect(@ptrToInt(&a.c) - @ptrToInt(&a) == @byteOffsetOf(A, "c")); + try expect(@ptrToInt(&a.d) - @ptrToInt(&a) == @byteOffsetOf(A, "d")); + try expect(@ptrToInt(&a.e) - @ptrToInt(&a) == @byteOffsetOf(A, "e")); + try expect(@ptrToInt(&a.f) - @ptrToInt(&a) == @byteOffsetOf(A, "f")); + try expect(@ptrToInt(&a.g) - @ptrToInt(&a) == @byteOffsetOf(A, "g")); + try expect(@ptrToInt(&a.h) - @ptrToInt(&a) == @byteOffsetOf(A, "h")); + try expect(@ptrToInt(&a.i) - @ptrToInt(&a) == @byteOffsetOf(A, "i")); } 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 a: [p3a_len]u8, b: usize, }; - std.testing.expectEqual(0, @byteOffsetOf(P3, "a")); - std.testing.expectEqual(p3a_len, @byteOffsetOf(P3, "b")); + try std.testing.expectEqual(0, @byteOffsetOf(P3, "a")); + try std.testing.expectEqual(p3a_len, @byteOffsetOf(P3, "b")); const p5a_len = 5; const P5 = packed struct { a: [p5a_len]u8, b: usize, }; - std.testing.expectEqual(0, @byteOffsetOf(P5, "a")); - std.testing.expectEqual(p5a_len, @byteOffsetOf(P5, "b")); + try std.testing.expectEqual(0, @byteOffsetOf(P5, "a")); + try std.testing.expectEqual(p5a_len, @byteOffsetOf(P5, "b")); const p6a_len = 6; const P6 = packed struct { a: [p6a_len]u8, b: usize, }; - std.testing.expectEqual(0, @byteOffsetOf(P6, "a")); - std.testing.expectEqual(p6a_len, @byteOffsetOf(P6, "b")); + try std.testing.expectEqual(0, @byteOffsetOf(P6, "a")); + try std.testing.expectEqual(p6a_len, @byteOffsetOf(P6, "b")); const p7a_len = 7; const P7 = packed struct { a: [p7a_len]u8, b: usize, }; - std.testing.expectEqual(0, @byteOffsetOf(P7, "a")); - std.testing.expectEqual(p7a_len, @byteOffsetOf(P7, "b")); + try std.testing.expectEqual(0, @byteOffsetOf(P7, "a")); + try std.testing.expectEqual(p7a_len, @byteOffsetOf(P7, "b")); const p9a_len = 9; const P9 = packed struct { a: [p9a_len]u8, b: usize, }; - std.testing.expectEqual(0, @byteOffsetOf(P9, "a")); - std.testing.expectEqual(p9a_len, @byteOffsetOf(P9, "b")); + try std.testing.expectEqual(0, @byteOffsetOf(P9, "a")); + try std.testing.expectEqual(p9a_len, @byteOffsetOf(P9, "b")); // 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25 etc. are further cases } test "@bitOffsetOf" { // Packed structs have fixed memory layout - expect(@bitOffsetOf(P, "a") == 0); - expect(@bitOffsetOf(P, "b") == 8); - expect(@bitOffsetOf(P, "c") == 40); - expect(@bitOffsetOf(P, "d") == 48); - expect(@bitOffsetOf(P, "e") == 51); - expect(@bitOffsetOf(P, "f") == 56); - expect(@bitOffsetOf(P, "g") == 72); + try expect(@bitOffsetOf(P, "a") == 0); + try expect(@bitOffsetOf(P, "b") == 8); + try expect(@bitOffsetOf(P, "c") == 40); + try expect(@bitOffsetOf(P, "d") == 48); + try expect(@bitOffsetOf(P, "e") == 51); + try expect(@bitOffsetOf(P, "f") == 56); + try expect(@bitOffsetOf(P, "g") == 72); - expect(@byteOffsetOf(A, "a") * 8 == @bitOffsetOf(A, "a")); - expect(@byteOffsetOf(A, "b") * 8 == @bitOffsetOf(A, "b")); - expect(@byteOffsetOf(A, "c") * 8 == @bitOffsetOf(A, "c")); - expect(@byteOffsetOf(A, "d") * 8 == @bitOffsetOf(A, "d")); - expect(@byteOffsetOf(A, "e") * 8 == @bitOffsetOf(A, "e")); - expect(@byteOffsetOf(A, "f") * 8 == @bitOffsetOf(A, "f")); - expect(@byteOffsetOf(A, "g") * 8 == @bitOffsetOf(A, "g")); + try expect(@byteOffsetOf(A, "a") * 8 == @bitOffsetOf(A, "a")); + try expect(@byteOffsetOf(A, "b") * 8 == @bitOffsetOf(A, "b")); + try expect(@byteOffsetOf(A, "c") * 8 == @bitOffsetOf(A, "c")); + try expect(@byteOffsetOf(A, "d") * 8 == @bitOffsetOf(A, "d")); + try expect(@byteOffsetOf(A, "e") * 8 == @bitOffsetOf(A, "e")); + try expect(@byteOffsetOf(A, "f") * 8 == @bitOffsetOf(A, "f")); + try expect(@byteOffsetOf(A, "g") * 8 == @bitOffsetOf(A, "g")); } test "@sizeOf on compile-time types" { - expect(@sizeOf(comptime_int) == 0); - expect(@sizeOf(comptime_float) == 0); - expect(@sizeOf(@TypeOf(.hi)) == 0); - expect(@sizeOf(@TypeOf(type)) == 0); + try expect(@sizeOf(comptime_int) == 0); + try expect(@sizeOf(comptime_float) == 0); + try expect(@sizeOf(@TypeOf(.hi)) == 0); + try expect(@sizeOf(@TypeOf(type)) == 0); } test "@sizeOf(T) == 0 doesn't force resolving struct size" { @@ -140,8 +140,8 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" { }; }; - expect(@sizeOf(S.Foo) == 4); - expect(@sizeOf(S.Bar) == 8); + try expect(@sizeOf(S.Foo) == 4); + try expect(@sizeOf(S.Bar) == 8); } test "@TypeOf() has no runtime side effects" { @@ -153,8 +153,8 @@ test "@TypeOf() has no runtime side effects" { }; var data: i32 = 0; const T = @TypeOf(S.foo(i32, &data)); - comptime expect(T == i32); - expect(data == 0); + comptime try expect(T == i32); + try expect(data == 0); } test "@TypeOf() with multiple arguments" { @@ -162,21 +162,21 @@ test "@TypeOf() with multiple arguments" { var var_1: u32 = undefined; var var_2: u8 = undefined; var var_3: u64 = undefined; - comptime expect(@TypeOf(var_1, var_2, var_3) == u64); + comptime try expect(@TypeOf(var_1, var_2, var_3) == u64); } { var var_1: f16 = undefined; var var_2: f32 = undefined; var var_3: f64 = undefined; - comptime expect(@TypeOf(var_1, var_2, var_3) == f64); + comptime try expect(@TypeOf(var_1, var_2, var_3) == f64); } { var var_1: u16 = undefined; - comptime expect(@TypeOf(var_1, 0xffff) == u16); + comptime try expect(@TypeOf(var_1, 0xffff) == u16); } { var var_1: f32 = undefined; - comptime expect(@TypeOf(var_1, 3.1415) == f32); + comptime try expect(@TypeOf(var_1, 3.1415) == f32); } } @@ -189,8 +189,8 @@ test "branching logic inside @TypeOf" { } }; const T = @TypeOf(S.foo() catch undefined); - comptime expect(T == i32); - expect(S.data == 0); + comptime try expect(T == i32); + try expect(S.data == 0); } fn fn1(alpha: bool) void { @@ -203,12 +203,12 @@ test "lazy @sizeOf result is checked for definedness" { } test "@bitSizeOf" { - expect(@bitSizeOf(u2) == 2); - expect(@bitSizeOf(u8) == @sizeOf(u8) * 8); - expect(@bitSizeOf(struct { + try expect(@bitSizeOf(u2) == 2); + try expect(@bitSizeOf(u8) == @sizeOf(u8) * 8); + try expect(@bitSizeOf(struct { a: u2, }) == 8); - expect(@bitSizeOf(packed struct { + try expect(@bitSizeOf(packed struct { a: u2, }) == 2); } @@ -241,24 +241,24 @@ test "@sizeOf comparison against zero" { f2: H(***@This()), }; const S = struct { - fn doTheTest(comptime T: type, comptime result: bool) void { - expectEqual(result, @sizeOf(T) > 0); + fn doTheTest(comptime T: type, comptime result: bool) !void { + try expectEqual(result, @sizeOf(T) > 0); } }; // Zero-sized type - S.doTheTest(u0, false); - S.doTheTest(*u0, false); + try S.doTheTest(u0, false); + try S.doTheTest(*u0, false); // Non byte-sized type - S.doTheTest(u1, true); - S.doTheTest(*u1, true); + try S.doTheTest(u1, true); + try S.doTheTest(*u1, true); // Regular type - S.doTheTest(u8, true); - S.doTheTest(*u8, true); - S.doTheTest(f32, true); - S.doTheTest(*f32, true); + try S.doTheTest(u8, true); + try S.doTheTest(*u8, true); + try S.doTheTest(f32, true); + try S.doTheTest(*f32, true); // Container with ptr pointing to themselves - S.doTheTest(S0, true); - S.doTheTest(U0, true); - S.doTheTest(S1, true); - S.doTheTest(U1, true); + try S.doTheTest(S0, true); + try S.doTheTest(U0, true); + try S.doTheTest(S1, true); + try S.doTheTest(U1, true); } diff --git a/test/stage1/behavior/slice.zig b/test/stage1/behavior/slice.zig index 330e218f93..d324c34477 100644 --- a/test/stage1/behavior/slice.zig +++ b/test/stage1/behavior/slice.zig @@ -7,11 +7,11 @@ const mem = std.mem; const x = @intToPtr([*]i32, 0x1000)[0..0x500]; const y = x[0x100..]; test "compile time slice of pointer to hard coded address" { - expect(@ptrToInt(x) == 0x1000); - expect(x.len == 0x500); + try expect(@ptrToInt(x) == 0x1000); + try expect(x.len == 0x500); - expect(@ptrToInt(y) == 0x1100); - expect(y.len == 0x400); + try expect(@ptrToInt(y) == 0x1100); + try expect(y.len == 0x400); } test "runtime safety lets us slice from len..len" { @@ -20,7 +20,7 @@ test "runtime safety lets us slice from len..len" { 2, 3, }; - expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), "")); + try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), "")); } fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 { @@ -29,18 +29,18 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 { test "implicitly cast array of size 0 to slice" { var msg = [_]u8{}; - assertLenIsZero(&msg); + try assertLenIsZero(&msg); } -fn assertLenIsZero(msg: []const u8) void { - expect(msg.len == 0); +fn assertLenIsZero(msg: []const u8) !void { + try expect(msg.len == 0); } test "C pointer" { var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf"; var len: u32 = 10; var slice = buf[0..len]; - expectEqualSlices(u8, "kjdhfkjdhf", slice); + try expectEqualSlices(u8, "kjdhfkjdhf", slice); } test "C pointer slice access" { @@ -48,11 +48,11 @@ test "C pointer slice access" { const c_ptr = @ptrCast([*c]const u32, &buf); var runtime_zero: usize = 0; - comptime expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1])); - comptime expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1])); + comptime try expectEqual([]const u32, @TypeOf(c_ptr[runtime_zero..1])); + comptime try expectEqual(*const [1]u32, @TypeOf(c_ptr[0..1])); for (c_ptr[0..5]) |*cl| { - expectEqual(@as(u32, 42), cl.*); + try expectEqual(@as(u32, 42), cl.*); } } @@ -65,8 +65,8 @@ fn sliceSum(comptime q: []const u8) i32 { } test "comptime slices are disambiguated" { - expect(sliceSum(&[_]u8{ 1, 2 }) == 3); - expect(sliceSum(&[_]u8{ 3, 4 }) == 7); + try expect(sliceSum(&[_]u8{ 1, 2 }) == 3); + try expect(sliceSum(&[_]u8{ 3, 4 }) == 7); } test "slice type with custom alignment" { @@ -77,20 +77,20 @@ test "slice type with custom alignment" { var array: [10]LazilyResolvedType align(32) = undefined; slice = &array; slice[1].anything = 42; - expect(array[1].anything == 42); + try expect(array[1].anything == 42); } test "access len index of sentinel-terminated slice" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var slice: [:0]const u8 = "hello"; - expect(slice.len == 5); - expect(slice[5] == 0); + try expect(slice.len == 5); + try expect(slice[5] == 0); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "obtaining a null terminated slice" { @@ -108,230 +108,230 @@ test "obtaining a null terminated slice" { var runtime_len: usize = 3; const ptr2 = buf[0..runtime_len :0]; // ptr2 is a null-terminated slice - comptime expect(@TypeOf(ptr2) == [:0]u8); - comptime expect(@TypeOf(ptr2[0..2]) == *[2]u8); + comptime try expect(@TypeOf(ptr2) == [:0]u8); + comptime try expect(@TypeOf(ptr2[0..2]) == *[2]u8); var runtime_zero: usize = 0; - comptime expect(@TypeOf(ptr2[runtime_zero..2]) == []u8); + comptime try expect(@TypeOf(ptr2[runtime_zero..2]) == []u8); } test "empty array to slice" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const empty: []align(16) u8 = &[_]u8{}; const align_1: []align(1) u8 = empty; const align_4: []align(4) u8 = empty; const align_16: []align(16) u8 = empty; - expectEqual(1, @typeInfo(@TypeOf(align_1)).Pointer.alignment); - expectEqual(4, @typeInfo(@TypeOf(align_4)).Pointer.alignment); - expectEqual(16, @typeInfo(@TypeOf(align_16)).Pointer.alignment); + try expectEqual(1, @typeInfo(@TypeOf(align_1)).Pointer.alignment); + try expectEqual(4, @typeInfo(@TypeOf(align_4)).Pointer.alignment); + try expectEqual(16, @typeInfo(@TypeOf(align_16)).Pointer.alignment); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "@ptrCast slice to pointer" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var array align(@alignOf(u16)) = [5]u8{ 0xff, 0xff, 0xff, 0xff, 0xff }; var slice: []u8 = &array; var ptr = @ptrCast(*u16, slice); - expect(ptr.* == 65535); + try expect(ptr.* == 65535); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "slice syntax resulting in pointer-to-array" { const S = struct { - fn doTheTest() void { - testArray(); - testArrayZ(); - testArray0(); - testArrayAlign(); - testPointer(); - testPointerZ(); - testPointer0(); - testPointerAlign(); - testSlice(); - testSliceZ(); - testSlice0(); - testSliceOpt(); - testSliceAlign(); + fn doTheTest() !void { + try testArray(); + try testArrayZ(); + try testArray0(); + try testArrayAlign(); + try testPointer(); + try testPointerZ(); + try testPointer0(); + try testPointerAlign(); + try testSlice(); + try testSliceZ(); + try testSlice0(); + try testSliceOpt(); + try testSliceAlign(); } - fn testArray() void { + fn testArray() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var slice = array[1..3]; - comptime expect(@TypeOf(slice) == *[2]u8); - expect(slice[0] == 2); - expect(slice[1] == 3); + comptime try expect(@TypeOf(slice) == *[2]u8); + try expect(slice[0] == 2); + try expect(slice[1] == 3); } - fn testArrayZ() void { + fn testArrayZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; - comptime expect(@TypeOf(array[1..3]) == *[2]u8); - comptime expect(@TypeOf(array[1..5]) == *[4:0]u8); - comptime expect(@TypeOf(array[1..]) == *[4:0]u8); - comptime expect(@TypeOf(array[1..3 :4]) == *[2:4]u8); + comptime try expect(@TypeOf(array[1..3]) == *[2]u8); + comptime try expect(@TypeOf(array[1..5]) == *[4:0]u8); + comptime try expect(@TypeOf(array[1..]) == *[4:0]u8); + comptime try expect(@TypeOf(array[1..3 :4]) == *[2:4]u8); } - fn testArray0() void { + fn testArray0() !void { { var array = [0]u8{}; var slice = array[0..0]; - comptime expect(@TypeOf(slice) == *[0]u8); + comptime try expect(@TypeOf(slice) == *[0]u8); } { var array = [0:0]u8{}; var slice = array[0..0]; - comptime expect(@TypeOf(slice) == *[0:0]u8); - expect(slice[0] == 0); + comptime try expect(@TypeOf(slice) == *[0:0]u8); + try expect(slice[0] == 0); } } - fn testArrayAlign() void { + fn testArrayAlign() !void { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var slice = array[4..5]; - comptime expect(@TypeOf(slice) == *align(4) [1]u8); - expect(slice[0] == 5); - comptime expect(@TypeOf(array[0..2]) == *align(4) [2]u8); + comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try expect(slice[0] == 5); + comptime try expect(@TypeOf(array[0..2]) == *align(4) [2]u8); } - fn testPointer() void { + fn testPointer() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var pointer: [*]u8 = &array; var slice = pointer[1..3]; - comptime expect(@TypeOf(slice) == *[2]u8); - expect(slice[0] == 2); - expect(slice[1] == 3); + comptime try expect(@TypeOf(slice) == *[2]u8); + try expect(slice[0] == 2); + try expect(slice[1] == 3); } - fn testPointerZ() void { + fn testPointerZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var pointer: [*:0]u8 = &array; - comptime expect(@TypeOf(pointer[1..3]) == *[2]u8); - comptime expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8); + comptime try expect(@TypeOf(pointer[1..3]) == *[2]u8); + comptime try expect(@TypeOf(pointer[1..3 :4]) == *[2:4]u8); } - fn testPointer0() void { + fn testPointer0() !void { var pointer: [*]const u0 = &[1]u0{0}; var slice = pointer[0..1]; - comptime expect(@TypeOf(slice) == *const [1]u0); - expect(slice[0] == 0); + comptime try expect(@TypeOf(slice) == *const [1]u0); + try expect(slice[0] == 0); } - fn testPointerAlign() void { + fn testPointerAlign() !void { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var pointer: [*]align(4) u8 = &array; var slice = pointer[4..5]; - comptime expect(@TypeOf(slice) == *align(4) [1]u8); - expect(slice[0] == 5); - comptime expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8); + comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try expect(slice[0] == 5); + comptime try expect(@TypeOf(pointer[0..2]) == *align(4) [2]u8); } - fn testSlice() void { + fn testSlice() !void { var array = [5]u8{ 1, 2, 3, 4, 5 }; var src_slice: []u8 = &array; var slice = src_slice[1..3]; - comptime expect(@TypeOf(slice) == *[2]u8); - expect(slice[0] == 2); - expect(slice[1] == 3); + comptime try expect(@TypeOf(slice) == *[2]u8); + try expect(slice[0] == 2); + try expect(slice[1] == 3); } - fn testSliceZ() void { + fn testSliceZ() !void { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; var slice: [:0]u8 = &array; - comptime expect(@TypeOf(slice[1..3]) == *[2]u8); - comptime expect(@TypeOf(slice[1..]) == [:0]u8); - comptime expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); + comptime try expect(@TypeOf(slice[1..3]) == *[2]u8); + comptime try expect(@TypeOf(slice[1..]) == [:0]u8); + comptime try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8); } - fn testSliceOpt() void { + fn testSliceOpt() !void { var array: [2]u8 = [2]u8{ 1, 2 }; var slice: ?[]u8 = &array; - comptime expect(@TypeOf(&array, slice) == ?[]u8); - comptime expect(@TypeOf(slice.?[0..2]) == *[2]u8); + comptime try expect(@TypeOf(&array, slice) == ?[]u8); + comptime try expect(@TypeOf(slice.?[0..2]) == *[2]u8); } - fn testSlice0() void { + fn testSlice0() !void { { var array = [0]u8{}; var src_slice: []u8 = &array; var slice = src_slice[0..0]; - comptime expect(@TypeOf(slice) == *[0]u8); + comptime try expect(@TypeOf(slice) == *[0]u8); } { var array = [0:0]u8{}; var src_slice: [:0]u8 = &array; var slice = src_slice[0..0]; - comptime expect(@TypeOf(slice) == *[0]u8); + comptime try expect(@TypeOf(slice) == *[0]u8); } } - fn testSliceAlign() void { + fn testSliceAlign() !void { var array align(4) = [5]u8{ 1, 2, 3, 4, 5 }; var src_slice: []align(4) u8 = &array; var slice = src_slice[4..5]; - comptime expect(@TypeOf(slice) == *align(4) [1]u8); - expect(slice[0] == 5); - comptime expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8); + comptime try expect(@TypeOf(slice) == *align(4) [1]u8); + try expect(slice[0] == 5); + comptime try expect(@TypeOf(src_slice[0..2]) == *align(4) [2]u8); } - fn testConcatStrLiterals() void { - expectEqualSlices("a"[0..] ++ "b"[0..], "ab"); - expectEqualSlices("a"[0..:0] ++ "b"[0..:0], "ab"); + fn testConcatStrLiterals() !void { + try expectEqualSlices("a"[0..] ++ "b"[0..], "ab"); + try expectEqualSlices("a"[0.. :0] ++ "b"[0.. :0], "ab"); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "slice of hardcoded address to pointer" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const pointer = @intToPtr([*]u8, 0x04)[0..2]; - comptime expect(@TypeOf(pointer) == *[2]u8); + comptime try expect(@TypeOf(pointer) == *[2]u8); const slice: []const u8 = pointer; - expect(@ptrToInt(slice.ptr) == 4); - expect(slice.len == 2); + try expect(@ptrToInt(slice.ptr) == 4); + try expect(slice.len == 2); } }; - S.doTheTest(); + try S.doTheTest(); } test "type coercion of pointer to anon struct literal to pointer to slice" { const S = struct { - const U = union{ + const U = union { a: u32, b: bool, c: []const u8, }; - fn doTheTest() void { + fn doTheTest() !void { var x1: u8 = 42; const t1 = &.{ x1, 56, 54 }; var slice1: []const u8 = t1; - expect(slice1.len == 3); - expect(slice1[0] == 42); - expect(slice1[1] == 56); - expect(slice1[2] == 54); - + try expect(slice1.len == 3); + try expect(slice1[0] == 42); + try expect(slice1[1] == 56); + try expect(slice1[2] == 54); + var x2: []const u8 = "hello"; const t2 = &.{ x2, ", ", "world!" }; // @compileLog(@TypeOf(t2)); var slice2: []const []const u8 = t2; - expect(slice2.len == 3); - expect(mem.eql(u8, slice2[0], "hello")); - expect(mem.eql(u8, slice2[1], ", ")); - expect(mem.eql(u8, slice2[2], "world!")); + try expect(slice2.len == 3); + try expect(mem.eql(u8, slice2[0], "hello")); + try expect(mem.eql(u8, slice2[1], ", ")); + try expect(mem.eql(u8, slice2[2], "world!")); } }; - // S.doTheTest(); - comptime S.doTheTest(); + // try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/src.zig b/test/stage1/behavior/src.zig index 27fa144e54..9dd1badaae 100644 --- a/test/stage1/behavior/src.zig +++ b/test/stage1/behavior/src.zig @@ -2,16 +2,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); - expect(src.column == 17); - expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); - expect(std.mem.endsWith(u8, src.file, "src.zig")); - expect(src.fn_name[src.fn_name.len] == 0); - expect(src.file[src.file.len] == 0); + try expect(src.line == 9); + try expect(src.column == 17); + try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); + try expect(std.mem.endsWith(u8, src.file, "src.zig")); + try expect(src.fn_name[src.fn_name.len] == 0); + try expect(src.file[src.file.len] == 0); } diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig index f893e5b4ca..cf90936bdb 100644 --- a/test/stage1/behavior/struct.zig +++ b/test/stage1/behavior/struct.zig @@ -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); - expect(@sizeOf(VoidStructFieldsFoo) == 4); + try expect(foo.b == 1); + 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 { - expect(foo.b); +fn testFoo(foo: StructFoo) !void { + 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); - expect(getB(&data) == 2); - expect(getC(&data) == 3); - comptime expect(@sizeOf(BitField1) == 1); + try expect(getA(&data) == 1); + try expect(getB(&data) == 2); + try expect(getC(&data) == 3); + 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); - expect(data.b == 3); + try expect(data.a == 2); + 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); - expect(value.b == 0); - expect(value.c == 0); - expect(value.d == 0); + try expect(value.a == 1); + try expect(value.b == 0); + try expect(value.c == 0); + try expect(value.d == 0); value.b += 1; - expect(value.a == 1); - expect(value.b == 1); - expect(value.c == 0); - expect(value.d == 0); + try expect(value.a == 1); + try expect(value.b == 1); + try expect(value.c == 0); + try expect(value.d == 0); value.c += 1; - expect(value.a == 1); - expect(value.b == 1); - expect(value.c == 1); - expect(value.d == 0); + try expect(value.a == 1); + try expect(value.b == 1); + try expect(value.c == 1); + try expect(value.d == 0); value.d += 1; - expect(value.a == 1); - expect(value.b == 1); - expect(value.c == 1); - expect(value.d == 1); + try expect(value.a == 1); + try expect(value.b == 1); + try expect(value.c == 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); - expect(@sizeOf(FooArray24Bits) == 2 + 2 * 4 + 2); + try expect(@sizeOf([9]Foo32Bits) == 9 * 4); + 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); - expect(ptr.b[0].field == 0); - expect(ptr.b[1].field == 0); - expect(ptr.c == 0); + try expect(ptr.a == 0); + try expect(ptr.b[0].field == 0); + try expect(ptr.b[1].field == 0); + try expect(ptr.c == 0); ptr.a = maxInt(u16); - expect(ptr.a == maxInt(u16)); - expect(ptr.b[0].field == 0); - expect(ptr.b[1].field == 0); - expect(ptr.c == 0); + try expect(ptr.a == maxInt(u16)); + try expect(ptr.b[0].field == 0); + try expect(ptr.b[1].field == 0); + try expect(ptr.c == 0); ptr.b[0].field = maxInt(u24); - expect(ptr.a == maxInt(u16)); - expect(ptr.b[0].field == maxInt(u24)); - expect(ptr.b[1].field == 0); - expect(ptr.c == 0); + try expect(ptr.a == maxInt(u16)); + try expect(ptr.b[0].field == maxInt(u24)); + try expect(ptr.b[1].field == 0); + try expect(ptr.c == 0); ptr.b[1].field = maxInt(u24); - expect(ptr.a == maxInt(u16)); - expect(ptr.b[0].field == maxInt(u24)); - expect(ptr.b[1].field == maxInt(u24)); - expect(ptr.c == 0); + try expect(ptr.a == maxInt(u16)); + try expect(ptr.b[0].field == maxInt(u24)); + try expect(ptr.b[1].field == maxInt(u24)); + try expect(ptr.c == 0); ptr.c = maxInt(u16); - expect(ptr.a == maxInt(u16)); - expect(ptr.b[0].field == maxInt(u24)); - expect(ptr.b[1].field == maxInt(u24)); - expect(ptr.c == maxInt(u16)); + try expect(ptr.a == maxInt(u16)); + try expect(ptr.b[0].field == maxInt(u24)); + try expect(ptr.b[1].field == maxInt(u24)); + 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); - expect(@sizeOf(FooArrayOfAligned) == 2 * 2); + try expect(@sizeOf(FooStructAligned) == 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); - expect(ptr.a[0].b == 0xbb); - expect(ptr.a[1].a == 0xbb); - expect(ptr.a[1].b == 0xbb); + try expect(ptr.a[0].a == 0xbb); + try expect(ptr.a[0].b == 0xbb); + try expect(ptr.a[1].a == 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); - expect(s1.y == x1); - expect(s2.x == @intCast(u4, x2)); - expect(s2.y == @intCast(u4, x2)); + try expect(s1.x == x1); + try expect(s1.y == x1); + try expect(s2.x == @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); - expect(bitfields.f2 == 0x2222); - expect(bitfields.f3 == 0x33); - expect(bitfields.f4 == 0x44); - expect(bitfields.f5 == 0x5); - expect(bitfields.f6 == 0x6); - expect(bitfields.f7 == 0x77); + try expect(bitfields.f1 == 0x1111); + try expect(bitfields.f2 == 0x2222); + try expect(bitfields.f3 == 0x33); + try expect(bitfields.f4 == 0x44); + try expect(bitfields.f5 == 0x5); + try expect(bitfields.f6 == 0x6); + 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)); - expect(s.doC()); - expect(S.do(&s)); - expect(s.do()); + try expect(S.doC(&s)); + try expect(s.doC()); + try expect(S.do(&s)); + 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 { - expectEqualSlices(u8, slice, "abcdefghijklmnopqurstu"); + fn bar(slice: []const u8) !void { + 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(); - comptime S.doTheTest(); + try 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]); - expectEqual(@as(f32, 11.0), s.data[1]); - expectEqual(@as(f32, 20.0), s.data[2]); + try expectEqual(@as(f32, 6.0), s.data[0]); + try expectEqual(@as(f32, 11.0), s.data[1]); + 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(); - comptime S.entry(); + try 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(); - comptime S.doTheTest(); + try 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); - expect(s.y == 42); + try expect(s.x == 1); + 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); - expect(p.y == 2); + try expect(p.x == 1); + try expect(p.y == 2); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "fully anonymous struct" { const S = struct { - fn doTheTest() void { - dump(.{ + fn doTheTest() !void { + try dump(.{ .int = @as(u32, 1234), .float = @as(f64, 12.34), .b = true, .s = "hi", }); } - fn dump(args: anytype) void { - expect(args.int == 1234); - expect(args.float == 12.34); - expect(args.b); - expect(args.s[0] == 'h'); - expect(args.s[1] == 'i'); + fn dump(args: anytype) !void { + try expect(args.int == 1234); + try expect(args.float == 12.34); + try expect(args.b); + try expect(args.s[0] == 'h'); + try expect(args.s[1] == 'i'); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "fully anonymous list literal" { const S = struct { - fn doTheTest() void { - dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" }); + fn doTheTest() !void { + try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" }); } - fn dump(args: anytype) void { - expect(args.@"0" == 1234); - expect(args.@"1" == 12.34); - expect(args.@"2"); - expect(args.@"3"[0] == 'h'); - expect(args.@"3"[1] == 'i'); + fn dump(args: anytype) !void { + try expect(args.@"0" == 1234); + try expect(args.@"1" == 12.34); + try expect(args.@"2"); + try expect(args.@"3"[0] == 'h'); + try expect(args.@"3"[1] == 'i'); } }; - S.doTheTest(); - comptime S.doTheTest(); + try 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); - expect(vec.@"1" == 55); - expect(vec.@"2" == 99); + try expect(vec.@"0" == 22); + try expect(vec.@"1" == 55); + 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); - expect(pt.y == 2); + try expect(pt.x == 1); + 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(); - comptime S.doTheTest(); + try 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); - expectEqual(true, True.kind.Bool); + try expectEqual(@as(u32, 2), True.ref); + 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); - expect(std.mem.eql(u8, y0.B, "foo")); - expect(y0.C == {}); - expect(y0.D.field == 1234); - expect(y1.A == y); - expect(std.mem.eql(u8, y1.B, "foo")); - expect(y1.C == {}); - expect(y1.D.field == 1234); + try expect(y0.A == 123); + try expect(std.mem.eql(u8, y0.B, "foo")); + try expect(y0.C == {}); + try expect(y0.D.field == 1234); + try expect(y1.A == y); + try expect(std.mem.eql(u8, y1.B, "foo")); + try expect(y1.C == {}); + try expect(y1.D.field == 1234); } }; - S.doTheTest(); - comptime S.doTheTest(); + try 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); - expect(std.mem.eql(u8, y0.B, "foo")); - expect(y0.C == {}); - expect(y0.D.field == 1234); - expect(y1.A == y); - expect(std.mem.eql(u8, y1.B, "foo")); - expect(y1.C == {}); - expect(y1.D.field == 1234); + try expect(y0.A == 123); + try expect(std.mem.eql(u8, y0.B, "foo")); + try expect(y0.C == {}); + try expect(y0.D.field == 1234); + try expect(y1.A == y); + try expect(std.mem.eql(u8, y1.B, "foo")); + try expect(y1.C == {}); + try expect(y1.D.field == 1234); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "packed struct with undefined initializers" { @@ -929,16 +929,16 @@ 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); - expectEqual(@as(u3, 4), p.b); - expectEqual(@as(u3, 6), p.c); + try expectEqual(@as(u3, 2), p.a); + try expectEqual(@as(u3, 4), p.b); + try expectEqual(@as(u3, 6), p.c); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/struct_contains_null_ptr_itself.zig b/test/stage1/behavior/struct_contains_null_ptr_itself.zig index 991d742cec..28aa1d57aa 100644 --- a/test/stage1/behavior/struct_contains_null_ptr_itself.zig +++ b/test/stage1/behavior/struct_contains_null_ptr_itself.zig @@ -3,7 +3,7 @@ const expect = std.testing.expect; test "struct contains null pointer which contains original struct" { var x: ?*NodeLineComment = null; - expect(x == null); + try expect(x == null); } pub const Node = struct { diff --git a/test/stage1/behavior/struct_contains_slice_of_itself.zig b/test/stage1/behavior/struct_contains_slice_of_itself.zig index 14bf0320a2..11b838a758 100644 --- a/test/stage1/behavior/struct_contains_slice_of_itself.zig +++ b/test/stage1/behavior/struct_contains_slice_of_itself.zig @@ -39,12 +39,12 @@ test "struct contains slice of itself" { .payload = 1234, .children = nodes[0..], }; - expect(root.payload == 1234); - expect(root.children[0].payload == 1); - expect(root.children[1].payload == 2); - expect(root.children[2].payload == 3); - expect(root.children[2].children[0].payload == 31); - expect(root.children[2].children[1].payload == 32); + try expect(root.payload == 1234); + try expect(root.children[0].payload == 1); + try expect(root.children[1].payload == 2); + try expect(root.children[2].payload == 3); + try expect(root.children[2].children[0].payload == 31); + try expect(root.children[2].children[1].payload == 32); } test "struct contains aligned slice of itself" { @@ -76,10 +76,10 @@ test "struct contains aligned slice of itself" { .payload = 1234, .children = nodes[0..], }; - expect(root.payload == 1234); - expect(root.children[0].payload == 1); - expect(root.children[1].payload == 2); - expect(root.children[2].payload == 3); - expect(root.children[2].children[0].payload == 31); - expect(root.children[2].children[1].payload == 32); + try expect(root.payload == 1234); + try expect(root.children[0].payload == 1); + try expect(root.children[1].payload == 2); + try expect(root.children[2].payload == 3); + try expect(root.children[2].children[0].payload == 31); + try expect(root.children[2].children[1].payload == 32); } diff --git a/test/stage1/behavior/switch.zig b/test/stage1/behavior/switch.zig index 20ca0d3146..9d05e3edea 100644 --- a/test/stage1/behavior/switch.zig +++ b/test/stage1/behavior/switch.zig @@ -4,23 +4,23 @@ const expectError = std.testing.expectError; const expectEqual = std.testing.expectEqual; test "switch with numbers" { - testSwitchWithNumbers(13); + try testSwitchWithNumbers(13); } -fn testSwitchWithNumbers(x: u32) void { +fn testSwitchWithNumbers(x: u32) !void { const result = switch (x) { 1, 2, 3, 4...8 => false, 13 => true, else => false, }; - expect(result); + try expect(result); } test "switch with all ranges" { - expect(testSwitchWithAllRanges(50, 3) == 1); - expect(testSwitchWithAllRanges(101, 0) == 2); - expect(testSwitchWithAllRanges(300, 5) == 3); - expect(testSwitchWithAllRanges(301, 6) == 6); + try expect(testSwitchWithAllRanges(50, 3) == 1); + try expect(testSwitchWithAllRanges(101, 0) == 2); + try expect(testSwitchWithAllRanges(300, 5) == 3); + try expect(testSwitchWithAllRanges(301, 6) == 6); } fn testSwitchWithAllRanges(x: u32, y: u32) u32 { @@ -43,7 +43,7 @@ test "implicit comptime switch" { }; comptime { - expect(result + 1 == 14); + try expect(result + 1 == 14); } } @@ -65,16 +65,16 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void { } test "switch statement" { - nonConstSwitch(SwitchStatmentFoo.C); + try nonConstSwitch(SwitchStatmentFoo.C); } -fn nonConstSwitch(foo: SwitchStatmentFoo) void { +fn nonConstSwitch(foo: SwitchStatmentFoo) !void { const val = switch (foo) { SwitchStatmentFoo.A => @as(i32, 1), SwitchStatmentFoo.B => 2, SwitchStatmentFoo.C => 3, SwitchStatmentFoo.D => 4, }; - expect(val == 3); + try expect(val == 3); } const SwitchStatmentFoo = enum { A, @@ -84,22 +84,22 @@ const SwitchStatmentFoo = enum { }; test "switch prong with variable" { - switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); - switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); - switchProngWithVarFn(SwitchProngWithVarEnum{ .Meh = {} }); + try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); + try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); + try switchProngWithVarFn(SwitchProngWithVarEnum{ .Meh = {} }); } const SwitchProngWithVarEnum = union(enum) { One: i32, Two: f32, Meh: void, }; -fn switchProngWithVarFn(a: SwitchProngWithVarEnum) void { +fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void { switch (a) { SwitchProngWithVarEnum.One => |x| { - expect(x == 13); + try expect(x == 13); }, SwitchProngWithVarEnum.Two => |x| { - expect(x == 13.0); + try expect(x == 13.0); }, SwitchProngWithVarEnum.Meh => |x| { const v: void = x; @@ -108,18 +108,18 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) void { } test "switch on enum using pointer capture" { - testSwitchEnumPtrCapture(); - comptime testSwitchEnumPtrCapture(); + try testSwitchEnumPtrCapture(); + comptime try testSwitchEnumPtrCapture(); } -fn testSwitchEnumPtrCapture() void { +fn testSwitchEnumPtrCapture() !void { var value = SwitchProngWithVarEnum{ .One = 1234 }; switch (value) { SwitchProngWithVarEnum.One => |*x| x.* += 1, else => unreachable, } switch (value) { - SwitchProngWithVarEnum.One => |x| expect(x == 1235), + SwitchProngWithVarEnum.One => |x| try expect(x == 1235), else => unreachable, } } @@ -130,7 +130,7 @@ test "switch with multiple expressions" { 4, 5, 6 => 2, else => @as(i32, 3), }; - expect(x == 2); + try expect(x == 2); } fn returnsFive() i32 { return 5; @@ -152,12 +152,12 @@ fn returnsFalse() bool { } } test "switch on const enum with var" { - expect(!returnsFalse()); + try expect(!returnsFalse()); } test "switch on type" { - expect(trueIfBoolFalseOtherwise(bool)); - expect(!trueIfBoolFalseOtherwise(i32)); + try expect(trueIfBoolFalseOtherwise(bool)); + try expect(!trueIfBoolFalseOtherwise(i32)); } fn trueIfBoolFalseOtherwise(comptime T: type) bool { @@ -168,21 +168,21 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool { } test "switch handles all cases of number" { - testSwitchHandleAllCases(); - comptime testSwitchHandleAllCases(); + try testSwitchHandleAllCases(); + comptime try testSwitchHandleAllCases(); } -fn testSwitchHandleAllCases() void { - expect(testSwitchHandleAllCasesExhaustive(0) == 3); - expect(testSwitchHandleAllCasesExhaustive(1) == 2); - expect(testSwitchHandleAllCasesExhaustive(2) == 1); - expect(testSwitchHandleAllCasesExhaustive(3) == 0); +fn testSwitchHandleAllCases() !void { + try expect(testSwitchHandleAllCasesExhaustive(0) == 3); + try expect(testSwitchHandleAllCasesExhaustive(1) == 2); + try expect(testSwitchHandleAllCasesExhaustive(2) == 1); + try expect(testSwitchHandleAllCasesExhaustive(3) == 0); - expect(testSwitchHandleAllCasesRange(100) == 0); - expect(testSwitchHandleAllCasesRange(200) == 1); - expect(testSwitchHandleAllCasesRange(201) == 2); - expect(testSwitchHandleAllCasesRange(202) == 4); - expect(testSwitchHandleAllCasesRange(230) == 3); + try expect(testSwitchHandleAllCasesRange(100) == 0); + try expect(testSwitchHandleAllCasesRange(200) == 1); + try expect(testSwitchHandleAllCasesRange(201) == 2); + try expect(testSwitchHandleAllCasesRange(202) == 4); + try expect(testSwitchHandleAllCasesRange(230) == 3); } fn testSwitchHandleAllCasesExhaustive(x: u2) u2 { @@ -205,13 +205,13 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 { } test "switch all prongs unreachable" { - testAllProngsUnreachable(); - comptime testAllProngsUnreachable(); + try testAllProngsUnreachable(); + comptime try testAllProngsUnreachable(); } -fn testAllProngsUnreachable() void { - expect(switchWithUnreachable(1) == 2); - expect(switchWithUnreachable(2) == 10); +fn testAllProngsUnreachable() !void { + try expect(switchWithUnreachable(1) == 2); + try expect(switchWithUnreachable(2) == 10); } fn switchWithUnreachable(x: i32) i32 { @@ -233,23 +233,23 @@ test "capture value of switch with all unreachable prongs" { const x = return_a_number() catch |err| switch (err) { else => unreachable, }; - expect(x == 1); + try expect(x == 1); } test "switching on booleans" { - testSwitchOnBools(); - comptime testSwitchOnBools(); + try testSwitchOnBools(); + comptime try testSwitchOnBools(); } -fn testSwitchOnBools() void { - expect(testSwitchOnBoolsTrueAndFalse(true) == false); - expect(testSwitchOnBoolsTrueAndFalse(false) == true); +fn testSwitchOnBools() !void { + try expect(testSwitchOnBoolsTrueAndFalse(true) == false); + try expect(testSwitchOnBoolsTrueAndFalse(false) == true); - expect(testSwitchOnBoolsTrueWithElse(true) == false); - expect(testSwitchOnBoolsTrueWithElse(false) == true); + try expect(testSwitchOnBoolsTrueWithElse(true) == false); + try expect(testSwitchOnBoolsTrueWithElse(false) == true); - expect(testSwitchOnBoolsFalseWithElse(true) == false); - expect(testSwitchOnBoolsFalseWithElse(false) == true); + try expect(testSwitchOnBoolsFalseWithElse(true) == false); + try expect(testSwitchOnBoolsFalseWithElse(false) == true); } fn testSwitchOnBoolsTrueAndFalse(x: bool) bool { @@ -276,14 +276,14 @@ fn testSwitchOnBoolsFalseWithElse(x: bool) bool { test "u0" { var val: u0 = 0; switch (val) { - 0 => expect(val == 0), + 0 => try expect(val == 0), } } test "undefined.u0" { var val: u0 = undefined; switch (val) { - 0 => expect(val == 0), + 0 => try expect(val == 0), } } @@ -295,15 +295,15 @@ test "anon enum literal used in switch on union enum" { var foo = Foo{ .a = 1234 }; switch (foo) { .a => |x| { - expect(x == 1234); + try expect(x == 1234); }, } } test "else prong of switch on error set excludes other cases" { const S = struct { - fn doTheTest() void { - expectError(error.C, bar()); + fn doTheTest() !void { + try expectError(error.C, bar()); } const E = error{ A, @@ -326,14 +326,14 @@ test "else prong of switch on error set excludes other cases" { }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "switch prongs with error set cases make a new error set type for capture value" { const S = struct { - fn doTheTest() void { - expectError(error.B, bar()); + fn doTheTest() !void { + try expectError(error.B, bar()); } const E = E1 || E2; @@ -358,14 +358,14 @@ test "switch prongs with error set cases make a new error set type for capture v }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "return result loc and then switch with range implicit casted to error union" { const S = struct { - fn doTheTest() void { - expect((func(0xb) catch unreachable) == 0xb); + fn doTheTest() !void { + try expect((func(0xb) catch unreachable) == 0xb); } fn func(d: u8) anyerror!u8 { return switch (d) { @@ -374,13 +374,13 @@ test "return result loc and then switch with range implicit casted to error unio }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "switch with null and T peer types and inferred result location type" { const S = struct { - fn doTheTest(c: u8) void { + fn doTheTest(c: u8) !void { if (switch (c) { 0 => true, else => null, @@ -389,8 +389,8 @@ test "switch with null and T peer types and inferred result location type" { } } }; - S.doTheTest(1); - comptime S.doTheTest(1); + try S.doTheTest(1); + comptime try S.doTheTest(1); } test "switch prongs with cases with identical payload types" { @@ -400,31 +400,31 @@ test "switch prongs with cases with identical payload types" { C: usize, }; const S = struct { - fn doTheTest() void { - doTheSwitch1(Union{ .A = 8 }); - doTheSwitch2(Union{ .B = -8 }); + fn doTheTest() !void { + try doTheSwitch1(Union{ .A = 8 }); + try doTheSwitch2(Union{ .B = -8 }); } - fn doTheSwitch1(u: Union) void { + fn doTheSwitch1(u: Union) !void { switch (u) { .A, .C => |e| { - expect(@TypeOf(e) == usize); - expect(e == 8); + try expect(@TypeOf(e) == usize); + try expect(e == 8); }, .B => |e| @panic("fail"), } } - fn doTheSwitch2(u: Union) void { + fn doTheSwitch2(u: Union) !void { switch (u) { .A, .C => |e| @panic("fail"), .B => |e| { - expect(@TypeOf(e) == isize); - expect(e == -8); + try expect(@TypeOf(e) == isize); + try expect(e == -8); }, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "switch with disjoint range" { @@ -438,19 +438,19 @@ test "switch with disjoint range" { test "switch variable for range and multiple prongs" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var u: u8 = 16; - doTheSwitch(u); - comptime doTheSwitch(u); + try doTheSwitch(u); + comptime try doTheSwitch(u); var v: u8 = 42; - doTheSwitch(v); - comptime doTheSwitch(v); + try doTheSwitch(v); + comptime try doTheSwitch(v); } - fn doTheSwitch(q: u8) void { + fn doTheSwitch(q: u8) !void { switch (q) { - 0...40 => |x| expect(x == 16), - 41, 42, 43 => |x| expect(x == 42), - else => expect(false), + 0...40 => |x| try expect(x == 16), + 41, 42, 43 => |x| try expect(x == 42), + else => try expect(false), } } }; @@ -493,31 +493,31 @@ test "switch on pointer type" { } }; - expect(1 == S.doTheTest(S.P1)); - expect(2 == S.doTheTest(S.P2)); - expect(3 == S.doTheTest(S.P3)); - comptime expect(1 == S.doTheTest(S.P1)); - comptime expect(2 == S.doTheTest(S.P2)); - comptime expect(3 == S.doTheTest(S.P3)); + try expect(1 == S.doTheTest(S.P1)); + try expect(2 == S.doTheTest(S.P2)); + try expect(3 == S.doTheTest(S.P3)); + comptime try expect(1 == S.doTheTest(S.P1)); + comptime try expect(2 == S.doTheTest(S.P2)); + comptime try expect(3 == S.doTheTest(S.P3)); } test "switch on error set with single else" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var some: error{Foo} = error.Foo; - expect(switch (some) { + try expect(switch (some) { else => |a| true, }); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "while copies its payload" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var tmp: union(enum) { A: u8, B: u32, @@ -526,12 +526,12 @@ test "while copies its payload" { .A => |value| { // Modify the original union tmp = .{ .B = 0x10101010 }; - expectEqual(@as(u8, 42), value); + try expectEqual(@as(u8, 42), value); }, else => unreachable, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/switch_prong_err_enum.zig b/test/stage1/behavior/switch_prong_err_enum.zig index 3593eabb5a..b68f21df6f 100644 --- a/test/stage1/behavior/switch_prong_err_enum.zig +++ b/test/stage1/behavior/switch_prong_err_enum.zig @@ -22,9 +22,9 @@ fn doThing(form_id: u64) anyerror!FormValue { test "switch prong returns error enum" { switch (doThing(17) catch unreachable) { FormValue.Address => |payload| { - expect(payload == 1); + try expect(payload == 1); }, else => unreachable, } - expect(read_count == 1); + try expect(read_count == 1); } diff --git a/test/stage1/behavior/switch_prong_implicit_cast.zig b/test/stage1/behavior/switch_prong_implicit_cast.zig index da965915ca..bc08fea93f 100644 --- a/test/stage1/behavior/switch_prong_implicit_cast.zig +++ b/test/stage1/behavior/switch_prong_implicit_cast.zig @@ -18,5 +18,5 @@ test "switch prong implicit cast" { FormValue.One => false, FormValue.Two => |x| x, }; - expect(result); + try expect(result); } diff --git a/test/stage1/behavior/this.zig b/test/stage1/behavior/this.zig index 927c0808ea..086fe2814a 100644 --- a/test/stage1/behavior/this.zig +++ b/test/stage1/behavior/this.zig @@ -20,7 +20,7 @@ fn add(x: i32, y: i32) i32 { } test "this refer to module call private fn" { - expect(module.add(1, 2) == 3); + try expect(module.add(1, 2) == 3); } test "this refer to container" { @@ -29,6 +29,6 @@ test "this refer to container" { .y = 34, }; pt.addOne(); - expect(pt.x == 13); - expect(pt.y == 35); + try expect(pt.x == 13); + try expect(pt.y == 35); } diff --git a/test/stage1/behavior/translate_c_macros.zig b/test/stage1/behavior/translate_c_macros.zig index 640f1c8c86..21b289af25 100644 --- a/test/stage1/behavior/translate_c_macros.zig +++ b/test/stage1/behavior/translate_c_macros.zig @@ -4,7 +4,7 @@ const expectEqual = @import("std").testing.expectEqual; const h = @cImport(@cInclude("stage1/behavior/translate_c_macros.h")); test "initializer list expression" { - expectEqual(h.Color{ + try expectEqual(h.Color{ .r = 200, .g = 200, .b = 200, @@ -13,10 +13,10 @@ test "initializer list expression" { } test "sizeof in macros" { - expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32)); - expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32)); + try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF(u32)); + try expectEqual(@as(c_int, @sizeOf(u32)), h.MY_SIZEOF2(u32)); } test "reference to a struct type" { - expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO); + try expectEqual(@sizeOf(h.struct_Foo), h.SIZE_OF_FOO); } diff --git a/test/stage1/behavior/truncate.zig b/test/stage1/behavior/truncate.zig index 099b6c3359..0d67c5d6dd 100644 --- a/test/stage1/behavior/truncate.zig +++ b/test/stage1/behavior/truncate.zig @@ -4,33 +4,33 @@ const expect = std.testing.expect; test "truncate u0 to larger integer allowed and has comptime known result" { var x: u0 = 0; const y = @truncate(u8, x); - comptime expect(y == 0); + comptime try expect(y == 0); } test "truncate.u0.literal" { var z = @truncate(u0, 0); - expect(z == 0); + try expect(z == 0); } test "truncate.u0.const" { const c0: usize = 0; var z = @truncate(u0, c0); - expect(z == 0); + try expect(z == 0); } test "truncate.u0.var" { var d: u8 = 2; var z = @truncate(u0, d); - expect(z == 0); + try expect(z == 0); } test "truncate sign mismatch but comptime known so it works anyway" { const x: u32 = 10; var result = @truncate(i8, x); - expect(result == 10); + try expect(result == 10); } test "truncate on comptime integer" { var x = @truncate(u16, 9999); - expect(x == 9999); + try expect(x == 9999); } diff --git a/test/stage1/behavior/try.zig b/test/stage1/behavior/try.zig index 9e93183c3b..029d946588 100644 --- a/test/stage1/behavior/try.zig +++ b/test/stage1/behavior/try.zig @@ -1,17 +1,17 @@ const expect = @import("std").testing.expect; test "try on error union" { - tryOnErrorUnionImpl(); - comptime tryOnErrorUnionImpl(); + try tryOnErrorUnionImpl(); + comptime try tryOnErrorUnionImpl(); } -fn tryOnErrorUnionImpl() void { +fn tryOnErrorUnionImpl() !void { const x = if (returnsTen()) |val| val + 1 else |err| switch (err) { error.ItBroke, error.NoMem => 1, error.CrappedOut => @as(i32, 2), else => unreachable, }; - expect(x == 11); + try expect(x == 11); } fn returnsTen() anyerror!i32 { @@ -20,10 +20,10 @@ fn returnsTen() anyerror!i32 { test "try without vars" { const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2); - expect(result1 == 2); + try expect(result1 == 2); const result2 = if (failIfTrue(false)) 1 else |_| @as(i32, 2); - expect(result2 == 1); + try expect(result2 == 1); } fn failIfTrue(ok: bool) anyerror!void { @@ -38,6 +38,6 @@ test "try then not executed with assignment" { if (failIfTrue(true)) { unreachable; } else |err| { - expect(err == error.ItBroke); + try expect(err == error.ItBroke); } } diff --git a/test/stage1/behavior/tuple.zig b/test/stage1/behavior/tuple.zig index 4eb5b73abb..0a32c664dd 100644 --- a/test/stage1/behavior/tuple.zig +++ b/test/stage1/behavior/tuple.zig @@ -5,93 +5,93 @@ const expectEqual = testing.expectEqual; test "tuple concatenation" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var a: i32 = 1; var b: i32 = 2; var x = .{a}; var y = .{b}; var c = x ++ y; - expectEqual(@as(i32, 1), c[0]); - expectEqual(@as(i32, 2), c[1]); + try expectEqual(@as(i32, 1), c[0]); + try expectEqual(@as(i32, 2), c[1]); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "tuple multiplication" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { { const t = .{} ** 4; - expectEqual(0, @typeInfo(@TypeOf(t)).Struct.fields.len); + try expectEqual(0, @typeInfo(@TypeOf(t)).Struct.fields.len); } { const t = .{'a'} ** 4; - expectEqual(4, @typeInfo(@TypeOf(t)).Struct.fields.len); - inline for (t) |x| expectEqual('a', x); + try expectEqual(4, @typeInfo(@TypeOf(t)).Struct.fields.len); + inline for (t) |x| try expectEqual('a', x); } { const t = .{ 1, 2, 3 } ** 4; - expectEqual(12, @typeInfo(@TypeOf(t)).Struct.fields.len); - inline for (t) |x, i| expectEqual(1 + i % 3, x); + try expectEqual(12, @typeInfo(@TypeOf(t)).Struct.fields.len); + inline for (t) |x, i| try expectEqual(1 + i % 3, x); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); const T = struct { - fn consume_tuple(tuple: anytype, len: usize) void { - expect(tuple.len == len); + fn consume_tuple(tuple: anytype, len: usize) !void { + try expect(tuple.len == len); } - fn doTheTest() void { + fn doTheTest() !void { const t1 = .{}; var rt_var: u8 = 42; const t2 = .{rt_var} ++ .{}; - expect(t2.len == 1); - expect(t2.@"0" == rt_var); - expect(t2.@"0" == 42); - expect(&t2.@"0" != &rt_var); + try expect(t2.len == 1); + try expect(t2.@"0" == rt_var); + try expect(t2.@"0" == 42); + try expect(&t2.@"0" != &rt_var); - consume_tuple(t1 ++ t1, 0); - consume_tuple(.{} ++ .{}, 0); - consume_tuple(.{0} ++ .{}, 1); - consume_tuple(.{0} ++ .{1}, 2); - consume_tuple(.{ 0, 1, 2 } ++ .{ u8, 1, noreturn }, 6); - consume_tuple(t2 ++ t1, 1); - consume_tuple(t1 ++ t2, 1); - consume_tuple(t2 ++ t2, 2); - consume_tuple(.{rt_var} ++ .{}, 1); - consume_tuple(.{rt_var} ++ t1, 1); - consume_tuple(.{} ++ .{rt_var}, 1); - consume_tuple(t2 ++ .{void}, 2); - consume_tuple(t2 ++ .{0}, 2); - consume_tuple(.{0} ++ t2, 2); - consume_tuple(.{void} ++ t2, 2); - consume_tuple(.{u8} ++ .{rt_var} ++ .{true}, 3); + try consume_tuple(t1 ++ t1, 0); + try consume_tuple(.{} ++ .{}, 0); + try consume_tuple(.{0} ++ .{}, 1); + try consume_tuple(.{0} ++ .{1}, 2); + try consume_tuple(.{ 0, 1, 2 } ++ .{ u8, 1, noreturn }, 6); + try consume_tuple(t2 ++ t1, 1); + try consume_tuple(t1 ++ t2, 1); + try consume_tuple(t2 ++ t2, 2); + try consume_tuple(.{rt_var} ++ .{}, 1); + try consume_tuple(.{rt_var} ++ t1, 1); + try consume_tuple(.{} ++ .{rt_var}, 1); + try consume_tuple(t2 ++ .{void}, 2); + try consume_tuple(t2 ++ .{0}, 2); + try consume_tuple(.{0} ++ t2, 2); + try consume_tuple(.{void} ++ t2, 2); + try consume_tuple(.{u8} ++ .{rt_var} ++ .{true}, 3); } }; - T.doTheTest(); - comptime T.doTheTest(); + try T.doTheTest(); + comptime try T.doTheTest(); } test "pass tuple to comptime var parameter" { const S = struct { - fn Foo(comptime args: anytype) void { - expect(args[0] == 1); + fn Foo(comptime args: anytype) !void { + try expect(args[0] == 1); } - fn doTheTest() void { - Foo(.{1}); + fn doTheTest() !void { + try Foo(.{1}); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "tuple initializer for var" { diff --git a/test/stage1/behavior/type.zig b/test/stage1/behavior/type.zig index 7b0f3a9e6c..7a01283bfb 100644 --- a/test/stage1/behavior/type.zig +++ b/test/stage1/behavior/type.zig @@ -4,52 +4,52 @@ const TypeInfo = builtin.TypeInfo; const std = @import("std"); const testing = std.testing; -fn testTypes(comptime types: []const type) void { +fn testTypes(comptime types: []const type) !void { inline for (types) |testType| { - testing.expect(testType == @Type(@typeInfo(testType))); + try testing.expect(testType == @Type(@typeInfo(testType))); } } test "Type.MetaType" { - testing.expect(type == @Type(TypeInfo{ .Type = undefined })); - testTypes(&[_]type{type}); + try testing.expect(type == @Type(TypeInfo{ .Type = undefined })); + try testTypes(&[_]type{type}); } test "Type.Void" { - testing.expect(void == @Type(TypeInfo{ .Void = undefined })); - testTypes(&[_]type{void}); + try testing.expect(void == @Type(TypeInfo{ .Void = undefined })); + try testTypes(&[_]type{void}); } test "Type.Bool" { - testing.expect(bool == @Type(TypeInfo{ .Bool = undefined })); - testTypes(&[_]type{bool}); + try testing.expect(bool == @Type(TypeInfo{ .Bool = undefined })); + try testTypes(&[_]type{bool}); } test "Type.NoReturn" { - testing.expect(noreturn == @Type(TypeInfo{ .NoReturn = undefined })); - testTypes(&[_]type{noreturn}); + try testing.expect(noreturn == @Type(TypeInfo{ .NoReturn = undefined })); + try testTypes(&[_]type{noreturn}); } test "Type.Int" { - testing.expect(u1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 1 } })); - testing.expect(i1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 1 } })); - testing.expect(u8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 8 } })); - testing.expect(i8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 8 } })); - testing.expect(u64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 64 } })); - testing.expect(i64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 64 } })); - testTypes(&[_]type{ u8, u32, i64 }); + try testing.expect(u1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 1 } })); + try testing.expect(i1 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 1 } })); + try testing.expect(u8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 8 } })); + try testing.expect(i8 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 8 } })); + try testing.expect(u64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .unsigned, .bits = 64 } })); + try testing.expect(i64 == @Type(TypeInfo{ .Int = TypeInfo.Int{ .signedness = .signed, .bits = 64 } })); + try testTypes(&[_]type{ u8, u32, i64 }); } test "Type.Float" { - testing.expect(f16 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 16 } })); - testing.expect(f32 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 32 } })); - testing.expect(f64 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 64 } })); - testing.expect(f128 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 128 } })); - testTypes(&[_]type{ f16, f32, f64, f128 }); + try testing.expect(f16 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 16 } })); + try testing.expect(f32 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 32 } })); + try testing.expect(f64 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 64 } })); + try testing.expect(f128 == @Type(TypeInfo{ .Float = TypeInfo.Float{ .bits = 128 } })); + try testTypes(&[_]type{ f16, f32, f64, f128 }); } test "Type.Pointer" { - testTypes(&[_]type{ + try testTypes(&[_]type{ // One Value Pointer Types *u8, *const u8, *volatile u8, *const volatile u8, @@ -94,41 +94,41 @@ test "Type.Pointer" { } test "Type.Array" { - testing.expect([123]u8 == @Type(TypeInfo{ + try testing.expect([123]u8 == @Type(TypeInfo{ .Array = TypeInfo.Array{ .len = 123, .child = u8, .sentinel = null, }, })); - testing.expect([2]u32 == @Type(TypeInfo{ + try testing.expect([2]u32 == @Type(TypeInfo{ .Array = TypeInfo.Array{ .len = 2, .child = u32, .sentinel = null, }, })); - testing.expect([2:0]u32 == @Type(TypeInfo{ + try testing.expect([2:0]u32 == @Type(TypeInfo{ .Array = TypeInfo.Array{ .len = 2, .child = u32, .sentinel = 0, }, })); - testTypes(&[_]type{ [1]u8, [30]usize, [7]bool }); + try testTypes(&[_]type{ [1]u8, [30]usize, [7]bool }); } test "Type.ComptimeFloat" { - testTypes(&[_]type{comptime_float}); + try testTypes(&[_]type{comptime_float}); } test "Type.ComptimeInt" { - testTypes(&[_]type{comptime_int}); + try testTypes(&[_]type{comptime_int}); } test "Type.Undefined" { - testTypes(&[_]type{@TypeOf(undefined)}); + try testTypes(&[_]type{@TypeOf(undefined)}); } test "Type.Null" { - testTypes(&[_]type{@TypeOf(null)}); + try testTypes(&[_]type{@TypeOf(null)}); } test "@Type create slice with null sentinel" { const Slice = @Type(builtin.TypeInfo{ @@ -142,10 +142,10 @@ test "@Type create slice with null sentinel" { .sentinel = null, }, }); - testing.expect(Slice == []align(8) const *i32); + try testing.expect(Slice == []align(8) const *i32); } test "@Type picks up the sentinel value from TypeInfo" { - testTypes(&[_]type{ + try testTypes(&[_]type{ [11:0]u8, [4:10]u8, [*:0]u8, [*:0]const u8, [*:0]volatile u8, [*:0]const volatile u8, @@ -173,7 +173,7 @@ test "@Type picks up the sentinel value from TypeInfo" { } test "Type.Optional" { - testTypes(&[_]type{ + try testTypes(&[_]type{ ?u8, ?*u8, ?[]u8, @@ -183,7 +183,7 @@ test "Type.Optional" { } test "Type.ErrorUnion" { - testTypes(&[_]type{ + try testTypes(&[_]type{ error{}!void, error{Error}!void, }); @@ -195,8 +195,8 @@ test "Type.Opaque" { .decls = &[_]TypeInfo.Declaration{}, }, }); - testing.expect(Opaque != opaque {}); - testing.expectEqualSlices( + try testing.expect(Opaque != opaque {}); + try testing.expectEqualSlices( TypeInfo.Declaration, &[_]TypeInfo.Declaration{}, @typeInfo(Opaque).Opaque.decls, @@ -204,7 +204,7 @@ test "Type.Opaque" { } test "Type.Vector" { - testTypes(&[_]type{ + try testTypes(&[_]type{ @Vector(0, u8), @Vector(4, u8), @Vector(8, *u8), @@ -215,7 +215,7 @@ test "Type.Vector" { } test "Type.AnyFrame" { - testTypes(&[_]type{ + try testTypes(&[_]type{ anyframe, anyframe->u8, anyframe->anyframe->u8, @@ -223,7 +223,7 @@ test "Type.AnyFrame" { } test "Type.EnumLiteral" { - testTypes(&[_]type{ + try testTypes(&[_]type{ @TypeOf(.Dummy), }); } @@ -233,7 +233,7 @@ fn add(a: i32, b: i32) i32 { } test "Type.Frame" { - testTypes(&[_]type{ + try testTypes(&[_]type{ @Frame(add), }); } @@ -248,45 +248,45 @@ test "Type.ErrorSet" { test "Type.Struct" { const A = @Type(@typeInfo(struct { x: u8, y: u32 })); const infoA = @typeInfo(A).Struct; - testing.expectEqual(TypeInfo.ContainerLayout.Auto, infoA.layout); - testing.expectEqualSlices(u8, "x", infoA.fields[0].name); - testing.expectEqual(u8, infoA.fields[0].field_type); - testing.expectEqual(@as(?u8, null), infoA.fields[0].default_value); - testing.expectEqualSlices(u8, "y", infoA.fields[1].name); - testing.expectEqual(u32, infoA.fields[1].field_type); - testing.expectEqual(@as(?u32, null), infoA.fields[1].default_value); - testing.expectEqualSlices(TypeInfo.Declaration, &[_]TypeInfo.Declaration{}, infoA.decls); - testing.expectEqual(@as(bool, false), infoA.is_tuple); + try testing.expectEqual(TypeInfo.ContainerLayout.Auto, infoA.layout); + try testing.expectEqualSlices(u8, "x", infoA.fields[0].name); + try testing.expectEqual(u8, infoA.fields[0].field_type); + try testing.expectEqual(@as(?u8, null), infoA.fields[0].default_value); + try testing.expectEqualSlices(u8, "y", infoA.fields[1].name); + try testing.expectEqual(u32, infoA.fields[1].field_type); + try testing.expectEqual(@as(?u32, null), infoA.fields[1].default_value); + try testing.expectEqualSlices(TypeInfo.Declaration, &[_]TypeInfo.Declaration{}, infoA.decls); + try testing.expectEqual(@as(bool, false), infoA.is_tuple); var a = A{ .x = 0, .y = 1 }; - testing.expectEqual(@as(u8, 0), a.x); - testing.expectEqual(@as(u32, 1), a.y); + try testing.expectEqual(@as(u8, 0), a.x); + try testing.expectEqual(@as(u32, 1), a.y); a.y += 1; - testing.expectEqual(@as(u32, 2), a.y); + try testing.expectEqual(@as(u32, 2), a.y); const B = @Type(@typeInfo(extern struct { x: u8, y: u32 = 5 })); const infoB = @typeInfo(B).Struct; - testing.expectEqual(TypeInfo.ContainerLayout.Extern, infoB.layout); - testing.expectEqualSlices(u8, "x", infoB.fields[0].name); - testing.expectEqual(u8, infoB.fields[0].field_type); - testing.expectEqual(@as(?u8, null), infoB.fields[0].default_value); - testing.expectEqualSlices(u8, "y", infoB.fields[1].name); - testing.expectEqual(u32, infoB.fields[1].field_type); - testing.expectEqual(@as(?u32, 5), infoB.fields[1].default_value); - testing.expectEqual(@as(usize, 0), infoB.decls.len); - testing.expectEqual(@as(bool, false), infoB.is_tuple); + try testing.expectEqual(TypeInfo.ContainerLayout.Extern, infoB.layout); + try testing.expectEqualSlices(u8, "x", infoB.fields[0].name); + try testing.expectEqual(u8, infoB.fields[0].field_type); + try testing.expectEqual(@as(?u8, null), infoB.fields[0].default_value); + try testing.expectEqualSlices(u8, "y", infoB.fields[1].name); + try testing.expectEqual(u32, infoB.fields[1].field_type); + try testing.expectEqual(@as(?u32, 5), infoB.fields[1].default_value); + try testing.expectEqual(@as(usize, 0), infoB.decls.len); + try testing.expectEqual(@as(bool, false), infoB.is_tuple); const C = @Type(@typeInfo(packed struct { x: u8 = 3, y: u32 = 5 })); const infoC = @typeInfo(C).Struct; - testing.expectEqual(TypeInfo.ContainerLayout.Packed, infoC.layout); - testing.expectEqualSlices(u8, "x", infoC.fields[0].name); - testing.expectEqual(u8, infoC.fields[0].field_type); - testing.expectEqual(@as(?u8, 3), infoC.fields[0].default_value); - testing.expectEqualSlices(u8, "y", infoC.fields[1].name); - testing.expectEqual(u32, infoC.fields[1].field_type); - testing.expectEqual(@as(?u32, 5), infoC.fields[1].default_value); - testing.expectEqual(@as(usize, 0), infoC.decls.len); - testing.expectEqual(@as(bool, false), infoC.is_tuple); + try testing.expectEqual(TypeInfo.ContainerLayout.Packed, infoC.layout); + try testing.expectEqualSlices(u8, "x", infoC.fields[0].name); + try testing.expectEqual(u8, infoC.fields[0].field_type); + try testing.expectEqual(@as(?u8, 3), infoC.fields[0].default_value); + try testing.expectEqualSlices(u8, "y", infoC.fields[1].name); + try testing.expectEqual(u32, infoC.fields[1].field_type); + try testing.expectEqual(@as(?u32, 5), infoC.fields[1].default_value); + try testing.expectEqual(@as(usize, 0), infoC.decls.len); + try testing.expectEqual(@as(bool, false), infoC.is_tuple); } test "Type.Enum" { @@ -302,9 +302,9 @@ test "Type.Enum" { .is_exhaustive = true, }, }); - testing.expectEqual(true, @typeInfo(Foo).Enum.is_exhaustive); - testing.expectEqual(@as(u8, 1), @enumToInt(Foo.a)); - testing.expectEqual(@as(u8, 5), @enumToInt(Foo.b)); + try testing.expectEqual(true, @typeInfo(Foo).Enum.is_exhaustive); + try testing.expectEqual(@as(u8, 1), @enumToInt(Foo.a)); + try testing.expectEqual(@as(u8, 5), @enumToInt(Foo.b)); const Bar = @Type(.{ .Enum = .{ .layout = .Extern, @@ -317,10 +317,10 @@ test "Type.Enum" { .is_exhaustive = false, }, }); - testing.expectEqual(false, @typeInfo(Bar).Enum.is_exhaustive); - testing.expectEqual(@as(u32, 1), @enumToInt(Bar.a)); - testing.expectEqual(@as(u32, 5), @enumToInt(Bar.b)); - testing.expectEqual(@as(u32, 6), @enumToInt(@intToEnum(Bar, 6))); + try testing.expectEqual(false, @typeInfo(Bar).Enum.is_exhaustive); + try testing.expectEqual(@as(u32, 1), @enumToInt(Bar.a)); + try testing.expectEqual(@as(u32, 5), @enumToInt(Bar.b)); + try testing.expectEqual(@as(u32, 6), @enumToInt(@intToEnum(Bar, 6))); } test "Type.Union" { @@ -338,7 +338,7 @@ test "Type.Union" { var untagged = Untagged{ .int = 1 }; untagged.float = 2.0; untagged.int = 3; - testing.expectEqual(@as(i32, 3), untagged.int); + try testing.expectEqual(@as(i32, 3), untagged.int); const PackedUntagged = @Type(.{ .Union = .{ @@ -352,8 +352,8 @@ test "Type.Union" { }, }); var packed_untagged = PackedUntagged{ .signed = -1 }; - testing.expectEqual(@as(i32, -1), packed_untagged.signed); - testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned); + try testing.expectEqual(@as(i32, -1), packed_untagged.signed); + try testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned); const Tag = @Type(.{ .Enum = .{ @@ -379,9 +379,9 @@ test "Type.Union" { }, }); var tagged = Tagged{ .signed = -1 }; - testing.expectEqual(Tag.signed, tagged); + try testing.expectEqual(Tag.signed, tagged); tagged = .{ .unsigned = 1 }; - testing.expectEqual(Tag.unsigned, tagged); + try testing.expectEqual(Tag.unsigned, tagged); } test "Type.Union from Type.Enum" { @@ -447,7 +447,7 @@ test "Type.BoundFn" { pub fn foo(self: *const @This()) align(4) callconv(.Unspecified) void {} }; const test_instance: TestStruct = undefined; - testing.expect(std.meta.eql( + try testing.expect(std.meta.eql( @typeName(@TypeOf(test_instance.foo)), @typeName(@Type(@typeInfo(@TypeOf(test_instance.foo)))), )); diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig index f944b7904c..e8ae3827d9 100644 --- a/test/stage1/behavior/type_info.zig +++ b/test/stage1/behavior/type_info.zig @@ -9,151 +9,151 @@ const expect = std.testing.expect; const expectEqualStrings = std.testing.expectEqualStrings; test "type info: tag type, void info" { - testBasic(); - comptime testBasic(); + try testBasic(); + comptime try testBasic(); } -fn testBasic() void { - expect(@typeInfo(TypeInfo).Union.tag_type == TypeId); +fn testBasic() !void { + try expect(@typeInfo(TypeInfo).Union.tag_type == TypeId); const void_info = @typeInfo(void); - expect(void_info == TypeId.Void); - expect(void_info.Void == {}); + try expect(void_info == TypeId.Void); + try expect(void_info.Void == {}); } test "type info: integer, floating point type info" { - testIntFloat(); - comptime testIntFloat(); + try testIntFloat(); + comptime try testIntFloat(); } -fn testIntFloat() void { +fn testIntFloat() !void { const u8_info = @typeInfo(u8); - expect(u8_info == .Int); - expect(u8_info.Int.signedness == .unsigned); - expect(u8_info.Int.bits == 8); + try expect(u8_info == .Int); + try expect(u8_info.Int.signedness == .unsigned); + try expect(u8_info.Int.bits == 8); const f64_info = @typeInfo(f64); - expect(f64_info == .Float); - expect(f64_info.Float.bits == 64); + try expect(f64_info == .Float); + try expect(f64_info.Float.bits == 64); } test "type info: pointer type info" { - testPointer(); - comptime testPointer(); + try testPointer(); + comptime try testPointer(); } -fn testPointer() void { +fn testPointer() !void { const u32_ptr_info = @typeInfo(*u32); - expect(u32_ptr_info == .Pointer); - expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.One); - expect(u32_ptr_info.Pointer.is_const == false); - expect(u32_ptr_info.Pointer.is_volatile == false); - expect(u32_ptr_info.Pointer.alignment == @alignOf(u32)); - expect(u32_ptr_info.Pointer.child == u32); - expect(u32_ptr_info.Pointer.sentinel == null); + try expect(u32_ptr_info == .Pointer); + try expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.One); + try expect(u32_ptr_info.Pointer.is_const == false); + try expect(u32_ptr_info.Pointer.is_volatile == false); + try expect(u32_ptr_info.Pointer.alignment == @alignOf(u32)); + try expect(u32_ptr_info.Pointer.child == u32); + try expect(u32_ptr_info.Pointer.sentinel == null); } test "type info: unknown length pointer type info" { - testUnknownLenPtr(); - comptime testUnknownLenPtr(); + try testUnknownLenPtr(); + comptime try testUnknownLenPtr(); } -fn testUnknownLenPtr() void { +fn testUnknownLenPtr() !void { const u32_ptr_info = @typeInfo([*]const volatile f64); - expect(u32_ptr_info == .Pointer); - expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many); - expect(u32_ptr_info.Pointer.is_const == true); - expect(u32_ptr_info.Pointer.is_volatile == true); - expect(u32_ptr_info.Pointer.sentinel == null); - expect(u32_ptr_info.Pointer.alignment == @alignOf(f64)); - expect(u32_ptr_info.Pointer.child == f64); + try expect(u32_ptr_info == .Pointer); + try expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many); + try expect(u32_ptr_info.Pointer.is_const == true); + try expect(u32_ptr_info.Pointer.is_volatile == true); + try expect(u32_ptr_info.Pointer.sentinel == null); + try expect(u32_ptr_info.Pointer.alignment == @alignOf(f64)); + try expect(u32_ptr_info.Pointer.child == f64); } test "type info: null terminated pointer type info" { - testNullTerminatedPtr(); - comptime testNullTerminatedPtr(); + try testNullTerminatedPtr(); + comptime try testNullTerminatedPtr(); } -fn testNullTerminatedPtr() void { +fn testNullTerminatedPtr() !void { const ptr_info = @typeInfo([*:0]u8); - expect(ptr_info == .Pointer); - expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many); - expect(ptr_info.Pointer.is_const == false); - expect(ptr_info.Pointer.is_volatile == false); - expect(ptr_info.Pointer.sentinel.? == 0); + try expect(ptr_info == .Pointer); + try expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many); + try expect(ptr_info.Pointer.is_const == false); + try expect(ptr_info.Pointer.is_volatile == false); + try expect(ptr_info.Pointer.sentinel.? == 0); - expect(@typeInfo([:0]u8).Pointer.sentinel != null); + try expect(@typeInfo([:0]u8).Pointer.sentinel != null); } test "type info: C pointer type info" { - testCPtr(); - comptime testCPtr(); + try testCPtr(); + comptime try testCPtr(); } -fn testCPtr() void { +fn testCPtr() !void { const ptr_info = @typeInfo([*c]align(4) const i8); - expect(ptr_info == .Pointer); - expect(ptr_info.Pointer.size == .C); - expect(ptr_info.Pointer.is_const); - expect(!ptr_info.Pointer.is_volatile); - expect(ptr_info.Pointer.alignment == 4); - expect(ptr_info.Pointer.child == i8); + try expect(ptr_info == .Pointer); + try expect(ptr_info.Pointer.size == .C); + try expect(ptr_info.Pointer.is_const); + try expect(!ptr_info.Pointer.is_volatile); + try expect(ptr_info.Pointer.alignment == 4); + try expect(ptr_info.Pointer.child == i8); } test "type info: slice type info" { - testSlice(); - comptime testSlice(); + try testSlice(); + comptime try testSlice(); } -fn testSlice() void { +fn testSlice() !void { const u32_slice_info = @typeInfo([]u32); - expect(u32_slice_info == .Pointer); - expect(u32_slice_info.Pointer.size == .Slice); - expect(u32_slice_info.Pointer.is_const == false); - expect(u32_slice_info.Pointer.is_volatile == false); - expect(u32_slice_info.Pointer.alignment == 4); - expect(u32_slice_info.Pointer.child == u32); + try expect(u32_slice_info == .Pointer); + try expect(u32_slice_info.Pointer.size == .Slice); + try expect(u32_slice_info.Pointer.is_const == false); + try expect(u32_slice_info.Pointer.is_volatile == false); + try expect(u32_slice_info.Pointer.alignment == 4); + try expect(u32_slice_info.Pointer.child == u32); } test "type info: array type info" { - testArray(); - comptime testArray(); + try testArray(); + comptime try testArray(); } -fn testArray() void { +fn testArray() !void { { const info = @typeInfo([42]u8); - expect(info == .Array); - expect(info.Array.len == 42); - expect(info.Array.child == u8); - expect(info.Array.sentinel == null); + try expect(info == .Array); + try expect(info.Array.len == 42); + try expect(info.Array.child == u8); + try expect(info.Array.sentinel == null); } { const info = @typeInfo([10:0]u8); - expect(info.Array.len == 10); - expect(info.Array.child == u8); - expect(info.Array.sentinel.? == @as(u8, 0)); - expect(@sizeOf([10:0]u8) == info.Array.len + 1); + try expect(info.Array.len == 10); + try expect(info.Array.child == u8); + try expect(info.Array.sentinel.? == @as(u8, 0)); + try expect(@sizeOf([10:0]u8) == info.Array.len + 1); } } test "type info: optional type info" { - testOptional(); - comptime testOptional(); + try testOptional(); + comptime try testOptional(); } -fn testOptional() void { +fn testOptional() !void { const null_info = @typeInfo(?void); - expect(null_info == .Optional); - expect(null_info.Optional.child == void); + try expect(null_info == .Optional); + try expect(null_info.Optional.child == void); } test "type info: error set, error union info" { - testErrorSet(); - comptime testErrorSet(); + try testErrorSet(); + comptime try testErrorSet(); } -fn testErrorSet() void { +fn testErrorSet() !void { const TestErrorSet = error{ First, Second, @@ -161,26 +161,26 @@ fn testErrorSet() void { }; const error_set_info = @typeInfo(TestErrorSet); - expect(error_set_info == .ErrorSet); - expect(error_set_info.ErrorSet.?.len == 3); - expect(mem.eql(u8, error_set_info.ErrorSet.?[0].name, "First")); + try expect(error_set_info == .ErrorSet); + try expect(error_set_info.ErrorSet.?.len == 3); + try expect(mem.eql(u8, error_set_info.ErrorSet.?[0].name, "First")); const error_union_info = @typeInfo(TestErrorSet!usize); - expect(error_union_info == .ErrorUnion); - expect(error_union_info.ErrorUnion.error_set == TestErrorSet); - expect(error_union_info.ErrorUnion.payload == usize); + try expect(error_union_info == .ErrorUnion); + try expect(error_union_info.ErrorUnion.error_set == TestErrorSet); + try expect(error_union_info.ErrorUnion.payload == usize); const global_info = @typeInfo(anyerror); - expect(global_info == .ErrorSet); - expect(global_info.ErrorSet == null); + try expect(global_info == .ErrorSet); + try expect(global_info.ErrorSet == null); } test "type info: enum info" { - testEnum(); - comptime testEnum(); + try testEnum(); + comptime try testEnum(); } -fn testEnum() void { +fn testEnum() !void { const Os = enum { Windows, Macos, @@ -189,28 +189,28 @@ fn testEnum() void { }; const os_info = @typeInfo(Os); - expect(os_info == .Enum); - expect(os_info.Enum.layout == .Auto); - expect(os_info.Enum.fields.len == 4); - expect(mem.eql(u8, os_info.Enum.fields[1].name, "Macos")); - expect(os_info.Enum.fields[3].value == 3); - expect(os_info.Enum.tag_type == u2); - expect(os_info.Enum.decls.len == 0); + try expect(os_info == .Enum); + try expect(os_info.Enum.layout == .Auto); + try expect(os_info.Enum.fields.len == 4); + try expect(mem.eql(u8, os_info.Enum.fields[1].name, "Macos")); + try expect(os_info.Enum.fields[3].value == 3); + try expect(os_info.Enum.tag_type == u2); + try expect(os_info.Enum.decls.len == 0); } test "type info: union info" { - testUnion(); - comptime testUnion(); + try testUnion(); + comptime try testUnion(); } -fn testUnion() void { +fn testUnion() !void { const typeinfo_info = @typeInfo(TypeInfo); - expect(typeinfo_info == .Union); - expect(typeinfo_info.Union.layout == .Auto); - expect(typeinfo_info.Union.tag_type.? == TypeId); - expect(typeinfo_info.Union.fields.len == 25); - expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int)); - expect(typeinfo_info.Union.decls.len == 22); + try expect(typeinfo_info == .Union); + try expect(typeinfo_info.Union.layout == .Auto); + try expect(typeinfo_info.Union.tag_type.? == TypeId); + try expect(typeinfo_info.Union.fields.len == 25); + try expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int)); + try expect(typeinfo_info.Union.decls.len == 22); const TestNoTagUnion = union { Foo: void, @@ -218,52 +218,52 @@ fn testUnion() void { }; const notag_union_info = @typeInfo(TestNoTagUnion); - expect(notag_union_info == .Union); - expect(notag_union_info.Union.tag_type == null); - expect(notag_union_info.Union.layout == .Auto); - expect(notag_union_info.Union.fields.len == 2); - expect(notag_union_info.Union.fields[0].alignment == @alignOf(void)); - expect(notag_union_info.Union.fields[1].field_type == u32); - expect(notag_union_info.Union.fields[1].alignment == @alignOf(u32)); + try expect(notag_union_info == .Union); + try expect(notag_union_info.Union.tag_type == null); + try expect(notag_union_info.Union.layout == .Auto); + try expect(notag_union_info.Union.fields.len == 2); + try expect(notag_union_info.Union.fields[0].alignment == @alignOf(void)); + try expect(notag_union_info.Union.fields[1].field_type == u32); + try expect(notag_union_info.Union.fields[1].alignment == @alignOf(u32)); const TestExternUnion = extern union { foo: *c_void, }; const extern_union_info = @typeInfo(TestExternUnion); - expect(extern_union_info.Union.layout == .Extern); - expect(extern_union_info.Union.tag_type == null); - expect(extern_union_info.Union.fields[0].field_type == *c_void); + try expect(extern_union_info.Union.layout == .Extern); + try expect(extern_union_info.Union.tag_type == null); + try expect(extern_union_info.Union.fields[0].field_type == *c_void); } test "type info: struct info" { - testStruct(); - comptime testStruct(); + try testStruct(); + comptime try testStruct(); } -fn testStruct() void { +fn testStruct() !void { const unpacked_struct_info = @typeInfo(TestUnpackedStruct); - expect(unpacked_struct_info.Struct.is_tuple == false); - expect(unpacked_struct_info.Struct.fields[0].alignment == @alignOf(u32)); - expect(unpacked_struct_info.Struct.fields[0].default_value.? == 4); - expectEqualStrings("foobar", unpacked_struct_info.Struct.fields[1].default_value.?); + try expect(unpacked_struct_info.Struct.is_tuple == false); + try expect(unpacked_struct_info.Struct.fields[0].alignment == @alignOf(u32)); + try expect(unpacked_struct_info.Struct.fields[0].default_value.? == 4); + try expectEqualStrings("foobar", unpacked_struct_info.Struct.fields[1].default_value.?); const struct_info = @typeInfo(TestStruct); - expect(struct_info == .Struct); - expect(struct_info.Struct.is_tuple == false); - expect(struct_info.Struct.layout == .Packed); - expect(struct_info.Struct.fields.len == 4); - expect(struct_info.Struct.fields[0].alignment == 2 * @alignOf(usize)); - expect(struct_info.Struct.fields[2].field_type == *TestStruct); - expect(struct_info.Struct.fields[2].default_value == null); - expect(struct_info.Struct.fields[3].default_value.? == 4); - expect(struct_info.Struct.fields[3].alignment == 1); - expect(struct_info.Struct.decls.len == 2); - expect(struct_info.Struct.decls[0].is_pub); - expect(!struct_info.Struct.decls[0].data.Fn.is_extern); - expect(struct_info.Struct.decls[0].data.Fn.lib_name == null); - expect(struct_info.Struct.decls[0].data.Fn.return_type == void); - expect(struct_info.Struct.decls[0].data.Fn.fn_type == fn (*const TestStruct) void); + try expect(struct_info == .Struct); + try expect(struct_info.Struct.is_tuple == false); + try expect(struct_info.Struct.layout == .Packed); + try expect(struct_info.Struct.fields.len == 4); + try expect(struct_info.Struct.fields[0].alignment == 2 * @alignOf(usize)); + try expect(struct_info.Struct.fields[2].field_type == *TestStruct); + try expect(struct_info.Struct.fields[2].default_value == null); + try expect(struct_info.Struct.fields[3].default_value.? == 4); + try expect(struct_info.Struct.fields[3].alignment == 1); + try expect(struct_info.Struct.decls.len == 2); + try expect(struct_info.Struct.decls[0].is_pub); + try expect(!struct_info.Struct.decls[0].data.Fn.is_extern); + try expect(struct_info.Struct.decls[0].data.Fn.lib_name == null); + try expect(struct_info.Struct.decls[0].data.Fn.return_type == void); + try expect(struct_info.Struct.decls[0].data.Fn.fn_type == fn (*const TestStruct) void); } const TestUnpackedStruct = struct { @@ -282,43 +282,43 @@ const TestStruct = packed struct { }; test "type info: opaque info" { - testOpaque(); - comptime testOpaque(); + try testOpaque(); + comptime try testOpaque(); } -fn testOpaque() void { +fn testOpaque() !void { const Foo = opaque { const A = 1; fn b() void {} }; const foo_info = @typeInfo(Foo); - expect(foo_info.Opaque.decls.len == 2); + try expect(foo_info.Opaque.decls.len == 2); } test "type info: function type info" { // wasm doesn't support align attributes on functions if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; - testFunction(); - comptime testFunction(); + try testFunction(); + comptime try testFunction(); } -fn testFunction() void { +fn testFunction() !void { const fn_info = @typeInfo(@TypeOf(foo)); - expect(fn_info == .Fn); - expect(fn_info.Fn.alignment > 0); - expect(fn_info.Fn.calling_convention == .C); - expect(!fn_info.Fn.is_generic); - expect(fn_info.Fn.args.len == 2); - expect(fn_info.Fn.is_var_args); - expect(fn_info.Fn.return_type.? == usize); + try expect(fn_info == .Fn); + try expect(fn_info.Fn.alignment > 0); + try expect(fn_info.Fn.calling_convention == .C); + try expect(!fn_info.Fn.is_generic); + try expect(fn_info.Fn.args.len == 2); + try expect(fn_info.Fn.is_var_args); + try expect(fn_info.Fn.return_type.? == usize); const fn_aligned_info = @typeInfo(@TypeOf(fooAligned)); - expect(fn_aligned_info.Fn.alignment == 4); + try expect(fn_aligned_info.Fn.alignment == 4); const test_instance: TestStruct = undefined; const bound_fn_info = @typeInfo(@TypeOf(test_instance.foo)); - expect(bound_fn_info == .BoundFn); - expect(bound_fn_info.BoundFn.args[0].arg_type.? == *const TestStruct); + try expect(bound_fn_info == .BoundFn); + try expect(bound_fn_info.BoundFn.args[0].arg_type.? == *const TestStruct); } extern fn foo(a: usize, b: bool, ...) callconv(.C) usize; @@ -332,33 +332,33 @@ test "typeInfo with comptime parameter in struct fn def" { } test "type info: vectors" { - testVector(); - comptime testVector(); + try testVector(); + comptime try testVector(); } -fn testVector() void { +fn testVector() !void { const vec_info = @typeInfo(std.meta.Vector(4, i32)); - expect(vec_info == .Vector); - expect(vec_info.Vector.len == 4); - expect(vec_info.Vector.child == i32); + try expect(vec_info == .Vector); + try expect(vec_info.Vector.len == 4); + try expect(vec_info.Vector.child == i32); } test "type info: anyframe and anyframe->T" { - testAnyFrame(); - comptime testAnyFrame(); + try testAnyFrame(); + comptime try testAnyFrame(); } -fn testAnyFrame() void { +fn testAnyFrame() !void { { const anyframe_info = @typeInfo(anyframe->i32); - expect(anyframe_info == .AnyFrame); - expect(anyframe_info.AnyFrame.child.? == i32); + try expect(anyframe_info == .AnyFrame); + try expect(anyframe_info.AnyFrame.child.? == i32); } { const anyframe_info = @typeInfo(anyframe); - expect(anyframe_info == .AnyFrame); - expect(anyframe_info.AnyFrame.child == null); + try expect(anyframe_info == .AnyFrame); + try expect(anyframe_info.AnyFrame.child == null); } } @@ -385,9 +385,9 @@ test "type info: extern fns with and without lib names" { comptime { for (info.Struct.decls) |decl| { if (std.mem.eql(u8, decl.name, "bar1")) { - expect(decl.data.Fn.lib_name == null); + try expect(decl.data.Fn.lib_name == null); } else { - expectEqualStrings("cool", decl.data.Fn.lib_name.?); + try expectEqualStrings("cool", decl.data.Fn.lib_name.?); } } } @@ -397,12 +397,12 @@ test "data field is a compile-time value" { const S = struct { const Bar = @as(isize, -1); }; - comptime expect(@typeInfo(S).Struct.decls[0].data.Var == isize); + comptime try expect(@typeInfo(S).Struct.decls[0].data.Var == isize); } test "sentinel of opaque pointer type" { const c_void_info = @typeInfo(*c_void); - expect(c_void_info.Pointer.sentinel == null); + try expect(c_void_info.Pointer.sentinel == null); } test "@typeInfo does not force declarations into existence" { @@ -413,12 +413,12 @@ test "@typeInfo does not force declarations into existence" { @compileError("test failed"); } }; - comptime expect(@typeInfo(S).Struct.fields.len == 1); + comptime try expect(@typeInfo(S).Struct.fields.len == 1); } test "defaut value for a var-typed field" { const S = struct { x: anytype }; - expect(@typeInfo(S).Struct.fields[0].default_value == null); + try expect(@typeInfo(S).Struct.fields[0].default_value == null); } fn add(a: i32, b: i32) i32 { @@ -428,7 +428,7 @@ fn add(a: i32, b: i32) i32 { test "type info for async frames" { switch (@typeInfo(@Frame(add))) { .Frame => |frame| { - expect(frame.function == add); + try expect(frame.function == add); }, else => unreachable, } @@ -438,7 +438,7 @@ test "type info: value is correctly copied" { comptime { var ptrInfo = @typeInfo([]u32); ptrInfo.Pointer.size = .One; - expect(@typeInfo([]u32).Pointer.size == .Slice); + try expect(@typeInfo([]u32).Pointer.size == .Slice); } } @@ -451,22 +451,22 @@ test "Declarations are returned in declaration order" { const e = 5; }; const d = @typeInfo(S).Struct.decls; - expect(std.mem.eql(u8, d[0].name, "a")); - expect(std.mem.eql(u8, d[1].name, "b")); - expect(std.mem.eql(u8, d[2].name, "c")); - expect(std.mem.eql(u8, d[3].name, "d")); - expect(std.mem.eql(u8, d[4].name, "e")); + try expect(std.mem.eql(u8, d[0].name, "a")); + try expect(std.mem.eql(u8, d[1].name, "b")); + try expect(std.mem.eql(u8, d[2].name, "c")); + try expect(std.mem.eql(u8, d[3].name, "d")); + try expect(std.mem.eql(u8, d[4].name, "e")); } test "Struct.is_tuple" { - expect(@typeInfo(@TypeOf(.{0})).Struct.is_tuple); - expect(!@typeInfo(@TypeOf(.{ .a = 0 })).Struct.is_tuple); + try expect(@typeInfo(@TypeOf(.{0})).Struct.is_tuple); + try expect(!@typeInfo(@TypeOf(.{ .a = 0 })).Struct.is_tuple); } test "StructField.is_comptime" { const info = @typeInfo(struct { x: u8 = 3, comptime y: u32 = 5 }).Struct; - expect(!info.fields[0].is_comptime); - expect(info.fields[1].is_comptime); + try expect(!info.fields[0].is_comptime); + try expect(info.fields[1].is_comptime); } test "typeInfo resolves usingnamespace declarations" { @@ -479,6 +479,6 @@ test "typeInfo resolves usingnamespace declarations" { usingnamespace A; }; - expect(@typeInfo(B).Struct.decls.len == 2); + try expect(@typeInfo(B).Struct.decls.len == 2); //a } diff --git a/test/stage1/behavior/typename.zig b/test/stage1/behavior/typename.zig index 1abefe5b5e..bf8464244b 100644 --- a/test/stage1/behavior/typename.zig +++ b/test/stage1/behavior/typename.zig @@ -3,5 +3,5 @@ const expect = std.testing.expect; const expectEqualSlices = std.testing.expectEqualSlices; test "slice" { - expectEqualSlices(u8, "[]u8", @typeName([]u8)); + try expectEqualSlices(u8, "[]u8", @typeName([]u8)); } diff --git a/test/stage1/behavior/undefined.zig b/test/stage1/behavior/undefined.zig index 114b0262b1..a160f86221 100644 --- a/test/stage1/behavior/undefined.zig +++ b/test/stage1/behavior/undefined.zig @@ -12,16 +12,16 @@ fn initStaticArray() [10]i32 { } const static_array = initStaticArray(); test "init static array to undefined" { - expect(static_array[0] == 1); - expect(static_array[4] == 2); - expect(static_array[7] == 3); - expect(static_array[9] == 4); + try expect(static_array[0] == 1); + try expect(static_array[4] == 2); + try expect(static_array[7] == 3); + try expect(static_array[9] == 4); comptime { - expect(static_array[0] == 1); - expect(static_array[4] == 2); - expect(static_array[7] == 3); - expect(static_array[9] == 4); + try expect(static_array[0] == 1); + try expect(static_array[4] == 2); + try expect(static_array[7] == 3); + try expect(static_array[9] == 4); } } @@ -41,12 +41,12 @@ test "assign undefined to struct" { comptime { var foo: Foo = undefined; setFooX(&foo); - expect(foo.x == 2); + try expect(foo.x == 2); } { var foo: Foo = undefined; setFooX(&foo); - expect(foo.x == 2); + try expect(foo.x == 2); } } @@ -54,16 +54,16 @@ test "assign undefined to struct with method" { comptime { var foo: Foo = undefined; foo.setFooXMethod(); - expect(foo.x == 3); + try expect(foo.x == 3); } { var foo: Foo = undefined; foo.setFooXMethod(); - expect(foo.x == 3); + try expect(foo.x == 3); } } test "type name of undefined" { const x = undefined; - expect(mem.eql(u8, @typeName(@TypeOf(x)), "(undefined)")); + try expect(mem.eql(u8, @typeName(@TypeOf(x)), "(undefined)")); } diff --git a/test/stage1/behavior/union.zig b/test/stage1/behavior/union.zig index e46b6bb6b9..66396bebb4 100644 --- a/test/stage1/behavior/union.zig +++ b/test/stage1/behavior/union.zig @@ -30,11 +30,11 @@ const array = [_]Value{ test "unions embedded in aggregate types" { switch (array[1]) { - Value.Array => |arr| expect(arr[4] == 3), + Value.Array => |arr| try expect(arr[4] == 3), else => unreachable, } switch ((err catch unreachable).val1) { - Value.Int => |x| expect(x == 1234), + Value.Int => |x| try expect(x == 1234), else => unreachable, } } @@ -46,18 +46,18 @@ const Foo = union { test "basic unions" { var foo = Foo{ .int = 1 }; - expect(foo.int == 1); + try expect(foo.int == 1); foo = Foo{ .float = 12.34 }; - expect(foo.float == 12.34); + try expect(foo.float == 12.34); } test "comptime union field access" { comptime { var foo = Foo{ .int = 0 }; - expect(foo.int == 0); + try expect(foo.int == 0); foo = Foo{ .float = 42.42 }; - expect(foo.float == 42.42); + try expect(foo.float == 42.42); } } @@ -65,10 +65,10 @@ test "init union with runtime value" { var foo: Foo = undefined; setFloat(&foo, 12.34); - expect(foo.float == 12.34); + try expect(foo.float == 12.34); setInt(&foo, 42); - expect(foo.int == 42); + try expect(foo.int == 42); } fn setFloat(foo: *Foo, x: f64) void { @@ -86,9 +86,9 @@ const FooExtern = extern union { test "basic extern unions" { var foo = FooExtern{ .int = 1 }; - expect(foo.int == 1); + try expect(foo.int == 1); foo.float = 12.34; - expect(foo.float == 12.34); + try expect(foo.float == 12.34); } const Letter = enum { @@ -103,16 +103,16 @@ const Payload = union(Letter) { }; test "union with specified enum tag" { - doTest(); - comptime doTest(); + try doTest(); + comptime try doTest(); } -fn doTest() void { - expect(bar(Payload{ .A = 1234 }) == -10); +fn doTest() !void { + try expect((try bar(Payload{ .A = 1234 })) == -10); } -fn bar(value: Payload) i32 { - expect(@as(Letter, value) == Letter.A); +fn bar(value: Payload) !i32 { + try expect(@as(Letter, value) == Letter.A); return switch (value) { Payload.A => |x| return x - 1244, Payload.B => |x| if (x == 12.34) @as(i32, 20) else 21, @@ -128,8 +128,8 @@ const MultipleChoice = union(enum(u32)) { }; test "simple union(enum(u32))" { var x = MultipleChoice.C; - expect(x == MultipleChoice.C); - expect(@enumToInt(@as(Tag(MultipleChoice), x)) == 60); + try expect(x == MultipleChoice.C); + try expect(@enumToInt(@as(Tag(MultipleChoice), x)) == 60); } const MultipleChoice2 = union(enum(u32)) { @@ -145,14 +145,14 @@ const MultipleChoice2 = union(enum(u32)) { }; test "union(enum(u32)) with specified and unspecified tag values" { - comptime expect(Tag(Tag(MultipleChoice2)) == u32); - testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); - comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); + comptime try expect(Tag(Tag(MultipleChoice2)) == u32); + try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); + comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); } -fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void { - expect(@enumToInt(@as(Tag(MultipleChoice2), x)) == 60); - expect(1123 == switch (x) { +fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { + try expect(@enumToInt(@as(Tag(MultipleChoice2), x)) == 60); + try expect(1123 == switch (x) { MultipleChoice2.A => 1, MultipleChoice2.B => 2, MultipleChoice2.C => |v| @as(i32, 1000) + v, @@ -170,7 +170,7 @@ const ExternPtrOrInt = extern union { int: u64, }; test "extern union size" { - comptime expect(@sizeOf(ExternPtrOrInt) == 8); + comptime try expect(@sizeOf(ExternPtrOrInt) == 8); } const PackedPtrOrInt = packed union { @@ -178,14 +178,14 @@ const PackedPtrOrInt = packed union { int: u64, }; test "extern union size" { - comptime expect(@sizeOf(PackedPtrOrInt) == 8); + comptime try expect(@sizeOf(PackedPtrOrInt) == 8); } const ZeroBits = union { OnlyField: void, }; test "union with only 1 field which is void should be zero bits" { - comptime expect(@sizeOf(ZeroBits) == 0); + comptime try expect(@sizeOf(ZeroBits) == 0); } const TheTag = enum { @@ -199,23 +199,23 @@ const TheUnion = union(TheTag) { C: i32, }; test "union field access gives the enum values" { - expect(TheUnion.A == TheTag.A); - expect(TheUnion.B == TheTag.B); - expect(TheUnion.C == TheTag.C); + try expect(TheUnion.A == TheTag.A); + try expect(TheUnion.B == TheTag.B); + try expect(TheUnion.C == TheTag.C); } test "cast union to tag type of union" { - testCastUnionToTag(TheUnion{ .B = 1234 }); - comptime testCastUnionToTag(TheUnion{ .B = 1234 }); + try testCastUnionToTag(TheUnion{ .B = 1234 }); + comptime try testCastUnionToTag(TheUnion{ .B = 1234 }); } -fn testCastUnionToTag(x: TheUnion) void { - expect(@as(TheTag, x) == TheTag.B); +fn testCastUnionToTag(x: TheUnion) !void { + try expect(@as(TheTag, x) == TheTag.B); } test "cast tag type of union to union" { var x: Value2 = Letter2.B; - expect(@as(Letter2, x) == Letter2.B); + try expect(@as(Letter2, x) == Letter2.B); } const Letter2 = enum { A, @@ -230,11 +230,11 @@ const Value2 = union(Letter2) { test "implicit cast union to its tag type" { var x: Value2 = Letter2.B; - expect(x == Letter2.B); - giveMeLetterB(x); + try expect(x == Letter2.B); + try giveMeLetterB(x); } -fn giveMeLetterB(x: Letter2) void { - expect(x == Value2.B); +fn giveMeLetterB(x: Letter2) !void { + try expect(x == Value2.B); } pub const PackThis = union(enum) { @@ -243,11 +243,11 @@ pub const PackThis = union(enum) { }; test "constant packed union" { - testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }}); + try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }}); } -fn testConstPackedUnion(expected_tokens: []const PackThis) void { - expect(expected_tokens[0].StringLiteral == 1); +fn testConstPackedUnion(expected_tokens: []const PackThis) !void { + try expect(expected_tokens[0].StringLiteral == 1); } test "switch on union with only 1 field" { @@ -259,7 +259,7 @@ test "switch on union with only 1 field" { z = PartialInstWithPayload{ .Compiled = 1234 }; switch (z) { PartialInstWithPayload.Compiled => |x| { - expect(x == 1234); + try expect(x == 1234); return; }, } @@ -285,11 +285,11 @@ test "access a member of tagged union with conflicting enum tag name" { const B = void; }; - comptime expect(Bar.A == u8); + comptime try expect(Bar.A == u8); } test "tagged union initialization with runtime void" { - expect(testTaggedUnionInit({})); + try expect(testTaggedUnionInit({})); } const TaggedUnionWithAVoid = union(enum) { @@ -327,9 +327,9 @@ test "union with only 1 field casted to its enum type" { var e = Expr{ .Literal = Literal{ .Bool = true } }; const ExprTag = Tag(Expr); - comptime expect(Tag(ExprTag) == u0); + comptime try expect(Tag(ExprTag) == u0); var t = @as(ExprTag, e); - expect(t == Expr.Literal); + try expect(t == Expr.Literal); } 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 }; var e = Expr{ .Literal = Literal{ .Bool = true } }; - comptime expect(Tag(ExprTag) == comptime_int); + comptime try expect(Tag(ExprTag) == comptime_int); var t = @as(ExprTag, e); - expect(t == Expr.Literal); - expect(@enumToInt(t) == 33); - comptime expect(@enumToInt(t) == 33); + try expect(t == Expr.Literal); + try expect(@enumToInt(t) == 33); + comptime try expect(@enumToInt(t) == 33); } test "@enumToInt works on unions" { @@ -364,9 +364,9 @@ test "@enumToInt works on unions" { const a = Bar{ .A = true }; var b = Bar{ .B = undefined }; var c = Bar.C; - expect(@enumToInt(a) == 0); - expect(@enumToInt(b) == 1); - expect(@enumToInt(c) == 2); + try expect(@enumToInt(a) == 0); + try expect(@enumToInt(b) == 1); + try expect(@enumToInt(c) == 2); } const Attribute = union(enum) { @@ -393,23 +393,23 @@ test "comptime union field value equality" { const b1 = Setter(Attribute{ .B = 9 }); const b2 = Setter(Attribute{ .B = 5 }); - expect(a0 == a0); - expect(a1 == a1); - expect(a0 == a2); + try expect(a0 == a0); + try expect(a1 == a1); + try expect(a0 == a2); - expect(b0 == b0); - expect(b1 == b1); - expect(b0 == b2); + try expect(b0 == b0); + try expect(b1 == b1); + try expect(b0 == b2); - expect(a0 != b0); - expect(a0 != a1); - expect(b0 != b1); + try expect(a0 != b0); + try expect(a0 != a1); + try expect(b0 != b1); } test "return union init with void payload" { const S = struct { - fn entry() void { - expect(func().state == State.one); + fn entry() !void { + try expect(func().state == State.one); } const Outer = union(enum) { state: State, @@ -422,8 +422,8 @@ test "return union init with void payload" { return Outer{ .state = State{ .one = {} } }; } }; - S.entry(); - comptime S.entry(); + try S.entry(); + comptime try S.entry(); } test "@unionInit can modify a union type" { @@ -435,14 +435,14 @@ test "@unionInit can modify a union type" { var value: UnionInitEnum = undefined; value = @unionInit(UnionInitEnum, "Boolean", true); - expect(value.Boolean == true); + try expect(value.Boolean == true); value.Boolean = false; - expect(value.Boolean == false); + try expect(value.Boolean == false); value = @unionInit(UnionInitEnum, "Byte", 2); - expect(value.Byte == 2); + try expect(value.Byte == 2); value.Byte = 3; - expect(value.Byte == 3); + try expect(value.Byte == 3); } test "@unionInit can modify a pointer value" { @@ -455,10 +455,10 @@ test "@unionInit can modify a pointer value" { var value_ptr = &value; value_ptr.* = @unionInit(UnionInitEnum, "Boolean", true); - expect(value.Boolean == true); + try expect(value.Boolean == true); value_ptr.* = @unionInit(UnionInitEnum, "Byte", 2); - expect(value.Byte == 2); + try expect(value.Byte == 2); } test "union no tag with struct member" { @@ -471,38 +471,38 @@ test "union no tag with struct member" { u.foo(); } -fn testComparison() void { +fn testComparison() !void { var x = Payload{ .A = 42 }; - expect(x == .A); - expect(x != .B); - expect(x != .C); - expect((x == .B) == false); - expect((x == .C) == false); - expect((x != .A) == false); + try expect(x == .A); + try expect(x != .B); + try expect(x != .C); + try expect((x == .B) == false); + try expect((x == .C) == false); + try expect((x != .A) == false); } test "comparison between union and enum literal" { - testComparison(); - comptime testComparison(); + try testComparison(); + comptime try testComparison(); } test "packed union generates correctly aligned LLVM type" { const U = packed union { - f1: fn () void, + f1: fn () error{TestUnexpectedResult}!void, f2: u32, }; var foo = [_]U{ U{ .f1 = doTest }, U{ .f2 = 0 }, }; - foo[0].f1(); + try foo[0].f1(); } test "union with one member defaults to u0 tag type" { const U0 = union(enum) { X: u32, }; - comptime expect(Tag(Tag(U0)) == u0); + comptime try expect(Tag(Tag(U0)) == u0); } test "union with comptime_int tag" { @@ -511,7 +511,7 @@ test "union with comptime_int tag" { Y: u16, Z: u8, }; - comptime expect(Tag(Tag(Union)) == comptime_int); + comptime try expect(Tag(Tag(Union)) == comptime_int); } test "extern union doesn't trigger field check at comptime" { @@ -521,7 +521,7 @@ test "extern union doesn't trigger field check at comptime" { }; const x = U{ .x = 0x55AAAA55 }; - comptime expect(x.y == 0x55); + comptime try expect(x.y == 0x55); } const Foo1 = union(enum) { @@ -535,7 +535,7 @@ test "global union with single field is correctly initialized" { glbl = Foo1{ .f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 }, }; - expect(glbl.f.x == 123); + try expect(glbl.f.x == 123); } pub const FooUnion = union(enum) { @@ -548,8 +548,8 @@ var glbl_array: [2]FooUnion = undefined; test "initialize global array of union" { glbl_array[1] = FooUnion{ .U1 = 2 }; glbl_array[0] = FooUnion{ .U0 = 1 }; - expect(glbl_array[0].U0 == 1); - expect(glbl_array[1].U1 == 2); + try expect(glbl_array[0].U0 == 1); + try expect(glbl_array[1].U1 == 2); } test "anonymous union literal syntax" { @@ -559,19 +559,19 @@ test "anonymous union literal syntax" { float: f64, }; - fn doTheTest() void { + fn doTheTest() !void { var i: Number = .{ .int = 42 }; var f = makeNumber(); - expect(i.int == 42); - expect(f.float == 12.34); + try expect(i.int == 42); + try expect(f.float == 12.34); } fn makeNumber() Number { return .{ .float = 12.34 }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "update the tag value for zero-sized unions" { @@ -580,9 +580,9 @@ test "update the tag value for zero-sized unions" { U1: void, }; var x = S{ .U0 = {} }; - expect(x == .U0); + try expect(x == .U0); x = S{ .U1 = {} }; - expect(x == .U1); + try expect(x == .U1); } 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" { const ArchTag = Tag(Arch); - fn doTheTest() void { + fn doTheTest() !void { var x: ArchTag = getArch1(); - expect(x == .One); + try expect(x == .One); var y: ArchTag = getArch2(); - expect(y == .Two); + try expect(y == .Two); } pub fn getArch1() Arch { @@ -610,8 +610,8 @@ test "function call result coerces from tagged union to the tag" { return .{ .Two = 99 }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "0-sized extern union definition" { @@ -620,7 +620,7 @@ test "0-sized extern union definition" { const f = 1; }; - expect(U.f == 1); + try expect(U.f == 1); } test "union initializer generates padding only if needed" { @@ -629,7 +629,7 @@ test "union initializer generates padding only if needed" { }; var v = U{ .A = 532 }; - expect(v.A == 532); + try expect(v.A == 532); } test "runtime tag name with single field" { @@ -638,7 +638,7 @@ test "runtime tag name with single field" { }; var v = U{ .A = 42 }; - expect(std.mem.eql(u8, @tagName(v), "A")); + try expect(std.mem.eql(u8, @tagName(v), "A")); } test "cast from anonymous struct to union" { @@ -648,7 +648,7 @@ test "cast from anonymous struct to union" { B: []const u8, C: void, }; - fn doTheTest() void { + fn doTheTest() !void { var y: u32 = 42; const t0 = .{ .A = 123 }; const t1 = .{ .B = "foo" }; @@ -658,14 +658,14 @@ test "cast from anonymous struct to union" { var x1: U = t1; const x2: U = t2; var x3: U = t3; - expect(x0.A == 123); - expect(std.mem.eql(u8, x1.B, "foo")); - expect(x2 == .C); - expect(x3.A == y); + try expect(x0.A == 123); + try expect(std.mem.eql(u8, x1.B, "foo")); + try expect(x2 == .C); + try expect(x3.A == y); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } 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" { B: []const u8, C: void, }; - fn doTheTest() void { + fn doTheTest() !void { var y: u32 = 42; const t0 = &.{ .A = 123 }; const t1 = &.{ .B = "foo" }; @@ -685,14 +685,14 @@ test "cast from pointer to anonymous struct to pointer to union" { var x1: *const U = t1; const x2: *const U = t2; var x3: *const U = t3; - expect(x0.A == 123); - expect(std.mem.eql(u8, x1.B, "foo")); - expect(x2.* == .C); - expect(x3.A == y); + try expect(x0.A == 123); + try expect(std.mem.eql(u8, x1.B, "foo")); + try expect(x2.* == .C); + try expect(x3.A == y); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "method call on an empty union" { @@ -707,13 +707,13 @@ test "method call on an empty union" { } }; - fn doTheTest() void { + fn doTheTest() !void { var u = MyUnion{ .X1 = [0]u8{} }; - expect(u.useIt()); + try expect(u.useIt()); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "switching on non exhaustive union" { @@ -727,16 +727,16 @@ test "switching on non exhaustive union" { a: i32, b: u32, }; - fn doTheTest() void { + fn doTheTest() !void { var a = U{ .a = 2 }; switch (a) { - .a => |val| expect(val == 2), + .a => |val| try expect(val == 2), .b => unreachable, } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "containers with single-field enums" { @@ -746,21 +746,21 @@ test "containers with single-field enums" { const C = struct { a: A }; const D = struct { a: B }; - fn doTheTest() void { + fn doTheTest() !void { var array1 = [1]A{A{ .f1 = {} }}; var array2 = [1]B{B{ .f1 = {} }}; - expect(array1[0] == .f1); - expect(array2[0] == .f1); + try expect(array1[0] == .f1); + try expect(array2[0] == .f1); var struct1 = C{ .a = A{ .f1 = {} } }; var struct2 = D{ .a = B{ .f1 = {} } }; - expect(struct1.a == .f1); - expect(struct2.a == .f1); + try expect(struct1.a == .f1); + try expect(struct2.a == .f1); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "@unionInit on union w/ tag but no fields" { @@ -776,18 +776,18 @@ test "@unionInit on union w/ tag but no fields" { }; comptime { - expect(@sizeOf(Data) != 0); + try expect(@sizeOf(Data) != 0); } - fn doTheTest() void { + fn doTheTest() !void { var data: Data = .{ .no_op = .{} }; var o = Data.decode(&[_]u8{}); - expectEqual(Type.no_op, o); + try expectEqual(Type.no_op, o); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "union enum type gets a separate scope" { @@ -797,10 +797,10 @@ test "union enum type gets a separate scope" { const foo = 1; }; - fn doTheTest() void { - expect(!@hasDecl(Tag(U), "foo")); + fn doTheTest() !void { + try expect(!@hasDecl(Tag(U), "foo")); } }; - S.doTheTest(); + try S.doTheTest(); } diff --git a/test/stage1/behavior/usingnamespace.zig b/test/stage1/behavior/usingnamespace.zig index a44bf1bbc3..b529b24dd4 100644 --- a/test/stage1/behavior/usingnamespace.zig +++ b/test/stage1/behavior/usingnamespace.zig @@ -9,8 +9,8 @@ fn Foo(comptime T: type) type { test "usingnamespace inside a generic struct" { const std2 = Foo(std); const testing2 = Foo(std.testing); - std2.testing.expect(true); - testing2.expect(true); + try std2.testing.expect(true); + try testing2.expect(true); } usingnamespace struct { @@ -18,5 +18,5 @@ usingnamespace struct { }; test "usingnamespace does not redeclare an imported variable" { - comptime std.testing.expect(foo == 42); + comptime try std.testing.expect(foo == 42); } diff --git a/test/stage1/behavior/var_args.zig b/test/stage1/behavior/var_args.zig index eae8f8f888..8935877167 100644 --- a/test/stage1/behavior/var_args.zig +++ b/test/stage1/behavior/var_args.zig @@ -12,9 +12,9 @@ fn add(args: anytype) i32 { } test "add arbitrary args" { - expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); - expect(add(.{@as(i32, 1234)}) == 1234); - expect(add(.{}) == 0); + try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); + try expect(add(.{@as(i32, 1234)}) == 1234); + try expect(add(.{}) == 0); } fn readFirstVarArg(args: anytype) void { @@ -26,9 +26,9 @@ test "send void arg to var args" { } test "pass args directly" { - expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); - expect(addSomeStuff(.{@as(i32, 1234)}) == 1234); - expect(addSomeStuff(.{}) == 0); + try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); + try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234); + try expect(addSomeStuff(.{}) == 0); } fn addSomeStuff(args: anytype) i32 { @@ -36,23 +36,23 @@ fn addSomeStuff(args: anytype) i32 { } test "runtime parameter before var args" { - expect(extraFn(10, .{}) == 0); - expect(extraFn(10, .{false}) == 1); - expect(extraFn(10, .{ false, true }) == 2); + try expect((try extraFn(10, .{})) == 0); + try expect((try extraFn(10, .{false})) == 1); + try expect((try extraFn(10, .{ false, true })) == 2); comptime { - expect(extraFn(10, .{}) == 0); - expect(extraFn(10, .{false}) == 1); - expect(extraFn(10, .{ false, true }) == 2); + try expect((try extraFn(10, .{})) == 0); + try expect((try extraFn(10, .{false})) == 1); + try expect((try extraFn(10, .{ false, true })) == 2); } } -fn extraFn(extra: u32, args: anytype) usize { +fn extraFn(extra: u32, args: anytype) !usize { if (args.len >= 1) { - expect(args[0] == false); + try expect(args[0] == false); } if (args.len >= 2) { - expect(args[1] == true); + try expect(args[1] == true); } return args.len; } @@ -70,8 +70,8 @@ fn foo2(args: anytype) bool { } test "array of var args functions" { - expect(foos[0](.{})); - expect(!foos[1](.{})); + try expect(foos[0](.{})); + try expect(!foos[1](.{})); } test "pass zero length array to var args param" { diff --git a/test/stage1/behavior/vector.zig b/test/stage1/behavior/vector.zig index 4b88ce020a..5c754dd1d0 100644 --- a/test/stage1/behavior/vector.zig +++ b/test/stage1/behavior/vector.zig @@ -9,104 +9,104 @@ const Vector = std.meta.Vector; test "implicit cast vector to array - bool" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { const a: Vector(4, bool) = [_]bool{ true, false, true, false }; const result_array: [4]bool = a; - expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false })); + try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector wrap operators" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 }; var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 }; - expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 })); - expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 })); - expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 })); + try expect(mem.eql(i32, &@as([4]i32, v +% x), &[4]i32{ -2147483648, 2147483645, 33, 44 })); + try expect(mem.eql(i32, &@as([4]i32, v -% x), &[4]i32{ 2147483646, 2147483647, 27, 36 })); + try expect(mem.eql(i32, &@as([4]i32, v *% x), &[4]i32{ 2147483647, 2, 90, 160 })); var z: Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 }; - expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 })); + try expect(mem.eql(i32, &@as([4]i32, -%z), &[4]i32{ -1, -2, -3, -2147483648 })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector bin compares with mem.eql" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 }; var x: Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 }; - expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false })); - expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true })); - expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false })); - expect(mem.eql(bool, &@as([4]bool, v > x), &[4]bool{ true, false, false, true })); - expect(mem.eql(bool, &@as([4]bool, v <= x), &[4]bool{ false, true, true, false })); - expect(mem.eql(bool, &@as([4]bool, v >= x), &[4]bool{ true, false, true, true })); + try expect(mem.eql(bool, &@as([4]bool, v == x), &[4]bool{ false, false, true, false })); + try expect(mem.eql(bool, &@as([4]bool, v != x), &[4]bool{ true, true, false, true })); + try expect(mem.eql(bool, &@as([4]bool, v < x), &[4]bool{ false, true, false, false })); + try expect(mem.eql(bool, &@as([4]bool, v > x), &[4]bool{ true, false, false, true })); + try expect(mem.eql(bool, &@as([4]bool, v <= x), &[4]bool{ false, true, true, false })); + try expect(mem.eql(bool, &@as([4]bool, v >= x), &[4]bool{ true, false, true, true })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector int operators" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 }; var x: Vector(4, i32) = [4]i32{ 1, 2, 3, 4 }; - expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 })); - expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 })); - expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 })); - expect(mem.eql(i32, &@as([4]i32, -v), &[4]i32{ -10, -20, -30, -40 })); + try expect(mem.eql(i32, &@as([4]i32, v + x), &[4]i32{ 11, 22, 33, 44 })); + try expect(mem.eql(i32, &@as([4]i32, v - x), &[4]i32{ 9, 18, 27, 36 })); + try expect(mem.eql(i32, &@as([4]i32, v * x), &[4]i32{ 10, 40, 90, 160 })); + try expect(mem.eql(i32, &@as([4]i32, -v), &[4]i32{ -10, -20, -30, -40 })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector float operators" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 }; var x: Vector(4, f32) = [4]f32{ 1, 2, 3, 4 }; - expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 })); - expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 })); - expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 })); - expect(mem.eql(f32, &@as([4]f32, -x), &[4]f32{ -1, -2, -3, -4 })); + try expect(mem.eql(f32, &@as([4]f32, v + x), &[4]f32{ 11, 22, 33, 44 })); + try expect(mem.eql(f32, &@as([4]f32, v - x), &[4]f32{ 9, 18, 27, 36 })); + try expect(mem.eql(f32, &@as([4]f32, v * x), &[4]f32{ 10, 40, 90, 160 })); + try expect(mem.eql(f32, &@as([4]f32, -x), &[4]f32{ -1, -2, -3, -4 })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector bit operators" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 }; var x: Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 }; - expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 })); - expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 })); - expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 })); + try expect(mem.eql(u8, &@as([4]u8, v ^ x), &[4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 })); + try expect(mem.eql(u8, &@as([4]u8, v | x), &[4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 })); + try expect(mem.eql(u8, &@as([4]u8, v & x), &[4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "implicit cast vector to array" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 }; var result_array: [4]i32 = a; result_array = a; - expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 })); + try expect(mem.eql(i32, &result_array, &[4]i32{ 1, 2, 3, 4 })); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "array to vector" { @@ -120,141 +120,141 @@ test "vector casts of sizes not divisable by 8" { if (std.Target.current.os.tag == .dragonfly) return error.SkipZigTest; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { { var v: Vector(4, u3) = [4]u3{ 5, 2, 3, 0 }; var x: [4]u3 = v; - expect(mem.eql(u3, &x, &@as([4]u3, v))); + try expect(mem.eql(u3, &x, &@as([4]u3, v))); } { var v: Vector(4, u2) = [4]u2{ 1, 2, 3, 0 }; var x: [4]u2 = v; - expect(mem.eql(u2, &x, &@as([4]u2, v))); + try expect(mem.eql(u2, &x, &@as([4]u2, v))); } { var v: Vector(4, u1) = [4]u1{ 1, 0, 1, 0 }; var x: [4]u1 = v; - expect(mem.eql(u1, &x, &@as([4]u1, v))); + try expect(mem.eql(u1, &x, &@as([4]u1, v))); } { var v: Vector(4, bool) = [4]bool{ false, false, true, false }; var x: [4]bool = v; - expect(mem.eql(bool, &x, &@as([4]bool, v))); + try expect(mem.eql(bool, &x, &@as([4]bool, v))); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector @splat" { const S = struct { - fn testForT(comptime N: comptime_int, v: anytype) void { + fn testForT(comptime N: comptime_int, v: anytype) !void { const T = @TypeOf(v); var vec = @splat(N, v); - expectEqual(Vector(N, T), @TypeOf(vec)); + try expectEqual(Vector(N, T), @TypeOf(vec)); var as_array = @as([N]T, vec); - for (as_array) |elem| expectEqual(v, elem); + for (as_array) |elem| try expectEqual(v, elem); } - fn doTheTest() void { + fn doTheTest() !void { // Splats with multiple-of-8 bit types that fill a 128bit vector. - testForT(16, @as(u8, 0xEE)); - testForT(8, @as(u16, 0xBEEF)); - testForT(4, @as(u32, 0xDEADBEEF)); - testForT(2, @as(u64, 0xCAFEF00DDEADBEEF)); + try testForT(16, @as(u8, 0xEE)); + try testForT(8, @as(u16, 0xBEEF)); + try testForT(4, @as(u32, 0xDEADBEEF)); + try testForT(2, @as(u64, 0xCAFEF00DDEADBEEF)); - testForT(8, @as(f16, 3.1415)); - testForT(4, @as(f32, 3.1415)); - testForT(2, @as(f64, 3.1415)); + try testForT(8, @as(f16, 3.1415)); + try testForT(4, @as(f32, 3.1415)); + try testForT(2, @as(f64, 3.1415)); // Same but fill more than 128 bits. - testForT(16 * 2, @as(u8, 0xEE)); - testForT(8 * 2, @as(u16, 0xBEEF)); - testForT(4 * 2, @as(u32, 0xDEADBEEF)); - testForT(2 * 2, @as(u64, 0xCAFEF00DDEADBEEF)); + try testForT(16 * 2, @as(u8, 0xEE)); + try testForT(8 * 2, @as(u16, 0xBEEF)); + try testForT(4 * 2, @as(u32, 0xDEADBEEF)); + try testForT(2 * 2, @as(u64, 0xCAFEF00DDEADBEEF)); - testForT(8 * 2, @as(f16, 3.1415)); - testForT(4 * 2, @as(f32, 3.1415)); - testForT(2 * 2, @as(f64, 3.1415)); + try testForT(8 * 2, @as(f16, 3.1415)); + try testForT(4 * 2, @as(f32, 3.1415)); + try testForT(2 * 2, @as(f64, 3.1415)); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "load vector elements via comptime index" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined }; - expect(v[0] == 1); - expect(v[1] == 2); - expect(loadv(&v[2]) == 3); + try expect(v[0] == 1); + try expect(v[1] == 2); + try expect(loadv(&v[2]) == 3); } fn loadv(ptr: anytype) i32 { return ptr.*; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "store vector elements via comptime index" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined }; v[2] = 42; - expect(v[1] == 5); + try expect(v[1] == 5); v[3] = -364; - expect(v[2] == 42); - expect(-364 == v[3]); + try expect(v[2] == 42); + try expect(-364 == v[3]); storev(&v[0], 100); - expect(v[0] == 100); + try expect(v[0] == 100); } fn storev(ptr: anytype, x: i32) void { ptr.* = x; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "load vector elements via runtime index" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined }; var i: u32 = 0; - expect(v[i] == 1); + try expect(v[i] == 1); i += 1; - expect(v[i] == 2); + try expect(v[i] == 2); i += 1; - expect(v[i] == 3); + try expect(v[i] == 3); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "store vector elements via runtime index" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined }; var i: u32 = 2; v[i] = 1; - expect(v[1] == 5); - expect(v[2] == 1); + try expect(v[1] == 5); + try expect(v[2] == 1); i += 1; v[i] = -364; - expect(-364 == v[3]); + try expect(-364 == v[3]); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "initialize vector which is a struct field" { @@ -263,155 +263,155 @@ test "initialize vector which is a struct field" { }; const S = struct { - fn doTheTest() void { + fn doTheTest() !void { var foo = Vec4Obj{ .data = [_]f32{ 1, 2, 3, 4 }, }; } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector comparison operators" { const S = struct { - fn doTheTest() void { + fn doTheTest() !void { { const v1: Vector(4, bool) = [_]bool{ true, false, true, false }; const v2: Vector(4, bool) = [_]bool{ false, true, false, true }; - expectEqual(@splat(4, true), v1 == v1); - expectEqual(@splat(4, false), v1 == v2); - expectEqual(@splat(4, true), v1 != v2); - expectEqual(@splat(4, false), v2 != v2); + try expectEqual(@splat(4, true), v1 == v1); + try expectEqual(@splat(4, false), v1 == v2); + try expectEqual(@splat(4, true), v1 != v2); + try expectEqual(@splat(4, false), v2 != v2); } { const v1 = @splat(4, @as(u32, 0xc0ffeeee)); const v2: Vector(4, c_uint) = v1; const v3 = @splat(4, @as(u32, 0xdeadbeef)); - expectEqual(@splat(4, true), v1 == v2); - expectEqual(@splat(4, false), v1 == v3); - expectEqual(@splat(4, true), v1 != v3); - expectEqual(@splat(4, false), v1 != v2); + try expectEqual(@splat(4, true), v1 == v2); + try expectEqual(@splat(4, false), v1 == v3); + try expectEqual(@splat(4, true), v1 != v3); + try expectEqual(@splat(4, false), v1 != v2); } { // Comptime-known LHS/RHS var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 }; const v2 = @splat(4, @as(u32, 2)); const v3: @Vector(4, bool) = [_]bool{ true, false, true, false }; - expectEqual(v3, v1 == v2); - expectEqual(v3, v2 == v1); + try expectEqual(v3, v1 == v2); + try expectEqual(v3, v2 == v1); } } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector division operators" { const S = struct { - fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) void { + fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void { if (!comptime std.meta.trait.isSignedInt(T)) { const d0 = x / y; for (@as([4]T, d0)) |v, i| { - expectEqual(x[i] / y[i], v); + try expectEqual(x[i] / y[i], v); } } const d1 = @divExact(x, y); for (@as([4]T, d1)) |v, i| { - expectEqual(@divExact(x[i], y[i]), v); + try expectEqual(@divExact(x[i], y[i]), v); } const d2 = @divFloor(x, y); for (@as([4]T, d2)) |v, i| { - expectEqual(@divFloor(x[i], y[i]), v); + try expectEqual(@divFloor(x[i], y[i]), v); } const d3 = @divTrunc(x, y); for (@as([4]T, d3)) |v, i| { - expectEqual(@divTrunc(x[i], y[i]), v); + try expectEqual(@divTrunc(x[i], y[i]), v); } } - fn doTheTestMod(comptime T: type, x: Vector(4, T), y: Vector(4, T)) void { + fn doTheTestMod(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void { if ((!comptime std.meta.trait.isSignedInt(T)) and @typeInfo(T) != .Float) { const r0 = x % y; for (@as([4]T, r0)) |v, i| { - expectEqual(x[i] % y[i], v); + try expectEqual(x[i] % y[i], v); } } const r1 = @mod(x, y); for (@as([4]T, r1)) |v, i| { - expectEqual(@mod(x[i], y[i]), v); + try expectEqual(@mod(x[i], y[i]), v); } const r2 = @rem(x, y); for (@as([4]T, r2)) |v, i| { - expectEqual(@rem(x[i], y[i]), v); + try expectEqual(@rem(x[i], y[i]), v); } } - fn doTheTest() void { + fn doTheTest() !void { // https://github.com/ziglang/zig/issues/4952 if (std.builtin.os.tag != .windows) { - doTheTestDiv(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, -1.0, -2.0 }); + try doTheTestDiv(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, -1.0, -2.0 }); } - doTheTestDiv(f32, [4]f32{ 4.0, -4.0, 4.0, -4.0 }, [4]f32{ 1.0, 2.0, -1.0, -2.0 }); - doTheTestDiv(f64, [4]f64{ 4.0, -4.0, 4.0, -4.0 }, [4]f64{ 1.0, 2.0, -1.0, -2.0 }); + try doTheTestDiv(f32, [4]f32{ 4.0, -4.0, 4.0, -4.0 }, [4]f32{ 1.0, 2.0, -1.0, -2.0 }); + try doTheTestDiv(f64, [4]f64{ 4.0, -4.0, 4.0, -4.0 }, [4]f64{ 1.0, 2.0, -1.0, -2.0 }); // https://github.com/ziglang/zig/issues/4952 if (std.builtin.os.tag != .windows) { - doTheTestMod(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, 0.5, 3.0 }); + try doTheTestMod(f16, [4]f16{ 4.0, -4.0, 4.0, -4.0 }, [4]f16{ 1.0, 2.0, 0.5, 3.0 }); } - doTheTestMod(f32, [4]f32{ 4.0, -4.0, 4.0, -4.0 }, [4]f32{ 1.0, 2.0, 0.5, 3.0 }); - doTheTestMod(f64, [4]f64{ 4.0, -4.0, 4.0, -4.0 }, [4]f64{ 1.0, 2.0, 0.5, 3.0 }); + try doTheTestMod(f32, [4]f32{ 4.0, -4.0, 4.0, -4.0 }, [4]f32{ 1.0, 2.0, 0.5, 3.0 }); + try doTheTestMod(f64, [4]f64{ 4.0, -4.0, 4.0, -4.0 }, [4]f64{ 1.0, 2.0, 0.5, 3.0 }); - doTheTestDiv(i8, [4]i8{ 4, -4, 4, -4 }, [4]i8{ 1, 2, -1, -2 }); - doTheTestDiv(i16, [4]i16{ 4, -4, 4, -4 }, [4]i16{ 1, 2, -1, -2 }); - doTheTestDiv(i32, [4]i32{ 4, -4, 4, -4 }, [4]i32{ 1, 2, -1, -2 }); - doTheTestDiv(i64, [4]i64{ 4, -4, 4, -4 }, [4]i64{ 1, 2, -1, -2 }); + try doTheTestDiv(i8, [4]i8{ 4, -4, 4, -4 }, [4]i8{ 1, 2, -1, -2 }); + try doTheTestDiv(i16, [4]i16{ 4, -4, 4, -4 }, [4]i16{ 1, 2, -1, -2 }); + try doTheTestDiv(i32, [4]i32{ 4, -4, 4, -4 }, [4]i32{ 1, 2, -1, -2 }); + try doTheTestDiv(i64, [4]i64{ 4, -4, 4, -4 }, [4]i64{ 1, 2, -1, -2 }); - doTheTestMod(i8, [4]i8{ 4, -4, 4, -4 }, [4]i8{ 1, 2, 4, 8 }); - doTheTestMod(i16, [4]i16{ 4, -4, 4, -4 }, [4]i16{ 1, 2, 4, 8 }); - doTheTestMod(i32, [4]i32{ 4, -4, 4, -4 }, [4]i32{ 1, 2, 4, 8 }); - doTheTestMod(i64, [4]i64{ 4, -4, 4, -4 }, [4]i64{ 1, 2, 4, 8 }); + try doTheTestMod(i8, [4]i8{ 4, -4, 4, -4 }, [4]i8{ 1, 2, 4, 8 }); + try doTheTestMod(i16, [4]i16{ 4, -4, 4, -4 }, [4]i16{ 1, 2, 4, 8 }); + try doTheTestMod(i32, [4]i32{ 4, -4, 4, -4 }, [4]i32{ 1, 2, 4, 8 }); + try doTheTestMod(i64, [4]i64{ 4, -4, 4, -4 }, [4]i64{ 1, 2, 4, 8 }); - doTheTestDiv(u8, [4]u8{ 1, 2, 4, 8 }, [4]u8{ 1, 1, 2, 4 }); - doTheTestDiv(u16, [4]u16{ 1, 2, 4, 8 }, [4]u16{ 1, 1, 2, 4 }); - doTheTestDiv(u32, [4]u32{ 1, 2, 4, 8 }, [4]u32{ 1, 1, 2, 4 }); - doTheTestDiv(u64, [4]u64{ 1, 2, 4, 8 }, [4]u64{ 1, 1, 2, 4 }); + try doTheTestDiv(u8, [4]u8{ 1, 2, 4, 8 }, [4]u8{ 1, 1, 2, 4 }); + try doTheTestDiv(u16, [4]u16{ 1, 2, 4, 8 }, [4]u16{ 1, 1, 2, 4 }); + try doTheTestDiv(u32, [4]u32{ 1, 2, 4, 8 }, [4]u32{ 1, 1, 2, 4 }); + try doTheTestDiv(u64, [4]u64{ 1, 2, 4, 8 }, [4]u64{ 1, 1, 2, 4 }); - doTheTestMod(u8, [4]u8{ 1, 2, 4, 8 }, [4]u8{ 1, 1, 2, 4 }); - doTheTestMod(u16, [4]u16{ 1, 2, 4, 8 }, [4]u16{ 1, 1, 2, 4 }); - doTheTestMod(u32, [4]u32{ 1, 2, 4, 8 }, [4]u32{ 1, 1, 2, 4 }); - doTheTestMod(u64, [4]u64{ 1, 2, 4, 8 }, [4]u64{ 1, 1, 2, 4 }); + try doTheTestMod(u8, [4]u8{ 1, 2, 4, 8 }, [4]u8{ 1, 1, 2, 4 }); + try doTheTestMod(u16, [4]u16{ 1, 2, 4, 8 }, [4]u16{ 1, 1, 2, 4 }); + try doTheTestMod(u32, [4]u32{ 1, 2, 4, 8 }, [4]u32{ 1, 1, 2, 4 }); + try doTheTestMod(u64, [4]u64{ 1, 2, 4, 8 }, [4]u64{ 1, 1, 2, 4 }); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector bitwise not operator" { const S = struct { - fn doTheTestNot(comptime T: type, x: Vector(4, T)) void { + fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void { var y = ~x; for (@as([4]T, y)) |v, i| { - expectEqual(~x[i], v); + try expectEqual(~x[i], v); } } - fn doTheTest() void { - doTheTestNot(u8, [_]u8{ 0, 2, 4, 255 }); - doTheTestNot(u16, [_]u16{ 0, 2, 4, 255 }); - doTheTestNot(u32, [_]u32{ 0, 2, 4, 255 }); - doTheTestNot(u64, [_]u64{ 0, 2, 4, 255 }); + fn doTheTest() !void { + try doTheTestNot(u8, [_]u8{ 0, 2, 4, 255 }); + try doTheTestNot(u16, [_]u16{ 0, 2, 4, 255 }); + try doTheTestNot(u32, [_]u32{ 0, 2, 4, 255 }); + try doTheTestNot(u64, [_]u64{ 0, 2, 4, 255 }); - doTheTestNot(u8, [_]u8{ 0, 2, 4, 255 }); - doTheTestNot(u16, [_]u16{ 0, 2, 4, 255 }); - doTheTestNot(u32, [_]u32{ 0, 2, 4, 255 }); - doTheTestNot(u64, [_]u64{ 0, 2, 4, 255 }); + try doTheTestNot(u8, [_]u8{ 0, 2, 4, 255 }); + try doTheTestNot(u16, [_]u16{ 0, 2, 4, 255 }); + try doTheTestNot(u32, [_]u32{ 0, 2, 4, 255 }); + try doTheTestNot(u64, [_]u64{ 0, 2, 4, 255 }); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector shift operators" { @@ -419,7 +419,7 @@ test "vector shift operators" { if (builtin.os.tag == .wasi) return error.SkipZigTest; const S = struct { - fn doTheTestShift(x: anytype, y: anytype) void { + fn doTheTestShift(x: anytype, y: anytype) !void { const N = @typeInfo(@TypeOf(x)).Array.len; const TX = @typeInfo(@TypeOf(x)).Array.child; const TY = @typeInfo(@TypeOf(y)).Array.child; @@ -429,14 +429,14 @@ test "vector shift operators" { var z0 = xv >> yv; for (@as([N]TX, z0)) |v, i| { - expectEqual(x[i] >> y[i], v); + try expectEqual(x[i] >> y[i], v); } var z1 = xv << yv; for (@as([N]TX, z1)) |v, i| { - expectEqual(x[i] << y[i], v); + try expectEqual(x[i] << y[i], v); } } - fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) void { + fn doTheTestShiftExact(x: anytype, y: anytype, dir: enum { Left, Right }) !void { const N = @typeInfo(@TypeOf(x)).Array.len; const TX = @typeInfo(@TypeOf(x)).Array.child; const TY = @typeInfo(@TypeOf(y)).Array.child; @@ -447,33 +447,33 @@ test "vector shift operators" { var z = if (dir == .Left) @shlExact(xv, yv) else @shrExact(xv, yv); for (@as([N]TX, z)) |v, i| { const check = if (dir == .Left) x[i] << y[i] else x[i] >> y[i]; - expectEqual(check, v); + try expectEqual(check, v); } } - fn doTheTest() void { - doTheTestShift([_]u8{ 0, 2, 4, math.maxInt(u8) }, [_]u3{ 2, 0, 2, 7 }); - doTheTestShift([_]u16{ 0, 2, 4, math.maxInt(u16) }, [_]u4{ 2, 0, 2, 15 }); - doTheTestShift([_]u24{ 0, 2, 4, math.maxInt(u24) }, [_]u5{ 2, 0, 2, 23 }); - doTheTestShift([_]u32{ 0, 2, 4, math.maxInt(u32) }, [_]u5{ 2, 0, 2, 31 }); - doTheTestShift([_]u64{ 0xfe, math.maxInt(u64) }, [_]u6{ 0, 63 }); + fn doTheTest() !void { + try doTheTestShift([_]u8{ 0, 2, 4, math.maxInt(u8) }, [_]u3{ 2, 0, 2, 7 }); + try doTheTestShift([_]u16{ 0, 2, 4, math.maxInt(u16) }, [_]u4{ 2, 0, 2, 15 }); + try doTheTestShift([_]u24{ 0, 2, 4, math.maxInt(u24) }, [_]u5{ 2, 0, 2, 23 }); + try doTheTestShift([_]u32{ 0, 2, 4, math.maxInt(u32) }, [_]u5{ 2, 0, 2, 31 }); + try doTheTestShift([_]u64{ 0xfe, math.maxInt(u64) }, [_]u6{ 0, 63 }); - doTheTestShift([_]i8{ 0, 2, 4, math.maxInt(i8) }, [_]u3{ 2, 0, 2, 7 }); - doTheTestShift([_]i16{ 0, 2, 4, math.maxInt(i16) }, [_]u4{ 2, 0, 2, 7 }); - doTheTestShift([_]i24{ 0, 2, 4, math.maxInt(i24) }, [_]u5{ 2, 0, 2, 7 }); - doTheTestShift([_]i32{ 0, 2, 4, math.maxInt(i32) }, [_]u5{ 2, 0, 2, 7 }); - doTheTestShift([_]i64{ 0xfe, math.maxInt(i64) }, [_]u6{ 0, 63 }); + try doTheTestShift([_]i8{ 0, 2, 4, math.maxInt(i8) }, [_]u3{ 2, 0, 2, 7 }); + try doTheTestShift([_]i16{ 0, 2, 4, math.maxInt(i16) }, [_]u4{ 2, 0, 2, 7 }); + try doTheTestShift([_]i24{ 0, 2, 4, math.maxInt(i24) }, [_]u5{ 2, 0, 2, 7 }); + try doTheTestShift([_]i32{ 0, 2, 4, math.maxInt(i32) }, [_]u5{ 2, 0, 2, 7 }); + try doTheTestShift([_]i64{ 0xfe, math.maxInt(i64) }, [_]u6{ 0, 63 }); - doTheTestShiftExact([_]u8{ 0, 1, 1 << 7, math.maxInt(u8) ^ 1 }, [_]u3{ 4, 0, 7, 1 }, .Right); - doTheTestShiftExact([_]u16{ 0, 1, 1 << 15, math.maxInt(u16) ^ 1 }, [_]u4{ 4, 0, 15, 1 }, .Right); - doTheTestShiftExact([_]u24{ 0, 1, 1 << 23, math.maxInt(u24) ^ 1 }, [_]u5{ 4, 0, 23, 1 }, .Right); - doTheTestShiftExact([_]u32{ 0, 1, 1 << 31, math.maxInt(u32) ^ 1 }, [_]u5{ 4, 0, 31, 1 }, .Right); - doTheTestShiftExact([_]u64{ 1 << 63, 1 }, [_]u6{ 63, 0 }, .Right); + try doTheTestShiftExact([_]u8{ 0, 1, 1 << 7, math.maxInt(u8) ^ 1 }, [_]u3{ 4, 0, 7, 1 }, .Right); + try doTheTestShiftExact([_]u16{ 0, 1, 1 << 15, math.maxInt(u16) ^ 1 }, [_]u4{ 4, 0, 15, 1 }, .Right); + try doTheTestShiftExact([_]u24{ 0, 1, 1 << 23, math.maxInt(u24) ^ 1 }, [_]u5{ 4, 0, 23, 1 }, .Right); + try doTheTestShiftExact([_]u32{ 0, 1, 1 << 31, math.maxInt(u32) ^ 1 }, [_]u5{ 4, 0, 31, 1 }, .Right); + try doTheTestShiftExact([_]u64{ 1 << 63, 1 }, [_]u6{ 63, 0 }, .Right); - doTheTestShiftExact([_]u8{ 0, 1, 1, math.maxInt(u8) ^ (1 << 7) }, [_]u3{ 4, 0, 7, 1 }, .Left); - doTheTestShiftExact([_]u16{ 0, 1, 1, math.maxInt(u16) ^ (1 << 15) }, [_]u4{ 4, 0, 15, 1 }, .Left); - doTheTestShiftExact([_]u24{ 0, 1, 1, math.maxInt(u24) ^ (1 << 23) }, [_]u5{ 4, 0, 23, 1 }, .Left); - doTheTestShiftExact([_]u32{ 0, 1, 1, math.maxInt(u32) ^ (1 << 31) }, [_]u5{ 4, 0, 31, 1 }, .Left); - doTheTestShiftExact([_]u64{ 1 << 63, 1 }, [_]u6{ 0, 63 }, .Left); + try doTheTestShiftExact([_]u8{ 0, 1, 1, math.maxInt(u8) ^ (1 << 7) }, [_]u3{ 4, 0, 7, 1 }, .Left); + try doTheTestShiftExact([_]u16{ 0, 1, 1, math.maxInt(u16) ^ (1 << 15) }, [_]u4{ 4, 0, 15, 1 }, .Left); + try doTheTestShiftExact([_]u24{ 0, 1, 1, math.maxInt(u24) ^ (1 << 23) }, [_]u5{ 4, 0, 23, 1 }, .Left); + try doTheTestShiftExact([_]u32{ 0, 1, 1, math.maxInt(u32) ^ (1 << 31) }, [_]u5{ 4, 0, 31, 1 }, .Left); + try doTheTestShiftExact([_]u64{ 1 << 63, 1 }, [_]u6{ 0, 63 }, .Left); } }; @@ -500,19 +500,19 @@ test "vector shift operators" { else => {}, } - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } test "vector reduce operation" { const S = struct { - fn doTheTestReduce(comptime op: builtin.ReduceOp, x: anytype, expected: anytype) void { + fn doTheTestReduce(comptime op: builtin.ReduceOp, x: anytype, expected: anytype) !void { const N = @typeInfo(@TypeOf(x)).Array.len; const TX = @typeInfo(@TypeOf(x)).Array.child; var r = @reduce(op, @as(Vector(N, TX), x)); switch (@typeInfo(TX)) { - .Int, .Bool => expectEqual(expected, r), + .Int, .Bool => try expectEqual(expected, r), .Float => { const expected_nan = math.isNan(expected); const got_nan = math.isNan(r); @@ -521,120 +521,120 @@ test "vector reduce operation" { // Do this check explicitly as two NaN values are never // equal. } else { - expectApproxEqRel(expected, r, math.sqrt(math.epsilon(TX))); + try expectApproxEqRel(expected, r, math.sqrt(math.epsilon(TX))); } }, else => unreachable, } } - fn doTheTest() void { - doTheTestReduce(.Add, [4]i16{ -9, -99, -999, -9999 }, @as(i32, -11106)); - doTheTestReduce(.Add, [4]u16{ 9, 99, 999, 9999 }, @as(u32, 11106)); - doTheTestReduce(.Add, [4]i32{ -9, -99, -999, -9999 }, @as(i32, -11106)); - doTheTestReduce(.Add, [4]u32{ 9, 99, 999, 9999 }, @as(u32, 11106)); - doTheTestReduce(.Add, [4]i64{ -9, -99, -999, -9999 }, @as(i64, -11106)); - doTheTestReduce(.Add, [4]u64{ 9, 99, 999, 9999 }, @as(u64, 11106)); - doTheTestReduce(.Add, [4]i128{ -9, -99, -999, -9999 }, @as(i128, -11106)); - doTheTestReduce(.Add, [4]u128{ 9, 99, 999, 9999 }, @as(u128, 11106)); - doTheTestReduce(.Add, [4]f16{ -1.9, 5.1, -60.3, 100.0 }, @as(f16, 42.9)); - doTheTestReduce(.Add, [4]f32{ -1.9, 5.1, -60.3, 100.0 }, @as(f32, 42.9)); - doTheTestReduce(.Add, [4]f64{ -1.9, 5.1, -60.3, 100.0 }, @as(f64, 42.9)); + fn doTheTest() !void { + try doTheTestReduce(.Add, [4]i16{ -9, -99, -999, -9999 }, @as(i32, -11106)); + try doTheTestReduce(.Add, [4]u16{ 9, 99, 999, 9999 }, @as(u32, 11106)); + try doTheTestReduce(.Add, [4]i32{ -9, -99, -999, -9999 }, @as(i32, -11106)); + try doTheTestReduce(.Add, [4]u32{ 9, 99, 999, 9999 }, @as(u32, 11106)); + try doTheTestReduce(.Add, [4]i64{ -9, -99, -999, -9999 }, @as(i64, -11106)); + try doTheTestReduce(.Add, [4]u64{ 9, 99, 999, 9999 }, @as(u64, 11106)); + try doTheTestReduce(.Add, [4]i128{ -9, -99, -999, -9999 }, @as(i128, -11106)); + try doTheTestReduce(.Add, [4]u128{ 9, 99, 999, 9999 }, @as(u128, 11106)); + try doTheTestReduce(.Add, [4]f16{ -1.9, 5.1, -60.3, 100.0 }, @as(f16, 42.9)); + try doTheTestReduce(.Add, [4]f32{ -1.9, 5.1, -60.3, 100.0 }, @as(f32, 42.9)); + try doTheTestReduce(.Add, [4]f64{ -1.9, 5.1, -60.3, 100.0 }, @as(f64, 42.9)); - doTheTestReduce(.And, [4]bool{ true, false, true, true }, @as(bool, false)); - doTheTestReduce(.And, [4]u1{ 1, 0, 1, 1 }, @as(u1, 0)); - doTheTestReduce(.And, [4]u16{ 0xffff, 0xff55, 0xaaff, 0x1010 }, @as(u16, 0x10)); - doTheTestReduce(.And, [4]u32{ 0xffffffff, 0xffff5555, 0xaaaaffff, 0x10101010 }, @as(u32, 0x1010)); - doTheTestReduce(.And, [4]u64{ 0xffffffff, 0xffff5555, 0xaaaaffff, 0x10101010 }, @as(u64, 0x1010)); + try doTheTestReduce(.And, [4]bool{ true, false, true, true }, @as(bool, false)); + try doTheTestReduce(.And, [4]u1{ 1, 0, 1, 1 }, @as(u1, 0)); + try doTheTestReduce(.And, [4]u16{ 0xffff, 0xff55, 0xaaff, 0x1010 }, @as(u16, 0x10)); + try doTheTestReduce(.And, [4]u32{ 0xffffffff, 0xffff5555, 0xaaaaffff, 0x10101010 }, @as(u32, 0x1010)); + try doTheTestReduce(.And, [4]u64{ 0xffffffff, 0xffff5555, 0xaaaaffff, 0x10101010 }, @as(u64, 0x1010)); - doTheTestReduce(.Min, [4]i16{ -1, 2, 3, 4 }, @as(i16, -1)); - doTheTestReduce(.Min, [4]u16{ 1, 2, 3, 4 }, @as(u16, 1)); - doTheTestReduce(.Min, [4]i32{ 1234567, -386, 0, 3 }, @as(i32, -386)); - doTheTestReduce(.Min, [4]u32{ 99, 9999, 9, 99999 }, @as(u32, 9)); + try doTheTestReduce(.Min, [4]i16{ -1, 2, 3, 4 }, @as(i16, -1)); + try doTheTestReduce(.Min, [4]u16{ 1, 2, 3, 4 }, @as(u16, 1)); + try doTheTestReduce(.Min, [4]i32{ 1234567, -386, 0, 3 }, @as(i32, -386)); + try doTheTestReduce(.Min, [4]u32{ 99, 9999, 9, 99999 }, @as(u32, 9)); // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 if (std.builtin.arch != .aarch64) { - doTheTestReduce(.Min, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, -386)); - doTheTestReduce(.Min, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 9)); + try doTheTestReduce(.Min, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, -386)); + try doTheTestReduce(.Min, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 9)); } - doTheTestReduce(.Min, [4]i128{ 1234567, -386, 0, 3 }, @as(i128, -386)); - doTheTestReduce(.Min, [4]u128{ 99, 9999, 9, 99999 }, @as(u128, 9)); - doTheTestReduce(.Min, [4]f16{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f16, -100.0)); - doTheTestReduce(.Min, [4]f32{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f32, -100.0)); - doTheTestReduce(.Min, [4]f64{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f64, -100.0)); + try doTheTestReduce(.Min, [4]i128{ 1234567, -386, 0, 3 }, @as(i128, -386)); + try doTheTestReduce(.Min, [4]u128{ 99, 9999, 9, 99999 }, @as(u128, 9)); + try doTheTestReduce(.Min, [4]f16{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f16, -100.0)); + try doTheTestReduce(.Min, [4]f32{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f32, -100.0)); + try doTheTestReduce(.Min, [4]f64{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f64, -100.0)); - doTheTestReduce(.Max, [4]i16{ -1, 2, 3, 4 }, @as(i16, 4)); - doTheTestReduce(.Max, [4]u16{ 1, 2, 3, 4 }, @as(u16, 4)); - doTheTestReduce(.Max, [4]i32{ 1234567, -386, 0, 3 }, @as(i32, 1234567)); - doTheTestReduce(.Max, [4]u32{ 99, 9999, 9, 99999 }, @as(u32, 99999)); + try doTheTestReduce(.Max, [4]i16{ -1, 2, 3, 4 }, @as(i16, 4)); + try doTheTestReduce(.Max, [4]u16{ 1, 2, 3, 4 }, @as(u16, 4)); + try doTheTestReduce(.Max, [4]i32{ 1234567, -386, 0, 3 }, @as(i32, 1234567)); + try doTheTestReduce(.Max, [4]u32{ 99, 9999, 9, 99999 }, @as(u32, 99999)); // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 if (std.builtin.arch != .aarch64) { - doTheTestReduce(.Max, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, 1234567)); - doTheTestReduce(.Max, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 99999)); + try doTheTestReduce(.Max, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, 1234567)); + try doTheTestReduce(.Max, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 99999)); } - doTheTestReduce(.Max, [4]i128{ 1234567, -386, 0, 3 }, @as(i128, 1234567)); - doTheTestReduce(.Max, [4]u128{ 99, 9999, 9, 99999 }, @as(u128, 99999)); - doTheTestReduce(.Max, [4]f16{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f16, 10.0e9)); - doTheTestReduce(.Max, [4]f32{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f32, 10.0e9)); - doTheTestReduce(.Max, [4]f64{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f64, 10.0e9)); + try doTheTestReduce(.Max, [4]i128{ 1234567, -386, 0, 3 }, @as(i128, 1234567)); + try doTheTestReduce(.Max, [4]u128{ 99, 9999, 9, 99999 }, @as(u128, 99999)); + try doTheTestReduce(.Max, [4]f16{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f16, 10.0e9)); + try doTheTestReduce(.Max, [4]f32{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f32, 10.0e9)); + try doTheTestReduce(.Max, [4]f64{ -10.3, 10.0e9, 13.0, -100.0 }, @as(f64, 10.0e9)); - doTheTestReduce(.Mul, [4]i16{ -1, 2, 3, 4 }, @as(i16, -24)); - doTheTestReduce(.Mul, [4]u16{ 1, 2, 3, 4 }, @as(u16, 24)); - doTheTestReduce(.Mul, [4]i32{ -9, -99, -999, 999 }, @as(i32, -889218891)); - doTheTestReduce(.Mul, [4]u32{ 1, 2, 3, 4 }, @as(u32, 24)); - doTheTestReduce(.Mul, [4]i64{ 9, 99, 999, 9999 }, @as(i64, 8900199891)); - doTheTestReduce(.Mul, [4]u64{ 9, 99, 999, 9999 }, @as(u64, 8900199891)); - doTheTestReduce(.Mul, [4]i128{ -9, -99, -999, 9999 }, @as(i128, -8900199891)); - doTheTestReduce(.Mul, [4]u128{ 9, 99, 999, 9999 }, @as(u128, 8900199891)); - doTheTestReduce(.Mul, [4]f16{ -1.9, 5.1, -60.3, 100.0 }, @as(f16, 58430.7)); - doTheTestReduce(.Mul, [4]f32{ -1.9, 5.1, -60.3, 100.0 }, @as(f32, 58430.7)); - doTheTestReduce(.Mul, [4]f64{ -1.9, 5.1, -60.3, 100.0 }, @as(f64, 58430.7)); + try doTheTestReduce(.Mul, [4]i16{ -1, 2, 3, 4 }, @as(i16, -24)); + try doTheTestReduce(.Mul, [4]u16{ 1, 2, 3, 4 }, @as(u16, 24)); + try doTheTestReduce(.Mul, [4]i32{ -9, -99, -999, 999 }, @as(i32, -889218891)); + try doTheTestReduce(.Mul, [4]u32{ 1, 2, 3, 4 }, @as(u32, 24)); + try doTheTestReduce(.Mul, [4]i64{ 9, 99, 999, 9999 }, @as(i64, 8900199891)); + try doTheTestReduce(.Mul, [4]u64{ 9, 99, 999, 9999 }, @as(u64, 8900199891)); + try doTheTestReduce(.Mul, [4]i128{ -9, -99, -999, 9999 }, @as(i128, -8900199891)); + try doTheTestReduce(.Mul, [4]u128{ 9, 99, 999, 9999 }, @as(u128, 8900199891)); + try doTheTestReduce(.Mul, [4]f16{ -1.9, 5.1, -60.3, 100.0 }, @as(f16, 58430.7)); + try doTheTestReduce(.Mul, [4]f32{ -1.9, 5.1, -60.3, 100.0 }, @as(f32, 58430.7)); + try doTheTestReduce(.Mul, [4]f64{ -1.9, 5.1, -60.3, 100.0 }, @as(f64, 58430.7)); - doTheTestReduce(.Or, [4]bool{ false, true, false, false }, @as(bool, true)); - doTheTestReduce(.Or, [4]u1{ 0, 1, 0, 0 }, @as(u1, 1)); - doTheTestReduce(.Or, [4]u16{ 0xff00, 0xff00, 0xf0, 0xf }, ~@as(u16, 0)); - doTheTestReduce(.Or, [4]u32{ 0xffff0000, 0xff00, 0xf0, 0xf }, ~@as(u32, 0)); - doTheTestReduce(.Or, [4]u64{ 0xffff0000, 0xff00, 0xf0, 0xf }, @as(u64, 0xffffffff)); - doTheTestReduce(.Or, [4]u128{ 0xffff0000, 0xff00, 0xf0, 0xf }, @as(u128, 0xffffffff)); + try doTheTestReduce(.Or, [4]bool{ false, true, false, false }, @as(bool, true)); + try doTheTestReduce(.Or, [4]u1{ 0, 1, 0, 0 }, @as(u1, 1)); + try doTheTestReduce(.Or, [4]u16{ 0xff00, 0xff00, 0xf0, 0xf }, ~@as(u16, 0)); + try doTheTestReduce(.Or, [4]u32{ 0xffff0000, 0xff00, 0xf0, 0xf }, ~@as(u32, 0)); + try doTheTestReduce(.Or, [4]u64{ 0xffff0000, 0xff00, 0xf0, 0xf }, @as(u64, 0xffffffff)); + try doTheTestReduce(.Or, [4]u128{ 0xffff0000, 0xff00, 0xf0, 0xf }, @as(u128, 0xffffffff)); - doTheTestReduce(.Xor, [4]bool{ true, true, true, false }, @as(bool, true)); - doTheTestReduce(.Xor, [4]u1{ 1, 1, 1, 0 }, @as(u1, 1)); - doTheTestReduce(.Xor, [4]u16{ 0x0000, 0x3333, 0x8888, 0x4444 }, ~@as(u16, 0)); - doTheTestReduce(.Xor, [4]u32{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, ~@as(u32, 0)); - doTheTestReduce(.Xor, [4]u64{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, @as(u64, 0xffffffff)); - doTheTestReduce(.Xor, [4]u128{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, @as(u128, 0xffffffff)); + try doTheTestReduce(.Xor, [4]bool{ true, true, true, false }, @as(bool, true)); + try doTheTestReduce(.Xor, [4]u1{ 1, 1, 1, 0 }, @as(u1, 1)); + try doTheTestReduce(.Xor, [4]u16{ 0x0000, 0x3333, 0x8888, 0x4444 }, ~@as(u16, 0)); + try doTheTestReduce(.Xor, [4]u32{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, ~@as(u32, 0)); + try doTheTestReduce(.Xor, [4]u64{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, @as(u64, 0xffffffff)); + try doTheTestReduce(.Xor, [4]u128{ 0x00000000, 0x33333333, 0x88888888, 0x44444444 }, @as(u128, 0xffffffff)); // Test the reduction on vectors containing NaNs. const f16_nan = math.nan(f16); const f32_nan = math.nan(f32); const f64_nan = math.nan(f64); - doTheTestReduce(.Add, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); - doTheTestReduce(.Add, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); - doTheTestReduce(.Add, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); + try doTheTestReduce(.Add, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); + try doTheTestReduce(.Add, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); + try doTheTestReduce(.Add, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 if (false) { - doTheTestReduce(.Min, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); - doTheTestReduce(.Min, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); - doTheTestReduce(.Min, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); + try doTheTestReduce(.Min, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); + try doTheTestReduce(.Min, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); + try doTheTestReduce(.Min, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); - doTheTestReduce(.Max, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); - doTheTestReduce(.Max, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); - doTheTestReduce(.Max, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); + try doTheTestReduce(.Max, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); + try doTheTestReduce(.Max, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); + try doTheTestReduce(.Max, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); } - doTheTestReduce(.Mul, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); - doTheTestReduce(.Mul, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); - doTheTestReduce(.Mul, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); + try doTheTestReduce(.Mul, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, f16_nan); + try doTheTestReduce(.Mul, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, f32_nan); + try doTheTestReduce(.Mul, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, f64_nan); } }; - S.doTheTest(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/void.zig b/test/stage1/behavior/void.zig index 80df9fe4f9..4f49d5fca1 100644 --- a/test/stage1/behavior/void.zig +++ b/test/stage1/behavior/void.zig @@ -13,14 +13,14 @@ test "compare void with void compile time known" { .b = 1, .c = {}, }; - expect(foo.a == {}); + try expect(foo.a == {}); } } test "iterate over a void slice" { var j: usize = 0; for (times(10)) |_, i| { - expect(i == j); + try expect(i == j); j += 1; } } @@ -31,7 +31,7 @@ fn times(n: usize) []const void { test "void optional" { var x: ?void = {}; - expect(x != null); + try expect(x != null); } test "void array as a local variable initializer" { diff --git a/test/stage1/behavior/wasm.zig b/test/stage1/behavior/wasm.zig index 24557ee19b..2190295514 100644 --- a/test/stage1/behavior/wasm.zig +++ b/test/stage1/behavior/wasm.zig @@ -3,6 +3,6 @@ const expect = std.testing.expect; test "memory size and grow" { var prev = @wasmMemorySize(0); - expect(prev == @wasmMemoryGrow(0, 1)); - expect(prev + 1 == @wasmMemorySize(0)); + try expect(prev == @wasmMemoryGrow(0, 1)); + try expect(prev + 1 == @wasmMemorySize(0)); } diff --git a/test/stage1/behavior/while.zig b/test/stage1/behavior/while.zig index c9207396f7..a237b4b866 100644 --- a/test/stage1/behavior/while.zig +++ b/test/stage1/behavior/while.zig @@ -6,8 +6,8 @@ test "while loop" { while (i < 4) { i += 1; } - expect(i == 4); - expect(whileLoop1() == 1); + try expect(i == 4); + 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(); - expect(continue_and_break_counter == 8); + try runContinueAndBreakTest(); + 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); - expect(got_else == 1); + try expect(sum == 10); + 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); - expect(got_else == 1); + try expect(sum == 45); + 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); - expect(got_else == 1); + try expect(sum == 45); + 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 - @as(i32, 2); - expect(result == 2); + } else @as(i32, 2); + try expect(result == 2); } test "while on optional with else result follow break prong" { const result = while (returnOptional(10)) |value| { break value; - } else - @as(i32, 2); - expect(result == 10); + } else @as(i32, 2); + try expect(result == 10); } test "while on error union with else result follow else prong" { const result = while (returnError()) |value| { break value; - } else |err| - @as(i32, 2); - expect(result == 2); + } else |err| @as(i32, 2); + try expect(result == 2); } test "while on error union with else result follow break prong" { const result = while (returnSuccess(10)) |value| { break value; - } else |err| - @as(i32, 2); - expect(result == 10); + } else |err| @as(i32, 2); + try expect(result == 10); } test "while on bool with else result follow else prong" { const result = while (returnFalse()) { break @as(i32, 10); - } else - @as(i32, 2); - expect(result == 2); + } else @as(i32, 2); + try expect(result == 2); } test "while on bool with else result follow break prong" { const result = while (returnTrue()) { break @as(i32, 10); - } else - @as(i32, 2); - expect(result == 10); + } else @as(i32, 2); + try 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); - comptime S.entry(true, false); + try 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); - comptime S.entry(true, false); + try 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); - comptime S.entry(true, false); + try 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(); - comptime S.doTheTest(); + try S.doTheTest(); + comptime try S.doTheTest(); } diff --git a/test/stage1/behavior/widening.zig b/test/stage1/behavior/widening.zig index 2f215ccb11..b703291a88 100644 --- a/test/stage1/behavior/widening.zig +++ b/test/stage1/behavior/widening.zig @@ -9,13 +9,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" { @@ -23,9 +23,9 @@ test "float widening" { var b: f32 = a; var c: f64 = b; var d: f128 = c; - expect(a == b); - expect(b == c); - expect(c == d); + try expect(a == b); + try expect(b == c); + try expect(c == d); } test "float widening f16 to f128" { @@ -35,5 +35,5 @@ test "float widening f16 to f128" { var x: f16 = 12.34; var y: f128 = x; - expect(x == y); + try expect(x == y); } diff --git a/test/stage1/c_abi/main.zig b/test/stage1/c_abi/main.zig index 51fcc406ee..3be6d9c1cd 100644 --- a/test/stage1/c_abi/main.zig +++ b/test/stage1/c_abi/main.zig @@ -24,11 +24,11 @@ extern fn c_i64(i64) void; extern fn c_five_integers(i32, i32, i32, i32, i32) void; export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void { - expect(a == 12); - expect(b == 34); - expect(c == 56); - expect(d == 78); - expect(e == 90); + expect(a == 12) catch @panic("test failure"); + expect(b == 34) catch @panic("test failure"); + expect(c == 56) catch @panic("test failure"); + expect(d == 78) catch @panic("test failure"); + expect(e == 90) catch @panic("test failure"); } test "C ABI integers" { @@ -45,28 +45,28 @@ test "C ABI integers" { } export fn zig_u8(x: u8) void { - expect(x == 0xff); + expect(x == 0xff) catch @panic("test failure"); } export fn zig_u16(x: u16) void { - expect(x == 0xfffe); + expect(x == 0xfffe) catch @panic("test failure"); } export fn zig_u32(x: u32) void { - expect(x == 0xfffffffd); + expect(x == 0xfffffffd) catch @panic("test failure"); } export fn zig_u64(x: u64) void { - expect(x == 0xfffffffffffffffc); + expect(x == 0xfffffffffffffffc) catch @panic("test failure"); } export fn zig_i8(x: i8) void { - expect(x == -1); + expect(x == -1) catch @panic("test failure"); } export fn zig_i16(x: i16) void { - expect(x == -2); + expect(x == -2) catch @panic("test failure"); } export fn zig_i32(x: i32) void { - expect(x == -3); + expect(x == -3) catch @panic("test failure"); } export fn zig_i64(x: i64) void { - expect(x == -4); + expect(x == -4) catch @panic("test failure"); } extern fn c_f32(f32) void; @@ -76,11 +76,11 @@ extern fn c_f64(f64) void; extern fn c_five_floats(f32, f32, f32, f32, f32) void; export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void { - expect(a == 1.0); - expect(b == 2.0); - expect(c == 3.0); - expect(d == 4.0); - expect(e == 5.0); + expect(a == 1.0) catch @panic("test failure"); + expect(b == 2.0) catch @panic("test failure"); + expect(c == 3.0) catch @panic("test failure"); + expect(d == 4.0) catch @panic("test failure"); + expect(e == 5.0) catch @panic("test failure"); } test "C ABI floats" { @@ -90,10 +90,10 @@ test "C ABI floats" { } export fn zig_f32(x: f32) void { - expect(x == 12.34); + expect(x == 12.34) catch @panic("test failure"); } export fn zig_f64(x: f64) void { - expect(x == 56.78); + expect(x == 56.78) catch @panic("test failure"); } extern fn c_ptr(*c_void) void; @@ -103,7 +103,7 @@ test "C ABI pointer" { } export fn zig_ptr(x: *c_void) void { - expect(@ptrToInt(x) == 0xdeadbeef); + expect(@ptrToInt(x) == 0xdeadbeef) catch @panic("test failure"); } extern fn c_bool(bool) void; @@ -113,7 +113,7 @@ test "C ABI bool" { } export fn zig_bool(x: bool) void { - expect(x); + expect(x) catch @panic("test failure"); } const BigStruct = extern struct { @@ -137,11 +137,11 @@ test "C ABI big struct" { } export fn zig_big_struct(x: BigStruct) void { - expect(x.a == 1); - expect(x.b == 2); - expect(x.c == 3); - expect(x.d == 4); - expect(x.e == 5); + expect(x.a == 1) catch @panic("test failure"); + expect(x.b == 2) catch @panic("test failure"); + expect(x.c == 3) catch @panic("test failure"); + expect(x.d == 4) catch @panic("test failure"); + expect(x.e == 5) catch @panic("test failure"); } const BigUnion = extern union { @@ -163,11 +163,11 @@ test "C ABI big union" { } export fn zig_big_union(x: BigUnion) void { - expect(x.a.a == 1); - expect(x.a.b == 2); - expect(x.a.c == 3); - expect(x.a.d == 4); - expect(x.a.e == 5); + expect(x.a.a == 1) catch @panic("test failure"); + expect(x.a.b == 2) catch @panic("test failure"); + expect(x.a.c == 3) catch @panic("test failure"); + expect(x.a.d == 4) catch @panic("test failure"); + expect(x.a.e == 5) catch @panic("test failure"); } const SmallStructInts = extern struct { @@ -189,10 +189,10 @@ test "C ABI small struct of ints" { } export fn zig_small_struct_ints(x: SmallStructInts) void { - expect(x.a == 1); - expect(x.b == 2); - expect(x.c == 3); - expect(x.d == 4); + expect(x.a == 1) catch @panic("test failure"); + expect(x.b == 2) catch @panic("test failure"); + expect(x.c == 3) catch @panic("test failure"); + expect(x.d == 4) catch @panic("test failure"); } const SplitStructInt = extern struct { @@ -212,9 +212,9 @@ test "C ABI split struct of ints" { } export fn zig_split_struct_ints(x: SplitStructInt) void { - expect(x.a == 1234); - expect(x.b == 100); - expect(x.c == 1337); + expect(x.a == 1234) catch @panic("test failure"); + expect(x.b == 100) catch @panic("test failure"); + expect(x.c == 1337) catch @panic("test failure"); } extern fn c_big_struct_both(BigStruct) BigStruct; @@ -228,19 +228,19 @@ test "C ABI sret and byval together" { .e = 5, }; var y = c_big_struct_both(s); - expect(y.a == 10); - expect(y.b == 11); - expect(y.c == 12); - expect(y.d == 13); - expect(y.e == 14); + try expect(y.a == 10); + try expect(y.b == 11); + try expect(y.c == 12); + try expect(y.d == 13); + try expect(y.e == 14); } export fn zig_big_struct_both(x: BigStruct) BigStruct { - expect(x.a == 30); - expect(x.b == 31); - expect(x.c == 32); - expect(x.d == 33); - expect(x.e == 34); + expect(x.a == 30) catch @panic("test failure"); + expect(x.b == 31) catch @panic("test failure"); + expect(x.c == 32) catch @panic("test failure"); + expect(x.d == 33) catch @panic("test failure"); + expect(x.e == 34) catch @panic("test failure"); var s = BigStruct{ .a = 20, .b = 21, @@ -324,15 +324,15 @@ extern fn c_ret_i32() i32; extern fn c_ret_i64() i64; test "C ABI integer return types" { - expect(c_ret_bool() == true); + try expect(c_ret_bool() == true); - expect(c_ret_u8() == 0xff); - expect(c_ret_u16() == 0xffff); - expect(c_ret_u32() == 0xffffffff); - expect(c_ret_u64() == 0xffffffffffffffff); + try expect(c_ret_u8() == 0xff); + try expect(c_ret_u16() == 0xffff); + try expect(c_ret_u32() == 0xffffffff); + try expect(c_ret_u64() == 0xffffffffffffffff); - expect(c_ret_i8() == -1); - expect(c_ret_i16() == -1); - expect(c_ret_i32() == -1); - expect(c_ret_i64() == -1); + try expect(c_ret_i8() == -1); + try expect(c_ret_i16() == -1); + try expect(c_ret_i32() == -1); + try expect(c_ret_i64() == -1); } diff --git a/test/standalone/brace_expansion/main.zig b/test/standalone/brace_expansion/main.zig index 73c0e6fdae..990c2b1660 100644 --- a/test/standalone/brace_expansion/main.zig +++ b/test/standalone/brace_expansion/main.zig @@ -241,52 +241,52 @@ pub fn main() !void { test "invalid inputs" { global_allocator = std.testing.allocator; - expectError("}ABC", error.InvalidInput); - expectError("{ABC", error.InvalidInput); - expectError("}{", error.InvalidInput); - expectError("{}", error.InvalidInput); - expectError("A,B,C", error.InvalidInput); - expectError("{A{B,C}", error.InvalidInput); - expectError("{A,}", error.InvalidInput); + try expectError("}ABC", error.InvalidInput); + try expectError("{ABC", error.InvalidInput); + try expectError("}{", error.InvalidInput); + try expectError("{}", error.InvalidInput); + try expectError("A,B,C", error.InvalidInput); + try expectError("{A{B,C}", error.InvalidInput); + try expectError("{A,}", error.InvalidInput); - expectError("\n", error.InvalidInput); + try expectError("\n", error.InvalidInput); } -fn expectError(test_input: []const u8, expected_err: anyerror) void { +fn expectError(test_input: []const u8, expected_err: anyerror) !void { var output_buf = ArrayList(u8).init(global_allocator); defer output_buf.deinit(); - testing.expectError(expected_err, expandString(test_input, &output_buf)); + try testing.expectError(expected_err, expandString(test_input, &output_buf)); } test "valid inputs" { global_allocator = std.testing.allocator; - expectExpansion("{x,y,z}", "x y z"); - expectExpansion("{A,B}{x,y}", "Ax Ay Bx By"); - expectExpansion("{A,B{x,y}}", "A Bx By"); + try expectExpansion("{x,y,z}", "x y z"); + try expectExpansion("{A,B}{x,y}", "Ax Ay Bx By"); + try expectExpansion("{A,B{x,y}}", "A Bx By"); - expectExpansion("{ABC}", "ABC"); - expectExpansion("{A,B,C}", "A B C"); - expectExpansion("ABC", "ABC"); + try expectExpansion("{ABC}", "ABC"); + try expectExpansion("{A,B,C}", "A B C"); + try expectExpansion("ABC", "ABC"); - expectExpansion("", ""); - expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh"); - expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh"); - expectExpansion("{A,B}a", "Aa Ba"); - expectExpansion("{C,{x,y}}", "C x y"); - expectExpansion("z{C,{x,y}}", "zC zx zy"); - expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg"); - expectExpansion("a{x,y}b", "axb ayb"); - expectExpansion("z{{a,b}}", "za zb"); - expectExpansion("a{b}", "ab"); + try expectExpansion("", ""); + try expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh"); + try expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh"); + try expectExpansion("{A,B}a", "Aa Ba"); + try expectExpansion("{C,{x,y}}", "C x y"); + try expectExpansion("z{C,{x,y}}", "zC zx zy"); + try expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg"); + try expectExpansion("a{x,y}b", "axb ayb"); + try expectExpansion("z{{a,b}}", "za zb"); + try expectExpansion("a{b}", "ab"); } -fn expectExpansion(test_input: []const u8, expected_result: []const u8) void { +fn expectExpansion(test_input: []const u8, expected_result: []const u8) !void { var result = ArrayList(u8).init(global_allocator); defer result.deinit(); expandString(test_input, &result) catch unreachable; - testing.expectEqualSlices(u8, expected_result, result.items); + try testing.expectEqualSlices(u8, expected_result, result.items); } diff --git a/test/standalone/empty_env/main.zig b/test/standalone/empty_env/main.zig index f4ebf56136..e0c647bb2c 100644 --- a/test/standalone/empty_env/main.zig +++ b/test/standalone/empty_env/main.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn main() void { +pub fn main() !void { const env_map = std.process.getEnvMap(std.testing.allocator) catch @panic("unable to get env map"); - std.testing.expect(env_map.count() == 0); + try std.testing.expect(env_map.count() == 0); } diff --git a/test/standalone/global_linkage/main.zig b/test/standalone/global_linkage/main.zig index 53d953765b..cd2c1c31b2 100644 --- a/test/standalone/global_linkage/main.zig +++ b/test/standalone/global_linkage/main.zig @@ -4,6 +4,6 @@ extern var obj1_integer: usize; extern var obj2_integer: usize; test "access the external integers" { - std.testing.expect(obj1_integer == 421); - std.testing.expect(obj2_integer == 422); + try std.testing.expect(obj1_integer == 421); + try std.testing.expect(obj2_integer == 422); } diff --git a/test/standalone/issue_794/main.zig b/test/standalone/issue_794/main.zig index 191bdc9b4f..d8c4364bf0 100644 --- a/test/standalone/issue_794/main.zig +++ b/test/standalone/issue_794/main.zig @@ -3,5 +3,5 @@ const std = @import("std"); const testing = std.testing; test "c import" { - comptime testing.expect(c.NUMBER == 1234); + comptime try testing.expect(c.NUMBER == 1234); } diff --git a/test/standalone/link_interdependent_static_c_libs/main.zig b/test/standalone/link_interdependent_static_c_libs/main.zig index 1d8f854125..cb5d2e7b77 100644 --- a/test/standalone/link_interdependent_static_c_libs/main.zig +++ b/test/standalone/link_interdependent_static_c_libs/main.zig @@ -4,5 +4,5 @@ const c = @cImport(@cInclude("b.h")); test "import C sub" { const result = c.sub(2, 1); - expect(result == 1); + try expect(result == 1); } diff --git a/test/standalone/static_c_lib/foo.zig b/test/standalone/static_c_lib/foo.zig index a5ba90c95d..da02875408 100644 --- a/test/standalone/static_c_lib/foo.zig +++ b/test/standalone/static_c_lib/foo.zig @@ -4,9 +4,9 @@ const c = @cImport(@cInclude("foo.h")); test "C add" { const result = c.add(1, 2); - expect(result == 3); + try expect(result == 3); } test "C extern variable" { - expect(c.foo == 12345); + try expect(c.foo == 12345); } diff --git a/test/standalone/use_alias/main.zig b/test/standalone/use_alias/main.zig index 75a8b5e81a..be9d6da6c3 100644 --- a/test/standalone/use_alias/main.zig +++ b/test/standalone/use_alias/main.zig @@ -6,5 +6,5 @@ test "symbol exists" { .a = 1, .b = 1, }; - expect(foo.a + foo.b == 2); + try expect(foo.a + foo.b == 2); } From 42a95197f32b46ee7b504282ab345209cb43c247 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Wed, 5 May 2021 21:29:16 +0300 Subject: [PATCH 4/8] update usage of std.testing in stage2 --- src/Cache.zig | 36 +++++++++--------- src/Compilation.zig | 16 ++++---- src/DepTokenizer.zig | 4 +- src/codegen/aarch64.zig | 64 ++++++++++++++++---------------- src/codegen/arm.zig | 24 ++++++------ src/codegen/riscv64.zig | 2 +- src/codegen/wasm.zig | 10 ++--- src/link/MachO/CodeSignature.zig | 2 +- src/link/MachO/Trie.zig | 52 +++++++++++++------------- src/link/MachO/commands.zig | 4 +- src/register_manager.zig | 48 ++++++++++++------------ src/test.zig | 6 +-- src/value.zig | 6 +-- 13 files changed, 137 insertions(+), 137 deletions(-) diff --git a/src/Cache.zig b/src/Cache.zig index f2fdafff9b..5bc32b4b68 100644 --- a/src/Cache.zig +++ b/src/Cache.zig @@ -727,7 +727,7 @@ test "cache file and then recall it" { _ = try ch.addFile(temp_file, null); // There should be nothing in the cache - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); digest1 = ch.final(); try ch.writeManifest(); @@ -742,13 +742,13 @@ test "cache file and then recall it" { _ = try ch.addFile(temp_file, null); // Cache hit! We just "built" the same file - testing.expect(try ch.hit()); + try testing.expect(try ch.hit()); digest2 = ch.final(); try ch.writeManifest(); } - testing.expectEqual(digest1, digest2); + try testing.expectEqual(digest1, digest2); } try cwd.deleteTree(temp_manifest_dir); @@ -760,11 +760,11 @@ test "give problematic timestamp" { // to make it problematic, we make it only accurate to the second fs_clock = @divTrunc(fs_clock, std.time.ns_per_s); fs_clock *= std.time.ns_per_s; - testing.expect(isProblematicTimestamp(fs_clock)); + try testing.expect(isProblematicTimestamp(fs_clock)); } test "give nonproblematic timestamp" { - testing.expect(!isProblematicTimestamp(std.time.nanoTimestamp() - std.time.ns_per_s)); + try testing.expect(!isProblematicTimestamp(std.time.nanoTimestamp() - std.time.ns_per_s)); } test "check that changing a file makes cache fail" { @@ -807,9 +807,9 @@ test "check that changing a file makes cache fail" { const temp_file_idx = try ch.addFile(temp_file, 100); // There should be nothing in the cache - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); - testing.expect(mem.eql(u8, original_temp_file_contents, ch.files.items[temp_file_idx].contents.?)); + try testing.expect(mem.eql(u8, original_temp_file_contents, ch.files.items[temp_file_idx].contents.?)); digest1 = ch.final(); @@ -826,17 +826,17 @@ test "check that changing a file makes cache fail" { const temp_file_idx = try ch.addFile(temp_file, 100); // A file that we depend on has been updated, so the cache should not contain an entry for it - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); // The cache system does not keep the contents of re-hashed input files. - testing.expect(ch.files.items[temp_file_idx].contents == null); + try testing.expect(ch.files.items[temp_file_idx].contents == null); digest2 = ch.final(); try ch.writeManifest(); } - testing.expect(!mem.eql(u8, digest1[0..], digest2[0..])); + try testing.expect(!mem.eql(u8, digest1[0..], digest2[0..])); } try cwd.deleteTree(temp_manifest_dir); @@ -868,7 +868,7 @@ test "no file inputs" { ch.hash.addBytes("1234"); // There should be nothing in the cache - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); digest1 = ch.final(); @@ -880,12 +880,12 @@ test "no file inputs" { ch.hash.addBytes("1234"); - testing.expect(try ch.hit()); + try testing.expect(try ch.hit()); digest2 = ch.final(); try ch.writeManifest(); } - testing.expectEqual(digest1, digest2); + try testing.expectEqual(digest1, digest2); } test "Manifest with files added after initial hash work" { @@ -926,7 +926,7 @@ test "Manifest with files added after initial hash work" { _ = try ch.addFile(temp_file1, null); // There should be nothing in the cache - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); _ = try ch.addFilePost(temp_file2); @@ -940,12 +940,12 @@ test "Manifest with files added after initial hash work" { ch.hash.addBytes("1234"); _ = try ch.addFile(temp_file1, null); - testing.expect(try ch.hit()); + try testing.expect(try ch.hit()); digest2 = ch.final(); try ch.writeManifest(); } - testing.expect(mem.eql(u8, &digest1, &digest2)); + try testing.expect(mem.eql(u8, &digest1, &digest2)); // Modify the file added after initial hash const ts2 = std.time.nanoTimestamp(); @@ -963,7 +963,7 @@ test "Manifest with files added after initial hash work" { _ = try ch.addFile(temp_file1, null); // A file that we depend on has been updated, so the cache should not contain an entry for it - testing.expectEqual(false, try ch.hit()); + try testing.expectEqual(false, try ch.hit()); _ = try ch.addFilePost(temp_file2); @@ -972,7 +972,7 @@ test "Manifest with files added after initial hash work" { try ch.writeManifest(); } - testing.expect(!mem.eql(u8, &digest1, &digest3)); + try testing.expect(!mem.eql(u8, &digest1, &digest3)); } try cwd.deleteTree(temp_manifest_dir); diff --git a/src/Compilation.zig b/src/Compilation.zig index 58d6f41858..c779398b31 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -2852,14 +2852,14 @@ pub fn classifyFileExt(filename: []const u8) FileExt { } test "classifyFileExt" { - std.testing.expectEqual(FileExt.cpp, classifyFileExt("foo.cc")); - std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.nim")); - std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so")); - std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1")); - std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2")); - std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2.3")); - std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.so.1.2.3~")); - std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig")); + try std.testing.expectEqual(FileExt.cpp, classifyFileExt("foo.cc")); + try std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.nim")); + try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so")); + try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1")); + try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2")); + try std.testing.expectEqual(FileExt.shared_library, classifyFileExt("foo.so.1.2.3")); + try std.testing.expectEqual(FileExt.unknown, classifyFileExt("foo.so.1.2.3~")); + try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig")); } fn haveFramePointer(comp: *const Compilation) bool { diff --git a/src/DepTokenizer.zig b/src/DepTokenizer.zig index 0bd2999719..c8417f2df1 100644 --- a/src/DepTokenizer.zig +++ b/src/DepTokenizer.zig @@ -918,7 +918,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void { } if (std.mem.eql(u8, expect, buffer.items)) { - testing.expect(true); + try testing.expect(true); return; } @@ -930,7 +930,7 @@ fn depTokenizer(input: []const u8, expect: []const u8) !void { try printSection(out, ">>>> got", buffer.items); try printRuler(out); - testing.expect(false); + try testing.expect(false); } fn printSection(out: anytype, label: []const u8, bytes: []const u8) !void { diff --git a/src/codegen/aarch64.zig b/src/codegen/aarch64.zig index b456465075..1c176df017 100644 --- a/src/codegen/aarch64.zig +++ b/src/codegen/aarch64.zig @@ -67,27 +67,27 @@ pub const c_abi_int_param_regs = [_]Register{ .x0, .x1, .x2, .x3, .x4, .x5, .x6, pub const c_abi_int_return_regs = [_]Register{ .x0, .x1, .x2, .x3, .x4, .x5, .x6, .x7 }; test "Register.id" { - testing.expectEqual(@as(u5, 0), Register.x0.id()); - testing.expectEqual(@as(u5, 0), Register.w0.id()); + try testing.expectEqual(@as(u5, 0), Register.x0.id()); + try testing.expectEqual(@as(u5, 0), Register.w0.id()); - testing.expectEqual(@as(u5, 31), Register.xzr.id()); - testing.expectEqual(@as(u5, 31), Register.wzr.id()); + try testing.expectEqual(@as(u5, 31), Register.xzr.id()); + try testing.expectEqual(@as(u5, 31), Register.wzr.id()); - testing.expectEqual(@as(u5, 31), Register.sp.id()); - testing.expectEqual(@as(u5, 31), Register.sp.id()); + try testing.expectEqual(@as(u5, 31), Register.sp.id()); + try testing.expectEqual(@as(u5, 31), Register.sp.id()); } test "Register.size" { - testing.expectEqual(@as(u7, 64), Register.x19.size()); - testing.expectEqual(@as(u7, 32), Register.w3.size()); + try testing.expectEqual(@as(u7, 64), Register.x19.size()); + try testing.expectEqual(@as(u7, 32), Register.w3.size()); } test "Register.to64/to32" { - testing.expectEqual(Register.x0, Register.w0.to64()); - testing.expectEqual(Register.x0, Register.x0.to64()); + try testing.expectEqual(Register.x0, Register.w0.to64()); + try testing.expectEqual(Register.x0, Register.x0.to64()); - testing.expectEqual(Register.w3, Register.w3.to32()); - testing.expectEqual(Register.w3, Register.x3.to32()); + try testing.expectEqual(Register.w3, Register.w3.to32()); + try testing.expectEqual(Register.w3, Register.x3.to32()); } // zig fmt: off @@ -169,33 +169,33 @@ pub const FloatingPointRegister = enum(u8) { // zig fmt: on test "FloatingPointRegister.id" { - testing.expectEqual(@as(u5, 0), FloatingPointRegister.b0.id()); - testing.expectEqual(@as(u5, 0), FloatingPointRegister.h0.id()); - testing.expectEqual(@as(u5, 0), FloatingPointRegister.s0.id()); - testing.expectEqual(@as(u5, 0), FloatingPointRegister.d0.id()); - testing.expectEqual(@as(u5, 0), FloatingPointRegister.q0.id()); + try testing.expectEqual(@as(u5, 0), FloatingPointRegister.b0.id()); + try testing.expectEqual(@as(u5, 0), FloatingPointRegister.h0.id()); + try testing.expectEqual(@as(u5, 0), FloatingPointRegister.s0.id()); + try testing.expectEqual(@as(u5, 0), FloatingPointRegister.d0.id()); + try testing.expectEqual(@as(u5, 0), FloatingPointRegister.q0.id()); - testing.expectEqual(@as(u5, 2), FloatingPointRegister.q2.id()); - testing.expectEqual(@as(u5, 31), FloatingPointRegister.d31.id()); + try testing.expectEqual(@as(u5, 2), FloatingPointRegister.q2.id()); + try testing.expectEqual(@as(u5, 31), FloatingPointRegister.d31.id()); } test "FloatingPointRegister.size" { - testing.expectEqual(@as(u8, 128), FloatingPointRegister.q1.size()); - testing.expectEqual(@as(u8, 64), FloatingPointRegister.d2.size()); - testing.expectEqual(@as(u8, 32), FloatingPointRegister.s3.size()); - testing.expectEqual(@as(u8, 16), FloatingPointRegister.h4.size()); - testing.expectEqual(@as(u8, 8), FloatingPointRegister.b5.size()); + try testing.expectEqual(@as(u8, 128), FloatingPointRegister.q1.size()); + try testing.expectEqual(@as(u8, 64), FloatingPointRegister.d2.size()); + try testing.expectEqual(@as(u8, 32), FloatingPointRegister.s3.size()); + try testing.expectEqual(@as(u8, 16), FloatingPointRegister.h4.size()); + try testing.expectEqual(@as(u8, 8), FloatingPointRegister.b5.size()); } test "FloatingPointRegister.toX" { - testing.expectEqual(FloatingPointRegister.q1, FloatingPointRegister.q1.to128()); - testing.expectEqual(FloatingPointRegister.q2, FloatingPointRegister.b2.to128()); - testing.expectEqual(FloatingPointRegister.q3, FloatingPointRegister.h3.to128()); + try testing.expectEqual(FloatingPointRegister.q1, FloatingPointRegister.q1.to128()); + try testing.expectEqual(FloatingPointRegister.q2, FloatingPointRegister.b2.to128()); + try testing.expectEqual(FloatingPointRegister.q3, FloatingPointRegister.h3.to128()); - testing.expectEqual(FloatingPointRegister.d0, FloatingPointRegister.q0.to64()); - testing.expectEqual(FloatingPointRegister.s1, FloatingPointRegister.d1.to32()); - testing.expectEqual(FloatingPointRegister.h2, FloatingPointRegister.s2.to16()); - testing.expectEqual(FloatingPointRegister.b3, FloatingPointRegister.h3.to8()); + try testing.expectEqual(FloatingPointRegister.d0, FloatingPointRegister.q0.to64()); + try testing.expectEqual(FloatingPointRegister.s1, FloatingPointRegister.d1.to32()); + try testing.expectEqual(FloatingPointRegister.h2, FloatingPointRegister.s2.to16()); + try testing.expectEqual(FloatingPointRegister.b3, FloatingPointRegister.h3.to8()); } /// Represents an instruction in the AArch64 instruction set @@ -1225,6 +1225,6 @@ test "serialize instructions" { for (testcases) |case| { const actual = case.inst.toU32(); - testing.expectEqual(case.expected, actual); + try testing.expectEqual(case.expected, actual); } } diff --git a/src/codegen/arm.zig b/src/codegen/arm.zig index d538d28c50..cc6abe2e52 100644 --- a/src/codegen/arm.zig +++ b/src/codegen/arm.zig @@ -88,19 +88,19 @@ pub const Condition = enum(u4) { }; test "condition from CompareOperator" { - testing.expectEqual(@as(Condition, .eq), Condition.fromCompareOperatorSigned(.eq)); - testing.expectEqual(@as(Condition, .eq), Condition.fromCompareOperatorUnsigned(.eq)); + try testing.expectEqual(@as(Condition, .eq), Condition.fromCompareOperatorSigned(.eq)); + try testing.expectEqual(@as(Condition, .eq), Condition.fromCompareOperatorUnsigned(.eq)); - testing.expectEqual(@as(Condition, .gt), Condition.fromCompareOperatorSigned(.gt)); - testing.expectEqual(@as(Condition, .hi), Condition.fromCompareOperatorUnsigned(.gt)); + try testing.expectEqual(@as(Condition, .gt), Condition.fromCompareOperatorSigned(.gt)); + try testing.expectEqual(@as(Condition, .hi), Condition.fromCompareOperatorUnsigned(.gt)); - testing.expectEqual(@as(Condition, .le), Condition.fromCompareOperatorSigned(.lte)); - testing.expectEqual(@as(Condition, .ls), Condition.fromCompareOperatorUnsigned(.lte)); + try testing.expectEqual(@as(Condition, .le), Condition.fromCompareOperatorSigned(.lte)); + try testing.expectEqual(@as(Condition, .ls), Condition.fromCompareOperatorUnsigned(.lte)); } test "negate condition" { - testing.expectEqual(@as(Condition, .eq), Condition.ne.negate()); - testing.expectEqual(@as(Condition, .ne), Condition.eq.negate()); + try testing.expectEqual(@as(Condition, .eq), Condition.ne.negate()); + try testing.expectEqual(@as(Condition, .ne), Condition.eq.negate()); } /// Represents a register in the ARM instruction set architecture @@ -175,8 +175,8 @@ pub const Register = enum(u5) { }; test "Register.id" { - testing.expectEqual(@as(u4, 15), Register.r15.id()); - testing.expectEqual(@as(u4, 15), Register.pc.id()); + try testing.expectEqual(@as(u4, 15), Register.r15.id()); + try testing.expectEqual(@as(u4, 15), Register.pc.id()); } /// Program status registers containing flags, mode bits and other @@ -1225,7 +1225,7 @@ test "serialize instructions" { for (testcases) |case| { const actual = case.inst.toU32(); - testing.expectEqual(case.expected, actual); + try testing.expectEqual(case.expected, actual); } } @@ -1265,6 +1265,6 @@ test "aliases" { }; for (testcases) |case| { - testing.expectEqual(case.expected.toU32(), case.actual.toU32()); + try testing.expectEqual(case.expected.toU32(), case.actual.toU32()); } } diff --git a/src/codegen/riscv64.zig b/src/codegen/riscv64.zig index a01f38289a..831f74b1b7 100644 --- a/src/codegen/riscv64.zig +++ b/src/codegen/riscv64.zig @@ -465,6 +465,6 @@ test "serialize instructions" { for (testcases) |case| { const actual = case.inst.toU32(); - testing.expectEqual(case.expected, actual); + try testing.expectEqual(case.expected, actual); } } diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig index 400a5cd1a3..759afa1047 100644 --- a/src/codegen/wasm.zig +++ b/src/codegen/wasm.zig @@ -463,11 +463,11 @@ test "Wasm - buildOpcode" { const i64_extend32_s = buildOpcode(.{ .op = .extend, .valtype1 = .i64, .width = 32, .signedness = .signed }); const f64_reinterpret_i64 = buildOpcode(.{ .op = .reinterpret, .valtype1 = .f64, .valtype2 = .i64 }); - testing.expectEqual(@as(wasm.Opcode, .i32_const), i32_const); - testing.expectEqual(@as(wasm.Opcode, .end), end); - testing.expectEqual(@as(wasm.Opcode, .local_get), local_get); - testing.expectEqual(@as(wasm.Opcode, .i64_extend32_s), i64_extend32_s); - testing.expectEqual(@as(wasm.Opcode, .f64_reinterpret_i64), f64_reinterpret_i64); + try testing.expectEqual(@as(wasm.Opcode, .i32_const), i32_const); + try testing.expectEqual(@as(wasm.Opcode, .end), end); + try testing.expectEqual(@as(wasm.Opcode, .local_get), local_get); + try testing.expectEqual(@as(wasm.Opcode, .i64_extend32_s), i64_extend32_s); + try testing.expectEqual(@as(wasm.Opcode, .f64_reinterpret_i64), f64_reinterpret_i64); } pub const Result = union(enum) { diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig index ef0fc6c3e2..d0dd47be92 100644 --- a/src/link/MachO/CodeSignature.zig +++ b/src/link/MachO/CodeSignature.zig @@ -182,7 +182,7 @@ test "CodeSignature header" { try code_sig.writeHeader(stream.writer()); const expected = &[_]u8{ 0xfa, 0xde, 0x0c, 0xc0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0 }; - testing.expect(mem.eql(u8, expected, &buffer)); + try testing.expect(mem.eql(u8, expected, &buffer)); } pub fn calcCodeSignaturePaddingSize(id: []const u8, file_size: u64, page_size: u16) u32 { diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig index f7d54cf578..379b10e2d8 100644 --- a/src/link/MachO/Trie.zig +++ b/src/link/MachO/Trie.zig @@ -404,15 +404,15 @@ test "Trie node count" { var trie = Trie.init(gpa); defer trie.deinit(); - testing.expectEqual(trie.node_count, 0); - testing.expect(trie.root == null); + try testing.expectEqual(trie.node_count, 0); + try testing.expect(trie.root == null); try trie.put(.{ .name = "_main", .vmaddr_offset = 0, .export_flags = 0, }); - testing.expectEqual(trie.node_count, 2); + try testing.expectEqual(trie.node_count, 2); // Inserting the same node shouldn't update the trie. try trie.put(.{ @@ -420,14 +420,14 @@ test "Trie node count" { .vmaddr_offset = 0, .export_flags = 0, }); - testing.expectEqual(trie.node_count, 2); + try testing.expectEqual(trie.node_count, 2); try trie.put(.{ .name = "__mh_execute_header", .vmaddr_offset = 0x1000, .export_flags = 0, }); - testing.expectEqual(trie.node_count, 4); + try testing.expectEqual(trie.node_count, 4); // Inserting the same node shouldn't update the trie. try trie.put(.{ @@ -435,13 +435,13 @@ test "Trie node count" { .vmaddr_offset = 0x1000, .export_flags = 0, }); - testing.expectEqual(trie.node_count, 4); + try testing.expectEqual(trie.node_count, 4); try trie.put(.{ .name = "_main", .vmaddr_offset = 0, .export_flags = 0, }); - testing.expectEqual(trie.node_count, 4); + try testing.expectEqual(trie.node_count, 4); } test "Trie basic" { @@ -455,8 +455,8 @@ test "Trie basic" { .vmaddr_offset = 0, .export_flags = 0, }); - testing.expect(trie.root.?.edges.items.len == 1); - testing.expect(mem.eql(u8, trie.root.?.edges.items[0].label, "_st")); + try testing.expect(trie.root.?.edges.items.len == 1); + try testing.expect(mem.eql(u8, trie.root.?.edges.items[0].label, "_st")); { // root --- _st ---> node --- art ---> node @@ -465,12 +465,12 @@ test "Trie basic" { .vmaddr_offset = 0, .export_flags = 0, }); - testing.expect(trie.root.?.edges.items.len == 1); + try testing.expect(trie.root.?.edges.items.len == 1); const nextEdge = &trie.root.?.edges.items[0]; - testing.expect(mem.eql(u8, nextEdge.label, "_st")); - testing.expect(nextEdge.to.edges.items.len == 1); - testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "art")); + try testing.expect(mem.eql(u8, nextEdge.label, "_st")); + try testing.expect(nextEdge.to.edges.items.len == 1); + try testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "art")); } { // root --- _ ---> node --- st ---> node --- art ---> node @@ -481,16 +481,16 @@ test "Trie basic" { .vmaddr_offset = 0, .export_flags = 0, }); - testing.expect(trie.root.?.edges.items.len == 1); + try testing.expect(trie.root.?.edges.items.len == 1); const nextEdge = &trie.root.?.edges.items[0]; - testing.expect(mem.eql(u8, nextEdge.label, "_")); - testing.expect(nextEdge.to.edges.items.len == 2); - testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "st")); - testing.expect(mem.eql(u8, nextEdge.to.edges.items[1].label, "main")); + try testing.expect(mem.eql(u8, nextEdge.label, "_")); + try testing.expect(nextEdge.to.edges.items.len == 2); + try testing.expect(mem.eql(u8, nextEdge.to.edges.items[0].label, "st")); + try testing.expect(mem.eql(u8, nextEdge.to.edges.items[1].label, "main")); const nextNextEdge = &nextEdge.to.edges.items[0]; - testing.expect(mem.eql(u8, nextNextEdge.to.edges.items[0].label, "art")); + try testing.expect(mem.eql(u8, nextNextEdge.to.edges.items[0].label, "art")); } } @@ -529,15 +529,15 @@ test "write Trie to a byte stream" { var stream = std.io.fixedBufferStream(buffer); { const nwritten = try trie.write(stream.writer()); - testing.expect(nwritten == trie.size); - testing.expect(mem.eql(u8, buffer, &exp_buffer)); + try testing.expect(nwritten == trie.size); + try testing.expect(mem.eql(u8, buffer, &exp_buffer)); } { // Writing finalized trie again should yield the same result. try stream.seekTo(0); const nwritten = try trie.write(stream.writer()); - testing.expect(nwritten == trie.size); - testing.expect(mem.eql(u8, buffer, &exp_buffer)); + try testing.expect(nwritten == trie.size); + try testing.expect(mem.eql(u8, buffer, &exp_buffer)); } } @@ -560,7 +560,7 @@ test "parse Trie from byte stream" { defer trie.deinit(); const nread = try trie.read(in_stream.reader()); - testing.expect(nread == in_buffer.len); + try testing.expect(nread == in_buffer.len); try trie.finalize(); @@ -569,6 +569,6 @@ test "parse Trie from byte stream" { var out_stream = std.io.fixedBufferStream(out_buffer); const nwritten = try trie.write(out_stream.writer()); - testing.expect(nwritten == trie.size); - testing.expect(mem.eql(u8, &in_buffer, out_buffer)); + try testing.expect(nwritten == trie.size); + try testing.expect(mem.eql(u8, &in_buffer, out_buffer)); } diff --git a/src/link/MachO/commands.zig b/src/link/MachO/commands.zig index 67b808d856..f81e5c757d 100644 --- a/src/link/MachO/commands.zig +++ b/src/link/MachO/commands.zig @@ -286,13 +286,13 @@ fn testRead(allocator: *Allocator, buffer: []const u8, expected: anytype) !void var stream = io.fixedBufferStream(buffer); var given = try LoadCommand.read(allocator, stream.reader()); defer given.deinit(allocator); - testing.expect(expected.eql(given)); + try testing.expect(expected.eql(given)); } fn testWrite(buffer: []u8, cmd: LoadCommand, expected: []const u8) !void { var stream = io.fixedBufferStream(buffer); try cmd.write(stream.writer()); - testing.expect(mem.eql(u8, expected, buffer[0..expected.len])); + try testing.expect(mem.eql(u8, expected, buffer[0..expected.len])); } test "read-write segment command" { diff --git a/src/register_manager.zig b/src/register_manager.zig index 270c762887..2c812cef89 100644 --- a/src/register_manager.zig +++ b/src/register_manager.zig @@ -267,21 +267,21 @@ test "tryAllocReg: no spilling" { .src = .unneeded, }; - std.testing.expect(!function.register_manager.isRegAllocated(.r2)); - std.testing.expect(!function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r3)); - std.testing.expectEqual(@as(?MockRegister, .r2), function.register_manager.tryAllocReg(&mock_instruction)); - std.testing.expectEqual(@as(?MockRegister, .r3), function.register_manager.tryAllocReg(&mock_instruction)); - std.testing.expectEqual(@as(?MockRegister, null), function.register_manager.tryAllocReg(&mock_instruction)); + try std.testing.expectEqual(@as(?MockRegister, .r2), function.register_manager.tryAllocReg(&mock_instruction)); + try std.testing.expectEqual(@as(?MockRegister, .r3), function.register_manager.tryAllocReg(&mock_instruction)); + try std.testing.expectEqual(@as(?MockRegister, null), function.register_manager.tryAllocReg(&mock_instruction)); - std.testing.expect(function.register_manager.isRegAllocated(.r2)); - std.testing.expect(function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(function.register_manager.isRegAllocated(.r3)); function.register_manager.freeReg(.r2); function.register_manager.freeReg(.r3); - std.testing.expect(function.register_manager.isRegAllocated(.r2)); - std.testing.expect(function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(function.register_manager.isRegAllocated(.r3)); } test "allocReg: spilling" { @@ -298,20 +298,20 @@ test "allocReg: spilling" { .src = .unneeded, }; - std.testing.expect(!function.register_manager.isRegAllocated(.r2)); - std.testing.expect(!function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r3)); - std.testing.expectEqual(@as(?MockRegister, .r2), try function.register_manager.allocReg(&mock_instruction)); - std.testing.expectEqual(@as(?MockRegister, .r3), try function.register_manager.allocReg(&mock_instruction)); + try std.testing.expectEqual(@as(?MockRegister, .r2), try function.register_manager.allocReg(&mock_instruction)); + try std.testing.expectEqual(@as(?MockRegister, .r3), try function.register_manager.allocReg(&mock_instruction)); // Spill a register - std.testing.expectEqual(@as(?MockRegister, .r2), try function.register_manager.allocReg(&mock_instruction)); - std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r2}, function.spilled.items); + try std.testing.expectEqual(@as(?MockRegister, .r2), try function.register_manager.allocReg(&mock_instruction)); + try std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r2}, function.spilled.items); // No spilling necessary function.register_manager.freeReg(.r3); - std.testing.expectEqual(@as(?MockRegister, .r3), try function.register_manager.allocReg(&mock_instruction)); - std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r2}, function.spilled.items); + try std.testing.expectEqual(@as(?MockRegister, .r3), try function.register_manager.allocReg(&mock_instruction)); + try std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r2}, function.spilled.items); } test "getReg" { @@ -328,18 +328,18 @@ test "getReg" { .src = .unneeded, }; - std.testing.expect(!function.register_manager.isRegAllocated(.r2)); - std.testing.expect(!function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r3)); try function.register_manager.getReg(.r3, &mock_instruction); - std.testing.expect(!function.register_manager.isRegAllocated(.r2)); - std.testing.expect(function.register_manager.isRegAllocated(.r3)); + try std.testing.expect(!function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(function.register_manager.isRegAllocated(.r3)); // Spill r3 try function.register_manager.getReg(.r3, &mock_instruction); - std.testing.expect(!function.register_manager.isRegAllocated(.r2)); - std.testing.expect(function.register_manager.isRegAllocated(.r3)); - std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r3}, function.spilled.items); + try std.testing.expect(!function.register_manager.isRegAllocated(.r2)); + try std.testing.expect(function.register_manager.isRegAllocated(.r3)); + try std.testing.expectEqualSlices(MockRegister, &[_]MockRegister{.r3}, function.spilled.items); } diff --git a/src/test.zig b/src/test.zig index ca3f073e14..f1cf543252 100644 --- a/src/test.zig +++ b/src/test.zig @@ -705,14 +705,14 @@ pub const TestContext = struct { defer file.close(); const out = try file.reader().readAllAlloc(arena, 5 * 1024 * 1024); - std.testing.expectEqualStrings(expected_output, out); + try std.testing.expectEqualStrings(expected_output, out); }, .CompareObjectFile => |expected_output| { var file = try tmp.dir.openFile(bin_name, .{ .read = true }); defer file.close(); const out = try file.reader().readAllAlloc(arena, 5 * 1024 * 1024); - std.testing.expectEqualStrings(expected_output, out); + try std.testing.expectEqualStrings(expected_output, out); }, .Error => |case_error_list| { var test_node = update_node.start("assert", 0); @@ -939,7 +939,7 @@ pub const TestContext = struct { return error.ZigTestFailed; }, } - std.testing.expectEqualStrings(expected_stdout, exec_result.stdout); + try std.testing.expectEqualStrings(expected_stdout, exec_result.stdout); // We allow stderr to have garbage in it because wasmtime prints a // warning about --invoke even though we don't pass it. //std.testing.expectEqualStrings("", exec_result.stderr); diff --git a/src/value.zig b/src/value.zig index 66a23692c1..6501e788c3 100644 --- a/src/value.zig +++ b/src/value.zig @@ -1456,19 +1456,19 @@ test "hash same value different representation" { .data = 0, }; const zero_2 = Value.initPayload(&payload_1.base); - std.testing.expectEqual(zero_1.hash(), zero_2.hash()); + try std.testing.expectEqual(zero_1.hash(), zero_2.hash()); var payload_2 = Value.Payload.I64{ .base = .{ .tag = .int_i64 }, .data = 0, }; const zero_3 = Value.initPayload(&payload_2.base); - std.testing.expectEqual(zero_2.hash(), zero_3.hash()); + try std.testing.expectEqual(zero_2.hash(), zero_3.hash()); var payload_3 = Value.Payload.BigInt{ .base = .{ .tag = .int_big_negative }, .data = &[_]std.math.big.Limb{0}, }; const zero_4 = Value.initPayload(&payload_3.base); - std.testing.expectEqual(zero_3.hash(), zero_4.hash()); + try std.testing.expectEqual(zero_3.hash(), zero_4.hash()); } From 7fe39c4e9680870f0bf30368c9f5b345b262b0eb Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Thu, 6 May 2021 09:32:29 +0300 Subject: [PATCH 5/8] update usage of std.testing in compiler_rt --- lib/std/special/c.zig | 40 +- lib/std/special/compiler_rt/addXf3_test.zig | 26 +- lib/std/special/compiler_rt/ashldi3_test.zig | 40 +- lib/std/special/compiler_rt/ashlti3_test.zig | 76 +-- lib/std/special/compiler_rt/ashrdi3_test.zig | 76 +-- lib/std/special/compiler_rt/ashrti3_test.zig | 76 +-- lib/std/special/compiler_rt/clzsi2_test.zig | 562 +++++++++--------- lib/std/special/compiler_rt/divdf3_test.zig | 6 +- lib/std/special/compiler_rt/divsf3_test.zig | 6 +- lib/std/special/compiler_rt/divtf3_test.zig | 20 +- lib/std/special/compiler_rt/divti3_test.zig | 22 +- .../special/compiler_rt/extendXfYf2_test.zig | 110 ++-- lib/std/special/compiler_rt/fixdfdi_test.zig | 82 +-- lib/std/special/compiler_rt/fixdfsi_test.zig | 94 +-- lib/std/special/compiler_rt/fixdfti_test.zig | 82 +-- lib/std/special/compiler_rt/fixint_test.zig | 244 ++++---- lib/std/special/compiler_rt/fixsfdi_test.zig | 86 +-- lib/std/special/compiler_rt/fixsfsi_test.zig | 98 +-- lib/std/special/compiler_rt/fixsfti_test.zig | 114 ++-- lib/std/special/compiler_rt/fixtfdi_test.zig | 98 +-- lib/std/special/compiler_rt/fixtfsi_test.zig | 98 +-- lib/std/special/compiler_rt/fixtfti_test.zig | 82 +-- .../special/compiler_rt/fixunsdfdi_test.zig | 46 +- .../special/compiler_rt/fixunsdfsi_test.zig | 52 +- .../special/compiler_rt/fixunsdfti_test.zig | 62 +- .../special/compiler_rt/fixunssfdi_test.zig | 44 +- .../special/compiler_rt/fixunssfsi_test.zig | 46 +- .../special/compiler_rt/fixunssfti_test.zig | 56 +- .../special/compiler_rt/fixunstfdi_test.zig | 66 +- .../special/compiler_rt/fixunstfsi_test.zig | 20 +- .../special/compiler_rt/fixunstfti_test.zig | 34 +- .../special/compiler_rt/floatdidf_test.zig | 88 +-- .../special/compiler_rt/floatdisf_test.zig | 46 +- .../special/compiler_rt/floatditf_test.zig | 20 +- lib/std/special/compiler_rt/floatsiXf.zig | 38 +- .../special/compiler_rt/floattidf_test.zig | 118 ++-- .../special/compiler_rt/floattisf_test.zig | 68 +-- .../special/compiler_rt/floattitf_test.zig | 138 ++--- .../special/compiler_rt/floatundidf_test.zig | 82 +-- lib/std/special/compiler_rt/floatundisf.zig | 48 +- .../special/compiler_rt/floatunditf_test.zig | 18 +- lib/std/special/compiler_rt/floatunsidf.zig | 12 +- lib/std/special/compiler_rt/floatunsisf.zig | 12 +- .../special/compiler_rt/floatunsitf_test.zig | 10 +- .../special/compiler_rt/floatuntidf_test.zig | 112 ++-- .../special/compiler_rt/floatuntisf_test.zig | 86 +-- .../special/compiler_rt/floatuntitf_test.zig | 142 ++--- lib/std/special/compiler_rt/int.zig | 114 ++-- lib/std/special/compiler_rt/lshrdi3_test.zig | 76 +-- lib/std/special/compiler_rt/lshrti3_test.zig | 76 +-- lib/std/special/compiler_rt/modti3_test.zig | 38 +- lib/std/special/compiler_rt/mulXf3_test.zig | 18 +- lib/std/special/compiler_rt/muldi3_test.zig | 72 +-- lib/std/special/compiler_rt/mulodi4_test.zig | 132 ++-- lib/std/special/compiler_rt/muloti4_test.zig | 114 ++-- lib/std/special/compiler_rt/multi3_test.zig | 74 +-- .../special/compiler_rt/popcountdi2_test.zig | 14 +- .../special/compiler_rt/truncXfYf2_test.zig | 72 +-- .../special/compiler_rt/udivmoddi4_test.zig | 4 +- .../special/compiler_rt/udivmodti4_test.zig | 4 +- 60 files changed, 2205 insertions(+), 2205 deletions(-) diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig index 49d679210b..db0e107def 100644 --- a/lib/std/special/c.zig +++ b/lib/std/special/c.zig @@ -66,7 +66,7 @@ test "strcpy" { s1[0] = 0; _ = strcpy(&s1, "foobarbaz"); - std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); + try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); } fn strncpy(dest: [*:0]u8, src: [*:0]const u8, n: usize) callconv(.C) [*:0]u8 { @@ -86,7 +86,7 @@ test "strncpy" { s1[0] = 0; _ = strncpy(&s1, "foobarbaz", @sizeOf(@TypeOf(s1))); - std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); + try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); } fn strcat(dest: [*:0]u8, src: [*:0]const u8) callconv(.C) [*:0]u8 { @@ -109,7 +109,7 @@ test "strcat" { _ = strcat(&s1, "foo"); _ = strcat(&s1, "bar"); _ = strcat(&s1, "baz"); - std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); + try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); } fn strncat(dest: [*:0]u8, src: [*:0]const u8, avail: usize) callconv(.C) [*:0]u8 { @@ -132,7 +132,7 @@ test "strncat" { _ = strncat(&s1, "foo1111", 3); _ = strncat(&s1, "bar1111", 3); _ = strncat(&s1, "baz1111", 3); - std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); + try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1)); } fn strcmp(s1: [*:0]const u8, s2: [*:0]const u8) callconv(.C) c_int { @@ -871,13 +871,13 @@ test "fmod, fmodf" { try std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0))); try std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0))); - std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0)); - std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0)); + try std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0)); + try std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0)); - std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0)); - std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0)); - std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0)); - std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0)); + try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0)); + try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0)); + try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0)); + try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0)); } } @@ -902,11 +902,11 @@ test "fmin, fminf" { const nan_val = math.nan(T); try std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val))); - std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0)); - std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val)); - std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0)); - std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0)); + try std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0)); } } @@ -931,11 +931,11 @@ test "fmax, fmaxf" { const nan_val = math.nan(T); try std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val))); - std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0)); - std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val)); - std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0)); - std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0)); + try std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0)); + try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0)); } } @@ -1090,7 +1090,7 @@ test "sqrt" { // Note that @sqrt will either generate the sqrt opcode (if supported by the // target ISA) or a call to `sqrtf` otherwise. for (V) |val| - std.testing.expectEqual(@sqrt(val), sqrt(val)); + try std.testing.expectEqual(@sqrt(val), sqrt(val)); } test "sqrt special" { @@ -1195,7 +1195,7 @@ test "sqrtf" { // Note that @sqrt will either generate the sqrt opcode (if supported by the // target ISA) or a call to `sqrtf` otherwise. for (V) |val| - std.testing.expectEqual(@sqrt(val), sqrtf(val)); + try std.testing.expectEqual(@sqrt(val), sqrtf(val)); } test "sqrtf special" { diff --git a/lib/std/special/compiler_rt/addXf3_test.zig b/lib/std/special/compiler_rt/addXf3_test.zig index a8f454384c..33051ed970 100644 --- a/lib/std/special/compiler_rt/addXf3_test.zig +++ b/lib/std/special/compiler_rt/addXf3_test.zig @@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64); const __addtf3 = @import("addXf3.zig").__addtf3; -fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void { +fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void { const x = __addtf3(a, b); const rep = @bitCast(u128, x); @@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void { } } - @panic("__addtf3 test failure"); + return error.TestFailed; } test "addtf3" { - test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // NaN + any = NaN - test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // inf + inf = inf - test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0); + try test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0); // inf + any = inf - test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0); + try test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0); // any + any - test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c); + try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c); } const __subtf3 = @import("addXf3.zig").__subtf3; -fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void { +fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void { const x = __subtf3(a, b); const rep = @bitCast(u128, x); @@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void { } } - @panic("__subtf3 test failure"); + return error.TestFailed; } test "subtf3" { // qNaN - any = qNaN - test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // NaN + any = NaN - test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // inf - any = inf - test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0); + try test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0); // any + any - test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c); + try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c); } diff --git a/lib/std/special/compiler_rt/ashldi3_test.zig b/lib/std/special/compiler_rt/ashldi3_test.zig index dfc3712e39..4b1eb1f9e4 100644 --- a/lib/std/special/compiler_rt/ashldi3_test.zig +++ b/lib/std/special/compiler_rt/ashldi3_test.zig @@ -6,32 +6,32 @@ const __ashldi3 = @import("shift.zig").__ashldi3; const testing = @import("std").testing; -fn test__ashldi3(a: i64, b: i32, expected: u64) void { +fn test__ashldi3(a: i64, b: i32, expected: u64) !void { const x = __ashldi3(a, b); - testing.expectEqual(@bitCast(i64, expected), x); + try testing.expectEqual(@bitCast(i64, expected), x); } test "ashldi3" { - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000); - test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000); + try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000); } diff --git a/lib/std/special/compiler_rt/ashlti3_test.zig b/lib/std/special/compiler_rt/ashlti3_test.zig index 453fa9e77b..1187120457 100644 --- a/lib/std/special/compiler_rt/ashlti3_test.zig +++ b/lib/std/special/compiler_rt/ashlti3_test.zig @@ -6,46 +6,46 @@ const __ashlti3 = @import("shift.zig").__ashlti3; const testing = @import("std").testing; -fn test__ashlti3(a: i128, b: i32, expected: i128) void { +fn test__ashlti3(a: i128, b: i32, expected: i128) !void { const x = __ashlti3(a, b); - testing.expectEqual(expected, x); + try testing.expectEqual(expected, x); } test "ashlti3" { - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000))); - test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000))); + try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000))); } diff --git a/lib/std/special/compiler_rt/ashrdi3_test.zig b/lib/std/special/compiler_rt/ashrdi3_test.zig index 77fe286185..423c22fc12 100644 --- a/lib/std/special/compiler_rt/ashrdi3_test.zig +++ b/lib/std/special/compiler_rt/ashrdi3_test.zig @@ -6,55 +6,55 @@ const __ashrdi3 = @import("shift.zig").__ashrdi3; const testing = @import("std").testing; -fn test__ashrdi3(a: i64, b: i32, expected: u64) void { +fn test__ashrdi3(a: i64, b: i32, expected: u64) !void { const x = __ashrdi3(a, b); - testing.expectEqual(@bitCast(i64, expected), x); + try testing.expectEqual(@bitCast(i64, expected), x); } test "ashrdi3" { - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0); - test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0); + try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753); - test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9); - test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA); - test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD); - test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE); - test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE); + try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF); } diff --git a/lib/std/special/compiler_rt/ashrti3_test.zig b/lib/std/special/compiler_rt/ashrti3_test.zig index 5f4e166001..e6d1d7ddba 100644 --- a/lib/std/special/compiler_rt/ashrti3_test.zig +++ b/lib/std/special/compiler_rt/ashrti3_test.zig @@ -6,56 +6,56 @@ const __ashrti3 = @import("shift.zig").__ashrti3; const testing = @import("std").testing; -fn test__ashrti3(a: i128, b: i32, expected: i128) void { +fn test__ashrti3(a: i128, b: i32, expected: i128) !void { const x = __ashrti3(a, b); - testing.expectEqual(expected, x); + try testing.expectEqual(expected, x); } test "ashrti3" { - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); - test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); + try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))); } diff --git a/lib/std/special/compiler_rt/clzsi2_test.zig b/lib/std/special/compiler_rt/clzsi2_test.zig index c74a1c3ec2..b7828cf632 100644 --- a/lib/std/special/compiler_rt/clzsi2_test.zig +++ b/lib/std/special/compiler_rt/clzsi2_test.zig @@ -6,294 +6,294 @@ const clzsi2 = @import("clzsi2.zig"); const testing = @import("std").testing; -fn test__clzsi2(a: u32, expected: i32) void { +fn test__clzsi2(a: u32, expected: i32) !void { // XXX At high optimization levels this test may be horribly miscompiled if // one of the naked implementations is selected. var nakedClzsi2 = clzsi2.__clzsi2; var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2); var x = @bitCast(i32, a); var result = actualClzsi2(x); - testing.expectEqual(expected, result); + try testing.expectEqual(expected, result); } test "clzsi2" { - test__clzsi2(0x00800000, 8); - test__clzsi2(0x01000000, 7); - test__clzsi2(0x02000000, 6); - test__clzsi2(0x03000000, 6); - test__clzsi2(0x04000000, 5); - test__clzsi2(0x05000000, 5); - test__clzsi2(0x06000000, 5); - test__clzsi2(0x07000000, 5); - test__clzsi2(0x08000000, 4); - test__clzsi2(0x09000000, 4); - test__clzsi2(0x0A000000, 4); - test__clzsi2(0x0B000000, 4); - test__clzsi2(0x0C000000, 4); - test__clzsi2(0x0D000000, 4); - test__clzsi2(0x0E000000, 4); - test__clzsi2(0x0F000000, 4); - test__clzsi2(0x10000000, 3); - test__clzsi2(0x11000000, 3); - test__clzsi2(0x12000000, 3); - test__clzsi2(0x13000000, 3); - test__clzsi2(0x14000000, 3); - test__clzsi2(0x15000000, 3); - test__clzsi2(0x16000000, 3); - test__clzsi2(0x17000000, 3); - test__clzsi2(0x18000000, 3); - test__clzsi2(0x19000000, 3); - test__clzsi2(0x1A000000, 3); - test__clzsi2(0x1B000000, 3); - test__clzsi2(0x1C000000, 3); - test__clzsi2(0x1D000000, 3); - test__clzsi2(0x1E000000, 3); - test__clzsi2(0x1F000000, 3); - test__clzsi2(0x20000000, 2); - test__clzsi2(0x21000000, 2); - test__clzsi2(0x22000000, 2); - test__clzsi2(0x23000000, 2); - test__clzsi2(0x24000000, 2); - test__clzsi2(0x25000000, 2); - test__clzsi2(0x26000000, 2); - test__clzsi2(0x27000000, 2); - test__clzsi2(0x28000000, 2); - test__clzsi2(0x29000000, 2); - test__clzsi2(0x2A000000, 2); - test__clzsi2(0x2B000000, 2); - test__clzsi2(0x2C000000, 2); - test__clzsi2(0x2D000000, 2); - test__clzsi2(0x2E000000, 2); - test__clzsi2(0x2F000000, 2); - test__clzsi2(0x30000000, 2); - test__clzsi2(0x31000000, 2); - test__clzsi2(0x32000000, 2); - test__clzsi2(0x33000000, 2); - test__clzsi2(0x34000000, 2); - test__clzsi2(0x35000000, 2); - test__clzsi2(0x36000000, 2); - test__clzsi2(0x37000000, 2); - test__clzsi2(0x38000000, 2); - test__clzsi2(0x39000000, 2); - test__clzsi2(0x3A000000, 2); - test__clzsi2(0x3B000000, 2); - test__clzsi2(0x3C000000, 2); - test__clzsi2(0x3D000000, 2); - test__clzsi2(0x3E000000, 2); - test__clzsi2(0x3F000000, 2); - test__clzsi2(0x40000000, 1); - test__clzsi2(0x41000000, 1); - test__clzsi2(0x42000000, 1); - test__clzsi2(0x43000000, 1); - test__clzsi2(0x44000000, 1); - test__clzsi2(0x45000000, 1); - test__clzsi2(0x46000000, 1); - test__clzsi2(0x47000000, 1); - test__clzsi2(0x48000000, 1); - test__clzsi2(0x49000000, 1); - test__clzsi2(0x4A000000, 1); - test__clzsi2(0x4B000000, 1); - test__clzsi2(0x4C000000, 1); - test__clzsi2(0x4D000000, 1); - test__clzsi2(0x4E000000, 1); - test__clzsi2(0x4F000000, 1); - test__clzsi2(0x50000000, 1); - test__clzsi2(0x51000000, 1); - test__clzsi2(0x52000000, 1); - test__clzsi2(0x53000000, 1); - test__clzsi2(0x54000000, 1); - test__clzsi2(0x55000000, 1); - test__clzsi2(0x56000000, 1); - test__clzsi2(0x57000000, 1); - test__clzsi2(0x58000000, 1); - test__clzsi2(0x59000000, 1); - test__clzsi2(0x5A000000, 1); - test__clzsi2(0x5B000000, 1); - test__clzsi2(0x5C000000, 1); - test__clzsi2(0x5D000000, 1); - test__clzsi2(0x5E000000, 1); - test__clzsi2(0x5F000000, 1); - test__clzsi2(0x60000000, 1); - test__clzsi2(0x61000000, 1); - test__clzsi2(0x62000000, 1); - test__clzsi2(0x63000000, 1); - test__clzsi2(0x64000000, 1); - test__clzsi2(0x65000000, 1); - test__clzsi2(0x66000000, 1); - test__clzsi2(0x67000000, 1); - test__clzsi2(0x68000000, 1); - test__clzsi2(0x69000000, 1); - test__clzsi2(0x6A000000, 1); - test__clzsi2(0x6B000000, 1); - test__clzsi2(0x6C000000, 1); - test__clzsi2(0x6D000000, 1); - test__clzsi2(0x6E000000, 1); - test__clzsi2(0x6F000000, 1); - test__clzsi2(0x70000000, 1); - test__clzsi2(0x71000000, 1); - test__clzsi2(0x72000000, 1); - test__clzsi2(0x73000000, 1); - test__clzsi2(0x74000000, 1); - test__clzsi2(0x75000000, 1); - test__clzsi2(0x76000000, 1); - test__clzsi2(0x77000000, 1); - test__clzsi2(0x78000000, 1); - test__clzsi2(0x79000000, 1); - test__clzsi2(0x7A000000, 1); - test__clzsi2(0x7B000000, 1); - test__clzsi2(0x7C000000, 1); - test__clzsi2(0x7D000000, 1); - test__clzsi2(0x7E000000, 1); - test__clzsi2(0x7F000000, 1); - test__clzsi2(0x80000000, 0); - test__clzsi2(0x81000000, 0); - test__clzsi2(0x82000000, 0); - test__clzsi2(0x83000000, 0); - test__clzsi2(0x84000000, 0); - test__clzsi2(0x85000000, 0); - test__clzsi2(0x86000000, 0); - test__clzsi2(0x87000000, 0); - test__clzsi2(0x88000000, 0); - test__clzsi2(0x89000000, 0); - test__clzsi2(0x8A000000, 0); - test__clzsi2(0x8B000000, 0); - test__clzsi2(0x8C000000, 0); - test__clzsi2(0x8D000000, 0); - test__clzsi2(0x8E000000, 0); - test__clzsi2(0x8F000000, 0); - test__clzsi2(0x90000000, 0); - test__clzsi2(0x91000000, 0); - test__clzsi2(0x92000000, 0); - test__clzsi2(0x93000000, 0); - test__clzsi2(0x94000000, 0); - test__clzsi2(0x95000000, 0); - test__clzsi2(0x96000000, 0); - test__clzsi2(0x97000000, 0); - test__clzsi2(0x98000000, 0); - test__clzsi2(0x99000000, 0); - test__clzsi2(0x9A000000, 0); - test__clzsi2(0x9B000000, 0); - test__clzsi2(0x9C000000, 0); - test__clzsi2(0x9D000000, 0); - test__clzsi2(0x9E000000, 0); - test__clzsi2(0x9F000000, 0); - test__clzsi2(0xA0000000, 0); - test__clzsi2(0xA1000000, 0); - test__clzsi2(0xA2000000, 0); - test__clzsi2(0xA3000000, 0); - test__clzsi2(0xA4000000, 0); - test__clzsi2(0xA5000000, 0); - test__clzsi2(0xA6000000, 0); - test__clzsi2(0xA7000000, 0); - test__clzsi2(0xA8000000, 0); - test__clzsi2(0xA9000000, 0); - test__clzsi2(0xAA000000, 0); - test__clzsi2(0xAB000000, 0); - test__clzsi2(0xAC000000, 0); - test__clzsi2(0xAD000000, 0); - test__clzsi2(0xAE000000, 0); - test__clzsi2(0xAF000000, 0); - test__clzsi2(0xB0000000, 0); - test__clzsi2(0xB1000000, 0); - test__clzsi2(0xB2000000, 0); - test__clzsi2(0xB3000000, 0); - test__clzsi2(0xB4000000, 0); - test__clzsi2(0xB5000000, 0); - test__clzsi2(0xB6000000, 0); - test__clzsi2(0xB7000000, 0); - test__clzsi2(0xB8000000, 0); - test__clzsi2(0xB9000000, 0); - test__clzsi2(0xBA000000, 0); - test__clzsi2(0xBB000000, 0); - test__clzsi2(0xBC000000, 0); - test__clzsi2(0xBD000000, 0); - test__clzsi2(0xBE000000, 0); - test__clzsi2(0xBF000000, 0); - test__clzsi2(0xC0000000, 0); - test__clzsi2(0xC1000000, 0); - test__clzsi2(0xC2000000, 0); - test__clzsi2(0xC3000000, 0); - test__clzsi2(0xC4000000, 0); - test__clzsi2(0xC5000000, 0); - test__clzsi2(0xC6000000, 0); - test__clzsi2(0xC7000000, 0); - test__clzsi2(0xC8000000, 0); - test__clzsi2(0xC9000000, 0); - test__clzsi2(0xCA000000, 0); - test__clzsi2(0xCB000000, 0); - test__clzsi2(0xCC000000, 0); - test__clzsi2(0xCD000000, 0); - test__clzsi2(0xCE000000, 0); - test__clzsi2(0xCF000000, 0); - test__clzsi2(0xD0000000, 0); - test__clzsi2(0xD1000000, 0); - test__clzsi2(0xD2000000, 0); - test__clzsi2(0xD3000000, 0); - test__clzsi2(0xD4000000, 0); - test__clzsi2(0xD5000000, 0); - test__clzsi2(0xD6000000, 0); - test__clzsi2(0xD7000000, 0); - test__clzsi2(0xD8000000, 0); - test__clzsi2(0xD9000000, 0); - test__clzsi2(0xDA000000, 0); - test__clzsi2(0xDB000000, 0); - test__clzsi2(0xDC000000, 0); - test__clzsi2(0xDD000000, 0); - test__clzsi2(0xDE000000, 0); - test__clzsi2(0xDF000000, 0); - test__clzsi2(0xE0000000, 0); - test__clzsi2(0xE1000000, 0); - test__clzsi2(0xE2000000, 0); - test__clzsi2(0xE3000000, 0); - test__clzsi2(0xE4000000, 0); - test__clzsi2(0xE5000000, 0); - test__clzsi2(0xE6000000, 0); - test__clzsi2(0xE7000000, 0); - test__clzsi2(0xE8000000, 0); - test__clzsi2(0xE9000000, 0); - test__clzsi2(0xEA000000, 0); - test__clzsi2(0xEB000000, 0); - test__clzsi2(0xEC000000, 0); - test__clzsi2(0xED000000, 0); - test__clzsi2(0xEE000000, 0); - test__clzsi2(0xEF000000, 0); - test__clzsi2(0xF0000000, 0); - test__clzsi2(0xF1000000, 0); - test__clzsi2(0xF2000000, 0); - test__clzsi2(0xF3000000, 0); - test__clzsi2(0xF4000000, 0); - test__clzsi2(0xF5000000, 0); - test__clzsi2(0xF6000000, 0); - test__clzsi2(0xF7000000, 0); - test__clzsi2(0xF8000000, 0); - test__clzsi2(0xF9000000, 0); - test__clzsi2(0xFA000000, 0); - test__clzsi2(0xFB000000, 0); - test__clzsi2(0xFC000000, 0); - test__clzsi2(0xFD000000, 0); - test__clzsi2(0xFE000000, 0); - test__clzsi2(0xFF000000, 0); - test__clzsi2(0x00000001, 31); - test__clzsi2(0x00000002, 30); - test__clzsi2(0x00000004, 29); - test__clzsi2(0x00000008, 28); - test__clzsi2(0x00000010, 27); - test__clzsi2(0x00000020, 26); - test__clzsi2(0x00000040, 25); - test__clzsi2(0x00000080, 24); - test__clzsi2(0x00000100, 23); - test__clzsi2(0x00000200, 22); - test__clzsi2(0x00000400, 21); - test__clzsi2(0x00000800, 20); - test__clzsi2(0x00001000, 19); - test__clzsi2(0x00002000, 18); - test__clzsi2(0x00004000, 17); - test__clzsi2(0x00008000, 16); - test__clzsi2(0x00010000, 15); - test__clzsi2(0x00020000, 14); - test__clzsi2(0x00040000, 13); - test__clzsi2(0x00080000, 12); - test__clzsi2(0x00100000, 11); - test__clzsi2(0x00200000, 10); - test__clzsi2(0x00400000, 9); + try test__clzsi2(0x00800000, 8); + try test__clzsi2(0x01000000, 7); + try test__clzsi2(0x02000000, 6); + try test__clzsi2(0x03000000, 6); + try test__clzsi2(0x04000000, 5); + try test__clzsi2(0x05000000, 5); + try test__clzsi2(0x06000000, 5); + try test__clzsi2(0x07000000, 5); + try test__clzsi2(0x08000000, 4); + try test__clzsi2(0x09000000, 4); + try test__clzsi2(0x0A000000, 4); + try test__clzsi2(0x0B000000, 4); + try test__clzsi2(0x0C000000, 4); + try test__clzsi2(0x0D000000, 4); + try test__clzsi2(0x0E000000, 4); + try test__clzsi2(0x0F000000, 4); + try test__clzsi2(0x10000000, 3); + try test__clzsi2(0x11000000, 3); + try test__clzsi2(0x12000000, 3); + try test__clzsi2(0x13000000, 3); + try test__clzsi2(0x14000000, 3); + try test__clzsi2(0x15000000, 3); + try test__clzsi2(0x16000000, 3); + try test__clzsi2(0x17000000, 3); + try test__clzsi2(0x18000000, 3); + try test__clzsi2(0x19000000, 3); + try test__clzsi2(0x1A000000, 3); + try test__clzsi2(0x1B000000, 3); + try test__clzsi2(0x1C000000, 3); + try test__clzsi2(0x1D000000, 3); + try test__clzsi2(0x1E000000, 3); + try test__clzsi2(0x1F000000, 3); + try test__clzsi2(0x20000000, 2); + try test__clzsi2(0x21000000, 2); + try test__clzsi2(0x22000000, 2); + try test__clzsi2(0x23000000, 2); + try test__clzsi2(0x24000000, 2); + try test__clzsi2(0x25000000, 2); + try test__clzsi2(0x26000000, 2); + try test__clzsi2(0x27000000, 2); + try test__clzsi2(0x28000000, 2); + try test__clzsi2(0x29000000, 2); + try test__clzsi2(0x2A000000, 2); + try test__clzsi2(0x2B000000, 2); + try test__clzsi2(0x2C000000, 2); + try test__clzsi2(0x2D000000, 2); + try test__clzsi2(0x2E000000, 2); + try test__clzsi2(0x2F000000, 2); + try test__clzsi2(0x30000000, 2); + try test__clzsi2(0x31000000, 2); + try test__clzsi2(0x32000000, 2); + try test__clzsi2(0x33000000, 2); + try test__clzsi2(0x34000000, 2); + try test__clzsi2(0x35000000, 2); + try test__clzsi2(0x36000000, 2); + try test__clzsi2(0x37000000, 2); + try test__clzsi2(0x38000000, 2); + try test__clzsi2(0x39000000, 2); + try test__clzsi2(0x3A000000, 2); + try test__clzsi2(0x3B000000, 2); + try test__clzsi2(0x3C000000, 2); + try test__clzsi2(0x3D000000, 2); + try test__clzsi2(0x3E000000, 2); + try test__clzsi2(0x3F000000, 2); + try test__clzsi2(0x40000000, 1); + try test__clzsi2(0x41000000, 1); + try test__clzsi2(0x42000000, 1); + try test__clzsi2(0x43000000, 1); + try test__clzsi2(0x44000000, 1); + try test__clzsi2(0x45000000, 1); + try test__clzsi2(0x46000000, 1); + try test__clzsi2(0x47000000, 1); + try test__clzsi2(0x48000000, 1); + try test__clzsi2(0x49000000, 1); + try test__clzsi2(0x4A000000, 1); + try test__clzsi2(0x4B000000, 1); + try test__clzsi2(0x4C000000, 1); + try test__clzsi2(0x4D000000, 1); + try test__clzsi2(0x4E000000, 1); + try test__clzsi2(0x4F000000, 1); + try test__clzsi2(0x50000000, 1); + try test__clzsi2(0x51000000, 1); + try test__clzsi2(0x52000000, 1); + try test__clzsi2(0x53000000, 1); + try test__clzsi2(0x54000000, 1); + try test__clzsi2(0x55000000, 1); + try test__clzsi2(0x56000000, 1); + try test__clzsi2(0x57000000, 1); + try test__clzsi2(0x58000000, 1); + try test__clzsi2(0x59000000, 1); + try test__clzsi2(0x5A000000, 1); + try test__clzsi2(0x5B000000, 1); + try test__clzsi2(0x5C000000, 1); + try test__clzsi2(0x5D000000, 1); + try test__clzsi2(0x5E000000, 1); + try test__clzsi2(0x5F000000, 1); + try test__clzsi2(0x60000000, 1); + try test__clzsi2(0x61000000, 1); + try test__clzsi2(0x62000000, 1); + try test__clzsi2(0x63000000, 1); + try test__clzsi2(0x64000000, 1); + try test__clzsi2(0x65000000, 1); + try test__clzsi2(0x66000000, 1); + try test__clzsi2(0x67000000, 1); + try test__clzsi2(0x68000000, 1); + try test__clzsi2(0x69000000, 1); + try test__clzsi2(0x6A000000, 1); + try test__clzsi2(0x6B000000, 1); + try test__clzsi2(0x6C000000, 1); + try test__clzsi2(0x6D000000, 1); + try test__clzsi2(0x6E000000, 1); + try test__clzsi2(0x6F000000, 1); + try test__clzsi2(0x70000000, 1); + try test__clzsi2(0x71000000, 1); + try test__clzsi2(0x72000000, 1); + try test__clzsi2(0x73000000, 1); + try test__clzsi2(0x74000000, 1); + try test__clzsi2(0x75000000, 1); + try test__clzsi2(0x76000000, 1); + try test__clzsi2(0x77000000, 1); + try test__clzsi2(0x78000000, 1); + try test__clzsi2(0x79000000, 1); + try test__clzsi2(0x7A000000, 1); + try test__clzsi2(0x7B000000, 1); + try test__clzsi2(0x7C000000, 1); + try test__clzsi2(0x7D000000, 1); + try test__clzsi2(0x7E000000, 1); + try test__clzsi2(0x7F000000, 1); + try test__clzsi2(0x80000000, 0); + try test__clzsi2(0x81000000, 0); + try test__clzsi2(0x82000000, 0); + try test__clzsi2(0x83000000, 0); + try test__clzsi2(0x84000000, 0); + try test__clzsi2(0x85000000, 0); + try test__clzsi2(0x86000000, 0); + try test__clzsi2(0x87000000, 0); + try test__clzsi2(0x88000000, 0); + try test__clzsi2(0x89000000, 0); + try test__clzsi2(0x8A000000, 0); + try test__clzsi2(0x8B000000, 0); + try test__clzsi2(0x8C000000, 0); + try test__clzsi2(0x8D000000, 0); + try test__clzsi2(0x8E000000, 0); + try test__clzsi2(0x8F000000, 0); + try test__clzsi2(0x90000000, 0); + try test__clzsi2(0x91000000, 0); + try test__clzsi2(0x92000000, 0); + try test__clzsi2(0x93000000, 0); + try test__clzsi2(0x94000000, 0); + try test__clzsi2(0x95000000, 0); + try test__clzsi2(0x96000000, 0); + try test__clzsi2(0x97000000, 0); + try test__clzsi2(0x98000000, 0); + try test__clzsi2(0x99000000, 0); + try test__clzsi2(0x9A000000, 0); + try test__clzsi2(0x9B000000, 0); + try test__clzsi2(0x9C000000, 0); + try test__clzsi2(0x9D000000, 0); + try test__clzsi2(0x9E000000, 0); + try test__clzsi2(0x9F000000, 0); + try test__clzsi2(0xA0000000, 0); + try test__clzsi2(0xA1000000, 0); + try test__clzsi2(0xA2000000, 0); + try test__clzsi2(0xA3000000, 0); + try test__clzsi2(0xA4000000, 0); + try test__clzsi2(0xA5000000, 0); + try test__clzsi2(0xA6000000, 0); + try test__clzsi2(0xA7000000, 0); + try test__clzsi2(0xA8000000, 0); + try test__clzsi2(0xA9000000, 0); + try test__clzsi2(0xAA000000, 0); + try test__clzsi2(0xAB000000, 0); + try test__clzsi2(0xAC000000, 0); + try test__clzsi2(0xAD000000, 0); + try test__clzsi2(0xAE000000, 0); + try test__clzsi2(0xAF000000, 0); + try test__clzsi2(0xB0000000, 0); + try test__clzsi2(0xB1000000, 0); + try test__clzsi2(0xB2000000, 0); + try test__clzsi2(0xB3000000, 0); + try test__clzsi2(0xB4000000, 0); + try test__clzsi2(0xB5000000, 0); + try test__clzsi2(0xB6000000, 0); + try test__clzsi2(0xB7000000, 0); + try test__clzsi2(0xB8000000, 0); + try test__clzsi2(0xB9000000, 0); + try test__clzsi2(0xBA000000, 0); + try test__clzsi2(0xBB000000, 0); + try test__clzsi2(0xBC000000, 0); + try test__clzsi2(0xBD000000, 0); + try test__clzsi2(0xBE000000, 0); + try test__clzsi2(0xBF000000, 0); + try test__clzsi2(0xC0000000, 0); + try test__clzsi2(0xC1000000, 0); + try test__clzsi2(0xC2000000, 0); + try test__clzsi2(0xC3000000, 0); + try test__clzsi2(0xC4000000, 0); + try test__clzsi2(0xC5000000, 0); + try test__clzsi2(0xC6000000, 0); + try test__clzsi2(0xC7000000, 0); + try test__clzsi2(0xC8000000, 0); + try test__clzsi2(0xC9000000, 0); + try test__clzsi2(0xCA000000, 0); + try test__clzsi2(0xCB000000, 0); + try test__clzsi2(0xCC000000, 0); + try test__clzsi2(0xCD000000, 0); + try test__clzsi2(0xCE000000, 0); + try test__clzsi2(0xCF000000, 0); + try test__clzsi2(0xD0000000, 0); + try test__clzsi2(0xD1000000, 0); + try test__clzsi2(0xD2000000, 0); + try test__clzsi2(0xD3000000, 0); + try test__clzsi2(0xD4000000, 0); + try test__clzsi2(0xD5000000, 0); + try test__clzsi2(0xD6000000, 0); + try test__clzsi2(0xD7000000, 0); + try test__clzsi2(0xD8000000, 0); + try test__clzsi2(0xD9000000, 0); + try test__clzsi2(0xDA000000, 0); + try test__clzsi2(0xDB000000, 0); + try test__clzsi2(0xDC000000, 0); + try test__clzsi2(0xDD000000, 0); + try test__clzsi2(0xDE000000, 0); + try test__clzsi2(0xDF000000, 0); + try test__clzsi2(0xE0000000, 0); + try test__clzsi2(0xE1000000, 0); + try test__clzsi2(0xE2000000, 0); + try test__clzsi2(0xE3000000, 0); + try test__clzsi2(0xE4000000, 0); + try test__clzsi2(0xE5000000, 0); + try test__clzsi2(0xE6000000, 0); + try test__clzsi2(0xE7000000, 0); + try test__clzsi2(0xE8000000, 0); + try test__clzsi2(0xE9000000, 0); + try test__clzsi2(0xEA000000, 0); + try test__clzsi2(0xEB000000, 0); + try test__clzsi2(0xEC000000, 0); + try test__clzsi2(0xED000000, 0); + try test__clzsi2(0xEE000000, 0); + try test__clzsi2(0xEF000000, 0); + try test__clzsi2(0xF0000000, 0); + try test__clzsi2(0xF1000000, 0); + try test__clzsi2(0xF2000000, 0); + try test__clzsi2(0xF3000000, 0); + try test__clzsi2(0xF4000000, 0); + try test__clzsi2(0xF5000000, 0); + try test__clzsi2(0xF6000000, 0); + try test__clzsi2(0xF7000000, 0); + try test__clzsi2(0xF8000000, 0); + try test__clzsi2(0xF9000000, 0); + try test__clzsi2(0xFA000000, 0); + try test__clzsi2(0xFB000000, 0); + try test__clzsi2(0xFC000000, 0); + try test__clzsi2(0xFD000000, 0); + try test__clzsi2(0xFE000000, 0); + try test__clzsi2(0xFF000000, 0); + try test__clzsi2(0x00000001, 31); + try test__clzsi2(0x00000002, 30); + try test__clzsi2(0x00000004, 29); + try test__clzsi2(0x00000008, 28); + try test__clzsi2(0x00000010, 27); + try test__clzsi2(0x00000020, 26); + try test__clzsi2(0x00000040, 25); + try test__clzsi2(0x00000080, 24); + try test__clzsi2(0x00000100, 23); + try test__clzsi2(0x00000200, 22); + try test__clzsi2(0x00000400, 21); + try test__clzsi2(0x00000800, 20); + try test__clzsi2(0x00001000, 19); + try test__clzsi2(0x00002000, 18); + try test__clzsi2(0x00004000, 17); + try test__clzsi2(0x00008000, 16); + try test__clzsi2(0x00010000, 15); + try test__clzsi2(0x00020000, 14); + try test__clzsi2(0x00040000, 13); + try test__clzsi2(0x00080000, 12); + try test__clzsi2(0x00100000, 11); + try test__clzsi2(0x00200000, 10); + try test__clzsi2(0x00400000, 9); } diff --git a/lib/std/special/compiler_rt/divdf3_test.zig b/lib/std/special/compiler_rt/divdf3_test.zig index 0bced93de5..a472b5ed08 100644 --- a/lib/std/special/compiler_rt/divdf3_test.zig +++ b/lib/std/special/compiler_rt/divdf3_test.zig @@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool { return false; } -fn test__divdf3(a: f64, b: f64, expected: u64) void { +fn test__divdf3(a: f64, b: f64, expected: u64) !void { const x = __divdf3(a, b); const ret = compareResultD(x, expected); try testing.expect(ret == true); } test "divdf3" { - test__divdf3(1.0, 3.0, 0x3fd5555555555555); - test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000); + try test__divdf3(1.0, 3.0, 0x3fd5555555555555); + try test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000); } diff --git a/lib/std/special/compiler_rt/divsf3_test.zig b/lib/std/special/compiler_rt/divsf3_test.zig index b7bf220d8b..97f34d34a5 100644 --- a/lib/std/special/compiler_rt/divsf3_test.zig +++ b/lib/std/special/compiler_rt/divsf3_test.zig @@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool { return false; } -fn test__divsf3(a: f32, b: f32, expected: u32) void { +fn test__divsf3(a: f32, b: f32, expected: u32) !void { const x = __divsf3(a, b); const ret = compareResultF(x, expected); try testing.expect(ret == true); } test "divsf3" { - test__divsf3(1.0, 3.0, 0x3EAAAAAB); - test__divsf3(2.3509887e-38, 2.0, 0x00800000); + try test__divsf3(1.0, 3.0, 0x3EAAAAAB); + try test__divsf3(2.3509887e-38, 2.0, 0x00800000); } diff --git a/lib/std/special/compiler_rt/divtf3_test.zig b/lib/std/special/compiler_rt/divtf3_test.zig index 325be493cd..3915177091 100644 --- a/lib/std/special/compiler_rt/divtf3_test.zig +++ b/lib/std/special/compiler_rt/divtf3_test.zig @@ -28,7 +28,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool { return false; } -fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void { +fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) !void { const x = __divtf3(a, b); const ret = compareResultLD(x, expectedHi, expectedLo); try testing.expect(ret == true); @@ -36,16 +36,16 @@ fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void { test "divtf3" { // qNaN / any = qNaN - test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0); + try test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0); // NaN / any = NaN - test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0); + try test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0); // inf / any = inf - test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0); + try test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0); - test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2); - test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2); - test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac); - test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252); - test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078); - test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0); + try test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2); + try test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2); + try test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac); + try test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252); + try test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078); + try test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0); } diff --git a/lib/std/special/compiler_rt/divti3_test.zig b/lib/std/special/compiler_rt/divti3_test.zig index 61aab97475..c4f7fd01b6 100644 --- a/lib/std/special/compiler_rt/divti3_test.zig +++ b/lib/std/special/compiler_rt/divti3_test.zig @@ -6,21 +6,21 @@ const __divti3 = @import("divti3.zig").__divti3; const testing = @import("std").testing; -fn test__divti3(a: i128, b: i128, expected: i128) void { +fn test__divti3(a: i128, b: i128, expected: i128) !void { const x = __divti3(a, b); try testing.expect(x == expected); } test "divti3" { - test__divti3(0, 1, 0); - test__divti3(0, -1, 0); - test__divti3(2, 1, 2); - test__divti3(2, -1, -2); - test__divti3(-2, 1, -2); - test__divti3(-2, -1, 2); + try test__divti3(0, 1, 0); + try test__divti3(0, -1, 0); + try test__divti3(2, 1, 2); + try test__divti3(2, -1, -2); + try test__divti3(-2, 1, -2); + try test__divti3(-2, -1, 2); - test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124))); - test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124))); - test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124))); - test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124))); + try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124))); + try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124))); + try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124))); + try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124))); } diff --git a/lib/std/special/compiler_rt/extendXfYf2_test.zig b/lib/std/special/compiler_rt/extendXfYf2_test.zig index f05d33eac3..f75b9d9297 100644 --- a/lib/std/special/compiler_rt/extendXfYf2_test.zig +++ b/lib/std/special/compiler_rt/extendXfYf2_test.zig @@ -9,7 +9,7 @@ const __extendhftf2 = @import("extendXfYf2.zig").__extendhftf2; const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2; const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2; -fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void { +fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) !void { const x = __extenddftf2(a); const rep = @bitCast(u128, x); @@ -31,7 +31,7 @@ fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void { @panic("__extenddftf2 test failure"); } -fn test__extendhfsf2(a: u16, expected: u32) void { +fn test__extendhfsf2(a: u16, expected: u32) !void { const x = __extendhfsf2(a); const rep = @bitCast(u32, x); @@ -44,10 +44,10 @@ fn test__extendhfsf2(a: u16, expected: u32) void { } } - @panic("__extendhfsf2 test failure"); + return error.TestFailure; } -fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void { +fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) !void { const x = __extendsftf2(a); const rep = @bitCast(u128, x); @@ -66,77 +66,77 @@ fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void { } } - @panic("__extendsftf2 test failure"); + return error.TestFailure; } test "extenddftf2" { // qNaN - test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0); + try test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0); // NaN - test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0); + try test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0); // inf - test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0); + try test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0); // zero - test__extenddftf2(0.0, 0x0, 0x0); + try test__extenddftf2(0.0, 0x0, 0x0); - test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000); + try test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000); - test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000); + try test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000); - test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000); + try test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000); - test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000); + try test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000); } test "extendhfsf2" { - test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN - test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN + try test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN + try test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN // On x86 the NaN becomes quiet because the return is pushed on the x87 // stack due to ABI requirements if (builtin.arch != .i386 and builtin.os.tag == .windows) - test__extendhfsf2(0x7c01, 0x7f802000); // sNaN + try test__extendhfsf2(0x7c01, 0x7f802000); // sNaN - test__extendhfsf2(0, 0); // 0 - test__extendhfsf2(0x8000, 0x80000000); // -0 + try test__extendhfsf2(0, 0); // 0 + try test__extendhfsf2(0x8000, 0x80000000); // -0 - test__extendhfsf2(0x7c00, 0x7f800000); // inf - test__extendhfsf2(0xfc00, 0xff800000); // -inf + try test__extendhfsf2(0x7c00, 0x7f800000); // inf + try test__extendhfsf2(0xfc00, 0xff800000); // -inf - test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24 - test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24 + try test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24 + try test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24 - test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2**-14 - 2**-24 - test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2**-14 + 2**-24 + try test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2**-14 - 2**-24 + try test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2**-14 + 2**-24 - test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14 - test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14 + try test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14 + try test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14 - test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504 - test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504 + try test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504 + try test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504 - test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10 - test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10 + try test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10 + try test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10 - test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3 - test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3 + try test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3 + try test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3 } test "extendsftf2" { // qNaN - test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0); + try test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0); // NaN - test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0); + try test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0); // inf - test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0); + try test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0); // zero - test__extendsftf2(0.0, 0x0, 0x0); - test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0); - test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0); - test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0); - test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0); + try test__extendsftf2(0.0, 0x0, 0x0); + try test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0); + try test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0); + try test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0); + try test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0); } fn makeQNaN64() f64 { @@ -163,7 +163,7 @@ fn makeInf32() f32 { return @bitCast(f32, @as(u32, 0x7f800000)); } -fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void { +fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) !void { const x = __extendhftf2(a); const rep = @bitCast(u128, x); @@ -182,29 +182,29 @@ fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void { } } - @panic("__extendhftf2 test failure"); + return error.TestFailure; } test "extendhftf2" { // qNaN - test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0); + try test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0); // NaN - test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0); + try test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0); // inf - test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0); - test__extendhftf2(0xfc00, 0xffff000000000000, 0x0); + try test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0); + try test__extendhftf2(0xfc00, 0xffff000000000000, 0x0); // zero - test__extendhftf2(0x0000, 0x0000000000000000, 0x0); - test__extendhftf2(0x8000, 0x8000000000000000, 0x0); + try test__extendhftf2(0x0000, 0x0000000000000000, 0x0); + try test__extendhftf2(0x8000, 0x8000000000000000, 0x0); // denormal - test__extendhftf2(0x0010, 0x3feb000000000000, 0x0); - test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0); - test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0); + try test__extendhftf2(0x0010, 0x3feb000000000000, 0x0); + try test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0); + try test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0); // pi - test__extendhftf2(0x4248, 0x4000920000000000, 0x0); - test__extendhftf2(0xc248, 0xc000920000000000, 0x0); + try test__extendhftf2(0x4248, 0x4000920000000000, 0x0); + try test__extendhftf2(0xc248, 0xc000920000000000, 0x0); - test__extendhftf2(0x508c, 0x4004230000000000, 0x0); - test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0); + try test__extendhftf2(0x508c, 0x4004230000000000, 0x0); + try test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0); } diff --git a/lib/std/special/compiler_rt/fixdfdi_test.zig b/lib/std/special/compiler_rt/fixdfdi_test.zig index cc638e1e50..c8220b532d 100644 --- a/lib/std/special/compiler_rt/fixdfdi_test.zig +++ b/lib/std/special/compiler_rt/fixdfdi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixdfdi(a: f64, expected: i64) void { +fn test__fixdfdi(a: f64, expected: i64) !void { const x = __fixdfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)}); try testing.expect(x == expected); @@ -17,54 +17,54 @@ fn test__fixdfdi(a: f64, expected: i64) void { test "fixdfdi" { //warn("\n", .{}); - test__fixdfdi(-math.f64_max, math.minInt(i64)); + try test__fixdfdi(-math.f64_max, math.minInt(i64)); - test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000); - test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000); - test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); - test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); + try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); - test__fixdfdi(-2.01, -2); - test__fixdfdi(-2.0, -2); - test__fixdfdi(-1.99, -1); - test__fixdfdi(-1.0, -1); - test__fixdfdi(-0.99, 0); - test__fixdfdi(-0.5, 0); - test__fixdfdi(-math.f64_min, 0); - test__fixdfdi(0.0, 0); - test__fixdfdi(math.f64_min, 0); - test__fixdfdi(0.5, 0); - test__fixdfdi(0.99, 0); - test__fixdfdi(1.0, 1); - test__fixdfdi(1.5, 1); - test__fixdfdi(1.99, 1); - test__fixdfdi(2.0, 2); - test__fixdfdi(2.01, 2); + try test__fixdfdi(-2.01, -2); + try test__fixdfdi(-2.0, -2); + try test__fixdfdi(-1.99, -1); + try test__fixdfdi(-1.0, -1); + try test__fixdfdi(-0.99, 0); + try test__fixdfdi(-0.5, 0); + try test__fixdfdi(-math.f64_min, 0); + try test__fixdfdi(0.0, 0); + try test__fixdfdi(math.f64_min, 0); + try test__fixdfdi(0.5, 0); + try test__fixdfdi(0.99, 0); + try test__fixdfdi(1.0, 1); + try test__fixdfdi(1.5, 1); + try test__fixdfdi(1.99, 1); + try test__fixdfdi(2.0, 2); + try test__fixdfdi(2.01, 2); - test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - test__fixdfdi(math.f64_max, math.maxInt(i64)); + try test__fixdfdi(math.f64_max, math.maxInt(i64)); } diff --git a/lib/std/special/compiler_rt/fixdfsi_test.zig b/lib/std/special/compiler_rt/fixdfsi_test.zig index e1425f8d5e..c9ebcbeddc 100644 --- a/lib/std/special/compiler_rt/fixdfsi_test.zig +++ b/lib/std/special/compiler_rt/fixdfsi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixdfsi(a: f64, expected: i32) void { +fn test__fixdfsi(a: f64, expected: i32) !void { const x = __fixdfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)}); try testing.expect(x == expected); @@ -17,62 +17,62 @@ fn test__fixdfsi(a: f64, expected: i32) void { test "fixdfsi" { //warn("\n", .{}); - test__fixdfsi(-math.f64_max, math.minInt(i32)); + try test__fixdfsi(-math.f64_max, math.minInt(i32)); - test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - test__fixdfsi(-0x1.0000000000000p+127, -0x80000000); - test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - test__fixdfsi(-0x1.0000000000001p+63, -0x80000000); - test__fixdfsi(-0x1.0000000000000p+63, -0x80000000); - test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000); - test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000); + try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000); - test__fixdfsi(-0x1.000000p+31, -0x80000000); - test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixdfsi(-0x1.000000p+31, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - test__fixdfsi(-2.01, -2); - test__fixdfsi(-2.0, -2); - test__fixdfsi(-1.99, -1); - test__fixdfsi(-1.0, -1); - test__fixdfsi(-0.99, 0); - test__fixdfsi(-0.5, 0); - test__fixdfsi(-math.f64_min, 0); - test__fixdfsi(0.0, 0); - test__fixdfsi(math.f64_min, 0); - test__fixdfsi(0.5, 0); - test__fixdfsi(0.99, 0); - test__fixdfsi(1.0, 1); - test__fixdfsi(1.5, 1); - test__fixdfsi(1.99, 1); - test__fixdfsi(2.0, 2); - test__fixdfsi(2.01, 2); + try test__fixdfsi(-2.01, -2); + try test__fixdfsi(-2.0, -2); + try test__fixdfsi(-1.99, -1); + try test__fixdfsi(-1.0, -1); + try test__fixdfsi(-0.99, 0); + try test__fixdfsi(-0.5, 0); + try test__fixdfsi(-math.f64_min, 0); + try test__fixdfsi(0.0, 0); + try test__fixdfsi(math.f64_min, 0); + try test__fixdfsi(0.5, 0); + try test__fixdfsi(0.99, 0); + try test__fixdfsi(1.0, 1); + try test__fixdfsi(1.5, 1); + try test__fixdfsi(1.99, 1); + try test__fixdfsi(2.0, 2); + try test__fixdfsi(2.01, 2); - test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); - test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - test__fixdfsi(math.f64_max, math.maxInt(i32)); + try test__fixdfsi(math.f64_max, math.maxInt(i32)); } diff --git a/lib/std/special/compiler_rt/fixdfti_test.zig b/lib/std/special/compiler_rt/fixdfti_test.zig index 99a0b90bf6..76f08f985d 100644 --- a/lib/std/special/compiler_rt/fixdfti_test.zig +++ b/lib/std/special/compiler_rt/fixdfti_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixdfti(a: f64, expected: i128) void { +fn test__fixdfti(a: f64, expected: i128) !void { const x = __fixdfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)}); try testing.expect(x == expected); @@ -17,54 +17,54 @@ fn test__fixdfti(a: f64, expected: i128) void { test "fixdfti" { //warn("\n", .{}); - test__fixdfti(-math.f64_max, math.minInt(i128)); + try test__fixdfti(-math.f64_max, math.minInt(i128)); - test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); - test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); + try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); - test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800); - test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800); + try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - test__fixdfti(-2.01, -2); - test__fixdfti(-2.0, -2); - test__fixdfti(-1.99, -1); - test__fixdfti(-1.0, -1); - test__fixdfti(-0.99, 0); - test__fixdfti(-0.5, 0); - test__fixdfti(-math.f64_min, 0); - test__fixdfti(0.0, 0); - test__fixdfti(math.f64_min, 0); - test__fixdfti(0.5, 0); - test__fixdfti(0.99, 0); - test__fixdfti(1.0, 1); - test__fixdfti(1.5, 1); - test__fixdfti(1.99, 1); - test__fixdfti(2.0, 2); - test__fixdfti(2.01, 2); + try test__fixdfti(-2.01, -2); + try test__fixdfti(-2.0, -2); + try test__fixdfti(-1.99, -1); + try test__fixdfti(-1.0, -1); + try test__fixdfti(-0.99, 0); + try test__fixdfti(-0.5, 0); + try test__fixdfti(-math.f64_min, 0); + try test__fixdfti(0.0, 0); + try test__fixdfti(math.f64_min, 0); + try test__fixdfti(0.5, 0); + try test__fixdfti(0.99, 0); + try test__fixdfti(1.0, 1); + try test__fixdfti(1.5, 1); + try test__fixdfti(1.99, 1); + try test__fixdfti(2.0, 2); + try test__fixdfti(2.01, 2); - test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000); - test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800); + try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800); - test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - test__fixdfti(math.f64_max, math.maxInt(i128)); + try test__fixdfti(math.f64_max, math.maxInt(i128)); } diff --git a/lib/std/special/compiler_rt/fixint_test.zig b/lib/std/special/compiler_rt/fixint_test.zig index 10237bca77..86bc32e642 100644 --- a/lib/std/special/compiler_rt/fixint_test.zig +++ b/lib/std/special/compiler_rt/fixint_test.zig @@ -11,147 +11,147 @@ const warn = std.debug.warn; const fixint = @import("fixint.zig").fixint; -fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void { +fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) !void { const x = fixint(fp_t, fixint_t, a); //warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected}); try testing.expect(x == expected); } test "fixint.i1" { - test__fixint(f32, i1, -math.inf_f32, -1); - test__fixint(f32, i1, -math.f32_max, -1); - test__fixint(f32, i1, -2.0, -1); - test__fixint(f32, i1, -1.1, -1); - test__fixint(f32, i1, -1.0, -1); - test__fixint(f32, i1, -0.9, 0); - test__fixint(f32, i1, -0.1, 0); - test__fixint(f32, i1, -math.f32_min, 0); - test__fixint(f32, i1, -0.0, 0); - test__fixint(f32, i1, 0.0, 0); - test__fixint(f32, i1, math.f32_min, 0); - test__fixint(f32, i1, 0.1, 0); - test__fixint(f32, i1, 0.9, 0); - test__fixint(f32, i1, 1.0, 0); - test__fixint(f32, i1, 2.0, 0); - test__fixint(f32, i1, math.f32_max, 0); - test__fixint(f32, i1, math.inf_f32, 0); + try test__fixint(f32, i1, -math.inf_f32, -1); + try test__fixint(f32, i1, -math.f32_max, -1); + try test__fixint(f32, i1, -2.0, -1); + try test__fixint(f32, i1, -1.1, -1); + try test__fixint(f32, i1, -1.0, -1); + try test__fixint(f32, i1, -0.9, 0); + try test__fixint(f32, i1, -0.1, 0); + try test__fixint(f32, i1, -math.f32_min, 0); + try test__fixint(f32, i1, -0.0, 0); + try test__fixint(f32, i1, 0.0, 0); + try test__fixint(f32, i1, math.f32_min, 0); + try test__fixint(f32, i1, 0.1, 0); + try test__fixint(f32, i1, 0.9, 0); + try test__fixint(f32, i1, 1.0, 0); + try test__fixint(f32, i1, 2.0, 0); + try test__fixint(f32, i1, math.f32_max, 0); + try test__fixint(f32, i1, math.inf_f32, 0); } test "fixint.i2" { - test__fixint(f32, i2, -math.inf_f32, -2); - test__fixint(f32, i2, -math.f32_max, -2); - test__fixint(f32, i2, -2.0, -2); - test__fixint(f32, i2, -1.9, -1); - test__fixint(f32, i2, -1.1, -1); - test__fixint(f32, i2, -1.0, -1); - test__fixint(f32, i2, -0.9, 0); - test__fixint(f32, i2, -0.1, 0); - test__fixint(f32, i2, -math.f32_min, 0); - test__fixint(f32, i2, -0.0, 0); - test__fixint(f32, i2, 0.0, 0); - test__fixint(f32, i2, math.f32_min, 0); - test__fixint(f32, i2, 0.1, 0); - test__fixint(f32, i2, 0.9, 0); - test__fixint(f32, i2, 1.0, 1); - test__fixint(f32, i2, 2.0, 1); - test__fixint(f32, i2, math.f32_max, 1); - test__fixint(f32, i2, math.inf_f32, 1); + try test__fixint(f32, i2, -math.inf_f32, -2); + try test__fixint(f32, i2, -math.f32_max, -2); + try test__fixint(f32, i2, -2.0, -2); + try test__fixint(f32, i2, -1.9, -1); + try test__fixint(f32, i2, -1.1, -1); + try test__fixint(f32, i2, -1.0, -1); + try test__fixint(f32, i2, -0.9, 0); + try test__fixint(f32, i2, -0.1, 0); + try test__fixint(f32, i2, -math.f32_min, 0); + try test__fixint(f32, i2, -0.0, 0); + try test__fixint(f32, i2, 0.0, 0); + try test__fixint(f32, i2, math.f32_min, 0); + try test__fixint(f32, i2, 0.1, 0); + try test__fixint(f32, i2, 0.9, 0); + try test__fixint(f32, i2, 1.0, 1); + try test__fixint(f32, i2, 2.0, 1); + try test__fixint(f32, i2, math.f32_max, 1); + try test__fixint(f32, i2, math.inf_f32, 1); } test "fixint.i3" { - test__fixint(f32, i3, -math.inf_f32, -4); - test__fixint(f32, i3, -math.f32_max, -4); - test__fixint(f32, i3, -4.0, -4); - test__fixint(f32, i3, -3.0, -3); - test__fixint(f32, i3, -2.0, -2); - test__fixint(f32, i3, -1.9, -1); - test__fixint(f32, i3, -1.1, -1); - test__fixint(f32, i3, -1.0, -1); - test__fixint(f32, i3, -0.9, 0); - test__fixint(f32, i3, -0.1, 0); - test__fixint(f32, i3, -math.f32_min, 0); - test__fixint(f32, i3, -0.0, 0); - test__fixint(f32, i3, 0.0, 0); - test__fixint(f32, i3, math.f32_min, 0); - test__fixint(f32, i3, 0.1, 0); - test__fixint(f32, i3, 0.9, 0); - test__fixint(f32, i3, 1.0, 1); - test__fixint(f32, i3, 2.0, 2); - test__fixint(f32, i3, 3.0, 3); - test__fixint(f32, i3, 4.0, 3); - test__fixint(f32, i3, math.f32_max, 3); - test__fixint(f32, i3, math.inf_f32, 3); + try test__fixint(f32, i3, -math.inf_f32, -4); + try test__fixint(f32, i3, -math.f32_max, -4); + try test__fixint(f32, i3, -4.0, -4); + try test__fixint(f32, i3, -3.0, -3); + try test__fixint(f32, i3, -2.0, -2); + try test__fixint(f32, i3, -1.9, -1); + try test__fixint(f32, i3, -1.1, -1); + try test__fixint(f32, i3, -1.0, -1); + try test__fixint(f32, i3, -0.9, 0); + try test__fixint(f32, i3, -0.1, 0); + try test__fixint(f32, i3, -math.f32_min, 0); + try test__fixint(f32, i3, -0.0, 0); + try test__fixint(f32, i3, 0.0, 0); + try test__fixint(f32, i3, math.f32_min, 0); + try test__fixint(f32, i3, 0.1, 0); + try test__fixint(f32, i3, 0.9, 0); + try test__fixint(f32, i3, 1.0, 1); + try test__fixint(f32, i3, 2.0, 2); + try test__fixint(f32, i3, 3.0, 3); + try test__fixint(f32, i3, 4.0, 3); + try test__fixint(f32, i3, math.f32_max, 3); + try test__fixint(f32, i3, math.inf_f32, 3); } test "fixint.i32" { - test__fixint(f64, i32, -math.inf_f64, math.minInt(i32)); - test__fixint(f64, i32, -math.f64_max, math.minInt(i32)); - test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32)); - test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1); - test__fixint(f64, i32, -2.0, -2); - test__fixint(f64, i32, -1.9, -1); - test__fixint(f64, i32, -1.1, -1); - test__fixint(f64, i32, -1.0, -1); - test__fixint(f64, i32, -0.9, 0); - test__fixint(f64, i32, -0.1, 0); - test__fixint(f64, i32, -math.f32_min, 0); - test__fixint(f64, i32, -0.0, 0); - test__fixint(f64, i32, 0.0, 0); - test__fixint(f64, i32, math.f32_min, 0); - test__fixint(f64, i32, 0.1, 0); - test__fixint(f64, i32, 0.9, 0); - test__fixint(f64, i32, 1.0, 1); - test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1); - test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32)); - test__fixint(f64, i32, math.f64_max, math.maxInt(i32)); - test__fixint(f64, i32, math.inf_f64, math.maxInt(i32)); + try test__fixint(f64, i32, -math.inf_f64, math.minInt(i32)); + try test__fixint(f64, i32, -math.f64_max, math.minInt(i32)); + try test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32)); + try test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1); + try test__fixint(f64, i32, -2.0, -2); + try test__fixint(f64, i32, -1.9, -1); + try test__fixint(f64, i32, -1.1, -1); + try test__fixint(f64, i32, -1.0, -1); + try test__fixint(f64, i32, -0.9, 0); + try test__fixint(f64, i32, -0.1, 0); + try test__fixint(f64, i32, -math.f32_min, 0); + try test__fixint(f64, i32, -0.0, 0); + try test__fixint(f64, i32, 0.0, 0); + try test__fixint(f64, i32, math.f32_min, 0); + try test__fixint(f64, i32, 0.1, 0); + try test__fixint(f64, i32, 0.9, 0); + try test__fixint(f64, i32, 1.0, 1); + try test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1); + try test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32)); + try test__fixint(f64, i32, math.f64_max, math.maxInt(i32)); + try test__fixint(f64, i32, math.inf_f64, math.maxInt(i32)); } test "fixint.i64" { - test__fixint(f64, i64, -math.inf_f64, math.minInt(i64)); - test__fixint(f64, i64, -math.f64_max, math.minInt(i64)); - test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64)); - test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64)); - test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2); - test__fixint(f64, i64, -2.0, -2); - test__fixint(f64, i64, -1.9, -1); - test__fixint(f64, i64, -1.1, -1); - test__fixint(f64, i64, -1.0, -1); - test__fixint(f64, i64, -0.9, 0); - test__fixint(f64, i64, -0.1, 0); - test__fixint(f64, i64, -math.f32_min, 0); - test__fixint(f64, i64, -0.0, 0); - test__fixint(f64, i64, 0.0, 0); - test__fixint(f64, i64, math.f32_min, 0); - test__fixint(f64, i64, 0.1, 0); - test__fixint(f64, i64, 0.9, 0); - test__fixint(f64, i64, 1.0, 1); - test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64)); - test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64)); - test__fixint(f64, i64, math.f64_max, math.maxInt(i64)); - test__fixint(f64, i64, math.inf_f64, math.maxInt(i64)); + try test__fixint(f64, i64, -math.inf_f64, math.minInt(i64)); + try test__fixint(f64, i64, -math.f64_max, math.minInt(i64)); + try test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64)); + try test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64)); + try test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2); + try test__fixint(f64, i64, -2.0, -2); + try test__fixint(f64, i64, -1.9, -1); + try test__fixint(f64, i64, -1.1, -1); + try test__fixint(f64, i64, -1.0, -1); + try test__fixint(f64, i64, -0.9, 0); + try test__fixint(f64, i64, -0.1, 0); + try test__fixint(f64, i64, -math.f32_min, 0); + try test__fixint(f64, i64, -0.0, 0); + try test__fixint(f64, i64, 0.0, 0); + try test__fixint(f64, i64, math.f32_min, 0); + try test__fixint(f64, i64, 0.1, 0); + try test__fixint(f64, i64, 0.9, 0); + try test__fixint(f64, i64, 1.0, 1); + try test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64)); + try test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64)); + try test__fixint(f64, i64, math.f64_max, math.maxInt(i64)); + try test__fixint(f64, i64, math.inf_f64, math.maxInt(i64)); } test "fixint.i128" { - test__fixint(f64, i128, -math.inf_f64, math.minInt(i128)); - test__fixint(f64, i128, -math.f64_max, math.minInt(i128)); - test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128)); - test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128)); - test__fixint(f64, i128, -2.0, -2); - test__fixint(f64, i128, -1.9, -1); - test__fixint(f64, i128, -1.1, -1); - test__fixint(f64, i128, -1.0, -1); - test__fixint(f64, i128, -0.9, 0); - test__fixint(f64, i128, -0.1, 0); - test__fixint(f64, i128, -math.f32_min, 0); - test__fixint(f64, i128, -0.0, 0); - test__fixint(f64, i128, 0.0, 0); - test__fixint(f64, i128, math.f32_min, 0); - test__fixint(f64, i128, 0.1, 0); - test__fixint(f64, i128, 0.9, 0); - test__fixint(f64, i128, 1.0, 1); - test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128)); - test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128)); - test__fixint(f64, i128, math.f64_max, math.maxInt(i128)); - test__fixint(f64, i128, math.inf_f64, math.maxInt(i128)); + try test__fixint(f64, i128, -math.inf_f64, math.minInt(i128)); + try test__fixint(f64, i128, -math.f64_max, math.minInt(i128)); + try test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128)); + try test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128)); + try test__fixint(f64, i128, -2.0, -2); + try test__fixint(f64, i128, -1.9, -1); + try test__fixint(f64, i128, -1.1, -1); + try test__fixint(f64, i128, -1.0, -1); + try test__fixint(f64, i128, -0.9, 0); + try test__fixint(f64, i128, -0.1, 0); + try test__fixint(f64, i128, -math.f32_min, 0); + try test__fixint(f64, i128, -0.0, 0); + try test__fixint(f64, i128, 0.0, 0); + try test__fixint(f64, i128, math.f32_min, 0); + try test__fixint(f64, i128, 0.1, 0); + try test__fixint(f64, i128, 0.9, 0); + try test__fixint(f64, i128, 1.0, 1); + try test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128)); + try test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128)); + try test__fixint(f64, i128, math.f64_max, math.maxInt(i128)); + try test__fixint(f64, i128, math.inf_f64, math.maxInt(i128)); } diff --git a/lib/std/special/compiler_rt/fixsfdi_test.zig b/lib/std/special/compiler_rt/fixsfdi_test.zig index 50410411ca..e18a15d9a3 100644 --- a/lib/std/special/compiler_rt/fixsfdi_test.zig +++ b/lib/std/special/compiler_rt/fixsfdi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixsfdi(a: f32, expected: i64) void { +fn test__fixsfdi(a: f32, expected: i64) !void { const x = __fixsfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)}); try testing.expect(x == expected); @@ -17,56 +17,56 @@ fn test__fixsfdi(a: f32, expected: i64) void { test "fixsfdi" { //warn("\n", .{}); - test__fixsfdi(-math.f32_max, math.minInt(i64)); + try test__fixsfdi(-math.f32_max, math.minInt(i64)); - test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000); - test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); + try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000); - test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); - test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); + try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); - test__fixsfdi(-2.01, -2); - test__fixsfdi(-2.0, -2); - test__fixsfdi(-1.99, -1); - test__fixsfdi(-1.0, -1); - test__fixsfdi(-0.99, 0); - test__fixsfdi(-0.5, 0); - test__fixsfdi(-math.f32_min, 0); - test__fixsfdi(0.0, 0); - test__fixsfdi(math.f32_min, 0); - test__fixsfdi(0.5, 0); - test__fixsfdi(0.99, 0); - test__fixsfdi(1.0, 1); - test__fixsfdi(1.5, 1); - test__fixsfdi(1.99, 1); - test__fixsfdi(2.0, 2); - test__fixsfdi(2.01, 2); + try test__fixsfdi(-2.01, -2); + try test__fixsfdi(-2.0, -2); + try test__fixsfdi(-1.99, -1); + try test__fixsfdi(-1.0, -1); + try test__fixsfdi(-0.99, 0); + try test__fixsfdi(-0.5, 0); + try test__fixsfdi(-math.f32_min, 0); + try test__fixsfdi(0.0, 0); + try test__fixsfdi(math.f32_min, 0); + try test__fixsfdi(0.5, 0); + try test__fixsfdi(0.99, 0); + try test__fixsfdi(1.0, 1); + try test__fixsfdi(1.5, 1); + try test__fixsfdi(1.99, 1); + try test__fixsfdi(2.0, 2); + try test__fixsfdi(2.01, 2); - test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - test__fixsfdi(math.f64_max, math.maxInt(i64)); + try test__fixsfdi(math.f64_max, math.maxInt(i64)); } diff --git a/lib/std/special/compiler_rt/fixsfsi_test.zig b/lib/std/special/compiler_rt/fixsfsi_test.zig index ac01e884ce..6bc451a697 100644 --- a/lib/std/special/compiler_rt/fixsfsi_test.zig +++ b/lib/std/special/compiler_rt/fixsfsi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixsfsi(a: f32, expected: i32) void { +fn test__fixsfsi(a: f32, expected: i32) !void { const x = __fixsfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)}); try testing.expect(x == expected); @@ -17,64 +17,64 @@ fn test__fixsfsi(a: f32, expected: i32) void { test "fixsfsi" { //warn("\n", .{}); - test__fixsfsi(-math.f32_max, math.minInt(i32)); + try test__fixsfsi(-math.f32_max, math.minInt(i32)); - test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - test__fixsfsi(-0x1.0000000000000p+127, -0x80000000); - test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - test__fixsfsi(-0x1.0000000000001p+63, -0x80000000); - test__fixsfsi(-0x1.0000000000000p+63, -0x80000000); - test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000); - test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000); + try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000); - test__fixsfsi(-0x1.000000p+31, -0x80000000); - test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000); - test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); + try test__fixsfsi(-0x1.000000p+31, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000); + try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); - test__fixsfsi(-2.01, -2); - test__fixsfsi(-2.0, -2); - test__fixsfsi(-1.99, -1); - test__fixsfsi(-1.0, -1); - test__fixsfsi(-0.99, 0); - test__fixsfsi(-0.5, 0); - test__fixsfsi(-math.f32_min, 0); - test__fixsfsi(0.0, 0); - test__fixsfsi(math.f32_min, 0); - test__fixsfsi(0.5, 0); - test__fixsfsi(0.99, 0); - test__fixsfsi(1.0, 1); - test__fixsfsi(1.5, 1); - test__fixsfsi(1.99, 1); - test__fixsfsi(2.0, 2); - test__fixsfsi(2.01, 2); + try test__fixsfsi(-2.01, -2); + try test__fixsfsi(-2.0, -2); + try test__fixsfsi(-1.99, -1); + try test__fixsfsi(-1.0, -1); + try test__fixsfsi(-0.99, 0); + try test__fixsfsi(-0.5, 0); + try test__fixsfsi(-math.f32_min, 0); + try test__fixsfsi(0.0, 0); + try test__fixsfsi(math.f32_min, 0); + try test__fixsfsi(0.5, 0); + try test__fixsfsi(0.99, 0); + try test__fixsfsi(1.0, 1); + try test__fixsfsi(1.5, 1); + try test__fixsfsi(1.99, 1); + try test__fixsfsi(2.0, 2); + try test__fixsfsi(2.01, 2); - test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF); - test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF); + try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - test__fixsfsi(math.f32_max, math.maxInt(i32)); + try test__fixsfsi(math.f32_max, math.maxInt(i32)); } diff --git a/lib/std/special/compiler_rt/fixsfti_test.zig b/lib/std/special/compiler_rt/fixsfti_test.zig index f99a92b03c..792716d5d3 100644 --- a/lib/std/special/compiler_rt/fixsfti_test.zig +++ b/lib/std/special/compiler_rt/fixsfti_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixsfti(a: f32, expected: i128) void { +fn test__fixsfti(a: f32, expected: i128) !void { const x = __fixsfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)}); try testing.expect(x == expected); @@ -17,72 +17,72 @@ fn test__fixsfti(a: f32, expected: i128) void { test "fixsfti" { //warn("\n", .{}); - test__fixsfti(-math.f32_max, math.minInt(i128)); + try test__fixsfti(-math.f32_max, math.minInt(i128)); - test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000); - test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000); - test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000); - test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000); - test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000); + try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000); + try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000); - test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000); - test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); - test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); + try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); - test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000); - test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - test__fixsfti(-0x1.000000p+31, -0x80000000); - test__fixsfti(-0x1.FFFFFFp+30, -0x80000000); - test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80); - test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00); + try test__fixsfti(-0x1.000000p+31, -0x80000000); + try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000); + try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00); - test__fixsfti(-2.01, -2); - test__fixsfti(-2.0, -2); - test__fixsfti(-1.99, -1); - test__fixsfti(-1.0, -1); - test__fixsfti(-0.99, 0); - test__fixsfti(-0.5, 0); - test__fixsfti(-math.f32_min, 0); - test__fixsfti(0.0, 0); - test__fixsfti(math.f32_min, 0); - test__fixsfti(0.5, 0); - test__fixsfti(0.99, 0); - test__fixsfti(1.0, 1); - test__fixsfti(1.5, 1); - test__fixsfti(1.99, 1); - test__fixsfti(2.0, 2); - test__fixsfti(2.01, 2); + try test__fixsfti(-2.01, -2); + try test__fixsfti(-2.0, -2); + try test__fixsfti(-1.99, -1); + try test__fixsfti(-1.0, -1); + try test__fixsfti(-0.99, 0); + try test__fixsfti(-0.5, 0); + try test__fixsfti(-math.f32_min, 0); + try test__fixsfti(0.0, 0); + try test__fixsfti(math.f32_min, 0); + try test__fixsfti(0.5, 0); + try test__fixsfti(0.99, 0); + try test__fixsfti(1.0, 1); + try test__fixsfti(1.5, 1); + try test__fixsfti(1.99, 1); + try test__fixsfti(2.0, 2); + try test__fixsfti(2.01, 2); - test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixsfti(0x1.FFFFFFp+30, 0x80000000); - test__fixsfti(0x1.000000p+31, 0x80000000); + try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixsfti(0x1.FFFFFFp+30, 0x80000000); + try test__fixsfti(0x1.000000p+31, 0x80000000); - test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000); + try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000); - test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000); - test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000); - test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000); - test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000); + try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000); + try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000); - test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000); - test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000); - test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000); + try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000); + try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - test__fixsfti(math.f32_max, math.maxInt(i128)); + try test__fixsfti(math.f32_max, math.maxInt(i128)); } diff --git a/lib/std/special/compiler_rt/fixtfdi_test.zig b/lib/std/special/compiler_rt/fixtfdi_test.zig index c5079379bf..ef72e6527c 100644 --- a/lib/std/special/compiler_rt/fixtfdi_test.zig +++ b/lib/std/special/compiler_rt/fixtfdi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixtfdi(a: f128, expected: i64) void { +fn test__fixtfdi(a: f128, expected: i64) !void { const x = __fixtfdi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)}); try testing.expect(x == expected); @@ -17,64 +17,64 @@ fn test__fixtfdi(a: f128, expected: i64) void { test "fixtfdi" { //warn("\n", .{}); - test__fixtfdi(-math.f128_max, math.minInt(i64)); + try test__fixtfdi(-math.f128_max, math.minInt(i64)); - test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000); - test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000); - test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000); - test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000); + try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000); + try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000); - test__fixtfdi(-0x1.000000p+31, -0x80000000); - test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80); - test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00); + try test__fixtfdi(-0x1.000000p+31, -0x80000000); + try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00); - test__fixtfdi(-2.01, -2); - test__fixtfdi(-2.0, -2); - test__fixtfdi(-1.99, -1); - test__fixtfdi(-1.0, -1); - test__fixtfdi(-0.99, 0); - test__fixtfdi(-0.5, 0); - test__fixtfdi(-math.f64_min, 0); - test__fixtfdi(0.0, 0); - test__fixtfdi(math.f64_min, 0); - test__fixtfdi(0.5, 0); - test__fixtfdi(0.99, 0); - test__fixtfdi(1.0, 1); - test__fixtfdi(1.5, 1); - test__fixtfdi(1.99, 1); - test__fixtfdi(2.0, 2); - test__fixtfdi(2.01, 2); + try test__fixtfdi(-2.01, -2); + try test__fixtfdi(-2.0, -2); + try test__fixtfdi(-1.99, -1); + try test__fixtfdi(-1.0, -1); + try test__fixtfdi(-0.99, 0); + try test__fixtfdi(-0.5, 0); + try test__fixtfdi(-math.f64_min, 0); + try test__fixtfdi(0.0, 0); + try test__fixtfdi(math.f64_min, 0); + try test__fixtfdi(0.5, 0); + try test__fixtfdi(0.99, 0); + try test__fixtfdi(1.0, 1); + try test__fixtfdi(1.5, 1); + try test__fixtfdi(1.99, 1); + try test__fixtfdi(2.0, 2); + try test__fixtfdi(2.01, 2); - test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0); - test__fixtfdi(0x1.000000p+31, 0x80000000); + try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixtfdi(0x1.000000p+31, 0x80000000); - test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - test__fixtfdi(math.f128_max, math.maxInt(i64)); + try test__fixtfdi(math.f128_max, math.maxInt(i64)); } diff --git a/lib/std/special/compiler_rt/fixtfsi_test.zig b/lib/std/special/compiler_rt/fixtfsi_test.zig index 1e21944aa8..61a963b07d 100644 --- a/lib/std/special/compiler_rt/fixtfsi_test.zig +++ b/lib/std/special/compiler_rt/fixtfsi_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixtfsi(a: f128, expected: i32) void { +fn test__fixtfsi(a: f128, expected: i32) !void { const x = __fixtfsi(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)}); try testing.expect(x == expected); @@ -17,64 +17,64 @@ fn test__fixtfsi(a: f128, expected: i32) void { test "fixtfsi" { //warn("\n", .{}); - test__fixtfsi(-math.f128_max, math.minInt(i32)); + try test__fixtfsi(-math.f128_max, math.minInt(i32)); - test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - test__fixtfsi(-0x1.0000000000000p+127, -0x80000000); - test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - test__fixtfsi(-0x1.0000000000001p+63, -0x80000000); - test__fixtfsi(-0x1.0000000000000p+63, -0x80000000); - test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000); - test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000); + try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000); - test__fixtfsi(-0x1.000000p+31, -0x80000000); - test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); + try test__fixtfsi(-0x1.000000p+31, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); - test__fixtfsi(-2.01, -2); - test__fixtfsi(-2.0, -2); - test__fixtfsi(-1.99, -1); - test__fixtfsi(-1.0, -1); - test__fixtfsi(-0.99, 0); - test__fixtfsi(-0.5, 0); - test__fixtfsi(-math.f32_min, 0); - test__fixtfsi(0.0, 0); - test__fixtfsi(math.f32_min, 0); - test__fixtfsi(0.5, 0); - test__fixtfsi(0.99, 0); - test__fixtfsi(1.0, 1); - test__fixtfsi(1.5, 1); - test__fixtfsi(1.99, 1); - test__fixtfsi(2.0, 2); - test__fixtfsi(2.01, 2); + try test__fixtfsi(-2.01, -2); + try test__fixtfsi(-2.0, -2); + try test__fixtfsi(-1.99, -1); + try test__fixtfsi(-1.0, -1); + try test__fixtfsi(-0.99, 0); + try test__fixtfsi(-0.5, 0); + try test__fixtfsi(-math.f32_min, 0); + try test__fixtfsi(0.0, 0); + try test__fixtfsi(math.f32_min, 0); + try test__fixtfsi(0.5, 0); + try test__fixtfsi(0.99, 0); + try test__fixtfsi(1.0, 1); + try test__fixtfsi(1.5, 1); + try test__fixtfsi(1.99, 1); + try test__fixtfsi(2.0, 2); + try test__fixtfsi(2.01, 2); - test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); - test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - test__fixtfsi(math.f128_max, math.maxInt(i32)); + try test__fixtfsi(math.f128_max, math.maxInt(i32)); } diff --git a/lib/std/special/compiler_rt/fixtfti_test.zig b/lib/std/special/compiler_rt/fixtfti_test.zig index ef2b02e96c..23ec67a737 100644 --- a/lib/std/special/compiler_rt/fixtfti_test.zig +++ b/lib/std/special/compiler_rt/fixtfti_test.zig @@ -9,7 +9,7 @@ const math = std.math; const testing = std.testing; const warn = std.debug.warn; -fn test__fixtfti(a: f128, expected: i128) void { +fn test__fixtfti(a: f128, expected: i128) !void { const x = __fixtfti(a); //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)}); try testing.expect(x == expected); @@ -17,54 +17,54 @@ fn test__fixtfti(a: f128, expected: i128) void { test "fixtfti" { //warn("\n", .{}); - test__fixtfti(-math.f128_max, math.minInt(i128)); + try test__fixtfti(-math.f128_max, math.minInt(i128)); - test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); - test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); + try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); - test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800); - test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000); - test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800); + try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - test__fixtfti(-2.01, -2); - test__fixtfti(-2.0, -2); - test__fixtfti(-1.99, -1); - test__fixtfti(-1.0, -1); - test__fixtfti(-0.99, 0); - test__fixtfti(-0.5, 0); - test__fixtfti(-math.f128_min, 0); - test__fixtfti(0.0, 0); - test__fixtfti(math.f128_min, 0); - test__fixtfti(0.5, 0); - test__fixtfti(0.99, 0); - test__fixtfti(1.0, 1); - test__fixtfti(1.5, 1); - test__fixtfti(1.99, 1); - test__fixtfti(2.0, 2); - test__fixtfti(2.01, 2); + try test__fixtfti(-2.01, -2); + try test__fixtfti(-2.0, -2); + try test__fixtfti(-1.99, -1); + try test__fixtfti(-1.0, -1); + try test__fixtfti(-0.99, 0); + try test__fixtfti(-0.5, 0); + try test__fixtfti(-math.f128_min, 0); + try test__fixtfti(0.0, 0); + try test__fixtfti(math.f128_min, 0); + try test__fixtfti(0.5, 0); + try test__fixtfti(0.99, 0); + try test__fixtfti(1.0, 1); + try test__fixtfti(1.5, 1); + try test__fixtfti(1.99, 1); + try test__fixtfti(2.0, 2); + try test__fixtfti(2.01, 2); - test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000); - test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800); + try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800); - test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - test__fixtfti(math.f128_max, math.maxInt(i128)); + try test__fixtfti(math.f128_max, math.maxInt(i128)); } diff --git a/lib/std/special/compiler_rt/fixunsdfdi_test.zig b/lib/std/special/compiler_rt/fixunsdfdi_test.zig index 6a9f302a54..dcccb076d4 100644 --- a/lib/std/special/compiler_rt/fixunsdfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfdi_test.zig @@ -6,7 +6,7 @@ const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi; const testing = @import("std").testing; -fn test__fixunsdfdi(a: f64, expected: u64) void { +fn test__fixunsdfdi(a: f64, expected: u64) !void { const x = __fixunsdfdi(a); try testing.expect(x == expected); } @@ -15,30 +15,30 @@ test "fixunsdfdi" { //test__fixunsdfdi(0.0, 0); //test__fixunsdfdi(0.5, 0); //test__fixunsdfdi(0.99, 0); - test__fixunsdfdi(1.0, 1); - test__fixunsdfdi(1.5, 1); - test__fixunsdfdi(1.99, 1); - test__fixunsdfdi(2.0, 2); - test__fixunsdfdi(2.01, 2); - test__fixunsdfdi(-0.5, 0); - test__fixunsdfdi(-0.99, 0); - test__fixunsdfdi(-1.0, 0); - test__fixunsdfdi(-1.5, 0); - test__fixunsdfdi(-1.99, 0); - test__fixunsdfdi(-2.0, 0); - test__fixunsdfdi(-2.01, 0); + try test__fixunsdfdi(1.0, 1); + try test__fixunsdfdi(1.5, 1); + try test__fixunsdfdi(1.99, 1); + try test__fixunsdfdi(2.0, 2); + try test__fixunsdfdi(2.01, 2); + try test__fixunsdfdi(-0.5, 0); + try test__fixunsdfdi(-0.99, 0); + try test__fixunsdfdi(-1.0, 0); + try test__fixunsdfdi(-1.5, 0); + try test__fixunsdfdi(-1.99, 0); + try test__fixunsdfdi(-2.0, 0); + try test__fixunsdfdi(-2.01, 0); - test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixunsdfdi(-0x1.FFFFFEp+62, 0); - test__fixunsdfdi(-0x1.FFFFFCp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFEp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFCp+62, 0); - test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); - test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000); - test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); + try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0); - test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0); } diff --git a/lib/std/special/compiler_rt/fixunsdfsi_test.zig b/lib/std/special/compiler_rt/fixunsdfsi_test.zig index dc71b11312..059eb208c7 100644 --- a/lib/std/special/compiler_rt/fixunsdfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfsi_test.zig @@ -6,39 +6,39 @@ const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi; const testing = @import("std").testing; -fn test__fixunsdfsi(a: f64, expected: u32) void { +fn test__fixunsdfsi(a: f64, expected: u32) !void { const x = __fixunsdfsi(a); try testing.expect(x == expected); } test "fixunsdfsi" { - test__fixunsdfsi(0.0, 0); + try test__fixunsdfsi(0.0, 0); - test__fixunsdfsi(0.5, 0); - test__fixunsdfsi(0.99, 0); - test__fixunsdfsi(1.0, 1); - test__fixunsdfsi(1.5, 1); - test__fixunsdfsi(1.99, 1); - test__fixunsdfsi(2.0, 2); - test__fixunsdfsi(2.01, 2); - test__fixunsdfsi(-0.5, 0); - test__fixunsdfsi(-0.99, 0); - test__fixunsdfsi(-1.0, 0); - test__fixunsdfsi(-1.5, 0); - test__fixunsdfsi(-1.99, 0); - test__fixunsdfsi(-2.0, 0); - test__fixunsdfsi(-2.01, 0); + try test__fixunsdfsi(0.5, 0); + try test__fixunsdfsi(0.99, 0); + try test__fixunsdfsi(1.0, 1); + try test__fixunsdfsi(1.5, 1); + try test__fixunsdfsi(1.99, 1); + try test__fixunsdfsi(2.0, 2); + try test__fixunsdfsi(2.01, 2); + try test__fixunsdfsi(-0.5, 0); + try test__fixunsdfsi(-0.99, 0); + try test__fixunsdfsi(-1.0, 0); + try test__fixunsdfsi(-1.5, 0); + try test__fixunsdfsi(-1.99, 0); + try test__fixunsdfsi(-2.0, 0); + try test__fixunsdfsi(-2.01, 0); - test__fixunsdfsi(0x1.000000p+31, 0x80000000); - test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF); - test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00); - test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixunsdfsi(0x1.000000p+31, 0x80000000); + try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF); + try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00); + try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixunsdfsi(-0x1.FFFFFEp+30, 0); - test__fixunsdfsi(-0x1.FFFFFCp+30, 0); + try test__fixunsdfsi(-0x1.FFFFFEp+30, 0); + try test__fixunsdfsi(-0x1.FFFFFCp+30, 0); - test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF); - test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF); - test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE); + try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF); + try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF); + try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE); } diff --git a/lib/std/special/compiler_rt/fixunsdfti_test.zig b/lib/std/special/compiler_rt/fixunsdfti_test.zig index 6cecc1619e..89098afb33 100644 --- a/lib/std/special/compiler_rt/fixunsdfti_test.zig +++ b/lib/std/special/compiler_rt/fixunsdfti_test.zig @@ -6,46 +6,46 @@ const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti; const testing = @import("std").testing; -fn test__fixunsdfti(a: f64, expected: u128) void { +fn test__fixunsdfti(a: f64, expected: u128) !void { const x = __fixunsdfti(a); try testing.expect(x == expected); } test "fixunsdfti" { - test__fixunsdfti(0.0, 0); + try test__fixunsdfti(0.0, 0); - test__fixunsdfti(0.5, 0); - test__fixunsdfti(0.99, 0); - test__fixunsdfti(1.0, 1); - test__fixunsdfti(1.5, 1); - test__fixunsdfti(1.99, 1); - test__fixunsdfti(2.0, 2); - test__fixunsdfti(2.01, 2); - test__fixunsdfti(-0.5, 0); - test__fixunsdfti(-0.99, 0); - test__fixunsdfti(-1.0, 0); - test__fixunsdfti(-1.5, 0); - test__fixunsdfti(-1.99, 0); - test__fixunsdfti(-2.0, 0); - test__fixunsdfti(-2.01, 0); + try test__fixunsdfti(0.5, 0); + try test__fixunsdfti(0.99, 0); + try test__fixunsdfti(1.0, 1); + try test__fixunsdfti(1.5, 1); + try test__fixunsdfti(1.99, 1); + try test__fixunsdfti(2.0, 2); + try test__fixunsdfti(2.01, 2); + try test__fixunsdfti(-0.5, 0); + try test__fixunsdfti(-0.99, 0); + try test__fixunsdfti(-1.0, 0); + try test__fixunsdfti(-1.5, 0); + try test__fixunsdfti(-1.99, 0); + try test__fixunsdfti(-2.0, 0); + try test__fixunsdfti(-2.01, 0); - test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixunsdfti(-0x1.FFFFFEp+62, 0); - test__fixunsdfti(-0x1.FFFFFCp+62, 0); + try test__fixunsdfti(-0x1.FFFFFEp+62, 0); + try test__fixunsdfti(-0x1.FFFFFCp+62, 0); - test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); - test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000); - test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); + try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000); - test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000); - test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000); + try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0); - test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0); + try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0); } diff --git a/lib/std/special/compiler_rt/fixunssfdi_test.zig b/lib/std/special/compiler_rt/fixunssfdi_test.zig index 0b5ca1a18f..005e005a9b 100644 --- a/lib/std/special/compiler_rt/fixunssfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunssfdi_test.zig @@ -6,35 +6,35 @@ const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi; const testing = @import("std").testing; -fn test__fixunssfdi(a: f32, expected: u64) void { +fn test__fixunssfdi(a: f32, expected: u64) !void { const x = __fixunssfdi(a); try testing.expect(x == expected); } test "fixunssfdi" { - test__fixunssfdi(0.0, 0); + try test__fixunssfdi(0.0, 0); - test__fixunssfdi(0.5, 0); - test__fixunssfdi(0.99, 0); - test__fixunssfdi(1.0, 1); - test__fixunssfdi(1.5, 1); - test__fixunssfdi(1.99, 1); - test__fixunssfdi(2.0, 2); - test__fixunssfdi(2.01, 2); - test__fixunssfdi(-0.5, 0); - test__fixunssfdi(-0.99, 0); + try test__fixunssfdi(0.5, 0); + try test__fixunssfdi(0.99, 0); + try test__fixunssfdi(1.0, 1); + try test__fixunssfdi(1.5, 1); + try test__fixunssfdi(1.99, 1); + try test__fixunssfdi(2.0, 2); + try test__fixunssfdi(2.01, 2); + try test__fixunssfdi(-0.5, 0); + try test__fixunssfdi(-0.99, 0); - test__fixunssfdi(-1.0, 0); - test__fixunssfdi(-1.5, 0); - test__fixunssfdi(-1.99, 0); - test__fixunssfdi(-2.0, 0); - test__fixunssfdi(-2.01, 0); + try test__fixunssfdi(-1.0, 0); + try test__fixunssfdi(-1.5, 0); + try test__fixunssfdi(-1.99, 0); + try test__fixunssfdi(-2.0, 0); + try test__fixunssfdi(-2.01, 0); - test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000); - test__fixunssfdi(0x1.000000p+63, 0x8000000000000000); - test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000); + try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000); + try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000); - test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000); + try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000); + try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000); } diff --git a/lib/std/special/compiler_rt/fixunssfsi_test.zig b/lib/std/special/compiler_rt/fixunssfsi_test.zig index 608dd59ff5..90cb202230 100644 --- a/lib/std/special/compiler_rt/fixunssfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunssfsi_test.zig @@ -6,36 +6,36 @@ const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi; const testing = @import("std").testing; -fn test__fixunssfsi(a: f32, expected: u32) void { +fn test__fixunssfsi(a: f32, expected: u32) !void { const x = __fixunssfsi(a); try testing.expect(x == expected); } test "fixunssfsi" { - test__fixunssfsi(0.0, 0); + try test__fixunssfsi(0.0, 0); - test__fixunssfsi(0.5, 0); - test__fixunssfsi(0.99, 0); - test__fixunssfsi(1.0, 1); - test__fixunssfsi(1.5, 1); - test__fixunssfsi(1.99, 1); - test__fixunssfsi(2.0, 2); - test__fixunssfsi(2.01, 2); - test__fixunssfsi(-0.5, 0); - test__fixunssfsi(-0.99, 0); + try test__fixunssfsi(0.5, 0); + try test__fixunssfsi(0.99, 0); + try test__fixunssfsi(1.0, 1); + try test__fixunssfsi(1.5, 1); + try test__fixunssfsi(1.99, 1); + try test__fixunssfsi(2.0, 2); + try test__fixunssfsi(2.01, 2); + try test__fixunssfsi(-0.5, 0); + try test__fixunssfsi(-0.99, 0); - test__fixunssfsi(-1.0, 0); - test__fixunssfsi(-1.5, 0); - test__fixunssfsi(-1.99, 0); - test__fixunssfsi(-2.0, 0); - test__fixunssfsi(-2.01, 0); + try test__fixunssfsi(-1.0, 0); + try test__fixunssfsi(-1.5, 0); + try test__fixunssfsi(-1.99, 0); + try test__fixunssfsi(-2.0, 0); + try test__fixunssfsi(-2.01, 0); - test__fixunssfsi(0x1.000000p+31, 0x80000000); - test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF); - test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00); - test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixunssfsi(0x1.000000p+31, 0x80000000); + try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF); + try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00); + try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - test__fixunssfsi(-0x1.FFFFFEp+30, 0); - test__fixunssfsi(-0x1.FFFFFCp+30, 0); + try test__fixunssfsi(-0x1.FFFFFEp+30, 0); + try test__fixunssfsi(-0x1.FFFFFCp+30, 0); } diff --git a/lib/std/special/compiler_rt/fixunssfti_test.zig b/lib/std/special/compiler_rt/fixunssfti_test.zig index 5ba5b98d63..6dabae8ba8 100644 --- a/lib/std/special/compiler_rt/fixunssfti_test.zig +++ b/lib/std/special/compiler_rt/fixunssfti_test.zig @@ -6,41 +6,41 @@ const __fixunssfti = @import("fixunssfti.zig").__fixunssfti; const testing = @import("std").testing; -fn test__fixunssfti(a: f32, expected: u128) void { +fn test__fixunssfti(a: f32, expected: u128) !void { const x = __fixunssfti(a); try testing.expect(x == expected); } test "fixunssfti" { - test__fixunssfti(0.0, 0); + try test__fixunssfti(0.0, 0); - test__fixunssfti(0.5, 0); - test__fixunssfti(0.99, 0); - test__fixunssfti(1.0, 1); - test__fixunssfti(1.5, 1); - test__fixunssfti(1.99, 1); - test__fixunssfti(2.0, 2); - test__fixunssfti(2.01, 2); - test__fixunssfti(-0.5, 0); - test__fixunssfti(-0.99, 0); + try test__fixunssfti(0.5, 0); + try test__fixunssfti(0.99, 0); + try test__fixunssfti(1.0, 1); + try test__fixunssfti(1.5, 1); + try test__fixunssfti(1.99, 1); + try test__fixunssfti(2.0, 2); + try test__fixunssfti(2.01, 2); + try test__fixunssfti(-0.5, 0); + try test__fixunssfti(-0.99, 0); - test__fixunssfti(-1.0, 0); - test__fixunssfti(-1.5, 0); - test__fixunssfti(-1.99, 0); - test__fixunssfti(-2.0, 0); - test__fixunssfti(-2.01, 0); + try test__fixunssfti(-1.0, 0); + try test__fixunssfti(-1.5, 0); + try test__fixunssfti(-1.99, 0); + try test__fixunssfti(-2.0, 0); + try test__fixunssfti(-2.01, 0); - test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000); - test__fixunssfti(0x1.000000p+63, 0x8000000000000000); - test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000); - test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000); - test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000); - test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000); + try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000); + try test__fixunssfti(0x1.000000p+63, 0x8000000000000000); + try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000); + try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000); + try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000); + try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000); - test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000); - test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000); - test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000); - test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000); } diff --git a/lib/std/special/compiler_rt/fixunstfdi_test.zig b/lib/std/special/compiler_rt/fixunstfdi_test.zig index 3d832b35d0..7102203cc0 100644 --- a/lib/std/special/compiler_rt/fixunstfdi_test.zig +++ b/lib/std/special/compiler_rt/fixunstfdi_test.zig @@ -6,49 +6,49 @@ const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi; const testing = @import("std").testing; -fn test__fixunstfdi(a: f128, expected: u64) void { +fn test__fixunstfdi(a: f128, expected: u64) !void { const x = __fixunstfdi(a); try testing.expect(x == expected); } test "fixunstfdi" { - test__fixunstfdi(0.0, 0); + try test__fixunstfdi(0.0, 0); - test__fixunstfdi(0.5, 0); - test__fixunstfdi(0.99, 0); - test__fixunstfdi(1.0, 1); - test__fixunstfdi(1.5, 1); - test__fixunstfdi(1.99, 1); - test__fixunstfdi(2.0, 2); - test__fixunstfdi(2.01, 2); - test__fixunstfdi(-0.5, 0); - test__fixunstfdi(-0.99, 0); - test__fixunstfdi(-1.0, 0); - test__fixunstfdi(-1.5, 0); - test__fixunstfdi(-1.99, 0); - test__fixunstfdi(-2.0, 0); - test__fixunstfdi(-2.01, 0); + try test__fixunstfdi(0.5, 0); + try test__fixunstfdi(0.99, 0); + try test__fixunstfdi(1.0, 1); + try test__fixunstfdi(1.5, 1); + try test__fixunstfdi(1.99, 1); + try test__fixunstfdi(2.0, 2); + try test__fixunstfdi(2.01, 2); + try test__fixunstfdi(-0.5, 0); + try test__fixunstfdi(-0.99, 0); + try test__fixunstfdi(-1.0, 0); + try test__fixunstfdi(-1.5, 0); + try test__fixunstfdi(-1.99, 0); + try test__fixunstfdi(-2.0, 0); + try test__fixunstfdi(-2.01, 0); - test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - test__fixunstfdi(-0x1.FFFFFEp+62, 0); - test__fixunstfdi(-0x1.FFFFFCp+62, 0); + try test__fixunstfdi(-0x1.FFFFFEp+62, 0); + try test__fixunstfdi(-0x1.FFFFFCp+62, 0); - test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0); - test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0); - test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF); - test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001); - test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000); - test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF); - test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE); - test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF); + try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001); + try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE); + try test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF); - test__fixunstfdi(-0x1.0000000000000000p+63, 0); - test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0); - test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0); + try test__fixunstfdi(-0x1.0000000000000000p+63, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0); } diff --git a/lib/std/special/compiler_rt/fixunstfsi_test.zig b/lib/std/special/compiler_rt/fixunstfsi_test.zig index e2aa597d9c..9173b01f46 100644 --- a/lib/std/special/compiler_rt/fixunstfsi_test.zig +++ b/lib/std/special/compiler_rt/fixunstfsi_test.zig @@ -6,7 +6,7 @@ const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi; const testing = @import("std").testing; -fn test__fixunstfsi(a: f128, expected: u32) void { +fn test__fixunstfsi(a: f128, expected: u32) !void { const x = __fixunstfsi(a); try testing.expect(x == expected); } @@ -14,14 +14,14 @@ fn test__fixunstfsi(a: f128, expected: u32) void { const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); test "fixunstfsi" { - test__fixunstfsi(inf128, 0xffffffff); - test__fixunstfsi(0, 0x0); - test__fixunstfsi(0x1.23456789abcdefp+5, 0x24); - test__fixunstfsi(0x1.23456789abcdefp-3, 0x0); - test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456); - test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff); - test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff); - test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0); + try test__fixunstfsi(inf128, 0xffffffff); + try test__fixunstfsi(0, 0x0); + try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24); + try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0); + try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456); + try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff); + try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff); + try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0); - test__fixunstfsi(0x1.p+32, 0xFFFFFFFF); + try test__fixunstfsi(0x1.p+32, 0xFFFFFFFF); } diff --git a/lib/std/special/compiler_rt/fixunstfti_test.zig b/lib/std/special/compiler_rt/fixunstfti_test.zig index bc3ee0be24..450b07b524 100644 --- a/lib/std/special/compiler_rt/fixunstfti_test.zig +++ b/lib/std/special/compiler_rt/fixunstfti_test.zig @@ -6,7 +6,7 @@ const __fixunstfti = @import("fixunstfti.zig").__fixunstfti; const testing = @import("std").testing; -fn test__fixunstfti(a: f128, expected: u128) void { +fn test__fixunstfti(a: f128, expected: u128) !void { const x = __fixunstfti(a); try testing.expect(x == expected); } @@ -14,24 +14,24 @@ fn test__fixunstfti(a: f128, expected: u128) void { const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); test "fixunstfti" { - test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff); + try test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff); - test__fixunstfti(0.0, 0); + try test__fixunstfti(0.0, 0); - test__fixunstfti(0.5, 0); - test__fixunstfti(0.99, 0); - test__fixunstfti(1.0, 1); - test__fixunstfti(1.5, 1); - test__fixunstfti(1.99, 1); - test__fixunstfti(2.0, 2); - test__fixunstfti(2.01, 2); - test__fixunstfti(-0.01, 0); - test__fixunstfti(-0.99, 0); + try test__fixunstfti(0.5, 0); + try test__fixunstfti(0.99, 0); + try test__fixunstfti(1.0, 1); + try test__fixunstfti(1.5, 1); + try test__fixunstfti(1.99, 1); + try test__fixunstfti(2.0, 2); + try test__fixunstfti(2.01, 2); + try test__fixunstfti(-0.01, 0); + try test__fixunstfti(-0.99, 0); - test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff); + try test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff); - test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000); - test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000); - test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff); - test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff); + try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000); + try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000); + try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff); + try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff); } diff --git a/lib/std/special/compiler_rt/floatdidf_test.zig b/lib/std/special/compiler_rt/floatdidf_test.zig index 85d79bff3c..d20e6b39aa 100644 --- a/lib/std/special/compiler_rt/floatdidf_test.zig +++ b/lib/std/special/compiler_rt/floatdidf_test.zig @@ -6,53 +6,53 @@ const __floatdidf = @import("floatdidf.zig").__floatdidf; const testing = @import("std").testing; -fn test__floatdidf(a: i64, expected: f64) void { +fn test__floatdidf(a: i64, expected: f64) !void { const r = __floatdidf(a); try testing.expect(r == expected); } test "floatdidf" { - test__floatdidf(0, 0.0); - test__floatdidf(1, 1.0); - test__floatdidf(2, 2.0); - test__floatdidf(20, 20.0); - test__floatdidf(-1, -1.0); - test__floatdidf(-2, -2.0); - test__floatdidf(-20, -20.0); - test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63); - test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); - test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0, 0.0); + try test__floatdidf(1, 1.0); + try test__floatdidf(2, 2.0); + try test__floatdidf(20, 20.0); + try test__floatdidf(-1, -1.0); + try test__floatdidf(-2, -2.0); + try test__floatdidf(-20, -20.0); + try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); + try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); } diff --git a/lib/std/special/compiler_rt/floatdisf_test.zig b/lib/std/special/compiler_rt/floatdisf_test.zig index c16481b3dd..a90326e943 100644 --- a/lib/std/special/compiler_rt/floatdisf_test.zig +++ b/lib/std/special/compiler_rt/floatdisf_test.zig @@ -6,32 +6,32 @@ const __floatdisf = @import("floatXisf.zig").__floatdisf; const testing = @import("std").testing; -fn test__floatdisf(a: i64, expected: f32) void { +fn test__floatdisf(a: i64, expected: f32) !void { const x = __floatdisf(a); try testing.expect(x == expected); } test "floatdisf" { - test__floatdisf(0, 0.0); - test__floatdisf(1, 1.0); - test__floatdisf(2, 2.0); - test__floatdisf(-1, -1.0); - test__floatdisf(-2, -2.0); - test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62); - test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62); - test__floatdisf(0x8000000000000000, -0x1.000000p+63); - test__floatdisf(0x8000000000000001, -0x1.000000p+63); - test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + try test__floatdisf(0, 0.0); + try test__floatdisf(1, 1.0); + try test__floatdisf(2, 2.0); + try test__floatdisf(-1, -1.0); + try test__floatdisf(-2, -2.0); + try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62); + try test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62); + try test__floatdisf(0x8000000000000000, -0x1.000000p+63); + try test__floatdisf(0x8000000000000001, -0x1.000000p+63); + try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); } diff --git a/lib/std/special/compiler_rt/floatditf_test.zig b/lib/std/special/compiler_rt/floatditf_test.zig index 82df9158e0..bec8384dce 100644 --- a/lib/std/special/compiler_rt/floatditf_test.zig +++ b/lib/std/special/compiler_rt/floatditf_test.zig @@ -6,21 +6,21 @@ const __floatditf = @import("floatditf.zig").__floatditf; const testing = @import("std").testing; -fn test__floatditf(a: i64, expected: f128) void { +fn test__floatditf(a: i64, expected: f128) !void { const x = __floatditf(a); try testing.expect(x == expected); } test "floatditf" { - test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000)); - test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000)); - test__floatditf(0x2, make_ti(0x4000000000000000, 0x0)); - test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0)); - test__floatditf(0x0, make_ti(0x0, 0x0)); - test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0)); - test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0)); - test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000)); - test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0)); + try test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000)); + try test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000)); + try test__floatditf(0x2, make_ti(0x4000000000000000, 0x0)); + try test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0)); + try test__floatditf(0x0, make_ti(0x0, 0x0)); + try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0)); + try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0)); + try test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000)); + try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0)); } fn make_ti(high: u64, low: u64) f128 { diff --git a/lib/std/special/compiler_rt/floatsiXf.zig b/lib/std/special/compiler_rt/floatsiXf.zig index 3f36f8dea0..91e52ac50a 100644 --- a/lib/std/special/compiler_rt/floatsiXf.zig +++ b/lib/std/special/compiler_rt/floatsiXf.zig @@ -84,42 +84,42 @@ pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 { return @call(.{ .modifier = .always_inline }, __floatsisf, .{arg}); } -fn test_one_floatsitf(a: i32, expected: u128) void { +fn test_one_floatsitf(a: i32, expected: u128) !void { const r = __floatsitf(a); try std.testing.expect(@bitCast(u128, r) == expected); } -fn test_one_floatsidf(a: i32, expected: u64) void { +fn test_one_floatsidf(a: i32, expected: u64) !void { const r = __floatsidf(a); try std.testing.expect(@bitCast(u64, r) == expected); } -fn test_one_floatsisf(a: i32, expected: u32) void { +fn test_one_floatsisf(a: i32, expected: u32) !void { const r = __floatsisf(a); try std.testing.expect(@bitCast(u32, r) == expected); } test "floatsidf" { - test_one_floatsidf(0, 0x0000000000000000); - test_one_floatsidf(1, 0x3ff0000000000000); - test_one_floatsidf(-1, 0xbff0000000000000); - test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000); - test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000); + try test_one_floatsidf(0, 0x0000000000000000); + try test_one_floatsidf(1, 0x3ff0000000000000); + try test_one_floatsidf(-1, 0xbff0000000000000); + try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000); + try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000); } test "floatsisf" { - test_one_floatsisf(0, 0x00000000); - test_one_floatsisf(1, 0x3f800000); - test_one_floatsisf(-1, 0xbf800000); - test_one_floatsisf(0x7FFFFFFF, 0x4f000000); - test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000); + try test_one_floatsisf(0, 0x00000000); + try test_one_floatsisf(1, 0x3f800000); + try test_one_floatsisf(-1, 0xbf800000); + try test_one_floatsisf(0x7FFFFFFF, 0x4f000000); + try test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000); } test "floatsitf" { - test_one_floatsitf(0, 0); - test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); - test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000); - test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000); - test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000); - test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000); + try test_one_floatsitf(0, 0); + try test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); + try test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000); + try test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000); + try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000); + try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000); } diff --git a/lib/std/special/compiler_rt/floattidf_test.zig b/lib/std/special/compiler_rt/floattidf_test.zig index 0523b2a59b..826b73f8a1 100644 --- a/lib/std/special/compiler_rt/floattidf_test.zig +++ b/lib/std/special/compiler_rt/floattidf_test.zig @@ -6,79 +6,79 @@ const __floattidf = @import("floattidf.zig").__floattidf; const testing = @import("std").testing; -fn test__floattidf(a: i128, expected: f64) void { +fn test__floattidf(a: i128, expected: f64) !void { const x = __floattidf(a); try testing.expect(x == expected); } test "floattidf" { - test__floattidf(0, 0.0); + try test__floattidf(0, 0.0); - test__floattidf(1, 1.0); - test__floattidf(2, 2.0); - test__floattidf(20, 20.0); - test__floattidf(-1, -1.0); - test__floattidf(-2, -2.0); - test__floattidf(-20, -20.0); + try test__floattidf(1, 1.0); + try test__floattidf(2, 2.0); + try test__floattidf(20, 20.0); + try test__floattidf(-1, -1.0); + try test__floattidf(-2, -2.0); + try test__floattidf(-20, -20.0); - test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); - test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); - test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); - test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); + try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); + try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); + try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); + try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); - test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); - test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127); + try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); + try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127); - test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); - test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); - test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); - test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); - test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); - test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); + try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); } fn make_ti(high: u64, low: u64) i128 { diff --git a/lib/std/special/compiler_rt/floattisf_test.zig b/lib/std/special/compiler_rt/floattisf_test.zig index 88f0989f18..28df0b54ea 100644 --- a/lib/std/special/compiler_rt/floattisf_test.zig +++ b/lib/std/special/compiler_rt/floattisf_test.zig @@ -6,55 +6,55 @@ const __floattisf = @import("floatXisf.zig").__floattisf; const testing = @import("std").testing; -fn test__floattisf(a: i128, expected: f32) void { +fn test__floattisf(a: i128, expected: f32) !void { const x = __floattisf(a); try testing.expect(x == expected); } test "floattisf" { - test__floattisf(0, 0.0); + try test__floattisf(0, 0.0); - test__floattisf(1, 1.0); - test__floattisf(2, 2.0); - test__floattisf(-1, -1.0); - test__floattisf(-2, -2.0); + try test__floattisf(1, 1.0); + try test__floattisf(2, 2.0); + try test__floattisf(-1, -1.0); + try test__floattisf(-2, -2.0); - test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); - test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); - test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); - test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); - test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); - test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); - test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); + try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); - test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); + try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); } fn make_ti(high: u64, low: u64) i128 { diff --git a/lib/std/special/compiler_rt/floattitf_test.zig b/lib/std/special/compiler_rt/floattitf_test.zig index 0650665e4f..cf0aa138a9 100644 --- a/lib/std/special/compiler_rt/floattitf_test.zig +++ b/lib/std/special/compiler_rt/floattitf_test.zig @@ -6,91 +6,91 @@ const __floattitf = @import("floattitf.zig").__floattitf; const testing = @import("std").testing; -fn test__floattitf(a: i128, expected: f128) void { +fn test__floattitf(a: i128, expected: f128) !void { const x = __floattitf(a); try testing.expect(x == expected); } test "floattitf" { - test__floattitf(0, 0.0); + try test__floattitf(0, 0.0); - test__floattitf(1, 1.0); - test__floattitf(2, 2.0); - test__floattitf(20, 20.0); - test__floattitf(-1, -1.0); - test__floattitf(-2, -2.0); - test__floattitf(-20, -20.0); + try test__floattitf(1, 1.0); + try test__floattitf(2, 2.0); + try test__floattitf(20, 20.0); + try test__floattitf(-1, -1.0); + try test__floattitf(-2, -2.0); + try test__floattitf(-20, -20.0); - test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); - test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); - test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); - test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); + try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); + try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); + try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); + try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); - test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); - test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); + try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); + try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); - test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); - test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); - test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); - test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); - test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); - test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); - test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); - test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); - test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); - test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); - test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); - test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); - test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); - test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); + try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); + try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); + try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); + try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); + try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); + try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); + try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); + try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); + try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); + try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); + try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); + try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); + try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); - test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); - test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); - test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); - test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); - test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); - test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); - test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); - test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); - test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); - test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); - test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); - test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); - test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); + try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); + try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); + try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); + try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); + try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); + try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); + try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); + try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); + try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); + try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); + try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); + try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); + try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); - test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); + try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); - test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); } fn make_ti(high: u64, low: u64) i128 { diff --git a/lib/std/special/compiler_rt/floatundidf_test.zig b/lib/std/special/compiler_rt/floatundidf_test.zig index 5c92d74106..3094396326 100644 --- a/lib/std/special/compiler_rt/floatundidf_test.zig +++ b/lib/std/special/compiler_rt/floatundidf_test.zig @@ -6,50 +6,50 @@ const __floatundidf = @import("floatundidf.zig").__floatundidf; const testing = @import("std").testing; -fn test__floatundidf(a: u64, expected: f64) void { +fn test__floatundidf(a: u64, expected: f64) !void { const r = __floatundidf(a); try testing.expect(r == expected); } test "floatundidf" { - test__floatundidf(0, 0.0); - test__floatundidf(1, 1.0); - test__floatundidf(2, 2.0); - test__floatundidf(20, 20.0); - test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floatundidf(0x8000008000000000, 0x1.000001p+63); - test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63); - test__floatundidf(0x8000010000000000, 0x1.000002p+63); - test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63); - test__floatundidf(0x8000000000000000, 0x1p+63); - test__floatundidf(0x8000000000000001, 0x1p+63); - test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0, 0.0); + try test__floatundidf(1, 1.0); + try test__floatundidf(2, 2.0); + try test__floatundidf(20, 20.0); + try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatundidf(0x8000008000000000, 0x1.000001p+63); + try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63); + try test__floatundidf(0x8000010000000000, 0x1.000002p+63); + try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63); + try test__floatundidf(0x8000000000000000, 0x1p+63); + try test__floatundidf(0x8000000000000001, 0x1p+63); + try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); } diff --git a/lib/std/special/compiler_rt/floatundisf.zig b/lib/std/special/compiler_rt/floatundisf.zig index ac7e576316..2367416847 100644 --- a/lib/std/special/compiler_rt/floatundisf.zig +++ b/lib/std/special/compiler_rt/floatundisf.zig @@ -66,31 +66,31 @@ pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 { return @call(.{ .modifier = .always_inline }, __floatundisf, .{arg}); } -fn test__floatundisf(a: u64, expected: f32) void { - std.testing.expectEqual(expected, __floatundisf(a)); +fn test__floatundisf(a: u64, expected: f32) !void { + try std.testing.expectEqual(expected, __floatundisf(a)); } test "floatundisf" { - test__floatundisf(0, 0.0); - test__floatundisf(1, 1.0); - test__floatundisf(2, 2.0); - test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatundisf(0x8000008000000000, 0x1p+63); - test__floatundisf(0x8000010000000000, 0x1.000002p+63); - test__floatundisf(0x8000000000000000, 0x1p+63); - test__floatundisf(0x8000000000000001, 0x1p+63); - test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); - test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); - test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + try test__floatundisf(0, 0.0); + try test__floatundisf(1, 1.0); + try test__floatundisf(2, 2.0); + try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatundisf(0x8000008000000000, 0x1p+63); + try test__floatundisf(0x8000010000000000, 0x1.000002p+63); + try test__floatundisf(0x8000000000000000, 0x1p+63); + try test__floatundisf(0x8000000000000001, 0x1p+63); + try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); + try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); + try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); } diff --git a/lib/std/special/compiler_rt/floatunditf_test.zig b/lib/std/special/compiler_rt/floatunditf_test.zig index e734355589..20dca4df4e 100644 --- a/lib/std/special/compiler_rt/floatunditf_test.zig +++ b/lib/std/special/compiler_rt/floatunditf_test.zig @@ -5,7 +5,7 @@ // and substantial portions of the software. const __floatunditf = @import("floatunditf.zig").__floatunditf; -fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void { +fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void { const x = __floatunditf(a); const x_repr = @bitCast(u128, x); @@ -26,12 +26,12 @@ fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void { } test "floatunditf" { - test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); - test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); - test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0); - test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); - test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); - test__floatunditf(0x2, 0x4000000000000000, 0x0); - test__floatunditf(0x1, 0x3fff000000000000, 0x0); - test__floatunditf(0x0, 0x0, 0x0); + try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); + try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); + try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0); + try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); + try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); + try test__floatunditf(0x2, 0x4000000000000000, 0x0); + try test__floatunditf(0x1, 0x3fff000000000000, 0x0); + try test__floatunditf(0x0, 0x0, 0x0); } diff --git a/lib/std/special/compiler_rt/floatunsidf.zig b/lib/std/special/compiler_rt/floatunsidf.zig index c97cc6ae47..e3f54e8042 100644 --- a/lib/std/special/compiler_rt/floatunsidf.zig +++ b/lib/std/special/compiler_rt/floatunsidf.zig @@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 { return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg}); } -fn test_one_floatunsidf(a: u32, expected: u64) void { +fn test_one_floatunsidf(a: u32, expected: u64) !void { const r = __floatunsidf(a); try std.testing.expect(@bitCast(u64, r) == expected); } test "floatsidf" { // Test the produced bit pattern - test_one_floatunsidf(0, 0x0000000000000000); - test_one_floatunsidf(1, 0x3ff0000000000000); - test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000); - test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000); - test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000); + try test_one_floatunsidf(0, 0x0000000000000000); + try test_one_floatunsidf(1, 0x3ff0000000000000); + try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000); + try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000); + try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000); } diff --git a/lib/std/special/compiler_rt/floatunsisf.zig b/lib/std/special/compiler_rt/floatunsisf.zig index d707217671..1ff11c6388 100644 --- a/lib/std/special/compiler_rt/floatunsisf.zig +++ b/lib/std/special/compiler_rt/floatunsisf.zig @@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 { return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg}); } -fn test_one_floatunsisf(a: u32, expected: u32) void { +fn test_one_floatunsisf(a: u32, expected: u32) !void { const r = __floatunsisf(a); try std.testing.expect(@bitCast(u32, r) == expected); } test "floatunsisf" { // Test the produced bit pattern - test_one_floatunsisf(0, 0); - test_one_floatunsisf(1, 0x3f800000); - test_one_floatunsisf(0x7FFFFFFF, 0x4f000000); - test_one_floatunsisf(0x80000000, 0x4f000000); - test_one_floatunsisf(0xFFFFFFFF, 0x4f800000); + try test_one_floatunsisf(0, 0); + try test_one_floatunsisf(1, 0x3f800000); + try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000); + try test_one_floatunsisf(0x80000000, 0x4f000000); + try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000); } diff --git a/lib/std/special/compiler_rt/floatunsitf_test.zig b/lib/std/special/compiler_rt/floatunsitf_test.zig index 7e7b8b69b9..4e62282422 100644 --- a/lib/std/special/compiler_rt/floatunsitf_test.zig +++ b/lib/std/special/compiler_rt/floatunsitf_test.zig @@ -5,7 +5,7 @@ // and substantial portions of the software. const __floatunsitf = @import("floatunsitf.zig").__floatunsitf; -fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void { +fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) !void { const x = __floatunsitf(a); const x_repr = @bitCast(u128, x); @@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void { } test "floatunsitf" { - test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0); - test__floatunsitf(0, 0x0, 0x0); - test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0); - test__floatunsitf(0x12345678, 0x401b234567800000, 0x0); + try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0); + try test__floatunsitf(0, 0x0, 0x0); + try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0); + try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0); } diff --git a/lib/std/special/compiler_rt/floatuntidf_test.zig b/lib/std/special/compiler_rt/floatuntidf_test.zig index 53f32d0fd7..735b5bcdbb 100644 --- a/lib/std/special/compiler_rt/floatuntidf_test.zig +++ b/lib/std/special/compiler_rt/floatuntidf_test.zig @@ -6,76 +6,76 @@ const __floatuntidf = @import("floatuntidf.zig").__floatuntidf; const testing = @import("std").testing; -fn test__floatuntidf(a: u128, expected: f64) void { +fn test__floatuntidf(a: u128, expected: f64) !void { const x = __floatuntidf(a); try testing.expect(x == expected); } test "floatuntidf" { - test__floatuntidf(0, 0.0); + try test__floatuntidf(0, 0.0); - test__floatuntidf(1, 1.0); - test__floatuntidf(2, 2.0); - test__floatuntidf(20, 20.0); + try test__floatuntidf(1, 1.0); + try test__floatuntidf(2, 2.0); + try test__floatuntidf(20, 20.0); - test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); - test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127); - test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); - test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127); + try test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); + try test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127); + try test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); + try test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127); - test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); - test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127); + try test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); + try test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127); - test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); - test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); - test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); - test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); - test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); - test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); + try test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); } fn make_ti(high: u64, low: u64) u128 { diff --git a/lib/std/special/compiler_rt/floatuntisf_test.zig b/lib/std/special/compiler_rt/floatuntisf_test.zig index 464118fe3b..5657db1c82 100644 --- a/lib/std/special/compiler_rt/floatuntisf_test.zig +++ b/lib/std/special/compiler_rt/floatuntisf_test.zig @@ -6,67 +6,67 @@ const __floatuntisf = @import("floatuntisf.zig").__floatuntisf; const testing = @import("std").testing; -fn test__floatuntisf(a: u128, expected: f32) void { +fn test__floatuntisf(a: u128, expected: f32) !void { const x = __floatuntisf(a); try testing.expect(x == expected); } test "floatuntisf" { - test__floatuntisf(0, 0.0); + try test__floatuntisf(0, 0.0); - test__floatuntisf(1, 1.0); - test__floatuntisf(2, 2.0); - test__floatuntisf(20, 20.0); + try test__floatuntisf(1, 1.0); + try test__floatuntisf(2, 2.0); + try test__floatuntisf(20, 20.0); - test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); - test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127); - test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); + try test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); + try test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127); + try test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); - test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); + try test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); - test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); - test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); + try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); + try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); - test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); - test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); + try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); } fn make_ti(high: u64, low: u64) u128 { diff --git a/lib/std/special/compiler_rt/floatuntitf_test.zig b/lib/std/special/compiler_rt/floatuntitf_test.zig index 80f7eec96b..41057aa38c 100644 --- a/lib/std/special/compiler_rt/floatuntitf_test.zig +++ b/lib/std/special/compiler_rt/floatuntitf_test.zig @@ -6,94 +6,94 @@ const __floatuntitf = @import("floatuntitf.zig").__floatuntitf; const testing = @import("std").testing; -fn test__floatuntitf(a: u128, expected: f128) void { +fn test__floatuntitf(a: u128, expected: f128) !void { const x = __floatuntitf(a); try testing.expect(x == expected); } test "floatuntitf" { - test__floatuntitf(0, 0.0); + try test__floatuntitf(0, 0.0); - test__floatuntitf(1, 1.0); - test__floatuntitf(2, 2.0); - test__floatuntitf(20, 20.0); + try test__floatuntitf(1, 1.0); + try test__floatuntitf(2, 2.0); + try test__floatuntitf(20, 20.0); - test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); - test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); - test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); + try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); + try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); + try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); - test__floatuntitf(0x8000008000000000, 0x8.000008p+60); - test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60); - test__floatuntitf(0x8000010000000000, 0x8.00001p+60); - test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60); + try test__floatuntitf(0x8000008000000000, 0x8.000008p+60); + try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60); + try test__floatuntitf(0x8000010000000000, 0x8.00001p+60); + try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60); - test__floatuntitf(0x8000000000000000, 0x8p+60); - test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60); + try test__floatuntitf(0x8000000000000000, 0x8p+60); + try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60); - test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); - test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); - test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); - test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); - test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); - test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); - test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); - test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); - test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); - test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); - test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); - test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); - test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); - test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); + try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); + try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); + try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); + try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); + try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); + try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); + try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); + try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); + try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); + try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); + try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); + try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); + try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); - test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); - test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); - test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); - test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); - test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); - test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); - test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); - test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); - test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); - test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); - test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); - test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); - test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + try test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); + try test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); + try test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); + try test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); + try test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); - test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); + try test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); - test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); - test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); + try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); + try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); - test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); } fn make_ti(high: u64, low: u64) u128 { diff --git a/lib/std/special/compiler_rt/int.zig b/lib/std/special/compiler_rt/int.zig index 1e519252a3..4533d10ab9 100644 --- a/lib/std/special/compiler_rt/int.zig +++ b/lib/std/special/compiler_rt/int.zig @@ -58,11 +58,11 @@ test "test_divdi3" { }; for (cases) |case| { - test_one_divdi3(case[0], case[1], case[2]); + try test_one_divdi3(case[0], case[1], case[2]); } } -fn test_one_divdi3(a: i64, b: i64, expected_q: i64) void { +fn test_one_divdi3(a: i64, b: i64, expected_q: i64) !void { const q: i64 = __divdi3(a, b); try testing.expect(q == expected_q); } @@ -98,11 +98,11 @@ test "test_moddi3" { }; for (cases) |case| { - test_one_moddi3(case[0], case[1], case[2]); + try test_one_moddi3(case[0], case[1], case[2]); } } -fn test_one_moddi3(a: i64, b: i64, expected_r: i64) void { +fn test_one_moddi3(a: i64, b: i64, expected_r: i64) !void { const r: i64 = __moddi3(a, b); try testing.expect(r == expected_r); } @@ -121,14 +121,14 @@ pub fn __umoddi3(a: u64, b: u64) callconv(.C) u64 { } test "test_umoddi3" { - test_one_umoddi3(0, 1, 0); - test_one_umoddi3(2, 1, 0); - test_one_umoddi3(0x8000000000000000, 1, 0x0); - test_one_umoddi3(0x8000000000000000, 2, 0x0); - test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1); + try test_one_umoddi3(0, 1, 0); + try test_one_umoddi3(2, 1, 0); + try test_one_umoddi3(0x8000000000000000, 1, 0x0); + try test_one_umoddi3(0x8000000000000000, 2, 0x0); + try test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1); } -fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) void { +fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) !void { const r = __umoddi3(a, b); try testing.expect(r == expected_r); } @@ -159,11 +159,11 @@ test "test_divmodsi4" { }; for (cases) |case| { - test_one_divmodsi4(case[0], case[1], case[2], case[3]); + try test_one_divmodsi4(case[0], case[1], case[2], case[3]); } } -fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) void { +fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) !void { var r: i32 = undefined; const q: i32 = __divmodsi4(a, b, &r); try testing.expect(q == expected_q and r == expected_r); @@ -207,11 +207,11 @@ test "test_divsi3" { }; for (cases) |case| { - test_one_divsi3(case[0], case[1], case[2]); + try test_one_divsi3(case[0], case[1], case[2]); } } -fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void { +fn test_one_divsi3(a: i32, b: i32, expected_q: i32) !void { const q: i32 = __divsi3(a, b); try testing.expect(q == expected_q); } @@ -394,11 +394,11 @@ test "test_udivsi3" { }; for (cases) |case| { - test_one_udivsi3(case[0], case[1], case[2]); + try test_one_udivsi3(case[0], case[1], case[2]); } } -fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) void { +fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) !void { const q: u32 = __udivsi3(a, b); try testing.expect(q == expected_q); } @@ -425,11 +425,11 @@ test "test_modsi3" { }; for (cases) |case| { - test_one_modsi3(case[0], case[1], case[2]); + try test_one_modsi3(case[0], case[1], case[2]); } } -fn test_one_modsi3(a: i32, b: i32, expected_r: i32) void { +fn test_one_modsi3(a: i32, b: i32, expected_r: i32) !void { const r: i32 = __modsi3(a, b); try testing.expect(r == expected_r); } @@ -577,11 +577,11 @@ test "test_umodsi3" { }; for (cases) |case| { - test_one_umodsi3(case[0], case[1], case[2]); + try test_one_umodsi3(case[0], case[1], case[2]); } } -fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) void { +fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) !void { const r: u32 = __umodsi3(a, b); try testing.expect(r == expected_r); } @@ -602,44 +602,44 @@ pub fn __mulsi3(a: i32, b: i32) callconv(.C) i32 { return @bitCast(i32, r); } -fn test_one_mulsi3(a: i32, b: i32, result: i32) void { - testing.expectEqual(result, __mulsi3(a, b)); +fn test_one_mulsi3(a: i32, b: i32, result: i32) !void { + try testing.expectEqual(result, __mulsi3(a, b)); } test "mulsi3" { - test_one_mulsi3(0, 0, 0); - test_one_mulsi3(0, 1, 0); - test_one_mulsi3(1, 0, 0); - test_one_mulsi3(0, 10, 0); - test_one_mulsi3(10, 0, 0); - test_one_mulsi3(0, maxInt(i32), 0); - test_one_mulsi3(maxInt(i32), 0, 0); - test_one_mulsi3(0, -1, 0); - test_one_mulsi3(-1, 0, 0); - test_one_mulsi3(0, -10, 0); - test_one_mulsi3(-10, 0, 0); - test_one_mulsi3(0, minInt(i32), 0); - test_one_mulsi3(minInt(i32), 0, 0); - test_one_mulsi3(1, 1, 1); - test_one_mulsi3(1, 10, 10); - test_one_mulsi3(10, 1, 10); - test_one_mulsi3(1, maxInt(i32), maxInt(i32)); - test_one_mulsi3(maxInt(i32), 1, maxInt(i32)); - test_one_mulsi3(1, -1, -1); - test_one_mulsi3(1, -10, -10); - test_one_mulsi3(-10, 1, -10); - test_one_mulsi3(1, minInt(i32), minInt(i32)); - test_one_mulsi3(minInt(i32), 1, minInt(i32)); - test_one_mulsi3(46340, 46340, 2147395600); - test_one_mulsi3(-46340, 46340, -2147395600); - test_one_mulsi3(46340, -46340, -2147395600); - test_one_mulsi3(-46340, -46340, 2147395600); - test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176)); - test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176)); - test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176)); - test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176)); - test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176)); - test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176)); - test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176)); - test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176)); + try test_one_mulsi3(0, 0, 0); + try test_one_mulsi3(0, 1, 0); + try test_one_mulsi3(1, 0, 0); + try test_one_mulsi3(0, 10, 0); + try test_one_mulsi3(10, 0, 0); + try test_one_mulsi3(0, maxInt(i32), 0); + try test_one_mulsi3(maxInt(i32), 0, 0); + try test_one_mulsi3(0, -1, 0); + try test_one_mulsi3(-1, 0, 0); + try test_one_mulsi3(0, -10, 0); + try test_one_mulsi3(-10, 0, 0); + try test_one_mulsi3(0, minInt(i32), 0); + try test_one_mulsi3(minInt(i32), 0, 0); + try test_one_mulsi3(1, 1, 1); + try test_one_mulsi3(1, 10, 10); + try test_one_mulsi3(10, 1, 10); + try test_one_mulsi3(1, maxInt(i32), maxInt(i32)); + try test_one_mulsi3(maxInt(i32), 1, maxInt(i32)); + try test_one_mulsi3(1, -1, -1); + try test_one_mulsi3(1, -10, -10); + try test_one_mulsi3(-10, 1, -10); + try test_one_mulsi3(1, minInt(i32), minInt(i32)); + try test_one_mulsi3(minInt(i32), 1, minInt(i32)); + try test_one_mulsi3(46340, 46340, 2147395600); + try test_one_mulsi3(-46340, 46340, -2147395600); + try test_one_mulsi3(46340, -46340, -2147395600); + try test_one_mulsi3(-46340, -46340, 2147395600); + try test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176)); + try test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176)); + try test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176)); + try test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176)); + try test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176)); + try test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176)); + try test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176)); + try test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176)); } diff --git a/lib/std/special/compiler_rt/lshrdi3_test.zig b/lib/std/special/compiler_rt/lshrdi3_test.zig index 5443fd9bce..1e3270711e 100644 --- a/lib/std/special/compiler_rt/lshrdi3_test.zig +++ b/lib/std/special/compiler_rt/lshrdi3_test.zig @@ -6,55 +6,55 @@ const __lshrdi3 = @import("shift.zig").__lshrdi3; const testing = @import("std").testing; -fn test__lshrdi3(a: i64, b: i32, expected: u64) void { +fn test__lshrdi3(a: i64, b: i32, expected: u64) !void { const x = __lshrdi3(a, b); - testing.expectEqual(@bitCast(i64, expected), x); + try testing.expectEqual(@bitCast(i64, expected), x); } test "lshrdi3" { - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0); - test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0); + try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753); - test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9); - test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA); - test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5); - test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2); - test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2); + try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1); } diff --git a/lib/std/special/compiler_rt/lshrti3_test.zig b/lib/std/special/compiler_rt/lshrti3_test.zig index bfd812f028..3cb134f777 100644 --- a/lib/std/special/compiler_rt/lshrti3_test.zig +++ b/lib/std/special/compiler_rt/lshrti3_test.zig @@ -6,46 +6,46 @@ const __lshrti3 = @import("shift.zig").__lshrti3; const testing = @import("std").testing; -fn test__lshrti3(a: i128, b: i32, expected: i128) void { +fn test__lshrti3(a: i128, b: i32, expected: i128) !void { const x = __lshrti3(a, b); - testing.expectEqual(expected, x); + try testing.expectEqual(expected, x); } test "lshrti3" { - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003))); - test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003))); + try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001))); } diff --git a/lib/std/special/compiler_rt/modti3_test.zig b/lib/std/special/compiler_rt/modti3_test.zig index e3d670ef13..e053941730 100644 --- a/lib/std/special/compiler_rt/modti3_test.zig +++ b/lib/std/special/compiler_rt/modti3_test.zig @@ -6,32 +6,32 @@ const __modti3 = @import("modti3.zig").__modti3; const testing = @import("std").testing; -fn test__modti3(a: i128, b: i128, expected: i128) void { +fn test__modti3(a: i128, b: i128, expected: i128) !void { const x = __modti3(a, b); try testing.expect(x == expected); } test "modti3" { - test__modti3(0, 1, 0); - test__modti3(0, -1, 0); - test__modti3(5, 3, 2); - test__modti3(5, -3, 2); - test__modti3(-5, 3, -2); - test__modti3(-5, -3, -2); + try test__modti3(0, 1, 0); + try test__modti3(0, -1, 0); + try test__modti3(5, 3, 2); + try test__modti3(5, -3, 2); + try test__modti3(-5, 3, -2); + try test__modti3(-5, -3, -2); - test__modti3(0x8000000000000000, 1, 0x0); - test__modti3(0x8000000000000000, -1, 0x0); - test__modti3(0x8000000000000000, 2, 0x0); - test__modti3(0x8000000000000000, -2, 0x0); - test__modti3(0x8000000000000000, 3, 2); - test__modti3(0x8000000000000000, -3, 2); + try test__modti3(0x8000000000000000, 1, 0x0); + try test__modti3(0x8000000000000000, -1, 0x0); + try test__modti3(0x8000000000000000, 2, 0x0); + try test__modti3(0x8000000000000000, -2, 0x0); + try test__modti3(0x8000000000000000, 3, 2); + try test__modti3(0x8000000000000000, -3, 2); - test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0); - test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0); - test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0); - test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0); - test__modti3(make_ti(0x8000000000000000, 0), 3, -2); - test__modti3(make_ti(0x8000000000000000, 0), -3, -2); + try test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0); + try test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0); + try test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0); + try test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0); + try test__modti3(make_ti(0x8000000000000000, 0), 3, -2); + try test__modti3(make_ti(0x8000000000000000, 0), -3, -2); } fn make_ti(high: u64, low: u64) i128 { diff --git a/lib/std/special/compiler_rt/mulXf3_test.zig b/lib/std/special/compiler_rt/mulXf3_test.zig index 272c96522d..b73f03d6c1 100644 --- a/lib/std/special/compiler_rt/mulXf3_test.zig +++ b/lib/std/special/compiler_rt/mulXf3_test.zig @@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool { return false; } -fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void { +fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void { const x = __multf3(a, b); if (compareResultLD(x, expected_hi, expected_lo)) @@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 { } test "multf3" { // qNaN * any = qNaN - test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // NaN * any = NaN const a = makeNaN128(0x800030000000); - test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); + try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0); // inf * any = inf - test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0); + try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0); // any * any - test__multf3( + try test__multf3( @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)), @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)), 0x400423e7f9e3c9fc, 0xd906c2c2a85777c4, ); - test__multf3( + try test__multf3( @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)), @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)), 0x3fc52a163c6223fc, 0xc94c4bf0430768b4, ); - test__multf3( + try test__multf3( 0x1.234425696abcad34a35eeffefdcbap+456, 0x451.ed98d76e5d46e5f24323dff21ffp+600, 0x44293a91de5e0e94, 0xe8ed17cc2cdf64ac, ); - test__multf3( + try test__multf3( @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)), @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)), 0x3d4f37c1a3137cae, 0xfc6807048bc2836a, ); - test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0); + try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0); } diff --git a/lib/std/special/compiler_rt/muldi3_test.zig b/lib/std/special/compiler_rt/muldi3_test.zig index 3bf3e7626f..914e42bd15 100644 --- a/lib/std/special/compiler_rt/muldi3_test.zig +++ b/lib/std/special/compiler_rt/muldi3_test.zig @@ -6,51 +6,51 @@ const __muldi3 = @import("muldi3.zig").__muldi3; const testing = @import("std").testing; -fn test__muldi3(a: i64, b: i64, expected: i64) void { +fn test__muldi3(a: i64, b: i64, expected: i64) !void { const x = __muldi3(a, b); try testing.expect(x == expected); } test "muldi3" { - test__muldi3(0, 0, 0); - test__muldi3(0, 1, 0); - test__muldi3(1, 0, 0); - test__muldi3(0, 10, 0); - test__muldi3(10, 0, 0); - test__muldi3(0, 81985529216486895, 0); - test__muldi3(81985529216486895, 0, 0); + try test__muldi3(0, 0, 0); + try test__muldi3(0, 1, 0); + try test__muldi3(1, 0, 0); + try test__muldi3(0, 10, 0); + try test__muldi3(10, 0, 0); + try test__muldi3(0, 81985529216486895, 0); + try test__muldi3(81985529216486895, 0, 0); - test__muldi3(0, -1, 0); - test__muldi3(-1, 0, 0); - test__muldi3(0, -10, 0); - test__muldi3(-10, 0, 0); - test__muldi3(0, -81985529216486895, 0); - test__muldi3(-81985529216486895, 0, 0); + try test__muldi3(0, -1, 0); + try test__muldi3(-1, 0, 0); + try test__muldi3(0, -10, 0); + try test__muldi3(-10, 0, 0); + try test__muldi3(0, -81985529216486895, 0); + try test__muldi3(-81985529216486895, 0, 0); - test__muldi3(1, 1, 1); - test__muldi3(1, 10, 10); - test__muldi3(10, 1, 10); - test__muldi3(1, 81985529216486895, 81985529216486895); - test__muldi3(81985529216486895, 1, 81985529216486895); + try test__muldi3(1, 1, 1); + try test__muldi3(1, 10, 10); + try test__muldi3(10, 1, 10); + try test__muldi3(1, 81985529216486895, 81985529216486895); + try test__muldi3(81985529216486895, 1, 81985529216486895); - test__muldi3(1, -1, -1); - test__muldi3(1, -10, -10); - test__muldi3(-10, 1, -10); - test__muldi3(1, -81985529216486895, -81985529216486895); - test__muldi3(-81985529216486895, 1, -81985529216486895); + try test__muldi3(1, -1, -1); + try test__muldi3(1, -10, -10); + try test__muldi3(-10, 1, -10); + try test__muldi3(1, -81985529216486895, -81985529216486895); + try test__muldi3(-81985529216486895, 1, -81985529216486895); - test__muldi3(3037000499, 3037000499, 9223372030926249001); - test__muldi3(-3037000499, 3037000499, -9223372030926249001); - test__muldi3(3037000499, -3037000499, -9223372030926249001); - test__muldi3(-3037000499, -3037000499, 9223372030926249001); + try test__muldi3(3037000499, 3037000499, 9223372030926249001); + try test__muldi3(-3037000499, 3037000499, -9223372030926249001); + try test__muldi3(3037000499, -3037000499, -9223372030926249001); + try test__muldi3(-3037000499, -3037000499, 9223372030926249001); - test__muldi3(4398046511103, 2097152, 9223372036852678656); - test__muldi3(-4398046511103, 2097152, -9223372036852678656); - test__muldi3(4398046511103, -2097152, -9223372036852678656); - test__muldi3(-4398046511103, -2097152, 9223372036852678656); + try test__muldi3(4398046511103, 2097152, 9223372036852678656); + try test__muldi3(-4398046511103, 2097152, -9223372036852678656); + try test__muldi3(4398046511103, -2097152, -9223372036852678656); + try test__muldi3(-4398046511103, -2097152, 9223372036852678656); - test__muldi3(2097152, 4398046511103, 9223372036852678656); - test__muldi3(-2097152, 4398046511103, -9223372036852678656); - test__muldi3(2097152, -4398046511103, -9223372036852678656); - test__muldi3(-2097152, -4398046511103, 9223372036852678656); + try test__muldi3(2097152, 4398046511103, 9223372036852678656); + try test__muldi3(-2097152, 4398046511103, -9223372036852678656); + try test__muldi3(2097152, -4398046511103, -9223372036852678656); + try test__muldi3(-2097152, -4398046511103, 9223372036852678656); } diff --git a/lib/std/special/compiler_rt/mulodi4_test.zig b/lib/std/special/compiler_rt/mulodi4_test.zig index 26082cf74e..c865b7a0c5 100644 --- a/lib/std/special/compiler_rt/mulodi4_test.zig +++ b/lib/std/special/compiler_rt/mulodi4_test.zig @@ -6,85 +6,85 @@ const __mulodi4 = @import("mulodi4.zig").__mulodi4; const testing = @import("std").testing; -fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) void { +fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) !void { var overflow: c_int = undefined; const x = __mulodi4(a, b, &overflow); try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); } test "mulodi4" { - test__mulodi4(0, 0, 0, 0); - test__mulodi4(0, 1, 0, 0); - test__mulodi4(1, 0, 0, 0); - test__mulodi4(0, 10, 0, 0); - test__mulodi4(10, 0, 0, 0); - test__mulodi4(0, 81985529216486895, 0, 0); - test__mulodi4(81985529216486895, 0, 0, 0); + try test__mulodi4(0, 0, 0, 0); + try test__mulodi4(0, 1, 0, 0); + try test__mulodi4(1, 0, 0, 0); + try test__mulodi4(0, 10, 0, 0); + try test__mulodi4(10, 0, 0, 0); + try test__mulodi4(0, 81985529216486895, 0, 0); + try test__mulodi4(81985529216486895, 0, 0, 0); - test__mulodi4(0, -1, 0, 0); - test__mulodi4(-1, 0, 0, 0); - test__mulodi4(0, -10, 0, 0); - test__mulodi4(-10, 0, 0, 0); - test__mulodi4(0, -81985529216486895, 0, 0); - test__mulodi4(-81985529216486895, 0, 0, 0); + try test__mulodi4(0, -1, 0, 0); + try test__mulodi4(-1, 0, 0, 0); + try test__mulodi4(0, -10, 0, 0); + try test__mulodi4(-10, 0, 0, 0); + try test__mulodi4(0, -81985529216486895, 0, 0); + try test__mulodi4(-81985529216486895, 0, 0, 0); - test__mulodi4(1, 1, 1, 0); - test__mulodi4(1, 10, 10, 0); - test__mulodi4(10, 1, 10, 0); - test__mulodi4(1, 81985529216486895, 81985529216486895, 0); - test__mulodi4(81985529216486895, 1, 81985529216486895, 0); + try test__mulodi4(1, 1, 1, 0); + try test__mulodi4(1, 10, 10, 0); + try test__mulodi4(10, 1, 10, 0); + try test__mulodi4(1, 81985529216486895, 81985529216486895, 0); + try test__mulodi4(81985529216486895, 1, 81985529216486895, 0); - test__mulodi4(1, -1, -1, 0); - test__mulodi4(1, -10, -10, 0); - test__mulodi4(-10, 1, -10, 0); - test__mulodi4(1, -81985529216486895, -81985529216486895, 0); - test__mulodi4(-81985529216486895, 1, -81985529216486895, 0); + try test__mulodi4(1, -1, -1, 0); + try test__mulodi4(1, -10, -10, 0); + try test__mulodi4(-10, 1, -10, 0); + try test__mulodi4(1, -81985529216486895, -81985529216486895, 0); + try test__mulodi4(-81985529216486895, 1, -81985529216486895, 0); - test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0); - test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0); - test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0); - test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0); + try test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0); + try test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0); + try test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0); + try test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0); - test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0); - test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0); - test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0); - test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0); + try test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0); + try test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0); + try test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0); + try test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0); - test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0); - test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0); - test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0); - test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0); + try test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0); + try test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0); + try test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0); + try test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0); - test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1); - test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1); - test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); - test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); - test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0); - test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0); - test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0); - test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0); - test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); - test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); + try test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1); + try test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1); + try test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); + try test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); + try test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0); + try test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0); + try test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0); + try test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0); + try test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); + try test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0); - test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0); - test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0); + try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0); + try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); - test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0); - test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0); - test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); - test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0); - test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); - test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1); + try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0); + try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0); + try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0); + try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0); + try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1); + try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1); } diff --git a/lib/std/special/compiler_rt/muloti4_test.zig b/lib/std/special/compiler_rt/muloti4_test.zig index 7ff0650145..34c1d2daab 100644 --- a/lib/std/special/compiler_rt/muloti4_test.zig +++ b/lib/std/special/compiler_rt/muloti4_test.zig @@ -6,76 +6,76 @@ const __muloti4 = @import("muloti4.zig").__muloti4; const testing = @import("std").testing; -fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void { +fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) !void { var overflow: c_int = undefined; const x = __muloti4(a, b, &overflow); try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected)); } test "muloti4" { - test__muloti4(0, 0, 0, 0); - test__muloti4(0, 1, 0, 0); - test__muloti4(1, 0, 0, 0); - test__muloti4(0, 10, 0, 0); - test__muloti4(10, 0, 0, 0); + try test__muloti4(0, 0, 0, 0); + try test__muloti4(0, 1, 0, 0); + try test__muloti4(1, 0, 0, 0); + try test__muloti4(0, 10, 0, 0); + try test__muloti4(10, 0, 0, 0); - test__muloti4(0, 81985529216486895, 0, 0); - test__muloti4(81985529216486895, 0, 0, 0); + try test__muloti4(0, 81985529216486895, 0, 0); + try test__muloti4(81985529216486895, 0, 0, 0); - test__muloti4(0, -1, 0, 0); - test__muloti4(-1, 0, 0, 0); - test__muloti4(0, -10, 0, 0); - test__muloti4(-10, 0, 0, 0); - test__muloti4(0, -81985529216486895, 0, 0); - test__muloti4(-81985529216486895, 0, 0, 0); + try test__muloti4(0, -1, 0, 0); + try test__muloti4(-1, 0, 0, 0); + try test__muloti4(0, -10, 0, 0); + try test__muloti4(-10, 0, 0, 0); + try test__muloti4(0, -81985529216486895, 0, 0); + try test__muloti4(-81985529216486895, 0, 0, 0); - test__muloti4(3037000499, 3037000499, 9223372030926249001, 0); - test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0); - test__muloti4(3037000499, -3037000499, -9223372030926249001, 0); - test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0); + try test__muloti4(3037000499, 3037000499, 9223372030926249001, 0); + try test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0); + try test__muloti4(3037000499, -3037000499, -9223372030926249001, 0); + try test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0); - test__muloti4(4398046511103, 2097152, 9223372036852678656, 0); - test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0); - test__muloti4(4398046511103, -2097152, -9223372036852678656, 0); - test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0); + try test__muloti4(4398046511103, 2097152, 9223372036852678656, 0); + try test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0); + try test__muloti4(4398046511103, -2097152, -9223372036852678656, 0); + try test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0); - test__muloti4(2097152, 4398046511103, 9223372036852678656, 0); - test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0); - test__muloti4(2097152, -4398046511103, -9223372036852678656, 0); - test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0); + try test__muloti4(2097152, 4398046511103, 9223372036852678656, 0); + try test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0); + try test__muloti4(2097152, -4398046511103, -9223372036852678656, 0); + try test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0); - test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); - test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0); - test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0); - test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); - test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); + try test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0); + try test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); + try test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0); - test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0); - test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0); + try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0); + try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); - test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0); - test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); - test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); - test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); - test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); + try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0); + try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); + try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0); + try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); + try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1); } diff --git a/lib/std/special/compiler_rt/multi3_test.zig b/lib/std/special/compiler_rt/multi3_test.zig index b5c5bd3836..a9ac760099 100644 --- a/lib/std/special/compiler_rt/multi3_test.zig +++ b/lib/std/special/compiler_rt/multi3_test.zig @@ -6,53 +6,53 @@ const __multi3 = @import("multi3.zig").__multi3; const testing = @import("std").testing; -fn test__multi3(a: i128, b: i128, expected: i128) void { +fn test__multi3(a: i128, b: i128, expected: i128) !void { const x = __multi3(a, b); try testing.expect(x == expected); } test "multi3" { - test__multi3(0, 0, 0); - test__multi3(0, 1, 0); - test__multi3(1, 0, 0); - test__multi3(0, 10, 0); - test__multi3(10, 0, 0); - test__multi3(0, 81985529216486895, 0); - test__multi3(81985529216486895, 0, 0); + try test__multi3(0, 0, 0); + try test__multi3(0, 1, 0); + try test__multi3(1, 0, 0); + try test__multi3(0, 10, 0); + try test__multi3(10, 0, 0); + try test__multi3(0, 81985529216486895, 0); + try test__multi3(81985529216486895, 0, 0); - test__multi3(0, -1, 0); - test__multi3(-1, 0, 0); - test__multi3(0, -10, 0); - test__multi3(-10, 0, 0); - test__multi3(0, -81985529216486895, 0); - test__multi3(-81985529216486895, 0, 0); + try test__multi3(0, -1, 0); + try test__multi3(-1, 0, 0); + try test__multi3(0, -10, 0); + try test__multi3(-10, 0, 0); + try test__multi3(0, -81985529216486895, 0); + try test__multi3(-81985529216486895, 0, 0); - test__multi3(1, 1, 1); - test__multi3(1, 10, 10); - test__multi3(10, 1, 10); - test__multi3(1, 81985529216486895, 81985529216486895); - test__multi3(81985529216486895, 1, 81985529216486895); + try test__multi3(1, 1, 1); + try test__multi3(1, 10, 10); + try test__multi3(10, 1, 10); + try test__multi3(1, 81985529216486895, 81985529216486895); + try test__multi3(81985529216486895, 1, 81985529216486895); - test__multi3(1, -1, -1); - test__multi3(1, -10, -10); - test__multi3(-10, 1, -10); - test__multi3(1, -81985529216486895, -81985529216486895); - test__multi3(-81985529216486895, 1, -81985529216486895); + try test__multi3(1, -1, -1); + try test__multi3(1, -10, -10); + try test__multi3(-10, 1, -10); + try test__multi3(1, -81985529216486895, -81985529216486895); + try test__multi3(-81985529216486895, 1, -81985529216486895); - test__multi3(3037000499, 3037000499, 9223372030926249001); - test__multi3(-3037000499, 3037000499, -9223372030926249001); - test__multi3(3037000499, -3037000499, -9223372030926249001); - test__multi3(-3037000499, -3037000499, 9223372030926249001); + try test__multi3(3037000499, 3037000499, 9223372030926249001); + try test__multi3(-3037000499, 3037000499, -9223372030926249001); + try test__multi3(3037000499, -3037000499, -9223372030926249001); + try test__multi3(-3037000499, -3037000499, 9223372030926249001); - test__multi3(4398046511103, 2097152, 9223372036852678656); - test__multi3(-4398046511103, 2097152, -9223372036852678656); - test__multi3(4398046511103, -2097152, -9223372036852678656); - test__multi3(-4398046511103, -2097152, 9223372036852678656); + try test__multi3(4398046511103, 2097152, 9223372036852678656); + try test__multi3(-4398046511103, 2097152, -9223372036852678656); + try test__multi3(4398046511103, -2097152, -9223372036852678656); + try test__multi3(-4398046511103, -2097152, 9223372036852678656); - test__multi3(2097152, 4398046511103, 9223372036852678656); - test__multi3(-2097152, 4398046511103, -9223372036852678656); - test__multi3(2097152, -4398046511103, -9223372036852678656); - test__multi3(-2097152, -4398046511103, 9223372036852678656); + try test__multi3(2097152, 4398046511103, 9223372036852678656); + try test__multi3(-2097152, 4398046511103, -9223372036852678656); + try test__multi3(2097152, -4398046511103, -9223372036852678656); + try test__multi3(-2097152, -4398046511103, 9223372036852678656); - test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000); + try test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000); } diff --git a/lib/std/special/compiler_rt/popcountdi2_test.zig b/lib/std/special/compiler_rt/popcountdi2_test.zig index 3cb7d00c97..056b9827ef 100644 --- a/lib/std/special/compiler_rt/popcountdi2_test.zig +++ b/lib/std/special/compiler_rt/popcountdi2_test.zig @@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 { return r; } -fn test__popcountdi2(a: i64) void { +fn test__popcountdi2(a: i64) !void { const x = __popcountdi2(a); const expected = naive_popcount(a); try testing.expect(expected == x); } test "popcountdi2" { - test__popcountdi2(0); - test__popcountdi2(1); - test__popcountdi2(2); - test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD))); - test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE))); - test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF))); + try test__popcountdi2(0); + try test__popcountdi2(1); + try test__popcountdi2(2); + try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD))); + try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE))); + try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF))); // TODO some fuzz testing } diff --git a/lib/std/special/compiler_rt/truncXfYf2_test.zig b/lib/std/special/compiler_rt/truncXfYf2_test.zig index 4fae5d1fc0..9e581fd636 100644 --- a/lib/std/special/compiler_rt/truncXfYf2_test.zig +++ b/lib/std/special/compiler_rt/truncXfYf2_test.zig @@ -5,67 +5,67 @@ // and substantial portions of the software. const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2; -fn test__truncsfhf2(a: u32, expected: u16) void { +fn test__truncsfhf2(a: u32, expected: u16) !void { const actual = __truncsfhf2(@bitCast(f32, a)); if (actual == expected) { return; } - @panic("__truncsfhf2 test failure"); + return error.TestFailure; } test "truncsfhf2" { - test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN - test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN + try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN + try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN - test__truncsfhf2(0, 0); // 0 - test__truncsfhf2(0x80000000, 0x8000); // -0 + try test__truncsfhf2(0, 0); // 0 + try test__truncsfhf2(0x80000000, 0x8000); // -0 - test__truncsfhf2(0x7f800000, 0x7c00); // inf - test__truncsfhf2(0xff800000, 0xfc00); // -inf + try test__truncsfhf2(0x7f800000, 0x7c00); // inf + try test__truncsfhf2(0xff800000, 0xfc00); // -inf - test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf - test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf + try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf + try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf - test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf - test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf + try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf + try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf - test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14 - test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14 + try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14 + try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14 - test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504 - test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504 + try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504 + try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504 - test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504 - test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504 + try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504 + try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504 - test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504 - test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504 + try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504 + try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504 - test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10 - test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10 + try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10 + try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10 - test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3 - test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3 + try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3 + try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3 - test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535 - test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535 + try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535 + try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535 - test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12 + try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12 - test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1 - test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14 + try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1 + try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14 - test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24 - test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24 + try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24 + try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24 - test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24 - test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24 + try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24 + try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24 - test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20 - test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24 - test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero + try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20 + try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24 + try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero } const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2; diff --git a/lib/std/special/compiler_rt/udivmoddi4_test.zig b/lib/std/special/compiler_rt/udivmoddi4_test.zig index e652afa316..edc07bc1db 100644 --- a/lib/std/special/compiler_rt/udivmoddi4_test.zig +++ b/lib/std/special/compiler_rt/udivmoddi4_test.zig @@ -8,7 +8,7 @@ const __udivmoddi4 = @import("int.zig").__udivmoddi4; const testing = @import("std").testing; -fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void { +fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) !void { var r: u64 = undefined; const q = __udivmoddi4(a, b, &r); try testing.expect(q == expected_q); @@ -17,7 +17,7 @@ fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void { test "udivmoddi4" { for (cases) |case| { - test__udivmoddi4(case[0], case[1], case[2], case[3]); + try test__udivmoddi4(case[0], case[1], case[2], case[3]); } } diff --git a/lib/std/special/compiler_rt/udivmodti4_test.zig b/lib/std/special/compiler_rt/udivmodti4_test.zig index 2ada7eda09..5d39470f53 100644 --- a/lib/std/special/compiler_rt/udivmodti4_test.zig +++ b/lib/std/special/compiler_rt/udivmodti4_test.zig @@ -8,7 +8,7 @@ const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4; const testing = @import("std").testing; -fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void { +fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) !void { var r: u128 = undefined; const q = __udivmodti4(a, b, &r); try testing.expect(q == expected_q); @@ -17,7 +17,7 @@ fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void { test "udivmodti4" { for (cases) |case| { - test__udivmodti4(case[0], case[1], case[2], case[3]); + try test__udivmodti4(case[0], case[1], case[2], case[3]); } } From 08b6baca122698db0d8543c8953d543f318c6422 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Sat, 8 May 2021 10:45:19 +0300 Subject: [PATCH 6/8] update usage of std.testing in langref.html --- doc/langref.html.in | 697 ++++++++++++++++++++++---------------------- 1 file changed, 349 insertions(+), 348 deletions(-) diff --git a/doc/langref.html.in b/doc/langref.html.in index 744d33f85c..e21b6274e1 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -358,7 +358,7 @@ test "comments" { //expect(false); const x = true; // another comment - expect(x); + try expect(x); } {#code_end#}

@@ -718,15 +718,15 @@ const mem = @import("std").mem; test "string literals" { const bytes = "hello"; - expect(@TypeOf(bytes) == *const [5:0]u8); - expect(bytes.len == 5); - expect(bytes[1] == 'e'); - expect(bytes[5] == 0); - expect('e' == '\x65'); - expect('\u{1f4a9}' == 128169); - expect('πŸ’―' == 128175); - expect(mem.eql(u8, "hello", "h\x65llo")); - expect("\xff"[0] == 0xff); // non-UTF-8 strings are possible with \xNN notation. + try expect(@TypeOf(bytes) == *const [5:0]u8); + try expect(bytes.len == 5); + try expect(bytes[1] == 'e'); + try expect(bytes[5] == 0); + try expect('e' == '\x65'); + try expect('\u{1f4a9}' == 128169); + try expect('πŸ’―' == 128175); + try expect(mem.eql(u8, "hello", "h\x65llo")); + 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#}

Variables must be initialized:

@@ -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#}

@@ -887,8 +887,8 @@ var y: i32 = add(10, x); const x: i32 = add(12, 34); test "global variables" { - expect(x == 46); - expect(y == 56); + try expect(x == 46); + 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); - expect(foo() == 1236); + try expect(foo() == 1235); + try expect(foo() == 1236); } fn foo() i32 { @@ -985,8 +985,8 @@ test "comptime vars" { x += 1; y += 1; - expect(x == 2); - expect(y == 2); + try expect(x == 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); - expect(some_integers[99] == 99); + try expect(some_integers[10] == 10); + 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); - expect(all_zero[5] == 0); + assert(all_zero.len == 10); + 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); - expect(fancy_array[4].y == 8); + try expect(fancy_array[4].x == 4); + 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); - expect(more_points[4].y == 6); - expect(more_points.len == 10); + try expect(more_points[4].x == 3); + try expect(more_points[4].y == 6); + 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); - expect(array[1] == 22); - expect(array[2] == 33); - expect(array[3] == 44); + try expect(array[0] == 11); + try expect(array[1] == 22); + try expect(array[2] == 33); + try expect(array[3] == 44); } {#code_end#}

@@ -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 { - expect(args.@"0" == 1234); - expect(args.@"1" == 12.34); - expect(args.@"2"); - expect(args.@"3"[0] == 'h'); - expect(args.@"3"[1] == 'i'); +fn dump(args: anytype) !void { + try expect(args.@"0" == 1234); + try expect(args.@"1" == 12.34); + try expect(args.@"2"); + try expect(args.@"3"[0] == 'h'); + 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); - expect(array.len == 4); - expect(array[4] == 0); + try expect(@TypeOf(array) == [4:0]u8); + try expect(array.len == 4); + 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#}

@@ -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#}

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); - expect(addr == 0xdeadbee0); + try expect(@TypeOf(addr) == usize); + try expect(addr == 0xdeadbee0); } {#code_end#}

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); - expect(addr == 0xdeadbee0); + try expect(@TypeOf(addr) == usize); + 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#}

@@ -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); - expect(*i32 == *align(align_of_i32) i32); + try expect(@TypeOf(&x) == *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); - expect(@TypeOf(&foo) == *align(4) u8); + try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4); + 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); - expect(@TypeOf(noop1) == fn() align(1) void); - expect(@TypeOf(noop4) == fn() align(4) void); + try expect(derp() == 1234); + try expect(@TypeOf(noop1) == fn() align(1) void); + try expect(@TypeOf(noop4) == fn() align(4) void); noop1(); noop4(); } @@ -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]); - expect(slice.len == array.len); + try expect(&slice[0] == &array[0]); + 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); - expect(@TypeOf(&slice[0]) == *i32); - expect(@ptrToInt(slice.ptr) == @ptrToInt(&slice[0])); + try expect(@TypeOf(slice.ptr) == [*]i32); + try expect(@TypeOf(&slice[0]) == *i32); + 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); - expect(slice2[0] == 3); + try expect(slice2.len == 1); + 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); - expect(slice[5] == 0); + try expect(slice.len == 5); + 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); - expect(@sizeOf(Empty) == 0); + try expect(Empty.PI == 3.14); + 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(); - comptime doTheTest(); + try doTheTest(); + comptime try doTheTest(); } -fn doTheTest() void { - expect(@sizeOf(Full) == 2); - expect(@sizeOf(Divided) == 2); +fn doTheTest() !void { + try expect(@sizeOf(Full) == 2); + try expect(@sizeOf(Divided) == 2); var full = Full{ .number = 0x1234 }; var divided = @bitCast(Divided, full); switch (builtin.endian) { .Big => { - expect(divided.half1 == 0x12); - expect(divided.quarter3 == 0x3); - expect(divided.quarter4 == 0x4); + try expect(divided.half1 == 0x12); + try expect(divided.quarter3 == 0x3); + try expect(divided.quarter4 == 0x4); }, .Little => { - expect(divided.half1 == 0x34); - expect(divided.quarter3 == 0x2); - expect(divided.quarter4 == 0x1); + try expect(divided.half1 == 0x34); + try expect(divided.quarter3 == 0x2); + 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#}

@@ -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)); - expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c)); + try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.b)); + try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c)); } {#code_end#}

@@ -2733,13 +2734,13 @@ const BitField = packed struct { test "pointer to non-bit-aligned field" { comptime { - expect(@bitOffsetOf(BitField, "a") == 0); - expect(@bitOffsetOf(BitField, "b") == 3); - expect(@bitOffsetOf(BitField, "c") == 6); + try expect(@bitOffsetOf(BitField, "a") == 0); + try expect(@bitOffsetOf(BitField, "b") == 3); + try expect(@bitOffsetOf(BitField, "c") == 6); - expect(@byteOffsetOf(BitField, "a") == 0); - expect(@byteOffsetOf(BitField, "b") == 0); - expect(@byteOffsetOf(BitField, "c") == 0); + try expect(@byteOffsetOf(BitField, "a") == 0); + try expect(@byteOffsetOf(BitField, "b") == 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)); - expectEqual(*align(2) u32, @TypeOf(&foo.a)); - expectEqual(*align(64) u32, @TypeOf(&foo.b)); + try expectEqual(64, @alignOf(S)); + try expectEqual(*align(2) u32, @TypeOf(&foo.a)); + try expectEqual(*align(64) u32, @TypeOf(&foo.b)); } {#code_end#}

@@ -2834,8 +2835,8 @@ test "anonymous struct literal" { .x = 13, .y = 67, }; - expect(pt.x == 13); - expect(pt.y == 67); + try expect(pt.x == 13); + try expect(pt.y == 67); } {#code_end#}

@@ -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 { - expect(args.int == 1234); - expect(args.float == 12.34); - expect(args.b); - expect(args.s[0] == 'h'); - expect(args.s[1] == 'i'); +fn dump(args: anytype) !void { + try expect(args.int == 1234); + try expect(args.float == 12.34); + try expect(args.b); + try expect(args.s[0] == 'h'); + try expect(args.s[1] == 'i'); } {#code_end#}

@@ -2884,14 +2885,14 @@ test "tuple" { true, "hi", } ++ .{false} ** 2; - expect(values[0] == 1234); - expect(values[4] == false); + try expect(values[0] == 1234); + try expect(values[4] == false); inline for (values) |v, i| { if (i != 2) continue; - expect(v); + try expect(v); } - expect(values.len == 6); - expect(values.@"3"[0] == 'h'); + try expect(values.len == 6); + 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); - expect(@enumToInt(Value.one) == 1); - expect(@enumToInt(Value.two) == 2); + try expect(@enumToInt(Value.zero) == 0); + try expect(@enumToInt(Value.one) == 1); + 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); - expect(@enumToInt(Value2.thousand) == 1000); - expect(@enumToInt(Value2.million) == 1000000); + try expect(@enumToInt(Value2.hundred) == 100); + try expect(@enumToInt(Value2.thousand) == 1000); + 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); - expect(mem.eql(u8, @typeInfo(Small).Enum.fields[1].name, "two")); + try expect(@typeInfo(Small).Enum.fields.len == 4); + 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#}

This makes the enum eligible to be in a {#link|packed struct#}.

@@ -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#}

@@ -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); - expect(c2 == .not_ok); + try expect(c1 == .ok); + try expect(c2 == .not_ok); } {#code_end#}

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#}

@@ -3250,8 +3251,8 @@ test "union method" { var v1 = Variant{ .int = 1 }; var v2 = Variant{ .boolean = false }; - expect(v1.truthy()); - expect(!v2.truthy()); + try expect(v1.truthy()); + try expect(!v2.truthy()); } {#code_end#}

@@ -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); - expect(f.float == 12.34); + try expect(i.int == 42); + 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); - expect(y == 124); + try expect(x == 124); + try expect(y == 124); } {#code_end#}

Here, {#syntax#}blk{#endsyntax#} can be any name.

@@ -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); - expect(a.c.x == 2); + try expect(b == 6); + 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#}

@@ -3591,7 +3592,7 @@ test "while break" { break; i += 1; } - expect(i == 10); + try expect(i == 10); } {#code_end#}

@@ -3608,7 +3609,7 @@ test "while continue" { continue; break; } - expect(i == 10); + try expect(i == 10); } {#code_end#}

@@ -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)); - expect(!rangeHasNumber(0, 10, 15)); + try expect(rangeHasNumber(0, 10, 5)); + 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); - expect(items[1] == 5); - expect(items[2] == 3); + try expect(items[0] == 4); + try expect(items[1] == 5); + 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); - expect(do_op(sub2, 5, 6) == -1); + try expect(do_op(add, 5, 6) == 11); + try expect(do_op(sub2, 5, 6) == -1); } {#code_end#}

Function values are like pointers:

{#code_begin|obj#} -const expect = @import("std").testing.expect; +const assert = @import("std").debug.assert; comptime { - expect(@TypeOf(foo) == fn()void); - expect(@sizeOf(fn()void) == @sizeOf(?fn()void)); + assert(@TypeOf(foo) == 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#}

@@ -4387,11 +4388,11 @@ fn addFortyTwo(x: anytype) @TypeOf(x) { } test "fn type inference" { - expect(addFortyTwo(1) == 43); - expect(@TypeOf(addFortyTwo(1)) == comptime_int); + try expect(addFortyTwo(1) == 43); + try expect(@TypeOf(addFortyTwo(1)) == comptime_int); var y: i64 = 2; - expect(addFortyTwo(y) == 44); - expect(@TypeOf(addFortyTwo(y)) == i64); + try expect(addFortyTwo(y) == 44); + 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); - expect(@typeInfo(@TypeOf(expect)).Fn.is_var_args == false); + try expect(@typeInfo(@TypeOf(expect)).Fn.args[0].arg_type.? == bool); + 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#}

@@ -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); - expect(y == null); + try expect(x.? == 1234); + try expect(y == null); } {#code_end#}

It works nested inside the {#link|Error Union Type#}, too:

@@ -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); - expect((try y) == null); + try expect((try x).? == 1234); + 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); - std.testing.expectError(error.Failure, y); + try expect((try x) == 1234); + 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); - expect(@TypeOf(c) == i16); + try expect(c == 46); + try expect(@TypeOf(c) == i16); } test "peer resolve arrays of different size to const slice" { - expect(mem.eql(u8, boolToStr(true), "true")); - expect(mem.eql(u8, boolToStr(false), "false")); - comptime expect(mem.eql(u8, boolToStr(true), "true")); - comptime expect(mem.eql(u8, boolToStr(false), "false")); + try expect(mem.eql(u8, boolToStr(true), "true")); + try expect(mem.eql(u8, boolToStr(false), "false")); + comptime try expect(mem.eql(u8, boolToStr(true), "true")); + 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); - comptime testPeerResolveArrayConstSlice(true); + try 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")); - expect(mem.eql(u8, value2, "zz")); + try expect(mem.eql(u8, value1, "aoeu")); + try expect(mem.eql(u8, value2, "zz")); } test "peer type resolution: ?T and T" { - expect(peerTypeTAndOptionalT(true, false).? == 0); - expect(peerTypeTAndOptionalT(false, false).? == 3); + try expect(peerTypeTAndOptionalT(true, false).? == 0); + try expect(peerTypeTAndOptionalT(false, false).? == 3); comptime { - expect(peerTypeTAndOptionalT(true, false).? == 0); - expect(peerTypeTAndOptionalT(false, false).? == 3); + try expect(peerTypeTAndOptionalT(true, false).? == 0); + 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); - expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); + try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); + try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); comptime { - expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); - expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); + try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); + 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); - expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + try expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); } comptime { var data = "hi".*; const slice = data[0..]; - expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); - expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + try expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + 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); - expect(b == a); + try expect(a == b); + 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)); - expect(!map.contains(3)); + try expect(map.contains(2)); + try expect(!map.contains(3)); _ = map.remove(2); - expect(!map.contains(2)); + try expect(!map.contains(2)); } {#code_end#}

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#}

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#}

@@ -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#}

@@ -5894,9 +5895,9 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 { } test "perform fn" { - expect(performFn('t', 1) == 6); - expect(performFn('o', 0) == 1); - expect(performFn('w', 99) == 99); + try expect(performFn('t', 1) == 6); + try expect(performFn('o', 0) == 1); + try expect(performFn('w', 99) == 99); } {#code_end#}

@@ -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" {

What if we fix the base case, but put the wrong value in the {#syntax#}expect{#endsyntax#} line?

- {#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#}

@@ -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); - expect(std.mem.eql(u8, &seq_points, "abcdefghi")); + try expect(final_result == 1234); + 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.

- 
{#syntax#}const expect = @import("std").testing.expect;
+      
{#syntax#}const expect = @import("std").debug.assert;
 comptime {
-    expect(*u32 == *align(@alignOf(u32)) u32);
+    assert(*u32 == *align(@alignOf(u32)) u32);
 }{#endsyntax#}

       

       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);
-    expect(@field(p, "y") == 5);
+    try expect(@field(p, "x") == 4);
+    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"));
-    expect(!@hasDecl(Foo, "nope1234"));
+    try expect(!@hasDecl(Foo, "nope"));
+    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));
-    expect(prev + 1 == @wasmMemorySize(0));
+    try expect(prev == @wasmMemoryGrow(0, 1));
+    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));
-    expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
+    comptime try expect(@TypeOf(result) == std.meta.Vector(4, u32));
+    try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
 }
       {#code_end#}
       

@@ -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);
-    expect(is_all_true == false);
+    comptime try expect(@TypeOf(is_all_true) == bool);
+    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);
-    expect(src.column == 17);
-    expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
-    expect(std.mem.endsWith(u8, src.file, "test.zig"));
+    try expect(src.line == 9);
+    try expect(src.column == 17);
+    try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest"));
+    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#}
       

@@ -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);
-    expect(data == 0);
+    comptime try expect(T == i32);
+    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#}
       

@@ -9720,13 +9721,13 @@ test "assert in release fast mode" {
       

       Better practice for checking the output when testing is to use {#syntax#}std.testing.expect{#endsyntax#}:
       

-      {#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#}
       
See the rest of the {#syntax#}std.testing{#endsyntax#} namespace for more available functions.


From 7437c47d55da4c73aba26327d1a140aaf6591d4a Mon Sep 17 00:00:00 2001
From: Veikka Tuominen 
Date: Sat, 8 May 2021 15:11:06 +0300
Subject: [PATCH 7/8] tests: work around miscompilation

---
 test/stage1/behavior/struct.zig | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/stage1/behavior/struct.zig b/test/stage1/behavior/struct.zig
index cf90936bdb..85bc3b04bc 100644
--- a/test/stage1/behavior/struct.zig
+++ b/test/stage1/behavior/struct.zig
@@ -933,9 +933,10 @@ test "packed struct with undefined initializers" {
             var p: P = undefined;
             p = P{ .a = 2, .b = 4, .c = 6 };
             // Make sure the compiler doesn't touch the unprefixed fields.
-            try expectEqual(@as(u3, 2), p.a);
-            try expectEqual(@as(u3, 4), p.b);
-            try expectEqual(@as(u3, 6), p.c);
+            // Use expect since i386-linux doesn't like expectEqual
+            try expect(p.a == 2);
+            try expect(p.b == 4);
+            try expect(p.c == 6);
         }
     };
 

From fed1c9c3ece7b79ce7fccc6af510f1dab98401a9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley 
Date: Sat, 8 May 2021 11:24:07 -0700
Subject: [PATCH 8/8] link/MachO: fix --verbose-link ensureCapacity bug

---
 src/link/MachO.zig | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index aaf88ad815..09414b4cdd 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -687,10 +687,7 @@ fn linkWithLLD(self: *MachO, comp: *Compilation) !void {
                 try argv.append("zig");
                 try argv.append("ld");
 
-                try argv.ensureCapacity(input_files.items.len);
-                for (input_files.items) |f| {
-                    argv.appendAssumeCapacity(f);
-                }
+                try argv.appendSlice(input_files.items);
 
                 try argv.append("-o");
                 try argv.append(full_out_path);