basalt-win32 0.0.0-rc5

package/native/tests/test_win32_scrollview.cpp

@@ -0,0 +1,385 @@
+// Tests for <ScrollView> on Windows: the offset, the clamp, the wheel's
+// routing, and the commands.
+//
+// The first tests any of the three desktops has for a scroll manager. GTK's and
+// AppKit's are exercised end to end by `scripts/compare_hosts.sh` running
+// `js/scroll.js` on both, which is a better test in every way except that it
+// needs two working desktops and this machine has one -- WSL2 will not start
+// here, so nothing else can check Windows against another host. So the
+// arithmetic gets tested directly instead.
+//
+// What is observable from here is narrower than what the manager does, and the
+// two limits are worth naming rather than working around. A ShadowView built by
+// hand has no ShadowNodeFamily, so `State::updateState` finds nothing to commit
+// into and the unthrottled state write-back cannot be asserted on. And an
+// EventEmitter built by hand has no EventDispatcher, so `onScroll` goes
+// nowhere. What is left is the part that decides where the content actually
+// sits: the clamp, the adoption, the routing and the commands.
+
+#include "TestHarness.h"
+
+#include "Win32MountingManager.h"
+#include "Win32ScrollView.h"
+// For hitTestTag: what a press would find, which is the other half of "the
+// scroll moved" and the half a scroll manager can get silently wrong.
+#include "Win32TouchDispatcher.h"
+
+#include <react/renderer/components/scrollview/ScrollViewProps.h>
+#include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+#include <react/renderer/components/scrollview/ScrollViewState.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <memory>
+
+using basalt::Win32MountingManager;
+using basalt::Win32ScrollViewManager;
+using basalt::win32::RnWin32View;
+using facebook::react::LayoutMetrics;
+using facebook::react::MountingTransaction;
+using facebook::react::Point;
+using facebook::react::Rect;
+using facebook::react::ScrollViewProps;
+using facebook::react::ScrollViewShadowNode;
+using facebook::react::ScrollViewState;
+using facebook::react::ShadowNodeFamily;
+using facebook::react::ShadowView;
+using facebook::react::ShadowViewMutation;
+using facebook::react::ShadowViewMutationList;
+using facebook::react::Size;
+using facebook::react::SurfaceId;
+using facebook::react::Tag;
+using facebook::react::TransactionTelemetry;
+using facebook::react::ViewProps;
+
+namespace {
+
+constexpr SurfaceId kSurfaceId = 1;
+
+ShadowView makeView(Tag tag, float x, float y, float width, float height) {
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = x, .y = y}, .size = {.width = width, .height = height}};
+
+  ShadowView view;
+  view.componentName = "View";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = std::make_shared<ViewProps>();
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+// A ScrollView whose viewport is `width`x`height` and whose content is
+// `contentWidth`x`contentHeight` -- which is the whole of what the manager
+// needs, because Yoga has already laid the content out at its full size by the
+// time a mutation arrives.
+ShadowView makeScrollView(Tag tag,
+                          float x,
+                          float y,
+                          float width,
+                          float height,
+                          float contentWidth,
+                          float contentHeight,
+                          bool scrollEnabled = true,
+                          Point initialOffset = Point{0, 0}) {
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = x, .y = y}, .size = {.width = width, .height = height}};
+
+  auto props = std::make_shared<ScrollViewProps>();
+  props->scrollEnabled = scrollEnabled;
+
+  ScrollViewState data;
+  data.contentOffset = initialOffset;
+  data.contentBoundingRect = Rect{.origin = {.x = 0, .y = 0},
+                                  .size = Size{.width = contentWidth, .height = contentHeight}};
+
+  ShadowView view;
+  view.componentName = "ScrollView";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = props;
+  view.layoutMetrics = metrics;
+  // An empty family: nothing can be committed back through it, which is what
+  // makes the state write-back unobservable here. See the file header.
+  view.state = std::make_shared<const ScrollViewShadowNode::ConcreteState>(
+      std::make_shared<const ScrollViewState>(data), ShadowNodeFamily::Weak{});
+  return view;
+}
+
+void apply(Win32MountingManager &manager, ShadowViewMutationList &&mutations) {
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+}
+
+// Creates and inserts one shadow view under `parent`, in a single transaction.
+void mount(Win32MountingManager &manager, Tag parent, const ShadowView &shadowView) {
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(shadowView));
+  mutations.push_back(ShadowViewMutation::InsertMutation(parent, shadowView, 0));
+  apply(manager, std::move(mutations));
+}
+
+// One notch's worth of pixels, in the direction a contentOffset grows.
+constexpr double kNotch = Win32ScrollViewManager::kWheelStepPixels;
+
+} // namespace
+
+// The offset is applied to the view, which is where painting and hit testing
+// both read it -- so this is the one assertion that covers all three.
+TEST(win32_a_wheel_scrolls_the_view_under_it) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+
+  EXPECT(manager.scrollAt(root, 200, 150, 0, 5 * kNotch));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 5 * kNotch, 0.01);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollX(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// The clamp, at both ends. Content 1000 tall in a 300 viewport can scroll 700
+// and no further, and nothing can scroll above the top.
+TEST(win32_the_offset_is_clamped_to_the_content) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+
+  manager.scrollAt(root, 200, 150, 0, 100 * kNotch);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 700.0, 0.01);
+
+  manager.scrollAt(root, 200, 150, 0, -100 * kNotch);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Content that fits does not scroll at all, but the wheel is still consumed --
+// matching AppKit, and matching what every desktop does: a list at its end must
+// not hand the wheel to whatever is behind it.
+TEST(win32_content_that_fits_consumes_the_wheel_and_does_not_move) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 200));
+
+  EXPECT(manager.scrollAt(root, 200, 150, 0, 5 * kNotch));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// scrollEnabled: false does not consume, so the wheel keeps going up the tree.
+TEST(win32_a_disabled_scroll_view_passes_the_wheel_on) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000, false));
+
+  EXPECT(!manager.scrollAt(root, 200, 150, 0, 5 * kNotch));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A wheel over a plain row scrolls the list containing it. GTK gets this from
+// attaching a controller per widget and AppKit from the responder chain; here
+// it is the parent walk in scrollAt, so it is worth an assertion.
+TEST(win32_a_wheel_over_a_child_scrolls_its_scroll_view) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+  mount(manager, 10, makeView(11, 0, 0, 400, 80));
+
+  // The point lands on the row, not on the ScrollView.
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 200, 40)), 11L);
+
+  EXPECT(manager.scrollAt(root, 200, 40, 0, 2 * kNotch));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 2 * kNotch, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A list inside a list scrolls the inner one. Innermost-first is the whole
+// reason the walk starts at the hit view rather than at the root.
+TEST(win32_a_nested_scroll_view_takes_the_wheel_first) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+  mount(manager, 10, makeScrollView(11, 0, 0, 400, 100, 400, 500));
+
+  EXPECT(manager.scrollAt(root, 200, 50, 0, 1 * kNotch));
+  EXPECT_NEAR(manager.viewForTag(11)->scrollY(), kNotch, 0.01);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Scrolling moves what a press lands on. `hitTest` adds the scroll offset back
+// on the way down, so this needs nothing from the scroll manager -- which is
+// exactly the claim being checked, because a list that scrolls correctly and
+// answers presses meant for the row above is the bug this prevents.
+TEST(win32_hit_testing_follows_the_scroll) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+  // Two rows, the second below the fold at y=400.
+  mount(manager, 10, makeView(12, 0, 400, 400, 100));
+  mount(manager, 10, makeView(11, 0, 0, 400, 100));
+
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 200, 50)), 11L);
+
+  manager.scrollAt(root, 200, 150, 0, 400);
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 200, 50)), 12L);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A ScrollView must clip whatever its props say. Its content is deliberately
+// larger than its frame, and without this it paints over its siblings.
+TEST(win32_a_scroll_view_clips_regardless_of_overflow) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+
+  EXPECT(manager.viewForTag(10)->clipsChildren());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// An offset already in the state is adopted rather than reset. That is what a
+// `contentOffset` prop looks like by the time it reaches here, and what a
+// surface that was suspended and remounted carries.
+TEST(win32_an_initial_offset_in_the_state_is_adopted) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000, true, Point{0, 120}));
+
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 120.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Content can shrink under a scrolled offset -- a list whose items were
+// filtered away. The re-clamp on every mutation is what stops the view from
+// being left showing empty space below its own content.
+TEST(win32_shrinking_content_pulls_the_offset_back) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+
+  manager.scrollAt(root, 200, 150, 0, 700);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 700.0, 0.01);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(
+      ShadowViewMutation::UpdateMutation(makeScrollView(10, 0, 0, 400, 300, 400, 1000),
+                                         makeScrollView(10, 0, 0, 400, 300, 400, 500),
+                                         kSurfaceId));
+  apply(manager, std::move(mutations));
+
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 200.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// scrollTo and scrollToEnd, which arrive through dispatchCommand. js/scroll.js
+// drives itself through a ref, so this is the path that file exercises and the
+// only one that needs no wheel.
+TEST(win32_scroll_to_and_scroll_to_end_move_the_offset) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+
+  manager.applyCommand(10, "scrollTo", folly::dynamic::array(0, 265, false));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 265.0, 0.01);
+
+  manager.applyCommand(10, "scrollToEnd", folly::dynamic::array(false));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 700.0, 0.01);
+
+  // scrollTo past the end is clamped like any other offset.
+  manager.applyCommand(10, "scrollTo", folly::dynamic::array(0, 5000, false));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 700.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A command for a tag that is not a ScrollView, and one for a tag that is gone.
+// Both are ordinary: a scrollTo can arrive after the surface that owned it was
+// torn down.
+TEST(win32_a_command_for_an_unknown_tag_is_survivable) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeView(10, 0, 0, 100, 100));
+
+  manager.applyCommand(10, "scrollTo", folly::dynamic::array(0, 100, false));
+  manager.applyCommand(999, "scrollTo", folly::dynamic::array(0, 100, false));
+  manager.applyCommand(10, "somethingElse", folly::dynamic::array());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// The entry has to go with the view. A wheel arriving after the ScrollView was
+// deleted must find nothing rather than a dangling RnWin32View pointer.
+TEST(win32_deleting_a_scroll_view_forgets_its_entry) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000));
+  EXPECT(manager.scrollAt(root, 200, 150, 0, kNotch));
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::RemoveMutation(
+      kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 400, 1000), 0));
+  mutations.push_back(
+      ShadowViewMutation::DeleteMutation(makeScrollView(10, 0, 0, 400, 300, 400, 1000)));
+  apply(manager, std::move(mutations));
+
+  EXPECT(manager.viewForTag(10) == nullptr);
+  EXPECT(!manager.scrollAt(root, 200, 150, 0, kNotch));
+  manager.applyCommand(10, "scrollTo", folly::dynamic::array(0, 100, false));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Nothing under the pointer, and no surface at all. The host reads the return
+// value to decide whether to leave the message to DefWindowProc, so "false"
+// here is the difference between a wheel over a non-scrolling app doing nothing
+// and doing nothing *and* being swallowed.
+TEST(win32_a_wheel_over_nothing_is_not_consumed) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeView(10, 0, 0, 100, 100));
+
+  EXPECT(!manager.scrollAt(root, 50, 50, 0, kNotch));
+  EXPECT(!manager.scrollAt(root, 5000, 5000, 0, kNotch));
+  EXPECT(!manager.scrollAt(nullptr, 50, 50, 0, kNotch));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Horizontal, which travels the same path with the other axis and is easy to
+// leave half-wired: WM_MOUSEHWHEEL is a separate message with the opposite
+// sign convention to WM_MOUSEWHEEL.
+TEST(win32_a_horizontal_wheel_scrolls_the_other_axis) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, makeScrollView(10, 0, 0, 400, 300, 1200, 300));
+
+  EXPECT(manager.scrollAt(root, 200, 150, 3 * kNotch, 0));
+  EXPECT_NEAR(manager.viewForTag(10)->scrollX(), 3 * kNotch, 0.01);
+  EXPECT_NEAR(manager.viewForTag(10)->scrollY(), 0.0, 0.01);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}

