basalt-core 0.0.0-rc5

package/native/tests/TestHarness.cpp

@@ -0,0 +1,109 @@
+// The runner itself, with no toolkit in it.
+//
+// The toolkit lives in the `main` beside this file -- GTK has to be initialised
+// before a widget can be constructed, and AppKit has its own requirements -- so
+// each platform brings its own entry point and shares everything below.
+
+#include "TestHarness.h"
+
+#include <algorithm>
+#include <cctype>
+#include <sstream>
+
+namespace basalt::testing {
+
+namespace {
+
+struct CurrentTest {
+  std::string name;
+  std::vector<std::string> failures;
+};
+
+CurrentTest &current() {
+  static CurrentTest test;
+  return test;
+}
+
+} // namespace
+
+std::vector<TestCase> &registry() {
+  static std::vector<TestCase> cases;
+  return cases;
+}
+
+void recordFailure(const std::string &where, const std::string &what) {
+  current().failures.push_back(where + ": " + what);
+}
+
+namespace {
+
+std::string lowered(std::string text) {
+  std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) {
+    return static_cast<char>(std::tolower(c));
+  });
+  return text;
+}
+
+} // namespace
+
+int runAllTests(int argc, char **argv) {
+  // Arguments are substrings of test names, and a test runs if it matches any
+  // of them. There is a lot of the day in the difference between running one
+  // test and running all of them, and this runner used to accept an argument
+  // and silently ignore it -- which is worse than rejecting one, because it
+  // looks like the filter worked and every test passed.
+  std::vector<std::string> wanted;
+  for (int i = 1; i < argc; i++) {
+    const std::string argument = argv[i];
+    if (argument == "--list") {
+      for (const auto &test : registry()) {
+        std::cout << test.name << "\n";
+      }
+      return 0;
+    }
+    wanted.push_back(lowered(argument));
+  }
+
+  std::vector<TestCase> selected;
+  for (const auto &test : registry()) {
+    const std::string name = lowered(test.name);
+    if (wanted.empty() ||
+        std::any_of(wanted.begin(), wanted.end(), [&name](const std::string &needle) {
+          return name.find(needle) != std::string::npos;
+        })) {
+      selected.push_back(test);
+    }
+  }
+
+  if (selected.empty()) {
+    std::cout << "no test matches; --list prints the names\n";
+    return 1;
+  }
+
+  int failed = 0;
+
+  std::cout << "running " << selected.size() << " tests\n";
+
+  for (const auto &test : selected) {
+    current().name = test.name;
+    current().failures.clear();
+
+    test.body();
+
+    if (current().failures.empty()) {
+      std::cout << "  ok    " << test.name << "\n";
+    } else {
+      ++failed;
+      std::cout << "  FAIL  " << test.name << "\n";
+      for (const auto &failure : current().failures) {
+        std::cout << "        " << failure << "\n";
+      }
+    }
+  }
+
+  std::cout << "\n" << selected.size() - static_cast<size_t>(failed) << "/" << selected.size()
+            << " passed\n";
+  return failed == 0 ? 0 : 1;
+}
+
+} // namespace basalt::testing

package/native/tests/TestHarness.h

