basalt-gtk 0.0.0-rc5

package/native/tests/test_mounting.cpp

@@ -0,0 +1,415 @@
+// Tests for GtkMountingManager: does a stream of ShadowViewMutations produce
+// the widget tree it describes?
+//
+// This is the layer worth testing hardest. Everything above it is React
+// Native's own code, everything below is GTK's, and the mutation walk is where
+// this project can be wrong on its own.
+
+#include "TestHarness.h"
+#include "TreeDump.h"
+
+#include "GtkMountingManager.h"
+
+#include <string>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Color.h>
+
+#include <cstdint>
+
+using facebook::react::ColorComponents;
+using facebook::react::LayoutMetrics;
+using facebook::react::MountingTransaction;
+using facebook::react::ShadowView;
+using facebook::react::ShadowViewMutation;
+using facebook::react::ShadowViewMutationList;
+using facebook::react::SurfaceId;
+using facebook::react::Tag;
+using facebook::react::TransactionTelemetry;
+using facebook::react::ViewProps;
+
+namespace {
+
+constexpr SurfaceId kSurfaceId = 1;
+
+ShadowView makeView(Tag tag,
+                    float x,
+                    float y,
+                    float width,
+                    float height,
+                    float red = 0.0F,
+                    float green = 0.0F,
+                    float blue = 0.0F) {
+  auto props = std::make_shared<ViewProps>();
+  props->backgroundColor = facebook::react::colorFromComponents(
+      ColorComponents{.red = red, .green = green, .blue = blue, .alpha = 1.0F});
+
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = x, .y = y}, .size = {.width = width, .height = height}};
+
+  ShadowView view;
+  view.componentName = "View";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = props;
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+// Applies mutations synchronously. executeMount would queue onto the main loop,
+// which a test has no reason to spin.
+void apply(basalt::GtkMountingManager &manager, ShadowViewMutationList &&mutations) {
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+}
+
+int childCount(RnView *view) {
+  int count = 0;
+  for (GtkWidget *child = gtk_widget_get_first_child(GTK_WIDGET(view)); child != nullptr;
+       child = gtk_widget_get_next_sibling(child)) {
+    ++count;
+  }
+  return count;
+}
+
+// The tag of the nth child, or -1.
+int childTagAt(RnView *view, int index) {
+  int i = 0;
+  for (GtkWidget *child = gtk_widget_get_first_child(GTK_WIDGET(view)); child != nullptr;
+       child = gtk_widget_get_next_sibling(child)) {
+    if (i == index) {
+      return rn_view_get_tag(RN_VIEW(child));
+    }
+    ++i;
+  }
+  return -1;
+}
+
+} // namespace
+
+TEST(create_and_insert_builds_the_tree) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(10, 0, 0, 100, 50)));
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(11, 0, 60, 100, 50)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(10, 0, 0, 100, 50), 0));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(11, 0, 60, 100, 50), 1));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(childCount(root), 2);
+  EXPECT_EQ(childTagAt(root, 0), 10);
+  EXPECT_EQ(childTagAt(root, 1), 11);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(insert_honours_the_index) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList first;
+  first.push_back(ShadowViewMutation::CreateMutation(makeView(20, 0, 0, 10, 10)));
+  first.push_back(ShadowViewMutation::CreateMutation(makeView(21, 0, 0, 10, 10)));
+  first.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(20, 0, 0, 10, 10), 0));
+  first.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(21, 0, 0, 10, 10), 1));
+  apply(manager, std::move(first));
+
+  // Fabric numbers inserts by their position in the parent's final child list,
+  // so a later mutation can land between two existing children.
+  ShadowViewMutationList second;
+  second.push_back(ShadowViewMutation::CreateMutation(makeView(22, 0, 0, 10, 10)));
+  second.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(22, 0, 0, 10, 10), 1));
+  apply(manager, std::move(second));
+
+  EXPECT_EQ(childCount(root), 3);
+  EXPECT_EQ(childTagAt(root, 0), 20);
+  EXPECT_EQ(childTagAt(root, 1), 22);
+  EXPECT_EQ(childTagAt(root, 2), 21);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(remove_detaches_but_does_not_destroy) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(30, 0, 0, 10, 10)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(30, 0, 0, 10, 10), 0));
+  apply(manager, std::move(mutations));
+
+  ShadowViewMutationList removal;
+  removal.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, makeView(30, 0, 0, 10, 10), 0));
+  apply(manager, std::move(removal));
+
+  // Detached from the parent...
+  EXPECT_EQ(childCount(root), 0);
+
+  // ...but still alive, because a re-Insert may follow before the Delete. This
+  // is the invariant the registry's strong reference exists for.
+  ShadowViewMutationList reinsert;
+  reinsert.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(30, 0, 0, 10, 10), 0));
+  apply(manager, std::move(reinsert));
+
+  EXPECT_EQ(childCount(root), 1);
+  EXPECT_EQ(childTagAt(root, 0), 30);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(update_changes_frame_without_reparenting) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(40, 5, 6, 100, 50)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(40, 5, 6, 100, 50), 0));
+  apply(manager, std::move(mutations));
+
+  ShadowViewMutationList update;
+  update.push_back(ShadowViewMutation::UpdateMutation(
+      makeView(40, 5, 6, 100, 50), makeView(40, 7, 8, 200, 75), kSurfaceId));
+  apply(manager, std::move(update));
+
+  EXPECT_EQ(childCount(root), 1);
+
+  graphene_rect_t frame;
+  rn_view_get_frame(RN_VIEW(gtk_widget_get_first_child(GTK_WIDGET(root))), &frame);
+  EXPECT_NEAR(frame.origin.x, 7.0, 0.001);
+  EXPECT_NEAR(frame.origin.y, 8.0, 0.001);
+  EXPECT_NEAR(frame.size.width, 200.0, 0.001);
+  EXPECT_NEAR(frame.size.height, 75.0, 0.001);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(delete_removes_the_view_from_the_registry) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(50, 0, 0, 10, 10)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(50, 0, 0, 10, 10), 0));
+  apply(manager, std::move(mutations));
+
+  ShadowViewMutationList teardown;
+  teardown.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, makeView(50, 0, 0, 10, 10), 0));
+  teardown.push_back(ShadowViewMutation::DeleteMutation(makeView(50, 0, 0, 10, 10)));
+  apply(manager, std::move(teardown));
+
+  EXPECT_EQ(childCount(root), 0);
+
+  // A stray Insert for a deleted tag must be ignored rather than crash, since
+  // that is what a bug upstream would look like from here.
+  ShadowViewMutationList stray;
+  stray.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(50, 0, 0, 10, 10), 0));
+  apply(manager, std::move(stray));
+  EXPECT_EQ(childCount(root), 0);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(nested_children_are_parented_to_their_own_parent) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(60, 0, 0, 200, 200)));
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(61, 10, 10, 50, 50)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, makeView(60, 0, 0, 200, 200), 0));
+  // parentTag 60, not the surface root.
+  mutations.push_back(ShadowViewMutation::InsertMutation(60, makeView(61, 10, 10, 50, 50), 0));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(childCount(root), 1);
+  RnView *outer = RN_VIEW(gtk_widget_get_first_child(GTK_WIDGET(root)));
+  EXPECT_EQ(rn_view_get_tag(outer), 60);
+  EXPECT_EQ(childCount(outer), 1);
+  EXPECT_EQ(childTagAt(outer, 0), 61);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(surface_root_is_reused_not_recreated) {
+  basalt::GtkMountingManager manager;
+  RnView *first = manager.createSurfaceRoot(kSurfaceId);
+  RnView *again = manager.createSurfaceRoot(kSurfaceId);
+
+  // Fabric emits no Create for a root, so asking twice must not produce two.
+  EXPECT(first == again);
+  EXPECT(manager.getSurfaceRoot(kSurfaceId) == first);
+
+  // In Fabric a SurfaceId *is* the root's tag.
+  EXPECT_EQ(rn_view_get_tag(first), static_cast<int>(kSurfaceId));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+  EXPECT(manager.getSurfaceRoot(kSurfaceId) == nullptr);
+}
+
+TEST(has_component_matches_the_registered_descriptors) {
+  basalt::GtkMountingManager manager;
+
+  EXPECT(manager.hasComponent("View"));
+  EXPECT(manager.hasComponent("RootView"));
+  EXPECT(manager.hasComponent("Paragraph"));
+  EXPECT(manager.hasComponent("Image"));
+  EXPECT(manager.hasComponent("ScrollView"));
+  EXPECT(manager.hasComponent("TextInput"));
+  EXPECT(manager.hasComponent("ActivityIndicatorView"));
+  EXPECT(manager.hasComponent("Switch"));
+  EXPECT(manager.hasComponent("ModalHostView"));
+  EXPECT(manager.hasComponent("PullToRefreshView"));
+  // What React Native substitutes for a component nobody registered. Mounting
+  // it is what turns "nothing happens" into a view the tree dump can show.
+  EXPECT(manager.hasComponent("UnimplementedNativeView"));
+
+  // Claiming a component without a GTK peer is worse than admitting the gap:
+  // the registry would build shadow nodes nothing can mount.
+  //
+  // `ActivityIndicator` is here rather than above on purpose: the component
+  // React Native actually mounts is `ActivityIndicatorView`, and answering to
+  // the name a reader expects would be answering to a name nothing sends.
+  EXPECT(!manager.hasComponent("Slider"));
+  EXPECT(!manager.hasComponent("ActivityIndicator"));
+  EXPECT(!manager.hasComponent("SomethingNobodyHasHeardOf"));
+}
+
+// Hover runs only for views that asked for it, and the ask arrives as props on
+// every Create and Update. Recorded by the mutation walk, so a cursor crossing
+// an app that uses no hover costs a hit test and nothing else.
+TEST(a_hover_listener_is_remembered_from_the_props) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowView listening = makeView(10, 0, 0, 100, 50);
+  auto props = std::make_shared<ViewProps>();
+  props->events[facebook::react::ViewEvents::Offset::PointerEnter] = true;
+  listening.props = props;
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(listening));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, listening, 0));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(manager.hoverListenersForTag(10),
+            static_cast<std::uint16_t>(basalt::HoverListenerEnter));
+  // A view that never asked is not stored at all.
+  EXPECT_EQ(manager.hoverListenersForTag(kSurfaceId),
+            static_cast<std::uint16_t>(basalt::HoverListenerNone));
+
+  // An update can take the listener away again, and leaving the old mask behind
+  // would mean dispatching to a view that stopped listening.
+  ShadowViewMutationList updates;
+  updates.push_back(
+      ShadowViewMutation::UpdateMutation(listening, makeView(10, 0, 0, 100, 50), kSurfaceId));
+  apply(manager, std::move(updates));
+  EXPECT_EQ(manager.hoverListenersForTag(10),
+            static_cast<std::uint16_t>(basalt::HoverListenerNone));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// --- transformOrigin --------------------------------------------------------
+//
+// `resolveTransform` folds the origin into the matrix, and all three hosts
+// call it -- so this has been "passed through but never exercised" since it
+// was written. What makes it checkable without a display is that the anchor
+// is a claim about a point: scaling about the top-left must leave the
+// top-left corner exactly where it was.
+//
+// The hosts anchor a transform at the view's centre, which is what an
+// untouched `transformOrigin` means, so the matrix is in centre-relative
+// coordinates and the top-left corner is at (-w/2, -h/2).
+
+namespace {
+
+ShadowView makeTransformed(Tag tag,
+                           float width,
+                           float height,
+                           facebook::react::Transform transform,
+                           facebook::react::TransformOrigin origin = {}) {
+  // Fresh props rather than a copy of makeView's: BaseViewProps has a deleted
+  // copy constructor at React Native 0.86, which is what a current Expo app
+  // installs. Copying compiled against main and broke the version an app
+  // actually has -- found by building a real create-expo-app, not here.
+  ShadowView view = makeView(tag, 0.0F, 0.0F, width, height);
+  auto props = std::make_shared<ViewProps>();
+  props->transform = transform;
+  props->transformOrigin = origin;
+  view.props = props;
+  return view;
+}
+
+// The dump this host wrote, as a string.
+std::string treeOf(RnView *root) {
+  char *described = rn_view_describe_tree(root);
+  std::string tree = described != nullptr ? described : "";
+  g_free(described);
+  return tree;
+}
+
+} // namespace
+
+TEST(transform_origin_anchors_the_corner_it_names) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  using facebook::react::Transform;
+  using facebook::react::TransformOrigin;
+  using facebook::react::UnitType;
+  using facebook::react::ValueUnit;
+
+  // Doubled about the top-left of a 100x50 view.
+  TransformOrigin topLeft;
+  topLeft.xy = {ValueUnit(0.0F, UnitType::Point), ValueUnit(0.0F, UnitType::Point)};
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(
+      makeTransformed(30, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F), topLeft)));
+  mutations.push_back(ShadowViewMutation::InsertMutation(
+      kSurfaceId,
+      makeTransformed(30, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F), topLeft),
+      0));
+  apply(manager, std::move(mutations));
+
+  const auto matrix = basalt::testing::transformIn(treeOf(root), 30);
+  EXPECT_EQ(matrix[0], 2.0);
+  EXPECT_EQ(matrix[3], 2.0);
+
+  // The corner the origin names, in the centre-relative coordinates the
+  // matrix is written in, has to come back to itself: (-50,-25) scaled by two
+  // is (-100,-50), so the translation has to put 50 and 25 back.
+  const double cornerX = matrix[0] * -50.0 + matrix[2] * -25.0 + matrix[4];
+  const double cornerY = matrix[1] * -50.0 + matrix[3] * -25.0 + matrix[5];
+  EXPECT_EQ(cornerX, -50.0);
+  EXPECT_EQ(cornerY, -25.0);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// And with no origin set, the centre is the anchor -- which is the default
+// every host relies on, and the reason an unset origin must not be folded in
+// as (0,0).
+TEST(no_transform_origin_anchors_the_centre) {
+  basalt::GtkMountingManager manager;
+  RnView *root = manager.createSurfaceRoot(kSurfaceId);
+
+  using facebook::react::Transform;
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(
+      makeTransformed(31, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F))));
+  mutations.push_back(ShadowViewMutation::InsertMutation(
+      kSurfaceId, makeTransformed(31, 100.0F, 50.0F, Transform::Scale(2.0F, 2.0F, 1.0F)), 0));
+  apply(manager, std::move(mutations));
+
+  const auto matrix = basalt::testing::transformIn(treeOf(root), 31);
+  EXPECT_EQ(matrix[0], 2.0);
+  EXPECT_EQ(matrix[3], 2.0);
+  // No translation at all: the centre is already the anchor.
+  EXPECT_EQ(matrix[4], 0.0);
+  EXPECT_EQ(matrix[5], 0.0);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}

