// SPDX-License-Identifier: GPL-3.0-or-later import AppKit import SwiftUI import XCTest @MainActor final class SourceFindTests: XCTestCase { private final class Source: NSTextView { let history = UndoManager() override var undoManager: UndoManager? { history } } private func source(_ text: String) -> Source { let view = Source(frame: NSRect(x: 0, y: 0, width: 400, height: 200)) view.isRichText = false; view.allowsUndo = true; view.string = text return view } private func assertEscapeAfterReplaceAndUndo(_ editor: NSTextView, finder: SourceFind, file: StaticString = #filePath, line: UInt = #line) throws { let original = editor.string let history = try XCTUnwrap(editor.undoManager, file: file, line: line) finder.query = "earth"; finder.replacement = "Mars"; finder.show(replace: true) finder.replace(all: true) XCTAssertEqual(editor.string, original.replacingOccurrences(of: "EARTH earth", with: "Mars Mars"), file: file, line: line) XCTAssertTrue(history.canUndo, file: file, line: line) history.undo() XCTAssertEqual(editor.string, original, file: file, line: line) XCTAssertTrue(editor.window?.firstResponder === editor, file: file, line: line) let selection = editor.selectedRange(), canUndo = history.canUndo, canRedo = history.canRedo let undoName = history.undoActionName, redoName = history.redoActionName editor.cancelOperation(nil) XCTAssertFalse(finder.visible, file: file, line: line) XCTAssertEqual(editor.string, original, file: file, line: line) XCTAssertEqual(editor.selectedRange(), selection, file: file, line: line) XCTAssertEqual(history.canUndo, canUndo, file: file, line: line) XCTAssertEqual(history.canRedo, canRedo, file: file, line: line) XCTAssertEqual(history.undoActionName, undoName, file: file, line: line) XCTAssertEqual(history.redoActionName, redoName, file: file, line: line) } func testBASICAndCEditorsCloseFindFromSourceAfterReplaceAndUndo() throws { final class Buffer { var text: String; init(_ text: String) { self.text = text } } for basic in [true, false] { let buffer = Buffer(basic ? "10 PRINT \"EARTH earth\"" : "/* EARTH earth */\nint main(void) { return 0; }") let binding = Binding(get: { buffer.text }, set: { buffer.text = $0 }) let finder = SourceFind() let view: AnyView if basic { view = AnyView(BASICSourceEditor(finder: finder, text: binding, readOnly: false, completionRequest: UUID(), editorAction: nil, breakpoints: [], stoppedLine: nil, stoppedToken: nil, toggleBreakpoint: { _ in }, actionHandled: { _, _ in }, cursorChanged: { _ in }, assistance: { _ in }, quickHelp: { _ in })) } else { view = AnyView(CSourceEditor(finder: finder, text: binding, currentLine: nil)) } let host = NSHostingView(rootView: view) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 440, height: 230), styleMask: [.titled], backing: .buffered, defer: false) window.contentView = host; host.layoutSubtreeIfNeeded() let editor = try XCTUnwrap(finder.editor) XCTAssertTrue((editor as? SourceFindEditor)?.sourceFind === finder) try assertEscapeAfterReplaceAndUndo(editor, finder: finder) XCTAssertEqual(buffer.text, editor.string) } } func testSourceEscapePrioritizesInlinePreviewAndClearsPreparedCandidates() throws { let finder = SourceFind() let basic = BASICTextView(frame: .zero) basic.isRichText = false; basic.isEditable = true; basic.string = "10 PRI" basic.setSelectedRange(NSRange(location: 6, length: 0)) finder.editor = basic; finder.show() basic.refreshInlineSuggestion() XCTAssertNotNil(basic.inlineSuggestion) basic.cancelOperation(nil) XCTAssertTrue(finder.visible); XCTAssertNil(basic.inlineSuggestion) XCTAssertEqual(basic.string, "10 PRI") basic.cancelOperation(nil) XCTAssertFalse(finder.visible) finder.show() XCTAssertTrue(basic.prepareCompletion()) // Preparing candidates does not open AppKit's native completion popup. // This command reaches the source editor and must close Find once. basic.cancelOperation(nil) XCTAssertFalse(finder.visible) XCTAssertEqual(basic.rangeForUserCompletion.location, NSNotFound) XCTAssertEqual(basic.string, "10 PRI") let c = CMOCCompletionTextView(frame: .zero) c.isRichText = false; c.isEditable = true; c.string = "pri" c.setSelectedRange(NSRange(location: 3, length: 0)) c.completionProvider = { _, _ in [ .init(name: "printf", detail: "Function", conditional: false, replacementRange: NSRange(location: 0, length: 3), insertion: "printf") ] } finder.editor = c; finder.show() XCTAssertTrue(c.prepareCompletion()) c.cancelOperation(nil) XCTAssertFalse(finder.visible); XCTAssertEqual(c.string, "pri") XCTAssertEqual(c.rangeForUserCompletion.location, NSNotFound) } func testInactiveSourceCannotCloseAnotherEditorsFindAndBindingIsWeak() { let finder = SourceFind(), old = BASICTextView(frame: .zero), active = CMOCCompletionTextView(frame: .zero) finder.editor = old XCTAssertTrue(old.sourceFind === finder) finder.editor = active; finder.show() old.cancelOperation(nil) XCTAssertTrue(finder.visible) active.cancelOperation(nil) XCTAssertFalse(finder.visible) weak var releasedFinder: SourceFind? autoreleasepool { let temporary = SourceFind() temporary.editor = old; releasedFinder = temporary XCTAssertTrue(old.sourceFind === temporary) } XCTAssertNil(releasedFinder) XCTAssertNil(old.sourceFind) } private final class CancelRecipient: NSResponder { var cancellations = 0 override func cancelOperation(_ sender: Any?) { cancellations += 1 } } func testUnmatchedSourceEscapeForwardsOnlyToTheNextResponder() { for editor in [BASICTextView(frame: .zero), CMOCCompletionTextView(frame: .zero)] as [NSTextView] { let finder = SourceFind() finder.editor = editor editor.string = "unchanged" editor.setSelectedRange(NSRange(location: 0, length: 3)) // A hostless editor has no recipient. Optional AppKit commands must // simply go unhandled instead of calling an undefined super method. editor.cancelOperation(nil) XCTAssertFalse(finder.visible) let recipient = CancelRecipient() editor.nextResponder = recipient editor.cancelOperation(nil) XCTAssertEqual(recipient.cancellations, 1) XCTAssertEqual(editor.string, "unchanged") XCTAssertEqual(editor.selectedRange(), NSRange(location: 0, length: 3)) finder.show() editor.cancelOperation(nil) XCTAssertFalse(finder.visible) XCTAssertEqual(recipient.cancellations, 1, "Closing Find consumes Escape before the next responder") } } func testCSourceIsPaintedBesideBreakpointGutter() throws { let program = "int main(void) {\n return 42;\n}\n" for appearance in [NSAppearance.Name.aqua, .darkAqua] { let finder = SourceFind() let host = NSHostingView(rootView: CSourceEditor(finder: finder, text: .constant(program), currentLine: nil)) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 440, height: 180), styleMask: [.borderless], backing: .buffered, defer: false) window.appearance = NSAppearance(named: appearance) window.contentView = host host.layoutSubtreeIfNeeded() let editor = try XCTUnwrap(finder.editor) let ruler = try XCTUnwrap(editor.enclosingScrollView?.verticalRulerView as? CLineRuler) XCTAssertFalse(ruler.visibleRows().isEmpty) let image = try XCTUnwrap(host.bitmapImageRepForCachingDisplay(in: host.bounds)) host.cacheDisplay(in: host.bounds, to: image) // Inspect the composed workspace, since a ruler can cover already laid-out glyphs. // The sample has colored C keywords on a neutral editor background. let scale = CGFloat(image.pixelsWide) / host.bounds.width let left = Int(host.convert(ruler.bounds, from: ruler).maxX * scale) + 2 var coloredPixels = 0 for x in left.. 0.12 && rgb.blueComponent - rgb.greenComponent > 0.12 { coloredPixels += 1 } } } XCTAssertGreaterThan(coloredPixels, 10, "C syntax should be visible in \(appearance.rawValue)") } } func testNavigationWrapsAndSearchIsLiteral() { let find = SourceFind(), view = source("🌎 EARTH . earth") find.editor = view; find.query = "Earth" let first = NSRange(location: 3, length: 5), second = NSRange(location: 11, length: 5) XCTAssertEqual(view.selectedRange(), first) find.selectMatch(backward: true); XCTAssertEqual(view.selectedRange(), second) find.selectMatch(); XCTAssertEqual(view.selectedRange(), first) find.matchCase = true; XCTAssertTrue(find.matches(in: view.string).isEmpty) find.query = "."; XCTAssertEqual(find.matches(in: view.string), [NSRange(location: 9, length: 1)]) } func testUtf16PositionsFollowActualBufferBytesEvenWhenStringsCompareEqual() { let find = SourceFind(), composed = source("é.é"), decomposed = source("e\u{301}.e\u{301}") find.editor = composed; find.query = "." XCTAssertEqual(find.matches(in: composed.string).first?.location, 1) find.editor = decomposed XCTAssertEqual(find.matches(in: decomposed.string).first?.location, 2) find.replacement = "!" find.replace(all: true) XCTAssertEqual(Array(decomposed.string.utf8), Array("e\u{301}!e\u{301}".utf8)) find.editor = composed; find.matchCase = true; find.query = "é" find.replacement = "e\u{301}"; find.replace(all: true) XCTAssertEqual(Array(composed.string.utf8), Array("e\u{301}.e\u{301}".utf8)) XCTAssertTrue(AssemblyBuffer(path: "demo.asm", text: composed.string, saved: "é.é").dirty) XCTAssertTrue(CMOCEditorDocument(id: "demo.c", text: composed.string, savedText: "é.é", savedHash: "").dirty) } func testStaleSelectionIsFoundBeforeReplacingAndDeleting() { let find = SourceFind(), view = source("cat dog CAT") find.editor = view; find.query = "cat"; find.replacement = "fox" view.setSelectedRange(NSRange(location: 4, length: 3)) find.replace(all: false) XCTAssertEqual(view.string, "cat dog CAT") XCTAssertEqual(view.selectedRange(), NSRange(location: 8, length: 3)) find.replace(all: false); XCTAssertEqual(view.string, "cat dog fox") XCTAssertEqual(view.selectedRange(), NSRange(location: 0, length: 3)) find.replacement = ""; find.replace(all: false) XCTAssertEqual(view.string, " dog fox") } /// Exercise the production representable and its delegate. Replacing in a /// detached NSTextView alone cannot verify dirty state, per-buffer Undo or Save. func testAssemblyFindEditsActiveBufferAndSurvivesSavingAndReopening() async throws { struct Host: View { @ObservedObject var model: AssemblyDevelopmentModel let finder: SourceFind let pool: AssemblyEditorPool var body: some View { AssemblyEditor(finder: finder, model: model, pool: pool, lookup: {}) } } let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let suite = "FindTests." + UUID().uuidString let defaults = try XCTUnwrap(UserDefaults(suiteName: suite)) defer { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: root) } let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = AssemblyDevelopmentModel(machine: machine, recoveryURL: root.appendingPathComponent("Drafts.json")) let finder = SourceFind(), pool = AssemblyEditorPool() let originalID = model.activeID, originalText = model.buffer.text let host = NSHostingView(rootView: Host(model: model, finder: finder, pool: pool)) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 420, height: 230), styleMask: [.titled], backing: .buffered, defer: false) window.contentView = host window.contentView?.layoutSubtreeIfNeeded() func awaitBuffer(_ text: String) async throws { for _ in 0..<60 { host.layoutSubtreeIfNeeded() if finder.editor?.string == text { return } try await Task.sleep(nanoseconds: 20_000_000) } struct StaleEditor: Error {} XCTFail("Assembly editor did not display the selected source") throw StaleEditor() } try await awaitBuffer(originalText) model.openExample(title: "Second", source: "; A A\n", target6309: false) try await awaitBuffer("; A A\n") let secondEditor = try XCTUnwrap(finder.editor) finder.query = "A"; finder.replacement = "BB"; finder.replace(all: true) XCTAssertEqual(model.buffer.text, "; BB BB\n") XCTAssertTrue(model.buffer.dirty) let secondID = model.activeID model.select(originalID); try await awaitBuffer(originalText) XCTAssertFalse(finder.editor?.undoManager?.canUndo ?? true) finder.show() secondEditor.cancelOperation(nil) XCTAssertTrue(finder.visible, "A retained inactive assembly tab must not close the active tab's Find bar") finder.editor?.cancelOperation(nil) XCTAssertFalse(finder.visible) model.select(secondID); try await awaitBuffer("; BB BB\n") finder.editor?.undoManager?.undo(); XCTAssertEqual(model.buffer.text, "; A A\n") finder.editor?.undoManager?.redo(); XCTAssertEqual(model.buffer.text, "; BB BB\n") let destination = root.appendingPathComponent("words.asm") for _ in 0..<300 where machine.busy { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertFalse(machine.busy, "Wait for emulator startup before saving.") model.save(to: destination) for _ in 0..<300 where model.buffer.dirty || model.buffer.path != "words.asm" { try await Task.sleep(nanoseconds: 20_000_000) } guard !model.buffer.dirty else { return XCTFail("Save result: \(model.message)") } XCTAssertEqual(try String(contentsOf: destination, encoding: .utf8), "; BB BB\n") model.closeDocument() model.open(destination, folder: false) try await awaitBuffer("; BB BB\n") XCTAssertFalse(model.buffer.dirty) model.openExample(title: "Escape", source: "; EARTH earth\n", target6309: false) try await awaitBuffer("; EARTH earth\n") let escapeEditor = try XCTUnwrap(finder.editor) XCTAssertTrue((escapeEditor as? SourceFindEditor)?.sourceFind === finder) try assertEscapeAfterReplaceAndUndo(escapeEditor, finder: finder) model.openExample(title: "Completion", source: " LD", target6309: false) try await awaitBuffer(" LD") let completionEditor = try XCTUnwrap(finder.editor) completionEditor.setSelectedRange(NSRange(location: 6, length: 0)) finder.show() var selectedCandidate = -1 let candidates = completionEditor.completions(forPartialWordRange: NSRange(location: 4, length: 2), indexOfSelectedItem: &selectedCandidate) XCTAssertFalse(candidates?.isEmpty ?? true) completionEditor.cancelOperation(nil) XCTAssertFalse(finder.visible) XCTAssertEqual(completionEditor.string, " LD") let originalNext = completionEditor.nextResponder, recipient = CancelRecipient() completionEditor.nextResponder = recipient completionEditor.cancelOperation(nil) completionEditor.nextResponder = originalNext XCTAssertEqual(recipient.cancellations, 1) XCTAssertEqual(completionEditor.string, " LD") await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } func testBundledCoCoHeaderCanBeSearchedAndReplacementLeavesItIntact() async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let toolchain = root.appendingPathComponent("Toolchain") let includes = toolchain.appendingPathComponent("share/cmoc/include") try FileManager.default.createDirectory(at: includes, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let repository = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .deletingLastPathComponent().deletingLastPathComponent() let headerURL = includes.appendingPathComponent("coco.h") try FileManager.default.copyItem(at: repository.appendingPathComponent("third_party/cmoc/src/stdlib/coco.h"), to: headerURL) let original = try String(contentsOf: headerURL, encoding: .utf8) let suite = "FindHeader." + UUID().uuidString let defaults = try XCTUnwrap(UserDefaults(suiteName: suite)) defer { defaults.removePersistentDomain(forName: suite) } let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, toolchain: toolchain, defaults: defaults, buildRoot: root.appendingPathComponent("Build"), recoveryRoot: root.appendingPathComponent("Recovery")) try model.adopt(CMOCProject.create(at: root.appendingPathComponent("Project"))) let path = CMOCIndexInputs.libraryPrefix + "coco.h" for _ in 0..<200 where model.projectIndex?.documents[path] == nil { try await Task.sleep(nanoseconds: 20_000_000) } model.openFile(path) XCTAssertEqual(model.selectedFile, path) XCTAssertTrue(model.selectedFileIsGenerated) XCTAssertEqual(model.source, original) let finder = SourceFind() let editorView = CSourceEditor(finder: finder, text: Binding(get: { model.source }, set: { model.source = $0 }), currentLine: nil, file: model.selectedFile, readOnly: model.selectedFileIsGenerated) let host = NSHostingView(rootView: editorView) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 420, height: 230), styleMask: [.titled], backing: .buffered, defer: false) window.contentView = host host.layoutSubtreeIfNeeded() let editor = try XCTUnwrap(finder.editor) XCTAssertFalse(editor.isEditable) finder.query = "initCoCoSupport" XCTAssertEqual((editor.string as NSString).substring(with: editor.selectedRange()), finder.query) finder.replacement = "changed" finder.replace(all: false); finder.replace(all: true) XCTAssertEqual(editor.string, original) XCTAssertEqual(model.source, original) XCTAssertEqual(try String(contentsOf: headerURL, encoding: .utf8), original) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } func testFastForwardShortcutOnlyRoutesFromEmulatorAndChangesMachineSpeed() async throws { guard #available(macOS 14.4, *) else { throw XCTSkip("Hosting a native menu offscreen requires macOS 14.4.") } let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let suite = "FindShortcuts." + UUID().uuidString let defaults = try XCTUnwrap(UserDefaults(suiteName: suite)) defer { defaults.removePersistentDomain(forName: suite) } let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) for _ in 0..<300 where machine.busy { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertFalse(machine.settings.fastForward) let editorMenu = NSHostingMenu(rootView: FastForwardMenuItem(machine: machine, values: machine.menuState.values, emulatorFocused: false)) let emulatorMenu = NSHostingMenu(rootView: FastForwardMenuItem(machine: machine, values: machine.menuState.values, emulatorFocused: true)) let editorItem = try XCTUnwrap(editorMenu.item(withTitle: "Fast-forward")) let emulatorItem = try XCTUnwrap(emulatorMenu.item(withTitle: "Fast-forward")) XCTAssertTrue(editorItem.keyEquivalent.isEmpty) XCTAssertEqual(emulatorItem.keyEquivalent.lowercased(), "f") XCTAssertTrue(emulatorItem.keyEquivalentModifierMask.contains(.command)) // AppKit represents Shift either in the modifier mask or by an uppercase // key equivalent. Activate the actual command from its native menu. XCTAssertTrue(emulatorItem.keyEquivalentModifierMask.contains(.shift) || emulatorItem.keyEquivalent == "F") XCTAssertTrue(emulatorItem.isEnabled) emulatorMenu.performActionForItem(at: emulatorMenu.index(of: emulatorItem)) for _ in 0..<100 where !machine.settings.fastForward { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertTrue(machine.settings.fastForward) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } func testLockedBASICSourceCanBeSearchedButCannotBeReplaced() throws { let finder = SourceFind(), program = "10 PRINT 42\n" let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 420, height: 230), styleMask: [.titled], backing: .buffered, defer: false) let view = BASICSourceEditor(finder: finder, text: .constant(program), readOnly: true, completionRequest: UUID(), editorAction: nil, breakpoints: [], stoppedLine: nil, stoppedToken: nil, toggleBreakpoint: { _ in }, actionHandled: { _, _ in }, cursorChanged: { _ in }, assistance: { _ in }, quickHelp: { _ in }) let host = NSHostingView(rootView: view) window.contentView = host host.layoutSubtreeIfNeeded() let editor = try XCTUnwrap(finder.editor) XCTAssertFalse(editor.isEditable) finder.query = "PRINT" XCTAssertEqual((editor.string as NSString).substring(with: editor.selectedRange()), "PRINT") finder.replacement = "changed" finder.replace(all: false); finder.replace(all: true) XCTAssertEqual(editor.string, program) } func testExpansionLimitRejectsTheWholeEditBeforeItCanEnterUndo() { let find = SourceFind(), original = String(repeating: "x", count: 2048) let view = source(original) find.editor = view; find.query = "x"; find.replacement = String(repeating: "y", count: 2048) find.replace(all: true) XCTAssertEqual(view.string, original) XCTAssertNotNil(find.message) XCTAssertFalse(view.history.canUndo) } func testReplaceAllIsOneUndoAndReadOnlyAndEmptySearchAreSafe() { let find = SourceFind(), view = source("A A A") find.editor = view; find.query = "A"; find.replacement = "AA" find.replace(all: true); XCTAssertEqual(view.string, "AA AA AA") view.undoManager?.undo(); XCTAssertEqual(view.string, "A A A") view.undoManager?.redo(); XCTAssertEqual(view.string, "AA AA AA") let readOnly = source("A"); readOnly.isEditable = false find.editor = readOnly; find.replace(all: true); find.replace(all: false) XCTAssertEqual(readOnly.string, "A"); XCTAssertEqual(view.string, "AA AA AA") find.editor = view; find.query = ""; find.replace(all: true) XCTAssertEqual(view.string, "AA AA AA") } }