basalt-core 0.0.0-rc5 → 0.1.0

package/native/tests/test_scroll_visible_position.cpp

@@ -0,0 +1,121 @@
+// Keeping the content still while items are inserted above it.
+//
+// Arithmetic, so it can be asserted without a display and without a mounting
+// transaction -- which is most of the reason it lives in core rather than in
+// three hosts. What each host adds is the children's boxes.
+
+#include "TestHarness.h"
+
+#include "ScrollVisiblePosition.h"
+
+#include <sstream>
+#include <vector>
+
+using basalt::firstVisibleChild;
+using basalt::ScrollChildBox;
+using basalt::visiblePositionAdjustment;
+
+namespace {
+
+// Ten rows of a hundred points each, tagged 100 upwards.
+std::vector<ScrollChildBox> rows(int count = 10, double height = 100.0) {
+  std::vector<ScrollChildBox> boxes;
+  for (int index = 0; index < count; index++) {
+    boxes.push_back(ScrollChildBox{.tag = 100 + index,
+                                   .leading = static_cast<double>(index) * height,
+                                   .length = height});
+  }
+  return boxes;
+}
+
+} // namespace
+
+TEST(visible_the_first_visible_child_is_the_one_watched) {
+  // Scrolled 250 down: the first two rows are above the viewport entirely and
+  // the third is the first with anything on screen.
+  const auto pinned = firstVisibleChild(rows(), 0, 250.0);
+  EXPECT(pinned.has);
+  EXPECT_EQ(pinned.tag, 102);
+  EXPECT_NEAR(pinned.leading, 200.0, 0.0001);
+}
+
+TEST(visible_a_partly_visible_child_counts_as_visible) {
+  // 199 down: one point of the second row is on screen, which is enough -- the
+  // rule is the trailing edge being past the offset, not the leading edge.
+  const auto pinned = firstVisibleChild(rows(), 0, 199.0);
+  EXPECT(pinned.has);
+  EXPECT_EQ(pinned.tag, 101);
+}
+
+TEST(visible_min_index_skips_the_children_before_it) {
+  // What `minIndexForVisible` is for: a header that is not part of the list's
+  // content and must not be the thing held still.
+  const auto pinned = firstVisibleChild(rows(), 3, 0.0);
+  EXPECT(pinned.has);
+  EXPECT_EQ(pinned.tag, 103);
+}
+
+TEST(visible_the_last_child_is_the_fallback) {
+  // Scrolled past everything: no child is visible, and the last one is watched
+  // anyway. Without this a list at its end would adjust by nothing, which is
+  // the case a chat view is in almost all the time.
+  const auto pinned = firstVisibleChild(rows(), 0, 5000.0);
+  EXPECT(pinned.has);
+  EXPECT_EQ(pinned.tag, 109);
+}
+
+TEST(visible_an_empty_list_has_nothing_to_watch) {
+  EXPECT(!firstVisibleChild({}, 0, 0.0).has);
+  // And an index past the end is the app saying none of these: watching the
+  // last child there would be watching one it excluded.
+  EXPECT(!firstVisibleChild(rows(3), 5, 0.0).has);
+}
+
+TEST(visible_a_child_that_moved_down_moves_the_offset_with_it) {
+  // A row inserted above the watched one: it is now 100 further down, so the
+  // offset goes 100 further down and the content under the eye does not move.
+  const auto adjustment = visiblePositionAdjustment(200.0, 300.0, 250.0, std::nullopt);
+  EXPECT(adjustment.move);
+  EXPECT_NEAR(adjustment.delta, 100.0, 0.0001);
+  EXPECT(!adjustment.autoscrollToStart);
+}
+
+TEST(visible_a_child_that_moved_up_moves_the_offset_up) {
+  // The other direction, which is a row above being removed.
+  const auto adjustment = visiblePositionAdjustment(300.0, 200.0, 350.0, std::nullopt);
+  EXPECT(adjustment.move);
+  EXPECT_NEAR(adjustment.delta, -100.0, 0.0001);
+}
+
+TEST(visible_half_a_point_is_not_a_move) {
+  // Layout repeats to within a rounding error, and a list that moved by that on
+  // every transaction would drift under the person reading it.
+  EXPECT(!visiblePositionAdjustment(200.0, 200.4, 250.0, std::nullopt).move);
+  EXPECT(!visiblePositionAdjustment(200.0, 199.6, 250.0, std::nullopt).move);
+  EXPECT(visiblePositionAdjustment(200.0, 200.6, 250.0, std::nullopt).move);
+}
+
+TEST(visible_a_list_near_the_start_follows_the_new_content) {
+  // `autoscrollToTopThreshold`, which reads backwards until the case is named:
+  // a chat list sitting at the top, where the new messages arrive, should
+  // follow them rather than hold its place.
+  const auto adjustment = visiblePositionAdjustment(200.0, 300.0, 40.0, 50);
+  EXPECT(adjustment.move);
+  EXPECT(adjustment.autoscrollToStart);
+}
+
+TEST(visible_a_list_away_from_the_start_holds_its_place) {
+  // The same insertion with the list further down: it holds still, which is the
+  // behaviour the prop is mostly about.
+  const auto adjustment = visiblePositionAdjustment(200.0, 300.0, 400.0, 50);
+  EXPECT(adjustment.move);
+  EXPECT(!adjustment.autoscrollToStart);
+}
+
+TEST(visible_no_threshold_never_autoscrolls) {
+  // The prop's other half is optional, and an absent one must not be read as
+  // zero: a list exactly at the start would then be dragged there every time.
+  const auto adjustment = visiblePositionAdjustment(200.0, 300.0, 0.0, std::nullopt);
+  EXPECT(adjustment.move);
+  EXPECT(!adjustment.autoscrollToStart);
+}

