@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.1

package/ios/Tests/PdfCanvasCoreTests/TimingTests.swift

@@ -1,179 +0,0 @@
-import Foundation
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- Numbers, printed rather than asserted.
-
- THESE ARE NOT PASS/FAIL TESTS AND MUST NOT BECOME ONES. Their counterpart is
- `PdfCanvasDeviceTimingTest` on Android, whose own lesson is written into
- `AndroidRasterizerOptions.poolSize`: a synthetic fixture measured two lanes at
- 1.06x-1.25x while a real drawing measured 0.82x, and the synthetic number would
- have shipped the wrong default. So what these produce is a SHAPE, on whatever
- machine ran them, and the numbers that decide anything come from a device with a
- real document on it — `app/dev-pdf-canvas-probe.tsx` in the consuming app.
-
- The one thing they do assert is that nothing failed, because a timing loop that
- silently rendered zero tiles would still print a very fast number.
- */
-final class TimingTests: XCTestCase {
-
-  private func measure(_ label: String, _ body: () -> Void) -> Double {
-    var best = Double.infinity
-    for _ in 0..<5 {
-      let started = Date()
-      body()
-      best = min(best, Date().timeIntervalSince(started) * 1000)
-    }
-    print("PDFCANVAS-TIMING \(label): \(String(format: "%.2f", best)) ms")
-    return best
-  }
-
-  /**
-   Per-tile cost at the sizes the planner actually asks for.
-
-   `maxPieceDimension` is 1024, so 512² and 1024² are the two that matter, and
-   `minEpochIntervalMs` is defined as the measured p95 of one of them.
-   */
-  func testTileCostBySize() throws {
-    let r = try openFixture(
-      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-tiles.pdf")
-    var rendered = 0
-    for side in [256, 512, 1024] {
-      let scale = 4.0
-      _ = measure("tile \(side)px @4x") {
-        if (try? r.render(
-          request(
-            x: 100, y: 100, width: Double(side) / scale, height: Double(side) / scale,
-            scale: scale),
-          cancellation: nil, sink: nil)) != nil
-        {
-          rendered += 1
-        }
-      }
-    }
-    XCTAssertEqual(rendered, 15, "every measured render must have succeeded")
-    r.close()
-  }
-
-  /**
-   A whole ARCH-D base raster at a plausible fit scale.
-
-   The base layer is `fitZoom * pixelRatio * baseQuality` over the whole sheet, so
-   on a DPR-3 phone an ARCH-D page is roughly 1170x1755 — which is what this
-   approximates. It is the single largest raster the package ever asks a backend
-   for, and therefore the one that sets the worst-case first paint.
-   */
-  func testWholePageBaseRasterCost() throws {
-    let r = try openFixture(
-      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-base.pdf")
-    var rendered = 0
-    _ = measure("ARCH-D base @0.677x (1170x1755)") {
-      if (try? r.render(
-        request(width: 1728, height: 2592, scale: 0.677), cancellation: nil,
-        sink: nil)) != nil
-      {
-        rendered += 1
-      }
-    }
-    XCTAssertEqual(rendered, 5)
-    r.close()
-  }
-
-  /**
-   Lane scaling, over the schedule the controller actually runs: N lanes pulling
-   from one shared cursor of plan items.
-
-   ON THIS MACHINE CoreGraphics parallelises — the probe measured 1.53x at two lanes
-   and 2.28x at four on a dense ARCH-D page, which is the OPPOSITE of Android, where
-   AOSP serialises `PdfRenderer` behind a process-wide PDFium lock that convoys and
-   every lane count above one measures worse. That difference is why
-   `IosRasterizerOptions.poolSize` does not cite any Android evidence.
-   *
-   IT IS STILL NOT A REASON TO RAISE THE DEFAULT. This is a Mac with a lot of cores
-   and a fixture whose tiles cost about a millisecond; a phone under thermal
-   pressure with a real drawing is a different measurement, and it is the one that
-   decides. Printed here so the shape is on record and so a device run has something
-   to be compared against.
-   */
-  func testLaneScaling() throws {
-    let data = TestPdfs.grid(width: 1728, height: 2592, pitch: 4)
-    var items: [(Double, Double)] = []
-    for index in 0..<24 {
-      let column = Double(index % 6) * 256.0
-      let row = Double(index / 6) * 256.0
-      items.append((column, row))
-    }
-    var baseline = 0.0
-    for lanes in [1, 2, 4] {
-      let r = try openFixture(
-        data, name: "timing-lanes-\(lanes).pdf", poolSize: lanes)
-      let lock = NSLock()
-      var completed = 0
-      let ms = measure("\(lanes) lane(s), 24x 1024px tiles @4x") {
-        var cursor = 0
-        DispatchQueue.concurrentPerform(iterations: lanes) { _ in
-          while true {
-            lock.lock()
-            let index = cursor
-            cursor += 1
-            lock.unlock()
-            if index >= items.count { return }
-            let (x, y) = items[index]
-            if (try? r.render(
-              request(x: x, y: y, width: 256, height: 256, scale: 4),
-              cancellation: nil, sink: nil)) != nil
-            {
-              lock.lock()
-              completed += 1
-              lock.unlock()
-            }
-          }
-        }
-      }
-      if lanes == 1 { baseline = ms }
-      print(
-        "PDFCANVAS-TIMING \(lanes) lane(s) relative: "
-          + String(format: "%.2fx", baseline / ms))
-      XCTAssertEqual(
-        completed, items.count * 5, "every tile in every repetition must land")
-      r.close()
-    }
-  }
-
-  /**
-   The two engines' relative cost, which is what makes `annotations: true` a
-   deliberate choice rather than a free one.
-
-   PDFKit has to build and keep a `PDFDocument` alongside the `CGPDFDocumentRef`, so
-   the FIRST annotated render in a lane pays for a second parse. That is why the
-   PDFKit document is lazy — every tile the controller asks for passes
-   `annotations: false` and never triggers it.
-   */
-  func testEngineCostComparison() throws {
-    let r = try openFixture(
-      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-engines.pdf")
-    var rendered = 0
-    // Warm both, so neither measurement includes its parse.
-    _ = try? r.render(
-      request(width: 200, height: 200, scale: 1, annotations: false),
-      cancellation: nil, sink: nil)
-    _ = try? r.render(
-      request(width: 200, height: 200, scale: 1, annotations: true),
-      cancellation: nil, sink: nil)
-
-    for annotations in [false, true] {
-      _ = measure("512px @4x annotations=\(annotations)") {
-        if (try? r.render(
-          request(width: 128, height: 128, scale: 4, annotations: annotations),
-          cancellation: nil, sink: nil)) != nil
-        {
-          rendered += 1
-        }
-      }
-    }
-    XCTAssertEqual(rendered, 10)
-    r.close()
-  }
-}

package/ios/Tests/PdfCanvasCoreTests/TransformTests.swift

@@ -1,283 +0,0 @@
-import CoreGraphics
-import XCTest
-
-@testable import PdfCanvasCore
-
-/**
- The three affine transforms, checked by mapping corners — no PDF, no bitmap, no
- CoreGraphics state.
-
- THIS FILE IS DELIBERATELY FIRST. Every failure mode of a transform produces a
- plausible-looking image rather than an error: a rotation applied the wrong way
- round, a crop-box origin left in, a y-flip half a pixel off. Checking them here
- means a rendering failure further down is a rendering failure, and not this.
- */
-final class TransformTests: XCTestCase {
-
-  /// A 200x100 box at the origin, so a swap of width and height is visible.
-  private let box = CGRect(x: 0, y: 0, width: 200, height: 100)
-
-  private func mapped(_ point: CGPoint, _ transform: CGAffineTransform) -> CGPoint {
-    point.applying(transform)
-  }
-
-  private func assertPoint(
-    _ actual: CGPoint, _ expected: CGPoint, _ what: String,
-    file: StaticString = #filePath, line: UInt = #line
-  ) {
-    XCTAssertEqual(
-      Double(actual.x), Double(expected.x), accuracy: 1e-9,
-      "\(what): x", file: file, line: line)
-    XCTAssertEqual(
-      Double(actual.y), Double(expected.y), accuracy: 1e-9,
-      "\(what): y", file: file, line: line)
-  }
-
-  // ---------------------------------------------------------------- //
-  // PDF user space -> doc space
-  // ---------------------------------------------------------------- //
-
-  /**
-   Rotation 0 is a pure y-flip through the box's top edge.
-
-   The PDF's bottom-left corner is doc space's bottom-LEFT, and the PDF's top-left
-   is doc (0, 0). An implementation that forgot the flip entirely would map
-   bottom-left to (0, 0), which is the single most likely mistake here.
-   */
-  func testRotationZeroFlipsYAndNothingElse() {
-    let t = PdfCanvasPdfToDocTransform(box, 0)
-    assertPoint(mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 0, y: 0), "PDF top-left")
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 100), "PDF bottom-left")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 200, y: 0), "PDF top-right")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 0), t), CGPoint(x: 200, y: 100), "PDF bottom-right")
-  }
-
-  /**
-   `/Rotate 90` is a CLOCKWISE quarter turn of the displayed page.
-
-   Turning a sheet of paper clockwise sends its bottom-left corner to the top-left
-   and its bottom-right to the bottom-left. Those two are what distinguish 90 from
-   270; a test that only checked the page's SIZE would pass for either.
-   */
-  func testRotation90TurnsClockwise() {
-    let t = PdfCanvasPdfToDocTransform(box, 90)
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 0), "PDF bottom-left")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 0), t), CGPoint(x: 0, y: 200), "PDF bottom-right")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 100, y: 200), "PDF top-right")
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 100, y: 0), "PDF top-left")
-  }
-
-  func testRotation180TurnsHalfway() {
-    let t = PdfCanvasPdfToDocTransform(box, 180)
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 200, y: 0), "PDF bottom-left")
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 200, y: 100), "PDF top-left")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 0, y: 100), "PDF top-right")
-  }
-
-  func testRotation270TurnsCounterClockwise() {
-    let t = PdfCanvasPdfToDocTransform(box, 270)
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 100, y: 200), "PDF bottom-left")
-    assertPoint(
-      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 0, y: 200), "PDF top-left")
-    assertPoint(
-      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 0, y: 0), "PDF top-right")
-  }
-
-  /**
-   Every rotation is a reflection, not a rotation, in raw coordinates.
-
-   Doc space is y-down and PDF space is y-up, so a determinant of +1 anywhere here
-   would mean the flip had been lost. Cheap, and it catches a whole class of sign
-   errors that the corner checks above could miss if two of them were wrong in
-   compensating ways.
-   */
-  func testEveryRotationHasDeterminantMinusOne() {
-    for rotation in [0, 90, 180, 270] {
-      let t = PdfCanvasPdfToDocTransform(box, rotation)
-      XCTAssertEqual(
-        Double(t.a * t.d - t.b * t.c), -1, accuracy: 1e-9,
-        "rotation \(rotation) should be orientation-reversing")
-    }
-  }
-
-  /**
-   The crop box's own top-left lands at doc (0, 0), whatever its origin is.
-
-   The fixture this mirrors has MediaBox `0 0 400 400` and CropBox
-   `100 150 300 350`. Without the `-minX` / `minY + height` terms the marker at
-   the crop box's top-left would be drawn 100pt right and 50pt down, which on a
-   flat page is invisible.
-   */
-  func testCropBoxOriginIsSubtracted() {
-    let crop = CGRect(x: 100, y: 150, width: 200, height: 200)
-    let t = PdfCanvasPdfToDocTransform(crop, 0)
-    assertPoint(
-      mapped(CGPoint(x: 100, y: 350), t), CGPoint(x: 0, y: 0), "crop top-left")
-    assertPoint(
-      mapped(CGPoint(x: 300, y: 150), t), CGPoint(x: 200, y: 200),
-      "crop bottom-right")
-  }
-
-  /// The same, for a rotated page — where the two corrections interact.
-  func testCropBoxOriginIsSubtractedUnderRotation() {
-    let crop = CGRect(x: 100, y: 150, width: 200, height: 100)
-    // Rotated 90, the page is 100 wide and 200 tall.
-    let t = PdfCanvasPdfToDocTransform(crop, 90)
-    assertPoint(
-      mapped(CGPoint(x: 100, y: 150), t), CGPoint(x: 0, y: 0),
-      "crop bottom-left -> doc top-left")
-    assertPoint(
-      mapped(CGPoint(x: 300, y: 150), t), CGPoint(x: 0, y: 200),
-      "crop bottom-right -> doc bottom-left")
-    assertPoint(
-      mapped(CGPoint(x: 100, y: 250), t), CGPoint(x: 100, y: 0),
-      "crop top-left -> doc top-right")
-  }
-
-  /// A rotation that is not a multiple of 90 is treated as 0 rather than rounded.
-  func testUnusableRotationsFallBackToZero() {
-    let zero = PdfCanvasPdfToDocTransform(box, 0)
-    for rotation in [45, 1, 359, 137] {
-      XCTAssertTrue(
-        PdfCanvasPdfToDocTransform(box, rotation) == zero,
-        "rotation \(rotation) should behave as 0")
-    }
-  }
-
-  /// Negatives and out-of-range multiples normalise rather than falling back.
-  func testRotationsNormalise() {
-    XCTAssertEqual(PdfCanvasNormalizeRotation(-90), 270)
-    XCTAssertEqual(PdfCanvasNormalizeRotation(450), 90)
-    XCTAssertEqual(PdfCanvasNormalizeRotation(-450), 270)
-    XCTAssertEqual(PdfCanvasNormalizeRotation(720), 0)
-    XCTAssertEqual(PdfCanvasNormalizeRotation(45), 0)
-    XCTAssertTrue(
-      PdfCanvasPdfToDocTransform(box, -90) == PdfCanvasPdfToDocTransform(box, 270),
-      "-90 should behave as 270")
-  }
-
-  // ---------------------------------------------------------------- //
-  // Doc space -> raster space
-  // ---------------------------------------------------------------- //
-
-  /**
-   The doc rect's top-left lands at the raster's top-left, and its bottom-right at
-   the bottom-right.
-
-   Stated in CG's own y-up coordinates, because that is what the transform emits:
-   the raster's top-left is (0, H).
-   */
-  func testDocRectMapsOntoTheWholeRaster() {
-    let t = PdfCanvasDocToRasterTransform(37, 23, 4, 164)
-    assertPoint(
-      mapped(CGPoint(x: 37, y: 23), t), CGPoint(x: 0, y: 164), "doc top-left")
-    assertPoint(
-      mapped(CGPoint(x: 37 + 64, y: 23 + 41), t), CGPoint(x: 256, y: 0),
-      "doc bottom-right")
-  }
-
-  /**
-   TWO RASTERS AT THE SAME SCALE AGREE WHERE THEY OVERLAP — the property the cache
-   and the overlapping detail pieces depend on, and the one the rounded
-   `pixelHeight` in the flip looks like it should break.
-   *
-   The two rects below have heights that round in OPPOSITE directions at scale 1
-   (100.4 -> 100, 100.6 -> 101), so a transform that leaked its rounding into
-   content placement would put the same doc point on different rows. The check is
-   in ROWS FROM THE TOP, which is how a raster is indexed and where the `H` term
-   cancels.
-   */
-  func testRastersAtTheSameScaleAgreeWhereTheyOverlap() {
-    let scale = 1.0
-    // Rect A: doc y 0 .. 100.4, 100 rows. Rect B: doc y 50 .. 150.6, 101 rows.
-    let a = PdfCanvasDocToRasterTransform(0, 0, scale, 100)
-    let b = PdfCanvasDocToRasterTransform(0, 50, scale, 101)
-
-    for docY in stride(from: 50.0, through: 100.0, by: 5.0) {
-      let rowFromTopInA = 100 - Double(mapped(CGPoint(x: 0, y: docY), a).y)
-      let rowFromTopInB = 101 - Double(mapped(CGPoint(x: 0, y: docY), b).y)
-      XCTAssertEqual(
-        rowFromTopInA, docY, accuracy: 1e-9,
-        "doc y \(docY) should sit at row \(docY) of A")
-      XCTAssertEqual(
-        rowFromTopInB, docY - 50, accuracy: 1e-9,
-        "doc y \(docY) should sit at row \(docY - 50) of B")
-    }
-  }
-
-  /**
-   Scale is used exactly as requested, never re-derived from the pixel size.
-
-   A doc rect of 512.4 points at scale 4 is 2050 pixels wide (2049.6 rounded), and
-   a re-derived scale would be 2050/512.4 = 4.00078. Over 2050 pixels that is a
-   drift of 1.6 px at the far edge relative to a neighbour drawn at exactly 4 —
-   which is precisely the misregistration the overlap rule cannot absorb.
-   */
-  func testScaleIsNotReDerivedFromThePixelSize() {
-    let scale = 4.0
-    let docWidth = 512.4
-    let r = request(width: docWidth, height: 100, scale: scale)
-    XCTAssertEqual(r.pixelWidth, 2050, "512.4 * 4 = 2049.6, rounds to 2050")
-
-    let t = PdfCanvasDocToRasterTransform(0, 0, scale, r.pixelHeight)
-    // The far edge lands 0.4 px short of the raster's right edge — that is the
-    // half-pixel the comment on `tileMatrix` describes, left showing the fill.
-    XCTAssertEqual(
-      Double(mapped(CGPoint(x: docWidth, y: 0), t).x), 2049.6, accuracy: 1e-9)
-    // A re-derived scale would have landed it at exactly 2050, agreeing with the
-    // raster and disagreeing with every neighbour.
-  }
-
-  // ---------------------------------------------------------------- //
-  // Doc space -> PDFKit's space
-  // ---------------------------------------------------------------- //
-
-  /**
-   PDFKit's transform is a pure flip through the POST-ROTATION page height.
-
-   Nothing else, because PDFKit applies `/Rotate` and the crop-box origin itself —
-   measured, and the asymmetry with `-[PDFPage boundsForBox:]` is the trap this
-   whole function exists to keep out of the rasterizer.
-   */
-  func testPdfKitTransformIsAPureFlip() {
-    let t = PdfCanvasDocToPdfKitTransform(612)
-    assertPoint(mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 612), "doc origin")
-    assertPoint(
-      mapped(CGPoint(x: 792, y: 612), t), CGPoint(x: 792, y: 0),
-      "doc bottom-right")
-    XCTAssertEqual(Double(t.a * t.d - t.b * t.c), -1, accuracy: 1e-9)
-  }
-
-  // ---------------------------------------------------------------- //
-  // Pixel sizing
-  // ---------------------------------------------------------------- //
-
-  /**
-   `round`, at least 1, matching `planner.ts` and `RasterRequest.java`.
-
-   The three have to agree exactly: the planner declares the pixel size in the
-   `RasterPlanItem` the cache is keyed on, so a backend that used `ceil` would
-   return a raster of a different size than the plan promised.
-   */
-  func testPixelExtentsRoundAndFloorAtOne() {
-    XCTAssertEqual(request(width: 100, height: 100, scale: 1).pixelWidth, 100)
-    XCTAssertEqual(request(width: 100.4, height: 1, scale: 1).pixelWidth, 100)
-    XCTAssertEqual(request(width: 100.5, height: 1, scale: 1).pixelWidth, 101)
-    XCTAssertEqual(request(width: 100.6, height: 1, scale: 1).pixelWidth, 101)
-    XCTAssertEqual(request(width: 0.1, height: 0.1, scale: 1).pixelWidth, 1)
-    XCTAssertEqual(request(width: 0.1, height: 0.1, scale: 1).pixelHeight, 1)
-    XCTAssertEqual(request(width: 512.4, height: 1, scale: 4).pixelWidth, 2050)
-    XCTAssertEqual(request(width: 512.5, height: 1, scale: 4).pixelWidth, 2050)
-  }
-}