@@ -0,0 +1,89 @@
+// A very small test harness.
+//
+// Deliberately not googletest. React Native vendors its own copy for its own
+// tests, and pulling that into this build would mean another third-party tree
+// to pin and another way for the build to break on an upstream bump. Everything
+// below is about sixty lines and has no dependencies.
+//
+// Tests self-register through the TEST macro and run in registration order.
+// A failed check records a message and keeps going, so one broken assertion
+// does not hide the rest of the test's findings.
+
+#pragma once
+
+// If glog's macros are visible, make sure nothing here quietly binds to them.
+#if defined(CHECK_EQ) && !defined(BASALT_TEST_HARNESS_ALLOW_GLOG_CHECK)
+// Intentionally left alone: glog owns CHECK/CHECK_EQ. This header defines
+// EXPECT/EXPECT_EQ/EXPECT_NEAR instead, which glog does not use.
+#endif
+
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace basalt::testing {
+
+struct TestCase {
+  std::string name;
+  std::function<void()> body;
+};
+
+// Registry and current-test state. A single translation unit owns these; see
+// TestHarness.cpp.
+std::vector<TestCase> &registry();
+void recordFailure(const std::string &where, const std::string &what);
+// Runs the registered tests. Any arguments are substrings of test names: a test
+// runs if it matches one of them, and `--list` prints the names and exits.
+int runAllTests(int argc = 0, char **argv = nullptr);
+
+struct Registrar {
+  Registrar(const char *name, std::function<void()> body) {
+    registry().push_back(TestCase{name, std::move(body)});
+  }
+};
+
+} // namespace basalt::testing
+
+#define TEST(name)                                                                                 \
+  static void name();                                                                              \
+  static ::basalt::testing::Registrar registrar_##name(#name, name);                              \
+  static void name()
+
+// Named EXPECT rather than CHECK because glog -- which React Native pulls in
+// through almost every header -- already defines CHECK and CHECK_EQ. Those win
+// the preprocessor fight silently, and a failing assertion then aborts the
+// process instead of being recorded, taking every later test with it.
+#define EXPECT(condition)                                                                           \
+  do {                                                                                             \
+    if (!(condition)) {                                                                            \
+      ::basalt::testing::recordFailure(std::string(__FILE__) + ":" + std::to_string(__LINE__),     \
+                                        "expected " #condition);                                   \
+    }                                                                                              \
+  } while (false)
+
+#define EXPECT_EQ(actual, expected)                                                                 \
+  do {                                                                                             \
+    const auto actualValue = (actual);                                                             \
+    const auto expectedValue = (expected);                                                         \
+    if (!(actualValue == expectedValue)) {                                                         \
+      std::ostringstream message;                                                                  \
+      message << "expected " #actual " == " #expected " but got " << actualValue << " vs "         \
+              << expectedValue;                                                                    \
+      ::basalt::testing::recordFailure(std::string(__FILE__) + ":" + std::to_string(__LINE__),     \
+                                        message.str());                                            \
+    }                                                                                              \
+  } while (false)
+
+#define EXPECT_NEAR(actual, expected, tolerance)                                                    \
+  do {                                                                                             \
+    const double actualValue = static_cast<double>(actual);                                        \
+    const double expectedValue = static_cast<double>(expected);                                    \
+    if (std::fabs(actualValue - expectedValue) > (tolerance)) {                                    \
+      std::ostringstream message;                                                                  \
+      message << "expected " #actual " ~= " << expectedValue << " but got " << actualValue;         \
+      ::basalt::testing::recordFailure(std::string(__FILE__) + ":" + std::to_string(__LINE__),     \
+                                        message.str());                                            \
+    }                                                                                              \
+  } while (false)

package/native/tests/TreeDump.h

@@ -0,0 +1,49 @@
+// Reading a field back out of a host's tree dump.
+//
+// The three hosts print the same tree in the same format -- that is what
+// scripts/compare_hosts.sh rests on -- so a test that wants one number out of
+// it should not have to know which host wrote it. This is here rather than
+// three times over for the same reason the dump's field order is written down
+// three times over: the moment they drift, the comparison is worthless.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <sstream>
+#include <string>
+
+namespace basalt::testing {
+
+// The six numbers of `transform=(a,b,c,d,tx,ty)` for one tag: the 2D affine
+// part, in the order CSS writes a matrix(). All zeroes when that tag printed
+// no transform at all, which is what an identity looks like in this dump --
+// distinguishable from a real matrix, since a real one never has a zero a
+// and d together.
+inline std::array<double, 6> transformIn(const std::string &tree, int tag) {
+  std::array<double, 6> found{};
+  std::istringstream lines(tree);
+  std::string line;
+  const std::string needle = "tag=" + std::to_string(tag) + " ";
+  while (std::getline(lines, line)) {
+    if (line.find(needle) == std::string::npos) {
+      continue;
+    }
+    const auto at = line.find("transform=(");
+    if (at == std::string::npos) {
+      return found;
+    }
+    std::string numbers = line.substr(at + std::strlen("transform=("));
+    numbers = numbers.substr(0, numbers.find(')'));
+    std::replace(numbers.begin(), numbers.end(), ',', ' ');
+    std::istringstream parts(numbers);
+    for (auto &value : found) {
+      parts >> value;
+    }
+    return found;
+  }
+  return found;
+}
+
+} // namespace basalt::testing

package/native/tests/test_app_identity.cpp

@@ -0,0 +1,114 @@
+// What the app calls itself, read from beside its bundle.
+//
+// A generic host binary cannot know which application it is, and everything the
+// operating system keys on identity needs it: a notification's name and icon, a
+// taskbar group, a GTK application id. `cli/packageApp.js` writes the answer and
+// this is the reading half.
+//
+// What is worth asserting is the degrading, not the happy path. This file is
+// written by a build step and read at startup, so every way it can be wrong is
+// a way an app fails to start -- and an app that refuses to run because
+// somebody hand-edited a JSON file would be a worse platform than one that runs
+// without an icon.
+
+#include "TestHarness.h"
+
+#include "AppIdentity.h"
+
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+using basalt::AppIdentity;
+using basalt::readAppIdentity;
+
+namespace {
+
+// A directory with `app.identity.json` in it, and the bundle path a host would
+// have been given. Removed by the destructor: a test that leaves files behind
+// makes the next run's failure someone else's.
+struct Beside {
+  std::filesystem::path directory;
+
+  explicit Beside(const std::string &contents) {
+    directory = std::filesystem::temp_directory_path() /
+        ("basalt-identity-" + std::to_string(reinterpret_cast<std::uintptr_t>(this)));
+    std::filesystem::create_directories(directory);
+    if (!contents.empty()) {
+      std::ofstream file(directory / "app.identity.json");
+      file << contents;
+    }
+  }
+
+  ~Beside() {
+    std::error_code ignored;
+    std::filesystem::remove_all(directory, ignored);
+  }
+
+  Beside(const Beside &) = delete;
+  Beside &operator=(const Beside &) = delete;
+
+  std::string bundlePath() const {
+    return (directory / "main.jsbundle.js").string();
+  }
+};
+
+} // namespace
+
+TEST(identity_is_read_from_beside_the_bundle) {
+  const Beside beside(R"({
+    "name": "The Demo",
+    "identifier": "dev.example.demo",
+    "schemes": ["demo", "demo2"],
+    "version": "1.2.3"
+  })");
+
+  const AppIdentity identity = readAppIdentity(beside.bundlePath());
+  EXPECT(!identity.empty());
+  EXPECT_EQ(identity.name, std::string("The Demo"));
+  EXPECT_EQ(identity.identifier, std::string("dev.example.demo"));
+  EXPECT_EQ(identity.version, std::string("1.2.3"));
+  EXPECT_EQ((long)identity.schemes.size(), 2L);
+  EXPECT_EQ(identity.schemes[0], std::string("demo"));
+}
+
+TEST(identity_absent_is_not_an_error) {
+  // An app built by hand, with no CLI anywhere near it. Every caller treats an
+  // empty identity as "this platform's identity features are off", which is the
+  // answer all three hosts gave before any of this existed.
+  const Beside beside("");
+  EXPECT(readAppIdentity(beside.bundlePath()).empty());
+}
+
+TEST(identity_malformed_is_the_same_as_absent) {
+  const Beside beside("this is not json at all");
+  EXPECT(readAppIdentity(beside.bundlePath()).empty());
+}
+
+TEST(identity_of_the_wrong_shape_is_the_same_as_absent) {
+  // Valid JSON, wrong thing. Refusing to start over this would be worse than
+  // starting without an icon.
+  const Beside beside("[1, 2, 3]");
+  EXPECT(readAppIdentity(beside.bundlePath()).empty());
+}
+
+TEST(identity_missing_fields_are_left_empty_rather_than_guessed) {
+  // The identifier is the one field that decides anything -- `empty()` is
+  // defined by it, because a name with no identifier cannot be registered with
+  // any of the three desktops.
+  const Beside beside(R"({"name": "Nameless"})");
+  const AppIdentity identity = readAppIdentity(beside.bundlePath());
+  EXPECT(identity.empty());
+  EXPECT_EQ(identity.name, std::string("Nameless"));
+  EXPECT(identity.schemes.empty());
+}
+
+TEST(identity_a_scheme_list_with_rubbish_in_it_keeps_the_strings) {
+  const Beside beside(R"({"identifier": "dev.example.demo", "schemes": ["demo", 7, null]})");
+  const AppIdentity identity = readAppIdentity(beside.bundlePath());
+  EXPECT(!identity.empty());
+  EXPECT_EQ((long)identity.schemes.size(), 1L);
+  EXPECT_EQ(identity.schemes[0], std::string("demo"));
+}

