basalt-gtk 0.0.0-rc5

package/native/gtk/mount_harness_gtk.cpp

@@ -0,0 +1,143 @@
+// Drives real ShadowViewMutations through the real GtkMountingManager into
+// real GTK widgets, with no JS runtime, no Hermes and no Metro.
+//
+// Note that executeMount only *queues*: in a real host it is called on the JS
+// thread and marshals to the GTK main thread. Calling it from the main thread
+// here takes the same path, one main-loop turn later.
+//
+// This is the checkpoint between "the mounting manager compiles" and "React
+// Native runs": it exercises the actual mutation walk against the actual
+// Fabric types, so a mistake in the Create/Insert/Update/Remove/Delete
+// handling shows up on screen rather than in review.
+
+#include "GtkMountingManager.h"
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/mounting/MountingTransaction.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+
+#include <memory>
+#include <utility>
+
+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 makeShadowView(Tag tag,
+                          float x, float y, float width, float height,
+                          float red, float green, float blue,
+                          float opacity = 1.0f) {
+  auto props = std::make_shared<ViewProps>();
+  props->backgroundColor = facebook::react::colorFromComponents(
+      ColorComponents{.red = red, .green = green, .blue = blue, .alpha = 1.0f});
+  props->opacity = opacity;
+
+  LayoutMetrics layoutMetrics;
+  layoutMetrics.frame = {.origin = {.x = x, .y = y},
+                         .size = {.width = width, .height = height}};
+
+  ShadowView shadowView;
+  shadowView.componentName = "View";
+  shadowView.surfaceId = kSurfaceId;
+  shadowView.tag = tag;
+  shadowView.props = props;
+  shadowView.layoutMetrics = layoutMetrics;
+  return shadowView;
+}
+
+MountingTransaction makeTransaction(MountingTransaction::Number number,
+                                    ShadowViewMutationList &&mutations) {
+  return MountingTransaction(kSurfaceId, number, std::move(mutations), TransactionTelemetry{});
+}
+
+basalt::GtkMountingManager *g_mountingManager = nullptr;
+
+// Second transaction: recolour one view, and remove another entirely. Fabric
+// always emits Remove before Delete, and this reproduces that ordering.
+gboolean applySecondTransaction(gpointer /*user_data*/) {
+  g_message("--- transaction 2: update tag 2, remove+delete tag 3 ---");
+
+  ShadowViewMutationList mutations;
+
+  // Update: same tag, new props. Recolour blue -> purple and shrink.
+  const ShadowView oldBlue = makeShadowView(2, 32, 32, 240, 160, 0.30f, 0.55f, 0.95f);
+  const ShadowView newBlue = makeShadowView(2, 32, 32, 240, 100, 0.60f, 0.35f, 0.90f);
+  mutations.push_back(ShadowViewMutation::UpdateMutation(oldBlue, newBlue, kSurfaceId));
+
+  // Remove then Delete, the order Fabric guarantees.
+  const ShadowView orange = makeShadowView(3, 296, 32, 240, 160, 0.95f, 0.45f, 0.35f);
+  mutations.push_back(ShadowViewMutation::RemoveMutation(kSurfaceId, orange, 1));
+  mutations.push_back(ShadowViewMutation::DeleteMutation(orange));
+
+  g_mountingManager->executeMount(kSurfaceId, makeTransaction(2, std::move(mutations)));
+
+  g_message("--- transaction 2 queued ---");
+  return G_SOURCE_REMOVE;
+}
+
+void onActivate(GtkApplication *app, gpointer /*user_data*/) {
+  GtkWidget *window = gtk_application_window_new(app);
+  gtk_window_set_title(GTK_WINDOW(window), "basalt-core — mount harness");
+  gtk_window_set_default_size(GTK_WINDOW(window), 640, 420);
+
+  // The host owns the root: Fabric never emits a Create for it.
+  RnView *root = g_mountingManager->createSurfaceRoot(kSurfaceId);
+  gtk_window_set_child(GTK_WINDOW(window), GTK_WIDGET(root));
+
+  g_message("--- transaction 1: create + insert 4 views ---");
+
+  ShadowViewMutationList mutations;
+
+  const ShadowView blue = makeShadowView(2, 32, 32, 240, 160, 0.30f, 0.55f, 0.95f);
+  const ShadowView orange = makeShadowView(3, 296, 32, 240, 160, 0.95f, 0.45f, 0.35f);
+  const ShadowView green = makeShadowView(4, 32, 224, 504, 140, 0.35f, 0.80f, 0.55f);
+  const ShadowView nested = makeShadowView(5, 24, 24, 120, 90, 1.0f, 1.0f, 1.0f, 0.85f);
+
+  // Fabric emits every Create before the Inserts that place them.
+  mutations.push_back(ShadowViewMutation::CreateMutation(blue));
+  mutations.push_back(ShadowViewMutation::CreateMutation(orange));
+  mutations.push_back(ShadowViewMutation::CreateMutation(green));
+  mutations.push_back(ShadowViewMutation::CreateMutation(nested));
+
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, blue, 0));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, orange, 1));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, green, 2));
+  mutations.push_back(ShadowViewMutation::InsertMutation(blue.tag, nested, 0));
+
+  g_mountingManager->executeMount(kSurfaceId, makeTransaction(1, std::move(mutations)));
+
+  g_message("--- transaction 1 queued (applies on the next main-loop turn) ---");
+
+  gtk_window_present(GTK_WINDOW(window));
+
+  g_timeout_add(2000, applySecondTransaction, nullptr);
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+  // Constructed on the main thread: GtkMountingManager records this thread and
+  // asserts every executeMount arrives on it.
+  basalt::GtkMountingManager mountingManager;
+  g_mountingManager = &mountingManager;
+
+  GtkApplication *app =
+      gtk_application_new("dev.basalt.mountharness", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect(app, "activate", G_CALLBACK(onActivate), nullptr);
+  const int status = g_application_run(G_APPLICATION(app), argc, argv);
+  g_object_unref(app);
+  return status;
+}

