Commit 1a8ed9a6580453e6aa8133d716692e7bad34be14 | zig

author	Techatrix <techatrix@mailbox.org> 2026-03-10 17:28:04+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-03-11 02:32:29+01:00
log	1a8ed9a6580453e6aa8133d716692e7bad34be14
tree	6dd5263953c82b424478924386708d738147b913
parent	acde20a14804dd3c6dcc7940cdf49af240c74f58

checkAllAllocationFailures: provide result type to 'extra_args'

1 files changed, 55 insertions(+), 40 deletions(-)

lib
- std
  - testing.zig

lib/std/testing.zig+55-40

 @@ -1112,48 +1112,16 @@ test {
 ///     defer allocator.free(bar);
 /// }
 /// ```
-pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime test_fn: anytype, extra_args: anytype) !void {
+pub fn checkAllAllocationFailures(
-    switch (@typeInfo(@typeInfo(@TypeOf(test_fn)).@"fn".return_type.?)) {
+    backing_allocator: std.mem.Allocator,
-        .error_union => |info| {
+    comptime test_fn: anytype,
-            if (info.payload != void) {
+    extra_args: CheckAllAllocationFailuresExtraArgs(@TypeOf(test_fn)),
-                @compileError("Return type must be !void");
+) !void {
-            }
-        },
-        else => @compileError("Return type must be !void"),
-    }
-    if (@typeInfo(@TypeOf(extra_args)) != .@"struct") {
-        @compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(extra_args)));
-    }
-    const ArgsTuple = std.meta.ArgsTuple(@TypeOf(test_fn));
-    const fn_args_fields = @typeInfo(ArgsTuple).@"struct".fields;
-    if (fn_args_fields.len == 0 or fn_args_fields[0].type != std.mem.Allocator) {
-        @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
-    }
-    const expected_args_tuple_len = fn_args_fields.len - 1;
-    if (extra_args.len != expected_args_tuple_len) {
-        @compileError("The provided function expects " ++ std.fmt.comptimePrint("{d}", .{expected_args_tuple_len}) ++ " extra arguments, but the provided tuple contains " ++ std.fmt.comptimePrint("{d}", .{extra_args.len}));
-    }
-    // Setup the tuple that will actually be used with @call (we'll need to insert
-    // the failing allocator in field @"0" before each @call)
-    var args: ArgsTuple = undefined;
-    inline for (@typeInfo(@TypeOf(extra_args)).@"struct".fields, 0..) |field, i| {
-        const arg_i_str = comptime str: {
-            var str_buf: [100]u8 = undefined;
-            const args_i = i + 1;
-            const str_len = std.fmt.printInt(&str_buf, args_i, 10, .lower, .{});
-            break :str str_buf[0..str_len];
-        };
-        @field(args, arg_i_str) = @field(extra_args, field.name);
-    }
     // Try it once with unlimited memory, make sure it works
     const needed_alloc_count = x: {
         var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{});
-        args.@"0" = failing_allocator_inst.allocator();
-        try @call(.auto, test_fn, args);
+        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);
         break :x failing_allocator_inst.alloc_index;
     };
 @@ -1161,9 +1129,8 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime
         var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{
             .fail_index = fail_index,
         });
-        args.@"0" = failing_allocator_inst.allocator();
-        if (@call(.auto, test_fn, args)) |_| {
+        if (@call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args)) |_| {
             if (failing_allocator_inst.has_induced_failure) {
                 return error.SwallowedOutOfMemoryError;
             } else {
 @@ -1194,6 +1161,54 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime
     }
 }
+fn CheckAllAllocationFailuresExtraArgs(comptime TestFn: type) type {
+    switch (@typeInfo(@typeInfo(TestFn).@"fn".return_type.?)) {
+        .error_union => |info| {
+            if (info.payload != void) {
+                @compileError("Return type must be !void");
+            }
+        },
+        else => @compileError("Return type must be !void"),
+    }
+    const ArgsTuple = std.meta.ArgsTuple(TestFn);
+    const fields = @typeInfo(ArgsTuple).@"struct".fields;
+    if (fields.len == 0 or fields[0].type != std.mem.Allocator) {
+        @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
+    }
+    var extra_args: [fields.len - 1]type = undefined;
+    for (&extra_args, fields[1..]) |*arg, field| {
+        arg.* = field.type;
+    }
+    return @Tuple(&extra_args);
+}
+test "checkAllAllocationFailures provide result type to 'extra_args' argument" {
+    try checkAllAllocationFailures(
+        std.testing.allocator,
+        struct {
+            fn f(ally: std.mem.Allocator, params: struct {
+                foo_len: u32,
+                bar_len: u32,
+            }) !void {
+                const foo = try ally.alloc(u8, params.foo_len);
+                defer ally.free(foo);
+                const bar = try ally.alloc(u8, params.bar_len);
+                defer ally.free(bar);
+            }
+        }.f,
+        .{
+            .{
+                .foo_len = 3,
+                .bar_len = 5,
+            },
+        },
+    );
+}
 /// Given a type, references all the declarations inside, so that the semantic analyzer sees them.
 pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;