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

package/native/tests/fixtures.cpp

@@ -0,0 +1,451 @@
+#include "fixtures.h"
+
+#include <array>
+#include <cstdio>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+
+namespace fixtures {
+
+namespace {
+
+/* ------------------------------------------------------------------ *
+ * The writer
+ * ------------------------------------------------------------------ */
+
+/// Assembles objects and writes a correct xref table, which every reader prefers.
+class Writer {
+ public:
+  Writer() {
+    write("%PDF-1.4\n");
+    // A binary comment line marks the file as binary, per the spec's advice.
+    const uint8_t marker[] = {0x25, 0xE2, 0xE3, 0xCF, 0xD3, 0x0A};
+    out_.insert(out_.end(), marker, marker + sizeof(marker));
+  }
+
+  void write(const std::string& s) { out_.insert(out_.end(), s.begin(), s.end()); }
+  void write(const Bytes& b) { out_.insert(out_.end(), b.begin(), b.end()); }
+
+  int count() const { return static_cast<int>(offsets_.size()); }
+
+  /// Returns the object number, 1-based.
+  int add(const std::string& body) { return add(Bytes(body.begin(), body.end())); }
+
+  int add(const Bytes& body) {
+    const int number = count() + 1;
+    offsets_.push_back(out_.size());
+    write(std::to_string(number) + " 0 obj\n");
+    write(body);
+    write("\nendobj\n");
+    return number;
+  }
+
+  Bytes finish(int rootObject, const std::string& extraTrailer = "") {
+    const size_t xref = out_.size();
+    const size_t size = offsets_.size() + 1;
+    write("xref\n0 " + std::to_string(size) + "\n");
+    write("0000000000 65535 f \n");
+    for (size_t offset : offsets_) {
+      char line[32];
+      std::snprintf(line, sizeof(line), "%010zu 00000 n \n", offset);
+      write(std::string(line));
+    }
+    write("trailer\n<< /Size " + std::to_string(size) + " /Root " + std::to_string(rootObject) +
+          " 0 R " + extraTrailer + " >>\nstartxref\n" + std::to_string(xref) + "\n%%EOF\n");
+    return out_;
+  }
+
+ private:
+  Bytes out_;
+  std::vector<size_t> offsets_;
+};
+
+std::string boxString(const Box& box) {
+  return "[" + std::to_string(box.x0) + " " + std::to_string(box.y0) + " " +
+         std::to_string(box.x1) + " " + std::to_string(box.y1) + "]";
+}
+
+std::string streamObject(const std::string& content, const std::string& extraDict = "") {
+  return "<< /Length " + std::to_string(content.size()) + extraDict + " >>\nstream\n" + content +
+         "endstream";
+}
+
+std::string fmt(double value) {
+  char buffer[32];
+  std::snprintf(buffer, sizeof(buffer), "%g", value);
+  return buffer;
+}
+
+}  // namespace
+
+/* ------------------------------------------------------------------ *
+ * Single-page fixtures
+ * ------------------------------------------------------------------ */
+
+Bytes page(Box mediaBox, const Box* cropBox, int rotate, const std::string& content) {
+  Writer w;
+  const int contents = w.add(streamObject(content));
+  // COMPUTED, not hardcoded: /Parent has to name the page tree, which is
+  // written next-but-one.
+  const int pagesNumber = w.count() + 2;
+  std::string dict = "<< /Type /Page /Parent " + std::to_string(pagesNumber) +
+                     " 0 R /MediaBox " + boxString(mediaBox);
+  if (cropBox != nullptr) dict += " /CropBox " + boxString(*cropBox);
+  if (rotate != 0) dict += " /Rotate " + std::to_string(rotate);
+  dict += " /Contents " + std::to_string(contents) + " 0 R /Resources << >> >>";
+  const int pageObj = w.add(dict);
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) + " 0 R >>");
+  if (pages != pagesNumber) throw std::logic_error("pages object number drifted");
+  return w.finish(catalog);
+}
+
+Bytes quadrants(int width, int height, int rotate) {
+  const int hw = width / 2;
+  const int hh = height / 2;
+  const std::string content = "1 0 0 rg 0 0 " + std::to_string(hw) + " " + std::to_string(hh) +
+                              " re f\n0 1 0 rg " + std::to_string(hw) + " 0 " + std::to_string(hw) +
+                              " " + std::to_string(hh) + " re f\n0 0 1 rg 0 " + std::to_string(hh) +
+                              " " + std::to_string(hw) + " " + std::to_string(hh) +
+                              " re f\n0 0 0 rg " + std::to_string(hw) + " " + std::to_string(hh) +
+                              " " + std::to_string(hw) + " " + std::to_string(hh) + " re f\n";
+  return page({0, 0, width, height}, nullptr, rotate, content);
+}
+
+Bytes grid(int width, int height, int pitch) {
+  std::string content = "1 1 1 rg 0 0 " + std::to_string(width) + " " + std::to_string(height) +
+                        " re f\n0 0 0 RG 0.5 w\n";
+  for (int x = 0; x <= width; x += pitch) {
+    content += std::to_string(x) + " 0 m " + std::to_string(x) + " " + std::to_string(height) + " l S\n";
+  }
+  for (int y = 0; y <= height; y += pitch) {
+    content += "0 " + std::to_string(y) + " m " + std::to_string(width) + " " + std::to_string(y) + " l S\n";
+  }
+  content += "1 0 0 RG 2 w 0 0 m " + std::to_string(width) + " " + std::to_string(height) + " l S " +
+             std::to_string(width) + " 0 m 0 " + std::to_string(height) + " l S\n";
+  return page({0, 0, width, height}, nullptr, 0, content);
+}
+
+Bytes rotated(int degrees) {
+  // PDF user space is y-UP from the bottom-left, so the top-left 112x100 of
+  // the page is the rect (0, 692) to (112, 792).
+  const std::string content = "1 1 1 rg 0 0 612 792 re f\n1 0 0 rg 0 692 112 100 re f\n0 0 1 rg 0 0 112 100 re f\n";
+  return page({0, 0, kLetterW, kLetterH}, nullptr, degrees, content);
+}
+
+Bytes offsetCropBox() {
+  // CropBox (100, 150) to (300, 350): 200 x 200 points, top-left at (100, 350).
+  const std::string content =
+      "0.5 0.5 0.5 rg 0 0 400 400 re f\n1 0 0 rg 100 310 40 40 re f\n0 0 1 rg 260 150 40 40 re f\n";
+  const Box crop{100, 150, 300, 350};
+  return page({0, 0, 400, 400}, &crop, 0, content);
+}
+
+Bytes cropBoxOverhangingMediaBox() {
+  const Box crop{50, 50, 400, 400};
+  return page({0, 0, 200, 200}, &crop, 0, "0.5 0.5 0.5 rg 0 0 200 200 re f\n");
+}
+
+Bytes antialiasedWhiteEdge() {
+  const std::string content =
+      "1 1 1 rg\n50 10 m\n72.09 10 90 27.91 90 50 c\n90 72.09 72.09 90 50 90 c\n"
+      "27.91 90 10 72.09 10 50 c\n10 27.91 27.91 10 50 10 c\nf\n";
+  return page({0, 0, 100, 100}, nullptr, 0, content);
+}
+
+Bytes annotatedPage() {
+  Writer w;
+  const std::string content = "1 1 1 rg 0 0 200 200 re f\n1 0 0 rg 10 10 30 30 re f\n";
+  const int contents = w.add(streamObject(content));
+  // The annotation and its appearance stream are written BEFORE the page
+  // dictionary that names them, so /Annots is built from the object number
+  // they actually got.
+  const std::string appearance = "0 1 0 rg 0 0 100 100 re f\n";
+  const int ap = w.add(streamObject(appearance, " /Type /XObject /Subtype /Form /BBox [0 0 100 100]"));
+  const int annot = w.add("<< /Type /Annot /Subtype /Square /Rect [50 50 150 150] /F 4 /AP << /N " +
+                          std::to_string(ap) + " 0 R >> >>");
+  const int pagesNumber = w.count() + 2;
+  const int pageObj = w.add("<< /Type /Page /Parent " + std::to_string(pagesNumber) +
+                            " 0 R /MediaBox [0 0 200 200] /Annots [" + std::to_string(annot) +
+                            " 0 R] /Contents " + std::to_string(contents) + " 0 R /Resources << >> >>");
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) + " 0 R >>");
+  if (pages != pagesNumber) throw std::logic_error("pages object number drifted");
+  return w.finish(catalog);
+}
+
+Bytes formFieldPage() {
+  Writer w;
+  const std::string content = "1 1 1 rg 0 0 200 200 re f\n1 0 0 rg 10 10 30 30 re f\n";
+  const int contents = w.add(streamObject(content));
+  // A merged field/widget dictionary — the common single-widget shape — whose
+  // normal appearance paints a solid blue box. `/FT /Tx` with a value and a
+  // default appearance so PDFium treats it as a real text field rather than an
+  // orphan widget.
+  const std::string appearance = "0 0 1 rg 0 0 100 50 re f\n";
+  const int ap = w.add(streamObject(appearance, " /Type /XObject /Subtype /Form /BBox [0 0 100 50]"));
+  const int pagesNumber = w.count() + 3;  // widget, page, then the tree
+  const int pageNumber = w.count() + 2;
+  const int widget = w.add("<< /Type /Annot /Subtype /Widget /FT /Tx /T (field) /V (value) /Ff 0 "
+                           "/Rect [50 50 150 100] /F 4 /P " + std::to_string(pageNumber) +
+                           " 0 R /DA (/Helv 12 Tf 0 g) /MK << /BG [0 0 1] >> /AP << /N " +
+                           std::to_string(ap) + " 0 R >> >>");
+  const int pageObj = w.add("<< /Type /Page /Parent " + std::to_string(pagesNumber) +
+                            " 0 R /MediaBox [0 0 200 200] /Annots [" + std::to_string(widget) +
+                            " 0 R] /Contents " + std::to_string(contents) + " 0 R /Resources << >> >>");
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) +
+                            " 0 R /AcroForm << /Fields [" + std::to_string(widget) +
+                            " 0 R] /DA (/Helv 0 Tf 0 g) /NeedAppearances false >> >>");
+  if (pages != pagesNumber || pageObj != pageNumber) throw std::logic_error("object numbers drifted");
+  return w.finish(catalog);
+}
+
+/* ------------------------------------------------------------------ *
+ * Multi-page fixtures
+ * ------------------------------------------------------------------ */
+
+Bytes multiPage(const std::vector<PageSpec>& specs) {
+  Writer w;
+  std::vector<int> contentObjects;
+  for (const auto& spec : specs) contentObjects.push_back(w.add(streamObject(spec.content)));
+  const int treeNumber = static_cast<int>(contentObjects.size() + specs.size()) + 1;
+  std::vector<int> pageObjects;
+  for (size_t i = 0; i < specs.size(); i++) {
+    std::string dict = "<< /Type /Page /Parent " + std::to_string(treeNumber) + " 0 R /MediaBox [0 0 " +
+                       std::to_string(specs[i].width) + " " + std::to_string(specs[i].height) + "]";
+    if (specs[i].rotate != 0) dict += " /Rotate " + std::to_string(specs[i].rotate);
+    dict += " /Contents " + std::to_string(contentObjects[i]) + " 0 R /Resources << >> >>";
+    pageObjects.push_back(w.add(dict));
+  }
+  std::string kids;
+  for (int number : pageObjects) kids += std::to_string(number) + " 0 R ";
+  const int tree = w.add("<< /Type /Pages /Kids [" + kids + "] /Count " + std::to_string(specs.size()) + " >>");
+  if (tree != treeNumber) throw std::logic_error("tree object number drifted");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(tree) + " 0 R >>");
+  return w.finish(catalog);
+}
+
+Bytes mixedSizeDocument() {
+  std::vector<PageSpec> specs;
+  const std::pair<int, int> sizes[] = {{kLetterW, kLetterH}, {kArchDW, kArchDH}, {200, 900}};
+  for (const auto& size : sizes) {
+    specs.push_back({size.first, size.second, 0,
+                     "0.5 0.5 0.5 rg 0 0 " + std::to_string(size.first) + " " +
+                         std::to_string(size.second) + " re f\n"});
+  }
+  return multiPage(specs);
+}
+
+Bytes coloredPages(const std::vector<std::array<double, 3>>& colors, int width, int height) {
+  std::vector<PageSpec> specs;
+  for (const auto& color : colors) {
+    specs.push_back({width, height, 0,
+                     fmt(color[0]) + " " + fmt(color[1]) + " " + fmt(color[2]) + " rg 0 0 " +
+                         std::to_string(width) + " " + std::to_string(height) + " re f\n"});
+  }
+  return multiPage(specs);
+}
+
+/* ------------------------------------------------------------------ *
+ * Not-PDFs
+ * ------------------------------------------------------------------ */
+
+Bytes headerOnlyGarbage() {
+  std::string s = "%PDF-1.7\n";
+  for (int i = 0; i < 200; i++) s += "garbage line " + std::to_string(i) + "\n";
+  return Bytes(s.begin(), s.end());
+}
+
+Bytes notAPdfAtAll() {
+  std::string s;
+  for (int i = 0; i < 200; i++) s += "this is a text file, line " + std::to_string(i) + "\n";
+  s += "%PDF-1.7 too late to count\n";
+  return Bytes(s.begin(), s.end());
+}
+
+/* ------------------------------------------------------------------ *
+ * Encryption (standard security handler, R=2, V=1, RC4-40)
+ * ------------------------------------------------------------------ */
+
+const char* const kUserPassword = "secret";
+/// Non-empty, and that is load-bearing: with an empty owner password every
+/// reader's owner-authentication path (Algorithm 7) recovers the user password
+/// from /O and opens the document with no password at all.
+const char* const kOwnerPassword = "owner";
+
+namespace {
+
+const uint8_t kPad[32] = {0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E,
+                          0x56, 0xFF, 0xFA, 0x01, 0x08, 0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68,
+                          0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A};
+
+Bytes padded(const std::string& password) {
+  Bytes out(32, 0);
+  const size_t n = std::min<size_t>(password.size(), 32);
+  for (size_t i = 0; i < n; i++) out[i] = static_cast<uint8_t>(password[i]);
+  for (size_t i = n; i < 32; i++) out[i] = kPad[i - n];
+  return out;
+}
+
+Bytes rc4(const Bytes& key, const Bytes& data) {
+  std::array<int, 256> s{};
+  for (int i = 0; i < 256; i++) s[i] = i;
+  for (int i = 0, j = 0; i < 256; i++) {
+    j = (j + s[i] + key[i % key.size()]) & 0xFF;
+    std::swap(s[i], s[j]);
+  }
+  Bytes out(data.size());
+  for (size_t k = 0, i = 0, j = 0; k < data.size(); k++) {
+    i = (i + 1) & 0xFF;
+    j = (j + s[i]) & 0xFF;
+    std::swap(s[i], s[j]);
+    out[k] = static_cast<uint8_t>(data[k] ^ s[(s[i] + s[j]) & 0xFF]);
+  }
+  return out;
+}
+
+/// MD5, written out rather than pulled from a platform library, so the fixture
+/// is the same bytes on every host.
+Bytes md5(const Bytes& message) {
+  static const uint32_t s[64] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
+                                 5, 9,  14, 20, 5, 9,  14, 20, 5, 9,  14, 20, 5, 9,  14, 20,
+                                 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
+                                 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21};
+  static const uint32_t k[64] = {
+      0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+      0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+      0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+      0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+      0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+      0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+      0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+      0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
+
+  Bytes msg = message;
+  const uint64_t bitLength = static_cast<uint64_t>(message.size()) * 8;
+  msg.push_back(0x80);
+  while (msg.size() % 64 != 56) msg.push_back(0);
+  for (int i = 0; i < 8; i++) msg.push_back(static_cast<uint8_t>(bitLength >> (8 * i)));
+
+  uint32_t a0 = 0x67452301, b0 = 0xefcdab89, c0 = 0x98badcfe, d0 = 0x10325476;
+  for (size_t chunk = 0; chunk < msg.size(); chunk += 64) {
+    uint32_t m[16];
+    for (int i = 0; i < 16; i++) {
+      const size_t o = chunk + static_cast<size_t>(i) * 4;
+      m[i] = static_cast<uint32_t>(msg[o]) | (static_cast<uint32_t>(msg[o + 1]) << 8) |
+             (static_cast<uint32_t>(msg[o + 2]) << 16) | (static_cast<uint32_t>(msg[o + 3]) << 24);
+    }
+    uint32_t a = a0, b = b0, c = c0, d = d0;
+    for (int i = 0; i < 64; i++) {
+      uint32_t f;
+      int g;
+      switch (i / 16) {
+        case 0: f = (b & c) | (~b & d); g = i; break;
+        case 1: f = (d & b) | (~d & c); g = (5 * i + 1) % 16; break;
+        case 2: f = b ^ c ^ d; g = (3 * i + 5) % 16; break;
+        default: f = c ^ (b | ~d); g = (7 * i) % 16; break;
+      }
+      f = f + a + k[i] + m[g];
+      a = d;
+      d = c;
+      c = b;
+      b = b + ((f << s[i]) | (f >> (32 - s[i])));
+    }
+    a0 += a; b0 += b; c0 += c; d0 += d;
+  }
+  Bytes out;
+  for (uint32_t word : {a0, b0, c0, d0}) {
+    for (int i = 0; i < 4; i++) out.push_back(static_cast<uint8_t>(word >> (8 * i)));
+  }
+  return out;
+}
+
+Bytes concat(std::initializer_list<Bytes> parts) {
+  Bytes out;
+  for (const auto& part : parts) out.insert(out.end(), part.begin(), part.end());
+  return out;
+}
+
+std::string hex(const Bytes& bytes) {
+  std::string out;
+  char buffer[3];
+  for (uint8_t b : bytes) {
+    std::snprintf(buffer, sizeof(buffer), "%02X", b);
+    out += buffer;
+  }
+  return out;
+}
+
+}  // namespace
+
+Bytes encrypted() {
+  const std::string contentString = "1 0 0 rg 0 0 200 200 re f\n";
+  const Bytes content(contentString.begin(), contentString.end());
+
+  const Bytes fileId = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+                        0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10};
+  const int32_t permissions = -1;
+  const Bytes pBytes = {static_cast<uint8_t>(permissions), static_cast<uint8_t>(permissions >> 8),
+                        static_cast<uint8_t>(permissions >> 16), static_cast<uint8_t>(permissions >> 24)};
+
+  // Algorithm 3: /O is the padded USER password, RC4'd with the MD5 of the
+  // padded OWNER password.
+  Bytes ownerDigest = md5(padded(kOwnerPassword));
+  const Bytes ownerKey(ownerDigest.begin(), ownerDigest.begin() + 5);
+  const Bytes o = rc4(ownerKey, padded(kUserPassword));
+
+  // Algorithm 2: the file encryption key.
+  Bytes fileDigest = md5(concat({padded(kUserPassword), o, pBytes, fileId}));
+  const Bytes fileKey(fileDigest.begin(), fileDigest.begin() + 5);
+
+  // Algorithm 4 (R=2): /U is the pad string RC4'd with the file key.
+  const Bytes u = rc4(fileKey, Bytes(kPad, kPad + 32));
+
+  // Algorithm 1: per-object key. Object 1 is the content stream.
+  const Bytes extra = {1, 0, 0, 0, 0};
+  Bytes objectDigest = md5(concat({fileKey, extra}));
+  const Bytes objectKey(objectDigest.begin(), objectDigest.begin() + 10);
+  const Bytes encryptedContent = rc4(objectKey, content);
+
+  Writer w;
+  Bytes streamObj;
+  const std::string head = "<< /Length " + std::to_string(encryptedContent.size()) + " >>\nstream\n";
+  streamObj.insert(streamObj.end(), head.begin(), head.end());
+  streamObj.insert(streamObj.end(), encryptedContent.begin(), encryptedContent.end());
+  const std::string tail = "\nendstream";
+  streamObj.insert(streamObj.end(), tail.begin(), tail.end());
+  const int contents = w.add(streamObj);
+  const int pageObj = w.add("<< /Type /Page /Parent 3 0 R /MediaBox [0 0 200 200] /Contents " +
+                            std::to_string(contents) + " 0 R /Resources << >> >>");
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) + " 0 R >>");
+  const int encrypt = w.add("<< /Filter /Standard /V 1 /R 2 /O <" + hex(o) + "> /U <" + hex(u) +
+                            "> /P " + std::to_string(permissions) + " >>");
+  if (pages != 3) throw std::logic_error("pages object is not 3");
+  return w.finish(catalog, "/Encrypt " + std::to_string(encrypt) + " 0 R /ID [<" + hex(fileId) +
+                               "> <" + hex(fileId) + ">]");
+}
+
+/* ------------------------------------------------------------------ *
+ * Files
+ * ------------------------------------------------------------------ */
+
+std::string tempDir() {
+  const auto dir = std::filesystem::temp_directory_path() / "pdfcanvas-native-tests";
+  std::filesystem::create_directories(dir);
+  return dir.string();
+}
+
+std::string writeTemp(const Bytes& bytes, const std::string& name) {
+  const auto path = std::filesystem::path(tempDir()) / name;
+  std::ofstream out(path, std::ios::binary | std::ios::trunc);
+  out.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
+  out.close();
+  return path.string();
+}
+
+}  // namespace fixtures

