Commit e5a95c6af123d614522de57f875b620deb152cc0 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-03-13 15:56:09-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-03-13 15:56:09-07:00
log	e5a95c6af123d614522de57f875b620deb152cc0
tree	bab31574cd2b31cf723d6d68749391b52f534fc4
parent	d029e0e972dc34788e9674d0cb72e964b64e17c4

std: promote tests to doctests

Now these show up as "example usage" in generated documentation.

26 files changed, 313 insertions(+), 290 deletions(-)

lib/std/ascii.zig+9-9

...	...	@@ -147,7 +147,7 @@ pub fn isWhitespace(c: u8) bool {
147	147	/// See also: `isWhitespace`
148	148	pub const whitespace = [_]u8{ ' ', '\t', '\n', '\r', control_code.vt, control_code.ff };
149	149
150		test "whitespace" {
	150	test whitespace {
151	151	for (whitespace) \|char\| try std.testing.expect(isWhitespace(char));
152	152
153	153	var i: u8 = 0;
...	...	@@ -278,7 +278,7 @@ pub fn lowerString(output: []u8, ascii_string: []const u8) []u8 {
278	278	return output[0..ascii_string.len];
279	279	}
280	280
281		test "lowerString" {
	281	test lowerString {
282	282	var buf: [1024]u8 = undefined;
283	283	const result = lowerString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");
284	284	try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);
...	...	@@ -291,7 +291,7 @@ pub fn allocLowerString(allocator: std.mem.Allocator, ascii_string: []const u8)
291	291	return lowerString(result, ascii_string);
292	292	}
293	293
294		test "allocLowerString" {
	294	test allocLowerString {
295	295	const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
296	296	defer std.testing.allocator.free(result);
297	297	try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);
...	...	@@ -307,7 +307,7 @@ pub fn upperString(output: []u8, ascii_string: []const u8) []u8 {
307	307	return output[0..ascii_string.len];
308	308	}
309	309
310		test "upperString" {
	310	test upperString {
311	311	var buf: [1024]u8 = undefined;
312	312	const result = upperString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");
313	313	try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);
...	...	@@ -320,7 +320,7 @@ pub fn allocUpperString(allocator: std.mem.Allocator, ascii_string: []const u8)
320	320	return upperString(result, ascii_string);
321	321	}
322	322
323		test "allocUpperString" {
	323	test allocUpperString {
324	324	const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
325	325	defer std.testing.allocator.free(result);
326	326	try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);
...	...	@@ -335,7 +335,7 @@ pub fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {
335	335	return true;
336	336	}
337	337
338		test "eqlIgnoreCase" {
	338	test eqlIgnoreCase {
339	339	try std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));
340	340	try std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));
341	341	try std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));
...	...	@@ -345,7 +345,7 @@ pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
345	345	return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[0..needle.len], needle);
346	346	}
347	347
348		test "startsWithIgnoreCase" {
	348	test startsWithIgnoreCase {
349	349	try std.testing.expect(startsWithIgnoreCase("boB", "Bo"));
350	350	try std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));
351	351	}
...	...	@@ -354,7 +354,7 @@ pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
354	354	return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[haystack.len - needle.len ..], needle);
355	355	}
356	356
357		test "endsWithIgnoreCase" {
	357	test endsWithIgnoreCase {
358	358	try std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));
359	359	try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));
360	360	}
...	...	@@ -409,7 +409,7 @@ fn boyerMooreHorspoolPreprocessIgnoreCase(pattern: []const u8, table: *[256]usiz
409	409	}
410	410	}
411	411
412		test "indexOfIgnoreCase" {
	412	test indexOfIgnoreCase {
413	413	try std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14);
414	414	try std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null);
415	415	try std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);

lib/std/bit_set.zig+5-5

