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

package/android/src/androidTest/java/tools/reekon/pdfcanvas/PdfCanvasRasterizerTest.java

@@ -1,775 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.util.Log;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.platform.app.InstrumentationRegistry;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-
-/**
- * Geometry, registration, background and pixel layout for
- * {@link PdfCanvasRasterizer}.
- *
- * Every test here names the bug it catches. That is not decoration: a rasterizer
- * fails by producing a PLAUSIBLE WRONG IMAGE — sheared, offset, black where it
- * should be white, channels swapped — and none of those throw. A test that only
- * asserts "some bytes came back" passes for all of them.
- */
-@RunWith(AndroidJUnit4.class)
-public class PdfCanvasRasterizerTest {
-
-  private static final String TAG = "PDFCANVAS";
-
-  private static Context ctx() {
-    return InstrumentationRegistry.getInstrumentation().getTargetContext();
-  }
-
-  private static RasterRequest req(
-      int page, float x, float y, float w, float h, float scale, int background) {
-    return new RasterRequest(page, x, y, w, h, scale, false, background);
-  }
-
-  private static RasterRequest white(
-      int page, float x, float y, float w, float h, float scale) {
-    return req(page, x, y, w, h, scale, RasterRequest.BACKGROUND_WHITE);
-  }
-
-  /* ================================================================ *
-   * 1. The S1 property, now against THIS code
-   * ================================================================ */
-
-  /**
-   * A tile must BE the corresponding region of a larger render at the same
-   * scale.
-   *
-   * CATCHES: a sign error in {@code postTranslate} (the tile would show the
-   * mirror-image offset), an x/y transposition (the origin here has x != y and
-   * the region offset inside the reference has dx != dy, so neither can hide),
-   * scale applied to the translate twice, and any inset/rounding of the doc rect
-   * before it reaches the matrix. All four produce a perfectly valid-looking
-   * image, and all four break the overlap registration that the detail rasters
-   * and the cache both depend on.
-   *
-   * Note that BOTH renders here use a non-zero origin. Spike S1 compared a tile
-   * against a full-page render, so its reference had a zero translate and could
-   * not have caught a translate that is wrong only for a moving origin.
-   */
-  @Test
-  public void tileIsPixelIdenticalToTheSameRegionOfALargerRender() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "s1-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      final float scale = 4f;
-      // Reference region and tile, both interior, both with x != y.
-      RasterPixels reference = r.render(white(0, 100f, 300f, 400f, 400f, scale), null);
-      RasterPixels tile = r.render(white(0, 200f, 450f, 128f, 128f, scale), null);
-
-      int dx = Math.round((200f - 100f) * scale);
-      int dy = Math.round((450f - 300f) * scale);
-
-      Diff diff = compareRegion(tile, reference, dx, dy);
-      String summary = "tile 512^2 @" + scale + "x inside " + reference.width + "x"
-          + reference.height + " at (" + dx + "," + dy + ") | " + diff;
-      Log.i(TAG, "S1-property " + summary);
-
-      // Same bar spike S1 used: anti-aliasing on a stroke edge can differ by a
-      // hair, but a wrong ORIGIN or SCALE moves a large share of this
-      // high-frequency pattern and cannot sneak under it.
-      assertTrue(summary, diff.mismatchPercent < 0.5);
-      assertTrue(summary, diff.maxDelta <= 64);
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * Two rasters asked for at the SAME scale must agree pixel-for-pixel wherever
-   * they overlap, even when neither doc rect lands on a whole number of pixels.
-   *
-   * CATCHES: re-deriving the scale from the rounded pixel size
-   * ({@code pixelWidth() / docWidth}) instead of using the requested
-   * {@code scale} verbatim. That change is tempting — it makes each raster cover
-   * its doc rect to the last sub-pixel — and it is invisible to
-   * {@link #tileIsPixelIdenticalToTheSameRegionOfALargerRender}, whose rects are
-   * 400 and 128 points at 4x and therefore land on exact pixel counts, so the
-   * derived scale comes out to exactly 4 for both. {@code tileMatrix}'s comment
-   * used to claim this property "rests on" that test. It did not, and nothing
-   * pinned it until this.
-   *
-   * The rects here are chosen so the rounding goes OPPOSITE ways:
-   * 128.125 x 4 = 512.5, which rounds UP to 513, and 128.1 x 4 = 512.4, which
-   * rounds DOWN to 512. Under exact scale both rasters map pixel i to doc
-   * {@code origin + i/4} and are identical over the 512-pixel overlap. Under a
-   * derived scale one is drawn at 513/128.125 and the other at 512/128.1, and
-   * the two drift apart by close to a full pixel by the far corner — which on
-   * this high-frequency pattern moves a large share of the pixels.
-   *
-   * Both rects share an origin, so the overlap starts at (0, 0) in each and no
-   * offset arithmetic can absorb the error.
-   */
-  @Test
-  public void rastersAtTheSameScaleAgreeWhereTheyOverlap() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "scale-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      final float scale = 4f;
-      final float originX = 100f;
-      final float originY = 200f;
-
-      RasterPixels roundsUp =
-          r.render(white(0, originX, originY, 128.125f, 128.125f, scale), null);
-      RasterPixels roundsDown =
-          r.render(white(0, originX, originY, 128.1f, 128.1f, scale), null);
-
-      // The rounding is the whole point of the fixture, so assert it happened.
-      assertEquals("128.125pt @4x must round UP to 513px", 513, roundsUp.width);
-      assertEquals("128.1pt @4x must round DOWN to 512px", 512, roundsDown.width);
-
-      Diff diff = compareRegion(roundsDown, roundsUp, 0, 0);
-      String summary = "overlap 512^2 inside 513^2 @" + scale + "x | " + diff;
-      Log.i(TAG, "same-scale " + summary);
-
-      assertTrue(summary, diff.mismatchPercent < 0.5);
-      assertTrue(summary, diff.maxDelta <= 64);
-    } finally {
-      r.close();
-    }
-  }
-
-  /* ================================================================ *
-   * 2. Background — S1 finding 3
-   * ================================================================ */
-
-  /**
-   * CATCHES: a missing pre-fill. Spike S1 measured that
-   * {@code PdfRenderer.render} PRESERVES whatever was in the bitmap and never
-   * clears it, so area the page does not cover keeps the allocation's zeros —
-   * transparent black — and composites under the app's annotation layers as a
-   * BLACK page rather than a blank one. This test samples a pixel beyond the
-   * page edge, which the renderer provably never touches, so a white result
-   * there can only have come from the pre-fill.
-   */
-  @Test
-  public void whiteBackgroundFillsAreaThePageDoesNotCover() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "bg-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      // Straddles the page's bottom-right corner: doc x 500..700, y 700..900,
-      // against a 612x792 page.
-      RasterPixels px = r.render(white(0, 500f, 700f, 200f, 200f, 1f), null);
-      assertEquals(200, px.width);
-      assertEquals(200, px.height);
-
-      // (190, 190) is doc (690, 890) — outside the page on both axes.
-      int[] outside = rgba(px, 190, 190);
-      assertEquals("R outside page: " + describe(outside), 255, outside[0]);
-      assertEquals("G outside page: " + describe(outside), 255, outside[1]);
-      assertEquals("B outside page: " + describe(outside), 255, outside[2]);
-      assertEquals("A outside page: " + describe(outside), 255, outside[3]);
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * CATCHES: a backend that ignores {@code background} and always fills white.
-   * That failure is invisible on an opaque page and only shows up when the host
-   * composites the raster over something, at which point the "transparent"
-   * raster hides the layer beneath it.
-   *
-   * Also catches the opposite mistake — a bitmap that was never rendered into at
-   * all — because the in-page sample must be OPAQUE.
-   */
-  @Test
-  public void transparentBackgroundLeavesUncoveredAreaTransparent() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "bg2-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      RasterPixels px =
-          r.render(
-              req(0, 500f, 700f, 200f, 200f, 1f, RasterRequest.BACKGROUND_TRANSPARENT), null);
-
-      int[] outside = rgba(px, 190, 190);
-      assertEquals("alpha outside page: " + describe(outside), 0, outside[3]);
-
-      // (10, 10) is doc (510, 710) — well inside the page, which the pattern
-      // paints opaque white.
-      int[] inside = rgba(px, 10, 10);
-      assertEquals("alpha inside page: " + describe(inside), 255, inside[3]);
-    } finally {
-      r.close();
-    }
-  }
-
-  /* ================================================================ *
-   * 3. Page geometry
-   * ================================================================ */
-
-  /**
-   * CATCHES: probing page 0 and reporting its size for every page — which a
-   * single-size document cannot catch, and which is the natural shape of a
-   * "cache the first geometry" bug.
-   */
-  @Test
-  public void pageGeometryIsPerPage() throws Exception {
-    File pdf = TestPdfs.mixedSizes(ctx(), "mixed.pdf");
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      assertEquals(3, r.pageCount());
-      for (int p = 0; p < 3; p++) {
-        int[] expected = TestPdfs.mixedSizeExpectation(p);
-        PageGeometry g = r.pageGeometry(p);
-        assertEquals("page " + p + " width", expected[0], g.widthPoints);
-        assertEquals("page " + p + " height", expected[1], g.heightPoints);
-        assertEquals("page " + p + " index", p, g.index);
-      }
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * Page geometry is post-rotation on EVERY level tested, including the API 24
-   * floor.
-   *
-   * CATCHES: reporting the MediaBox instead of the displayed box. This half is
-   * unconditional — {@code getWidth()} forwards to PDFium's
-   * {@code FPDF_GetPageWidth}, and {@code CPDF_Page::UpdateDimensions} swaps the
-   * media box's axes for /Rotate 90 and 270 on every build measured.
-   */
-  @Test
-  public void rotatedPageGeometryIsPostRotation() throws Exception {
-    File pdf = TestPdfs.rotated90(ctx(), "rotated-geom.pdf");
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      PageGeometry g = r.pageGeometry(0);
-      Log.i(TAG, "rotation geometry " + g);
-      assertEquals("width should be the 792pt long edge", TestPdfs.LETTER_H, g.widthPoints);
-      assertEquals("height should be the 612pt short edge", TestPdfs.LETTER_W, g.heightPoints);
-      assertEquals("residual rotation the caller must apply", 0, g.rotationDegrees);
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * Whether a rotated page is DRAWN upright is a platform capability, and this
-   * asserts the backend's report of it against what the platform actually does.
-   *
-   * The fixture is a 612x792 page with {@code /Rotate 90} and two markers: red
-   * at the unrotated top-left, blue at the unrotated bottom-left. A clockwise
-   * quarter turn — which is what /Rotate means — puts red at the displayed
-   * top-RIGHT and blue at the displayed top-LEFT. An unrotated render leaves red
-   * top-left; a counter-clockwise render puts red bottom-left. All three are
-   * distinguishable here, which a dimensions-only assertion could not do:
-   * swapping width and height while drawing the content unrotated would pass
-   * that, and is exactly what API 24 does.
-   *
-   * CATCHES, on a platform that rotates: any of those three wrong placements.
-   * CATCHES, on a platform that does not: a {@link PdfPlatformQuirks} probe that
-   * lies. The UNSUPPORTED branch asserts the MEASURED broken layout — content
-   * drawn unrotated with the y-flip taken from the post-rotation height, so blue
-   * lands at y = 612 - 100 and red is pushed off the top — rather than merely
-   * skipping. A probe stuck on SUPPORTED fails on API 24 and one stuck on
-   * UNSUPPORTED fails on API 31/33, so neither constant passes this.
-   */
-  @Test
-  public void rotatedPageRendersUprightWhereThePlatformSupportsIt() throws Exception {
-    PdfPlatformQuirks.RotationSupport support =
-        PdfCanvasRasterizer.rotationSupport(ctx().getCacheDir());
-    File pdf = TestPdfs.rotated90(ctx(), "rotated-render.pdf");
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      PageGeometry g = r.pageGeometry(0);
-      RasterPixels px = r.render(white(0, 0f, 0f, g.widthPoints, g.heightPoints, 1f), null);
-      assertEquals(TestPdfs.LETTER_H, px.width);
-      assertEquals(TestPdfs.LETTER_W, px.height);
-
-      int[] topRight = rgba(px, px.width - 40, 40);
-      int[] topLeft = rgba(px, 40, 40);
-      int[] middle = rgba(px, px.width / 2, px.height / 2);
-      Log.i(TAG, "rotation support=" + support + " samples tr=" + describe(topRight)
-          + " tl=" + describe(topLeft) + " mid=" + describe(middle));
-
-      if (support == PdfPlatformQuirks.RotationSupport.SUPPORTED) {
-        assertTrue("top-right should be the red marker: " + describe(topRight), isRed(topRight));
-        assertTrue("top-left should be the blue marker: " + describe(topLeft), isBlue(topLeft));
-        assertTrue("middle should be blank page: " + describe(middle), isWhite(middle));
-      } else {
-        // The measured API 24 layout: content unrotated, y-flip using the
-        // post-rotation height of 612, so blue (PDF y 0..100) lands at
-        // 612-100..612 and red (PDF y 692..792) is translated off the top.
-        assertTrue(
-            "probe says " + support + ", so red must NOT be at the top-right: "
-                + describe(topRight),
-            !isRed(topRight));
-        int[] blue = rgba(px, 40, 560);
-        assertTrue(
-            "probe says " + support + ", so blue must be at the measured broken "
-                + "position (x40, y560): " + describe(blue),
-            isBlue(blue));
-      }
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * CATCHES: a lazy {@code pageGeometry} that opens the page on demand.
-   *
-   * The contract says the call is cheap and must not load a page, and the only
-   * way to observe that from outside is to ask when loading a page is
-   * impossible. After {@code close()} every PdfRenderer is shut; a lazy
-   * implementation would throw or crash here, while a precomputed one returns
-   * the same numbers it did before. Page 2 is read ONLY after close, so an
-   * implementation that lazily cached page 0 during open cannot pass by
-   * accident.
-   */
-  @Test
-  public void pageGeometryIsPrecomputedAtOpenNotLoadedOnDemand() throws Exception {
-    File pdf = TestPdfs.mixedSizes(ctx(), "mixed-lazy.pdf");
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    PageGeometry beforeClose = r.pageGeometry(0);
-    r.close();
-
-    PageGeometry afterClose = r.pageGeometry(0);
-    assertEquals(beforeClose.widthPoints, afterClose.widthPoints);
-    assertEquals(beforeClose.heightPoints, afterClose.heightPoints);
-
-    int[] expected = TestPdfs.mixedSizeExpectation(2);
-    PageGeometry neverAskedBefore = r.pageGeometry(2);
-    assertEquals(expected[0], neverAskedBefore.widthPoints);
-    assertEquals(expected[1], neverAskedBefore.heightPoints);
-    assertEquals(3, r.pageCount());
-  }
-
-  /* ================================================================ *
-   * 4. Pixel layout — byte order and stride
-   * ================================================================ */
-
-  /**
-   * CATCHES: reporting {@code bgra8888}, or emitting ARGB (the order the config
-   * is NAMED for) while claiming RGBA.
-   *
-   * {@code Bitmap.Config.ARGB_8888} is named after the packed int that
-   * {@code getPixel} returns, not after the in-memory byte order, which is
-   * R,G,B,A. Getting this backwards does not fail — it swaps red and blue in
-   * every raster, which looks like a colour-management problem and gets chased
-   * in the wrong place for a day.
-   */
-  @Test
-  public void pixelBytesAreRgbaNotBgraOrArgb() throws Exception {
-    File pdf = TestPdfs.quadrants(ctx(), "quads.pdf", 200, 300);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      RasterPixels px = r.render(white(0, 0f, 0f, 200f, 300f, 1f), null);
-      assertEquals(RasterPixels.FORMAT_RGBA_8888, px.format);
-
-      int[] red = rgba(px, 50, 75);
-      int[] green = rgba(px, 150, 75);
-      int[] blue = rgba(px, 50, 225);
-      int[] black = rgba(px, 150, 225);
-      Log.i(TAG, "channel order r=" + describe(red) + " g=" + describe(green)
-          + " b=" + describe(blue) + " k=" + describe(black));
-
-      assertTrue("first byte of the red quadrant must be R: " + describe(red), isRed(red));
-      assertTrue("green quadrant: " + describe(green), isGreen(green));
-      assertTrue("blue quadrant: " + describe(blue), isBlue(blue));
-      assertTrue("black quadrant: " + describe(black), isBlack(black));
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * The reported {@code rowBytes} must be the stride the PLATFORM chose for a
-   * bitmap of these dimensions and config — not a number this backend derived.
-   *
-   * CATCHES: any stride the backend states that the platform did not use. The
-   * reference is an independently allocated {@code Bitmap} of the same width,
-   * height and {@code ARGB_8888} config, asked for its own
-   * {@code getRowBytes()} / {@code getByteCount()}. That is the only claim that
-   * can be checked from outside, and it is checked at seven widths including odd
-   * and prime ones, which is where a platform would pad if it padded anywhere.
-   *
-   * WHAT IT CANNOT CATCH, stated plainly because the previous version of this
-   * comment claimed otherwise. {@code Bitmap.createBitmap} goes to
-   * {@code SkImageInfo::minRowBytes()}, which is {@code width * bytesPerPixel}
-   * with no alignment, so on every Android build measured here the stride IS
-   * {@code width * 4} at every width — 1, 3, 17, 33, 127, 200 and 201 all come
-   * back tight. On such a platform an implementation that ASSUMED
-   * {@code width * 4} is indistinguishable from one that read
-   * {@code getRowBytes()}, by this test or by any other, because the two
-   * quantities are equal. The old buffer-length assertion
-   * ({@code rowBytes * height == bytes.length}) did not close that gap either:
-   * both sides move together when the buffer is sized from
-   * {@code getByteCount()}.
-   *
-   * So the honest statement of what is defended: the backend states a stride the
-   * platform agrees with, and the moment a device DOES pad — a bitmap that came
-   * from a hardware buffer, or a future allocator that aligns rows — the
-   * assumption becomes wrong and this test is the thing that notices. The
-   * padded-stride path itself is covered on the JS side, where the fake backend
-   * can pad on demand (`reports the stride the backend gave, padding and all`).
-   */
-  @Test
-  public void rowBytesIsReportedNotAssumed() throws Exception {
-    File pdf = TestPdfs.quadrants(ctx(), "quads-stride.pdf", 200, 300);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    StringBuilder measured = new StringBuilder("rowBytes measured:");
-    try {
-      for (int targetWidth : new int[] {1, 3, 17, 33, 127, 200, 201}) {
-        float scale = targetWidth / 200f;
-        RasterPixels px = r.render(white(0, 0f, 0f, 200f, 300f, scale), null);
-        assertEquals(targetWidth, px.width);
-
-        // The platform's own answer for this exact allocation. Same call the
-        // backend makes, on a bitmap this test owns, so the comparison is
-        // against the platform rather than against the backend's arithmetic.
-        Bitmap probe = Bitmap.createBitmap(px.width, px.height, Bitmap.Config.ARGB_8888);
-        int platformRowBytes = probe.getRowBytes();
-        int platformByteCount = probe.getByteCount();
-        probe.recycle();
-
-        measured
-            .append(' ')
-            .append(px.width)
-            .append('x')
-            .append(px.height)
-            .append("->")
-            .append(px.rowBytes)
-            .append(px.rowBytes == px.width * 4 ? "(tight)" : "(PADDED)");
-
-        assertEquals(
-            "reported rowBytes must be the platform's own stride for a "
-                + px.width + "x" + px.height + " ARGB_8888 bitmap",
-            platformRowBytes,
-            px.rowBytes);
-        assertEquals(
-            "buffer length must be the platform's own byteCount for a "
-                + px.width + "x" + px.height + " ARGB_8888 bitmap",
-            platformByteCount,
-            px.bytes.length);
-        assertTrue(
-            "rowBytes " + px.rowBytes + " cannot hold " + px.width + " pixels",
-            px.rowBytes >= px.width * 4);
-        assertEquals(
-            "buffer length must be rowBytes*height for width " + px.width,
-            px.rowBytes * px.height,
-            px.bytes.length);
-
-        // Quadrant sampling only means anything once the raster is big enough
-        // for a quadrant to have interior pixels.
-        if (px.width >= 16 && px.height >= 16) {
-          int qx = px.width / 4;
-          int qy = px.height / 4;
-          assertTrue("red quadrant at width " + px.width + ": "
-              + describe(rgba(px, qx, qy)), isRed(rgba(px, qx, qy)));
-          assertTrue("green quadrant at width " + px.width + ": "
-              + describe(rgba(px, px.width - 1 - qx, qy)),
-              isGreen(rgba(px, px.width - 1 - qx, qy)));
-          assertTrue("blue quadrant at width " + px.width + ": "
-              + describe(rgba(px, qx, px.height - 1 - qy)),
-              isBlue(rgba(px, qx, px.height - 1 - qy)));
-        }
-      }
-    } finally {
-      r.close();
-    }
-    Log.i(TAG, measured.toString());
-  }
-
-  /* ================================================================ *
-   * 5. Request plumbing
-   * ================================================================ */
-
-  /**
-   * CATCHES: ignoring {@code RasterRequest.page} and rendering page 0 every
-   * time. Identical-looking pages make that bug invisible, so each page here is
-   * a different flat colour.
-   */
-  @Test
-  public void eachRequestRendersItsOwnPage() throws Exception {
-    int[] colors = {Color.RED, Color.GREEN, Color.BLUE};
-    File pdf = TestPdfs.coloredPages(ctx(), "colored.pdf", colors, 100, 100);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      assertEquals(3, r.pageCount());
-      assertTrue(isRed(rgba(r.render(white(0, 0f, 0f, 100f, 100f, 1f), null), 50, 50)));
-      assertTrue(isGreen(rgba(r.render(white(1, 0f, 0f, 100f, 100f, 1f), null), 50, 50)));
-      assertTrue(isBlue(rgba(r.render(white(2, 0f, 0f, 100f, 100f, 1f), null), 50, 50)));
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * CATCHES: a spool path that truncates, reorders, or reopens the wrong file.
-   * Byte-for-byte equality against the same document opened from disk is the
-   * only assertion that catches a spool which is merely CLOSE to right.
-   */
-  @Test
-  public void openBytesMatchesOpenFile() throws Exception {
-    File pdf = TestPdfs.quadrants(ctx(), "quads-bytes.pdf", 200, 300);
-    byte[] data = readAll(pdf);
-
-    RasterRequest request = white(0, 20f, 30f, 150f, 150f, 2f);
-    PdfCanvasRasterizer fromFile = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    RasterPixels a;
-    try {
-      a = fromFile.render(request, null);
-    } finally {
-      fromFile.close();
-    }
-
-    PdfCanvasRasterizer fromBytes =
-        PdfCanvasRasterizer.openBytes(ctx().getCacheDir(), data, null, 1);
-    RasterPixels b;
-    try {
-      assertEquals(fromFile.pageCount(), fromBytes.pageCount());
-      b = fromBytes.render(request, null);
-    } finally {
-      fromBytes.close();
-    }
-
-    assertEquals(a.width, b.width);
-    assertEquals(a.height, b.height);
-    assertEquals(a.rowBytes, b.rowBytes);
-    Diff diff = compareRegion(b, a, 0, 0);
-    assertEquals("openBytes must match openFile exactly: " + diff, 0, diff.mismatches);
-  }
-
-  /**
-   * CATCHES: an {@code openBytes} spool file that outlives its rasterizer.
-   *
-   * Nothing asserted this before, and it is the kind of leak nobody ever
-   * notices: a whole extra copy of every document opened from bytes, left in the
-   * cache directory until the OS decides to reclaim it. On the ARCH-D drawings
-   * this package exists for that is tens of megabytes per document, and the copy
-   * is invisible — the app has a working rasterizer and no error anywhere.
-   *
-   * Both exits are checked, because they are different code paths: {@code close()}
-   * deletes the spool it was handed, and the failure path inside
-   * {@code openBytes} has to delete a spool no rasterizer ever took ownership of.
-   * A private directory is used rather than the shared cache dir so the count is
-   * an assertion rather than a guess about what else is in there.
-   */
-  @Test
-  public void openBytesDeletesItsSpoolFile() throws Exception {
-    File spoolDir = new File(ctx().getCacheDir(), "spool-lifecycle");
-    emptyDirectory(spoolDir);
-
-    byte[] good = readAll(TestPdfs.quadrants(ctx(), "spool-quads.pdf", 200, 300));
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openBytes(spoolDir, good, null, 1);
-    assertEquals(
-        "the document must be spooled to disk while it is open — PdfRenderer "
-            + "needs a seekable descriptor",
-        1,
-        countFiles(spoolDir));
-    r.close();
-    assertEquals("close() must delete the spool file", 0, countFiles(spoolDir));
-
-    // A failed open: the spool exists, and nothing else will ever delete it.
-    byte[] garbage = readAll(TestPdfs.notAPdf(ctx(), "spool-notes.txt"));
-    try {
-      PdfCanvasRasterizer.openBytes(spoolDir, garbage, null, 1).close();
-      fail("garbage bytes should not have opened");
-    } catch (PdfRasterException e) {
-      assertEquals(PdfErrorCode.CORRUPT, e.code());
-    }
-    assertEquals("a failed openBytes must delete its spool file", 0, countFiles(spoolDir));
-  }
-
-  private static void emptyDirectory(File dir) {
-    File[] existing = dir.listFiles();
-    if (existing != null) {
-      for (File f : existing) {
-        //noinspection ResultOfMethodCallIgnored
-        f.delete();
-      }
-    }
-    if (!dir.exists() && !dir.mkdirs()) {
-      fail("could not create " + dir);
-    }
-    assertEquals("the spool directory must start empty", 0, countFiles(dir));
-  }
-
-  private static int countFiles(File dir) {
-    File[] files = dir.listFiles();
-    return files == null ? 0 : files.length;
-  }
-
-  /* ================================================================ *
-   * 6. Timings — reported, not asserted
-   * ================================================================ */
-
-  /**
-   * No assertion beyond "it completed". These numbers exist to be READ: the
-   * package's {@code minEpochIntervalMs} is meant to be the measured p95 raster
-   * time, and an emulator can only give the SHAPE of that. Asserting a wall time
-   * here would produce a test that fails on a loaded CI machine and tells nobody
-   * anything.
-   */
-  @Test
-  public void reportsTimings() throws Exception {
-    File letter =
-        TestPdfs.pattern(ctx(), "t-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    File arch = TestPdfs.pattern(ctx(), "t-archd.pdf", TestPdfs.ARCH_D_W, TestPdfs.ARCH_D_H);
-
-    StringBuilder sb = new StringBuilder("timings (ms, best of 3):");
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(arch, null, 1);
-    try {
-      sb.append(" archD-tile512@1x=").append(best(r, white(0, 400f, 600f, 512f, 512f, 1f)));
-      sb.append(" @4x=").append(best(r, white(0, 400f, 600f, 128f, 128f, 4f)));
-      sb.append(" @8x=").append(best(r, white(0, 400f, 600f, 64f, 64f, 8f)));
-      // The fit-scale whole-page base raster: 1170x1755 for an ARCH-D sheet.
-      sb.append(" archD-base1170x1755=")
-          .append(best(r, white(0, 0f, 0f, TestPdfs.ARCH_D_W, TestPdfs.ARCH_D_H, 0.677f)));
-    } finally {
-      r.close();
-    }
-
-    PdfCanvasRasterizer r2 = PdfCanvasRasterizer.openFile(letter, null, 1);
-    try {
-      sb.append(" letter-full@2x=")
-          .append(best(r2, white(0, 0f, 0f, TestPdfs.LETTER_W, TestPdfs.LETTER_H, 2f)));
-      long t0 = System.nanoTime();
-      PdfCanvasRasterizer probe = PdfCanvasRasterizer.openFile(letter, null, 2);
-      long openMs = (System.nanoTime() - t0) / 1_000_000;
-      probe.close();
-      sb.append(" open+geometry(1page,pool2)=").append(openMs);
-    } finally {
-      r2.close();
-    }
-    Log.i(TAG, sb.toString());
-  }
-
-  private static long best(PdfCanvasRasterizer r, RasterRequest request)
-      throws PdfRasterException {
-    long best = Long.MAX_VALUE;
-    for (int i = 0; i < 3; i++) {
-      long t = System.nanoTime();
-      r.render(request, null);
-      long ms = (System.nanoTime() - t) / 1_000_000;
-      if (ms < best) {
-        best = ms;
-      }
-    }
-    return best;
-  }
-
-  /* ================================================================ *
-   * Helpers
-   * ================================================================ */
-
-  /** RGBA at (x, y), read through the REPORTED stride. */
-  static int[] rgba(RasterPixels px, int x, int y) {
-    return new int[] {
-      px.channel(x, y, 0), px.channel(x, y, 1), px.channel(x, y, 2), px.channel(x, y, 3)
-    };
-  }
-
-  static String describe(int[] rgba) {
-    return "rgba(" + rgba[0] + "," + rgba[1] + "," + rgba[2] + "," + rgba[3] + ")";
-  }
-
-  private static final int TOLERANCE = 6;
-
-  private static boolean near(int actual, int expected) {
-    return Math.abs(actual - expected) <= TOLERANCE;
-  }
-
-  static boolean isRed(int[] c) {
-    return near(c[0], 255) && near(c[1], 0) && near(c[2], 0) && near(c[3], 255);
-  }
-
-  static boolean isGreen(int[] c) {
-    return near(c[0], 0) && near(c[1], 255) && near(c[2], 0) && near(c[3], 255);
-  }
-
-  static boolean isBlue(int[] c) {
-    return near(c[0], 0) && near(c[1], 0) && near(c[2], 255) && near(c[3], 255);
-  }
-
-  static boolean isBlack(int[] c) {
-    return near(c[0], 0) && near(c[1], 0) && near(c[2], 0) && near(c[3], 255);
-  }
-
-  static boolean isWhite(int[] c) {
-    return near(c[0], 255) && near(c[1], 255) && near(c[2], 255) && near(c[3], 255);
-  }
-
-  static final class Diff {
-    final int mismatches;
-    final int maxDelta;
-    final int total;
-    final double mismatchPercent;
-
-    Diff(int mismatches, int maxDelta, int total) {
-      this.mismatches = mismatches;
-      this.maxDelta = maxDelta;
-      this.total = total;
-      this.mismatchPercent = total == 0 ? 0 : 100.0 * mismatches / total;
-    }
-
-    @Override
-    public String toString() {
-      return "mismatches=" + mismatches + "/" + total
-          + String.format(" (%.4f%%)", mismatchPercent) + " maxDelta=" + maxDelta;
-    }
-  }
-
-  /**
-   * Compares `tile` against the region of `reference` starting at (dx, dy).
-   * A per-channel delta of 2 or less is not counted as a mismatch — that is
-   * anti-aliasing noise on a stroke edge, which S1 also measured (maxDelta 1).
-   */
-  static Diff compareRegion(RasterPixels tile, RasterPixels reference, int dx, int dy) {
-    int mismatches = 0;
-    int maxDelta = 0;
-    int total = tile.width * tile.height;
-    for (int y = 0; y < tile.height; y++) {
-      for (int x = 0; x < tile.width; x++) {
-        for (int c = 0; c < 4; c++) {
-          int d = Math.abs(tile.channel(x, y, c) - reference.channel(x + dx, y + dy, c));
-          if (d > maxDelta) {
-            maxDelta = d;
-          }
-          if (d > 2) {
-            mismatches++;
-            break;
-          }
-        }
-      }
-    }
-    return new Diff(mismatches, maxDelta, total);
-  }
-
-  private static byte[] readAll(File file) throws IOException {
-    byte[] out = new byte[(int) file.length()];
-    try (FileInputStream in = new FileInputStream(file)) {
-      int read = 0;
-      while (read < out.length) {
-        int n = in.read(out, read, out.length - read);
-        if (n < 0) {
-          fail("Short read on " + file);
-        }
-        read += n;
-      }
-    }
-    return out;
-  }
-}