tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/ewah.zig

@@ -1,286 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const math = std.math;
-const mem = std.mem;
-const stdx = @import("stdx.zig");
-const div_ceil = stdx.div_ceil;
-const disjoint_slices = stdx.disjoint_slices;
-
-/// Encode or decode a bitset using Daniel Lemire's EWAH codec.
-/// ("Histogram-Aware Sorting for Enhanced Word-Aligned Compression in Bitmap Indexes")
-///
-/// EWAH uses only two types of words, where the first type is a 64-bit verbatim ("literal") word.
-/// The second type of word is a marker word:
-/// * The first bit indicates which uniform word will follow.
-/// * The next 31 bits are used to store the number of uniform words.
-/// * The last 32 bits are used to store the number of literal words following the uniform words.
-/// EWAH bitmaps begin with a marker word. A 'marker' looks like (assuming a 64-bit word):
-///
-///     [uniform_bit:u1][uniform_word_count:u31(LE)][literal_word_count:u32(LE)]
-///
-/// and is immediately followed by `literal_word_count` 64-bit literals.
-/// When decoding a marker, the uniform words precede the literal words.
-///
-/// This encoding requires that the architecture is little-endian with 64-bit words.
-pub fn ewah(comptime Word: type) type {
-    const word_bits = @bitSizeOf(Word);
-
-    return struct {
-        const Self = @This();
-
-        const marker_uniform_word_count_max = (1 << ((word_bits / 2) - 1)) - 1;
-        const marker_literal_word_count_max = (1 << (word_bits / 2)) - 1;
-
-        pub const MarkerUniformCount = math.IntFittingRange(0, marker_uniform_word_count_max); // Word=usize → u31
-        pub const MarkerLiteralCount = math.IntFittingRange(0, marker_literal_word_count_max); // Word=usize → u32
-
-        const Marker = packed struct {
-            uniform_bit: u1, // Whether the uniform word is all 0s or all 1s.
-            uniform_word_count: MarkerUniformCount, // 31-bit number of uniform words following the marker.
-            literal_word_count: MarkerLiteralCount, // 32-bit number of literal words following the uniform words.
-        };
-
-        comptime {
-            assert(@import("builtin").target.cpu.arch.endian() == std.builtin.Endian.Little);
-            assert(@typeInfo(Word).Int.signedness == .unsigned);
-            assert(word_bits % 8 == 0); // A multiple of a byte, so that words can be cast to bytes.
-            assert(@bitSizeOf(Marker) == word_bits);
-            assert(@sizeOf(Marker) == @sizeOf(Word));
-
-            assert(@bitSizeOf(MarkerUniformCount) % 2 == 1);
-            assert(math.maxInt(MarkerUniformCount) == marker_uniform_word_count_max);
-
-            assert(@bitSizeOf(MarkerLiteralCount) % 2 == 0);
-            assert(math.maxInt(MarkerLiteralCount) == marker_literal_word_count_max);
-        }
-
-        inline fn marker_word(mark: Marker) Word {
-            return @bitCast(Word, mark);
-        }
-
-        /// Decodes the compressed bitset in `source` into `target_words`.
-        /// Returns the number of *words* written to `target_words`.
-        // TODO Refactor to return an error when `source` is invalid,
-        // so that we can test invalid encodings.
-        pub fn decode(source: []align(@alignOf(Word)) const u8, target_words: []Word) usize {
-            assert(source.len % @sizeOf(Word) == 0);
-            assert(disjoint_slices(u8, Word, source, target_words));
-
-            const source_words = mem.bytesAsSlice(Word, source);
-            var source_index: usize = 0;
-            var target_index: usize = 0;
-            while (source_index < source_words.len) {
-                const marker = @ptrCast(*const Marker, &source_words[source_index]);
-                source_index += 1;
-                std.mem.set(
-                    Word,
-                    target_words[target_index..][0..marker.uniform_word_count],
-                    if (marker.uniform_bit == 1) ~@as(Word, 0) else 0,
-                );
-                target_index += marker.uniform_word_count;
-                stdx.copy_disjoint(
-                    .exact,
-                    Word,
-                    target_words[target_index..][0..marker.literal_word_count],
-                    source_words[source_index..][0..marker.literal_word_count],
-                );
-                source_index += marker.literal_word_count;
-                target_index += marker.literal_word_count;
-            }
-            assert(source_index == source_words.len);
-            assert(target_index <= target_words.len);
-            return target_index;
-        }
-
-        // Returns the number of bytes written to `target`.
-        pub fn encode(source_words: []const Word, target: []align(@alignOf(Word)) u8) usize {
-            assert(target.len == encode_size_max(source_words.len));
-            assert(disjoint_slices(Word, u8, source_words, target));
-
-            const target_words = mem.bytesAsSlice(Word, target);
-            std.mem.set(Word, target_words, 0);
-
-            var target_index: usize = 0;
-            var source_index: usize = 0;
-            while (source_index < source_words.len) {
-                const word = source_words[source_index];
-
-                const uniform_word_count = count: {
-                    if (is_literal(word)) break :count 0;
-                    // Measure run length.
-                    const uniform_max = math.min(source_words.len - source_index, marker_uniform_word_count_max);
-                    var uniform: usize = 1;
-                    while (uniform < uniform_max and source_words[source_index + uniform] == word) uniform += 1;
-                    break :count uniform;
-                };
-                source_index += uniform_word_count;
-                // For consistent encoding, set the run/uniform bit to 0 when there is no run.
-                const uniform_bit = if (uniform_word_count == 0) 0 else @intCast(u1, word & 1);
-
-                // Count sequential literals that immediately follow the run.
-                const literals_max = math.min(source_words.len - source_index, marker_literal_word_count_max);
-                const literal_word_count = for (source_words[source_index..][0..literals_max]) |w, i| {
-                    if (!is_literal(w)) break i;
-                } else literals_max;
-
-                target_words[target_index] = marker_word(.{
-                    .uniform_bit = uniform_bit,
-                    .uniform_word_count = @intCast(MarkerUniformCount, uniform_word_count),
-                    .literal_word_count = @intCast(MarkerLiteralCount, literal_word_count),
-                });
-                target_index += 1;
-                stdx.copy_disjoint(
-                    .exact,
-                    Word,
-                    target_words[target_index..][0..literal_word_count],
-                    source_words[source_index..][0..literal_word_count],
-                );
-                source_index += literal_word_count;
-                target_index += literal_word_count;
-            }
-            assert(source_index == source_words.len);
-
-            return target_index * @sizeOf(Word);
-        }
-
-        /// Returns the maximum number of bytes required to encode `word_count` words.
-        /// Assumes (pessimistically) that every word will be encoded as a literal.
-        pub fn encode_size_max(word_count: usize) usize {
-            const marker_count = div_ceil(word_count, marker_literal_word_count_max);
-            return marker_count * @sizeOf(Marker) + word_count * @sizeOf(Word);
-        }
-
-        inline fn is_literal(word: Word) bool {
-            return word != 0 and word != ~@as(Word, 0);
-        }
-    };
-}
-
-test "ewah encode→decode cycle" {
-    const fuzz = @import("./ewah_fuzz.zig");
-    var prng = std.rand.DefaultPrng.init(123);
-
-    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
-        var decoded: [4096]Word = undefined;
-
-        std.mem.set(Word, &decoded, 0);
-        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
-
-        std.mem.set(Word, &decoded, std.math.maxInt(Word));
-        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
-
-        prng.random().bytes(std.mem.asBytes(&decoded));
-        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
-    }
-}
-
-test "ewah Word=u8" {
-    try test_decode_with_word(u8);
-
-    const codec = ewah(u8);
-    var uniform_word_count: usize = 0;
-    while (uniform_word_count <= math.maxInt(codec.MarkerUniformCount)) : (uniform_word_count += 1) {
-        try test_decode(u8, &.{
-            codec.marker_word(.{
-                .uniform_bit = 0,
-                .uniform_word_count = @intCast(codec.MarkerUniformCount, uniform_word_count),
-                .literal_word_count = 3,
-            }),
-            12,
-            34,
-            56,
-        });
-    }
-
-    try std.testing.expectEqual(codec.encode_size_max(0), 0);
-    try std.testing.expectEqual(codec.encode(&.{}, &.{}), 0);
-}
-
-test "ewah Word=u16" {
-    try test_decode_with_word(u16);
-}
-
-// decode → encode → decode
-fn test_decode_with_word(comptime Word: type) !void {
-    const codec = ewah(Word);
-
-    // No set bits.
-    try test_decode(Word, &.{});
-    // Alternating runs, no literals.
-    try test_decode(Word, &.{
-        codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 2, .literal_word_count = 0 }),
-        codec.marker_word(.{ .uniform_bit = 1, .uniform_word_count = 3, .literal_word_count = 0 }),
-        codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 4, .literal_word_count = 0 }),
-    });
-    // Alternating runs, with literals.
-    try test_decode(Word, &.{
-        codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 2, .literal_word_count = 1 }),
-        12,
-        codec.marker_word(.{ .uniform_bit = 1, .uniform_word_count = 3, .literal_word_count = 1 }),
-        34,
-        codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 4, .literal_word_count = 1 }),
-        56,
-    });
-    // Consecutive run marker overflow.
-    try test_decode(Word, &.{
-        codec.marker_word(.{
-            .uniform_bit = 0,
-            .uniform_word_count = math.maxInt(codec.MarkerUniformCount),
-            .literal_word_count = 0,
-        }),
-        codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 2, .literal_word_count = 0 }),
-    });
-
-    var encoding = std.ArrayList(Word).init(std.testing.allocator);
-    defer encoding.deinit();
-
-    {
-        // Consecutive literal marker overflow.
-        try encoding.append(codec.marker_word(.{
-            .uniform_bit = 0,
-            .uniform_word_count = 0,
-            .literal_word_count = math.maxInt(codec.MarkerLiteralCount),
-        }));
-        var i: Word = 0;
-        while (i < math.maxInt(codec.MarkerLiteralCount)) : (i += 1) try encoding.append(i + 1);
-        try encoding.append(codec.marker_word(.{
-            .uniform_bit = 0,
-            .uniform_word_count = 0,
-            .literal_word_count = 2,
-        }));
-        try encoding.append(i + 2);
-        try encoding.append(i + 3);
-        try test_decode(Word, encoding.items);
-        encoding.items.len = 0;
-    }
-}
-
-fn test_decode(comptime Word: type, encoded_expect_words: []Word) !void {
-    const encoded_expect = mem.sliceAsBytes(encoded_expect_words);
-    const codec = ewah(Word);
-    const decoded_expect_data = try std.testing.allocator.alloc(Word, 4 * math.maxInt(Word));
-    defer std.testing.allocator.free(decoded_expect_data);
-
-    const decoded_expect_length = codec.decode(encoded_expect, decoded_expect_data);
-    const decoded_expect = decoded_expect_data[0..decoded_expect_length];
-    const encoded_actual = try std.testing.allocator.alignedAlloc(
-        u8,
-        @alignOf(Word),
-        codec.encode_size_max(decoded_expect.len),
-    );
-    defer std.testing.allocator.free(encoded_actual);
-
-    const encoded_actual_length = codec.encode(decoded_expect, encoded_actual);
-    try std.testing.expectEqual(encoded_expect.len, encoded_actual_length);
-    try std.testing.expectEqualSlices(u8, encoded_expect, encoded_actual[0..encoded_actual_length]);
-
-    const encoded_size_max = codec.encode_size_max(decoded_expect.len);
-    try std.testing.expect(encoded_expect.len <= encoded_size_max);
-
-    const decoded_actual = try std.testing.allocator.alloc(Word, decoded_expect.len);
-    defer std.testing.allocator.free(decoded_actual);
-
-    const decoded_actual_length = codec.decode(encoded_actual, decoded_actual);
-    try std.testing.expectEqual(decoded_expect.len, decoded_actual_length);
-    try std.testing.expectEqualSlices(Word, decoded_expect, decoded_actual);
-}

