lightweight variant (#1)

Reviewed-on: #1 Co-authored-by: Aleksandr Neychev <alexnejchev73@gmail.com>
2026-08-12 13:37:30 +00:00
parent a0d3098fe4
commit 55ac8e6556
147 changed files with 4055 additions and 2349 deletions
@@ -0,0 +1,106 @@
+using CursorLang.Core.Interop;
+using CursorLang.Tests.Shared;
+
+namespace CursorLang.Core.Tests.Interop;
+
+/// <summary>
+/// Vetting the caret position. Some applications report it in their own
+/// coordinate system, and such answers have to be sifted out by the bounds
+/// of the input window.
+/// </summary>
+public sealed class CaretNativeTests
+{
+    private static readonly PopupWindowNative.Rect Window = new()
+    {
+        Left = 100,
+        Top = 100,
+        Right = 900,
+        Bottom = 700,
+    };
+
+    [Fact]
+    public void A_caret_inside_the_window_is_taken_as_is()
+    {
+        var caret = new PopupWindowNative.Rect { Left = 200, Top = 300, Right = 202, Bottom = 320 };
+
+        Assert.Equal(caret, CaretNative.Validate(caret, Window, scale: 1.5));
+    }
+
+    // The application reported the coordinates without the screen scale: on
+    // their own they sit above and to the left of the input window, and after
+    // being brought to the scale they land inside it
+    [Fact]
+    public void An_unscaled_caret_is_brought_to_the_screen_scale()
+    {
+        var caret = new PopupWindowNative.Rect { Left = 80, Top = 80, Right = 81, Bottom = 90 };
+
+        PopupWindowNative.Rect? validated = CaretNative.Validate(caret, Window, scale: 1.5);
+
+        Assert.NotNull(validated);
+        Assert.Equal(120, validated.Value.Left);
+        Assert.Equal(120, validated.Value.Top);
+        Assert.Equal(121, validated.Value.Right);
+        Assert.Equal(135, validated.Value.Bottom);
+    }
+
+    [Fact]
+    public void A_caret_far_from_the_window_is_discarded()
+    {
+        var caret = new PopupWindowNative.Rect { Left = 5000, Top = 5000, Right = 5002, Bottom = 5020 };
+
+        Assert.Null(CaretNative.Validate(caret, Window, scale: 1.5));
+    }
+
+    // At the ordinary scale there is nothing to fix: wrong coordinates stay wrong
+    [Fact]
+    public void At_scale_one_a_caret_outside_the_window_is_discarded()
+    {
+        var caret = new PopupWindowNative.Rect { Left = 10, Top = 10, Right = 12, Bottom = 30 };
+
+        Assert.Null(CaretNative.Validate(caret, Window, scale: 1.0));
+    }
+
+    [Theory]
+    [InlineData(100, 100, 900, 700, true)]
+    [InlineData(99, 100, 900, 700, false)]
+    [InlineData(100, 99, 900, 700, false)]
+    [InlineData(100, 100, 901, 700, false)]
+    [InlineData(100, 100, 900, 701, false)]
+    [InlineData(400, 400, 402, 420, true)]
+    public void Inside_the_window_means_entirely_inside(
+        int left, int top, int right, int bottom, bool expected)
+    {
+        var caret = new PopupWindowNative.Rect { Left = left, Top = top, Right = right, Bottom = bottom };
+
+        Assert.Equal(expected, CaretNative.IsInside(caret, Window));
+    }
+
+    // When there is no caret, its rectangle comes back with zero height. Zero
+    // coordinates, on the other hand, are the ordinary start of an empty field
+    [Theory]
+    [InlineData(0, 0, 0, 0, true)]
+    [InlineData(0, 0, 2, 0, true)]
+    [InlineData(0, 10, 2, 5, true)]
+    [InlineData(0, 0, 0, 1, false)]
+    [InlineData(0, 0, 0, 20, false)]
+    public void A_caret_without_height_counts_as_empty(
+        int left, int top, int right, int bottom, bool expected)
+    {
+        var rect = new PopupWindowNative.Rect { Left = left, Top = top, Right = right, Bottom = bottom };
+
+        Assert.Equal(expected, CaretNative.IsEmpty(rect));
+    }
+
+    // The answer depends on what is on screen right now, but it has no right to
+    // throw: the tooltip is shown whatever the answer
+    [Fact]
+    public void Asking_the_system_for_the_caret_goes_without_errors()
+    {
+        PopupWindowNative.Rect? caret = Pump.Run(CaretNative.TryGetCaretRect);
+
+        if (caret is not null)
+        {
+            Assert.True(caret.Value.Bottom > caret.Value.Top);
+        }
+    }
+}
@@ -0,0 +1,209 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+using CursorLang.Core.Interop;
+using CursorLang.Tests.Shared;
+
+namespace CursorLang.Core.Tests.Interop;
+
+/// <summary>
+/// Making sense of the events of the system keyboard hook.
+/// </summary>
+/// <remarks>
+/// The events are fed straight into the handler the way Windows sends them:
+/// the tests have no right to press keys for real — the interception is shared
+/// by the whole system, and a real press would land in someone else's window.
+/// </remarks>
+public sealed class LowLevelKeyboardHookTests
+{
+    private const int HcAction = 0;
+    private const int WmKeyDown = 0x0100;
+    private const int WmKeyUp = 0x0101;
+    private const int WmSysKeyDown = 0x0104;
+    private const int WmSysKeyUp = 0x0105;
+    private const int WmMouseMove = 0x0200;
+
+    private const uint Injected = 0x10;
+    private const int CapsLock = 0x14;
+
+    [Theory]
+    [InlineData(WmKeyDown, true)]
+    [InlineData(WmSysKeyDown, true)]
+    [InlineData(WmKeyUp, false)]
+    [InlineData(WmSysKeyUp, false)]
+    public void Presses_and_releases_reach_the_handler(int message, bool expectedKeyDown)
+    {
+        List<(int Key, bool IsDown)> events = [];
+        var hook = new LowLevelKeyboardHook((key, isDown) =>
+        {
+            events.Add((key, isDown));
+            return false;
+        });
+
+        using (hook)
+        {
+            Send(hook, HcAction, message, CapsLock, flags: 0);
+        }
+
+        Assert.Equal([(CapsLock, expectedKeyDown)], events);
+    }
+
+    [Fact]
+    public void A_swallowed_event_goes_no_further()
+    {
+        using var hook = new LowLevelKeyboardHook(static (_, _) => true);
+
+        IntPtr result = Send(hook, HcAction, WmKeyDown, CapsLock, flags: 0);
+
+        // A non-zero answer breaks the chain: neither the application nor the
+        // case handler in Windows will see the event
+        Assert.Equal(new IntPtr(1), result);
+    }
+
+    // Synthetic input comes from on-screen keyboards and automation tools
+    [Fact]
+    public void Synthetic_input_is_not_intercepted()
+    {
+        List<int> keys = [];
+        using var hook = new LowLevelKeyboardHook((key, _) =>
+        {
+            keys.Add(key);
+            return true;
+        });
+
+        IntPtr result = Send(hook, HcAction, WmKeyDown, CapsLock, Injected);
+
+        Assert.Empty(keys);
+        Assert.NotEqual(new IntPtr(1), result);
+    }
+
+    // Windows asks for events below zero not to be inspected but simply passed on
+    [Fact]
+    public void Events_not_meant_for_inspection_are_passed_on()
+    {
+        List<int> keys = [];
+        using var hook = new LowLevelKeyboardHook((key, _) =>
+        {
+            keys.Add(key);
+            return true;
+        });
+
+        Send(hook, code: -1, WmKeyDown, CapsLock, flags: 0);
+
+        Assert.Empty(keys);
+    }
+
+    [Fact]
+    public void The_other_messages_are_not_shown_to_the_handler()
+    {
+        List<int> keys = [];
+        using var hook = new LowLevelKeyboardHook((key, _) =>
+        {
+            keys.Add(key);
+            return true;
+        });
+
+        Send(hook, HcAction, WmMouseMove, CapsLock, flags: 0);
+
+        Assert.Empty(keys);
+    }
+
+    [Fact]
+    public void The_handler_sees_the_code_of_the_pressed_key()
+    {
+        List<int> keys = [];
+        using var hook = new LowLevelKeyboardHook((key, _) =>
+        {
+            keys.Add(key);
+            return false;
+        });
+
+        Send(hook, HcAction, WmKeyDown, virtualKey: 0x41, flags: 0);
+        Send(hook, HcAction, WmKeyDown, virtualKey: 0x1B, flags: 0);
+
+        Assert.Equal([0x41, 0x1B], keys);
+    }
+
+    [Fact]
+    public void The_interception_is_installed_and_removed()
+    {
+        Pump.Run(() =>
+        {
+            using var hook = new LowLevelKeyboardHook(static (_, _) => false);
+
+            Assert.False(hook.IsInstalled);
+
+            Assert.True(hook.Install());
+            Assert.True(hook.IsInstalled);
+
+            hook.Uninstall();
+            Assert.False(hook.IsInstalled);
+        });
+    }
+
+    [Fact]
+    public void Installing_again_changes_nothing()
+    {
+        Pump.Run(() =>
+        {
+            using var hook = new LowLevelKeyboardHook(static (_, _) => false);
+
+            Assert.True(hook.Install());
+            Assert.True(hook.Install());
+            Assert.True(hook.IsInstalled);
+
+            hook.Uninstall();
+        });
+    }
+
+    [Fact]
+    public void Removing_without_installing_passes_silently()
+    {
+        var hook = new LowLevelKeyboardHook(static (_, _) => false);
+
+        hook.Uninstall();
+        hook.Uninstall();
+
+        Assert.False(hook.IsInstalled);
+    }
+
+    [Fact]
+    public void Closing_removes_the_interception()
+    {
+        Pump.Run(() =>
+        {
+            var hook = new LowLevelKeyboardHook(static (_, _) => false);
+            hook.Install();
+
+            hook.Dispose();
+
+            Assert.False(hook.IsInstalled);
+        });
+    }
+
+    // The event arrives from Windows as a structure in unmanaged memory
+    private static IntPtr Send(
+        LowLevelKeyboardHook hook, int code, int message, int virtualKey, uint flags)
+    {
+        // vkCode, scanCode, flags and time take four bytes each, then a pointer
+        const int Size = 24;
+        IntPtr data = Marshal.AllocHGlobal(Size);
+
+        try
+        {
+            Marshal.WriteInt32(data, 0, virtualKey);
+            Marshal.WriteInt32(data, 4, 0);
+            Marshal.WriteInt32(data, 8, (int)flags);
+            Marshal.WriteInt32(data, 12, 0);
+            Marshal.WriteIntPtr(data, 16, IntPtr.Zero);
+
+            MethodInfo handler = typeof(LowLevelKeyboardHook)
+                .GetMethod("OnHookEvent", BindingFlags.Instance | BindingFlags.NonPublic)!;
+
+            return (IntPtr)handler.Invoke(hook, [code, new IntPtr(message), data])!;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(data);
+        }
+    }
+}