@reekon-tools/react-native-pdf-canvas 0.1.0 → 0.2.0

package/ios/Tests/PdfCanvasCoreTests/FailureTests.swift

@@ -1,262 +0,0 @@
-import Foundation
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- The error codes, and the preflight that makes them distinguishable.
-
- THE POINT IS THE CODE, NOT THE FAILURE. `CGPDFDocumentCreateWithURL` returning
- NULL is one signal for "no such file", "no permission", "zero bytes" and "not a
- PDF", and a host showing "corrupt" for a path that simply does not exist sends
- somebody looking at the wrong thing. Every case below asserts which code came back,
- because the codes are the whole contract across the bridge — `PdfCanvasErrorCodeWire`
- is the TypeScript union member verbatim and there is no translation table in
- between.
- */
-final class FailureTests: XCTestCase {
-
-  private func expectFailure(
-    _ url: URL,
-    password: String? = nil,
-    _ expected: PdfCanvasErrorCode,
-    _ what: String,
-    file: StaticString = #filePath,
-    line: UInt = #line
-  ) {
-    XCTAssertThrowsError(
-      try PdfCanvasRasterizer.open(fileURL: url, password: password, poolSize: 1),
-      what, file: file, line: line
-    ) { error in
-      let ns = error as NSError
-      XCTAssertEqual(
-        PdfCanvasErrorCodeOf(ns), expected,
-        "\(what): got \(PdfCanvasErrorCodeWire(PdfCanvasErrorCodeOf(ns))) — "
-          + ns.localizedDescription,
-        file: file, line: line)
-    }
-  }
-
-  // ---------------------------------------------------------------- //
-  // Not there / not readable / not a PDF
-  // ---------------------------------------------------------------- //
-
-  func testAMissingFileIsNotFound() {
-    let url = URL(fileURLWithPath: NSTemporaryDirectory())
-      .appendingPathComponent("pdfcanvas-does-not-exist-\(UUID().uuidString).pdf")
-    expectFailure(url, .notFound, "a path with nothing at it")
-  }
-
-  func testADirectoryIsNotFound() {
-    expectFailure(
-      URL(fileURLWithPath: NSTemporaryDirectory()), .notFound,
-      "a directory is not a document")
-  }
-
-  /// A non-file URL is `not-found` with a message that says why, rather than a hang.
-  func testARemoteUrlIsNotFound() {
-    expectFailure(
-      URL(string: "https://example.com/a.pdf")!, .notFound,
-      "this backend does no networking")
-  }
-
-  func testAnEmptyFileIsCorrupt() throws {
-    let url = try TestPdfs.write(Data(), name: "empty.pdf")
-    expectFailure(url, .corrupt, "0 bytes")
-  }
-
-  /**
-   A file with no `%PDF-` header in its first 1024 bytes is `corrupt`, and the
-   message says what was looked for.
-
-   The window matters in both directions, so the fixture puts a real header at
-   ~5 KB in: a scan of the whole file would ACCEPT this and hand CoreGraphics
-   something it will refuse with no explanation.
-   */
-  func testAFileWithNoHeaderInTheWindowIsCorrupt() throws {
-    let url = try TestPdfs.write(TestPdfs.notAPdfAtAll(), name: "not-a-pdf.pdf")
-    expectFailure(url, .corrupt, "no header in the first 1024 bytes")
-    XCTAssertThrowsError(
-      try PdfCanvasRasterizer.open(fileURL: url, password: nil, poolSize: 1)
-    ) { error in
-      XCTAssertTrue(
-        (error as NSError).localizedDescription.contains("%PDF-"),
-        "the message should name what was looked for: "
-          + (error as NSError).localizedDescription)
-    }
-  }
-
-  /**
-   Leading junk BEFORE the header is tolerated, because every other reader
-   tolerates it.
-
-   Real files carry it — an HTTP preamble, a shell wrapper — and the spec allows
-   it. A preflight that demanded the header at byte 0 would reject documents that
-   open everywhere else, which is a worse failure than the one it prevents.
-   */
-  func testLeadingJunkBeforeTheHeaderIsTolerated() throws {
-    var data = Data("this is some junk a proxy prepended\n".utf8)
-    data.append(TestPdfs.quadrants(width: 50, height: 50))
-    let url = try TestPdfs.write(data, name: "junk-prefix.pdf")
-    // CoreGraphics is the one that decides whether it can still parse it; the
-    // point here is that PREFLIGHT does not reject it out of hand. Either it opens
-    // or it fails as `corrupt` from CoreGraphics — never with the "no %PDF- header"
-    // message, which is what would mean preflight had refused it.
-    do {
-      let r = try PdfCanvasRasterizer.open(fileURL: url, password: nil, poolSize: 1)
-      XCTAssertEqual(r.pageCount, 1)
-      r.close()
-    } catch {
-      XCTAssertFalse(
-        (error as NSError).localizedDescription.contains("no %PDF- header"),
-        "preflight must not be the one rejecting this")
-    }
-  }
-
-  /**
-   A `%PDF-` header over garbage is `corrupt`, and it does not poison anything.
-
-   THIS IS THE TEST ANDROID CANNOT PASS WITHOUT A GUARD. On API 24 a `PdfRenderer`
-   constructor that throws permanently poisons PDFium for the whole process — one
-   failed open plus a garbage collection and the next successful open segfaults in
-   `CPDF_Document`, which is why `PdfPreflight.java` exists as a correctness
-   mechanism. CoreGraphics returns NULL and carries on, so the second half of this
-   test — a good document opening cleanly afterwards, in the same process — is the
-   evidence that no equivalent guard is needed here.
-   */
-  func testHeaderOnlyGarbageIsCorruptAndPoisonsNothing() throws {
-    let bad = try TestPdfs.write(TestPdfs.headerOnlyGarbage(), name: "garbage.pdf")
-    expectFailure(bad, .corrupt, "a header over garbage")
-
-    // Again, several times, interleaved with good opens — the shape that breaks on
-    // API 24.
-    for i in 0..<5 {
-      expectFailure(bad, .corrupt, "repeat \(i)")
-      let good = try openFixture(
-        TestPdfs.quadrants(width: 40, height: 40), name: "good-after-bad-\(i).pdf")
-      let raster = try renderWholePage(good)
-      assertPixel(raster, 10, 30, .red, "a good document still renders after \(i + 1) failures")
-      good.close()
-    }
-  }
-
-  // ---------------------------------------------------------------- //
-  // Encryption
-  // ---------------------------------------------------------------- //
-
-  /**
-   An encrypted document with no password is `password-required`; with the wrong
-   one, `password-incorrect`; with the right one, it opens and RENDERS.
-
-   The third part is what makes this more than an error-code test: iOS is the only
-   native backend that can actually open an encrypted document.
-   `PdfRendererPool.open` on Android REJECTS any password with `unsupported`,
-   because `android.graphics.pdf.LoadParams` landed at API 35 — so the same file is
-   a hard failure there and a working document here.
-   */
-  func testEncryptedDocuments() throws {
-    let url = try TestPdfs.write(TestPdfs.encrypted(), name: "encrypted-cases.pdf")
-    expectFailure(url, password: nil, .passwordRequired, "no password")
-    expectFailure(url, password: "", .passwordRequired, "an empty password")
-    expectFailure(url, password: "wrong", .passwordIncorrect, "a wrong password")
-
-    let ok = try PdfCanvasRasterizer.open(
-      fileURL: url, password: TestPdfs.userPassword, poolSize: 1)
-    XCTAssertEqual(ok.pageCount, 1)
-    let raster = try renderWholePage(ok, scale: 1)
-    assertPixel(raster, 100, 100, .red, "the decrypted content stream must draw")
-    ok.close()
-  }
-
-  /**
-   And an encrypted document renders through PDFKit too, which unlocks separately.
-
-   The two engines keep separate locks, so the password has to be presented twice —
-   once to `CGPDFDocumentUnlockWithPassword` at open, once to
-   `-[PDFDocument unlockWithPassword:]` on the first `annotations: true` render. A
-   backend that only did the first would fail the SECOND render of a document that
-   had already opened fine, which is about the most confusing shape a bug can have.
-   */
-  func testEncryptedDocumentsRenderThroughPdfKitToo() throws {
-    let url = try TestPdfs.write(TestPdfs.encrypted(), name: "encrypted-pdfkit.pdf")
-    let ok = try PdfCanvasRasterizer.open(
-      fileURL: url, password: TestPdfs.userPassword, poolSize: 1)
-    let raster = try renderWholePage(ok, scale: 1, annotations: true)
-    assertPixel(raster, 100, 100, .red)
-    ok.close()
-  }
-
-  // ---------------------------------------------------------------- //
-  // The wire format
-  // ---------------------------------------------------------------- //
-
-  /**
-   The wire strings are the TypeScript union members, verbatim.
-
-   Restated here rather than derived, which is the point: this list and the one in
-   `src/types.ts` are the contract, and if one is edited without the other a
-   `PdfError` arrives in JS with a code no consumer can switch on. Android has a
-   third copy for the same reason.
-   */
-  func testWireStringsMatchTheTypeScriptUnion() {
-    let expected: [(PdfCanvasErrorCode, String)] = [
-      (.notFound, "not-found"),
-      (.passwordRequired, "password-required"),
-      (.passwordIncorrect, "password-incorrect"),
-      (.corrupt, "corrupt"),
-      (.unsupported, "unsupported"),
-      (.cancelled, "cancelled"),
-      (.outOfMemory, "out-of-memory"),
-      (.backendFailure, "backend-failure"),
-    ]
-    for (code, wire) in expected {
-      XCTAssertEqual(PdfCanvasErrorCodeWire(code), wire)
-    }
-    XCTAssertEqual(expected.count, 8, "the union has eight members")
-  }
-
-  /// A foreign error reads as `backend-failure` rather than as a wrong code.
-  func testAForeignErrorIsBackendFailure() {
-    let foreign = NSError(domain: NSCocoaErrorDomain, code: 4, userInfo: nil)
-    XCTAssertEqual(PdfCanvasErrorCodeOf(foreign), .backendFailure)
-  }
-
-  /// The underlying error is kept, because a `corrupt` verdict needs its cause.
-  func testTheUnderlyingErrorIsKept() {
-    let cause = NSError(domain: "test", code: 7, userInfo: nil)
-    let error = PdfCanvasMakeError(.corrupt, "wrapped", cause) as NSError
-    XCTAssertEqual(error.localizedDescription, "wrapped")
-    XCTAssertEqual(
-      (error.userInfo[NSUnderlyingErrorKey] as? NSError)?.code, 7)
-  }
-
-  // ---------------------------------------------------------------- //
-  // Preflight, directly
-  // ---------------------------------------------------------------- //
-
-  func testPreflightAcceptsARealDocument() throws {
-    let url = try TestPdfs.write(
-      TestPdfs.quadrants(width: 40, height: 40), name: "preflight-ok.pdf")
-    XCTAssertNoThrow(try PdfCanvasPreflight.check(fileURL: url))
-  }
-
-  func testPreflightOnDataChecksTheHeaderWindow() {
-    XCTAssertNoThrow(
-      try PdfCanvasPreflight.check(TestPdfs.quadrants(width: 10, height: 10)))
-    XCTAssertThrowsError(try PdfCanvasPreflight.check(Data())) { error in
-      XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .corrupt)
-    }
-    XCTAssertThrowsError(try PdfCanvasPreflight.check(TestPdfs.notAPdfAtAll())) {
-      error in
-      XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .corrupt)
-    }
-    // A header at the very edge of the window is still found.
-    var edge = Data(repeating: 0x20, count: 1019)
-    edge.append(Data("%PDF-".utf8))
-    XCTAssertNoThrow(try PdfCanvasPreflight.check(edge))
-    // One byte further out is not.
-    var past = Data(repeating: 0x20, count: 1020)
-    past.append(Data("%PDF-".utf8))
-    XCTAssertThrowsError(try PdfCanvasPreflight.check(past))
-  }
-}