package/src/tigerbeetle/src/ewah_benchmark.zig

@@ -1,120 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const ewah = @import("ewah.zig").ewah(usize);
-
-const BitSetConfig = struct {
-    words: usize,
-    run_length_e: usize,
-    literals_length_e: usize,
-};
-
-const samples = 100;
-const repeats: usize = 100_000;
-
-// Explanation of fields:
-// - "n": Number of randomly generate bitsets to test.
-// - "words": The length of the decoded bitset, in u64s.
-// - "run_length_e": The expected length of a run, ignoring truncation due to reaching the end of
-//   the bitset.
-// - "literals_length_e": Expected length of a sequence of literals.
-const configs = [_]BitSetConfig{
-    // primarily runs
-    .{ .words = 640, .run_length_e = 10, .literals_length_e = 10 },
-    .{ .words = 640, .run_length_e = 100, .literals_length_e = 10 },
-    .{ .words = 640, .run_length_e = 200, .literals_length_e = 10 },
-    // primarily literals
-    .{ .words = 640, .run_length_e = 1, .literals_length_e = 100 },
-};
-
-var prng = std.rand.DefaultPrng.init(42);
-
-pub fn main() !void {
-    const stdout = std.io.getStdOut().writer();
-
-    for (configs) |config| {
-        var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-        defer arena.deinit();
-
-        const allocator = arena.allocator();
-        var i: usize = 0;
-        var bitsets: [samples][]usize = undefined;
-        var bitsets_encoded: [samples][]align(@alignOf(usize)) u8 = undefined;
-        var bitsets_decoded: [samples][]usize = undefined;
-        var bitset_lengths: [samples]usize = undefined;
-        while (i < samples) : (i += 1) {
-            bitsets[i] = try make_bitset(allocator, config);
-            bitsets_encoded[i] = try allocator.alignedAlloc(u8, @alignOf(usize), ewah.encode_size_max(bitsets[0].len));
-            bitsets_decoded[i] = try allocator.alloc(usize, config.words);
-        }
-
-        // Benchmark encoding.
-        const encode_timer = try std.time.Timer.start();
-        i = 0;
-        while (i < samples) : (i += 1) {
-            var j: usize = 0;
-            var size: usize = undefined;
-            while (j < repeats) : (j += 1) {
-                size = ewah.encode(bitsets[i], bitsets_encoded[i]);
-            }
-            bitset_lengths[i] = size;
-        }
-        const encode_time = encode_timer.read() / samples / repeats;
-
-        const decode_timer = try std.time.Timer.start();
-        // Benchmark decoding.
-        i = 0;
-        while (i < samples) : (i += 1) {
-            const bitset_encoded = bitsets_encoded[i][0..bitset_lengths[i]];
-            var j: usize = 0;
-            while (j < repeats) : (j += 1) {
-                _ = ewah.decode(bitset_encoded, bitsets_decoded[i]);
-            }
-        }
-        const decode_time = decode_timer.read() / samples / repeats;
-
-        i = 0;
-        while (i < samples) : (i += 1) {
-            assert(std.mem.eql(usize, bitsets[i], bitsets_decoded[i]));
-        }
-
-        // Compute compression ratio.
-        var total_uncompressed: f64 = 0.0;
-        var total_compressed: f64 = 0.0;
-        i = 0;
-        while (i < samples) : (i += 1) {
-            total_uncompressed += @intToFloat(f64, bitsets[i].len * @sizeOf(usize));
-            total_compressed += @intToFloat(f64, bitset_lengths[i]);
-        }
-
-        try stdout.print("Words={:_>3} E(Run)={:_>3} E(Literal)={:_>3} EncTime={:_>6}ns DecTime={:_>6}ns Ratio={d:_>6.2}\n", .{
-            config.words,
-            config.run_length_e,
-            config.literals_length_e,
-            encode_time,
-            decode_time,
-            total_uncompressed / total_compressed,
-        });
-    }
-}
-
-fn make_bitset(allocator: std.mem.Allocator, config: BitSetConfig) ![]usize {
-    var words = try allocator.alloc(usize, config.words);
-    var w: usize = 0;
-    var literal: usize = 1;
-    while (w < words.len) : (w += 1) {
-        const run_length = prng.random().uintLessThan(usize, 2 * config.run_length_e);
-        const literals_length = prng.random().uintLessThan(usize, 2 * config.literals_length_e);
-        const run_bit = prng.random().boolean();
-
-        const run_end = std.math.min(w + run_length, words.len);
-        while (w < run_end) : (w += 1) {
-            words[w] = if (run_bit) std.math.maxInt(usize) else 0;
-        }
-        const literals_end = std.math.min(w + literals_length, words.len);
-        while (w < literals_end) : (w += 1) {
-            words[w] = literal;
-            literal += 1;
-        }
-    }
-    return words;
-}

