basalt-gtk 0.0.0-rc5

package/native/tests/test_titlebar.cpp

@@ -0,0 +1,137 @@
+// The title bar's metrics and what it does to the window.
+//
+// What the two styles look like is in the screenshots that went with phase 58;
+// what is assertable is the arithmetic an app lays itself out against, and
+// whether the window really took the style rather than the metrics being
+// computed from a flag nothing acted on.
+
+#include "TestHarness.h"
+
+#include "GtkTitleBar.h"
+
+#include <sstream>
+
+namespace {
+
+// A window and the controls the host overlays, built the way main_gtk.cpp
+// builds them. Never shown: the metrics are a property of the widgets rather
+// than of anything on screen.
+struct Fixture {
+  GtkWindow *window;
+  GtkWidget *controls;
+
+  Fixture() {
+    window = GTK_WINDOW(gtk_window_new());
+    controls = gtk_window_controls_new(GTK_PACK_END);
+    GtkWidget *overlay = gtk_overlay_new();
+    gtk_overlay_add_overlay(GTK_OVERLAY(overlay), controls);
+    gtk_window_set_child(window, overlay);
+    basalt::titleBar().attach(window, controls);
+  }
+
+  ~Fixture() { gtk_window_destroy(window); }
+};
+
+} // namespace
+
+TEST(titlebar_native_style_costs_the_app_nothing) {
+  Fixture fixture;
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Native);
+
+  // GTK's decorations sit above the child rather than over it, so they take
+  // nothing from the app. Windows and macOS report the same zeroes, arrived at
+  // differently -- there the system's caption is outside the client area.
+  const auto metrics = basalt::titleBar().metrics();
+  EXPECT(metrics.style == basalt::TitleBarStyle::Native);
+  EXPECT_EQ(metrics.height, 0.0);
+  EXPECT_EQ(metrics.buttonsWidth, 0.0);
+  EXPECT(gtk_window_get_decorated(fixture.window));
+}
+
+TEST(titlebar_hidden_style_reports_what_to_leave_clear) {
+  Fixture fixture;
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Hidden);
+
+  const auto metrics = basalt::titleBar().metrics();
+  EXPECT(metrics.style == basalt::TitleBarStyle::Hidden);
+  // Measured from the controls rather than assumed: how big they are is the
+  // theme's business, and a hard-coded size would be wrong on every desktop
+  // that disagrees.
+  EXPECT(metrics.height > 0.0);
+  EXPECT(metrics.buttonsWidth > 0.0);
+
+  // The window really did take the style.
+  EXPECT(!gtk_window_get_decorated(fixture.window));
+  // And the host's stand-in buttons are up, because GTK's own went with the
+  // decorations -- which is where this host differs from the other two.
+  EXPECT(gtk_widget_get_visible(fixture.controls));
+
+  // Back again, so an unmounted request restores the window.
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Native);
+  EXPECT(gtk_window_get_decorated(fixture.window));
+  EXPECT(!gtk_widget_get_visible(fixture.controls));
+  EXPECT_EQ(basalt::titleBar().metrics().height, 0.0);
+}
+
+TEST(titlebar_takes_a_title) {
+  Fixture fixture;
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Native);
+  basalt::titleBar().setTitle(std::string("Inbox"));
+
+  const char *title = gtk_window_get_title(fixture.window);
+  EXPECT_EQ(std::string(title != nullptr ? title : ""), std::string("Inbox"));
+}
+
+// The caption buttons' functions, for an app drawing its own header.
+//
+// What these *do* was checked live -- a probe drove the window from 900x700 to
+// maximised and back on both hosts, then minimised and closed it. What a test
+// can pin is the half that has no window on the other end: the module outlives
+// the window at shutdown, and a JavaScript call arriving then must not take the
+// process with it.
+TEST(titlebar_actions_are_safe_with_no_window) {
+  basalt::titleBar().attach(nullptr, nullptr);
+  basalt::titleBar().minimize();
+  basalt::titleBar().toggleMaximize();
+  basalt::titleBar().close();
+  basalt::titleBar().startDrag();
+  EXPECT(true);
+}
+
+TEST(titlebar_toggles_maximize) {
+  Fixture fixture;
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Native);
+
+  // An unmapped window still records the request, which is what this asks
+  // about -- whether the toggle reads the state and flips it rather than
+  // always maximising.
+  basalt::titleBar().toggleMaximize();
+  EXPECT(gtk_window_is_maximized(fixture.window));
+  basalt::titleBar().toggleMaximize();
+  EXPECT(!gtk_window_is_maximized(fixture.window));
+}
+
+// The window going away underneath it, which is what happens at quit and what
+// Window.close() does on purpose -- with JavaScript still running and still
+// able to call any of this.
+TEST(titlebar_survives_its_window_being_destroyed) {
+  GtkWindow *window = GTK_WINDOW(gtk_window_new());
+  GtkWidget *controls = gtk_window_controls_new(GTK_PACK_END);
+  GtkWidget *overlay = gtk_overlay_new();
+  gtk_overlay_add_overlay(GTK_OVERLAY(overlay), controls);
+  gtk_window_set_child(window, overlay);
+
+  basalt::titleBar().attach(window, controls);
+  basalt::titleBar().setStyle(basalt::TitleBarStyle::Hidden);
+
+  gtk_window_destroy(window);
+
+  // Every one of these is reachable from JavaScript after the window has gone.
+  basalt::titleBar().setTitle(std::string("late"));
+  basalt::titleBar().setColors(0xFF4285F4u, std::nullopt, std::nullopt);
+  basalt::titleBar().minimize();
+  basalt::titleBar().toggleMaximize();
+  basalt::titleBar().close();
+  const auto metrics = basalt::titleBar().metrics();
+  EXPECT_EQ(metrics.height, 0.0);
+}

