basalt-core 0.0.0-rc5

package/native/tests/test_blobs.cpp

@@ -0,0 +1,157 @@
+// Tests for the blob byte store.
+//
+// Core's, so compiled into both platforms' suites -- a blob is a byte array
+// with a name everywhere, and there is nothing here a toolkit could change.
+//
+// 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
+// on both hosts. This covers the half underneath, where an off-by-one lives.
+
+#include "TestHarness.h"
+
+#include "BlobModule.h"
+#include "BlobRegistry.h"
+
+#include <sstream>
+#include <string>
+
+namespace {
+
+// Unique per test, so one test's leftovers cannot be another's fixture -- the
+// registry is process-wide and nothing evicts from it.
+std::string freshId(const char *name) {
+  static int counter = 0;
+  return std::string("test-") + name + "-" + std::to_string(++counter);
+}
+
+} // namespace
+
+TEST(a_stored_blob_reads_back) {
+  const auto id = freshId("roundtrip");
+  basalt::storeBlob(id, "hello");
+
+  EXPECT_EQ(static_cast<int>(basalt::blobSize(id)), 5);
+  const auto bytes = basalt::blobBytes(id);
+  EXPECT(bytes.has_value());
+  EXPECT_EQ(bytes.value_or(""), std::string("hello"));
+
+  basalt::releaseBlob(id);
+}
+
+TEST(an_unknown_blob_is_absent_rather_than_empty) {
+  // The distinction matters: "" is a legal blob, and an app that asked for a
+  // released one should be told so rather than handed nothing.
+  EXPECT(!basalt::blobBytes("never-stored").has_value());
+  EXPECT(!basalt::blobSlice("never-stored", 0, 10).has_value());
+  EXPECT_EQ(static_cast<int>(basalt::blobSize("never-stored")), 0);
+}
+
+TEST(slicing_takes_the_part_asked_for) {
+  const auto id = freshId("slice");
+  basalt::storeBlob(id, "0123456789");
+
+  EXPECT_EQ(basalt::blobSlice(id, 0, 3).value_or(""), std::string("012"));
+  EXPECT_EQ(basalt::blobSlice(id, 2, 3).value_or(""), std::string("234"));
+  EXPECT_EQ(basalt::blobSlice(id, 7, 3).value_or(""), std::string("789"));
+
+  basalt::releaseBlob(id);
+}
+
+// JavaScript computes offsets from sizes it was told, so a disagreement should
+// be a short read rather than an exception three layers from the cause.
+TEST(a_slice_past_the_end_is_clamped_not_rejected) {
+  const auto id = freshId("clamp");
+  basalt::storeBlob(id, "abcde");
+
+  // Runs off the end.
+  EXPECT_EQ(basalt::blobSlice(id, 3, 100).value_or("!"), std::string("de"));
+  // Starts past the end: empty, and still *present*, because the blob exists.
+  const auto beyond = basalt::blobSlice(id, 50, 10);
+  EXPECT(beyond.has_value());
+  EXPECT_EQ(beyond.value_or("!"), std::string(""));
+
+  basalt::releaseBlob(id);
+}
+
+TEST(releasing_removes_it) {
+  const auto id = freshId("release");
+  basalt::storeBlob(id, "temporary");
+  EXPECT(basalt::blobBytes(id).has_value());
+
+  basalt::releaseBlob(id);
+  EXPECT(!basalt::blobBytes(id).has_value());
+
+  // Twice is not an error: JavaScript's Blob.close() can be called again, and
+  // a garbage collector may follow it.
+  basalt::releaseBlob(id);
+}
+
+TEST(storing_twice_replaces) {
+  const auto id = freshId("replace");
+  basalt::storeBlob(id, "first");
+  basalt::storeBlob(id, "second");
+
+  EXPECT_EQ(basalt::blobBytes(id).value_or(""), std::string("second"));
+  basalt::releaseBlob(id);
+}
+
+// Blobs are bytes, not text. A store that assumed UTF-8 or stopped at a NUL
+// would corrupt every image an app ever fetched.
+TEST(binary_content_survives) {
+  const auto id = freshId("binary");
+  const std::string bytes("\x00\x01\xFF\x00 tail", 9);
+  basalt::storeBlob(id, bytes);
+
+  EXPECT_EQ(static_cast<int>(basalt::blobSize(id)), 9);
+  EXPECT(basalt::blobBytes(id).value_or("") == bytes);
+
+  basalt::releaseBlob(id);
+}
+
+// --- base64 ----------------------------------------------------------------
+//
+// On the path of every `fetch` since the setUpXHR override: a blob response is
+// requested as base64 and decoded here, so a bug in this codec is a bug in
+// every request an app makes, not only in `.blob()`.
+
+TEST(base64_round_trips_every_tail_length) {
+  // Lengths 0..8 cover both padded cases and the aligned one, several times
+  // over. The tail is where base64 goes wrong and it goes wrong nowhere else.
+  const std::string source = "ABCDEFGH";
+  for (size_t length = 0; length <= source.size(); length++) {
+    const std::string original = source.substr(0, length);
+    const std::string encoded = basalt::detail::base64Encode(original);
+    EXPECT_EQ(basalt::detail::base64Decode(encoded), original);
+  }
+}
+
+TEST(base64_encodes_the_padding_the_usual_way) {
+  EXPECT_EQ(basalt::detail::base64Encode("A"), std::string("QQ=="));
+  EXPECT_EQ(basalt::detail::base64Encode("AB"), std::string("QUI="));
+  EXPECT_EQ(basalt::detail::base64Encode("ABC"), std::string("QUJD"));
+}
+
+TEST(base64_decodes_what_a_server_actually_sends) {
+  // The exact string a 404 from Metro produced while this was being written,
+  // which is how the round trip was first shown to be byte-exact.
+  EXPECT_EQ(basalt::detail::base64Decode("QXNzZXQgbm90IGZvdW5k"),
+            std::string("Asset not found"));
+}
+
+TEST(base64_survives_bytes_that_are_not_text) {
+  // The reason a blob response cannot be delivered as a string: every byte
+  // value, including the high half and an embedded NUL.
+  std::string binary;
+  for (int i = 0; i < 256; i++) {
+    binary.push_back(static_cast<char>(i));
+  }
+  EXPECT_EQ(basalt::detail::base64Decode(basalt::detail::base64Encode(binary)), binary);
+}
+
+TEST(base64_ignores_whitespace_and_a_truncated_group) {
+  // Newlines are legal in base64 in the wild, and a single leftover character
+  // encodes no whole byte, so it contributes nothing rather than a zero.
+  EXPECT_EQ(basalt::detail::base64Decode("QUJD\nQUJD"), std::string("ABCABC"));
+  EXPECT_EQ(basalt::detail::base64Decode("QUJDQ"), std::string("ABC"));
+}

