@zigc/lib 0.16.0 → 0.17.0-dev.131

package/std/crypto/tls/Client.zig

@@ -353,7 +353,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
         if (record_len > tls.max_ciphertext_len) return error.TlsRecordOverflow;
         const record_buffer = input.take(record_len) catch |err| switch (err) {
             error.EndOfStream => return error.TlsConnectionTruncated,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         var record_decoder: tls.Decoder = .fromTheirSlice(record_buffer);
         var ctd, const ct = content: switch (cipher_state) {
@@ -382,7 +382,9 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         P.AEAD.decrypt(cleartext, ciphertext, auth_tag, record_header, nonce, pv.server_handshake_key) catch
                             return error.TlsBadRecordMac;
                         // TODO use scalar, non-slice version
-                        cleartext_fragment_end += mem.trimEnd(u8, cleartext, "\x00").len;
+                        const trimmed_len = mem.trimEnd(u8, cleartext, "\x00").len;
+                        if (trimmed_len == 0) return error.TlsDecodeError;
+                        cleartext_fragment_end += trimmed_len;
                     },
                 }
                 read_seq += 1;
@@ -1155,7 +1157,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                 return failRead(c, error.TlsConnectionTruncated);
             }
         },
-        error.ReadFailed => return error.ReadFailed,
+        error.ReadFailed => |e| return e,
     };
     const ct: tls.ContentType = @enumFromInt(record_header[0]);
     const legacy_version = mem.readInt(u16, record_header[1..][0..2], .big);
@@ -1166,7 +1168,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
     if (record_end > input.buffered().len) {
         input.fillMore() catch |err| switch (err) {
             error.EndOfStream => return failRead(c, error.TlsConnectionTruncated),
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         if (record_end > input.buffered().len) return 0;
     }
@@ -1176,6 +1178,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
             .tls_1_3 => {
                 const pv = &p.tls_1_3;
                 const P = @TypeOf(p.*);
+                if (record_len < P.AEAD.tag_length) return failRead(c, error.TlsRecordOverflow);
                 const ad = input.take(tls.record_header_len) catch unreachable; // already peeked
                 const ciphertext_len = record_len - P.AEAD.tag_length;
                 const ciphertext = input.take(ciphertext_len) catch unreachable; // already peeked
@@ -1192,6 +1195,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                     return failRead(c, error.TlsBadRecordMac);
                 // TODO use scalar, non-slice version
                 const msg = mem.trimEnd(u8, cleartext, "\x00");
+                if (msg.len == 0) return failRead(c, error.TlsDecodeError);
                 break :cleartext .{ msg.len - 1, @enumFromInt(msg[msg.len - 1]) };
             },
             .tls_1_2 => {
@@ -1668,3 +1672,74 @@ else
         .AES_256_GCM_SHA384,
         .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
     });