package/native/tests/fixtures.h

@@ -0,0 +1,96 @@
+// PDFs built in memory, so a test has no asset to ship and the content is known
+// exactly rather than eyeballed.
+//
+// A PORT OF THE RETIRED `TestPdfs.swift` / `TestPdfs.java`, now the ONE copy:
+// every platform is proven against the same bytes, so a rendering disagreement
+// can only be a rendering disagreement. Every fixture is hand-written PDF
+// syntax — the bytes are the input, and nothing about what they mean depends on
+// the code under test.
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace fixtures {
+
+using Bytes = std::vector<uint8_t>;
+
+constexpr int kLetterW = 612;
+constexpr int kLetterH = 792;
+/// ARCH-D, the sheet size this package exists for.
+constexpr int kArchDW = 1728;
+constexpr int kArchDH = 2592;
+
+struct Box {
+  int x0, y0, x1, y1;
+};
+
+/// Four saturated quadrants in PDF user space (y-up): red bottom-left, green
+/// bottom-right, blue top-left, black top-right. Saturated is what makes a
+/// channel-order test possible at all; quadrants make a stride error visible;
+/// and because the four differ in both axes, a y-flip and an x/y transposition
+/// each move half the pixels.
+Bytes quadrants(int width, int height, int rotate = 0);
+
+/// Detail at every spatial frequency: a `pitch`-point grid catches a scale
+/// error, the two diagonals catch a transposition. Also the shape a real
+/// drawing has — hundreds of stroked lines.
+Bytes grid(int width, int height, int pitch = 8);
+
+/// A 612x792 page carrying `/Rotate degrees`, red filling the UNROTATED
+/// top-left 112x100 points and blue the unrotated bottom-left.
+Bytes rotated(int degrees);
+
+/// MediaBox 0 0 400 400, CropBox 100 150 300 350, a red marker at the crop
+/// box's own top-left and a blue one at its bottom-right.
+Bytes offsetCropBox();
+
+/// A CropBox that overhangs its MediaBox, so the intersection is testable.
+Bytes cropBoxOverhangingMediaBox();
+
+/// An antialiased opaque-white circle on an empty page: rendered transparent
+/// this decides the alpha encoding.
+Bytes antialiasedWhiteEdge();
+
+/// A page whose only GREEN is inside a `/Square` annotation's appearance
+/// stream. Content: white page with a red marker.
+Bytes annotatedPage();
+
+/// A page whose only BLUE is a text-field WIDGET's appearance stream, reachable
+/// through the document's AcroForm. Content: white page with a red marker.
+Bytes formFieldPage();
+
+/// A single page with explicit boxes, rotation and content.
+Bytes page(Box mediaBox, const Box* cropBox, int rotate, const std::string& content);
+
+struct PageSpec {
+  int width;
+  int height;
+  int rotate;
+  std::string content;
+};
+Bytes multiPage(const std::vector<PageSpec>& pages);
+
+/// Letter, ARCH-D, and 200x900 — three sizes, so geometry is per page.
+Bytes mixedSizeDocument();
+/// One flat colour per page.
+Bytes coloredPages(const std::vector<std::array<double, 3>>& colors, int width, int height);
+
+/// A valid `%PDF-` header and nothing else that parses.
+Bytes headerOnlyGarbage();
+/// No `%PDF-` header anywhere near the front.
+Bytes notAPdfAtAll();
+
+/// A 200x200 red page encrypted with the standard security handler (R=2, V=1,
+/// RC4-40), user password `kUserPassword`, owner password `kOwnerPassword`.
+extern const char* const kUserPassword;
+extern const char* const kOwnerPassword;
+Bytes encrypted();
+
+/// Writes bytes to a fresh file under the system temp dir and returns its path.
+std::string writeTemp(const Bytes& bytes, const std::string& name);
+/// The temp directory fixtures write into.
+std::string tempDir();
+
+}  // namespace fixtures

