@xincli/opentui-core 0.4.6 → 0.4.7

package/src/zig/tests/mem-registry_test.zig

@@ -1,473 +0,0 @@
-const std = @import("std");
-const mem_registry = @import("../mem-registry.zig");
-
-const MemRegistry = mem_registry.MemRegistry;
-const MemRegistryError = mem_registry.MemRegistryError;
-
-test "MemRegistry - init and deinit" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 255), registry.getFreeSlots());
-}
-
-test "MemRegistry - register owned memory" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = try std.testing.allocator.dupe(u8, "Hello, World!");
-    const id = try registry.register(text, true);
-
-    try std.testing.expectEqual(@as(u8, 0), id);
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 254), registry.getFreeSlots());
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqualStrings("Hello, World!", retrieved.?);
-}
-
-test "MemRegistry - register non-owned memory" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = "Hello, World!";
-    const id = try registry.register(text, false);
-
-    try std.testing.expectEqual(@as(u8, 0), id);
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqualStrings("Hello, World!", retrieved.?);
-}
-
-test "MemRegistry - register multiple buffers" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "First";
-    const text2 = "Second";
-    const text3 = "Third";
-
-    const id1 = try registry.register(text1, false);
-    const id2 = try registry.register(text2, false);
-    const id3 = try registry.register(text3, false);
-
-    try std.testing.expectEqual(@as(u8, 0), id1);
-    try std.testing.expectEqual(@as(u8, 1), id2);
-    try std.testing.expectEqual(@as(u8, 2), id3);
-    try std.testing.expectEqual(@as(usize, 3), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 252), registry.getFreeSlots());
-
-    try std.testing.expectEqualStrings("First", registry.get(id1).?);
-    try std.testing.expectEqualStrings("Second", registry.get(id2).?);
-    try std.testing.expectEqualStrings("Third", registry.get(id3).?);
-}
-
-test "MemRegistry - get invalid ID returns null" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = "Test";
-    _ = try registry.register(text, false);
-
-    try std.testing.expect(registry.get(1) == null);
-    try std.testing.expect(registry.get(5) == null);
-    try std.testing.expect(registry.get(255) == null);
-}
-
-test "MemRegistry - replace owned buffer" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = try std.testing.allocator.dupe(u8, "Original");
-    const id = try registry.register(text1, true);
-
-    const text2 = try std.testing.allocator.dupe(u8, "Replaced");
-    try registry.replace(id, text2, true);
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqualStrings("Replaced", retrieved.?);
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-}
-
-test "MemRegistry - replace non-owned buffer with owned" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "Original";
-    const id = try registry.register(text1, false);
-
-    const text2 = try std.testing.allocator.dupe(u8, "Replaced");
-    try registry.replace(id, text2, true);
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqualStrings("Replaced", retrieved.?);
-}
-
-test "MemRegistry - replace with invalid ID" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = "Test";
-    const result = registry.replace(5, text, false);
-    try std.testing.expectError(MemRegistryError.InvalidMemId, result);
-}
-
-test "MemRegistry - clear owned buffers" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = try std.testing.allocator.dupe(u8, "First");
-    const text2 = try std.testing.allocator.dupe(u8, "Second");
-    _ = try registry.register(text1, true);
-    _ = try registry.register(text2, true);
-
-    try std.testing.expectEqual(@as(usize, 2), registry.getUsedSlots());
-
-    registry.clear();
-
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 255), registry.getFreeSlots());
-}
-
-test "MemRegistry - clear non-owned buffers" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "First";
-    const text2 = "Second";
-    _ = try registry.register(text1, false);
-    _ = try registry.register(text2, false);
-
-    try std.testing.expectEqual(@as(usize, 2), registry.getUsedSlots());
-
-    registry.clear();
-
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-}
-
-test "MemRegistry - max capacity" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    var i: usize = 0;
-    while (i < 255) : (i += 1) {
-        const text = "test";
-        _ = try registry.register(text, false);
-    }
-
-    try std.testing.expectEqual(@as(usize, 255), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 0), registry.getFreeSlots());
-
-    const text = "overflow";
-    const result = registry.register(text, false);
-    try std.testing.expectError(MemRegistryError.OutOfMemory, result);
-}
-
-test "MemRegistry - clear and reuse" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "First";
-    const id1 = try registry.register(text1, false);
-    try std.testing.expectEqual(@as(u8, 0), id1);
-
-    registry.clear();
-
-    const text2 = "Second";
-    const id2 = try registry.register(text2, false);
-    try std.testing.expectEqual(@as(u8, 0), id2);
-    try std.testing.expectEqualStrings("Second", registry.get(id2).?);
-}
-
-test "MemRegistry - mixed owned and non-owned buffers" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const owned = try std.testing.allocator.dupe(u8, "Owned");
-    const non_owned = "Not Owned";
-
-    const id1 = try registry.register(owned, true);
-    const id2 = try registry.register(non_owned, false);
-
-    try std.testing.expectEqual(@as(usize, 2), registry.getUsedSlots());
-
-    try std.testing.expectEqualStrings("Owned", registry.get(id1).?);
-    try std.testing.expectEqualStrings("Not Owned", registry.get(id2).?);
-
-    registry.clear();
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-}
-
-test "MemRegistry - large buffer registration" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const large_text = [_]u8{'A'} ** 10000;
-    const id = try registry.register(&large_text, false);
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqual(@as(usize, 10000), retrieved.?.len);
-}
-
-test "MemRegistry - empty buffer registration" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const empty = "";
-    const id = try registry.register(empty, false);
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqual(@as(usize, 0), retrieved.?.len);
-}
-
-test "MemRegistry - sequential replace operations" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "First";
-    const id = try registry.register(text1, false);
-
-    const text2 = "Second";
-    try registry.replace(id, text2, false);
-    try std.testing.expectEqualStrings("Second", registry.get(id).?);
-
-    const text3 = "Third";
-    try registry.replace(id, text3, false);
-    try std.testing.expectEqualStrings("Third", registry.get(id).?);
-
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-}
-
-test "MemRegistry - replace owned with non-owned" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = try std.testing.allocator.dupe(u8, "Owned");
-    const id = try registry.register(text1, true);
-
-    const text2 = "Not Owned";
-    try registry.replace(id, text2, false);
-
-    const retrieved = registry.get(id);
-    try std.testing.expect(retrieved != null);
-    try std.testing.expectEqualStrings("Not Owned", retrieved.?);
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-}
-
-test "MemRegistry - stress test with many registrations and clears" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    var round: usize = 0;
-    while (round < 10) : (round += 1) {
-        var i: usize = 0;
-        while (i < 50) : (i += 1) {
-            const text = "test";
-            _ = try registry.register(text, false);
-        }
-        try std.testing.expectEqual(@as(usize, 50), registry.getUsedSlots());
-        registry.clear();
-        try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    }
-}
-
-test "MemRegistry - unregister basic" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = "Hello";
-    const id = try registry.register(text, false);
-
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-    try std.testing.expectEqualStrings("Hello", registry.get(id).?);
-
-    try registry.unregister(id);
-
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    try std.testing.expect(registry.get(id) == null);
-}
-
-test "MemRegistry - unregister owned buffer frees memory" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = try std.testing.allocator.dupe(u8, "Owned Buffer");
-    const id = try registry.register(text, true);
-
-    try std.testing.expectEqual(@as(usize, 1), registry.getUsedSlots());
-
-    // Should free the memory when unregistered
-    try registry.unregister(id);
-
-    try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    try std.testing.expect(registry.get(id) == null);
-}
-
-test "MemRegistry - unregister invalid ID" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const result = registry.unregister(5);
-    try std.testing.expectError(MemRegistryError.InvalidMemId, result);
-}
-
-test "MemRegistry - unregister twice fails" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text = "Test";
-    const id = try registry.register(text, false);
-
-    try registry.unregister(id);
-
-    // Second unregister should fail
-    const result = registry.unregister(id);
-    try std.testing.expectError(MemRegistryError.InvalidMemId, result);
-}
-
-test "MemRegistry - slot reuse after unregister" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "First";
-    const text2 = "Second";
-    const text3 = "Third";
-
-    const id1 = try registry.register(text1, false);
-    const id2 = try registry.register(text2, false);
-    const id3 = try registry.register(text3, false);
-
-    try std.testing.expectEqual(@as(u8, 0), id1);
-    try std.testing.expectEqual(@as(u8, 1), id2);
-    try std.testing.expectEqual(@as(u8, 2), id3);
-    try std.testing.expectEqual(@as(usize, 3), registry.getUsedSlots());
-
-    // Unregister middle slot
-    try registry.unregister(id2);
-    try std.testing.expectEqual(@as(usize, 2), registry.getUsedSlots());
-
-    // Register new buffer - should reuse slot 1
-    const text4 = "Fourth";
-    const id4 = try registry.register(text4, false);
-    try std.testing.expectEqual(@as(u8, 1), id4);
-    try std.testing.expectEqual(@as(usize, 3), registry.getUsedSlots());
-
-    // Verify contents
-    try std.testing.expectEqualStrings("First", registry.get(id1).?);
-    try std.testing.expectEqualStrings("Fourth", registry.get(id4).?);
-    try std.testing.expectEqualStrings("Third", registry.get(id3).?);
-}
-
-test "MemRegistry - thousands of register/unregister cycles" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    // Simulate thousands of register/unregister operations
-    // This ensures slot reuse works over long periods
-    var cycle: usize = 0;
-    while (cycle < 1000) : (cycle += 1) {
-        var ids: [10]u8 = undefined;
-
-        // Register 10 buffers
-        var i: usize = 0;
-        while (i < 10) : (i += 1) {
-            const text = "test";
-            ids[i] = try registry.register(text, false);
-        }
-
-        try std.testing.expectEqual(@as(usize, 10), registry.getUsedSlots());
-
-        // Unregister all
-        i = 0;
-        while (i < 10) : (i += 1) {
-            try registry.unregister(ids[i]);
-        }
-
-        try std.testing.expectEqual(@as(usize, 0), registry.getUsedSlots());
-    }
-
-    // Verify we can still register after all those cycles
-    const text = "final";
-    const id = try registry.register(text, false);
-    try std.testing.expectEqualStrings("final", registry.get(id).?);
-}
-
-test "MemRegistry - max capacity 255 with slot reuse" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    // Fill all 255 slots
-    // NOTE: This test ensures the registry respects the u8 ID limit (max 255 slots).
-    // If the ID type is changed from u8 to u16, this test would fail because:
-    // 1. The test fills exactly 255 slots
-    // 2. It expects OutOfMemory error on the 256th registration
-    // 3. With u16, the limit would be 65535, so no error would occur
-    var i: usize = 0;
-    var ids: [255]u8 = undefined;
-    while (i < 255) : (i += 1) {
-        const text = "test";
-        ids[i] = try registry.register(text, false);
-    }
-
-    try std.testing.expectEqual(@as(usize, 255), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 0), registry.getFreeSlots());
-
-    // Should fail to register one more
-    const text = "overflow";
-    const result = registry.register(text, false);
-    try std.testing.expectError(MemRegistryError.OutOfMemory, result);
-
-    // Unregister one slot
-    try registry.unregister(ids[100]);
-    try std.testing.expectEqual(@as(usize, 254), registry.getUsedSlots());
-    try std.testing.expectEqual(@as(usize, 1), registry.getFreeSlots());
-
-    // Now we should be able to register again
-    const new_text = "reused";
-    const new_id = try registry.register(new_text, false);
-    try std.testing.expectEqual(@as(u8, 100), new_id); // Should reuse slot 100
-    try std.testing.expectEqualStrings("reused", registry.get(new_id).?);
-}
-
-test "MemRegistry - replace inactive slot fails" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    const text1 = "Original";
-    const id = try registry.register(text1, false);
-
-    try registry.unregister(id);
-
-    // Try to replace inactive slot
-    const text2 = "Replacement";
-    const result = registry.replace(id, text2, false);
-    try std.testing.expectError(MemRegistryError.InvalidMemId, result);
-}
-
-test "MemRegistry - getFreeSlots accounts for unregistered slots" {
-    var registry = MemRegistry.init(std.testing.allocator);
-    defer registry.deinit();
-
-    try std.testing.expectEqual(@as(usize, 255), registry.getFreeSlots());
-
-    const id1 = try registry.register("test1", false);
-    const id2 = try registry.register("test2", false);
-    const id3 = try registry.register("test3", false);
-
-    try std.testing.expectEqual(@as(usize, 252), registry.getFreeSlots());
-
-    try registry.unregister(id2);
-    try std.testing.expectEqual(@as(usize, 253), registry.getFreeSlots());
-
-    try registry.unregister(id1);
-    try registry.unregister(id3);
-    try std.testing.expectEqual(@as(usize, 255), registry.getFreeSlots());
-}

