basalt-core 0.0.0-rc5

package/native/tests/test_scroll_indicator.cpp

@@ -0,0 +1,149 @@
+// Where a scrollbar's thumb goes. Arithmetic, so it can be asserted without a
+// display -- which matters more here than usual, because a scrollbar is pure
+// paint and paint is what these hosts cannot otherwise check.
+
+#include "TestHarness.h"
+
+#include "ScrollIndicator.h"
+
+#include <sstream>
+
+using basalt::kScrollIndicatorInset;
+using basalt::kScrollIndicatorMinimumLength;
+using basalt::ScrollIndicator;
+using basalt::scrollIndicatorFor;
+
+namespace {
+
+TEST(indicator_content_that_fits_has_none) {
+  // A scrollbar for content that cannot scroll is noise, and every list shorter
+  // than its container would otherwise grow one.
+  EXPECT(!scrollIndicatorFor(400, 400, 0).visible);
+  EXPECT(!scrollIndicatorFor(400, 120, 0).visible);
+}
+
+TEST(indicator_a_long_list_gets_a_short_thumb) {
+  // The thumb is the visible fraction: a quarter on screen, a quarter of the
+  // track.
+  const ScrollIndicator indicator = scrollIndicatorFor(400, 1600, 0);
+  EXPECT(indicator.visible);
+  const double track = 400 - 2 * kScrollIndicatorInset;
+  EXPECT(indicator.length > track * 0.24);
+  EXPECT(indicator.length < track * 0.26);
+}
+
+TEST(indicator_a_very_long_list_still_has_a_grabbable_thumb) {
+  // Without a floor this is under a pixel, which stops reading as a position.
+  const ScrollIndicator indicator = scrollIndicatorFor(400, 400000, 0);
+  EXPECT_EQ(indicator.length, kScrollIndicatorMinimumLength);
+}
+
+TEST(indicator_at_the_top_it_sits_at_the_top) {
+  const ScrollIndicator indicator = scrollIndicatorFor(400, 1600, 0);
+  EXPECT_EQ(indicator.offset, kScrollIndicatorInset);
+}
+
+TEST(indicator_at_the_bottom_it_sits_at_the_bottom) {
+  // The end of the track, not past it: the thumb's far edge lands on the inset.
+  const ScrollIndicator indicator = scrollIndicatorFor(400, 1600, 1200);
+  const double track = 400 - 2 * kScrollIndicatorInset;
+  EXPECT_EQ(indicator.offset + indicator.length, kScrollIndicatorInset + track);
+}
+
+TEST(indicator_halfway_is_halfway) {
+  const ScrollIndicator indicator = scrollIndicatorFor(400, 1600, 600);
+  const double track = 400 - 2 * kScrollIndicatorInset;
+  const double expected = kScrollIndicatorInset + 0.5 * (track - indicator.length);
+  EXPECT_EQ(indicator.offset, expected);
+}
+
+TEST(indicator_an_overscroll_does_not_move_it_past_the_ends) {
+  // An elastic overscroll goes negative at the top and past the end at the
+  // bottom. A thumb that vanished there would flicker at exactly the moment
+  // somebody is looking at it.
+  const ScrollIndicator above = scrollIndicatorFor(400, 1600, -80);
+  EXPECT(above.visible);
+  EXPECT_EQ(above.offset, kScrollIndicatorInset);
+
+  const ScrollIndicator below = scrollIndicatorFor(400, 1600, 1600);
+  const double track = 400 - 2 * kScrollIndicatorInset;
+  EXPECT_EQ(below.offset + below.length, kScrollIndicatorInset + track);
+}
+
+TEST(indicator_a_container_of_nothing_has_none) {
+  // A view that has not been laid out yet, which happens on the first mount.
+  EXPECT(!scrollIndicatorFor(0, 1600, 0).visible);
+}
+
+} // namespace
+
+// --------------------------------------------------------------------------
+// Insets
+// --------------------------------------------------------------------------
+//
+// The two kinds do different jobs, and the tests are separate for that reason:
+// `contentInset` changes how far there is to go, and `scrollIndicatorInsets`
+// changes only where the bar is drawn.
+
+TEST(indicator_a_content_inset_leaves_room_at_the_top) {
+  // 100 of container, 400 of content, and 50 more to pull into above it. At the
+  // very top the offset is -50, and the thumb belongs at the start of the track.
+  const auto top =
+      basalt::scrollIndicatorFor(100.0, 400.0, -50.0, basalt::ScrollAxisInsets{50.0, 0.0});
+  EXPECT(top.visible);
+  EXPECT_NEAR(top.offset, basalt::kScrollIndicatorInset, 0.001);
+
+  // And at the bottom it still ends at the end.
+  const auto bottom =
+      basalt::scrollIndicatorFor(100.0, 400.0, 300.0, basalt::ScrollAxisInsets{50.0, 0.0});
+  EXPECT_NEAR(bottom.offset + bottom.length, 100.0 - basalt::kScrollIndicatorInset, 0.001);
+}
+
+// Offset zero is the top of the *content*, which with a leading inset is no
+// longer the top of the range -- so the thumb is a little way down. This is the
+// case that was wrong before insets were read at all.
+TEST(indicator_a_content_inset_moves_where_zero_sits) {
+  const auto without = basalt::scrollIndicatorFor(100.0, 400.0, 0.0);
+  const auto with =
+      basalt::scrollIndicatorFor(100.0, 400.0, 0.0, basalt::ScrollAxisInsets{50.0, 0.0});
+  EXPECT(with.offset > without.offset);
+}
+
+TEST(indicator_an_indicator_inset_shortens_the_track) {
+  // A 400 view over 800 of content, so the thumb is about half the track and
+  // well clear of the minimum length -- which at a 100 view would have been
+  // the answer either way, and would have made this pass without proving
+  // anything.
+  const auto plain = basalt::scrollIndicatorFor(400.0, 800.0, 0.0);
+  const auto inset = basalt::scrollIndicatorFor(
+      400.0, 800.0, 0.0, basalt::ScrollAxisInsets{}, basalt::ScrollAxisInsets{20.0, 10.0});
+
+  // It starts below the inset...
+  EXPECT_NEAR(inset.offset, basalt::kScrollIndicatorInset + 20.0, 0.001);
+  // ...and a shorter track means a shorter thumb.
+  EXPECT(inset.length < plain.length);
+
+  // At the far end it stops short of the trailing inset.
+  const auto end = basalt::scrollIndicatorFor(
+      400.0, 800.0, 400.0, basalt::ScrollAxisInsets{}, basalt::ScrollAxisInsets{20.0, 10.0});
+  EXPECT_NEAR(end.offset + end.length, 400.0 - basalt::kScrollIndicatorInset - 10.0, 0.001);
+}
+
+// An indicator inset does not change what there is to scroll through, so it
+// must not change the *fraction* the thumb represents beyond the track being
+// shorter -- and it must not make the bar disappear.
+TEST(indicator_an_indicator_inset_alone_does_not_hide_the_bar) {
+  const auto indicator = basalt::scrollIndicatorFor(
+      100.0, 400.0, 0.0, basalt::ScrollAxisInsets{}, basalt::ScrollAxisInsets{40.0, 40.0});
+  EXPECT(indicator.visible);
+  EXPECT(indicator.length > 0.0);
+}
+
+// Content that fits exactly, with room to pull above it: there *is* somewhere
+// to go, so there is something to indicate. Asking the content rather than the
+// range would have called this unscrollable.
+TEST(indicator_content_that_fits_but_can_be_pulled_still_has_a_bar) {
+  const auto indicator =
+      basalt::scrollIndicatorFor(100.0, 100.0, 0.0, basalt::ScrollAxisInsets{50.0, 0.0});
+  EXPECT(indicator.visible);
+}