package/native/tests/harness.h

@@ -0,0 +1,122 @@
+// A hundred lines of test harness, so the core takes no test dependency.
+//
+// `TEST(name) { ... }` registers a case; `CHECK*` record a failure and keep
+// going within the case (so one report names every wrong pixel, not the first);
+// `REQUIRE*` abort the case. `EXPECT_ERROR(expr, code)` is the one that earns
+// its place: every failure mode in this package is a `PdfError` with a code a
+// UI can switch on, and "it threw" is not the same as "it threw the right one".
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "pdfcanvas/error.h"
+
+namespace harness {
+
+struct Failure {
+  std::string file;
+  int line;
+  std::string message;
+};
+
+struct Context {
+  std::vector<Failure> failures;
+  void fail(const char* file, int line, std::string message) {
+    failures.push_back({file, line, std::move(message)});
+  }
+};
+
+Context& current();
+
+struct Case {
+  const char* name;
+  std::function<void()> body;
+};
+
+std::vector<Case>& cases();
+
+struct Registrar {
+  Registrar(const char* name, void (*body)()) { cases().push_back({name, body}); }
+};
+
+/// Aborts the current case. Caught by the runner.
+struct Abort {};
+
+template <typename T>
+std::string show(const T& value) {
+  std::ostringstream out;
+  out << value;
+  return out.str();
+}
+
+}  // namespace harness
+
+#define TEST(name)                                          \
+  static void name();                                       \
+  static ::harness::Registrar registrar_##name(#name, &name); \
+  static void name()
+
+#define CHECK(cond)                                                                 \
+  do {                                                                              \
+    if (!(cond)) ::harness::current().fail(__FILE__, __LINE__, "CHECK failed: " #cond); \
+  } while (0)
+
+#define CHECK_MSG(cond, msg)                                                        \
+  do {                                                                              \
+    if (!(cond))                                                                    \
+      ::harness::current().fail(__FILE__, __LINE__,                                 \
+                                std::string("CHECK failed: " #cond " — ") + (msg)); \
+  } while (0)
+
+#define CHECK_EQ(a, b)                                                                 \
+  do {                                                                                 \
+    const auto _va = (a);                                                              \
+    const auto _vb = (b);                                                              \
+    if (!(_va == _vb))                                                                 \
+      ::harness::current().fail(__FILE__, __LINE__,                                    \
+                                std::string("CHECK_EQ failed: " #a " == " #b " (") +   \
+                                    ::harness::show(_va) + " vs " + ::harness::show(_vb) + ")"); \
+  } while (0)
+
+#define CHECK_NEAR(a, b, tol)                                                          \
+  do {                                                                                 \
+    const double _va = static_cast<double>(a);                                         \
+    const double _vb = static_cast<double>(b);                                         \
+    if (std::fabs(_va - _vb) > (tol))                                                  \
+      ::harness::current().fail(__FILE__, __LINE__,                                    \
+                                std::string("CHECK_NEAR failed: " #a " ~ " #b " (") +  \
+                                    ::harness::show(_va) + " vs " + ::harness::show(_vb) + ")"); \
+  } while (0)
+
+#define REQUIRE(cond)                                                                   \
+  do {                                                                                  \
+    if (!(cond)) {                                                                      \
+      ::harness::current().fail(__FILE__, __LINE__, "REQUIRE failed: " #cond);         \
+      throw ::harness::Abort{};                                                         \
+    }                                                                                   \
+  } while (0)
+
+/// The expression must throw a `PdfError` whose code is `expected`.
+#define EXPECT_ERROR(expr, expected)                                                       \
+  do {                                                                                     \
+    bool _threw = false;                                                                   \
+    try {                                                                                  \
+      (void)(expr);                                                                        \
+    } catch (const ::pdfcanvas::PdfError& _error) {                                        \
+      _threw = true;                                                                       \
+      if (_error.code() != (expected))                                                     \
+        ::harness::current().fail(                                                         \
+            __FILE__, __LINE__,                                                            \
+            std::string("EXPECT_ERROR: " #expr " threw ") +                                \
+                ::pdfcanvas::wireName(_error.code()) + " (" + _error.message() +           \
+                "), expected " + ::pdfcanvas::wireName(expected));                         \
+    }                                                                                      \
+    if (!_threw)                                                                           \
+      ::harness::current().fail(__FILE__, __LINE__,                                        \
+                                std::string("EXPECT_ERROR: " #expr " did not throw; expected ") + \
+                                    ::pdfcanvas::wireName(expected));                      \
+  } while (0)