basalt-core 0.0.0-rc5 → 0.1.0

package/native/tests/test_action_sheet.cpp

@@ -0,0 +1,157 @@
+// The menu an action sheet becomes, and reading an answer back out of it.
+//
+// All of the interesting behaviour is the index arithmetic, which is why it is a
+// function rather than part of the module: `ActionSheetIOS` numbers the array it
+// passed, a menu index counts every entry including the title and the message,
+// and getting that wrong means an app runs the wrong choice -- the quietest
+// possible bug, because every index is a valid index.
+//
+// What is asserted here and nowhere else: a dismissal is not an option, a
+// header cannot be chosen, and the offset is exactly the number of entries the
+// title and message took.
+
+#include "TestHarness.h"
+
+#include "ActionSheet.h"
+
+#include <sstream>
+#include <string>
+
+using basalt::ActionSheetMenu;
+using basalt::ActionSheetRequest;
+using basalt::actionSheetChoice;
+using basalt::actionSheetMenu;
+
+namespace {
+
+ActionSheetRequest threeOptions() {
+  ActionSheetRequest request;
+  request.options = {"Save", "Discard", "Cancel"};
+  request.cancelIndex = 2;
+  return request;
+}
+
+} // namespace
+
+TEST(action_sheet_options_with_no_title_start_at_the_top) {
+  const ActionSheetRequest request = threeOptions();
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT_EQ(menu.offset, 0);
+  EXPECT_EQ((long)menu.menu.entries.size(), 3L);
+  EXPECT_EQ(menu.menu.entries[0].label, std::string("Save"));
+  // Negative is "wherever the pointer is", which is what a sheet with no anchor
+  // wants and what MenuRequest already means by it.
+  EXPECT(menu.menu.x < 0.0);
+  EXPECT(menu.menu.y < 0.0);
+}
+
+TEST(action_sheet_a_title_and_a_message_are_disabled_entries_above_a_separator) {
+  ActionSheetRequest request = threeOptions();
+  request.title = "Unsaved changes";
+  request.message = "Three files have not been written";
+
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT_EQ(menu.offset, 3);
+  EXPECT_EQ((long)menu.menu.entries.size(), 6L);
+  EXPECT_EQ(menu.menu.entries[0].label, std::string("Unsaved changes"));
+  EXPECT(!menu.menu.entries[0].enabled);
+  EXPECT(!menu.menu.entries[1].enabled);
+  EXPECT(menu.menu.entries[2].isSeparator());
+  EXPECT_EQ(menu.menu.entries[3].label, std::string("Save"));
+  EXPECT(menu.menu.entries[3].enabled);
+}
+
+TEST(action_sheet_a_message_alone_still_takes_a_separator) {
+  ActionSheetRequest request = threeOptions();
+  request.message = "Three files have not been written";
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT_EQ(menu.offset, 2);
+  EXPECT(menu.menu.entries[1].isSeparator());
+}
+
+TEST(action_sheet_disabled_indices_grey_the_option_they_name) {
+  ActionSheetRequest request = threeOptions();
+  request.disabledIndices = {1};
+  request.title = "Unsaved changes";
+
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  // Offset 2: a title and its separator. The disabled option is the app's
+  // index 1, which is this menu's index 3.
+  EXPECT_EQ(menu.offset, 2);
+  EXPECT(menu.menu.entries[2].enabled);
+  EXPECT(!menu.menu.entries[3].enabled);
+  EXPECT(menu.menu.entries[4].enabled);
+}
+
+TEST(action_sheet_an_option_chosen_is_the_apps_own_index) {
+  ActionSheetRequest request = threeOptions();
+  request.title = "Unsaved changes";
+  const ActionSheetMenu menu = actionSheetMenu(request);
+
+  // A title and its separator, so menu index 2 is the first option -- which the
+  // app knows as 0. This is the whole reason the offset is carried rather than
+  // recomputed, and the arithmetic is the one thing here that can be silently
+  // wrong: every index is a valid index.
+  EXPECT_EQ(menu.offset, 2);
+  EXPECT(actionSheetChoice(request, menu, 2).has_value());
+  EXPECT_EQ(*actionSheetChoice(request, menu, 2), 0);
+  EXPECT_EQ(*actionSheetChoice(request, menu, 4), 2);
+  // One past the last option, which the menu does not have.
+  EXPECT(!actionSheetChoice(request, menu, 5).has_value());
+}
+
+TEST(action_sheet_a_header_is_not_a_choice) {
+  ActionSheetRequest request = threeOptions();
+  request.title = "Unsaved changes";
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  // A person cannot click a disabled entry and a script cannot either, but the
+  // arithmetic has to refuse it on its own: index 0 minus an offset of 2 is not
+  // an option, and reporting -2 to an app would be worse than reporting nothing.
+  EXPECT(!actionSheetChoice(request, menu, 0).has_value());
+  EXPECT(!actionSheetChoice(request, menu, 1).has_value());
+}
+
+TEST(action_sheet_an_index_past_the_end_is_not_a_choice) {
+  const ActionSheetRequest request = threeOptions();
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT(!actionSheetChoice(request, menu, 3).has_value());
+  EXPECT(!actionSheetChoice(request, menu, 99).has_value());
+}
+
+TEST(action_sheet_a_dismissal_is_the_cancel_choice_when_there_is_one) {
+  // The one place this platform answers something iOS does not. Escape closing
+  // a menu is ordinary where an iPad popover being tapped away is not, and an
+  // app that named a cancel choice has already said what to do with it.
+  const ActionSheetRequest request = threeOptions();
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT(actionSheetChoice(request, menu, -1).has_value());
+  EXPECT_EQ(*actionSheetChoice(request, menu, -1), 2);
+}
+
+TEST(action_sheet_a_dismissal_with_no_cancel_choice_reports_nothing) {
+  // Nothing rather than -1: `UIAlertController` calls the callback from a
+  // button's handler, so a sheet that goes away without one calls nothing, and
+  // an app never has to understand an index that is not an index.
+  ActionSheetRequest request = threeOptions();
+  request.cancelIndex = -1;
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT(!actionSheetChoice(request, menu, -1).has_value());
+}
+
+TEST(action_sheet_a_cancel_index_the_options_do_not_have_reports_nothing) {
+  // An app that passed a stale index. Reporting it would be reporting an index
+  // into an array that is too short, which is a crash in somebody's handler.
+  ActionSheetRequest request = threeOptions();
+  request.cancelIndex = 7;
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT(!actionSheetChoice(request, menu, -1).has_value());
+}
+
+TEST(action_sheet_an_anchor_puts_the_menu_where_the_caller_said) {
+  ActionSheetRequest request = threeOptions();
+  request.x = 120.0;
+  request.y = 240.0;
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  EXPECT_NEAR(menu.menu.x, 120.0, 0.01);
+  EXPECT_NEAR(menu.menu.y, 240.0, 0.01);
+}

