basalt-gtk 0.0.0-rc5

package/native/tests/test_skia_texture.cpp

@@ -0,0 +1,120 @@
+// The one thing between Skia and the screen on this host: a pixel format.
+//
+// gtk/GtkSkiaPeer.cpp renders a `<Canvas>` into an `SkImageInfo::MakeN32Premul`
+// surface and hands the bytes to `gdk_memory_texture_new` as
+// `GDK_MEMORY_B8G8R8A8_PREMULTIPLIED`. That is a claim about two libraries
+// agreeing on byte order, made in a comment, and it is the kind of claim that
+// fails silently: every red in the app comes out blue, nothing logs, nothing
+// crashes, and the bug looks like a Skia problem rather than a layout of bytes.
+//
+// So this draws known colours through the real path and reads them back. It
+// does not test the peer's plumbing -- registration, sizing, the weak
+// reference -- which needs a manager and therefore a runtime. It tests the
+// assumption underneath all of it.
+//
+// Only built with Skia; see the CMakeLists.
+
+#include "TestHarness.h"
+
+#include <gtk/gtk.h>
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkSurface.h"
+
+#include <cstdint>
+#include <sstream>
+#include <vector>
+
+namespace {
+
+// The peer's conversion, on its own so the test runs the same three calls.
+GdkTexture *toTexture(const sk_sp<SkSurface> &surface, int width, int height) {
+  SkPixmap pixels;
+  if (!surface->peekPixels(&pixels)) {
+    return nullptr;
+  }
+  GBytes *bytes = g_bytes_new(pixels.addr(), pixels.computeByteSize());
+  GdkTexture *texture = gdk_memory_texture_new(
+      width, height, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, bytes, pixels.rowBytes());
+  g_bytes_unref(bytes);
+  return texture;
+}
+
+struct Rgba {
+  uint8_t red = 0;
+  uint8_t green = 0;
+  uint8_t blue = 0;
+  uint8_t alpha = 0;
+};
+
+// One pixel out of a downloaded texture. `gdk_texture_download` writes
+// GDK_MEMORY_DEFAULT, which is premultiplied BGRA -- so this names the channels
+// rather than trusting the reader to remember which byte is which.
+Rgba pixelAt(const std::vector<uint8_t> &data, int stride, int x, int y) {
+  const uint8_t *p = data.data() + static_cast<size_t>(y) * stride + static_cast<size_t>(x) * 4;
+  Rgba out;
+  out.blue = p[0];
+  out.green = p[1];
+  out.red = p[2];
+  out.alpha = p[3];
+  return out;
+}
+
+} // namespace
+
+TEST(skia_a_canvas_surface_becomes_a_texture_of_the_same_colours) {
+  constexpr int kWidth = 4;
+  constexpr int kHeight = 2;
+
+  sk_sp<SkSurface> surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(kWidth, kHeight));
+  EXPECT(surface != nullptr);
+
+  SkCanvas *canvas = surface->getCanvas();
+  canvas->clear(SK_ColorTRANSPARENT);
+  SkPaint paint;
+  // Opaque red, and opaque blue beside it. Red alone would pass even if the
+  // two libraries disagreed and swapped it with blue -- there would be nothing
+  // to notice. Two channels that differ is what makes the swap visible.
+  paint.setColor(SK_ColorRED);
+  canvas->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), paint);
+  paint.setColor(SK_ColorBLUE);
+  canvas->drawRect(SkRect::MakeXYWH(1, 0, 1, 1), paint);
+
+  GdkTexture *texture = toTexture(surface, kWidth, kHeight);
+  EXPECT(texture != nullptr);
+  if (texture == nullptr) {
+    return;
+  }
+
+  EXPECT_EQ(gdk_texture_get_width(texture), kWidth);
+  EXPECT_EQ(gdk_texture_get_height(texture), kHeight);
+
+  const int stride = kWidth * 4;
+  std::vector<uint8_t> data(static_cast<size_t>(stride) * kHeight, 0);
+  gdk_texture_download(texture, data.data(), static_cast<gsize>(stride));
+
+  const Rgba red = pixelAt(data, stride, 0, 0);
+  EXPECT_EQ(static_cast<int>(red.red), 255);
+  EXPECT_EQ(static_cast<int>(red.green), 0);
+  EXPECT_EQ(static_cast<int>(red.blue), 0);
+  EXPECT_EQ(static_cast<int>(red.alpha), 255);
+
+  const Rgba blue = pixelAt(data, stride, 1, 0);
+  EXPECT_EQ(static_cast<int>(blue.red), 0);
+  EXPECT_EQ(static_cast<int>(blue.green), 0);
+  EXPECT_EQ(static_cast<int>(blue.blue), 255);
+  EXPECT_EQ(static_cast<int>(blue.alpha), 255);
+
+  // And the part nothing drew stays transparent, which is what lets a canvas
+  // sit over the view behind it rather than punching a black hole in it. The
+  // renderer clears to transparent before every picture for this reason.
+  const Rgba untouched = pixelAt(data, stride, 3, 1);
+  EXPECT_EQ(static_cast<int>(untouched.alpha), 0);
+
+  g_object_unref(texture);
+}

package/native/tests/test_text.cpp

