const std = @import("std");const host = @import("../hosts/host.zig");const composer_selection = @import("../input/composer_selection.zig");const composer_replacement = @import("../input/composer_replacement.zig");const composer_undo = @import("../input/composer_undo.zig");const edit_history = @import("../input/edit_history.zig");const editor_state = @import("../input/editor_state.zig");const input_limit_rejection = @import("../input/input_limit_rejection.zig");const picker_state = @import("../input/picker_state.zig");const registered_entities = @import("../input/registered_entities.zig");const vertical_navigation = @import("../input/vertical_navigation.zig"); pub const ClipboardResult = enum {    inactive,    copied,    cut,    copy_failed,    delete_failed,}; pub fn copySelection(    edit: *const editor_state.State,    clipboard: host.Clipboard,) ClipboardResult {    const selected = edit.selectedText() orelse return .inactive;    if (!(clipboard.copy(selected) catch false)) return .copy_failed;    return .copied;} pub fn cutSelection(    alloc: std.mem.Allocator,    selection: composer_selection.State,    pending_images: ?*composer_replacement.ImageBlocks,    clipboard: host.Clipboard,) ClipboardResult {    const selected = selection.selectedText() orelse return .inactive;    if (!(clipboard.copy(selected) catch false)) return .copy_failed;    if (!selection.delete(alloc, pending_images)) return .delete_failed;    return .cut;} const TestInput = struct {    edit: editor_state.State = .{},    history: edit_history.State = .{},    picker: picker_state.State = .{},    entities: registered_entities.State = .{},    vertical_navigation: vertical_navigation.State = .{},    input_limit_rejection: input_limit_rejection.State = .{},     fn deinit(self: *TestInput, alloc: std.mem.Allocator) void {        self.edit.deinit(alloc);        self.history.deinit(alloc);        self.picker.deinit(alloc);        self.entities.deinit(alloc);    }     fn selection(self: *TestInput) composer_selection.State {        return .{ .insertion = .{            .edit = &self.edit,            .history = &self.history,            .picker = &self.picker,            .entities = &self.entities,            .vertical_navigation = &self.vertical_navigation,            .input_limit_rejection = &self.input_limit_rejection,        } };    }     fn undo(self: *TestInput) composer_undo.State {        return .{            .edit = &self.edit,            .history = &self.history,            .picker = &self.picker,            .entities = &self.entities,            .vertical_navigation = &self.vertical_navigation,            .input_limit_rejection = &self.input_limit_rejection,        };    }}; const TestClipboard = struct {    copied: std.ArrayList(u8) = .empty,    succeed: bool = true,     fn deinit(self: *TestClipboard, alloc: std.mem.Allocator) void {        self.copied.deinit(alloc);    }     fn clipboard(self: *TestClipboard) host.Clipboard {        return .{ .context = self, .copy_fn = copy };    }     fn copy(raw_context: ?*anyopaque, bytes: []const u8) host.ClipboardError!bool {        const self: *TestClipboard = @ptrCast(@alignCast(raw_context.?));        if (!self.succeed) return false;        self.copied.appendSlice(std.testing.allocator, bytes) catch return error.CopyFailed;        return true;    }}; test "selection clipboard operations copy before cut" {    const alloc = std.testing.allocator;    var input: TestInput = .{};    defer input.deinit(alloc);    try input.edit.setText(alloc, "alpha beta");    _ = input.selection().begin(0);    _ = input.selection().extend("alpha".len);     var test_clipboard: TestClipboard = .{};    defer test_clipboard.deinit(alloc);    try std.testing.expectEqual(        ClipboardResult.copied,        copySelection(&input.edit, test_clipboard.clipboard()),    );    try std.testing.expectEqualStrings("alpha", test_clipboard.copied.items);    try std.testing.expectEqualStrings("alpha beta", input.edit.input.items);     test_clipboard.copied.clearRetainingCapacity();    try std.testing.expectEqual(        ClipboardResult.cut,        cutSelection(alloc, input.selection(), null, test_clipboard.clipboard()),    );    try std.testing.expectEqualStrings("alpha", test_clipboard.copied.items);    try std.testing.expectEqualStrings(" beta", input.edit.input.items);    try std.testing.expect(try input.undo().undo(alloc));    try std.testing.expectEqualStrings("alpha beta", input.edit.input.items);} test "failed clipboard copy preserves selection and text" {    const alloc = std.testing.allocator;    var input: TestInput = .{};    defer input.deinit(alloc);    try input.edit.setText(alloc, "alpha beta");    _ = input.selection().begin(0);    _ = input.selection().extend("alpha".len);     var test_clipboard: TestClipboard = .{ .succeed = false };    defer test_clipboard.deinit(alloc);    try std.testing.expectEqual(        ClipboardResult.copy_failed,        cutSelection(alloc, input.selection(), null, test_clipboard.clipboard()),    );    try std.testing.expectEqualStrings("alpha beta", input.edit.input.items);    try std.testing.expectEqualStrings("alpha", input.selection().selectedText().?);}