package/native/tests/test_scroll_snap.cpp

@@ -0,0 +1,112 @@
+// Where a scroll comes to rest: paging, intervals and explicit offsets.
+//
+// Arithmetic, so it can be asserted without a display -- which is most of the
+// reason it lives in core rather than in three hosts.
+
+#include "TestHarness.h"
+
+#include "ScrollSnap.h"
+
+#include <sstream>
+
+using basalt::ScrollSnapAlignment;
+using basalt::ScrollSnapConfig;
+using basalt::scrollSnapTarget;
+
+namespace {
+
+// A page-sized container over five pages of content.
+constexpr double kContainer = 400.0;
+constexpr double kContent = 2000.0;
+
+double snapped(const ScrollSnapConfig &config, double offset, double velocity) {
+  const auto target = scrollSnapTarget(config, offset, velocity, kContainer, kContent);
+  return target ? *target : -1.0;
+}
+
+TEST(snap_nothing_configured_snaps_nothing) {
+  // A plain ScrollView must be unaffected: this runs at the end of every drag.
+  const ScrollSnapConfig none;
+  EXPECT(!scrollSnapTarget(none, 137, 0, kContainer, kContent).has_value());
+}
+
+TEST(snap_paging_settles_on_the_nearest_page) {
+  ScrollSnapConfig config;
+  config.paging = true;
+  // Just past a page boundary, released: back to the page behind.
+  EXPECT_EQ(snapped(config, 420, 0), 400.0);
+  // Most of the way to the next: forward to it.
+  EXPECT_EQ(snapped(config, 790, 0), 800.0);
+}
+
+TEST(snap_a_flick_moves_a_whole_page) {
+  // The rule that makes a carousel feel like one: a flick carries even when the
+  // finger left nearer the page it started on.
+  ScrollSnapConfig config;
+  config.paging = true;
+  EXPECT_EQ(snapped(config, 410, 900), 800.0);
+}
+
+TEST(snap_a_flick_backwards_moves_back) {
+  ScrollSnapConfig config;
+  config.paging = true;
+  EXPECT_EQ(snapped(config, 790, -900), 400.0);
+}
+
+TEST(snap_an_interval_is_not_the_container) {
+  ScrollSnapConfig config;
+  config.interval = 250;
+  EXPECT_EQ(snapped(config, 260, 0), 250.0);
+  EXPECT_EQ(snapped(config, 380, 0), 500.0);
+}
+
+TEST(snap_explicit_offsets_win_over_an_interval) {
+  // A list of points is a more specific statement than a spacing.
+  ScrollSnapConfig config;
+  config.interval = 250;
+  config.offsets = {0, 90, 610};
+  EXPECT_EQ(snapped(config, 100, 0), 90.0);
+  EXPECT_EQ(snapped(config, 500, 0), 610.0);
+}
+
+TEST(snap_a_flick_across_explicit_offsets_moves_one_entry) {
+  ScrollSnapConfig config;
+  config.offsets = {0, 90, 610};
+  EXPECT_EQ(snapped(config, 95, 900), 610.0);
+  EXPECT_EQ(snapped(config, 600, -900), 90.0);
+}
+
+TEST(snap_never_past_the_end_of_the_content) {
+  // The furthest a scroll view can be is content minus container. A flick at
+  // the last page must not propose an offset beyond it, which would be a view
+  // showing nothing.
+  ScrollSnapConfig config;
+  config.paging = true;
+  EXPECT_EQ(snapped(config, 1600, 2000), kContent - kContainer);
+}
+
+TEST(snap_never_before_the_start) {
+  ScrollSnapConfig config;
+  config.paging = true;
+  EXPECT_EQ(snapped(config, 10, -2000), 0.0);
+}
+
+TEST(snap_centre_alignment_lines_up_the_middle) {
+  // With a 400 container and a 400 interval, centre alignment puts a boundary
+  // at the middle of the view -- so the resting offsets sit half a container
+  // back from the start-aligned ones.
+  ScrollSnapConfig config;
+  config.interval = 400;
+  config.alignment = ScrollSnapAlignment::Center;
+  EXPECT_EQ(snapped(config, 210, 0), 200.0);
+}
+
+TEST(snap_content_shorter_than_the_container_stays_at_zero) {
+  ScrollSnapConfig config;
+  config.paging = true;
+  const auto target = scrollSnapTarget(config, 0, 900, 400, 200);
+  EXPECT(target.has_value());
+  EXPECT_EQ(*target, 0.0);
+}
+
+} // namespace

