Commit b077f3ab7d55374d2770336db236ecd7b18238a8 | zig

author	Benjamin Feng <benjamin.feng@glassdoor.com> 2020-01-29 21:22:01-06:00
committer	Benjamin Feng <benjamin.feng@glassdoor.com> 2020-01-29 22:22:00-06:00
log	b077f3ab7d55374d2770336db236ecd7b18238a8
tree	d1a9453a3faf5e019afd75f3d7b59a0162ae1142
parent	70ad84c8209ae7ab14472f77f9452820bc47c30e

Promoted "leak_count_allocator" to the main testing.allocator

23 files changed, 95 insertions(+), 94 deletions(-)

doc
- docgen.zig
lib
- std
  - array_list.zig
  - buffer.zig
  - debug.zig
  - fifo.zig
  - fmt.zig
  - fs
    path.zig
  - linked_list.zig
  - os
    test.zig
  - priority_queue.zig
  - process.zig
  - special
    test_runner.zig
  - testing.zig
  - testing
    leak_count_allocator.zig
  - unicode.zig
  - zig
    ast.zig
test
- compare_output.zig
- compile_errors.zig
- stage1
  - behavior
    const_slice_child.zig
- standalone
  - brace_expansion
    main.zig
  - cat
    main.zig
  - empty_env
    main.zig
  - load_dynamic_library
    main.zig

doc/docgen.zig+2-2

...	...	@@ -672,8 +672,8 @@ const TermState = enum {
672	672
673	673	test "term color" {
674	674	const input_bytes = "A\x1b[32;1mgreen\x1b[0mB";
675		const result = try termColor(std.testing.leak_count_allocator, input_bytes);
676		defer std.testing.leak_count_allocator.free(result);
	675	const result = try termColor(std.testing.allocator, input_bytes);
	676	defer std.testing.allocator.free(result);
677	677	testing.expectEqualSlices(u8, "A<span class=\"t32\">green</span>B", result);
678	678	}
679	679

lib/std/array_list.zig+7-7

...	...	@@ -320,7 +320,7 @@ test "std.ArrayList.basic" {
320	320	}
321	321
322	322	test "std.ArrayList.orderedRemove" {
323		var list = ArrayList(i32).init(testing.leak_count_allocator);
	323	var list = ArrayList(i32).init(testing.allocator);
324	324	defer list.deinit();
325	325
326	326	try list.append(1);
...	...	@@ -347,7 +347,7 @@ test "std.ArrayList.orderedRemove" {
347	347	}
348	348
349	349	test "std.ArrayList.swapRemove" {
350		var list = ArrayList(i32).init(testing.leak_count_allocator);
	350	var list = ArrayList(i32).init(testing.allocator);
351	351	defer list.deinit();
352	352
353	353	try list.append(1);
...	...	@@ -374,7 +374,7 @@ test "std.ArrayList.swapRemove" {
374	374	}
375	375
376	376	test "std.ArrayList.swapRemoveOrError" {
377		var list = ArrayList(i32).init(testing.leak_count_allocator);
	377	var list = ArrayList(i32).init(testing.allocator);
378	378	defer list.deinit();
379	379
380	380	// Test just after initialization
...	...	@@ -402,7 +402,7 @@ test "std.ArrayList.swapRemoveOrError" {
402	402	}
403	403
404	404	test "std.ArrayList.insert" {
405		var list = ArrayList(i32).init(testing.leak_count_allocator);
	405	var list = ArrayList(i32).init(testing.allocator);
406	406	defer list.deinit();
407	407
408	408	try list.append(1);
...	...	@@ -416,7 +416,7 @@ test "std.ArrayList.insert" {
416	416	}
417	417
418	418	test "std.ArrayList.insertSlice" {
419		var list = ArrayList(i32).init(testing.leak_count_allocator);
	419	var list = ArrayList(i32).init(testing.allocator);
420	420	defer list.deinit();
421	421
422	422	try list.append(1);
...	...	@@ -443,8 +443,8 @@ const Item = struct {
443	443	};
444	444
445	445	test "std.ArrayList: ArrayList(T) of struct T" {
446		var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(testing.leak_count_allocator) };
	446	var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(testing.allocator) };
447	447	defer root.sub_items.deinit();
448		try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(testing.leak_count_allocator) });
	448	try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(testing.allocator) });
449	449	testing.expect(root.sub_items.items[0].integer == 42);
450	450	}

