basalt-appkit 0.0.0-rc5

package/native/tests/test_appkit_scrollbar.mm

@@ -0,0 +1,132 @@
+// The overlay scrollbar, on the macOS view layer.
+//
+// core/ScrollIndicator.h is where the geometry is decided, and
+// tests/test_scroll_indicator.cpp already checks the arithmetic. What is left
+// is the part that is only true on this platform: AppKit draws subviews *over*
+// their superview, and a ScrollView always has one -- its content -- covering
+// the whole of it. So the thumb is a view of its own, kept last among the
+// subviews, which is AppKit's definition of topmost.
+//
+// That is the decision worth a test. A thumb drawn in the scroll view's own
+// `drawRect:` would compute exactly the same numbers, report exactly the same
+// dump line, and be invisible behind the list.
+
+#include "ScrollIndicator.h"
+#include "TestHarness.h"
+
+#import "RnAppKitView.h"
+
+namespace {
+
+// The view the scrollbars are drawn into, which is deliberately not an
+// RnAppKitView -- that is what keeps it out of the paint order, out of hit
+// testing and out of the tree dump's children.
+NSView *indicatorViewOf(RnAppKitView *view) {
+  NSView *last = view.subviews.lastObject;
+  if (last == nil || [last isKindOfClass:[RnAppKitView class]]) {
+    return nil;
+  }
+  return last;
+}
+
+RnAppKitView *scrollViewWithIndicators(CGFloat width, CGFloat height) {
+  RnAppKitView *view = [RnAppKitView viewWithTag:1];
+  [view setRnFrameX:0 y:0 width:width height:height];
+  // A hundred-point window onto four hundred points of content, which
+  // core/ScrollIndicator.h turns into a quarter-length thumb.
+  const basalt::ScrollIndicator vertical = basalt::scrollIndicatorFor(height, height * 4, 0);
+  [view setRnScrollIndicatorVerticalOffset:vertical.offset
+                            verticalLength:vertical.length
+                          horizontalOffset:0
+                          horizontalLength:0];
+  return view;
+}
+
+// Draws one view into a white bitmap and answers whether anything landed on the
+// pixel asked for. Alpha 0.35 black over white is mid-grey, so "darker than
+// white" is the whole test -- nothing here pins a colour.
+bool inkAt(NSView *view, CGSize size, int atX, int atY) {
+  CGColorSpaceRef space = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+  CGContextRef context = CGBitmapContextCreate(nullptr, (size_t)size.width, (size_t)size.height, 8,
+                                               0, space, kCGImageAlphaPremultipliedLast);
+  CGColorSpaceRelease(space);
+  CGContextSetRGBFillColor(context, 1, 1, 1, 1);
+  CGContextFillRect(context, CGRectMake(0, 0, size.width, size.height));
+  // A CGBitmapContext counts y from the bottom and this view counts it from the
+  // top, and `graphicsContextWithCGContext:flipped:` only *declares* which way
+  // up a context is -- it applies no transform. Without this the assertions
+  // below would be upside down, and a thumb at the bottom would pass a test
+  // written for one at the top.
+  CGContextTranslateCTM(context, 0, size.height);
+  CGContextScaleCTM(context, 1, -1);
+
+  NSGraphicsContext *previous = NSGraphicsContext.currentContext;
+  NSGraphicsContext.currentContext = [NSGraphicsContext graphicsContextWithCGContext:context
+                                                                             flipped:YES];
+  [view drawRect:NSMakeRect(0, 0, size.width, size.height)];
+  NSGraphicsContext.currentContext = previous;
+
+  auto *pixels = static_cast<unsigned char *>(CGBitmapContextGetData(context));
+  const size_t stride = CGBitmapContextGetBytesPerRow(context);
+  const bool marked = pixels[(size_t)atY * stride + (size_t)atX * 4] < 250;
+  CGContextRelease(context);
+  return marked;
+}
+
+} // namespace
+
+// The thumb exists, and it is the last subview -- which is the one AppKit draws
+// on top of the others.
+TEST(appkit_scrollbar_is_the_topmost_subview) {
+  RnAppKitView *view = scrollViewWithIndicators(100, 100);
+  NSView *indicators = indicatorViewOf(view);
+  EXPECT(indicators != nil);
+
+  // A content view arrives, as one always does: React Native wraps a
+  // ScrollView's children in exactly one.
+  RnAppKitView *content = [RnAppKitView viewWithTag:2];
+  [content setRnFrameX:0 y:0 width:100 height:400];
+  [view insertRnChild:content atIndex:0];
+  EXPECT(indicatorViewOf(view) == indicators);
+
+  // And again past the end of the list, which is the insert that appends.
+  RnAppKitView *second = [RnAppKitView viewWithTag:3];
+  [view insertRnChild:second atIndex:5];
+  EXPECT(indicatorViewOf(view) == indicators);
+}
+
+// It is paint and nothing else: a press goes to the content underneath.
+TEST(appkit_scrollbar_is_not_a_hit_target) {
+  RnAppKitView *view = scrollViewWithIndicators(100, 100);
+  NSView *indicators = indicatorViewOf(view);
+  EXPECT([indicators hitTest:NSMakePoint(97, 10)] == nil);
+}
+
+// The thumb lands at the trailing edge, at the top, and nowhere else.
+TEST(appkit_scrollbar_draws_at_the_trailing_edge) {
+  RnAppKitView *view = scrollViewWithIndicators(100, 100);
+  NSView *indicators = indicatorViewOf(view);
+  EXPECT(indicators != nil);
+
+  const CGSize size = CGSizeMake(100, 100);
+  // Inside the bar: two in from the right edge, three more into its six points
+  // of thickness, and ten down -- which is inside a thumb a quarter of 96 long.
+  EXPECT(inkAt(indicators, size, 95, 10));
+  // The middle of the view, where a scrollbar has no business being.
+  EXPECT(!inkAt(indicators, size, 50, 50));
+  // Past the end of the thumb: it starts at the top, so the bottom is bare.
+  EXPECT(!inkAt(indicators, size, 95, 90));
+}
+
+// Content that fits takes the whole thing away again, rather than leaving a
+// zero-length bar behind.
+TEST(appkit_scrollbar_goes_away_when_everything_fits) {
+  RnAppKitView *view = scrollViewWithIndicators(100, 100);
+  EXPECT(indicatorViewOf(view) != nil);
+
+  [view setRnScrollIndicatorVerticalOffset:0
+                            verticalLength:0
+                          horizontalOffset:0
+                          horizontalLength:0];
+  EXPECT(indicatorViewOf(view) == nil);
+}

