diff --git a/lib/std/ascii.zig b/lib/std/ascii.zig
index e47ef4db65..70bc2c5050 100644
--- a/lib/std/ascii.zig
+++ b/lib/std/ascii.zig
@@ -147,7 +147,7 @@ pub fn isWhitespace(c: u8) bool {
 /// See also: `isWhitespace`
 pub const whitespace = [_]u8{ ' ', '\t', '\n', '\r', control_code.vt, control_code.ff };
 
-test "whitespace" {
+test whitespace {
     for (whitespace) |char| try std.testing.expect(isWhitespace(char));
 
     var i: u8 = 0;
@@ -278,7 +278,7 @@ pub fn lowerString(output: []u8, ascii_string: []const u8) []u8 {
     return output[0..ascii_string.len];
 }
 
-test "lowerString" {
+test lowerString {
     var buf: [1024]u8 = undefined;
     const result = lowerString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");
     try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);
@@ -291,7 +291,7 @@ pub fn allocLowerString(allocator: std.mem.Allocator, ascii_string: []const u8)
     return lowerString(result, ascii_string);
 }
 
-test "allocLowerString" {
+test allocLowerString {
     const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);
@@ -307,7 +307,7 @@ pub fn upperString(output: []u8, ascii_string: []const u8) []u8 {
     return output[0..ascii_string.len];
 }
 
-test "upperString" {
+test upperString {
     var buf: [1024]u8 = undefined;
     const result = upperString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");
     try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);
@@ -320,7 +320,7 @@ pub fn allocUpperString(allocator: std.mem.Allocator, ascii_string: []const u8)
     return upperString(result, ascii_string);
 }
 
-test "allocUpperString" {
+test allocUpperString {
     const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);
@@ -335,7 +335,7 @@ pub fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {
     return true;
 }
 
-test "eqlIgnoreCase" {
+test eqlIgnoreCase {
     try std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));
     try std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));
     try std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));
@@ -345,7 +345,7 @@ pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
     return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[0..needle.len], needle);
 }
 
-test "startsWithIgnoreCase" {
+test startsWithIgnoreCase {
     try std.testing.expect(startsWithIgnoreCase("boB", "Bo"));
     try std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));
 }
@@ -354,7 +354,7 @@ pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
     return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[haystack.len - needle.len ..], needle);
 }
 
-test "endsWithIgnoreCase" {
+test endsWithIgnoreCase {
     try std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));
     try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));
 }
@@ -409,7 +409,7 @@ fn boyerMooreHorspoolPreprocessIgnoreCase(pattern: []const u8, table: *[256]usiz
     }
 }
 