package/native/tests/test_app_paths.cpp

@@ -0,0 +1,48 @@
+// Where a packaged application's own files are.
+//
+// What is testable without packaging anything: that it answers at all, that the
+// answer is a directory that exists, and that a binary which is *not* in a
+// bundle -- this test, run out of a build directory -- is told so rather than
+// being handed a Resources path that is not there. The bundle case is asserted
+// by the shape it recognises, which is cli/packageApp.ts's and cannot be built
+// here.
+
+#include "TestHarness.h"
+
+#include "AppPaths.h"
+
+#include <filesystem>
+#include <sstream>
+#include <string>
+
+TEST(the_resource_path_is_a_directory_that_exists) {
+  const std::string path = basalt::applicationResourcePath();
+  EXPECT(!path.empty());
+
+  std::error_code code;
+  EXPECT(std::filesystem::is_directory(path, code));
+}
+
+TEST(a_binary_outside_a_bundle_is_told_its_own_directory) {
+  // This suite runs out of a build directory rather than a Foo.app, so the
+  // honest answer is that directory -- not a Resources path beside it that
+  // nothing created. A packaged run is recognised by the layout the packager
+  // makes, and this is not it.
+  const std::string path = basalt::applicationResourcePath();
+  EXPECT(path.find("Contents/Resources") == std::string::npos);
+
+  // And it is where this binary is, which is the claim.
+  std::error_code code;
+  const auto expected = std::filesystem::weakly_canonical(
+      std::filesystem::current_path(code) / "build", code);
+  // Compared loosely: the suite may be run from anywhere, so what is asserted is
+  // that the answer is a real directory containing something, not its spelling.
+  EXPECT(std::filesystem::exists(path, code));
+  (void)expected;
+}
+
+TEST(the_answer_does_not_change_between_calls) {
+  // It cannot: the executable does not move while it runs. Worth pinning
+  // because the JavaScript side caches on that basis.
+  EXPECT_EQ(basalt::applicationResourcePath(), basalt::applicationResourcePath());
+}

