basalt-appkit 0.0.0-rc5 → 0.2.0

package/native/tests/test_appkit_input.mm

@@ -13,6 +13,11 @@
 
 #include "TestHarness.h"
 
+#include "EventRecorder.h"
+
+#include <algorithm>
+#include <string>
+
 #include "PointerButtons.h"
 
 #import "AppKitFocus.h"
@@ -850,3 +855,207 @@ TEST(focus_activating_nothing_is_not_a_click) {
     manager.destroySurfaceRoot(kSurfaceId);
   }
 }
+
+// `hitSlop`: how far outside its own box a view answers a press.
+//
+// Deliberately the same four questions the GTK suite asks of it, in the same
+// order and with the same geometry, because the two hit tests are separate code
+// answering one contract -- the day they disagree, these fail here rather than
+// in an app. Asserted through the hit test rather than against the stored
+// insets: a view that remembered its slop and did not widen its box would leave
+// every target the size it was.
+TEST(appkit_hit_slop_grows_the_target_outside_the_box) {
+  @autoreleasepool {
+    RnAppKitView *root = box(1, 0, 0, 400, 400);
+    RnAppKitView *icon = box(60, 100, 100, 20, 20);
+    [root insertRnChild:icon atIndex:0];
+    const CGFloat insets[4] = {12, 12, 12, 12};
+    [icon setRnHitSlop:insets];
+
+    EXPECT_EQ((long)hit(root, 110, 110), 60L);
+    EXPECT_EQ((long)hit(root, 92, 110), 60L);
+    EXPECT_EQ((long)hit(root, 128, 110), 60L);
+    EXPECT_EQ((long)hit(root, 110, 92), 60L);
+    EXPECT_EQ((long)hit(root, 110, 128), 60L);
+    EXPECT_EQ((long)hit(root, 80, 110), 1L);
+  }
+}
+
+// Each edge on its own: four numbers in one struct is four chances to read one
+// into the wrong side, and a slop that grew the top when the app asked for the
+// bottom would pass any symmetric test.
+TEST(appkit_hit_slop_applies_each_edge_where_it_was_asked_for) {
+  @autoreleasepool {
+    RnAppKitView *root = box(1, 0, 0, 400, 400);
+    RnAppKitView *view = box(61, 100, 100, 20, 20);
+    [root insertRnChild:view atIndex:0];
+
+    const CGFloat top[4] = {15, 0, 0, 0};
+    [view setRnHitSlop:top];
+    EXPECT_EQ((long)hit(root, 110, 90), 61L);
+    EXPECT_EQ((long)hit(root, 110, 130), 1L);
+    EXPECT_EQ((long)hit(root, 90, 110), 1L);
+    EXPECT_EQ((long)hit(root, 130, 110), 1L);
+
+    const CGFloat bottom[4] = {0, 0, 15, 0};
+    [view setRnHitSlop:bottom];
+    EXPECT_EQ((long)hit(root, 110, 130), 61L);
+    EXPECT_EQ((long)hit(root, 110, 90), 1L);
+  }
+}
+
+TEST(appkit_hit_slop_can_be_taken_away_again) {
+  @autoreleasepool {
+    RnAppKitView *root = box(1, 0, 0, 400, 400);
+    RnAppKitView *view = box(62, 100, 100, 20, 20);
+    [root insertRnChild:view atIndex:0];
+    const CGFloat insets[4] = {12, 12, 12, 12};
+    [view setRnHitSlop:insets];
+    EXPECT_EQ((long)hit(root, 92, 110), 62L);
+
+    [view setRnHitSlop:nullptr];
+    EXPECT_EQ((long)hit(root, 92, 110), 1L);
+    EXPECT_EQ((long)hit(root, 110, 110), 62L);
+  }
+}
+
+// A slop that overlaps a sibling does not win over it: the sibling is drawn on
+// top, and a target reaching under something visible would take presses meant
+// for it.
+TEST(appkit_hit_slop_does_not_beat_a_view_drawn_over_it) {
+  @autoreleasepool {
+    RnAppKitView *root = box(1, 0, 0, 400, 400);
+    RnAppKitView *first = box(63, 100, 100, 20, 20);
+    [root insertRnChild:first atIndex:0];
+    const CGFloat insets[4] = {0, 40, 0, 0};
+    [first setRnHitSlop:insets];
+
+    RnAppKitView *second = box(64, 130, 100, 20, 20);
+    [root insertRnChild:second atIndex:1];
+
+    EXPECT_EQ((long)hit(root, 125, 110), 63L);
+    EXPECT_EQ((long)hit(root, 140, 110), 64L);
+  }
+}
+
+TEST(appkit_hit_slop_is_reported_in_the_tree) {
+  @autoreleasepool {
+    RnAppKitView *view = box(1, 0, 0, 20, 20);
+    EXPECT(![[view describeTree] containsString:@"hit-slop="]);
+
+    const CGFloat insets[4] = {1, 2, 3, 4};
+    [view setRnHitSlop:insets];
+    EXPECT([[view describeTree] containsString:@"hit-slop=(1,2,3,4)"]);
+  }
+}
+
+namespace {
+
+// The recorder reports every event it saw, in order; these two tests ask only
+// whether a kind arrived at all.
+bool saw(const basalt::testing::EventRecorder &recorder, const std::string &type) {
+  const auto seen = recorder.seen();
+  return std::find(seen.begin(), seen.end(), type) != seen.end();
+}
+
+} // namespace
+
+// A press the window cannot finish, which is React Native's `touchCancel`.
+//
+// A touch has to end one of two ways. A press that simply stops is the shape
+// that leaves a `<Pressable>` highlighted for the rest of the screen's life:
+// `onPressOut` never runs and the responder is never released. GTK gets this
+// from its gesture recogniser's `cancelled` signal; AppKit has none, so the
+// dispatcher watches for its window to stop being key, which is what happens
+// when the person switches app mid-press.
+//
+// The whole path is here rather than just the cancel: the press goes in through
+// the same input handler AppKit calls, the notification is the real one, and
+// the event comes out of a real emitter.
+TEST(a_press_is_cancelled_when_the_window_stops_being_key) {
+  @autoreleasepool {
+    const basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *root = manager.createSurfaceRoot(kSurfaceId);
+    [root setRnFrameX:0 y:0 width:400 height:300];
+
+    ShadowView view = makeView(10, 40, 50, 120, 60);
+    view.eventEmitter = recorder.emitter<facebook::react::TouchEventEmitter>();
+    ShadowViewMutationList mutations;
+    mutations.push_back(ShadowViewMutation::CreateMutation(view));
+    mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, view, 0));
+    apply(manager, std::move(mutations));
+
+    // A window, because the notification this listens for names one and an
+    // unparented root belongs to none.
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    // Not released when closed: see test_appkit_services.mm.
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:root];
+
+    basalt::AppKitTouchDispatcher dispatcher(&manager, root);
+
+    // Down and *not* up, which is the state the cancel is about.
+    [root.rnInputHandler rnMouseDownAt:NSMakePoint(50, 60) button:0];
+    EXPECT(saw(recorder, "topTouchStart"));
+    EXPECT(!saw(recorder, "topTouchCancel"));
+
+    [NSNotificationCenter.defaultCenter postNotificationName:NSWindowDidResignKeyNotification
+                                                      object:window];
+    EXPECT(saw(recorder, "topTouchCancel"));
+    // And not an end: a cancelled touch is not a completed one, and a
+    // `<Pressable>` treats the two differently.
+    EXPECT(!saw(recorder, "topTouchEnd"));
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// Another window losing focus is not this press's business. With several
+// windows open, a dispatcher that cancelled on every notification would cancel
+// every other window's touch.
+TEST(a_press_survives_another_windows_focus_loss) {
+  @autoreleasepool {
+    const basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *root = manager.createSurfaceRoot(kSurfaceId);
+    [root setRnFrameX:0 y:0 width:400 height:300];
+
+    ShadowView view = makeView(10, 40, 50, 120, 60);
+    view.eventEmitter = recorder.emitter<facebook::react::TouchEventEmitter>();
+    ShadowViewMutationList mutations;
+    mutations.push_back(ShadowViewMutation::CreateMutation(view));
+    mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, view, 0));
+    apply(manager, std::move(mutations));
+
+    NSWindow *mine = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                 styleMask:NSWindowStyleMaskTitled
+                                                   backing:NSBackingStoreBuffered
+                                                     defer:NO];
+    mine.releasedWhenClosed = NO;
+    [mine.contentView addSubview:root];
+    NSWindow *other = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 200, 100)
+                                                  styleMask:NSWindowStyleMaskTitled
+                                                    backing:NSBackingStoreBuffered
+                                                      defer:NO];
+    other.releasedWhenClosed = NO;
+
+    basalt::AppKitTouchDispatcher dispatcher(&manager, root);
+    [root.rnInputHandler rnMouseDownAt:NSMakePoint(50, 60) button:0];
+    EXPECT(saw(recorder, "topTouchStart"));
+
+    [NSNotificationCenter.defaultCenter postNotificationName:NSWindowDidResignKeyNotification
+                                                      object:other];
+    EXPECT(!saw(recorder, "topTouchCancel"));
+
+    [mine orderOut:nil];
+    [mine close];
+    [other close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}