package/native/tests/test_app_state.cpp

@@ -0,0 +1,60 @@
+// What `AppState.currentState` says, which was the empty string on every host
+// until 2026-10-10. See core/AppStateHost.h.
+
+#include "TestHarness.h"
+
+#include "AppStateHost.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+using basalt::AppStateKind;
+using basalt::appStateFor;
+using basalt::appStateName;
+
+TEST(app_state_is_the_two_facts_a_desktop_has) {
+  EXPECT(appStateFor(true, true) == AppStateKind::Active);
+  // Visible and not frontmost: iOS's `inactive` is a transition, and the
+  // desktop analogue is another window being in front -- which is the same
+  // thing an app uses it for.
+  EXPECT(appStateFor(false, true) == AppStateKind::Inactive);
+  // Invisible wins over focused: a minimised window that still holds focus is
+  // not something an app should treat as frontmost.
+  EXPECT(appStateFor(true, false) == AppStateKind::Background);
+  EXPECT(appStateFor(false, false) == AppStateKind::Background);
+}
+
+TEST(app_state_names_are_react_natives_own) {
+  EXPECT(std::string(appStateName(AppStateKind::Active)) == "active");
+  EXPECT(std::string(appStateName(AppStateKind::Inactive)) == "inactive");
+  EXPECT(std::string(appStateName(AppStateKind::Background)) == "background");
+}
+
+// An application that has drawn a window is active, which is what an app
+// reading `currentState` before any event arrives should be told. Upstream
+// answers the empty string, which is not one of React Native's own states.
+TEST(app_state_starts_active) {
+  EXPECT(basalt::currentAppState() == AppStateKind::Active);
+}
+
+TEST(app_state_tells_the_listener_only_when_it_changes) {
+  std::vector<AppStateKind> seen;
+  basalt::setAppStateListener([&seen](AppStateKind state) { seen.push_back(state); });
+
+  basalt::notifyAppState(AppStateKind::Active);  // already active
+  basalt::notifyAppState(AppStateKind::Inactive);
+  basalt::notifyAppState(AppStateKind::Inactive);
+  basalt::notifyAppState(AppStateKind::Background);
+  basalt::notifyAppState(AppStateKind::Active);
+
+  EXPECT_EQ((long)seen.size(), 3L);
+  EXPECT(seen[0] == AppStateKind::Inactive);
+  EXPECT(seen[1] == AppStateKind::Background);
+  EXPECT(seen[2] == AppStateKind::Active);
+
+  // And the state is readable without a listener, which is where
+  // `getCurrentAppState` reads it.
+  EXPECT(basalt::currentAppState() == AppStateKind::Active);
+  basalt::setAppStateListener(nullptr);
+}

