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

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

@@ -1,226 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import android.content.Context;
-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.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Cancellation, and specifically the HONESTY of it.
- *
- * {@code PdfRenderer.Page.render} is synchronous and uninterruptible once
- * entered. The claim this backend makes is therefore narrow: a cancel prevents
- * the NEXT piece of work starting and discards a result that is no longer
- * wanted, and it does not — cannot — stop a render that is already drawing.
- *
- * A test that only asserted "cancelling makes it throw" would pass equally for a
- * backend that genuinely interrupted and for one that pretends to. The
- * distinguishing evidence is WHICH STAGE reported the cancellation, which is why
- * {@link RasterCancellation} puts the stage in the message.
- */
-@RunWith(AndroidJUnit4.class)
-public class PdfCanvasCancellationTest {
-
-  private static final String TAG = "PDFCANVAS";
-
-  private static Context ctx() {
-    return InstrumentationRegistry.getInstrumentation().getTargetContext();
-  }
-
-  /**
-   * CATCHES: a signal that is only consulted after the work is done — i.e. an
-   * implementation that renders first and checks later. The bar here is not just
-   * the error code but that no bitmap was allocated and no page opened, which
-   * shows up as this call returning far faster than a real render.
-   */
-  @Test
-  public void cancelBeforeStartRefusesWithoutRendering() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "cancel-archd.pdf", TestPdfs.ARCH_D_W, TestPdfs.ARCH_D_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      RasterRequest heavy =
-          new RasterRequest(
-              0, 200f, 300f, 1200f, 1200f, 1f, false, RasterRequest.BACKGROUND_WHITE);
-
-      long t0 = System.nanoTime();
-      r.render(heavy, null);
-      long uncancelledMs = (System.nanoTime() - t0) / 1_000_000;
-
-      RasterCancellation signal = new RasterCancellation();
-      signal.cancel();
-      long t1 = System.nanoTime();
-      try {
-        r.render(heavy, signal);
-        fail("A pre-cancelled render must not return pixels");
-      } catch (PdfRasterException e) {
-        long cancelledMs = (System.nanoTime() - t1) / 1_000_000;
-        assertEquals(PdfErrorCode.CANCELLED, e.code());
-        assertTrue(
-            "should have reported the entry check, not a later stage: " + e.getMessage(),
-            e.getMessage().contains("before start"));
-        Log.i(TAG, "cancel-before-start: uncancelled=" + uncancelledMs + "ms refused in "
-            + cancelledMs + "ms");
-        assertTrue(
-            "refusing should be far cheaper than rendering (uncancelled=" + uncancelledMs
-                + "ms, refused=" + cancelledMs + "ms)",
-            cancelledMs * 4 < uncancelledMs || cancelledMs <= 2);
-      }
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * CATCHES: a backend that CLAIMS to interrupt a render.
-   *
-   * A cancel raised while {@code PdfRenderer.render} is executing cannot take
-   * effect until it returns, so the only stage that can report it is the
-   * post-render check — the one that saves no drawing and merely stops a
-   * superseded raster being handed back. If some future change chunked the
-   * render and bailed early, this assertion would fail, which is the point:
-   * the claim in {@link RasterCancellation}'s comment and the code would have
-   * diverged.
-   *
-   * The retry loop is not flakiness padding — it is how the test lands the
-   * cancel INSIDE the render window on machines whose render time it does not
-   * know. A cancel that arrives too early is reported by the "before render"
-   * stage and a cancel that arrives too late does not fire at all; both are
-   * detected by name and retried with an adjusted delay, and neither is accepted
-   * as a pass.
-   */
-  @Test
-  public void cancelDuringAnInFlightRenderIsObservedOnlyAfterItFinishes() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "cancel2-archd.pdf", TestPdfs.ARCH_D_W, TestPdfs.ARCH_D_H);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      // Big enough that the render window is measurable. S1 finding 2: cost
-      // tracks DESTINATION BITMAP AREA, so 1600x1600 is the lever, not the
-      // scale.
-      RasterRequest heavy =
-          new RasterRequest(
-              0, 200f, 300f, 800f, 800f, 2f, false, RasterRequest.BACKGROUND_WHITE);
-
-      long baselineMs = Long.MAX_VALUE;
-      for (int i = 0; i < 3; i++) {
-        long t = System.nanoTime();
-        r.render(heavy, null);
-        baselineMs = Math.min(baselineMs, (System.nanoTime() - t) / 1_000_000);
-      }
-      Log.i(TAG, "cancel-in-flight: baseline render = " + baselineMs + "ms");
-
-      long delayMs = Math.max(5, baselineMs / 2);
-      String stage = null;
-      long elapsedMs = -1;
-
-      for (int attempt = 0; attempt < 6 && stage == null; attempt++) {
-        CountDownLatch started = new CountDownLatch(1);
-        AtomicReference<PdfRasterException> thrown = new AtomicReference<>();
-        AtomicReference<RasterPixels> returned = new AtomicReference<>();
-        RasterCancellation signal = new RasterCancellation();
-        long[] elapsed = new long[1];
-
-        Thread worker =
-            new Thread(
-                () -> {
-                  started.countDown();
-                  long t = System.nanoTime();
-                  try {
-                    returned.set(r.render(heavy, signal));
-                  } catch (PdfRasterException e) {
-                    thrown.set(e);
-                  }
-                  elapsed[0] = (System.nanoTime() - t) / 1_000_000;
-                });
-        worker.start();
-        assertTrue(started.await(10, TimeUnit.SECONDS));
-        Thread.sleep(delayMs);
-        signal.cancel();
-        worker.join(120_000);
-
-        PdfRasterException e = thrown.get();
-        if (e == null) {
-          // Cancel landed after the render had already returned. Aim earlier.
-          assertNotNull("neither a result nor an exception", returned.get());
-          delayMs = Math.max(2, delayMs / 2);
-          Log.i(TAG, "cancel-in-flight: attempt " + attempt + " landed too late, retrying at "
-              + delayMs + "ms");
-          continue;
-        }
-        assertEquals(PdfErrorCode.CANCELLED, e.code());
-        if (e.getMessage().contains("after render")) {
-          stage = "after render";
-          elapsedMs = elapsed[0];
-        } else {
-          // Landed before render() was entered. Aim later.
-          delayMs = Math.max(delayMs * 2, delayMs + 5);
-          Log.i(TAG, "cancel-in-flight: attempt " + attempt + " landed at '" + e.getMessage()
-              + "', retrying at " + delayMs + "ms");
-        }
-      }
-
-      assertNotNull(
-          "never managed to cancel inside the render window; baseline=" + baselineMs + "ms",
-          stage);
-      Log.i(TAG, "cancel-in-flight: observed at '" + stage + "' after " + elapsedMs
-          + "ms (baseline " + baselineMs + "ms)");
-      // The render ran to completion despite the cancel. If it had been
-      // interrupted, this would be a fraction of the baseline.
-      assertTrue(
-          "a cancelled in-flight render should still have taken about a full render "
-              + "(elapsed=" + elapsedMs + "ms, baseline=" + baselineMs + "ms)",
-          elapsedMs * 2 >= baselineMs);
-    } finally {
-      r.close();
-    }
-  }
-
-  /**
-   * CATCHES: a cancel that leaks across requests — a shared or static signal, or
-   * a pool slot left in a cancelled state. One superseded tile must not poison
-   * the next one, and with a pool of one the two renders provably share a
-   * renderer.
-   */
-  @Test
-  public void aCancelledRenderDoesNotAffectTheNextOne() throws Exception {
-    File pdf = TestPdfs.quadrants(ctx(), "cancel-quads.pdf", 200, 300);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      RasterRequest request =
-          new RasterRequest(0, 0f, 0f, 200f, 300f, 1f, false, RasterRequest.BACKGROUND_WHITE);
-
-      RasterCancellation cancelled = new RasterCancellation();
-      cancelled.cancel();
-      try {
-        r.render(request, cancelled);
-        fail("expected the cancelled render to throw");
-      } catch (PdfRasterException expected) {
-        assertEquals(PdfErrorCode.CANCELLED, expected.code());
-      }
-
-      RasterPixels px = r.render(request, null);
-      assertTrue(
-          "the render after a cancelled one must be correct",
-          PdfCanvasRasterizerTest.isRed(PdfCanvasRasterizerTest.rgba(px, 50, 75)));
-
-      RasterPixels withFreshSignal = r.render(request, new RasterCancellation());
-      assertNotNull("a fresh, uncancelled signal must not refuse", withFreshSignal);
-    } finally {
-      r.close();
-    }
-  }
-}

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