...	...	@@ -1648,7 +1648,7 @@ fn testStaticBitSet(comptime Set: type) !void {
1648	1648	try testPureBitSet(Set);
1649	1649	}
1650	1650
1651		test "IntegerBitSet" {
	1651	test IntegerBitSet {
1652	1652	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1653	1653
1654	1654	try testStaticBitSet(IntegerBitSet(0));
...	...	@@ -1661,7 +1661,7 @@ test "IntegerBitSet" {
1661	1661	try testStaticBitSet(IntegerBitSet(127));
1662	1662	}
1663	1663
1664		test "ArrayBitSet" {
	1664	test ArrayBitSet {
1665	1665	inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) \|size\| {
1666	1666	try testStaticBitSet(ArrayBitSet(u8, size));
1667	1667	try testStaticBitSet(ArrayBitSet(u16, size));
...	...	@@ -1671,7 +1671,7 @@ test "ArrayBitSet" {
1671	1671	}
1672	1672	}
1673	1673
1674		test "DynamicBitSetUnmanaged" {
	1674	test DynamicBitSetUnmanaged {
1675	1675	const allocator = std.testing.allocator;
1676	1676	var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
1677	1677	try testing.expectEqual(@as(usize, 0), a.count());
...	...	@@ -1724,7 +1724,7 @@ test "DynamicBitSetUnmanaged" {
1724	1724	}
1725	1725	}
1726	1726
1727		test "DynamicBitSet" {
	1727	test DynamicBitSet {
1728	1728	const allocator = std.testing.allocator;
1729	1729	var a = try DynamicBitSet.initEmpty(allocator, 300);
1730	1730	try testing.expectEqual(@as(usize, 0), a.count());
...	...	@@ -1765,7 +1765,7 @@ test "DynamicBitSet" {
1765	1765	}
1766	1766	}
1767	1767
1768		test "StaticBitSet" {
	1768	test StaticBitSet {
1769	1769	try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));
1770	1770	try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));
1771	1771	try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));

lib/std/bounded_array.zig+1-1

...	...	@@ -287,7 +287,7 @@ pub fn BoundedArrayAligned(
287	287	};
288	288	}
289	289
290		test "BoundedArray" {
	290	test BoundedArray {
291	291	var a = try BoundedArray(u8, 64).init(32);
292	292
293	293	try testing.expectEqual(a.capacity(), 64);

lib/std/child_process.zig+3-3

...	...	@@ -1230,7 +1230,7 @@ fn windowsCreateProcessSupportsExtension(ext: []const u16) ?CreateProcessSupport
1230	1230	return null;
1231	1231	}
1232	1232
1233		test "windowsCreateProcessSupportsExtension" {
	1233	test windowsCreateProcessSupportsExtension {
1234	1234	try std.testing.expectEqual(CreateProcessSupportedExtension.exe, windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e' }).?);
1235	1235	try std.testing.expect(windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e', 'c' }) == null);
1236	1236	}
...	...	@@ -1321,7 +1321,7 @@ pub fn argvToCommandLineWindows(
1321	1321	return try unicode.wtf8ToWtf16LeAllocZ(allocator, buf.items);
1322	1322	}
1323	1323
1324		test "argvToCommandLineWindows" {
	1324	test argvToCommandLineWindows {
1325	1325	const t = testArgvToCommandLineWindows;
1326	1326
1327	1327	try t(&.{
...	...	@@ -1555,7 +1555,7 @@ pub fn createNullDelimitedEnvMap(arena: mem.Allocator, env_map: *const EnvMap) !
1555	1555	return envp_buf;
1556	1556	}
1557	1557
1558		test "createNullDelimitedEnvMap" {
	1558	test createNullDelimitedEnvMap {
1559	1559	const testing = std.testing;
1560	1560	const allocator = testing.allocator;
1561	1561	var envmap = EnvMap.init(allocator);

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

...	...	@@ -138,7 +138,7 @@ pub inline fn secureZero(comptime T: type, s: []T) void {
138	138	@memset(@as([]volatile T, s), 0);
139	139	}
140	140
141		test "timingSafeEql" {
	141	test timingSafeEql {
142	142	var a: [100]u8 = undefined;
143	143	var b: [100]u8 = undefined;
144	144	random.bytes(a[0..]);
...	...	@@ -162,7 +162,7 @@ test "timingSafeEql (vectors)" {
162	162	try testing.expect(timingSafeEql(@Vector(100, u8), v1, v3));
163	163	}
164	164
165		test "timingSafeCompare" {
	165	test timingSafeCompare {
166	166	var a = [_]u8{10} ** 32;
167	167	var b = [_]u8{10} ** 32;
168	168	try testing.expectEqual(timingSafeCompare(u8, &a, &b, .big), .eq);
...	...	@@ -195,7 +195,7 @@ test "timingSafe{Add,Sub}" {
195	195	}
196	196	}
197	197
198		test "secureZero" {
	198	test secureZero {
199	199	var a = [_]u8{0xfe} ** 8;
200	200	var b = [_]u8{0xfe} ** 8;
201	201

lib/std/debug.zig+2-2

...	...	@@ -908,7 +908,7 @@ fn machoSearchSymbols(symbols: []const MachoSymbol, address: usize) ?*const Mach
908	908	return null;
909	909	}
910	910
911		test "machoSearchSymbols" {
	911	test machoSearchSymbols {
912	912	const symbols = [_]MachoSymbol{
913	913	.{ .addr = 100, .strx = undefined, .size = undefined, .ofile = undefined },
914	914	.{ .addr = 200, .strx = undefined, .size = undefined, .ofile = undefined },
...	...	@@ -1502,7 +1502,7 @@ fn printLineFromFileAnyOs(out_stream: anytype, line_info: LineInfo) !void {
1502	1502	}
1503	1503	}
1504	1504
1505		test "printLineFromFileAnyOs" {
	1505	test printLineFromFileAnyOs {
1506	1506	var output = std.ArrayList(u8).init(std.testing.allocator);
1507	1507	defer output.deinit();
1508	1508	const output_stream = output.writer();

lib/std/fifo.zig+1-1

...	...	@@ -507,7 +507,7 @@ test "LinearFifo(u8, .Dynamic)" {
507	507	}
508	508	}
509	509
510		test "LinearFifo" {
	510	test LinearFifo {
511	511	inline for ([_]type{ u1, u8, u16, u64 }) \|T\| {
512	512	inline for ([_]LinearFifoBufferType{ LinearFifoBufferType{ .Static = 32 }, .Slice, .Dynamic }) \|bt\| {
513	513	const FifoType = LinearFifo(T, bt);

lib/std/fmt.zig+9-9

...	...	@@ -1300,7 +1300,7 @@ pub fn fmtDuration(ns: u64) Formatter(formatDuration) {
1300	1300	return .{ .data = data };
1301	1301	}
1302	1302
1303		test "fmtDuration" {
	1303	test fmtDuration {
1304	1304	var buf: [24]u8 = undefined;
1305	1305	inline for (.{
1306	1306	.{ .s = "0ns", .d = 0 },
...	...	@@ -1364,7 +1364,7 @@ pub fn fmtDurationSigned(ns: i64) Formatter(formatDurationSigned) {
1364	1364	return .{ .data = ns };
1365	1365	}
1366	1366
1367		test "fmtDurationSigned" {
	1367	test fmtDurationSigned {
1368	1368	var buf: [24]u8 = undefined;
1369	1369	inline for (.{
1370	1370	.{ .s = "0ns", .d = 0 },
...	...	@@ -1494,7 +1494,7 @@ pub fn parseInt(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
1494	1494	return parseWithSign(T, buf, base, .pos);
1495	1495	}
1496	1496
1497		test "parseInt" {
	1497	test parseInt {
1498	1498	try std.testing.expect((try parseInt(i32, "-10", 10)) == -10);
1499	1499	try std.testing.expect((try parseInt(i32, "+10", 10)) == 10);
1500	1500	try std.testing.expect((try parseInt(u32, "+10", 10)) == 10);
...	...	@@ -1636,7 +1636,7 @@ pub fn parseUnsigned(comptime T: type, buf: []const u8, base: u8) ParseIntError!
1636	1636	return parseWithSign(T, buf, base, .pos);
1637	1637	}
1638	1638
1639		test "parseUnsigned" {
	1639	test parseUnsigned {
1640	1640	try std.testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);
1641	1641	try std.testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);
1642	1642	try std.testing.expect((try parseUnsigned(u16, "65_535", 10)) == 65535);
...	...	@@ -1710,7 +1710,7 @@ pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
1710	1710	return math.mul(usize, number, multiplier);
1711	1711	}
1712	1712
1713		test "parseIntSizeSuffix" {
	1713	test parseIntSizeSuffix {
1714	1714	try std.testing.expect(try parseIntSizeSuffix("2", 10) == 2);
1715	1715	try std.testing.expect(try parseIntSizeSuffix("2B", 10) == 2);
1716	1716	try std.testing.expect(try parseIntSizeSuffix("2kB", 10) == 2000);
...	...	@@ -1793,7 +1793,7 @@ pub fn allocPrintZ(allocator: mem.Allocator, comptime fmt: []const u8, args: any
1793	1793	return result[0 .. result.len - 1 :0];
1794	1794	}
1795	1795
1796		test "bufPrintInt" {
	1796	test bufPrintIntToSlice {
1797	1797	var buffer: [100]u8 = undefined;
1798	1798	const buf = buffer[0..];
1799	1799
...	...	@@ -1827,7 +1827,7 @@ pub inline fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [cou
1827	1827	}
1828	1828	}
1829	1829
1830		test "comptimePrint" {
	1830	test comptimePrint {
1831	1831	@setEvalBranchQuota(2000);
1832	1832	try std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptimePrint("{}", .{100})));
1833	1833	try std.testing.expectEqualSlices(u8, "100", comptimePrint("{}", .{100}));
...	...	@@ -2442,14 +2442,14 @@ pub fn hexToBytes(out: []u8, input: []const u8) ![]u8 {
2442	2442	return out[0 .. in_i / 2];
2443	2443	}
2444	2444
2445		test "bytesToHex" {
	2445	test bytesToHex {
2446	2446	const input = "input slice";
2447	2447	const encoded = bytesToHex(input, .lower);
2448	2448	var decoded: [input.len]u8 = undefined;
2449	2449	try std.testing.expectEqualSlices(u8, input, try hexToBytes(&decoded, &encoded));
2450	2450	}
2451	2451
2452		test "hexToBytes" {
	2452	test hexToBytes {
2453	2453	var buf: [32]u8 = undefined;
2454	2454	try expectFmt("90" 32, "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "90" 32))});
2455	2455	try expectFmt("ABCD", "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "ABCD"))});

lib/std/fs/get_app_data_dir.zig+1-1

...	...	@@ -60,7 +60,7 @@ pub fn getAppDataDir(allocator: mem.Allocator, appname: []const u8) GetAppDataDi
60	60	}
61	61	}
62	62
63		test "getAppDataDir" {
	63	test getAppDataDir {
64	64	if (builtin.os.tag == .wasi) return error.SkipZigTest;
65	65
66	66	// We can't actually validate the result

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

...	...	@@ -180,7 +180,7 @@ fn testJoinMaybeZPosix(paths: []const []const u8, expected: []const u8, zero: bo
180	180	try testing.expectEqualSlices(u8, expected, if (zero) actual[0 .. actual.len - 1 :0] else actual);
181	181	}
182	182
183		test "join" {
	183	test join {
184	184	{
185	185	const actual: []u8 = try join(testing.allocator, &[_][]const u8{});
186	186	defer testing.allocator.free(actual);
...	...	@@ -303,7 +303,7 @@ pub fn isAbsolutePosixZ(path_c: [*:0]const u8) bool {
303	303	return isAbsolutePosix(mem.sliceTo(path_c, 0));
304	304	}
305	305
306		test "isAbsoluteWindows" {
	306	test isAbsoluteWindows {
307	307	try testIsAbsoluteWindows("", false);
308	308	try testIsAbsoluteWindows("/", true);
309	309	try testIsAbsoluteWindows("//", true);
...	...	@@ -326,7 +326,7 @@ test "isAbsoluteWindows" {
326	326	try testIsAbsoluteWindows("/usr/local", true);
327	327	}
328	328
329		test "isAbsolutePosix" {
	329	test isAbsolutePosix {
330	330	try testIsAbsolutePosix("", false);
331	331	try testIsAbsolutePosix("/home/foo", true);
332	332	try testIsAbsolutePosix("/home/foo/..", true);
...	...	@@ -400,7 +400,7 @@ pub fn windowsParsePath(path: []const u8) WindowsPath {
400	400	return relative_path;
401	401	}
402	402
403		test "windowsParsePath" {
	403	test windowsParsePath {
404	404	{
405	405	const parsed = windowsParsePath("//a/b");
406	406	try testing.expect(parsed.is_abs);
...	...	@@ -884,7 +884,7 @@ pub fn dirnamePosix(path: []const u8) ?[]const u8 {
884	884	return path[0..end_index];
885	885	}
886	886
887		test "dirnamePosix" {
	887	test dirnamePosix {
888	888	try testDirnamePosix("/a/b/c", "/a/b");
889	889	try testDirnamePosix("/a/b/c///", "/a/b");
890	890	try testDirnamePosix("/a", "/");
...	...	@@ -898,7 +898,7 @@ test "dirnamePosix" {
898	898	try testDirnamePosix("a//", null);
899	899	}
900	900
901		test "dirnameWindows" {
	901	test dirnameWindows {
902	902	try testDirnameWindows("c:\\", null);
903	903	try testDirnameWindows("c:\\foo", "c:\\");
904	904	try testDirnameWindows("c:\\foo\\", "c:\\");
...	...	@@ -1011,7 +1011,7 @@ pub fn basenameWindows(path: []const u8) []const u8 {
1011	1011	return path[start_index + 1 .. end_index];
1012	1012	}
1013	1013
1014		test "basename" {
	1014	test basename {
1015	1015	try testBasename("", "");
1016	1016	try testBasename("/", "");
1017	1017	try testBasename("/dir/basename.ext", "basename.ext");
...	...	@@ -1186,7 +1186,7 @@ pub fn relativePosix(allocator: Allocator, from: []const u8, to: []const u8) ![]
1186	1186	return [_]u8{};
1187	1187	}
1188	1188
1189		test "relative" {
	1189	test relative {
1190	1190	try testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");
1191	1191	try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");
1192	1192	try testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");
...	...	@@ -1271,7 +1271,7 @@ fn testExtension(path: []const u8, expected: []const u8) !void {
1271	1271	try testing.expectEqualStrings(expected, extension(path));
1272	1272	}
1273	1273
1274		test "extension" {
	1274	test extension {
1275	1275	try testExtension("", "");
1276	1276	try testExtension(".", "");
1277	1277	try testExtension("a.", ".");
...	...	@@ -1328,7 +1328,7 @@ fn testStem(path: []const u8, expected: []const u8) !void {
1328	1328	try testing.expectEqualStrings(expected, stem(path));
1329	1329	}
1330	1330
1331		test "stem" {
	1331	test stem {
1332	1332	try testStem("hello/world/lib.tar.gz", "lib.tar");
1333	1333	try testStem("hello/world/lib.tar", "lib");
1334	1334	try testStem("hello/world/lib", "lib");

lib/std/io.zig+1-1

...	...	@@ -425,7 +425,7 @@ fn dummyWrite(context: void, data: []const u8) error{}!usize {
425	425	return data.len;
426	426	}
427	427
428		test "null_writer" {
	428	test null_writer {
429	429	null_writer.writeAll("yay" ** 10) catch \|err\| switch (err) {};
430	430	}
431	431

lib/std/math.zig+91-70

...	...	@@ -161,28 +161,51 @@ pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool {
161	161	return @abs(x - y) <= @max(@abs(x), @abs(y)) * tolerance;
162	162	}
163	163
164		test "approxEqAbs and approxEqRel" {
	164	test approxEqAbs {
165	165	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
166	166	const eps_value = comptime floatEps(T);
167		const sqrt_eps_value = comptime sqrt(eps_value);
168		const nan_value = comptime nan(T);
169		const inf_value = comptime inf(T);
170	167	const min_value = comptime floatMin(T);
171	168
172	169	try testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value));
173	170	try testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value));
174	171	try testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value));
175		try testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value));
176		try testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value));
177	172	try testing.expect(!approxEqAbs(T, 1.0 + 2 * eps_value, 1.0, eps_value));
178	173	try testing.expect(approxEqAbs(T, 1.0 + 1 * eps_value, 1.0, eps_value));
	174	try testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2));
	175	try testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2));
	176	}
	177
	178	comptime {
	179	// `comptime_float` is guaranteed to have the same precision and operations of
	180	// the largest other floating point type, which is f128 but it doesn't have a
	181	// defined layout so we can't rely on `@bitCast` to construct the smallest
	182	// possible epsilon value like we do in the tests above. In the same vein, we
	183	// also can't represent a max/min, `NaN` or `Inf` values.
	184	const eps_value = 1e-4;
	185
	186	try testing.expect(approxEqAbs(comptime_float, 0.0, 0.0, eps_value));
	187	try testing.expect(approxEqAbs(comptime_float, -0.0, -0.0, eps_value));
	188	try testing.expect(approxEqAbs(comptime_float, 0.0, -0.0, eps_value));
	189	try testing.expect(!approxEqAbs(comptime_float, 1.0 + 2 * eps_value, 1.0, eps_value));
	190	try testing.expect(approxEqAbs(comptime_float, 1.0 + 1 * eps_value, 1.0, eps_value));
	191	}
	192	}
	193
	194	test approxEqRel {
	195	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
	196	const eps_value = comptime floatEps(T);
	197	const sqrt_eps_value = comptime sqrt(eps_value);
	198	const nan_value = comptime nan(T);
	199	const inf_value = comptime inf(T);
	200	const min_value = comptime floatMin(T);
	201
	202	try testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value));
	203	try testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value));
179	204	try testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value));
180	205	try testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value));
181	206	try testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value));
182	207	try testing.expect(approxEqRel(T, min_value, min_value, sqrt_eps_value));
183	208	try testing.expect(approxEqRel(T, -min_value, -min_value, sqrt_eps_value));
184		try testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2));
185		try testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2));
186	209	}
187	210
188	211	comptime {
...	...	@@ -194,13 +217,8 @@ test "approxEqAbs and approxEqRel" {
194	217	const eps_value = 1e-4;
195	218	const sqrt_eps_value = sqrt(eps_value);
196	219
197		try testing.expect(approxEqAbs(comptime_float, 0.0, 0.0, eps_value));
198		try testing.expect(approxEqAbs(comptime_float, -0.0, -0.0, eps_value));
199		try testing.expect(approxEqAbs(comptime_float, 0.0, -0.0, eps_value));
200	220	try testing.expect(approxEqRel(comptime_float, 1.0, 1.0, sqrt_eps_value));
201	221	try testing.expect(!approxEqRel(comptime_float, 1.0, 0.0, sqrt_eps_value));
202		try testing.expect(!approxEqAbs(comptime_float, 1.0 + 2 * eps_value, 1.0, eps_value));
203		try testing.expect(approxEqAbs(comptime_float, 1.0 + 1 * eps_value, 1.0, eps_value));
204	222	}
205	223	}
206	224
...	...	@@ -300,7 +318,7 @@ pub fn radiansToDegrees(comptime T: type, angle_in_radians: T) T {
300	318	return angle_in_radians * 180.0 / pi;
301	319	}
302	320
303		test "radiansToDegrees" {
	321	test radiansToDegrees {
304	322	try std.testing.expectApproxEqAbs(@as(f32, 0), radiansToDegrees(f32, 0), 1e-6);
305	323	try std.testing.expectApproxEqAbs(@as(f32, 90), radiansToDegrees(f32, pi / 2.0), 1e-6);
306	324	try std.testing.expectApproxEqAbs(@as(f32, -45), radiansToDegrees(f32, -pi / 4.0), 1e-6);
...	...	@@ -315,7 +333,7 @@ pub fn degreesToRadians(comptime T: type, angle_in_degrees: T) T {
315	333	return angle_in_degrees * pi / 180.0;
316	334	}
317	335
318		test "degreesToRadians" {
	336	test degreesToRadians {
319	337	try std.testing.expectApproxEqAbs(@as(f32, pi / 2.0), degreesToRadians(f32, 90), 1e-6);
320	338	try std.testing.expectApproxEqAbs(@as(f32, -3 * pi / 2.0), degreesToRadians(f32, -270), 1e-6);
321	339	try std.testing.expectApproxEqAbs(@as(f32, 2 * pi), degreesToRadians(f32, 360), 1e-6);
...	...	@@ -464,7 +482,7 @@ pub fn wrap(x: anytype, r: anytype) @TypeOf(x) {
464	482	},
465	483	}
466	484	}
467		test "wrap" {
	485	test wrap {
468	486	// Within range
469	487	try testing.expect(wrap(@as(i32, -75), @as(i32, 180)) == -75);
470	488	try testing.expect(wrap(@as(i32, -75), @as(i32, -180)) == -75);
...	...	@@ -501,8 +519,7 @@ test "wrap" {
501	519	var i: i32 = 1;
502	520	_ = &i;
503	521	try testing.expect(wrap(i, 10) == 1);
504		}
505		test wrap {
	522
506	523	const limit: i32 = 180;
507	524	// Within range
508	525	try testing.expect(wrap(@as(i32, -75), limit) == -75);
...	...	@@ -527,7 +544,7 @@ pub fn clamp(val: anytype, lower: anytype, upper: anytype) @TypeOf(val, lower, u
527	544	assert(lower <= upper);
528	545	return @max(lower, @min(val, upper));
529	546	}
530		test "clamp" {
	547	test clamp {
531	548	// Within range
532	549	try testing.expect(std.math.clamp(@as(i32, -1), @as(i32, -4), @as(i32, 7)) == -1);
533	550	// Below
...	...	@@ -608,7 +625,7 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
608	625	return a << casted_shift_amt;
609	626	}
610	627
611		test "shl" {
	628	test shl {
612	629	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
613	630	// https://github.com/ziglang/zig/issues/12012
614	631	return error.SkipZigTest;
...	...	@@ -653,7 +670,7 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
653	670	return a >> casted_shift_amt;
654	671	}
655	672
656		test "shr" {
	673	test shr {
657	674	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
658	675	// https://github.com/ziglang/zig/issues/12012
659	676	return error.SkipZigTest;
...	...	@@ -699,7 +716,7 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T {
699	716	}
700	717	}
701	718
702		test "rotr" {
	719	test rotr {
703	720	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
704	721	// https://github.com/ziglang/zig/issues/12012
705	722	return error.SkipZigTest;
...	...	@@ -744,7 +761,7 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T {
744	761	}
745	762	}
746	763
747		test "rotl" {
	764	test rotl {
748	765	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
749	766	// https://github.com/ziglang/zig/issues/12012
750	767	return error.SkipZigTest;
...	...	@@ -806,7 +823,7 @@ pub fn IntFittingRange(comptime from: comptime_int, comptime to: comptime_int) t
806	823	return std.meta.Int(signedness, magnitude_bits);
807	824	}
808	825
809		test "IntFittingRange" {
	826	test IntFittingRange {
810	827	try testing.expect(IntFittingRange(0, 0) == u0);
811	828	try testing.expect(IntFittingRange(0, 1) == u1);
812	829	try testing.expect(IntFittingRange(0, 2) == u2);
...	...	@@ -874,7 +891,7 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
874	891	return @divTrunc(numerator, denominator);
875	892	}
876	893
877		test "divTrunc" {
	894	test divTrunc {
878	895	try testDivTrunc();
879	896	try comptime testDivTrunc();
880	897	}
...	...	@@ -898,7 +915,7 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
898	915	return @divFloor(numerator, denominator);
899	916	}
900	917
901		test "divFloor" {
	918	test divFloor {
902	919	try testDivFloor();
903	920	try comptime testDivFloor();
904	921	}
...	...	@@ -935,7 +952,7 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
935	952	}
936	953	}
937	954
938		test "divCeil" {
	955	test divCeil {
939	956	try testDivCeil();
940	957	try comptime testDivCeil();
941	958	}
...	...	@@ -979,7 +996,7 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
979	996	return result;
980	997	}
981	998
982		test "divExact" {
	999	test divExact {
983	1000	try testDivExact();
984	1001	try comptime testDivExact();
985	1002	}
...	...	@@ -1005,7 +1022,7 @@ pub fn mod(comptime T: type, numerator: T, denominator: T) !T {
1005	1022	return @mod(numerator, denominator);
1006	1023	}
1007	1024
1008		test "mod" {
	1025	test mod {
1009	1026	try testMod();
1010	1027	try comptime testMod();
1011	1028	}
...	...	@@ -1031,7 +1048,7 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T {
1031	1048	return @rem(numerator, denominator);
1032	1049	}
1033	1050
1034		test "rem" {
	1051	test rem {
1035	1052	try testRem();
1036	1053	try comptime testRem();
1037	1054	}
...	...	@@ -1060,7 +1077,7 @@ pub fn negateCast(x: anytype) !std.meta.Int(.signed, @bitSizeOf(@TypeOf(x))) {
1060	1077	return -@as(int, @intCast(x));
1061	1078	}
1062	1079
1063		test "negateCast" {
	1080	test negateCast {
1064	1081	try testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999);
1065	1082	try testing.expect(@TypeOf(negateCast(@as(u32, 999)) catch unreachable) == i32);
1066	1083
...	...	@@ -1085,7 +1102,7 @@ pub fn cast(comptime T: type, x: anytype) ?T {
1085	1102	}
1086	1103	}
1087	1104
1088		test "cast" {
	1105	test cast {
1089	1106	try testing.expect(cast(u8, 300) == null);
1090	1107	try testing.expect(cast(u8, @as(u32, 300)) == null);
1091	1108	try testing.expect(cast(i8, -200) == null);
...	...	@@ -1144,7 +1161,7 @@ pub fn ByteAlignedInt(comptime T: type) type {
1144	1161	return extended_type;
1145	1162	}
1146	1163
1147		test "ByteAlignedInt" {
	1164	test ByteAlignedInt {
1148	1165	try testing.expect(ByteAlignedInt(u0) == u0);
1149	1166	try testing.expect(ByteAlignedInt(i0) == i0);
1150	1167	try testing.expect(ByteAlignedInt(u3) == u8);
...	...	@@ -1182,7 +1199,7 @@ pub fn floorPowerOfTwo(comptime T: type, value: T) T {
1182	1199	return @as(T, 1) << log2_int(uT, @as(uT, @intCast(value)));
1183	1200	}
1184	1201
1185		test "floorPowerOfTwo" {
	1202	test floorPowerOfTwo {
1186	1203	try testFloorPowerOfTwo();
1187	1204	try comptime testFloorPowerOfTwo();
1188	1205	}
...	...	@@ -1244,7 +1261,7 @@ pub fn ceilPowerOfTwoAssert(comptime T: type, value: T) T {
1244	1261	return ceilPowerOfTwo(T, value) catch unreachable;
1245	1262	}
1246	1263
1247		test "ceilPowerOfTwoPromote" {
	1264	test ceilPowerOfTwoPromote {
1248	1265	try testCeilPowerOfTwoPromote();
1249	1266	try comptime testCeilPowerOfTwoPromote();
1250	1267	}
...	...	@@ -1261,7 +1278,7 @@ fn testCeilPowerOfTwoPromote() !void {
1261	1278	try testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9));
1262	1279	}
1263	1280
1264		test "ceilPowerOfTwo" {
	1281	test ceilPowerOfTwo {
1265	1282	try testCeilPowerOfTwo();
1266	1283	try comptime testCeilPowerOfTwo();
1267	1284	}
...	...	@@ -1354,7 +1371,7 @@ pub fn lossyCast(comptime T: type, value: anytype) T {
1354	1371	}
1355	1372	}
1356	1373
1357		test "lossyCast" {
	1374	test lossyCast {
1358	1375	try testing.expect(lossyCast(i16, 70000.0) == @as(i16, 32767));
1359	1376	try testing.expect(lossyCast(u32, @as(i16, -255)) == @as(u32, 0));
1360	1377	try testing.expect(lossyCast(i9, @as(u32, 200)) == @as(i9, 200));
...	...	@@ -1383,7 +1400,7 @@ pub fn lerp(a: anytype, b: anytype, t: anytype) @TypeOf(a, b, t) {
1383	1400	return @mulAdd(Type, b - a, t, a);
1384	1401	}
1385	1402
1386		test "lerp" {
	1403	test lerp {
1387	1404	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/17884
1388	1405	if (builtin.zig_backend == .stage2_x86_64 and
1389	1406	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .fma)) return error.SkipZigTest;
...	...	@@ -1437,7 +1454,7 @@ pub fn minInt(comptime T: type) comptime_int {
1437	1454	return -(1 << (bit_count - 1));
1438	1455	}
1439	1456
1440		test "minInt and maxInt" {
	1457	test maxInt {
1441	1458	try testing.expect(maxInt(u0) == 0);
1442	1459	try testing.expect(maxInt(u1) == 1);
1443	1460	try testing.expect(maxInt(u8) == 255);
...	...	@@ -1454,7 +1471,9 @@ test "minInt and maxInt" {
1454	1471	try testing.expect(maxInt(i63) == 4611686018427387903);
1455	1472	try testing.expect(maxInt(i64) == 9223372036854775807);
1456	1473	try testing.expect(maxInt(i128) == 170141183460469231731687303715884105727);
	1474	}
1457	1475
	1476	test minInt {
1458	1477	try testing.expect(minInt(u0) == 0);
1459	1478	try testing.expect(minInt(u1) == 0);
1460	1479	try testing.expect(minInt(u8) == 0);
...	...	@@ -1492,7 +1511,7 @@ pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(
1492	1511	return @as(ResultInt, a) * @as(ResultInt, b);
1493	1512	}
1494	1513
1495		test "mulWide" {
	1514	test mulWide {
1496	1515	try testing.expect(mulWide(u8, 5, 5) == 25);
1497	1516	try testing.expect(mulWide(i8, 5, -5) == -25);
1498	1517	try testing.expect(mulWide(u8, 100, 100) == 10000);
...	...	@@ -1517,6 +1536,12 @@ pub const Order = enum {
1517	1536	};
1518	1537	}
1519	1538
	1539	test invert {
	1540	try testing.expect(Order.invert(order(0, 0)) == .eq);
	1541	try testing.expect(Order.invert(order(1, 0)) == .lt);
	1542	try testing.expect(Order.invert(order(-1, 0)) == .gt);
	1543	}
	1544
1520	1545	pub fn compare(self: Order, op: CompareOperator) bool {
1521	1546	return switch (self) {
1522	1547	.lt => switch (op) {
...	...	@@ -1545,6 +1570,19 @@ pub const Order = enum {
1545	1570	},
1546	1571	};
1547	1572	}
	1573
	1574	// TODO flaw in the language, can't make this a doctest due to ambiguous reference
	1575	// also: can't currently add a doctest from an outside scope
	1576	test "compare" {
	1577	try testing.expect(order(-1, 0).compare(.lt));
	1578	try testing.expect(order(-1, 0).compare(.lte));
	1579	try testing.expect(order(0, 0).compare(.lte));
	1580	try testing.expect(order(0, 0).compare(.eq));
	1581	try testing.expect(order(0, 0).compare(.gte));
	1582	try testing.expect(order(1, 0).compare(.gte));
	1583	try testing.expect(order(1, 0).compare(.gt));
	1584	try testing.expect(order(1, 0).compare(.neq));
	1585	}
1548	1586	};
1549	1587
1550	1588	/// Given two numbers, this function returns the order they are with respect to each other.
...	...	@@ -1587,6 +1625,15 @@ pub const CompareOperator = enum {
1587	1625	.neq => .neq,
1588	1626	};
1589	1627	}
	1628
	1629	test reverse {
	1630	inline for (@typeInfo(CompareOperator).Enum.fields) \|op_field\| {
	1631	const op = @as(CompareOperator, @enumFromInt(op_field.value));
	1632	try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2));
	1633	try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3));
	1634	try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4));
	1635	}
	1636	}
1590	1637	};
1591	1638
1592	1639	/// This function does the same thing as comparison operators, however the
...	...	@@ -1603,7 +1650,7 @@ pub fn compare(a: anytype, op: CompareOperator, b: anytype) bool {
1603	1650	};
1604	1651	}
1605	1652
1606		test "compare between signed and unsigned" {
	1653	test compare {
1607	1654	try testing.expect(compare(@as(i8, -1), .lt, @as(u8, 255)));
1608	1655	try testing.expect(compare(@as(i8, 2), .gt, @as(u8, 1)));
1609	1656	try testing.expect(!compare(@as(i8, -1), .gte, @as(u8, 255)));
...	...	@@ -1623,38 +1670,12 @@ test "compare between signed and unsigned" {
1623	1670	try testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));
1624	1671	}
1625	1672
1626		test "order" {
	1673	test order {
1627	1674	try testing.expect(order(0, 0) == .eq);
1628	1675	try testing.expect(order(1, 0) == .gt);
1629	1676	try testing.expect(order(-1, 0) == .lt);
1630	1677	}
1631	1678
1632		test "order.invert" {
1633		try testing.expect(Order.invert(order(0, 0)) == .eq);
1634		try testing.expect(Order.invert(order(1, 0)) == .lt);
1635		try testing.expect(Order.invert(order(-1, 0)) == .gt);
1636		}
1637
1638		test "order.compare" {
1639		try testing.expect(order(-1, 0).compare(.lt));
1640		try testing.expect(order(-1, 0).compare(.lte));
1641		try testing.expect(order(0, 0).compare(.lte));
1642		try testing.expect(order(0, 0).compare(.eq));
1643		try testing.expect(order(0, 0).compare(.gte));
1644		try testing.expect(order(1, 0).compare(.gte));
1645		try testing.expect(order(1, 0).compare(.gt));
1646		try testing.expect(order(1, 0).compare(.neq));
1647		}
1648
1649		test "compare.reverse" {
1650		inline for (@typeInfo(CompareOperator).Enum.fields) \|op_field\| {
1651		const op = @as(CompareOperator, @enumFromInt(op_field.value));
1652		try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2));
1653		try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3));
1654		try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4));
1655		}
1656		}
1657
1658	1679	/// Returns a mask of all ones if value is true,
1659	1680	/// and a mask of all zeroes if value is false.
1660	1681	/// Compiles to one instruction for register sized integers.
...	...	@@ -1676,7 +1697,7 @@ pub inline fn boolMask(comptime MaskInt: type, value: bool) MaskInt {
1676	1697	return -%@as(MaskInt, @intCast(@intFromBool(value)));
1677	1698	}
1678	1699
1679		test "boolMask" {
	1700	test boolMask {
1680	1701	const runTest = struct {
1681	1702	fn runTest() !void {
1682	1703	try testing.expectEqual(@as(u1, 0), boolMask(u1, false));
...	...	@@ -1824,7 +1845,7 @@ fn testSign() !void {
1824	1845	try std.testing.expectEqual(0.0, sign(0.0));
1825	1846	}
1826	1847
1827		test "sign" {
	1848	test sign {
1828	1849	if (builtin.zig_backend == .stage2_llvm) {
1829	1850	// https://github.com/ziglang/zig/issues/12012
1830	1851	return error.SkipZigTest;

lib/std/mem.zig+66-64

...	...	@@ -306,7 +306,7 @@ pub fn zeroes(comptime T: type) T {
306	306	}
307	307	}
308	308
309		test "zeroes" {
	309	test zeroes {
310	310	const C_struct = extern struct {
311	311	x: u32,
312	312	y: u32 align(128),
...	...	@@ -475,7 +475,7 @@ pub fn zeroInit(comptime T: type, init: anytype) T {
475	475	}
476	476	}
477	477
478		test "zeroInit" {
	478	test zeroInit {
479	479	const I = struct {
480	480	d: f64,
481	481	};
...	...	@@ -606,16 +606,19 @@ pub fn orderZ(comptime T: type, lhs: [:0]const T, rhs: [:0]const T) math.Order
606	606	return math.order(lhs[i], rhs[i]);
607	607	}
608	608
609		test "order and orderZ" {
	609	test order {
610	610	try testing.expect(order(u8, "abcd", "bee") == .lt);
611		try testing.expect(orderZ(u8, "abcd", "bee") == .lt);
612	611	try testing.expect(order(u8, "abc", "abc") == .eq);
613		try testing.expect(orderZ(u8, "abc", "abc") == .eq);
614	612	try testing.expect(order(u8, "abc", "abc0") == .lt);
615		try testing.expect(orderZ(u8, "abc", "abc0") == .lt);
616	613	try testing.expect(order(u8, "", "") == .eq);
617		try testing.expect(orderZ(u8, "", "") == .eq);
618	614	try testing.expect(order(u8, "", "a") == .lt);
	615	}
	616
	617	test orderZ {
	618	try testing.expect(orderZ(u8, "abcd", "bee") == .lt);
	619	try testing.expect(orderZ(u8, "abc", "abc") == .eq);
	620	try testing.expect(orderZ(u8, "abc", "abc0") == .lt);
	621	try testing.expect(orderZ(u8, "", "") == .eq);
619	622	try testing.expect(orderZ(u8, "", "a") == .lt);
620	623	}
621	624
...	...	@@ -624,7 +627,7 @@ pub fn lessThan(comptime T: type, lhs: []const T, rhs: []const T) bool {
624	627	return order(T, lhs, rhs) == .lt;
625	628	}
626	629
627		test "lessThan" {
	630	test lessThan {
628	631	try testing.expect(lessThan(u8, "abcd", "bee"));
629	632	try testing.expect(!lessThan(u8, "abc", "abc"));
630	633	try testing.expect(lessThan(u8, "abc", "abc0"));
...	...	@@ -726,7 +729,7 @@ pub fn indexOfDiff(comptime T: type, a: []const T, b: []const T) ?usize {
726	729	return if (a.len == b.len) null else shortest;
727	730	}
728	731
729		test "indexOfDiff" {
	732	test indexOfDiff {
730	733	try testing.expectEqual(indexOfDiff(u8, "one", "one"), null);
731	734	try testing.expectEqual(indexOfDiff(u8, "one two", "one"), 3);
732	735	try testing.expectEqual(indexOfDiff(u8, "one", "one two"), 3);
...	...	@@ -759,7 +762,7 @@ fn Span(comptime T: type) type {
759	762	@compileError("invalid type given to std.mem.span: " ++ @typeName(T));
760	763	}
761	764
762		test "Span" {
	765	test Span {
763	766	try testing.expect(Span([*:1]u16) == [:1]u16);
764	767	try testing.expect(Span(?[*:1]u16) == ?[:1]u16);
765	768	try testing.expect(Span([*:1]const u8) == [:1]const u8);
...	...	@@ -793,7 +796,7 @@ pub fn span(ptr: anytype) Span(@TypeOf(ptr)) {
793	796	}
794	797	}
795	798
796		test "span" {
	799	test span {
797	800	var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 };
798	801	const ptr = @as([*:3]u16, array[0..2 :3]);
799	802	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(
877	880	}
878	881	}
879	882
880		test "sliceTo" {
	883	test sliceTo {
881	884	try testing.expectEqualSlices(u8, "aoeu", sliceTo("aoeu", 0));
882	885
883	886	{
...	...	@@ -963,7 +966,7 @@ fn lenSliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) usize {
963	966	@compileError("invalid type given to std.mem.sliceTo: " ++ @typeName(@TypeOf(ptr)));
964	967	}
965	968
966		test "lenSliceTo" {
	969	test lenSliceTo {
967	970	try testing.expect(lenSliceTo("aoeu", 0) == 4);
968	971
969	972	{
...	...	@@ -1018,7 +1021,7 @@ pub fn len(value: anytype) usize {
1018	1021	}
1019	1022	}
1020	1023
1021		test "len" {
	1024	test len {
1022	1025	var array: [5]u16 = [_]u16{ 1, 2, 0, 4, 5 };
1023	1026	const ptr = @as([*:4]u16, array[0..3 :4]);
1024	1027	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
1157	1160	return slice[begin..end];
1158	1161	}
1159	1162
1160		test "trim" {
	1163	test trim {
1161	1164	try testing.expectEqualSlices(u8, "foo\n ", trimLeft(u8, " foo\n ", " \n"));
1162	1165	try testing.expectEqualSlices(u8, " foo", trimRight(u8, " foo\n ", " \n"));
1163	1166	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,
1240	1243	return null;
1241	1244	}
1242	1245
1243		test "indexOfScalarPos" {
	1246	test indexOfScalarPos {
1244	1247	const Types = [_]type{ u8, u16, u32, u64 };
1245	1248
1246	1249	inline for (Types) \|T\| {
...	...	@@ -1316,7 +1319,7 @@ pub fn indexOfNonePos(comptime T: type, slice: []const T, start_index: usize, va
1316	1319	return null;
1317	1320	}
1318	1321
1319		test "indexOfNone" {
	1322	test indexOfNone {
1320	1323	try testing.expect(indexOfNone(u8, "abc123", "123").? == 0);
1321	1324	try testing.expect(lastIndexOfNone(u8, "abc123", "123").? == 2);
1322	1325	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
1460	1463	return null;
1461	1464	}
1462	1465
1463		test "indexOf" {
	1466	test indexOf {
1464	1467	try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8);
1465	1468	try testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8);
1466	1469	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 {
1533	1536	return found;
1534	1537	}
1535	1538
1536		test "count" {
	1539	test count {
1537	1540	try testing.expect(count(u8, "", "h") == 0);
1538	1541	try testing.expect(count(u8, "h", "h") == 1);
1539	1542	try testing.expect(count(u8, "hh", "h") == 2);
...	...	@@ -1565,7 +1568,7 @@ pub fn containsAtLeast(comptime T: type, haystack: []const T, expected_count: us
1565	1568	return false;
1566	1569	}
1567	1570
1568		test "containsAtLeast" {
	1571	test containsAtLeast {
1569	1572	try testing.expect(containsAtLeast(u8, "aa", 0, "a"));
1570	1573	try testing.expect(containsAtLeast(u8, "aa", 1, "a"));
1571	1574	try testing.expect(containsAtLeast(u8, "aa", 2, "a"));
...	...	@@ -1698,6 +1701,9 @@ test readInt {
1698	1701
1699	1702	try testing.expect(readInt(i16, &[_]u8{ 0xff, 0xfd }, .big) == -3);
1700	1703	try testing.expect(readInt(i16, &[_]u8{ 0xfc, 0xff }, .little) == -4);
	1704
	1705	try moreReadIntTests();
	1706	try comptime moreReadIntTests();
1701	1707	}
1702	1708
1703	1709	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 {
2027	2033	}
2028	2034	}
2029	2035
2030		test "byteSwapAllFields" {
	2036	test byteSwapAllFields {
2031	2037	const T = extern struct {
2032	2038	f0: u8,
2033	2039	f1: u16,
...	...	@@ -2136,7 +2142,7 @@ pub fn tokenizeScalar(comptime T: type, buffer: []const T, delimiter: T) TokenIt
2136	2142	};
2137	2143	}
2138	2144
2139		test "tokenizeScalar" {
	2145	test tokenizeScalar {
2140	2146	var it = tokenizeScalar(u8, " abc def ghi ", ' ');
2141	2147	try testing.expect(eql(u8, it.next().?, "abc"));
2142	2148	try testing.expect(eql(u8, it.peek().?, "def"));
...	...	@@ -2177,7 +2183,7 @@ test "tokenizeScalar" {
2177	2183	try testing.expect(it16.next() == null);
2178	2184	}
2179	2185
2180		test "tokenizeAny" {
	2186	test tokenizeAny {
2181	2187	var it = tokenizeAny(u8, "a\|b,c/d e", " /,\|");
2182	2188	try testing.expect(eql(u8, it.next().?, "a"));
2183	2189	try testing.expect(eql(u8, it.peek().?, "b"));
...	...	@@ -2205,7 +2211,7 @@ test "tokenizeAny" {
2205	2211	try testing.expect(it16.next() == null);
2206	2212	}
2207	2213
2208		test "tokenizeSequence" {
	2214	test tokenizeSequence {
2209	2215	var it = tokenizeSequence(u8, "a<>b<><>c><>d><", "<>");
2210	2216	try testing.expectEqualStrings("a", it.next().?);
2211	2217	try testing.expectEqualStrings("b", it.peek().?);
...	...	@@ -2334,7 +2340,7 @@ pub fn splitScalar(comptime T: type, buffer: []const T, delimiter: T) SplitItera
2334	2340	};
2335	2341	}
2336	2342
2337		test "splitScalar" {
	2343	test splitScalar {
2338	2344	var it = splitScalar(u8, "abc\|def\|\|ghi", '\|');
2339	2345	try testing.expectEqualSlices(u8, it.rest(), "abc\|def\|\|ghi");
2340	2346	try testing.expectEqualSlices(u8, it.first(), "abc");
...	...	@@ -2377,7 +2383,7 @@ test "splitScalar" {
2377	2383	try testing.expect(it16.next() == null);
2378	2384	}
2379	2385
2380		test "splitSequence" {
	2386	test splitSequence {
2381	2387	var it = splitSequence(u8, "a, b ,, c, d, e", ", ");
2382	2388	try testing.expectEqualSlices(u8, it.first(), "a");
2383	2389	try testing.expectEqualSlices(u8, it.rest(), "b ,, c, d, e");
...	...	@@ -2400,7 +2406,7 @@ test "splitSequence" {
2400	2406	try testing.expect(it16.next() == null);
2401	2407	}
2402	2408
2403		test "splitAny" {
	2409	test splitAny {
2404	2410	var it = splitAny(u8, "a,b, c d e", ", ");
2405	2411	try testing.expectEqualSlices(u8, it.first(), "a");
2406	2412	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
2536	2542	};
2537	2543	}
2538	2544
2539		test "splitBackwardsScalar" {
	2545	test splitBackwardsScalar {
2540	2546	var it = splitBackwardsScalar(u8, "abc\|def\|\|ghi", '\|');
2541	2547	try testing.expectEqualSlices(u8, it.rest(), "abc\|def\|\|ghi");
2542	2548	try testing.expectEqualSlices(u8, it.first(), "ghi");
...	...	@@ -2575,7 +2581,7 @@ test "splitBackwardsScalar" {
2575	2581	try testing.expect(it16.next() == null);
2576	2582	}
2577	2583
2578		test "splitBackwardsSequence" {
	2584	test splitBackwardsSequence {
2579	2585	var it = splitBackwardsSequence(u8, "a, b ,, c, d, e", ", ");
2580	2586	try testing.expectEqualSlices(u8, it.rest(), "a, b ,, c, d, e");
2581	2587	try testing.expectEqualSlices(u8, it.first(), "e");
...	...	@@ -2608,7 +2614,7 @@ test "splitBackwardsSequence" {
2608	2614	try testing.expect(it16.next() == null);
2609	2615	}
2610	2616
2611		test "splitBackwardsAny" {
	2617	test splitBackwardsAny {
2612	2618	var it = splitBackwardsAny(u8, "a,b, c d e", ", ");
2613	2619	try testing.expectEqualSlices(u8, it.rest(), "a,b, c d e");
2614	2620	try testing.expectEqualSlices(u8, it.first(), "e");
...	...	@@ -2715,7 +2721,7 @@ pub fn window(comptime T: type, buffer: []const T, size: usize, advance: usize)
2715	2721	};
2716	2722	}
2717	2723
2718		test "window" {
	2724	test window {
2719	2725	{
2720	2726	// moving average size 3
2721	2727	var it = window(u8, "abcdefg", 3, 1);
...	...	@@ -2841,7 +2847,7 @@ pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool
2841	2847	return if (needle.len > haystack.len) false else eql(T, haystack[0..needle.len], needle);
2842	2848	}
2843	2849
2844		test "startsWith" {
	2850	test startsWith {
2845	2851	try testing.expect(startsWith(u8, "Bob", "Bo"));
2846	2852	try testing.expect(!startsWith(u8, "Needle in haystack", "haystack"));
2847	2853	}
...	...	@@ -2850,7 +2856,7 @@ pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool {
2850	2856	return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len ..], needle);
2851	2857	}
2852	2858
2853		test "endsWith" {
	2859	test endsWith {
2854	2860	try testing.expect(endsWith(u8, "Needle in haystack", "haystack"));
2855	2861	try testing.expect(!endsWith(u8, "Bob", "Bo"));
2856	2862	}
...	...	@@ -3086,7 +3092,7 @@ fn joinMaybeZ(allocator: Allocator, separator: []const u8, slices: []const []con
3086	3092	return buf;
3087	3093	}
3088	3094
3089		test "join" {
	3095	test join {
3090	3096	{
3091	3097	const str = try join(testing.allocator, ",", &[_][]const u8{});
3092	3098	defer testing.allocator.free(str);
...	...	@@ -3109,7 +3115,7 @@ test "join" {
3109	3115	}
3110	3116	}
3111	3117
3112		test "joinZ" {
	3118	test joinZ {
3113	3119	{
3114	3120	const str = try joinZ(testing.allocator, ",", &[_][]const u8{});
3115	3121	defer testing.allocator.free(str);
...	...	@@ -3181,7 +3187,7 @@ pub fn concatMaybeSentinel(allocator: Allocator, comptime T: type, slices: []con
3181	3187	return buf;
3182	3188	}
3183	3189
3184		test "concat" {
	3190	test concat {
3185	3191	{
3186	3192	const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" });
3187	3193	defer testing.allocator.free(str);
...	...	@@ -3219,17 +3225,13 @@ test "concat" {
3219	3225	}
3220	3226	}
3221	3227
3222		test "testStringEquality" {
	3228	test eql {
3223	3229	try testing.expect(eql(u8, "abcd", "abcd"));
3224	3230	try testing.expect(!eql(u8, "abcdef", "abZdef"));
3225	3231	try testing.expect(!eql(u8, "abcdefg", "abcdef"));
3226	3232	}
3227	3233
3228		test "testReadInt" {
3229		try testReadIntImpl();
3230		try comptime testReadIntImpl();
3231		}
3232		fn testReadIntImpl() !void {
	3234	fn moreReadIntTests() !void {
3233	3235	{
3234	3236	const bytes = [_]u8{
3235	3237	0x12,
...	...	@@ -3287,7 +3289,7 @@ pub fn min(comptime T: type, slice: []const T) T {
3287	3289	return best;
3288	3290	}
3289	3291
3290		test "min" {
	3292	test min {
3291	3293	try testing.expectEqual(min(u8, "abcdefg"), 'a');
3292	3294	try testing.expectEqual(min(u8, "bcdefga"), 'a');
3293	3295	try testing.expectEqual(min(u8, "a"), 'a');
...	...	@@ -3304,7 +3306,7 @@ pub fn max(comptime T: type, slice: []const T) T {
3304	3306	return best;
3305	3307	}
3306	3308
3307		test "max" {
	3309	test max {
3308	3310	try testing.expectEqual(max(u8, "abcdefg"), 'g');
3309	3311	try testing.expectEqual(max(u8, "gabcdef"), 'g');
3310	3312	try testing.expectEqual(max(u8, "g"), 'g');
...	...	@@ -3357,7 +3359,7 @@ pub fn indexOfMin(comptime T: type, slice: []const T) usize {
3357	3359	return index;
3358	3360	}
3359	3361
3360		test "indexOfMin" {
	3362	test indexOfMin {
3361	3363	try testing.expectEqual(indexOfMin(u8, "abcdefg"), 0);
3362	3364	try testing.expectEqual(indexOfMin(u8, "bcdefga"), 6);
3363	3365	try testing.expectEqual(indexOfMin(u8, "a"), 0);
...	...	@@ -3378,7 +3380,7 @@ pub fn indexOfMax(comptime T: type, slice: []const T) usize {
3378	3380	return index;
3379	3381	}
3380	3382
3381		test "indexOfMax" {
	3383	test indexOfMax {
3382	3384	try testing.expectEqual(indexOfMax(u8, "abcdefg"), 6);
3383	3385	try testing.expectEqual(indexOfMax(u8, "gabcdef"), 0);
3384	3386	try testing.expectEqual(indexOfMax(u8, "a"), 0);
...	...	@@ -3408,7 +3410,7 @@ pub fn indexOfMinMax(comptime T: type, slice: []const T) IndexOfMinMaxResult {
3408	3410
3409	3411	pub const IndexOfMinMaxResult = struct { index_min: usize, index_max: usize };
3410	3412
3411		test "indexOfMinMax" {
	3413	test indexOfMinMax {
3412	3414	try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 0, .index_max = 6 }, indexOfMinMax(u8, "abcdefg"));
3413	3415	try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 1, .index_max = 0 }, indexOfMinMax(u8, "gabcdef"));
3414	3416	try testing.expectEqual(IndexOfMinMaxResult{ .index_min = 0, .index_max = 0 }, indexOfMinMax(u8, "a"));
...	...	@@ -3429,7 +3431,7 @@ pub fn reverse(comptime T: type, items: []T) void {
3429	3431	}
3430	3432	}
3431	3433
3432		test "reverse" {
	3434	test reverse {
3433	3435	var arr = [_]i32{ 5, 3, 1, 2, 4 };
3434	3436	reverse(i32, arr[0..]);
3435	3437
...	...	@@ -3490,7 +3492,7 @@ pub fn reverseIterator(slice: anytype) ReverseIterator(@TypeOf(slice)) {
3490	3492	return .{ .ptr = slice.ptr, .index = slice.len };
3491	3493	}
3492	3494
3493		test "reverseIterator" {
	3495	test reverseIterator {
3494	3496	{
3495	3497	var it = reverseIterator("abc");
3496	3498	try testing.expectEqual(@as(?u8, 'c'), it.next());
...	...	@@ -3548,7 +3550,7 @@ pub fn rotate(comptime T: type, items: []T, amount: usize) void {
3548	3550	reverse(T, items);
3549	3551	}
3550	3552
3551		test "rotate" {
	3553	test rotate {
3552	3554	var arr = [_]i32{ 5, 3, 1, 2, 4 };
3553	3555	rotate(i32, arr[0..], 2);
3554	3556
...	...	@@ -3582,7 +3584,7 @@ pub fn replace(comptime T: type, input: []const T, needle: []const T, replacemen
3582	3584	return replacements;
3583	3585	}
3584	3586
3585		test "replace" {
	3587	test replace {
3586	3588	var output: [29]u8 = undefined;
3587	3589	var replacements = replace(u8, "All your base are belong to us", "base", "Zig", output[0..]);
3588	3590	var expected: []const u8 = "All your Zig are belong to us";
...	...	@@ -3645,7 +3647,7 @@ fn testCollapseRepeats(str: []const u8, elem: u8, expected: []const u8) !void {
3645	3647	defer std.testing.allocator.free(mutable);
3646	3648	try testing.expect(std.mem.eql(u8, collapseRepeats(u8, mutable, elem), expected));
3647	3649	}
3648		test "collapseRepeats" {
	3650	test collapseRepeats {
3649	3651	try testCollapseRepeats("", '/', "");
3650	3652	try testCollapseRepeats("a", '/', "a");
3651	3653	try testCollapseRepeats("/", '/', "/");
...	...	@@ -3679,7 +3681,7 @@ pub fn replacementSize(comptime T: type, input: []const T, needle: []const T, re
3679	3681	return size;
3680	3682	}
3681	3683
3682		test "replacementSize" {
	3684	test replacementSize {
3683	3685	try testing.expect(replacementSize(u8, "All your base are belong to us", "base", "Zig") == 29);
3684	3686	try testing.expect(replacementSize(u8, "Favor reading code over writing code.", "code", "") == 29);
3685	3687	try testing.expect(replacementSize(u8, "Only one obvious way to do things.", "things.", "things in Zig.") == 41);
...	...	@@ -3699,7 +3701,7 @@ pub fn replaceOwned(comptime T: type, allocator: Allocator, input: []const T, ne
3699	3701	return output;
3700	3702	}
3701	3703
3702		test "replaceOwned" {
	3704	test replaceOwned {
3703	3705	const gpa = std.testing.allocator;
3704	3706
3705	3707	const base_replace = replaceOwned(u8, gpa, "All your base are belong to us", "base", "Zig") catch @panic("out of memory");
...	...	@@ -3803,7 +3805,7 @@ pub fn alignPointer(ptr: anytype, align_to: usize) ?@TypeOf(ptr) {
3803	3805	return @alignCast(ptr + adjust_off);
3804	3806	}
3805	3807
3806		test "alignPointer" {
	3808	test alignPointer {
3807	3809	const S = struct {
3808	3810	fn checkAlign(comptime T: type, base: usize, align_to: usize, expected: usize) !void {
3809	3811	const ptr: T = @ptrFromInt(base);
...	...	@@ -3852,7 +3854,7 @@ pub fn asBytes(ptr: anytype) AsBytesReturnType(@TypeOf(ptr)) {
3852	3854	return @ptrCast(@alignCast(ptr));
3853	3855	}
3854	3856
3855		test "asBytes" {
	3857	test asBytes {
3856	3858	const deadbeef = @as(u32, 0xDEADBEEF);
3857	3859	const deadbeef_bytes = switch (native_endian) {
3858	3860	.big => "\xDE\xAD\xBE\xEF",
...	...	@@ -3912,7 +3914,7 @@ pub fn toBytes(value: anytype) [@sizeOf(@TypeOf(value))]u8 {
3912	3914	return asBytes(&value).*;
3913	3915	}
3914	3916
3915		test "toBytes" {
	3917	test toBytes {
3916	3918	var my_bytes = toBytes(@as(u32, 0x12345678));
3917	3919	switch (native_endian) {
3918	3920	.big => try testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")),
...	...	@@ -3936,7 +3938,7 @@ pub fn bytesAsValue(comptime T: type, bytes: anytype) BytesAsValueReturnType(T,
3936	3938	return @ptrCast(bytes);
3937	3939	}
3938	3940
3939		test "bytesAsValue" {
	3941	test bytesAsValue {
3940	3942	const deadbeef = @as(u32, 0xDEADBEEF);
3941	3943	const deadbeef_bytes = switch (native_endian) {
3942	3944	.big => "\xDE\xAD\xBE\xEF",
...	...	@@ -3995,7 +3997,7 @@ test "bytesAsValue preserves pointer attributes" {
3995	3997	pub fn bytesToValue(comptime T: type, bytes: anytype) T {
3996	3998	return bytesAsValue(T, bytes).*;
3997	3999	}
3998		test "bytesToValue" {
	4000	test bytesToValue {
3999	4001	const deadbeef_bytes = switch (native_endian) {
4000	4002	.big => "\xDE\xAD\xBE\xEF",
4001	4003	.little => "\xEF\xBE\xAD\xDE",
...	...	@@ -4023,7 +4025,7 @@ pub fn bytesAsSlice(comptime T: type, bytes: anytype) BytesAsSliceReturnType(T,
4023	4025	return @as(cast_target, @ptrCast(bytes))[0..@divExact(bytes.len, @sizeOf(T))];
4024	4026	}
4025	4027
4026		test "bytesAsSlice" {
	4028	test bytesAsSlice {
4027	4029	{
4028	4030	const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF };
4029	4031	const slice = bytesAsSlice(u16, bytes[0..]);
...	...	@@ -4112,7 +4114,7 @@ pub fn sliceAsBytes(slice: anytype) SliceAsBytesReturnType(@TypeOf(slice)) {
4112	4114	return @as(cast_target, @ptrCast(slice))[0 .. slice.len * @sizeOf(std.meta.Elem(Slice))];
4113	4115	}
4114	4116
4115		test "sliceAsBytes" {
	4117	test sliceAsBytes {
4116	4118	const bytes = [_]u16{ 0xDEAD, 0xBEEF };
4117	4119	const slice = sliceAsBytes(bytes[0..]);
4118	4120	try testing.expect(slice.len == 4);
...	...	@@ -4270,7 +4272,7 @@ fn doNotOptimizeAwayC(ptr: anytype) void {
4270	4272	dest.* = 0;
4271	4273	}
4272	4274
4273		test "doNotOptimizeAway" {
	4275	test doNotOptimizeAway {
4274	4276	comptime doNotOptimizeAway("test");
4275	4277
4276	4278	doNotOptimizeAway(null);
...	...	@@ -4295,7 +4297,7 @@ test "doNotOptimizeAway" {
4295	4297	doNotOptimizeAway(@as(std.builtin.Endian, .little));
4296	4298	}
4297	4299
4298		test "alignForward" {
	4300	test alignForward {
4299	4301	try testing.expect(alignForward(usize, 1, 1) == 1);
4300	4302	try testing.expect(alignForward(usize, 2, 1) == 2);
4301	4303	try testing.expect(alignForward(usize, 1, 2) == 2);
...	...	@@ -4364,7 +4366,7 @@ pub fn isAlignedGeneric(comptime T: type, addr: T, alignment: T) bool {
4364	4366	return alignBackward(T, addr, alignment) == addr;
4365	4367	}
4366	4368
4367		test "isAligned" {
	4369	test isAligned {
4368	4370	try testing.expect(isAligned(0, 4));
4369	4371	try testing.expect(isAligned(1, 1));
4370	4372	try testing.expect(isAligned(2, 1));

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

...	...	@@ -132,7 +132,7 @@ pub fn TrailerFlags(comptime Fields: type) type {
132	132	};
133	133	}
134	134
135		test "TrailerFlags" {
	135	test TrailerFlags {
136	136	const Flags = TrailerFlags(struct {
137	137	a: i32,
138	138	b: bool,

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

...	...	@@ -1077,7 +1077,7 @@ pub fn QueryObjectName(
1077	1077	else => \|e\| return unexpectedStatus(e),
1078	1078	}
1079	1079	}
1080		test "QueryObjectName" {
	1080	test QueryObjectName {
1081	1081	if (builtin.os.tag != .windows)
1082	1082	return;
1083	1083
...	...	@@ -1245,7 +1245,7 @@ pub fn GetFinalPathNameByHandle(
1245	1245	}
1246	1246	}
1247	1247
1248		test "GetFinalPathNameByHandle" {
	1248	test GetFinalPathNameByHandle {
1249	1249	if (builtin.os.tag != .windows)
1250	1250	return;
1251	1251
...	...	@@ -2467,7 +2467,7 @@ pub fn ntToWin32Namespace(path: []const u16) !PathSpace {
2467	2467	}
2468	2468	}
2469	2469
2470		test "ntToWin32Namespace" {
	2470	test ntToWin32Namespace {
2471	2471	const L = std.unicode.utf8ToUtf16LeStringLiteral;
2472	2472
2473	2473	try testNtToWin32Namespace(L("UNC"), L("\\??\\UNC"));
...	...	@@ -3386,7 +3386,7 @@ pub const GUID = extern struct {
3386	3386	}
3387	3387	};
3388	3388
3389		test "GUID" {
	3389	test GUID {
3390	3390	try std.testing.expectEqual(
3391	3391	GUID{
3392	3392	.Data1 = 0x01234567,

lib/std/process.zig+3-3

...	...	@@ -209,7 +209,7 @@ pub const EnvMap = struct {
209	209	}
210	210	};
211	211
212		test "EnvMap" {
	212	test EnvMap {
213	213	var env = EnvMap.init(testing.allocator);
214	214	defer env.deinit();
215	215
...	...	@@ -371,7 +371,7 @@ pub fn getEnvMap(allocator: Allocator) GetEnvMapError!EnvMap {
371	371	}
372	372	}
373	373
374		test "getEnvMap" {
	374	test getEnvMap {
375	375	var env = try getEnvMap(testing.allocator);
376	376	defer env.deinit();
377	377	}
...	...	@@ -1132,7 +1132,7 @@ pub fn argsFree(allocator: Allocator, args_alloc: []const [:0]u8) void {
1132	1132	return allocator.free(aligned_allocated_buf);
1133	1133	}
1134	1134
1135		test "ArgIteratorWindows" {
	1135	test ArgIteratorWindows {
1136	1136	const t = testArgIteratorWindows;
1137	1137
1138	1138	try t(

lib/std/sort.zig+9-9

...	...	@@ -430,7 +430,7 @@ pub fn binarySearch(
430	430	return null;
431	431	}
432	432
433		test "binarySearch" {
	433	test binarySearch {
434	434	const S = struct {
435	435	fn order_u32(context: void, lhs: u32, rhs: u32) math.Order {
436	436	_ = context;
...	...	@@ -537,7 +537,7 @@ pub fn lowerBound(
537	537	return left;
538	538	}
539	539
540		test "lowerBound" {
	540	test lowerBound {
541	541	const S = struct {
542	542	fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
543	543	_ = context;
...	...	@@ -627,7 +627,7 @@ pub fn upperBound(
627	627	return left;
628	628	}
629	629
630		test "upperBound" {
	630	test upperBound {
631	631	const S = struct {
632	632	fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
633	633	_ = context;
...	...	@@ -712,7 +712,7 @@ pub fn equalRange(
712	712	};
713	713	}
714	714
715		test "equalRange" {
	715	test equalRange {
716	716	const S = struct {
717	717	fn lower_u32(context: void, lhs: u32, rhs: u32) bool {
718	718	_ = context;
...	...	@@ -792,7 +792,7 @@ pub fn argMin(
792	792	return smallest_index;
793	793	}
794	794
795		test "argMin" {
	795	test argMin {
796	796	try testing.expectEqual(@as(?usize, null), argMin(i32, &[_]i32{}, {}, asc_i32));
797	797	try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{1}, {}, asc_i32));
798	798	try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));
...	...	@@ -812,7 +812,7 @@ pub fn min(
812	812	return items[i];
813	813	}
814	814
815		test "min" {
	815	test min {
816	816	try testing.expectEqual(@as(?i32, null), min(i32, &[_]i32{}, {}, asc_i32));
817	817	try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{1}, {}, asc_i32));
818	818	try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));
...	...	@@ -844,7 +844,7 @@ pub fn argMax(
844	844	return biggest_index;
845	845	}
846	846
847		test "argMax" {
	847	test argMax {
848	848	try testing.expectEqual(@as(?usize, null), argMax(i32, &[_]i32{}, {}, asc_i32));
849	849	try testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{1}, {}, asc_i32));
850	850	try testing.expectEqual(@as(?usize, 4), argMax(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));
...	...	@@ -864,7 +864,7 @@ pub fn max(
864	864	return items[i];
865	865	}
866	866
867		test "max" {
	867	test max {
868	868	try testing.expectEqual(@as(?i32, null), max(i32, &[_]i32{}, {}, asc_i32));
869	869	try testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{1}, {}, asc_i32));
870	870	try testing.expectEqual(@as(?i32, 5), max(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));
...	...	@@ -890,7 +890,7 @@ pub fn isSorted(
890	890	return true;
891	891	}
892	892
893		test "isSorted" {
	893	test isSorted {
894	894	try testing.expect(isSorted(i32, &[_]i32{}, {}, asc_i32));
895	895	try testing.expect(isSorted(i32, &[_]i32{10}, {}, asc_i32));
896	896	try testing.expect(isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

lib/std/tar.zig+2-2

...	...	@@ -676,7 +676,7 @@ fn stripComponents(path: []const u8, count: u32) []const u8 {
676	676	return path[i..];
677	677	}
678	678
679		test "stripComponents" {
	679	test stripComponents {
680	680	const expectEqualStrings = testing.expectEqualStrings;
681	681	try expectEqualStrings("a/b/c", stripComponents("a/b/c", 0));
682	682	try expectEqualStrings("b/c", stripComponents("a/b/c", 1));
...	...	@@ -685,7 +685,7 @@ test "stripComponents" {
685	685	try expectEqualStrings("", stripComponents("a/b/c", 4));
686	686	}
687	687
688		test "PaxIterator" {
	688	test PaxIterator {
689	689	const Attr = struct {
690	690	kind: PaxAttributeKind,
691	691	value: []const u8 = undefined,

lib/std/testing.zig+2-2

...	...	@@ -242,7 +242,7 @@ fn expectApproxEqAbsInner(comptime T: type, expected: T, actual: T, tolerance: T
242	242	}
243	243	}
244	244
245		test "expectApproxEqAbs" {
	245	test expectApproxEqAbs {
246	246	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
247	247	const pos_x: T = 12.0;
248	248	const pos_y: T = 12.06;
...	...	@@ -278,7 +278,7 @@ fn expectApproxEqRelInner(comptime T: type, expected: T, actual: T, tolerance: T
278	278	}
279	279	}
280	280
281		test "expectApproxEqRel" {
	281	test expectApproxEqRel {
282	282	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
283	283	const eps_value = comptime math.floatEps(T);
284	284	const sqrt_eps_value = comptime @sqrt(eps_value);

lib/std/time.zig+3-3

...	...	@@ -52,7 +52,7 @@ pub fn sleep(nanoseconds: u64) void {
52	52	std.os.nanosleep(s, ns);
53	53	}
54	54
55		test "sleep" {
	55	test sleep {
56	56	sleep(1);
57	57	}
58	58
...	...	@@ -122,7 +122,7 @@ pub fn nanoTimestamp() i128 {
122	122	}
123	123	}
124	124
125		test "timestamp" {
	125	test milliTimestamp {
126	126	const margin = ns_per_ms * 50;
127	127
128	128	const time_0 = milliTimestamp();
...	...	@@ -326,7 +326,7 @@ pub const Timer = struct {
326	326	}
327	327	};
328	328
329		test "Timer + Instant" {
	329	test Timer {
330	330	const margin = ns_per_ms * 150;
331	331
332	332	var timer = try Timer.start();

lib/std/time/epoch.zig+1-1

...	...	@@ -53,7 +53,7 @@ pub fn isLeapYear(year: Year) bool {
53	53	return (0 == @mod(year, 400));
54	54	}
55	55
56		test "isLeapYear" {
	56	test isLeapYear {
57	57	try testing.expectEqual(false, isLeapYear(2095));
58	58	try testing.expectEqual(true, isLeapYear(2096));
59	59	try testing.expectEqual(false, isLeapYear(2100));

lib/std/unicode.zig+4-4

...	...	@@ -907,7 +907,7 @@ pub fn fmtUtf8(utf8: []const u8) std.fmt.Formatter(formatUtf8) {
907	907	return .{ .data = utf8 };
908	908	}
909	909
910		test "fmtUtf8" {
	910	test fmtUtf8 {
911	911	const expectFmt = testing.expectFmt;
912	912	try expectFmt("", "{}", .{fmtUtf8("")});
913	913	try expectFmt("foo", "{}", .{fmtUtf8("foo")});
...	...	@@ -1249,7 +1249,7 @@ pub fn utf8ToUtf16LeImpl(utf16le: []u16, utf8: []const u8, comptime surrogates:
1249	1249	return dest_index;
1250	1250	}
1251	1251
1252		test "utf8ToUtf16Le" {
	1252	test utf8ToUtf16Le {
1253	1253	var utf16le: [128]u16 = undefined;
1254	1254	{
1255	1255	const length = try utf8ToUtf16Le(utf16le[0..], "𐐷");
...	...	@@ -1430,7 +1430,7 @@ pub fn fmtUtf16Le(utf16le: []const u16) std.fmt.Formatter(formatUtf16Le) {
1430	1430	return .{ .data = utf16le };
1431	1431	}
1432	1432
1433		test "fmtUtf16Le" {
	1433	test fmtUtf16Le {
1434	1434	const expectFmt = testing.expectFmt;
1435	1435	try expectFmt("", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral(""))});
1436	1436	try expectFmt("foo", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral("foo"))});
...	...	@@ -1443,7 +1443,7 @@ test "fmtUtf16Le" {
1443	1443	try expectFmt("", "{}", .{fmtUtf16Le(&[_]u16{mem.readInt(u16, "\x00\xe0", native_endian)})});
1444	1444	}
1445	1445
1446		test "utf8ToUtf16LeStringLiteral" {
	1446	test utf8ToUtf16LeStringLiteral {
1447	1447	{
1448	1448	const bytes = [_:0]u16{
1449	1449	mem.nativeToLittle(u16, 0x41),

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

...	...	@@ -137,7 +137,7 @@ pub fn countLeaks() CountResult {
137	137	return res;
138	138	}
139	139
140		test "countLeaks" {
	140	test countLeaks {
141	141	try testing.expectEqual(
142	142	@as(CountResult, .{
143	143	.leaked = 0,
...	...	@@ -167,7 +167,7 @@ pub fn countLeakBlocks() CountResult {
167	167	return res;
168	168	}
169	169
170		test "countLeakBlocks" {
	170	test countLeakBlocks {
171	171	try testing.expectEqual(
172	172	@as(CountResult, .{
173	173	.leaked = 0,

lib/std/zig/ErrorBundle.zig+77-77

...	...	@@ -642,96 +642,96 @@ pub const Wip = struct {
642	642	i += 1;
643	643	}
644	644	}
645		};
646	645
647		test "addBundleAsRoots" {
648		var bundle = bundle: {
649		var wip: ErrorBundle.Wip = undefined;
650		try wip.init(std.testing.allocator);
651		errdefer wip.deinit();
652
653		var ref_traces: [3]ReferenceTrace = undefined;
654		for (&ref_traces, 0..) \|*ref_trace, i\| {
655		if (i == ref_traces.len - 1) {
656		// sentinel reference trace
657		ref_trace.* = .{
658		.decl_name = 3, // signifies 3 hidden references
659		.src_loc = .none,
660		};
661		} else {
662		ref_trace.* = .{
663		.decl_name = try wip.addString("foo"),
664		.src_loc = try wip.addSourceLocation(.{
665		.src_path = try wip.addString("foo"),
666		.line = 1,
667		.column = 2,
668		.span_start = 3,
669		.span_main = 4,
670		.span_end = 5,
671		.source_line = 0,
672		}),
673		};
	646	test addBundleAsRoots {
	647	var bundle = bundle: {
	648	var wip: ErrorBundle.Wip = undefined;
	649	try wip.init(std.testing.allocator);
	650	errdefer wip.deinit();
	651
	652	var ref_traces: [3]ReferenceTrace = undefined;
	653	for (&ref_traces, 0..) \|*ref_trace, i\| {
	654	if (i == ref_traces.len - 1) {
	655	// sentinel reference trace
	656	ref_trace.* = .{
	657	.decl_name = 3, // signifies 3 hidden references
	658	.src_loc = .none,
	659	};
	660	} else {
	661	ref_trace.* = .{
	662	.decl_name = try wip.addString("foo"),
	663	.src_loc = try wip.addSourceLocation(.{
	664	.src_path = try wip.addString("foo"),
	665	.line = 1,
	666	.column = 2,
	667	.span_start = 3,
	668	.span_main = 4,
	669	.span_end = 5,
	670	.source_line = 0,
	671	}),
	672	};
	673	}
674	674	}
675		}
676	675
677		const src_loc = try wip.addSourceLocation(.{
678		.src_path = try wip.addString("foo"),
679		.line = 1,
680		.column = 2,
681		.span_start = 3,
682		.span_main = 4,
683		.span_end = 5,
684		.source_line = try wip.addString("some source code"),
685		.reference_trace_len = ref_traces.len,
686		});
687		for (&ref_traces) \|ref_trace\| {
688		try wip.addReferenceTrace(ref_trace);
689		}
690
691		try wip.addRootErrorMessage(ErrorMessage{
692		.msg = try wip.addString("hello world"),
693		.src_loc = src_loc,
694		.notes_len = 1,
695		});
696		const i = try wip.reserveNotes(1);
697		const note_index = @intFromEnum(wip.addErrorMessageAssumeCapacity(.{
698		.msg = try wip.addString("this is a note"),
699		.src_loc = try wip.addSourceLocation(.{
700		.src_path = try wip.addString("bar"),
	676	const src_loc = try wip.addSourceLocation(.{
	677	.src_path = try wip.addString("foo"),
701	678	.line = 1,
702	679	.column = 2,
703	680	.span_start = 3,
704	681	.span_main = 4,
705	682	.span_end = 5,
706		.source_line = try wip.addString("another line of source"),
707		}),
708		}));
709		wip.extra.items[i] = note_index;
	683	.source_line = try wip.addString("some source code"),
	684	.reference_trace_len = ref_traces.len,
	685	});
	686	for (&ref_traces) \|ref_trace\| {
	687	try wip.addReferenceTrace(ref_trace);
	688	}
710	689
711		break :bundle try wip.toOwnedBundle("");
712		};
713		defer bundle.deinit(std.testing.allocator);
	690	try wip.addRootErrorMessage(ErrorMessage{
	691	.msg = try wip.addString("hello world"),
	692	.src_loc = src_loc,
	693	.notes_len = 1,
	694	});
	695	const i = try wip.reserveNotes(1);
	696	const note_index = @intFromEnum(wip.addErrorMessageAssumeCapacity(.{
	697	.msg = try wip.addString("this is a note"),
	698	.src_loc = try wip.addSourceLocation(.{
	699	.src_path = try wip.addString("bar"),
	700	.line = 1,
	701	.column = 2,
	702	.span_start = 3,
	703	.span_main = 4,
	704	.span_end = 5,
	705	.source_line = try wip.addString("another line of source"),
	706	}),
	707	}));
	708	wip.extra.items[i] = note_index;
	709
	710	break :bundle try wip.toOwnedBundle("");
	711	};
	712	defer bundle.deinit(std.testing.allocator);
714	713
715		const ttyconf: std.io.tty.Config = .no_color;
	714	const ttyconf: std.io.tty.Config = .no_color;
716	715
717		var bundle_buf = std.ArrayList(u8).init(std.testing.allocator);
718		defer bundle_buf.deinit();
719		try bundle.renderToWriter(.{ .ttyconf = ttyconf }, bundle_buf.writer());
	716	var bundle_buf = std.ArrayList(u8).init(std.testing.allocator);
	717	defer bundle_buf.deinit();
	718	try bundle.renderToWriter(.{ .ttyconf = ttyconf }, bundle_buf.writer());
720	719
721		var copy = copy: {
722		var wip: ErrorBundle.Wip = undefined;
723		try wip.init(std.testing.allocator);
724		errdefer wip.deinit();
	720	var copy = copy: {
	721	var wip: ErrorBundle.Wip = undefined;
	722	try wip.init(std.testing.allocator);
	723	errdefer wip.deinit();
725	724
726		try wip.addBundleAsRoots(bundle);
	725	try wip.addBundleAsRoots(bundle);
727	726
728		break :copy try wip.toOwnedBundle("");
729		};
730		defer copy.deinit(std.testing.allocator);
	727	break :copy try wip.toOwnedBundle("");
	728	};
	729	defer copy.deinit(std.testing.allocator);
731	730
732		var copy_buf = std.ArrayList(u8).init(std.testing.allocator);
733		defer copy_buf.deinit();
734		try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_buf.writer());
	731	var copy_buf = std.ArrayList(u8).init(std.testing.allocator);
	732	defer copy_buf.deinit();
	733	try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_buf.writer());
735	734
736		try std.testing.expectEqualStrings(bundle_buf.items, copy_buf.items);
737		}
	735	try std.testing.expectEqualStrings(bundle_buf.items, copy_buf.items);
	736	}
	737	};

lib/std/zig/primitives.zig+1-1

...	...	@@ -51,7 +51,7 @@ pub fn isPrimitive(name: []const u8) bool {
51	51	return true;
52	52	}
53	53
54		test "isPrimitive" {
	54	test isPrimitive {
55	55	const expect = std.testing.expect;
56	56	try expect(!isPrimitive(""));
57	57	try expect(!isPrimitive("_"));

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

...	...	@@ -148,7 +148,7 @@ pub fn parseEscapeSequence(slice: []const u8, offset: *usize) ParsedCharLiteral
148	148	}
149	149	}
150	150
151		test "parseCharLiteral" {
	151	test parseCharLiteral {
152	152	try std.testing.expectEqual(
153	153	ParsedCharLiteral{ .success = 'a' },
154	154	parseCharLiteral("'a'"),
...	...	@@ -281,7 +281,7 @@ pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]
281	281	}
282	282	}
283	283
284		test "parse" {
	284	test parseAlloc {
285	285	const expect = std.testing.expect;
286	286	const expectError = std.testing.expectError;
287	287	const eql = std.mem.eql;