@fairyhunter13/opentui-core 0.1.90 → 0.1.92

package/src/zig/tests/link_test.zig

@@ -1,190 +0,0 @@
-const std = @import("std");
-const link = @import("../link.zig");
-
-const LinkPool = link.LinkPool;
-const LinkPoolError = link.LinkPoolError;
-const LinkTracker = link.LinkTracker;
-
-test "LinkPool - can initialize and cleanup" {
-    var pool = LinkPool.init(std.testing.allocator);
-    pool.deinit();
-}
-
-test "LinkPool - alloc and get URL" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const url = "https://example.com";
-    const id = try pool.alloc(url);
-    try pool.incref(id);
-    defer pool.decref(id) catch {};
-
-    const retrieved = try pool.get(id);
-    try std.testing.expectEqualSlices(u8, url, retrieved);
-}
-
-test "LinkPool - decref to zero allows slot reuse" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id1 = try pool.alloc("https://first.example");
-    try pool.incref(id1);
-    try pool.decref(id1);
-
-    const id2 = try pool.alloc("https://second.example");
-    try pool.incref(id2);
-    defer pool.decref(id2) catch {};
-
-    const stale_get = pool.get(id1);
-    try std.testing.expectError(LinkPoolError.WrongGeneration, stale_get);
-
-    const stale_incref = pool.incref(id1);
-    try std.testing.expectError(LinkPoolError.WrongGeneration, stale_incref);
-
-    const stale_decref = pool.decref(id1);
-    try std.testing.expectError(LinkPoolError.WrongGeneration, stale_decref);
-
-    try std.testing.expectEqualSlices(u8, "https://second.example", try pool.get(id2));
-}
-
-test "LinkPool - decref on zero refcount fails" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("https://example.com");
-    try std.testing.expectError(LinkPoolError.InvalidId, pool.decref(id));
-}
-
-test "LinkPool - alloc never returns sentinel zero ID" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const rounds: usize = 300;
-    for (0..rounds) |_| {
-        const id = try pool.alloc("https://example.com/rotate");
-        try std.testing.expect(id != 0);
-
-        try pool.incref(id);
-        try pool.decref(id);
-    }
-}
-
-test "LinkTracker - add/remove keeps one pool ref per ID" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("https://example.com/same");
-
-    var tracker = LinkTracker.init(std.testing.allocator, &pool);
-    defer tracker.deinit();
-
-    tracker.addCellRef(id);
-    tracker.addCellRef(id);
-    tracker.addCellRef(id);
-
-    try std.testing.expectEqual(@as(u32, 1), tracker.getLinkCount());
-    try std.testing.expectEqual(@as(u32, 1), try pool.getRefcount(id));
-
-    tracker.removeCellRef(id);
-    try std.testing.expectEqual(@as(u32, 1), tracker.getLinkCount());
-    try std.testing.expectEqual(@as(u32, 1), try pool.getRefcount(id));
-
-    tracker.removeCellRef(id);
-    try std.testing.expectEqual(@as(u32, 1), tracker.getLinkCount());
-    try std.testing.expectEqual(@as(u32, 1), try pool.getRefcount(id));
-
-    tracker.removeCellRef(id);
-    try std.testing.expectEqual(@as(u32, 0), tracker.getLinkCount());
-    try std.testing.expectEqual(@as(u32, 0), try pool.getRefcount(id));
-}
-
-test "LinkTracker - clear releases tracked IDs" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id1 = try pool.alloc("https://example.com/1");
-    const id2 = try pool.alloc("https://example.com/2");
-
-    var tracker = LinkTracker.init(std.testing.allocator, &pool);
-    defer tracker.deinit();
-
-    tracker.addCellRef(id1);
-    tracker.addCellRef(id2);
-
-    try std.testing.expect(tracker.hasAny());
-    try std.testing.expectEqual(@as(u32, 2), try pool.getRefcount(id1) + try pool.getRefcount(id2));
-
-    tracker.clear();
-
-    try std.testing.expect(!tracker.hasAny());
-    try std.testing.expectEqual(@as(u32, 0), try pool.getRefcount(id1));
-    try std.testing.expectEqual(@as(u32, 0), try pool.getRefcount(id2));
-}
-
-test "LinkTracker - clear only decrefs once per ID with multiple cell refs" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const id = try pool.alloc("https://example.com/shared");
-
-    var tracker_a = LinkTracker.init(std.testing.allocator, &pool);
-    defer tracker_a.deinit();
-
-    var tracker_b = LinkTracker.init(std.testing.allocator, &pool);
-    defer tracker_b.deinit();
-
-    tracker_a.addCellRef(id);
-    tracker_a.addCellRef(id);
-    tracker_a.addCellRef(id);
-
-    tracker_b.addCellRef(id);
-
-    try std.testing.expectEqual(@as(u32, 2), try pool.getRefcount(id));
-
-    // Clear tracker A should decref once (2 -> 1).
-    tracker_a.clear();
-
-    try std.testing.expectEqual(@as(u32, 1), try pool.getRefcount(id));
-    try std.testing.expectEqualSlices(u8, "https://example.com/shared", try pool.get(id));
-}
-
-test "LinkPool - leak repro: alloc-only IDs accumulate live slots" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const rounds: usize = 4096;
-    for (0..rounds) |i| {
-        var buf: [64]u8 = undefined;
-        const url = std.fmt.bufPrint(&buf, "https://example.com/r{d}", .{i}) catch unreachable;
-        _ = try pool.alloc(url);
-    }
-
-    try std.testing.expect(pool.getLiveSlotCount() > 0);
-    try std.testing.expect(pool.getFreeSlotCount() < pool.getTotalSlots());
-}
-
-test "LinkPool - alloc reuses live ID for same URL" {
-    var pool = LinkPool.init(std.testing.allocator);
-    defer pool.deinit();
-
-    const url = "https://example.com/stable";
-
-    const id1 = try pool.alloc(url);
-    try pool.incref(id1);
-
-    const id2 = try pool.alloc(url);
-    try std.testing.expectEqual(id1, id2);
-    try std.testing.expectEqual(@as(u32, 1), try pool.getRefcount(id1));
-
-    try pool.decref(id1);
-
-    const id3 = try pool.alloc(url);
-    try pool.incref(id3);
-    defer pool.decref(id3) catch {};
-
-    try std.testing.expect(id3 != id1);
-    try std.testing.expectEqualSlices(u8, url, try pool.get(id3));
-
-    const id4 = try pool.alloc(url);
-    try std.testing.expectEqual(id3, id4);
-}

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());
-}