// 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..> (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..= 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") } }