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

package/ios/Tests/PdfCanvasCoreTests/RasterizerTests.swift

@@ -1,544 +0,0 @@
-import CoreGraphics
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- What the backend actually draws.
-
- Every test here names the bug it catches, because every one of these failure modes
- produces a plausible image rather than an error: a channel swap, a stride shear, a
- y-flip, a page ignored, an annotation drawn twice, a transparent page composited
- as black.
- */
-final class RasterizerTests: XCTestCase {
-
-  // ---------------------------------------------------------------- //
-  // The doc-space contract
-  // ---------------------------------------------------------------- //
-
-  /**
-   The four quadrants land where doc space says, which pins the y-flip, the channel
-   order and the stride at once.
-
-   The fixture is y-UP in PDF space — red bottom-left, green bottom-right, blue
-   top-left, black top-right — so in doc space (y-down, origin top-left) they read
-   blue, black, red, green clockwise from the top-left. Getting that mapping the
-   wrong way round is the single most likely error in the whole backend, and a grey
-   or symmetric fixture could not see it.
-   */
-  func testQuadrantsLandWhereDocSpaceSaysTheyShould() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 200, height: 100), name: "quadrants.pdf")
-    let raster = try renderWholePage(rasterizer, scale: 2)
-    XCTAssertEqual(raster.width, 400)
-    XCTAssertEqual(raster.height, 200)
-
-    assertPixel(raster, 20, 20, .blue, "doc top-left is the PDF's top-left")
-    assertPixel(raster, 380, 20, .black, "doc top-right is the PDF's top-right")
-    assertPixel(raster, 20, 180, .red, "doc bottom-left is the PDF's bottom-left")
-    assertPixel(raster, 380, 180, .green, "doc bottom-right")
-    rasterizer.close()
-  }
-
-  /**
-   A tile is pixel-identical to the same region cropped from a whole-page render.
-
-   THE PROPERTY THE ENTIRE DETAIL LAYER RESTS ON, and the direct counterpart of
-   spike S1 on Android (0/262144 mismatching, maxDelta 1) and S3 on PDFium web
-   (byte-identical). If an off-page-origin transform were even slightly wrong here,
-   every detail piece would be misregistered against the base and against the
-   consumer's strokes — with no error anywhere.
-
-   The tile's origin and size are deliberately not round numbers: (37, 23) 64x41pt
-   at scale 4 lands on 148 and 92 device pixels, so a transform that quietly
-   rounded the offset to a whole pixel would show up.
-   */
-  func testATileIsIdenticalToThatRegionOfAWholePageRender() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.grid(width: 200, height: 100), name: "grid-tile.pdf")
-    let scale = 4.0
-    let whole = try renderWholePage(rasterizer, scale: scale)
-
-    let tile = try rasterizer.render(
-      request(x: 37, y: 23, width: 64, height: 41, scale: scale),
-      cancellation: nil, sink: nil)
-    XCTAssertEqual(tile.width, 256)
-    XCTAssertEqual(tile.height, 164)
-
-    let result = compare(tile, whole, offsetX: Int(37 * scale), offsetY: Int(23 * scale))
-    XCTAssertEqual(
-      result.differing, 0,
-      "\(result.differing)/\(result.total) pixels differ, maxDelta \(result.maxDelta)")
-    XCTAssertEqual(result.maxDelta, 0)
-    rasterizer.close()
-  }
-
-  /**
-   Two tiles requested at the same scale agree over their overlap.
-
-   The property the cache and the overlapping detail pieces depend on, checked
-   through a render rather than through the transform alone — and with heights that
-   round in OPPOSITE directions, which is what would expose a `pixelHeight` leaking
-   into content placement.
-   */
-  func testRastersAtTheSameScaleAgreeWhereTheyOverlap() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.grid(width: 200, height: 200), name: "grid-overlap.pdf")
-    let scale = 4.0
-    // 25.1pt tall -> 100 rows; 25.4pt tall -> 102 rows. Different roundings.
-    let a = try rasterizer.render(
-      request(x: 10, y: 10, width: 50.1, height: 25.1, scale: scale),
-      cancellation: nil, sink: nil)
-    let b = try rasterizer.render(
-      request(x: 10, y: 20, width: 50.1, height: 25.4, scale: scale),
-      cancellation: nil, sink: nil)
-    XCTAssertNotEqual(a.height, b.height, "the fixture must round differently")
-
-    // The overlap is doc y 20..35.1, i.e. rows 40.. of A and rows 0.. of B.
-    let overlapRows = Int((35.1 - 20) * scale) - 1
-    var differing = 0
-    var maxDelta = 0
-    for row in 0..<overlapRows {
-      for x in 0..<a.width {
-        let pa = a.pixel(x, row + Int(10 * scale))
-        let pb = b.pixel(x, row)
-        let d = max(
-          abs(pa.r - pb.r),
-          max(abs(pa.g - pb.g), max(abs(pa.b - pb.b), abs(pa.a - pb.a))))
-        if d != 0 { differing += 1 }
-        maxDelta = max(maxDelta, d)
-      }
-    }
-    XCTAssertEqual(
-      differing, 0,
-      "\(differing) pixels differ over the overlap, maxDelta \(maxDelta)")
-    rasterizer.close()
-  }
-
-  /**
-   Cost is FLAT IN SCALE, so a viewport-sized detail raster is constant in zoom.
-
-   Not a timing assertion with a threshold — those are flaky on shared CI — but a
-   shape assertion: rendering the SAME pixel count at 8x costs no more than about
-   four times what it costs at 1x. The premise being defended is that CoreGraphics
-   clips rather than rasterizing the whole page and discarding most of it; if it did
-   the latter, an 8x tile would cost 64x. The measured figures on an Apple-silicon
-   Mac are 0.49 / 0.39 / 0.43 / 0.39 ms at 1 / 2 / 4 / 8, i.e. flat.
-   */
-  func testCostIsFlatInScale() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.grid(width: 1728, height: 2592), name: "grid-archd.pdf")
-    let side = 256.0
-
-    func best(scale: Double) -> Double {
-      var best = Double.infinity
-      for _ in 0..<5 {
-        let started = Date()
-        _ = try? rasterizer.render(
-          request(
-            x: 100, y: 100, width: side / scale, height: side / scale, scale: scale),
-          cancellation: nil, sink: nil)
-        best = min(best, Date().timeIntervalSince(started))
-      }
-      return best
-    }
-
-    _ = best(scale: 1)  // warm
-    let one = best(scale: 1)
-    let eight = best(scale: 8)
-    XCTAssertLessThan(
-      eight, one * 8 + 0.010,
-      "256px at 8x took \(eight * 1000)ms against \(one * 1000)ms at 1x — if the "
-        + "engine rasterized the whole page and discarded it, this would be ~64x")
-    rasterizer.close()
-  }
-
-  // ---------------------------------------------------------------- //
-  // Backgrounds
-  // ---------------------------------------------------------------- //
-
-  /**
-   The white pre-fill is required, not defensive.
-
-   A `CGBitmapContext` draws into whatever memory it was handed, and both sinks
-   reserve ZEROED memory — which is transparent BLACK. Composited under the app's
-   annotation layers that reads as a black page, and `ingest.ts` cannot repair it
-   because it cannot tell "the PDF painted black here" from "nothing painted here".
-   The fixture's page is 100x100 with a 40x40 marker, so most of it is untouched by
-   the content stream.
-   */
-  func testWhiteBackgroundFillsEverythingTheContentDoesNotPaint() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.page(
-        mediaBox: (0, 0, 100, 100), content: "1 0 0 rg 0 0 40 40 re f\n"),
-      name: "sparse.pdf")
-    let raster = try renderWholePage(rasterizer, scale: 1, background: .white)
-    assertPixel(raster, 90, 10, .white, "unpainted area must be opaque white")
-    assertPixel(raster, 50, 50, .white)
-    assertPixel(raster, 10, 90, .red, "the marker is at the PDF's bottom-left")
-    rasterizer.close()
-  }
-
-  /// And `transparent` leaves the same area with alpha 0 rather than opaque black.
-  func testTransparentBackgroundLeavesUnpaintedAreaClear() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.page(
-        mediaBox: (0, 0, 100, 100), content: "1 0 0 rg 0 0 40 40 re f\n"),
-      name: "sparse-clear.pdf")
-    let raster = try renderWholePage(rasterizer, scale: 1, background: .transparent)
-    assertPixel(raster, 90, 10, .clear, "unpainted area must be fully transparent")
-    assertPixel(raster, 10, 90, .red, "the marker is still opaque")
-    rasterizer.close()
-  }
-
-  /**
-   ALPHA IS PREMULTIPLIED, measured off the bytes.
-
-   The one cell the spec's alpha table had marked NOT MEASURED. A 62%-covered
-   opaque-white edge reads `[158,158,158,158]` premultiplied and
-   `[255,255,255,158]` straight; PDFium and pdf.js both produce the latter, so this
-   is the value that makes `RasterPixels.alpha` a field rather than a constant.
-
-   It is also, on this platform, forced: `CGBitmapContextCreate` refuses
-   `kCGImageAlphaLast` and `kCGImageAlphaFirst` outright — asserted below, so the
-   claim in `PdfCanvasRasterizer.m` is checked rather than quoted.
-   */
-  func testAlphaIsPremultiplied() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.antialiasedWhiteEdge(), name: "aa-edge.pdf")
-    let raster = try renderWholePage(rasterizer, scale: 4, background: .transparent)
-
-    var partials: [PdfCanvasRasterPixels.Pixel] = []
-    for y in 0..<raster.height {
-      for x in 0..<raster.width {
-        let p = raster.pixel(x, y)
-        if p.a > 20 && p.a < 235 { partials.append(p) }
-      }
-    }
-    XCTAssertGreaterThan(
-      partials.count, 50, "the circle's edge should give plenty of partial coverage")
-    for p in partials {
-      XCTAssertEqual(
-        p.r, p.a,
-        "premultiplied means channel == alpha for opaque white; got \(p)")
-      XCTAssertEqual(p.g, p.a, "got \(p)")
-      XCTAssertEqual(p.b, p.a, "got \(p)")
-    }
-    rasterizer.close()
-  }
-
-  /// Straight alpha is not merely unused here — CoreGraphics refuses it.
-  func testCoreGraphicsRefusesStraightAlpha() {
-    let sRGB = CGColorSpace(name: CGColorSpace.sRGB)!
-    var buffer = [UInt8](repeating: 0, count: 16 * 16 * 4)
-    func accepts(_ info: UInt32) -> Bool {
-      buffer.withUnsafeMutableBytes { raw in
-        CGContext(
-          data: raw.baseAddress, width: 16, height: 16, bitsPerComponent: 8,
-          bytesPerRow: 64, space: sRGB, bitmapInfo: info) != nil
-      }
-    }
-    XCTAssertTrue(
-      accepts(
-        CGImageAlphaInfo.premultipliedLast.rawValue
-          | CGBitmapInfo.byteOrder32Big.rawValue),
-      "the configuration this library uses")
-    XCTAssertFalse(
-      accepts(CGImageAlphaInfo.last.rawValue | CGBitmapInfo.byteOrder32Big.rawValue),
-      "straight RGBA is refused, which is why alpha is premultiplied here")
-    XCTAssertFalse(
-      accepts(
-        CGImageAlphaInfo.first.rawValue | CGBitmapInfo.byteOrder32Little.rawValue),
-      "straight BGRA is refused too")
-  }
-
-  // ---------------------------------------------------------------- //
-  // Stride and format
-  // ---------------------------------------------------------------- //
-
-  /**
-   `rowBytes` is tight, and it is REPORTED rather than left to the reader.
-
-   Tight is a fact about this backend, not about CoreGraphics: this library chooses
-   the stride it hands `CGBitmapContextCreate`. What the reader must not do is
-   assume it, because a wrong stride shears rather than fails. Odd and prime widths
-   are included because a padding rule would show up there first.
-   */
-  func testRowBytesIsTightAndReported() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 200, height: 200), name: "stride.pdf")
-    for width in [1, 3, 7, 13, 1023, 1025] {
-      let raster = try rasterizer.render(
-        request(width: Double(width), height: 4, scale: 1),
-        cancellation: nil, sink: nil)
-      XCTAssertEqual(raster.width, width)
-      XCTAssertEqual(
-        raster.rowBytes, width * 4,
-        "width \(width) should be tightly packed")
-      // And the buffer is exactly as long as the stride claims.
-      XCTAssertEqual(raster.bytes?.count, width * 4 * 4)
-    }
-    rasterizer.close()
-  }
-
-  /// The format string is the one `PixelFormat` in `src/types.ts` understands.
-  func testFormatIsRgba8888() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 20, height: 20), name: "format.pdf")
-    let raster = try renderWholePage(rasterizer)
-    XCTAssertEqual(raster.format, "rgba8888")
-    XCTAssertEqual(raster.format, PdfCanvasFormatRGBA8888)
-    rasterizer.close()
-  }
-
-  // ---------------------------------------------------------------- //
-  // Pages
-  // ---------------------------------------------------------------- //
-
-  /**
-   `request.page` is honoured.
-
-   Catches a backend that renders page 0 for every request — which a single-page
-   fixture cannot catch at all, and a multi-page fixture with identical pages
-   catches only by luck. One flat colour per page is the cheapest fixture that can.
-   */
-  func testEachPageRendersItsOwnContent() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.coloredPages(
-        [(1, 0, 0), (0, 1, 0), (0, 0, 1)], width: 40, height: 40),
-      name: "colored.pdf")
-    let expected: [PdfCanvasRasterPixels.Pixel] = [.red, .green, .blue]
-    for page in 0..<3 {
-      let raster = try renderWholePage(rasterizer, page: page)
-      assertPixel(raster, 20, 20, expected[page], "page \(page)")
-    }
-    rasterizer.close()
-  }
-
-  /**
-   A `/Rotate 90` page draws UPRIGHT, with the marker in the right corner.
-
-   Dimensions alone are not enough: an implementation that swapped width and height
-   and drew the content unrotated would report 792x612 too. The fixture puts red at
-   the unrotated top-left, which a clockwise quarter turn sends to the displayed
-   TOP-RIGHT, and blue at the unrotated bottom-left, which goes to the displayed
-   TOP-LEFT. Getting the direction backwards swaps the two.
-   */
-  func testRotatedPagesDrawUpright() throws {
-    // /Rotate 90: red -> displayed top-right, blue -> displayed top-left.
-    let ninety = try openFixture(TestPdfs.rotated(90), name: "draw-90.pdf")
-    let a = try renderWholePage(ninety, scale: 0.25)
-    XCTAssertEqual(a.width, 198)
-    XCTAssertEqual(a.height, 153)
-    assertPixel(a, 6, 6, .blue, "/Rotate 90 puts the unrotated bottom-left top-left")
-    assertPixel(a, 190, 6, .red, "/Rotate 90 puts the unrotated top-left top-right")
-    ninety.close()
-
-    // /Rotate 270 is a quarter turn the other way: red -> bottom-left,
-    // blue -> bottom-right.
-    let twoSeventy = try openFixture(TestPdfs.rotated(270), name: "draw-270.pdf")
-    let b = try renderWholePage(twoSeventy, scale: 0.25)
-    XCTAssertEqual(b.width, 198)
-    XCTAssertEqual(b.height, 153)
-    assertPixel(b, 6, 146, .red, "/Rotate 270 puts the unrotated top-left bottom-left")
-    assertPixel(
-      b, 190, 146, .blue, "/Rotate 270 puts the unrotated bottom-left bottom-right")
-    twoSeventy.close()
-
-    // /Rotate 180 flips both axes: red -> bottom-right, blue -> top-right.
-    let oneEighty = try openFixture(TestPdfs.rotated(180), name: "draw-180.pdf")
-    let c = try renderWholePage(oneEighty, scale: 0.25)
-    XCTAssertEqual(c.width, 153)
-    XCTAssertEqual(c.height, 198)
-    assertPixel(c, 146, 190, .red, "/Rotate 180 puts the unrotated top-left bottom-right")
-    assertPixel(c, 146, 6, .blue)
-    oneEighty.close()
-  }
-
-  /**
-   A crop box offset from the media box puts the crop box's own top-left at doc
-   (0, 0).
-
-   Both engines, because they get there by different routes: the CoreGraphics path
-   subtracts the origin in the transform, and PDFKit normalises it itself. A test
-   that only covered one would leave the other's behaviour a guess.
-   */
-  func testOffsetCropBoxIsHonouredByBothEngines() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.offsetCropBox(), name: "crop-render.pdf")
-    for annotations in [false, true] {
-      let raster = try renderWholePage(rasterizer, scale: 1, annotations: annotations)
-      XCTAssertEqual(raster.width, 200)
-      XCTAssertEqual(raster.height, 200)
-      assertPixel(
-        raster, 10, 10, .red,
-        "crop-local top-left, annotations=\(annotations)")
-      assertPixel(
-        raster, 190, 190, .blue,
-        "crop-local bottom-right, annotations=\(annotations)")
-      assertPixel(
-        raster, 100, 100, PdfCanvasRasterPixels.Pixel(r: 128, g: 128, b: 128, a: 255),
-        tolerance: 2, "the page's own grey, annotations=\(annotations)")
-    }
-    rasterizer.close()
-  }
-
-  // ---------------------------------------------------------------- //
-  // The two engines
-  // ---------------------------------------------------------------- //
-
-  /**
-   ON A PAGE WITH NO ANNOTATIONS THE TWO ENGINES AGREE BYTE-FOR-BYTE.
-
-   This is what makes selecting an engine per render safe: `annotations` changes
-   what is composited and nothing about the geometry. If the two disagreed, a
-   thumbnail and a tile of the same region would be misregistered against each
-   other, and the app would see a seam that only appears where an annotation-bearing
-   raster meets a tile.
-
-   It is also the test that catches PDFKit's `boundsForBox:` trap: flipping by the
-   unrotated height instead of the post-rotation one moves the whole page, so the
-   comparison explodes rather than drifting.
-   */
-  func testBothEnginesAgreeOnAPageWithNoAnnotations() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 200, height: 100), name: "engines-agree.pdf")
-    let viaCG = try renderWholePage(rasterizer, scale: 4, annotations: false)
-    let viaKit = try renderWholePage(rasterizer, scale: 4, annotations: true)
-    XCTAssertEqual(viaCG.width, viaKit.width)
-    XCTAssertEqual(viaCG.height, viaKit.height)
-    let result = compare(viaCG, viaKit)
-    XCTAssertEqual(
-      result.differing, 0,
-      "\(result.differing)/\(result.total) differ, maxDelta \(result.maxDelta)"
-        + "\nCG:\n\(viaCG.map())\nPDFKit:\n\(viaKit.map())")
-    rasterizer.close()
-  }
-
-  /// And they agree on a ROTATED page too, which is where the flip height matters.
-  func testBothEnginesAgreeOnARotatedPage() throws {
-    let rasterizer = try openFixture(TestPdfs.rotated(90), name: "engines-rot.pdf")
-    let viaCG = try renderWholePage(rasterizer, scale: 0.25, annotations: false)
-    let viaKit = try renderWholePage(rasterizer, scale: 0.25, annotations: true)
-    let result = compare(viaCG, viaKit)
-    // Two engines rasterizing the same geometry are allowed to disagree on
-    // antialiased edges; what must not happen is a translation or a rotation. A
-    // handful of edge pixels is fine, a large fraction is not.
-    XCTAssertLessThan(
-      Double(result.differing) / Double(result.total), 0.02,
-      "\(result.differing)/\(result.total) differ, maxDelta \(result.maxDelta)"
-        + "\nCG:\n\(viaCG.map())\nPDFKit:\n\(viaKit.map())")
-    rasterizer.close()
-  }
-
-  /**
-   `annotations` IS HONOURED IN BOTH DIRECTIONS — the one capability iOS has that
-   Android does not.
-
-   The fixture's content stream paints nothing green; the only green in the file is
-   inside an annotation's appearance stream. So green in the raster can only have
-   come from compositing the annotation. `annotations: false` must show none of it,
-   which is what stops an app that draws its own copy of a PDF-embedded annotation
-   from seeing it twice.
-   */
-  func testAnnotationsAreDrawnOnlyWhenAsked() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.annotatedPage(), name: "annotated.pdf")
-
-    let without = try renderWholePage(rasterizer, scale: 1, annotations: false)
-    // The annotation's /Rect is 50 50 150 150 in PDF space, so its centre is doc
-    // (100, 100) on a 200x200 page.
-    assertPixel(
-      without, 100, 100, .white,
-      "CGContextDrawPDFPage must not composite an annotation appearance stream")
-    assertPixel(without, 20, 180, .red, "the content stream's own marker is drawn")
-
-    let with = try renderWholePage(rasterizer, scale: 1, annotations: true)
-    assertPixel(
-      with, 100, 100, .green, "PDFKit must composite the annotation")
-    assertPixel(with, 20, 180, .red, "and still draw the content stream")
-    rasterizer.close()
-  }
-
-  // ---------------------------------------------------------------- //
-  // Refusals
-  // ---------------------------------------------------------------- //
-
-  /// An absurd raster is refused by name rather than by a jetsam kill.
-  func testAnAbsurdRasterIsRefused() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 100, height: 100), name: "huge.pdf")
-    XCTAssertThrowsError(
-      try rasterizer.render(
-        request(width: 100, height: 100, scale: 900), cancellation: nil, sink: nil)
-    ) { error in
-      XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .outOfMemory)
-      XCTAssertTrue(
-        (error as NSError).localizedDescription.contains("Refused"),
-        (error as NSError).localizedDescription)
-    }
-    // 90000 x 90000 is 8.1e9 pixels, well past the 64 Mpx backstop.
-    XCTAssertGreaterThan(90000 * 90000, PdfCanvasRasterizer.maxRasterPixels)
-    rasterizer.close()
-  }
-
-  /// A degenerate request is a named failure, not a 1x1 raster of nothing.
-  func testDegenerateRequestsAreRefused() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 100, height: 100), name: "degenerate.pdf")
-    let bad: [(String, PdfCanvasRasterRequest)] = [
-      ("zero width", request(width: 0, height: 10, scale: 1)),
-      ("zero height", request(width: 10, height: 0, scale: 1)),
-      ("negative width", request(width: -10, height: 10, scale: 1)),
-      ("zero scale", request(width: 10, height: 10, scale: 0)),
-      ("negative scale", request(width: 10, height: 10, scale: -2)),
-      ("infinite scale", request(width: 10, height: 10, scale: .infinity)),
-      ("nan origin", request(x: .nan, width: 10, height: 10, scale: 1)),
-    ]
-    for (what, req) in bad {
-      XCTAssertThrowsError(
-        try rasterizer.render(req, cancellation: nil, sink: nil), what
-      ) { error in
-        XCTAssertEqual(
-          PdfCanvasErrorCodeOf(error as NSError), .backendFailure, what)
-      }
-    }
-    rasterizer.close()
-  }
-
-  /// A render against a closed handle fails rather than crashing.
-  func testRenderingAfterCloseFails() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 100, height: 100), name: "closed.pdf")
-    rasterizer.close()
-    XCTAssertTrue(rasterizer.isClosed)
-    XCTAssertThrowsError(
-      try rasterizer.render(
-        request(width: 100, height: 100, scale: 1), cancellation: nil, sink: nil)
-    ) { error in
-      XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .backendFailure)
-    }
-    // Idempotent.
-    rasterizer.close()
-  }
-
-  /// A page index the document does not have is `not-found`, from `render` too.
-  func testRenderingAMissingPageIsNotFound() throws {
-    let rasterizer = try openFixture(
-      TestPdfs.quadrants(width: 100, height: 100), name: "missing-page.pdf")
-    XCTAssertThrowsError(
-      try rasterizer.render(
-        request(page: 7, width: 100, height: 100, scale: 1),
-        cancellation: nil, sink: nil)
-    ) { error in
-      XCTAssertEqual(PdfCanvasErrorCodeOf(error as NSError), .notFound)
-    }
-    rasterizer.close()
-  }
-
-  /// `rotationSupport` is the constant the wire format expects.
-  func testRotationSupportIsSupported() {
-    XCTAssertEqual(PdfCanvasRasterizer.rotationSupport, "supported")
-  }
-}