From cab9da35bd65c81e8efbac3a6c970ce17627e4c7 Mon Sep 17 00:00:00 2001 From: Gregory Anders Date: Mon, 28 Aug 2023 20:25:05 -0500 Subject: [PATCH] std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls. --- lib/std/array_list.zig | 22 +++-------- lib/std/heap/general_purpose_allocator.zig | 2 +- lib/std/heap/memory_pool.zig | 4 +- lib/std/json/scanner_test.zig | 2 +- lib/std/json/static_test.zig | 3 +- lib/std/testing.zig | 8 ++-- lib/std/testing/failing_allocator.zig | 45 ++++++++++++++-------- 7 files changed, 44 insertions(+), 42 deletions(-) diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig index ec38fad50b..a258475517 100644 --- a/lib/std/array_list.zig +++ b/lib/std/array_list.zig @@ -1587,13 +1587,8 @@ test "std.ArrayListUnmanaged(u8) implements writer" { } test "shrink still sets length when resizing is disabled" { - // Use the testing allocator but with resize disabled. - var a = testing.allocator; - a.vtable = &.{ - .alloc = a.vtable.alloc, - .resize = Allocator.noResize, - .free = a.vtable.free, - }; + var failing_allocator = testing.FailingAllocator.init(testing.allocator, .{ .resize_fail_index = 0 }); + const a = failing_allocator.allocator(); { var list = ArrayList(i32).init(a); @@ -1620,13 +1615,9 @@ test "shrink still sets length when resizing is disabled" { } test "shrinkAndFree with a copy" { - // Use the testing allocator but with resize disabled. - var a = testing.allocator; - a.vtable = &.{ - .alloc = a.vtable.alloc, - .resize = Allocator.noResize, - .free = a.vtable.free, - }; + var failing_allocator = testing.FailingAllocator.init(testing.allocator, .{ .resize_fail_index = 0 }); + const a = failing_allocator.allocator(); + var list = ArrayList(i32).init(a); defer list.deinit(); @@ -1748,8 +1739,7 @@ test "ArrayListAligned/ArrayListAlignedUnmanaged accepts unaligned slices" { test "std.ArrayList(u0)" { // An ArrayList on zero-sized types should not need to allocate - var failing_allocator = testing.FailingAllocator.init(testing.allocator, 0); - const a = failing_allocator.allocator(); + const a = testing.failing_allocator; var list = ArrayList(u0).init(a); defer list.deinit(); diff --git a/lib/std/heap/general_purpose_allocator.zig b/lib/std/heap/general_purpose_allocator.zig index ccc4b6a8b2..7bdcf9ca2d 100644 --- a/lib/std/heap/general_purpose_allocator.zig +++ b/lib/std/heap/general_purpose_allocator.zig @@ -1305,7 +1305,7 @@ test "realloc large object to larger alignment" { } test "large object shrinks to small but allocation fails during shrink" { - var failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, 3); + var failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, .{ .fail_index = 3 }); var gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = failing_allocator.allocator() }; defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak"); const allocator = gpa.allocator(); diff --git a/lib/std/heap/memory_pool.zig b/lib/std/heap/memory_pool.zig index b56a15d006..764198d36d 100644 --- a/lib/std/heap/memory_pool.zig +++ b/lib/std/heap/memory_pool.zig @@ -164,8 +164,8 @@ test "memory pool: preheating (success)" { } test "memory pool: preheating (failure)" { - var failer = std.testing.FailingAllocator.init(std.testing.allocator, 0); - try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initPreheated(failer.allocator(), 5)); + var failer = std.testing.failing_allocator; + try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initPreheated(failer, 5)); } test "memory pool: growable" { diff --git a/lib/std/json/scanner_test.zig b/lib/std/json/scanner_test.zig index acc4fc7404..8ab7f5e715 100644 --- a/lib/std/json/scanner_test.zig +++ b/lib/std/json/scanner_test.zig @@ -397,7 +397,7 @@ test "skipValue" { } fn testEnsureStackCapacity(do_ensure: bool) !void { - var fail_alloc = std.testing.FailingAllocator.init(std.testing.allocator, 1); + var fail_alloc = std.testing.FailingAllocator.init(std.testing.allocator, .{ .fail_index = 1 }); const failing_allocator = fail_alloc.allocator(); const nestings = 999; // intentionally not a power of 2. diff --git a/lib/std/json/static_test.zig b/lib/std/json/static_test.zig index bbfdc6c409..82b0d89044 100644 --- a/lib/std/json/static_test.zig +++ b/lib/std/json/static_test.zig @@ -461,8 +461,7 @@ test "parse into tagged union errors" { try testing.expectError(error.UnexpectedToken, parseFromSliceLeaky(T, arena.allocator(), "{\"nothing\":{\"no\":0}}", .{})); // Allocator failure - var fail_alloc = testing.FailingAllocator.init(testing.allocator, 0); - try testing.expectError(error.OutOfMemory, parseFromSlice(T, fail_alloc.allocator(), "{\"string\"\"foo\"}", .{})); + try testing.expectError(error.OutOfMemory, parseFromSlice(T, testing.failing_allocator, "{\"string\"\"foo\"}", .{})); } test "parse into struct with no fields" { diff --git a/lib/std/testing.zig b/lib/std/testing.zig index 40a95a450b..17ac0d4b04 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -14,7 +14,7 @@ pub var allocator_instance = b: { }; pub const failing_allocator = failing_allocator_instance.allocator(); -pub var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.allocator(), 0); +pub var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.allocator(), .{ .fail_index = 0 }); pub var base_allocator_instance = std.heap.FixedBufferAllocator.init(""); @@ -1081,16 +1081,16 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime // 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, std.math.maxInt(usize)); + var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{}); args.@"0" = failing_allocator_inst.allocator(); try @call(.auto, test_fn, args); - break :x failing_allocator_inst.index; + break :x failing_allocator_inst.alloc_index; }; var fail_index: usize = 0; while (fail_index < needed_alloc_count) : (fail_index += 1) { - var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, fail_index); + 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)) |_| { diff --git a/lib/std/testing/failing_allocator.zig b/lib/std/testing/failing_allocator.zig index 313af987ab..3a83f313bf 100644 --- a/lib/std/testing/failing_allocator.zig +++ b/lib/std/testing/failing_allocator.zig @@ -1,19 +1,33 @@ const std = @import("../std.zig"); const mem = std.mem; +pub const Config = struct { + /// The number of successful allocations you can expect from this allocator. + /// The next allocation will fail. For example, with `fail_index` equal to + /// 2, the following test will pass: + /// + /// var a = try failing_alloc.create(i32); + /// var b = try failing_alloc.create(i32); + /// testing.expectError(error.OutOfMemory, failing_alloc.create(i32)); + fail_index: usize = std.math.maxInt(usize), + + /// Number of successful resizes to expect from this allocator. The next resize will fail. + resize_fail_index: usize = std.math.maxInt(usize), +}; + /// Allocator that fails after N allocations, useful for making sure out of /// memory conditions are handled correctly. /// /// To use this, first initialize it and get an allocator with /// /// `const failing_allocator = &FailingAllocator.init(, -/// ).allocator;` +/// ).allocator;` /// /// Then use `failing_allocator` anywhere you would have used a /// different allocator. pub const FailingAllocator = struct { - index: usize, - fail_index: usize, + alloc_index: usize, + resize_index: usize, internal_allocator: mem.Allocator, allocated_bytes: usize, freed_bytes: usize, @@ -21,28 +35,24 @@ pub const FailingAllocator = struct { deallocations: usize, stack_addresses: [num_stack_frames]usize, has_induced_failure: bool, + fail_index: usize, + resize_fail_index: usize, const num_stack_frames = if (std.debug.sys_can_stack_trace) 16 else 0; - /// `fail_index` is the number of successful allocations you can - /// expect from this allocator. The next allocation will fail. - /// For example, if this is called with `fail_index` equal to 2, - /// the following test will pass: - /// - /// var a = try failing_alloc.create(i32); - /// var b = try failing_alloc.create(i32); - /// testing.expectError(error.OutOfMemory, failing_alloc.create(i32)); - pub fn init(internal_allocator: mem.Allocator, fail_index: usize) FailingAllocator { + pub fn init(internal_allocator: mem.Allocator, config: Config) FailingAllocator { return FailingAllocator{ .internal_allocator = internal_allocator, - .fail_index = fail_index, - .index = 0, + .alloc_index = 0, + .resize_index = 0, .allocated_bytes = 0, .freed_bytes = 0, .allocations = 0, .deallocations = 0, .stack_addresses = undefined, .has_induced_failure = false, + .fail_index = config.fail_index, + .resize_fail_index = config.resize_fail_index, }; } @@ -64,7 +74,7 @@ pub const FailingAllocator = struct { return_address: usize, ) ?[*]u8 { const self: *FailingAllocator = @ptrCast(@alignCast(ctx)); - if (self.index == self.fail_index) { + if (self.alloc_index == self.fail_index) { if (!self.has_induced_failure) { @memset(&self.stack_addresses, 0); var stack_trace = std.builtin.StackTrace{ @@ -80,7 +90,7 @@ pub const FailingAllocator = struct { return null; self.allocated_bytes += len; self.allocations += 1; - self.index += 1; + self.alloc_index += 1; return result; } @@ -92,6 +102,8 @@ pub const FailingAllocator = struct { ra: usize, ) bool { const self: *FailingAllocator = @ptrCast(@alignCast(ctx)); + if (self.resize_index == self.resize_fail_index) + return false; if (!self.internal_allocator.rawResize(old_mem, log2_old_align, new_len, ra)) return false; if (new_len < old_mem.len) { @@ -99,6 +111,7 @@ pub const FailingAllocator = struct { } else { self.allocated_bytes += new_len - old_mem.len; } + self.resize_index += 1; return true; }