+
+fn testReadError(input_buf: []const u8, cipher: tls.ApplicationCipher) ReadError {
+    var input_reader: Reader = .fixed(input_buf);
+    var read_buf: [tls.max_ciphertext_record_len]u8 = undefined;
+    var c: Client = .{
+        .input = &input_reader,
+        .reader = .{
+            .buffer = &read_buf,
+            .vtable = &.{ .stream = stream, .readVec = readVec },
+            .seek = 0,
+            .end = 0,
+        },
+        .output = undefined,
+        .writer = undefined,
+        .tls_version = .tls_1_3,
+        .read_seq = 0,
+        .write_seq = 0,
+        .received_close_notify = false,
+        .allow_truncation_attacks = false,
+        .application_cipher = cipher,
+        .ssl_key_log = null,
+    };
+    var w: Writer = .failing;
+    std.testing.expectError(error.ReadFailed, c.reader.stream(&w, .unlimited)) catch
+        @panic("expected ReadFailed");
+    return c.read_err.?;
+}
+
+test "empty inner plaintext" {
+    const AEAD = crypto.aead.chacha_poly.ChaCha20Poly1305;
+    const key: [AEAD.key_length]u8 = @splat(0);
+    const iv: [AEAD.nonce_length]u8 = @splat(0);
+
+    const plaintext = [1]u8{0x00};
+    var ciphertext: [plaintext.len]u8 = undefined;
+    var tag: [AEAD.tag_length]u8 = undefined;
+    const content_len: u16 = plaintext.len + AEAD.tag_length;
+    const record_header = [_]u8{ 0x17, 0x03, 0x03 } ++ mem.toBytes(big(content_len));
+    AEAD.encrypt(&ciphertext, &tag, &plaintext, &record_header, iv, key);
+
+    try std.testing.expectEqual(error.TlsDecodeError, testReadError(
+        &record_header ++ ciphertext ++ tag,
+        .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
+            .server_key = key,
+            .server_iv = iv,
+            .client_secret = undefined,
+            .server_secret = undefined,
+            .client_key = undefined,
+            .client_iv = undefined,
+        } } },
+    ));
+}
+
+test "record shorter than tag" {
+    const AEAD = crypto.aead.chacha_poly.ChaCha20Poly1305;
+    const record_len: u16 = AEAD.tag_length - 1;
+    const header = [_]u8{ 0x17, 0x03, 0x03 } ++ mem.toBytes(big(record_len));
+    const wire = header ++ @as([record_len]u8, @splat(0));
+
+    try std.testing.expectEqual(error.TlsRecordOverflow, testReadError(
+        &wire,
+        .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
+            .server_key = undefined,
+            .server_iv = undefined,
+            .client_secret = undefined,
+            .server_secret = undefined,
+            .client_key = undefined,
+            .client_iv = undefined,
+        } } },
+    ));
+}

package/std/crypto/tls.zig