package/native/tests/TestMainGtk.cpp

@@ -0,0 +1,25 @@
+// The GTK test suite's entry point.
+//
+// Separate from the runner because it is the only part of the suite that knows
+// about a toolkit: every test here touches widgets, and a GtkWidget cannot be
+// constructed before GTK is initialised. The macOS suite has its own.
+
+#include "TestHarness.h"
+
+#include <gtk/gtk.h>
+
+#include <iostream>
+
+int main(int argc, char **argv) {
+
+  // No window is ever presented, but GTK still needs a display connection: on a
+  // headless machine run this under a nested or virtual display server. See
+  // docs/TESTING.md.
+  if (gtk_init_check() == FALSE) {
+    std::cerr << "could not initialise GTK; these tests need a display.\n"
+              << "On a headless Linux box: xvfb-run -a ./build/basalt_gtk_tests\n";
+    return 77; // The convention automake uses for "skipped", not "failed".
+  }
+
+  return basalt::testing::runAllTests(argc, argv);
+}

package/native/tests/notification_stub.cpp

@@ -0,0 +1,103 @@
+// A stand-in for a desktop's notification daemon.
+//
+// The one thing missing from testing notifications: `GtkNotifications.cpp`
+// sends `Notify` over the session bus, and neither a Mac nor a CI runner has
+// anything listening for it. Without something here the only paths that could
+// be exercised were the two that report why nothing can be sent.
+//
+// It owns `org.freedesktop.Notifications` on whatever bus it is started on,
+// answers `Notify` with an increasing id, and prints what it was asked to show
+// so the end-to-end suite can assert on it. Everything a real daemon does
+// beyond that -- the window, the timeout, the actions, the signals back -- is
+// what a test does not need and what would make this a second implementation
+// rather than a fixture.
+//
+// Started by scripts/integration_test.py, which also starts the bus. See
+// docs/TESTING.md.
+#include <gio/gio.h>
+#include <stdio.h>
+
+static const char *kXml =
+    "<node><interface name='org.freedesktop.Notifications'>"
+    "  <method name='Notify'>"
+    "    <arg type='s' name='app_name' direction='in'/>"
+    "    <arg type='u' name='replaces_id' direction='in'/>"
+    "    <arg type='s' name='app_icon' direction='in'/>"
+    "    <arg type='s' name='summary' direction='in'/>"
+    "    <arg type='s' name='body' direction='in'/>"
+    "    <arg type='as' name='actions' direction='in'/>"
+    "    <arg type='a{sv}' name='hints' direction='in'/>"
+    "    <arg type='i' name='timeout' direction='in'/>"
+    "    <arg type='u' name='id' direction='out'/>"
+    "  </method>"
+    "  <method name='CloseNotification'>"
+    "    <arg type='u' name='id' direction='in'/>"
+    "  </method>"
+    "  <method name='GetCapabilities'>"
+    "    <arg type='as' name='caps' direction='out'/>"
+    "  </method>"
+    "</interface></node>";
+
+static guint32 nextId = 1;
+
+static void onCall(GDBusConnection *connection, const gchar *sender, const gchar *path,
+                   const gchar *interface, const gchar *method, GVariant *parameters,
+                   GDBusMethodInvocation *invocation, gpointer user_data) {
+  (void)connection; (void)sender; (void)path; (void)interface; (void)user_data;
+
+  if (g_strcmp0(method, "Notify") == 0) {
+    const gchar *app = nullptr, *icon = nullptr, *summary = nullptr, *body = nullptr;
+    guint32 replaces = 0;
+    gint timeout = 0;
+    GVariantIter *actions = nullptr;
+    GVariant *hints = nullptr;
+    g_variant_get(parameters, "(&su&s&s&sas@a{sv}i)", &app, &replaces, &icon, &summary, &body,
+                  &actions, &hints, &timeout);
+    printf("STUB Notify app=%s summary=%s body=%s\n", app, summary, body);
+    fflush(stdout);
+    if (actions != nullptr) g_variant_iter_free(actions);
+    if (hints != nullptr) g_variant_unref(hints);
+    g_dbus_method_invocation_return_value(invocation, g_variant_new("(u)", nextId++));
+    return;
+  }
+  if (g_strcmp0(method, "CloseNotification") == 0) {
+    guint32 id = 0;
+    g_variant_get(parameters, "(u)", &id);
+    printf("STUB CloseNotification id=%u\n", id);
+    fflush(stdout);
+    g_dbus_method_invocation_return_value(invocation, nullptr);
+    return;
+  }
+  if (g_strcmp0(method, "GetCapabilities") == 0) {
+    GVariantBuilder caps;
+    g_variant_builder_init(&caps, G_VARIANT_TYPE("as"));
+    g_variant_builder_add(&caps, "s", "body");
+    g_dbus_method_invocation_return_value(invocation, g_variant_new("(as)", &caps));
+    return;
+  }
+  g_dbus_method_invocation_return_dbus_error(invocation, "org.freedesktop.DBus.Error.UnknownMethod",
+                                             "no");
+}
+
+static const GDBusInterfaceVTable kVTable = {onCall, nullptr, nullptr, {nullptr}};
+
+static void onBusAcquired(GDBusConnection *connection, const gchar *name, gpointer user_data) {
+  (void)name;
+  auto *info = static_cast<GDBusNodeInfo *>(user_data);
+  g_dbus_connection_register_object(connection, "/org/freedesktop/Notifications",
+                                    info->interfaces[0], &kVTable, nullptr, nullptr, nullptr);
+}
+
+static void onNameAcquired(GDBusConnection *c, const gchar *name, gpointer d) {
+  (void)c; (void)d;
+  printf("STUB ready %s\n", name);
+  fflush(stdout);
+}
+
+int main(void) {
+  GDBusNodeInfo *info = g_dbus_node_info_new_for_xml(kXml, nullptr);
+  g_bus_own_name(G_BUS_TYPE_SESSION, "org.freedesktop.Notifications", G_BUS_NAME_OWNER_FLAGS_NONE,
+                 onBusAcquired, onNameAcquired, nullptr, info, nullptr);
+  g_main_loop_run(g_main_loop_new(nullptr, FALSE));
+  return 0;
+}