package/native/tests/test_settle.cpp

@@ -0,0 +1,115 @@
+// When a host has nothing left to wait for.
+//
+// The decision, not the quitting: three hosts shut down three ways and each owns
+// that. What is shared -- and so what can be got wrong once and be wrong
+// everywhere -- is when they are *allowed* to.
+//
+// The interesting case is the one that was wrong first. The hosts report their
+// scripted-input schedule whether or not any was asked for, and that total is
+// never zero because a tap needs a window to land on, so a scenario that only
+// mounts was waiting out an empty schedule: 2.96 seconds against a 3 second
+// budget, which is no saving at all on exactly the scenarios this exists for.
+
+#include "TestHarness.h"
+
+#include "TestSettle.h"
+
+#include <cstdlib>
+#include <sstream>
+#include <string>
+
+namespace {
+
+void setVariable(const char *name, const char *value) {
+#ifdef _WIN32
+  _putenv_s(name, value);
+#else
+  setenv(name, value, 1);
+#endif
+}
+
+} // namespace
+
+// First, because both `quitWhenSettledMs` and `anyScriptedInputRequested` cache
+// on first read -- the environment does not change under a running process, and
+// hosts ask on a timer. The ordering below is deliberate, not incidental.
+//
+// Zero settle so nothing here has to sleep: the question is whether the
+// conditions are met, and the delay after them is arithmetic.
+TEST(settle_reads_the_variable) {
+  setVariable(basalt::kQuitWhenSettledVar, "0");
+  EXPECT(basalt::quitWhenSettledMs().has_value());
+  EXPECT_EQ((int)*basalt::quitWhenSettledMs(), 0);
+}
+
+TEST(settle_waits_for_the_first_mount) {
+  // Nothing has mounted yet in this process -- no host here -- so however long
+  // has passed, there is nothing to have settled.
+  EXPECT(!basalt::hasSettled());
+
+  basalt::noteMountApplied();
+  EXPECT(basalt::hasSettled());
+}
+
+TEST(settle_keeps_the_first_mount_not_the_last) {
+  const long long first = basalt::firstMountAtMsRef().load();
+  EXPECT(first != 0);
+
+  // A reload mounts again. Taking the later one would push the settle out on
+  // every commit, so an app that re-renders steadily would never settle at all.
+  basalt::noteMountApplied();
+  EXPECT_EQ((long long)basalt::firstMountAtMsRef().load(), first);
+}
+
+TEST(settle_ignores_a_schedule_nobody_asked_for) {
+  // No input instrument is set in this process, so the schedule the hosts report
+  // is the bare 1500ms base and means nothing. Reporting an hour must not push
+  // the settle out by an hour.
+  basalt::noteScriptedInputEndsInMs(3600000);
+  EXPECT(!basalt::anyScriptedInputRequested());
+  EXPECT(basalt::hasSettled());
+}
+
+TEST(settle_lists_the_instruments_that_delay_it) {
+  // The list is what decides whether a reported schedule is real. An input
+  // instrument missing from it settles its scenario before the input lands --
+  // which fails rather than passes, because everything that opts in asserts on
+  // the mounted tree, but it fails a long way from the change that caused it.
+  std::size_t count = 0;
+  const char *const *vars = basalt::scriptedInputVars(count);
+  EXPECT(count >= 11);
+
+  // Every instrument a host lays out on its scripted timer. Not
+  // BASALT_TEST_MENU or BASALT_TEST_DIALOG: those answer something when it
+  // appears rather than being scheduled, so they do not move the end of the
+  // schedule. scripts/test_harness.py holds the list against the hosts.
+  for (const char *needed : {"BASALT_TEST_TAP",
+                             "BASALT_TEST_SECONDARY_TAP",
+                             "BASALT_TEST_CLICK",
+                             "BASALT_TEST_HOVER",
+                             "BASALT_TEST_SCROLL",
+                             "BASALT_TEST_FOCUS",
+                             "BASALT_TEST_TYPE",
+                             "BASALT_TEST_DRAG",
+                             "BASALT_TEST_DROP",
+                             "BASALT_TEST_QUIT",
+                             "BASALT_TEST_CLOSE_WINDOW"}) {
+    bool found = false;
+    for (std::size_t i = 0; i < count; i++) {
+      if (std::string(vars[i]) == needed) {
+        found = true;
+        break;
+      }
+    }
+    EXPECT_EQ(std::string(found ? needed : "missing from scriptedInputVars"), std::string(needed));
+  }
+}
+
+TEST(settle_message_is_shared) {
+  // For the reason core/TestQuitFile.h gives: BASALT_QUIT_AFTER_MS's line had to
+  // be retrofitted onto Windows after a scenario asserted on a string only two
+  // hosts printed.
+  EXPECT_EQ(std::string(basalt::kQuitWhenSettledVar), std::string("BASALT_QUIT_WHEN_SETTLED"));
+  EXPECT_EQ(std::string(basalt::kQuitWhenSettledMessage),
+            std::string("BASALT_QUIT_WHEN_SETTLED: settled; quitting"));
+}

