basalt-core 0.0.0-rc5 → 0.2.0

package/native/tests/test_device_metrics.cpp

@@ -0,0 +1,126 @@
+// What `Dimensions` and `PixelRatio` are told, which until 2026-10-10 was a
+// hardcoded 1280x720 with a zero scale and an uninitialised font scale. See
+// core/DeviceMetrics.h.
+
+#include "TestHarness.h"
+
+#include "DeviceMetrics.h"
+
+#include <sstream>
+#include <vector>
+
+using basalt::deviceMetricsFrom;
+using basalt::DisplayInfo;
+using basalt::WindowBounds;
+
+namespace {
+
+DisplayInfo display(double x, double width, double scale, bool primary) {
+  DisplayInfo info;
+  info.x = x;
+  info.y = 0.0;
+  info.width = width;
+  info.height = 900.0;
+  info.workX = x;
+  info.workWidth = width;
+  info.workHeight = 900.0;
+  info.scaleFactor = scale;
+  info.primary = primary;
+  return info;
+}
+
+WindowBounds window(double x, double width, double height) {
+  WindowBounds bounds;
+  bounds.x = x;
+  bounds.y = 0.0;
+  bounds.width = width;
+  bounds.height = height;
+  return bounds;
+}
+
+} // namespace
+
+TEST(device_metrics_report_the_window_and_the_screen_it_is_on) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 2.0, true)};
+  const auto metrics = deviceMetricsFrom(window(100.0, 900.0, 732.0), 900.0, 700.0, displays, 1.0);
+
+  EXPECT_EQ((long)metrics.window.width, 900L);
+  // The surface, not the frame: the window is 732 tall and 32 of that is a
+  // title bar the app cannot lay anything out in.
+  EXPECT_EQ((long)metrics.window.height, 700L);
+  // The screen is the display, not the window: the distinction React Native
+  // draws, and one that matters on a desktop where a window is a fraction of a
+  // screen.
+  EXPECT_EQ((long)metrics.screen.width, 1440L);
+  EXPECT_EQ((long)metrics.screen.height, 900L);
+  EXPECT_EQ((long)metrics.window.scale, 2L);
+  EXPECT_EQ((long)metrics.screen.scale, 2L);
+}
+
+// Which display a window is on is its centre's, so a window straddling two
+// reports the one most of it is on.
+TEST(device_metrics_follow_the_window_to_another_display) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 2.0, true),
+                                          display(1440.0, 1920.0, 1.0, false)};
+
+  const auto onFirst = deviceMetricsFrom(window(1000.0, 800.0, 600.0), 0.0, 0.0, displays, 1.0);
+  EXPECT_EQ((long)onFirst.window.scale, 2L);
+  EXPECT_EQ((long)onFirst.screen.width, 1440L);
+
+  const auto onSecond = deviceMetricsFrom(window(2000.0, 800.0, 600.0), 0.0, 0.0, displays, 1.0);
+  EXPECT_EQ((long)onSecond.window.scale, 1L);
+  EXPECT_EQ((long)onSecond.screen.width, 1920L);
+}
+
+// `PixelRatio.get()` is this number and `roundToNearestPixel` divides by it, so
+// a zero is a NaN in an app's layout arithmetic -- which is what upstream's
+// hardcoded constants produced.
+TEST(device_metrics_never_report_a_zero_scale) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 0.0, true)};
+  const auto metrics = deviceMetricsFrom(window(0.0, 900.0, 700.0), 0.0, 0.0, displays, 0.0);
+
+  EXPECT_EQ((long)metrics.window.scale, 1L);
+  EXPECT_EQ((long)metrics.window.fontScale, 1L);
+  EXPECT_EQ((long)metrics.screen.scale, 1L);
+  EXPECT_EQ((long)metrics.screen.fontScale, 1L);
+}
+
+// The text scale rides along, because `Dimensions` is where React Native puts
+// it and `PixelRatio.getFontScale()` is what reads it.
+TEST(device_metrics_carry_the_text_scale) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 1.0, true)};
+  const auto metrics = deviceMetricsFrom(window(0.0, 900.0, 700.0), 0.0, 0.0, displays, 1.5);
+
+  EXPECT_EQ((long)(metrics.window.fontScale * 10), 15L);
+  EXPECT_EQ((long)(metrics.screen.fontScale * 10), 15L);
+}
+
+// Before the host has reported a window at all, which is where an app's first
+// render is. Zero would be divided by.
+TEST(device_metrics_borrow_the_screen_before_the_first_frame) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 2.0, true)};
+  const auto metrics = deviceMetricsFrom(WindowBounds{}, 0.0, 0.0, displays, 1.0);
+
+  EXPECT_EQ((long)metrics.window.width, 1440L);
+  EXPECT_EQ((long)metrics.window.height, 900L);
+}
+
+// And with no displays either, which is a host that has reported nothing: the
+// numbers are zero rather than invented, but the two scales are still one.
+TEST(device_metrics_with_nothing_reported_are_zero_but_divisible) {
+  const auto metrics = deviceMetricsFrom(WindowBounds{}, 0.0, 0.0, {}, 1.0);
+
+  EXPECT_EQ((long)metrics.window.width, 0L);
+  EXPECT_EQ((long)metrics.window.scale, 1L);
+  EXPECT_EQ((long)metrics.window.fontScale, 1L);
+}
+
+// A window whose surface has not started yet reports the window itself, which
+// is the closest thing there is to an answer before the first layout.
+TEST(device_metrics_fall_back_to_the_window_before_a_surface_starts) {
+  const std::vector<DisplayInfo> displays{display(0.0, 1440.0, 1.0, true)};
+  const auto metrics = deviceMetricsFrom(window(0.0, 820.0, 640.0), 0.0, 0.0, displays, 1.0);
+
+  EXPECT_EQ((long)metrics.window.width, 820L);
+  EXPECT_EQ((long)metrics.window.height, 640L);
+}