package/ios/Tests/PdfCanvasCoreTests/GeometryTests.swift

@@ -1,173 +0,0 @@
-import CoreGraphics
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- Page geometry, which is where a wrong answer is worst.
-
- A `PageGeometry` is what the layout function turns into the document's whole
- coordinate space, so a wrong one is not a missing page — it is every page after it
- in the wrong place. And nothing about it throws: a swapped width and height on a
- rotated page produces a document that lays out cleanly and draws sideways.
- */
-final class GeometryTests: XCTestCase {
-
-  /**
-   Geometry is POST-ROTATION, and this backend computes it rather than inheriting
-   it.
-
-   MEASURED and worth restating, because it is the opposite of Android: on a
-   `/Rotate 90` letter page, `CGPDFPageGetBoxRect(page, kCGPDFCropBox)` returns
-   `(0, 0, 612, 792)` — UNROTATED — and `CGPDFPageGetRotationAngle` returns 90.
-   Android's `PdfRenderer.Page.getWidth()` is already post-rotation and cannot
-   report `/Rotate` at all. So the swap below is arithmetic this library owns.
-   */
-  func testPageGeometryIsPostRotation() throws {
-    for (rotation, expected) in [
-      (0, (612.0, 792.0)), (90, (792.0, 612.0)), (180, (612.0, 792.0)),
-      (270, (792.0, 612.0)),
-    ] {
-      let rasterizer = try openFixture(
-        TestPdfs.rotated(rotation), name: "rotated-\(rotation).pdf")
-      let geometry = try rasterizer.pageGeometry(at: 0)
-      XCTAssertEqual(
-        Double(geometry.widthPoints), expected.0, accuracy: 1e-9,
-        "/Rotate \(rotation) width")
-      XCTAssertEqual(
-        Double(geometry.heightPoints), expected.1, accuracy: 1e-9,
-        "/Rotate \(rotation) height")
-      XCTAssertEqual(
-        geometry.rotationDegrees, rotation, "/Rotate \(rotation) should be reported")
-      rasterizer.close()
-    }
-  }
-
-  /**
-   `/Rotate` is REPORTED, not normalised away — which is what the web PDFium
-   backend does and the opposite of Android.
-
-   Android reports 0 because `PdfRenderer` gives it no way to read the value; that
-   is an inability, not a policy, and `native-bridge.ts` documents the divergence
-   at the field. This test exists so nobody "fixes" iOS to match Android.
-   */
-  func testRotationIsReportedPerPage() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.rotatedPages([0, 90, 180, 270]), name: "rotated-pages.pdf")
-    XCTAssertEqual(rasterizer.pageCount, 4)
-    for (index, rotation) in [0, 90, 180, 270].enumerated() {
-      let geometry = try rasterizer.pageGeometry(at: index)
-      XCTAssertEqual(geometry.rotationDegrees, rotation, "page \(index)")
-      // The fixture's pages are 200x100, so 90/270 must report 100x200.
-      let quarter = rotation == 90 || rotation == 270
-      XCTAssertEqual(Double(geometry.widthPoints), quarter ? 100 : 200, accuracy: 1e-9)
-      XCTAssertEqual(Double(geometry.heightPoints), quarter ? 200 : 100, accuracy: 1e-9)
-    }
-    rasterizer.close()
-  }
-
-  /**
-   Each page reports its OWN size.
-
-   Catches an implementation that probes page 0 and reports its size for every
-   page — which a single-page fixture cannot catch at all, and which would lay a
-   three-page document out as three copies of its first page.
-   */
-  func testEachPageReportsItsOwnSize() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.mixedSizeDocument(), name: "mixed-sizes.pdf")
-    XCTAssertEqual(rasterizer.pageCount, TestPdfs.mixedSizes.count)
-    for (index, size) in TestPdfs.mixedSizes.enumerated() {
-      let geometry = try rasterizer.pageGeometry(at: index)
-      XCTAssertEqual(Double(geometry.widthPoints), Double(size.0), accuracy: 1e-9)
-      XCTAssertEqual(Double(geometry.heightPoints), Double(size.1), accuracy: 1e-9)
-      XCTAssertEqual(geometry.index, index)
-    }
-    rasterizer.close()
-  }
-
-  /**
-   Geometry is precomputed at open, not loaded on demand.
-
-   Asked for AFTER `close()`, when every `CGPDFDocumentRef` is gone: a lazy
-   implementation throws or crashes here. A page is read that was never asked about
-   before the close, so a lazily-cached page 0 cannot pass by accident. This is the
-   `RasterizerHandle` contract — "cheap: must not load a page" — held to.
-   */
-  func testGeometryIsPrecomputedAtOpenNotLoadedOnDemand() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.mixedSizeDocument(), name: "mixed-sizes-closed.pdf")
-    _ = try rasterizer.pageGeometry(at: 0)
-    rasterizer.close()
-    let last = try rasterizer.pageGeometry(at: TestPdfs.mixedSizes.count - 1)
-    XCTAssertEqual(
-      Double(last.widthPoints), Double(TestPdfs.mixedSizes.last!.0), accuracy: 1e-9)
-  }
-
-  /// An out-of-range index is `not-found`, not a crash and not a clamped page.
-  func testOutOfRangePageIsNotFound() throws {
-    let rasterizer = try openFixture(TestPdfs.quadrants(width: 100, height: 100), name: "one-page.pdf")
-    for index in [-1, 1, 99] {
-      XCTAssertThrowsError(try rasterizer.pageGeometry(at: index)) { error in
-        XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .notFound)
-      }
-    }
-    rasterizer.close()
-  }
-
-  /**
-   The crop box is used, and it is INTERSECTED with the media box.
-
-   `CGPDFPageGetBoxRect(kCGPDFCropBox)` already falls back to the media box when
-   there is no crop box, so the fallback is not the interesting half. The
-   intersection is: a file whose crop box overhangs its media box would otherwise
-   report a page larger than the paper, and every rect the layout function derives
-   from it would be wrong by the overhang.
-   */
-  func testCropBoxIsUsedAndIntersectedWithMediaBox() throws {
-    let offset = try openFixture(TestPdfs.offsetCropBox(), name: "offset-crop.pdf")
-    let cropped = try offset.pageGeometry(at: 0)
-    XCTAssertEqual(Double(cropped.widthPoints), 200, accuracy: 1e-9)
-    XCTAssertEqual(Double(cropped.heightPoints), 200, accuracy: 1e-9)
-    XCTAssertEqual(Double(cropped.cropBox.origin.x), 100, accuracy: 1e-9)
-    XCTAssertEqual(Double(cropped.cropBox.origin.y), 150, accuracy: 1e-9)
-    offset.close()
-
-    // MediaBox 0 0 200 200, CropBox 50 50 400 400 -> intersection is 50,50 150x150.
-    let overhang = try openFixture(
-      TestPdfs.cropBoxOverhangingMediaBox(), name: "overhang-crop.pdf")
-    let clamped = try overhang.pageGeometry(at: 0)
-    XCTAssertEqual(
-      Double(clamped.widthPoints), 150, accuracy: 1e-9,
-      "an un-intersected crop box would report 350")
-    XCTAssertEqual(Double(clamped.heightPoints), 150, accuracy: 1e-9)
-    overhang.close()
-  }
-
-  /// The page count comes from the document, and a one-page fixture is one page.
-  func testPageCount() throws {
-    let one = try openFixture(TestPdfs.quadrants(width: 50, height: 50), name: "count-1.pdf")
-    XCTAssertEqual(one.pageCount, 1)
-    one.close()
-
-    let three = try openFixture(
-      TestPdfs.coloredPages(
-        [(1, 0, 0), (0, 1, 0), (0, 0, 1)], width: 60, height: 40),
-      name: "count-3.pdf")
-    XCTAssertEqual(three.pageCount, 3)
-    three.close()
-  }
-
-  /// The pool size actually opened is what is reported, clamped rather than trusted.
-  func testPoolSizeIsClamped() throws {
-    let data = TestPdfs.quadrants(width: 50, height: 50)
-    for (asked, expected) in [(-3, 1), (0, 1), (1, 1), (2, 2), (4, 4), (99, 4)] {
-      let rasterizer = try openFixture(
-        data, name: "pool-\(asked).pdf", poolSize: asked)
-      XCTAssertEqual(
-        rasterizer.poolSize, expected,
-        "asked for \(asked) lanes, kPdfCanvasMaxPoolSize is \(kPdfCanvasMaxPoolSize)")
-      rasterizer.close()
-    }
-  }
-}