package/native/tests/test_titlebar_drag.cpp

@@ -0,0 +1,138 @@
+// Which parts of an app-drawn header drag the window.
+//
+// The same questions tests/test_win32_titlebar.cpp asks of Windows, in the
+// same order: a label inside a drag region drags, a no-drag region inside one
+// stays pressable, a drag region nested inside *that* drags again, and a point
+// under nothing marked is ordinary client area. Most of what this tests is
+// whether the two desktops still agree, which is why the shape is copied
+// rather than reinvented.
+//
+// What it cannot test is the move itself. gdk_toplevel_begin_move hands the
+// window to the compositor, which needs a real pointer grab from a real press;
+// synthesising one needs a session this suite does not have. So the seam is
+// the hit test -- the part that decides *whether* to begin a move -- and the
+// begin itself is left to the end-to-end suite and to a person with a mouse.
+
+#include "TestHarness.h"
+
+#include "GtkTitleBarLayout.h"
+#include "RnView.h"
+#include "TitleBarRegions.h"
+
+#include <sstream>
+
+namespace {
+
+RnView *addChild(RnView *parent,
+                 int tag,
+                 float x,
+                 float y,
+                 float width,
+                 float height,
+                 const char *nativeId = nullptr) {
+  RnView *child = rn_view_new(tag);
+  g_object_ref_sink(child);
+  rn_view_set_frame(child, x, y, width, height);
+  rn_view_set_native_id(child, nativeId);
+  rn_view_insert_child(parent, child, 0);
+  return child;
+}
+
+// A real, shown window, for the reason tests/test_hittest.cpp gives: this
+// walks up from gtk_widget_pick, and pick skips widgets that are not mapped.
+// A tree allocated in isolation would be picked as nothing at all -- and
+// "nothing" answers false, which is also the honest answer for a point that
+// does not drag. Every test below would pass without testing anything.
+//
+// That is what the first test guards against: it expects *true*, so if the
+// tree ever stops being allocated the suite fails rather than going quietly
+// green.
+struct Scene {
+  GtkWidget *window;
+  RnView *root;
+
+  explicit Scene(int width, int height) {
+    root = rn_view_new(1);
+    window = gtk_window_new();
+    gtk_window_set_default_size(GTK_WINDOW(window), width, height);
+    gtk_window_set_child(GTK_WINDOW(window), GTK_WIDGET(root));
+  }
+
+  ~Scene() { gtk_window_destroy(GTK_WINDOW(window)); }
+
+  Scene(const Scene &) = delete;
+  Scene &operator=(const Scene &) = delete;
+
+  void show() {
+    gtk_widget_set_visible(window, TRUE);
+    pump();
+  }
+
+  // Bounded, so a machine that never produces a frame fails an assertion
+  // rather than hanging the suite.
+  static void pump() {
+    const gint64 deadline = g_get_monotonic_time() + 500000; // 500ms
+    while (g_get_monotonic_time() < deadline) {
+      while (g_main_context_iteration(nullptr, FALSE)) {
+      }
+      g_usleep(1000);
+    }
+  }
+};
+
+} // namespace
+
+TEST(titlebar_a_label_inside_a_drag_region_drags_the_window) {
+  Scene scene(800, 600);
+  RnView *header = addChild(scene.root, 2, 0.0F, 0.0F, 800.0F, 32.0F, basalt::kTitleBarDragRegionId);
+  // Unmarked, and inside the header: the marked ancestor decides.
+  addChild(header, 3, 10.0F, 5.0F, 100.0F, 20.0F);
+  scene.show();
+
+  EXPECT(basalt::isTitleBarDragRegionAt(scene.root, 20.0, 10.0));
+  EXPECT(basalt::isTitleBarDragRegionAt(scene.root, 400.0, 10.0));
+}
+
+TEST(titlebar_a_no_drag_region_inside_a_drag_region_stays_pressable) {
+  Scene scene(800, 600);
+  RnView *header = addChild(scene.root, 2, 0.0F, 0.0F, 800.0F, 32.0F, basalt::kTitleBarDragRegionId);
+  RnView *button =
+      addChild(header, 3, 600.0F, 0.0F, 50.0F, 32.0F, basalt::kTitleBarNoDragRegionId);
+  scene.show();
+
+  EXPECT(!basalt::isTitleBarDragRegionAt(scene.root, 620.0, 10.0));
+
+  // And a drag region nested inside that button drags again: the nearest
+  // marker decides, not the outermost.
+  addChild(button, 4, 5.0F, 5.0F, 10.0F, 10.0F, basalt::kTitleBarDragRegionId);
+  Scene::pump();
+  EXPECT(basalt::isTitleBarDragRegionAt(scene.root, 607.0, 7.0));
+}
+
+TEST(titlebar_a_point_under_nothing_marked_is_ordinary_client_area) {
+  Scene scene(800, 600);
+  addChild(scene.root, 2, 0.0F, 0.0F, 800.0F, 32.0F, basalt::kTitleBarDragRegionId);
+  addChild(scene.root, 3, 0.0F, 32.0F, 800.0F, 568.0F);
+  scene.show();
+
+  EXPECT(!basalt::isTitleBarDragRegionAt(scene.root, 400.0, 300.0));
+  // A miss altogether -- outside the root -- is not a drag either.
+  EXPECT(!basalt::isTitleBarDragRegionAt(scene.root, 900.0, 10.0));
+}
+
+TEST(titlebar_a_root_marked_whole_drags_everywhere_it_is_not_overridden) {
+  // An app that wants its entire surface to drag, which is a real shape for a
+  // small tool window, and the case that fails if the walk stops before the
+  // root rather than after it.
+  Scene scene(400, 300);
+  rn_view_set_native_id(scene.root, basalt::kTitleBarDragRegionId);
+  addChild(scene.root, 2, 100.0F, 100.0F, 80.0F, 40.0F, basalt::kTitleBarNoDragRegionId);
+  scene.show();
+
+  EXPECT(basalt::isTitleBarDragRegionAt(scene.root, 10.0, 10.0));
+  EXPECT(!basalt::isTitleBarDragRegionAt(scene.root, 140.0, 120.0));
+}
+
+TEST(titlebar_drag_regions_are_safe_without_a_tree) {
+  EXPECT(!basalt::isTitleBarDragRegionAt(nullptr, 0.0, 0.0));
+}

