Sync source edition with VCC Plus 3.7.0 build 63

This commit is contained in:
Brian Holman committed 2026-11-14 01:43:46 -07:00
1 parent c652a5276d
commit b2ecec4d87
86 files changed
+10519 -472

No files matched your search

@@ -93,6 +93,68 @@ final class SoftwareLibraryBrowseTests: XCTestCase {
XCTAssertEqual(LibraryBrowseQuery.type(of: cartridge, related: [disk, music]), "Other", "Conflicting editions do not establish a type")
XCTAssertEqual(LibraryBrowseQuery.type(of: release("demo", category: "Disks/Games/Sierra Games/Demos")), "Games")
}
func testUnifiedPersonalGamesAreFirstAndAvailableToLocalDiskCompanion() {
var entry = PersonalSoftwareEntry(id: UUID(), title: "Private Game", files: [
.init(path: "PRIVATE.DSK", kind: "disk", byteSize: 4, sha256: String(repeating: "a", count: 64))
])
entry.category = "Games"
let privateRelease = entry.release(in: directory)
let privateTitle = SoftwareLibraryTitle(id: entry.titleID, name: entry.title, identityStatus: "personal", releases: [privateRelease])
let publicGame = title("public-game", name: "Public Game", [release("public-edition", category: "Disks/Games")])
let titles = [privateTitle, publicGame]
XCTAssertEqual(LibraryBrowseQuery(scope: .all, softwareType: "Games").apply(to: titles, favorites: [entry.titleID], installed: [entry.releaseID]).map(\.id), [entry.titleID, publicGame.id])
XCTAssertEqual(LibraryBrowseQuery(scope: .all, category: "Games").apply(to: [privateTitle], favorites: [], installed: []).count, 1)
for scope in [LibraryBrowseQuery.Scope.started, .showcase, .installed] {
XCTAssertTrue(LibraryBrowseQuery(scope: scope).apply(to: [privateTitle], favorites: [entry.titleID], installed: [entry.releaseID]).isEmpty)
}
XCTAssertEqual(LibraryBrowseQuery(scope: .personal).apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID])
XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: titles, favorites: [entry.titleID], installed: []).map(\.id), [entry.titleID])
XCTAssertEqual(LibraryBrowseQuery(scope: .search, text: "Private Game").apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID])
let companion = SoftwareLibraryCatalog(titles: titles, metadata: [:]).companionDisksOnly
XCTAssertEqual(companion.titles.map(\.id), [privateTitle.id, publicGame.id], "The user's local companion can browse their own disks")
}
func testPersonalGroupIsAlphabeticalBeforeCatalogWithoutMergingSameNames() {
func personal(_ name: String, bytes: Int64) -> SoftwareLibraryTitle {
var entry = PersonalSoftwareEntry(id: UUID(), title: name, files: [.init(path: "GAME.dsk", kind: "disk", byteSize: bytes, sha256: String(repeating: "a", count: 64))])
entry.category = "Games"
return .init(id: entry.titleID, name: name, identityStatus: "personal", releases: [entry.release(in: directory)])
}
let privateA = personal("A Game", bytes: 10000), privateZ = personal("Z Game", bytes: 1)
let publicA = title("public-a", name: "A Game", [release("a", bytes: 10)])
let publicB = title("public-b", name: "B Game", [release("b", bytes: 50)])
for sort in LibraryBrowseQuery.Sort.allCases {
let rows = LibraryBrowseQuery(scope: .all, softwareType: "Games", sort: sort).apply(to: [publicA, privateZ, publicB, privateA], favorites: [], installed: [])
XCTAssertEqual(Array(rows.prefix(2)).map(\.id), [privateA.id, privateZ.id])
XCTAssertTrue(rows[0].isPersonal); XCTAssertFalse(rows[2].isPersonal)
XCTAssertEqual(rows.count, 4, "Personal and catalog editions with the same name stay distinct")
XCTAssertEqual(Array(rows.suffix(2)).map(\.id), sort == .size ? [publicB.id, publicA.id] : [publicA.id, publicB.id])
}
XCTAssertTrue(LibraryBrowseQuery(scope: .all, softwareType: "Music").apply(to: [privateA], favorites: [], installed: []).isEmpty)
}
@MainActor
func testHeaderSearchEscapesEveryPriorScopeAndFacetsAndResumes() async throws {
let support = directory.appendingPathComponent("GlobalSearch")
let continuity = LibraryContinuityStore(directory: support)
let model = SoftwareLibraryModel(state: .init(directory: support), continuity: continuity)
model.restoreBrowseContext()
for scope in LibraryBrowseQuery.Scope.allCases where scope != .search {
model.query = .init(scope: scope, category: "Disks", softwareType: "Music", media: "cassette", evidence: "checked", sort: .modified)
model.setSearchText("Popstar")
XCTAssertEqual(model.query, .init(scope: .search, text: "Popstar", sort: .modified))
}
model.query.media = "disk"; model.setSearchText("Popstar Game")
XCTAssertEqual(model.query.media, "disk", "Explicit filters within Search Results survive further typing")
model.saveBrowseContext(); await continuity.flush()
let resumed = SoftwareLibraryModel(state: .init(directory: support), continuity: LibraryContinuityStore(directory: support))
await resumed.load(from: try database()); try await settle(resumed)
XCTAssertEqual(resumed.query.scope, .search); XCTAssertEqual(resumed.query.text, "Popstar Game")
XCTAssertEqual(resumed.query.media, "disk")
model.setSearchText("")
XCTAssertEqual(model.query.scope, .all); XCTAssertEqual(model.query.text, "")
await model.shutdown(); await resumed.shutdown()
}
func testAdvancedFacetsMatchTheSameEditionAndKeepUnknownEvidenceHonest() {
let disk = release("disk", environment: "os9", processor: "6309", hardware: ["speech-sound": "optional"], videoModes: ["SG-12"])
let tape = release("tape", media: "cassette", environment: "basic", processor: "either", hardware: ["joystick": "unspecified"], videoModes: ["6847T1"])
@@ -221,6 +283,87 @@ final class SoftwareLibraryBrowseTests: XCTestCase {
await state.flush()
}
@MainActor
func testColdResumeRetainsSelectionWhileCatalogRecoveryIsDelayed() async throws {
let support = directory.appendingPathComponent("DelayedResume")
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
let query = LibraryBrowseQuery(scope: .all)
let encoded = String(decoding: try JSONEncoder().encode(query), as: UTF8.self)
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded, "layout": "Table"], selectedID: "other"), for: "software-main")
await continuity.flush()
let restored = LibraryContinuityStore(directory: support)
let model = SoftwareLibraryModel(state: state, continuity: restored), url = try database()
let loading = Task { await model.load(from: url, catalogLoader: { url in
try await Task.sleep(nanoseconds: 350_000_000)
return try await SoftwareLibraryCatalog.load(from: url)
}) }
for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) }
try await Task.sleep(nanoseconds: 180_000_000) // exceeds the empty-result filter debounce
XCTAssertTrue(model.loading)
XCTAssertEqual(model.selection, "other")
XCTAssertEqual(restored.browse(for: "software-main")?.selectedID, "other", "An empty interim result must not overwrite resume state")
await loading.value; try await settle(model)
XCTAssertEqual(model.selection, "other"); XCTAssertEqual(model.layout, "Table")
XCTAssertEqual(model.selectedRow?.name, "Other Game")
await model.shutdown()
}
@MainActor
func testFailedCatalogReadKeepsPublicResumePendingForRetry() async throws {
let support = directory.appendingPathComponent("FailedResume")
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self)
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main")
let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database()
await model.load(from: url, catalogLoader: { _ in throw CocoaError(.fileReadNoPermission) })
try await settle(model)
XCTAssertNotNil(model.error); XCTAssertNil(model.catalog)
XCTAssertEqual(model.selection, "other")
XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, "other")
await model.load(from: url); try await settle(model)
XCTAssertNil(model.error); XCTAssertEqual(model.selection, "other")
XCTAssertEqual(model.selectedRow?.name, "Other Game")
await model.shutdown()
}
@MainActor
func testPrivateScopeRemainsUsableWhenPublicCatalogCannotLoad() async throws {
let support = directory.appendingPathComponent("PrivateWithoutCatalog")
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .personal)), as: UTF8.self)
continuity.setBrowse(.init(scope: "personal", filters: ["browse-query": encoded], selectedID: "personal:missing"), for: "software-main")
let model = SoftwareLibraryModel(state: state, continuity: continuity)
let source = directory.appendingPathComponent("LOCAL.ccc"); try Data([0x12,0x39]).write(to: source)
let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft)
await model.load(from: directory.appendingPathComponent("Unavailable.sqlite"), catalogLoader: { _ in throw CocoaError(.fileReadNoSuchFile) })
try await settle(model)
XCTAssertNil(model.catalog); XCTAssertNotNil(model.error)
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selectedRow?.id, entry.titleID)
await model.shutdown()
}
@MainActor
func testPersonalSaveDuringColdCatalogLoadWinsOverResumedPublicScope() async throws {
let support = directory.appendingPathComponent("PersonalDuringLoad")
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self)
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main")
let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database()
let source = directory.appendingPathComponent("AUTHORED.ccc")
try Data([0x12,0x39]).write(to: source)
let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft)
let loading = Task { await model.load(from: url, catalogLoader: { url in
try await Task.sleep(nanoseconds: 500_000_000)
return try await SoftwareLibraryCatalog.load(from: url)
}) }
for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) }
try await Task.sleep(nanoseconds: 150_000_000)
model.editPersonal(entry); model.savePersonal(entry, allowDuplicate: false)
for _ in 0..<100 where model.personalSaving { try await Task.sleep(nanoseconds: 5_000_000) }
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID)
await loading.value; try await settle(model)
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID)
XCTAssertEqual(model.selectedRow?.id, entry.titleID)
await model.shutdown()
XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, entry.titleID)
}
@MainActor
func testRapidQueriesAndFavoriteChangesPublishLatestResults() async throws {
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal"))
let model = SoftwareLibraryModel(state: state)