package/native/tests/test_accessibility.cpp

@@ -0,0 +1,251 @@
+// Tests for the accessibility mapping.
+//
+// GTK ships assertion helpers for exactly this (gtktestatcontext.h), so what a
+// screen reader would be told can be read back rather than inferred. That is
+// unusual and worth using: accessibility is otherwise the easiest thing in a UI
+// to believe you have done.
+
+#include "TestHarness.h"
+
+#include "GtkMountingManager.h"
+
+#include <react/renderer/components/iostextinput/TextInputProps.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/core/RawPropsParser.h>
+
+#include <sstream>
+
+using facebook::react::AccessibilityState;
+using facebook::react::ImportantForAccessibility;
+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;
+
+// Builds a view with whatever accessibility props the caller wants to set.
+ShadowView makeAccessibleView(Tag tag, const std::function<void(ViewProps &)> &configure) {
+  auto props = std::make_shared<ViewProps>();
+  configure(*props);
+
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = 0, .y = 0}, .size = {.width = 50, .height = 50}};
+
+  ShadowView view;
+  view.componentName = "View";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = props;
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+// The same, for a <TextInput>. Its props have to be real TextInputProps or the
+// mounting manager builds no peer, and those are only reachable through React
+// Native's own parser -- the fields that matter are const.
+ShadowView makeTextInputView(Tag tag, const std::function<void(ViewProps &)> & /*configure*/,
+                             const std::string &label) {
+  static const facebook::react::RawPropsParser parser = []() {
+    facebook::react::RawPropsParser prepared;
+    prepared.prepare<facebook::react::TextInputProps>();
+    return prepared;
+  }();
+
+  static const auto contextContainer =
+      std::make_shared<const facebook::react::ContextContainer>();
+  const facebook::react::PropsParserContext context{kSurfaceId, *contextContainer};
+
+  folly::dynamic raw = folly::dynamic::object("text", "")("accessibilityLabel", label);
+  facebook::react::RawProps rawProps{std::move(raw)};
+  rawProps.parse(parser);
+
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = 0, .y = 0}, .size = {.width = 200, .height = 40}};
+
+  ShadowView view;
+  view.componentName = "TextInput";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = std::make_shared<const facebook::react::TextInputProps>(
+      context, facebook::react::TextInputProps{}, rawProps);
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+// Mounts one view and hands back the widget.
+RnView *mountOne(basalt::GtkMountingManager &manager, const ShadowView &view) {
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(view));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, view, 0));
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+
+  RnView *root = manager.getSurfaceRoot(kSurfaceId);
+  return RN_VIEW(gtk_widget_get_first_child(GTK_WIDGET(root)));
+}
+
+} // namespace
+
+TEST(accessibility_role_maps_to_a_gtk_role) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *button = mountOne(manager, makeAccessibleView(10, [](ViewProps &props) {
+                              props.accessibilityRole = "button";
+                            }));
+  EXPECT_EQ(static_cast<int>(gtk_accessible_get_accessible_role(GTK_ACCESSIBLE(button))),
+            static_cast<int>(GTK_ACCESSIBLE_ROLE_BUTTON));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(unknown_accessibility_role_falls_back_to_generic) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  // A wrong role is worse than no role: it makes a widget announce itself as
+  // something it is not.
+  RnView *view = mountOne(manager, makeAccessibleView(11, [](ViewProps &props) {
+                            props.accessibilityRole = "somethingReactNativeInvented";
+                          }));
+  EXPECT_EQ(static_cast<int>(gtk_accessible_get_accessible_role(GTK_ACCESSIBLE(view))),
+            static_cast<int>(GTK_ACCESSIBLE_ROLE_GENERIC));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(accessibility_label_and_hint_reach_the_accessible) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *view = mountOne(manager, makeAccessibleView(12, [](ViewProps &props) {
+                            props.accessibilityLabel = "Play";
+                            props.accessibilityHint = "Starts the track";
+                          }));
+
+  char *mismatch = gtk_test_accessible_check_property(
+      GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_PROPERTY_LABEL, "Play");
+  EXPECT(mismatch == nullptr);
+  g_free(mismatch);
+
+  mismatch = gtk_test_accessible_check_property(
+      GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_PROPERTY_DESCRIPTION, "Starts the track");
+  EXPECT(mismatch == nullptr);
+  g_free(mismatch);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A field's label has to be on the field, not on the view wrapping it. The
+// peer is a real GtkText and is what AT-SPI presents as a text box, so a label
+// left on the wrapper is a labelled field that announces no name.
+TEST(a_text_input_label_lands_on_the_peer_not_the_wrapper) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *view = mountOne(manager, makeTextInputView(13, nullptr, "Your name"));
+  GtkWidget *peer = rn_view_get_editable(view);
+  EXPECT(peer != nullptr);
+
+  char *mismatch = gtk_test_accessible_check_property(
+      GTK_ACCESSIBLE(peer), GTK_ACCESSIBLE_PROPERTY_LABEL, "Your name");
+  EXPECT(mismatch == nullptr);
+  g_free(mismatch);
+
+  // And not announced twice: the wrapper does not also carry the name. Checked
+  // by asking for a mismatch rather than for an empty string, because an unset
+  // GTK property is not the empty one and does not compare equal to it.
+  mismatch = gtk_test_accessible_check_property(
+      GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_PROPERTY_LABEL, "Your name");
+  EXPECT(mismatch != nullptr);
+  g_free(mismatch);
+
+  // The wrapper is scaffolding rather than a control, so it is presentational
+  // and a screen reader walks past it to the peer. Decided at construction
+  // because a GtkAccessible role cannot be changed later.
+  EXPECT_EQ(static_cast<int>(gtk_accessible_get_accessible_role(GTK_ACCESSIBLE(view))),
+            static_cast<int>(GTK_ACCESSIBLE_ROLE_PRESENTATION));
+
+  // And the tree dump says nothing about it. React Native has no role here to
+  // report, AppKit prints none either, and a name invented for GTK's benefit
+  // would make the two hosts disagree on this view alone.
+  std::ostringstream dump;
+  char *text = rn_view_describe_tree(view);
+  dump << text;
+  g_free(text);
+  EXPECT(dump.str().find("role=") == std::string::npos);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(accessibility_state_reaches_the_accessible) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *view = mountOne(manager, makeAccessibleView(13, [](ViewProps &props) {
+                            AccessibilityState state;
+                            state.disabled = true;
+                            state.selected = true;
+                            state.checked = AccessibilityState::Checked;
+                            props.accessibilityState = state;
+                          }));
+
+  EXPECT(gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_DISABLED));
+  EXPECT(gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_SELECTED));
+  EXPECT(gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_CHECKED));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(no_accessibility_state_leaves_checked_unset) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  // A view that never says anything about "checked" is not an unchecked
+  // checkbox, and a screen reader should not announce it as one.
+  RnView *view = mountOne(manager, makeAccessibleView(14, [](ViewProps &props) { (void)props; }));
+
+  EXPECT(!gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_CHECKED));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(elements_hidden_marks_the_view_hidden) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *view = mountOne(manager, makeAccessibleView(15, [](ViewProps &props) {
+                            props.accessibilityElementsHidden = true;
+                          }));
+  EXPECT(gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_HIDDEN));
+
+  RnView *shown = mountOne(manager, makeAccessibleView(16, [](ViewProps &props) { (void)props; }));
+  char *mismatch = gtk_test_accessible_check_state(
+      GTK_ACCESSIBLE(shown), GTK_ACCESSIBLE_STATE_HIDDEN, FALSE);
+  EXPECT(mismatch == nullptr);
+  g_free(mismatch);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+TEST(important_for_accessibility_no_hide_descendants_hides_too) {
+  basalt::GtkMountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  RnView *view = mountOne(manager, makeAccessibleView(17, [](ViewProps &props) {
+                            props.importantForAccessibility =
+                                ImportantForAccessibility::NoHideDescendants;
+                          }));
+  EXPECT(gtk_test_accessible_has_state(GTK_ACCESSIBLE(view), GTK_ACCESSIBLE_STATE_HIDDEN));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}