package/ios/Tests/PdfCanvasCoreTests/PreviewTests.swift

@@ -1,114 +0,0 @@
-import CoreGraphics
-import Foundation
-import ImageIO
-import UniformTypeIdentifiers
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- Writes what the rasterizer produced to PNG, so a human can look at it.
-
- NOT A GOLDEN-IMAGE TEST, and deliberately not one. Byte-exact reference images churn
- on every OS update — the spec says so where it rejects them for the reference scenes —
- and every property worth asserting is already asserted numerically elsewhere in this
- suite: quadrant placement, tile-vs-whole-page equality at maxDelta 0, rotation corners,
- the two engines' agreement, premultiplied alpha.
-
- What this adds is the thing no numeric assertion covers: somebody can open the files and
- see that a page looks like a page. It exists because the alternative on this toolchain is
- a simulator screenshot, and driving a dev-client simulator needs synthetic taps that need
- an accessibility grant — a worse dependency than a PNG in a temp directory.
-
- The only assertion is that every file was written and is non-trivial in size, because a
- preview test that silently wrote nothing would be worse than no preview test.
- */
-final class PreviewTests: XCTestCase {
-
-  private func outputDirectory() throws -> URL {
-    let dir = URL(fileURLWithPath: NSTemporaryDirectory())
-      .appendingPathComponent("pdfcanvas-previews", isDirectory: true)
-    try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-    return dir
-  }
-
-  /// Raster bytes -> PNG, through the same premultiplied RGBA layout the raster has.
-  private func writePng(
-    _ raster: PdfCanvasRasterPixels, to url: URL
-  ) throws {
-    let bytes = try XCTUnwrap(raster.bytes)
-    let provider = try XCTUnwrap(CGDataProvider(data: bytes as CFData))
-    let image = try XCTUnwrap(
-      CGImage(
-        width: raster.width, height: raster.height, bitsPerComponent: 8,
-        bitsPerPixel: 32, bytesPerRow: raster.rowBytes,
-        space: CGColorSpace(name: CGColorSpace.sRGB)!,
-        bitmapInfo: CGBitmapInfo(
-          rawValue: CGImageAlphaInfo.premultipliedLast.rawValue
-            | CGBitmapInfo.byteOrder32Big.rawValue),
-        provider: provider, decode: nil, shouldInterpolate: false,
-        intent: .defaultIntent))
-    let destination = try XCTUnwrap(
-      CGImageDestinationCreateWithURL(
-        url as CFURL, UTType.png.identifier as CFString, 1, nil))
-    CGImageDestinationAddImage(destination, image, nil)
-    XCTAssertTrue(CGImageDestinationFinalize(destination), "failed to write \(url.path)")
-  }
-
-  func testWritePreviews() throws {
-    let dir = try outputDirectory()
-    var written: [String] = []
-
-    func emit(
-      _ name: String, _ data: Data, page: Int = 0, scale: Double = 1,
-      annotations: Bool = false, background: PdfCanvasBackground = .white,
-      rect: (Double, Double, Double, Double)? = nil
-    ) throws {
-      let rasterizer = try openFixture(data, name: "preview-\(name).pdf")
-      let geometry = try rasterizer.pageGeometry(at: page)
-      let r = rect ?? (0, 0, geometry.widthPoints, geometry.heightPoints)
-      let raster = try rasterizer.render(
-        request(
-          page: page, x: r.0, y: r.1, width: r.2, height: r.3, scale: scale,
-          annotations: annotations, background: background),
-        cancellation: nil, sink: nil)
-      let url = dir.appendingPathComponent("\(name).png")
-      try writePng(raster, to: url)
-      let size = try FileManager.default.attributesOfItem(atPath: url.path)[.size]
-        as? Int ?? 0
-      XCTAssertGreaterThan(size, 200, "\(name).png is suspiciously small")
-      written.append("\(name).png \(raster.width)x\(raster.height) \(size)B")
-      rasterizer.close()
-    }
-
-    // A dense ARCH-D grid, whole page at a plausible fit scale: the base layer.
-    try emit("base-archd", TestPdfs.grid(width: 1728, height: 2592), scale: 0.25)
-    // One tile of the same sheet at a detail scale: the detail layer.
-    try emit(
-      "detail-tile", TestPdfs.grid(width: 1728, height: 2592), scale: 4,
-      rect: (300, 400, 128, 128))
-    // The doc-space contract, where a y-flip or channel swap is obvious.
-    try emit("quadrants", TestPdfs.quadrants(width: 200, height: 100), scale: 2)
-    // All four rotations, drawn upright.
-    for rotation in [0, 90, 180, 270] {
-      try emit("rotate-\(rotation)", TestPdfs.rotated(rotation), scale: 0.25)
-    }
-    // An offset crop box, through both engines.
-    try emit("cropbox-cg", TestPdfs.offsetCropBox(), scale: 1)
-    try emit("cropbox-pdfkit", TestPdfs.offsetCropBox(), scale: 1, annotations: true)
-    // The annotation flag, both ways.
-    try emit("annots-off", TestPdfs.annotatedPage(), scale: 1, annotations: false)
-    try emit("annots-on", TestPdfs.annotatedPage(), scale: 1, annotations: true)
-    // A transparent background, so the alpha is visible rather than inferred.
-    try emit(
-      "transparent", TestPdfs.antialiasedWhiteEdge(), scale: 4,
-      background: .transparent)
-    // A page from a multi-page document, so `request.page` is visibly honoured.
-    try emit(
-      "page-2", TestPdfs.coloredPages([(1, 0, 0), (0, 1, 0), (0, 0, 1)],
-      width: 120, height: 80), page: 2, scale: 1)
-
-    print("PDFCANVAS-PREVIEWS \(dir.path)")
-    for line in written { print("  \(line)") }
-  }
-}