package/native/tests/test_appkit_services.mm

@@ -0,0 +1,57 @@
+// Tests for macOS's half of the platform-services seam.
+//
+// The clipboard and URL halves only. The alert is tested from JavaScript
+// instead; see the note further down for why it cannot be tested here.
+
+#include "TestHarness.h"
+
+#include "PlatformServices.h"
+
+#import <Cocoa/Cocoa.h>
+
+#include <sstream>
+#include <string>
+
+TEST(clipboard_round_trips) {
+  @autoreleasepool {
+    const std::string original = basalt::clipboardText();
+
+    basalt::setClipboardText("basalt round trip");
+    EXPECT_EQ(basalt::clipboardText(), std::string("basalt round trip"));
+
+    // Unicode, because NSPasteboard is UTF-16 inside and the conversion either
+    // way is where a clipboard loses characters.
+    basalt::setClipboardText("héllo · 世界");
+    EXPECT_EQ(basalt::clipboardText(), std::string("héllo · 世界"));
+
+    // Put back whatever was there: this is the user's clipboard, not the
+    // suite's.
+    basalt::setClipboardText(original);
+  }
+}
+
+TEST(can_open_url_answers_by_scheme) {
+  @autoreleasepool {
+    // Something is always registered for http on a Mac.
+    EXPECT(basalt::canOpenUrl("https://example.com"));
+    EXPECT(!basalt::canOpenUrl("zzznotascheme:whatever"));
+    EXPECT(!basalt::canOpenUrl(""));
+    EXPECT(!basalt::canOpenUrl("not a url at all"));
+  }
+}
+
+// There is no test here for the alert, deliberately.
+//
+// A sheet attaches to a key or main window, and a command-line binary's
+// activation policy is `prohibited` -- its windows can never become either. So
+// showAlert falls back to a modal run loop, which is right in the real case it
+// exists for (an alert before the first window is on screen) and puts a real
+// dialog on the developer's actual desktop when a test does it. It did, once,
+// while this was being written.
+//
+// What the alert needs proving about it is that it does not block: it is called
+// from the JavaScript thread, and a modal run loop there would freeze every
+// mount, timer and animation frame until somebody clicked. That is checked by
+// js/alert.js instead, which keeps a 300ms heartbeat running and shows an alert
+// half a second in -- the ticks carry straight on past it, which a blocking
+// implementation could not do.