package/native/tests/test_share.cpp

@@ -0,0 +1,75 @@
+// The share picker's two answers, which are the only part of sharing with a
+// result that can be wrong.
+//
+// Core's, so compiled into every platform's suite. What is *not* here is
+// `presentAlert`: it reads BASALT_TEST_DIALOG once into a static, because an
+// environment variable cannot change under a running process, and a test that
+// wanted two different values could not have them. That path is covered by the
+// end-to-end suite, which can run the host twice.
+
+#include "TestHarness.h"
+
+#include "ShareFallback.h"
+
+#include <sstream>
+#include <string>
+
+namespace {
+
+basalt::ShareRequest requestOf(const char *message, const char *url, const char *title = "") {
+  basalt::ShareRequest request;
+  request.message = message;
+  request.url = url;
+  request.title = title;
+  return request;
+}
+
+} // namespace
+
+TEST(share_the_clipboard_gets_both_the_message_and_the_link) {
+  // A link with a sentence about it is what most calls to Share are, and
+  // dropping either half would be dropping half of what the app asked for.
+  EXPECT_EQ(basalt::shareClipboardText(requestOf("Look at this", "https://example.com")),
+            std::string("Look at this\nhttps://example.com"));
+}
+
+TEST(share_the_clipboard_gets_whichever_half_was_given) {
+  EXPECT_EQ(basalt::shareClipboardText(requestOf("Look at this", "")), std::string("Look at this"));
+  EXPECT_EQ(basalt::shareClipboardText(requestOf("", "https://example.com")),
+            std::string("https://example.com"));
+  // React Native's own invariant refuses this before it reaches a platform, so
+  // it is only here to say that nothing here falls over if it ever does.
+  EXPECT_EQ(basalt::shareClipboardText(requestOf("", "")), std::string(""));
+}
+
+TEST(share_a_mailto_carries_the_body_and_the_subject) {
+  const std::string url =
+      basalt::shareMailtoUrl(requestOf("Look at this", "https://example.com", "A link"));
+  EXPECT(url.rfind("mailto:?body=", 0) == 0);
+  EXPECT(url.find("subject=A%20link") != std::string::npos);
+  // The newline between the two halves, encoded rather than literal: a raw one
+  // ends the URL as far as most mail clients are concerned.
+  EXPECT(url.find("%0A") != std::string::npos);
+}
+
+TEST(share_a_mailto_encodes_what_would_otherwise_change_its_meaning) {
+  const std::string url = basalt::shareMailtoUrl(requestOf("tea & biscuits?", ""));
+  // The one that actually bites: an unencoded `&` ends the body and starts a
+  // header, so half the message silently disappears from the draft.
+  EXPECT(url.find("%26") != std::string::npos);
+  EXPECT(url.find("&biscuits") == std::string::npos);
+  // And `?`, which would otherwise start the query a second time.
+  EXPECT(url.find("%3F") != std::string::npos);
+}
+
+TEST(share_a_mailto_leaves_the_unreserved_characters_alone) {
+  // Encoding everything would be correct and unreadable. RFC 3986's unreserved
+  // set is what a URL may carry as-is.
+  const std::string url = basalt::shareMailtoUrl(requestOf("abcXYZ019-_.~", ""));
+  EXPECT(url.find("abcXYZ019-_.~") != std::string::npos);
+}
+
+TEST(share_a_mailto_without_a_title_has_no_subject) {
+  const std::string url = basalt::shareMailtoUrl(requestOf("no title here", ""));
+  EXPECT(url.find("subject=") == std::string::npos);
+}