package/src/tigerbeetle/src/ewah_fuzz.zig

@@ -1,130 +0,0 @@
-//! Fuzz EWAH encode/decode cycle.
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.fuzz_ewah);
-
-const ewah = @import("./ewah.zig");
-const fuzz = @import("./testing/fuzz.zig");
-
-pub const tigerbeetle_config = @import("config.zig").configs.test_min;
-
-pub fn main() !void {
-    const allocator = std.testing.allocator;
-    const args = try fuzz.parse_fuzz_args(allocator);
-
-    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
-        var prng = std.rand.DefaultPrng.init(args.seed);
-        const random = prng.random();
-
-        const decoded_size_max = @divExact(1024 * 1024, @sizeOf(Word));
-        const decoded_size = random.uintLessThan(usize, 1 + decoded_size_max);
-        const decoded = try allocator.alloc(Word, decoded_size);
-        defer allocator.free(decoded);
-
-        const decoded_bits_total = decoded_size * @bitSizeOf(Word);
-        const decoded_bits = random.uintLessThan(usize, decoded_bits_total);
-        generate_bits(random, std.mem.sliceAsBytes(decoded[0..decoded_size]), decoded_bits);
-
-        var context = try ContextType(Word).init(allocator, decoded.len);
-        defer context.deinit(allocator);
-
-        const encoded_size = try context.test_encode_decode(decoded);
-
-        log.info("word={} decoded={} encoded={} compression_ratio={d:.2} set={d:.2}", .{
-            Word,
-            decoded_size,
-            encoded_size,
-            @intToFloat(f64, decoded_size) / @intToFloat(f64, encoded_size),
-            @intToFloat(f64, decoded_bits) / @intToFloat(f64, decoded_bits_total),
-        });
-    }
-}
-
-pub fn fuzz_encode_decode(
-    comptime Word: type,
-    allocator: std.mem.Allocator,
-    decoded: []const Word,
-) !void {
-    var context = try ContextType(Word).init(allocator, decoded.len);
-    defer context.deinit(allocator);
-
-    _ = try context.test_encode_decode(decoded);
-}
-
-/// Modify `data` such that it has exactly `bits_set_total` randomly-chosen bits set,
-/// with the remaining bits unset.
-fn generate_bits(random: std.rand.Random, data: []u8, bits_set_total: usize) void {
-    const bits_total = data.len * @bitSizeOf(u8);
-    assert(bits_set_total <= bits_total);
-
-    // Start off full or empty to save some work.
-    const init_empty = bits_set_total < @divExact(bits_total, 2);
-    std.mem.set(u8, data, if (init_empty) @as(u8, 0) else std.math.maxInt(u8));
-
-    var bits_set = if (init_empty) 0 else bits_total;
-    while (bits_set != bits_set_total) {
-        const bit = random.uintLessThan(usize, bits_total);
-        const word = @divFloor(bit, @bitSizeOf(u8));
-        const mask = @as(u8, 1) << @intCast(std.math.Log2Int(u8), bit % @bitSizeOf(u8));
-
-        if (init_empty) {
-            if (data[word] & mask != 0) continue;
-            data[word] |= mask;
-            bits_set += 1;
-        } else {
-            if (data[word] & mask == 0) continue;
-            data[word] &= ~mask;
-            bits_set -= 1;
-        }
-    }
-}
-
-fn ContextType(comptime Word: type) type {
-    return struct {
-        const Self = @This();
-        const Codec = ewah.ewah(Word);
-
-        decoded_actual: []Word,
-        encoded_actual: []align(@alignOf(Word)) u8,
-
-        fn init(allocator: std.mem.Allocator, size_max: usize) !Self {
-            const decoded_actual = try allocator.alloc(Word, size_max);
-            errdefer allocator.free(decoded_actual);
-
-            const encoded_actual = try allocator.alignedAlloc(
-                u8,
-                @alignOf(Word),
-                Codec.encode_size_max(size_max),
-            );
-            errdefer allocator.free(encoded_actual);
-
-            return Self{
-                .decoded_actual = decoded_actual,
-                .encoded_actual = encoded_actual,
-            };
-        }
-
-        fn deinit(context: *Self, allocator: std.mem.Allocator) void {
-            allocator.free(context.decoded_actual);
-            allocator.free(context.encoded_actual);
-        }
-
-        fn test_encode_decode(context: Self, decoded_expect: []const Word) !usize {
-            assert(decoded_expect.len > 0);
-
-            const encoded_size = Codec.encode(decoded_expect, context.encoded_actual);
-            const decoded_actual_size = Codec.decode(
-                context.encoded_actual[0..encoded_size],
-                context.decoded_actual[0..],
-            );
-
-            try std.testing.expectEqual(decoded_expect.len, decoded_actual_size);
-            try std.testing.expectEqualSlices(
-                Word,
-                decoded_expect,
-                context.decoded_actual[0..decoded_actual_size],
-            );
-            return encoded_size;
-        }
-    };
-}