package/native/tests/test_settings_store.cpp

@@ -0,0 +1,257 @@
+// `Settings`, which is a file on this platform.
+//
+// What is worth asserting is not that a key round-trips -- a map does that --
+// but the four things this store has to get right for the API above it to
+// behave the way an app written against iOS expects:
+//
+//   * a value outlives the process, which is the whole point of `Settings`;
+//   * `merge` answers only the keys that *changed*, because that is what a
+//     watcher would be told about and what decides whether anything is written;
+//   * a null value deletes rather than stores a null, which is what
+//     `RCTSettingsManager` does and what `Settings.set({k: null})` means;
+//   * every way the file can be wrong leaves an app running, because a settings
+//     file somebody hand-edited is not a reason to refuse to start.
+//
+// The module over it is three lines of jsi per method and is covered by
+// e2e/settings.tsx, which runs a host twice and reads back what the first run
+// wrote. This file is the half that can be asserted without a runtime.
+
+#include "TestHarness.h"
+
+#include "SettingsStore.h"
+
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+using basalt::SettingsStore;
+
+namespace {
+
+void setEnvironment(const char *name, const std::string &value) {
+#if defined(_WIN32)
+  _putenv_s(name, value.c_str());
+#else
+  setenv(name, value.c_str(), 1);
+#endif
+}
+
+void unsetEnvironment(const char *name) {
+#if defined(_WIN32)
+  // The documented way to remove one: `_putenv_s` with an empty value.
+  _putenv_s(name, "");
+#else
+  unsetenv(name);
+#endif
+}
+
+// A directory of its own per test, removed afterwards. A test that leaves files
+// behind makes the next run's failure someone else's.
+struct Scratch {
+  std::filesystem::path directory;
+
+  Scratch() {
+    directory = std::filesystem::temp_directory_path() /
+        ("basalt-settings-" + std::to_string(reinterpret_cast<std::uintptr_t>(this)));
+    std::filesystem::create_directories(directory);
+  }
+
+  ~Scratch() {
+    std::error_code ignored;
+    std::filesystem::remove_all(directory, ignored);
+  }
+
+  Scratch(const Scratch &) = delete;
+  Scratch &operator=(const Scratch &) = delete;
+
+  std::filesystem::path file() const {
+    return directory / "settings.json";
+  }
+
+  void write(const std::string &contents) const {
+    std::ofstream stream(file());
+    stream << contents;
+  }
+
+  std::string read() const {
+    std::ifstream stream(file());
+    std::stringstream buffer;
+    buffer << stream.rdbuf();
+    return buffer.str();
+  }
+};
+
+std::string stringAt(const SettingsStore &store, const char *key) {
+  const folly::dynamic &values = store.values();
+  const auto found = values.find(key);
+  return found == values.items().end() || !found->second.isString()
+      ? std::string{}
+      : found->second.asString();
+}
+
+} // namespace
+
+TEST(settings_a_first_run_has_no_settings_and_is_not_an_error) {
+  const Scratch scratch;
+  const SettingsStore store(scratch.file());
+  EXPECT(store.values().isObject());
+  EXPECT_EQ((long)store.values().size(), 0L);
+  // Nothing is written by reading, so an app that only ever reads settings
+  // leaves no file behind.
+  EXPECT(!std::filesystem::exists(scratch.file()));
+}
+
+TEST(settings_outlive_the_process) {
+  // The claim the whole module exists for. Two stores over one file is what two
+  // runs of a host are, minus the process.
+  const Scratch scratch;
+  {
+    SettingsStore store(scratch.file());
+    store.merge(folly::dynamic::object("tab", "inbox")("seen", 3));
+  }
+  const SettingsStore reopened(scratch.file());
+  EXPECT_EQ(stringAt(reopened, "tab"), std::string("inbox"));
+  EXPECT_EQ((long)reopened.values()["seen"].asInt(), 3L);
+}
+
+TEST(settings_merge_answers_only_the_keys_that_changed) {
+  const Scratch scratch;
+  SettingsStore store(scratch.file());
+
+  const std::vector<std::string> first = store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT_EQ((long)first.size(), 1L);
+  EXPECT_EQ(first[0], std::string("tab"));
+
+  // The same value again. An app re-rendering and setting what it already set
+  // is the normal case, and it is neither a change to report nor a reason to
+  // write the file.
+  const std::vector<std::string> again = store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT(again.empty());
+
+  const std::vector<std::string> changed = store.merge(folly::dynamic::object("tab", "archive"));
+  EXPECT_EQ((long)changed.size(), 1L);
+  EXPECT_EQ(stringAt(store, "tab"), std::string("archive"));
+}
+
+TEST(settings_merge_is_one_key_deep_like_object_assign) {
+  // `Settings.set` is `Object.assign` in JavaScript and this has to agree with
+  // it, or the copy in memory and the copy on disk disagree about what a nested
+  // object holds.
+  const Scratch scratch;
+  SettingsStore store(scratch.file());
+  store.merge(folly::dynamic::object("window", folly::dynamic::object("x", 10)("y", 20)));
+  store.merge(folly::dynamic::object("window", folly::dynamic::object("x", 30)));
+  EXPECT_EQ((long)store.values()["window"]["x"].asInt(), 30L);
+  EXPECT(store.values()["window"].find("y") == store.values()["window"].items().end());
+}
+
+TEST(settings_a_null_value_deletes_the_key) {
+  // iOS's behaviour, and not an accident of it: `RCTSettingsManager` calls
+  // `removeObjectForKey:` when the value does not convert to a property list,
+  // so `Settings.set({tab: null})` forgets the key there and has to here.
+  const Scratch scratch;
+  SettingsStore store(scratch.file());
+  store.merge(folly::dynamic::object("tab", "inbox"));
+
+  const std::vector<std::string> changed = store.merge(folly::dynamic::object("tab", nullptr));
+  EXPECT_EQ((long)changed.size(), 1L);
+  EXPECT_EQ((long)store.values().size(), 0L);
+
+  // And deleting what is not there changes nothing, so it is not reported.
+  EXPECT(store.merge(folly::dynamic::object("tab", nullptr)).empty());
+}
+
+TEST(settings_deleting_answers_what_was_actually_there) {
+  const Scratch scratch;
+  SettingsStore store(scratch.file());
+  store.merge(folly::dynamic::object("tab", "inbox")("seen", 3));
+
+  const std::vector<std::string> removed = store.erase({"tab", "never-set"});
+  EXPECT_EQ((long)removed.size(), 1L);
+  EXPECT_EQ(removed[0], std::string("tab"));
+  EXPECT_EQ((long)store.values().size(), 1L);
+
+  const SettingsStore reopened(scratch.file());
+  EXPECT_EQ((long)reopened.values().size(), 1L);
+}
+
+TEST(settings_a_file_that_is_not_json_starts_empty_rather_than_failing) {
+  const Scratch scratch;
+  scratch.write("this is not json at all");
+  const SettingsStore store(scratch.file());
+  EXPECT_EQ((long)store.values().size(), 0L);
+}
+
+TEST(settings_a_file_of_the_wrong_shape_starts_empty) {
+  // Valid JSON, wrong thing. Keyed access over an array would throw on every
+  // call afterwards, so the shape is checked once, at the read.
+  const Scratch scratch;
+  scratch.write("[1, 2, 3]");
+  const SettingsStore store(scratch.file());
+  EXPECT(store.values().isObject());
+  EXPECT_EQ((long)store.values().size(), 0L);
+}
+
+TEST(settings_a_bad_file_is_replaced_by_the_next_write) {
+  const Scratch scratch;
+  scratch.write("{ truncated");
+  SettingsStore store(scratch.file());
+  store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT_EQ(stringAt(SettingsStore(scratch.file()), "tab"), std::string("inbox"));
+}
+
+TEST(settings_the_file_is_replaced_whole_and_leaves_nothing_beside_it) {
+  // The write goes to a sibling and is renamed over, so that a process that
+  // dies mid-write leaves the previous file rather than half of a new one. The
+  // sibling must not survive a successful write: a stale `settings.json.new`
+  // next to the real file would be a puzzle for whoever looked.
+  const Scratch scratch;
+  SettingsStore store(scratch.file());
+  store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT(!std::filesystem::exists(scratch.file().string() + ".new"));
+  EXPECT(scratch.read().find("inbox") != std::string::npos);
+}
+
+TEST(settings_a_directory_that_does_not_exist_yet_is_created) {
+  // The first run of a packaged app: nothing under the config directory has its
+  // identifier yet.
+  const Scratch scratch;
+  const std::filesystem::path nested = scratch.directory / "dev.example.demo" / "settings.json";
+  SettingsStore store(nested);
+  store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT(std::filesystem::exists(nested));
+}
+
+TEST(settings_with_nowhere_to_put_them_stay_in_memory) {
+  // A container with no HOME and no APPDATA. The alternative would be a module
+  // that throws at startup, which is the failure this whole entry was about.
+  SettingsStore store({});
+  const std::vector<std::string> changed = store.merge(folly::dynamic::object("tab", "inbox"));
+  EXPECT_EQ((long)changed.size(), 1L);
+  EXPECT_EQ(stringAt(store, "tab"), std::string("inbox"));
+}
+
+TEST(settings_the_path_can_be_pointed_somewhere_by_the_environment) {
+  const Scratch scratch;
+  setEnvironment(basalt::kSettingsFileVar, scratch.file().string());
+  EXPECT_EQ(basalt::settingsFilePath().string(), scratch.file().string());
+  unsetEnvironment(basalt::kSettingsFileVar);
+}
+
+TEST(settings_live_under_this_desktop_own_config_directory_by_default) {
+  // Not the contents of the path -- that is the operating system's answer and
+  // differs per machine -- but its shape: somewhere absolute, in a directory of
+  // the application's own, called settings.json. An app with no identity file
+  // lands under `basalt`, which is what a host built by hand is.
+  unsetEnvironment(basalt::kSettingsFileVar);
+  const std::filesystem::path path = basalt::settingsFilePath();
+  // Empty would mean neither HOME nor APPDATA was set, which is not a machine
+  // any suite runs on; if this ever fires, the environment is the finding.
+  EXPECT(!path.empty());
+  EXPECT(path.is_absolute());
+  EXPECT_EQ(path.filename().string(), std::string("settings.json"));
+  EXPECT(!path.parent_path().filename().empty());
+}

