basalt-core 0.0.0-rc5

package/native/tests/test_gestures.cpp

@@ -0,0 +1,331 @@
+// Tests for the gesture recognisers.
+//
+// Core's, so compiled into both platforms' suites: a pan is a pan whichever
+// toolkit reported the pointer.
+//
+// Driven through the registry rather than through the module, which is what
+// makes them possible at all -- the module hops to the UI thread, and a test
+// binary has no UI thread to hop to. The same reason keeps the long press out
+// of here: it activates from a timer, and `postDelayed` needs a run loop. What
+// is covered is everything decided by the pointer itself.
+
+#include "TestHarness.h"
+
+#include "Gestures.h"
+
+#include <sstream>
+#include <string>
+#include <initializer_list>
+#include <vector>
+
+namespace {
+
+struct Recorded {
+  std::string event;
+  int handlerTag{0};
+  int state{0};
+  int oldState{-1};
+  double translationX{0};
+  double translationY{0};
+};
+
+// A registry with nothing left over from the last test. The registry is a
+// process-wide singleton -- there is one pointer -- so each test starts by
+// dropping whatever the previous one attached.
+basalt::GestureRegistry &fresh(std::vector<Recorded> &recorded) {
+  auto &registry = basalt::gestures();
+  for (int tag = 1; tag <= 32; tag++) {
+    registry.drop(tag);
+  }
+  recorded.clear();
+  registry.setEmitter([&recorded](const std::string &event, folly::dynamic payload) {
+    Recorded entry;
+    entry.event = event;
+    entry.handlerTag = static_cast<int>(payload["handlerTag"].asDouble());
+    entry.state = static_cast<int>(payload["state"].asDouble());
+    if (const auto *old = payload.get_ptr("oldState"); old != nullptr) {
+      entry.oldState = static_cast<int>(old->asDouble());
+    }
+    if (const auto *tx = payload.get_ptr("translationX"); tx != nullptr) {
+      entry.translationX = tx->asDouble();
+    }
+    if (const auto *ty = payload.get_ptr("translationY"); ty != nullptr) {
+      entry.translationY = ty->asDouble();
+    }
+    recorded.push_back(entry);
+  });
+  return registry;
+}
+
+// The state changes one handler went through, as "2,4,5" -- readable in a
+// failure message, which a vector of ints is not.
+std::string statesFor(const std::vector<Recorded> &recorded, int handlerTag) {
+  std::ostringstream states;
+  bool first = true;
+  for (const auto &entry : recorded) {
+    if (entry.handlerTag == handlerTag && entry.event == "onGestureHandlerStateChange") {
+      if (!first) {
+        states << ",";
+      }
+      states << entry.state;
+      first = false;
+    }
+  }
+  return states.str();
+}
+
+int countOf(const std::vector<Recorded> &recorded, int handlerTag, const char *event) {
+  int count = 0;
+  for (const auto &entry : recorded) {
+    if (entry.handlerTag == handlerTag && entry.event == event) {
+      count++;
+    }
+  }
+  return count;
+}
+
+std::vector<basalt::HitView> chainOf(int tag, double originX = 0, double originY = 0) {
+  return {basalt::HitView{.tag = tag, .originX = originX, .originY = originY}};
+}
+
+// Spelled the same way statesFor() spells them, so an expectation reads as the
+// sequence it is.
+std::string states(std::initializer_list<int> values) {
+  std::ostringstream out;
+  bool first = true;
+  for (int value : values) {
+    if (!first) {
+      out << ",";
+    }
+    out << value;
+    first = false;
+  }
+  return out.str();
+}
+
+constexpr int kBegan = static_cast<int>(basalt::GestureState::Began);
+constexpr int kActive = static_cast<int>(basalt::GestureState::Active);
+constexpr int kEnd = static_cast<int>(basalt::GestureState::End);
+constexpr int kFailed = static_cast<int>(basalt::GestureState::Failed);
+constexpr int kCancelled = static_cast<int>(basalt::GestureState::Cancelled);
+
+} // namespace
+
+TEST(a_pan_begins_then_activates_once_it_has_moved) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 50, 50, 0);
+  // Under the default 10pt slop: still only BEGAN.
+  registry.pointerMove(54, 50, 16);
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan}));
+
+  registry.pointerMove(80, 50, 32);
+  registry.pointerUp(80, 50, 48);
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive, kEnd}));
+}
+
+TEST(a_pans_translation_is_measured_from_where_it_started) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 50, 50, 0);
+  registry.pointerMove(90, 70, 16);
+  registry.pointerMove(120, 90, 32);
+
+  // Not from the previous update: RNGH's translation is cumulative, and an app
+  // that adds it up frame by frame moves twice as far as the pointer did.
+  const Recorded &last = recorded.back();
+  EXPECT_EQ(last.event, std::string("onGestureHandlerEvent"));
+  EXPECT_EQ(static_cast<int>(last.translationX), 70);
+  EXPECT_EQ(static_cast<int>(last.translationY), 40);
+}
+
+TEST(a_tap_is_a_press_that_did_not_move) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("TapGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerUp(12, 11, 90);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive, kEnd}));
+}
+
+TEST(a_tap_fails_when_the_pointer_wanders) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("TapGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+  registry.pointerUp(200, 10, 80);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kFailed}));
+}
+
+TEST(a_tap_fails_when_it_is_held_too_long) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("TapGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerUp(10, 10, 5000);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kFailed}));
+}
+
+TEST(a_gesture_that_activates_cancels_the_others) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+  registry.create("TapGestureHandler", 2, folly::dynamic::object());
+  registry.attach(2, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive}));
+  // The tap had already failed on the slop check, which is the right answer for
+  // the wrong-looking reason: either way it must not be left at BEGAN.
+  const std::string tapStates = statesFor(recorded, 2);
+  EXPECT(tapStates == states({kBegan, kFailed}) || tapStates == states({kBegan, kCancelled}));
+}
+
+TEST(simultaneous_handlers_are_left_alone) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  // A second pan on the same view, declared simultaneous with the first. Both
+  // should activate; without the declaration the second would be cancelled.
+  folly::dynamic simultaneous = folly::dynamic::object("simultaneousHandlers",
+                                                       folly::dynamic::array(1));
+  registry.create("PanGestureHandler", 2, simultaneous);
+  registry.attach(2, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+  registry.pointerUp(200, 10, 80);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive, kEnd}));
+  EXPECT_EQ(statesFor(recorded, 2), states({kBegan, kActive, kEnd}));
+}
+
+TEST(a_handler_waits_for_the_one_it_was_told_to_wait_for) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+  registry.create("PanGestureHandler", 2,
+                  folly::dynamic::object("waitFor", folly::dynamic::array(1)));
+  registry.attach(2, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+
+  // 1 activated, which cancelled 2 -- and 2 never activated, because it was
+  // waiting for 1 to fail and 1 did the opposite.
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive}));
+  const std::string waiting = statesFor(recorded, 2);
+  EXPECT(waiting == states({kBegan, kFailed}) || waiting == states({kBegan, kCancelled}));
+}
+
+TEST(a_gesture_reaches_a_handler_on_an_ancestor) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  // Attached to the outer view, while the pointer lands on the inner one.
+  registry.attach(1, 200);
+
+  const std::vector<basalt::HitView> chain = {
+      basalt::HitView{.tag = 100, .originX = 30, .originY = 30},
+      basalt::HitView{.tag = 200, .originX = 10, .originY = 10},
+  };
+  registry.pointerDown(chain, 50, 50, 0);
+  registry.pointerMove(100, 50, 16);
+
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kActive}));
+}
+
+TEST(a_dropped_handler_stops_hearing_about_the_pointer) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+  registry.drop(1);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+
+  EXPECT_EQ(countOf(recorded, 1, "onGestureHandlerStateChange"), 0);
+  EXPECT(registry.empty());
+}
+
+TEST(a_handler_attached_to_nothing_is_never_offered_a_gesture) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  // No attach: the view tag is 0, which is not a view.
+
+  registry.pointerDown(chainOf(0), 10, 10, 0);
+  registry.pointerMove(200, 10, 40);
+
+  EXPECT_EQ(countOf(recorded, 1, "onGestureHandlerStateChange"), 0);
+  registry.drop(1);
+}
+
+TEST(a_gesture_that_cannot_happen_here_fails_rather_than_hanging) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  // Pinch needs a second finger, which a cursor does not have.
+  registry.create("PinchGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  registry.pointerDown(chainOf(100), 10, 10, 0);
+  registry.pointerMove(200, 200, 40);
+  registry.pointerUp(200, 200, 80);
+
+  // BEGAN then FAILED, never ACTIVE: an app's onBegin runs and its onStart does
+  // not, which is what "this platform cannot do that" should look like.
+  EXPECT_EQ(statesFor(recorded, 1), states({kBegan, kFailed}));
+}
+
+TEST(the_pointers_position_is_reported_relative_to_the_handlers_view) {
+  std::vector<Recorded> recorded;
+  auto &registry = fresh(recorded);
+  registry.create("PanGestureHandler", 1, folly::dynamic::object());
+  registry.attach(1, 100);
+
+  // The view sits at (40, 20) in the root, so a pointer at (100, 60) is at
+  // (60, 40) inside it.
+  registry.pointerDown(chainOf(100, 40, 20), 100, 60, 0);
+
+  bool checked = false;
+  for (const auto &entry : recorded) {
+    (void)entry;
+    checked = true;
+  }
+  EXPECT(checked);
+
+  // Read the payload directly for the one field the recorder does not keep.
+  registry.setEmitter([&checked](const std::string &, folly::dynamic payload) {
+    EXPECT_EQ(static_cast<int>(payload["x"].asDouble()), 80);
+    EXPECT_EQ(static_cast<int>(payload["y"].asDouble()), 40);
+    EXPECT_EQ(static_cast<int>(payload["absoluteX"].asDouble()), 120);
+    checked = true;
+  });
+  registry.pointerMove(120, 60, 16);
+  registry.pointerUp(120, 60, 32);
+}

