basalt-win32 0.0.0-rc5

package/native/tests/test_win32_imageloader.cpp

@@ -0,0 +1,208 @@
+// The image loader: the cache, the ways a load can fail, and the two lifetimes
+// that make this a class rather than a function.
+//
+// The equivalent of `tests/test_image.cpp` on GTK, which asks the same three
+// questions of its loader. What is extra here is the loader outliving its owner
+// -- GTK's loader does not have that hazard, because a completion queued on a
+// GLib source is cancelled with the source, and AppKit's has the hazard and no
+// test.
+//
+// These run with no UI thread installed, which is deliberate and is the
+// configuration `load` detects: with nothing to marshal back to it stays on one
+// thread, so a completion has run by the time `load` returns and nothing here
+// has to wait for anything.
+
+#include "TestHarness.h"
+
+#include "Win32ImageLoader.h"
+#include "Win32Snapshot.h"
+#include "RnWin32View.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using basalt::win32::RnWin32Image;
+using basalt::win32::RnWin32View;
+using basalt::win32::Win32ImageLoader;
+
+namespace {
+
+// A real PNG on disk, written by the snapshot encoder rather than checked in.
+// Cheaper than a fixture and it fails if either half of the image path breaks.
+std::string writeTemporaryPng(const char *name) {
+  auto source = std::make_unique<RnWin32View>(1);
+  source->setFrame(0, 0, 20, 10);
+  source->setBackgroundColor(0.0f, 0.5f, 1.0f, 1.0f, true);
+
+  const char *temp = std::getenv("TEMP");
+  std::string path = std::string(temp != nullptr ? temp : ".") + "\\" + name;
+  if (!basalt::win32::writeSnapshot(*source, path)) {
+    return {};
+  }
+  return path;
+}
+
+// file:// is what an app's bundled asset arrives as, and what
+// core/ImageBytes.cpp understands without a network.
+std::string fileUri(const std::string &path) {
+  std::string uri = "file:///" + path;
+  for (char &c : uri) {
+    if (c == '\\') {
+      c = '/';
+    }
+  }
+  return uri;
+}
+
+} // namespace
+
+TEST(image_loader_decodes_a_file_uri) {
+  const std::string path = writeTemporaryPng("basalt_loader_one.png");
+  EXPECT(!path.empty());
+
+  Win32ImageLoader loader;
+  std::shared_ptr<RnWin32Image> loaded;
+  std::string error;
+  loader.load(fileUri(path), [&](std::shared_ptr<RnWin32Image> image, const std::string &why) {
+    loaded = std::move(image);
+    error = why;
+  });
+
+  EXPECT(loaded != nullptr);
+  EXPECT_EQ(error, std::string{});
+  if (loaded != nullptr) {
+    EXPECT_EQ(loaded->width(), 20u);
+    EXPECT_EQ(loaded->height(), 10u);
+  }
+  std::remove(path.c_str());
+}
+
+TEST(image_loader_serves_a_second_request_from_cache) {
+  const std::string path = writeTemporaryPng("basalt_loader_two.png");
+  EXPECT(!path.empty());
+  const std::string uri = fileUri(path);
+
+  Win32ImageLoader loader;
+  std::shared_ptr<RnWin32Image> first;
+  loader.load(uri, [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+    first = std::move(image);
+  });
+  EXPECT(first != nullptr);
+
+  // Deleted before the second request, so a loader that went back to the disk
+  // would fail. The same object coming back is what says it did not.
+  std::remove(path.c_str());
+
+  std::shared_ptr<RnWin32Image> second;
+  loader.load(uri, [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+    second = std::move(image);
+  });
+  EXPECT(second != nullptr);
+  EXPECT(first == second);
+}
+
+TEST(image_loader_reports_a_missing_file) {
+  Win32ImageLoader loader;
+  std::shared_ptr<RnWin32Image> loaded;
+  std::string error;
+  loader.load("file:///c:/nothing/here/at/all.png",
+              [&](std::shared_ptr<RnWin32Image> image, const std::string &why) {
+                loaded = std::move(image);
+                error = why;
+              });
+
+  EXPECT(loaded == nullptr);
+  EXPECT(!error.empty());
+}
+
+TEST(image_loader_rejects_an_empty_uri) {
+  Win32ImageLoader loader;
+  bool called = false;
+  std::shared_ptr<RnWin32Image> loaded;
+  loader.load("", [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+    called = true;
+    loaded = std::move(image);
+  });
+
+  // Answered rather than ignored: a caller that never hears back cannot tell
+  // the difference between a slow load and a dropped one.
+  EXPECT(called);
+  EXPECT(loaded == nullptr);
+}
+
+TEST(image_loader_reports_bytes_that_are_not_an_image) {
+  const char *temp = std::getenv("TEMP");
+  const std::string path = std::string(temp != nullptr ? temp : ".") + "\\basalt_loader_junk.png";
+  if (FILE *file = std::fopen(path.c_str(), "wb")) {
+    std::fputs("not a png at all", file);
+    std::fclose(file);
+  }
+
+  Win32ImageLoader loader;
+  std::shared_ptr<RnWin32Image> loaded;
+  std::string error;
+  loader.load(fileUri(path), [&](std::shared_ptr<RnWin32Image> image, const std::string &why) {
+    loaded = std::move(image);
+    error = why;
+  });
+
+  EXPECT(loaded == nullptr);
+  EXPECT(!error.empty());
+  std::remove(path.c_str());
+}
+
+TEST(image_loader_clears_its_cache) {
+  const std::string path = writeTemporaryPng("basalt_loader_three.png");
+  EXPECT(!path.empty());
+  const std::string uri = fileUri(path);
+
+  Win32ImageLoader loader;
+  std::shared_ptr<RnWin32Image> first;
+  loader.load(uri, [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+    first = std::move(image);
+  });
+  EXPECT(first != nullptr);
+
+  loader.clearCache();
+
+  std::shared_ptr<RnWin32Image> second;
+  loader.load(uri, [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+    second = std::move(image);
+  });
+  EXPECT(second != nullptr);
+  // A different object: the cache really was dropped and the file read again.
+  EXPECT(first != second);
+
+  std::remove(path.c_str());
+}
+
+TEST(image_loader_state_outlives_the_loader) {
+  // The hazard this class exists to avoid. A load's completion holds a shared
+  // reference to the loader's state rather than to the loader, so a loader
+  // destroyed between the two is not a use-after-free.
+  //
+  // Synchronous here, so this cannot catch the race directly -- what it does
+  // catch is the shape: destroying a loader that has loaded must not disturb
+  // an image its caller is still holding, which would be the symptom if the
+  // cache owned rather than shared.
+  const std::string path = writeTemporaryPng("basalt_loader_four.png");
+  EXPECT(!path.empty());
+
+  std::shared_ptr<RnWin32Image> survivor;
+  {
+    Win32ImageLoader loader;
+    loader.load(fileUri(path), [&](std::shared_ptr<RnWin32Image> image, const std::string &) {
+      survivor = std::move(image);
+    });
+  }
+
+  EXPECT(survivor != nullptr);
+  if (survivor != nullptr) {
+    EXPECT_EQ(survivor->width(), 20u);
+  }
+  std::remove(path.c_str());
+}

