basalt-win32 0.0.0-stage → 0.2.0

package/native/tests/test_win32_mounting.cpp

@@ -0,0 +1,757 @@
+// Tests for Win32MountingManager: does a stream of ShadowViewMutations produce
+// the view tree it describes?
+//
+// Deliberately the same nine questions `tests/test_mounting.cpp` asks of GTK
+// and `tests/test_appkit_mounting.mm` asks of AppKit, in the same order, with
+// the same tags and frames. All three managers share their walk, so most of
+// this is asking whether the sharing actually holds -- and the day it stops,
+// these fail here rather than in an app.
+//
+// One is new and is about this platform specifically:
+// `win32_delete_frees_the_view` exists because Windows is the first of the
+// three where the registry's ownership is written out rather than delegated to
+// a refcount or to ARC.
+
+#include "TestHarness.h"
+#include "TreeDump.h"
+
+#include "DirectWriteLayout.h"
+#include "Win32MountingManager.h"
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Color.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <sstream>
+#include <vector>
+
+using basalt::Win32MountingManager;
+using basalt::win32::RnWin32View;
+using facebook::react::ColorComponents;
+using facebook::react::LayoutMetrics;
+using facebook::react::MountingTransaction;
+using facebook::react::ShadowView;
+using facebook::react::ShadowViewMutation;
+using facebook::react::ShadowViewMutationList;
+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,
+                    float red = 0.0F,
+                    float green = 0.0F,
+                    float blue = 0.0F) {
+  auto props = std::make_shared<ViewProps>();
+  props->backgroundColor = facebook::react::colorFromComponents(
+      ColorComponents{.red = red, .green = green, .blue = blue, .alpha = 1.0F});
+
+  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 = props;
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+// Applies mutations synchronously. executeMount would post to the UI thread,
+// which a test has no message loop to pump -- though with no host installed
+// postToUiThread runs inline anyway, so this is about being explicit rather
+// than about avoiding a hang.
+void apply(Win32MountingManager &manager, ShadowViewMutationList &&mutations) {
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+}
+
+size_t childCount(const RnWin32View *view) {
+  return view->children().size();
+}
+
+// The tag of the nth child, or -1.
+int32_t childTagAt(const RnWin32View *view, size_t index) {
+  if (index >= view->children().size()) {
+    return -1;
+  }
+  return view->children()[index]->tag();
+}
+
+} // namespace
+
+TEST(win32_create_and_insert_builds_the_tree) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(10, 0, 0, 100, 50)));
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(11, 0, 60, 100, 50)));
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(kSurfaceId, makeView(10, 0, 0, 100, 50), 0));
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(kSurfaceId, makeView(11, 0, 60, 100, 50), 1));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(childCount(root), size_t{2});
+  EXPECT_EQ(childTagAt(root, 0), 10);
+  EXPECT_EQ(childTagAt(root, 1), 11);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_insert_honours_the_index) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList first;
+  first.push_back(ShadowViewMutation::CreateMutation(makeView(20, 0, 0, 10, 10)));
+  first.push_back(ShadowViewMutation::CreateMutation(makeView(21, 0, 0, 10, 10)));
+  first.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(20, 0, 0, 10, 10), 0));
+  first.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(21, 0, 0, 10, 10), 1));
+  apply(manager, std::move(first));
+
+  // An Insert's index counts positions in the parent's *final* child list, so
+  // this lands between the two. An append-only implementation passes every
+  // other test in this file.
+  ShadowViewMutationList second;
+  second.push_back(ShadowViewMutation::CreateMutation(makeView(22, 0, 0, 10, 10)));
+  second.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(22, 0, 0, 10, 10), 1));
+  apply(manager, std::move(second));
+
+  EXPECT_EQ(childCount(root), size_t{3});
+  EXPECT_EQ(childTagAt(root, 0), 20);
+  EXPECT_EQ(childTagAt(root, 1), 22);
+  EXPECT_EQ(childTagAt(root, 2), 21);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_remove_detaches_but_does_not_destroy) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(30, 0, 0, 10, 10)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(30, 0, 0, 10, 10), 0));
+  apply(manager, std::move(mutations));
+
+  ShadowViewMutationList removal;
+  removal.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, makeView(30, 0, 0, 10, 10), 0));
+  apply(manager, std::move(removal));
+
+  // A reparent is a Remove and an Insert with no Delete between them, so the
+  // view has to survive the gap -- and the registry is the only thing holding
+  // it. Asking the registry is the assertion: if Remove had destroyed it, this
+  // would be null or a dangling pointer.
+  EXPECT_EQ(childCount(root), size_t{0});
+  EXPECT(manager.viewForTag(30) != nullptr);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_update_changes_frame_without_reparenting) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(40, 0, 0, 100, 50)));
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(kSurfaceId, makeView(40, 0, 0, 100, 50), 0));
+  apply(manager, std::move(mutations));
+
+  ShadowViewMutationList update;
+  update.push_back(ShadowViewMutation::UpdateMutation(
+      makeView(40, 0, 0, 100, 50), makeView(40, 5, 6, 70, 30), kSurfaceId));
+  apply(manager, std::move(update));
+
+  RnWin32View *view = manager.viewForTag(40);
+  EXPECT(view != nullptr);
+  EXPECT_EQ(childCount(root), size_t{1});
+  EXPECT_NEAR(view->frame().x, 5.0, 0.001);
+  EXPECT_NEAR(view->frame().y, 6.0, 0.001);
+  EXPECT_NEAR(view->frame().width, 70.0, 0.001);
+  EXPECT_NEAR(view->frame().height, 30.0, 0.001);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_delete_removes_the_view_from_the_registry) {
+  Win32MountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(50, 0, 0, 10, 10)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(50, 0, 0, 10, 10), 0));
+  apply(manager, std::move(mutations));
+  EXPECT(manager.viewForTag(50) != nullptr);
+
+  // Fabric guarantees the Remove before the Delete, and this is that order.
+  ShadowViewMutationList teardown;
+  teardown.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, makeView(50, 0, 0, 10, 10), 0));
+  teardown.push_back(ShadowViewMutation::DeleteMutation(makeView(50, 0, 0, 10, 10)));
+  apply(manager, std::move(teardown));
+
+  EXPECT(manager.viewForTag(50) == nullptr);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_nested_children_are_parented_to_their_own_parent) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(60, 0, 0, 100, 100)));
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(61, 10, 10, 20, 20)));
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(kSurfaceId, makeView(60, 0, 0, 100, 100), 0));
+  // Parented to 60, not to the surface root.
+  mutations.push_back(ShadowViewMutation::InsertMutation(60, makeView(61, 10, 10, 20, 20), 0));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(childCount(root), size_t{1});
+  RnWin32View *middle = manager.viewForTag(60);
+  EXPECT(middle != nullptr);
+  EXPECT_EQ(childCount(middle), size_t{1});
+  EXPECT_EQ(childTagAt(middle, 0), 61);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_surface_root_is_reused_not_recreated) {
+  Win32MountingManager manager;
+  RnWin32View *first = manager.createSurfaceRoot(kSurfaceId);
+  RnWin32View *second = manager.createSurfaceRoot(kSurfaceId);
+
+  // In Fabric a SurfaceId *is* the root node's tag, and Fabric emits no Create
+  // for it -- the root shadow node is the base of every diff, so it must
+  // already exist when the first transaction arrives. Asking twice must not
+  // make two.
+  EXPECT(first == second);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_a_mutation_for_an_unknown_tag_is_survivable) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  // What a bug upstream, or a transaction racing a surface teardown, looks like
+  // from down here. It must not be fatal.
+  ShadowViewMutationList mutations;
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(kSurfaceId, makeView(999, 0, 0, 10, 10), 0));
+  mutations.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, makeView(998, 0, 0, 10, 10), 0));
+  mutations.push_back(ShadowViewMutation::DeleteMutation(makeView(997, 0, 0, 10, 10)));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(childCount(root), size_t{0});
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_props_reach_the_view_through_a_mutation) {
+  Win32MountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(
+      ShadowViewMutation::CreateMutation(makeView(70, 0, 0, 64, 32, 1.0F, 0.0F, 0.0F)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(
+      kSurfaceId, makeView(70, 0, 0, 64, 32, 1.0F, 0.0F, 0.0F), 0));
+  apply(manager, std::move(mutations));
+
+  // The whole trip: a ViewProps built here, through the walk, into the view's
+  // own state and out again as the dump the three hosts compare.
+  RnWin32View *view = manager.viewForTag(70);
+  EXPECT(view != nullptr);
+  EXPECT(view->hasBackgroundColor());
+  EXPECT_EQ(view->describeTree(), std::string("view tag=70 frame=(0,0 64x32) bg=#ff0000ff\n"));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(win32_has_component_matches_the_registered_descriptors) {
+  Win32MountingManager manager;
+
+  // Two statements of one fact, and when they disagree the registry wins:
+  // Fabric builds shadow nodes nothing can mount and the app renders blank
+  // rectangles rather than reporting anything. See ComponentRegistryWin32.cpp.
+  EXPECT(manager.hasComponent("View"));
+  EXPECT(manager.hasComponent("RootView"));
+  EXPECT(manager.hasComponent("Paragraph"));
+  EXPECT(manager.hasComponent("Image"));
+  EXPECT(manager.hasComponent("ScrollView"));
+  EXPECT(manager.hasComponent("TextInput"));
+  EXPECT(manager.hasComponent("ActivityIndicatorView"));
+  EXPECT(manager.hasComponent("Switch"));
+  EXPECT(manager.hasComponent("ModalHostView"));
+  EXPECT(manager.hasComponent("PullToRefreshView"));
+  // What React Native substitutes for a component nobody registered. Mounting
+  // it is what turns "nothing happens" into a view the tree dump can show.
+  EXPECT(manager.hasComponent("UnimplementedNativeView"));
+
+  // Claiming a component this host cannot mount is worse than admitting the
+  // gap. `ActivityIndicator` is here rather than above on purpose: the
+  // component React Native actually mounts is `ActivityIndicatorView`, and
+  // answering to the name a reader expects would be answering to a name
+  // nothing sends.
+  EXPECT(!manager.hasComponent("Slider"));
+  EXPECT(!manager.hasComponent("ActivityIndicator"));
+  EXPECT(!manager.hasComponent("SomethingNobodyHasHeardOf"));
+}
+
+// --- transformOrigin --------------------------------------------------------
+//
+// `resolveTransform` folds the origin into the matrix, and all three hosts
+// call it -- so this has been "passed through but never exercised" since it
+// was written. What makes it checkable without a display is that the anchor
+// is a claim about a point: scaling about the top-left must leave the
+// top-left corner exactly where it was.
+//
+// The hosts anchor a transform at the view's centre, which is what an
+// untouched `transformOrigin` means, so the matrix is in centre-relative
+// coordinates and the top-left corner is at (-w/2, -h/2).
+//
+// The same two tests are in the other two suites, with the same tags, for the
+// same reason the ones above are.
+
+namespace {
+
+ShadowView makeTransformed(Tag tag,
+                           float width,
+                           float height,
+                           facebook::react::Transform transform,
+                           facebook::react::TransformOrigin origin = {}) {
+  // Fresh props rather than a copy of makeView's: BaseViewProps has a deleted
+  // copy constructor at React Native 0.86, which is what a current Expo app
+  // installs. Copying compiled against main and broke the version an app
+  // actually has -- found by building a real create-expo-app, not here.
+  ShadowView view = makeView(tag, 0.0F, 0.0F, width, height);
+  auto props = std::make_shared<ViewProps>();
+  props->transform = transform;
+  props->transformOrigin = origin;
+  view.props = props;
+  return view;
+}
+
+} // namespace
+
+TEST(transform_origin_anchors_the_corner_it_names) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  using facebook::react::Transform;
+  using facebook::react::TransformOrigin;
+  using facebook::react::UnitType;
+  using facebook::react::ValueUnit;
+
+  // Doubled about the top-left of a 100x50 view.
+  TransformOrigin topLeft;
+  topLeft.xy = {ValueUnit(0.0F, UnitType::Point), ValueUnit(0.0F, UnitType::Point)};
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(
+      makeTransformed(30, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F), topLeft)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(
+      kSurfaceId,
+      makeTransformed(30, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F), topLeft),
+      0));
+  apply(manager, std::move(mutations));
+
+  const auto matrix = basalt::testing::transformIn(root->describeTree(), 30);
+  EXPECT_EQ(matrix[0], 2.0);
+  EXPECT_EQ(matrix[3], 2.0);
+
+  // The corner the origin names, in the centre-relative coordinates the
+  // matrix is written in, has to come back to itself: (-50,-25) scaled by two
+  // is (-100,-50), so the translation has to put 50 and 25 back.
+  const double cornerX = matrix[0] * -50.0 + matrix[2] * -25.0 + matrix[4];
+  const double cornerY = matrix[1] * -50.0 + matrix[3] * -25.0 + matrix[5];
+  EXPECT_EQ(cornerX, -50.0);
+  EXPECT_EQ(cornerY, -25.0);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// And with no origin set, the centre is the anchor -- which is the default
+// every host relies on, and the reason an unset origin must not be folded in
+// as (0,0).
+TEST(no_transform_origin_anchors_the_centre) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+
+  using facebook::react::Transform;
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(
+      makeTransformed(31, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F))));
+  mutations.push_back(ShadowViewMutation::InsertMutation(
+      kSurfaceId, makeTransformed(31, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F)), 0));
+  apply(manager, std::move(mutations));
+
+  const auto matrix = basalt::testing::transformIn(root->describeTree(), 31);
+  EXPECT_EQ(matrix[0], 2.0);
+  EXPECT_EQ(matrix[3], 2.0);
+  // No translation at all: the centre is already the anchor.
+  EXPECT_EQ(matrix[4], 0.0);
+  EXPECT_EQ(matrix[5], 0.0);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// ---------------------------------------------------------------------------
+// What a TextAttributes becomes on this platform: the case mapping and the
+// decoration flags.
+//
+// Here rather than in tests/test_win32_text.cpp because both need React
+// Native's TextAttributes, and that file is compiled into the toolkit-only
+// build as well. The pixels are its half; this is the translation.
+// ---------------------------------------------------------------------------
+namespace {
+
+facebook::react::TextAttributes withTransform(facebook::react::TextTransform transform) {
+  facebook::react::TextAttributes attributes;
+  attributes.textTransform = transform;
+  return attributes;
+}
+
+std::string transformed(facebook::react::TextTransform transform, const std::string &text) {
+  return basalt::win32::transformedFragmentText(withTransform(transform), text);
+}
+
+} // namespace
+
+TEST(win32_text_transform_maps_case) {
+  using facebook::react::TextTransform;
+
+  EXPECT_EQ(transformed(TextTransform::Uppercase, "hello there"), std::string("HELLO THERE"));
+  EXPECT_EQ(transformed(TextTransform::Lowercase, "HELLO THERE"), std::string("hello there"));
+
+  // Through LCMapStringEx rather than through `std::toupper`, which is what
+  // makes this work for anything but ASCII: a byte-wise map leaves an accented
+  // letter alone and looks right in English.
+  // Written as UTF-8 escapes rather than as the letters themselves, because
+  // this file carries no encoding declaration and MSVC without /utf-8 reads a
+  // literal's bytes as the machine's code page. The string is "creme brulee"
+  // with a grave, a circumflex and an acute on it.
+  EXPECT_EQ(transformed(TextTransform::Uppercase, "cr\xc3\xa8me br\xc3\xbbl\xc3\xa9" "e"),
+            std::string("CR\xc3\x88ME BR\xc3\x9bL\xc3\x89" "E"));
+
+
+  // React Native's own capitalize rule, from RCTAttributedTextUtils.mm and
+  // copied on all three hosts: split on single spaces, lowercase the word, and
+  // uppercase its first character unless it is a digit. So "iOS" becomes "Ios",
+  // which is surprising and is what the other platforms do.
+  EXPECT_EQ(transformed(TextTransform::Capitalize, "hello iOS world"),
+            std::string("Hello Ios World"));
+  EXPECT_EQ(transformed(TextTransform::Capitalize, "3rd place"), std::string("3rd Place"));
+  // Double spaces are kept, which falls out of splitting on single ones.
+  EXPECT_EQ(transformed(TextTransform::Capitalize, "a  b"), std::string("A  B"));
+
+  // No transform, and the empty string, both come back untouched.
+  facebook::react::TextAttributes plain;
+  EXPECT_EQ(basalt::win32::transformedFragmentText(plain, "Left Alone"),
+            std::string("Left Alone"));
+  EXPECT_EQ(transformed(TextTransform::Uppercase, ""), std::string(""));
+}
+
+// **Windows keeps the German sharp s where the other two hosts expand it.**
+// Measured on CI on 2026-10-09, which is the only Windows this repository has:
+// `LCMapStringEx` with `LCMAP_UPPERCASE | LCMAP_LINGUISTIC_CASING` maps it to
+// itself, so "Strasse" written with it uppercases to "STRA" + the sharp s +
+// "E", seven bytes. GLib's `g_utf8_strup` and NSString's `uppercaseString`
+// both answer "STRASSE", and so does every browser on Windows, because they go
+// through ICU rather than through the locale API.
+//
+// Asserted rather than tolerated, so that the day this host is changed the test
+// says so and the record gets updated with it.
+// backlog/platform-windows.md names the call that would close the gap:
+// `u_strToUpper`, from the ICU that Windows 10 1703 and later ship, which does
+// Unicode's full case mapping.
+TEST(win32_text_transform_keeps_the_sharp_s) {
+  const std::string mapped =
+      transformed(facebook::react::TextTransform::Uppercase, "Stra\xc3\x9f" "e");
+  EXPECT_EQ(mapped, std::string("STRA\xc3\x9f" "E"));
+  // Which is one byte longer than "STRASSE" is, and a byte shorter than the
+  // input: the sharp s is two bytes in UTF-8 and did not change.
+  EXPECT_EQ((int)mapped.size(), 7);
+}
+
+TEST(win32_a_decoration_reaches_the_style) {
+  using facebook::react::TextDecorationLineType;
+
+  facebook::react::TextAttributes attributes;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).underline);
+  EXPECT(!basalt::win32::buildTextStyle(attributes).strikethrough);
+
+  attributes.textDecorationLineType = TextDecorationLineType::Underline;
+  EXPECT(basalt::win32::buildTextStyle(attributes).underline);
+  EXPECT(!basalt::win32::buildTextStyle(attributes).strikethrough);
+
+  attributes.textDecorationLineType = TextDecorationLineType::Strikethrough;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).underline);
+  EXPECT(basalt::win32::buildTextStyle(attributes).strikethrough);
+
+  attributes.textDecorationLineType = TextDecorationLineType::UnderlineStrikethrough;
+  EXPECT(basalt::win32::buildTextStyle(attributes).underline);
+  EXPECT(basalt::win32::buildTextStyle(attributes).strikethrough);
+
+  // `None` is a line the app turned off, not an absent prop, and it draws
+  // nothing -- which core/TextDecorations.h answers for all three hosts.
+  attributes.textDecorationLineType = TextDecorationLineType::None;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).underline);
+  EXPECT(!basalt::win32::buildTextStyle(attributes).strikethrough);
+}
+
+// ---------------------------------------------------------------------------
+// writingDirection, fontVariant and a fragment's opacity, as they arrive.
+//
+// The pixels for the first are in tests/test_win32_text.cpp; these are the
+// translations, which need React Native's TextAttributes.
+// ---------------------------------------------------------------------------
+TEST(win32_a_writing_direction_reaches_the_style) {
+  using facebook::react::WritingDirection;
+
+  facebook::react::TextAttributes attributes;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).rightToLeft);
+
+  attributes.baseWritingDirection = WritingDirection::RightToLeft;
+  EXPECT(basalt::win32::buildTextStyle(attributes).rightToLeft);
+
+  attributes.baseWritingDirection = WritingDirection::LeftToRight;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).rightToLeft);
+
+  // `natural` is left-to-right here, as it is on the other two hosts for Latin
+  // text: DirectWrite takes a direction rather than deciding one from the
+  // string, so there is no third state to pass on.
+  attributes.baseWritingDirection = WritingDirection::Natural;
+  EXPECT(!basalt::win32::buildTextStyle(attributes).rightToLeft);
+}
+
+// `lineBreakMode`, which React Native's JavaScript spells `lineBreakModeIOS`:
+// whether a line that does not fit wraps or is cut, and where.
+//
+// The prop reached nothing here -- `RnTextStyle` had no field for it -- so a
+// `<Text lineBreakModeIOS="tail">` wrapped onto four lines on this host and cut
+// to one on the platform the prop is named after. What the style carries is
+// the mode; what DirectWrite does with it is in RnWin32TextLayout.cpp, which
+// turns wrapping off for the four that cut and trims the line.
+TEST(win32_a_line_break_mode_reaches_the_style) {
+  using basalt::win32::RnLineBreakMode;
+  using facebook::react::LineBreakMode;
+
+  facebook::react::TextAttributes attributes;
+  // Nothing asked for wraps between words, which is React Native's default and
+  // what every ordinary paragraph depends on.
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Word);
+
+  attributes.lineBreakMode = LineBreakMode::Word;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Word);
+  attributes.lineBreakMode = LineBreakMode::Char;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Char);
+  attributes.lineBreakMode = LineBreakMode::Clip;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Clip);
+  attributes.lineBreakMode = LineBreakMode::Tail;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Tail);
+
+  // Head and middle arrive as themselves even though DirectWrite cuts the end
+  // for both: the style says what the app asked for, so the host can say what
+  // it did with it rather than pretending the app asked for a tail.
+  attributes.lineBreakMode = LineBreakMode::Head;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Head);
+  attributes.lineBreakMode = LineBreakMode::Middle;
+  EXPECT(basalt::win32::buildTextStyle(attributes).lineBreakMode == RnLineBreakMode::Middle);
+}
+
+TEST(win32_an_alignment_keeps_start_and_end_relative) {
+  using basalt::win32::RnTextAlign;
+  using facebook::react::TextAlignment;
+
+  facebook::react::TextAttributes attributes;
+  // Nothing asked for is natural, not physical left: the difference only shows
+  // in a right-to-left paragraph, where it is the difference between the entry
+  // this closed and the bug it described.
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Natural);
+
+  attributes.alignment = TextAlignment::Left;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Left);
+  attributes.alignment = TextAlignment::Right;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Right);
+  attributes.alignment = TextAlignment::Center;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Center);
+  attributes.alignment = TextAlignment::Justified;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Justified);
+  attributes.alignment = TextAlignment::Natural;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Natural);
+#if BASALT_RN_MINOR >= 87
+  // `start` and `end` are resolved against the *layout* direction before they
+  // reach DirectWrite, which is what the fourth argument carries. Nothing
+  // passed is a left-to-right app, so they are the left and right edges.
+  attributes.alignment = TextAlignment::Start;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Left);
+  attributes.alignment = TextAlignment::End;
+  EXPECT(basalt::win32::buildTextStyle(attributes).align == RnTextAlign::Right);
+
+  // And the other way round on a mirrored desktop, for the same Latin text:
+  // this is the case DirectWrite's own LEADING and TRAILING get wrong, they
+  // being relative to the paragraph rather than to the app. See
+  // core/TextAlignments.h and backlog/text.md.
+  const basalt::TextDirections mirrored{.paragraph = false, .relative = true};
+  attributes.alignment = TextAlignment::Start;
+  EXPECT(basalt::win32::buildTextStyle(attributes, {}, std::nullopt, mirrored).align
+         == RnTextAlign::Right);
+  attributes.alignment = TextAlignment::End;
+  EXPECT(basalt::win32::buildTextStyle(attributes, {}, std::nullopt, mirrored).align
+         == RnTextAlign::Left);
+#endif
+}
+
+TEST(win32_font_variants_become_opentype_tags) {
+  using facebook::react::FontVariant;
+
+  facebook::react::TextAttributes attributes;
+  EXPECT(basalt::win32::buildTextStyle(attributes).fontFeatures.empty());
+
+  attributes.fontVariant = static_cast<FontVariant>(
+      static_cast<int>(FontVariant::SmallCaps) | static_cast<int>(FontVariant::TabularNums));
+  const auto features = basalt::win32::buildTextStyle(attributes).fontFeatures;
+  EXPECT_EQ((int)features.size(), 2);
+  // In core's order rather than the bitmask's, which is what makes this
+  // comparable with the GTK host's settings string.
+  EXPECT_EQ(features[0], std::string("smcp"));
+  EXPECT_EQ(features[1], std::string("tnum"));
+
+  // A stylistic alternate is `ssNN`, which is the case a table of tags gets
+  // wrong and core builds from the number instead.
+  attributes.fontVariant = FontVariant::StylisticSeven;
+  const auto alternate = basalt::win32::buildTextStyle(attributes).fontFeatures;
+  EXPECT_EQ((int)alternate.size(), 1);
+  EXPECT_EQ(alternate[0], std::string("ss07"));
+}
+
+TEST(win32_a_fragment_opacity_multiplies_the_alpha) {
+  facebook::react::TextAttributes attributes;
+  attributes.foregroundColor = facebook::react::colorFromComponents(
+      facebook::react::ColorComponents{1.0F, 0.0F, 0.0F, 1.0F});
+
+  // No opacity asked for: opaque, which is also what an unset colour is.
+  EXPECT_NEAR(basalt::win32::buildTextStyle(attributes).color[3], 1.0f, 0.01f);
+
+  attributes.opacity = 0.5;
+  const auto style = basalt::win32::buildTextStyle(attributes);
+  EXPECT_NEAR(style.color[3], 0.5f, 0.01f);
+  // And the channels are untouched: opacity is alpha, not a tint.
+  EXPECT_NEAR(style.color[0], 1.0f, 0.01f);
+  EXPECT_NEAR(style.color[1], 0.0f, 0.01f);
+
+  // Out of range is clamped, a stylesheet being able to ask for either.
+  attributes.opacity = 2.0;
+  EXPECT_NEAR(basalt::win32::buildTextStyle(attributes).color[3], 1.0f, 0.01f);
+  attributes.opacity = -1.0;
+  EXPECT_NEAR(basalt::win32::buildTextStyle(attributes).color[3], 0.0f, 0.01f);
+}
+
+// --- adjustsFontSizeToFit ----------------------------------------------------
+//
+// The search is core's and tested there; what these ask is the half that is
+// DirectWrite's -- that the ratio reaches the font sizes, that the fitted
+// paragraph actually fits, and that a paragraph which never asked is untouched.
+namespace {
+
+facebook::react::AttributedString fittingLabel(const std::string &text, float fontSize) {
+  facebook::react::TextAttributes attributes;
+  attributes.fontSize = fontSize;
+
+  facebook::react::AttributedString::Fragment fragment;
+  fragment.string = text;
+  fragment.textAttributes = attributes;
+
+  facebook::react::AttributedString string;
+  string.appendFragment(std::move(fragment));
+  return string;
+}
+
+} // namespace
+
+TEST(win32_adjusts_font_size_to_fit_shrinks_until_it_fits) {
+  const auto text = fittingLabel("Delete all of the messages", 32.0f);
+
+  facebook::react::ParagraphAttributes fitting;
+  fitting.adjustsFontSizeToFit = true;
+  const basalt::FontFit fit = basalt::win32::textFitScale(text, fitting, 200.0f, 40.0f);
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio < 1.0);
+
+  // And the fitted paragraph fits, measured through the same builder the host
+  // paints with.
+  const auto layout = basalt::win32::buildTextLayout(text, fitting, fit);
+  EXPECT(layout != nullptr);
+  if (layout == nullptr) {
+    return;
+  }
+  const basalt::win32::RnTextSize size = layout->measure(200.0f);
+  EXPECT(size.width <= 200.0f);
+  EXPECT(size.height <= 40.0f);
+}
+
+TEST(win32_a_paragraph_that_did_not_ask_is_not_shrunk) {
+  const auto text = fittingLabel("Delete all of the messages", 32.0f);
+  facebook::react::ParagraphAttributes plain;
+  EXPECT(!basalt::win32::textFitScale(text, plain, 200.0f, 40.0f).scales());
+
+  const auto layout = basalt::win32::buildTextLayout(text, plain);
+  EXPECT(layout != nullptr);
+  if (layout == nullptr) {
+    return;
+  }
+  // Wrapped and taller than the box, rather than shrunk into it.
+  EXPECT(layout->measure(200.0f).height > 40.0f);
+}
+
+TEST(win32_a_paragraph_that_already_fits_keeps_its_size) {
+  facebook::react::ParagraphAttributes fitting;
+  fitting.adjustsFontSizeToFit = true;
+  EXPECT(
+      !basalt::win32::textFitScale(fittingLabel("Hi", 16.0f), fitting, 300.0f, 100.0f).scales());
+}
+
+TEST(win32_the_minimum_font_size_stops_the_shrinking) {
+  facebook::react::ParagraphAttributes fitting;
+  fitting.adjustsFontSizeToFit = true;
+  fitting.minimumFontSize = 24.0f;
+  const basalt::FontFit fit = basalt::win32::textFitScale(
+      fittingLabel("Delete all of the messages", 32.0f), fitting, 60.0f, 30.0f);
+  EXPECT_NEAR(fit.apply(32.0), 24.0, 0.0001);
+
+  // Which is the size the style ends up with, this being where the ratio is
+  // applied.
+  facebook::react::TextAttributes attributes;
+  attributes.fontSize = 32.0;
+  EXPECT_NEAR(basalt::win32::buildTextStyle(attributes, fit).fontSize, 24.0f, 0.01f);
+}
+
+TEST(win32_a_line_limit_does_not_hide_the_overflow_from_the_search) {
+  // `numberOfLines` with `adjustsFontSizeToFit` is the pairing a button label
+  // is written with, and the reason the search measures the *untruncated*
+  // paragraph: a one-line limit makes a layout that fits any box by throwing
+  // text away.
+  facebook::react::ParagraphAttributes oneLine;
+  oneLine.adjustsFontSizeToFit = true;
+  oneLine.maximumNumberOfLines = 1;
+  const basalt::FontFit fit = basalt::win32::textFitScale(
+      fittingLabel("Delete all of the messages", 32.0f), oneLine, 200.0f, 40.0f);
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio < 1.0);
+}