package/native/tests/test_background_layers.cpp

@@ -0,0 +1,281 @@
+// Where a background image goes and how it tiles. See core/BackgroundLayers.h.
+//
+// Every number is specified and every wrong answer still paints a gradient, so
+// these are the spec's own cases: percentages against the area rather than the
+// image, the far edges against the space the image leaves, `round` changing the
+// size before anything tiles, and `space` changing the step and the anchor but
+// not the size.
+//
+// The areas are deliberately different throughout -- a 100x100 border box with a
+// 10pt border, so the padding box is (10,10,80,80) -- because an implementation
+// that used one for both is the mistake this file exists to catch, and it is
+// invisible on a view with no border.
+
+#include "TestHarness.h"
+
+#include "BackgroundLayers.h"
+
+#include <sstream>
+
+using basalt::BackgroundArea;
+using basalt::BackgroundLayer;
+using basalt::resolveBackgroundLayer;
+using facebook::react::BackgroundPosition;
+using facebook::react::BackgroundRepeat;
+using facebook::react::BackgroundRepeatStyle;
+using facebook::react::BackgroundSize;
+using facebook::react::BackgroundSizeLengthPercentage;
+using facebook::react::UnitType;
+using facebook::react::ValueUnit;
+
+namespace {
+
+const BackgroundArea kPainting{0.0F, 0.0F, 100.0F, 100.0F};
+const BackgroundArea kPositioning{10.0F, 10.0F, 80.0F, 80.0F};
+
+// React Native's defaults, which are what an app that sets none of the three
+// props sends: auto size, the top left corner, and repeat in both axes.
+BackgroundSize autoSize() { return BackgroundSizeLengthPercentage{}; }
+
+BackgroundSize sized(float x, UnitType xUnit, float y, UnitType yUnit) {
+  BackgroundSizeLengthPercentage size;
+  size.x = ValueUnit{x, xUnit};
+  size.y = ValueUnit{y, yUnit};
+  return size;
+}
+
+BackgroundPosition at(float x, UnitType xUnit, float y, UnitType yUnit) {
+  BackgroundPosition position;
+  position.left = ValueUnit{x, xUnit};
+  position.top = ValueUnit{y, yUnit};
+  return position;
+}
+
+BackgroundRepeat repeating(BackgroundRepeatStyle x, BackgroundRepeatStyle y) {
+  BackgroundRepeat repeat;
+  repeat.x = x;
+  repeat.y = y;
+  return repeat;
+}
+
+bool near(float a, float b) { return std::fabs(a - b) < 0.01F; }
+
+} // namespace
+
+// The defaults, which is the case every view with a gradient and nothing else
+// goes through. The image fills the *padding* box, not the border box, which is
+// the difference from what this platform drew before the props were read.
+TEST(background_the_defaults_fill_the_padding_box) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning, kPainting, autoSize(), BackgroundPosition{}, BackgroundRepeat{});
+
+  EXPECT(near(layer.width, 80.0F));
+  EXPECT(near(layer.height, 80.0F));
+  // Repeat is React Native's default, so the tile is the image and the pattern
+  // is backed up far enough to cover the border box it is clipped to.
+  EXPECT(layer.repeatsX);
+  EXPECT(layer.repeatsY);
+  EXPECT(near(layer.tileWidth, 80.0F));
+  EXPECT(near(layer.tileHeight, 80.0F));
+  EXPECT(near(layer.tileX, -70.0F));
+  EXPECT(near(layer.tileY, -70.0F));
+  // The image is drawn at the tile's origin, the tile being the image itself.
+  EXPECT(near(layer.x, layer.tileX));
+  EXPECT(near(layer.y, layer.tileY));
+}
+
+// A size in points and a size in percent, where the percentage is of the
+// positioning area and not of the painting area: 50% of an 80pt padding box is
+// 40, where 50% of the 100pt border box would be 50.
+TEST(background_a_size_resolves_against_the_positioning_area) {
+  const BackgroundLayer points = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(30.0F, UnitType::Point, 20.0F, UnitType::Point),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::NoRepeat, BackgroundRepeatStyle::NoRepeat));
+  EXPECT(near(points.width, 30.0F));
+  EXPECT(near(points.height, 20.0F));
+
+  const BackgroundLayer percent = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(50.0F, UnitType::Percent, 25.0F, UnitType::Percent),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::NoRepeat, BackgroundRepeatStyle::NoRepeat));
+  EXPECT(near(percent.width, 40.0F));
+  EXPECT(near(percent.height, 20.0F));
+}
+
+// `cover` and `contain` come to the area, which is what CSS says for an image
+// with no intrinsic size -- a gradient -- and is what iOS does with them.
+TEST(background_cover_and_contain_are_the_area_for_a_gradient) {
+  for (const auto keyword :
+       {facebook::react::BackgroundSizeKeyword::Cover, facebook::react::BackgroundSizeKeyword::Contain}) {
+    const BackgroundLayer layer = resolveBackgroundLayer(
+        kPositioning, kPainting, keyword, BackgroundPosition{}, BackgroundRepeat{});
+    EXPECT(near(layer.width, 80.0F));
+    EXPECT(near(layer.height, 80.0F));
+  }
+}
+
+// The position, against the space the image leaves rather than the whole area.
+// A 30pt image in an 80pt area has 50pt of slack, so 50% of it is 25 -- not 40.
+TEST(background_a_position_resolves_against_the_space_the_image_leaves) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(30.0F, UnitType::Point, 30.0F, UnitType::Point),
+      at(50.0F, UnitType::Percent, 100.0F, UnitType::Percent),
+      repeating(BackgroundRepeatStyle::NoRepeat, BackgroundRepeatStyle::NoRepeat));
+
+  EXPECT(near(layer.x, 10.0F + 25.0F));
+  // 100% of the slack is flush with the far edge of the padding box.
+  EXPECT(near(layer.y, 10.0F + 50.0F));
+}
+
+// The far edges are not the near ones. `right: 25%` is a quarter of the slack in
+// from the right, which is three quarters along, and an implementation that
+// resolved both the same way would be right exactly half the time.
+TEST(background_the_far_edges_are_measured_from_the_far_side) {
+  BackgroundPosition position;
+  position.right = ValueUnit{25.0F, UnitType::Percent};
+  position.bottom = ValueUnit{10.0F, UnitType::Point};
+
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(40.0F, UnitType::Point, 40.0F, UnitType::Point),
+      position,
+      repeating(BackgroundRepeatStyle::NoRepeat, BackgroundRepeatStyle::NoRepeat));
+
+  // 40pt of slack, a quarter of it from the right: 10 + 30.
+  EXPECT(near(layer.x, 40.0F));
+  // 10pt in from the bottom of the padding box: 10 + 40 - 10.
+  EXPECT(near(layer.y, 40.0F));
+}
+
+// `no-repeat` leaves the tile as the painting area, so a host that repeats in
+// both axes at once draws it exactly once.
+TEST(background_no_repeat_is_one_tile_over_the_painting_area) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(30.0F, UnitType::Point, 30.0F, UnitType::Point),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::NoRepeat, BackgroundRepeatStyle::NoRepeat));
+
+  EXPECT(!layer.repeatsX);
+  EXPECT(!layer.repeatsY);
+  EXPECT(near(layer.tileX, 0.0F));
+  EXPECT(near(layer.tileY, 0.0F));
+  EXPECT(near(layer.tileWidth, 100.0F));
+  EXPECT(near(layer.tileHeight, 100.0F));
+  // And the image stays where the position put it.
+  EXPECT(near(layer.x, 10.0F));
+  EXPECT(near(layer.y, 10.0F));
+}
+
+// One axis each way, which is `repeat-x`: the tile spans the painting area
+// downwards and steps by the image's width across.
+TEST(background_one_axis_can_repeat_while_the_other_does_not) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(20.0F, UnitType::Point, 20.0F, UnitType::Point),
+      at(0.0F, UnitType::Point, 30.0F, UnitType::Point),
+      repeating(BackgroundRepeatStyle::Repeat, BackgroundRepeatStyle::NoRepeat));
+
+  EXPECT(layer.repeatsX);
+  EXPECT(!layer.repeatsY);
+  EXPECT(near(layer.tileWidth, 20.0F));
+  EXPECT(near(layer.tileHeight, 100.0F));
+  // Backed up to cover the border box: 10 - 20 is -10.
+  EXPECT(near(layer.tileX, -10.0F));
+  EXPECT(near(layer.tileY, 0.0F));
+  // The row sits where the position put it, inside the tile.
+  EXPECT(near(layer.y, 40.0F));
+}
+
+// `round` divides the area into a whole number of tiles before anything else
+// happens, because it changes the size: 30pt into 80pt is 2.67 tiles, so the
+// nearest whole number is 3 and the tile becomes 26.67.
+TEST(background_round_divides_the_area_into_whole_tiles) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(30.0F, UnitType::Point, 30.0F, UnitType::Point),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::Round, BackgroundRepeatStyle::Round));
+
+  EXPECT(near(layer.width, 80.0F / 3.0F));
+  EXPECT(near(layer.height, 80.0F / 3.0F));
+  // And it tiles by that size, with no gap: `round` is `repeat` with the size
+  // adjusted.
+  EXPECT(near(layer.tileWidth, layer.width));
+  EXPECT(layer.repeatsX);
+
+  // A size that already divides the area is left alone, which is the branch that
+  // stops a division by a remainder of zero turning into a wrong size.
+  const BackgroundLayer exact = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(40.0F, UnitType::Point, 40.0F, UnitType::Point),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::Round, BackgroundRepeatStyle::Round));
+  EXPECT(near(exact.width, 40.0F));
+}
+
+// `space` keeps the size and shares the slack between the tiles, and the first
+// tile is flush with the area rather than where the position asked: 30pt into
+// 80pt fits twice with 20pt left over, so the step is 50.
+TEST(background_space_shares_the_slack_between_tiles) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(30.0F, UnitType::Point, 30.0F, UnitType::Point),
+      at(50.0F, UnitType::Percent, 50.0F, UnitType::Percent),
+      repeating(BackgroundRepeatStyle::Space, BackgroundRepeatStyle::Space));
+
+  EXPECT(near(layer.width, 30.0F));
+  EXPECT(near(layer.tileWidth, 50.0F));
+  EXPECT(layer.repeatsX);
+  // Anchored on the area, not on the position: 10 backed up by one step is -40.
+  EXPECT(near(layer.tileX, -40.0F));
+  EXPECT(near(layer.x, layer.tileX));
+}
+
+// `space` with one tile has no slack to share, so it stops repeating -- which is
+// the case that would otherwise divide by zero.
+TEST(background_space_with_one_tile_does_not_repeat) {
+  const BackgroundLayer layer = resolveBackgroundLayer(
+      kPositioning,
+      kPainting,
+      sized(60.0F, UnitType::Point, 60.0F, UnitType::Point),
+      BackgroundPosition{},
+      repeating(BackgroundRepeatStyle::Space, BackgroundRepeatStyle::Space));
+
+  EXPECT(!layer.repeatsX);
+  EXPECT(!layer.repeatsY);
+  EXPECT(near(layer.width, 60.0F));
+  EXPECT(near(layer.x, 10.0F));
+}
+
+// Nothing to paint, which both hosts have to be told rather than left to divide
+// by it: a view mid-layout has no size at all.
+TEST(background_an_empty_area_is_nothing_to_paint) {
+  const BackgroundArea nothing{0.0F, 0.0F, 0.0F, 0.0F};
+  EXPECT(resolveBackgroundLayer(nothing, kPainting, autoSize(), BackgroundPosition{},
+                                BackgroundRepeat{})
+             .empty());
+  EXPECT(resolveBackgroundLayer(kPositioning, nothing, autoSize(), BackgroundPosition{},
+                                BackgroundRepeat{})
+             .empty());
+  // And a size of zero, which a stylesheet can ask for.
+  EXPECT(resolveBackgroundLayer(kPositioning,
+                                kPainting,
+                                sized(0.0F, UnitType::Point, 10.0F, UnitType::Point),
+                                BackgroundPosition{},
+                                BackgroundRepeat{})
+             .empty());
+}

