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,295 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import CryptoKit
|
||||
import Foundation
|
||||
import PDFKit
|
||||
import SQLite3
|
||||
import XCTest
|
||||
|
||||
@MainActor
|
||||
final class ArchiveReaderTests: XCTestCase {
|
||||
private var directory: URL!
|
||||
private var cache: ArchiveAssetCache!
|
||||
|
||||
override func setUpWithError() throws {
|
||||
directory = FileManager.default.temporaryDirectory.appendingPathComponent("ArchiveReader-" + UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false)
|
||||
let config = URLSessionConfiguration.ephemeral
|
||||
config.protocolClasses = [ArchiveFixtureTransport.self]
|
||||
cache = ArchiveAssetCache(directory: directory, configuration: config)
|
||||
}
|
||||
|
||||
override func tearDownWithError() throws {
|
||||
try FileManager.default.removeItem(at: directory)
|
||||
}
|
||||
|
||||
private func record(_ name: String, format: String, bytes: Data, member: String? = nil, range: ArchiveMemberRange? = nil) -> ArchiveDocument {
|
||||
let digest = SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
|
||||
return ArchiveDocument(id: digest, title: name, collection: "Books",
|
||||
sourceURL: URL(string: "https://colorcomputerarchive.com/repo/Documents/Books/" + name)!,
|
||||
memberPath: member, pageCount: 1, deliveryURL: nil, deliveryBytes: nil,
|
||||
format: format, sourceBytes: Int64(bytes.count), memberRange: range)
|
||||
}
|
||||
|
||||
private func waitFor(_ condition: () -> Bool) async throws {
|
||||
let limit = ContinuousClock.now + .seconds(5)
|
||||
while !condition() {
|
||||
guard ContinuousClock.now < limit else { throw ReaderTimeout() }
|
||||
try await Task.sleep(for: .milliseconds(10))
|
||||
}
|
||||
}
|
||||
|
||||
private struct ReaderTimeout: Error {}
|
||||
|
||||
func testSelectingPDFPagesReusesTheVerifiedDocumentAndOpensTheCitedPage() async throws {
|
||||
let pdf = PDFDocument()
|
||||
for color in [NSColor.white, .gray] {
|
||||
let image = NSImage(size: NSSize(width: 240, height: 320), flipped: false) { rect in
|
||||
color.setFill()
|
||||
rect.fill()
|
||||
return true
|
||||
}
|
||||
pdf.insert(try XCTUnwrap(PDFPage(image: image)), at: pdf.pageCount)
|
||||
}
|
||||
let bytes = try XCTUnwrap(pdf.dataRepresentation())
|
||||
let digest = SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
|
||||
let source = URL(string: "https://colorcomputerarchive.com/repo/Documents/Books/Pages.pdf")!
|
||||
let delivery = URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Documents/Books/Pages.pdf")!
|
||||
let item = ArchiveDocument(id: digest, title: "Pages", collection: "Books", sourceURL: source,
|
||||
memberPath: nil, pageCount: 2, deliveryURL: delivery, deliveryBytes: Int64(bytes.count))
|
||||
try bytes.write(to: directory.appendingPathComponent(digest + ".pdf"))
|
||||
let model = ArchiveReaderModel(remembersPage: false, cache: cache)
|
||||
defer { model.reset() }
|
||||
model.view.frame = NSRect(x: 0, y: 0, width: 300, height: 300)
|
||||
model.open(item, page: 1)
|
||||
model.open(item, page: 2)
|
||||
try await waitFor { model.progress == nil }
|
||||
let rendered = try XCTUnwrap(model.document)
|
||||
XCTAssertTrue(model.view.document === rendered)
|
||||
XCTAssertEqual(rendered.pageCount, 2)
|
||||
XCTAssertEqual(model.page, 2)
|
||||
XCTAssertTrue(model.view.currentPage === rendered.page(at: 1))
|
||||
model.open(item, page: 1)
|
||||
XCTAssertTrue(model.document === rendered)
|
||||
XCTAssertNil(model.progress)
|
||||
XCTAssertEqual(model.page, 1)
|
||||
XCTAssertTrue(model.view.currentPage === rendered.page(at: 0))
|
||||
}
|
||||
|
||||
func testSelectingTextThenCachedImageReplacesThePreview() async throws {
|
||||
let model = ArchiveReaderModel(remembersPage: false, cache: cache)
|
||||
defer { model.reset() }
|
||||
let text = record("Notes.txt", format: "text", bytes: ArchiveFixtureTransport.listing)
|
||||
model.open(text, page: 1)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertNil(model.error)
|
||||
guard case .text(let contents) = model.preview else { return XCTFail("Expected the selected text in the reader") }
|
||||
XCTAssertEqual(contents, "A tide chart for the CoCo.\n")
|
||||
|
||||
// The transport has no image response. A verified retained copy must open offline.
|
||||
let png = Data(base64Encoded: "iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAAAAAC4HznGAAAAEElEQVR4nGNQcEhgaFhzBAAH5AKxE0HCuwAAAABJRU5ErkJggg==")!
|
||||
let image = record("Map.png", format: "image", bytes: png)
|
||||
try png.write(to: directory.appendingPathComponent(image.id + ".png"))
|
||||
model.open(image, page: 1)
|
||||
XCTAssertNil(model.preview, "Selection changes must clear the previous document immediately")
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertNil(model.error)
|
||||
guard case .image(let displayed) = model.preview else { return XCTFail("The cached image was not rendered") }
|
||||
XCTAssertEqual(displayed.width, 3)
|
||||
XCTAssertEqual(displayed.height, 2)
|
||||
XCTAssertEqual(model.referenceID, image.id)
|
||||
XCTAssertNil(model.document)
|
||||
model.open(image, page: 2)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertNil(model.preview, "A missing image frame must not be silently replaced by frame one")
|
||||
XCTAssertNotNil(model.error)
|
||||
|
||||
model.reset()
|
||||
XCTAssertNil(model.preview)
|
||||
XCTAssertNil(model.referenceID)
|
||||
}
|
||||
|
||||
func testTextReaderPreservesLegacyEncodingsAndRemovesFloppyPadding() throws {
|
||||
let url = directory.appendingPathComponent("Letter.txt")
|
||||
let accented = "Café\n£5"
|
||||
let utf8 = Data([0xef, 0xbb, 0xbf]) + Data("Café\r£5".utf8)
|
||||
let utf16 = Data([0xff, 0xfe]) + (try XCTUnwrap("Café\r£5".data(using: .utf16LittleEndian)))
|
||||
let legacy = Data([0x43, 0x61, 0x66, 0xe9, 0x0d, 0x0a, 0xa3, 0x35, 0x1a, 0x00])
|
||||
for bytes in [utf8, utf16, legacy] {
|
||||
try bytes.write(to: url)
|
||||
guard case .text(let contents) = try ArchiveInlineContent.loadText(at: url) else {
|
||||
return XCTFail("Expected a selectable text preview")
|
||||
}
|
||||
XCTAssertEqual(contents, accented)
|
||||
}
|
||||
try Data([0x93, 0x52, 0x55, 0x4e, 0x94]).write(to: url)
|
||||
guard case .text(let instruction) = try ArchiveInlineContent.loadText(at: url) else {
|
||||
return XCTFail("Expected Windows-1252 walkthrough text")
|
||||
}
|
||||
XCTAssertEqual(instruction, "“RUN”")
|
||||
}
|
||||
|
||||
func testRapidSelectionCancelsAnUnfinishedTransfer() async throws {
|
||||
let first = record("Hold.txt", format: "text", bytes: Data("Slow response".utf8))
|
||||
let next = record("Notes.txt", format: "text", bytes: ArchiveFixtureTransport.listing)
|
||||
let model = ArchiveReaderModel(remembersPage: false, cache: cache)
|
||||
defer { model.reset() }
|
||||
model.open(first, page: 1)
|
||||
try await waitFor {
|
||||
if case .downloading = model.progress { return true }
|
||||
return false
|
||||
}
|
||||
model.open(next, page: 1)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertEqual(model.referenceID, next.id)
|
||||
XCTAssertNil(model.error)
|
||||
guard case .text(let contents) = model.preview else { return XCTFail("The next selection did not load") }
|
||||
XCTAssertEqual(contents, "A tide chart for the CoCo.\n")
|
||||
XCTAssertFalse(FileManager.default.fileExists(atPath: directory.appendingPathComponent(first.id + ".txt").path))
|
||||
}
|
||||
|
||||
func testDownloadReportsBytesWhileTheRemainingContentIsStillPending() async throws {
|
||||
let chunk = ArchiveFixtureTransport.listingChunk
|
||||
let bytes = chunk + chunk
|
||||
let item = record("Progress.txt", format: "text", bytes: bytes)
|
||||
let receipt = try XCTUnwrap(ArchiveAssetReceipt(document: item))
|
||||
let total = Int64(bytes.count)
|
||||
let advanced = XCTestExpectation(description: "Download reports a positive, incomplete byte count")
|
||||
let complete = XCTestExpectation(description: "Download reports all expected bytes")
|
||||
let download = Task {
|
||||
try await cache.localCopy(receipt) { event in
|
||||
guard case let .downloading(done, expected) = event, expected == total else { return }
|
||||
if done > 0, done < total { advanced.fulfill() }
|
||||
if done == total { complete.fulfill() }
|
||||
}
|
||||
}
|
||||
defer { download.cancel() }
|
||||
let first = await XCTWaiter.fulfillment(of: [advanced], timeout: 5)
|
||||
XCTAssertEqual(first, .completed, "The download must advance while the second chunk is withheld")
|
||||
NotificationCenter.default.post(name: ArchiveFixtureTransport.releaseSecondChunk, object: nil)
|
||||
guard first == .completed else { return }
|
||||
let local = try await download.value
|
||||
XCTAssertEqual(try Data(contentsOf: local), bytes)
|
||||
await fulfillment(of: [complete], timeout: 2)
|
||||
}
|
||||
|
||||
func testWorksheetCitationOpensTheSelectedSheetAndChangesSheetsInPlace() async throws {
|
||||
let url = directory.appendingPathComponent("ArchiveLibrary.sqlite")
|
||||
var db: OpaquePointer?
|
||||
XCTAssertEqual(sqlite3_open(url.path, &db), SQLITE_OK)
|
||||
defer { sqlite3_close(db) }
|
||||
let digest = String(repeating: "a", count: 64)
|
||||
let sql = """
|
||||
PRAGMA application_id=0x56434341;
|
||||
PRAGMA user_version=2;
|
||||
CREATE TABLE document(id INTEGER PRIMARY KEY,sha256 TEXT,title TEXT,collection TEXT,format TEXT,source_url TEXT,page_count INTEGER);
|
||||
CREATE TABLE page(id INTEGER PRIMARY KEY,document_id INTEGER,page_number INTEGER,page_label TEXT,locator_kind TEXT,is_ocr INTEGER);
|
||||
CREATE TABLE reader_section(page_id INTEGER PRIMARY KEY,text TEXT);
|
||||
INSERT INTO document VALUES(1,'\(digest)','Ledger','Books','office-xls','https://colorcomputerarchive.com/repo/Documents/Books/Ledger.xls',2);
|
||||
INSERT INTO page VALUES(1,1,1,'January','worksheet',0),(2,1,2,'February','worksheet',0);
|
||||
INSERT INTO reader_section VALUES(1,'Parts' || char(9) || '3'),(2,'Disks' || char(9) || '8');
|
||||
"""
|
||||
guard sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK else {
|
||||
return XCTFail(String(cString: sqlite3_errmsg(db)))
|
||||
}
|
||||
let catalog = ArchiveLibraryCatalog(url: url)
|
||||
let citation = try await catalog.citation(id: "sha256:" + digest + ":worksheet:2")
|
||||
let hit = try XCTUnwrap(citation)
|
||||
XCTAssertNil(hit.page)
|
||||
XCTAssertEqual(hit.locator, "February")
|
||||
let model = ArchiveReaderModel(remembersPage: false, cache: cache, catalog: catalog)
|
||||
defer { model.reset() }
|
||||
model.open(hit.document, page: hit.locationNumber)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertEqual(model.page, 2)
|
||||
XCTAssertEqual(model.sectionLabel, "February")
|
||||
guard case .worksheet(let february) = model.preview else { return XCTFail("Expected the cited worksheet") }
|
||||
XCTAssertEqual(february, "Disks\t8")
|
||||
model.open(hit.document, page: 1)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertEqual(model.page, 1)
|
||||
XCTAssertEqual(model.sectionLabel, "January")
|
||||
guard case .worksheet(let january) = model.preview else { return XCTFail("Expected the first worksheet") }
|
||||
XCTAssertEqual(january, "Parts\t3")
|
||||
model.open(hit.document, page: 3)
|
||||
try await waitFor { model.progress == nil }
|
||||
XCTAssertNil(model.preview)
|
||||
XCTAssertNotNil(model.error)
|
||||
}
|
||||
|
||||
func testZIPRangeAndWholeArchiveFallbackProduceTheVerifiedMember() async throws {
|
||||
// The fixture archive has one raw-DEFLATE member, Tips/notes.txt, beginning at byte 44.
|
||||
for name in ["Range.zip", "Whole.zip", "Shifted.zip", "Changed.zip"] {
|
||||
let asset = record(name, format: "text", bytes: ArchiveFixtureTransport.listing, member: "Tips/notes.txt",
|
||||
range: .init(offset: 44, compressedBytes: 30, method: 8, archiveBytes: 156))
|
||||
let receipt = try XCTUnwrap(ArchiveAssetReceipt(document: asset))
|
||||
if name == "Shifted.zip" || name == "Changed.zip" {
|
||||
do {
|
||||
_ = try await cache.localCopy(receipt) { _ in }
|
||||
XCTFail("Accepted the incorrect response to " + name)
|
||||
} catch { }
|
||||
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: directory.path).isEmpty)
|
||||
} else {
|
||||
let saved = try await cache.localCopy(receipt) { _ in }
|
||||
XCTAssertEqual(try Data(contentsOf: saved), ArchiveFixtureTransport.listing)
|
||||
try FileManager.default.removeItem(at: saved)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private final class ArchiveFixtureTransport: URLProtocol {
|
||||
static let listing = Data("A tide chart for the CoCo.\r\n".utf8)
|
||||
static let listingChunk = Data(repeating: 65, count: 1024 * 1024)
|
||||
static let releaseSecondChunk = Notification.Name("ArchiveReaderTests.releaseSecondChunk")
|
||||
private var releaseObserver: NSObjectProtocol?
|
||||
static let zip = Data(base64Encoded: "UEsDBBQAAAAIAAAAIVyuKpHqHgAAABwAAAAOAAAAVGlwcy9ub3Rlcy50eHRzVCjJTElVSM5ILCpRSMsvUijJSFVwznfO1+PlAgBQSwECFAMUAAAACAAAACFcriqR6h4AAAAcAAAADgAAAAAAAAAAAAAAgAEAAAAAVGlwcy9ub3Rlcy50eHRQSwUGAAAAAAEAAQA8AAAASgAAAAAA")!
|
||||
|
||||
override class func canInit(with request: URLRequest) -> Bool { true }
|
||||
override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
|
||||
override func startLoading() {
|
||||
guard let url = request.url else { return }
|
||||
var headers: [String: String] = [:]
|
||||
var status = 200
|
||||
var payload = Data()
|
||||
switch url.lastPathComponent {
|
||||
case "Hold.txt": return // Intentionally pending until the user chooses another row.
|
||||
case "Notes.txt": payload = Self.listing
|
||||
case "Progress.txt":
|
||||
let headers = ["Content-Length": String(2 * Self.listingChunk.count)]
|
||||
let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: headers)!
|
||||
releaseObserver = NotificationCenter.default.addObserver(forName: Self.releaseSecondChunk, object: nil, queue: nil) { [weak self] _ in
|
||||
guard let self else { return }
|
||||
self.client?.urlProtocol(self, didLoad: Self.listingChunk)
|
||||
self.client?.urlProtocolDidFinishLoading(self)
|
||||
}
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocol(self, didLoad: Self.listingChunk)
|
||||
return
|
||||
case "Range.zip", "Whole.zip", "Shifted.zip", "Changed.zip":
|
||||
guard request.value(forHTTPHeaderField: "Range") == "bytes=44-73" else {
|
||||
client?.urlProtocol(self, didFailWithError: URLError(.badURL))
|
||||
return
|
||||
}
|
||||
if url.lastPathComponent == "Whole.zip" {
|
||||
payload = Self.zip
|
||||
} else {
|
||||
status = 206
|
||||
payload = Self.zip.subdata(in: 44..<74)
|
||||
headers["Content-Range"] = url.lastPathComponent == "Shifted.zip" ? "bytes 45-74/156" : "bytes 44-73/156"
|
||||
// Valid DEFLATE with an altered first character and the original decoded length.
|
||||
if url.lastPathComponent == "Changed.zip" { payload[0] ^= 0x10 }
|
||||
}
|
||||
default:
|
||||
client?.urlProtocol(self, didFailWithError: URLError(.notConnectedToInternet))
|
||||
return
|
||||
}
|
||||
headers["Content-Length"] = String(payload.count)
|
||||
let response = HTTPURLResponse(url: url, statusCode: status, httpVersion: "HTTP/1.1", headerFields: headers)!
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocol(self, didLoad: payload)
|
||||
client?.urlProtocolDidFinishLoading(self)
|
||||
}
|
||||
override func stopLoading() {
|
||||
if let releaseObserver { NotificationCenter.default.removeObserver(releaseObserver) }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user