package/src/tigerbeetle/src/fifo.zig

@@ -1,120 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// An intrusive first in/first out linked list.
-/// The element type T must have a field called "next" of type ?*T
-pub fn FIFO(comptime T: type) type {
-    return struct {
-        const Self = @This();
-
-        in: ?*T = null,
-        out: ?*T = null,
-
-        pub fn push(self: *Self, elem: *T) void {
-            assert(elem.next == null);
-            if (self.in) |in| {
-                in.next = elem;
-                self.in = elem;
-            } else {
-                assert(self.out == null);
-                self.in = elem;
-                self.out = elem;
-            }
-        }
-
-        pub fn pop(self: *Self) ?*T {
-            const ret = self.out orelse return null;
-            self.out = ret.next;
-            ret.next = null;
-            if (self.in == ret) self.in = null;
-            return ret;
-        }
-
-        pub fn peek(self: Self) ?*T {
-            return self.out;
-        }
-
-        pub fn empty(self: Self) bool {
-            return self.peek() == null;
-        }
-
-        /// Remove an element from the FIFO. Asserts that the element is
-        /// in the FIFO. This operation is O(N), if this is done often you
-        /// probably want a different data structure.
-        pub fn remove(self: *Self, to_remove: *T) void {
-            if (to_remove == self.out) {
-                _ = self.pop();
-                return;
-            }
-            var it = self.out;
-            while (it) |elem| : (it = elem.next) {
-                if (to_remove == elem.next) {
-                    if (to_remove == self.in) self.in = elem;
-                    elem.next = to_remove.next;
-                    to_remove.next = null;
-                    break;
-                }
-            } else unreachable;
-        }
-    };
-}
-
-test "push/pop/peek/remove/empty" {
-    const testing = @import("std").testing;
-
-    const Foo = struct { next: ?*@This() = null };
-
-    var one: Foo = .{};
-    var two: Foo = .{};
-    var three: Foo = .{};
-
-    var fifo: FIFO(Foo) = .{};
-    try testing.expect(fifo.empty());
-
-    fifo.push(&one);
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &one), fifo.peek());
-
-    fifo.push(&two);
-    fifo.push(&three);
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &one), fifo.peek());
-
-    fifo.remove(&one);
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &two), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-    try testing.expect(fifo.empty());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.push(&three);
-    fifo.remove(&two);
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-    try testing.expect(fifo.empty());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.push(&three);
-    fifo.remove(&three);
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expect(!fifo.empty());
-    try testing.expectEqual(@as(?*Foo, &two), fifo.pop());
-    try testing.expect(fifo.empty());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-    try testing.expect(fifo.empty());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.remove(&two);
-    fifo.push(&three);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-    try testing.expect(fifo.empty());
-}