package/native/tests/test_appearance.cpp

@@ -0,0 +1,107 @@
+// Tests for the portable half of light-vs-dark.
+//
+// The first test in this project that belongs to *neither* platform. It lives
+// with the shared core and is compiled into both suites, because what it checks
+// -- that a JavaScript override beats the system, that releasing it hands
+// control back, that listeners hear both -- is core's behaviour and would
+// otherwise be asserted twice or not at all.
+//
+// It never asks what the system is actually set to. That is the seam, it
+// differs by machine, and a test that depended on it would pass on a dark Mac
+// and fail on a light one.
+
+#include "TestHarness.h"
+
+#include "ColorScheme.h"
+
+#include <sstream>
+#include <vector>
+
+namespace {
+
+// Whatever this machine is, expressed as the one it is not -- so these tests
+// can flip to something that is genuinely a change.
+basalt::ColorScheme opposite(basalt::ColorScheme scheme) {
+  return scheme == basalt::ColorScheme::Dark ? basalt::ColorScheme::Light
+                                             : basalt::ColorScheme::Dark;
+}
+
+} // namespace
+
+TEST(color_scheme_names_match_react_natives_spelling) {
+  EXPECT_EQ(std::string(basalt::colorSchemeName(basalt::ColorScheme::Light)), std::string("light"));
+  EXPECT_EQ(std::string(basalt::colorSchemeName(basalt::ColorScheme::Dark)), std::string("dark"));
+}
+
+TEST(an_override_beats_the_system) {
+  const auto system = basalt::systemColorScheme();
+  const auto other = opposite(system);
+
+  basalt::setColorSchemeOverride(basalt::colorSchemeName(other));
+  EXPECT(basalt::effectiveColorScheme() == other);
+
+  // And releasing it hands control back, rather than leaving the last override
+  // in place -- which is what `Appearance.setColorScheme('auto')` asks for.
+  basalt::clearColorSchemeOverride();
+  EXPECT(basalt::effectiveColorScheme() == system);
+}
+
+TEST(listeners_hear_an_override_and_its_release) {
+  std::vector<basalt::ColorScheme> heard;
+  const int token = basalt::addColorSchemeObserver(
+      [&heard](basalt::ColorScheme scheme) { heard.push_back(scheme); });
+
+  const auto system = basalt::systemColorScheme();
+  const auto other = opposite(system);
+
+  basalt::setColorSchemeOverride(basalt::colorSchemeName(other));
+  basalt::clearColorSchemeOverride();
+
+  EXPECT_EQ(static_cast<int>(heard.size()), 2);
+  if (heard.size() == 2) {
+    EXPECT(heard[0] == other);
+    EXPECT(heard[1] == system);
+  }
+
+  basalt::removeColorSchemeObserver(token);
+}
+
+// Nothing outside the process changed, so an override that changes nothing must
+// still be a no-op rather than a spurious notification -- but releasing one that
+// was never set must not notify either. The second is the one worth pinning:
+// `Appearance.setColorScheme('auto')` on a fresh app is a perfectly ordinary
+// call and should not wake every listener.
+TEST(releasing_an_override_that_was_never_set_notifies_nobody) {
+  int calls = 0;
+  const int token =
+      basalt::addColorSchemeObserver([&calls](basalt::ColorScheme) { calls++; });
+
+  basalt::clearColorSchemeOverride();
+  EXPECT_EQ(calls, 0);
+
+  basalt::removeColorSchemeObserver(token);
+}
+
+TEST(a_removed_listener_stops_hearing) {
+  int calls = 0;
+  const int token =
+      basalt::addColorSchemeObserver([&calls](basalt::ColorScheme) { calls++; });
+  basalt::removeColorSchemeObserver(token);
+
+  basalt::setColorSchemeOverride("dark");
+  basalt::clearColorSchemeOverride();
+
+  EXPECT_EQ(calls, 0);
+}
+
+// An empty string is how a caller says "no override" without knowing React
+// Native's spelling for it. It must not be read as a scheme name and quietly
+// resolve to light.
+TEST(an_empty_override_clears_rather_than_meaning_light) {
+  const auto system = basalt::systemColorScheme();
+
+  basalt::setColorSchemeOverride(basalt::colorSchemeName(opposite(system)));
+  basalt::setColorSchemeOverride("");
+
+  EXPECT(basalt::effectiveColorScheme() == system);
+}