package/native/tests/test_appkit_skia.mm

@@ -0,0 +1,212 @@
+// That Skia actually renders on this host, rather than merely linking.
+//
+// `RNSkiaModule: Skia installed` says the bindings were constructed. It does not
+// say a pixel can be drawn, and the two are a long way apart: a Metal device that
+// fails to create, a GrDirectContext that comes back null, a surface that wraps a
+// texture nothing can read -- each of those installs perfectly well and then
+// produces nothing. So this draws a known shape into an offscreen surface and
+// reads the pixels back out.
+//
+// Against real pixels rather than against the objects returned, for the reason
+// test_appkit_image.mm gives about resize modes: a call that returned a plausible
+// surface and drew nowhere would pass either way. What is asserted is where the
+// ink landed.
+//
+// Only compiled when the build was pointed at an app that has the package, so
+// these run on a developer's machine and not in CI -- which has no app and so no
+// Skia. See ../../basalt-core/native/cmake/Skia.cmake.
+
+#include "TestHarness.h"
+
+#include "AppKitSkiaContext.h"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
+
+#include <cstdint>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace {
+
+constexpr int kSize = 64;
+
+// The context as the module builds it, minus the call invoker. Nothing here
+// crosses to the JavaScript thread, so a null one is honest: it would be used by
+// runOnJavascriptThread, which no test below reaches.
+std::shared_ptr<RNSkia::RNSkPlatformContext> context() {
+  static std::shared_ptr<RNSkia::RNSkPlatformContext> shared =
+      basalt::makeSkiaPlatformContext(nullptr);
+  return shared;
+}
+
+// One pixel, read back from a GPU surface. Premultiplied BGRA is what
+// MakeOffscreen's texture is, and readPixels converts into whatever is asked
+// for -- RGBA here, so the assertions below read in the order the names suggest.
+struct Pixel {
+  uint8_t r = 0, g = 0, b = 0, a = 0;
+
+  std::string describe() const {
+    std::ostringstream out;
+    out << "rgba(" << (int)r << "," << (int)g << "," << (int)b << "," << (int)a << ")";
+    return out.str();
+  }
+};
+
+std::vector<Pixel> readBack(const sk_sp<SkSurface> &surface) {
+  sk_sp<SkImage> snapshot = surface->makeImageSnapshot();
+  if (snapshot == nullptr) {
+    return {};
+  }
+  const SkImageInfo info =
+      SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+  std::vector<Pixel> pixels(static_cast<size_t>(kSize) * kSize);
+  // Through the direct context, because the image is texture-backed: the
+  // no-context overload returns false for one and the failure looks like an
+  // all-zero bitmap, which is also what a surface nothing drew into looks like.
+  if (!snapshot->readPixels(context()->getDirectContext(), info, pixels.data(),
+                            kSize * sizeof(Pixel), 0, 0)) {
+    return {};
+  }
+  return pixels;
+}
+
+const Pixel &at(const std::vector<Pixel> &pixels, int x, int y) {
+  return pixels[static_cast<size_t>(y) * kSize + x];
+}
+
+} // namespace
+
+TEST(skia_has_a_gpu_context) {
+  // If this is null nothing below can work, and the reason is a Metal device
+  // that would not create rather than anything about Skia.
+  EXPECT(context()->getDirectContext() != nullptr);
+}
+
+TEST(skia_makes_an_offscreen_surface) {
+  // The call an app renders frames for export through; see kino's
+  // export/renderFrame.tsx, which is Skia.Surface.MakeOffscreen.
+  sk_sp<SkSurface> surface = context()->makeOffscreenSurface(kSize, kSize);
+  EXPECT(surface != nullptr);
+  EXPECT_EQ(surface->width(), kSize);
+  EXPECT_EQ(surface->height(), kSize);
+}
+
+TEST(skia_draws_a_rectangle_where_it_was_asked_to) {
+  sk_sp<SkSurface> surface = context()->makeOffscreenSurface(kSize, kSize);
+  EXPECT(surface != nullptr);
+
+  SkCanvas *canvas = surface->getCanvas();
+  canvas->clear(SK_ColorTRANSPARENT);
+  SkPaint paint;
+  paint.setColor(SK_ColorRED);
+  // A quarter of the surface, offset from the origin so that "drew something"
+  // and "drew it in the right place" are different assertions.
+  canvas->drawRect(SkRect::MakeXYWH(16, 16, 32, 32), paint);
+
+  const std::vector<Pixel> pixels = readBack(surface);
+  EXPECT(!pixels.empty());
+  if (pixels.empty()) {
+    return;
+  }
+
+  // Inside: red, opaque.
+  const Pixel &inside = at(pixels, 32, 32);
+  EXPECT_EQ(inside.describe(), std::string("rgba(255,0,0,255)"));
+
+  // Outside, well clear of the edge: nothing was drawn, so nothing is there.
+  // Not tested right at the boundary -- antialiasing puts an edge half a pixel
+  // either way, and pinning that fails on a future Skia for no useful reason.
+  const Pixel &outside = at(pixels, 4, 4);
+  EXPECT_EQ(outside.describe(), std::string("rgba(0,0,0,0)"));
+}
+
+TEST(skia_draws_a_path) {
+  // Paths are the other half of what an app actually uses -- kino imports Path,
+  // Rect, RoundedRect and RadialGradient -- and they go through a different
+  // part of Skia than a rectangle fill.
+  sk_sp<SkSurface> surface = context()->makeOffscreenSurface(kSize, kSize);
+  EXPECT(surface != nullptr);
+
+  SkCanvas *canvas = surface->getCanvas();
+  canvas->clear(SK_ColorTRANSPARENT);
+  SkPaint paint;
+  paint.setColor(SK_ColorGREEN);
+  paint.setAntiAlias(false);
+  // A triangle filling the lower left half, so the two diagonal corners differ.
+  //
+  // Through SkPathBuilder: this Skia has no SkPath::moveTo. Worth knowing when
+  // porting anything that touches paths -- the mutating API moved and the old
+  // one is gone rather than deprecated.
+  SkPathBuilder builder;
+  builder.moveTo(0, 0);
+  builder.lineTo(0, kSize);
+  builder.lineTo(kSize, kSize);
+  builder.close();
+  canvas->drawPath(builder.detach(), paint);
+
+  const std::vector<Pixel> pixels = readBack(surface);
+  EXPECT(!pixels.empty());
+  if (pixels.empty()) {
+    return;
+  }
+  // Inside the triangle, and outside it. The corners rather than near the
+  // hypotenuse, for the antialiasing reason above.
+  EXPECT_EQ(at(pixels, 4, 60).describe(), std::string("rgba(0,255,0,255)"));
+  EXPECT_EQ(at(pixels, 60, 4).describe(), std::string("rgba(0,0,0,0)"));
+}
+
+TEST(skia_finds_the_system_fonts) {
+  // CoreText through Skia's own font manager, which is what Text and matchFont
+  // resolve against. A manager with no families is the shape this fails in.
+  sk_sp<SkFontMgr> fonts = context()->createFontMgr();
+  EXPECT(fonts != nullptr);
+  EXPECT(fonts->countFamilies() > 0);
+
+  // And the host's own list, which the package asks for by a different route.
+  EXPECT(!context()->getSystemFontFamilies().empty());
+}
+
+TEST(skia_says_which_calls_it_does_not_implement) {
+  // The three that throw do so with their own name in the message. Asserted
+  // because the alternative -- a blank image or a zero handle -- reads as a
+  // rendering bug rather than as a missing feature, which is the whole reason
+  // they throw.
+  bool threw = false;
+  std::string message;
+  try {
+    context()->takeScreenshotFromViewTag(7);
+  } catch (const std::exception &error) {
+    threw = true;
+    message = error.what();
+  }
+  EXPECT(threw);
+  EXPECT(message.find("not implemented") != std::string::npos);
+  EXPECT(message.find("7") != std::string::npos);
+
+  threw = false;
+  try {
+    context()->makeTestNativeBuffer(8, 8);
+  } catch (const std::exception &error) {
+    threw = true;
+    message = error.what();
+  }
+  EXPECT(threw);
+  EXPECT(message.find("CVPixelBuffer") != std::string::npos);
+
+  // And the one that deliberately does not throw: releasing a buffer nothing
+  // handed out must be quiet, because throwing from a release path turns a leak
+  // into a crash.
+  context()->releaseNativeBuffer(0);
+}

