tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/docs_website/src/single_page_writer.zig

@@ -1,169 +0,0 @@
-const std = @import("std");
-
-pub fn main() !void {
-    var args = std.process.args();
-    _ = args.skip();
-
-    var file_buffer: [150 * 1024]u8 = undefined;
-    var stdout = std.io.getStdOut().writer();
-
-    while (args.next()) |page_path| {
-        const html_path = args.next().?;
-        const html = try read_file(std.fs.cwd(), html_path, &file_buffer);
-
-        // Clear links following h1 tags.
-        var clear_h1_link = false;
-
-        var it = AttributeIterator.init(html);
-        while (it.next()) |attribute| {
-            try stdout.writeAll(attribute.prefix);
-
-            if (std.mem.eql(u8, attribute.tag, "use")) {
-                // Don't alter.
-                try stdout.writeAll(attribute.value);
-            } else {
-                // Rewrite attribute values.
-                const is_h1 = std.mem.eql(u8, attribute.tag, "h1");
-                defer clear_h1_link = is_h1;
-
-                const value = if (is_h1 or clear_h1_link) "" else attribute.value;
-                try switch (attribute.typ) {
-                    .link => rewrite_link(value, page_path, stdout),
-                    .id => rewrite_id(value, page_path, stdout),
-                };
-            }
-        }
-        const remaining = it.html[it.position..];
-        try stdout.print("{s}\n", .{remaining});
-    }
-}
-
-fn rewrite_link(link: []const u8, page_path: []const u8, writer: anytype) !void {
-    if (std.mem.startsWith(u8, link, "http") // external link.
-    or std.mem.startsWith(u8, link, "mailto:") // email.
-    or std.mem.startsWith(u8, link, "#cb") // code block link.
-    ) {
-        return try writer.writeAll(link);
-    }
-
-    var base: []const u8 = link;
-    var fragment: ?[]const u8 = null;
-    if (std.mem.lastIndexOfScalar(u8, link, '#')) |index| {
-        base = link[0..index];
-        fragment = link[index + 1 ..];
-    }
-
-    var buffer: [200]u8 = undefined;
-    var fba = std.heap.FixedBufferAllocator.init(&buffer);
-    const allocator = fba.allocator();
-
-    var path = if (base.len > 0 and base[0] == '/')
-        base[1..]
-    else
-        try std.fs.path.resolvePosix(allocator, &.{ page_path, base });
-    if (std.mem.eql(u8, path, ".")) path = "";
-    path = std.mem.trimRight(u8, path, "/");
-
-    const slug = try path2slug(allocator, path);
-    if (fragment) |frag| {
-        if (slug.len > 0) {
-            try writer.print("#{s}-{s}", .{ slug, frag });
-        } else {
-            try writer.print("#{s}", .{frag});
-        }
-    } else {
-        try writer.print("#{s}", .{slug});
-    }
-}
-
-fn rewrite_id(id: []const u8, page_path: []const u8, writer: anytype) !void {
-    if (std.mem.startsWith(u8, id, "cb") // code block lines.
-    ) {
-        return try writer.writeAll(id);
-    }
-
-    if (page_path.len > 0) {
-        var buffer: [200]u8 = undefined;
-        var fba = std.heap.FixedBufferAllocator.init(&buffer);
-        const allocator = fba.allocator();
-        const slug = try path2slug(allocator, page_path);
-        if (id.len > 0) {
-            try writer.print("{s}-{s}", .{ slug, id });
-        } else {
-            try writer.writeAll(slug);
-        }
-    } else {
-        try writer.writeAll(id);
-    }
-}
-
-fn path2slug(allocator: std.mem.Allocator, path: []const u8) ![]const u8 {
-    const slug = try allocator.dupe(u8, path);
-    std.mem.replaceScalar(u8, slug, '/', '-');
-    return slug;
-}
-
-const AttributeIterator = struct {
-    const Attribute = struct {
-        const Type = enum { link, id };
-
-        typ: Type,
-        tag: []const u8,
-        prefix: []const u8,
-        value: []const u8,
-    };
-
-    const link_prefix = "href=\"";
-    const id_prefix = "id=\"";
-
-    html: []const u8,
-    position: usize = 0,
-
-    fn init(html: []const u8) AttributeIterator {
-        return .{ .html = html };
-    }
-
-    fn next(self: *AttributeIterator) ?Attribute {
-        var first_index: ?usize = null;
-        var typ: Attribute.Type = undefined;
-
-        // Find the first link or id attribute.
-        const remaining = self.html[self.position..];
-        if (std.mem.indexOf(u8, remaining, link_prefix)) |link_index| {
-            first_index = link_index + link_prefix.len;
-            typ = .link;
-        }
-        if (std.mem.indexOf(u8, remaining, id_prefix)) |id_index| {
-            if (first_index) |index| {
-                if (id_index < index) {
-                    first_index = id_index + id_prefix.len;
-                    typ = .id;
-                }
-            } else {
-                first_index = id_index + id_prefix.len;
-                typ = .id;
-            }
-        }
-
-        const value_start = first_index orelse return null;
-        const value_len = std.mem.indexOfScalar(u8, remaining[value_start..], '"').?;
-
-        const prefix = remaining[0..value_start];
-        const value = remaining[value_start..][0..value_len];
-        self.position += value_start + value_len;
-
-        // Find the associated tag.
-        const tag_slice = self.html[0 .. self.position - value_len];
-        const tag_index = std.mem.lastIndexOfScalar(u8, tag_slice, '<').? + 1;
-        const tag_len = std.mem.indexOfAny(u8, tag_slice[tag_index..], " \n").?;
-        const tag = tag_slice[tag_index..][0..tag_len];
-
-        return .{ .typ = typ, .tag = tag, .prefix = prefix, .value = value };
-    }
-};
-
-fn read_file(dir: std.fs.Dir, path: []const u8, page_buffer: []u8) ![]const u8 {
-    const result = try dir.readFile(path, page_buffer);
-    if (result.len == page_buffer.len) return error.FileToLarge;
-    return result;
-}