package/native/tests/test_version.cpp

@@ -0,0 +1,49 @@
+// Parsing the React Native version this host was built against.
+//
+// It matters because React Native's development builds compare it against the
+// bundle's own version and complain loudly when they disagree, and because
+// ReactCxxPlatform hardcodes 1000.0.0, so the comparison can never pass without
+// this. A prerelease tag is the interesting case: read carelessly, "0.88.0-rc.2"
+// turns into patch 0 and a silently discarded tag, or worse, a patch parsed
+// from "0-rc".
+
+#include "TestHarness.h"
+
+#include "PlatformConstantsModule.h"
+
+using basalt::DesktopPlatformConstantsModule;
+
+TEST(version_parses_a_stable_release) {
+  const auto version = DesktopPlatformConstantsModule::parseVersion("0.87.1");
+  EXPECT_EQ(version.major, 0);
+  EXPECT_EQ(version.minor, 87);
+  EXPECT_EQ(version.patch, 1);
+  EXPECT(version.prerelease.empty());
+}
+
+TEST(version_parses_the_main_placeholder) {
+  // What React Native calls itself on main, and the value this whole class
+  // exists to stop being reported against a release.
+  const auto version = DesktopPlatformConstantsModule::parseVersion("1000.0.0");
+  EXPECT_EQ(version.major, 1000);
+  EXPECT_EQ(version.minor, 0);
+  EXPECT_EQ(version.patch, 0);
+}
+
+TEST(version_keeps_a_prerelease_tag_out_of_the_patch) {
+  const auto version = DesktopPlatformConstantsModule::parseVersion("0.88.0-rc.2");
+  EXPECT_EQ(version.major, 0);
+  EXPECT_EQ(version.minor, 88);
+  EXPECT_EQ(version.patch, 0);
+  EXPECT_EQ(version.prerelease, std::string("rc.2"));
+}
+
+TEST(version_survives_something_it_does_not_understand) {
+  // Never a crash and never a wrong number: a version that cannot be parsed
+  // reports zeroes, which disagrees with every bundle and so fails loudly
+  // rather than matching one by accident.
+  const auto version = DesktopPlatformConstantsModule::parseVersion("");
+  EXPECT_EQ(version.major, 0);
+  EXPECT_EQ(version.minor, 0);
+  EXPECT_EQ(version.patch, 0);
+}