@@ -0,0 +1,147 @@
+// Tests for the Pango text layer.
+//
+// These assert relationships rather than pixel counts. Font metrics differ
+// between machines and fontconfig setups, so "this string is 214.5 points wide"
+// is not a fact worth encoding; "constraining the width makes it wrap, and
+// wrapping makes it taller" is.
+
+#include "TestHarness.h"
+
+#include "PangoTextLayout.h"
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+
+#include <sstream>
+
+using facebook::react::AttributedString;
+using facebook::react::EllipsizeMode;
+using facebook::react::FontWeight;
+using facebook::react::ParagraphAttributes;
+using facebook::react::TextAttributes;
+
+namespace {
+
+AttributedString makeText(const std::string &text, float fontSize = 16.0F) {
+  TextAttributes attributes;
+  attributes.fontSize = fontSize;
+
+  AttributedString::Fragment fragment;
+  fragment.string = text;
+  fragment.textAttributes = attributes;
+
+  AttributedString result;
+  result.appendFragment(std::move(fragment));
+  return result;
+}
+
+struct Measured {
+  float width;
+  float height;
+};
+
+Measured measure(const AttributedString &text, const ParagraphAttributes &attributes, float maxWidth) {
+  PangoLayout *layout = basalt::buildTextLayout(text, attributes, maxWidth);
+  Measured measured{};
+  basalt::textLayoutSize(layout, &measured.width, &measured.height);
+  g_object_unref(layout);
+  return measured;
+}
+
+const char *kLongText =
+    "Yoga asked Pango how wide this paragraph wants to be, and Pango answered in "
+    "1024ths of a pixel, which is a unit nobody enjoys debugging.";
+
+} // namespace
+
+TEST(text_has_a_size) {
+  const auto measured = measure(makeText("Hello"), ParagraphAttributes{}, -1.0F);
+  EXPECT(measured.width > 0.0F);
+  EXPECT(measured.height > 0.0F);
+}
+
+TEST(larger_font_measures_larger) {
+  const auto small = measure(makeText("Hello", 12.0F), ParagraphAttributes{}, -1.0F);
+  const auto large = measure(makeText("Hello", 36.0F), ParagraphAttributes{}, -1.0F);
+
+  EXPECT(large.width > small.width);
+  EXPECT(large.height > small.height);
+}
+
+TEST(constraining_the_width_wraps_and_grows_taller) {
+  const auto unconstrained = measure(makeText(kLongText), ParagraphAttributes{}, -1.0F);
+  const auto wrapped = measure(makeText(kLongText), ParagraphAttributes{}, 200.0F);
+
+  // Wrapping is the whole point: narrower, and more than one line tall.
+  EXPECT(wrapped.width <= 200.5F);
+  EXPECT(wrapped.width < unconstrained.width);
+  EXPECT(wrapped.height > unconstrained.height);
+}
+
+TEST(number_of_lines_truncates) {
+  ParagraphAttributes oneLine;
+  oneLine.maximumNumberOfLines = 1;
+  oneLine.ellipsizeMode = EllipsizeMode::Tail;
+
+  const auto unlimited = measure(makeText(kLongText), ParagraphAttributes{}, 200.0F);
+  const auto limited = measure(makeText(kLongText), oneLine, 200.0F);
+
+  EXPECT(limited.height < unlimited.height);
+}
+
+TEST(default_ellipsize_mode_does_not_collapse_a_paragraph) {
+  // React Native defaults ellipsizeMode to Tail, and Pango ellipsizes to a
+  // *single line* when no height is set. Translating that default faithfully
+  // once turned every wrapping paragraph into one line, so this is a
+  // regression test for the bug rather than a test of Pango.
+  ParagraphAttributes defaults;
+  defaults.ellipsizeMode = EllipsizeMode::Tail;
+  EXPECT_EQ(defaults.maximumNumberOfLines, 0);
+
+  const auto measured = measure(makeText(kLongText), defaults, 200.0F);
+  const auto oneLineTall = measure(makeText("Hello"), ParagraphAttributes{}, -1.0F);
+
+  EXPECT(measured.height > oneLineTall.height * 1.5F);
+}
+
+TEST(font_size_is_absolute_not_points) {
+  // set_size would resolve against the context's resolution, making a fontSize
+  // of 100 render at about 133px on a 96dpi context. React Native's fontSize is
+  // in logical pixels, so a single line of 100pt text should be roughly 100
+  // tall, not a third taller again.
+  const auto measured = measure(makeText("Hg", 100.0F), ParagraphAttributes{}, -1.0F);
+
+  EXPECT(measured.height > 90.0F);
+  EXPECT(measured.height < 130.0F);
+}
+
+TEST(bold_is_wider_than_regular) {
+  TextAttributes regular;
+  regular.fontSize = 24.0F;
+
+  TextAttributes bold;
+  bold.fontSize = 24.0F;
+  bold.fontWeight = FontWeight::Bold;
+
+  const auto build = [](const TextAttributes &attributes) {
+    AttributedString::Fragment fragment;
+    fragment.string = "Weight";
+    fragment.textAttributes = attributes;
+    AttributedString text;
+    text.appendFragment(std::move(fragment));
+    return text;
+  };
+
+  const auto regularSize = measure(build(regular), ParagraphAttributes{}, -1.0F);
+  const auto boldSize = measure(build(bold), ParagraphAttributes{}, -1.0F);
+
+  // Not guaranteed by typography in general, but true of every sans-serif
+  // family a desktop ships as its default. If this fails the font description
+  // is probably not being applied at all.
+  EXPECT(boldSize.width >= regularSize.width);
+}
+
+TEST(empty_text_measures_to_zero_width) {
+  const auto measured = measure(makeText(""), ParagraphAttributes{}, -1.0F);
+  EXPECT_NEAR(measured.width, 0.0, 0.001);
+}