@@ -666,7 +666,7 @@ pub const Decoder = struct {
         if (request_amt > dest.len) return error.TlsRecordOverflow;
         stream.readSlice(dest[0..request_amt]) catch |err| switch (err) {
             error.EndOfStream => return error.TlsConnectionTruncated,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         d.cap += request_amt;
     }

package/std/crypto.zig

@@ -367,6 +367,7 @@ test {
     _ = ff;
     _ = errors;
     _ = tls;
+    _ = tls.Client;
     _ = Certificate;
     _ = codecs;
 }

package/std/debug/Pdb.zig

@@ -138,7 +138,7 @@ pub fn parseDbiStream(self: *Pdb) !void {
     if (section_contrib_size != 0) {
         const version = reader.takeEnum(pdb.SectionContrSubstreamVersion, .little) catch |err| switch (err) {
             error.InvalidEnumTag, error.EndOfStream => return error.InvalidDebugInfo,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         _ = version;
         sect_cont_offset += @sizeOf(u32);

package/std/debug.zig

@@ -1197,8 +1197,9 @@ fn printSourceAtAddress(
 
     // Initialize the symbol array with space for at least one element, allocating this on the stack
     // in the common case where only one element is needed
-    var symbol_fallback_allocator = std.heap.stackFallback(@sizeOf(Symbol) + @alignOf(Symbol) - 1, getDebugInfoAllocator());
-    const symbol_allocator = symbol_fallback_allocator.get();
+    var buf: [1]Symbol = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&buf), getDebugInfoAllocator());
+    const symbol_allocator = bfa.allocator();
     var symbols = std.ArrayList(Symbol).initCapacity(symbol_allocator, 1) catch unreachable;
     defer symbols.deinit(symbol_allocator);
 
@@ -1576,12 +1577,12 @@ fn handleSegfaultPosix(sig: posix.SIG, info: *const posix.siginfo_t, ctx_ptr: ?*
             .tvos,
             .visionos,
             .watchos,
+            .haiku,
             => @intFromPtr(info.addr),
             .linux,
             => @intFromPtr(info.fields.sigfault.addr),
             .netbsd,
             => @intFromPtr(info.info.reason.fault.addr),
-            .haiku,
             .openbsd,
             => @intFromPtr(info.data.fault.addr),
             .illumos,

package/std/fmt.zig

@@ -542,7 +542,7 @@ pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
     }
     const multiplier = math.powi(usize, magnitude_base, orders_of_magnitude) catch |err| switch (err) {
         error.Underflow => unreachable,
-        error.Overflow => return error.Overflow,
+        error.Overflow => |e| return e,
     };
     const number = try std.fmt.parseInt(usize, without_suffix, digit_base);
     return math.mul(usize, number, multiplier);
@@ -1342,9 +1342,9 @@ pub const hex_charset = "0123456789abcdef";
 
 /// Converts an unsigned integer of any multiple of u8 to an array of lowercase
 /// hex bytes, little endian.
-pub fn hex(x: anytype) [@sizeOf(@TypeOf(x)) * 2]u8 {
+pub fn hex(x: anytype) [@typeInfo(@TypeOf(x)).int.bits / 4]u8 {
     comptime assert(@typeInfo(@TypeOf(x)).int.signedness == .unsigned);
-    var result: [@sizeOf(@TypeOf(x)) * 2]u8 = undefined;
+    var result: [@typeInfo(@TypeOf(x)).int.bits / 4]u8 = undefined;
     var i: usize = 0;
     while (i < result.len / 2) : (i += 1) {
         const byte: u8 = @truncate(x >> @intCast(8 * i));
@@ -1360,6 +1360,11 @@ test hex {
         try std.testing.expect(x.len == 8);
         try std.testing.expectEqualStrings("efbeadde", &x);
     }
+    {
+        const s = "[" ++ hex(@as(u48, 0x12345678_abcd)) ++ "]";
+        try std.testing.expect(s.len == 14);
+        try std.testing.expectEqualStrings("[cdab78563412]", s);
+    }
     {
         const s = "[" ++ hex(@as(u64, 0x12345678_abcdef00)) ++ "]";
         try std.testing.expect(s.len == 18);

package/std/fs/path.zig

@@ -894,8 +894,9 @@ pub fn resolve(allocator: Allocator, paths: []const []const u8) Allocator.Error!
 pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) Allocator.Error![]u8 {
     // Avoid heap allocation when paths.len is <= @bitSizeOf(usize) * 2
     // (we use `* 3` because stackFallback uses 1 usize as a length)
-    var bit_set_allocator_state = std.heap.stackFallback(@sizeOf(usize) * 3, allocator);
-    const bit_set_allocator = bit_set_allocator_state.get();
+    var buf: [3]usize = undefined;
+    var bit_set_allocator_state: std.heap.BufferFirstAllocator = .init(@ptrCast(&buf), allocator);
+    const bit_set_allocator = bit_set_allocator_state.allocator();
     var relevant_paths = try std.bit_set.DynamicBitSetUnmanaged.initEmpty(bit_set_allocator, paths.len);
     defer relevant_paths.deinit(bit_set_allocator);
 
@@ -1642,7 +1643,8 @@ fn windowsResolveAgainstCwd(
     parsed: WindowsPath2(u8),
 ) ![]u8 {
     // Space for 256 WTF-16 code units; potentially 3 WTF-8 bytes per WTF-16 code unit
-    var temp_allocator_state = std.heap.stackFallback(256 * 3, gpa);
+    var buf: [256 * 3]u8 = undefined;
+    var temp_allocator_state: std.heap.BufferFirstAllocator = .init(&buf, gpa);
     return switch (parsed.kind) {
         .drive_absolute,
         .unc_absolute,
@@ -1668,7 +1670,7 @@ fn windowsResolveAgainstCwd(
             }
         },
         .drive_relative => blk: {
-            const temp_allocator = temp_allocator_state.get();
+            const temp_allocator = temp_allocator_state.allocator();
             const drive_cwd = drive_cwd: {
                 const parsed_cwd = parsePathWindows(u8, cwd);
 

package/std/heap/BufferFirstAllocator.zig

@@ -0,0 +1,165 @@
+//! An allocator that attempts to allocate from the given buffer, falling back to
+//! `fallback_allocator` if this fails.
+
+const std = @import("../std.zig");
+const heap = std.heap;
+const testing = std.testing;
+
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const FixedBufferAllocator = std.heap.FixedBufferAllocator;
+
+const BufferFirstAllocator = @This();
+
+fallback_allocator: Allocator,
+fixed_buffer_allocator: FixedBufferAllocator,
+
+pub fn init(buffer: []u8, fallback_allocator: Allocator) BufferFirstAllocator {
+    return .{
+        .fallback_allocator = fallback_allocator,
+        .fixed_buffer_allocator = .init(buffer),
+    };
+}
+
+pub fn allocator(self: *BufferFirstAllocator) Allocator {
+    return .{
+        .ptr = self,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    };
+}
+
+fn alloc(
+    ctx: *anyopaque,
+    len: usize,
+    alignment: Alignment,
+    ra: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
+        return self.fallback_allocator.rawAlloc(len, alignment, ra);
+}
+
+fn resize(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    ra: usize,
+) bool {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
+    } else {
+        return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
+    }
+}
+
+fn remap(
+    context: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(context));
+    if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
+        return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
+    } else {
+        return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
+    }
+}
+
+fn free(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    ra: usize,
+) void {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
+    } else {
+        return self.fallback_allocator.rawFree(buf, alignment, ra);
+    }
+}
+
+test "BufferFirstAllocator" {
+    // Buffer first specific tests
+    {
+        var buffer: [10]u8 = undefined;
+        var bfa_state: BufferFirstAllocator = .init(&buffer, std.testing.allocator);
+        const bfa = bfa_state.allocator();
+
+        // We're under the limit, so we should be allocated in the buffer
+        const txt0 = "hellowrld";
+        const buf0 = try bfa.create(@TypeOf(txt0.*));
+        buf0.* = txt0.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf0.ptr));
+
+        // We're now over the limit, so we should be allocated from the fallback
+        const txt1 = "test!";
+        const buf1 = try bfa.create(@TypeOf(txt1.*));
+        buf1.* = txt1.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf1.ptr));
+
+        // Free the allocation that took up space in the buffer
+        try testing.expectEqualStrings(txt0, buf0);
+        bfa.destroy(buf0);
+
+        // The next allocation would go in the buffer, but it's too big so it doesn't
+        const txt2 = "qwertyqwerty";
+        const buf2 = try bfa.create(@TypeOf(txt2.*));
+        buf2.* = txt2.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf2.ptr));
+
+        // The next allocation is smaller and fits in the buffer
+        const txt3 = "dvorak";
+        const buf3 = try bfa.create(@TypeOf(txt3.*));
+        buf3.* = txt3.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf3.ptr));
+
+        // The remainder in the buffer is too small for the following allocation so it falls back
+        const txt4 = "moretext";
+        const buf4 = try bfa.create(@TypeOf(txt4.*));
+        buf4.* = txt4.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf4.ptr));
+
+        // Check equality on the remaining buffers and free them
+        try testing.expectEqualStrings(txt1, buf1);
+        bfa.destroy(buf1);
+        try testing.expectEqualStrings(txt2, buf2);
+        bfa.destroy(buf2);
+        try testing.expectEqualStrings(txt3, buf3);
+        bfa.destroy(buf3);
+        try testing.expectEqualStrings(txt4, buf4);
+        bfa.destroy(buf4);
+
+        try testing.expectEqual(0, bfa_state.fixed_buffer_allocator.end_index);
+    }
+
+    // Standard allocator tests
+    {
+        var buf: [4096]u8 = undefined;
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocator(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAligned(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorLargeAlignment(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAlignedShrink(bfa.allocator());
+        }
+    }
+}

package/std/heap.zig

@@ -12,6 +12,7 @@ const Alignment = std.mem.Alignment;
 pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
+pub const BufferFirstAllocator = @import("heap/BufferFirstAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
 pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
 pub const BrkAllocator = @import("heap/BrkAllocator.zig");
@@ -367,113 +368,6 @@ pub const brk_allocator: Allocator = .{
     .vtable = &BrkAllocator.vtable,
 };
 
-/// Returns a `StackFallbackAllocator` allocating using either a
-/// `FixedBufferAllocator` on an array of size `size` and falling back to
-/// `fallback_allocator` if that fails.
-pub fn stackFallback(comptime size: usize, fallback_allocator: Allocator) StackFallbackAllocator(size) {
-    return StackFallbackAllocator(size){
-        .buffer = undefined,
-        .fallback_allocator = fallback_allocator,
-        .fixed_buffer_allocator = undefined,
-    };
-}
-
-/// An allocator that attempts to allocate using a
-/// `FixedBufferAllocator` using an array of size `size`. If the
-/// allocation fails, it will fall back to using
-/// `fallback_allocator`. Easily created with `stackFallback`.
-pub fn StackFallbackAllocator(comptime size: usize) type {
-    return struct {
-        const Self = @This();
-
-        buffer: [size]u8,
-        fallback_allocator: Allocator,
-        fixed_buffer_allocator: FixedBufferAllocator,
-        get_called: if (std.debug.runtime_safety) bool else void =
-            if (std.debug.runtime_safety) false else {},
-
-        /// This function both fetches a `Allocator` interface to this
-        /// allocator *and* resets the internal buffer allocator.
-        pub fn get(self: *Self) Allocator {
-            if (std.debug.runtime_safety) {
-                assert(!self.get_called); // `get` called multiple times; instead use `const allocator = stackFallback(N).get();`
-                self.get_called = true;
-            }
-            self.fixed_buffer_allocator = FixedBufferAllocator.init(self.buffer[0..]);
-            return .{
-                .ptr = self,
-                .vtable = &.{
-                    .alloc = alloc,
-                    .resize = resize,
-                    .remap = remap,
-                    .free = free,
-                },
-            };
-        }
-
-        /// Unlike most std allocators `StackFallbackAllocator` modifies
-        /// its internal state before returning an implementation of
-        /// the`Allocator` interface and therefore also doesn't use
-        /// the usual `.allocator()` method.
-        pub const allocator = @compileError("use 'const allocator = stackFallback(N).get();' instead");
-
-        fn alloc(
-            ctx: *anyopaque,
-            len: usize,
-            alignment: Alignment,
-            ra: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
-                return self.fallback_allocator.rawAlloc(len, alignment, ra);
-        }
-
-        fn resize(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            ra: usize,
-        ) bool {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
-            } else {
-                return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
-            }
-        }
-
-        fn remap(
-            context: *anyopaque,
-            memory: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            return_address: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(context));
-            if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
-                return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
-            } else {
-                return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
-            }
-        }
-
-        fn free(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            ra: usize,
-        ) void {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
-            } else {
-                return self.fallback_allocator.rawFree(buf, alignment, ra);
-            }
-        }
-    };
-}
-
 test c_allocator {
     if (builtin.link_libc) {
         try testAllocator(c_allocator);
@@ -524,25 +418,6 @@ test ArenaAllocator {
     try testAllocatorAlignedShrink(allocator);
 }
 
-test "StackFallbackAllocator" {
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocator(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAligned(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorLargeAlignment(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAlignedShrink(stack_allocator.get());
-    }
-}
-
 /// This one should not try alignments that exceed what C malloc can handle.
 pub fn testAllocator(base_allocator: mem.Allocator) !void {
     var validationAllocator = mem.validationWrap(base_allocator);
@@ -1011,6 +886,7 @@ test {
     _ = ArenaAllocator;
     _ = DebugAllocator(.{});
     _ = FixedBufferAllocator;
+    _ = BufferFirstAllocator;
     if (builtin.single_threaded) {
         if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
             _ = brk_allocator;