data/ext/tb_client/tigerbeetle/src/docs_website/src/website.zig

@@ -1,46 +0,0 @@
-const std = @import("std");
-const LazyPath = std.Build.LazyPath;
-const Compile = std.Build.Step.Compile;
-
-pub const Website = @This();
-
-pub const file_size_max = 2 << 20; // 1 MiB
-
-url_prefix: []const u8,
-pandoc_bin: LazyPath,
-
-page_writer_exe: *Compile,
-
-pub fn init(b: *std.Build, url_prefix: []const u8, pandoc_bin: LazyPath) Website {
-    return .{
-        .url_prefix = url_prefix,
-        .pandoc_bin = pandoc_bin,
-        .page_writer_exe = b.addExecutable(.{
-            .name = "page_writer",
-            .root_source_file = b.path("src/page_writer.zig"),
-            .target = b.graph.host,
-        }),
-    };
-}
-
-pub fn write_page(self: Website, options: struct {
-    title: []const u8 = "TigerBeetle",
-    author: []const u8 = "TigerBeetle Team",
-    page_path: []const u8,
-    include_search: bool = true,
-    nav: []const u8,
-    content: LazyPath,
-}) LazyPath {
-    const b = self.page_writer_exe.step.owner;
-    const page_writer_run = b.addRunArtifact(self.page_writer_exe);
-    page_writer_run.addArgs(&.{
-        options.title,
-        options.author,
-        self.url_prefix,
-        options.page_path,
-        if (options.include_search) "true" else "false",
-        options.nav,
-    });
-    page_writer_run.addFileArg(options.content);
-    return page_writer_run.addOutputFileArg("page.html");
-}

data/ext/tb_client/tigerbeetle/src/ewah.zig