@@ -1,239 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import android.content.Context;
-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.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * The pool, under concurrency.
- *
- * The rule being defended is narrow and absolute: {@code PdfRenderer} allows ONE
- * open page per instance, so two threads on ONE renderer is what does not work.
- * Two renderers is fine. Every test here exists because the failure mode of
- * getting that wrong is either an {@code IllegalStateException} from a thread
- * nobody is watching, or — worse — two renders interleaving into each other's
- * bitmaps and producing two plausible, wrong images.
- */
-@RunWith(AndroidJUnit4.class)
-public class PdfCanvasConcurrencyTest {
-
-  private static final String TAG = "PDFCANVAS";
-
-  private static Context ctx() {
-    return InstrumentationRegistry.getInstrumentation().getTargetContext();
-  }
-
-  /** Eight distinct interior tiles of an ARCH-D sheet, each visually different. */
-  private static List<RasterRequest> tileSet() {
-    List<RasterRequest> out = new ArrayList<>();
-    for (int i = 0; i < 8; i++) {
-      float x = 100f + i * 137f;
-      float y = 200f + i * 211f;
-      out.add(new RasterRequest(0, x, y, 96f, 96f, 3f, false, RasterRequest.BACKGROUND_WHITE));
-    }
-    return out;
-  }
-
-  /**
-   * CATCHES: any interleaving that corrupts a raster once several renders are
-   * genuinely in flight through a pool of four.
-   *
-   * References are computed SERIALLY first, on one thread, so they are known
-   * good. Every concurrent result is then compared byte-for-byte against its
-   * reference — because the dangerous failure is not the one that throws, it is
-   * two renders mixing pixels and both coming back plausible.
-   *
-   * WHAT THIS TEST DOES NOT RELIABLY CATCH, corrected after measuring rather
-   * than assumed. It used to claim it catches "a pool that hands the same
-   * PdfRenderer to two threads". It does not, or not dependably: with
-   * {@code lease()} mutated to hand every thread renderer #0, this test failed
-   * on API 24 and 33 in one run and on API 24 and 31 in the next — the threads
-   * simply do not always collide inside the {@code openPage}..{@code close}
-   * window, which for these 288x288 tiles is a fraction of a millisecond. A
-   * test that catches a bug in two runs out of three is a coin toss reported as
-   * evidence.
-   *
-   * The double-lease property is pinned DETERMINISTICALLY by
-   * {@link #poolOfOneSerialisesRatherThanDoubleLeasing}, which failed on all
-   * three levels in both runs of that same mutation. That is the test to look at
-   * if this one ever starts passing while the pool is broken.
-   */
-  @Test
-  public void concurrentRendersThroughThePoolAreAllCorrect() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "conc-archd.pdf", TestPdfs.ARCH_D_W, TestPdfs.ARCH_D_H);
-    List<RasterRequest> requests = tileSet();
-
-    PdfCanvasRasterizer serial = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    List<RasterPixels> reference = new ArrayList<>();
-    long serialStart = System.nanoTime();
-    try {
-      for (RasterRequest request : requests) {
-        reference.add(serial.render(request, null));
-      }
-    } finally {
-      serial.close();
-    }
-    long serialMs = (System.nanoTime() - serialStart) / 1_000_000;
-
-    PdfCanvasRasterizer parallel = PdfCanvasRasterizer.openFile(pdf, null, 4);
-    assertEquals("pool should have been created at the requested size", 4, parallel.poolSize());
-
-    int threads = 4;
-    int rounds = 3;
-    ExecutorService pool = Executors.newFixedThreadPool(threads);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(threads);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-
-    long parallelStart;
-    try {
-      for (int t = 0; t < threads; t++) {
-        final int threadIndex = t;
-        pool.execute(
-            () -> {
-              try {
-                go.await();
-                for (int round = 0; round < rounds; round++) {
-                  for (int i = threadIndex; i < requests.size(); i += threads) {
-                    RasterPixels got = parallel.render(requests.get(i), null);
-                    RasterPixels want = reference.get(i);
-                    assertEquals("width for tile " + i, want.width, got.width);
-                    PdfCanvasRasterizerTest.Diff diff =
-                        PdfCanvasRasterizerTest.compareRegion(got, want, 0, 0);
-                    if (diff.mismatches != 0) {
-                      throw new AssertionError("tile " + i + " differs from its serial "
-                          + "reference: " + diff);
-                    }
-                  }
-                }
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      parallelStart = System.nanoTime();
-      go.countDown();
-      assertTrue("threads did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-    } finally {
-      pool.shutdownNow();
-      parallel.close();
-    }
-    long parallelMs = (System.nanoTime() - parallelStart) / 1_000_000;
-
-    assertNull(
-        failure.get() == null ? null : String.valueOf(failure.get()), failure.get());
-
-    // Reported, not asserted. AOSP serialises every PdfRenderer native call
-    // behind a process-wide PDFium lock, so the pool buys CORRECTNESS (no shared
-    // open page) rather than throughput. If these two numbers are close, that is
-    // the lock; if the parallel run is meaningfully faster, this platform build
-    // does not have it. Either way the pool is still required.
-    Log.i(TAG, "concurrency: " + requests.size() + " tiles serial=" + serialMs + "ms | "
-        + (threads * rounds * requests.size() / threads) + " tiles across " + threads
-        + " threads, pool=4, =" + parallelMs + "ms");
-  }
-
-  /**
-   * CATCHES: a pool that leases the same renderer twice under contention. This
-   * is THE test for that property, and the only one that catches it every time.
-   *
-   * With a pool of ONE and four threads pushing, every request must queue. A
-   * correct pool serialises them and every result is right; a broken lease hands
-   * renderer #0 to two threads at once, and {@code openPage} throws
-   * "Current page not closed" — which this backend reports as a
-   * {@code backend-failure} naming the double lease, so the failure message
-   * points straight at the cause.
-   *
-   * Why this one is deterministic where
-   * {@link #concurrentRendersThroughThePoolAreAllCorrect} is not: a pool of one
-   * means EVERY pair of threads contends for the same renderer, so a lease that
-   * does not remove the renderer from the free queue collides on essentially the
-   * first overlap rather than on whichever pair of the four happens to line up.
-   * Measured: mutating {@code lease()} to hand out renderer #0 without taking it
-   * failed here on API 24, 31 and 33 in both runs, while the four-renderer test
-   * caught it on only two of the three each time.
-   */
-  @Test
-  public void poolOfOneSerialisesRatherThanDoubleLeasing() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "conc1-letter.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    RasterRequest request =
-        new RasterRequest(0, 100f, 200f, 200f, 200f, 2f, false, RasterRequest.BACKGROUND_WHITE);
-
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    assertEquals(1, r.poolSize());
-    RasterPixels reference = r.render(request, null);
-
-    int threads = 4;
-    ExecutorService pool = Executors.newFixedThreadPool(threads);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(threads);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    try {
-      for (int t = 0; t < threads; t++) {
-        pool.execute(
-            () -> {
-              try {
-                go.await();
-                for (int i = 0; i < 6; i++) {
-                  RasterPixels got = r.render(request, null);
-                  PdfCanvasRasterizerTest.Diff diff =
-                      PdfCanvasRasterizerTest.compareRegion(got, reference, 0, 0);
-                  if (diff.mismatches != 0) {
-                    throw new AssertionError("serialised render differs: " + diff);
-                  }
-                }
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      go.countDown();
-      assertTrue("threads did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-    } finally {
-      pool.shutdownNow();
-      r.close();
-    }
-    assertNull(String.valueOf(failure.get()), failure.get());
-  }
-
-  /**
-   * CATCHES: a pool that clamps its size wrongly, or accepts a nonsense size and
-   * then allocates that many renderers. Each renderer holds an fd and a parsed
-   * document, so an unclamped 64 would be 64 of both.
-   */
-  @Test
-  public void poolSizeIsClamped() throws Exception {
-    File pdf = TestPdfs.pattern(ctx(), "clamp.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H);
-    PdfCanvasRasterizer zero = PdfCanvasRasterizer.openFile(pdf, null, 0);
-    PdfCanvasRasterizer huge = PdfCanvasRasterizer.openFile(pdf, null, 64);
-    try {
-      assertEquals(1, zero.poolSize());
-      assertEquals(PdfRendererPool.MAX_POOL_SIZE, huge.poolSize());
-    } finally {
-      zero.close();
-      huge.close();
-    }
-  }
-}