package/native/tests/test_controls.cpp

@@ -0,0 +1,185 @@
+// The four components that are a control rather than a box, minus the pixels.
+//
+// What is asserted here is the half that three hosts share: how a ShadowView's
+// props become a ControlState, what the tree dump says about it, and the pull
+// gesture that fires a <RefreshControl>. None of it needs a toolkit, which is
+// the point -- a GtkSwitch, an NSSwitch and a Direct2D rounded rectangle have
+// nothing in common, and everything above them has to be identical or the same
+// app is a different app on each desktop.
+//
+// The pull is the part most worth a test. It has exactly one rule that is easy
+// to get wrong and invisible when it is -- fire once per gesture, not once per
+// wheel notch -- and a mouse cannot be asked about it.
+
+#include "TestHarness.h"
+
+#include <memory>
+
+#include "DesktopControls.h"
+#include "PullToRefresh.h"
+
+#include <react/renderer/components/FBReactNativeSpec/Props.h>
+
+using basalt::ControlKind;
+using basalt::ControlState;
+using basalt::controlKindFor;
+using basalt::controlStateOf;
+using basalt::describeControl;
+using basalt::kPullToRefreshThreshold;
+using basalt::PullToRefreshTracker;
+using facebook::react::ShadowView;
+
+namespace {
+
+// A mounted view of a given component name, carrying props built by the caller.
+// Fabric's ShadowView is a plain struct, so this is the whole fixture.
+//
+// The props arrive already in a shared_ptr rather than being copied into one.
+// BaseViewProps has a deleted copy constructor at React Native 0.86 -- which
+// is what a current Expo app installs -- so copying compiled here, against
+// the checkout's newer React Native, and failed in the one place it matters.
+template <typename Props>
+ShadowView viewOf(const char *componentName, std::shared_ptr<Props> props) {
+  ShadowView view;
+  view.componentName = componentName;
+  view.tag = 10;
+  view.props = std::move(props);
+  return view;
+}
+
+} // namespace
+
+TEST(controls_name_decides_kind) {
+  EXPECT(controlKindFor("ActivityIndicatorView") == ControlKind::ActivityIndicator);
+  EXPECT(controlKindFor("Switch") == ControlKind::Switch);
+  EXPECT(controlKindFor("PullToRefreshView") == ControlKind::PullToRefresh);
+  // Everything else, including the modal -- which is a control in the backlog's
+  // sense and not in this one: it has no widget, it is an overlay.
+  EXPECT(controlKindFor("View") == ControlKind::None);
+  EXPECT(controlKindFor("ModalHostView") == ControlKind::None);
+  EXPECT(controlKindFor(nullptr) == ControlKind::None);
+}
+
+TEST(controls_indicator_props_are_read) {
+  auto props = std::make_shared<facebook::react::ActivityIndicatorViewProps>();
+  props->animating = true;
+  props->size = facebook::react::ActivityIndicatorViewSize::Large;
+
+  const ControlState state = controlStateOf(viewOf("ActivityIndicatorView", props));
+  EXPECT(state.kind == ControlKind::ActivityIndicator);
+  EXPECT(state.on);
+  EXPECT(state.large);
+  // React Native's default, which is the one that makes a stopped indicator
+  // draw nothing at all rather than draw a still one.
+  EXPECT(state.hidesWhenStopped);
+  EXPECT(!state.hasForeground);
+}
+
+TEST(controls_switch_props_are_read) {
+  auto props = std::make_shared<facebook::react::SwitchProps>();
+  props->value = true;
+  props->disabled = true;
+
+  const ControlState state = controlStateOf(viewOf("Switch", props));
+  EXPECT(state.kind == ControlKind::Switch);
+  EXPECT(state.on);
+  EXPECT(state.disabled);
+}
+
+TEST(controls_refresh_props_are_read) {
+  auto props = std::make_shared<facebook::react::PullToRefreshViewProps>();
+  props->refreshing = true;
+
+  const ControlState state = controlStateOf(viewOf("PullToRefreshView", props));
+  EXPECT(state.kind == ControlKind::PullToRefresh);
+  EXPECT(state.on);
+}
+
+TEST(controls_a_plain_view_is_not_a_control) {
+  auto props = std::make_shared<facebook::react::ViewProps>();
+  const ControlState state = controlStateOf(viewOf("View", props));
+  EXPECT(state.kind == ControlKind::None);
+  EXPECT(describeControl(state).empty());
+}
+
+TEST(controls_description_is_one_string_for_three_hosts) {
+  ControlState state;
+  state.kind = ControlKind::Switch;
+  state.on = true;
+  EXPECT_EQ(describeControl(state), std::string("switch:on"));
+  state.disabled = true;
+  EXPECT_EQ(describeControl(state), std::string("switch:on:disabled"));
+
+  state = ControlState{};
+  state.kind = ControlKind::ActivityIndicator;
+  state.on = true;
+  EXPECT_EQ(describeControl(state), std::string("spinner:animating"));
+  state.large = true;
+  EXPECT_EQ(describeControl(state), std::string("spinner-large:animating"));
+  state.on = false;
+  EXPECT_EQ(describeControl(state), std::string("spinner-large:stopped"));
+
+  state = ControlState{};
+  state.kind = ControlKind::PullToRefresh;
+  EXPECT_EQ(describeControl(state), std::string("refresh:idle"));
+}
+
+// --- The pull ----------------------------------------------------------------
+
+TEST(pull_a_scroll_view_with_no_refresh_control_never_fires) {
+  PullToRefreshTracker tracker;
+  EXPECT(!tracker.pull(1, 1000.0));
+  EXPECT_EQ((long)tracker.controlFor(1), 0L);
+}
+
+TEST(pull_fires_once_the_threshold_is_crossed) {
+  PullToRefreshTracker tracker;
+  tracker.attach(1, 2);
+  EXPECT_EQ((long)tracker.controlFor(1), 2L);
+
+  EXPECT(!tracker.pull(1, kPullToRefreshThreshold / 2.0));
+  EXPECT(tracker.pull(1, kPullToRefreshThreshold / 2.0 + 1.0));
+}
+
+TEST(pull_fires_once_per_gesture_and_not_once_per_notch) {
+  PullToRefreshTracker tracker;
+  tracker.attach(1, 2);
+
+  EXPECT(tracker.pull(1, kPullToRefreshThreshold + 1.0));
+  // The wheel is still turning. React Native's contract is one onRefresh per
+  // pull, and without the latch this is sixty a second.
+  EXPECT(!tracker.pull(1, 100.0));
+  EXPECT(!tracker.pull(1, 100.0));
+
+  // Let go, and it can fire again.
+  tracker.release(1);
+  EXPECT(!tracker.pull(1, 10.0));
+  EXPECT(tracker.pull(1, kPullToRefreshThreshold));
+}
+
+TEST(pull_a_scroll_away_from_the_top_rearms_it) {
+  PullToRefreshTracker tracker;
+  tracker.attach(1, 2);
+  EXPECT(!tracker.pull(1, kPullToRefreshThreshold - 1.0));
+  // The list moved, so this was not one continuous pull past the top.
+  tracker.release(1);
+  EXPECT(!tracker.pull(1, kPullToRefreshThreshold - 1.0));
+}
+
+TEST(pull_forgetting_either_end_drops_the_pair) {
+  PullToRefreshTracker tracker;
+
+  // The control went away -- an app that stopped passing `refreshControl`.
+  tracker.attach(1, 2);
+  tracker.forget(2);
+  EXPECT_EQ((long)tracker.controlFor(1), 0L);
+  EXPECT(!tracker.pull(1, 1000.0));
+
+  // The scroll view went away, which is the ordinary unmount.
+  tracker.attach(3, 4);
+  tracker.forget(3);
+  EXPECT_EQ((long)tracker.controlFor(3), 0L);
+  // And the reverse map went with it, so re-attaching 4 elsewhere is clean.
+  tracker.attach(5, 4);
+  EXPECT_EQ((long)tracker.controlFor(5), 4L);
+}