package/native/tests/test_appkit_text.mm

@@ -0,0 +1,180 @@
+// Tests for the Core Text layer: does a paragraph measure and truncate the way
+// React Native means it to?
+//
+// Against RnTextLayout directly, with no Fabric and no React Native, for the
+// same reason the view tests are: this is the half that can be wrong on its
+// own, and a failure here is much easier to read than the same failure arriving
+// as a paragraph that is the wrong height on screen.
+//
+// Nothing here asserts an exact pixel size. Core Text over the system font is
+// not reproducible across macOS versions, and a test that pinned it would fail
+// on somebody else's machine for no useful reason. What is asserted is the
+// relationships that must hold whatever the font is.
+
+#include "TestHarness.h"
+
+#import "RnTextLayout.h"
+
+#include <sstream>
+
+namespace {
+
+NSAttributedString *styled(NSString *text, CGFloat size, NSTextAlignment alignment) {
+  NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
+  style.alignment = alignment;
+  style.lineBreakMode = NSLineBreakByWordWrapping;
+  return [[NSAttributedString alloc] initWithString:text
+                                         attributes:@{
+                                           NSFontAttributeName : [NSFont systemFontOfSize:size],
+                                           NSParagraphStyleAttributeName : style,
+                                         }];
+}
+
+RnTextLayout *layoutFor(NSString *text, CGFloat size, NSInteger lines) {
+  return [RnTextLayout layoutWithAttributedString:styled(text, size, NSTextAlignmentNatural)
+                             maximumNumberOfLines:lines
+                                   truncationType:kCTLineTruncationEnd
+                                        truncates:YES];
+}
+
+NSString *const kLong =
+    @"A paragraph long enough to wrap several times over, so that the line breaking has real "
+    @"work to do and a line limit has something to cut.";
+
+} // namespace
+
+TEST(text_measures_something) {
+  @autoreleasepool {
+    RnTextLayout *layout = layoutFor(@"Hello", 16, 0);
+    const CGSize size = [layout sizeForWidth:-1];
+
+    // The stub this replaces returned the minimum size, which is how text had
+    // no size at all on this platform until now.
+    EXPECT(size.width > 0);
+    EXPECT(size.height > 0);
+  }
+}
+
+TEST(text_at_a_bigger_size_measures_bigger) {
+  @autoreleasepool {
+    const CGSize small = [layoutFor(@"Hello", 12, 0) sizeForWidth:-1];
+    const CGSize large = [layoutFor(@"Hello", 32, 0) sizeForWidth:-1];
+
+    EXPECT(large.width > small.width);
+    EXPECT(large.height > small.height);
+  }
+}
+
+TEST(text_wraps_when_it_is_given_a_width) {
+  @autoreleasepool {
+    RnTextLayout *layout = layoutFor(kLong, 16, 0);
+
+    const CGSize unconstrained = [layout sizeForWidth:-1];
+    const CGSize narrow = [layout sizeForWidth:200];
+
+    // Wrapping trades width for height. Both halves matter: a layout that
+    // ignored the width would keep its height, and one that ignored the text
+    // would keep its width.
+    EXPECT(narrow.width <= 200);
+    EXPECT(narrow.height > unconstrained.height);
+  }
+}
+
+TEST(number_of_lines_limits_the_height) {
+  @autoreleasepool {
+    const CGSize unlimited = [layoutFor(kLong, 16, 0) sizeForWidth:200];
+    const CGSize twoLines = [layoutFor(kLong, 16, 2) sizeForWidth:200];
+    const CGSize oneLine = [layoutFor(kLong, 16, 1) sizeForWidth:200];
+
+    EXPECT(twoLines.height < unlimited.height);
+    EXPECT(oneLine.height < twoLines.height);
+
+    // Two lines is two lines tall, not "whatever fits". Core Text has no line
+    // limit of its own -- RnTextLayout applies it by keeping the first N lines
+    // -- so this is the assertion that the limit is really being applied rather
+    // than the text happening to be short.
+    EXPECT_NEAR(twoLines.height, oneLine.height * 2, 2.0);
+  }
+}
+
+// A limit that drops nothing must not add an ellipsis. Getting this wrong is
+// invisible until a paragraph that exactly fits gets one anyway.
+TEST(a_line_limit_that_fits_is_not_truncated) {
+  @autoreleasepool {
+    const CGSize unlimited = [layoutFor(@"Short", 16, 0) sizeForWidth:400];
+    const CGSize limited = [layoutFor(@"Short", 16, 3) sizeForWidth:400];
+
+    EXPECT_NEAR(limited.width, unlimited.width, 0.51);
+    EXPECT_NEAR(limited.height, unlimited.height, 0.51);
+  }
+}
+
+// Alignment changes where a line is drawn, never how big it is. A paragraph
+// that measured differently when centred would make Yoga lay it out wrong.
+TEST(alignment_does_not_change_the_measured_size) {
+  @autoreleasepool {
+    const auto measure = [](NSTextAlignment alignment) {
+      RnTextLayout *layout =
+          [RnTextLayout layoutWithAttributedString:styled(kLong, 16, alignment)
+                              maximumNumberOfLines:0
+                                    truncationType:kCTLineTruncationEnd
+                                         truncates:YES];
+      return [layout sizeForWidth:300];
+    };
+
+    const CGSize natural = measure(NSTextAlignmentNatural);
+    const CGSize centred = measure(NSTextAlignmentCenter);
+    const CGSize right = measure(NSTextAlignmentRight);
+
+    EXPECT_NEAR(centred.height, natural.height, 0.51);
+    EXPECT_NEAR(right.height, natural.height, 0.51);
+  }
+}
+
+// The drawing path, against a real bitmap: a laid-out paragraph has to put ink
+// on the page, and it has to put it in the half of the box the alignment says.
+TEST(text_draws_where_the_alignment_says) {
+  @autoreleasepool {
+    const CGSize size = CGSizeMake(300, 40);
+
+    const auto inkColumns = [&](NSTextAlignment alignment) {
+      RnTextLayout *layout =
+          [RnTextLayout layoutWithAttributedString:styled(@"Edge", 16, alignment)
+                              maximumNumberOfLines:0
+                                    truncationType:kCTLineTruncationEnd
+                                         truncates:YES];
+
+      CGColorSpaceRef space = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+      CGContextRef context = CGBitmapContextCreate(nullptr, (size_t)size.width, (size_t)size.height,
+                                                   8, 0, space, kCGImageAlphaPremultipliedLast);
+      CGColorSpaceRelease(space);
+      CGContextSetRGBFillColor(context, 1, 1, 1, 1);
+      CGContextFillRect(context, CGRectMake(0, 0, size.width, size.height));
+      [layout drawInContext:context size:size];
+
+      auto *pixels = static_cast<unsigned char *>(CGBitmapContextGetData(context));
+      const size_t stride = CGBitmapContextGetBytesPerRow(context);
+      int leftmost = -1;
+      for (size_t x = 0; x < (size_t)size.width && leftmost < 0; x++) {
+        for (size_t y = 0; y < (size_t)size.height; y++) {
+          if (pixels[y * stride + x * 4] < 200) {  // any ink at all
+            leftmost = (int)x;
+            break;
+          }
+        }
+      }
+      CGContextRelease(context);
+      return leftmost;
+    };
+
+    const int left = inkColumns(NSTextAlignmentNatural);
+    const int centred = inkColumns(NSTextAlignmentCenter);
+    const int right = inkColumns(NSTextAlignmentRight);
+
+    // Ink at all, first: a paragraph that drew nothing would pass every size
+    // assertion above.
+    EXPECT(left >= 0);
+    EXPECT(centred > left);
+    EXPECT(right > centred);
+  }
+}