package/native/tests/test_shadow_shape.cpp

@@ -0,0 +1,47 @@
+// A corner radius grown by a shadow's spread. See core/ShadowShape.h.
+//
+// The curve is the part worth a test: an addition would pass the first two
+// assertions below and fail every other one, and a shadow with the wrong corner
+// is the kind of difference nobody looks at closely enough to report.
+
+#include "TestHarness.h"
+
+#include "ShadowShape.h"
+
+#include <sstream>
+
+using basalt::spreadRadius;
+
+TEST(shadow_shape_a_square_corner_stays_square_without_a_spread) {
+  EXPECT_NEAR(spreadRadius(0.0, 0.0), 0.0, 0.0001);
+  EXPECT_NEAR(spreadRadius(12.0, 0.0), 12.0, 0.0001);
+}
+
+TEST(shadow_shape_a_radius_wider_than_the_spread_just_grows) {
+  // Past the knee the curve is the addition: the ratio only bends a corner
+  // tighter than the spread.
+  EXPECT_NEAR(spreadRadius(20.0, 5.0), 25.0, 0.0001);
+  EXPECT_NEAR(spreadRadius(10.0, 10.0), 20.0, 0.0001);
+}
+
+TEST(shadow_shape_a_tight_corner_is_rounded_more_gently_than_the_spread) {
+  // A square corner with a wide spread stays square: the ratio is zero, so the
+  // adjustment is multiplied by 1 + (-1)^3, which is nothing. Adding the spread
+  // would answer 10 here and turn a card's corner into a circle.
+  EXPECT_NEAR(spreadRadius(0.0, 10.0), 0.0, 0.0001);
+
+  // And in between, less than the addition but more than nothing: a quarter of
+  // the way up the ratio the cubic is still most of the way down.
+  const double grown = spreadRadius(2.0, 8.0);
+  EXPECT(grown > 2.0);
+  EXPECT(grown < 10.0);
+}
+
+TEST(shadow_shape_a_negative_spread_shrinks_and_stops_at_zero) {
+  // What an inset shadow's hole is built from.
+  EXPECT_NEAR(spreadRadius(20.0, -5.0), 15.0, 0.0001);
+  // Never negative: a radius that would go through zero is zero, and a negative
+  // one would turn a geometry inside out.
+  EXPECT_NEAR(spreadRadius(4.0, -20.0), 0.0, 0.0001);
+  EXPECT(spreadRadius(0.0, -10.0) >= 0.0);
+}