package/native/tests/test_hover.cpp

@@ -0,0 +1,92 @@
+// Tests for the hover gate.
+//
+// Core's, so compiled into every platform's suite: which views a cursor is
+// inside is the toolkit's answer, and what to do about it is not.
+//
+// What is asserted here is small on purpose, because the hover *model* is
+// React Native's own -- `PointerEventsProcessor` turns a stream of moves into
+// enter, leave, over and out, and a host that also emits those gets every one
+// of them twice over. See the header of HoverTracker.h. What is left to this
+// project is deciding which moves are worth dispatching at all, and the case
+// worth testing is the one that is easy to get wrong: the move *after* the
+// cursor leaves everything that was listening.
+
+#include "TestHarness.h"
+
+#include "HoverTracker.h"
+
+#include <cstdint>
+#include <sstream>
+
+namespace {
+
+using basalt::HoverTracker;
+
+constexpr std::uint16_t kListening = basalt::HoverListenerEnter | basalt::HoverListenerLeave;
+constexpr std::uint16_t kSilent = basalt::HoverListenerNone;
+
+} // namespace
+
+TEST(hover_dispatches_a_move_over_a_view_that_listens) {
+  HoverTracker tracker;
+  EXPECT(tracker.admitMove(10, kListening));
+  // Every move while the cursor is over it, because React Native works out
+  // whether anything actually changed.
+  EXPECT(tracker.admitMove(10, kListening));
+  EXPECT(tracker.admitMove(11, kListening));
+}
+
+TEST(hover_dispatches_nothing_over_views_that_do_not) {
+  HoverTracker tracker;
+  // The reason the gate exists: a cursor crossing an app that uses no hover
+  // must not cost a trip into JavaScript per motion event.
+  EXPECT(!tracker.admitMove(10, kSilent));
+  EXPECT(!tracker.admitMove(11, kSilent));
+}
+
+TEST(hover_dispatches_one_last_move_after_leaving_a_listening_view) {
+  HoverTracker tracker;
+  EXPECT(tracker.admitMove(10, kListening));
+  // The cursor is now over something that listens to nothing. Suppressing this
+  // move would leave React Native holding a hover path it never hears is
+  // stale, and view 10 hovered for good -- so exactly one more goes through.
+  EXPECT(tracker.admitMove(11, kSilent));
+  EXPECT(!tracker.admitMove(12, kSilent));
+}
+
+TEST(hover_leaving_the_surface_names_the_view_a_move_was_dispatched_at) {
+  HoverTracker tracker;
+  EXPECT(tracker.admitMove(10, kListening));
+  // A leave is dispatched at whatever React Native was last told about; the
+  // processor reads it as the pointer being gone and unwinds the path itself.
+  EXPECT_EQ(tracker.admitLeave(), 10);
+  // And a second leave is not a second event.
+  EXPECT_EQ(tracker.admitLeave(), 0);
+}
+
+TEST(hover_leaving_without_ever_dispatching_is_nothing) {
+  HoverTracker tracker;
+  tracker.admitMove(10, kSilent);
+  // React Native has no path to unwind, so there is nothing to tell it.
+  EXPECT_EQ(tracker.admitLeave(), 0);
+}
+
+TEST(hover_forget_drops_the_state_without_naming_anything) {
+  HoverTracker tracker;
+  tracker.admitMove(10, kListening);
+  // For a surface teardown: the view is about to stop existing, and a leave
+  // dispatched at it would be a lookup of an emitter that is gone.
+  tracker.forget();
+  EXPECT_EQ(tracker.admitLeave(), 0);
+  EXPECT(!tracker.admitMove(11, kSilent));
+}
+
+TEST(hover_listeners_come_off_the_props_react_native_parsed) {
+  facebook::react::ViewEvents events{};
+  EXPECT_EQ(basalt::hoverListenersFrom(events), (std::uint16_t)basalt::HoverListenerNone);
+
+  events[facebook::react::ViewEvents::Offset::PointerEnter] = true;
+  events[facebook::react::ViewEvents::Offset::PointerOutCapture] = true;
+  EXPECT_EQ(basalt::hoverListenersFrom(events),
+            (std::uint16_t)(basalt::HoverListenerEnter | basalt::HoverListenerOutCapture));
+}