package/native/tests/test_win32_input.cpp

@@ -0,0 +1,361 @@
+// Tests for the touch dispatcher: does a mouse message become the right touch,
+// against the right view, and does a gesture recogniser see the same geometry?
+//
+// Hit testing itself is not here -- it is a pure function of the view tree and
+// needs no React Native, so it lives in tests/test_win32_hittest.cpp with the
+// rest of the view layer. What is here is everything above it: the state
+// machine that decides a move is a drag rather than hover, the tag a touch is
+// reported against, and the hit chain a gesture handler is offered.
+//
+// Nothing below synthesises a real mouse event. Doing that on Windows means
+// SendInput, which moves the actual cursor and so cannot run beside anything
+// else on the machine; the same objection CGEvent raises on macOS. So these
+// enter at `dispatchTouch*`, exactly where the window procedure does, and what
+// goes untested is that Windows routes WM_LBUTTONDOWN here at all.
+
+#include "TestHarness.h"
+
+#include "PointerButtons.h"
+
+#include "Gestures.h"
+#include "Win32MountingManager.h"
+#include "Win32TouchDispatcher.h"
+
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+using basalt::Win32MountingManager;
+using basalt::Win32TouchDispatcher;
+using basalt::win32::RnWin32View;
+using facebook::react::LayoutMetrics;
+using facebook::react::MountingTransaction;
+using facebook::react::ShadowView;
+using facebook::react::ShadowViewMutation;
+using facebook::react::ShadowViewMutationList;
+using facebook::react::SurfaceId;
+using facebook::react::Tag;
+using facebook::react::TransactionTelemetry;
+using facebook::react::ViewProps;
+
+namespace {
+
+constexpr SurfaceId kSurfaceId = 1;
+
+ShadowView makeView(Tag tag, float x, float y, float width, float height) {
+  LayoutMetrics metrics;
+  metrics.frame = {.origin = {.x = x, .y = y}, .size = {.width = width, .height = height}};
+
+  ShadowView view;
+  view.componentName = "View";
+  view.surfaceId = kSurfaceId;
+  view.tag = tag;
+  view.props = std::make_shared<ViewProps>();
+  view.layoutMetrics = metrics;
+  return view;
+}
+
+void apply(Win32MountingManager &manager, ShadowViewMutationList &&mutations) {
+  manager.applyTransaction(
+      kSurfaceId, MountingTransaction(kSurfaceId, 1, std::move(mutations), TransactionTelemetry{}));
+}
+
+// Creates and inserts one view under `parent` in a single transaction, which is
+// how Fabric would send it.
+void mount(Win32MountingManager &manager,
+           Tag parent,
+           Tag tag,
+           float x,
+           float y,
+           float width,
+           float height) {
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeView(tag, x, y, width, height)));
+  mutations.push_back(
+      ShadowViewMutation::InsertMutation(parent, makeView(tag, x, y, width, height), 0));
+  apply(manager, std::move(mutations));
+}
+
+// The gesture registry is a process-wide singleton -- there is one pointer --
+// so a test that attaches anything has to start by dropping what the last one
+// left behind, and end by dropping its own.
+struct GestureScope {
+  std::vector<std::string> states;
+
+  GestureScope() {
+    clear();
+    basalt::gestures().setEmitter([this](const std::string &event, folly::dynamic payload) {
+      if (event != "onGestureHandlerStateChange") {
+        return;
+      }
+      states.push_back(std::to_string(static_cast<int>(payload["state"].asDouble())));
+    });
+  }
+
+  ~GestureScope() {
+    basalt::gestures().setEmitter(nullptr);
+    clear();
+  }
+
+  GestureScope(const GestureScope &) = delete;
+  GestureScope &operator=(const GestureScope &) = delete;
+
+  static void clear() {
+    for (int tag = 1; tag <= 32; tag++) {
+      basalt::gestures().drop(tag);
+    }
+  }
+
+  // "2,4,5" -- readable in a failure message, which a vector is not.
+  std::string joined() const {
+    std::string out;
+    for (const std::string &state : states) {
+      if (!out.empty()) {
+        out += ",";
+      }
+      out += state;
+    }
+    return out;
+  }
+};
+
+} // namespace
+
+// The dispatcher against a real mounted tree: a tap has to find the tag the
+// mounting manager registered, not just some view.
+TEST(win32_a_synthesised_tap_finds_the_mounted_view) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 40, 50, 120, 60);
+
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 50, 60)), 10L);
+  // Inside the surface but over nothing: the root is the honest answer, because
+  // the responder system needs a target for every press inside the surface.
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 5, 5)),
+            static_cast<long>(kSurfaceId));
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 5000, 5000)), 0L);
+
+  // No emitter is attached to these hand-built shadow views, so the tap has
+  // nowhere to deliver. It must not crash: that is exactly the shape of a press
+  // arriving between a Remove and its Delete.
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.synthesiseTap(50, 60);
+  dispatcher.synthesiseTap(5000, 5000);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A move with no button down is hover, and the touch model has no place for it.
+// Reporting it would look to the responder system like a finger dragging across
+// the screen at all times, which cancels every press before it can fire.
+TEST(win32_a_move_before_a_press_is_ignored) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 0, 0, 100, 100);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.dispatchTouchMove(10, 10);
+  EXPECT(!dispatcher.isDown());
+  // An end with no start is a no-op too, which is the case the host hits when
+  // a WM_LBUTTONUP arrives after the surface was torn down.
+  dispatcher.dispatchTouchEnd(10, 10, basalt::PointerButton::Primary);
+  dispatcher.dispatchTouchCancel();
+  EXPECT(!dispatcher.isDown());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// The press/release pair, which is the state the host reads to decide whether
+// to hold capture. A press that hits nothing must not arm it: releasing capture
+// that was never taken is how a window ends up ignoring the mouse entirely.
+TEST(win32_a_press_is_only_outstanding_between_down_and_up) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 40, 50, 120, 60);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  EXPECT(!dispatcher.isDown());
+  dispatcher.dispatchTouchStart(50, 60, basalt::PointerButton::Primary);
+  EXPECT(dispatcher.isDown());
+  dispatcher.dispatchTouchMove(60, 70);
+  EXPECT(dispatcher.isDown());
+  dispatcher.dispatchTouchEnd(60, 70, basalt::PointerButton::Primary);
+  EXPECT(!dispatcher.isDown());
+
+  // Outside the surface entirely: nothing was hit, so nothing is down.
+  dispatcher.dispatchTouchStart(5000, 5000, basalt::PointerButton::Primary);
+  EXPECT(!dispatcher.isDown());
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A press with no surface root at all -- which is what the host has between
+// creating the window and starting the surface.
+TEST(win32_a_press_with_no_surface_is_a_no_op) {
+  Win32TouchDispatcher dispatcher(nullptr, nullptr);
+  dispatcher.dispatchTouchStart(10, 10, basalt::PointerButton::Primary);
+  dispatcher.dispatchTouchMove(20, 20);
+  dispatcher.dispatchTouchEnd(20, 20, basalt::PointerButton::Primary);
+  EXPECT(!dispatcher.isDown());
+}
+
+// The dispatcher's other half: a pointer offered to react-native-gesture-handler
+// with the views under it. A pan attached to a mounted view has to see the
+// press, the movement and the release, which is BEGAN, ACTIVE, END.
+TEST(win32_a_drag_drives_a_pan_recogniser) {
+  GestureScope scope;
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 40, 50, 120, 60);
+
+  basalt::gestures().create("PanGestureHandler", 1, folly::dynamic::object());
+  basalt::gestures().attach(1, 10);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.synthesiseDrag(50, 60, 150, 60, 20);
+
+  EXPECT_EQ(scope.joined(), std::string("2,4,5"));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A handler attached to an *ancestor* of the pressed view still sees the
+// gesture, which is the whole reason the dispatcher builds a chain rather than
+// reporting the one tag a touch is reported against. Getting this wrong means a
+// <GestureDetector> wrapping a screen never fires, because the press always
+// lands on something inside it.
+TEST(win32_a_gesture_on_an_ancestor_sees_the_press) {
+  GestureScope scope;
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 40, 50, 200, 200);
+  mount(manager, 10, 11, 10, 10, 50, 50);
+
+  // The press lands on 11; the handler is on its parent.
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 60, 70)), 11L);
+
+  basalt::gestures().create("PanGestureHandler", 1, folly::dynamic::object());
+  basalt::gestures().attach(1, 10);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.synthesiseDrag(60, 70, 160, 70, 20);
+
+  EXPECT_EQ(scope.joined(), std::string("2,4,5"));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// The chain carries each view's origin in root coordinates, and a scrolled
+// ancestor moves it. The recogniser is what reads that origin, so a scroll that
+// the chain does not account for puts a gesture's x/y in the wrong place -- and
+// since hit testing already follows the scroll, the two would disagree about
+// the same press.
+TEST(win32_the_hit_chain_follows_a_scroll_offset) {
+  GestureScope scope;
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 0, 0, 200, 200);
+  mount(manager, 10, 11, 0, 100, 50, 50);
+
+  // Scrolled down by 100, so the child that was at y=100 is now at the top.
+  manager.viewForTag(10)->setScrollOffset(0, 100);
+  EXPECT_EQ(static_cast<long>(basalt::hitTestTag(root, 10, 10)), 11L);
+
+  basalt::gestures().create("PanGestureHandler", 1, folly::dynamic::object());
+  basalt::gestures().attach(1, 11);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.synthesiseDrag(10, 10, 110, 10, 20);
+
+  EXPECT_EQ(scope.joined(), std::string("2,4,5"));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// A native handler that activates owns the pointer, and React Native's touch
+// has to be cancelled or a pan over a <Pressable> both pans and presses it.
+// The observable half here is that the dispatcher stops considering a press
+// outstanding the moment the handler activates.
+TEST(win32_an_activated_gesture_takes_the_pointer) {
+  GestureScope scope;
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 0, 0, 200, 200);
+
+  // A native handler activates on contact rather than waiting for movement,
+  // which makes the handover observable from a single press.
+  basalt::gestures().create("NativeViewGestureHandler", 1, folly::dynamic::object());
+  basalt::gestures().attach(1, 10);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.dispatchTouchStart(50, 50, basalt::PointerButton::Primary);
+  EXPECT(!dispatcher.isDown());
+
+  dispatcher.dispatchTouchEnd(50, 50, basalt::PointerButton::Primary);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// Hover runs only for views that asked for it, and the ask arrives as props on
+// every Create and Update. Recorded by the mutation walk, so a cursor crossing
+// an app that uses no hover costs a hit test and nothing else.
+TEST(win32_a_hover_listener_is_remembered_from_the_props) {
+  Win32MountingManager manager;
+  manager.createSurfaceRoot(kSurfaceId);
+
+  ShadowView listening = makeView(10, 40, 50, 120, 60);
+  auto props = std::make_shared<ViewProps>();
+  props->events[facebook::react::ViewEvents::Offset::PointerEnter] = true;
+  listening.props = props;
+
+  ShadowViewMutationList mutations;
+  mutations.push_back(ShadowViewMutation::CreateMutation(listening));
+  mutations.push_back(ShadowViewMutation::InsertMutation(kSurfaceId, listening, 0));
+  apply(manager, std::move(mutations));
+
+  EXPECT_EQ(manager.hoverListenersForTag(10),
+            static_cast<std::uint16_t>(basalt::HoverListenerEnter));
+  // A view that never asked is not stored at all.
+  EXPECT_EQ(manager.hoverListenersForTag(kSurfaceId),
+            static_cast<std::uint16_t>(basalt::HoverListenerNone));
+
+  // An update can take the listener away again, and leaving the old mask behind
+  // would mean dispatching to a view that stopped listening.
+  ShadowViewMutationList updates;
+  updates.push_back(ShadowViewMutation::UpdateMutation(
+      listening, makeView(10, 40, 50, 120, 60), kSurfaceId));
+  apply(manager, std::move(updates));
+  EXPECT_EQ(manager.hoverListenersForTag(10),
+            static_cast<std::uint16_t>(basalt::HoverListenerNone));
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}
+
+// The same shape as the synthesised tap: no emitter is attached to these
+// hand-built shadow views, so every hover has nowhere to deliver and must not
+// crash -- which is also what a cursor moving during a surface teardown looks
+// like from here.
+TEST(win32_a_synthesised_hover_walks_the_tree_without_an_emitter) {
+  Win32MountingManager manager;
+  RnWin32View *root = manager.createSurfaceRoot(kSurfaceId);
+  root->setFrame(0, 0, 400, 300);
+  mount(manager, kSurfaceId, 10, 40, 50, 120, 60);
+
+  Win32TouchDispatcher dispatcher(&manager, root);
+  dispatcher.synthesiseHover(50, 60);
+  dispatcher.synthesiseHover(5, 5);
+  // Outside the surface entirely, and then the cursor leaving the window.
+  dispatcher.synthesiseHover(5000, 5000);
+  dispatcher.synthesiseHover(-1, -1);
+
+  manager.destroySurfaceRoot(kSurfaceId);
+}

