From e5994f5f573a51de4e604824355cac28b5ab4eba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carl=20=C3=85stholm?= <carl@astholm.se>
Date: Sat, 7 Oct 2023 21:53:10 +0200
Subject: [PATCH 1/4] Update `std.testing.expectEqual` and friends to use peer
 type resolution

This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
---
 lib/std/testing.zig | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index a26b6ff32104..f79f877deaf5 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -52,8 +52,13 @@ pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void
 /// This function is intended to be used only in tests. When the two values are not
 /// equal, prints diagnostics to stderr to show exactly how they are not equal,
 /// then returns a test failure error.
-/// `actual` is casted to the type of `expected`.
-pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
+/// `actual` and `expected` are coerced to a common type using peer type resolution.
+pub inline fn expectEqual(expected: anytype, actual: anytype) !void {
+    const T = @TypeOf(expected, actual);
+    return expectEqualInner(T, expected, actual);
+}
+
+fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
     switch (@typeInfo(@TypeOf(actual))) {
         .NoReturn,
         .Opaque,
@@ -224,9 +229,13 @@ pub fn expectFmt(expected: []const u8, comptime template: []const u8, args: anyt
 /// to show exactly how they are not equal, then returns a test failure error.
 /// See `math.approxEqAbs` for more information on the tolerance parameter.
 /// The types must be floating-point.
-pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
-    const T = @TypeOf(expected);
+/// `actual` and `expected` are coerced to a common type using peer type resolution.
+pub inline fn expectApproxEqAbs(expected: anytype, actual: anytype, tolerance: anytype) !void {
+    const T = @TypeOf(expected, actual, tolerance);
+    return expectApproxEqAbsInner(T, expected, actual, tolerance);
+}
 
+fn expectApproxEqAbsInner(comptime T: type, expected: T, actual: T, tolerance: T) !void {
     switch (@typeInfo(T)) {
         .Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
             print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
@@ -256,9 +265,13 @@ test "expectApproxEqAbs" {
 /// to show exactly how they are not equal, then returns a test failure error.
 /// See `math.approxEqRel` for more information on the tolerance parameter.
 /// The types must be floating-point.
-pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
-    const T = @TypeOf(expected);
+/// `actual` and `expected` are coerced to a common type using peer type resolution.
+pub inline fn expectApproxEqRel(expected: anytype, actual: anytype, tolerance: anytype) !void {
+    const T = @TypeOf(expected, actual, tolerance);
+    return expectApproxEqRelInner(T, expected, actual, tolerance);
+}
 
+fn expectApproxEqRelInner(comptime T: type, expected: T, actual: T, tolerance: T) !void {
     switch (@typeInfo(T)) {
         .Float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
             print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
@@ -653,17 +666,22 @@ pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8)
 /// This function is intended to be used only in tests. When the two values are not
 /// deeply equal, prints diagnostics to stderr to show exactly how they are not equal,
 /// then returns a test failure error.
-/// `actual` is casted to the type of `expected`.
+/// `actual` and `expected` are coerced to a common type using peer type resolution.
 ///
 /// Deeply equal is defined as follows:
-/// Primitive types are deeply equal if they are equal using  `==` operator.
+/// Primitive types are deeply equal if they are equal using `==` operator.
 /// Struct values are deeply equal if their corresponding fields are deeply equal.
 /// Container types(like Array/Slice/Vector) deeply equal when their corresponding elements are deeply equal.
 /// Pointer values are deeply equal if values they point to are deeply equal.
 ///
 /// Note: Self-referential structs are supported (e.g. things like std.SinglyLinkedList)
 /// but may cause infinite recursion or stack overflow when a container has a pointer to itself.
-pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) error{TestExpectedEqual}!void {
+pub inline fn expectEqualDeep(expected: anytype, actual: anytype) error{TestExpectedEqual}!void {
+    const T = @TypeOf(expected, actual);
+    return expectEqualDeepInner(T, expected, actual);
+}
+
+fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpectedEqual}!void {
     switch (@typeInfo(@TypeOf(actual))) {
         .NoReturn,
         .Opaque,

From 4c1da0912a474228750362a11db85799cac311b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carl=20=C3=85stholm?= <carl@astholm.se>
Date: Sat, 7 Oct 2023 22:42:12 +0200
Subject: [PATCH 2/4] Fix compile errors from the `expectEqual` change

---
 lib/std/math/float.zig          | 30 +++++++++++++++---------------
 lib/std/mem.zig                 | 10 ++++++----
 lib/std/multi_array_list.zig    | 24 ++++++++++++------------
 test/behavior/cast.zig          |  2 +-
 test/behavior/packed-struct.zig |  2 +-
 test/behavior/type.zig          |  4 ++--
 test/c_abi/main.zig             |  6 +++---
 7 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig
index a8de2dd7202f..fdebdf16a118 100644
--- a/lib/std/math/float.zig
+++ b/lib/std/math/float.zig
@@ -138,11 +138,11 @@ test "math.inf" {
     const inf_u64: u64 = 0x7FF0000000000000;
     const inf_u80: u80 = 0x7FFF8000000000000000;
     const inf_u128: u128 = 0x7FFF0000000000000000000000000000;
-    try expectEqual(inf_u16, @bitCast(inf(f16)));
-    try expectEqual(inf_u32, @bitCast(inf(f32)));
-    try expectEqual(inf_u64, @bitCast(inf(f64)));
-    try expectEqual(inf_u80, @bitCast(inf(f80)));
-    try expectEqual(inf_u128, @bitCast(inf(f128)));
+    try expectEqual(inf_u16, @as(u16, @bitCast(inf(f16))));
+    try expectEqual(inf_u32, @as(u32, @bitCast(inf(f32))));
+    try expectEqual(inf_u64, @as(u64, @bitCast(inf(f64))));
+    try expectEqual(inf_u80, @as(u80, @bitCast(inf(f80))));
+    try expectEqual(inf_u128, @as(u128, @bitCast(inf(f128))));
 }
 
 test "math.nan" {
@@ -151,11 +151,11 @@ test "math.nan" {
     const qnan_u64: u64 = 0x7FF8000000000000;
     const qnan_u80: u80 = 0x7FFFC000000000000000;
     const qnan_u128: u128 = 0x7FFF8000000000000000000000000000;
-    try expectEqual(qnan_u16, @bitCast(nan(f16)));
-    try expectEqual(qnan_u32, @bitCast(nan(f32)));
-    try expectEqual(qnan_u64, @bitCast(nan(f64)));
-    try expectEqual(qnan_u80, @bitCast(nan(f80)));
-    try expectEqual(qnan_u128, @bitCast(nan(f128)));
+    try expectEqual(qnan_u16, @as(u16, @bitCast(nan(f16))));
+    try expectEqual(qnan_u32, @as(u32, @bitCast(nan(f32))));
+    try expectEqual(qnan_u64, @as(u64, @bitCast(nan(f64))));
+    try expectEqual(qnan_u80, @as(u80, @bitCast(nan(f80))));
+    try expectEqual(qnan_u128, @as(u128, @bitCast(nan(f128))));
 }
 
 test "math.snan" {
@@ -167,9 +167,9 @@ test "math.snan" {
     const snan_u64: u64 = 0x7FF4000000000000;
     const snan_u80: u80 = 0x7FFFA000000000000000;
     const snan_u128: u128 = 0x7FFF4000000000000000000000000000;
-    try expectEqual(snan_u16, @bitCast(snan(f16)));
-    try expectEqual(snan_u32, @bitCast(snan(f32)));
-    try expectEqual(snan_u64, @bitCast(snan(f64)));
-    try expectEqual(snan_u80, @bitCast(snan(f80)));
-    try expectEqual(snan_u128, @bitCast(snan(f128)));
+    try expectEqual(snan_u16, @as(u16, @bitCast(snan(f16))));
+    try expectEqual(snan_u32, @as(u32, @bitCast(snan(f32))));
+    try expectEqual(snan_u64, @as(u64, @bitCast(snan(f64))));
+    try expectEqual(snan_u80, @as(u80, @bitCast(snan(f80))));
+    try expectEqual(snan_u128, @as(u128, @bitCast(snan(f128))));
 }
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 8e325e0b8e12..1e9e9652a82d 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -3262,7 +3262,7 @@ test "indexOfMax" {
 /// Finds the indices of the smallest and largest number in a slice. O(n).
 /// Returns an anonymous struct with the fields `index_min` and `index_max`.
 /// `slice` must not be empty.
-pub fn indexOfMinMax(comptime T: type, slice: []const T) struct { index_min: usize, index_max: usize } {
+pub fn indexOfMinMax(comptime T: type, slice: []const T) IndexOfMinMaxResult {
     assert(slice.len > 0);
     var minVal = slice[0];
     var maxVal = slice[0];
@@ -3281,10 +3281,12 @@ pub fn indexOfMinMax(comptime T: type, slice: []const T) struct { index_min: usi
     return .{ .index_min = minIdx, .index_max = maxIdx };
 }
 
+pub const IndexOfMinMaxResult = struct { index_min: usize, index_max: usize };
+
 test "indexOfMinMax" {
-    try testing.expectEqual(indexOfMinMax(u8, "abcdefg"), .{ .index_min = 0, .index_max = 6 });
-    try testing.expectEqual(indexOfMinMax(u8, "gabcdef"), .{ .index_min = 1, .index_max = 0 });
-    try testing.expectEqual(indexOfMinMax(u8, "a"), .{ .index_min = 0, .index_max = 0 });
+    try testing.expectEqual(indexOfMinMax(u8, "abcdefg"), IndexOfMinMaxResult{ .index_min = 0, .index_max = 6 });
+    try testing.expectEqual(indexOfMinMax(u8, "gabcdef"), IndexOfMinMaxResult{ .index_min = 1, .index_max = 0 });
+    try testing.expectEqual(indexOfMinMax(u8, "a"), IndexOfMinMaxResult{ .index_min = 0, .index_max = 0 });
 }
 
 pub fn swap(comptime T: type, a: *T, b: *T) void {
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index 5ff51440281a..7187e25f0fa8 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -842,24 +842,24 @@ test "union" {
         &.{ .a, .b, .b, .a, .a, .a, .a, .a, .a },
         list.items(.tags),
     );
-    try testing.expectEqual(list.get(0), .{ .a = 1 });
-    try testing.expectEqual(list.get(1), .{ .b = "zigzag" });
-    try testing.expectEqual(list.get(2), .{ .b = "foobar" });
-    try testing.expectEqual(list.get(3), .{ .a = 4 });
-    try testing.expectEqual(list.get(4), .{ .a = 5 });
-    try testing.expectEqual(list.get(5), .{ .a = 6 });
-    try testing.expectEqual(list.get(6), .{ .a = 7 });
-    try testing.expectEqual(list.get(7), .{ .a = 8 });
-    try testing.expectEqual(list.get(8), .{ .a = 9 });
+    try testing.expectEqual(list.get(0), Foo{ .a = 1 });
+    try testing.expectEqual(list.get(1), Foo{ .b = "zigzag" });
+    try testing.expectEqual(list.get(2), Foo{ .b = "foobar" });
+    try testing.expectEqual(list.get(3), Foo{ .a = 4 });
+    try testing.expectEqual(list.get(4), Foo{ .a = 5 });
+    try testing.expectEqual(list.get(5), Foo{ .a = 6 });
+    try testing.expectEqual(list.get(6), Foo{ .a = 7 });
+    try testing.expectEqual(list.get(7), Foo{ .a = 8 });
+    try testing.expectEqual(list.get(8), Foo{ .a = 9 });
 
     list.shrinkAndFree(ally, 3);
 
     try testing.expectEqual(@as(usize, 3), list.items(.tags).len);
     try testing.expectEqualSlices(meta.Tag(Foo), list.items(.tags), &.{ .a, .b, .b });
 
-    try testing.expectEqual(list.get(0), .{ .a = 1 });
-    try testing.expectEqual(list.get(1), .{ .b = "zigzag" });
-    try testing.expectEqual(list.get(2), .{ .b = "foobar" });
+    try testing.expectEqual(list.get(0), Foo{ .a = 1 });
+    try testing.expectEqual(list.get(1), Foo{ .b = "zigzag" });
+    try testing.expectEqual(list.get(2), Foo{ .b = "foobar" });
 }
 
 test "sorting a span" {
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index f0a1f602359f..10f3e80e2163 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1156,7 +1156,7 @@ test "cast function with an opaque parameter" {
         .func = @ptrCast(&Foo.funcImpl),
     };
     c.func(c.ctx);
-    try std.testing.expectEqual(foo, .{ .x = 101, .y = 201 });
+    try std.testing.expectEqual(foo, Foo{ .x = 101, .y = 201 });
 }
 
 test "implicit ptr to *anyopaque" {
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index f4aceaa82d93..c684bafcb345 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -1033,7 +1033,7 @@ test "modify nested packed struct aligned field" {
 
     var opts = Options{};
     opts.pretty_print.indent += 1;
-    try std.testing.expectEqual(@as(u17, 0b00000000100100000), @bitCast(opts));
+    try std.testing.expectEqual(@as(u17, 0b00000000100100000), @as(u17, @bitCast(opts)));
     try std.testing.expect(!opts.foo);
     try std.testing.expect(!opts.bar);
     try std.testing.expect(!opts.pretty_print.enabled);
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index 64c4c856693c..49ab54f48f99 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -438,9 +438,9 @@ test "Type.Union" {
         },
     });
     var tagged = Tagged{ .signed = -1 };
-    try testing.expectEqual(Tag.signed, tagged);
+    try testing.expectEqual(Tag.signed, @as(Tag, tagged));
     tagged = .{ .unsigned = 1 };
-    try testing.expectEqual(Tag.unsigned, tagged);
+    try testing.expectEqual(Tag.unsigned, @as(Tag, tagged));
 }
 
 test "Type.Union from Type.Enum" {
diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig
index d845f89eee39..919d2c908344 100644
--- a/test/c_abi/main.zig
+++ b/test/c_abi/main.zig
@@ -946,7 +946,7 @@ test "DC: C returns to Zig" {
     if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_DC(), .{ .v1 = -0.25, .v2 = 15 });
+    try expectEqual(c_ret_DC(), DC{ .v1 = -0.25, .v2 = 15 });
 }
 
 pub extern fn c_assert_DC(lv: DC) c_int;
@@ -998,7 +998,7 @@ test "CFF: C returns to Zig" {
     if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_CFF(), .{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 });
+    try expectEqual(c_ret_CFF(), CFF{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 });
 }
 pub extern fn c_assert_CFF(lv: CFF) c_int;
 pub extern fn c_assert_ret_CFF() c_int;
@@ -1045,7 +1045,7 @@ test "PD: C returns to Zig" {
     if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_PD(), .{ .v1 = null, .v2 = 0.5 });
+    try expectEqual(c_ret_PD(), PD{ .v1 = null, .v2 = 0.5 });
 }
 pub extern fn c_assert_PD(lv: PD) c_int;
 pub extern fn c_assert_ret_PD() c_int;

From d7b36503cad1de60cd0b6a115ef7ac336a03a09a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carl=20=C3=85stholm?= <carl@astholm.se>
Date: Sat, 7 Oct 2023 22:46:35 +0200
Subject: [PATCH 3/4] Remove some `@as` coercions from assertions

These are some spurious fixes to help illustrate the improved ergonomics of the `expectEqual` change. It is by no means complete.
---
 lib/std/debug.zig               |  4 +--
 lib/std/http.zig                |  4 +--
 lib/std/json/static_test.zig    | 26 ++++++++---------
 test/behavior/packed-struct.zig | 50 ++++++++++++++++-----------------
 4 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 2f515a287b22..179e821da22f 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -853,8 +853,8 @@ test "machoSearchSymbols" {
         .{ .addr = 300, .strx = undefined, .size = undefined, .ofile = undefined },
     };
 
-    try testing.expectEqual(@as(?*const MachoSymbol, null), machoSearchSymbols(&symbols, 0));
-    try testing.expectEqual(@as(?*const MachoSymbol, null), machoSearchSymbols(&symbols, 99));
+    try testing.expectEqual(null, machoSearchSymbols(&symbols, 0));
+    try testing.expectEqual(null, machoSearchSymbols(&symbols, 99));
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 100).?);
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 150).?);
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 199).?);
diff --git a/lib/std/http.zig b/lib/std/http.zig
index 9487e82106a4..9b2bce133814 100644
--- a/lib/std/http.zig
+++ b/lib/std/http.zig
@@ -283,8 +283,8 @@ pub const Status = enum(u10) {
     }
 
     test {
-        try std.testing.expectEqual(@as(?Status.Class, Status.Class.success), Status.ok.class());
-        try std.testing.expectEqual(@as(?Status.Class, Status.Class.client_error), Status.not_found.class());
+        try std.testing.expectEqual(Status.Class.success, Status.ok.class());
+        try std.testing.expectEqual(Status.Class.client_error, Status.not_found.class());
     }
 };
 
diff --git a/lib/std/json/static_test.zig b/lib/std/json/static_test.zig
index e3d296584c4c..1c89e05226ed 100644
--- a/lib/std/json/static_test.zig
+++ b/lib/std/json/static_test.zig
@@ -373,19 +373,19 @@ test "test all types" {
 test "parse" {
     try testing.expectEqual(false, try parseFromSliceLeaky(bool, testing.allocator, "false", .{}));
     try testing.expectEqual(true, try parseFromSliceLeaky(bool, testing.allocator, "true", .{}));
-    try testing.expectEqual(@as(u1, 1), try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
+    try testing.expectEqual(1, try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
     try testing.expectError(error.Overflow, parseFromSliceLeaky(u1, testing.allocator, "50", .{}));
-    try testing.expectEqual(@as(u64, 42), try parseFromSliceLeaky(u64, testing.allocator, "42", .{}));
-    try testing.expectEqual(@as(f64, 42), try parseFromSliceLeaky(f64, testing.allocator, "42.0", .{}));
-    try testing.expectEqual(@as(?bool, null), try parseFromSliceLeaky(?bool, testing.allocator, "null", .{}));
-    try testing.expectEqual(@as(?bool, true), try parseFromSliceLeaky(?bool, testing.allocator, "true", .{}));
+    try testing.expectEqual(42, try parseFromSliceLeaky(u64, testing.allocator, "42", .{}));
+    try testing.expectEqual(42, try parseFromSliceLeaky(f64, testing.allocator, "42.0", .{}));
+    try testing.expectEqual(null, try parseFromSliceLeaky(?bool, testing.allocator, "null", .{}));
+    try testing.expectEqual(true, try parseFromSliceLeaky(?bool, testing.allocator, "true", .{}));
 
-    try testing.expectEqual(@as([3]u8, "foo".*), try parseFromSliceLeaky([3]u8, testing.allocator, "\"foo\"", .{}));
-    try testing.expectEqual(@as([3]u8, "foo".*), try parseFromSliceLeaky([3]u8, testing.allocator, "[102, 111, 111]", .{}));
-    try testing.expectEqual(@as([0]u8, undefined), try parseFromSliceLeaky([0]u8, testing.allocator, "[]", .{}));
+    try testing.expectEqual("foo".*, try parseFromSliceLeaky([3]u8, testing.allocator, "\"foo\"", .{}));
+    try testing.expectEqual("foo".*, try parseFromSliceLeaky([3]u8, testing.allocator, "[102, 111, 111]", .{}));
+    try testing.expectEqual(undefined, try parseFromSliceLeaky([0]u8, testing.allocator, "[]", .{}));
 
-    try testing.expectEqual(@as(u64, 12345678901234567890), try parseFromSliceLeaky(u64, testing.allocator, "\"12345678901234567890\"", .{}));
-    try testing.expectEqual(@as(f64, 123.456), try parseFromSliceLeaky(f64, testing.allocator, "\"123.456\"", .{}));
+    try testing.expectEqual(12345678901234567890, try parseFromSliceLeaky(u64, testing.allocator, "\"12345678901234567890\"", .{}));
+    try testing.expectEqual(123.456, try parseFromSliceLeaky(f64, testing.allocator, "\"123.456\"", .{}));
 }
 
 test "parse into enum" {
@@ -394,9 +394,9 @@ test "parse into enum" {
         Bar,
         @"with\\escape",
     };
-    try testing.expectEqual(@as(T, .Foo), try parseFromSliceLeaky(T, testing.allocator, "\"Foo\"", .{}));
-    try testing.expectEqual(@as(T, .Foo), try parseFromSliceLeaky(T, testing.allocator, "42", .{}));
-    try testing.expectEqual(@as(T, .@"with\\escape"), try parseFromSliceLeaky(T, testing.allocator, "\"with\\\\escape\"", .{}));
+    try testing.expectEqual(.Foo, try parseFromSliceLeaky(T, testing.allocator, "\"Foo\"", .{}));
+    try testing.expectEqual(.Foo, try parseFromSliceLeaky(T, testing.allocator, "42", .{}));
+    try testing.expectEqual(.@"with\\escape", try parseFromSliceLeaky(T, testing.allocator, "\"with\\\\escape\"", .{}));
     try testing.expectError(error.InvalidEnumTag, parseFromSliceLeaky(T, testing.allocator, "5", .{}));
     try testing.expectError(error.InvalidEnumTag, parseFromSliceLeaky(T, testing.allocator, "\"Qux\"", .{}));
 }
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index c684bafcb345..d99bcc1b6e9b 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -173,17 +173,17 @@ test "correct sizeOf and offsets in packed structs" {
         try expectEqual(true, s1.bool_d);
         try expectEqual(true, s1.bool_e);
         try expectEqual(true, s1.bool_f);
-        try expectEqual(@as(u1, 1), s1.u1_a);
+        try expectEqual(1, s1.u1_a);
         try expectEqual(false, s1.bool_g);
-        try expectEqual(@as(u1, 0), s1.u1_b);
-        try expectEqual(@as(u3, 3), s1.u3_a);
-        try expectEqual(@as(u10, 0b1101000101), s1.u10_a);
-        try expectEqual(@as(u10, 0b0001001000), s1.u10_b);
+        try expectEqual(0, s1.u1_b);
+        try expectEqual(3, s1.u3_a);
+        try expectEqual(0b1101000101, s1.u10_a);
+        try expectEqual(0b0001001000, s1.u10_b);
 
         const s2 = @as(packed struct { x: u1, y: u7, z: u24 }, @bitCast(@as(u32, 0xd5c71ff4)));
-        try expectEqual(@as(u1, 0), s2.x);
-        try expectEqual(@as(u7, 0b1111010), s2.y);
-        try expectEqual(@as(u24, 0xd5c71f), s2.z);
+        try expectEqual(0, s2.x);
+        try expectEqual(0b1111010, s2.y);
+        try expectEqual(0xd5c71f, s2.z);
     }
 }
 
@@ -208,12 +208,12 @@ test "nested packed structs" {
 
     if (native_endian == .little) {
         const s3 = @as(S3Padded, @bitCast(@as(u64, 0xe952d5c71ff4))).s3;
-        try expectEqual(@as(u8, 0xf4), s3.x.a);
-        try expectEqual(@as(u8, 0x1f), s3.x.b);
-        try expectEqual(@as(u8, 0xc7), s3.x.c);
-        try expectEqual(@as(u8, 0xd5), s3.y.d);
-        try expectEqual(@as(u8, 0x52), s3.y.e);
-        try expectEqual(@as(u8, 0xe9), s3.y.f);
+        try expectEqual(0xf4, s3.x.a);
+        try expectEqual(0x1f, s3.x.b);
+        try expectEqual(0xc7, s3.x.c);
+        try expectEqual(0xd5, s3.y.d);
+        try expectEqual(0x52, s3.y.e);
+        try expectEqual(0xe9, s3.y.f);
     }
 
     const S4 = packed struct { a: i32, b: i8 };
@@ -249,8 +249,8 @@ test "regular in irregular packed struct" {
     foo.bar.a = 235;
     foo.bar.b = 42;
 
-    try expectEqual(@as(u16, 235), foo.bar.a);
-    try expectEqual(@as(u8, 42), foo.bar.b);
+    try expectEqual(235, foo.bar.a);
+    try expectEqual(42, foo.bar.b);
 }
 
 test "nested packed struct unaligned" {
@@ -456,12 +456,12 @@ test "nested packed struct field pointers" {
     const ptr_p0_c = &S2.s.p0.c;
     const ptr_p1_a = &S2.s.p1.a;
     const ptr_p1_b = &S2.s.p1.b;
-    try expectEqual(@as(u8, 1), ptr_base.*);
-    try expectEqual(@as(u4, 2), ptr_p0_a.*);
-    try expectEqual(@as(u4, 3), ptr_p0_b.*);
-    try expectEqual(@as(u8, 4), ptr_p0_c.*);
-    try expectEqual(@as(u7, 5), ptr_p1_a.*);
-    try expectEqual(@as(u8, 6), ptr_p1_b.*);
+    try expectEqual(1, ptr_base.*);
+    try expectEqual(2, ptr_p0_a.*);
+    try expectEqual(3, ptr_p0_b.*);
+    try expectEqual(4, ptr_p0_c.*);
+    try expectEqual(5, ptr_p1_a.*);
+    try expectEqual(6, ptr_p1_b.*);
 }
 
 test "load pointer from packed struct" {
@@ -1033,12 +1033,12 @@ test "modify nested packed struct aligned field" {
 
     var opts = Options{};
     opts.pretty_print.indent += 1;
-    try std.testing.expectEqual(@as(u17, 0b00000000100100000), @as(u17, @bitCast(opts)));
+    try std.testing.expectEqual(0b00000000100100000, @as(u17, @bitCast(opts)));
     try std.testing.expect(!opts.foo);
     try std.testing.expect(!opts.bar);
     try std.testing.expect(!opts.pretty_print.enabled);
-    try std.testing.expectEqual(@as(u4, 4), opts.pretty_print.num_spaces);
-    try std.testing.expectEqual(@as(u8, 1), opts.pretty_print.indent);
+    try std.testing.expectEqual(4, opts.pretty_print.num_spaces);
+    try std.testing.expectEqual(1, opts.pretty_print.indent);
     try std.testing.expect(!opts.baz);
 }
 

From 85869f8225dc3f2d21fe540559e05fd1fa94d5ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carl=20=C3=85stholm?= <carl@astholm.se>
Date: Mon, 1 Jan 2024 17:37:32 +0100
Subject: [PATCH 4/4] Correct expected/actual parameter order of some
 assertions

---
 lib/std/mem.zig              |  6 +++---
 lib/std/multi_array_list.zig | 24 ++++++++++++------------
 test/behavior/cast.zig       |  2 +-
 test/c_abi/main.zig          |  6 +++---
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 1e9e9652a82d..cee4322879d2 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -3284,9 +3284,9 @@ pub fn indexOfMinMax(comptime T: type, slice: []const T) IndexOfMinMaxResult {
 pub const IndexOfMinMaxResult = struct { index_min: usize, index_max: usize };
 
 test "indexOfMinMax" {
-    try testing.expectEqual(indexOfMinMax(u8, "abcdefg"), IndexOfMinMaxResult{ .index_min = 0, .index_max = 6 });
-    try testing.expectEqual(indexOfMinMax(u8, "gabcdef"), IndexOfMinMaxResult{ .index_min = 1, .index_max = 0 });
-    try testing.expectEqual(indexOfMinMax(u8, "a"), IndexOfMinMaxResult{ .index_min = 0, .index_max = 0 });
+    try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 0, .index_max = 6 }, indexOfMinMax(u8, "abcdefg"));
+    try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 1, .index_max = 0 }, indexOfMinMax(u8, "gabcdef"));
+    try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 0, .index_max = 0 }, indexOfMinMax(u8, "a"));
 }
 
 pub fn swap(comptime T: type, a: *T, b: *T) void {
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index 7187e25f0fa8..6ac3ad73e297 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -842,24 +842,24 @@ test "union" {
         &.{ .a, .b, .b, .a, .a, .a, .a, .a, .a },
         list.items(.tags),
     );
-    try testing.expectEqual(list.get(0), Foo{ .a = 1 });
-    try testing.expectEqual(list.get(1), Foo{ .b = "zigzag" });
-    try testing.expectEqual(list.get(2), Foo{ .b = "foobar" });
-    try testing.expectEqual(list.get(3), Foo{ .a = 4 });
-    try testing.expectEqual(list.get(4), Foo{ .a = 5 });
-    try testing.expectEqual(list.get(5), Foo{ .a = 6 });
-    try testing.expectEqual(list.get(6), Foo{ .a = 7 });
-    try testing.expectEqual(list.get(7), Foo{ .a = 8 });
-    try testing.expectEqual(list.get(8), Foo{ .a = 9 });
+    try testing.expectEqual(Foo{ .a = 1 }, list.get(0));
+    try testing.expectEqual(Foo{ .b = "zigzag" }, list.get(1));
+    try testing.expectEqual(Foo{ .b = "foobar" }, list.get(2));
+    try testing.expectEqual(Foo{ .a = 4 }, list.get(3));
+    try testing.expectEqual(Foo{ .a = 5 }, list.get(4));
+    try testing.expectEqual(Foo{ .a = 6 }, list.get(5));
+    try testing.expectEqual(Foo{ .a = 7 }, list.get(6));
+    try testing.expectEqual(Foo{ .a = 8 }, list.get(7));
+    try testing.expectEqual(Foo{ .a = 9 }, list.get(8));
 
     list.shrinkAndFree(ally, 3);
 
     try testing.expectEqual(@as(usize, 3), list.items(.tags).len);
     try testing.expectEqualSlices(meta.Tag(Foo), list.items(.tags), &.{ .a, .b, .b });
 
-    try testing.expectEqual(list.get(0), Foo{ .a = 1 });
-    try testing.expectEqual(list.get(1), Foo{ .b = "zigzag" });
-    try testing.expectEqual(list.get(2), Foo{ .b = "foobar" });
+    try testing.expectEqual(Foo{ .a = 1 }, list.get(0));
+    try testing.expectEqual(Foo{ .b = "zigzag" }, list.get(1));
+    try testing.expectEqual(Foo{ .b = "foobar" }, list.get(2));
 }
 
 test "sorting a span" {
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 10f3e80e2163..d7f347c8007e 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1156,7 +1156,7 @@ test "cast function with an opaque parameter" {
         .func = @ptrCast(&Foo.funcImpl),
     };
     c.func(c.ctx);
-    try std.testing.expectEqual(foo, Foo{ .x = 101, .y = 201 });
+    try std.testing.expectEqual(Foo{ .x = 101, .y = 201 }, foo);
 }
 
 test "implicit ptr to *anyopaque" {
diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig
index 919d2c908344..90bfe174ca9a 100644
--- a/test/c_abi/main.zig
+++ b/test/c_abi/main.zig
@@ -946,7 +946,7 @@ test "DC: C returns to Zig" {
     if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_DC(), DC{ .v1 = -0.25, .v2 = 15 });
+    try expectEqual(DC{ .v1 = -0.25, .v2 = 15 }, c_ret_DC());
 }
 
 pub extern fn c_assert_DC(lv: DC) c_int;
@@ -998,7 +998,7 @@ test "CFF: C returns to Zig" {
     if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_CFF(), CFF{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 });
+    try expectEqual(CFF{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }, c_ret_CFF());
 }
 pub extern fn c_assert_CFF(lv: CFF) c_int;
 pub extern fn c_assert_ret_CFF() c_int;
@@ -1045,7 +1045,7 @@ test "PD: C returns to Zig" {
     if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
     if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
-    try expectEqual(c_ret_PD(), PD{ .v1 = null, .v2 = 0.5 });
+    try expectEqual(PD{ .v1 = null, .v2 = 0.5 }, c_ret_PD());
 }
 pub extern fn c_assert_PD(lv: PD) c_int;
 pub extern fn c_assert_ret_PD() c_int;