package/native/tests/test_sourcecode.cpp

@@ -0,0 +1,62 @@
+// The bundle's own URL, which is also where every asset is looked for.
+//
+// Core's, so compiled into every platform's suite -- and the one thing here
+// worth testing hard is the shape of the string rather than its contents,
+// because React Native takes it apart with string operations that are silent
+// when they fail.
+//
+// `resolveAssetSource` finds the directory beside the bundle with
+// `scriptURL.lastIndexOf('/')`. A Windows path has no forward slash in it, so
+// that is -1, the directory comes out empty, and every `require()`d image
+// resolves to `file://assets/...` -- which opens nothing and says nothing. That
+// is what these assertions are for.
+
+#include "TestHarness.h"
+
+#include "SourceCodeModule.h"
+
+#include <sstream>
+#include <string>
+
+namespace {
+
+// Where the directory ends, which is the only thing React Native asks of this
+// string other than its `file://` prefix.
+std::string directoryOf(const std::string &url) {
+  const std::size_t slash = url.rfind('/');
+  return slash == std::string::npos ? std::string() : url.substr(0, slash + 1);
+}
+
+} // namespace
+
+TEST(sourcecode_a_bundle_url_is_a_file_url_with_a_directory_in_it) {
+  const std::string url = basalt::scriptURLFor("build/main.jsbundle.js", false, "", 0, "", "linux");
+
+  EXPECT(url.rfind("file:///", 0) == 0);
+  // Three slashes and then something: `file:///` alone would mean the
+  // directory is the filesystem root, which is what an empty path looks like.
+  EXPECT(url.size() > std::string("file:///").size());
+  // A directory that is more than the scheme. This is the assertion that fails
+  // on a path with no forward slashes in it.
+  EXPECT(directoryOf(url).size() > std::string("file:///").size());
+  EXPECT(url.find("main.jsbundle.js") != std::string::npos);
+  // No backslashes, on any platform: a Windows path reaches JavaScript as a URL
+  // and is taken apart as one.
+  EXPECT(url.find('\\') == std::string::npos);
+}
+
+TEST(sourcecode_a_relative_bundle_path_is_made_absolute) {
+  const std::string url = basalt::scriptURLFor("main.jsbundle.js", false, "", 0, "", "macos");
+  // `file://main.jsbundle.js` would be a URI with an authority and no path, and
+  // the directory beside it would be nothing at all.
+  EXPECT(url.rfind("file:///", 0) == 0);
+  EXPECT(directoryOf(url).size() > std::string("file:///").size());
+}
+
+TEST(sourcecode_dev_mode_reports_the_server_rather_than_the_file) {
+  const std::string url = basalt::scriptURLFor("build/main.jsbundle.js", true, "localhost", 8081, "index", "windows");
+  // Shaped like the URL the dev server served, because React Native recovers
+  // the server's address by stripping the path off this -- and assets then
+  // resolve to that server, with nothing copied anywhere.
+  EXPECT_EQ(url, std::string("http://localhost:8081/index.bundle?platform=windows&dev=true"));
+}

