Commit b077f3ab7d

Benjamin Feng <benjamin.feng@glassdoor.com>
2020-01-30 04:22:01
Promoted "leak_count_allocator" to the main testing.allocator
master
1 parent 70ad84c
Changed files (23)
doc
docgen.zig
lib
std
fs
path.zig
os
test.zig
special
test_runner.zig
testing
leak_count_allocator.zig
zig
ast.zig
array_list.zig
buffer.zig
debug.zig
fifo.zig
fmt.zig
linked_list.zig
priority_queue.zig
process.zig
testing.zig
unicode.zig
test
stage1
behavior
const_slice_child.zig
standalone
brace_expansion
main.zig
cat
main.zig
empty_env
main.zig
load_dynamic_library
main.zig
compare_output.zig
compile_errors.zig
doc/docgen.zig
@@ -672,8 +672,8 @@ const TermState = enum {
 
 test "term color" {
     const input_bytes = "A\x1b[32;1mgreen\x1b[0mB";
-    const result = try termColor(std.testing.leak_count_allocator, input_bytes);
-    defer std.testing.leak_count_allocator.free(result);
+    const result = try termColor(std.testing.allocator, input_bytes);
+    defer std.testing.allocator.free(result);
     testing.expectEqualSlices(u8, "A<span class=\"t32\">green</span>B", result);
 }
lib/std/fs/path.zig
@@ -665,8 +665,8 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
 }
 
 test "resolve" {
-    const cwd = try process.getCwdAlloc(testing.leak_count_allocator);
-    defer testing.leak_count_allocator.free(cwd);
+    const cwd = try process.getCwdAlloc(testing.allocator);
+    defer testing.allocator.free(cwd);
     if (builtin.os == .windows) {
         if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
             cwd[0] = asciiUpper(cwd[0]);
@@ -684,26 +684,26 @@ test "resolveWindows" {
         return error.SkipZigTest;
     }
     if (builtin.os == .windows) {
-        const cwd = try process.getCwdAlloc(testing.leak_count_allocator);
-        defer testing.leak_count_allocator.free(cwd);
+        const cwd = try process.getCwdAlloc(testing.allocator);
+        defer testing.allocator.free(cwd);
         const parsed_cwd = windowsParsePath(cwd);
         {
-            const expected = try join(testing.leak_count_allocator, &[_][]const u8{
+            const expected = try join(testing.allocator, &[_][]const u8{
                 parsed_cwd.disk_designator,
                 "usr\\local\\lib\\zig\\std\\array_list.zig",
             });
-            defer testing.leak_count_allocator.free(expected);
+            defer testing.allocator.free(expected);
             if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
                 expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
             }
             try testResolveWindows(&[_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" }, expected);
         }
         {
-            const expected = try join(testing.leak_count_allocator, &[_][]const u8{
+            const expected = try join(testing.allocator, &[_][]const u8{
                 cwd,
                 "usr\\local\\lib\\zig",
             });
-            defer testing.leak_count_allocator.free(expected);
+            defer testing.allocator.free(expected);
             if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
                 expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
             }
@@ -740,14 +740,14 @@ test "resolvePosix" {
 }
 
 fn testResolveWindows(paths: []const []const u8, expected: []const u8) !void {
-    const actual = try resolveWindows(testing.leak_count_allocator, paths);
-    defer testing.leak_count_allocator.free(actual);
+    const actual = try resolveWindows(testing.allocator, paths);
+    defer testing.allocator.free(actual);
     return testing.expect(mem.eql(u8, actual, expected));
 }
 
 fn testResolvePosix(paths: []const []const u8, expected: []const u8) !void {
-    const actual = try resolvePosix(testing.leak_count_allocator, paths);
-    defer testing.leak_count_allocator.free(actual);
+    const actual = try resolvePosix(testing.allocator, paths);
+    defer testing.allocator.free(actual);
     return testing.expect(mem.eql(u8, actual, expected));
 }
 
@@ -1172,13 +1172,13 @@ test "relative" {
 }
 
 fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) !void {
-    const result = try relativePosix(testing.leak_count_allocator, from, to);
-    defer testing.leak_count_allocator.free(result);
+    const result = try relativePosix(testing.allocator, from, to);
+    defer testing.allocator.free(result);
     testing.expectEqualSlices(u8, expected_output, result);
 }
 
 fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) !void {
-    const result = try relativeWindows(testing.leak_count_allocator, from, to);
-    defer testing.leak_count_allocator.free(result);
+    const result = try relativeWindows(testing.allocator, from, to);
+    defer testing.allocator.free(result);
     testing.expectEqualSlices(u8, expected_output, result);
 }
lib/std/os/test.zig
@@ -9,7 +9,7 @@ const elf = std.elf;
 const File = std.fs.File;
 const Thread = std.Thread;
 
-const a = std.testing.leak_count_allocator;
+const a = std.testing.allocator;
 
 const builtin = @import("builtin");
 const AtomicRmwOp = builtin.AtomicRmwOp;
lib/std/special/test_runner.zig
@@ -13,10 +13,11 @@ pub fn main() anyerror!void {
     };
 
     for (test_fn_list) |test_fn, i| {
-        std.testing.allocator_instance.reset();
+        std.testing.base_allocator_instance.reset();
         defer {
-            std.testing.leak_count_allocator_instance.validate() catch |err| {
-                @panic(@errorName(err));
+            std.testing.allocator_instance.validate() catch |err| switch (err) {
+                error.Leak => std.debug.panic("", .{}),
+                else => std.debug.panic("error.{}", .{@errorName(err)}),
             };
         }
lib/std/testing/leak_count_allocator.zig
@@ -39,7 +39,7 @@ pub const LeakCountAllocator = struct {
 
     pub fn validate(self: LeakCountAllocator) !void {
         if (self.count > 0) {
-            std.debug.warn("Detected leaked allocations without matching free: {}\n", .{self.count});
+            std.debug.warn("error - detected leaked allocations without matching free: {}\n", .{self.count});
             return error.Leak;
         }
     }
lib/std/zig/ast.zig
@@ -2287,7 +2287,7 @@ pub const Node = struct {
 test "iterate" {
     var root = Node.Root{
         .base = Node{ .id = Node.Id.Root },
-        .decls = Node.Root.DeclList.init(std.testing.leak_count_allocator),
+        .decls = Node.Root.DeclList.init(std.testing.allocator),
         .eof_token = 0,
     };
     var base = &root.base;
lib/std/array_list.zig
@@ -320,7 +320,7 @@ test "std.ArrayList.basic" {
 }
 
 test "std.ArrayList.orderedRemove" {
-    var list = ArrayList(i32).init(testing.leak_count_allocator);
+    var list = ArrayList(i32).init(testing.allocator);
     defer list.deinit();
 
     try list.append(1);
@@ -347,7 +347,7 @@ test "std.ArrayList.orderedRemove" {
 }
 
 test "std.ArrayList.swapRemove" {
-    var list = ArrayList(i32).init(testing.leak_count_allocator);
+    var list = ArrayList(i32).init(testing.allocator);
     defer list.deinit();
 
     try list.append(1);
@@ -374,7 +374,7 @@ test "std.ArrayList.swapRemove" {
 }
 
 test "std.ArrayList.swapRemoveOrError" {
-    var list = ArrayList(i32).init(testing.leak_count_allocator);
+    var list = ArrayList(i32).init(testing.allocator);
     defer list.deinit();
 
     // Test just after initialization
@@ -402,7 +402,7 @@ test "std.ArrayList.swapRemoveOrError" {
 }
 
 test "std.ArrayList.insert" {
-    var list = ArrayList(i32).init(testing.leak_count_allocator);
+    var list = ArrayList(i32).init(testing.allocator);
     defer list.deinit();
 
     try list.append(1);
@@ -416,7 +416,7 @@ test "std.ArrayList.insert" {
 }
 
 test "std.ArrayList.insertSlice" {
-    var list = ArrayList(i32).init(testing.leak_count_allocator);
+    var list = ArrayList(i32).init(testing.allocator);
     defer list.deinit();
 
     try list.append(1);
@@ -443,8 +443,8 @@ const Item = struct {
 };
 
 test "std.ArrayList: ArrayList(T) of struct T" {
-    var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(testing.leak_count_allocator) };
+    var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(testing.allocator) };
     defer root.sub_items.deinit();
-    try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(testing.leak_count_allocator) });
+    try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(testing.allocator) });
     testing.expect(root.sub_items.items[0].integer == 42);
 }
lib/std/buffer.zig
@@ -150,7 +150,7 @@ pub const Buffer = struct {
 };
 
 test "simple Buffer" {
-    var buf = try Buffer.init(testing.leak_count_allocator, "");
+    var buf = try Buffer.init(testing.allocator, "");
     defer buf.deinit();
 
     testing.expect(buf.len() == 0);
@@ -172,7 +172,7 @@ test "simple Buffer" {
 }
 
 test "Buffer.initSize" {
-    var buf = try Buffer.initSize(testing.leak_count_allocator, 3);
+    var buf = try Buffer.initSize(testing.allocator, 3);
     defer buf.deinit();
     testing.expect(buf.len() == 3);
     try buf.append("hello");
@@ -180,7 +180,7 @@ test "Buffer.initSize" {
 }
 
 test "Buffer.initCapacity" {
-    var buf = try Buffer.initCapacity(testing.leak_count_allocator, 10);
+    var buf = try Buffer.initCapacity(testing.allocator, 10);
     defer buf.deinit();
     testing.expect(buf.len() == 0);
     testing.expect(buf.capacity() >= 10);
lib/std/debug.zig
@@ -19,7 +19,7 @@ const windows = std.os.windows;
 
 pub const leb = @import("debug/leb128.zig");
 
-pub const global_allocator = @compileError("Please switch to std.testing.leak_count_allocator.");
+pub const global_allocator = @compileError("Please switch to std.testing.allocator.");
 pub const failing_allocator = @compileError("Please switch to std.testing.failing_allocator.");
 
 pub const runtime_safety = switch (builtin.mode) {
lib/std/fifo.zig
@@ -347,7 +347,7 @@ pub fn LinearFifo(
 }
 
 test "LinearFifo(u8, .Dynamic)" {
-    var fifo = LinearFifo(u8, .Dynamic).init(testing.leak_count_allocator);
+    var fifo = LinearFifo(u8, .Dynamic).init(testing.allocator);
     defer fifo.deinit();
 
     try fifo.write("HELLO");
@@ -422,7 +422,7 @@ test "LinearFifo" {
             var fifo = switch (bt) {
                 .Static => FifoType.init(),
                 .Slice => FifoType.init(buf[0..]),
-                .Dynamic => FifoType.init(testing.leak_count_allocator),
+                .Dynamic => FifoType.init(testing.allocator),
             };
             defer fifo.deinit();
lib/std/fmt.zig
@@ -1598,7 +1598,7 @@ test "hexToBytes" {
 test "formatIntValue with comptime_int" {
     const value: comptime_int = 123456789123456789;
 
-    var buf = try std.Buffer.init(std.testing.leak_count_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"));
@@ -1653,22 +1653,22 @@ test "formatType max_depth" {
     inst.a = &inst;
     inst.tu.ptr = &inst.tu;
 
-    var buf0 = try std.Buffer.init(std.testing.leak_count_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.testing.leak_count_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.testing.leak_count_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.testing.leak_count_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/linked_list.zig
@@ -143,7 +143,7 @@ pub fn SinglyLinkedList(comptime T: type) type {
 }
 
 test "basic SinglyLinkedList test" {
-    const allocator = testing.leak_count_allocator;
+    const allocator = testing.allocator;
     var list = SinglyLinkedList(u32).init();
 
     var one = try list.createNode(1, allocator);
@@ -404,7 +404,7 @@ pub fn TailQueue(comptime T: type) type {
 }
 
 test "basic TailQueue test" {
-    const allocator = testing.leak_count_allocator;
+    const allocator = testing.allocator;
     var list = TailQueue(u32).init();
 
     var one = try list.createNode(1, allocator);
@@ -456,7 +456,7 @@ test "basic TailQueue test" {
 }
 
 test "TailQueue concatenation" {
-    const allocator = testing.leak_count_allocator;
+    const allocator = testing.allocator;
     var list1 = TailQueue(u32).init();
     var list2 = TailQueue(u32).init();
lib/std/priority_queue.zig
@@ -239,7 +239,7 @@ fn greaterThan(a: u32, b: u32) bool {
 const PQ = PriorityQueue(u32);
 
 test "std.PriorityQueue: add and remove min heap" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     try queue.add(54);
@@ -257,7 +257,7 @@ test "std.PriorityQueue: add and remove min heap" {
 }
 
 test "std.PriorityQueue: add and remove same min heap" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     try queue.add(1);
@@ -275,14 +275,14 @@ test "std.PriorityQueue: add and remove same min heap" {
 }
 
 test "std.PriorityQueue: removeOrNull on empty" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     expect(queue.removeOrNull() == null);
 }
 
 test "std.PriorityQueue: edge case 3 elements" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     try queue.add(9);
@@ -294,7 +294,7 @@ test "std.PriorityQueue: edge case 3 elements" {
 }
 
 test "std.PriorityQueue: peek" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     expect(queue.peek() == null);
@@ -306,7 +306,7 @@ test "std.PriorityQueue: peek" {
 }
 
 test "std.PriorityQueue: sift up with odd indices" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     for (items) |e| {
@@ -320,7 +320,7 @@ test "std.PriorityQueue: sift up with odd indices" {
 }
 
 test "std.PriorityQueue: addSlice" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     try queue.addSlice(items[0..]);
@@ -333,8 +333,8 @@ test "std.PriorityQueue: addSlice" {
 
 test "std.PriorityQueue: fromOwnedSlice" {
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
-    const heap_items = try std.mem.dupe(testing.leak_count_allocator, u32, items[0..]);
-    var queue = PQ.fromOwnedSlice(testing.leak_count_allocator, lessThan, heap_items[0..]);
+    const heap_items = try std.mem.dupe(testing.allocator, u32, items[0..]);
+    var queue = PQ.fromOwnedSlice(testing.allocator, lessThan, heap_items[0..]);
     defer queue.deinit();
 
     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" {
 }
 
 test "std.PriorityQueue: add and remove max heap" {
-    var queue = PQ.init(testing.leak_count_allocator, greaterThan);
+    var queue = PQ.init(testing.allocator, greaterThan);
     defer queue.deinit();
 
     try queue.add(54);
@@ -362,7 +362,7 @@ test "std.PriorityQueue: add and remove max heap" {
 }
 
 test "std.PriorityQueue: add and remove same max heap" {
-    var queue = PQ.init(testing.leak_count_allocator, greaterThan);
+    var queue = PQ.init(testing.allocator, greaterThan);
     defer queue.deinit();
 
     try queue.add(1);
@@ -380,8 +380,8 @@ test "std.PriorityQueue: add and remove same max heap" {
 }
 
 test "std.PriorityQueue: iterator" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
-    var map = std.AutoHashMap(u32, void).init(testing.leak_count_allocator);
+    var queue = PQ.init(testing.allocator, lessThan);
+    var map = std.AutoHashMap(u32, void).init(testing.allocator);
     defer {
         queue.deinit();
         map.deinit();
@@ -402,7 +402,7 @@ test "std.PriorityQueue: iterator" {
 }
 
 test "std.PriorityQueue: remove at index" {
-    var queue = PQ.init(testing.leak_count_allocator, lessThan);
+    var queue = PQ.init(testing.allocator, lessThan);
     defer queue.deinit();
 
     try queue.add(3);
lib/std/process.zig
@@ -114,7 +114,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
 }
 
 test "os.getEnvMap" {
-    var env = try getEnvMap(std.testing.leak_count_allocator);
+    var env = try getEnvMap(std.testing.allocator);
     defer env.deinit();
 }
 
@@ -165,7 +165,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
 }
 
 test "os.getEnvVarOwned" {
-    var ga = std.testing.leak_count_allocator;
+    var ga = std.testing.allocator;
     testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));
 }
 
@@ -492,11 +492,11 @@ test "windows arg parsing" {
 fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {
     var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
     for (expected_args) |expected_arg| {
-        const arg = it.next(std.testing.leak_count_allocator).? catch unreachable;
-        defer std.testing.leak_count_allocator.free(arg);
+        const arg = it.next(std.testing.allocator).? catch unreachable;
+        defer std.testing.allocator.free(arg);
         testing.expectEqualSlices(u8, expected_arg, arg);
     }
-    testing.expect(it.next(std.testing.leak_count_allocator) == null);
+    testing.expect(it.next(std.testing.allocator) == null);
 }
 
 pub const UserInfo = struct {
lib/std/testing.zig
@@ -2,17 +2,17 @@ const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
 const std = @import("std.zig");
 
+pub const LeakCountAllocator = @import("testing/leak_count_allocator.zig").LeakCountAllocator;
+pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
+
 /// This should only be used in temporary test programs.
 pub const allocator = &allocator_instance.allocator;
-pub var allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
-var allocator_mem: [100 * 1024]u8 = undefined;
+pub var allocator_instance = LeakCountAllocator.init(&base_allocator_instance.allocator);
 
-pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
-pub const failing_allocator = &FailingAllocator.init(allocator, 0).allocator;
+pub const failing_allocator = &FailingAllocator.init(&base_allocator_instance.allocator, 0).allocator;
 
-pub const LeakCountAllocator = @import("testing/leak_count_allocator.zig").LeakCountAllocator;
-pub var leak_count_allocator_instance = LeakCountAllocator.init(allocator);
-pub const leak_count_allocator = &leak_count_allocator_instance.allocator;
+pub var base_allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
+var allocator_mem: [100 * 1024]u8 = undefined;
 
 /// This function is intended to be used only in tests. It prints diagnostics to stderr
 /// and then aborts when actual_error_union is not expected_error.
lib/std/unicode.zig
@@ -501,16 +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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        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"));
     }
 
@@ -518,8 +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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        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"));
     }
 
@@ -527,8 +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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80"));
     }
 
@@ -536,16 +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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        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.testing.leak_count_allocator, &utf16le);
-        defer std.testing.leak_count_allocator.free(utf8);
+        const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
+        defer std.testing.allocator.free(utf8);
         testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80"));
     }
 }
test/stage1/behavior/const_slice_child.zig
@@ -23,8 +23,8 @@ fn foo(args: [][]const u8) void {
 }
 
 fn bar(argc: usize) void {
-    const args = testing.leak_count_allocator.alloc([]const u8, argc) catch unreachable;
-    defer testing.leak_count_allocator.free(args);
+    const args = testing.allocator.alloc([]const u8, argc) catch unreachable;
+    defer testing.allocator.free(args);
     for (args) |_, i| {
         const ptr = argv[i];
         args[i] = ptr[0..strlen(ptr)];
test/standalone/brace_expansion/main.zig
@@ -201,7 +201,7 @@ pub fn main() !void {
 }
 
 test "invalid inputs" {
-    global_allocator = std.testing.leak_count_allocator;
+    global_allocator = std.testing.allocator;
 
     expectError("}ABC", error.InvalidInput);
     expectError("{ABC", error.InvalidInput);
@@ -222,7 +222,7 @@ fn expectError(test_input: []const u8, expected_err: anyerror) void {
 }
 
 test "valid inputs" {
-    global_allocator = std.testing.leak_count_allocator;
+    global_allocator = std.testing.allocator;
 
     expectExpansion("{x,y,z}", "x y z");
     expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
test/standalone/cat/main.zig
@@ -4,7 +4,7 @@ const process = std.process;
 const fs = std.fs;
 const mem = std.mem;
 const warn = std.debug.warn;
-const allocator = std.testing.leak_count_allocator;
+const allocator = std.testing.allocator;
 
 pub fn main() !void {
     var args_it = process.args();
test/standalone/empty_env/main.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
 pub fn main() void {
-    const env_map = std.process.getEnvMap(std.testing.leak_count_allocator) catch @panic("unable to get env map");
+    const env_map = std.process.getEnvMap(std.testing.allocator) catch @panic("unable to get env map");
     std.testing.expect(env_map.count() == 0);
 }
test/standalone/load_dynamic_library/main.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
 pub fn main() !void {
-    const args = try std.process.argsAlloc(std.testing.leak_count_allocator);
-    defer std.process.argsFree(std.testing.leak_count_allocator, args);
+    const args = try std.process.argsAlloc(std.testing.allocator);
+    defer std.process.argsFree(std.testing.allocator, args);
 
     const dynlib_name = args[1];
test/compare_output.zig
@@ -445,7 +445,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
             \\const std = @import("std");
             \\const io = std.io;
             \\const os = std.os;
-            \\const allocator = std.testing.leak_count_allocator;
+            \\const allocator = std.testing.allocator;
             \\
             \\pub fn main() !void {
             \\    var args_it = std.process.args();
@@ -486,7 +486,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
             \\const std = @import("std");
             \\const io = std.io;
             \\const os = std.os;
-            \\const allocator = std.testing.leak_count_allocator;
+            \\const allocator = std.testing.allocator;
             \\
             \\pub fn main() !void {
             \\    var args_it = std.process.args();
test/compile_errors.zig
@@ -5765,7 +5765,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() void {
         \\    const a = MdNode.Header {
-        \\        .text = MdText.init(&std.testing.leak_count_allocator),
+        \\        .text = MdText.init(&std.testing.allocator),
         \\        .weight = HeaderWeight.H1,
         \\    };
         \\}