@fairyhunter13/opentui-core 0.1.114 → 0.1.115

package/src/zig/tests/rope-nested_test.zig

@@ -1,712 +0,0 @@
-const std = @import("std");
-const rope_mod = @import("../rope.zig");
-
-// NOTE: This is not strictly necessary to be supported as it is not used this way in the codebase.
-// It can be removed if the rope needs to change in a way that would break this behavior.
-
-const Chunk = struct {
-    data: []const u8,
-    width: u32,
-
-    pub const Metrics = struct {
-        total_width: u32 = 0,
-        total_bytes: u32 = 0,
-
-        pub fn add(self: *Metrics, other: Metrics) void {
-            self.total_width += other.total_width;
-            self.total_bytes += other.total_bytes;
-        }
-    };
-
-    pub fn measure(self: *const Chunk) Metrics {
-        return .{
-            .total_width = self.width,
-            .total_bytes = @intCast(self.data.len),
-        };
-    }
-
-    pub fn empty() Chunk {
-        return .{ .data = "", .width = 0 };
-    }
-
-    pub fn is_empty(self: *const Chunk) bool {
-        return self.data.len == 0;
-    }
-};
-
-// Static empty chunk rope node for Line.empty()
-const empty_chunk_leaf_node = rope_mod.Rope(Chunk).Node{
-    .leaf = .{
-        .data = Chunk.empty(),
-    },
-};
-
-// Line type containing a rope of chunks
-const Line = struct {
-    chunks: rope_mod.Rope(Chunk),
-    line_id: u32,
-
-    pub const Metrics = struct {
-        total_width: u32 = 0,
-        total_lines: u32 = 1,
-
-        pub fn add(self: *Metrics, other: Metrics) void {
-            self.total_width += other.total_width;
-            self.total_lines += other.total_lines;
-        }
-    };
-
-    pub fn measure(self: *const Line) Metrics {
-        const chunk_metrics = self.chunks.root.metrics();
-        return .{
-            .total_width = chunk_metrics.custom.total_width,
-            .total_lines = 1,
-        };
-    }
-
-    pub fn empty() Line {
-        // Use static empty chunk rope - safe because it's immutable
-        const ChunkRope = rope_mod.Rope(Chunk);
-        return .{
-            .chunks = .{
-                .root = &empty_chunk_leaf_node,
-                .allocator = undefined, // Never used for empty
-                .empty_leaf = &empty_chunk_leaf_node,
-                .marker_cache = ChunkRope.MarkerCache.init(undefined),
-            },
-            .line_id = 0,
-        };
-    }
-
-    pub fn is_empty(self: *const Line) bool {
-        return self.line_id == 0 and self.chunks.count() == 1;
-    }
-};
-
-test "Nested Rope - create line with chunks" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks = [_]Chunk{
-        .{ .data = "Hello ", .width = 6 },
-        .{ .data = "World", .width = 5 },
-    };
-
-    const chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
-
-    const line = Line{
-        .chunks = chunk_rope,
-        .line_id = 1,
-    };
-
-    try std.testing.expectEqual(@as(u32, 2), line.chunks.count());
-    try std.testing.expectEqualStrings("Hello ", line.chunks.get(0).?.data);
-    try std.testing.expectEqualStrings("World", line.chunks.get(1).?.data);
-
-    const metrics = line.measure();
-    try std.testing.expectEqual(@as(u32, 11), metrics.total_width); // 6 + 5
-}
-
-test "Nested Rope - rope of lines with chunks" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{
-        .{ .data = "Line ", .width = 5 },
-        .{ .data = "One", .width = 3 },
-    };
-    const line1 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
-        .line_id = 1,
-    };
-
-    const chunks2 = [_]Chunk{
-        .{ .data = "Line ", .width = 5 },
-        .{ .data = "Two", .width = 3 },
-    };
-    const line2 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
-        .line_id = 2,
-    };
-
-    const lines = [_]Line{ line1, line2 };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
-
-    // Access nested data
-    const first_line = line_rope.get(0).?;
-    try std.testing.expectEqual(@as(u32, 1), first_line.line_id);
-    try std.testing.expectEqual(@as(u32, 2), first_line.chunks.count());
-    try std.testing.expectEqualStrings("Line ", first_line.chunks.get(0).?.data);
-
-    const second_line = line_rope.get(1).?;
-    try std.testing.expectEqual(@as(u32, 2), second_line.line_id);
-    try std.testing.expectEqualStrings("Two", second_line.chunks.get(1).?.data);
-}
-
-test "Nested Rope - insert chunk into line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks = [_]Chunk{
-        .{ .data = "Hello ", .width = 6 },
-        .{ .data = "World", .width = 5 },
-    };
-    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
-
-    try chunk_rope.insert(1, .{ .data = "Beautiful ", .width = 10 });
-
-    try std.testing.expectEqual(@as(u32, 3), chunk_rope.count());
-    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
-    try std.testing.expectEqualStrings("Beautiful ", chunk_rope.get(1).?.data);
-    try std.testing.expectEqualStrings("World", chunk_rope.get(2).?.data);
-
-    const metrics = chunk_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 21), metrics.custom.total_width); // 6 + 10 + 5
-}
-
-test "Nested Rope - delete chunk from line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks = [_]Chunk{
-        .{ .data = "A ", .width = 2 },
-        .{ .data = "B ", .width = 2 },
-        .{ .data = "C", .width = 1 },
-    };
-    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
-
-    try chunk_rope.delete(1);
-
-    try std.testing.expectEqual(@as(u32, 2), chunk_rope.count());
-    try std.testing.expectEqualStrings("A ", chunk_rope.get(0).?.data);
-    try std.testing.expectEqualStrings("C", chunk_rope.get(1).?.data);
-
-    const metrics = chunk_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 3), metrics.custom.total_width); // 2 + 1
-}
-
-test "Nested Rope - walk through lines and chunks" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{.{ .data = "Line1", .width = 5 }};
-    const chunks2 = [_]Chunk{.{ .data = "Line2", .width = 5 }};
-    const chunks3 = [_]Chunk{.{ .data = "Line3", .width = 5 }};
-
-    const lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
-    };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    const LineContext = struct {
-        total_lines: u32 = 0,
-        total_width: u32 = 0,
-
-        fn walker(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
-            _ = index;
-            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
-            self.total_lines += 1;
-
-            const metrics = line.chunks.root.metrics();
-            self.total_width += metrics.custom.total_width;
-            return .{};
-        }
-    };
-
-    var ctx = LineContext{};
-    try line_rope.walk(&ctx, LineContext.walker);
-
-    try std.testing.expectEqual(@as(u32, 3), ctx.total_lines);
-    try std.testing.expectEqual(@as(u32, 15), ctx.total_width); // 5 + 5 + 5
-}
-
-test "Nested Rope - complex line and chunk operations" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{
-        .{ .data = "First ", .width = 6 },
-        .{ .data = "line", .width = 4 },
-    };
-    const line1 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
-        .line_id = 1,
-    };
-
-    var line_rope = try rope_mod.Rope(Line).from_item(allocator, line1);
-
-    const chunks2 = [_]Chunk{.{ .data = "Second line", .width = 11 }};
-    const line2 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
-        .line_id = 2,
-    };
-    try line_rope.append(line2);
-
-    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
-
-    // Access specific chunk in specific line
-    const first_line = line_rope.get(0).?;
-    try std.testing.expectEqual(@as(u32, 2), first_line.chunks.count());
-    try std.testing.expectEqualStrings("First ", first_line.chunks.get(0).?.data);
-
-    const metrics = line_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 2), metrics.count);
-}
-
-test "Nested Rope - metrics propagate through all levels" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{
-        .{ .data = "abc", .width = 3 },
-        .{ .data = "def", .width = 3 },
-    };
-    const chunks2 = [_]Chunk{
-        .{ .data = "12345", .width = 5 },
-    };
-    const chunks3 = [_]Chunk{
-        .{ .data = "x", .width = 1 },
-        .{ .data = "y", .width = 1 },
-        .{ .data = "z", .width = 1 },
-    };
-
-    const lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
-    };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    const line_metrics = line_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 3), line_metrics.count);
-
-    const line1 = line_rope.get(0).?;
-    const line1_metrics = line1.measure();
-    try std.testing.expectEqual(@as(u32, 6), line1_metrics.total_width); // 3 + 3
-
-    const line2 = line_rope.get(1).?;
-    const line2_metrics = line2.measure();
-    try std.testing.expectEqual(@as(u32, 5), line2_metrics.total_width);
-
-    const line3 = line_rope.get(2).?;
-    const line3_metrics = line3.measure();
-    try std.testing.expectEqual(@as(u32, 3), line3_metrics.total_width); // 1 + 1 + 1
-}
-
-test "Nested Rope - simulate text buffer edit: insert within line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const initial_chunks = [_]Chunk{
-        .{ .data = "Hello ", .width = 6 },
-        .{ .data = "World", .width = 5 },
-    };
-    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
-
-    try chunk_rope.insert(1, .{ .data = "Beautiful ", .width = 10 });
-
-    try std.testing.expectEqual(@as(u32, 3), chunk_rope.count());
-
-    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
-    try std.testing.expectEqualStrings("Beautiful ", chunk_rope.get(1).?.data);
-    try std.testing.expectEqualStrings("World", chunk_rope.get(2).?.data);
-
-    const metrics = chunk_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 21), metrics.custom.total_width);
-}
-
-test "Nested Rope - simulate text buffer edit: delete within line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const initial_chunks = [_]Chunk{
-        .{ .data = "Hello ", .width = 6 },
-        .{ .data = "Beautiful ", .width = 10 },
-        .{ .data = "World", .width = 5 },
-    };
-    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
-
-    try chunk_rope.delete(1);
-
-    try std.testing.expectEqual(@as(u32, 2), chunk_rope.count());
-    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
-    try std.testing.expectEqualStrings("World", chunk_rope.get(1).?.data);
-
-    const metrics = chunk_rope.root.metrics();
-    try std.testing.expectEqual(@as(u32, 11), metrics.custom.total_width);
-}
-
-test "Nested Rope - insert line into document" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{.{ .data = "Line 1", .width = 6 }};
-    const chunks3 = [_]Chunk{.{ .data = "Line 3", .width = 6 }};
-
-    const initial_lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
-    };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &initial_lines);
-
-    const chunks2 = [_]Chunk{.{ .data = "Line 2", .width = 6 }};
-    const line2 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
-        .line_id = 2,
-    };
-    try line_rope.insert(1, line2);
-
-    try std.testing.expectEqual(@as(u32, 3), line_rope.count());
-    try std.testing.expectEqual(@as(u32, 1), line_rope.get(0).?.line_id);
-    try std.testing.expectEqual(@as(u32, 2), line_rope.get(1).?.line_id);
-    try std.testing.expectEqual(@as(u32, 3), line_rope.get(2).?.line_id);
-}
-
-test "Nested Rope - delete line from document" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{.{ .data = "Line 1", .width = 6 }};
-    const chunks2 = [_]Chunk{.{ .data = "Line 2", .width = 6 }};
-    const chunks3 = [_]Chunk{.{ .data = "Line 3", .width = 6 }};
-
-    const lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
-    };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    try line_rope.delete(1);
-
-    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
-    try std.testing.expectEqual(@as(u32, 1), line_rope.get(0).?.line_id);
-    try std.testing.expectEqual(@as(u32, 3), line_rope.get(1).?.line_id);
-}
-
-test "Nested Rope - modify chunks within a specific line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const initial_chunks = [_]Chunk{
-        .{ .data = "Hello", .width = 5 },
-    };
-    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
-
-    try chunk_rope.insert(1, .{ .data = " World", .width = 6 });
-
-    const line = Line{
-        .chunks = chunk_rope,
-        .line_id = 1,
-    };
-
-    const lines = [_]Line{line};
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    const retrieved_line = line_rope.get(0).?;
-    try std.testing.expectEqual(@as(u32, 2), retrieved_line.chunks.count());
-    try std.testing.expectEqualStrings("Hello", retrieved_line.chunks.get(0).?.data);
-    try std.testing.expectEqualStrings(" World", retrieved_line.chunks.get(1).?.data);
-
-    const line_metrics = retrieved_line.measure();
-    try std.testing.expectEqual(@as(u32, 11), line_metrics.total_width);
-}
-
-test "Nested Rope - walk all chunks in all lines" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{
-        .{ .data = "A", .width = 1 },
-        .{ .data = "B", .width = 1 },
-    };
-    const chunks2 = [_]Chunk{
-        .{ .data = "C", .width = 1 },
-        .{ .data = "D", .width = 1 },
-        .{ .data = "E", .width = 1 },
-    };
-
-    const lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
-    };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    var total_chunks: u32 = 0;
-    var total_bytes: u32 = 0;
-
-    const LineWalker = struct {
-        fn walk(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
-            _ = index;
-            const counters = @as(*[2]u32, @ptrCast(@alignCast(ctx)));
-
-            // Count chunks in this line
-            const ChunkWalker = struct {
-                fn walk(chunk_ctx: *anyopaque, chunk: *const Chunk, chunk_idx: u32) rope_mod.Rope(Chunk).Node.WalkerResult {
-                    _ = chunk_idx;
-                    const chunk_counters = @as(*[2]u32, @ptrCast(@alignCast(chunk_ctx)));
-                    chunk_counters[0] += 1; // total_chunks
-                    chunk_counters[1] += @intCast(chunk.data.len); // total_bytes
-                    return .{};
-                }
-            };
-
-            line.chunks.walk(counters, ChunkWalker.walk) catch {};
-            return .{};
-        }
-    };
-
-    var counters = [2]u32{ total_chunks, total_bytes };
-    try line_rope.walk(&counters, LineWalker.walk);
-    total_chunks = counters[0];
-    total_bytes = counters[1];
-
-    try std.testing.expectEqual(@as(u32, 5), total_chunks); // 2 + 3
-    try std.testing.expectEqual(@as(u32, 5), total_bytes); // All single char chunks
-}
-
-test "Nested Rope - simulate full text buffer workflow" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const chunks1 = [_]Chunk{
-        .{ .data = "Hello ", .width = 6 },
-        .{ .data = "World", .width = 5 },
-    };
-    const line1 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
-        .line_id = 1,
-    };
-
-    var document = try rope_mod.Rope(Line).from_item(allocator, line1);
-
-    const chunks2 = [_]Chunk{.{ .data = "Goodbye", .width = 7 }};
-    const line2 = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
-        .line_id = 2,
-    };
-    try document.append(line2);
-
-    try std.testing.expectEqual(@as(u32, 2), document.count());
-
-    const retrieved_line1 = document.get(0).?;
-    try std.testing.expectEqual(@as(u32, 2), retrieved_line1.chunks.count());
-
-    const retrieved_line2 = document.get(1).?;
-    try std.testing.expectEqual(@as(u32, 1), retrieved_line2.chunks.count());
-
-    var modified_chunks = retrieved_line1.chunks;
-    try modified_chunks.insert(1, .{ .data = "Beautiful ", .width = 10 });
-
-    const modified_line = Line{
-        .chunks = modified_chunks,
-        .line_id = 1,
-    };
-
-    // Note: In a real text buffer, you'd replace the line in the document
-    // For now, just verify the modified line has the new chunk
-    try std.testing.expectEqual(@as(u32, 3), modified_line.chunks.count());
-    try std.testing.expectEqualStrings("Beautiful ", modified_line.chunks.get(1).?.data);
-}
-
-test "Nested Rope - empty lines with no chunks" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const empty_chunks: []const Chunk = &[_]Chunk{};
-    const empty_line = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, empty_chunks),
-        .line_id = 1,
-    };
-
-    const chunks = [_]Chunk{.{ .data = "Content", .width = 7 }};
-    const content_line = Line{
-        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks),
-        .line_id = 2,
-    };
-
-    const lines = [_]Line{ empty_line, content_line };
-    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
-
-    const empty = line_rope.get(0).?;
-    try std.testing.expectEqual(@as(u32, 0), empty.chunks.count());
-
-    const content = line_rope.get(1).?;
-    try std.testing.expectEqual(@as(u32, 1), content.chunks.count());
-    try std.testing.expectEqualStrings("Content", content.chunks.get(0).?.data);
-}
-
-test "Nested Rope - large document with many lines and chunks" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var lines_array: [20]Line = undefined;
-    for (&lines_array, 0..) |*line, line_idx| {
-        var chunks_array: [3]Chunk = undefined;
-        for (&chunks_array, 0..) |*chunk, chunk_idx| {
-            chunk.* = .{
-                .data = "X",
-                .width = 1,
-            };
-            _ = chunk_idx;
-        }
-        line.* = Line{
-            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks_array),
-            .line_id = @intCast(line_idx),
-        };
-    }
-
-    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
-
-    try std.testing.expectEqual(@as(u32, 20), document.count());
-
-    const line_5 = document.get(5).?;
-    try std.testing.expectEqual(@as(u32, 5), line_5.line_id);
-    try std.testing.expectEqual(@as(u32, 3), line_5.chunks.count());
-
-    const line_15 = document.get(15).?;
-    try std.testing.expectEqual(@as(u32, 15), line_15.line_id);
-
-    try std.testing.expectEqualStrings("X", line_5.chunks.get(0).?.data);
-}
-
-test "Nested Rope - walk_from specific line" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var lines_array: [5]Line = undefined;
-    for (&lines_array, 0..) |*line, i| {
-        const chunks = [_]Chunk{.{ .data = "X", .width = 1 }};
-        line.* = Line{
-            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks),
-            .line_id = @intCast(i),
-        };
-    }
-    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
-
-    const Context = struct {
-        count: u32 = 0,
-        first_id: ?u32 = null,
-
-        fn walker(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
-            _ = index;
-            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
-            if (self.first_id == null) {
-                self.first_id = line.line_id;
-            }
-            self.count += 1;
-            return .{};
-        }
-    };
-
-    var ctx = Context{};
-    try document.walk_from(3, &ctx, Context.walker);
-
-    // Should walk lines 3 and 4 (indices 3 and 4)
-    try std.testing.expectEqual(@as(u32, 2), ctx.count);
-    try std.testing.expectEqual(@as(u32, 3), ctx.first_id.?);
-}
-
-test "Nested Rope - metrics aggregate correctly through all levels" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    // Line 1: 3 chunks, total width 10
-    const chunks1 = [_]Chunk{
-        .{ .data = "abc", .width = 3 },
-        .{ .data = "def", .width = 3 },
-        .{ .data = "ghij", .width = 4 },
-    };
-
-    // Line 2: 2 chunks, total width 15
-    const chunks2 = [_]Chunk{
-        .{ .data = "12345", .width = 5 },
-        .{ .data = "6789012345", .width = 10 },
-    };
-
-    const lines = [_]Line{
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
-        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
-    };
-    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines);
-
-    const line1 = document.get(0).?;
-    const chunk_metrics1 = line1.chunks.root.metrics();
-    try std.testing.expectEqual(@as(u32, 3), chunk_metrics1.count);
-    try std.testing.expectEqual(@as(u32, 10), chunk_metrics1.custom.total_width);
-    try std.testing.expectEqual(@as(u32, 10), chunk_metrics1.custom.total_bytes);
-
-    const line2 = document.get(1).?;
-    const chunk_metrics2 = line2.chunks.root.metrics();
-    try std.testing.expectEqual(@as(u32, 2), chunk_metrics2.count);
-    try std.testing.expectEqual(@as(u32, 15), chunk_metrics2.custom.total_width);
-    try std.testing.expectEqual(@as(u32, 15), chunk_metrics2.custom.total_bytes);
-
-    const line1_metrics = line1.measure();
-    try std.testing.expectEqual(@as(u32, 10), line1_metrics.total_width);
-
-    const doc_metrics = document.root.metrics();
-    try std.testing.expectEqual(@as(u32, 2), doc_metrics.count); // 2 lines
-}
-
-test "Nested Rope - O(log n) access to deeply nested data" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var lines_array: [100]Line = undefined;
-    for (&lines_array, 0..) |*line, line_idx| {
-        var chunks_array: [5]Chunk = undefined;
-        for (&chunks_array, 0..) |*chunk, chunk_idx| {
-            chunk.* = .{
-                .data = "c",
-                .width = 1,
-            };
-            _ = chunk_idx;
-        }
-        line.* = Line{
-            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks_array),
-            .line_id = @intCast(line_idx),
-        };
-    }
-
-    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
-
-    // Access line 50, chunk 3 (deep in the tree)
-    // This tests O(log lines) + O(log chunks) access
-    const line_50 = document.get(50).?;
-    try std.testing.expectEqual(@as(u32, 50), line_50.line_id);
-
-    const chunk_3 = line_50.chunks.get(3).?;
-    try std.testing.expectEqualStrings("c", chunk_3.data);
-
-    const doc_depth = document.root.depth();
-    try std.testing.expect(doc_depth < 20); // log2(100) ≈ 7, with some buffer
-
-    const line_depth = line_50.chunks.root.depth();
-    try std.testing.expect(line_depth < 10); // log2(5) ≈ 3, with buffer
-}