package/native/tests/test_window_close.cpp

@@ -0,0 +1,119 @@
+// Being asked before a window closes: the bookkeeping under it.
+//
+// The interesting parts of this feature are in three hosts and can only be
+// answered end to end, but what decides whether a close is refused is a set of
+// surface ids and a listener, and those are portable and cheap to be sure of.
+//
+// Worth asserting rather than assuming, because both ways it can be wrong are
+// silent. A window that stays in the set after it closes marks whichever window
+// is given that id next -- a window nobody asked to guard that refuses to
+// close, which looks like a stuck window manager. And a listener left holding a
+// module's emitter after the module has gone is a use-after-free reached from a
+// close button.
+
+#include "TestHarness.h"
+
+#include "WindowHost.h"
+
+#include <sstream>
+#include <vector>
+
+using facebook::react::SurfaceId;
+
+namespace {
+
+TEST(close_a_window_is_not_intercepted_by_default) {
+  // The default matters more than it looks: every window that never asks for
+  // this has to close exactly as it did before, and a close path that waits on
+  // JavaScript to say "go ahead" would be a window that does not close while
+  // the runtime is busy.
+  EXPECT(!basalt::hostWindowCloseIntercepted(4242));
+}
+
+TEST(close_interception_is_per_window) {
+  basalt::setHostWindowCloseIntercepted(11, true);
+  EXPECT(basalt::hostWindowCloseIntercepted(11));
+  EXPECT(!basalt::hostWindowCloseIntercepted(12));
+  basalt::setHostWindowCloseIntercepted(11, false);
+  EXPECT(!basalt::hostWindowCloseIntercepted(11));
+}
+
+TEST(close_a_window_that_closed_stops_being_intercepted) {
+  // Surface ids are not reused today. Relying on that would be relying on it:
+  // the cost of forgetting is nothing and the cost of remembering is a window
+  // that refuses to close for a reason nobody can find.
+  basalt::setHostWindowCloseIntercepted(21, true);
+  basalt::setHostWindowClosedListener(nullptr);
+  basalt::hostWindowClosed(21);
+  EXPECT(!basalt::hostWindowCloseIntercepted(21));
+}
+
+TEST(close_a_request_reaches_the_listener_with_the_window) {
+  std::vector<SurfaceId> asked;
+  basalt::setHostWindowCloseRequestListener([&asked](SurfaceId id) { asked.push_back(id); });
+
+  basalt::hostWindowCloseRequested(31);
+  basalt::hostWindowCloseRequested(32);
+
+  EXPECT_EQ((long)asked.size(), 2L);
+  EXPECT_EQ((long)asked[0], 31L);
+  EXPECT_EQ((long)asked[1], 32L);
+
+  // Cleared, the way the module clears it on the way out. A listener that
+  // outlives the module holding its emitter is a use-after-free with a close
+  // button in front of it.
+  basalt::setHostWindowCloseRequestListener(nullptr);
+  basalt::hostWindowCloseRequested(33);
+  EXPECT_EQ((long)asked.size(), 2L);
+}
+
+TEST(close_a_request_with_nobody_listening_is_not_a_crash) {
+  // The order the host and the module start in is not something a close button
+  // waits for.
+  basalt::setHostWindowCloseRequestListener(nullptr);
+  basalt::hostWindowCloseRequested(41);
+}
+
+} // namespace
+
+// --- Refusing to quit -------------------------------------------------------
+//
+// The same seam one level up: one application rather than one window. See
+// core/WindowHost.h for why both are a flag the host reads synchronously
+// rather than a callback it waits on.
+
+TEST(quit_is_not_intercepted_until_somebody_asks) {
+  // The default matters more here than in the window case: every application
+  // that never registers a handler must quit exactly as it did before, and
+  // there is only one flag to get wrong.
+  basalt::setHostQuitIntercepted(false);
+  EXPECT(!basalt::hostQuitIntercepted());
+}
+
+TEST(quit_interception_is_one_flag_for_the_application) {
+  basalt::setHostQuitIntercepted(true);
+  EXPECT(basalt::hostQuitIntercepted());
+  basalt::setHostQuitIntercepted(false);
+  EXPECT(!basalt::hostQuitIntercepted());
+}
+
+TEST(quit_a_request_reaches_the_listener) {
+  int asked = 0;
+  basalt::setHostQuitRequestListener([&asked]() { asked++; });
+
+  basalt::hostQuitRequested();
+  basalt::hostQuitRequested();
+  EXPECT_EQ((long)asked, 2L);
+
+  // Cleared the way the module clears it on the way out, for the same reason
+  // the close listener is: one that outlives the module holding its emitter
+  // is a use-after-free with a menu item in front of it.
+  basalt::setHostQuitRequestListener(nullptr);
+  basalt::hostQuitRequested();
+  EXPECT_EQ((long)asked, 2L);
+}
+
+TEST(quit_a_request_with_nobody_listening_is_not_a_crash) {
+  basalt::setHostQuitRequestListener(nullptr);
+  basalt::hostQuitRequested();
+}