package/src/zig/tests/memory_leak_regression_test.zig

@@ -1,234 +0,0 @@
-const std = @import("std");
-const gp = @import("../grapheme.zig");
-
-const GraphemePool = gp.GraphemePool;
-const GraphemePoolError = gp.GraphemePoolError;
-
-test "GraphemePool - invalid class_id returns InvalidId" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    // class_id 5, 6, 7 are invalid (valid are 0-4)
-    for ([_]u32{ 5, 6, 7 }) |invalid_class_id| {
-        const invalid_id = (invalid_class_id << (gp.GENERATION_BITS + gp.SLOT_BITS));
-
-        try std.testing.expectError(GraphemePoolError.InvalidId, pool.incref(invalid_id));
-        try std.testing.expectError(GraphemePoolError.InvalidId, pool.decref(invalid_id));
-        try std.testing.expectError(GraphemePoolError.InvalidId, pool.get(invalid_id));
-        try std.testing.expectError(GraphemePoolError.InvalidId, pool.getRefcount(invalid_id));
-    }
-}
-
-test "GraphemePool - out-of-range slot returns InvalidId before dereference" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    _ = try pool.alloc("allocated");
-
-    // Class 0 exists after the allocation, but the highest encodable slot has
-    // not been allocated. Public operations must reject it before slot access.
-    const invalid_id = gp.SLOT_MASK;
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.incref(invalid_id));
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.decref(invalid_id));
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.get(invalid_id));
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.getRefcount(invalid_id));
-}
-
-test "GraphemePool - unreferenced slot cannot be freed twice" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("pending");
-    try pool.freeUnreferenced(id);
-
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.freeUnreferenced(id));
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.get(id));
-}
-
-test "GraphemePool - decref release cannot be freed again as pending" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("live");
-    try pool.incref(id);
-    try pool.decref(id);
-
-    try std.testing.expectError(GraphemePoolError.InvalidId, pool.freeUnreferenced(id));
-}
-
-test "GraphemePool - failed first incref preserves pending ownership" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("owned");
-    const allocator = pool.allocator;
-    var failing_allocator = std.testing.FailingAllocator.init(
-        std.testing.allocator,
-        .{ .fail_index = 0 },
-    );
-    pool.allocator = failing_allocator.allocator();
-    defer pool.allocator = allocator;
-
-    try std.testing.expectError(GraphemePoolError.OutOfMemory, pool.incref(id));
-    try std.testing.expectEqual(@as(u32, 0), try pool.getRefcount(id));
-    try pool.freeUnreferenced(id);
-}
-
-test "GraphemePool - growth allocation failure leaves state reusable" {
-    var failing_allocator = std.testing.FailingAllocator.init(
-        std.testing.allocator,
-        .{ .fail_index = 1 },
-    );
-    var pool = GraphemePool.initWithOptions(failing_allocator.allocator(), .{
-        .slots_per_page = [_]u32{ 1, 1, 1, 1, 1 },
-    });
-    defer pool.deinit();
-
-    try std.testing.expectError(GraphemePoolError.OutOfMemory, pool.alloc("value"));
-    try std.testing.expect(failing_allocator.has_induced_failure);
-
-    failing_allocator.fail_index = std.math.maxInt(usize);
-    const id = try pool.alloc("value");
-    try pool.incref(id);
-    try std.testing.expectEqualSlices(u8, "value", try pool.get(id));
-    try pool.decref(id);
-}
-
-test "GraphemePool - defer cleanup on failure path" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    var allocated_ids: std.ArrayListUnmanaged(u32) = .{};
-    defer allocated_ids.deinit(std.testing.allocator);
-
-    for (0..5) |i| {
-        var buffer: [8]u8 = undefined;
-        const slice = std.fmt.bufPrint(&buffer, "{d}", .{i}) catch unreachable;
-        const gid = try pool.alloc(slice);
-        try pool.incref(gid);
-        try allocated_ids.append(std.testing.allocator, gid);
-    }
-
-    // Simulate failure cleanup
-    for (allocated_ids.items) |id| {
-        try pool.decref(id);
-    }
-
-    // Force slot reuse
-    for (0..5) |_| {
-        _ = try pool.alloc("reuse");
-    }
-
-    for (allocated_ids.items) |id| {
-        try std.testing.expectError(GraphemePoolError.WrongGeneration, pool.get(id));
-    }
-}
-
-test "GraphemePool - pending grapheme cleanup on failure" {
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    var result_graphemes: std.ArrayListUnmanaged(u32) = .{};
-    defer result_graphemes.deinit(std.testing.allocator);
-
-    var pending_gid: ?u32 = null;
-    const success = false; // intentionally never true to test cleanup path
-
-    defer {
-        if (!success) {
-            if (pending_gid) |pgid| {
-                pool.decref(pgid) catch {};
-            }
-            for (result_graphemes.items) |gid| {
-                pool.decref(gid) catch {};
-            }
-        }
-    }
-
-    const gid1 = try pool.alloc("grapheme1");
-    pending_gid = gid1;
-    try pool.incref(gid1);
-    try result_graphemes.append(std.testing.allocator, gid1);
-    pending_gid = null;
-
-    const gid2 = try pool.alloc("grapheme2");
-    pending_gid = gid2;
-    try pool.incref(gid2);
-    // Simulate failure before storing - pending_gid remains set
-}
-
-test "encodeUnicode - cleanup on mid-operation failure" {
-    const SimulateResult = struct {
-        success: bool,
-        captured_ids: [2]u32,
-        captured_count: usize,
-    };
-
-    const simulateEncodeUnicode = struct {
-        fn run(pool: *GraphemePool, should_fail: bool) SimulateResult {
-            var result: SimulateResult = .{
-                .success = false,
-                .captured_ids = undefined,
-                .captured_count = 0,
-            };
-            var pending_gid: ?u32 = null;
-            var stored_ids: [8]u32 = undefined;
-            var stored_count: usize = 0;
-
-            defer {
-                if (!result.success) {
-                    if (pending_gid) |pgid| {
-                        pool.decref(pgid) catch {};
-                    }
-                    for (stored_ids[0..stored_count]) |gid| {
-                        pool.decref(gid) catch {};
-                    }
-                }
-            }
-
-            const gid1 = pool.alloc("emoji1") catch return result;
-            result.captured_ids[result.captured_count] = gid1;
-            result.captured_count += 1;
-            pending_gid = gid1;
-            pool.incref(gid1) catch return result;
-            stored_ids[stored_count] = gid1;
-            stored_count += 1;
-            pending_gid = null;
-
-            const gid2 = pool.alloc("emoji2") catch return result;
-            result.captured_ids[result.captured_count] = gid2;
-            result.captured_count += 1;
-            pending_gid = gid2;
-            pool.incref(gid2) catch return result;
-
-            if (should_fail) {
-                return result;
-            }
-
-            stored_ids[stored_count] = gid2;
-            stored_count += 1;
-            pending_gid = null;
-
-            result.success = true;
-            return result;
-        }
-    }.run;
-
-    var pool = GraphemePool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const sim_result = simulateEncodeUnicode(&pool, true);
-    try std.testing.expect(!sim_result.success);
-    try std.testing.expectEqual(@as(usize, 2), sim_result.captured_count);
-
-    // Force slot reuse by allocating enough graphemes to cycle through freed slots
-    // Allocate more than captured to ensure freed slots get reused
-    for (0..4) |_| {
-        _ = try pool.alloc("reuse");
-    }
-
-    // Verify cleanup: old IDs should now have wrong generation
-    for (sim_result.captured_ids[0..sim_result.captured_count]) |old_id| {
-        try std.testing.expectError(GraphemePoolError.WrongGeneration, pool.get(old_id));
-    }
-}