package/native/tests/test_blend_modes.cpp

@@ -0,0 +1,79 @@
+// The `mixBlendMode` keyword table, against React Native's own parser.
+//
+// core/BlendModes.h is seventeen lines of switch, which is seventeen chances to
+// return the wrong neighbour's name -- and a wrong name is not a build error on
+// either host: it is a view that blends with the wrong mode, or stops blending.
+//
+// So the assertion is a round trip rather than a list compared with itself.
+// React Native parses these keywords with `blendModeFromString`, which is what
+// turns the app's style into the enum in the first place, so feeding the name
+// back through it has to give the value it came from. Nothing in this test
+// agrees with the table by construction.
+
+#include "TestHarness.h"
+
+#include "BlendModes.h"
+
+#include <set>
+#include <sstream>
+#include <string>
+
+using facebook::react::BlendMode;
+using facebook::react::blendModeFromString;
+
+namespace {
+
+// The enum is dense and PlusLighter is its last member, which is what makes a
+// loop over it legitimate: a mode added upstream lands inside this range and the
+// count below is what notices.
+constexpr int kModeCount = static_cast<int>(BlendMode::PlusLighter) + 1;
+
+} // namespace
+
+TEST(blend_modes_every_mode_round_trips_through_react_natives_parser) {
+  for (int i = 0; i < kModeCount; i++) {
+    const BlendMode mode = static_cast<BlendMode>(i);
+    const char *name = basalt::blendModeName(mode);
+    if (mode == BlendMode::Normal) {
+      // `normal` is the default and asks for nothing, so it crosses as nothing.
+      EXPECT(name == nullptr);
+      continue;
+    }
+    EXPECT(name != nullptr);
+    if (name == nullptr) {
+      continue;
+    }
+    const std::optional<BlendMode> parsed = blendModeFromString(name);
+    EXPECT(parsed.has_value());
+    EXPECT(parsed.has_value() && *parsed == mode);
+  }
+}
+
+// And no two modes share a name, which the round trip above would catch only if
+// the parser were injective -- it is, but this says the thing directly, and it is
+// the failure a copy-paste in a sixteen-line table actually produces.
+TEST(blend_modes_no_two_modes_share_a_name) {
+  std::set<std::string> seen;
+  int named = 0;
+  for (int i = 0; i < kModeCount; i++) {
+    const char *name = basalt::blendModeName(static_cast<BlendMode>(i));
+    if (name == nullptr) {
+      continue;
+    }
+    named++;
+    seen.insert(name);
+  }
+  EXPECT_EQ(named, kModeCount - 1);
+  EXPECT_EQ(static_cast<int>(seen.size()), named);
+}
+
+// The count, so that a mode added upstream is a failing test here rather than a
+// view that silently does not blend. CSS has sixteen separable and non-separable
+// blend modes plus `normal`, and React Native carries all seventeen.
+TEST(blend_modes_there_are_seventeen_of_them) {
+  EXPECT_EQ(kModeCount, 17);
+  // The ends of the enum, so a reordering upstream is not silently fine either.
+  EXPECT(basalt::blendModeName(BlendMode::Multiply) != nullptr);
+  EXPECT(std::string(basalt::blendModeName(BlendMode::Multiply)) == "multiply");
+  EXPECT(std::string(basalt::blendModeName(BlendMode::PlusLighter)) == "plus-lighter");
+}

package/native/tests/test_blobs.cpp

@@ -5,7 +5,7 @@
 //
 // What is *not* tested here is the module: createFromParts and readAsText take
 // jsi values, which need a runtime, and the thing worth proving about them --
-// that a Blob round-trips through JavaScript -- is proven by js/blob.js running
+// that a Blob round-trips through JavaScript -- is proven by e2e/blob.js running
 // on both hosts. This covers the half underneath, where an off-by-one lives.
 
 #include "TestHarness.h"