package/native/tests/test_backface.cpp

@@ -0,0 +1,79 @@
+// Which transforms turn a view away from the viewer.
+//
+// One rule, shared, so that a card flipped on three desktops hides its back at
+// the same angle. See core/Backface.h.
+
+#include "TestHarness.h"
+
+#include "Backface.h"
+
+#include <sstream>
+
+using basalt::facesAway;
+
+namespace {
+
+// CSS `matrix3d` order, which is what React Native produces.
+struct Matrix {
+  float m[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
+};
+
+} // namespace
+
+TEST(backface_identity_faces_the_viewer) {
+  const Matrix identity;
+  EXPECT(!facesAway(identity.m));
+}
+
+// Turning something in its own plane never shows its back, however far it
+// goes. This is the case a naive "is any angle past ninety" test gets wrong.
+TEST(backface_a_z_rotation_never_turns_away) {
+  Matrix half;
+  half.m[0] = -1;
+  half.m[5] = -1;
+  EXPECT(!facesAway(half.m));
+}
+
+TEST(backface_a_half_turn_about_y_faces_away) {
+  Matrix flipped;
+  flipped.m[0] = -1;
+  flipped.m[10] = -1;
+  EXPECT(facesAway(flipped.m));
+}
+
+TEST(backface_a_half_turn_about_x_faces_away) {
+  Matrix flipped;
+  flipped.m[5] = -1;
+  flipped.m[10] = -1;
+  EXPECT(facesAway(flipped.m));
+}
+
+// A mirror is a back face too, which is what CSS says and what anyone flipping
+// a card with a scale expects.
+TEST(backface_a_mirror_faces_away) {
+  Matrix mirrored;
+  mirrored.m[0] = -1;
+  EXPECT(facesAway(mirrored.m));
+}
+
+// Ninety degrees exactly is edge-on: the determinant is zero, nothing is
+// visible either way, and the answer must not flicker. Not facing away is the
+// side to fall on, because it is what the view was doing on the way in.
+TEST(backface_edge_on_is_not_yet_away) {
+  Matrix edge;
+  edge.m[0] = 0;
+  edge.m[10] = 0;
+  EXPECT(!facesAway(edge.m));
+}
+
+TEST(backface_a_scale_and_rotation_together_still_answer) {
+  // Rotated 180 about Y and scaled up: still mirrored, still away.
+  Matrix both;
+  both.m[0] = -2;
+  both.m[5] = 2;
+  EXPECT(facesAway(both.m));
+}
+
+TEST(backface_no_matrix_faces_the_viewer) {
+  EXPECT(!facesAway(nullptr));
+}