@@ -1,445 +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 disjoint_slices = stdx.disjoint_slices;
-const maybe = stdx.maybe;
-
-const constants = @import("constants.zig");
-
-/// 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 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 = std.meta.Int(.unsigned, word_bits / 2 - 1); // Word=u64 → u31
-        pub const MarkerLiteralCount = std.meta.Int(.unsigned, word_bits / 2); // Word=u64 → u32
-
-        pub const Marker = packed struct(Word) {
-            // Whether the uniform word is all 0s or all 1s.
-            uniform_bit: u1,
-            // 31-bit number of uniform words following the marker.
-            uniform_word_count: MarkerUniformCount,
-            // 32-bit number of literal words following the uniform words.
-            literal_word_count: MarkerLiteralCount,
-        };
-
-        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(mark);
-        }
-
-        pub const Decoder = struct {
-            /// The number of bytes of the source buffer (the encoded data) that still need to be
-            /// processed.
-            source_size_remaining: usize,
-            target_words: []Word,
-            target_index: usize = 0,
-            source_literal_words: usize = 0,
-
-            /// Returns the number of *words* written to `target_words` by this invocation.
-            // TODO Refactor to return an error when `source_chunk` is invalid,
-            // so that we can test invalid encodings.
-            pub fn decode_chunk(
-                decoder: *Decoder,
-                source_chunk: []align(@alignOf(Word)) const u8,
-            ) usize {
-                assert(source_chunk.len % @sizeOf(Word) == 0);
-
-                decoder.source_size_remaining -= source_chunk.len;
-
-                const source_words = mem.bytesAsSlice(Word, source_chunk);
-                const target_words = decoder.target_words;
-                assert(disjoint_slices(u8, Word, source_chunk, target_words));
-
-                var source_index: usize = 0;
-                var target_index: usize = decoder.target_index;
-                defer decoder.target_index = target_index;
-
-                if (decoder.source_literal_words > 0) {
-                    const literal_word_count_chunk =
-                        @min(decoder.source_literal_words, source_words.len);
-
-                    stdx.copy_disjoint(
-                        .exact,
-                        Word,
-                        target_words[target_index..][0..literal_word_count_chunk],
-                        source_words[source_index..][0..literal_word_count_chunk],
-                    );
-                    source_index += literal_word_count_chunk;
-                    target_index += literal_word_count_chunk;
-                    decoder.source_literal_words -= literal_word_count_chunk;
-                }
-
-                while (source_index < source_words.len) {
-                    assert(decoder.source_literal_words == 0);
-
-                    const marker: *const Marker = @ptrCast(&source_words[source_index]);
-                    source_index += 1;
-                    @memset(
-                        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;
-
-                    const literal_word_count_chunk =
-                        @min(marker.literal_word_count, source_words.len - source_index);
-                    stdx.copy_disjoint(
-                        .exact,
-                        Word,
-                        target_words[target_index..][0..literal_word_count_chunk],
-                        source_words[source_index..][0..literal_word_count_chunk],
-                    );
-                    source_index += literal_word_count_chunk;
-                    target_index += literal_word_count_chunk;
-                    decoder.source_literal_words =
-                        marker.literal_word_count - literal_word_count_chunk;
-                }
-                assert(source_index <= source_words.len);
-                assert(target_index <= target_words.len);
-
-                return target_index - decoder.target_index;
-            }
-
-            pub fn done(decoder: *const Decoder) bool {
-                assert(decoder.target_index <= decoder.target_words.len);
-
-                if (decoder.source_size_remaining == 0) {
-                    assert(decoder.source_literal_words == 0);
-                    return true;
-                } else {
-                    maybe(decoder.source_literal_words == 0);
-                    return false;
-                }
-            }
-        };
-
-        pub fn decode_chunks(target_words: []Word, source_size: usize) Decoder {
-            return .{
-                .target_words = target_words,
-                .source_size_remaining = source_size,
-            };
-        }
-
-        // (This is a helper for testing only.)
-        /// Decodes the compressed bitset in `source` into `target_words`.
-        /// Returns the number of *words* written to `target_words`.
-        pub fn decode_all(source: []align(@alignOf(Word)) const u8, target_words: []Word) usize {
-            comptime assert(constants.verify);
-            assert(source.len % @sizeOf(Word) == 0);
-            assert(disjoint_slices(u8, Word, source, target_words));
-
-            var decoder = decode_chunks(target_words, source.len);
-            return decoder.decode_chunk(source);
-        }
-
-        pub const Encoder = struct {
-            source_words: []const Word,
-            source_index: usize = 0,
-            /// The number of literals left over from the previous encode() call that still need to
-            /// be copied.
-            literal_word_count: usize = 0,
-
-            trailing_zero_runs_count: usize = 0,
-
-            /// Returns the number of bytes written to `target_chunk` by this invocation.
-            pub fn encode_chunk(encoder: *Encoder, target_chunk: []align(@alignOf(Word)) u8) usize {
-                const source_words = encoder.source_words;
-                assert(disjoint_slices(Word, u8, source_words, target_chunk));
-                assert(encoder.source_index <= encoder.source_words.len);
-                assert(encoder.literal_word_count <= encoder.source_words.len);
-
-                const target_words = mem.bytesAsSlice(Word, target_chunk);
-                @memset(target_words, 0);
-
-                var target_index: usize = 0;
-                var source_index: usize = encoder.source_index;
-
-                if (encoder.literal_word_count > 0) {
-                    maybe(encoder.source_index == 0);
-
-                    const literal_word_count_chunk =
-                        @min(encoder.literal_word_count, target_words.len);
-
-                    stdx.copy_disjoint(
-                        .exact,
-                        Word,
-                        target_words[target_index..][0..literal_word_count_chunk],
-                        source_words[source_index..][0..literal_word_count_chunk],
-                    );
-
-                    source_index += literal_word_count_chunk;
-                    target_index += literal_word_count_chunk;
-                    encoder.literal_word_count -= literal_word_count_chunk;
-                }
-
-                while (source_index < source_words.len and target_index < target_words.len) {
-                    assert(encoder.literal_word_count == 0);
-
-                    const word = source_words[source_index];
-
-                    const uniform_word_count = count: {
-                        if (is_literal(word)) break :count 0;
-                        // Measure run length.
-                        const uniform_max = @min(
-                            source_words.len - source_index,
-                            marker_uniform_word_count_max,
-                        );
-                        for (source_words[source_index..][0..uniform_max], 0..) |w, i| {
-                            if (w != word) break :count i;
-                        }
-                        break :count uniform_max;
-                    };
-                    source_index += uniform_word_count;
-                    // For consistent encoding, set the run/uniform bit to 0 when there is no run.
-                    const uniform_bit: u1 =
-                        if (uniform_word_count == 0) 0 else @intCast(word & 1);
-
-                    const literal_word_count = count: {
-                        // Count sequential literals that immediately follow the run.
-                        const literals_max = @min(
-                            source_words.len - source_index,
-                            marker_literal_word_count_max,
-                        );
-                        for (source_words[source_index..][0..literals_max], 0..) |w, i| {
-                            if (!is_literal(w)) break :count i;
-                        }
-                        break :count literals_max;
-                    };
-
-                    target_words[target_index] = marker_word(.{
-                        .uniform_bit = uniform_bit,
-                        .uniform_word_count = @intCast(uniform_word_count),
-                        .literal_word_count = @intCast(literal_word_count),
-                    });
-                    target_index += 1;
-
-                    const literal_word_count_chunk =
-                        @min(literal_word_count, target_words.len - target_index);
-                    stdx.copy_disjoint(
-                        .exact,
-                        Word,
-                        target_words[target_index..][0..literal_word_count_chunk],
-                        source_words[source_index..][0..literal_word_count_chunk],
-                    );
-                    source_index += literal_word_count_chunk;
-                    target_index += literal_word_count_chunk;
-
-                    encoder.literal_word_count = literal_word_count - literal_word_count_chunk;
-
-                    if (uniform_bit == 0 and literal_word_count == 0) {
-                        assert(uniform_word_count > 0);
-                        encoder.trailing_zero_runs_count += 1;
-                    } else {
-                        encoder.trailing_zero_runs_count = 0;
-                    }
-                }
-                assert(source_index <= source_words.len);
-
-                encoder.source_index = source_index;
-                return target_index * @sizeOf(Word);
-            }
-
-            pub fn done(encoder: *const Encoder) bool {
-                assert(encoder.source_index <= encoder.source_words.len);
-                return encoder.source_index == encoder.source_words.len;
-            }
-        };
-
-        pub fn encode_chunks(source_words: []const Word) Encoder {
-            return .{ .source_words = source_words };
-        }
-
-        // (This is a helper for testing only.)
-        // Returns the number of bytes written to `target`.
-        pub fn encode_all(source_words: []const Word, target: []align(@alignOf(Word)) u8) usize {
-            comptime assert(constants.verify);
-            assert(target.len == encode_size_max(source_words.len));
-            assert(disjoint_slices(Word, u8, source_words, target));
-
-            var encoder = encode_chunks(source_words);
-            defer assert(encoder.done());
-
-            return encoder.encode_chunk(target);
-        }
-
-        /// 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 = stdx.PRNG.from_seed_testing();
-
-    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
-        const Context = fuzz.ContextType(Word);
-        for ([_]usize{ 1, 2, 4, 5, 8, 16, 17, 32 }) |chunk_count| {
-            var decoded: [4096]Word = undefined;
-            const fuzz_options: Context.TestOptions = .{
-                .encode_chunk_words_count = @divFloor(decoded.len, chunk_count),
-                .decode_chunk_words_count = @divFloor(decoded.len, chunk_count),
-            };
-
-            @memset(&decoded, 0);
-            try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded, fuzz_options);
-
-            @memset(&decoded, std.math.maxInt(Word));
-            try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded, fuzz_options);
-
-            prng.fill(std.mem.asBytes(&decoded));
-            try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded, fuzz_options);
-        }
-    }
-}
-
-test "ewah Word=u8" {
-    try test_decode_with_word(u8);
-
-    const codec = ewah(u8);
-    for (0..math.maxInt(codec.MarkerUniformCount) + 1) |uniform_word_count| {
-        try test_decode(u8, &.{
-            codec.marker_word(.{
-                .uniform_bit = 0,
-                .uniform_word_count = @intCast(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_all(&.{}, &.{}), 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: []const 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_all(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_all(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_all(encoded_actual, decoded_actual);
-    try std.testing.expectEqual(decoded_expect.len, decoded_actual_length);
-    try std.testing.expectEqualSlices(Word, decoded_expect, decoded_actual);
-}