package/native/tests/test_devbundle.cpp

@@ -0,0 +1,103 @@
+// Tests for telling the bundle request apart from every other request, and for
+// what is kept when it fails.
+//
+// Core's, so compiled into both platforms' suites: which toolkit is drawing has
+// nothing to do with what Metro answered.
+//
+// The predicate is the part worth proving. It decides whether a response body
+// reaches the JS engine, so a false negative puts Metro's error page back in
+// front of the compiler and a false positive would swallow the body of an app's
+// own fetch -- a 404 from an API, which JavaScript is entitled to read.
+
+#include "TestHarness.h"
+
+#include "DevBundle.h"
+#include "SourceCodeModule.h"
+
+#include <sstream>
+#include <string>
+
+namespace {
+
+const char *kOriginHost = "localhost";
+constexpr uint32_t kOriginPort = 8081;
+
+void withDevServer() {
+  basalt::setDevServerOrigin(kOriginHost, kOriginPort);
+}
+
+} // namespace
+
+TEST(the_bundle_request_is_recognised) {
+  withDevServer();
+  EXPECT(basalt::isDevBundleRequest(
+      "GET",
+      "http://localhost:8081/index.bundle?platform=android&dev=true&app=basalt-macos"));
+  // Metro is also happy to serve it with no query at all.
+  EXPECT(basalt::isDevBundleRequest("GET", "http://localhost:8081/index.bundle"));
+  // Expo's entry point is not called index.
+  EXPECT(basalt::isDevBundleRequest("GET", "http://localhost:8081/node_modules/expo/AppEntry.bundle?platform=ios"));
+}
+
+TEST(other_dev_server_traffic_is_not_the_bundle) {
+  withDevServer();
+  // Symbolication posts a stack; it is not a bundle and its body is wanted.
+  EXPECT(!basalt::isDevBundleRequest("POST", "http://localhost:8081/symbolicate"));
+  // Assets are served by Metro too, out of the same origin.
+  EXPECT(!basalt::isDevBundleRequest("GET", "http://localhost:8081/assets/checker.png"));
+  EXPECT(!basalt::isDevBundleRequest("GET", "http://localhost:8081/status"));
+  // A source map sits next to the bundle and shares its name.
+  EXPECT(!basalt::isDevBundleRequest("GET", "http://localhost:8081/index.map?platform=ios"));
+}
+
+TEST(an_apps_own_request_is_never_the_bundle) {
+  withDevServer();
+  // The point of anchoring on the origin: another server's `.bundle` is none of
+  // this code's business, and its body belongs to whoever asked for it.
+  EXPECT(!basalt::isDevBundleRequest("GET", "https://example.com/index.bundle"));
+  EXPECT(!basalt::isDevBundleRequest("GET", "http://localhost:9000/index.bundle"));
+  // A prefix match on the host alone would accept this one.
+  EXPECT(!basalt::isDevBundleRequest("GET", "http://localhost:80811/index.bundle"));
+}
+
+TEST(metros_json_error_is_unwrapped) {
+  withDevServer();
+  basalt::recordDevBundleError(
+      500,
+      "http://localhost:8081/index.bundle",
+      R"json({"type":"TransformError","message":"App.js: Unexpected token (12:4)","errors":[]})json");
+
+  const auto error = basalt::devBundleError();
+  EXPECT(error.has_value());
+  EXPECT_EQ(static_cast<int>(error->status), 500);
+  // The message, not the JSON around it: it is what the developer has to read.
+  EXPECT_EQ(error->message, std::string("App.js: Unexpected token (12:4)"));
+}
+
+TEST(a_body_that_is_not_metros_is_kept_whole) {
+  withDevServer();
+  // A proxy, a tunnel's error page, a plain string. Unparseable is not a reason
+  // to report nothing -- whatever answered is the only clue there is.
+  basalt::recordDevBundleError(502, "http://localhost:8081/index.bundle", "<html>Bad Gateway</html>");
+
+  const auto error = basalt::devBundleError();
+  EXPECT(error.has_value());
+  EXPECT_EQ(static_cast<int>(error->status), 502);
+  EXPECT_EQ(error->message, std::string("<html>Bad Gateway</html>"));
+}
+
+TEST(a_dev_script_url_names_the_hosts_own_platform) {
+  // HMRClient registers this URL with Metro for Fast Refresh, and Metro sends
+  // updates for the platform it names. It used to say linux on every host, so
+  // a Windows app registered a Linux module graph and no edit ever reached it.
+  EXPECT_EQ(basalt::scriptURLFor("build/main.jsbundle.js", true, "localhost", 8081, "index", "windows"),
+            std::string("http://localhost:8081/index.bundle?platform=windows&dev=true"));
+  EXPECT_EQ(basalt::scriptURLFor("x.js", true, "127.0.0.1", 19000, "node_modules/expo/AppEntry", "macos"),
+            std::string("http://127.0.0.1:19000/node_modules/expo/AppEntry.bundle?platform=macos&dev=true"));
+
+  // Out of dev mode the platform plays no part: the answer is the file.
+  const std::string file =
+      basalt::scriptURLFor("build/main.jsbundle.js", false, "localhost", 8081, "index", "windows");
+  EXPECT(file.rfind("file://", 0) == 0);
+  EXPECT(file.find("main.jsbundle.js") != std::string::npos);
+}