package/native/tests/test_filters.cpp

@@ -0,0 +1,271 @@
+// The arithmetic behind `filter`, against the Filter Effects spec's own numbers.
+//
+// Seven of the nine functions are affine maps of colour, so the test for each is
+// a colour in and a colour out rather than a matrix compared against itself: the
+// spec says what grayscale(1) does to red, and that is checkable without
+// agreeing on how a matrix is stored. See core/Filters.h.
+
+#include "TestHarness.h"
+
+#include "Filters.h"
+
+#include <cmath>
+#include <sstream>
+
+using basalt::ColorMatrix;
+using basalt::ResolvedFilters;
+using basalt::resolveFilters;
+using facebook::react::FilterFunction;
+using facebook::react::FilterType;
+
+namespace {
+
+FilterFunction filter(FilterType type, double amount) {
+  FilterFunction function;
+  function.type = type;
+  function.parameters = static_cast<facebook::react::Float>(amount);
+  return function;
+}
+
+// The colour a list of filters makes of one colour, straight (not
+// premultiplied), which is the space both hosts apply the matrix in.
+struct Colour {
+  float red;
+  float green;
+  float blue;
+  float alpha;
+};
+
+Colour through(const std::vector<FilterFunction> &filters, Colour in) {
+  const ResolvedFilters resolved = resolveFilters(filters);
+  const float input[4] = {in.red, in.green, in.blue, in.alpha};
+  float output[4] = {0, 0, 0, 0};
+  resolved.matrix.apply(input, output);
+  return Colour{output[0], output[1], output[2], output[3]};
+}
+
+bool near(float a, float b, float slack = 0.002F) { return std::fabs(a - b) <= slack; }
+
+constexpr Colour kRed{1, 0, 0, 1};
+constexpr Colour kWhite{1, 1, 1, 1};
+constexpr Colour kBlack{0, 0, 0, 1};
+
+} // namespace
+
+// grayscale(1) replaces a colour with its luminance, and the weights are Rec.
+// 709's: red is 0.2126 of white. A matrix built from the wrong weights -- the
+// older 0.299/0.587/0.114 is the usual mistake -- gives 0.299 here.
+TEST(filters_grayscale_uses_the_luminance_weights_the_spec_names) {
+  const Colour grey = through({filter(FilterType::Grayscale, 1.0)}, kRed);
+  EXPECT(near(grey.red, 0.2126F));
+  EXPECT(near(grey.green, 0.2126F));
+  EXPECT(near(grey.blue, 0.2126F));
+  // Alpha is untouched: a filter that greys a colour does not make it
+  // transparent.
+  EXPECT(near(grey.alpha, 1.0F));
+
+  // Half way is half way between the colour and its luminance.
+  const Colour half = through({filter(FilterType::Grayscale, 0.5)}, kRed);
+  EXPECT(near(half.red, (1.0F + 0.2126F) / 2.0F));
+}
+
+// saturate(0) is grayscale(1) from the other end, which is how the spec defines
+// both, and a good check that one is not written twice with different numbers.
+TEST(filters_saturate_at_zero_is_grayscale) {
+  const Colour saturated = through({filter(FilterType::Saturate, 0.0)}, kRed);
+  const Colour grey = through({filter(FilterType::Grayscale, 1.0)}, kRed);
+  EXPECT(near(saturated.red, grey.red));
+  EXPECT(near(saturated.green, grey.green));
+  EXPECT(near(saturated.blue, grey.blue));
+
+  // And over-saturating is allowed: the prop takes any non-negative number.
+  const Colour over = through({filter(FilterType::Saturate, 2.0)}, Colour{0.5F, 0.5F, 0.6F, 1});
+  EXPECT(over.blue > 0.6F);
+}
+
+TEST(filters_invert_turns_black_white_and_back) {
+  const Colour inverted = through({filter(FilterType::Invert, 1.0)}, kBlack);
+  EXPECT(near(inverted.red, 1.0F));
+  EXPECT(near(inverted.green, 1.0F));
+  EXPECT(near(inverted.blue, 1.0F));
+
+  // Half an inversion is mid grey, whatever it started as: that is the point of
+  // the interpolation rather than a plain one-minus.
+  const Colour half = through({filter(FilterType::Invert, 0.5)}, kBlack);
+  EXPECT(near(half.red, 0.5F));
+  const Colour halfWhite = through({filter(FilterType::Invert, 0.5)}, kWhite);
+  EXPECT(near(halfWhite.red, 0.5F));
+}
+
+TEST(filters_brightness_scales_and_contrast_pivots_on_grey) {
+  const Colour brighter = through({filter(FilterType::Brightness, 2.0)}, Colour{0.25F, 0.25F, 0.25F, 1});
+  EXPECT(near(brighter.red, 0.5F));
+
+  // contrast(0) collapses everything onto mid grey; contrast(1) changes nothing.
+  const Colour flat = through({filter(FilterType::Contrast, 0.0)}, kRed);
+  EXPECT(near(flat.red, 0.5F));
+  EXPECT(near(flat.blue, 0.5F));
+  const Colour same = through({filter(FilterType::Contrast, 1.0)}, kRed);
+  EXPECT(near(same.red, 1.0F));
+  EXPECT(near(same.blue, 0.0F));
+  // And doubling it pushes away from grey in both directions.
+  const Colour harder = through({filter(FilterType::Contrast, 2.0)}, Colour{0.75F, 0.25F, 0.5F, 1});
+  EXPECT(near(harder.red, 1.0F));
+  EXPECT(near(harder.green, 0.0F));
+  EXPECT(near(harder.blue, 0.5F));
+}
+
+TEST(filters_sepia_matches_the_matrix_the_spec_prints) {
+  const Colour sepia = through({filter(FilterType::Sepia, 1.0)}, kRed);
+  EXPECT(near(sepia.red, 0.393F));
+  EXPECT(near(sepia.green, 0.349F));
+  EXPECT(near(sepia.blue, 0.272F));
+}
+
+// A full turn is the identity, which is the cheapest check that the rotation is
+// a rotation; and a quarter turn moves a hue without moving its luminance, which
+// is the property the spec's matrix is built around.
+TEST(filters_hue_rotate_comes_back_round) {
+  const Colour full = through({filter(FilterType::HueRotate, 360.0)}, kRed);
+  EXPECT(near(full.red, 1.0F, 0.01F));
+  EXPECT(near(full.green, 0.0F, 0.01F));
+  EXPECT(near(full.blue, 0.0F, 0.01F));
+
+  const Colour quarter = through({filter(FilterType::HueRotate, 120.0)}, kRed);
+  EXPECT(!near(quarter.red, 1.0F, 0.1F));
+  const float before = 0.2126F;
+  const float after = 0.2126F * quarter.red + 0.7152F * quarter.green + 0.0722F * quarter.blue;
+  EXPECT(near(after, before, 0.02F));
+}
+
+// Two filters are one matrix, applied in the order they were written. Brightness
+// then grayscale is not the same as grayscale then brightness for a saturated
+// colour... except that both are linear, which is why this asserts the composed
+// answer rather than an order-dependence that does not exist.
+TEST(filters_a_list_of_colour_filters_is_one_matrix) {
+  const ResolvedFilters resolved =
+      resolveFilters({filter(FilterType::Grayscale, 1.0), filter(FilterType::Brightness, 2.0)});
+  EXPECT(resolved.hasMatrix);
+  EXPECT(near(resolved.blurRadius, 0.0F));
+
+  const Colour both = through(
+      {filter(FilterType::Grayscale, 1.0), filter(FilterType::Brightness, 2.0)}, kRed);
+  EXPECT(near(both.red, 0.2126F * 2.0F));
+  EXPECT(near(both.green, 0.2126F * 2.0F));
+}
+
+// Opacity is alpha, not colour, and several of them multiply.
+TEST(filters_opacity_multiplies) {
+  EXPECT(near(resolveFilters({filter(FilterType::Opacity, 0.5)}).opacity, 0.5F));
+  EXPECT(near(
+      resolveFilters({filter(FilterType::Opacity, 0.5), filter(FilterType::Opacity, 0.5)}).opacity,
+      0.25F));
+  EXPECT(near(resolveFilters({filter(FilterType::Grayscale, 1.0)}).opacity, 1.0F));
+}
+
+// Two blurs are one blur of the combined variance, which is what convolving two
+// gaussians gives: 3 and 4 make 5, not 7.
+TEST(filters_two_blurs_compose_in_quadrature) {
+  EXPECT(near(resolveFilters({filter(FilterType::Blur, 8.0)}).blurRadius, 8.0F));
+  const float composed =
+      resolveFilters({filter(FilterType::Blur, 6.0), filter(FilterType::Blur, 8.0)}).blurRadius;
+  EXPECT(near(composed, 10.0F, 0.01F));
+}
+
+// A drop shadow is the one function that does not commute with the others, so it
+// is kept as a shadow rather than folded in -- and the rest of the list still
+// applies, which is what stops one function taking a whole style with it.
+TEST(filters_a_drop_shadow_is_kept_and_the_rest_still_applies) {
+  FilterFunction shadow;
+  shadow.type = FilterType::DropShadow;
+  shadow.parameters = facebook::react::DropShadowParams{};
+
+  const ResolvedFilters resolved =
+      resolveFilters({shadow, filter(FilterType::Grayscale, 1.0)});
+  EXPECT(resolved.hasDropShadow);
+  EXPECT_EQ((int)resolved.dropShadows.size(), 1);
+  EXPECT(resolved.hasMatrix);
+  EXPECT(!resolved.empty());
+}
+
+// The numbers come through as React Native parsed them: an offset, a standard
+// deviation -- not a CSS blur radius, which is what the field is named after --
+// and a colour. Each host converts from the sigma to whatever its own shadow
+// takes, so getting this wrong is a shadow twice as soft on one desktop.
+TEST(filters_a_drop_shadow_carries_its_offset_sigma_and_colour) {
+  FilterFunction function;
+  function.type = FilterType::DropShadow;
+  facebook::react::DropShadowParams params;
+  params.offsetX = 4;
+  params.offsetY = -6;
+  params.standardDeviation = 3;
+  params.color = facebook::react::colorFromComponents(
+      facebook::react::ColorComponents{1.0F, 0.0F, 0.0F, 0.5F});
+  function.parameters = params;
+
+  const ResolvedFilters resolved = resolveFilters({function});
+  EXPECT_EQ((int)resolved.dropShadows.size(), 1);
+  if (resolved.dropShadows.empty()) {
+    return;
+  }
+  const basalt::FilterShadow &shadow = resolved.dropShadows[0];
+  EXPECT(near(shadow.dx, 4.0F, 0.001F));
+  EXPECT(near(shadow.dy, -6.0F, 0.001F));
+  EXPECT(near(shadow.standardDeviation, 3.0F, 0.001F));
+  EXPECT(near(shadow.red, 1.0F, 0.01F));
+  EXPECT(near(shadow.green, 0.0F, 0.01F));
+  EXPECT(near(shadow.alpha, 0.5F, 0.01F));
+}
+
+// No colour is legal CSS -- it means `currentColor` -- and nothing here has one,
+// so it is opaque black. The alternative is dropping a declaration that parsed,
+// which is worse than a shadow in the wrong colour.
+TEST(filters_a_drop_shadow_with_no_colour_is_black) {
+  FilterFunction function;
+  function.type = FilterType::DropShadow;
+  function.parameters = facebook::react::DropShadowParams{};
+
+  const ResolvedFilters resolved = resolveFilters({function});
+  EXPECT_EQ((int)resolved.dropShadows.size(), 1);
+  if (resolved.dropShadows.empty()) {
+    return;
+  }
+  EXPECT(near(resolved.dropShadows[0].alpha, 1.0F, 0.01F));
+  EXPECT(near(resolved.dropShadows[0].red, 0.0F, 0.01F));
+}
+
+// Several of them, in the order they were written: CSS applies a filter list
+// left to right, so the first drop shadow is the one nearest the content, and a
+// host that reversed them would put the wrong one on top.
+TEST(filters_drop_shadows_keep_their_order) {
+  FilterFunction first;
+  first.type = FilterType::DropShadow;
+  facebook::react::DropShadowParams nearParams;
+  nearParams.offsetX = 1;
+  first.parameters = nearParams;
+
+  FilterFunction second;
+  second.type = FilterType::DropShadow;
+  facebook::react::DropShadowParams farParams;
+  farParams.offsetX = 9;
+  second.parameters = farParams;
+
+  const ResolvedFilters resolved = resolveFilters({first, second});
+  EXPECT_EQ((int)resolved.dropShadows.size(), 2);
+  if (resolved.dropShadows.size() != 2) {
+    return;
+  }
+  EXPECT(near(resolved.dropShadows[0].dx, 1.0F, 0.001F));
+  EXPECT(near(resolved.dropShadows[1].dx, 9.0F, 0.001F));
+}
+
+TEST(filters_an_empty_list_is_nothing_to_do) {
+  const ResolvedFilters resolved = resolveFilters({});
+  EXPECT(resolved.empty());
+  EXPECT(resolved.matrix.isIdentity());
+  EXPECT(!resolved.hasDropShadow);
+
+  // And a filter that does nothing is still nothing to do, which keeps a host
+  // from pushing an identity matrix node for `brightness(1)`.
+  EXPECT(resolveFilters({filter(FilterType::Brightness, 1.0)}).matrix.isIdentity());
+}