lib/std/buffer.zig+3-3

...	...	@@ -150,7 +150,7 @@ pub const Buffer = struct {
150	150	};
151	151
152	152	test "simple Buffer" {
153		var buf = try Buffer.init(testing.leak_count_allocator, "");
	153	var buf = try Buffer.init(testing.allocator, "");
154	154	defer buf.deinit();
155	155
156	156	testing.expect(buf.len() == 0);
...	...	@@ -172,7 +172,7 @@ test "simple Buffer" {
172	172	}
173	173
174	174	test "Buffer.initSize" {
175		var buf = try Buffer.initSize(testing.leak_count_allocator, 3);
	175	var buf = try Buffer.initSize(testing.allocator, 3);
176	176	defer buf.deinit();
177	177	testing.expect(buf.len() == 3);
178	178	try buf.append("hello");
...	...	@@ -180,7 +180,7 @@ test "Buffer.initSize" {
180	180	}
181	181
182	182	test "Buffer.initCapacity" {
183		var buf = try Buffer.initCapacity(testing.leak_count_allocator, 10);
	183	var buf = try Buffer.initCapacity(testing.allocator, 10);
184	184	defer buf.deinit();
185	185	testing.expect(buf.len() == 0);
186	186	testing.expect(buf.capacity() >= 10);

lib/std/debug.zig+1-1

...	...	@@ -19,7 +19,7 @@ const windows = std.os.windows;
19	19
20	20	pub const leb = @import("debug/leb128.zig");
21	21
22		pub const global_allocator = @compileError("Please switch to std.testing.leak_count_allocator.");
	22	pub const global_allocator = @compileError("Please switch to std.testing.allocator.");
23	23	pub const failing_allocator = @compileError("Please switch to std.testing.failing_allocator.");
24	24
25	25	pub const runtime_safety = switch (builtin.mode) {

lib/std/fifo.zig+2-2

...	...	@@ -347,7 +347,7 @@ pub fn LinearFifo(
347	347	}
348	348
349	349	test "LinearFifo(u8, .Dynamic)" {
350		var fifo = LinearFifo(u8, .Dynamic).init(testing.leak_count_allocator);
	350	var fifo = LinearFifo(u8, .Dynamic).init(testing.allocator);
351	351	defer fifo.deinit();
352	352
353	353	try fifo.write("HELLO");
...	...	@@ -422,7 +422,7 @@ test "LinearFifo" {
422	422	var fifo = switch (bt) {
423	423	.Static => FifoType.init(),
424	424	.Slice => FifoType.init(buf[0..]),
425		.Dynamic => FifoType.init(testing.leak_count_allocator),
	425	.Dynamic => FifoType.init(testing.allocator),
426	426	};
427	427	defer fifo.deinit();
428	428

lib/std/fmt.zig+5-5

...	...	@@ -1598,7 +1598,7 @@ test "hexToBytes" {
1598	1598	test "formatIntValue with comptime_int" {
1599	1599	const value: comptime_int = 123456789123456789;
1600	1600
1601		var buf = try std.Buffer.init(std.testing.leak_count_allocator, "");
	1601	var buf = try std.Buffer.init(std.testing.allocator, "");
1602	1602	defer buf.deinit();
1603	1603	try formatIntValue(value, "", FormatOptions{}, &buf, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append);
1604	1604	std.testing.expect(mem.eql(u8, buf.toSlice(), "123456789123456789"));
...	...	@@ -1653,22 +1653,22 @@ test "formatType max_depth" {
1653	1653	inst.a = &inst;
1654	1654	inst.tu.ptr = &inst.tu;
1655	1655
1656		var buf0 = try std.Buffer.init(std.testing.leak_count_allocator, "");
	1656	var buf0 = try std.Buffer.init(std.testing.allocator, "");
1657	1657	defer buf0.deinit();
1658	1658	try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 0);
1659	1659	std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
1660	1660
1661		var buf1 = try std.Buffer.init(std.testing.leak_count_allocator, "");
	1661	var buf1 = try std.Buffer.init(std.testing.allocator, "");
1662	1662	defer buf1.deinit();
1663	1663	try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 1);
1664	1664	std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
1665	1665
1666		var buf2 = try std.Buffer.init(std.testing.leak_count_allocator, "");
	1666	var buf2 = try std.Buffer.init(std.testing.allocator, "");
1667	1667	defer buf2.deinit();
1668	1668	try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 2);
1669	1669	std.testing.expect(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
1670	1670
1671		var buf3 = try std.Buffer.init(std.testing.leak_count_allocator, "");
	1671	var buf3 = try std.Buffer.init(std.testing.allocator, "");
1672	1672	defer buf3.deinit();
1673	1673	try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 3);
1674	1674	std.testing.expect(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));

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

...	...	@@ -665,8 +665,8 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
665	665	}
666	666
667	667	test "resolve" {
668		const cwd = try process.getCwdAlloc(testing.leak_count_allocator);
669		defer testing.leak_count_allocator.free(cwd);
	668	const cwd = try process.getCwdAlloc(testing.allocator);
	669	defer testing.allocator.free(cwd);
670	670	if (builtin.os == .windows) {
671	671	if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
672	672	cwd[0] = asciiUpper(cwd[0]);
...	...	@@ -684,26 +684,26 @@ test "resolveWindows" {
684	684	return error.SkipZigTest;
685	685	}
686	686	if (builtin.os == .windows) {
687		const cwd = try process.getCwdAlloc(testing.leak_count_allocator);
688		defer testing.leak_count_allocator.free(cwd);
	687	const cwd = try process.getCwdAlloc(testing.allocator);
	688	defer testing.allocator.free(cwd);
689	689	const parsed_cwd = windowsParsePath(cwd);
690	690	{
691		const expected = try join(testing.leak_count_allocator, &[_][]const u8{
	691	const expected = try join(testing.allocator, &[_][]const u8{
692	692	parsed_cwd.disk_designator,
693	693	"usr\\local\\lib\\zig\\std\\array_list.zig",
694	694	});
695		defer testing.leak_count_allocator.free(expected);
	695	defer testing.allocator.free(expected);
696	696	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
697	697	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
698	698	}
699	699	try testResolveWindows(&[_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" }, expected);
700	700	}
701	701	{
702		const expected = try join(testing.leak_count_allocator, &[_][]const u8{
	702	const expected = try join(testing.allocator, &[_][]const u8{
703	703	cwd,
704	704	"usr\\local\\lib\\zig",
705	705	});
706		defer testing.leak_count_allocator.free(expected);
	706	defer testing.allocator.free(expected);
707	707	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
708	708	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
709	709	}
...	...	@@ -740,14 +740,14 @@ test "resolvePosix" {
740	740	}
741	741
742	742	fn testResolveWindows(paths: []const []const u8, expected: []const u8) !void {
743		const actual = try resolveWindows(testing.leak_count_allocator, paths);
744		defer testing.leak_count_allocator.free(actual);
	743	const actual = try resolveWindows(testing.allocator, paths);
	744	defer testing.allocator.free(actual);
745	745	return testing.expect(mem.eql(u8, actual, expected));
746	746	}
747	747
748	748	fn testResolvePosix(paths: []const []const u8, expected: []const u8) !void {
749		const actual = try resolvePosix(testing.leak_count_allocator, paths);
750		defer testing.leak_count_allocator.free(actual);
	749	const actual = try resolvePosix(testing.allocator, paths);
	750	defer testing.allocator.free(actual);
751	751	return testing.expect(mem.eql(u8, actual, expected));
752	752	}
753	753
...	...	@@ -1172,13 +1172,13 @@ test "relative" {
1172	1172	}
1173	1173
1174	1174	fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) !void {
1175		const result = try relativePosix(testing.leak_count_allocator, from, to);
1176		defer testing.leak_count_allocator.free(result);
	1175	const result = try relativePosix(testing.allocator, from, to);
	1176	defer testing.allocator.free(result);
1177	1177	testing.expectEqualSlices(u8, expected_output, result);
1178	1178	}
1179	1179
1180	1180	fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) !void {
1181		const result = try relativeWindows(testing.leak_count_allocator, from, to);
1182		defer testing.leak_count_allocator.free(result);
	1181	const result = try relativeWindows(testing.allocator, from, to);
	1182	defer testing.allocator.free(result);
1183	1183	testing.expectEqualSlices(u8, expected_output, result);
1184	1184	}

lib/std/linked_list.zig+3-3

...	...	@@ -143,7 +143,7 @@ pub fn SinglyLinkedList(comptime T: type) type {
143	143	}
144	144
145	145	test "basic SinglyLinkedList test" {
146		const allocator = testing.leak_count_allocator;
	146	const allocator = testing.allocator;
147	147	var list = SinglyLinkedList(u32).init();
148	148
149	149	var one = try list.createNode(1, allocator);
...	...	@@ -404,7 +404,7 @@ pub fn TailQueue(comptime T: type) type {
404	404	}
405	405
406	406	test "basic TailQueue test" {
407		const allocator = testing.leak_count_allocator;
	407	const allocator = testing.allocator;
408	408	var list = TailQueue(u32).init();
409	409
410	410	var one = try list.createNode(1, allocator);
...	...	@@ -456,7 +456,7 @@ test "basic TailQueue test" {
456	456	}
457	457
458	458	test "TailQueue concatenation" {
459		const allocator = testing.leak_count_allocator;
	459	const allocator = testing.allocator;
460	460	var list1 = TailQueue(u32).init();
461	461	var list2 = TailQueue(u32).init();
462	462

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

...	...	@@ -9,7 +9,7 @@ const elf = std.elf;
9	9	const File = std.fs.File;
10	10	const Thread = std.Thread;
11	11
12		const a = std.testing.leak_count_allocator;
	12	const a = std.testing.allocator;
13	13
14	14	const builtin = @import("builtin");
15	15	const AtomicRmwOp = builtin.AtomicRmwOp;

lib/std/priority_queue.zig+14-14

...	...	@@ -239,7 +239,7 @@ fn greaterThan(a: u32, b: u32) bool {
239	239	const PQ = PriorityQueue(u32);
240	240
241	241	test "std.PriorityQueue: add and remove min heap" {
242		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	242	var queue = PQ.init(testing.allocator, lessThan);
243	243	defer queue.deinit();
244	244
245	245	try queue.add(54);
...	...	@@ -257,7 +257,7 @@ test "std.PriorityQueue: add and remove min heap" {
257	257	}
258	258
259	259	test "std.PriorityQueue: add and remove same min heap" {
260		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	260	var queue = PQ.init(testing.allocator, lessThan);
261	261	defer queue.deinit();
262	262
263	263	try queue.add(1);
...	...	@@ -275,14 +275,14 @@ test "std.PriorityQueue: add and remove same min heap" {
275	275	}
276	276
277	277	test "std.PriorityQueue: removeOrNull on empty" {
278		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	278	var queue = PQ.init(testing.allocator, lessThan);
279	279	defer queue.deinit();
280	280
281	281	expect(queue.removeOrNull() == null);
282	282	}
283	283
284	284	test "std.PriorityQueue: edge case 3 elements" {
285		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	285	var queue = PQ.init(testing.allocator, lessThan);
286	286	defer queue.deinit();
287	287
288	288	try queue.add(9);
...	...	@@ -294,7 +294,7 @@ test "std.PriorityQueue: edge case 3 elements" {
294	294	}
295	295
296	296	test "std.PriorityQueue: peek" {
297		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	297	var queue = PQ.init(testing.allocator, lessThan);
298	298	defer queue.deinit();
299	299
300	300	expect(queue.peek() == null);
...	...	@@ -306,7 +306,7 @@ test "std.PriorityQueue: peek" {
306	306	}
307	307
308	308	test "std.PriorityQueue: sift up with odd indices" {
309		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	309	var queue = PQ.init(testing.allocator, lessThan);
310	310	defer queue.deinit();
311	311	const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
312	312	for (items) \|e\| {
...	...	@@ -320,7 +320,7 @@ test "std.PriorityQueue: sift up with odd indices" {
320	320	}
321	321
322	322	test "std.PriorityQueue: addSlice" {
323		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	323	var queue = PQ.init(testing.allocator, lessThan);
324	324	defer queue.deinit();
325	325	const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
326	326	try queue.addSlice(items[0..]);
...	...	@@ -333,8 +333,8 @@ test "std.PriorityQueue: addSlice" {
333	333
334	334	test "std.PriorityQueue: fromOwnedSlice" {
335	335	const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
336		const heap_items = try std.mem.dupe(testing.leak_count_allocator, u32, items[0..]);
337		var queue = PQ.fromOwnedSlice(testing.leak_count_allocator, lessThan, heap_items[0..]);
	336	const heap_items = try std.mem.dupe(testing.allocator, u32, items[0..]);
	337	var queue = PQ.fromOwnedSlice(testing.allocator, lessThan, heap_items[0..]);
338	338	defer queue.deinit();
339	339
340	340	const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
...	...	@@ -344,7 +344,7 @@ test "std.PriorityQueue: fromOwnedSlice" {
344	344	}
345	345
346	346	test "std.PriorityQueue: add and remove max heap" {
347		var queue = PQ.init(testing.leak_count_allocator, greaterThan);
	347	var queue = PQ.init(testing.allocator, greaterThan);
348	348	defer queue.deinit();
349	349
350	350	try queue.add(54);
...	...	@@ -362,7 +362,7 @@ test "std.PriorityQueue: add and remove max heap" {
362	362	}
363	363
364	364	test "std.PriorityQueue: add and remove same max heap" {
365		var queue = PQ.init(testing.leak_count_allocator, greaterThan);
	365	var queue = PQ.init(testing.allocator, greaterThan);
366	366	defer queue.deinit();
367	367
368	368	try queue.add(1);
...	...	@@ -380,8 +380,8 @@ test "std.PriorityQueue: add and remove same max heap" {
380	380	}
381	381
382	382	test "std.PriorityQueue: iterator" {
383		var queue = PQ.init(testing.leak_count_allocator, lessThan);
384		var map = std.AutoHashMap(u32, void).init(testing.leak_count_allocator);
	383	var queue = PQ.init(testing.allocator, lessThan);
	384	var map = std.AutoHashMap(u32, void).init(testing.allocator);
385	385	defer {
386	386	queue.deinit();
387	387	map.deinit();
...	...	@@ -402,7 +402,7 @@ test "std.PriorityQueue: iterator" {
402	402	}
403	403
404	404	test "std.PriorityQueue: remove at index" {
405		var queue = PQ.init(testing.leak_count_allocator, lessThan);
	405	var queue = PQ.init(testing.allocator, lessThan);
406	406	defer queue.deinit();
407	407
408	408	try queue.add(3);

lib/std/process.zig+5-5

...	...	@@ -114,7 +114,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
114	114	}
115	115
116	116	test "os.getEnvMap" {
117		var env = try getEnvMap(std.testing.leak_count_allocator);
	117	var env = try getEnvMap(std.testing.allocator);
118	118	defer env.deinit();
119	119	}
120	120
...	...	@@ -165,7 +165,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
165	165	}
166	166
167	167	test "os.getEnvVarOwned" {
168		var ga = std.testing.leak_count_allocator;
	168	var ga = std.testing.allocator;
169	169	testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));
170	170	}
171	171
...	...	@@ -492,11 +492,11 @@ test "windows arg parsing" {
492	492	fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {
493	493	var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
494	494	for (expected_args) \|expected_arg\| {
495		const arg = it.next(std.testing.leak_count_allocator).? catch unreachable;
496		defer std.testing.leak_count_allocator.free(arg);
	495	const arg = it.next(std.testing.allocator).? catch unreachable;
	496	defer std.testing.allocator.free(arg);
497	497	testing.expectEqualSlices(u8, expected_arg, arg);
498	498	}
499		testing.expect(it.next(std.testing.leak_count_allocator) == null);
	499	testing.expect(it.next(std.testing.allocator) == null);
500	500	}
501	501
502	502	pub const UserInfo = struct {

lib/std/special/test_runner.zig+4-3

...	...	@@ -13,10 +13,11 @@ pub fn main() anyerror!void {
13	13	};
14	14
15	15	for (test_fn_list) \|test_fn, i\| {
16		std.testing.allocator_instance.reset();
	16	std.testing.base_allocator_instance.reset();
17	17	defer {
18		std.testing.leak_count_allocator_instance.validate() catch \|err\| {
19		@panic(@errorName(err));
	18	std.testing.allocator_instance.validate() catch \|err\| switch (err) {
	19	error.Leak => std.debug.panic("", .{}),
	20	else => std.debug.panic("error.{}", .{@errorName(err)}),
20	21	};
21	22	}
22	23

lib/std/testing.zig+7-7

...	...	@@ -2,17 +2,17 @@ const builtin = @import("builtin");
2	2	const TypeId = builtin.TypeId;
3	3	const std = @import("std.zig");
4	4
	5	pub const LeakCountAllocator = @import("testing/leak_count_allocator.zig").LeakCountAllocator;
	6	pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
	7
5	8	/// This should only be used in temporary test programs.
6	9	pub const allocator = &allocator_instance.allocator;
7		pub var allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
8		var allocator_mem: [100 * 1024]u8 = undefined;
	10	pub var allocator_instance = LeakCountAllocator.init(&base_allocator_instance.allocator);
9	11
10		pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
11		pub const failing_allocator = &FailingAllocator.init(allocator, 0).allocator;
	12	pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator;
12	13
13		pub const LeakCountAllocator = @import("testing/leak_count_allocator.zig").LeakCountAllocator;
14		pub var leak_count_allocator_instance = LeakCountAllocator.init(allocator);
15		pub const leak_count_allocator = &leak_count_allocator_instance.allocator;
	14	pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
	15	var allocator_mem: [100 * 1024]u8 = undefined;
16	16
17	17	/// This function is intended to be used only in tests. It prints diagnostics to stderr
18	18	/// and then aborts when actual_error_union is not expected_error.

lib/std/testing/leak_count_allocator.zig+1-1

...	...	@@ -39,7 +39,7 @@ pub const LeakCountAllocator = struct {
39	39
40	40	pub fn validate(self: LeakCountAllocator) !void {
41	41	if (self.count > 0) {
42		std.debug.warn("Detected leaked allocations without matching free: {}\n", .{self.count});
	42	std.debug.warn("error - detected leaked allocations without matching free: {}\n", .{self.count});
43	43	return error.Leak;
44	44	}
45	45	}

lib/std/unicode.zig+12-12

...	...	@@ -501,16 +501,16 @@ test "utf16leToUtf8" {
501	501	{
502	502	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 'A');
503	503	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 'a');
504		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
505		defer std.testing.leak_count_allocator.free(utf8);
	504	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	505	defer std.testing.allocator.free(utf8);
506	506	testing.expect(mem.eql(u8, utf8, "Aa"));
507	507	}
508	508
509	509	{
510	510	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0x80);
511	511	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xffff);
512		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
513		defer std.testing.leak_count_allocator.free(utf8);
	512	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	513	defer std.testing.allocator.free(utf8);
514	514	testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf"));
515	515	}
516	516
...	...	@@ -518,8 +518,8 @@ test "utf16leToUtf8" {
518	518	// the values just outside the surrogate half range
519	519	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd7ff);
520	520	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xe000);
521		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
522		defer std.testing.leak_count_allocator.free(utf8);
	521	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	522	defer std.testing.allocator.free(utf8);
523	523	testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80"));
524	524	}
525	525
...	...	@@ -527,8 +527,8 @@ test "utf16leToUtf8" {
527	527	// smallest surrogate pair
528	528	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd800);
529	529	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
530		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
531		defer std.testing.leak_count_allocator.free(utf8);
	530	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	531	defer std.testing.allocator.free(utf8);
532	532	testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80"));
533	533	}
534	534
...	...	@@ -536,16 +536,16 @@ test "utf16leToUtf8" {
536	536	// largest surrogate pair
537	537	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
538	538	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdfff);
539		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
540		defer std.testing.leak_count_allocator.free(utf8);
	539	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	540	defer std.testing.allocator.free(utf8);
541	541	testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf"));
542	542	}
543	543
544	544	{
545	545	mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
546	546	mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
547		const utf8 = try utf16leToUtf8Alloc(std.testing.leak_count_allocator, &utf16le);
548		defer std.testing.leak_count_allocator.free(utf8);
	547	const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
	548	defer std.testing.allocator.free(utf8);
549	549	testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80"));
550	550	}
551	551	}

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

...	...	@@ -2287,7 +2287,7 @@ pub const Node = struct {
2287	2287	test "iterate" {
2288	2288	var root = Node.Root{
2289	2289	.base = Node{ .id = Node.Id.Root },
2290		.decls = Node.Root.DeclList.init(std.testing.leak_count_allocator),
	2290	.decls = Node.Root.DeclList.init(std.testing.allocator),
2291	2291	.eof_token = 0,
2292	2292	};
2293	2293	var base = &root.base;

test/compare_output.zig+2-2

...	...	@@ -445,7 +445,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
445	445	\\const std = @import("std");
446	446	\\const io = std.io;
447	447	\\const os = std.os;
448		\\const allocator = std.testing.leak_count_allocator;
	448	\\const allocator = std.testing.allocator;
449	449	\\
450	450	\\pub fn main() !void {
451	451	\\ var args_it = std.process.args();
...	...	@@ -486,7 +486,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
486	486	\\const std = @import("std");
487	487	\\const io = std.io;
488	488	\\const os = std.os;
489		\\const allocator = std.testing.leak_count_allocator;
	489	\\const allocator = std.testing.allocator;
490	490	\\
491	491	\\pub fn main() !void {
492	492	\\ var args_it = std.process.args();

test/compile_errors.zig+1-1

...	...	@@ -5765,7 +5765,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5765	5765	\\
5766	5766	\\export fn entry() void {
5767	5767	\\ const a = MdNode.Header {
5768		\\ .text = MdText.init(&std.testing.leak_count_allocator),
	5768	\\ .text = MdText.init(&std.testing.allocator),
5769	5769	\\ .weight = HeaderWeight.H1,
5770	5770	\\ };
5771	5771	\\}

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

...	...	@@ -23,8 +23,8 @@ fn foo(args: [][]const u8) void {
23	23	}
24	24
25	25	fn bar(argc: usize) void {
26		const args = testing.leak_count_allocator.alloc([]const u8, argc) catch unreachable;
27		defer testing.leak_count_allocator.free(args);
	26	const args = testing.allocator.alloc([]const u8, argc) catch unreachable;
	27	defer testing.allocator.free(args);
28	28	for (args) \|_, i\| {
29	29	const ptr = argv[i];
30	30	args[i] = ptr[0..strlen(ptr)];

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

...	...	@@ -201,7 +201,7 @@ pub fn main() !void {
201	201	}
202	202
203	203	test "invalid inputs" {
204		global_allocator = std.testing.leak_count_allocator;
	204	global_allocator = std.testing.allocator;
205	205
206	206	expectError("}ABC", error.InvalidInput);
207	207	expectError("{ABC", error.InvalidInput);
...	...	@@ -222,7 +222,7 @@ fn expectError(test_input: []const u8, expected_err: anyerror) void {
222	222	}
223	223
224	224	test "valid inputs" {
225		global_allocator = std.testing.leak_count_allocator;
	225	global_allocator = std.testing.allocator;
226	226
227	227	expectExpansion("{x,y,z}", "x y z");
228	228	expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");

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

...	...	@@ -4,7 +4,7 @@ const process = std.process;
4	4	const fs = std.fs;
5	5	const mem = std.mem;
6	6	const warn = std.debug.warn;
7		const allocator = std.testing.leak_count_allocator;
	7	const allocator = std.testing.allocator;
8	8
9	9	pub fn main() !void {
10	10	var args_it = process.args();

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

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

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3	3	pub fn main() !void {
4		const args = try std.process.argsAlloc(std.testing.leak_count_allocator);
5		defer std.process.argsFree(std.testing.leak_count_allocator, args);
	4	const args = try std.process.argsAlloc(std.testing.allocator);
	5	defer std.process.argsFree(std.testing.allocator, args);
6	6
7	7	const dynlib_name = args[1];
8	8