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

669 lines
48 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import Foundation
final class DiskImageBackendTests: XCTestCase {
private var folder: URL!
private let content = Data("VCC Plus authored Disk Image Editor fixture.\rDECB and OS-9 round trips preserve exact file bytes.\r".utf8)
override func setUpWithError() throws {
folder = FileManager.default.temporaryDirectory.appendingPathComponent("Disk Editor backend " + UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
}
override func tearDownWithError() throws { try? FileManager.default.removeItem(at: folder) }
private func fixture(_ format: String) throws -> (URL, Data) {
let source = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/\(format).dsk")
let bytes = try Data(contentsOf: source)
let working = folder.appendingPathComponent(format + ".dsk")
try bytes.write(to: working)
return (working, bytes)
}
private func number(_ value: [String: Any], _ name: String) throws -> Int { try XCTUnwrap(value[name] as? NSNumber).intValue }
func testDECBRoundTripExplicitMetadataReplacementAndAllocationAccounting() throws {
let (url, original) = try fixture("DECB")
let initial = try VCCDiskImageEditorBackend.inspectImage(at: url)
XCTAssertEqual(initial["format"] as? String, "decb")
XCTAssertEqual(try number(initial, "byte_count"), 161280)
XCTAssertEqual(try number(initial, "capacity_bytes"), 68 * 2304)
XCTAssertEqual(try number(initial, "used_bytes"), 2304)
XCTAssertEqual(try number(initial, "free_bytes"), 67 * 2304)
XCTAssertEqual(try number(initial, "protected_suffix_bytes"), 0)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
let payload = Data((0..<3000).map { UInt8(truncatingIfNeeded: $0 * 17) })
try VCCDiskImageEditorBackend.importData(payload, named: "probe.bin", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false)
let entry = try XCTUnwrap(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).first { $0["name"] as? String == "PROBE.BIN" })
XCTAssertEqual(entry["size"] as? Int, 3000)
XCTAssertEqual(entry["file_type"] as? Int, 2)
XCTAssertEqual(entry["encoding"] as? String, "Binary")
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("PROBE.BIN", imageURL: url), payload)
let allocated = try VCCDiskImageEditorBackend.inspectImage(at: url)
XCTAssertEqual(try number(allocated, "used_bytes"), 3 * 2304)
XCTAssertEqual(try number(allocated, "capacity_bytes"), try number(allocated, "used_bytes") + number(allocated, "free_bytes"))
let beforeCollision = try Data(contentsOf: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: "PROBE.BIN", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), beforeCollision)
let tokenized = Data([0xff, 0, 0, 0x87, 0, 10, 0x87, 0x20, 0x34, 0x32, 0, 0, 0])
try VCCDiskImageEditorBackend.importData(tokenized, named: "PROBE.BIN", directory: "", imageURL: url, fileType: 0, ascii: false, replace: true)
try VCCDiskImageEditorBackend.renameEntry("PROBE.BIN", to: "TOKEN.BAS", imageURL: url)
let basic = try XCTUnwrap(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).first { $0["name"] as? String == "TOKEN.BAS" })
XCTAssertEqual(basic["type"] as? String, "BASIC program")
XCTAssertEqual(basic["encoding"] as? String, "Binary", "The extension must not turn tokenized BASIC into ASCII metadata")
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("TOKEN.BAS", imageURL: url), tokenized)
try VCCDiskImageEditorBackend.deleteEntry("TOKEN.BAS", directory: false, imageURL: url)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "used_bytes"), 2304)
// The editor's full-image Undo restores allocation metadata as well as files.
try original.write(to: url, options: .atomic)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), 67 * 2304)
}
func testOS9NestedFolderRoundTripAccountingAndEmptyFolderDeletion() throws {
let (url, original) = try fixture("OS9")
let initial = try VCCDiskImageEditorBackend.inspectImage(at: url)
XCTAssertEqual(initial["format"] as? String, "os9")
XCTAssertEqual(try number(initial, "capacity_bytes"), 630 * 256)
XCTAssertEqual(try number(initial, "used_bytes"), 6 * 256)
XCTAssertEqual(try number(initial, "protected_suffix_bytes"), 0)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
let row = try XCTUnwrap(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).first)
XCTAssertEqual(row["name"] as? String, "README.TXT")
XCTAssertEqual(row["owner"] as? Int, 0)
XCTAssertNotNil(row["modified"] as? NSNumber)
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
let payload = Data("Ordinary OS-9 text\r".utf8)
try VCCDiskImageEditorBackend.importData(payload, named: "NOTE", directory: "DOCS", imageURL: url, fileType: 3, ascii: true, replace: false)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/NOTE", imageURL: url), payload)
XCTAssertGreaterThan(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "used_bytes"), 6 * 256)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.deleteEntry("DOCS", directory: true, imageURL: url), "Nonempty folder deletion requires explicit content removal")
try VCCDiskImageEditorBackend.renameEntry("DOCS/NOTE", to: "RENAMED", imageURL: url)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/RENAMED", imageURL: url), payload)
try VCCDiskImageEditorBackend.deleteEntry("DOCS/RENAMED", directory: false, imageURL: url)
try VCCDiskImageEditorBackend.deleteEntry("DOCS", directory: true, imageURL: url)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "used_bytes"), 6 * 256)
try original.write(to: url, options: .atomic)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), 624 * 256)
}
func testPrivateWorkingCopyEditsAndFailuresNeverModifySourceFixture() throws {
for format in ["DECB", "OS9"] {
let (url, original) = try fixture(format)
let retained = folder.appendingPathComponent(format + "-original.dsk")
try original.write(to: retained)
try VCCDiskImageEditorBackend.importData(Data("test".utf8), named: "NEW.TXT", directory: "", imageURL: url, fileType: 3, ascii: true, replace: false)
XCTAssertEqual(try Data(contentsOf: retained), original)
let before = try Data(contentsOf: url)
for bad in ["../escape", "A/B", "BAD,NAME", "BAD:NAME", "BAD\\NAME", ".", "..", "bad\nname"] {
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: bad, directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), before)
}
XCTAssertThrowsError(try VCCDiskImageEditorBackend.readFile("../README.TXT", imageURL: url))
XCTAssertEqual(try Data(contentsOf: retained), original)
}
}
func testMalformedFATAndOS9DirectoryCyclesFailBeforeRetainedCLoops() throws {
let (decb, d) = try fixture("DECB")
var bytes = d; bytes[(17 * 18 + 1) * 256] = 0
try bytes.write(to: decb)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: decb))
XCTAssertThrowsError(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: decb))
let (os9, o) = try fixture("OS9")
bytes = o
let entry = 3 * 256 + 64
bytes.replaceSubrange(entry..<(entry + 29), with: Data(repeating: 0, count: 29))
bytes.replaceSubrange(entry..<(entry + 4), with: [0x4c, 0x4f, 0x4f, 0xd0])
bytes.replaceSubrange((entry + 29)..<(entry + 32), with: [0, 0, 2])
try bytes.write(to: os9)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: os9))
bytes = o; bytes[2 * 256 + 16] = 0xff
try bytes.write(to: os9)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.listDirectory("", imageURL: os9))
try Data(repeating: 0, count: 256).write(to: os9)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: os9))
}
func testOS9ModuleInformationAndTruncatedModuleRefusal() throws {
let (url, _) = try fixture("OS9")
let module = Data([0x87, 0xcd, 0, 17, 0, 9, 0x40, 0, 0, 0x54, 0x45, 0x53, 0xd4, 1, 0, 0, 0])
try VCCDiskImageEditorBackend.importData(module, named: "MODULE", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false)
let info = try VCCDiskImageEditorBackend.identifyFile("MODULE", imageURL: url)
XCTAssertTrue(info.contains("TEST"))
XCTAssertTrue(info.contains("CRC: Mismatch"), "An authored invalid CRC must not be called good")
try VCCDiskImageEditorBackend.importData(module.prefix(10), named: "SHORT", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.identifyFile("SHORT", imageURL: url))
}
func testDiskFullFailureRestoresWorkingImageAndRejectsUnsafeGeometry() throws {
for format in ["DECB", "OS9"] {
let (url, original) = try fixture(format)
let capacity = try number(VCCDiskImageEditorBackend.inspectImage(at: url), "capacity_bytes")
// It fits the nominal capacity but not the free allocation. The
// retained writer must fail; partially written private bytes undo.
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data(repeating: 0x42, count: capacity), named: "FULL.BIN", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), original)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
}
let (url, original) = try fixture("OS9")
var bytes = original
bytes[7] = 3 // Invalid non-power-of-two allocation clusters.
try bytes.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: url))
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: "TEST", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), bytes)
}
func testDECBSupplementaryTracksRoundTripPreservesOpaqueSuffixAndAccounting() throws {
for extraTracks in [1, 35] {
let (url, base) = try fixture("DECB")
// Authored opaque bytes deliberately contain no application header.
// Support must follow the filesystem extent, not a title signature.
let tail = Data((0..<(extraTracks * 18 * 256)).map { UInt8(truncatingIfNeeded: $0 * 29 + 7) })
let original = base + tail
try original.write(to: url)
let initial = try VCCDiskImageEditorBackend.inspectImage(at: url)
XCTAssertEqual(try number(initial, "byte_count"), original.count)
XCTAssertEqual(try number(initial, "protected_suffix_bytes"), tail.count)
XCTAssertEqual(try number(initial, "capacity_bytes"), 68 * 2304)
XCTAssertEqual(try number(initial, "free_bytes"), 67 * 2304)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
func assertProtected() throws {
let bytes = try Data(contentsOf: url)
XCTAssertEqual(bytes.count, original.count)
XCTAssertEqual(bytes.suffix(tail.count), tail)
}
let payload = Data((0..<5000).map { UInt8(truncatingIfNeeded: $0 * 17) })
try VCCDiskImageEditorBackend.importData(payload, named: "EXTRA.BIN", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false)
try assertProtected()
let imported = try Data(contentsOf: url)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "used_bytes"), 4 * 2304)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("EXTRA.BIN", imageURL: url), payload)
try VCCDiskImageEditorBackend.renameEntry("EXTRA.BIN", to: "RENAMED.BIN", imageURL: url)
try assertProtected()
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("RENAMED.BIN", imageURL: url), payload)
try VCCDiskImageEditorBackend.deleteEntry("RENAMED.BIN", directory: false, imageURL: url)
try assertProtected()
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), 67 * 2304)
// Full-image Undo/Redo must retain both allocation and opaque data.
try imported.write(to: url, options: .atomic)
try assertProtected()
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("EXTRA.BIN", imageURL: url), payload)
try original.write(to: url, options: .atomic)
XCTAssertEqual(try Data(contentsOf: url), original)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), 67 * 2304)
// It cannot consume supplementary tracks even though the full image
// is larger than the Disk BASIC filesystem's nominal capacity.
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data(repeating: 0x42, count: 68 * 2304), named: "FULL.BIN", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), original)
try assertProtected()
}
}
func testDECBSupplementaryTracksRejectMalformedPrefixAndPartialTracks() throws {
let (url, base) = try fixture("DECB")
let original = base + Data(repeating: 0x6d, count: 18 * 256)
let fat = (17 * 18 + 1) * 256
for invalidNext: UInt8 in [0, 68, 0xca, 0xff] {
var bytes = original; bytes[fat] = invalidNext
try bytes.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: url))
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: "TEST", directory: "", imageURL: url, fileType: 3, ascii: true, replace: false))
XCTAssertEqual(try Data(contentsOf: url), bytes)
}
for partialBytes in [1, 256, 18 * 256 - 1] {
let bytes = original + Data(repeating: 0x42, count: partialBytes)
try bytes.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: url))
XCTAssertThrowsError(try VCCDiskImageEditorBackend.deleteEntry("README.TXT", directory: false, imageURL: url))
XCTAssertEqual(try Data(contentsOf: url), bytes)
}
}
func testOS9FileMetadataChangesOnlyAttributesAndTwoByteOwner() throws {
let (url, _) = try fixture("OS9")
let initial = try VCCDiskImageEditorBackend.inspectImage(at: url)
// README.TXT is the authored fixture's descriptor at LSN 4.
let descriptor = 4 * 256
for (index, mask) in ([127, 0] + (0..<7).map { 1 << $0 } + [1, 2, 0]).enumerated() {
let user = index % 2 == 0 ? 255 : 0
let group = index % 2 == 0 ? 0 : 255
let before = try Data(contentsOf: url)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: url, ownerUser: user, ownerGroup: group, permissions: mask)
var expected = before
expected[descriptor] = UInt8(mask)
expected[descriptor + 1] = UInt8(group)
expected[descriptor + 2] = UInt8(user)
XCTAssertEqual(try Data(contentsOf: url), expected, "Contents, bitmap, size, timestamps, segments and link count must remain exact")
let row = try XCTUnwrap(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).first)
XCTAssertEqual(row["permissions"] as? Int, mask)
XCTAssertEqual(row["owner"] as? Int, user)
XCTAssertEqual(row["group"] as? Int, group)
XCTAssertEqual(row["is_directory"] as? Bool, false)
let info = try VCCDiskImageEditorBackend.inspectImage(at: url)
for field in ["capacity_bytes", "used_bytes", "free_bytes"] {
XCTAssertEqual(try number(info, field), try number(initial, field))
}
}
// A file with zero read/write bits remains repairable by its host editor.
try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: url, ownerUser: 255, ownerGroup: 255, permissions: 127)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: url, ownerUser: 0, ownerGroup: 0, permissions: 0x0b)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
}
func testOS9DirectoryMetadataPreservesDirectoryTypeAndEverythingElse() throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
let created = try Data(contentsOf: url)
// The new entry follows ., .. and README.TXT in the authored root data.
let entry = 3 * 256 + 3 * 32
let fd = created[(entry + 29)..<(entry + 32)].reduce(0) { ($0 << 8) | Int($1) }
XCTAssertGreaterThan(fd, 5)
for (user, group, mask) in [(0, 255, 0), (255, 0, 127), (255, 255, 1), (0, 0, 2)] {
let before = try Data(contentsOf: url)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "DOCS", imageURL: url, ownerUser: user, ownerGroup: group, permissions: mask)
var expected = before
expected[fd * 256] = 0x80 | UInt8(mask)
expected[fd * 256 + 1] = UInt8(group)
expected[fd * 256 + 2] = UInt8(user)
XCTAssertEqual(try Data(contentsOf: url), expected)
let row = try XCTUnwrap(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).first { $0["name"] as? String == "DOCS" })
XCTAssertEqual(row["is_directory"] as? Bool, true)
XCTAssertEqual(row["permissions"] as? Int, mask)
XCTAssertEqual(row["owner"] as? Int, user)
XCTAssertEqual(row["group"] as? Int, group)
}
// Even root permissions can be repaired without traversing guest access.
let before = try Data(contentsOf: url)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "", imageURL: url, ownerUser: 255, ownerGroup: 0, permissions: 0)
var expected = before; expected[2 * 256] = 0x80; expected[2 * 256 + 1] = 0; expected[2 * 256 + 2] = 255
XCTAssertEqual(try Data(contentsOf: url), expected)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "", imageURL: url, ownerUser: 0, ownerGroup: 0, permissions: 127)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
}
func testOS9MetadataRejectsInvalidValuesPathsAndDECBWithoutChangingBytes() throws {
let (url, original) = try fixture("OS9")
for (user, group, mask) in [(-1, 0, 0), (256, 0, 0), (0, -1, 0), (0, 256, 0),
(0, 0, -1), (0, 0, 128), (0, 0, 255), (Int.max, 0, 0), (0, Int.min, 0)] {
XCTAssertThrowsError(try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: url, ownerUser: user, ownerGroup: group, permissions: mask))
XCTAssertEqual(try Data(contentsOf: url), original)
}
for path in ["../README.TXT", "MISSING", "/README.TXT"] {
XCTAssertThrowsError(try VCCDiskImageEditorBackend.setOS9Metadata(for: path, imageURL: url, ownerUser: 0, ownerGroup: 0, permissions: 0))
XCTAssertEqual(try Data(contentsOf: url), original)
}
let (decb, d) = try fixture("DECB")
XCTAssertThrowsError(try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: decb, ownerUser: 0, ownerGroup: 0, permissions: 127))
XCTAssertEqual(try Data(contentsOf: decb), d)
}
private func os9Number(_ bytes: Data, _ offset: Int, _ count: Int) -> Int {
bytes[offset..<(offset + count)].reduce(0) { ($0 << 8) | Int($1) }
}
private func os9Put(_ bytes: inout Data, _ offset: Int, _ count: Int, _ value: Int) {
for index in 0..<count { bytes[offset + count - 1 - index] = UInt8(truncatingIfNeeded: value >> (index * 8)) }
}
private func os9Sectors(_ bytes: Data, descriptor: Int) -> [Int] {
(0..<48).flatMap { index -> [Int] in
let segment = descriptor * 256 + 16 + index * 5
let start = os9Number(bytes, segment, 3), count = os9Number(bytes, segment + 3, 2)
return count == 0 ? [] : Array(start..<(start + count))
}
}
private func os9Descriptor(_ bytes: Data, path: String) throws -> Int {
var descriptor = os9Number(bytes, 8, 3)
for name in path.split(separator: "/").map(String.init) {
let size = os9Number(bytes, descriptor * 256 + 9, 4), sectors = os9Sectors(bytes, descriptor: descriptor)
var found: Int?
for logical in stride(from: 0, to: size, by: 32) {
let offset = sectors[logical / 256] * 256 + logical % 256
if bytes[offset] == 0 { continue }
var decoded = ""
for byte in bytes[offset..<(offset + 29)] {
decoded.append(Character(UnicodeScalar(Int(byte & 127))!)); if byte & 128 != 0 { break }
}
if decoded.lowercased() == name.lowercased() { found = os9Number(bytes, offset + 29, 3); break }
}
descriptor = try XCTUnwrap(found, "Missing OS-9 path component: " + name)
}
return descriptor
}
private func assertOS9FileUnchanged(_ before: Data, source: String, _ after: Data, destination: String,
file: StaticString = #filePath, line: UInt = #line) throws {
let originalFD = try os9Descriptor(before, path: source), movedFD = try os9Descriptor(after, path: destination)
XCTAssertEqual(movedFD, originalFD, "A move must retain the FD LSN", file: file, line: line)
XCTAssertEqual(after[(movedFD * 256)..<((movedFD + 1) * 256)], before[(originalFD * 256)..<((originalFD + 1) * 256)],
"Owner, permissions, size, dates, link count and segment list must remain exact", file: file, line: line)
for sector in os9Sectors(before, descriptor: originalFD) {
XCTAssertEqual(after[(sector * 256)..<((sector + 1) * 256)], before[(sector * 256)..<((sector + 1) * 256)],
"File allocation bytes must not be copied, rewritten or freed", file: file, line: line)
}
}
func testOS9BatchMoveRelinksDescriptorsAcrossNestedFolders() throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
try VCCDiskImageEditorBackend.makeDirectory("ARCHIVE", in: "DOCS", imageURL: url)
let second = Data((0..<1600).map { UInt8(truncatingIfNeeded: $0 * 31) })
try VCCDiskImageEditorBackend.importData(second, named: "SECOND.DAT", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: false)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "README.TXT", imageURL: url, ownerUser: 29, ownerGroup: 17, permissions: 0x63)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "DOCS/SECOND.DAT", imageURL: url, ownerUser: 255, ownerGroup: 128, permissions: 0)
let before = try Data(contentsOf: url)
try VCCDiskImageEditorBackend.moveFiles(["readme.txt", "DOCS/SECOND.DAT"], toDirectory: "docs/archive", imageURL: url)
let after = try Data(contentsOf: url)
try assertOS9FileUnchanged(before, source: "README.TXT", after, destination: "DOCS/ARCHIVE/README.TXT")
try assertOS9FileUnchanged(before, source: "DOCS/SECOND.DAT", after, destination: "DOCS/ARCHIVE/SECOND.DAT")
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/ARCHIVE/README.TXT", imageURL: url), content)
XCTAssertFalse(try VCCDiskImageEditorBackend.listDirectory("", imageURL: url).contains { $0["name"] as? String == "README.TXT" })
XCTAssertFalse(try VCCDiskImageEditorBackend.listDirectory("DOCS", imageURL: url).contains { $0["name"] as? String == "SECOND.DAT" })
XCTAssertEqual(Set(try VCCDiskImageEditorBackend.listDirectory("DOCS/ARCHIVE", imageURL: url).compactMap { $0["name"] as? String }), ["README.TXT", "SECOND.DAT"])
// Moving back to the root reuses the empty entry without changing FD/data.
try VCCDiskImageEditorBackend.moveFiles(["DOCS/ARCHIVE/README.TXT"], toDirectory: "", imageURL: url)
try assertOS9FileUnchanged(before, source: "README.TXT", Data(contentsOf: url), destination: "README.TXT")
}
func testOS9MovePreflightRejectsWholeInvalidBatchAndDECB() throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
try VCCDiskImageEditorBackend.makeDirectory("OTHER", in: "", imageURL: url)
try VCCDiskImageEditorBackend.makeDirectory("EMPTY", in: "", imageURL: url)
try VCCDiskImageEditorBackend.importData(Data([1]), named: "readme.txt", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: false)
try VCCDiskImageEditorBackend.importData(Data([2]), named: "README.TXT", directory: "OTHER", imageURL: url, fileType: 2, ascii: false, replace: false)
let before = try Data(contentsOf: url)
for (paths, destination) in [
(["README.TXT"], "DOCS"), (["README.TXT", "readme.txt"], "EMPTY"),
(["README.TXT", "OTHER/README.TXT"], "EMPTY"), (["DOCS"], "EMPTY"), (["README.TXT", "MISSING"], "OTHER"),
(["README.TXT", "DOCS"], "OTHER"), (["README.TXT"], ""),
(["README.TXT"], "README.TXT"), (["README.TXT"], "MISSING"),
(["README.TXT"], "/DOCS"), (["../README.TXT"], "DOCS"), (["."], "DOCS"),
([".."], "DOCS"), ([String](), "DOCS")
] {
XCTAssertThrowsError(try VCCDiskImageEditorBackend.moveFiles(paths, toDirectory: destination, imageURL: url))
XCTAssertEqual(try Data(contentsOf: url), before, "Every rejection must retain the entire original image")
}
var malformed = before
malformed[4 * 256 + 16] = 0xff // README's data segment points past the image.
try malformed.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "OTHER", imageURL: url))
XCTAssertEqual(try Data(contentsOf: url), malformed)
let (decb, bytes) = try fixture("DECB")
XCTAssertThrowsError(try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "", imageURL: decb))
XCTAssertEqual(try Data(contentsOf: decb), bytes)
}
func testOS9MoveDirectoryGrowthAndFullDiskRollback() throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DEST", in: "", imageURL: url)
// Author a destination with exactly one allocated directory sector.
// Extra allocator-reserved sectors may remain allocated, but unreferenced.
var limited = try Data(contentsOf: url)
let fd = try os9Descriptor(limited, path: "DEST"), first = os9Sectors(limited, descriptor: fd)[0]
limited.replaceSubrange((fd * 256 + 16)..<(fd * 256 + 256), with: Data(repeating: 0, count: 240))
os9Put(&limited, fd * 256 + 16, 3, first); os9Put(&limited, fd * 256 + 19, 2, 1)
try limited.write(to: url)
for index in 0..<6 {
try VCCDiskImageEditorBackend.importData(Data([UInt8(index)]), named: "F\(index)", directory: "DEST", imageURL: url, fileType: 2, ascii: false, replace: false)
}
let before = try Data(contentsOf: url)
XCTAssertEqual(os9Sectors(before, descriptor: fd).count, 1)
XCTAssertEqual(os9Number(before, fd * 256 + 9, 4), 256)
var full = before
let mapBytes = os9Number(full, 4, 2)
full.replaceSubrange(256..<(256 + mapBytes), with: Data(repeating: 0xff, count: mapBytes))
try full.write(to: url)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), 0)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "DEST", imageURL: url))
XCTAssertEqual(try Data(contentsOf: url), full)
try before.write(to: url)
let free = try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes")
try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "DEST", imageURL: url)
let after = try Data(contentsOf: url)
XCTAssertEqual(os9Sectors(after, descriptor: fd).count, 2)
XCTAssertEqual(os9Number(after, fd * 256 + 9, 4), 288)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), free - 256)
try assertOS9FileUnchanged(before, source: "README.TXT", after, destination: "DEST/README.TXT")
}
func testOS9MoveStoreUndoRedoRestoresExactImageBytes() async throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DEST", in: "", imageURL: url)
let original = try Data(contentsOf: url)
let store = try DiskImageEditorStore(data: original)
let moved = try await store.change(.moveFiles(["README.TXT"], "DEST"), path: "")
XCTAssertFalse(moved.entries.contains { $0.name == "README.TXT" })
let restored = try await store.restore(original, path: "")
XCTAssertEqual(restored.bytes, original)
let redone = try await store.restore(moved.bytes, path: "DEST")
XCTAssertEqual(redone.bytes, moved.bytes); XCTAssertTrue(redone.entries.contains { $0.name == "README.TXT" })
XCTAssertEqual(try Data(contentsOf: url), original, "The caller's source file is outside the private edit transaction")
}
func testOS9MoveRetainsHardLinkedDescriptorAndLinkCount() throws {
let (url, _) = try fixture("OS9")
try VCCDiskImageEditorBackend.makeDirectory("DEST", in: "", imageURL: url)
var linked = try Data(contentsOf: url)
let root = try os9Descriptor(linked, path: ""), fd = try os9Descriptor(linked, path: "README.TXT")
let sectors = os9Sectors(linked, descriptor: root), oldSize = os9Number(linked, root * 256 + 9, 4)
let entry = sectors[oldSize / 256] * 256 + oldSize % 256
linked.replaceSubrange(entry..<(entry + 32), with: Data(repeating: 0, count: 32))
let name = Array("ALIAS.TXT".utf8)
for (index, byte) in name.enumerated() { linked[entry + index] = index == name.count - 1 ? byte | 128 : byte }
os9Put(&linked, entry + 29, 3, fd); os9Put(&linked, root * 256 + 9, 4, oldSize + 32)
linked[fd * 256 + 8] = 2
try linked.write(to: url)
_ = try VCCDiskImageEditorBackend.inspectImage(at: url)
try VCCDiskImageEditorBackend.moveFiles(["README.TXT", "ALIAS.TXT"], toDirectory: "DEST", imageURL: url)
let moved = try Data(contentsOf: url)
try assertOS9FileUnchanged(linked, source: "README.TXT", moved, destination: "DEST/README.TXT")
try assertOS9FileUnchanged(linked, source: "ALIAS.TXT", moved, destination: "DEST/ALIAS.TXT")
XCTAssertEqual(moved[fd * 256 + 8], 2)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DEST/ALIAS.TXT", imageURL: url), content)
}
private func authoredHardDisk(sectors: Int = 131072, cluster: Int = 4) throws -> Data {
let (_, template) = try fixture("OS9")
var bytes = Data(repeating: 0, count: sectors * 256)
bytes.replaceSubrange(0..<256, with: template.prefix(256))
let mapBytes = ((sectors + cluster - 1) / cluster + 7) / 8, mapSectors = (mapBytes + 255) / 256
let root = ((mapSectors + 1 + cluster - 1) / cluster) * cluster, file = root + cluster
os9Put(&bytes, 0, 3, sectors); os9Put(&bytes, 4, 2, mapBytes); os9Put(&bytes, 6, 2, cluster); os9Put(&bytes, 8, 3, root)
for index in 0...(file / cluster) { bytes[256 + index / 8] |= UInt8(0x80 >> (index % 8)) }
for (destination, source) in [(root, 2), (file, 4)] {
bytes.replaceSubrange((destination * 256)..<((destination + 1) * 256), with: template[(source * 256)..<((source + 1) * 256)])
bytes.replaceSubrange((destination * 256 + 16)..<((destination + 1) * 256), with: Data(repeating: 0, count: 240))
os9Put(&bytes, destination * 256 + 16, 3, destination + 1)
os9Put(&bytes, destination * 256 + 19, 2, cluster - 1)
}
bytes.replaceSubrange(((root + 1) * 256)..<((root + 2) * 256), with: template[(3 * 256)..<(4 * 256)])
for (index, descriptor) in [(0, root), (1, root), (2, file)] {
os9Put(&bytes, (root + 1) * 256 + index * 32 + 29, 3, descriptor)
}
bytes.replaceSubrange(((file + 1) * 256)..<((file + 2) * 256), with: template[(5 * 256)..<(6 * 256)])
return bytes
}
func testOS9HardDiskMultiSectorClustersRoundTripAndRollback() throws {
let url = folder.appendingPathComponent("HardDisk.os9")
let original = try authoredHardDisk(); try original.write(to: url)
let info = try VCCDiskImageEditorBackend.inspectImage(at: url)
XCTAssertEqual(try number(info, "byte_count"), 32 * 1024 * 1024)
XCTAssertEqual(try number(info, "allocation_unit_bytes"), 1024)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
let payload = Data((0..<20000).map { UInt8(truncatingIfNeeded: $0 * 19) })
try VCCDiskImageEditorBackend.importData(payload, named: "PROBE", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: false)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/PROBE", imageURL: url), payload)
try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "DOCS", imageURL: url)
try VCCDiskImageEditorBackend.renameEntry("DOCS/PROBE", to: "RENAMED", imageURL: url)
try VCCDiskImageEditorBackend.setOS9Metadata(for: "DOCS/RENAMED", imageURL: url, ownerUser: 255, ownerGroup: 17, permissions: 0x63)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/RENAMED", imageURL: url), payload)
let beforeReplacement = try Data(contentsOf: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: "RENAMED", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), beforeReplacement)
try VCCDiskImageEditorBackend.importData(Data([1, 2, 3]), named: "RENAMED", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: true)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/RENAMED", imageURL: url), Data([1, 2, 3]))
try VCCDiskImageEditorBackend.deleteEntry("DOCS/RENAMED", directory: false, imageURL: url)
try VCCDiskImageEditorBackend.moveFiles(["DOCS/README.TXT"], toDirectory: "", imageURL: url)
try VCCDiskImageEditorBackend.deleteEntry("DOCS", directory: true, imageURL: url)
XCTAssertEqual(try number(VCCDiskImageEditorBackend.inspectImage(at: url), "free_bytes"), try number(info, "free_bytes"))
let before = try Data(contentsOf: url)
var full = before; let mapBytes = os9Number(full, 4, 2)
full.replaceSubrange(256..<(256 + mapBytes), with: Data(repeating: 255, count: mapBytes)); try full.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.makeDirectory("FULL", in: "", imageURL: url))
XCTAssertEqual(try Data(contentsOf: url), full)
}
func testHardDiskVolumeDiscoverySelectionAndOutsideRegionPreservation() throws {
let (_, os9) = try fixture("OS9"), (_, decb) = try fixture("DECB")
let url = folder.appendingPathComponent("Combined.vhd"), selected = folder.appendingPathComponent("Selected.dsk")
// A foreign middle slot must retain numbering and remain opaque.
let opaque = Data(repeating: 0x5a, count: decb.count), suffix = Data(repeating: 0x37, count: 256)
let original = os9 + decb + opaque + decb + suffix
try original.write(to: url)
let volumes = try VCCDiskImageEditorBackend.discoverVolumes(at: url)
XCTAssertEqual(volumes.count, 3)
XCTAssertEqual(volumes.compactMap { $0["name"] as? String }.suffix(2), ["HDB-DOS disk 0", "HDB-DOS disk 2"])
let id = try XCTUnwrap(volumes.last?["id"] as? String)
try VCCDiskImageEditorBackend.extractVolume(id, imageURL: url, outputURL: selected)
XCTAssertEqual(try Data(contentsOf: selected), decb)
let payload = Data("Selected numbered volume only\r".utf8)
try VCCDiskImageEditorBackend.importData(payload, named: "NEW.TXT", directory: "", imageURL: selected, fileType: 3, ascii: true, replace: false)
try VCCDiskImageEditorBackend.replaceVolume(id, imageURL: url, volumeURL: selected)
let edited = try Data(contentsOf: url), start = os9.count + decb.count * 2
XCTAssertEqual(edited.prefix(start), original.prefix(start)); XCTAssertEqual(edited.suffix(suffix.count), suffix)
XCTAssertEqual(edited.count, original.count)
try VCCDiskImageEditorBackend.extractVolume(id, imageURL: url, outputURL: selected)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("NEW.TXT", imageURL: selected), payload)
let before = edited
XCTAssertThrowsError(try VCCDiskImageEditorBackend.replaceVolume("decb:1:161280", imageURL: url, volumeURL: selected))
XCTAssertEqual(try Data(contentsOf: url), before)
try (decb + suffix).write(to: selected)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.replaceVolume(id, imageURL: url, volumeURL: selected))
XCTAssertEqual(try Data(contentsOf: url), before)
try (decb + decb).write(to: url)
let plain = try VCCDiskImageEditorBackend.discoverVolumes(at: url)
XCTAssertEqual(plain.count, 2); XCTAssertEqual(plain.last?["index"] as? Int, 1)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.extractVolume("os9:0:161280", imageURL: url, outputURL: selected))
}
func testOS9HardDiskClusterBoundariesLinksAndOpaquePartialTail() throws {
let url = folder.appendingPathComponent("Boundaries.os9")
for cluster in [2, 8, 256] {
var bytes = try authoredHardDisk(sectors: 16384 + 3, cluster: cluster)
let root = os9Number(bytes, 8, 3), file = root + cluster
// Give the existing file a second directory entry and retain its FD.
let entry = (root + 1) * 256 + 96
for (index, byte) in Array("ALIAS".utf8).enumerated() { bytes[entry + index] = byte | (index == 4 ? 128 : 0) }
os9Put(&bytes, entry + 29, 3, file); os9Put(&bytes, root * 256 + 9, 4, 128)
bytes[file * 256 + 8] = 2
let tailStart = (16387 / cluster) * cluster * 256
bytes.replaceSubrange(tailStart..<bytes.count, with: Data(repeating: 0x6d, count: bytes.count - tailStart))
try bytes.write(to: url)
try VCCDiskImageEditorBackend.makeDirectory("DOCS", in: "", imageURL: url)
try VCCDiskImageEditorBackend.deleteEntry("ALIAS", directory: false, imageURL: url)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("README.TXT", imageURL: url), content)
let afterLink = try Data(contentsOf: url)
XCTAssertEqual(afterLink[file * 256 + 8], 1)
// Exercise descriptor/data cluster sharing and small-directory growth.
for index in 0..<(cluster * 8 + 1) {
try VCCDiskImageEditorBackend.importData(Data([UInt8(truncatingIfNeeded: index)]), named: "F\(index)", directory: "DOCS", imageURL: url, fileType: 2, ascii: false, replace: false)
if index >= 8 { break }
}
try VCCDiskImageEditorBackend.moveFiles(["README.TXT"], toDirectory: "DOCS", imageURL: url)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("DOCS/README.TXT", imageURL: url), content)
let after = try Data(contentsOf: url)
XCTAssertEqual(after.suffix(bytes.count - tailStart), bytes.suffix(bytes.count - tailStart), "Incomplete final allocation cluster is never consumed")
XCTAssertEqual(after.prefix(256), bytes.prefix(256), "Boot/volume identification sector remains exact")
}
}
func testOptionalInstalledNitrOS9CombinedHardDiskEditsOnlySelectedVolumes() throws {
let source = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent()
.appendingPathComponent("LocalResources/Media/NitrOS-9 L2 V3.3.0.vhd")
guard FileManager.default.fileExists(atPath: source.path) else {
throw XCTSkip("Optional privately supplied NitrOS-9 hard-drive image is absent")
}
let original = try Data(contentsOf: source)
let working = folder.appendingPathComponent("Private combined copy.vhd")
let selected = folder.appendingPathComponent("Private selected.dsk")
try original.write(to: working)
let volumes = try VCCDiskImageEditorBackend.discoverVolumes(at: working)
XCTAssertEqual(volumes.first?["format"] as? String, "os9")
XCTAssertGreaterThan(volumes.count, 1, "The supplied combined image must expose its formatted HDB-DOS volumes")
for format in ["os9", "decb"] {
let volume = try XCTUnwrap(volumes.first { $0["format"] as? String == format })
let identifier = try XCTUnwrap(volume["id"] as? String)
let start = try number(volume, "offset_bytes"), count = try number(volume, "byte_count")
let before = try Data(contentsOf: working)
try VCCDiskImageEditorBackend.extractVolume(identifier, imageURL: working, outputURL: selected)
let payload = Data("VCC Plus optional real hard-drive image check\r".utf8)
try VCCDiskImageEditorBackend.importData(payload, named: "VCCEDIT.TXT", directory: "", imageURL: selected, fileType: 3, ascii: true, replace: false)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("VCCEDIT.TXT", imageURL: selected), payload)
try VCCDiskImageEditorBackend.replaceVolume(identifier, imageURL: working, volumeURL: selected)
let after = try Data(contentsOf: working)
XCTAssertEqual(after.count, original.count)
XCTAssertEqual(after.prefix(start), before.prefix(start))
XCTAssertEqual(after.suffix(after.count - start - count), before.suffix(before.count - start - count))
try VCCDiskImageEditorBackend.extractVolume(identifier, imageURL: working, outputURL: selected)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("VCCEDIT.TXT", imageURL: selected), payload)
}
XCTAssertEqual(try Data(contentsOf: source), original, "Private source is read-only evidence, never the editor's working image")
}
func testOS9DeclaredBootExtentMustBeAllocatedAndWithinVolume() throws {
let url = folder.appendingPathComponent("Boot safety.os9")
let original = try authoredHardDisk(sectors: 16384, cluster: 4)
var bytes = original
os9Put(&bytes, 21, 3, 100); os9Put(&bytes, 24, 2, 600)
try bytes.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: url))
XCTAssertThrowsError(try VCCDiskImageEditorBackend.importData(Data([1]), named: "TEST", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false))
XCTAssertEqual(try Data(contentsOf: url), bytes)
bytes[256 + (100 / 4) / 8] |= UInt8(0x80 >> ((100 / 4) % 8))
try bytes.write(to: url)
_ = try VCCDiskImageEditorBackend.inspectImage(at: url)
let before = bytes
try VCCDiskImageEditorBackend.importData(Data([1]), named: "TEST", directory: "", imageURL: url, fileType: 2, ascii: false, replace: false)
XCTAssertEqual(try Data(contentsOf: url)[(100 * 256)..<(103 * 256)], before[(100 * 256)..<(103 * 256)])
for (start, size) in [(16383, 600), (0, 1), (16384, 0)] {
bytes = original; os9Put(&bytes, 21, 3, start); os9Put(&bytes, 24, 2, size); try bytes.write(to: url)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.inspectImage(at: url))
XCTAssertEqual(try Data(contentsOf: url), bytes)
}
}
func testExternalOS9BootStorageIsProtectedAndPointerRestoredOnMerge() throws {
let (_, os9) = try fixture("OS9"), (_, decb) = try fixture("DECB")
let full = folder.appendingPathComponent("External boot.vhd"), selected = folder.appendingPathComponent("External selected.dsk")
let boot = os9.count / 256 + decb.count / 256 + 10
var original = os9 + decb + decb
os9Put(&original, 21, 3, boot); os9Put(&original, 24, 2, 400)
original.replaceSubrange((boot * 256)..<((boot + 2) * 256), with: Data(repeating: 0x6d, count: 512))
try original.write(to: full)
let volumes = try VCCDiskImageEditorBackend.discoverVolumes(at: full)
XCTAssertEqual(volumes.count, 2, "The otherwise-valid HDB disk containing bootstrap bytes is protected")
XCTAssertEqual(volumes.last?["index"] as? Int, 0)
let id = try XCTUnwrap(volumes.first?["id"] as? String)
try VCCDiskImageEditorBackend.extractVolume(id, imageURL: full, outputURL: selected)
XCTAssertEqual(try Data(contentsOf: selected)[21..<26], Data(repeating: 0, count: 5), "Only the private FS copy omits its out-of-volume reference")
try VCCDiskImageEditorBackend.importData(Data([1, 2]), named: "TEST", directory: "", imageURL: selected, fileType: 2, ascii: false, replace: false)
try VCCDiskImageEditorBackend.replaceVolume(id, imageURL: full, volumeURL: selected)
let merged = try Data(contentsOf: full)
XCTAssertEqual(merged[21..<26], original[21..<26])
XCTAssertEqual(merged.suffix(decb.count * 2), original.suffix(decb.count * 2))
try VCCDiskImageEditorBackend.extractVolume(id, imageURL: full, outputURL: selected)
XCTAssertEqual(try VCCDiskImageEditorBackend.readFile("TEST", imageURL: selected), Data([1, 2]))
for (start, size) in [(original.count / 256, 1), (os9.count / 256 - 1, 600)] {
var bad = original; os9Put(&bad, 21, 3, start); os9Put(&bad, 24, 2, size); try bad.write(to: full)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.discoverVolumes(at: full))
XCTAssertEqual(try Data(contentsOf: full), bad)
}
// Fragmented boot uses an external descriptor, whose data spans must
// also stay outside the OS-9 prefix and within the full container.
var fragmented = original; os9Put(&fragmented, 24, 2, 0)
fragmented.replaceSubrange((boot * 256)..<((boot + 1) * 256), with: Data(repeating: 0, count: 256))
fragmented[boot * 256] = 0x0b; fragmented[boot * 256 + 8] = 1
os9Put(&fragmented, boot * 256 + 9, 4, 256)
os9Put(&fragmented, boot * 256 + 16, 3, boot + 1); os9Put(&fragmented, boot * 256 + 19, 2, 1)
try fragmented.write(to: full)
XCTAssertEqual(try VCCDiskImageEditorBackend.discoverVolumes(at: full).count, 2)
os9Put(&fragmented, boot * 256 + 16, 3, 5); try fragmented.write(to: full)
XCTAssertThrowsError(try VCCDiskImageEditorBackend.discoverVolumes(at: full), "An external bootstrap cannot reference mutable internal filesystem sectors")
}
}