Files

430 lines
25 KiB
Swift

// 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..<min(left + Int(200 * scale), image.pixelsWide) {
for y in 2..<(image.pixelsHigh - 2) {
guard let rgb = image.colorAt(x: x, y: y)?.usingColorSpace(.deviceRGB) else { continue }
if rgb.redComponent - rgb.greenComponent > 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")
}
}