package/native/tests/test_scrollview.cpp

@@ -0,0 +1,258 @@
+// Tests for the fling GTK hands over half-finished.
+//
+// `<ScrollView>` itself is exercised end to end by `scripts/compare_hosts.sh`
+// running `js/scroll.js` against both hosts, which is a better test than
+// anything here -- it compares one desktop's answer to another's. Momentum is
+// the part that cannot reach: a real fling needs a touchscreen, and the frame
+// clock that drives it needs a mapped window and two seconds of main loop.
+//
+// So the tick is driven directly instead. `fling` and `advanceFling` enter
+// exactly where GDK's `decelerate` signal and the frame clock do and skip
+// nothing above them; what goes untested is that GTK emits `decelerate` at all,
+// which is the same gap every synthesised input in this project leaves.
+//
+// The manager is built standalone rather than through GtkMountingManager: it
+// takes an emitter lookup and nothing else, and a lookup that answers nothing
+// is honest here -- an EventEmitter built by hand has no EventDispatcher, so
+// `onMomentumScrollBegin` would go nowhere anyway. What is observable is where
+// the content actually sits, which is what a fling is for.
+
+#include "TestHarness.h"
+
+#include "GtkScrollView.h"
+#include "RnView.h"
+
+#include <react/renderer/components/scrollview/ScrollViewProps.h>
+#include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+#include <react/renderer/components/scrollview/ScrollViewState.h>
+
+#include <memory>
+#include <sstream>
+
+using facebook::react::LayoutMetrics;
+using facebook::react::Point;
+using facebook::react::Rect;
+using facebook::react::ScrollViewProps;
+using facebook::react::ScrollViewShadowNode;
+using facebook::react::ScrollViewState;
+using facebook::react::ShadowNodeFamily;
+using facebook::react::ShadowView;
+using facebook::react::Size;
+using facebook::react::SurfaceId;
+using facebook::react::Tag;
+
+namespace {
+
+constexpr SurfaceId kSurfaceId = 1;
+constexpr double kFrame = 1.0 / 60.0;
+
+ShadowView makeScrollView(Tag tag,
+                          float width,
+                          float height,
+                          float contentWidth,
+                          float contentHeight,
+                          float decelerationRate = 0,
+                          bool pagingEnabled = false) {
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = 0, .y = 0}, .size = {.width = width, .height = height}};
+
+  auto props = std::make_shared<ScrollViewProps>();
+  props->decelerationRate = decelerationRate;
+  props->pagingEnabled = pagingEnabled;
+
+  ScrollViewState data;
+  data.contentOffset = Point{0, 0};
+  data.contentBoundingRect = Rect{.origin = {.x = 0, .y = 0},
+                                  .size = Size{.width = contentWidth, .height = contentHeight}};
+
+  ShadowView view;
+  view.componentName = "ScrollView";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = props;
+  view.layoutMetrics = metrics;
+  // An empty family: nothing can be committed back through it, so the
+  // unthrottled state write-back is not observable from here.
+  view.state = std::make_shared<const ScrollViewShadowNode::ConcreteState>(
+      std::make_shared<const ScrollViewState>(data), ShadowNodeFamily::Weak{});
+  return view;
+}
+
+// A manager with one ScrollView registered, and the widget it is registered
+// against. The widget is owned by the caller's scope, which is why the tests
+// sink and unref it rather than parenting it into anything.
+struct Scroller {
+  basalt::GtkScrollViewManager manager;
+  RnView *view;
+  Tag tag;
+
+  Scroller(Tag tag, float contentHeight, float decelerationRate = 0, bool pagingEnabled = false)
+      : manager([](Tag) { return facebook::react::EventEmitter::Shared{}; }),
+        view(rn_view_new(static_cast<int>(tag))),
+        tag(tag) {
+    g_object_ref_sink(view);
+    rn_view_set_frame(view, 0, 0, 400, 300);
+    manager.update(
+        view,
+        makeScrollView(tag, 400, 300, 400, contentHeight, decelerationRate, pagingEnabled));
+  }
+
+  ~Scroller() {
+    manager.remove(tag);
+    g_object_unref(view);
+  }
+
+  Scroller(const Scroller &) = delete;
+  Scroller &operator=(const Scroller &) = delete;
+
+  double offsetY() const {
+    double x = 0;
+    double y = 0;
+    rn_view_get_scroll_offset(view, &x, &y);
+    return y;
+  }
+
+  // Runs the fling to a standstill and returns how many frames it took.
+  // Bounded, so a fling that never stops fails the assertion rather than
+  // hanging the suite.
+  int settle() {
+    int frames = 0;
+    while (manager.advanceFling(tag, kFrame) && frames < 6000) {
+      frames++;
+    }
+    return frames + 1;
+  }
+};
+
+} // namespace
+
+TEST(scrollview_a_fling_coasts_and_stops) {
+  Scroller scroller(10, 4000);
+  EXPECT(scroller.manager.fling(scroller.tag, 0, 1200));
+  const int frames = scroller.settle();
+
+  // The same flight core/ScrollMomentum.h is tested for, arriving as an offset.
+  EXPECT(scroller.offsetY() > 450);
+  EXPECT(scroller.offsetY() < 750);
+  EXPECT(frames > 60);
+  EXPECT(frames < 200);
+  // And it is over: another tick moves nothing.
+  const double settled = scroller.offsetY();
+  EXPECT(!scroller.manager.advanceFling(scroller.tag, kFrame));
+  EXPECT_NEAR(scroller.offsetY(), settled, 0.001);
+}
+
+TEST(scrollview_a_fling_stops_at_the_end_of_the_content) {
+  // 300pt of viewport over 500pt of content: 200pt to travel, and a fling with
+  // enough velocity to want far more.
+  Scroller scroller(11, 500);
+  EXPECT(scroller.manager.fling(scroller.tag, 0, 4000));
+  const int frames = scroller.settle();
+
+  EXPECT_NEAR(scroller.offsetY(), 200.0, 0.001);
+  // The assertion that matters: it noticed. A fling that hits an edge still has
+  // velocity left, and without the check it would coast against the stop for a
+  // second before reporting that it had finished -- during which a list would
+  // believe it was still scrolling.
+  EXPECT(frames < 30);
+}
+
+TEST(scrollview_a_fling_is_clamped_at_the_top) {
+  Scroller scroller(12, 4000);
+  // Already at the top, flung further up: there is nowhere to go.
+  EXPECT(scroller.manager.fling(scroller.tag, 0, -1500));
+  scroller.settle();
+  EXPECT_NEAR(scroller.offsetY(), 0.0, 0.001);
+}
+
+TEST(scrollview_a_slow_flick_starts_no_fling) {
+  Scroller scroller(13, 4000);
+  // Below the model's stopping speed. Reporting a momentum scroll that began
+  // and ended in the same frame is worse than reporting none.
+  EXPECT(!scroller.manager.fling(scroller.tag, 0, 5));
+  EXPECT(!scroller.manager.advanceFling(scroller.tag, kFrame));
+  EXPECT_NEAR(scroller.offsetY(), 0.0, 0.001);
+}
+
+TEST(scrollview_a_scrollTo_command_takes_the_list_off_a_fling) {
+  Scroller scroller(14, 4000);
+  EXPECT(scroller.manager.fling(scroller.tag, 0, 1200));
+  scroller.manager.advanceFling(scroller.tag, kFrame);
+
+  scroller.manager.dispatchCommand(scroller.tag, "scrollTo", folly::dynamic::array(0, 900, false));
+  EXPECT_NEAR(scroller.offsetY(), 900.0, 0.001);
+  // The fling is gone rather than paused: an app that asked for an offset means
+  // that offset, not that offset plus wherever the coast was heading.
+  EXPECT(!scroller.manager.advanceFling(scroller.tag, kFrame));
+  EXPECT_NEAR(scroller.offsetY(), 900.0, 0.001);
+}
+
+TEST(scrollview_decelerationRate_shortens_a_fling) {
+  Scroller normal(15, 4000);
+  normal.manager.fling(normal.tag, 0, 1200);
+  normal.settle();
+
+  Scroller fast(16, 4000, basalt::ScrollMomentum::kFastDeceleration);
+  fast.manager.fling(fast.tag, 0, 1200);
+  fast.settle();
+
+  // React Native's prop, reaching the model. 'fast' is the smaller number and
+  // the shorter fling.
+  EXPECT(fast.offsetY() < normal.offsetY());
+}
+
+// --- Paging ------------------------------------------------------------------
+//
+// The arithmetic is tested in test_scroll_snap.cpp; what these assert is the
+// wiring -- that the props reach the manager, and that a fling on a paging list
+// settles on a boundary instead of coasting.
+//
+// The container is 300 tall, so a page is 300.
+
+TEST(scrollview_a_fling_on_a_paging_list_settles_on_a_page) {
+  Scroller scroller(11, 4000, 0, /*pagingEnabled=*/true);
+
+  // Returns false: a snapping list does not coast, so there is no fling to
+  // report having started.
+  EXPECT(!scroller.manager.fling(scroller.tag, 0, 1200));
+  // The settle is an animation rather than a fling, so it is advanced rather
+  // than coasted. Sixty frames is twice the curve's length.
+  for (int i = 0; i < 60; i++) {
+    scroller.manager.advanceAnimation(scroller.tag, 1.0 / 60.0);
+  }
+  EXPECT_EQ(scroller.offsetY(), 300.0);
+}
+
+TEST(scrollview_a_fling_backwards_settles_on_the_boundary_behind) {
+  // Twenty pixels into the second page, flicked back: the answer is that page's
+  // start, not the page before it. "The next point in the direction flicked" is
+  // symmetric -- forwards from here would be 600 -- and it is what CSS
+  // scroll-snap does. Going back two boundaries would mean a small flick could
+  // travel further than a large one.
+  Scroller scroller(12, 4000, 0, /*pagingEnabled=*/true);
+  scroller.manager.dispatchCommand(scroller.tag, "scrollTo", folly::dynamic::array(0, 320, false));
+  EXPECT(!scroller.manager.fling(scroller.tag, 0, -1200));
+  for (int i = 0; i < 60; i++) {
+    scroller.manager.advanceAnimation(scroller.tag, 1.0 / 60.0);
+  }
+  EXPECT_EQ(scroller.offsetY(), 300.0);
+}
+
+TEST(scrollview_a_fling_back_from_a_boundary_reaches_the_previous_page) {
+  // Exactly on a boundary there is nothing behind to settle on, so the flick
+  // takes the page before it -- which is what stops a list getting stuck.
+  Scroller scroller(14, 4000, 0, /*pagingEnabled=*/true);
+  scroller.manager.dispatchCommand(scroller.tag, "scrollTo", folly::dynamic::array(0, 300, false));
+  EXPECT(!scroller.manager.fling(scroller.tag, 0, -1200));
+  for (int i = 0; i < 60; i++) {
+    scroller.manager.advanceAnimation(scroller.tag, 1.0 / 60.0);
+  }
+  EXPECT_EQ(scroller.offsetY(), 0.0);
+}
+
+TEST(scrollview_a_fling_on_a_plain_list_still_coasts) {
+  // The guard that matters: paging is off for almost every list, and this path
+  // runs at the end of every fling.
+  Scroller scroller(13, 4000);
+  EXPECT(scroller.manager.fling(scroller.tag, 0, 1200));
+}