package/native/tests/test_view.cpp

@@ -0,0 +1,162 @@
+// Tests for the widget layer: frames, child ordering, scrolling and clipping.
+//
+// RnView has no React Native dependency, so these need no Fabric machinery.
+
+#include "TestHarness.h"
+
+#include "RnView.h"
+
+#include <sstream>
+
+namespace {
+
+// Allocating a widget tree the way GTK would, so the layout manager runs.
+void layout(RnView *root, int width, int height) {
+  gtk_widget_set_size_request(GTK_WIDGET(root), width, height);
+  gtk_widget_allocate(GTK_WIDGET(root), width, height, -1, nullptr);
+}
+
+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;
+}
+
+} // namespace
+
+TEST(view_stores_its_tag_and_frame) {
+  RnView *view = rn_view_new(7);
+  g_object_ref_sink(view);
+
+  EXPECT_EQ(rn_view_get_tag(view), 7);
+
+  rn_view_set_frame(view, 1.5F, 2.5F, 30.0F, 40.0F);
+  graphene_rect_t frame;
+  rn_view_get_frame(view, &frame);
+  EXPECT_NEAR(frame.origin.x, 1.5, 0.001);
+  EXPECT_NEAR(frame.origin.y, 2.5, 0.001);
+  EXPECT_NEAR(frame.size.width, 30.0, 0.001);
+  EXPECT_NEAR(frame.size.height, 40.0, 0.001);
+
+  g_object_unref(view);
+}
+
+TEST(children_insert_at_the_requested_index) {
+  RnView *parent = rn_view_new(1);
+  g_object_ref_sink(parent);
+
+  RnView *a = rn_view_new(10);
+  RnView *b = rn_view_new(11);
+  RnView *c = rn_view_new(12);
+  g_object_ref_sink(a);
+  g_object_ref_sink(b);
+  g_object_ref_sink(c);
+
+  rn_view_insert_child(parent, a, 0);
+  rn_view_insert_child(parent, b, 1);
+  rn_view_insert_child(parent, c, 1);
+
+  EXPECT_EQ(childCount(parent), 3);
+  EXPECT_EQ(rn_view_get_tag(RN_VIEW(gtk_widget_get_first_child(GTK_WIDGET(parent)))), 10);
+  EXPECT_EQ(rn_view_get_tag(RN_VIEW(gtk_widget_get_next_sibling(
+               gtk_widget_get_first_child(GTK_WIDGET(parent))))),
+           12);
+
+  rn_view_remove_child(parent, c);
+  EXPECT_EQ(childCount(parent), 2);
+
+  g_object_unref(c);
+  g_object_unref(parent);
+}
+
+TEST(layout_places_children_at_their_frames) {
+  RnView *parent = rn_view_new(1);
+  g_object_ref_sink(parent);
+
+  RnView *child = rn_view_new(2);
+  g_object_ref_sink(child);
+  rn_view_set_frame(child, 20.0F, 30.0F, 40.0F, 50.0F);
+  rn_view_insert_child(parent, child, 0);
+
+  layout(parent, 200, 200);
+
+  graphene_rect_t bounds;
+  EXPECT(gtk_widget_compute_bounds(GTK_WIDGET(child), GTK_WIDGET(parent), &bounds));
+  EXPECT_NEAR(bounds.origin.x, 20.0, 0.5);
+  EXPECT_NEAR(bounds.origin.y, 30.0, 0.5);
+  EXPECT_NEAR(bounds.size.width, 40.0, 0.5);
+  EXPECT_NEAR(bounds.size.height, 50.0, 0.5);
+
+  g_object_unref(parent);
+}
+
+TEST(scroll_offset_shifts_children) {
+  RnView *scroller = rn_view_new(1);
+  g_object_ref_sink(scroller);
+
+  RnView *content = rn_view_new(2);
+  g_object_ref_sink(content);
+  rn_view_set_frame(content, 0.0F, 0.0F, 100.0F, 1000.0F);
+  rn_view_insert_child(scroller, content, 0);
+
+  layout(scroller, 100, 200);
+  graphene_rect_t before;
+  EXPECT(gtk_widget_compute_bounds(GTK_WIDGET(content), GTK_WIDGET(scroller), &before));
+  EXPECT_NEAR(before.origin.y, 0.0, 0.5);
+
+  // Scrolling moves the children, not the scroller's own frame. This is what
+  // makes gtk_widget_pick follow the scroll for free.
+  rn_view_set_scroll_offset(scroller, 0.0, 150.0);
+  layout(scroller, 100, 200);
+
+  graphene_rect_t after;
+  EXPECT(gtk_widget_compute_bounds(GTK_WIDGET(content), GTK_WIDGET(scroller), &after));
+  EXPECT_NEAR(after.origin.y, -150.0, 0.5);
+
+  double x = 0;
+  double y = 0;
+  rn_view_get_scroll_offset(scroller, &x, &y);
+  EXPECT_NEAR(x, 0.0, 0.001);
+  EXPECT_NEAR(y, 150.0, 0.001);
+
+  g_object_unref(scroller);
+}
+
+TEST(measure_reports_zero_so_gtk_never_second_guesses_yoga) {
+  RnView *view = rn_view_new(1);
+  g_object_ref_sink(view);
+  rn_view_set_frame(view, 0.0F, 0.0F, 123.0F, 456.0F);
+
+  int minimum = -1;
+  int natural = -1;
+  int minimumBaseline = 0;
+  int naturalBaseline = 0;
+  gtk_widget_measure(
+      GTK_WIDGET(view), GTK_ORIENTATION_HORIZONTAL, -1, &minimum, &natural, &minimumBaseline, &naturalBaseline);
+
+  // React Native is the only source of truth for size. If this ever reports the
+  // frame instead, GTK starts participating in layout and the two disagree.
+  EXPECT_EQ(minimum, 0);
+  EXPECT_EQ(natural, 0);
+
+  g_object_unref(view);
+}
+
+TEST(dispose_unparents_children_rather_than_leaking_them) {
+  RnView *parent = rn_view_new(1);
+  g_object_ref_sink(parent);
+
+  RnView *child = rn_view_new(2);
+  g_object_ref_sink(child);
+  rn_view_insert_child(parent, child, 0);
+
+  // A Delete can arrive with children still attached. GTK warns and leaks if a
+  // widget is finalised while it still has any, so dispose unparents them.
+  g_object_unref(parent);
+
+  EXPECT(gtk_widget_get_parent(GTK_WIDGET(child)) == nullptr);
+  g_object_unref(child);
+}