package/native/tests/test_image_cache.cpp

@@ -0,0 +1,109 @@
+// Which decoded image gets dropped, and when.
+//
+// The three hosts hold three unrelated texture types and none of them can be
+// described here, so what is tested is the decision rather than the pixels --
+// see core/ImageCache.h.
+
+#include "TestHarness.h"
+
+#include "ImageCache.h"
+
+#include <sstream>
+
+using basalt::ImageCachePolicy;
+
+TEST(image_cache_keeps_what_fits) {
+  ImageCachePolicy cache(1000);
+  EXPECT(cache.insert("a", 400).empty());
+  EXPECT(cache.insert("b", 400).empty());
+  EXPECT_EQ((long)cache.count(), 2L);
+  EXPECT_EQ((long)cache.bytes(), 800L);
+}
+
+TEST(image_cache_evicts_the_oldest_when_it_does_not) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 400);
+  cache.insert("b", 400);
+
+  const auto evicted = cache.insert("c", 400);
+  EXPECT_EQ((long)evicted.size(), 1L);
+  EXPECT(evicted[0] == "a");
+  EXPECT_EQ((long)cache.count(), 2L);
+  EXPECT_EQ((long)cache.bytes(), 800L);
+}
+
+// The whole reason for least-recently-*used* rather than least recently added:
+// scrolling back up should not re-decode the rows about to be on screen.
+TEST(image_cache_a_use_saves_an_entry) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 400);
+  cache.insert("b", 400);
+  cache.noteUse("a");
+
+  const auto evicted = cache.insert("c", 400);
+  EXPECT_EQ((long)evicted.size(), 1L);
+  // `b` is now the oldest, because `a` was touched after it went in.
+  EXPECT(evicted[0] == "b");
+}
+
+TEST(image_cache_evicts_as_many_as_it_takes) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 300);
+  cache.insert("b", 300);
+  cache.insert("c", 300);
+
+  const auto evicted = cache.insert("big", 900);
+  EXPECT_EQ((long)evicted.size(), 3L);
+  EXPECT(evicted[0] == "a");
+  EXPECT(evicted[2] == "c");
+  EXPECT_EQ((long)cache.count(), 1L);
+}
+
+// On screen and larger than the whole budget. Keeping it is wrong in one way
+// and evicting it is wrong in a worse one: it would be decoded again on the
+// next frame, and every frame after that.
+TEST(image_cache_keeps_an_image_larger_than_the_budget) {
+  ImageCachePolicy cache(1000);
+  const auto evicted = cache.insert("huge", 5000);
+  EXPECT(evicted.empty());
+  EXPECT_EQ((long)cache.count(), 1L);
+
+  // And the next insert clears it out rather than leaving both.
+  const auto next = cache.insert("small", 100);
+  EXPECT_EQ((long)next.size(), 1L);
+  EXPECT(next[0] == "huge");
+}
+
+TEST(image_cache_reinserting_replaces_rather_than_doubling) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 400);
+  cache.insert("a", 600);
+  EXPECT_EQ((long)cache.count(), 1L);
+  EXPECT_EQ((long)cache.bytes(), 600L);
+}
+
+TEST(image_cache_remove_and_clear_free_their_bytes) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 400);
+  cache.insert("b", 300);
+
+  cache.remove("a");
+  EXPECT_EQ((long)cache.count(), 1L);
+  EXPECT_EQ((long)cache.bytes(), 300L);
+
+  // Removing what is not there is not an error: a host may release an image
+  // this never saw.
+  cache.remove("nothing");
+  EXPECT_EQ((long)cache.count(), 1L);
+
+  cache.clear();
+  EXPECT_EQ((long)cache.count(), 0L);
+  EXPECT_EQ((long)cache.bytes(), 0L);
+}
+
+TEST(image_cache_a_use_of_something_absent_is_harmless) {
+  ImageCachePolicy cache(1000);
+  cache.insert("a", 400);
+  cache.noteUse("never-seen");
+  EXPECT_EQ((long)cache.count(), 1L);
+}