package/native/tests/test_font_fitting.cpp

@@ -0,0 +1,172 @@
+// `adjustsFontSizeToFit`: the search that finds how far to shrink a paragraph.
+//
+// The search is core's and the measuring is each host's, so this hands it a
+// measurement that is arithmetic -- a paragraph whose size is proportional to
+// its font size, which is what a single line of text actually is. That makes
+// the ratio predictable and the assertions about the *rules* rather than about
+// a font.
+
+#include "TestHarness.h"
+
+#include "FontFitting.h"
+
+#include <limits>
+#include <sstream>
+
+using basalt::FontFit;
+using basalt::FontFitBox;
+using basalt::fontFitToBox;
+
+namespace {
+
+// A line of text `width` by `height` at its natural size, measured at a ratio.
+//
+// Linear in the ratio, which a single unwrapped line is: twice the font size is
+// twice the width and twice the height.
+auto line(double width, double height) {
+  return [width, height](double ratio) {
+    return FontFitBox{.width = width * ratio, .height = height * ratio};
+  };
+}
+
+} // namespace
+
+TEST(fit_text_that_already_fits_is_not_touched) {
+  // Upstream's first move, and the reason the prop never grows anything: a
+  // paragraph that fits is done, whatever room is left over.
+  const FontFit fit = fontFitToBox(FontFit{}, line(50, 10), FontFitBox{.width = 200, .height = 100});
+  EXPECT(!fit.scales());
+  EXPECT_NEAR(fit.ratio, 1.0, 0.0001);
+}
+
+TEST(fit_text_twice_too_wide_is_halved) {
+  // 200 wide in a 100 box: the ratio that fits is a half, and the search should
+  // land within a hair of it rather than at some ratio that merely fits.
+  const FontFit fit = fontFitToBox(FontFit{}, line(200, 10), FontFitBox{.width = 100, .height = 50});
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio > 0.45);
+  EXPECT(fit.ratio <= 0.5);
+}
+
+TEST(fit_the_height_can_be_what_binds) {
+  // A paragraph narrow enough and too tall: the search has to shrink for the
+  // dimension that does not fit, not only for the width.
+  const FontFit fit = fontFitToBox(FontFit{}, line(10, 200), FontFitBox{.width = 100, .height = 50});
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio <= 0.25);
+}
+
+TEST(fit_a_box_with_no_size_is_not_fitted_to) {
+  // An infinite dimension is Yoga saying "as much as you need", and a
+  // paragraph measured unconstrained always fits.
+  const double infinity = std::numeric_limits<double>::infinity();
+  EXPECT(!fontFitToBox(FontFit{}, line(200, 10), FontFitBox{.width = infinity, .height = 50})
+              .scales());
+  EXPECT(!fontFitToBox(FontFit{}, line(200, 10), FontFitBox{.width = 100, .height = infinity})
+              .scales());
+  // And a box of nothing is not a box: a paragraph in a zero-width column would
+  // otherwise shrink to the floor.
+  EXPECT(!fontFitToBox(FontFit{}, line(200, 10), FontFitBox{.width = 0, .height = 0}).scales());
+}
+
+TEST(fit_the_minimum_size_is_a_floor_and_not_a_refusal) {
+  // The clamp belongs to the fitting rather than to the text: scaling by the
+  // ratio and then clamping is what keeps a paragraph of mixed sizes in
+  // proportion until the floor bites.
+  FontFit limits;
+  limits.minimum = 10.0;
+  const FontFit fit =
+      fontFitToBox(limits, line(400, 10), FontFitBox{.width = 100, .height = 50});
+  EXPECT(fit.scales());
+  // A 16pt fragment would want 4pt and gets the floor.
+  EXPECT_NEAR(fit.apply(16.0), 10.0, 0.0001);
+  // And a fragment already below the floor is raised to it, which is what a
+  // minimum means: the search is about the paragraph, not about one fragment.
+  EXPECT_NEAR(fit.apply(2.0), 10.0, 0.0001);
+}
+
+TEST(fit_the_maximum_size_bounds_the_scaled_result) {
+  FontFit limits;
+  limits.maximum = 20.0;
+  FontFit scaled = limits;
+  scaled.ratio = 0.5;
+  EXPECT_NEAR(scaled.apply(80.0), 20.0, 0.0001);
+  EXPECT_NEAR(scaled.apply(30.0), 15.0, 0.0001);
+}
+
+TEST(fit_an_unscaled_paragraph_is_not_clamped) {
+  // The bounds are the fitting's, not the text's: a 200pt heading in an app
+  // that named a maximum of 96 is still 200pt while it fits.
+  FontFit limits;
+  limits.maximum = 96.0;
+  EXPECT_NEAR(limits.apply(200.0), 200.0, 0.0001);
+}
+
+TEST(fit_a_contradictory_pair_of_bounds_lets_the_minimum_win) {
+  // An app that asked for a minimum above its maximum has said something
+  // impossible; readable text is the better answer than invisible text.
+  facebook::react::ParagraphAttributes attributes;
+  attributes.minimumFontSize = 30.0F;
+  attributes.maximumFontSize = 10.0F;
+  const FontFit fit = basalt::fontFitLimits(attributes);
+  EXPECT_NEAR(fit.minimum, 30.0, 0.0001);
+  EXPECT_NEAR(fit.maximum, 30.0, 0.0001);
+}
+
+TEST(fit_unset_bounds_are_the_ones_ios_uses) {
+  // NaN is React Native's "nothing here", and the defaults are
+  // RCTTextLayoutManager's own rather than numbers invented here.
+  const FontFit fit = basalt::fontFitLimits(facebook::react::ParagraphAttributes{});
+  EXPECT_NEAR(fit.minimum, basalt::kFontFitMinimumSize, 0.0001);
+  EXPECT_NEAR(fit.maximum, basalt::kFontFitMaximumSize, 0.0001);
+}
+
+TEST(fit_a_paragraph_that_cannot_fit_at_all_still_answers) {
+  // Text a hundred times too big, with the floor in the way: the search closes
+  // on the smallest ratio that fitted rather than running for ever, and the
+  // clamp is what keeps the result legible.
+  FontFit limits;
+  limits.minimum = 8.0;
+  const FontFit fit =
+      fontFitToBox(limits, line(10000, 10), FontFitBox{.width = 100, .height = 50});
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio > 0.0);
+  EXPECT_NEAR(fit.apply(16.0), 8.0, 0.0001);
+}
+
+TEST(fit_a_minimum_scale_is_a_floor_on_the_ratio) {
+  // `minimumFontScale` is the same floor as `minimumFontSize` said as a ratio,
+  // which is Android's spelling of the prop. iOS ignores it; there is no reason
+  // to here, the search being a search over exactly this number.
+  FontFit limits;
+  limits.minimumRatio = 0.75;
+  const FontFit fit =
+      fontFitToBox(limits, line(400, 10), FontFitBox{.width = 100, .height = 50});
+  EXPECT(fit.scales());
+  EXPECT(fit.ratio >= 0.75);
+  // And the text does not fit at that ratio, which is the floor doing its job
+  // rather than the search failing: 400 * 0.75 is still past 100.
+  EXPECT_NEAR(fit.apply(16.0), 12.0, 0.0001);
+}
+
+TEST(fit_a_minimum_scale_of_one_refuses_to_shrink_at_all) {
+  // A legal thing to ask for, and worth not reading as "unset": the paragraph
+  // overflows rather than being made smaller.
+  FontFit limits;
+  limits.minimumRatio = 1.0;
+  const FontFit fit =
+      fontFitToBox(limits, line(400, 10), FontFitBox{.width = 100, .height = 50});
+  EXPECT_NEAR(fit.ratio, 1.0, 0.0001);
+}
+
+TEST(fit_an_unset_minimum_scale_is_not_a_floor_of_zero) {
+  facebook::react::ParagraphAttributes attributes;
+  EXPECT_NEAR(basalt::fontFitLimits(attributes).minimumRatio, 0.0, 0.0001);
+  // And a value outside React Native's own documented range is clamped into it
+  // rather than trusted: 0 would be a floor of nothing and 2 would be a floor
+  // above the ceiling.
+  attributes.minimumFontScale = 0.0F;
+  EXPECT_NEAR(basalt::fontFitLimits(attributes).minimumRatio, 0.01, 0.0001);
+  attributes.minimumFontScale = 2.0F;
+  EXPECT_NEAR(basalt::fontFitLimits(attributes).minimumRatio, 1.0, 0.0001);
+}