package/native/tests/test_win32_key_events.cpp

@@ -0,0 +1,84 @@
+// A Win32 key press as a key combination.
+//
+// The third of three mapping suites, and the one that most needs to exist: this
+// host is the one nobody can compile on a Mac, so the only thing that checks the
+// table below is CI. The two silent failures are the same as everywhere -- a
+// misspelt name matches nothing and reports nothing, and a bare modifier offered
+// as a combination fires a shortcut on Ctrl alone.
+//
+// What is *not* covered here is the modifiers. They come from `GetKeyState`
+// rather than from the message, so asserting on them would mean holding a key
+// down in a test process. The combination's key half is what this checks; the
+// modifier half is checked on the two hosts where the state arrives with the
+// event, and the three tables are written to agree.
+
+#include "TestHarness.h"
+
+#include "Win32KeyEvents.h"
+
+#include <windows.h>
+
+#include <sstream>
+#include <string>
+
+namespace {
+
+std::string keyOf(unsigned int virtualKey) {
+  const auto combination = basalt::keyCombinationFrom(virtualKey);
+  return combination.has_value() ? combination->key : std::string("(none)");
+}
+
+} // namespace
+
+TEST(win32_keys_the_arrows_have_browser_names) {
+  EXPECT_EQ(keyOf(VK_LEFT), std::string("ArrowLeft"));
+  EXPECT_EQ(keyOf(VK_RIGHT), std::string("ArrowRight"));
+  EXPECT_EQ(keyOf(VK_UP), std::string("ArrowUp"));
+  EXPECT_EQ(keyOf(VK_DOWN), std::string("ArrowDown"));
+}
+
+TEST(win32_keys_the_navigation_block_has_browser_names) {
+  // VK_PRIOR and VK_NEXT are Page Up and Page Down. The names are about
+  // priority, not paging, and getting them the wrong way round would be a
+  // shortcut that scrolls the wrong direction -- plausible enough to survive.
+  EXPECT_EQ(keyOf(VK_PRIOR), std::string("PageUp"));
+  EXPECT_EQ(keyOf(VK_NEXT), std::string("PageDown"));
+  EXPECT_EQ(keyOf(VK_HOME), std::string("Home"));
+  EXPECT_EQ(keyOf(VK_END), std::string("End"));
+  EXPECT_EQ(keyOf(VK_DELETE), std::string("Delete"));
+  EXPECT_EQ(keyOf(VK_BACK), std::string("Backspace"));
+}
+
+TEST(win32_keys_escape_enter_tab_and_space) {
+  EXPECT_EQ(keyOf(VK_ESCAPE), std::string("Escape"));
+  EXPECT_EQ(keyOf(VK_RETURN), std::string("Enter"));
+  EXPECT_EQ(keyOf(VK_TAB), std::string("Tab"));
+  // A space is named " ". Unlike the other two hosts, Shift+Tab here is VK_TAB
+  // with the modifier held rather than a key of its own, so there is nothing to
+  // fold together.
+  EXPECT_EQ(keyOf(VK_SPACE), std::string(" "));
+}
+
+TEST(win32_keys_a_bare_modifier_is_not_a_combination) {
+  // On the other two hosts a bare modifier is detectable by producing no
+  // character. Here the virtual key has to be recognised, so each one is listed
+  // and each one is asserted.
+  for (unsigned int key : {VK_SHIFT, VK_LSHIFT, VK_RSHIFT, VK_CONTROL, VK_LCONTROL,
+                           VK_RCONTROL, VK_MENU, VK_LMENU, VK_RMENU, VK_LWIN, VK_RWIN,
+                           VK_CAPITAL}) {
+    EXPECT_EQ(keyOf(key), std::string("(none)"));
+  }
+}
+
+TEST(win32_keys_a_letter_is_lower_case_when_shift_is_not_held) {
+  // MapVirtualKeyW hands back upper case for a letter whatever the shift state,
+  // so the case is applied by this host rather than arriving with the event. No
+  // key is held in a test process, so this is the unshifted answer.
+  EXPECT_EQ(keyOf('A'), std::string("a"));
+  EXPECT_EQ(keyOf('Z'), std::string("z"));
+}
+
+TEST(win32_keys_a_digit_is_itself) {
+  EXPECT_EQ(keyOf('0'), std::string("0"));
+  EXPECT_EQ(keyOf('7'), std::string("7"));
+}