diff --git a/lib/std/buf_map.zig b/lib/std/buf_map.zig
index 06f00608bb..df90025bae 100644
--- a/lib/std/buf_map.zig
+++ b/lib/std/buf_map.zig
@@ -83,6 +83,7 @@ pub const BufMap = struct {
 };
 
 test "BufMap" {
+    // TODO: uncomment and fix the leak
     var bufmap = BufMap.init(std.heap.page_allocator);
     defer bufmap.deinit();
 
diff --git a/lib/std/buf_set.zig b/lib/std/buf_set.zig
index 7ac8136e7d..89df0478ff 100644
--- a/lib/std/buf_set.zig
+++ b/lib/std/buf_set.zig
@@ -65,7 +65,7 @@ pub const BufSet = struct {
 };
 
 test "BufSet" {
-    var bufset = BufSet.init(std.heap.page_allocator);
+    var bufset = BufSet.init(std.testing.allocator);
     defer bufset.deinit();
 
     try bufset.put("x");
diff --git a/lib/std/build.zig b/lib/std/build.zig
index d310f53c06..40dd4a3484 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -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;
 }
 
diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index e60a1c1055..adde71875e 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -234,8 +234,8 @@ test "hash pointer" {
 test "hash slice shallow" {
     // Allocate one array dynamically so that we're assured it is not merged
     // with the other by the optimization passes.
-    const array1 = try std.heap.page_allocator.create([6]u32);
-    defer std.heap.page_allocator.destroy(array1);
+    const array1 = try std.testing.allocator.create([6]u32);
+    defer std.testing.allocator.destroy(array1);
     array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };
     const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };
     const a = array1[0..];
@@ -250,8 +250,8 @@ test "hash slice shallow" {
 test "hash slice deep" {
     // Allocate one array dynamically so that we're assured it is not merged
     // with the other by the optimization passes.
-    const array1 = try std.heap.page_allocator.create([6]u32);
-    defer std.heap.page_allocator.destroy(array1);
+    const array1 = try std.testing.allocator.create([6]u32);
+    defer std.testing.allocator.destroy(array1);
     array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };
     const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };
     const a = array1[0..];
@@ -278,7 +278,7 @@ test "hash struct deep" {
         }
     };
 
-    const allocator = std.heap.page_allocator;
+    const allocator = std.testing.allocator;
     const foo = try Foo.init(allocator, 123, 1.0, true);
     const bar = try Foo.init(allocator, 123, 1.0, true);
     const baz = try Foo.init(allocator, 123, 1.0, false);
diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index 57a2f58b92..80ca218df6 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -419,7 +419,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
 }
 
 test "basic hash map usage" {
-    var map = AutoHashMap(i32, i32).init(std.heap.page_allocator);
+    var map = AutoHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
     testing.expect((try map.put(1, 11)) == null);
@@ -463,7 +463,7 @@ test "basic hash map usage" {
 }
 
 test "iterator hash map" {
-    var reset_map = AutoHashMap(i32, i32).init(std.heap.page_allocator);
+    var reset_map = AutoHashMap(i32, i32).init(std.testing.allocator);
     defer reset_map.deinit();
 
     try reset_map.putNoClobber(1, 11);
@@ -509,7 +509,7 @@ test "iterator hash map" {
 }
 
 test "ensure capacity" {
-    var map = AutoHashMap(i32, i32).init(std.heap.page_allocator);
+    var map = AutoHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
     try map.ensureCapacity(20);
diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig
index 0d3be9e7e4..a872c03fde 100644
--- a/lib/std/os/test.zig
+++ b/lib/std/os/test.zig
@@ -235,8 +235,8 @@ test "pipe" {
 }
 
 test "argsAlloc" {
-    var args = try std.process.argsAlloc(std.heap.page_allocator);
-    std.process.argsFree(std.heap.page_allocator, args);
+    var args = try std.process.argsAlloc(std.testing.allocator);
+    std.process.argsFree(std.testing.allocator, args);
 }
 
 test "memfd_create" {
diff --git a/lib/std/packed_int_array.zig b/lib/std/packed_int_array.zig
index bc29e985b5..3dfa55e74b 100644
--- a/lib/std/packed_int_array.zig
+++ b/lib/std/packed_int_array.zig
@@ -604,7 +604,7 @@ test "PackedIntArray at end of available memory" {
         p: PackedArray,
     };
 
-    const allocator = std.heap.page_allocator;
+    const allocator = std.testing.allocator;
 
     var pad = try allocator.create(Padded);
     defer allocator.destroy(pad);
@@ -618,7 +618,7 @@ test "PackedIntSlice at end of available memory" {
     }
     const PackedSlice = PackedIntSlice(u11);
 
-    const allocator = std.heap.page_allocator;
+    const allocator = std.testing.allocator;
 
     var page = try allocator.alloc(u8, std.mem.page_size);
     defer allocator.free(page);
diff --git a/lib/std/segmented_list.zig b/lib/std/segmented_list.zig
index 80e4666b6a..d7d137175c 100644
--- a/lib/std/segmented_list.zig
+++ b/lib/std/segmented_list.zig
@@ -339,7 +339,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
 }
 
 test "std.SegmentedList" {
-    var a = std.heap.page_allocator;
+    var a = std.testing.allocator;
 
     try testSegmentedList(0, a);
     try testSegmentedList(1, a);
diff --git a/src-self-hosted/c_tokenizer.zig b/src-self-hosted/c_tokenizer.zig
index 7cff969c35..7e085bcf78 100644
--- a/src-self-hosted/c_tokenizer.zig
+++ b/src-self-hosted/c_tokenizer.zig
@@ -866,7 +866,7 @@ fn expectTokens(tl: *TokenList, src: [*:0]const u8, expected: []CToken) void {
 }
 
 test "tokenize macro" {
-    var tl = TokenList.init(std.heap.page_allocator);
+    var tl = TokenList.init(std.testing.allocator);
     defer tl.deinit();
 
     expectTokens(&tl, "TEST(0\n", &[_]CToken{
@@ -904,7 +904,7 @@ test "tokenize macro" {
 }
 
 test "tokenize macro ops" {
-    var tl = TokenList.init(std.heap.page_allocator);
+    var tl = TokenList.init(std.testing.allocator);
     defer tl.deinit();
 
     expectTokens(&tl, "ADD A + B", &[_]CToken{
diff --git a/test/stage1/behavior/async_fn.zig b/test/stage1/behavior/async_fn.zig
index 1b21ba7eff..c7ea183b6f 100644
--- a/test/stage1/behavior/async_fn.zig
+++ b/test/stage1/behavior/async_fn.zig
@@ -410,8 +410,8 @@ test "heap allocated async function frame" {
         var x: i32 = 42;
 
         fn doTheTest() !void {
-            const frame = try std.heap.page_allocator.create(@Frame(someFunc));
-            defer std.heap.page_allocator.destroy(frame);
+            const frame = try std.testing.allocator.create(@Frame(someFunc));
+            defer std.testing.allocator.destroy(frame);
 
             expect(x == 42);
             frame.* = async someFunc();
@@ -671,7 +671,7 @@ fn testAsyncAwaitTypicalUsage(
         }
 
         fn amain() !void {
-            const allocator = std.heap.page_allocator; // TODO once we have the debug allocator, use that, so that this can detect leaks
+            const allocator = std.testing.allocator;
             var download_frame = async fetchUrl(allocator, "https://example.com/");
             var download_awaited = false;
             errdefer if (!download_awaited) {