tigerbeetle 0.0.36 → 0.0.38

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

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,445 @@
+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);
+}