@xincli/opentui-core 0.4.6

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

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

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