package/native/tests/test_system_locale.cpp

@@ -0,0 +1,36 @@
+// `I18nManager.isRTL`, and the three things that decide it. See
+// core/SystemLocale.h.
+
+#include "TestHarness.h"
+
+#include "SystemLocale.h"
+
+#include <sstream>
+
+using basalt::resolveRightToLeft;
+
+TEST(rtl_follows_the_locale_when_nobody_has_said_otherwise) {
+  EXPECT(resolveRightToLeft(true, std::nullopt, true));
+  EXPECT(!resolveRightToLeft(true, std::nullopt, false));
+}
+
+// `forceRTL(true)` is for an app that wants to see its own right-to-left
+// layout on a left-to-right machine, which is the only way most developers
+// ever test one.
+TEST(rtl_can_be_forced_against_the_locale) {
+  EXPECT(resolveRightToLeft(true, true, false));
+}
+
+// And `forceRTL(false)` clears the force rather than forcing the other way,
+// which is what React Native's own platforms do: an app turning it off goes
+// back to following the system.
+TEST(rtl_unforced_is_not_forced_left_to_right) {
+  EXPECT(resolveRightToLeft(true, std::nullopt, true));
+}
+
+// `allowRTL(false)` wins over everything, which is how an app that has not
+// been laid out for mirroring opts out on a machine whose owner reads Arabic.
+TEST(rtl_can_be_refused_outright) {
+  EXPECT(!resolveRightToLeft(false, std::nullopt, true));
+  EXPECT(!resolveRightToLeft(false, true, true));
+}