package/native/tests/test_win32_text.cpp

@@ -0,0 +1,258 @@
+// DirectWrite measurement, and where the glyphs land.
+//
+// The union of what tests/test_text.cpp asks of Pango and
+// tests/test_appkit_text.mm asks of Core Text. Two of them are regression tests
+// on the other platforms rather than general questions, and they are here
+// because the bug each describes is a bug any text engine can have:
+// `font_size_is_absolute_not_points`, and that a default ellipsize mode does
+// not collapse a wrapping paragraph.
+//
+// No React Native and no window: RnWin32TextLayout knows nothing about either.
+
+#include "TestHarness.h"
+
+#include "RnWin32TextLayout.h"
+#include "RnWin32View.h"
+#include "Win32Snapshot.h"
+
+#include <memory>
+#include <sstream>
+#include <string>
+
+using basalt::win32::RnTextAlign;
+using basalt::win32::RnTextSize;
+using basalt::win32::RnTextStyle;
+using basalt::win32::RnWin32TextLayout;
+using basalt::win32::RnWin32View;
+
+namespace {
+
+std::shared_ptr<RnWin32TextLayout> paragraph(const std::string &text,
+                                             float fontSize = 16.0f,
+                                             int maxLines = 0) {
+  RnTextStyle style;
+  style.fontSize = fontSize;
+  return RnWin32TextLayout::create(text, style, maxLines);
+}
+
+constexpr const char *kLongText =
+    "The quick brown fox jumps over the lazy dog, and then does it again "
+    "because once was never going to be enough for a wrapping test.";
+
+} // namespace
+
+TEST(text_has_a_size) {
+  auto layout = paragraph("Hello");
+  EXPECT(layout != nullptr);
+
+  const RnTextSize size = layout->measure(-1.0f);
+  EXPECT(size.width > 0.0f);
+  EXPECT(size.height > 0.0f);
+}
+
+TEST(empty_text_measures_to_zero_width) {
+  auto layout = paragraph("");
+  EXPECT(layout != nullptr);
+
+  const RnTextSize size = layout->measure(-1.0f);
+  EXPECT_NEAR(size.width, 0.0, 0.5);
+  // A height, though: an empty line still occupies one. Both other platforms
+  // report the same, and a zero-height empty <Text> would collapse a layout
+  // that was relying on it to hold a row open.
+  EXPECT(size.height > 0.0f);
+}
+
+TEST(larger_font_measures_larger) {
+  const RnTextSize small = paragraph("Hello", 12.0f)->measure(-1.0f);
+  const RnTextSize large = paragraph("Hello", 36.0f)->measure(-1.0f);
+
+  EXPECT(large.width > small.width);
+  EXPECT(large.height > small.height);
+}
+
+TEST(font_size_is_absolute_not_points) {
+  // The bug this guards against, in the shape Pango had it: a size interpreted
+  // as points and resolved against 96dpi renders about a third larger than
+  // asked. React Native's fontSize is in density-independent pixels and every
+  // coordinate here lives in that same space, so a hundred-unit font must
+  // produce a line in the neighbourhood of a hundred units -- not a hundred and
+  // thirty-three, and certainly not a hundred and seventy-seven.
+  //
+  // The bounds are wide because a font's natural line spacing is its own
+  // business; what they exclude is a multiply by 96/72.
+  const RnTextSize size = paragraph("Hg", 100.0f)->measure(-1.0f);
+  EXPECT(size.height >= 90.0f);
+  EXPECT(size.height < 160.0f);
+}
+
+TEST(constraining_the_width_wraps_and_grows_taller) {
+  auto layout = paragraph(kLongText);
+
+  const RnTextSize wide = layout->measure(-1.0f);
+  const RnTextSize narrow = layout->measure(200.0f);
+
+  EXPECT(narrow.width <= 200.5f);
+  EXPECT(narrow.width < wide.width);
+  EXPECT(narrow.height > wide.height);
+}
+
+TEST(number_of_lines_truncates) {
+  auto unlimited = paragraph(kLongText, 16.0f, 0);
+  auto limited = paragraph(kLongText, 16.0f, 2);
+
+  const RnTextSize full = unlimited->measure(200.0f);
+  const RnTextSize clipped = limited->measure(200.0f);
+
+  EXPECT(clipped.height < full.height);
+  EXPECT(clipped.height > 0.0f);
+}
+
+TEST(a_line_limit_that_fits_is_not_truncated) {
+  // Five lines allowed and the paragraph needs fewer, so the limit must change
+  // nothing at all -- not the height, and not the text.
+  auto unlimited = paragraph("Short", 16.0f, 0);
+  auto limited = paragraph("Short", 16.0f, 5);
+
+  EXPECT_NEAR(limited->measure(-1.0f).height, unlimited->measure(-1.0f).height, 0.01);
+  EXPECT_NEAR(limited->measure(-1.0f).width, unlimited->measure(-1.0f).width, 0.01);
+}
+
+TEST(default_ellipsize_mode_does_not_collapse_a_paragraph) {
+  // Pango's trap, stated as a test: React Native's ellipsizeMode defaults to
+  // tail, and translating that faithfully by switching ellipsization on without
+  // also setting a height collapsed every wrapping paragraph to one line. A
+  // paragraph with no line limit must wrap to as many lines as it needs.
+  auto layout = paragraph(kLongText);
+
+  const RnTextSize oneLine = paragraph("Hello")->measure(-1.0f);
+  const RnTextSize wrapped = layout->measure(200.0f);
+
+  EXPECT(wrapped.height > oneLine.height * 2.0f);
+}
+
+TEST(bold_is_wider_than_regular) {
+  RnTextStyle regular;
+  regular.fontSize = 24.0f;
+  RnTextStyle bold = regular;
+  bold.bold = true;
+
+  const RnTextSize plain =
+      RnWin32TextLayout::create("Handgloves", regular, 0)->measure(-1.0f);
+  const RnTextSize heavy = RnWin32TextLayout::create("Handgloves", bold, 0)->measure(-1.0f);
+
+  EXPECT(heavy.width > plain.width);
+}
+
+TEST(alignment_does_not_change_the_measured_size) {
+  RnTextStyle left;
+  left.fontSize = 16.0f;
+  RnTextStyle centred = left;
+  centred.align = RnTextAlign::Center;
+
+  const RnTextSize a = RnWin32TextLayout::create(kLongText, left, 0)->measure(300.0f);
+  const RnTextSize b = RnWin32TextLayout::create(kLongText, centred, 0)->measure(300.0f);
+
+  // Alignment moves glyphs inside the box. It does not change how big the box
+  // has to be, and a platform that reported otherwise would make Yoga lay out
+  // a centred paragraph differently from a left-aligned one.
+  EXPECT_NEAR(a.width, b.width, 0.01);
+  EXPECT_NEAR(a.height, b.height, 0.01);
+}
+
+TEST(text_is_reported_in_the_tree) {
+  auto view = std::make_unique<RnWin32View>(7);
+  view->setFrame(0, 0, 200, 40);
+  view->setTextLayout(paragraph("Hi \"there\"\nyou"));
+
+  // Escaped the way the GTK side escapes it, so a quote or a newline keeps the
+  // dump to one line per view.
+  EXPECT_EQ(view->describeTree(),
+            std::string("view tag=7 frame=(0,0 200x40) text=\"Hi \\\"there\\\"\\nyou\"\n"));
+}
+
+TEST(text_draws_where_the_alignment_says) {
+  // The assertion the other two hosts cannot make: not that alignment was set,
+  // but that the glyphs moved. A left-aligned line puts ink near the left edge
+  // and none near the right; a right-aligned one does the opposite.
+  const auto inkColumns = [](RnTextAlign align) {
+    RnTextStyle style;
+    style.fontSize = 24.0f;
+    style.align = align;
+
+    auto root = std::make_unique<RnWin32View>(1);
+    root->setFrame(0, 0, 300, 40);
+    root->setTextLayout(RnWin32TextLayout::create("Ill", style, 0));
+
+    const basalt::win32::RnPixels pixels = basalt::win32::renderToPixels(*root);
+    int left = 0;
+    int right = 0;
+    for (unsigned y = 0; y < pixels.height(); y++) {
+      for (unsigned x = 0; x < 60; x++) {
+        if (pixels.at(x, y).alpha > 32) {
+          left++;
+        }
+        if (pixels.at(pixels.width() - 1 - x, y).alpha > 32) {
+          right++;
+        }
+      }
+    }
+    return std::pair<int, int>{left, right};
+  };
+
+  const auto [leftInkWhenLeft, rightInkWhenLeft] = inkColumns(RnTextAlign::Left);
+  EXPECT(leftInkWhenLeft > 0);
+  EXPECT_EQ(rightInkWhenLeft, 0);
+
+  const auto [leftInkWhenRight, rightInkWhenRight] = inkColumns(RnTextAlign::Right);
+  EXPECT_EQ(leftInkWhenRight, 0);
+  EXPECT(rightInkWhenRight > 0);
+}
+
+TEST(each_run_draws_in_its_own_colour) {
+  // `Hello <Text style={{color:'red'}}>world</Text>` is two runs of one
+  // paragraph, and DirectWrite carries colour as a *drawing effect* rather than
+  // as a range attribute -- so a layout built the obvious way renders the whole
+  // paragraph in the first run's colour. Both other desktops get this from
+  // their attributed string for free, which is why the gap here lasted as long
+  // as it did.
+  //
+  // Ink rather than an exact pixel: where a glyph lands depends on the font,
+  // and what is being asked is only which colours appear at all.
+  RnTextStyle red;
+  red.fontSize = 32.0f;
+  red.color[0] = 1.0f;
+  red.color[1] = 0.0f;
+  red.color[2] = 0.0f;
+
+  RnTextStyle blue = red;
+  blue.color[0] = 0.0f;
+  blue.color[2] = 1.0f;
+
+  auto root = std::make_unique<RnWin32View>(1);
+  root->setFrame(0, 0, 400, 60);
+  root->setTextLayout(RnWin32TextLayout::createFromRuns(
+      {basalt::win32::RnTextRun{"IIII", red}, basalt::win32::RnTextRun{"IIII", blue}}, 0));
+
+  const basalt::win32::RnPixels pixels = basalt::win32::renderToPixels(*root);
+  EXPECT(!pixels.empty());
+
+  int reddish = 0;
+  int bluish = 0;
+  for (unsigned y = 0; y < pixels.height(); y++) {
+    for (unsigned x = 0; x < pixels.width(); x++) {
+      const auto pixel = pixels.at(x, y);
+      if (pixel.alpha < 128) {
+        continue;
+      }
+      if (pixel.red > pixel.blue + 64) {
+        reddish++;
+      }
+      if (pixel.blue > pixel.red + 64) {
+        bluish++;
+      }
+    }
+  }
+
+  EXPECT(reddish > 0);
+  EXPECT(bluish > 0);
+}