package/native/tests/test_appkit_mounting.mm

@@ -10,6 +10,7 @@
 #include "TreeDump.h"
 
 #import "AppKitMountingManager.h"
+#import "RnAppKitView.h"
 
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/graphics/Color.h>
@@ -428,3 +429,362 @@ TEST(no_transform_origin_anchors_the_centre) {
   manager.destroySurfaceRoot(kSurfaceId);
   }
 }
+
+// `accessibilityLabelledBy` through a real transaction, which is the half the
+// view-level tests in test_appkit_accessibility.mm cannot reach: the prop names
+// another view by its `nativeID`, and Fabric mounts a field before the label
+// that follows it.
+//
+// Deliberately the same two cases the GTK suite asserts, in the same order and
+// with the same tags, for the reason the rest of this file is: the resolution is
+// shared in core/LabelRegistry.h, and the day the sharing stops holding these
+// fail here rather than in an app.
+namespace {
+
+ShadowView makeNamedView(Tag tag, const std::string &nativeId) {
+  ShadowView view = makeView(tag, 0, 0, 100, 50);
+  auto props = std::make_shared<ViewProps>();
+  props->nativeId = nativeId;
+  view.props = props;
+  return view;
+}
+
+ShadowView makeLabelledView(Tag tag, std::vector<std::string> ids) {
+  ShadowView view = makeView(tag, 0, 0, 100, 50);
+  auto props = std::make_shared<ViewProps>();
+  props->accessibilityLabelledBy.value = std::move(ids);
+  view.props = props;
+  return view;
+}
+
+} // namespace
+
+TEST(appkit_mounting_labelled_by_resolves_a_native_id) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    ShadowViewMutationList mutations;
+    mutations.push_back(ShadowViewMutation::CreateMutation(makeLabelledView(10, {"name-label"})));
+    mutations.push_back(
+        ShadowViewMutation::InsertMutation(kSurfaceId, makeLabelledView(10, {"name-label"}), 0));
+    mutations.push_back(ShadowViewMutation::CreateMutation(makeNamedView(20, "name-label")));
+    mutations.push_back(
+        ShadowViewMutation::InsertMutation(kSurfaceId, makeNamedView(20, "name-label"), 1));
+    apply(manager, std::move(mutations));
+
+    RnAppKitView *field = manager.viewForTag(10);
+    EXPECT(field != nil);
+    EXPECT(field.accessibilityTitleUIElement == manager.viewForTag(20));
+  }
+}
+
+// The label in a later transaction, which is what a resolution done as the props
+// arrived would miss.
+TEST(appkit_mounting_labelled_by_waits_for_a_label_that_mounts_later) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    ShadowViewMutationList first;
+    first.push_back(ShadowViewMutation::CreateMutation(makeLabelledView(10, {"name-label"})));
+    first.push_back(
+        ShadowViewMutation::InsertMutation(kSurfaceId, makeLabelledView(10, {"name-label"}), 0));
+    apply(manager, std::move(first));
+
+    RnAppKitView *field = manager.viewForTag(10);
+    EXPECT(field.accessibilityTitleUIElement == nil);
+
+    ShadowViewMutationList second;
+    second.push_back(ShadowViewMutation::CreateMutation(makeNamedView(20, "name-label")));
+    second.push_back(
+        ShadowViewMutation::InsertMutation(kSurfaceId, makeNamedView(20, "name-label"), 1));
+    manager.applyTransaction(
+        kSurfaceId, MountingTransaction(kSurfaceId, 2, std::move(second), TransactionTelemetry{}));
+
+    EXPECT(field.accessibilityTitleUIElement == manager.viewForTag(20));
+  }
+}
+
+// `accessibilityLiveRegion`: a status message read out when it changes.
+//
+// Nothing in an automated run is running VoiceOver, so what is asserted is the
+// decision rather than the speech: `-rnAnnounce:assertive:` records the text it
+// posted and these read it back. The rules -- what counts as a change -- are
+// core/LiveRegions.h's and are tested there; this is the wiring, and it is the
+// same four cases the GTK suite asserts.
+namespace {
+
+ShadowView makeStatusView(Tag tag,
+                          facebook::react::AccessibilityLiveRegion politeness,
+                          const std::string &label) {
+  ShadowView view = makeView(tag, 0, 0, 200, 40);
+  auto props = std::make_shared<ViewProps>();
+  props->accessibilityLiveRegion = politeness;
+  props->accessibilityLabel = label;
+  view.props = props;
+  return view;
+}
+
+void mountStatus(basalt::AppKitMountingManager &manager, const ShadowView &view, int transaction) {
+  ShadowViewMutationList mutations;
+  if (transaction == 1) {
+    mutations.push_back(ShadowViewMutation::CreateMutation(view));
+    mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, view, 0));
+  } else {
+    mutations.push_back(ShadowViewMutation::UpdateMutation(view, view, kSurfaceId));
+  }
+  manager.applyTransaction(
+      kSurfaceId,
+      MountingTransaction(kSurfaceId, transaction, std::move(mutations), TransactionTelemetry{}));
+}
+
+} // namespace
+
+TEST(appkit_mounting_a_live_region_says_nothing_when_it_appears) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    using facebook::react::AccessibilityLiveRegion;
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::Polite, "Saving"), 1);
+    // Mounting a status line is not news: the screen appeared, nothing changed.
+    EXPECT(manager.viewForTag(10).rnLastAnnouncement == nil);
+  }
+}
+
+TEST(appkit_mounting_a_live_region_announces_a_change) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    using facebook::react::AccessibilityLiveRegion;
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::Polite, "Saving"), 1);
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::Polite, "Saved"), 2);
+
+    RnAppKitView *status = manager.viewForTag(10);
+    EXPECT(status.rnLastAnnouncement != nil);
+    EXPECT([status.rnLastAnnouncement isEqualToString:@"Saved"]);
+  }
+}
+
+TEST(appkit_mounting_a_view_that_is_not_a_live_region_stays_quiet) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    using facebook::react::AccessibilityLiveRegion;
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::None, "Saving"), 1);
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::None, "Saved"), 2);
+    EXPECT(manager.viewForTag(10).rnLastAnnouncement == nil);
+  }
+}
+
+TEST(appkit_mounting_a_live_region_that_stops_being_one_goes_quiet) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    manager.createSurfaceRoot(kSurfaceId);
+
+    using facebook::react::AccessibilityLiveRegion;
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::Assertive, "Saving"), 1);
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::Assertive, "Saved"), 2);
+    RnAppKitView *status = manager.viewForTag(10);
+    EXPECT([status.rnLastAnnouncement isEqualToString:@"Saved"]);
+
+    mountStatus(manager, makeStatusView(10, AccessibilityLiveRegion::None, "Saved again"), 3);
+    // Still the old announcement: nothing new was said.
+    EXPECT([status.rnLastAnnouncement isEqualToString:@"Saved"]);
+  }
+}
+
+// The other source of a region's text: a <Text> inside it rather than a label on
+// it. Asserted against the collector directly, a Paragraph with real state being
+// more machinery than the question needs.
+TEST(appkit_collected_text_is_every_paragraph_in_the_subtree) {
+  @autoreleasepool {
+    RnAppKitView *region = [RnAppKitView viewWithTag:1];
+    [region setRnFrameX:0 y:0 width:200 height:100];
+    EXPECT_EQ(region.rnCollectedText.length, 0UL);
+
+    RnAppKitView *first = [RnAppKitView viewWithTag:2];
+    [first setRnFrameX:0 y:0 width:200 height:20];
+    [region insertRnChild:first atIndex:0];
+    RnAppKitView *second = [RnAppKitView viewWithTag:3];
+    [second setRnFrameX:0 y:20 width:200 height:20];
+    [region insertRnChild:second atIndex:1];
+    // No text layouts, so still nothing: a tree of plain views collects nothing
+    // rather than crashing on the way down.
+    EXPECT_EQ(region.rnCollectedText.length, 0UL);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// What the loader reads out of an animated file.
+//
+// Here rather than in tests/test_appkit_image.mm because it needs the loader,
+// which needs React Native's IImageLoader, and that file is compiled into the
+// toolkit-only build as well. The view's half of animation is there; this is
+// the half that reads the GIF's own bytes.
+// ---------------------------------------------------------------------------
+namespace {
+
+// The same four-pixel GIF the view tests use: red for 80ms, blue for 40ms,
+// looping forever. See tests/test_appkit_image.mm for how it was written.
+const char *const kAnimatedGifDataUri =
+    "data:image/gif;base64,"
+    "R0lGODlhBAAEAPAAAP8AAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQACAAAACwAAAAABAAEAAAC"
+    "BISPCQUAIfkEAAQAAAAsAAAAAAQABACAAAD/AAAAAgSEjwkFADs=";
+
+// A 4x2 still PNG, which must come back with no animation at all.
+const char *const kStillPngDataUri =
+    "data:image/png;base64,"
+    "iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAIAAADwyuo0AAAAFUlEQVR4nGN44OAA"
+    "RA4JD4CIAZkDAJQaC4Enje7+AAAAAElFTkSuQmCC";
+
+// Loads a URI and runs the main run loop until the answer arrives.
+//
+// The decode is on a worker thread and the delivery is a `dispatch_async` to
+// the main queue, which nothing in this suite otherwise drains, so the pump is
+// what makes a loader testable at all.
+bool loadAndWait(basalt::AppKitImageLoader &loader, const std::string &uri) {
+  bool done = false;
+  bool decoded = false;
+  loader.load(uri, [&](CGImageRef image, const std::string &) {
+    decoded = image != nullptr;
+    done = true;
+  });
+
+  NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:5.0];
+  while (!done && deadline.timeIntervalSinceNow > 0) {
+    [NSRunLoop.currentRunLoop runMode:NSDefaultRunLoopMode
+                           beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+  }
+  return done && decoded;
+}
+
+} // namespace
+
+TEST(appkit_the_loader_reads_an_animations_frames_and_delays) {
+  @autoreleasepool {
+    basalt::AppKitImageLoader loader;
+    const std::string uri = kAnimatedGifDataUri;
+    EXPECT(loadAndWait(loader, uri));
+
+    const basalt::AppKitImageLoader::Animation *animation = loader.animation(uri);
+    EXPECT(animation != nullptr);
+    if (animation == nullptr) {
+      return;
+    }
+    EXPECT_EQ((int)animation->frames.count, 2);
+    EXPECT_EQ((int)animation->delaysMs.count, 2);
+    // The file's own delays, per frame and unclamped. Equal numbers here would
+    // pass with a loader that read the first frame's delay and reused it.
+    EXPECT_EQ(animation->delaysMs[0].intValue, 80);
+    EXPECT_EQ(animation->delaysMs[1].intValue, 40);
+    // Zero is forever, which is what this GIF's NETSCAPE2.0 extension says.
+    EXPECT_EQ((int)animation->loopCount, 0);
+
+    // The same arrays on a second load, which is what lets a view tell a
+    // re-mount from a new animation.
+    EXPECT(loadAndWait(loader, uri));
+    EXPECT(loader.animation(uri)->frames == animation->frames);
+  }
+}
+
+// The same picture with no delays at all, which a great many GIFs carry:
+//
+//   magick -loop 0 -size 4x4 xc:'#ff0000' -size 4x4 xc:'#0000ff' anim.gif
+TEST(appkit_the_loader_leaves_a_zero_delay_alone) {
+  @autoreleasepool {
+    basalt::AppKitImageLoader loader;
+    const std::string uri =
+        "data:image/gif;base64,"
+        "R0lGODlhBAAEAPAAAP8AAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQAAAAAACwAAAAABAAEAAAC"
+        "BISPCQUAIfkEAAAAAAAsAAAAAAQABACAAAD/AAAAAgSEjwkFADs=";
+    EXPECT(loadAndWait(loader, uri));
+
+    const basalt::AppKitImageLoader::Animation *animation = loader.animation(uri);
+    EXPECT(animation != nullptr);
+    if (animation == nullptr) {
+      return;
+    }
+    // Unclamped, deliberately: ImageIO reports what the file says and
+    // core/ImageAnimation.h owns the rule, so both hosts and the next one apply
+    // the same one in the same place. The GTK host's gdk-pixbuf answers 100 for
+    // this file itself, which is why the clamp has to live where both can see
+    // it rather than in whichever decoder happens to need it.
+    EXPECT_EQ((int)animation->frames.count, 2);
+    EXPECT_EQ(animation->delaysMs[0].intValue, 0);
+    EXPECT_EQ(animation->delaysMs[1].intValue, 0);
+
+    // And the view paces it at a tenth of a second a frame, which is the clamp
+    // doing the work: without it the cycle is zero long and the first frame is
+    // the only one ever shown.
+    RnAppKitView *view = [RnAppKitView viewWithTag:1];
+    [view setRnFrameX:0 y:0 width:20 height:20];
+    [view setRnImageFrames:animation->frames
+                 delaysMs:animation->delaysMs
+                loopCount:animation->loopCount];
+    EXPECT_NEAR([view rnAdvanceImageAnimationBy:0], 100.0, 0.01);
+    [view rnAdvanceImageAnimationBy:99];
+    EXPECT_EQ((int)view.rnImageFrameIndex, 0);
+    [view rnAdvanceImageAnimationBy:1];
+    EXPECT_EQ((int)view.rnImageFrameIndex, 1);
+  }
+}
+
+TEST(appkit_the_loader_reports_no_animation_for_a_still_image) {
+  @autoreleasepool {
+    basalt::AppKitImageLoader loader;
+    const std::string uri = kStillPngDataUri;
+    EXPECT(loadAndWait(loader, uri));
+    EXPECT(loader.animation(uri) == nullptr);
+    EXPECT(loader.animation("data:image/png;base64,never-loaded") == nullptr);
+  }
+}
+
+
+// A GIF with no NETSCAPE2.0 extension at all, which is what "play once" looks
+// like in the format:
+//
+//   magick -loop 1 -delay 8 -size 4x4 xc:'#ff0000' \
+//                 -delay 4 -size 4x4 xc:'#0000ff' once.gif
+//
+// writes no application extension rather than a count of one.
+//
+// **Both hosts stop after one pass, which was measured rather than assumed.**
+// ImageIO answers `kCGImagePropertyGIFLoopCount` with 1 for this file, not with
+// nothing, so the loop count needs no special case for an absent extension;
+// gdk-pixbuf's iterator reports a delay of -1 at the end of the same file,
+// which this host's `rn_view_animation_delay_ms` turns into "nothing more is
+// due". So a non-looping GIF plays once on both, and neither of them had to be
+// taught it.
+TEST(appkit_a_gif_that_does_not_loop_plays_once) {
+  @autoreleasepool {
+    basalt::AppKitImageLoader loader;
+    const std::string uri = std::string("data:image/gif;base64,")
+        + "R0lGODlhBAAEAPAAAP8AAAAAACH5BAAIAAAALAAAAAAEAAQAAAIEhI8JBQAh+QQABAAAACwAAAAABAAE"
+        "AIAAAP8AAAACBISPCQUAOw==";
+    EXPECT(loadAndWait(loader, uri));
+
+    const basalt::AppKitImageLoader::Animation *animation = loader.animation(uri);
+    EXPECT(animation != nullptr);
+    if (animation == nullptr) {
+      return;
+    }
+    EXPECT_EQ((int)animation->loopCount, 1);
+
+    RnAppKitView *view = [RnAppKitView viewWithTag:1];
+    [view setRnFrameX:0 y:0 width:20 height:20];
+    [view setRnImageFrames:animation->frames
+                 delaysMs:animation->delaysMs
+                loopCount:animation->loopCount];
+
+    // Halfway through, still running.
+    EXPECT([view rnAdvanceImageAnimationBy:60] > 0.0);
+    // One pass is 120ms, after which nothing more is due and the last frame
+    // stays.
+    EXPECT_NEAR([view rnAdvanceImageAnimationBy:60], 0.0, 0.01);
+    EXPECT_EQ((int)view.rnImageFrameIndex, 1);
+  }
+}