tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/lsm/segmented_array.zig

@@ -1,1500 +0,0 @@
-const std = @import("std");
-
-const assert = std.debug.assert;
-const math = std.math;
-const mem = std.mem;
-
-const stdx = @import("stdx");
-const div_ceil = stdx.div_ceil;
-const binary_search_values_upsert_index =
-    @import("binary_search.zig").binary_search_values_upsert_index;
-const binary_search_keys = @import("binary_search.zig").binary_search_keys;
-const Direction = @import("../direction.zig").Direction;
-
-/// A "segmented array" is an array with efficient (amortized) random-insert/remove operations.
-/// Also known as an "unrolled linked list": https://en.wikipedia.org/wiki/Unrolled_linked_list
-///
-/// The structure consists of an array list of "nodes". Each node is a non-empty array of T.
-/// When a node fills, it is split into two adjacent, partially-full nodes.
-/// When a node empties, it is joined with a nearby node.
-///
-/// An absolute index is offset from the start of the segmented array.
-/// A relative index is offset from the start of a node.
-pub fn SegmentedArrayType(
-    comptime T: type,
-    comptime NodePool: type,
-    comptime element_count_max: u32,
-    comptime options: Options,
-) type {
-    return SegmentedArrayBaseType(T, NodePool, element_count_max, null, {}, options);
-}
-
-pub fn SortedSegmentedArrayType(
-    comptime T: type,
-    comptime NodePool: type,
-    comptime element_count_max: u32,
-    comptime Key: type,
-    comptime key_from_value: fn (*const T) callconv(.@"inline") Key,
-    comptime options: Options,
-) type {
-    return SegmentedArrayBaseType(T, NodePool, element_count_max, Key, key_from_value, options);
-}
-
-pub const Options = struct {
-    /// Assert all invariants before/after every public function.
-    /// Very expensive - only enable for debugging/fuzzing.
-    verify: bool = false,
-};
-
-fn SegmentedArrayBaseType(
-    comptime T: type,
-    comptime NodePool: type,
-    comptime element_count_max: u32,
-    // Set when the SegmentedArray is ordered:
-    comptime Key: ?type,
-    comptime key_from_value: if (Key) |K| (fn (*const T) callconv(.@"inline") K) else void,
-    comptime options: Options,
-) type {
-    comptime assert(Key == null or @typeInfo(Key.?) == .int or @typeInfo(Key.?) == .comptime_int);
-
-    return struct {
-        const SegmentedArray = @This();
-
-        pub const Cursor = struct {
-            node: u32,
-            relative_index: u32,
-        };
-
-        // We can't use @divExact() here as we store TableInfo structs of various sizes in this
-        // data structure. This means that there may be padding at the end of the node.
-        pub const node_capacity = blk: {
-            const max = @divFloor(NodePool.node_size, @sizeOf(T));
-
-            // We require that the node capacity is evenly divisible by 2 to simplify our code
-            // that splits/joins nodes at the midpoint.
-            const capacity = if (max % 2 == 0) max else max - 1;
-
-            assert(capacity >= 2);
-            assert(capacity % 2 == 0);
-            break :blk capacity;
-        };
-
-        comptime {
-            // If this assert fails, we should be using a non-segmented array instead!
-            assert(element_count_max > node_capacity);
-
-            // We use u32 for indexes and counts.
-            assert(element_count_max <= std.math.maxInt(u32));
-
-            // The buffers returned from the node_pool must be able to store T with correct
-            // alignment.
-            assert(NodePool.node_alignment >= @alignOf(T));
-        }
-
-        pub const node_count_max_naive = blk: {
-            // If a node fills up it is divided into two new nodes. Therefore,
-            // the worst possible space overhead is when all nodes are half full.
-            // This uses flooring division, we want to examine the worst case here.
-            const elements_per_node_min = @divExact(node_capacity, 2);
-            break :blk div_ceil(element_count_max, elements_per_node_min);
-        };
-
-        // We can't always actually reach node_count_max_naive in all configurations.
-        // If we're at node_count_max_naive-1 nodes, in order to split one more node we need:
-        pub const node_count_max = if (element_count_max >=
-            // * The node that we split must be full.
-            node_capacity +
-                // * The last node must have at least one element.
-                1 +
-                // * All other nodes must be at least half-full.
-                ((node_count_max_naive -| 3) * @divExact(node_capacity, 2)) +
-                // * And then we insert one more element into the full node.
-                1)
-            node_count_max_naive
-        else
-            node_count_max_naive - 1;
-
-        node_count: u32 = 0,
-        /// This is the segmented array. The first node_count pointers are non-null.
-        /// The rest are null. We only use optional pointers here to get safety checks.
-        nodes: *[node_count_max]?*[node_capacity]T,
-        /// Since nodes in a segmented array are usually not full, computing the absolute index
-        /// of an element in the full array is O(N) over the number of nodes. To avoid this cost
-        /// we precompute the absolute index of the first element of each node.
-        /// To avoid a separate counts field, we derive the number of elements in a node from the
-        /// index of that node and the next node.
-        /// To avoid special casing the count() function for the last node, we increase the array
-        /// length by 1 and store the total element count in the last slot.
-        indexes: *[node_count_max + 1]u32,
-
-        pub fn init(allocator: mem.Allocator) !SegmentedArray {
-            const nodes = try allocator.create([node_count_max]?*[node_capacity]T);
-            errdefer allocator.destroy(nodes);
-
-            const indexes = try allocator.create([node_count_max + 1]u32);
-            errdefer allocator.destroy(indexes);
-
-            @memset(nodes, null);
-            indexes[0] = 0;
-
-            const array = SegmentedArray{
-                .nodes = nodes,
-                .indexes = indexes,
-            };
-
-            if (options.verify) array.verify();
-
-            return array;
-        }
-
-        pub fn deinit(array: SegmentedArray, allocator: mem.Allocator, node_pool: *NodePool) void {
-            if (options.verify) array.verify();
-
-            for (array.nodes[0..array.node_count]) |node| {
-                node_pool.release(@ptrCast(@alignCast(node.?)));
-            }
-            allocator.free(array.nodes);
-            allocator.free(array.indexes);
-        }
-
-        pub fn reset(array: *SegmentedArray, node_pool: *NodePool) void {
-            if (options.verify) array.verify();
-
-            for (array.nodes[0..array.node_count]) |node| {
-                node_pool.release(@ptrCast(@alignCast(node.?)));
-            }
-            @memset(array.nodes, null);
-
-            array.indexes[0] = 0;
-            array.* = .{
-                .nodes = array.nodes,
-                .indexes = array.indexes,
-            };
-
-            if (options.verify) array.verify();
-        }
-
-        pub fn verify(array: SegmentedArray) void {
-            assert(array.node_count <= node_count_max);
-            for (array.nodes, 0..) |node, node_index| {
-                if (node_index < array.node_count) {
-                    // The first node_count pointers are non-null.
-                    assert(node != null);
-                } else {
-                    // The rest are non-null.
-                    assert(node == null);
-                }
-            }
-            for (array.nodes[0..array.node_count], 0..) |_, node_index| {
-                const c = array.count(@intCast(node_index));
-                // Every node is at most full.
-                assert(c <= node_capacity);
-                // Every node is at least half-full, except the last.
-                if (node_index < array.node_count - 1) {
-                    assert(c >= @divTrunc(node_capacity, 2));
-                }
-            }
-            if (Key) |K| {
-                // If Key is not null then the elements must be sorted by key_from_value (but not
-                // necessarily unique).
-                var key_prior_or_null: ?K = null;
-                for (array.nodes[0..array.node_count], 0..) |_, node_index| {
-                    for (array.node_elements(@intCast(node_index))) |*value| {
-                        const key = key_from_value(value);
-                        if (key_prior_or_null) |key_prior| {
-                            assert(key_prior <= key);
-                        }
-                        key_prior_or_null = key;
-                    }
-                }
-            }
-        }
-
-        /// Returns the absolute index of the element being inserted.
-        /// Available only when `Key != null`.
-        pub fn insert_element(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            element: T,
-        ) u32 {
-            comptime assert(Key != null);
-            if (options.verify) array.verify();
-
-            const count_before = array.len();
-
-            const cursor = array.search(key_from_value(&element));
-            const absolute_index = array.absolute_index_for_cursor(cursor);
-            array.insert_elements_at_absolute_index(node_pool, absolute_index, &[_]T{element});
-
-            if (options.verify) array.verify();
-
-            const count_after = array.len();
-            assert(count_after == count_before + 1);
-
-            return absolute_index;
-        }
-
-        /// Available only when `Key == null`.
-        pub fn insert_elements(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            absolute_index: u32,
-            elements: []const T,
-        ) void {
-            comptime assert(Key == null);
-            if (options.verify) array.verify();
-
-            const count_before = array.len();
-            array.insert_elements_at_absolute_index(
-                node_pool,
-                absolute_index,
-                elements,
-            );
-
-            const count_after = array.len();
-            assert(count_after == count_before + elements.len);
-
-            if (options.verify) array.verify();
-        }
-
-        fn insert_elements_at_absolute_index(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            absolute_index: u32,
-            elements: []const T,
-        ) void {
-            assert(elements.len > 0);
-            assert(absolute_index + elements.len <= element_count_max);
-
-            var i: u32 = 0;
-            while (i < elements.len) {
-                const batch = @min(node_capacity, elements.len - i);
-                array.insert_elements_batch(
-                    node_pool,
-                    absolute_index + i,
-                    elements[i..][0..batch],
-                );
-                i += batch;
-            }
-            assert(i == elements.len);
-        }
-
-        fn insert_elements_batch(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            absolute_index: u32,
-            elements: []const T,
-        ) void {
-            assert(elements.len > 0);
-            assert(elements.len <= node_capacity);
-            assert(absolute_index + elements.len <= element_count_max);
-
-            if (array.node_count == 0) {
-                assert(absolute_index == 0);
-
-                array.insert_empty_node_at(node_pool, 0);
-
-                assert(array.node_count == 1);
-                assert(array.nodes[0] != null);
-                assert(array.indexes[0] == 0);
-                assert(array.indexes[1] == 0);
-            }
-
-            const cursor = array.cursor_for_absolute_index(absolute_index);
-            assert(cursor.node < array.node_count);
-
-            const a = cursor.node;
-            const a_pointer = array.nodes[a].?;
-            assert(cursor.relative_index <= array.count(a));
-
-            const total = array.count(a) + @as(u32, @intCast(elements.len));
-            if (total <= node_capacity) {
-                stdx.copy_right(
-                    .inexact,
-                    T,
-                    a_pointer[cursor.relative_index + elements.len ..],
-                    a_pointer[cursor.relative_index..array.count(a)],
-                );
-                stdx.copy_disjoint(.inexact, T, a_pointer[cursor.relative_index..], elements);
-
-                array.increment_indexes_after(a, @intCast(elements.len));
-                return;
-            }
-
-            // Insert a new node after the node being split.
-            const b = a + 1;
-            array.insert_empty_node_at(node_pool, b);
-            const b_pointer = array.nodes[b].?;
-
-            const a_half = div_ceil(total, 2);
-            const b_half = total - a_half;
-            assert(a_half >= b_half);
-            assert(a_half + b_half == total);
-
-            // The 1st case can be seen as a special case of the 2nd.
-            // The 5th case can be seen as a special case of the 4th.
-            //
-            // elements: [yyyyyy], relative_index: 0
-            // [xxxxx_][______]
-            // [______][xxxxx_] // after first copy_backwards
-            // [______][xxxxx_] // skip mem.copyBackwards (a_half >= relative_index)
-            // [yyyyyy][xxxxx_] // after second copy_backwards
-            //
-            // elements: [yy], relative_index: 1
-            // [xxxxx_][______]
-            // [x__x__][xxx___] // after first copy_backwards
-            // [x__x__][xxx___] // skip mem.copyBackwards (a_half >= relative_index)
-            // [xyyx__][xxx___] // after second copy_backwards
-            //
-            // elements: [yy], relative_index: 2
-            // [xxx_][____]
-            // [xx__][_x__] // after first copy_backwards
-            // [xx__][_x__] // skip mem.copyBackwards (a_half >= relative_index)
-            // [xxy_][yx__] // after second copy_backwards
-            //
-            // elements: [yy], relative_index: 5
-            // [xxxxxx][______]
-            // [xxxxx_][___x__] // after first copy_backwards
-            // [xxxx__][x__x__] // after mem.copyBackwards (a_half < relative_index)
-            // [xxxx__][xyyx__] // after second copy_backwards
-            //
-            // elements: [yyyyy_], relative_index: 5
-            // [xxxxx_][______]
-            // [xxxxx_][______] // after first copy_backwards
-            // [xxxxx_][______] // skip mem.copyBackwards (a_half >= relative_index)
-            // [xxxxx_][yyyyy_] // after second copy_backwards
-
-            const a_half_pointer = a_pointer[0..a_half];
-            const b_half_pointer = b_pointer[0..b_half];
-
-            // Move part of `a` forwards to make space for elements.
-            copy_backwards(
-                a_half_pointer,
-                b_half_pointer,
-                cursor.relative_index + elements.len,
-                a_pointer[cursor.relative_index..array.count(a)],
-            );
-
-            if (a_half < cursor.relative_index) {
-                // Move the part of `a` that is past the half-way point into `b`.
-                stdx.copy_right(
-                    .inexact,
-                    T,
-                    b_half_pointer,
-                    a_pointer[a_half..cursor.relative_index],
-                );
-            }
-
-            // Move `elements` into `a` and/or `b`.
-            copy_backwards(
-                a_half_pointer,
-                b_half_pointer,
-                cursor.relative_index,
-                elements,
-            );
-
-            array.indexes[b] = array.indexes[a] + a_half;
-            array.increment_indexes_after(b, @intCast(elements.len));
-        }
-
-        /// Behaves like mem.copyBackwards, but as if `a` and `b` were a single contiguous slice.
-        /// `target` is the destination index within the concatenation of `a` and `b`.
-        fn copy_backwards(
-            a: []T,
-            b: []T,
-            target: usize,
-            source: []const T,
-        ) void {
-            assert(target + source.len <= a.len + b.len);
-            const target_a = a[@min(target, a.len)..@min(target + source.len, a.len)];
-            const target_b = b[target -| a.len..(target + source.len) -| a.len];
-            assert(target_a.len + target_b.len == source.len);
-            const source_a = source[0..target_a.len];
-            const source_b = source[target_a.len..];
-            if (target_b.ptr != source_b.ptr) {
-                stdx.copy_right(.exact, T, target_b, source_b);
-            }
-            if (target_a.ptr != source_a.ptr) {
-                stdx.copy_right(.exact, T, target_a, source_a);
-            }
-        }
-
-        /// Insert an empty node at index `node`.
-        fn insert_empty_node_at(array: *SegmentedArray, node_pool: *NodePool, node: u32) void {
-            assert(node <= array.node_count);
-            assert(array.node_count + 1 <= node_count_max);
-
-            stdx.copy_right(
-                .exact,
-                ?*[node_capacity]T,
-                array.nodes[node + 1 .. array.node_count + 1],
-                array.nodes[node..array.node_count],
-            );
-            stdx.copy_right(
-                .exact,
-                u32,
-                array.indexes[node + 1 .. array.node_count + 2],
-                array.indexes[node .. array.node_count + 1],
-            );
-
-            array.node_count += 1;
-            const node_pointer = node_pool.acquire();
-            comptime {
-                // @ptrCast does not check that the size or alignment agree
-                assert(std.meta.alignment(@TypeOf(node_pointer)) >= @alignOf(T));
-                assert(@sizeOf(@TypeOf(node_pointer.*)) >= @sizeOf([node_capacity]T));
-            }
-            array.nodes[node] = @ptrCast(@alignCast(node_pointer));
-            assert(array.indexes[node] == array.indexes[node + 1]);
-        }
-
-        pub fn remove_elements(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            absolute_index: u32,
-            remove_count: u32,
-        ) void {
-            if (options.verify) array.verify();
-
-            assert(array.node_count > 0);
-            assert(remove_count > 0);
-            assert(absolute_index + remove_count <= element_count_max);
-            assert(absolute_index + remove_count <= array.indexes[array.node_count]);
-
-            const half = @divExact(node_capacity, 2);
-
-            var i: u32 = remove_count;
-            while (i > 0) {
-                const batch = @min(half, i);
-                array.remove_elements_batch(node_pool, absolute_index, batch);
-                i -= batch;
-            }
-
-            if (options.verify) array.verify();
-        }
-
-        fn remove_elements_batch(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            absolute_index: u32,
-            remove_count: u32,
-        ) void {
-            assert(array.node_count > 0);
-
-            // Restricting the batch size to half node capacity ensures that elements
-            // are removed from at most two nodes.
-            const half = @divExact(node_capacity, 2);
-            assert(remove_count <= half);
-            assert(remove_count > 0);
-
-            assert(absolute_index + remove_count <= element_count_max);
-            assert(absolute_index + remove_count <= array.indexes[array.node_count]);
-
-            const cursor = array.cursor_for_absolute_index(absolute_index);
-            assert(cursor.node < array.node_count);
-
-            const a = cursor.node;
-            const a_pointer = array.nodes[a].?;
-            const a_remaining = cursor.relative_index;
-
-            // Remove elements from exactly one node:
-            if (a_remaining + remove_count <= array.count(a)) {
-                stdx.copy_left(
-                    .inexact,
-                    T,
-                    a_pointer[a_remaining..],
-                    a_pointer[a_remaining + remove_count .. array.count(a)],
-                );
-
-                array.decrement_indexes_after(a, remove_count);
-
-                array.maybe_remove_or_merge_node_with_next(node_pool, a);
-                return;
-            }
-
-            // Remove elements from exactly two nodes:
-
-            const b = a + 1;
-            const b_pointer = array.nodes[b].?;
-            const b_remaining = b_pointer[remove_count -
-                (array.count(a) - a_remaining) .. array.count(b)];
-
-            assert(@intFromPtr(b_remaining.ptr) > @intFromPtr(b_pointer));
-
-            // Only one of these nodes may become empty, as we limit batch size to
-            // half node capacity.
-            assert(a_remaining > 0 or b_remaining.len > 0);
-
-            if (a_remaining >= half) {
-                stdx.copy_left(.inexact, T, b_pointer, b_remaining);
-
-                array.indexes[b] = array.indexes[a] + a_remaining;
-                array.decrement_indexes_after(b, remove_count);
-
-                array.maybe_remove_or_merge_node_with_next(node_pool, b);
-            } else if (b_remaining.len >= half) {
-                assert(a_remaining < half);
-
-                array.indexes[b] = array.indexes[a] + a_remaining;
-                array.decrement_indexes_after(b, remove_count);
-
-                array.maybe_merge_nodes(node_pool, a, b_remaining);
-            } else {
-                assert(a_remaining < half and b_remaining.len < half);
-                assert(a_remaining + b_remaining.len <= node_capacity);
-
-                stdx.copy_disjoint(.inexact, T, a_pointer[a_remaining..], b_remaining);
-
-                array.indexes[b] =
-                    array.indexes[a] + a_remaining + @as(u32, @intCast(b_remaining.len));
-                array.decrement_indexes_after(b, remove_count);
-
-                array.remove_empty_node_at(node_pool, b);
-
-                // Either:
-                // * `b` was the last node so now `a` is the last node
-                // * both `a` and `b` were at least half-full so now `a` is at least half-full
-                assert(b == array.node_count or array.count(a) >= half);
-            }
-        }
-
-        fn maybe_remove_or_merge_node_with_next(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            node: u32,
-        ) void {
-            assert(node < array.node_count);
-
-            if (array.count(node) == 0) {
-                array.remove_empty_node_at(node_pool, node);
-                return;
-            }
-
-            if (node == array.node_count - 1) return;
-
-            const next_elements = array.nodes[node + 1].?[0..array.count(node + 1)];
-            array.maybe_merge_nodes(node_pool, node, next_elements);
-        }
-
-        fn maybe_merge_nodes(
-            array: *SegmentedArray,
-            node_pool: *NodePool,
-            node: u32,
-            elements_next_node: []T,
-        ) void {
-            const half = @divExact(node_capacity, 2);
-
-            const a = node;
-            const a_pointer = array.nodes[a].?;
-            assert(array.count(a) <= node_capacity);
-
-            // The elements_next_node slice may not be at the start of the node,
-            // but the length of the slice will match count(b).
-            const b = a + 1;
-            const b_pointer = array.nodes[b].?;
-            const b_elements = elements_next_node;
-            assert(b_elements.len == array.count(b));
-            assert(b_elements.len > 0);
-            assert(b_elements.len >= half or b == array.node_count - 1);
-            assert(b_elements.len <= node_capacity);
-            assert(@intFromPtr(b_elements.ptr) >= @intFromPtr(b_pointer));
-
-            // Our function would still be correct if this assert fails, but we would
-            // unnecessarily copy all elements of b to node a and then delete b
-            // instead of simply deleting a.
-            assert(!(array.count(a) == 0 and b_pointer == b_elements.ptr));
-
-            const total = array.count(a) + @as(u32, @intCast(b_elements.len));
-            if (total <= node_capacity) {
-                stdx.copy_disjoint(.inexact, T, a_pointer[array.count(a)..], b_elements);
-
-                array.indexes[b] = array.indexes[b + 1];
-                array.remove_empty_node_at(node_pool, b);
-
-                assert(array.count(a) >= half or a == array.node_count - 1);
-            } else if (array.count(a) < half) {
-                const a_half = div_ceil(total, 2);
-                const b_half = total - a_half;
-                assert(a_half >= b_half);
-                assert(a_half + b_half == total);
-
-                stdx.copy_disjoint(
-                    .exact,
-                    T,
-                    a_pointer[array.count(a)..a_half],
-                    b_elements[0 .. a_half - array.count(a)],
-                );
-                stdx.copy_left(.inexact, T, b_pointer, b_elements[a_half - array.count(a) ..]);
-
-                array.indexes[b] = array.indexes[a] + a_half;
-
-                assert(array.count(a) >= half);
-                assert(array.count(b) >= half);
-            } else {
-                assert(b_pointer == b_elements.ptr);
-                assert(array.indexes[b] + b_elements.len == array.indexes[b + 1]);
-            }
-        }
-
-        /// Remove an empty node at index `node`.
-        fn remove_empty_node_at(array: *SegmentedArray, node_pool: *NodePool, node: u32) void {
-            assert(array.node_count > 0);
-            assert(node < array.node_count);
-            assert(array.count(node) == 0);
-
-            node_pool.release(@ptrCast(@alignCast(array.nodes[node].?)));
-
-            stdx.copy_left(
-                .exact,
-                ?*[node_capacity]T,
-                array.nodes[node .. array.node_count - 1],
-                array.nodes[node + 1 .. array.node_count],
-            );
-            stdx.copy_left(
-                .exact,
-                u32,
-                array.indexes[node..array.node_count],
-                array.indexes[node + 1 .. array.node_count + 1],
-            );
-
-            array.node_count -= 1;
-            array.nodes[array.node_count] = null;
-            array.indexes[array.node_count + 1] = undefined;
-        }
-
-        inline fn count(array: SegmentedArray, node: u32) u32 {
-            const result = array.indexes[node + 1] - array.indexes[node];
-            assert(result <= node_capacity);
-            return result;
-        }
-
-        inline fn increment_indexes_after(array: *SegmentedArray, node: u32, delta: u32) void {
-            for (array.indexes[node + 1 .. array.node_count + 1]) |*i| i.* += delta;
-        }
-
-        inline fn decrement_indexes_after(array: *SegmentedArray, node: u32, delta: u32) void {
-            for (array.indexes[node + 1 .. array.node_count + 1]) |*i| i.* -= delta;
-        }
-
-        pub inline fn node_elements(array: SegmentedArray, node: u32) []T {
-            assert(node < array.node_count);
-            return array.nodes[node].?[0..array.count(node)];
-        }
-
-        pub inline fn node_last_element(array: SegmentedArray, node: u32) T {
-            return array.node_elements(node)[array.count(node) - 1];
-        }
-
-        pub inline fn element_at_cursor(array: SegmentedArray, cursor: Cursor) T {
-            return array.node_elements(cursor.node)[cursor.relative_index];
-        }
-
-        pub inline fn first(_: SegmentedArray) Cursor {
-            return .{
-                .node = 0,
-                .relative_index = 0,
-            };
-        }
-
-        pub inline fn last(array: SegmentedArray) Cursor {
-            if (array.node_count == 0) return array.first();
-
-            return .{
-                .node = array.node_count - 1,
-                .relative_index = array.count(array.node_count - 1) - 1,
-            };
-        }
-
-        pub inline fn len(array: SegmentedArray) u32 {
-            const result = array.indexes[array.node_count];
-            assert(result <= element_count_max);
-            return result;
-        }
-
-        // TODO Consider enabling ReleaseFast for this once tested.
-        pub fn absolute_index_for_cursor(array: SegmentedArray, cursor: Cursor) u32 {
-            if (array.node_count == 0) {
-                assert(cursor.node == 0);
-                assert(cursor.relative_index == 0);
-                return 0;
-            }
-            assert(cursor.node < array.node_count);
-            if (cursor.node == array.node_count - 1) {
-                // Insertion may target the index one past the end of the array.
-                assert(cursor.relative_index <= array.count(cursor.node));
-            } else {
-                assert(cursor.relative_index < array.count(cursor.node));
-            }
-            return array.indexes[cursor.node] + cursor.relative_index;
-        }
-
-        fn cursor_for_absolute_index(array: SegmentedArray, absolute_index: u32) Cursor {
-            // This function could handle node_count == 0 by returning a zero Cursor.
-            // However, this is an internal function and we don't require this behavior.
-            assert(array.node_count > 0);
-
-            assert(absolute_index < element_count_max);
-            assert(absolute_index <= array.len());
-
-            const result = binary_search_keys(
-                u32,
-                array.indexes[0..array.node_count],
-                absolute_index,
-                .{},
-            );
-
-            if (result.exact) {
-                return .{
-                    .node = result.index,
-                    .relative_index = 0,
-                };
-            } else {
-                const node = result.index - 1;
-                const relative_index = absolute_index - array.indexes[node];
-                if (node == array.node_count - 1) {
-                    // Insertion may target the index one past the end of the array.
-                    assert(relative_index <= array.count(node));
-                } else {
-                    assert(relative_index < array.count(node));
-                }
-                return .{
-                    .node = node,
-                    .relative_index = relative_index,
-                };
-            }
-        }
-
-        pub const Iterator = struct {
-            array: *const SegmentedArray,
-            direction: Direction,
-
-            cursor: Cursor,
-
-            /// The user may set this early to stop iteration. For example,
-            /// if the returned table info is outside the key range.
-            done: bool = false,
-
-            pub fn next(it: *Iterator) ?*T {
-                if (it.done) return null;
-
-                assert(it.cursor.node < it.array.node_count);
-
-                const elements = it.array.node_elements(it.cursor.node);
-                const element = &elements[it.cursor.relative_index];
-
-                switch (it.direction) {
-                    .ascending => {
-                        if (it.cursor.relative_index == elements.len - 1) {
-                            if (it.cursor.node == it.array.node_count - 1) {
-                                it.done = true;
-                            } else {
-                                it.cursor.node += 1;
-                                it.cursor.relative_index = 0;
-                            }
-                        } else {
-                            it.cursor.relative_index += 1;
-                        }
-                    },
-                    .descending => {
-                        if (it.cursor.relative_index == 0) {
-                            if (it.cursor.node == 0) {
-                                it.done = true;
-                            } else {
-                                it.cursor.node -= 1;
-                                it.cursor.relative_index = it.array.count(it.cursor.node) - 1;
-                            }
-                        } else {
-                            it.cursor.relative_index -= 1;
-                        }
-                    },
-                }
-
-                return element;
-            }
-        };
-
-        pub fn iterator_from_cursor(
-            array: *const SegmentedArray,
-            /// First element of iteration.
-            cursor: Cursor,
-            direction: Direction,
-        ) Iterator {
-            if (array.node_count == 0) {
-                assert(cursor.node == 0);
-                assert(cursor.relative_index == 0);
-
-                return .{
-                    .array = array,
-                    .direction = direction,
-                    .cursor = .{ .node = 0, .relative_index = 0 },
-                    .done = true,
-                };
-            } else if (cursor.node == array.node_count - 1 and
-                cursor.relative_index == array.count(cursor.node))
-            {
-                return switch (direction) {
-                    .ascending => .{
-                        .array = array,
-                        .direction = direction,
-                        .cursor = cursor,
-                        .done = true,
-                    },
-                    .descending => .{
-                        .array = array,
-                        .direction = direction,
-                        .cursor = .{
-                            .node = cursor.node,
-                            .relative_index = cursor.relative_index - 1,
-                        },
-                    },
-                };
-            } else {
-                assert(cursor.node < array.node_count);
-                assert(cursor.relative_index < array.count(cursor.node));
-
-                return .{
-                    .array = array,
-                    .direction = direction,
-                    .cursor = cursor,
-                };
-            }
-        }
-
-        pub fn iterator_from_index(
-            array: *const SegmentedArray,
-            /// First element of iteration.
-            absolute_index: u32,
-            direction: Direction,
-        ) Iterator {
-            assert(absolute_index < element_count_max);
-
-            if (array.node_count == 0) {
-                assert(absolute_index == 0);
-
-                return Iterator{
-                    .array = array,
-                    .direction = direction,
-                    .cursor = .{ .node = 0, .relative_index = 0 },
-                    .done = true,
-                };
-            } else {
-                assert(absolute_index < array.len());
-
-                return Iterator{
-                    .array = array,
-                    .direction = direction,
-                    .cursor = array.cursor_for_absolute_index(absolute_index),
-                };
-            }
-        }
-
-        /// Returns a cursor to the index of the key either exactly equal to the target key or,
-        /// if there is no exact match, the next greatest key.
-        /// Available only when `Key != null`.
-        pub fn search(
-            array: *const SegmentedArray,
-            key: K: {
-                assert(Key != null);
-                break :K Key.?;
-            },
-        ) Cursor {
-            const K = Key.?;
-            if (array.node_count == 0) {
-                return .{
-                    .node = 0,
-                    .relative_index = 0,
-                };
-            }
-
-            var offset: usize = 0;
-            var length: usize = array.node_count;
-            while (length > 1) {
-                const half = length / 2;
-                const mid = offset + half;
-
-                const node = &array.nodes[mid].?[0];
-
-                if (key_from_value(node) < key) {
-                    @branchHint(.unpredictable);
-                    offset = mid;
-                }
-
-                length -= half;
-            }
-
-            // Unlike a normal binary search, don't increment the offset when "key" is higher
-            // than the element — "round down" to the previous node.
-            // This guarantees that the node result is never "== node_count".
-            //
-            // (If there are two adjacent nodes starting with keys A and C, and we search B,
-            // we want to pick the A node.)
-            const node: u32 = @intCast(offset);
-            assert(node < array.node_count);
-
-            const relative_index = binary_search_values_upsert_index(
-                K,
-                T,
-                key_from_value,
-                array.node_elements(node),
-                key,
-                .{},
-            );
-
-            // Follow the same rule as absolute_index_for_cursor:
-            // only return relative_index==array.count() at the last node.
-            if (node + 1 < array.node_count and
-                relative_index == array.count(node))
-            {
-                return .{
-                    .node = node + 1,
-                    .relative_index = 0,
-                };
-            } else {
-                return .{
-                    .node = node,
-                    .relative_index = relative_index,
-                };
-            }
-        }
-    };
-}
-
-test "SortedSegmentedArray duplicate elements" {
-    // Create [0, 0, 0, 100, 100, 100, ~0, ~0, ~0] array, verify that the search is left-biased.
-    const testing = std.testing;
-
-    const NodePoolType = @import("node_pool.zig").NodePoolType;
-    const TestPool = NodePoolType(128 * @sizeOf(u32), 2 * @alignOf(u32));
-    const TestArray = SortedSegmentedArrayType(
-        u32,
-        TestPool,
-        1024,
-        u32,
-        struct {
-            inline fn key_from_value(value: *const u32) u32 {
-                return value.*;
-            }
-        }.key_from_value,
-        .{ .verify = true },
-    );
-
-    var pool: TestPool = undefined;
-    try pool.init(testing.allocator, TestArray.node_count_max);
-    defer pool.deinit(testing.allocator);
-
-    var array = try TestArray.init(testing.allocator);
-    defer array.deinit(testing.allocator, &pool);
-
-    for (0..3) |index| {
-        // Elements are inserted to the left of a row of duplicates.
-        var inserted_at = array.insert_element(&pool, 0);
-        try testing.expectEqual(inserted_at, 0);
-
-        inserted_at = array.insert_element(&pool, 100);
-        try testing.expectEqual(inserted_at, @as(u32, @intCast(index + 1)));
-
-        inserted_at = array.insert_element(&pool, math.maxInt(u32));
-        try testing.expectEqual(inserted_at, @as(u32, @intCast((index + 1) * 2)));
-    }
-    try testing.expectEqual(array.len(), 9);
-
-    // Search finds the leftmost element.
-    try testing.expectEqual(array.absolute_index_for_cursor(array.search(0)), 0);
-    try testing.expectEqual(array.absolute_index_for_cursor(array.search(100)), 3);
-    try testing.expectEqual(array.absolute_index_for_cursor(array.search(math.maxInt(u32))), 6);
-
-    // Ascending iterators pick the leftmost element.
-    // Descending iterators are weird --- they _also_ pick the leftmost element, although the
-    // rightmost makes more sense.
-    {
-        const target: u32 = 0;
-        var it = array.iterator_from_cursor(array.search(target), .ascending);
-        try testing.expectEqual(it.next().?.*, 0);
-        try testing.expectEqual(it.next().?.*, 0);
-        try testing.expectEqual(it.next().?.*, 0);
-        try testing.expectEqual(it.next().?.*, 100);
-
-        it = array.iterator_from_cursor(array.search(target), .descending);
-        try testing.expectEqual(it.next().?.*, 0);
-        try testing.expectEqual(it.next(), null);
-    }
-
-    {
-        const target: u32 = 100;
-        var it = array.iterator_from_cursor(array.search(target), .ascending);
-        try testing.expectEqual(it.next().?.*, 100);
-        try testing.expectEqual(it.next().?.*, 100);
-        try testing.expectEqual(it.next().?.*, 100);
-        try testing.expectEqual(it.next().?.*, math.maxInt(u32));
-
-        it = array.iterator_from_cursor(array.search(target), .descending);
-        try testing.expectEqual(it.next().?.*, 100);
-        try testing.expectEqual(it.next().?.*, 0);
-    }
-
-    {
-        const target: u32 = math.maxInt(u32);
-        var it = array.iterator_from_cursor(array.search(target), .ascending);
-        try testing.expectEqual(it.next().?.*, math.maxInt(u32));
-        try testing.expectEqual(it.next().?.*, math.maxInt(u32));
-        try testing.expectEqual(it.next().?.*, math.maxInt(u32));
-        try testing.expectEqual(it.next(), null);
-
-        it = array.iterator_from_cursor(array.search(target), .descending);
-        try testing.expectEqual(it.next().?.*, math.maxInt(u32));
-        try testing.expectEqual(it.next().?.*, 100);
-    }
-}
-
-/// In order to avoid making internal details of segmented array public, the fuzzing code is defined
-/// in this file an is driven by =segmented_array_fuzz.zig`.
-fn FuzzContextType(
-    comptime T: type,
-    comptime node_size: u32,
-    comptime element_count_max: u32,
-    comptime Key: type,
-    comptime key_from_value: fn (*const T) callconv(.@"inline") Key,
-    comptime element_order: enum { sorted, unsorted },
-    comptime options: Options,
-) type {
-    return struct {
-        const FuzzContext = @This();
-
-        const testing = std.testing;
-        const log = false;
-
-        const NodePoolType = @import("node_pool.zig").NodePoolType;
-
-        // Test overaligned nodes to catch compile errors for missing @alignCast()
-        const TestPool = NodePoolType(node_size, 2 * @alignOf(T));
-        const TestArray = switch (element_order) {
-            .sorted => SortedSegmentedArrayType(
-                T,
-                TestPool,
-                element_count_max,
-                Key,
-                key_from_value,
-                options,
-            ),
-            .unsorted => SegmentedArrayType(T, TestPool, element_count_max, options),
-        };
-
-        prng: *stdx.PRNG,
-
-        pool: TestPool,
-        array: TestArray,
-
-        reference: std.ArrayList(T),
-
-        inserts: u64 = 0,
-        removes: u64 = 0,
-
-        fn init(
-            context: *FuzzContext,
-            allocator: std.mem.Allocator,
-            prng: *stdx.PRNG,
-        ) !void {
-            context.* = .{
-                .prng = prng,
-
-                .pool = undefined,
-                .array = undefined,
-                .reference = undefined,
-            };
-
-            try context.pool.init(allocator, TestArray.node_count_max);
-            errdefer context.pool.deinit(allocator);
-
-            context.array = try TestArray.init(allocator);
-            errdefer context.array.deinit(allocator, &context.pool);
-
-            context.reference = std.ArrayList(T).init(allocator);
-            errdefer context.reference.deinit();
-            try context.reference.ensureTotalCapacity(element_count_max);
-        }
-
-        fn deinit(context: *FuzzContext, allocator: std.mem.Allocator) void {
-            context.array.deinit(allocator, &context.pool);
-            context.pool.deinit(allocator);
-
-            context.reference.deinit();
-        }
-
-        fn run(context: *FuzzContext) !void {
-            const Action = enum { insert, remove };
-            {
-                var i: usize = 0;
-                while (i < element_count_max * 2) : (i += 1) {
-                    switch (context.prng.enum_weighted(
-                        Action,
-                        .{
-                            .insert = 60,
-                            .remove = 40,
-                        },
-                    )) {
-                        .insert => try context.insert(),
-                        .remove => try context.remove(),
-                    }
-                }
-            }
-
-            {
-                var i: usize = 0;
-                while (i < element_count_max * 2) : (i += 1) {
-                    switch (context.prng.enum_weighted(
-                        Action,
-                        .{
-                            .insert = 40,
-                            .remove = 60,
-                        },
-                    )) {
-                        .insert => try context.insert(),
-                        .remove => try context.remove(),
-                    }
-                }
-            }
-
-            // Rarely, the code above won't generate an insert at all.
-            if (context.inserts > 0) {
-                try context.remove_all();
-            }
-
-            if (element_order == .unsorted) {
-                // Insert at the beginning of the array until the array is full.
-                while (context.array.len() < element_count_max) {
-                    try context.insert_before_first();
-                }
-                assert(context.array.node_count >= TestArray.node_count_max - 1);
-
-                // Remove all-but-one elements from the last node and insert them into the first
-                // node.
-                const element_count_last = context.array.count(context.array.node_count - 1);
-                var element_index: usize = 0;
-                while (element_index < element_count_last - 1) : (element_index += 1) {
-                    try context.remove_last();
-                    try context.insert_before_first();
-                }
-
-                // We should now have maxed out our node count.
-                assert(context.array.node_count == TestArray.node_count_max);
-
-                try context.remove_all();
-            }
-        }
-
-        fn insert(context: *FuzzContext) !void {
-            const reference_len: u32 = @intCast(context.reference.items.len);
-            const count_free = element_count_max - reference_len;
-
-            if (count_free == 0) return;
-
-            var buffer: [TestArray.node_capacity * 3]T = undefined;
-            const count_max = @min(count_free, TestArray.node_capacity * 3);
-            const count = context.prng.range_inclusive(u32, 1, count_max);
-            context.prng.fill(mem.sliceAsBytes(buffer[0..count]));
-
-            assert(context.reference.items.len <= element_count_max);
-
-            switch (element_order) {
-                .unsorted => {
-                    const index = context.prng.int_inclusive(u32, reference_len);
-
-                    context.array.insert_elements(&context.pool, index, buffer[0..count]);
-                    // TODO the standard library could use an AssumeCapacity variant of this.
-                    context.reference.insertSlice(index, buffer[0..count]) catch unreachable;
-                },
-                .sorted => {
-                    for (buffer[0..count]) |value| {
-                        const index_actual = context.array.insert_element(&context.pool, value);
-                        const index_expect = context.reference_index(key_from_value(&value));
-                        context.reference.insert(index_expect, value) catch unreachable;
-                        try std.testing.expectEqual(index_expect, index_actual);
-                    }
-                },
-            }
-            context.inserts += count;
-
-            try context.verify();
-        }
-
-        fn remove(context: *FuzzContext) !void {
-            const reference_len: u32 = @intCast(context.reference.items.len);
-            if (reference_len == 0) return;
-
-            const count_max = @min(reference_len, TestArray.node_capacity * 3);
-            const count = context.prng.range_inclusive(u32, 1, count_max);
-
-            assert(context.reference.items.len <= element_count_max);
-            const index = context.prng.int_inclusive(u32, reference_len - count);
-
-            context.array.remove_elements(&context.pool, index, count);
-
-            context.reference.replaceRange(index, count, &[0]T{}) catch unreachable;
-
-            context.removes += count;
-
-            try context.verify();
-        }
-
-        fn insert_before_first(context: *FuzzContext) !void {
-            assert(element_order == .unsorted);
-
-            const insert_index = context.array.absolute_index_for_cursor(context.array.first());
-
-            var element: T = undefined;
-            context.prng.fill(mem.asBytes(&element));
-
-            context.array.insert_elements(&context.pool, insert_index, &.{element});
-            context.reference.insert(insert_index, element) catch unreachable;
-
-            context.inserts += 1;
-
-            try context.verify();
-        }
-
-        fn remove_last(context: *FuzzContext) !void {
-            assert(element_order == .unsorted);
-
-            const remove_index = context.array.absolute_index_for_cursor(context.array.last());
-
-            context.array.remove_elements(&context.pool, remove_index, 1);
-            context.reference.replaceRange(remove_index, 1, &[0]T{}) catch unreachable;
-
-            context.removes += 1;
-
-            try context.verify();
-        }
-
-        fn remove_all(context: *FuzzContext) !void {
-            while (context.reference.items.len > 0) try context.remove();
-
-            try testing.expectEqual(@as(u32, 0), context.array.len());
-            try testing.expect(context.inserts > 0);
-            try testing.expect(context.inserts == context.removes);
-
-            if (log) {
-                std.debug.print("\ninserts: {}, removes: {}\n", .{
-                    context.inserts,
-                    context.removes,
-                });
-            }
-
-            try context.verify();
-        }
-
-        fn verify(context: *FuzzContext) !void {
-            if (log) {
-                std.debug.print("expect: ", .{});
-                for (context.reference.items) |i| std.debug.print("{}, ", .{i});
-
-                std.debug.print("\nactual: ", .{});
-                var it = context.array.iterator_from_index(0, .ascending);
-                while (it.next()) |i| std.debug.print("{}, ", .{i.*});
-                std.debug.print("\n", .{});
-            }
-
-            try testing.expectEqual(context.reference.items.len, context.array.len());
-
-            {
-                var it = context.array.iterator_from_index(0, .ascending);
-
-                for (context.reference.items) |expect| {
-                    const actual = it.next() orelse return error.TestUnexpectedResult;
-                    try testing.expectEqual(expect, actual.*);
-                }
-                try testing.expectEqual(@as(?*const T, null), it.next());
-            }
-
-            {
-                var it = context.array.iterator_from_index(
-                    @as(u32, @intCast(context.reference.items.len)) -| 1,
-                    .descending,
-                );
-
-                var i = context.reference.items.len;
-                while (i > 0) {
-                    i -= 1;
-
-                    const expect = context.reference.items[i];
-                    const actual = it.next() orelse return error.TestUnexpectedResult;
-                    try testing.expectEqual(expect, actual.*);
-                }
-                try testing.expectEqual(@as(?*const T, null), it.next());
-            }
-
-            {
-                for (context.reference.items, 0..) |_, i| {
-                    try testing.expect(std.meta.eql(
-                        i,
-                        context.array.absolute_index_for_cursor(
-                            context.array.cursor_for_absolute_index(@intCast(i)),
-                        ),
-                    ));
-                }
-            }
-
-            if (element_order == .sorted) {
-                for (context.reference.items, 0..) |*expect, i| {
-                    if (i == 0) continue;
-                    try testing.expect(key_from_value(&context.reference.items[i - 1]) <=
-                        key_from_value(expect));
-                }
-            }
-
-            if (context.array.len() == 0) {
-                try testing.expectEqual(@as(u32, 0), context.array.node_count);
-            }
-
-            for (context.array.nodes[context.array.node_count..]) |node| {
-                try testing.expectEqual(@as(?*[TestArray.node_capacity]T, null), node);
-            }
-
-            {
-                var i: u32 = 0;
-                while (i < context.array.node_count -| 1) : (i += 1) {
-                    try testing.expect(context.array.count(i) >=
-                        @divExact(TestArray.node_capacity, 2));
-                }
-            }
-            if (element_order == .sorted) try context.verify_search();
-        }
-
-        fn verify_search(context: *FuzzContext) !void {
-            var queries: [20]Key = undefined;
-            context.prng.fill(mem.sliceAsBytes(&queries));
-
-            // Test min/max exceptional values on different SegmentedArray shapes.
-            queries[0] = 0;
-            queries[1] = math.maxInt(Key);
-
-            for (queries) |query| {
-                try testing.expectEqual(
-                    context.reference_index(query),
-                    context.array.absolute_index_for_cursor(context.array.search(query)),
-                );
-            }
-
-            {
-                var iterator_end = context.array.iterator_from_cursor(
-                    context.array.search(math.maxInt(Key)),
-                    .ascending,
-                );
-                while (iterator_end.next()) |item| {
-                    try testing.expectEqual(key_from_value(item), math.maxInt(Key));
-                }
-            }
-
-            {
-                // 0 is not symmetric with maxInt, because `array.search` doesn't take direction
-                // into account.
-                var iterator_start = context.array.iterator_from_cursor(
-                    context.array.search(0),
-                    .descending,
-                );
-                if (context.reference.items.len == 0) {
-                    try testing.expectEqual(iterator_start.next(), null);
-                } else {
-                    try testing.expect(iterator_start.next() != null);
-                    try testing.expectEqual(iterator_start.next(), null);
-                }
-            }
-        }
-
-        fn reference_index(context: *const FuzzContext, key: Key) u32 {
-            return binary_search_values_upsert_index(
-                Key,
-                T,
-                key_from_value,
-                context.reference.items,
-                key,
-                .{},
-            );
-        }
-    };
-}
-
-pub fn run_fuzz(allocator: std.mem.Allocator, seed: u64, comptime options: Options) !void {
-    var prng = stdx.PRNG.from_seed(seed);
-
-    const CompositeKey = @import("composite_key.zig").CompositeKeyType(u64);
-    const TableType = @import("table.zig").TableType;
-    const TableInfoType = @import("manifest.zig").TreeTableInfoType;
-    const TableInfo = TableInfoType(TableType(
-        CompositeKey.Key,
-        CompositeKey,
-        CompositeKey.key_from_value,
-        CompositeKey.sentinel_key,
-        CompositeKey.tombstone,
-        CompositeKey.tombstone_from_key,
-        1, // Doesn't matter for this test.
-        .general,
-    ));
-
-    const CompareInt = struct {
-        inline fn key_from_value(value: *const u32) u32 {
-            return value.*;
-        }
-    };
-
-    const CompareTable = struct {
-        inline fn key_from_value(value: *const TableInfo) u64 {
-            return value.address;
-        }
-    };
-
-    const TestOptions = struct {
-        element_type: type,
-        node_size: u32,
-        element_count_max: u32,
-    };
-
-    var tested_padding = false;
-    var tested_node_capacity_min = false;
-
-    // We want to explore not just the bottom boundary but also the surrounding area
-    // as it may also have interesting edge cases.
-    inline for (.{
-        TestOptions{ .element_type = u32, .node_size = 8, .element_count_max = 3 },
-        TestOptions{ .element_type = u32, .node_size = 8, .element_count_max = 4 },
-        TestOptions{ .element_type = u32, .node_size = 8, .element_count_max = 5 },
-        TestOptions{ .element_type = u32, .node_size = 8, .element_count_max = 6 },
-        TestOptions{ .element_type = u32, .node_size = 8, .element_count_max = 1024 },
-        TestOptions{ .element_type = u32, .node_size = 16, .element_count_max = 1024 },
-        TestOptions{ .element_type = u32, .node_size = 32, .element_count_max = 1024 },
-        TestOptions{ .element_type = u32, .node_size = 64, .element_count_max = 1024 },
-        TestOptions{ .element_type = TableInfo, .node_size = 256, .element_count_max = 3 },
-        TestOptions{ .element_type = TableInfo, .node_size = 256, .element_count_max = 4 },
-        TestOptions{ .element_type = TableInfo, .node_size = 256, .element_count_max = 1024 },
-        TestOptions{ .element_type = TableInfo, .node_size = 512, .element_count_max = 1024 },
-        TestOptions{ .element_type = TableInfo, .node_size = 1024, .element_count_max = 1024 },
-    }) |test_options| {
-        inline for (.{ .sorted, .unsorted }) |order| {
-            const FuzzContext = FuzzContextType(
-                test_options.element_type,
-                test_options.node_size,
-                test_options.element_count_max,
-                if (test_options.element_type == u32) u32 else u64,
-                if (test_options.element_type == u32)
-                    CompareInt.key_from_value
-                else
-                    CompareTable.key_from_value,
-                order,
-                options,
-            );
-
-            var context: FuzzContext = undefined;
-            try context.init(allocator, &prng);
-            defer context.deinit(allocator);
-
-            try context.run();
-
-            if (test_options.node_size % @sizeOf(test_options.element_type) != 0) {
-                tested_padding = true;
-            }
-            if (FuzzContext.TestArray.node_capacity == 2) tested_node_capacity_min = true;
-        }
-    }
-
-    assert(tested_padding);
-    assert(tested_node_capacity_min);
-}