package/native/tests/test_js_runtime_access.cpp

@@ -0,0 +1,137 @@
+// The door to the JavaScript thread that a host leaves open.
+//
+// What is testable here is the decision -- is there a runner, does work reach
+// it, does clearing it stop the work -- and not the running, which needs a
+// runtime and a host. So the runner in these tests records what it was handed
+// rather than calling it: the point of the seam is that native code on some
+// other thread can post *without* knowing whether anyone is listening, and that
+// is exactly the part a test can pin down.
+//
+// The half that needs a runtime -- an event arriving at a JavaScript listener --
+// is proven by the harness scenario, the same division test_blobs.cpp makes.
+
+#include "TestHarness.h"
+
+#include "ExpoModules.h"
+#include "ExpoRuntime.h"
+#include "JsRuntimeAccess.h"
+
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace {
+
+// Restores the seam whatever a test does to it. Process-wide state that a later
+// test reads, exactly like the blob registry.
+struct RunnerFixture {
+  ~RunnerFixture() { basalt::setRuntimeRunner(nullptr); }
+};
+
+} // namespace
+
+TEST(without_a_host_there_is_nowhere_to_post) {
+  // The tests and the portability probe, and the answer has to be a reported
+  // false rather than a crash: a subprocess reader thread emitting into a
+  // process that never had a runtime is ordinary, not exceptional.
+  RunnerFixture fixture;
+  basalt::setRuntimeRunner(nullptr);
+
+  bool ran = false;
+  EXPECT(!basalt::runOnJsRuntime([&ran](facebook::jsi::Runtime &) { ran = true; }));
+  EXPECT(!ran);
+}
+
+TEST(work_reaches_the_runner_a_host_left) {
+  RunnerFixture fixture;
+  int posted = 0;
+  basalt::setRuntimeRunner([&posted](std::function<void(facebook::jsi::Runtime &)>) {
+    // Held rather than called: calling it needs a runtime. What is asserted is
+    // that it arrived.
+    posted++;
+  });
+
+  EXPECT(basalt::runOnJsRuntime([](facebook::jsi::Runtime &) {}));
+  EXPECT(basalt::runOnJsRuntime([](facebook::jsi::Runtime &) {}));
+  EXPECT_EQ(posted, 2);
+}
+
+TEST(clearing_the_runner_stops_the_posting) {
+  // The shutdown path: a host clears this before it destroys its ReactHost, so
+  // that work in flight from another thread does not reach a runtime that is
+  // being joined.
+  RunnerFixture fixture;
+  int posted = 0;
+  basalt::setRuntimeRunner([&posted](std::function<void(facebook::jsi::Runtime &)>) { posted++; });
+  EXPECT(basalt::runOnJsRuntime([](facebook::jsi::Runtime &) {}));
+
+  basalt::setRuntimeRunner(nullptr);
+  EXPECT(!basalt::runOnJsRuntime([](facebook::jsi::Runtime &) {}));
+  EXPECT_EQ(posted, 1);
+}
+
+TEST(an_expo_event_goes_through_the_same_door) {
+  // Which is the whole reason the door exists: an Expo module is handed no call
+  // invoker, so this is the only way it can emit.
+  //
+  // **Both builds, asked at runtime.** A build not pointed at an
+  // expo-modules-core has no Expo modules to emit on, and `emitExpoEvent` is
+  // then the documented no-op that answers false rather than a missing symbol.
+  // Asked through `hasExpoRuntime()` rather than `#ifdef BASALT_HAS_EXPO`
+  // because the define is added with `add_compile_definitions` in the core
+  // package's directory and a host's test target is a sibling, so the ifdef
+  // would read false in a suite where Expo is compiled in -- which is the wrong
+  // answer twice over. The first version of this test assumed the Expo build and
+  // passed on a machine with an app installed; CI, which has none, is where it
+  // failed.
+  RunnerFixture fixture;
+  basalt::setRuntimeRunner(nullptr);
+  EXPECT(!basalt::emitExpoEvent("KinoProcess", "onOutput", [](facebook::jsi::Runtime &,
+                                                             std::vector<facebook::jsi::Value> &) {
+  }));
+
+  int posted = 0;
+  basalt::setRuntimeRunner([&posted](std::function<void(facebook::jsi::Runtime &)>) { posted++; });
+  const bool emitted =
+      basalt::emitExpoEvent("KinoProcess", "onOutput", [](facebook::jsi::Runtime &,
+                                                          std::vector<facebook::jsi::Value> &) {});
+  if (basalt::hasExpoRuntime()) {
+    EXPECT(emitted);
+    EXPECT_EQ(posted, 1);
+  } else {
+    EXPECT(!emitted);
+    EXPECT_EQ(posted, 0);
+  }
+}
+
+TEST(the_call_invoker_over_the_runner_posts_and_says_it_cannot_wait) {
+  RunnerFixture fixture;
+  int posted = 0;
+  basalt::setRuntimeRunner([&posted](std::function<void(facebook::jsi::Runtime &)>) { posted++; });
+
+  const auto invoker = basalt::jsCallInvoker();
+  EXPECT(invoker != nullptr);
+  invoker->invokeAsync(facebook::react::CallFunc([](facebook::jsi::Runtime &) {}));
+  EXPECT_EQ(posted, 1);
+
+  // Rather than deadlocking, which is what a synchronous call from another
+  // thread into a busy runtime would do; see the header.
+  bool threw = false;
+  try {
+    invoker->invokeSync(facebook::react::CallFunc([](facebook::jsi::Runtime &) {}));
+  } catch (const std::logic_error &error) {
+    threw = true;
+    // Self-naming, so the message alone says which invoker and why.
+    EXPECT(std::string(error.what()).find("JsRuntimeAccess") != std::string::npos);
+  }
+  EXPECT(threw);
+  EXPECT_EQ(posted, 1);
+}
+
+TEST(the_same_invoker_survives_a_reload) {
+  // It holds nothing but the call to runOnJsRuntime, so a module that captured
+  // it before a Fast Refresh reload is still holding something that works --
+  // which is why one shared instance is safe to hand out.
+  EXPECT(basalt::jsCallInvoker() == basalt::jsCallInvoker());
+}