Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,668 @@
|
||||
// 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")
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user