package/native/tests/test_drag_and_drop.cpp

@@ -0,0 +1,143 @@
+// The parts of drag and drop that are a decision rather than a toolkit call.
+//
+// Which view is told, and whether it would take what is being dragged, are the
+// same questions on three desktops and are answered here once. What each
+// toolkit calls its drop target is not.
+
+#include "TestHarness.h"
+
+#include "DragAndDrop.h"
+
+#include <sstream>
+#include <string>
+
+using basalt::DragPayload;
+using basalt::DropAcceptsFiles;
+using basalt::DropAcceptsNone;
+using basalt::DropAcceptsText;
+
+TEST(drop_an_unmarked_native_id_accepts_nothing) {
+  // Every other nativeID an app sets, including the title bar's and its own.
+  EXPECT_EQ((int)basalt::dropAcceptsFrom(""), (int)DropAcceptsNone);
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("my-view"), (int)DropAcceptsNone);
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-titlebar-drag"), (int)DropAcceptsNone);
+  // Close, and not it: a prefix match must be a prefix.
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop"), (int)DropAcceptsNone);
+}
+
+TEST(drop_a_marker_says_what_it_takes) {
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:files"), (int)DropAcceptsFiles);
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:text"), (int)DropAcceptsText);
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:files,text"),
+            (int)(DropAcceptsFiles | DropAcceptsText));
+  // Order is the app's, not ours.
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:text,files"),
+            (int)(DropAcceptsFiles | DropAcceptsText));
+}
+
+TEST(drop_an_unknown_kind_degrades_rather_than_refuses) {
+  // A marker from a newer JavaScript than this host. Taking the kinds it
+  // knows is the difference between a view that accepts files and one that
+  // accepts nothing at all.
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:files,html"), (int)DropAcceptsFiles);
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:html"), (int)DropAcceptsNone);
+  // And an empty list is a marker that accepts nothing, which is not a crash.
+  EXPECT_EQ((int)basalt::dropAcceptsFrom("basalt-drop:"), (int)DropAcceptsNone);
+}
+
+TEST(drop_would_accept_asks_about_what_is_being_dragged) {
+  DragPayload files;
+  files.files.push_back("/tmp/one.txt");
+
+  DragPayload text;
+  text.text = "hello";
+
+  DragPayload both;
+  both.files.push_back("/tmp/one.txt");
+  both.text = "hello";
+
+  EXPECT(basalt::wouldAccept(DropAcceptsFiles, files));
+  EXPECT(!basalt::wouldAccept(DropAcceptsFiles, text));
+  EXPECT(basalt::wouldAccept(DropAcceptsText, text));
+  EXPECT(!basalt::wouldAccept(DropAcceptsText, files));
+
+  // Either kind is enough when a view takes both, and a view taking one still
+  // takes a payload carrying both -- a file manager commonly offers a file as
+  // a path and as its name.
+  EXPECT(basalt::wouldAccept(DropAcceptsFiles | DropAcceptsText, files));
+  EXPECT(basalt::wouldAccept(DropAcceptsFiles, both));
+  EXPECT(basalt::wouldAccept(DropAcceptsText, both));
+}
+
+TEST(drop_nothing_is_accepted_by_nobody) {
+  DragPayload nothing;
+  EXPECT(!basalt::wouldAccept(DropAcceptsFiles | DropAcceptsText, nothing));
+  // And a view that accepts nothing refuses a payload that has something,
+  // which is the case an unmarked view hits on every drag that passes over it.
+  DragPayload files;
+  files.files.push_back("/tmp/one.txt");
+  EXPECT(!basalt::wouldAccept(DropAcceptsNone, files));
+}
+
+TEST(drop_the_marker_round_trips) {
+  // JavaScript writes these strings and C++ reads them, from two files that
+  // cannot include each other. A round trip is what keeps them the same.
+  for (std::uint16_t accepts : {(std::uint16_t)DropAcceptsFiles,
+                                (std::uint16_t)DropAcceptsText,
+                                (std::uint16_t)(DropAcceptsFiles | DropAcceptsText)}) {
+    EXPECT_EQ((int)basalt::dropAcceptsFrom(basalt::dropTargetIdFor(accepts)), (int)accepts);
+  }
+}
+
+// --- Dragging out -----------------------------------------------------------
+
+TEST(drag_an_unmarked_native_id_carries_nothing) {
+  EXPECT(basalt::dragPayloadFrom("").empty());
+  EXPECT(basalt::dragPayloadFrom("my-view").empty());
+  // A drop marker is not a drag marker, which matters because a view may be
+  // both and the two prefixes must not collide.
+  EXPECT(basalt::dragPayloadFrom("basalt-drop:files").empty());
+}
+
+TEST(drag_a_marker_says_what_it_is) {
+  const DragPayload files = basalt::dragPayloadFrom("basalt-drag:files:/tmp/one.txt");
+  EXPECT_EQ((int)files.files.size(), 1);
+  EXPECT_EQ(files.files.empty() ? std::string{} : files.files[0], std::string("/tmp/one.txt"));
+  EXPECT(!files.hasText());
+
+  const DragPayload text = basalt::dragPayloadFrom("basalt-drag:text:hello");
+  EXPECT_EQ(text.text, std::string("hello"));
+  EXPECT(!text.hasFiles());
+}
+
+TEST(drag_a_value_may_contain_a_colon) {
+  // Only the first two colons are structure. A Windows path and a URL both
+  // depend on this, and splitting on every colon would quietly truncate them.
+  const DragPayload url = basalt::dragPayloadFrom("basalt-drag:text:https://example.com/a");
+  EXPECT_EQ(url.text, std::string("https://example.com/a"));
+
+  const DragPayload windows = basalt::dragPayloadFrom("basalt-drag:files:C:\\Users\\a.txt");
+  EXPECT_EQ(windows.files.empty() ? std::string{} : windows.files[0],
+            std::string("C:\\Users\\a.txt"));
+}
+
+TEST(drag_an_empty_or_unknown_marker_carries_nothing) {
+  EXPECT(basalt::dragPayloadFrom("basalt-drag:text:").empty());
+  EXPECT(basalt::dragPayloadFrom("basalt-drag:files:").empty());
+  EXPECT(basalt::dragPayloadFrom("basalt-drag:html:<b>").empty());
+  // No kind at all, which is what a half-written marker looks like.
+  EXPECT(basalt::dragPayloadFrom("basalt-drag:").empty());
+}
+
+TEST(drag_the_marker_round_trips) {
+  DragPayload files;
+  files.files.push_back("/tmp/one.txt");
+  DragPayload text;
+  text.text = "hello world";
+
+  for (const DragPayload &payload : {files, text}) {
+    const DragPayload back = basalt::dragPayloadFrom(basalt::dragSourceIdFor(payload));
+    EXPECT_EQ(back.files.size(), payload.files.size());
+    EXPECT_EQ(back.text, payload.text);
+  }
+}