Files
VCCPlusOSS/platforms/macos/Tests/SDCPersistenceTests.swift
T

124 lines
7.3 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class SDCPersistenceTests: XCTestCase {
private struct Fixture {
let root: URL, card: URL, rom: URL, store: DiskAssignmentStore
init() throws {
root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
card = root.appendingPathComponent("My SD Card", isDirectory: true)
rom = root.appendingPathComponent("SDC.rom")
store = DiskAssignmentStore(url: root.appendingPathComponent("settings.json"))
try FileManager.default.createDirectory(at: card, withIntermediateDirectories: true)
try Data(repeating: 0x12, count: 16384).write(to: rom)
}
func remove() { try? FileManager.default.removeItem(at: root) }
func assignments() -> DiskAssignments {
var result = DiskAssignments(), layout = CartridgeAssignments()
layout.multiPak = true; layout.mpiConfigured = true
layout.slots[4] = .init(kind: .sdc, url: rom, sdcFolderURL: card)
result.cartridges = layout
return result
}
}
func testSDCProfileRoundTripReferencesAndDefaultProtection() throws {
let f = try Fixture(); defer { f.remove() }
let assignments = f.assignments(); try f.store.save(assignments)
XCTAssertEqual(try f.store.load(), assignments)
XCTAssertNil(try f.store.load().cartridges?.slots[4].sdcReadOnly)
var profile = ConfigurationProfile(name: "SDC card"); profile.media = assignments
let url = f.root.appendingPathComponent("sdc.vccprofile")
try ProfileStore.write(profile, to: url)
let decoded = try ProfileStore.read(url)
XCTAssertEqual(decoded, profile)
XCTAssertTrue(decoded.references.contains { $0.key == .sdcFolder(4) && $0.url == f.card })
let request = try PreparedProfile.read(decoded).request()
XCTAssertEqual(request.kinds[4], 7); XCTAssertEqual(request.cartridgeROMs[4].count, 16384)
XCTAssertEqual(request.sdcFolders[4], f.card.path); XCTAssertEqual(request.sdcReadOnly[4], 1)
profile.media.cartridges?.slots[4].sdcReadOnly = false
XCTAssertEqual(try PreparedProfile.read(profile).request().sdcReadOnly[4], 0)
let duplicate = profile.media.cartridges!.slots[4]
profile.media.cartridges?.slots[2] = duplicate
XCTAssertThrowsError(try profile.validate(), "Only one SDC can occupy the Multi-Pak")
profile.media = assignments
profile.media.cartridges?.slots[4].sdcFolderURL = URL(string: "https://example.com/card")!
XCTAssertThrowsError(try profile.validate())
profile.media = assignments
profile.media.cartridges?.slots[4].kind = .rom
XCTAssertThrowsError(try profile.validate(), "SDC-only settings must not be silently attached to another device")
}
func testMissingCardPreflightAndReferenceRepair() throws {
let f = try Fixture(); defer { f.remove() }
var profile = ConfigurationProfile(name: "Missing card"); profile.media = f.assignments()
try FileManager.default.removeItem(at: f.card)
XCTAssertThrowsError(try PreparedProfile.read(profile))
let replacement = f.root.appendingPathComponent("Recovered", isDirectory: true)
try FileManager.default.createDirectory(at: replacement, withIntermediateDirectories: true)
profile.replace(.sdcFolder(4), with: replacement)
XCTAssertEqual(try PreparedProfile.read(profile).request().sdcFolders[4], replacement.path)
XCTAssertThrowsError(try DiskFiles.validateSDCFolder(f.rom), "A ROM file is not an SD folder")
try Data(repeating: 0, count: 8193).write(to: f.rom)
XCTAssertThrowsError(try DiskFiles.readSDCROM(f.rom))
}
@MainActor func testBothMissingReferencesCanBeRepairedOneAtATime() async throws {
let f = try Fixture(); defer { f.remove() }
try f.store.save(f.assignments())
let replacement = f.root.appendingPathComponent("replacement.rom")
try Data(repeating: 0x12, count: 8192).write(to: replacement)
try FileManager.default.removeItem(at: f.rom)
try FileManager.default.removeItem(at: f.card)
try await withModel(f.store) { model in
XCTAssertNotNil(model.cartridgeRestoreErrors[4])
model.selectCartridgeROM(replacement, slot: 4, kind: .sdc); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[4].url, replacement)
XCTAssertNotNil(model.cartridgeRestoreErrors[4])
let recovered = f.root.appendingPathComponent("Recovered", isDirectory: true)
try FileManager.default.createDirectory(at: recovered, withIntermediateDirectories: true)
model.selectSDCFolder(recovered, slot: 4); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[4].sdcFolderURL, recovered)
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
XCTAssertEqual(model.cartridgeNames[4], "CoCo SDC")
}
}
@MainActor private func settled(_ model: MachineModel) async throws {
for _ in 0..<1000 {
if !model.busy && !model.diskSaving { return }
try await Task.sleep(nanoseconds: 10_000_000)
}
throw NSError(domain: "SDCTestTimeout", code: 1)
}
@MainActor private func withModel(_ store: DiskAssignmentStore, body: (MachineModel) async throws -> Void) async throws {
let model = MachineModel(diskStore: store)
do { try await settled(model); try await body(model) }
catch { await withCheckedContinuation { done in model.shutdown { done.resume() } }; throw error }
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
@MainActor func testRememberedCardSlotMoveRecoveryAndSystemArtwork() async throws {
let f = try Fixture(); defer { f.remove() }
try f.store.save(f.assignments())
try await withModel(f.store) { model in
XCTAssertEqual(model.cartridgeNames[4], "CoCo SDC")
XCTAssertFalse(model.hardware.custom)
XCTAssertEqual(model.hardware.values["slot4"], "sdc")
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
model.assignCartridge(.sdc, slot: 2); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[4].kind, .empty)
XCTAssertEqual(model.cartridgeAssignments.slots[2].sdcFolderURL, f.card)
XCTAssertEqual(model.cartridgeAssignments.slots[2].url, f.rom)
XCTAssertEqual(model.hardware.values["slot2"], "sdc")
XCTAssertEqual(model.hardware.values["slot4"], "empty")
}
try FileManager.default.removeItem(at: f.card)
try await withModel(f.store) { model in
XCTAssertEqual(model.cartridgeAssignments.slots[2].kind, .sdc)
XCTAssertEqual(model.cartridgeAssignments.slots[2].sdcFolderURL, f.card)
XCTAssertNotNil(model.cartridgeRestoreErrors[2])
XCTAssertTrue(model.cartridgeNames[2].isEmpty)
try FileManager.default.createDirectory(at: f.card, withIntermediateDirectories: true)
model.retryRememberedCartridges(); try await settled(model)
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
XCTAssertEqual(model.cartridgeNames[2], "CoCo SDC")
}
}
}