-test "indexOfIgnoreCase" {
+test indexOfIgnoreCase {
     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);
diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig
index a27c5b28a3..d70f425e61 100644
--- a/lib/std/bit_set.zig
+++ b/lib/std/bit_set.zig
@@ -1648,7 +1648,7 @@ fn testStaticBitSet(comptime Set: type) !void {
     try testPureBitSet(Set);
 }
 
-test "IntegerBitSet" {
+test IntegerBitSet {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     try testStaticBitSet(IntegerBitSet(0));
@@ -1661,7 +1661,7 @@ test "IntegerBitSet" {
     try testStaticBitSet(IntegerBitSet(127));
 }
 
-test "ArrayBitSet" {
+test ArrayBitSet {
     inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {
         try testStaticBitSet(ArrayBitSet(u8, size));
         try testStaticBitSet(ArrayBitSet(u16, size));
@@ -1671,7 +1671,7 @@ test "ArrayBitSet" {
     }
 }
 
-test "DynamicBitSetUnmanaged" {
+test DynamicBitSetUnmanaged {
     const allocator = std.testing.allocator;
     var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
@@ -1724,7 +1724,7 @@ test "DynamicBitSetUnmanaged" {
     }
 }
 
-test "DynamicBitSet" {
+test DynamicBitSet {
     const allocator = std.testing.allocator;
     var a = try DynamicBitSet.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
@@ -1765,7 +1765,7 @@ test "DynamicBitSet" {
     }
 }
 
-test "StaticBitSet" {
+test StaticBitSet {
     try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));
     try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));
     try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));
diff --git a/lib/std/bounded_array.zig b/lib/std/bounded_array.zig
index 9867754dcd..d41857013c 100644
--- a/lib/std/bounded_array.zig
+++ b/lib/std/bounded_array.zig
@@ -287,7 +287,7 @@ pub fn BoundedArrayAligned(
     };
 }
 
-test "BoundedArray" {
+test BoundedArray {
     var a = try BoundedArray(u8, 64).init(32);
 
     try testing.expectEqual(a.capacity(), 64);
diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig
index c9db06d40b..dcc00b77d5 100644
--- a/lib/std/child_process.zig
+++ b/lib/std/child_process.zig
@@ -1231,7 +1231,7 @@ fn windowsCreateProcessSupportsExtension(ext: []const u16) ?CreateProcessSupport
     return null;
 }
 
-test "windowsCreateProcessSupportsExtension" {
+test windowsCreateProcessSupportsExtension {
     try std.testing.expectEqual(CreateProcessSupportedExtension.exe, windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e' }).?);
     try std.testing.expect(windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e', 'c' }) == null);
 }
@@ -1322,7 +1322,7 @@ pub fn argvToCommandLineWindows(
     return try unicode.wtf8ToWtf16LeAllocZ(allocator, buf.items);
 }
 
-test "argvToCommandLineWindows" {
+test argvToCommandLineWindows {
     const t = testArgvToCommandLineWindows;
 
     try t(&.{
@@ -1556,7 +1556,7 @@ pub fn createNullDelimitedEnvMap(arena: mem.Allocator, env_map: *const EnvMap) !
     return envp_buf;
 }
 
-test "createNullDelimitedEnvMap" {
+test createNullDelimitedEnvMap {
     const testing = std.testing;
     const allocator = testing.allocator;
     var envmap = EnvMap.init(allocator);
diff --git a/lib/std/crypto/utils.zig b/lib/std/crypto/utils.zig
index 37f2b06a5e..fd5544c45b 100644
--- a/lib/std/crypto/utils.zig
+++ b/lib/std/crypto/utils.zig
@@ -138,7 +138,7 @@ pub inline fn secureZero(comptime T: type, s: []T) void {
     @memset(@as([]volatile T, s), 0);
 }
 
-test "timingSafeEql" {
+test timingSafeEql {
     var a: [100]u8 = undefined;
     var b: [100]u8 = undefined;
     random.bytes(a[0..]);
@@ -162,7 +162,7 @@ test "timingSafeEql (vectors)" {
     try testing.expect(timingSafeEql(@Vector(100, u8), v1, v3));
 }
 
-test "timingSafeCompare" {
+test timingSafeCompare {
     var a = [_]u8{10} ** 32;
     var b = [_]u8{10} ** 32;
     try testing.expectEqual(timingSafeCompare(u8, &a, &b, .big), .eq);
@@ -195,7 +195,7 @@ test "timingSafe{Add,Sub}" {
     }
 }
 
-test "secureZero" {
+test secureZero {
     var a = [_]u8{0xfe} ** 8;
     var b = [_]u8{0xfe} ** 8;
 
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 7baa02fe74..053f27a39d 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -905,7 +905,7 @@ fn machoSearchSymbols(symbols: []const MachoSymbol, address: usize) ?*const Mach
     return null;
 }
 
-test "machoSearchSymbols" {
+test machoSearchSymbols {
     const symbols = [_]MachoSymbol{
         .{ .addr = 100, .strx = undefined, .size = undefined, .ofile = undefined },
         .{ .addr = 200, .strx = undefined, .size = undefined, .ofile = undefined },
@@ -1504,7 +1504,7 @@ fn printLineFromFileAnyOs(out_stream: anytype, line_info: LineInfo) !void {
     }
 }
 
-test "printLineFromFileAnyOs" {
+test printLineFromFileAnyOs {
     var output = std.ArrayList(u8).init(std.testing.allocator);
     defer output.deinit();
     const output_stream = output.writer();
diff --git a/lib/std/fifo.zig b/lib/std/fifo.zig
index a260867002..b07e870f04 100644
--- a/lib/std/fifo.zig
+++ b/lib/std/fifo.zig
@@ -507,7 +507,7 @@ test "LinearFifo(u8, .Dynamic)" {
     }
 }
 
-test "LinearFifo" {
+test LinearFifo {
     inline for ([_]type{ u1, u8, u16, u64 }) |T| {
         inline for ([_]LinearFifoBufferType{ LinearFifoBufferType{ .Static = 32 }, .Slice, .Dynamic }) |bt| {
             const FifoType = LinearFifo(T, bt);
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index e5b359d30f..c4a170b67f 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -1303,7 +1303,7 @@ pub fn fmtDuration(ns: u64) Formatter(formatDuration) {
     return .{ .data = data };
 }
 
-test "fmtDuration" {
+test fmtDuration {
     var buf: [24]u8 = undefined;
     inline for (.{
         .{ .s = "0ns", .d = 0 },
@@ -1367,7 +1367,7 @@ pub fn fmtDurationSigned(ns: i64) Formatter(formatDurationSigned) {
     return .{ .data = ns };
 }
 
-test "fmtDurationSigned" {
+test fmtDurationSigned {
     var buf: [24]u8 = undefined;
     inline for (.{
         .{ .s = "0ns", .d = 0 },
@@ -1497,7 +1497,7 @@ pub fn parseInt(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
     return parseWithSign(T, buf, base, .pos);
 }
 
-test "parseInt" {
+test parseInt {
     try std.testing.expect((try parseInt(i32, "-10", 10)) == -10);
     try std.testing.expect((try parseInt(i32, "+10", 10)) == 10);
     try std.testing.expect((try parseInt(u32, "+10", 10)) == 10);
@@ -1639,7 +1639,7 @@ pub fn parseUnsigned(comptime T: type, buf: []const u8, base: u8) ParseIntError!
     return parseWithSign(T, buf, base, .pos);
 }
 
-test "parseUnsigned" {
+test parseUnsigned {
     try std.testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);
     try std.testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);
     try std.testing.expect((try parseUnsigned(u16, "65_535", 10)) == 65535);
@@ -1713,7 +1713,7 @@ pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
     return math.mul(usize, number, multiplier);
 }
 
-test "parseIntSizeSuffix" {
+test parseIntSizeSuffix {
     try std.testing.expect(try parseIntSizeSuffix("2", 10) == 2);
     try std.testing.expect(try parseIntSizeSuffix("2B", 10) == 2);
     try std.testing.expect(try parseIntSizeSuffix("2kB", 10) == 2000);
@@ -1796,7 +1796,7 @@ pub fn allocPrintZ(allocator: mem.Allocator, comptime fmt: []const u8, args: any
     return result[0 .. result.len - 1 :0];
 }
 
-test "bufPrintInt" {
+test bufPrintIntToSlice {
     var buffer: [100]u8 = undefined;
     const buf = buffer[0..];
 
@@ -1830,7 +1830,7 @@ pub inline fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [cou
     }
 }
 
-test "comptimePrint" {
+test comptimePrint {
     @setEvalBranchQuota(2000);
     try std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptimePrint("{}", .{100})));
     try std.testing.expectEqualSlices(u8, "100", comptimePrint("{}", .{100}));
@@ -2445,14 +2445,14 @@ pub fn hexToBytes(out: []u8, input: []const u8) ![]u8 {
     return out[0 .. in_i / 2];
 }
 
-test "bytesToHex" {
+test bytesToHex {
     const input = "input slice";
     const encoded = bytesToHex(input, .lower);
     var decoded: [input.len]u8 = undefined;
     try std.testing.expectEqualSlices(u8, input, try hexToBytes(&decoded, &encoded));
 }
 
-test "hexToBytes" {
+test hexToBytes {
     var buf: [32]u8 = undefined;
     try expectFmt("90" ** 32, "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "90" ** 32))});
     try expectFmt("ABCD", "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "ABCD"))});
diff --git a/lib/std/fs/get_app_data_dir.zig b/lib/std/fs/get_app_data_dir.zig
index 9c84291199..d7a2a6ed08 100644
--- a/lib/std/fs/get_app_data_dir.zig
+++ b/lib/std/fs/get_app_data_dir.zig
@@ -61,7 +61,7 @@ pub fn getAppDataDir(allocator: mem.Allocator, appname: []const u8) GetAppDataDi
     }
 }
 
-test "getAppDataDir" {
+test getAppDataDir {
     if (native_os == .wasi) return error.SkipZigTest;
 
     // We can't actually validate the result
diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig
index c297bb1e2a..3376771313 100644
--- a/lib/std/fs/path.zig
+++ b/lib/std/fs/path.zig
@@ -180,7 +180,7 @@ fn testJoinMaybeZPosix(paths: []const []const u8, expected: []const u8, zero: bo
     try testing.expectEqualSlices(u8, expected, if (zero) actual[0 .. actual.len - 1 :0] else actual);
 }
 
-test "join" {
+test join {
     {
         const actual: []u8 = try join(testing.allocator, &[_][]const u8{});
         defer testing.allocator.free(actual);
@@ -303,7 +303,7 @@ pub fn isAbsolutePosixZ(path_c: [*:0]const u8) bool {
     return isAbsolutePosix(mem.sliceTo(path_c, 0));
 }
 
-test "isAbsoluteWindows" {
+test isAbsoluteWindows {
     try testIsAbsoluteWindows("", false);
     try testIsAbsoluteWindows("/", true);
     try testIsAbsoluteWindows("//", true);
@@ -326,7 +326,7 @@ test "isAbsoluteWindows" {
     try testIsAbsoluteWindows("/usr/local", true);
 }
 
-test "isAbsolutePosix" {
+test isAbsolutePosix {
     try testIsAbsolutePosix("", false);
     try testIsAbsolutePosix("/home/foo", true);
     try testIsAbsolutePosix("/home/foo/..", true);
@@ -400,7 +400,7 @@ pub fn windowsParsePath(path: []const u8) WindowsPath {
     return relative_path;
 }
 
-test "windowsParsePath" {
+test windowsParsePath {
     {
         const parsed = windowsParsePath("//a/b");
         try testing.expect(parsed.is_abs);
@@ -884,7 +884,7 @@ pub fn dirnamePosix(path: []const u8) ?[]const u8 {
     return path[0..end_index];
 }
 
-test "dirnamePosix" {
+test dirnamePosix {
     try testDirnamePosix("/a/b/c", "/a/b");
     try testDirnamePosix("/a/b/c///", "/a/b");
     try testDirnamePosix("/a", "/");
@@ -898,7 +898,7 @@ test "dirnamePosix" {
     try testDirnamePosix("a//", null);
 }
 
-test "dirnameWindows" {
+test dirnameWindows {
     try testDirnameWindows("c:\\", null);
     try testDirnameWindows("c:\\foo", "c:\\");
     try testDirnameWindows("c:\\foo\\", "c:\\");
@@ -1011,7 +1011,7 @@ pub fn basenameWindows(path: []const u8) []const u8 {
     return path[start_index + 1 .. end_index];
 }
 
-test "basename" {
+test basename {
     try testBasename("", "");
     try testBasename("/", "");
     try testBasename("/dir/basename.ext", "basename.ext");
@@ -1186,7 +1186,7 @@ pub fn relativePosix(allocator: Allocator, from: []const u8, to: []const u8) ![]
     return [_]u8{};
 }
 
-test "relative" {
+test relative {
     try testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");
     try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");
     try testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");
@@ -1271,7 +1271,7 @@ fn testExtension(path: []const u8, expected: []const u8) !void {
     try testing.expectEqualStrings(expected, extension(path));
 }
 
-test "extension" {
+test extension {
     try testExtension("", "");
     try testExtension(".", "");
     try testExtension("a.", ".");
@@ -1328,7 +1328,7 @@ fn testStem(path: []const u8, expected: []const u8) !void {
     try testing.expectEqualStrings(expected, stem(path));
 }
 
-test "stem" {
+test stem {
     try testStem("hello/world/lib.tar.gz", "lib.tar");
     try testStem("hello/world/lib.tar", "lib");
     try testStem("hello/world/lib", "lib");
diff --git a/lib/std/io.zig b/lib/std/io.zig
index 58724c582e..9f0f444a83 100644
--- a/lib/std/io.zig
+++ b/lib/std/io.zig
@@ -421,7 +421,7 @@ fn dummyWrite(context: void, data: []const u8) error{}!usize {
     return data.len;
 }
 
-test "null_writer" {
+test null_writer {
     null_writer.writeAll("yay" ** 10) catch |err| switch (err) {};
 }
 
diff --git a/lib/std/math.zig b/lib/std/math.zig
index 403c19d20b..7524b8d2f5 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -167,26 +167,16 @@ pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool {
     return @abs(x - y) <= @max(@abs(x), @abs(y)) * tolerance;
 }
 
-test "approxEqAbs and approxEqRel" {
+test approxEqAbs {
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
         const eps_value = comptime floatEps(T);
-        const sqrt_eps_value = comptime sqrt(eps_value);
-        const nan_value = comptime nan(T);
-        const inf_value = comptime inf(T);
         const min_value = comptime floatMin(T);
 
         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 * eps_value, 1.0, eps_value));
         try testing.expect(approxEqAbs(T, 1.0 + 1 * eps_value, 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));
     }
@@ -198,18 +188,46 @@ test "approxEqAbs and approxEqRel" {
         // possible epsilon value like we do in the tests above. In the same vein, we
         // also can't represent a max/min, `NaN` or `Inf` values.
         const eps_value = 1e-4;
-        const sqrt_eps_value = sqrt(eps_value);
 
         try testing.expect(approxEqAbs(comptime_float, 0.0, 0.0, eps_value));
         try testing.expect(approxEqAbs(comptime_float, -0.0, -0.0, eps_value));
         try testing.expect(approxEqAbs(comptime_float, 0.0, -0.0, eps_value));
-        try testing.expect(approxEqRel(comptime_float, 1.0, 1.0, sqrt_eps_value));
-        try testing.expect(!approxEqRel(comptime_float, 1.0, 0.0, sqrt_eps_value));
         try testing.expect(!approxEqAbs(comptime_float, 1.0 + 2 * eps_value, 1.0, eps_value));
         try testing.expect(approxEqAbs(comptime_float, 1.0 + 1 * eps_value, 1.0, eps_value));
     }
 }
 
+test approxEqRel {
+    inline for ([_]type{ f16, f32, f64, f128 }) |T| {
+        const eps_value = comptime floatEps(T);
+        const sqrt_eps_value = comptime sqrt(eps_value);
+        const nan_value = comptime nan(T);
+        const inf_value = comptime inf(T);
+        const min_value = comptime floatMin(T);
+
+        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(!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));
+    }
+
+    comptime {
+        // `comptime_float` is guaranteed to have the same precision and operations of
+        // the largest other floating point type, which is f128 but it doesn't have a
+        // defined layout so we can't rely on `@bitCast` to construct the smallest
+        // possible epsilon value like we do in the tests above. In the same vein, we
+        // also can't represent a max/min, `NaN` or `Inf` values.
+        const eps_value = 1e-4;
+        const sqrt_eps_value = sqrt(eps_value);
+
+        try testing.expect(approxEqRel(comptime_float, 1.0, 1.0, sqrt_eps_value));
+        try testing.expect(!approxEqRel(comptime_float, 1.0, 0.0, sqrt_eps_value));
+    }
+}
+
 pub const doNotOptimizeAway = @compileError("Deprecated: use `std.mem.doNotOptimizeAway` instead");
 
 pub fn raiseInvalid() void {
@@ -310,7 +328,7 @@ pub fn radiansToDegrees(ang: anytype) if (@TypeOf(ang) == comptime_int) comptime
     @compileError("Input must be float or a comptime number, or a vector of floats.");
 }
 
-test "radiansToDegrees" {
+test radiansToDegrees {
     const zero: f32 = 0;
     const half_pi: f32 = pi / 2.0;
     const neg_quart_pi: f32 = -pi / 4.0;
@@ -345,7 +363,7 @@ pub fn degreesToRadians(ang: anytype) if (@TypeOf(ang) == comptime_int) comptime
     @compileError("Input must be float or a comptime number, or a vector of floats.");
 }
 
-test "degreesToRadians" {
+test degreesToRadians {
     const ninety: f32 = 90;
     const neg_two_seventy: f32 = -270;
     const three_sixty: f32 = 360;
@@ -506,7 +524,7 @@ pub fn wrap(x: anytype, r: anytype) @TypeOf(x) {
         },
     }
 }
-test "wrap" {
+test wrap {
     // Within range
     try testing.expect(wrap(@as(i32, -75), @as(i32, 180)) == -75);
     try testing.expect(wrap(@as(i32, -75), @as(i32, -180)) == -75);
@@ -543,8 +561,7 @@ test "wrap" {
     var i: i32 = 1;
     _ = &i;
     try testing.expect(wrap(i, 10) == 1);
-}
-test wrap {
+
     const limit: i32 = 180;
     // Within range
     try testing.expect(wrap(@as(i32, -75), limit) == -75);
@@ -569,7 +586,7 @@ pub fn clamp(val: anytype, lower: anytype, upper: anytype) @TypeOf(val, lower, u
     assert(lower <= upper);
     return @max(lower, @min(val, upper));
 }
-test "clamp" {
+test clamp {
     // Within range
     try testing.expect(std.math.clamp(@as(i32, -1), @as(i32, -4), @as(i32, 7)) == -1);
     // Below
@@ -650,7 +667,7 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
     return a << casted_shift_amt;
 }
 
-test "shl" {
+test shl {
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
@@ -695,7 +712,7 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
     return a >> casted_shift_amt;
 }
 
-test "shr" {
+test shr {
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
@@ -741,7 +758,7 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T {
     }
 }
 
-test "rotr" {
+test rotr {
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
@@ -787,7 +804,7 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T {
     }
 }
 
-test "rotl" {
+test rotl {
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
@@ -850,7 +867,7 @@ pub fn IntFittingRange(comptime from: comptime_int, comptime to: comptime_int) t
     return std.meta.Int(signedness, magnitude_bits);
 }
 
-test "IntFittingRange" {
+test IntFittingRange {
     try testing.expect(IntFittingRange(0, 0) == u0);
     try testing.expect(IntFittingRange(0, 1) == u1);
     try testing.expect(IntFittingRange(0, 2) == u2);
@@ -918,7 +935,7 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
     return @divTrunc(numerator, denominator);
 }
 
-test "divTrunc" {
+test divTrunc {
     try testDivTrunc();
     try comptime testDivTrunc();
 }
@@ -942,7 +959,7 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
     return @divFloor(numerator, denominator);
 }
 
-test "divFloor" {
+test divFloor {
     try testDivFloor();
     try comptime testDivFloor();
 }
@@ -979,7 +996,7 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
     }
 }
 
-test "divCeil" {
+test divCeil {
     try testDivCeil();
     try comptime testDivCeil();
 }
@@ -1023,7 +1040,7 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
     return result;
 }
 
-test "divExact" {
+test divExact {
     try testDivExact();
     try comptime testDivExact();
 }
@@ -1049,7 +1066,7 @@ pub fn mod(comptime T: type, numerator: T, denominator: T) !T {
     return @mod(numerator, denominator);
 }
 
-test "mod" {
+test mod {
     try testMod();
     try comptime testMod();
 }
@@ -1075,7 +1092,7 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T {
     return @rem(numerator, denominator);
 }
 
-test "rem" {
+test rem {
     try testRem();
     try comptime testRem();
 }
@@ -1104,7 +1121,7 @@ pub fn negateCast(x: anytype) !std.meta.Int(.signed, @bitSizeOf(@TypeOf(x))) {
     return -@as(int, @intCast(x));
 }
 
-test "negateCast" {
+test negateCast {
     try testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999);
     try testing.expect(@TypeOf(negateCast(@as(u32, 999)) catch unreachable) == i32);
 
@@ -1129,7 +1146,7 @@ pub fn cast(comptime T: type, x: anytype) ?T {
     }
 }
 
-test "cast" {
+test cast {
     try testing.expect(cast(u8, 300) == null);
     try testing.expect(cast(u8, @as(u32, 300)) == null);
     try testing.expect(cast(i8, -200) == null);
@@ -1188,7 +1205,7 @@ pub fn ByteAlignedInt(comptime T: type) type {
     return extended_type;
 }
 
-test "ByteAlignedInt" {
+test ByteAlignedInt {
     try testing.expect(ByteAlignedInt(u0) == u0);
     try testing.expect(ByteAlignedInt(i0) == i0);
     try testing.expect(ByteAlignedInt(u3) == u8);
@@ -1226,7 +1243,7 @@ pub fn floorPowerOfTwo(comptime T: type, value: T) T {
     return @as(T, 1) << log2_int(uT, @as(uT, @intCast(value)));
 }
 
-test "floorPowerOfTwo" {
+test floorPowerOfTwo {
     try testFloorPowerOfTwo();
     try comptime testFloorPowerOfTwo();
 }
@@ -1288,7 +1305,7 @@ pub fn ceilPowerOfTwoAssert(comptime T: type, value: T) T {
     return ceilPowerOfTwo(T, value) catch unreachable;
 }
 
-test "ceilPowerOfTwoPromote" {
+test ceilPowerOfTwoPromote {
     try testCeilPowerOfTwoPromote();
     try comptime testCeilPowerOfTwoPromote();
 }
@@ -1305,7 +1322,7 @@ fn testCeilPowerOfTwoPromote() !void {
     try testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9));
 }
 
-test "ceilPowerOfTwo" {
+test ceilPowerOfTwo {
     try testCeilPowerOfTwo();
     try comptime testCeilPowerOfTwo();
 }
@@ -1398,7 +1415,7 @@ pub fn lossyCast(comptime T: type, value: anytype) T {
     }
 }
 
-test "lossyCast" {
+test lossyCast {
     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));
@@ -1417,7 +1434,7 @@ pub fn lerp(a: anytype, b: anytype, t: anytype) @TypeOf(a, b, t) {
     return @mulAdd(Type, b - a, t, a);
 }
 
-test "lerp" {
+test lerp {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/17884
     if (builtin.zig_backend == .stage2_x86_64 and
         !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .fma)) return error.SkipZigTest;
@@ -1483,7 +1500,7 @@ pub fn minInt(comptime T: type) comptime_int {
     return -(1 << (bit_count - 1));
 }
 
-test "minInt and maxInt" {
+test maxInt {
     try testing.expect(maxInt(u0) == 0);
     try testing.expect(maxInt(u1) == 1);
     try testing.expect(maxInt(u8) == 255);
@@ -1500,7 +1517,9 @@ test "minInt and maxInt" {
     try testing.expect(maxInt(i63) == 4611686018427387903);
     try testing.expect(maxInt(i64) == 9223372036854775807);
     try testing.expect(maxInt(i128) == 170141183460469231731687303715884105727);
+}
 
+test minInt {
     try testing.expect(minInt(u0) == 0);
     try testing.expect(minInt(u1) == 0);
     try testing.expect(minInt(u8) == 0);
@@ -1538,7 +1557,7 @@ pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(
     return @as(ResultInt, a) * @as(ResultInt, b);
 }
 
-test "mulWide" {
+test mulWide {
     try testing.expect(mulWide(u8, 5, 5) == 25);
     try testing.expect(mulWide(i8, 5, -5) == -25);
     try testing.expect(mulWide(u8, 100, 100) == 10000);
@@ -1563,6 +1582,12 @@ pub const Order = enum {
         };
     }
 
+    test invert {
+        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);
+    }
+
     pub fn compare(self: Order, op: CompareOperator) bool {
         return switch (self) {
             .lt => switch (op) {
@@ -1591,6 +1616,18 @@ pub const Order = enum {
             },
         };
     }
+
+    // https://github.com/ziglang/zig/issues/19295
+    test "compare" {
+        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));
+    }
 };
 
 /// Given two numbers, this function returns the order they are with respect to each other.
@@ -1633,6 +1670,15 @@ pub const CompareOperator = enum {
             .neq => .neq,
         };
     }
+
+    test reverse {
+        inline for (@typeInfo(CompareOperator).Enum.fields) |op_field| {
+            const op = @as(CompareOperator, @enumFromInt(op_field.value));
+            try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2));
+            try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3));
+            try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4));
+        }
+    }
 };
 
 /// This function does the same thing as comparison operators, however the
@@ -1649,7 +1695,7 @@ pub fn compare(a: anytype, op: CompareOperator, b: anytype) bool {
     };
 }
 
-test "compare between signed and unsigned" {
+test compare {
     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)));
@@ -1669,38 +1715,12 @@ test "compare between signed and unsigned" {
     try testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));
 }
 
-test "order" {
+test order {
     try testing.expect(order(0, 0) == .eq);
     try testing.expect(order(1, 0) == .gt);
     try testing.expect(order(-1, 0) == .lt);
 }
 
-test "order.invert" {
-    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" {
-    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 "compare.reverse" {
-    inline for (@typeInfo(CompareOperator).Enum.fields) |op_field| {
-        const op = @as(CompareOperator, @enumFromInt(op_field.value));
-        try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2));
-        try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3));
-        try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4));
-    }
-}
-
 /// Returns a mask of all ones if value is true,
 /// and a mask of all zeroes if value is false.
 /// Compiles to one instruction for register sized integers.
@@ -1722,7 +1742,7 @@ pub inline fn boolMask(comptime MaskInt: type, value: bool) MaskInt {
     return -%@as(MaskInt, @intCast(@intFromBool(value)));
 }
 
-test "boolMask" {
+test boolMask {
     const runTest = struct {
         fn runTest() !void {
             try testing.expectEqual(@as(u1, 0), boolMask(u1, false));
@@ -1870,7 +1890,7 @@ fn testSign() !void {
     try std.testing.expectEqual(0.0, sign(0.0));
 }
 
-test "sign" {
+test sign {
     if (builtin.zig_backend == .stage2_llvm) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index ffb202fc8a..eb39370346 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -306,7 +306,7 @@ pub fn zeroes(comptime T: type) T {
     }
 }
 
-test "zeroes" {
+test zeroes {
     const C_struct = extern struct {
         x: u32,
         y: u32 align(128),
@@ -475,7 +475,7 @@ pub fn zeroInit(comptime T: type, init: anytype) T {
     }
 }
 
-test "zeroInit" {
+test zeroInit {
     const I = struct {
         d: f64,
     };
@@ -606,16 +606,19 @@ pub fn orderZ(comptime T: type, lhs: [*:0]const T, rhs: [*:0]const T) math.Order
     return math.order(lhs[i], rhs[i]);
 }
 
-test "order and orderZ" {
+test order {
     try testing.expect(order(u8, "abcd", "bee") == .lt);
-    try testing.expect(orderZ(u8, "abcd", "bee") == .lt);
     try testing.expect(order(u8, "abc", "abc") == .eq);
-    try testing.expect(orderZ(u8, "abc", "abc") == .eq);
     try testing.expect(order(u8, "abc", "abc0") == .lt);
-    try testing.expect(orderZ(u8, "abc", "abc0") == .lt);
     try testing.expect(order(u8, "", "") == .eq);
-    try testing.expect(orderZ(u8, "", "") == .eq);
     try testing.expect(order(u8, "", "a") == .lt);
+}
+
+test orderZ {
+    try testing.expect(orderZ(u8, "abcd", "bee") == .lt);
+    try testing.expect(orderZ(u8, "abc", "abc") == .eq);
+    try testing.expect(orderZ(u8, "abc", "abc0") == .lt);
+    try testing.expect(orderZ(u8, "", "") == .eq);
     try testing.expect(orderZ(u8, "", "a") == .lt);
 }
 
@@ -624,7 +627,7 @@ pub fn lessThan(comptime T: type, lhs: []const T, rhs: []const T) bool {
     return order(T, lhs, rhs) == .lt;
 }
 
-test "lessThan" {
+test lessThan {
     try testing.expect(lessThan(u8, "abcd", "bee"));
     try testing.expect(!lessThan(u8, "abc", "abc"));
     try testing.expect(lessThan(u8, "abc", "abc0"));
@@ -726,7 +729,7 @@ pub fn indexOfDiff(comptime T: type, a: []const T, b: []const T) ?usize {
     return if (a.len == b.len) null else shortest;
 }
 
-test "indexOfDiff" {
+test indexOfDiff {
     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);
@@ -759,7 +762,7 @@ fn Span(comptime T: type) type {
     @compileError("invalid type given to std.mem.span: " ++ @typeName(T));
 }
 
-test "Span" {
+test Span {
     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);
@@ -793,7 +796,7 @@ pub fn span(ptr: anytype) Span(@TypeOf(ptr)) {
     }
 }
 
-test "span" {
+test span {
     var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 };
     const ptr = @as([*:3]u16, array[0..2 :3]);
     try testing.expect(eql(u16, span(ptr), &[_]u16{ 1, 2 }));
@@ -877,7 +880,7 @@ pub fn sliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) SliceTo(
     }
 }
 
-test "sliceTo" {
+test sliceTo {
     try testing.expectEqualSlices(u8, "aoeu", sliceTo("aoeu", 0));
 
     {
@@ -963,7 +966,7 @@ fn lenSliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) usize {
     @compileError("invalid type given to std.mem.sliceTo: " ++ @typeName(@TypeOf(ptr)));
 }
 
-test "lenSliceTo" {
+test lenSliceTo {
     try testing.expect(lenSliceTo("aoeu", 0) == 4);
 
     {
@@ -1018,7 +1021,7 @@ pub fn len(value: anytype) usize {
     }
 }
 
-test "len" {
+test len {
     var array: [5]u16 = [_]u16{ 1, 2, 0, 4, 5 };
     const ptr = @as([*:4]u16, array[0..3 :4]);
     try testing.expect(len(ptr) == 3);
@@ -1157,7 +1160,7 @@ pub fn trim(comptime T: type, slice: []const T, values_to_strip: []const T) []co
     return slice[begin..end];
 }
 
-test "trim" {
+test trim {
     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"));
@@ -1240,7 +1243,7 @@ pub fn indexOfScalarPos(comptime T: type, slice: []const T, start_index: usize,
     return null;
 }
 
-test "indexOfScalarPos" {
+test indexOfScalarPos {
     const Types = [_]type{ u8, u16, u32, u64 };
 
     inline for (Types) |T| {
@@ -1316,7 +1319,7 @@ pub fn indexOfNonePos(comptime T: type, slice: []const T, start_index: usize, va
     return null;
 }
 
-test "indexOfNone" {
+test indexOfNone {
     try testing.expect(indexOfNone(u8, "abc123", "123").? == 0);
     try testing.expect(lastIndexOfNone(u8, "abc123", "123").? == 2);
     try testing.expect(indexOfNone(u8, "123abc", "123").? == 3);
@@ -1460,7 +1463,7 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee
     return null;
 }
 
-test "indexOf" {
+test indexOf {
     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);
@@ -1533,7 +1536,7 @@ pub fn count(comptime T: type, haystack: []const T, needle: []const T) usize {
     return found;
 }
 
-test "count" {
+test count {
     try testing.expect(count(u8, "", "h") == 0);
     try testing.expect(count(u8, "h", "h") == 1);
     try testing.expect(count(u8, "hh", "h") == 2);
@@ -1565,7 +1568,7 @@ pub fn containsAtLeast(comptime T: type, haystack: []const T, expected_count: us
     return false;
 }
 
-test "containsAtLeast" {
+test containsAtLeast {
     try testing.expect(containsAtLeast(u8, "aa", 0, "a"));
     try testing.expect(containsAtLeast(u8, "aa", 1, "a"));
     try testing.expect(containsAtLeast(u8, "aa", 2, "a"));
@@ -1698,6 +1701,9 @@ test readInt {
 
     try testing.expect(readInt(i16, &[_]u8{ 0xff, 0xfd }, .big) == -3);
     try testing.expect(readInt(i16, &[_]u8{ 0xfc, 0xff }, .little) == -4);
+
+    try moreReadIntTests();
+    try comptime moreReadIntTests();
 }
 
 fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T {
@@ -2027,7 +2033,7 @@ pub fn byteSwapAllFields(comptime S: type, ptr: *S) void {
     }
 }
 
-test "byteSwapAllFields" {
+test byteSwapAllFields {
     const T = extern struct {
         f0: u8,
         f1: u16,
@@ -2136,7 +2142,7 @@ pub fn tokenizeScalar(comptime T: type, buffer: []const T, delimiter: T) TokenIt
     };
 }
 
-test "tokenizeScalar" {
+test tokenizeScalar {
     var it = tokenizeScalar(u8, "   abc def   ghi  ", ' ');
     try testing.expect(eql(u8, it.next().?, "abc"));
     try testing.expect(eql(u8, it.peek().?, "def"));
@@ -2177,7 +2183,7 @@ test "tokenizeScalar" {
     try testing.expect(it16.next() == null);
 }
 
-test "tokenizeAny" {
+test tokenizeAny {
     var it = tokenizeAny(u8, "a|b,c/d e", " /,|");
     try testing.expect(eql(u8, it.next().?, "a"));
     try testing.expect(eql(u8, it.peek().?, "b"));
@@ -2205,7 +2211,7 @@ test "tokenizeAny" {
     try testing.expect(it16.next() == null);
 }
 
-test "tokenizeSequence" {
+test tokenizeSequence {
     var it = tokenizeSequence(u8, "a<>b<><>c><>d><", "<>");
     try testing.expectEqualStrings("a", it.next().?);
     try testing.expectEqualStrings("b", it.peek().?);
@@ -2334,7 +2340,7 @@ pub fn splitScalar(comptime T: type, buffer: []const T, delimiter: T) SplitItera
     };
 }
 
-test "splitScalar" {
+test splitScalar {
     var it = splitScalar(u8, "abc|def||ghi", '|');
     try testing.expectEqualSlices(u8, it.rest(), "abc|def||ghi");
     try testing.expectEqualSlices(u8, it.first(), "abc");
@@ -2377,7 +2383,7 @@ test "splitScalar" {
     try testing.expect(it16.next() == null);
 }
 
-test "splitSequence" {
+test splitSequence {
     var it = splitSequence(u8, "a, b ,, c, d, e", ", ");
     try testing.expectEqualSlices(u8, it.first(), "a");
     try testing.expectEqualSlices(u8, it.rest(), "b ,, c, d, e");
@@ -2400,7 +2406,7 @@ test "splitSequence" {
     try testing.expect(it16.next() == null);
 }
 
-test "splitAny" {
+test splitAny {
     var it = splitAny(u8, "a,b, c d e", ", ");
     try testing.expectEqualSlices(u8, it.first(), "a");
     try testing.expectEqualSlices(u8, it.rest(), "b, c d e");
@@ -2536,7 +2542,7 @@ pub fn splitBackwardsScalar(comptime T: type, buffer: []const T, delimiter: T) S
     };
 }
 
-test "splitBackwardsScalar" {
+test splitBackwardsScalar {
     var it = splitBackwardsScalar(u8, "abc|def||ghi", '|');
     try testing.expectEqualSlices(u8, it.rest(), "abc|def||ghi");
     try testing.expectEqualSlices(u8, it.first(), "ghi");
@@ -2575,7 +2581,7 @@ test "splitBackwardsScalar" {
     try testing.expect(it16.next() == null);
 }
 
-test "splitBackwardsSequence" {
+test splitBackwardsSequence {
     var it = splitBackwardsSequence(u8, "a, b ,, c, d, e", ", ");
     try testing.expectEqualSlices(u8, it.rest(), "a, b ,, c, d, e");
     try testing.expectEqualSlices(u8, it.first(), "e");
@@ -2608,7 +2614,7 @@ test "splitBackwardsSequence" {
     try testing.expect(it16.next() == null);
 }
 
-test "splitBackwardsAny" {
+test splitBackwardsAny {
     var it = splitBackwardsAny(u8, "a,b, c d e", ", ");
     try testing.expectEqualSlices(u8, it.rest(), "a,b, c d e");
     try testing.expectEqualSlices(u8, it.first(), "e");
@@ -2715,7 +2721,7 @@ pub fn window(comptime T: type, buffer: []const T, size: usize, advance: usize)
     };
 }
 
-test "window" {
+test window {
     {
         // moving average size 3
         var it = window(u8, "abcdefg", 3, 1);
@@ -2841,7 +2847,7 @@ pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool
     return if (needle.len > haystack.len) false else eql(T, haystack[0..needle.len], needle);
 }
 
-test "startsWith" {
+test startsWith {
     try testing.expect(startsWith(u8, "Bob", "Bo"));
     try testing.expect(!startsWith(u8, "Needle in haystack", "haystack"));
 }
@@ -2850,7 +2856,7 @@ pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool {
     return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len ..], needle);
 }
 
-test "endsWith" {
+test endsWith {
     try testing.expect(endsWith(u8, "Needle in haystack", "haystack"));
     try testing.expect(!endsWith(u8, "Bob", "Bo"));
 }
@@ -3086,7 +3092,7 @@ fn joinMaybeZ(allocator: Allocator, separator: []const u8, slices: []const []con
     return buf;
 }
 
-test "join" {
+test join {
     {
         const str = try join(testing.allocator, ",", &[_][]const u8{});
         defer testing.allocator.free(str);
@@ -3109,7 +3115,7 @@ test "join" {
     }
 }
 
-test "joinZ" {
+test joinZ {
     {
         const str = try joinZ(testing.allocator, ",", &[_][]const u8{});
         defer testing.allocator.free(str);
@@ -3181,7 +3187,7 @@ pub fn concatMaybeSentinel(allocator: Allocator, comptime T: type, slices: []con
     return buf;
 }
 
-test "concat" {
+test concat {
     {
         const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" });
         defer testing.allocator.free(str);
@@ -3219,17 +3225,13 @@ test "concat" {
     }
 }
 
-test "testStringEquality" {
+test eql {
     try testing.expect(eql(u8, "abcd", "abcd"));
     try testing.expect(!eql(u8, "abcdef", "abZdef"));
     try testing.expect(!eql(u8, "abcdefg", "abcdef"));
 }
 
-test "testReadInt" {
-    try testReadIntImpl();
-    try comptime testReadIntImpl();
-}
-fn testReadIntImpl() !void {
+fn moreReadIntTests() !void {
     {
         const bytes = [_]u8{
             0x12,
@@ -3287,7 +3289,7 @@ pub fn min(comptime T: type, slice: []const T) T {
     return best;
 }
 
-test "min" {
+test min {
     try testing.expectEqual(min(u8, "abcdefg"), 'a');
     try testing.expectEqual(min(u8, "bcdefga"), 'a');
     try testing.expectEqual(min(u8, "a"), 'a');
@@ -3304,7 +3306,7 @@ pub fn max(comptime T: type, slice: []const T) T {
     return best;
 }
 
-test "max" {
+test max {
     try testing.expectEqual(max(u8, "abcdefg"), 'g');
     try testing.expectEqual(max(u8, "gabcdef"), 'g');
     try testing.expectEqual(max(u8, "g"), 'g');
@@ -3357,7 +3359,7 @@ pub fn indexOfMin(comptime T: type, slice: []const T) usize {
     return index;
 }
 
-test "indexOfMin" {
+test indexOfMin {
     try testing.expectEqual(indexOfMin(u8, "abcdefg"), 0);
     try testing.expectEqual(indexOfMin(u8, "bcdefga"), 6);
     try testing.expectEqual(indexOfMin(u8, "a"), 0);
@@ -3378,7 +3380,7 @@ pub fn indexOfMax(comptime T: type, slice: []const T) usize {
     return index;
 }
 
-test "indexOfMax" {
+test indexOfMax {
     try testing.expectEqual(indexOfMax(u8, "abcdefg"), 6);
     try testing.expectEqual(indexOfMax(u8, "gabcdef"), 0);
     try testing.expectEqual(indexOfMax(u8, "a"), 0);
@@ -3406,7 +3408,7 @@ pub fn indexOfMinMax(comptime T: type, slice: []const T) struct { usize, usize }
     return .{ minIdx, maxIdx };
 }
 
-test "indexOfMinMax" {
+test indexOfMinMax {
     try testing.expectEqual(.{ 0, 6 }, indexOfMinMax(u8, "abcdefg"));
     try testing.expectEqual(.{ 1, 0 }, indexOfMinMax(u8, "gabcdef"));
     try testing.expectEqual(.{ 0, 0 }, indexOfMinMax(u8, "a"));
@@ -3427,7 +3429,7 @@ pub fn reverse(comptime T: type, items: []T) void {
     }
 }
 
-test "reverse" {
+test reverse {
     var arr = [_]i32{ 5, 3, 1, 2, 4 };
     reverse(i32, arr[0..]);
 
@@ -3488,7 +3490,7 @@ pub fn reverseIterator(slice: anytype) ReverseIterator(@TypeOf(slice)) {
     return .{ .ptr = slice.ptr, .index = slice.len };
 }
 
-test "reverseIterator" {
+test reverseIterator {
     {
         var it = reverseIterator("abc");
         try testing.expectEqual(@as(?u8, 'c'), it.next());
@@ -3546,7 +3548,7 @@ pub fn rotate(comptime T: type, items: []T, amount: usize) void {
     reverse(T, items);
 }
 
-test "rotate" {
+test rotate {
     var arr = [_]i32{ 5, 3, 1, 2, 4 };
     rotate(i32, arr[0..], 2);
 
@@ -3580,7 +3582,7 @@ pub fn replace(comptime T: type, input: []const T, needle: []const T, replacemen
     return replacements;
 }
 
-test "replace" {
+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";
@@ -3643,7 +3645,7 @@ fn testCollapseRepeats(str: []const u8, elem: u8, expected: []const u8) !void {
     defer std.testing.allocator.free(mutable);
     try testing.expect(std.mem.eql(u8, collapseRepeats(u8, mutable, elem), expected));
 }
-test "collapseRepeats" {
+test collapseRepeats {
     try testCollapseRepeats("", '/', "");
     try testCollapseRepeats("a", '/', "a");
     try testCollapseRepeats("/", '/', "/");
@@ -3677,7 +3679,7 @@ pub fn replacementSize(comptime T: type, input: []const T, needle: []const T, re
     return size;
 }
 
-test "replacementSize" {
+test replacementSize {
     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);
@@ -3697,7 +3699,7 @@ pub fn replaceOwned(comptime T: type, allocator: Allocator, input: []const T, ne
     return output;
 }
 
-test "replaceOwned" {
+test replaceOwned {
     const gpa = std.testing.allocator;
 
     const base_replace = replaceOwned(u8, gpa, "All your base are belong to us", "base", "Zig") catch @panic("out of memory");
@@ -3801,7 +3803,7 @@ pub fn alignPointer(ptr: anytype, align_to: usize) ?@TypeOf(ptr) {
     return @alignCast(ptr + adjust_off);
 }
 
-test "alignPointer" {
+test alignPointer {
     const S = struct {
         fn checkAlign(comptime T: type, base: usize, align_to: usize, expected: usize) !void {
             const ptr: T = @ptrFromInt(base);
@@ -3850,7 +3852,7 @@ pub fn asBytes(ptr: anytype) AsBytesReturnType(@TypeOf(ptr)) {
     return @ptrCast(@alignCast(ptr));
 }
 
-test "asBytes" {
+test asBytes {
     const deadbeef = @as(u32, 0xDEADBEEF);
     const deadbeef_bytes = switch (native_endian) {
         .big => "\xDE\xAD\xBE\xEF",
@@ -3910,7 +3912,7 @@ pub fn toBytes(value: anytype) [@sizeOf(@TypeOf(value))]u8 {
     return asBytes(&value).*;
 }
 
-test "toBytes" {
+test toBytes {
     var my_bytes = toBytes(@as(u32, 0x12345678));
     switch (native_endian) {
         .big => try testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")),
@@ -3934,7 +3936,7 @@ pub fn bytesAsValue(comptime T: type, bytes: anytype) BytesAsValueReturnType(T,
     return @ptrCast(bytes);
 }
 
-test "bytesAsValue" {
+test bytesAsValue {
     const deadbeef = @as(u32, 0xDEADBEEF);
     const deadbeef_bytes = switch (native_endian) {
         .big => "\xDE\xAD\xBE\xEF",
@@ -3993,7 +3995,7 @@ test "bytesAsValue preserves pointer attributes" {
 pub fn bytesToValue(comptime T: type, bytes: anytype) T {
     return bytesAsValue(T, bytes).*;
 }
-test "bytesToValue" {
+test bytesToValue {
     const deadbeef_bytes = switch (native_endian) {
         .big => "\xDE\xAD\xBE\xEF",
         .little => "\xEF\xBE\xAD\xDE",
@@ -4021,7 +4023,7 @@ pub fn bytesAsSlice(comptime T: type, bytes: anytype) BytesAsSliceReturnType(T,
     return @as(cast_target, @ptrCast(bytes))[0..@divExact(bytes.len, @sizeOf(T))];
 }
 
-test "bytesAsSlice" {
+test bytesAsSlice {
     {
         const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF };
         const slice = bytesAsSlice(u16, bytes[0..]);
@@ -4110,7 +4112,7 @@ pub fn sliceAsBytes(slice: anytype) SliceAsBytesReturnType(@TypeOf(slice)) {
     return @as(cast_target, @ptrCast(slice))[0 .. slice.len * @sizeOf(std.meta.Elem(Slice))];
 }
 
-test "sliceAsBytes" {
+test sliceAsBytes {
     const bytes = [_]u16{ 0xDEAD, 0xBEEF };
     const slice = sliceAsBytes(bytes[0..]);
     try testing.expect(slice.len == 4);
@@ -4268,7 +4270,7 @@ fn doNotOptimizeAwayC(ptr: anytype) void {
     dest.* = 0;
 }
 
-test "doNotOptimizeAway" {
+test doNotOptimizeAway {
     comptime doNotOptimizeAway("test");
 
     doNotOptimizeAway(null);
@@ -4293,7 +4295,7 @@ test "doNotOptimizeAway" {
     doNotOptimizeAway(@as(std.builtin.Endian, .little));
 }
 
-test "alignForward" {
+test alignForward {
     try testing.expect(alignForward(usize, 1, 1) == 1);
     try testing.expect(alignForward(usize, 2, 1) == 2);
     try testing.expect(alignForward(usize, 1, 2) == 2);
@@ -4362,7 +4364,7 @@ pub fn isAlignedGeneric(comptime T: type, addr: T, alignment: T) bool {
     return alignBackward(T, addr, alignment) == addr;
 }
 
-test "isAligned" {
+test isAligned {
     try testing.expect(isAligned(0, 4));
     try testing.expect(isAligned(1, 1));
     try testing.expect(isAligned(2, 1));
diff --git a/lib/std/meta/trailer_flags.zig b/lib/std/meta/trailer_flags.zig
index 396eaa8f71..9e223768a7 100644
--- a/lib/std/meta/trailer_flags.zig
+++ b/lib/std/meta/trailer_flags.zig
@@ -132,7 +132,7 @@ pub fn TrailerFlags(comptime Fields: type) type {
     };
 }
 
-test "TrailerFlags" {
+test TrailerFlags {
     const Flags = TrailerFlags(struct {
         a: i32,
         b: bool,
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 6ea7611fd7..1c0b7d9d80 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -1379,7 +1379,7 @@ pub fn GetFinalPathNameByHandle(
     }
 }
 
-test "GetFinalPathNameByHandle" {
+test GetFinalPathNameByHandle {
     if (builtin.os.tag != .windows)
         return;
 
@@ -2601,7 +2601,7 @@ pub fn ntToWin32Namespace(path: []const u16) !PathSpace {
     }
 }
 
-test "ntToWin32Namespace" {
+test ntToWin32Namespace {
     const L = std.unicode.utf8ToUtf16LeStringLiteral;
 
     try testNtToWin32Namespace(L("UNC"), L("\\??\\UNC"));
@@ -3539,7 +3539,7 @@ pub const GUID = extern struct {
     }
 };
 
-test "GUID" {
+test GUID {
     try std.testing.expectEqual(
         GUID{
             .Data1 = 0x01234567,
diff --git a/lib/std/process.zig b/lib/std/process.zig
index b72c1963f5..8f3f990890 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -215,7 +215,7 @@ pub const EnvMap = struct {
     }
 };
 
-test "EnvMap" {
+test EnvMap {
     var env = EnvMap.init(testing.allocator);
     defer env.deinit();
 
@@ -377,7 +377,7 @@ pub fn getEnvMap(allocator: Allocator) GetEnvMapError!EnvMap {
     }
 }
 
-test "getEnvMap" {
+test getEnvMap {
     var env = try getEnvMap(testing.allocator);
     defer env.deinit();
 }
@@ -1181,7 +1181,7 @@ pub fn argsFree(allocator: Allocator, args_alloc: []const [:0]u8) void {
     return allocator.free(aligned_allocated_buf);
 }
 
-test "ArgIteratorWindows" {
+test ArgIteratorWindows {
     const t = testArgIteratorWindows;
 
     try t(
diff --git a/lib/std/sort.zig b/lib/std/sort.zig
index a697046ea6..03e9defd35 100644
--- a/lib/std/sort.zig
+++ b/lib/std/sort.zig
@@ -430,7 +430,7 @@ pub fn binarySearch(
     return null;
 }
 
-test "binarySearch" {
+test binarySearch {
     const S = struct {
         fn order_u32(context: void, lhs: u32, rhs: u32) math.Order {
             _ = context;
@@ -537,7 +537,7 @@ pub fn lowerBound(
     return left;
 }
 
-test "lowerBound" {
+test lowerBound {
     const S = struct {
         fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
             _ = context;
@@ -627,7 +627,7 @@ pub fn upperBound(
     return left;
 }
 
-test "upperBound" {
+test upperBound {
     const S = struct {
         fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
             _ = context;
@@ -712,7 +712,7 @@ pub fn equalRange(
     };
 }
 
-test "equalRange" {
+test equalRange {
     const S = struct {
         fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
             _ = context;
@@ -792,7 +792,7 @@ pub fn argMin(
     return smallest_index;
 }
 
-test "argMin" {
+test argMin {
     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));
@@ -812,7 +812,7 @@ pub fn min(
     return items[i];
 }
 
-test "min" {
+test min {
     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));
@@ -844,7 +844,7 @@ pub fn argMax(
     return biggest_index;
 }
 
-test "argMax" {
+test argMax {
     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));
@@ -864,7 +864,7 @@ pub fn max(
     return items[i];
 }
 
-test "max" {
+test max {
     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));
@@ -890,7 +890,7 @@ pub fn isSorted(
     return true;
 }
 
-test "isSorted" {
+test isSorted {
     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));
diff --git a/lib/std/tar.zig b/lib/std/tar.zig
index 13da27ca84..8ab7f0d09a 100644
--- a/lib/std/tar.zig
+++ b/lib/std/tar.zig
@@ -676,7 +676,7 @@ fn stripComponents(path: []const u8, count: u32) []const u8 {
     return path[i..];
 }
 
-test "stripComponents" {
+test stripComponents {
     const expectEqualStrings = testing.expectEqualStrings;
     try expectEqualStrings("a/b/c", stripComponents("a/b/c", 0));
     try expectEqualStrings("b/c", stripComponents("a/b/c", 1));
@@ -685,7 +685,7 @@ test "stripComponents" {
     try expectEqualStrings("", stripComponents("a/b/c", 4));
 }
 
-test "PaxIterator" {
+test PaxIterator {
     const Attr = struct {
         kind: PaxAttributeKind,
         value: []const u8 = undefined,
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index c6a4f9f78f..2d97580a22 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -242,7 +242,7 @@ fn expectApproxEqAbsInner(comptime T: type, expected: T, actual: T, tolerance: T
     }
 }
 
-test "expectApproxEqAbs" {
+test expectApproxEqAbs {
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
         const pos_x: T = 12.0;
         const pos_y: T = 12.06;
@@ -278,7 +278,7 @@ fn expectApproxEqRelInner(comptime T: type, expected: T, actual: T, tolerance: T
     }
 }
 
-test "expectApproxEqRel" {
+test expectApproxEqRel {
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
         const eps_value = comptime math.floatEps(T);
         const sqrt_eps_value = comptime @sqrt(eps_value);
diff --git a/lib/std/time.zig b/lib/std/time.zig
index 3a4be673cc..e8b37d3010 100644
--- a/lib/std/time.zig
+++ b/lib/std/time.zig
@@ -53,7 +53,7 @@ pub fn sleep(nanoseconds: u64) void {
     posix.nanosleep(s, ns);
 }
 
-test "sleep" {
+test sleep {
     sleep(1);
 }
 
@@ -123,7 +123,7 @@ pub fn nanoTimestamp() i128 {
     }
 }
 
-test "timestamp" {
+test milliTimestamp {
     const margin = ns_per_ms * 50;
 
     const time_0 = milliTimestamp();
@@ -327,7 +327,7 @@ pub const Timer = struct {
     }
 };
 
-test "Timer + Instant" {
+test Timer {
     const margin = ns_per_ms * 150;
 
     var timer = try Timer.start();
diff --git a/lib/std/time/epoch.zig b/lib/std/time/epoch.zig
index f467721a49..631fa178e4 100644
--- a/lib/std/time/epoch.zig
+++ b/lib/std/time/epoch.zig
@@ -53,7 +53,7 @@ pub fn isLeapYear(year: Year) bool {
     return (0 == @mod(year, 400));
 }
 
-test "isLeapYear" {
+test isLeapYear {
     try testing.expectEqual(false, isLeapYear(2095));
     try testing.expectEqual(true, isLeapYear(2096));
     try testing.expectEqual(false, isLeapYear(2100));
diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig
index b2067c4f8f..8a26c3383e 100644
--- a/lib/std/unicode.zig
+++ b/lib/std/unicode.zig
@@ -907,7 +907,7 @@ pub fn fmtUtf8(utf8: []const u8) std.fmt.Formatter(formatUtf8) {
     return .{ .data = utf8 };
 }
 
-test "fmtUtf8" {
+test fmtUtf8 {
     const expectFmt = testing.expectFmt;
     try expectFmt("", "{}", .{fmtUtf8("")});
     try expectFmt("foo", "{}", .{fmtUtf8("foo")});
@@ -1249,7 +1249,7 @@ pub fn utf8ToUtf16LeImpl(utf16le: []u16, utf8: []const u8, comptime surrogates:
     return dest_index;
 }
 
-test "utf8ToUtf16Le" {
+test utf8ToUtf16Le {
     var utf16le: [128]u16 = undefined;
     {
         const length = try utf8ToUtf16Le(utf16le[0..], "𐐷");
@@ -1430,7 +1430,7 @@ pub fn fmtUtf16Le(utf16le: []const u16) std.fmt.Formatter(formatUtf16Le) {
     return .{ .data = utf16le };
 }
 
-test "fmtUtf16Le" {
+test fmtUtf16Le {
     const expectFmt = testing.expectFmt;
     try expectFmt("", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral(""))});
     try expectFmt("foo", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral("foo"))});
@@ -1443,7 +1443,7 @@ test "fmtUtf16Le" {
     try expectFmt("", "{}", .{fmtUtf16Le(&[_]u16{mem.readInt(u16, "\x00\xe0", native_endian)})});
 }
 
-test "utf8ToUtf16LeStringLiteral" {
+test utf8ToUtf16LeStringLiteral {
     {
         const bytes = [_:0]u16{
             mem.nativeToLittle(u16, 0x41),
diff --git a/lib/std/valgrind/memcheck.zig b/lib/std/valgrind/memcheck.zig
index 773216e012..b9d321210a 100644
--- a/lib/std/valgrind/memcheck.zig
+++ b/lib/std/valgrind/memcheck.zig
@@ -137,7 +137,7 @@ pub fn countLeaks() CountResult {
     return res;
 }
 
-test "countLeaks" {
+test countLeaks {
     try testing.expectEqual(
         @as(CountResult, .{
             .leaked = 0,
@@ -167,7 +167,7 @@ pub fn countLeakBlocks() CountResult {
     return res;
 }
 
-test "countLeakBlocks" {
+test countLeakBlocks {
     try testing.expectEqual(
         @as(CountResult, .{
             .leaked = 0,
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index 15a9c746da..5a6651b248 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -642,96 +642,96 @@ pub const Wip = struct {
             i += 1;
         }
     }
-};
 
-test "addBundleAsRoots" {
-    var bundle = bundle: {
-        var wip: ErrorBundle.Wip = undefined;
-        try wip.init(std.testing.allocator);
-        errdefer wip.deinit();
+    test addBundleAsRoots {
+        var bundle = bundle: {
+            var wip: ErrorBundle.Wip = undefined;
+            try wip.init(std.testing.allocator);
+            errdefer wip.deinit();
 
-        var ref_traces: [3]ReferenceTrace = undefined;
-        for (&ref_traces, 0..) |*ref_trace, i| {
-            if (i == ref_traces.len - 1) {
-                // sentinel reference trace
-                ref_trace.* = .{
-                    .decl_name = 3, // signifies 3 hidden references
-                    .src_loc = .none,
-                };
-            } else {
-                ref_trace.* = .{
-                    .decl_name = try wip.addString("foo"),
-                    .src_loc = try wip.addSourceLocation(.{
-                        .src_path = try wip.addString("foo"),
-                        .line = 1,
-                        .column = 2,
-                        .span_start = 3,
-                        .span_main = 4,
-                        .span_end = 5,
-                        .source_line = 0,
-                    }),
-                };
+            var ref_traces: [3]ReferenceTrace = undefined;
+            for (&ref_traces, 0..) |*ref_trace, i| {
+                if (i == ref_traces.len - 1) {
+                    // sentinel reference trace
+                    ref_trace.* = .{
+                        .decl_name = 3, // signifies 3 hidden references
+                        .src_loc = .none,
+                    };
+                } else {
+                    ref_trace.* = .{
+                        .decl_name = try wip.addString("foo"),
+                        .src_loc = try wip.addSourceLocation(.{
+                            .src_path = try wip.addString("foo"),
+                            .line = 1,
+                            .column = 2,
+                            .span_start = 3,
+                            .span_main = 4,
+                            .span_end = 5,
+                            .source_line = 0,
+                        }),
+                    };
+                }
             }
-        }
 
-        const src_loc = try wip.addSourceLocation(.{
-            .src_path = try wip.addString("foo"),
-            .line = 1,
-            .column = 2,
-            .span_start = 3,
-            .span_main = 4,
-            .span_end = 5,
-            .source_line = try wip.addString("some source code"),
-            .reference_trace_len = ref_traces.len,
-        });
-        for (&ref_traces) |ref_trace| {
-            try wip.addReferenceTrace(ref_trace);
-        }
-
-        try wip.addRootErrorMessage(ErrorMessage{
-            .msg = try wip.addString("hello world"),
-            .src_loc = src_loc,
-            .notes_len = 1,
-        });
-        const i = try wip.reserveNotes(1);
-        const note_index = @intFromEnum(wip.addErrorMessageAssumeCapacity(.{
-            .msg = try wip.addString("this is a note"),
-            .src_loc = try wip.addSourceLocation(.{
-                .src_path = try wip.addString("bar"),
+            const src_loc = try wip.addSourceLocation(.{
+                .src_path = try wip.addString("foo"),
                 .line = 1,
                 .column = 2,
                 .span_start = 3,
                 .span_main = 4,
                 .span_end = 5,
-                .source_line = try wip.addString("another line of source"),
-            }),
-        }));
-        wip.extra.items[i] = note_index;
+                .source_line = try wip.addString("some source code"),
+                .reference_trace_len = ref_traces.len,
+            });
+            for (&ref_traces) |ref_trace| {
+                try wip.addReferenceTrace(ref_trace);
+            }
 
-        break :bundle try wip.toOwnedBundle("");
-    };
-    defer bundle.deinit(std.testing.allocator);
+            try wip.addRootErrorMessage(ErrorMessage{
+                .msg = try wip.addString("hello world"),
+                .src_loc = src_loc,
+                .notes_len = 1,
+            });
+            const i = try wip.reserveNotes(1);
+            const note_index = @intFromEnum(wip.addErrorMessageAssumeCapacity(.{
+                .msg = try wip.addString("this is a note"),
+                .src_loc = try wip.addSourceLocation(.{
+                    .src_path = try wip.addString("bar"),
+                    .line = 1,
+                    .column = 2,
+                    .span_start = 3,
+                    .span_main = 4,
+                    .span_end = 5,
+                    .source_line = try wip.addString("another line of source"),
+                }),
+            }));
+            wip.extra.items[i] = note_index;
 
-    const ttyconf: std.io.tty.Config = .no_color;
+            break :bundle try wip.toOwnedBundle("");
+        };
+        defer bundle.deinit(std.testing.allocator);
 
-    var bundle_buf = std.ArrayList(u8).init(std.testing.allocator);
-    defer bundle_buf.deinit();
-    try bundle.renderToWriter(.{ .ttyconf = ttyconf }, bundle_buf.writer());
+        const ttyconf: std.io.tty.Config = .no_color;
 
-    var copy = copy: {
-        var wip: ErrorBundle.Wip = undefined;
-        try wip.init(std.testing.allocator);
-        errdefer wip.deinit();
+        var bundle_buf = std.ArrayList(u8).init(std.testing.allocator);
+        defer bundle_buf.deinit();
+        try bundle.renderToWriter(.{ .ttyconf = ttyconf }, bundle_buf.writer());
 
-        try wip.addBundleAsRoots(bundle);
+        var copy = copy: {
+            var wip: ErrorBundle.Wip = undefined;
+            try wip.init(std.testing.allocator);
+            errdefer wip.deinit();
 
-        break :copy try wip.toOwnedBundle("");
-    };
-    defer copy.deinit(std.testing.allocator);
+            try wip.addBundleAsRoots(bundle);
 
-    var copy_buf = std.ArrayList(u8).init(std.testing.allocator);
-    defer copy_buf.deinit();
-    try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_buf.writer());
+            break :copy try wip.toOwnedBundle("");
+        };
+        defer copy.deinit(std.testing.allocator);
 
-    try std.testing.expectEqualStrings(bundle_buf.items, copy_buf.items);
-}
+        var copy_buf = std.ArrayList(u8).init(std.testing.allocator);
+        defer copy_buf.deinit();
+        try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_buf.writer());
+
+        try std.testing.expectEqualStrings(bundle_buf.items, copy_buf.items);
+    }
+};
diff --git a/lib/std/zig/primitives.zig b/lib/std/zig/primitives.zig
index 11d519e365..e4e96e55ac 100644
--- a/lib/std/zig/primitives.zig
+++ b/lib/std/zig/primitives.zig
@@ -51,7 +51,7 @@ pub fn isPrimitive(name: []const u8) bool {
     return true;
 }
 
-test "isPrimitive" {
+test isPrimitive {
     const expect = std.testing.expect;
     try expect(!isPrimitive(""));
     try expect(!isPrimitive("_"));
diff --git a/lib/std/zig/string_literal.zig b/lib/std/zig/string_literal.zig
index 8ba2fc2f65..c160d16b07 100644
--- a/lib/std/zig/string_literal.zig
+++ b/lib/std/zig/string_literal.zig
@@ -148,7 +148,7 @@ pub fn parseEscapeSequence(slice: []const u8, offset: *usize) ParsedCharLiteral
     }
 }
 
-test "parseCharLiteral" {
+test parseCharLiteral {
     try std.testing.expectEqual(
         ParsedCharLiteral{ .success = 'a' },
         parseCharLiteral("'a'"),
@@ -281,7 +281,7 @@ pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]
     }
 }
 
-test "parse" {
+test parseAlloc {
     const expect = std.testing.expect;
     const expectError = std.testing.expectError;
     const eql = std.mem.eql;