Commit 65b1a4953fd5b87f30260beb363d0e968dc8e291 | zig

doc/docgen.zig+2-1

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

doc/langref.html.in+4-5

lib/std/array_list.zig+8-7

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

lib/std/buf_map.zig+4-3

 @@ -43,9 +43,10 @@ pub const BufMap = struct {
     pub fn set(self: *BufMap, key: []const u8, value: []const u8) !void {
         const value_copy = try self.copy(value);
         errdefer self.free(value_copy);
-        // Avoid copying key if it already exists
         const get_or_put = try self.hash_map.getOrPut(key);
-        if (!get_or_put.found_existing) {
+        if (get_or_put.found_existing) {
+            self.free(get_or_put.kv.value);
+        } else {
             get_or_put.kv.key = self.copy(key) catch |err| {
                 _ = self.hash_map.remove(key);
                 return err;
 @@ -83,7 +84,7 @@ pub const BufMap = struct {
 };
 test "BufMap" {
-    var bufmap = BufMap.init(std.heap.page_allocator);
+    var bufmap = BufMap.init(std.testing.allocator);
     defer bufmap.deinit();
     try bufmap.set("x", "1");

lib/std/buf_set.zig+1-1

...	@@ -65,7 +65,7 @@ pub const BufSet = struct {	...	@@ -65,7 +65,7 @@ pub const BufSet = struct {
65	};	65	};
66		66
67	test "BufSet" {	67	test "BufSet" {
68	var bufset = BufSet.init(std.heap.page_allocator);	68	var bufset = BufSet.init(std.testing.allocator);
69	defer bufset.deinit();	69	defer bufset.deinit();
70		70
71	try bufset.put("x");	71	try bufset.put("x");

lib/std/buffer.zig+8-3

 @@ -150,7 +150,9 @@ pub const Buffer = struct {
 };
 test "simple Buffer" {
-    var buf = try Buffer.init(debug.global_allocator, "");
+    var buf = try Buffer.init(testing.allocator, "");
+    defer buf.deinit();
     testing.expect(buf.len() == 0);
     try buf.append("hello");
     try buf.append(" ");
 @@ -159,6 +161,7 @@ test "simple Buffer" {
     testing.expect(mem.eql(u8, mem.toSliceConst(u8, buf.toSliceConst().ptr), buf.toSliceConst()));
     var buf2 = try Buffer.initFromBuffer(buf);
+    defer buf2.deinit();
     testing.expect(buf.eql(buf2.toSliceConst()));
     testing.expect(buf.startsWith("hell"));
 @@ -169,14 +172,16 @@ test "simple Buffer" {
 }
 test "Buffer.initSize" {
-    var buf = try Buffer.initSize(debug.global_allocator, 3);
+    var buf = try Buffer.initSize(testing.allocator, 3);
+    defer buf.deinit();
     testing.expect(buf.len() == 3);
     try buf.append("hello");
     testing.expect(mem.eql(u8, buf.toSliceConst()[3..], "hello"));
 }
 test "Buffer.initCapacity" {
-    var buf = try Buffer.initCapacity(debug.global_allocator, 10);
+    var buf = try Buffer.initCapacity(testing.allocator, 10);
+    defer buf.deinit();
     testing.expect(buf.len() == 0);
     testing.expect(buf.capacity() >= 10);
     const old_cap = buf.capacity();

lib/std/build.zig+3

 @@ -1059,7 +1059,10 @@ pub const Builder = struct {
 };
 test "builder.findProgram compiles" {
+    // TODO: uncomment and fix the leak
+    // const builder = try Builder.create(std.testing.allocator, "zig", "zig-cache", "zig-cache");
     const builder = try Builder.create(std.heap.page_allocator, "zig", "zig-cache", "zig-cache");
+    defer builder.destroy();
     _ = builder.findProgram(&[_][]const u8{}, &[_][]const u8{}) catch null;
 }

lib/std/debug.zig+2-7

 @@ -19,8 +19,8 @@ const windows = std.os.windows;
 pub const leb = @import("debug/leb128.zig");
-pub const FailingAllocator = @import("debug/failing_allocator.zig").FailingAllocator;
+pub const global_allocator = @compileError("Please switch to std.testing.allocator.");
-pub const failing_allocator = &FailingAllocator.init(global_allocator, 0).allocator;
+pub const failing_allocator = @compileError("Please switch to std.testing.failing_allocator.");
 pub const runtime_safety = switch (builtin.mode) {
     .Debug, .ReleaseSafe => true,
 @@ -2196,11 +2196,6 @@ fn readInitialLength(comptime E: type, in_stream: *io.InStream(E), is_64: *bool)
     }
 }
-/// This should only be used in temporary test programs.
-pub const global_allocator = &global_fixed_allocator.allocator;
-var global_fixed_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(global_allocator_mem[0..]);
-var global_allocator_mem: [100 * 1024]u8 = undefined;
 /// TODO multithreaded awareness
 var debug_info_allocator: ?*mem.Allocator = null;
 var debug_info_arena_allocator: std.heap.ArenaAllocator = undefined;

lib/std/debug/failing_allocator.zig deleted-81

...	@@ -1,81 +0,0 @@
1	const std = @import("../std.zig");
2	const mem = std.mem;
3
4	/// Allocator that fails after N allocations, useful for making sure out of
5	/// memory conditions are handled correctly.
6	///
7	/// To use this, first initialize it and get an allocator with
8	///
9	/// `const failing_allocator = &FailingAllocator.init(<allocator>,
10	/// <fail_index>).allocator;`
11	///
12	/// Then use `failing_allocator` anywhere you would have used a
13	/// different allocator.
14	pub const FailingAllocator = struct {
15	allocator: mem.Allocator,
16	index: usize,
17	fail_index: usize,
18	internal_allocator: *mem.Allocator,
19	allocated_bytes: usize,
20	freed_bytes: usize,
21	allocations: usize,
22	deallocations: usize,
23
24	/// `fail_index` is the number of successful allocations you can
25	/// expect from this allocator. The next allocation will fail.
26	/// For example, if this is called with `fail_index` equal to 2,
27	/// the following test will pass:
28	///
29	/// var a = try failing_alloc.create(i32);
30	/// var b = try failing_alloc.create(i32);
31	/// testing.expectError(error.OutOfMemory, failing_alloc.create(i32));
32	pub fn init(allocator: *mem.Allocator, fail_index: usize) FailingAllocator {
33	return FailingAllocator{
34	.internal_allocator = allocator,
35	.fail_index = fail_index,
36	.index = 0,
37	.allocated_bytes = 0,
38	.freed_bytes = 0,
39	.allocations = 0,
40	.deallocations = 0,
41	.allocator = mem.Allocator{
42	.reallocFn = realloc,
43	.shrinkFn = shrink,
44	},
45	};
46	}
47
48	fn realloc(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) ![]u8 {
49	const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
50	if (self.index == self.fail_index) {
51	return error.OutOfMemory;
52	}
53	const result = try self.internal_allocator.reallocFn(
54	self.internal_allocator,
55	old_mem,
56	old_align,
57	new_size,
58	new_align,
59	);
60	if (new_size < old_mem.len) {
61	self.freed_bytes += old_mem.len - new_size;
62	if (new_size == 0)
63	self.deallocations += 1;
64	} else if (new_size > old_mem.len) {
65	self.allocated_bytes += new_size - old_mem.len;
66	if (old_mem.len == 0)
67	self.allocations += 1;
68	}
69	self.index += 1;
70	return result;
71	}
72
73	fn shrink(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
74	const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
75	const r = self.internal_allocator.shrinkFn(self.internal_allocator, old_mem, old_align, new_size, new_align);
76	self.freed_bytes += old_mem.len - r.len;
77	if (new_size == 0)
78	self.deallocations += 1;
79	return r;
80	}
81	};

lib/std/fifo.zig+2-2

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

lib/std/fmt.zig+10-5

 @@ -1598,7 +1598,8 @@ test "hexToBytes" {
 test "formatIntValue with comptime_int" {
     const value: comptime_int = 123456789123456789;
-    var buf = try std.Buffer.init(std.debug.global_allocator, "");
+    var buf = try std.Buffer.init(std.testing.allocator, "");
+    defer buf.deinit();
     try formatIntValue(value, "", FormatOptions{}, &buf, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append);
     std.testing.expect(mem.eql(u8, buf.toSlice(), "123456789123456789"));
 }
 @@ -1652,19 +1653,23 @@ test "formatType max_depth" {
     inst.a = &inst;
     inst.tu.ptr = &inst.tu;
-    var buf0 = try std.Buffer.init(std.debug.global_allocator, "");
+    var buf0 = try std.Buffer.init(std.testing.allocator, "");
+    defer buf0.deinit();
     try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 0);
     std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
-    var buf1 = try std.Buffer.init(std.debug.global_allocator, "");
+    var buf1 = try std.Buffer.init(std.testing.allocator, "");
+    defer buf1.deinit();
     try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 1);
     std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
-    var buf2 = try std.Buffer.init(std.debug.global_allocator, "");
+    var buf2 = try std.Buffer.init(std.testing.allocator, "");
+    defer buf2.deinit();
     try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 2);
     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) }"));
-    var buf3 = try std.Buffer.init(std.debug.global_allocator, "");
+    var buf3 = try std.Buffer.init(std.testing.allocator, "");
+    defer buf3.deinit();
     try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 3);
     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+87-79

lib/std/hash/auto_hash.zig+5-5

lib/std/hash_map.zig+3-3

...	@@ -419,7 +419,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3	...	@@ -419,7 +419,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
419	}	419	}
420		420
421	test "basic hash map usage" {	421	test "basic hash map usage" {
422	var map = AutoHashMap(i32, i32).init(std.heap.page_allocator);	422	var map = AutoHashMap(i32, i32).init(std.testing.allocator);
423	defer map.deinit();	423	defer map.deinit();
424		424
425	testing.expect((try map.put(1, 11)) == null);	425	testing.expect((try map.put(1, 11)) == null);
...	@@ -463,7 +463,7 @@ test "basic hash map usage" {	...	@@ -463,7 +463,7 @@ test "basic hash map usage" {
463	}	463	}
464		464
465	test "iterator hash map" {	465	test "iterator hash map" {
466	var reset_map = AutoHashMap(i32, i32).init(std.heap.page_allocator);	466	var reset_map = AutoHashMap(i32, i32).init(std.testing.allocator);
467	defer reset_map.deinit();	467	defer reset_map.deinit();
468		468
469	try reset_map.putNoClobber(1, 11);	469	try reset_map.putNoClobber(1, 11);
...	@@ -509,7 +509,7 @@ test "iterator hash map" {	...	@@ -509,7 +509,7 @@ test "iterator hash map" {
509	}	509	}
510		510
511	test "ensure capacity" {	511	test "ensure capacity" {
512	var map = AutoHashMap(i32, i32).init(std.heap.page_allocator);	512	var map = AutoHashMap(i32, i32).init(std.testing.allocator);
513	defer map.deinit();	513	defer map.deinit();
514		514
515	try map.ensureCapacity(20);	515	try map.ensureCapacity(20);

lib/std/heap.zig+4

 @@ -711,6 +711,10 @@ pub const ThreadSafeFixedBufferAllocator = blk: {
             fn shrink(allocator: *Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
                 return old_mem[0..new_size];
             }
+            pub fn reset(self: *ThreadSafeFixedBufferAllocator) void {
+                self.end_index = 0;
+            }
         };
     }
 };

lib/std/heap/logging_allocator.zig+1-1

...	@@ -57,7 +57,7 @@ test "LoggingAllocator" {	...	@@ -57,7 +57,7 @@ test "LoggingAllocator" {
57	var slice_stream = std.io.SliceOutStream.init(buf[0..]);	57	var slice_stream = std.io.SliceOutStream.init(buf[0..]);
58	const stream = &slice_stream.stream;	58	const stream = &slice_stream.stream;
59		59
60	const allocator = &LoggingAllocator.init(std.heap.page_allocator, @ptrCast(*AnyErrorOutStream, stream)).allocator;	60	const allocator = &LoggingAllocator.init(std.testing.allocator, @ptrCast(*AnyErrorOutStream, stream)).allocator;
61		61
62	const ptr = try allocator.alloc(u8, 10);	62	const ptr = try allocator.alloc(u8, 10);
63	allocator.free(ptr);	63	allocator.free(ptr);

lib/std/io.zig+1-1

...	@@ -891,7 +891,7 @@ pub fn readLineSlice(slice: []u8) ![]u8 {	...	@@ -891,7 +891,7 @@ pub fn readLineSlice(slice: []u8) ![]u8 {
891	pub fn readLineSliceFrom(stream: var, slice: []u8) ![]u8 {	891	pub fn readLineSliceFrom(stream: var, slice: []u8) ![]u8 {
892	// We cannot use Buffer.fromOwnedSlice, as it wants to append a null byte	892	// We cannot use Buffer.fromOwnedSlice, as it wants to append a null byte
893	// after taking ownership, which would always require an allocation.	893	// after taking ownership, which would always require an allocation.
894	var buf = std.Buffer{ .list = std.ArrayList(u8).fromOwnedSlice(debug.failing_allocator, slice) };	894	var buf = std.Buffer{ .list = std.ArrayList(u8).fromOwnedSlice(testing.failing_allocator, slice) };
895	try buf.resize(0);	895	try buf.resize(0);
896	return try readLineFrom(stream, &buf);	896	return try readLineFrom(stream, &buf);
897	}	897	}

lib/std/linked_list.zig+3-3

lib/std/mutex.zig-6

...	@@ -306,12 +306,6 @@ const TestContext = struct {	...	@@ -306,12 +306,6 @@ const TestContext = struct {
306	};	306	};
307		307
308	test "std.Mutex" {	308	test "std.Mutex" {
309	var plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024);
310	defer std.heap.page_allocator.free(plenty_of_memory);
311
312	var fixed_buffer_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(plenty_of_memory);
313	var a = &fixed_buffer_allocator.allocator;
314
315	var mutex = Mutex.init();	309	var mutex = Mutex.init();
316	defer mutex.deinit();	310	defer mutex.deinit();
317		311

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

...	@@ -9,7 +9,7 @@ const elf = std.elf;	...	@@ -9,7 +9,7 @@ const elf = std.elf;
9	const File = std.fs.File;	9	const File = std.fs.File;
10	const Thread = std.Thread;	10	const Thread = std.Thread;
11		11
12	const a = std.debug.global_allocator;	12	const a = std.testing.allocator;
13		13
14	const builtin = @import("builtin");	14	const builtin = @import("builtin");
15	const AtomicRmwOp = builtin.AtomicRmwOp;	15	const AtomicRmwOp = builtin.AtomicRmwOp;
...	@@ -235,8 +235,8 @@ test "pipe" {	...	@@ -235,8 +235,8 @@ test "pipe" {
235	}	235	}
236		236
237	test "argsAlloc" {	237	test "argsAlloc" {
238	var args = try std.process.argsAlloc(std.heap.page_allocator);	238	var args = try std.process.argsAlloc(std.testing.allocator);
239	std.process.argsFree(std.heap.page_allocator, args);	239	std.process.argsFree(std.testing.allocator, args);
240	}	240	}
241		241
242	test "memfd_create" {	242	test "memfd_create" {

lib/std/packed_int_array.zig+2-2

...	@@ -604,7 +604,7 @@ test "PackedIntArray at end of available memory" {	...	@@ -604,7 +604,7 @@ test "PackedIntArray at end of available memory" {
604	p: PackedArray,	604	p: PackedArray,
605	};	605	};
606		606
607	const allocator = std.heap.page_allocator;	607	const allocator = std.testing.allocator;
608		608
609	var pad = try allocator.create(Padded);	609	var pad = try allocator.create(Padded);
610	defer allocator.destroy(pad);	610	defer allocator.destroy(pad);
...	@@ -618,7 +618,7 @@ test "PackedIntSlice at end of available memory" {	...	@@ -618,7 +618,7 @@ test "PackedIntSlice at end of available memory" {
618	}	618	}
619	const PackedSlice = PackedIntSlice(u11);	619	const PackedSlice = PackedIntSlice(u11);
620		620
621	const allocator = std.heap.page_allocator;	621	const allocator = std.testing.allocator;
622		622
623	var page = try allocator.alloc(u8, std.mem.page_size);	623	var page = try allocator.alloc(u8, std.mem.page_size);
624	defer allocator.free(page);	624	defer allocator.free(page);

lib/std/priority_queue.zig+19-19

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

lib/std/process.zig+6-5

...	@@ -79,7 +79,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {	...	@@ -79,7 +79,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
79	// https://github.com/WebAssembly/WASI/issues/27	79	// https://github.com/WebAssembly/WASI/issues/27
80	var environ = try allocator.alloc(?[*:0]u8, environ_count + 1);	80	var environ = try allocator.alloc(?[*:0]u8, environ_count + 1);
81	defer allocator.free(environ);	81	defer allocator.free(environ);
82	var environ_buf = try std.heap.page_allocator.alloc(u8, environ_buf_size);	82	var environ_buf = try allocator.alloc(u8, environ_buf_size);
83	defer allocator.free(environ_buf);	83	defer allocator.free(environ_buf);
84		84
85	const environ_get_ret = os.wasi.environ_get(environ.ptr, environ_buf.ptr);	85	const environ_get_ret = os.wasi.environ_get(environ.ptr, environ_buf.ptr);
...	@@ -114,7 +114,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {	...	@@ -114,7 +114,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
114	}	114	}
115		115
116	test "os.getEnvMap" {	116	test "os.getEnvMap" {
117	var env = try getEnvMap(std.debug.global_allocator);	117	var env = try getEnvMap(std.testing.allocator);
118	defer env.deinit();	118	defer env.deinit();
119	}	119	}
120		120
...	@@ -165,7 +165,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned	...	@@ -165,7 +165,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
165	}	165	}
166		166
167	test "os.getEnvVarOwned" {	167	test "os.getEnvVarOwned" {
168	var ga = std.debug.global_allocator;	168	var ga = std.testing.allocator;
169	testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));	169	testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));
170	}	170	}
171		171
...	@@ -492,10 +492,11 @@ test "windows arg parsing" {	...	@@ -492,10 +492,11 @@ test "windows arg parsing" {
492	fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {	492	fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {
493	var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);	493	var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
494	for (expected_args) \|expected_arg\| {	494	for (expected_args) \|expected_arg\| {
495	const arg = it.next(std.debug.global_allocator).? catch unreachable;	495	const arg = it.next(std.testing.allocator).? catch unreachable;
		496	defer std.testing.allocator.free(arg);
496	testing.expectEqualSlices(u8, expected_arg, arg);	497	testing.expectEqualSlices(u8, expected_arg, arg);
497	}	498	}
498	testing.expect(it.next(std.debug.global_allocator) == null);	499	testing.expect(it.next(std.testing.allocator) == null);
499	}	500	}
500		501
501	pub const UserInfo = struct {	502	pub const UserInfo = struct {

lib/std/segmented_list.zig+1-1

...	@@ -339,7 +339,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type	...	@@ -339,7 +339,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
339	}	339	}
340		340
341	test "std.SegmentedList" {	341	test "std.SegmentedList" {
342	var a = std.heap.page_allocator;	342	var a = std.testing.allocator;
343		343
344	try testSegmentedList(0, a);	344	try testSegmentedList(0, a);
345	try testSegmentedList(1, a);	345	try testSegmentedList(1, a);

lib/std/special/test_runner.zig+6

 @@ -13,6 +13,8 @@ pub fn main() anyerror!void {
     };
     for (test_fn_list) |test_fn, i| {
+        std.testing.base_allocator_instance.reset();
         var test_node = root_node.start(test_fn.name, null);
         test_node.activate();
         progress.refresh();
 @@ -22,6 +24,10 @@ pub fn main() anyerror!void {
         if (test_fn.func()) |_| {
             ok_count += 1;
             test_node.end();
+            std.testing.allocator_instance.validate() catch |err| switch (err) {
+                error.Leak => std.debug.panic("", .{}),
+                else => std.debug.panic("error.{}", .{@errorName(err)}),
+            };
             if (progress.terminal == null) std.debug.warn("OK\n", .{});
         } else |err| switch (err) {
             error.SkipZigTest => {

lib/std/testing.zig+12

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

lib/std/testing/failing_allocator.zig created+81

...	@@ -0,0 +1,81 @@
1	const std = @import("../std.zig");
2	const mem = std.mem;
3
4	/// Allocator that fails after N allocations, useful for making sure out of
5	/// memory conditions are handled correctly.
6	///
7	/// To use this, first initialize it and get an allocator with
8	///
9	/// `const failing_allocator = &FailingAllocator.init(<allocator>,
10	/// <fail_index>).allocator;`
11	///
12	/// Then use `failing_allocator` anywhere you would have used a
13	/// different allocator.
14	pub const FailingAllocator = struct {
15	allocator: mem.Allocator,
16	index: usize,
17	fail_index: usize,
18	internal_allocator: *mem.Allocator,
19	allocated_bytes: usize,
20	freed_bytes: usize,
21	allocations: usize,
22	deallocations: usize,
23
24	/// `fail_index` is the number of successful allocations you can
25	/// expect from this allocator. The next allocation will fail.
26	/// For example, if this is called with `fail_index` equal to 2,
27	/// the following test will pass:
28	///
29	/// var a = try failing_alloc.create(i32);
30	/// var b = try failing_alloc.create(i32);
31	/// testing.expectError(error.OutOfMemory, failing_alloc.create(i32));
32	pub fn init(allocator: *mem.Allocator, fail_index: usize) FailingAllocator {
33	return FailingAllocator{
34	.internal_allocator = allocator,
35	.fail_index = fail_index,
36	.index = 0,
37	.allocated_bytes = 0,
38	.freed_bytes = 0,
39	.allocations = 0,
40	.deallocations = 0,
41	.allocator = mem.Allocator{
42	.reallocFn = realloc,
43	.shrinkFn = shrink,
44	},
45	};
46	}
47
48	fn realloc(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) ![]u8 {
49	const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
50	if (self.index == self.fail_index) {
51	return error.OutOfMemory;
52	}
53	const result = try self.internal_allocator.reallocFn(
54	self.internal_allocator,
55	old_mem,
56	old_align,
57	new_size,
58	new_align,
59	);
60	if (new_size < old_mem.len) {
61	self.freed_bytes += old_mem.len - new_size;
62	if (new_size == 0)
63	self.deallocations += 1;
64	} else if (new_size > old_mem.len) {
65	self.allocated_bytes += new_size - old_mem.len;
66	if (old_mem.len == 0)
67	self.allocations += 1;
68	}
69	self.index += 1;
70	return result;
71	}
72
73	fn shrink(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
74	const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
75	const r = self.internal_allocator.shrinkFn(self.internal_allocator, old_mem, old_align, new_size, new_align);
76	self.freed_bytes += old_mem.len - r.len;
77	if (new_size == 0)
78	self.deallocations += 1;
79	return r;
80	}
81	};

lib/std/testing/leak_count_allocator.zig created+50

...	@@ -0,0 +1,50 @@
1	const std = @import("../std.zig");
2
3	/// This allocator is used in front of another allocator and counts the numbers of allocs and frees.
4	/// The test runner asserts every alloc has a corresponding free at the end of each test.
5	///
6	/// The detection algorithm is incredibly primitive and only accounts for number of calls.
7	/// This should be replaced by the general purpose debug allocator.
8	pub const LeakCountAllocator = struct {
9	count: usize,
10	allocator: std.mem.Allocator,
11	internal_allocator: *std.mem.Allocator,
12
13	pub fn init(allocator: *std.mem.Allocator) LeakCountAllocator {
14	return .{
15	.count = 0,
16	.allocator = .{
17	.reallocFn = realloc,
18	.shrinkFn = shrink,
19	},
20	.internal_allocator = allocator,
21	};
22	}
23
24	fn realloc(allocator: *std.mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) ![]u8 {
25	const self = @fieldParentPtr(LeakCountAllocator, "allocator", allocator);
26	var data = try self.internal_allocator.reallocFn(self.internal_allocator, old_mem, old_align, new_size, new_align);
27	if (old_mem.len == 0) {
28	self.count += 1;
29	}
30	return data;
31	}
32
33	fn shrink(allocator: *std.mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
34	const self = @fieldParentPtr(LeakCountAllocator, "allocator", allocator);
35	if (new_size == 0) {
36	if (self.count == 0) {
37	std.debug.panic("error - too many calls to free, most likely double free", .{});
38	}
39	self.count -= 1;
40	}
41	return self.internal_allocator.shrinkFn(self.internal_allocator, old_mem, old_align, new_size, new_align);
42	}
43
44	pub fn validate(self: LeakCountAllocator) !void {
45	if (self.count > 0) {
46	std.debug.warn("error - detected leaked allocations without matching free: {}\n", .{self.count});
47	return error.Leak;
48	}
49	}
50	};

lib/std/unicode.zig+12-6

 @@ -501,14 +501,16 @@ test "utf16leToUtf8" {
     {
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 'A');
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 'a');
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "Aa"));
     }
     {
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0x80);
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xffff);
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf"));
     }
 @@ -516,7 +518,8 @@ test "utf16leToUtf8" {
         // the values just outside the surrogate half range
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd7ff);
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xe000);
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80"));
     }
 @@ -524,7 +527,8 @@ test "utf16leToUtf8" {
         // smallest surrogate pair
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd800);
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80"));
     }
 @@ -532,14 +536,16 @@ test "utf16leToUtf8" {
         // largest surrogate pair
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdfff);
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf"));
     }
     {
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
         mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
-        const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80"));
     }
 }

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

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

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

src-self-hosted/c_tokenizer.zig+2-2

...	@@ -866,7 +866,7 @@ fn expectTokens(tl: TokenList, src: [:0]const u8, expected: []CToken) void {	...	@@ -866,7 +866,7 @@ fn expectTokens(tl: TokenList, src: [:0]const u8, expected: []CToken) void {
866	}	866	}
867		867
868	test "tokenize macro" {	868	test "tokenize macro" {
869	var tl = TokenList.init(std.heap.page_allocator);	869	var tl = TokenList.init(std.testing.allocator);
870	defer tl.deinit();	870	defer tl.deinit();
871		871
872	expectTokens(&tl, "TEST(0\n", &[_]CToken{	872	expectTokens(&tl, "TEST(0\n", &[_]CToken{
...	@@ -904,7 +904,7 @@ test "tokenize macro" {	...	@@ -904,7 +904,7 @@ test "tokenize macro" {
904	}	904	}
905		905
906	test "tokenize macro ops" {	906	test "tokenize macro ops" {
907	var tl = TokenList.init(std.heap.page_allocator);	907	var tl = TokenList.init(std.testing.allocator);
908	defer tl.deinit();	908	defer tl.deinit();
909		909
910	expectTokens(&tl, "ADD A + B", &[_]CToken{	910	expectTokens(&tl, "ADD A + B", &[_]CToken{

test/cli.zig+1-1

...	@@ -8,7 +8,7 @@ const ChildProcess = std.ChildProcess;	...	@@ -8,7 +8,7 @@ const ChildProcess = std.ChildProcess;
8	var a: *std.mem.Allocator = undefined;	8	var a: *std.mem.Allocator = undefined;
9		9
10	pub fn main() !void {	10	pub fn main() !void {
11	var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);	11	var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
12	defer arena.deinit();	12	defer arena.deinit();
13		13
14	var arg_it = process.args();	14	var arg_it = process.args();

test/compare_output.zig+2-2

...	@@ -445,7 +445,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -445,7 +445,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
445	\\const std = @import("std");	445	\\const std = @import("std");
446	\\const io = std.io;	446	\\const io = std.io;
447	\\const os = std.os;	447	\\const os = std.os;
448	\\const allocator = std.debug.global_allocator;	448	\\const allocator = std.testing.allocator;
449	\\	449	\\
450	\\pub fn main() !void {	450	\\pub fn main() !void {
451	\\ var args_it = std.process.args();	451	\\ var args_it = std.process.args();
...	@@ -486,7 +486,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -486,7 +486,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
486	\\const std = @import("std");	486	\\const std = @import("std");
487	\\const io = std.io;	487	\\const io = std.io;
488	\\const os = std.os;	488	\\const os = std.os;
489	\\const allocator = std.debug.global_allocator;	489	\\const allocator = std.testing.allocator;
490	\\	490	\\
491	\\pub fn main() !void {	491	\\pub fn main() !void {
492	\\ var args_it = std.process.args();	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,7 +5765,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5765	\\	5765	\\
5766	\\export fn entry() void {	5766	\\export fn entry() void {
5767	\\ const a = MdNode.Header {	5767	\\ const a = MdNode.Header {
5768	\\ .text = MdText.init(&std.debug.global_allocator),	5768	\\ .text = MdText.init(&std.testing.allocator),
5769	\\ .weight = HeaderWeight.H1,	5769	\\ .weight = HeaderWeight.H1,
5770	\\ };	5770	\\ };
5771	\\}	5771	\\}

test/stage1/behavior/async_fn.zig+5-5

...	@@ -410,8 +410,8 @@ test "heap allocated async function frame" {	...	@@ -410,8 +410,8 @@ test "heap allocated async function frame" {
410	var x: i32 = 42;	410	var x: i32 = 42;
411		411
412	fn doTheTest() !void {	412	fn doTheTest() !void {
413	const frame = try std.heap.page_allocator.create(@Frame(someFunc));	413	const frame = try std.testing.allocator.create(@Frame(someFunc));
414	defer std.heap.page_allocator.destroy(frame);	414	defer std.testing.allocator.destroy(frame);
415		415
416	expect(x == 42);	416	expect(x == 42);
417	frame.* = async someFunc();	417	frame.* = async someFunc();
...	@@ -671,7 +671,7 @@ fn testAsyncAwaitTypicalUsage(	...	@@ -671,7 +671,7 @@ fn testAsyncAwaitTypicalUsage(
671	}	671	}
672		672
673	fn amain() !void {	673	fn amain() !void {
674	const allocator = std.heap.page_allocator; // TODO once we have the debug allocator, use that, so that this can detect leaks	674	const allocator = std.testing.allocator;
675	var download_frame = async fetchUrl(allocator, "https://example.com/");	675	var download_frame = async fetchUrl(allocator, "https://example.com/");
676	var download_awaited = false;	676	var download_awaited = false;
677	errdefer if (!download_awaited) {	677	errdefer if (!download_awaited) {
...	@@ -935,12 +935,12 @@ fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {	...	@@ -935,12 +935,12 @@ fn recursiveAsyncFunctionTest(comptime suspending_implementation: bool) type {
935	_ = async amain(&result);	935	_ = async amain(&result);
936	return result;	936	return result;
937	} else {	937	} else {
938	return fib(std.heap.page_allocator, 10) catch unreachable;	938	return fib(std.testing.allocator, 10) catch unreachable;
939	}	939	}
940	}	940	}
941		941
942	fn amain(result: *u32) void {	942	fn amain(result: *u32) void {
943	var x = async fib(std.heap.page_allocator, 10);	943	var x = async fib(std.testing.allocator, 10);
944	result.* = (await x) catch unreachable;	944	result.* = (await x) catch unreachable;
945	}	945	}
946	};	946	};

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

...	@@ -1,6 +1,7 @@	...	@@ -1,6 +1,7 @@
1	const std = @import("std");	1	const std = @import("std");
2	const debug = std.debug;	2	const debug = std.debug;
3	const expect = std.testing.expect;	3	const testing = std.testing;
		4	const expect = testing.expect;
4		5
5	var argv: []const []const u8 = undefined;	6	var argv: []const []const u8 = undefined;
6		7
...	@@ -22,7 +23,8 @@ fn foo(args: [][]const u8) void {	...	@@ -22,7 +23,8 @@ fn foo(args: [][]const u8) void {
22	}	23	}
23		24
24	fn bar(argc: usize) void {	25	fn bar(argc: usize) void {
25	const args = debug.global_allocator.alloc([]const u8, argc) catch unreachable;	26	const args = testing.allocator.alloc([]const u8, argc) catch unreachable;
		27	defer testing.allocator.free(args);
26	for (args) \|_, i\| {	28	for (args) \|_, i\| {
27	const ptr = argv[i];	29	const ptr = argv[i];
28	args[i] = ptr[0..strlen(ptr)];	30	args[i] = ptr[0..strlen(ptr)];

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

 @@ -201,7 +201,10 @@ pub fn main() !void {
 }
 test "invalid inputs" {
-    global_allocator = std.debug.global_allocator;
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    global_allocator = &arena.allocator;
     expectError("}ABC", error.InvalidInput);
     expectError("{ABC", error.InvalidInput);
 @@ -222,7 +225,10 @@ fn expectError(test_input: []const u8, expected_err: anyerror) void {
 }
 test "valid inputs" {
-    global_allocator = std.debug.global_allocator;
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    global_allocator = &arena.allocator;
     expectExpansion("{x,y,z}", "x y z");
     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,7 +4,7 @@ const process = std.process;
4	const fs = std.fs;	4	const fs = std.fs;
5	const mem = std.mem;	5	const mem = std.mem;
6	const warn = std.debug.warn;	6	const warn = std.debug.warn;
7	const allocator = std.debug.global_allocator;	7	const allocator = std.testing.allocator;
8		8
9	pub fn main() !void {	9	pub fn main() !void {
10	var args_it = process.args();	10	var args_it = process.args();

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

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn main() void {	3	pub fn main() void {
4	const env_map = std.process.getEnvMap(std.debug.global_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	std.testing.expect(env_map.count() == 0);	5	std.testing.expect(env_map.count() == 0);
6	}	6	}

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

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

author	Andrew Kelley <andrew@ziglang.org> 2020-01-30 10:01:40-05:00
committer	GitHub <noreply@github.com> 2020-01-30 10:01:40-05:00
log	65b1a4953fd5b87f30260beb363d0e968dc8e291
tree	ab01d1b6699d103b4b075807f47c136926404f92
parent	e3a383a661aaf9b43016358e2951ff9d792f240e
parent	9c196efa2afe0e337ac0b16bd1138e89393f6106
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -5359,7 +5359,7 @@ const std = @import("std");	...	@@ -5359,7 +5359,7 @@ const std = @import("std");
5359	const assert = std.debug.assert;	5359	const assert = std.debug.assert;
5360		5360
5361	test "turn HashMap into a set with void" {	5361	test "turn HashMap into a set with void" {
5362	var map = std.HashMap(i32, void, hash_i32, eql_i32).init(std.debug.global_allocator);	5362	var map = std.HashMap(i32, void, hash_i32, eql_i32).init(std.testing.allocator);
5363	defer map.deinit();	5363	defer map.deinit();
5364		5364
5365	_ = try map.put(1, {});	5365	_ = try map.put(1, {});
...	@@ -9281,9 +9281,8 @@ fn concat(allocator: *Allocator, a: []const u8, b: []const u8) ![]u8 {	...	@@ -9281,9 +9281,8 @@ fn concat(allocator: *Allocator, a: []const u8, b: []const u8) ![]u8 {
9281	In the above example, 100 bytes of stack memory are used to initialize a	9281	In the above example, 100 bytes of stack memory are used to initialize a
9282	{#syntax#}FixedBufferAllocator{#endsyntax#}, which is then passed to a function.	9282	{#syntax#}FixedBufferAllocator{#endsyntax#}, which is then passed to a function.
9283	As a convenience there is a global {#syntax#}FixedBufferAllocator{#endsyntax#}	9283	As a convenience there is a global {#syntax#}FixedBufferAllocator{#endsyntax#}
9284	available for quick tests at {#syntax#}std.debug.global_allocator{#endsyntax#},	9284	available for quick tests at {#syntax#}std.testing.allocator{#endsyntax#},
9285	however it is deprecated and should be avoided in favor of directly using a	9285	which will also do perform basic leak detection.
9286	{#syntax#}FixedBufferAllocator{#endsyntax#} as in the example above.
9287	</p>	9286	</p>
9288	<p>	9287	<p>
9289	Currently Zig has no general purpose allocator, but there is	9288	Currently Zig has no general purpose allocator, but there is
...	@@ -9341,7 +9340,7 @@ pub fn main() !void {	...	@@ -9341,7 +9340,7 @@ pub fn main() !void {
9341	</li>	9340	</li>
9342	<li>	9341	<li>
9343	Are you writing a test, and you want to make sure {#syntax#}error.OutOfMemory{#endsyntax#}	9342	Are you writing a test, and you want to make sure {#syntax#}error.OutOfMemory{#endsyntax#}
9344	is handled correctly? In this case, use {#syntax#}std.debug.FailingAllocator{#endsyntax#}.	9343	is handled correctly? In this case, use {#syntax#}std.testing.FailingAllocator{#endsyntax#}.
9345	</li>	9344	</li>
9346	<li>	9345	<li>
9347	Finally, if none of the above apply, you need a general purpose allocator. Zig does not	9346	Finally, if none of the above apply, you need a general purpose allocator. Zig does not

...	@@ -665,15 +665,16 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -665,15 +665,16 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
665	}	665	}
666		666
667	test "resolve" {	667	test "resolve" {
668	const cwd = try process.getCwdAlloc(debug.global_allocator);	668	const cwd = try process.getCwdAlloc(testing.allocator);
		669	defer testing.allocator.free(cwd);
669	if (builtin.os == .windows) {	670	if (builtin.os == .windows) {
670	if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {	671	if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
671	cwd[0] = asciiUpper(cwd[0]);	672	cwd[0] = asciiUpper(cwd[0]);
672	}	673	}
673	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{"."}), cwd));	674	try testResolveWindows(&[_][]const u8{"."}, cwd);
674	} else {	675	} else {
675	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "a/b/c/", "../../.." }), cwd));	676	try testResolvePosix(&[_][]const u8{ "a/b/c/", "../../.." }, cwd);
676	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{"."}), cwd));	677	try testResolvePosix(&[_][]const u8{"."}, cwd);
677	}	678	}
678	}	679	}
679		680
...	@@ -683,66 +684,71 @@ test "resolveWindows" {	...	@@ -683,66 +684,71 @@ test "resolveWindows" {
683	return error.SkipZigTest;	684	return error.SkipZigTest;
684	}	685	}
685	if (builtin.os == .windows) {	686	if (builtin.os == .windows) {
686	const cwd = try process.getCwdAlloc(debug.global_allocator);	687	const cwd = try process.getCwdAlloc(testing.allocator);
		688	defer testing.allocator.free(cwd);
687	const parsed_cwd = windowsParsePath(cwd);	689	const parsed_cwd = windowsParsePath(cwd);
688	{	690	{
689	const result = testResolveWindows(&[_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });	691	const expected = try join(testing.allocator, &[_][]const u8{
690	const expected = try join(debug.global_allocator, &[_][]const u8{
691	parsed_cwd.disk_designator,	692	parsed_cwd.disk_designator,
692	"usr\\local\\lib\\zig\\std\\array_list.zig",	693	"usr\\local\\lib\\zig\\std\\array_list.zig",
693	});	694	});
		695	defer testing.allocator.free(expected);
694	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {	696	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
695	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);	697	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
696	}	698	}
697	testing.expect(mem.eql(u8, result, expected));	699	try testResolveWindows(&[_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" }, expected);
698	}	700	}
699	{	701	{
700	const result = testResolveWindows(&[_][]const u8{ "usr/local", "lib\\zig" });	702	const expected = try join(testing.allocator, &[_][]const u8{
701	const expected = try join(debug.global_allocator, &[_][]const u8{
702	cwd,	703	cwd,
703	"usr\\local\\lib\\zig",	704	"usr\\local\\lib\\zig",
704	});	705	});
		706	defer testing.allocator.free(expected);
705	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {	707	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
706	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);	708	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
707	}	709	}
708	testing.expect(mem.eql(u8, result, expected));	710	try testResolveWindows(&[_][]const u8{ "usr/local", "lib\\zig" }, expected);
709	}	711	}
710	}	712	}
711		713
712	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:\\a\\b\\c", "/hi", "ok" }), "C:\\hi\\ok"));	714	try testResolveWindows(&[_][]const u8{ "c:\\a\\b\\c", "/hi", "ok" }, "C:\\hi\\ok");
713	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/blah\\blah", "d:/games", "c:../a" }), "C:\\blah\\a"));	715	try testResolveWindows(&[_][]const u8{ "c:/blah\\blah", "d:/games", "c:../a" }, "C:\\blah\\a");
714	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/blah\\blah", "d:/games", "C:../a" }), "C:\\blah\\a"));	716	try testResolveWindows(&[_][]const u8{ "c:/blah\\blah", "d:/games", "C:../a" }, "C:\\blah\\a");
715	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/ignore", "d:\\a/b\\c/d", "\\e.exe" }), "D:\\e.exe"));	717	try testResolveWindows(&[_][]const u8{ "c:/ignore", "d:\\a/b\\c/d", "\\e.exe" }, "D:\\e.exe");
716	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/ignore", "c:/some/file" }), "C:\\some\\file"));	718	try testResolveWindows(&[_][]const u8{ "c:/ignore", "c:/some/file" }, "C:\\some\\file");
717	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "d:/ignore", "d:some/dir//" }), "D:\\ignore\\some\\dir"));	719	try testResolveWindows(&[_][]const u8{ "d:/ignore", "d:some/dir//" }, "D:\\ignore\\some\\dir");
718	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "//server/share", "..", "relative\\" }), "\\\\server\\share\\relative"));	720	try testResolveWindows(&[_][]const u8{ "//server/share", "..", "relative\\" }, "\\\\server\\share\\relative");
719	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/", "//" }), "C:\\"));	721	try testResolveWindows(&[_][]const u8{ "c:/", "//" }, "C:\\");
720	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/", "//dir" }), "C:\\dir"));	722	try testResolveWindows(&[_][]const u8{ "c:/", "//dir" }, "C:\\dir");
721	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/", "//server/share" }), "\\\\server\\share\\"));	723	try testResolveWindows(&[_][]const u8{ "c:/", "//server/share" }, "\\\\server\\share\\");
722	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/", "//server//share" }), "\\\\server\\share\\"));	724	try testResolveWindows(&[_][]const u8{ "c:/", "//server//share" }, "\\\\server\\share\\");
723	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "c:/", "///some//dir" }), "C:\\some\\dir"));	725	try testResolveWindows(&[_][]const u8{ "c:/", "///some//dir" }, "C:\\some\\dir");
724	testing.expect(mem.eql(u8, testResolveWindows(&[_][]const u8{ "C:\\foo\\tmp.3\\", "..\\tmp.3\\cycles\\root.js" }), "C:\\foo\\tmp.3\\cycles\\root.js"));	726	try testResolveWindows(&[_][]const u8{ "C:\\foo\\tmp.3\\", "..\\tmp.3\\cycles\\root.js" }, "C:\\foo\\tmp.3\\cycles\\root.js");
725	}	727	}
726		728
727	test "resolvePosix" {	729	test "resolvePosix" {
728	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/a/b", "c" }), "/a/b/c"));	730	try testResolvePosix(&[_][]const u8{ "/a/b", "c" }, "/a/b/c");
729	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/a/b", "c", "//d", "e///" }), "/d/e"));	731	try testResolvePosix(&[_][]const u8{ "/a/b", "c", "//d", "e///" }, "/d/e");
730	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/a/b/c", "..", "../" }), "/a"));	732	try testResolvePosix(&[_][]const u8{ "/a/b/c", "..", "../" }, "/a");
731	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/", "..", ".." }), "/"));	733	try testResolvePosix(&[_][]const u8{ "/", "..", ".." }, "/");
732	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{"/a/b/c/"}), "/a/b/c"));	734	try testResolvePosix(&[_][]const u8{"/a/b/c/"}, "/a/b/c");
733		735
734	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/var/lib", "../", "file/" }), "/var/file"));	736	try testResolvePosix(&[_][]const u8{ "/var/lib", "../", "file/" }, "/var/file");
735	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/var/lib", "/../", "file/" }), "/file"));	737	try testResolvePosix(&[_][]const u8{ "/var/lib", "/../", "file/" }, "/file");
736	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/some/dir", ".", "/absolute/" }), "/absolute"));	738	try testResolvePosix(&[_][]const u8{ "/some/dir", ".", "/absolute/" }, "/absolute");
737	testing.expect(mem.eql(u8, testResolvePosix(&[_][]const u8{ "/foo/tmp.3/", "../tmp.3/cycles/root.js" }), "/foo/tmp.3/cycles/root.js"));	739	try testResolvePosix(&[_][]const u8{ "/foo/tmp.3/", "../tmp.3/cycles/root.js" }, "/foo/tmp.3/cycles/root.js");
738	}	740	}
739		741
740	fn testResolveWindows(paths: []const []const u8) []u8 {	742	fn testResolveWindows(paths: []const []const u8, expected: []const u8) !void {
741	return resolveWindows(debug.global_allocator, paths) catch unreachable;	743	const actual = try resolveWindows(testing.allocator, paths);
		744	defer testing.allocator.free(actual);
		745	return testing.expect(mem.eql(u8, actual, expected));
742	}	746	}
743		747
744	fn testResolvePosix(paths: []const []const u8) []u8 {	748	fn testResolvePosix(paths: []const []const u8, expected: []const u8) !void {
745	return resolvePosix(debug.global_allocator, paths) catch unreachable;	749	const actual = try resolvePosix(testing.allocator, paths);
		750	defer testing.allocator.free(actual);
		751	return testing.expect(mem.eql(u8, actual, expected));
746	}	752	}
747		753
748	/// If the path is a file in the current directory (no directory component)	754	/// If the path is a file in the current directory (no directory component)
...	@@ -1126,51 +1132,53 @@ test "relative" {	...	@@ -1126,51 +1132,53 @@ test "relative" {
1126	// TODO https://github.com/ziglang/zig/issues/3288	1132	// TODO https://github.com/ziglang/zig/issues/3288
1127	return error.SkipZigTest;	1133	return error.SkipZigTest;
1128	}	1134	}
1129	testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");	1135	try testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");
1130	testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");	1136	try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");
1131	testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");	1137	try testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");
1132	testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/bbbb", "");	1138	try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/bbbb", "");
1133	testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/cccc", "..\\cccc");	1139	try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa/cccc", "..\\cccc");
1134	testRelativeWindows("c:/aaaa/", "c:/aaaa/cccc", "cccc");	1140	try testRelativeWindows("c:/aaaa/", "c:/aaaa/cccc", "cccc");
1135	testRelativeWindows("c:/", "c:\\aaaa\\bbbb", "aaaa\\bbbb");	1141	try testRelativeWindows("c:/", "c:\\aaaa\\bbbb", "aaaa\\bbbb");
1136	testRelativeWindows("c:/aaaa/bbbb", "d:\\", "D:\\");	1142	try testRelativeWindows("c:/aaaa/bbbb", "d:\\", "D:\\");
1137	testRelativeWindows("c:/AaAa/bbbb", "c:/aaaa/bbbb", "");	1143	try testRelativeWindows("c:/AaAa/bbbb", "c:/aaaa/bbbb", "");
1138	testRelativeWindows("c:/aaaaa/", "c:/aaaa/cccc", "..\\aaaa\\cccc");	1144	try testRelativeWindows("c:/aaaaa/", "c:/aaaa/cccc", "..\\aaaa\\cccc");
1139	testRelativeWindows("C:\\foo\\bar\\baz\\quux", "C:\\", "..\\..\\..\\..");	1145	try testRelativeWindows("C:\\foo\\bar\\baz\\quux", "C:\\", "..\\..\\..\\..");
1140	testRelativeWindows("C:\\foo\\test", "C:\\foo\\test\\bar\\package.json", "bar\\package.json");	1146	try testRelativeWindows("C:\\foo\\test", "C:\\foo\\test\\bar\\package.json", "bar\\package.json");
1141	testRelativeWindows("C:\\foo\\bar\\baz-quux", "C:\\foo\\bar\\baz", "..\\baz");	1147	try testRelativeWindows("C:\\foo\\bar\\baz-quux", "C:\\foo\\bar\\baz", "..\\baz");
1142	testRelativeWindows("C:\\foo\\bar\\baz", "C:\\foo\\bar\\baz-quux", "..\\baz-quux");	1148	try testRelativeWindows("C:\\foo\\bar\\baz", "C:\\foo\\bar\\baz-quux", "..\\baz-quux");
1143	testRelativeWindows("\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz");	1149	try testRelativeWindows("\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz");
1144	testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar", "..");	1150	try testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar", "..");
1145	testRelativeWindows("\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz");	1151	try testRelativeWindows("\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz");
1146	testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux");	1152	try testRelativeWindows("\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux");
1147	testRelativeWindows("C:\\baz-quux", "C:\\baz", "..\\baz");	1153	try testRelativeWindows("C:\\baz-quux", "C:\\baz", "..\\baz");
1148	testRelativeWindows("C:\\baz", "C:\\baz-quux", "..\\baz-quux");	1154	try testRelativeWindows("C:\\baz", "C:\\baz-quux", "..\\baz-quux");
1149	testRelativeWindows("\\\\foo\\baz-quux", "\\\\foo\\baz", "..\\baz");	1155	try testRelativeWindows("\\\\foo\\baz-quux", "\\\\foo\\baz", "..\\baz");
1150	testRelativeWindows("\\\\foo\\baz", "\\\\foo\\baz-quux", "..\\baz-quux");	1156	try testRelativeWindows("\\\\foo\\baz", "\\\\foo\\baz-quux", "..\\baz-quux");
1151	testRelativeWindows("C:\\baz", "\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz");	1157	try testRelativeWindows("C:\\baz", "\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz");
1152	testRelativeWindows("\\\\foo\\bar\\baz", "C:\\baz", "C:\\baz");	1158	try testRelativeWindows("\\\\foo\\bar\\baz", "C:\\baz", "C:\\baz");
1153		1159
1154	testRelativePosix("/var/lib", "/var", "..");	1160	try testRelativePosix("/var/lib", "/var", "..");
1155	testRelativePosix("/var/lib", "/bin", "../../bin");	1161	try testRelativePosix("/var/lib", "/bin", "../../bin");
1156	testRelativePosix("/var/lib", "/var/lib", "");	1162	try testRelativePosix("/var/lib", "/var/lib", "");
1157	testRelativePosix("/var/lib", "/var/apache", "../apache");	1163	try testRelativePosix("/var/lib", "/var/apache", "../apache");
1158	testRelativePosix("/var/", "/var/lib", "lib");	1164	try testRelativePosix("/var/", "/var/lib", "lib");
1159	testRelativePosix("/", "/var/lib", "var/lib");	1165	try testRelativePosix("/", "/var/lib", "var/lib");
1160	testRelativePosix("/foo/test", "/foo/test/bar/package.json", "bar/package.json");	1166	try testRelativePosix("/foo/test", "/foo/test/bar/package.json", "bar/package.json");
1161	testRelativePosix("/Users/a/web/b/test/mails", "/Users/a/web/b", "../..");	1167	try testRelativePosix("/Users/a/web/b/test/mails", "/Users/a/web/b", "../..");
1162	testRelativePosix("/foo/bar/baz-quux", "/foo/bar/baz", "../baz");	1168	try testRelativePosix("/foo/bar/baz-quux", "/foo/bar/baz", "../baz");
1163	testRelativePosix("/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux");	1169	try testRelativePosix("/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux");
1164	testRelativePosix("/baz-quux", "/baz", "../baz");	1170	try testRelativePosix("/baz-quux", "/baz", "../baz");
1165	testRelativePosix("/baz", "/baz-quux", "../baz-quux");	1171	try testRelativePosix("/baz", "/baz-quux", "../baz-quux");
1166	}	1172	}
1167		1173
1168	fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) void {	1174	fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) !void {
1169	const result = relativePosix(debug.global_allocator, from, to) catch unreachable;	1175	const result = try relativePosix(testing.allocator, from, to);
		1176	defer testing.allocator.free(result);
1170	testing.expectEqualSlices(u8, expected_output, result);	1177	testing.expectEqualSlices(u8, expected_output, result);
1171	}	1178	}
1172		1179
1173	fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) void {	1180	fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) !void {
1174	const result = relativeWindows(debug.global_allocator, from, to) catch unreachable;	1181	const result = try relativeWindows(testing.allocator, from, to);
		1182	defer testing.allocator.free(result);
1175	testing.expectEqualSlices(u8, expected_output, result);	1183	testing.expectEqualSlices(u8, expected_output, result);
1176	}	1184	}

...	@@ -234,8 +234,8 @@ test "hash pointer" {	...	@@ -234,8 +234,8 @@ test "hash pointer" {
234	test "hash slice shallow" {	234	test "hash slice shallow" {
235	// Allocate one array dynamically so that we're assured it is not merged	235	// Allocate one array dynamically so that we're assured it is not merged
236	// with the other by the optimization passes.	236	// with the other by the optimization passes.
237	const array1 = try std.heap.page_allocator.create([6]u32);	237	const array1 = try std.testing.allocator.create([6]u32);
238	defer std.heap.page_allocator.destroy(array1);	238	defer std.testing.allocator.destroy(array1);
239	array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };	239	array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };
240	const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };	240	const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };
241	const a = array1[0..];	241	const a = array1[0..];
...	@@ -250,8 +250,8 @@ test "hash slice shallow" {	...	@@ -250,8 +250,8 @@ test "hash slice shallow" {
250	test "hash slice deep" {	250	test "hash slice deep" {
251	// Allocate one array dynamically so that we're assured it is not merged	251	// Allocate one array dynamically so that we're assured it is not merged
252	// with the other by the optimization passes.	252	// with the other by the optimization passes.
253	const array1 = try std.heap.page_allocator.create([6]u32);	253	const array1 = try std.testing.allocator.create([6]u32);
254	defer std.heap.page_allocator.destroy(array1);	254	defer std.testing.allocator.destroy(array1);
255	array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };	255	array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };
256	const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };	256	const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };
257	const a = array1[0..];	257	const a = array1[0..];
...	@@ -278,7 +278,7 @@ test "hash struct deep" {	...	@@ -278,7 +278,7 @@ test "hash struct deep" {
278	}	278	}
279	};	279	};
280		280
281	const allocator = std.heap.page_allocator;	281	const allocator = std.testing.allocator;
282	const foo = try Foo.init(allocator, 123, 1.0, true);	282	const foo = try Foo.init(allocator, 123, 1.0, true);
283	const bar = try Foo.init(allocator, 123, 1.0, true);	283	const bar = try Foo.init(allocator, 123, 1.0, true);
284	const baz = try Foo.init(allocator, 123, 1.0, false);	284	const baz = try Foo.init(allocator, 123, 1.0, false);

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

...	@@ -2773,7 +2773,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {	...	@@ -2773,7 +2773,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
2773	const needed_alloc_count = x: {	2773	const needed_alloc_count = x: {
2774	// Try it once with unlimited memory, make sure it works	2774	// Try it once with unlimited memory, make sure it works
2775	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);	2775	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
2776	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, maxInt(usize));	2776	var failing_allocator = std.testing.FailingAllocator.init(&fixed_allocator.allocator, maxInt(usize));
2777	var anything_changed: bool = undefined;	2777	var anything_changed: bool = undefined;
2778	const result_source = try testParse(source, &failing_allocator.allocator, &anything_changed);	2778	const result_source = try testParse(source, &failing_allocator.allocator, &anything_changed);
2779	if (!mem.eql(u8, result_source, expected_source)) {	2779	if (!mem.eql(u8, result_source, expected_source)) {
...	@@ -2797,7 +2797,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {	...	@@ -2797,7 +2797,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
2797	var fail_index: usize = 0;	2797	var fail_index: usize = 0;
2798	while (fail_index < needed_alloc_count) : (fail_index += 1) {	2798	while (fail_index < needed_alloc_count) : (fail_index += 1) {
2799	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);	2799	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
2800	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);	2800	var failing_allocator = std.testing.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
2801	var anything_changed: bool = undefined;	2801	var anything_changed: bool = undefined;
2802	if (testParse(source, &failing_allocator.allocator, &anything_changed)) \|_\| {	2802	if (testParse(source, &failing_allocator.allocator, &anything_changed)) \|_\| {
2803	return error.NondeterministicMemoryUsage;	2803	return error.NondeterministicMemoryUsage;

Merge pull request #4324 from fengb/testing-allocator