Files
VCCPlusOSS/platforms/macos/Tests/BASICReferenceTests.swift

579 lines
35 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import XCTest
import WebKit
// Content qualification may skip only an explicitly declared lookup edition.
// Missing or malformed manifests remain test failures, never silent skips.
enum TestBuildContent {
struct Manifest: Decodable {
let schemaVersion: Int
let profile: String
let manuals: String
}
static func read(resources: URL) throws -> Manifest {
let bytes = try Data(contentsOf: resources.appendingPathComponent("BuildContent.json"))
let value = try JSONDecoder().decode(Manifest.self, from: bytes)
guard value.schemaVersion == 1,
(value.profile == "normal" && value.manuals == "full") ||
(value.profile == "source" && value.manuals == "lookup") else {
throw CocoaError(.fileReadCorruptFile)
}
return value
}
static func requireFullManuals(resources: URL) throws {
if try read(resources: resources).manuals == "lookup" {
throw XCTSkip("This content profile includes BASIC and Assembly lookup; full-manual qualification is omitted.")
}
}
}
final class BASICReferenceTests: XCTestCase {
private func requireFullManualEdition() throws {
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let resources = try XCTUnwrap(app.resourceURL)
try TestBuildContent.requireFullManuals(resources: resources)
}
func testContentQualificationRequiresAValidExplicitManifest() throws {
let resources = FileManager.default.temporaryDirectory.appendingPathComponent("VCCContentManifest-" + UUID().uuidString)
try FileManager.default.createDirectory(at: resources, withIntermediateDirectories: false)
defer { try? FileManager.default.removeItem(at: resources) }
let manifest = resources.appendingPathComponent("BuildContent.json")
XCTAssertThrowsError(try TestBuildContent.read(resources: resources), "Missing content metadata is a failure")
for (profile, manuals) in [("normal", "full"), ("source", "lookup")] {
let bytes = try JSONSerialization.data(withJSONObject: ["schemaVersion": 1, "profile": profile, "manuals": manuals])
try bytes.write(to: manifest)
XCTAssertEqual(try TestBuildContent.read(resources: resources).manuals, manuals)
}
for invalid in ["{}", "not json", "{\"schemaVersion\":true,\"profile\":\"source\",\"manuals\":\"lookup\"}",
"{\"schemaVersion\":2,\"profile\":\"source\",\"manuals\":\"lookup\"}",
"{\"schemaVersion\":1,\"profile\":\"normal\",\"manuals\":\"lookup\"}"] {
try Data(invalid.utf8).write(to: manifest)
XCTAssertThrowsError(try TestBuildContent.read(resources: resources), invalid)
}
}
func testBASICAndAssemblyLookupTopicsAreReadableThroughTheNativeMCPIndex() async throws {
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let resources = try XCTUnwrap(app.resourceURL)
_ = try TestBuildContent.read(resources: resources)
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let index = MCPHelpIndex(root: root)
for (query, prefix) in [("PRINT", "programming-in-coco-basic/"), ("LDA", "assembly-language-programming/"),
("BHS", "assembly-language-programming/"), ("LBHS", "assembly-language-programming/")] {
let hits = try await index.search(query)
let hit = try XCTUnwrap(hits.first { $0.id.hasPrefix(prefix) }, query)
let topic = try await index.read(hit.id)
XCTAssertFalse(try XCTUnwrap(topic).text.isEmpty)
}
}
func testPackagedCollectionsRemainReadableForSelectedContentProfile() async throws {
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let resources = try XCTUnwrap(app.resourceURL)
let content = try TestBuildContent.read(resources: resources)
let catalog = try await SoftwareLibraryCatalog.load(from: resources.appendingPathComponent("SoftwareLibrary/catalog.sqlite"))
if content.profile == "source" {
XCTAssertTrue(catalog.titles.isEmpty)
XCTAssertEqual(catalog.releaseCount, 0)
}
let archiveURL = app.url(forResource: "ArchiveLibrary", withExtension: "sqlite", subdirectory: "ArchiveLibrary")
// Normal source checkouts can deliberately omit the optional index.
if archiveURL == nil && content.profile == "normal" { return }
let archive = ArchiveLibraryCatalog(url: try XCTUnwrap(archiveURL))
let collections = try await archive.collections()
let documents = try await archive.browse(collection: nil, limit: 10, offset: 0)
let matches = try await archive.search(query: "PRINT", collection: nil, limit: 10, offset: 0)
if content.profile == "source" {
XCTAssertTrue(collections.isEmpty)
XCTAssertTrue(documents.isEmpty)
XCTAssertTrue(matches.isEmpty)
}
}
func testManualExamplesResolveOnlyInsideTheBook() throws {
let files = FileManager.default
let temporary = files.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? files.removeItem(at: temporary) }
let root = temporary.appendingPathComponent("ManualLibrary")
let examples = root.appendingPathComponent("first-book/examples")
try files.createDirectory(at: examples, withIntermediateDirectories: true)
let signal = examples.appendingPathComponent("SIGNAL.bas")
try Data("10 END".utf8).write(to: signal)
let content = ManualLibraryContent(root: root)
XCTAssertEqual(content.relativePath(for: signal), "first-book/examples/SIGNAL.bas")
XCTAssertEqual(content.exampleURL(for: "first-book/examples/SIGNAL.bas"), signal.resolvingSymlinksInPath())
let outside = temporary.appendingPathComponent("personal.bas")
try Data().write(to: outside)
try files.createSymbolicLink(at: examples.appendingPathComponent("outside.bas"), withDestinationURL: outside)
XCTAssertNil(content.exampleURL(for: "first-book/examples/outside.bas"))
XCTAssertNil(content.exampleURL(for: "first-book/examples/../../../personal.bas"))
XCTAssertNil(content.exampleURL(for: "first-book/examples/missing.bas"))
XCTAssertNil(content.relativePath(for: outside))
}
func testPackagedDevelopmentExamplesOfferCopiesAndDoNotUseTheBASICEditor() throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let content = ManualLibraryContent(root: root)
let assembly = "your-first-6809-programs/examples/byte.asm"
XCTAssertEqual(content.copyTitle(for: assembly), "Save Assembly Example")
XCTAssertNil(content.exampleURL(for: assembly))
let source = "programming-in-c/examples/cargo.c"
XCTAssertEqual(content.copyTitle(for: source), "Save C Example")
XCTAssertNil(content.exampleURL(for: source))
XCTAssertEqual(content.copyTitle(for: "programming-in-c/examples/HelloDisk.zip"), "Save Example Project")
let advanced = "assembly-language-programming/examples/"
XCTAssertEqual(content.copyTitle(for: advanced + "bankwalk.asm"), "Save Assembly Example")
XCTAssertEqual(content.copyTitle(for: advanced + "Dispatch.zip"), "Save Example Project")
XCTAssertNil(content.exampleURL(for: advanced + "Dispatch.zip"))
let os9 = "working-with-os9/examples/"
XCTAssertEqual(content.copyTitle(for: os9 + "beacon.a"), "Save Assembly Example")
XCTAssertEqual(content.copyTitle(for: os9 + "night.b09"), "Save BASIC09 Example")
XCTAssertEqual(content.copyTitle(for: os9 + "watch.c"), "Save C Example")
XCTAssertNil(content.exampleURL(for: os9 + "night.b09"))
let hardware = "inside-the-coco-3/examples/"
XCTAssertEqual(content.copyTitle(for: hardware + "pixel-mask.asm"), "Save Assembly Example")
XCTAssertNotNil(content.exampleURL(for: hardware + "BEACON.bas"))
XCTAssertNil(content.copyTitle(for: "programming-in-c/examples/missing.c"))
XCTAssertNil(content.copyTitle(for: "programming-in-c/examples/../book-index.js"))
XCTAssertNil(content.copyTitle(for: "meet-your-color-computer/examples/SIGNAL.bas"))
let starter = "vibe-coding-with-chatgpt/examples/"
XCTAssertEqual(content.copyTitle(for: starter + "ProjectStarter.zip"), "Save Example Project")
XCTAssertEqual(content.copyTitle(for: starter + "PROJECT_SETUP_PREAMBLE.txt"), "Save Example Text")
XCTAssertNil(content.exampleURL(for: starter + "PROJECT_SETUP_PREAMBLE.txt"))
let reference = "toolchain-reference/sources/"
XCTAssertEqual(content.copyTitle(for: reference + "cmoc-manual.markdown"), "Save Original Manual Source")
XCTAssertEqual(content.copyTitle(for: reference + "lwtools-manual.docbook.sgml"), "Save Original Manual Source")
XCTAssertNil(content.copyTitle(for: reference + "lwtools-manual.pdf"), "PDFs remain readable in the library")
for help in ["cmoc-help.txt", "lwasm-help.txt", "lwlink-help.txt"] {
XCTAssertEqual(content.copyTitle(for: reference + help), "Save Command-Line Help")
}
XCTAssertTrue(content.allowsExternalReference(URL(string: "http://sarrazip.com/dev/cmoc.html")!))
XCTAssertTrue(content.allowsExternalReference(URL(string: "https://learn.chatgpt.com/docs/extend/mcp?surface=cli")!))
XCTAssertFalse(content.allowsExternalReference(URL(string: "https://example.com/unlisted")!))
XCTAssertFalse(content.allowsExternalReference(URL(fileURLWithPath: "/tmp/private.txt")))
}
func testOverlayContractIsDiscoverableAndReadableThroughTheBundledMCPIndex() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let index = MCPHelpIndex(root: root)
let hits = try await index.search("overlayGroups")
let hit = try XCTUnwrap(hits.first { $0.id.hasSuffix("#verified-physical-code-overlays") })
let read = try await index.read(hit.id)
let topic = try XCTUnwrap(read)
for field in ["banked_debug_manifest_versions", "verified_code_overlays", "overlayGroups", "residency_fingerprint"] {
XCTAssertTrue(topic.text.contains(field), field)
}
XCTAssertLessThanOrEqual(topic.text.utf8.count, 12 * 1024, "The complete contract must fit a read_topic response")
}
func testOriginalToolReferencesAreReadableThroughTheNativeMCPIndex() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let index = MCPHelpIndex(root: root)
for query in ["CMOC --initial-s", "LWASM --project-map", "LWLINK --sysroot"] {
let hits = try await index.search(query)
let hit = try XCTUnwrap(hits.first { $0.id.hasPrefix("toolchain-reference/") }, query)
let read = try await index.read(hit.id)
XCTAssertFalse(try XCTUnwrap(read).text.isEmpty)
}
let source = try String(contentsOf: root.appendingPathComponent("toolchain-reference/book-index.js"), encoding: .utf8)
let payload = source.dropFirst("(globalThis.manualBooks ??= []).push(".count).dropLast(3)
let record = try XCTUnwrap(JSONSerialization.jsonObject(with: Data(payload.utf8)) as? [String: Any])
for chapter in try XCTUnwrap(record["chapters"] as? [[String: Any]]) {
let page = try XCTUnwrap(chapter["page"] as? String)
for topic in try XCTUnwrap(chapter["sections"] as? [[String: Any]]) {
let id = try XCTUnwrap(topic["id"] as? String)
let read = try await index.read("toolchain-reference/\(page)#\(id)")
XCTAssertLessThanOrEqual(try XCTUnwrap(read).text.utf8.count, 12 * 1024,
"Every original-manual section must fit a complete read_topic response")
}
}
}
func testEveryBASICQuickReferenceTopicHasItsOwnBundledManualAnchor() throws {
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let content = ManualLibraryContent(root: root)
let catalog = try BASICReferenceCatalog.bundled.get()
var pages: [String: String] = [:]
var links = Set<URL>()
for entry in catalog.entries {
let url = try XCTUnwrap(content.basicTopicURL(for: entry))
let page = try XCTUnwrap(content.relativePath(for: url), entry.id)
let anchor = try XCTUnwrap(url.fragment, entry.id)
if pages[page] == nil {
pages[page] = try String(contentsOf: root.appendingPathComponent(page), encoding: .utf8)
}
XCTAssertTrue(links.insert(url).inserted, "Duplicate link for " + entry.id)
XCTAssertTrue(pages[page]?.contains("id=\"\(anchor)\"") == true, entry.id)
}
}
@MainActor
func testHandbookKeyboardModeLabelsFitAtCompactAndDesktopWidths() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let page = root.appendingPathComponent("users-handbook/keyboard.html")
for width in [320, 1024] {
let reader = ManualReader(content: ManualLibraryContent(root: root))
reader.webView.frame = CGRect(x: 0, y: 0, width: width, height: 800)
reader.webView.loadFileURL(page, allowingReadAccessTo: root)
let deadline = ContinuousClock.now + .seconds(8)
while reader.webView.url != page || reader.webView.isLoading {
guard ContinuousClock.now < deadline else {
return XCTFail("Keyboard chapter did not load")
}
try await Task.sleep(for: .milliseconds(40))
}
let measurements = try await reader.webView.evaluateJavaScript("""
(() => {
const rows = document.querySelectorAll('#keyboard-modes tr');
const lines = Array.from(rows, row => {
const range = document.createRange();
range.selectNodeContents(row.cells[0].querySelector('strong') || row.cells[0]);
return new Set(Array.from(range.getClientRects(), rect => rect.top)).size;
});
return [innerWidth, document.documentElement.scrollWidth, ...lines];
})()
""")
XCTAssertEqual(measurements as? [Int], [width, width, 1, 1, 1, 1],
"The page should fit and each of its four mode labels should occupy one line")
}
}
@MainActor
func testKeywordSearchUsesAllBundledBooksAndOpensLiteralCommand() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let reader = ManualReader(content: ManualLibraryContent(root: root))
let web = reader.webView
reader.showLibrarySearch()
let limit = ContinuousClock.now + .seconds(10)
while web.isLoading || web.url == nil {
guard ContinuousClock.now < limit else { return XCTFail("The manual shelf did not load") }
try await Task.sleep(for: .milliseconds(30))
}
let indexed = try await web.evaluateJavaScript("globalThis.manualBooks.map(book => book.book)")
let shelved = try await web.evaluateJavaScript("Array.from(document.querySelectorAll('.shelf-catalog dt a'), link => link.textContent)")
XCTAssertEqual(try XCTUnwrap(indexed as? [String]), try XCTUnwrap(shelved as? [String]))
func search(_ query: String) async throws -> [String] {
let result = try await web.callAsyncJavaScript("""
const field = document.getElementById("manual-query");
field.value = query;
field.dispatchEvent(new Event("input"));
return Array.from(document.querySelectorAll("#search-results a"), link => link.href);
""", arguments: ["query": query], in: nil, contentWorld: .page)
return try XCTUnwrap(result as? [String])
}
let capitals = try await search("What happened on the M2")
XCTAssertTrue(try XCTUnwrap(capitals.first).hasSuffix("/vibe-coding-with-chatgpt/06-capitals.html#m2-results"))
let cmoc = try await search("--initial-s")
XCTAssertTrue(cmoc.contains { $0.contains("/toolchain-reference/") }, "Bundled CMOC help must be searchable")
let lwasm = try await search("--listcol")
XCTAssertTrue(lwasm.contains { $0.contains("/toolchain-reference/") }, "Bundled LWASM help must be searchable")
let forward = try await search("joystick keyboard")
let reversed = try await search("KEYBOARD joystick")
XCTAssertFalse(forward.isEmpty)
XCTAssertEqual(Set(forward), Set(reversed))
let missing = try await search("joystick zzNoSuchKeyword")
XCTAssertTrue(missing.isEmpty)
let broad = try await search("CoCo")
let total = try await web.evaluateJavaScript("parseInt(document.getElementById('search-status').textContent, 10)")
XCTAssertGreaterThan(try XCTUnwrap(total as? Int), broad.count)
let more = try await web.evaluateJavaScript("document.querySelector('#search-results + button').click(); document.querySelectorAll('#search-results a').length")
XCTAssertGreaterThan(try XCTUnwrap(more as? Int), broad.count)
let command = try await search("print@")
let first = try XCTUnwrap(command.first)
XCTAssertTrue(first.contains("/programming-in-coco-basic/reference.html#term-print-at"), first)
let highlight = try await web.evaluateJavaScript("document.querySelector('#search-results a mark')?.textContent")
XCTAssertEqual(highlight as? String, "PRINT@")
_ = try await web.evaluateJavaScript("document.querySelector('#search-results a').click()")
let pageLimit = ContinuousClock.now + .seconds(5)
while web.url?.absoluteString != first || web.isLoading {
guard ContinuousClock.now < pageLimit else { return XCTFail("The matching section did not open") }
try await Task.sleep(for: .milliseconds(30))
}
let heading = try await web.evaluateJavaScript("document.querySelector(':target h2').textContent")
XCTAssertEqual(heading as? String, "PRINT@")
}
@MainActor
func testPackagedReaderOpensSignalAndKeepsChapter() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let reader = ManualReader(content: ManualLibraryContent(root: root))
func waitForPage(_ name: String) async throws {
let limit = ContinuousClock.now + .seconds(8)
while reader.webView.url?.lastPathComponent != name || reader.webView.isLoading {
guard ContinuousClock.now < limit else {
XCTFail("Timed out loading " + name + ": " + (reader.error ?? "no navigation error"))
throw CocoaError(.fileReadUnknown)
}
try await Task.sleep(for: .milliseconds(40))
}
}
reader.showHome()
try await waitForPage("index.html")
_ = try await reader.webView.evaluateJavaScript("document.querySelector('.shelf-routes a').click(); true")
try await waitForPage("template.html")
_ = try await reader.webView.evaluateJavaScript("document.querySelector('a[href*=catch-the-computer]').click(); true")
try await waitForPage("catch-the-computer.html")
let chapter = reader.webView.url
let opened = expectation(description: "Open the bundled example in BASIC")
reader.openExample = { path in
XCTAssertEqual(path, "meet-your-color-computer/examples/SIGNAL.bas")
opened.fulfill()
}
_ = try await reader.webView.evaluateJavaScript("document.querySelector('a[href$=\"SIGNAL.bas\"]').click(); true")
await fulfillment(of: [opened], timeout: 5)
XCTAssertEqual(reader.webView.url, chapter)
XCTAssertTrue(reader.webView.canGoBack)
}
@MainActor
func testUpdatedHandbookAndCapitalQuestFitAndLoadFigures() async throws {
try requireFullManualEdition()
let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent()
let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app")))
let root = try XCTUnwrap(app.url(forResource: "ManualLibrary", withExtension: nil))
let pages = ["users-handbook/desk.html", "users-handbook/media.html",
"users-handbook/workbenches.html", "vibe-coding-with-chatgpt/04-c.html",
"vibe-coding-with-chatgpt/06-capitals.html", "vibe-coding-with-chatgpt/08-field-guide.html",
"vibe-coding-with-chatgpt/09-start-a-project.html", "toolchain-reference/index.html",
"toolchain-reference/cmoc.html", "toolchain-reference/lwtools.html", "toolchain-reference/command-line.html"]
for width in [420, 1024] {
for path in pages {
let reader = ManualReader(content: ManualLibraryContent(root: root))
let web = reader.webView
web.frame = CGRect(x: 0, y: 0, width: width, height: 850)
let page = root.appendingPathComponent(path)
web.loadFileURL(page, allowingReadAccessTo: root)
let deadline = ContinuousClock.now + .seconds(12)
while web.url != page || web.isLoading {
guard ContinuousClock.now < deadline else { return XCTFail("Manual did not load: " + path) }
try await Task.sleep(for: .milliseconds(40))
}
let images = try await web.callAsyncJavaScript("""
await document.fonts.ready;
await Promise.all(Array.from(document.images, image => image.decode().catch(() => {})));
return Array.from(document.images).filter(image => !image.complete || image.naturalWidth === 0).map(image => image.getAttribute('src'));
""", contentWorld: .page)
XCTAssertEqual(images as? [String], [], "Every figure must load: " + path)
let size = try await web.evaluateJavaScript("[innerWidth, document.documentElement.scrollWidth]")
XCTAssertEqual(size as? [Int], [width, width], "The complete page must fit the reader: " + path)
if width == 1024, ["users-handbook/desk.html", "users-handbook/media.html", "vibe-coding-with-chatgpt/06-capitals.html"].contains(path) {
let anchor = path.contains("desk") ? "archive-reviewed-code" : path.contains("media") ? "disk-image-editor" : "capital-quest"
_ = try await web.callAsyncJavaScript("document.getElementById(anchor).scrollIntoView();", arguments: ["anchor": anchor], contentWorld: .page)
let image = try await web.takeSnapshot(configuration: nil)
let attachment = XCTAttachment(image: image)
attachment.name = "Updated manual — " + path
attachment.lifetime = .keepAlways
add(attachment)
}
}
}
}
private func lookup(_ marked: String) -> String? {
let marker = (marked as NSString).range(of: "|")
precondition(marker.location != NSNotFound)
let source = (marked as NSString).replacingCharacters(in: marker, with: "")
return BASICReferenceContext.keyword(in: source, at: marker.location)
}
func testContextResolvesCompositeCommandsAndTokenBoundaries() {
let cases: [(String, String)] = [
("10 LOA|DM \"PROGRAM\"", "LOADM"), ("10 SAVEM| \"PROGRAM\",100,200,100", "SAVEM"),
("10 CLOADM| \"PROGRAM\"", "CLOADM"), ("10 CSAVE|M \"PROGRAM\",100,200,100", "CSAVEM"),
("10 LINE IN|PUT A$", "LINE INPUT"), ("10 LINEINPUT A$|", "LINE INPUT"),
("10 ON ER|R GOTO 100", "ON ERR"), ("10 ONERRGOTO 100|", "ON ERR"),
("10 DEF F|NX(A)=A*2", "DEF FN"), ("10 PRINT US|ING \"###\";A", "PRINT USING"),
("10 PRINT@ 100, A|", "PRINT@"), ("10 PRINT @ 100, A|", "PRINT@"),
("10 GO TO 100|", "GOTO"), ("10 GOSUB 100|", "GOSUB"),
("10 go sub 100|", "GOSUB"), ("10 PRINT| A", "PRINT"),
("10 DATA|", "DATA"), ("10 REM|", "REM")
]
for (source, expected) in cases { XCTAssertEqual(lookup(source), expected, source) }
}
func testContextPrefersPointedFunctionAndOtherwiseUsesOwningStatement() {
XCTAssertEqual(lookup("10 PRINT LE|FT$(A$,2)"), "LEFT$")
XCTAssertEqual(lookup("10 PRINT LEFT$(A$,2|)"), "PRINT")
XCTAssertEqual(lookup("10 A=RN|D(6)"), "RND")
XCTAssertEqual(lookup("10 A=RND(6|)"), "LET")
XCTAssertEqual(lookup("10 A=42|"), "LET")
XCTAssertEqual(lookup("10 FOR I=1 TO 10|"), "FOR")
XCTAssertEqual(lookup("10 FOR I=1 TO 10:PRINT I|"), "PRINT")
XCTAssertEqual(lookup("10 IF A THEN PRINT A| ELSE PRINT B"), "PRINT")
XCTAssertEqual(lookup("10 IF A THEN PRINT A ELSE B=RND(6|)"), "LET")
XCTAssertEqual(lookup("10 IF A THEN 100|"), "IF")
XCTAssertEqual(lookup("10 ON A GOSUB 100,200|"), "ON")
XCTAssertEqual(lookup("10 INPUT \"TIME: \";A|"), "INPUT")
}
func testContextIgnoresLiteralCommentAndDataContents() {
for source in ["10 PRINT \"LE|FT$\"", "10 PRINT \"UNFINISHED|", "10 REM PRI|NT 1", "10 'PRI|NT 1",
"10 DATA PRINT,LOAD|", "10 DATA \"PRINT:|LOAD\",1", "10 PRINT 1|:PRINT 2"] {
XCTAssertNil(lookup(source), source)
}
XCTAssertEqual(lookup("10 DATA \"PRINT:LOAD\",1:PR|INT A"), "PRINT")
XCTAssertEqual(lookup("10 PRINT \"A:B\":SOUND 100,2|"), "SOUND")
XCTAssertEqual(lookup("10 REM 😀\r\n20 PR|INT A"), "PRINT")
XCTAssertNil(lookup("10| PRINT 1"))
XCTAssertNil(lookup("10 PRINT 1\n|"))
}
func testContextRejectsInvalidOrExcessiveOffsetsWithoutChangingSource() {
let source = "10 PRINT 1\n"
XCTAssertNil(BASICReferenceContext.keyword(in: source, at: -1))
XCTAssertNil(BASICReferenceContext.keyword(in: source, at: Int.max))
XCTAssertNil(BASICReferenceContext.keyword(in: "", at: 0))
XCTAssertNil(BASICReferenceContext.keyword(in: String(repeating: "A", count: BASICLanguage.maximumSourceBytes + 1), at: 1))
XCTAssertEqual(source, "10 PRINT 1\n")
}
private func fixture() throws -> BASICReferenceCatalog {
let rows: [(String, String, String, String)] = [
("PRINT", "PRINT", "common", "Text"), ("DRIVE", "DRIVE", "disk", "Storage"),
("RGB.DRIVE", "DRIVE", "rgbdos", "Storage"), ("SDC.DRIVE", "DRIVE", "sdcdos", "Storage"),
("ERROR.SN", "SN", "common", "Errors")
]
let entries: [[String: Any]] = rows.map { id, keyword, dialect, category in
["id": id, "keyword": keyword, "title": id, "category": category, "dialect": dialect,
"summary": id == "SDC.DRIVE" ? "Mount an image in a drive." : "Reference for " + keyword,
"syntax": [keyword], "parameters": [], "sample": keyword, "related": id == "PRINT" ? ["DRIVE"] : [],
"notes": [], "source": "basicGuide", "sourcePage": "1"]
}
let data = try JSONSerialization.data(withJSONObject: ["entries": entries, "examples": []])
return try JSONDecoder().decode(BASICReferenceCatalog.self, from: data)
}
func testEveryTopicCitesAnOfflineWorkWithItsOriginalPageConvention() throws {
let catalog = try BASICReferenceCatalog.bundled.get()
XCTAssertEqual(Set(catalog.entries.map(\.source)), Set(BASICReferenceWork.allCases))
let rgb = try XCTUnwrap(catalog.entries.first { $0.source == .rgbdos })
XCTAssertTrue(rgb.citation.contains("Krupski"))
XCTAssertTrue(rgb.citation.contains("PDF page"))
XCTAssertTrue(catalog.entries.contains { $0.citation.contains("1986. p. 27.") })
XCTAssertTrue(catalog.entries.allSatisfy { !$0.citation.contains("://") })
}
@MainActor func testBrowserLookupSelectsDialectAndClearsFilters() throws {
let model = BASICReferenceModel(catalog: try fixture())
model.category = "Text"; model.search = "print"
model.show(keyword: "drive", dialect: .sdcdos)
XCTAssertEqual(model.selectedID, "SDC.DRIVE")
XCTAssertNil(model.category); XCTAssertEqual(model.search, "")
model.show(keyword: "DRIVE", dialect: .rgbdos)
XCTAssertEqual(model.selectedID, "RGB.DRIVE")
model.show(keyword: "DRIVE")
XCTAssertEqual(model.selectedID, "DRIVE")
model.showError(code: "sn")
XCTAssertEqual(model.selectedID, "ERROR.SN")
}
@MainActor func testBrowserSearchCategoriesAndPinnedSelection() throws {
let model = BASICReferenceModel(catalog: try fixture())
model.show(keyword: "DRIVE", dialect: .sdcdos)
_ = BASICReferenceContext.keyword(in: "10 PRINT 42", at: 5)
XCTAssertEqual(model.selectedID, "SDC.DRIVE", "Reading cursor context must not replace a pinned topic")
model.search = "mount IMAGE"
XCTAssertEqual(model.filteredEntries.map(\.id), ["SDC.DRIVE"])
model.category = "Text"
XCTAssertTrue(model.filteredEntries.isEmpty); XCTAssertNil(model.selectedID)
model.category = nil; model.search = ""
XCTAssertEqual(model.filteredEntries.count, 5)
XCTAssertEqual(model.relatedEntry("DRIVE")?.id, "DRIVE")
XCTAssertNil(model.relatedEntry("not-a-topic"))
}
func testBundledCatalogCoverageLinksAndExampleStructure() throws {
let catalog = try BASICReferenceCatalog.bundled.get()
let ids = Set(catalog.entries.map(\.id))
XCTAssertEqual(ids.count, catalog.entries.count, "Topic identifiers must be unique")
let keywords = Set(catalog.entries.map { $0.keyword.uppercased() })
XCTAssertTrue(Set(BASICLanguage.words).subtracting(keywords).isEmpty,
"Every completion keyword should have a reference topic")
for keyword in ["LOADM", "SAVEM", "CLOADM", "CSAVEM", "LINE INPUT", "ON ERR", "DEF FN", "PRINT USING", "PRINT@"] {
XCTAssertTrue(keywords.contains(keyword), keyword)
}
let exampleIDs = Set(catalog.examples.map(\.id))
XCTAssertEqual(exampleIDs.count, catalog.examples.count)
XCTAssertFalse(catalog.examples.isEmpty)
for entry in catalog.entries {
XCTAssertFalse(entry.summary.isEmpty, entry.id)
XCTAssertFalse(entry.citation.isEmpty, entry.id)
XCTAssertTrue(Set(entry.related).isSubset(of: ids), "Broken related topic in " + entry.id)
if let exampleID = entry.exampleID { XCTAssertTrue(exampleIDs.contains(exampleID), entry.id) }
}
for example in catalog.examples {
let analysis = BASICLanguage.analyze(example.source)
XCTAssertFalse(analysis.hasErrors, example.id)
XCTAssertFalse(analysis.lines.isEmpty, example.id)
XCTAssertFalse(example.expectedOutput.isEmpty, example.id)
}
}
@MainActor func testExampleWorkspaceKeepsOriginalDraftAndMachineOwnership() async throws {
let directory = FileManager.default.temporaryDirectory.appendingPathComponent("BASICReference-" + UUID().uuidString)
let suite = "BASICReference-" + UUID().uuidString
let defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: directory) }
let machine = MachineModel(diskStore: .init(url: directory.appendingPathComponent("disks.json")),
displayDefaults: defaults, inputStore: .init(url: directory.appendingPathComponent("input.json")))
let originalDirectory = directory.appendingPathComponent("original")
let exampleDirectory = directory.appendingPathComponent("example")
let original = BASICDevelopmentModel(machine: machine, directory: originalDirectory)
original.source = "10 PRINT \"MY UNSAVED WORK\"\n"
original.persistDraft()
machine.basicWorkspaceOwner = original.workspaceID
let source = "10 PRINT 42\n20 END\n"
let example = BASICDevelopmentModel(machine: machine, directory: exampleDirectory,
initialSource: source, title: "Reference Example")
XCTAssertEqual(example.source, source)
XCTAssertEqual(example.title, "Reference Example")
XCTAssertFalse(example.dirty)
XCTAssertNil(example.fileURL)
XCTAssertNotEqual(original.workspaceID, example.workspaceID)
example.source = "10 PRINT 43\n20 END\n"
example.persistDraft()
XCTAssertEqual(machine.basicWorkspaceOwner, original.workspaceID)
XCTAssertEqual(original.source, "10 PRINT \"MY UNSAVED WORK\"\n")
XCTAssertTrue(original.dirty)
XCTAssertNil(original.fileURL)
let restoredExample = BASICDevelopmentModel(machine: machine, directory: exampleDirectory,
initialSource: source, title: "Reference Example")
let restoredOriginal = BASICDevelopmentModel(machine: machine, directory: originalDirectory)
XCTAssertEqual(restoredExample.source, example.source)
XCTAssertTrue(restoredExample.dirty)
XCTAssertEqual(restoredOriginal.source, original.source)
XCTAssertTrue(restoredOriginal.dirty)
XCTAssertEqual(machine.basicWorkspaceOwner, original.workspaceID)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
}