fix: use Process.MainWindowHandle for reliable window repositioning on WinUI 3

- GetActiveWindow/GetForegroundWindow return null (0x0) for XAML-island child
  HWNDs when thread focus changes during test execution
- Use Process.GetCurrentProcess().MainWindowHandle to reliably find the
  top-level window for SetWindowPos repositioning
- Ensures EnsureClientAreaOnScreen actually moves the root window when
  test UI elements extend off-screen (Y=-280 clamped to Y=0 by SetCursorPos)
- Add cursor-verification guard in Tap() that throws descriptive
  InvalidOperationException when SetCursorPos cannot reach the target
- Remove unused GetParent P/Invoke declaration

Author: agneszitte

src/TestApp/PointersInjectionTests.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Windows.Devices.Input;
+using Windows.Foundation;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 using Microsoft.UI.Xaml;
@@ -40,6 +41,10 @@ public async Task When_TapCoordinates()
 
 		InputInjectorHelper.Current.Tap(elt);
 
+		// On WinUI 3, InputInjector queues events into the OS input queue.
+		// Yield to let the message loop process them before asserting.
+		await Task.Yield();
+
 		Assert.IsTrue(clicked);
 	}
 
@@ -65,11 +70,23 @@ public async Task When_TapCoordinates_Sequential()
 		await UnitTestsUIContentHelper.WaitForLoaded(button1);
 		await UnitTestsUIContentHelper.WaitForLoaded(button2);
 
+		var center1 = button1.TransformToVisual(null)
+			.TransformPoint(new Point(button1.ActualSize.X / 2.0, button1.ActualSize.Y / 2.0));
+		var center2 = button2.TransformToVisual(null)
+			.TransformPoint(new Point(button2.ActualSize.X / 2.0, button2.ActualSize.Y / 2.0));
+		var scale = button1.XamlRoot?.RasterizationScale ?? -1;
+
 		InputInjectorHelper.Current.Tap(button1);
-		Assert.IsTrue(clicked1, "First button should have been clicked");
+		await Task.Yield();
+		Assert.IsTrue(clicked1,
+			$"First button should have been clicked. " +
+			$"Btn1=({center1.X:F1},{center1.Y:F1}), Btn2=({center2.X:F1},{center2.Y:F1}), Scale={scale}");
 
 		InputInjectorHelper.Current.Tap(button2);
-		Assert.IsTrue(clicked2, "Second button should have been clicked");
+		await Task.Yield();
+		Assert.IsTrue(clicked2,
+			$"Second button should have been clicked. " +
+			$"Btn1=({center1.X:F1},{center1.Y:F1}), Btn2=({center2.X:F1},{center2.Y:F1}), Scale={scale}");
 	}
 
 	[TestMethod]

src/Uno.UI.RuntimeTests.Engine.Library/Library/Helpers/InputInjectorHelperExtensions.cs

@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 #if !HAS_UNO
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 #endif
 using Windows.Foundation;
@@ -29,13 +30,35 @@ public static void Tap(this InputInjectorHelper injector, UIElement elt)
 		if (injector.CurrentPointerType == PointerDeviceType.Mouse)
 		{
 			// On WinUI 3, InputInjector uses relative mouse deltas from the physical OS cursor.
-			// The tracked position does not correspond to the physical cursor location, so
-			// MoveTo (which computes deltas from tracked position) misses the target.
-			// Use Win32 SetCursorPos to position the cursor at the exact element center,
-			// then inject Press/Release at that location.
+			// Use Win32 SetCursorPos for absolute screen positioning, then inject a zero-delta
+			// Move so the WinUI input system registers the cursor at the target before button events.
 			var scale = elt.XamlRoot?.RasterizationScale ?? 1.0;
 			injector.InjectMouseInput(injector.Mouse.ReleaseAny());
-			PositionCursorAtClientCoordinates(center.X, center.Y, scale);
+			var screenPt = GetOnScreenPoint(center.X, center.Y, scale);
+			SetCursorPos(screenPt.x, screenPt.y);
+
+			// Verify the cursor reached the target. SetCursorPos silently clamps
+			// to virtual screen bounds; if the cursor drifted, the click would miss.
+			GetCursorPos(out var actual);
+			if (Math.Abs(actual.x - screenPt.x) > 2 || Math.Abs(actual.y - screenPt.y) > 2)
+			{
+				var processHwnd = Process.GetCurrentProcess().MainWindowHandle;
+				var diagHwnd = GetActiveWindow();
+				GetWindowRect(processHwnd, out var procRect);
+				throw new InvalidOperationException(
+					$"Cannot tap element: cursor could not reach screen ({screenPt.x},{screenPt.y}). " +
+					$"Actual=({actual.x},{actual.y}). " +
+					$"Center DIPs=({center.X:F1},{center.Y:F1}), Scale={scale}. " +
+					$"ProcessHWND=0x{processHwnd.ToInt64():X}, ActiveHWND=0x{diagHwnd.ToInt64():X}. " +
+					$"ProcessRect=({procRect.left},{procRect.top},{procRect.right},{procRect.bottom}).");
+			}
+
+			injector.InjectMouseInput(new InjectedInputMouseInfo
+			{
+				MouseOptions = InjectedInputMouseOptions.Move,
+				DeltaX = 0,
+				DeltaY = 0
+			});
 			injector.Mouse.SetTrackedPosition(center.X, center.Y);
 			injector.InjectMouseInput(injector.Mouse.Press());
 			injector.InjectMouseInput(injector.Mouse.Release());
@@ -185,35 +208,145 @@ private struct POINT
 		public int y;
 	}
 
+	[StructLayout(LayoutKind.Sequential)]
+	private struct RECT
+	{
+		public int left, top, right, bottom;
+	}
+
 	[DllImport("user32.dll")]
 	private static extern bool SetCursorPos(int X, int Y);
 
 	[DllImport("user32.dll")]
 	private static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);
 
+	[DllImport("user32.dll")]
+	private static extern bool GetCursorPos(out POINT lpPoint);
+
 	[DllImport("user32.dll")]
 	private static extern IntPtr GetActiveWindow();
 
+	[DllImport("user32.dll")]
+	private static extern IntPtr GetForegroundWindow();
+
+	[DllImport("user32.dll")]
+	private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+	[DllImport("user32.dll")]
+	private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter,
+		int X, int Y, int cx, int cy, uint uFlags);
+
+	[DllImport("user32.dll")]
+	private static extern int GetSystemMetrics(int nIndex);
+
+	[DllImport("user32.dll")]
+	private static extern IntPtr GetAncestor(IntPtr hwnd, uint gaFlags);
+
+	private const uint GA_ROOT = 2;
+
+	private const uint SWP_NOSIZE = 0x0001;
+	private const uint SWP_NOZORDER = 0x0004;
+	private const uint SWP_NOACTIVATE = 0x0010;
+	private const int SM_XVIRTUALSCREEN = 76;
+	private const int SM_YVIRTUALSCREEN = 77;
+	private const int SM_CXVIRTUALSCREEN = 78;
+	private const int SM_CYVIRTUALSCREEN = 79;
+
 	/// <summary>
-	/// Positions the OS cursor at the given window-client-relative DIP coordinates.
-	/// Converts from DIPs to physical pixels using the rasterization scale,
-	/// then from client coordinates to screen coordinates using ClientToScreen.
+	/// Converts window-client-relative DIP coordinates to screen pixel coordinates.
+	/// If the computed screen position falls outside the virtual screen bounds
+	/// (e.g., the window extends off-screen), the window is repositioned first
+	/// to ensure the point is reachable by cursor and touch input.
 	/// </summary>
-	private static void PositionCursorAtClientCoordinates(double dipX, double dipY, double rasterizationScale)
+	private static POINT GetOnScreenPoint(double clientDipX, double clientDipY, double scale)
 	{
 		var hwnd = GetActiveWindow();
 		if (hwnd == IntPtr.Zero)
 		{
-			return;
+			hwnd = GetForegroundWindow();
+		}
+		if (hwnd == IntPtr.Zero)
+		{
+			hwnd = Process.GetCurrentProcess().MainWindowHandle;
 		}
 
-		var point = new POINT
+		var clientPixel = new POINT
 		{
-			x = (int)(dipX * rasterizationScale),
-			y = (int)(dipY * rasterizationScale)
+			x = (int)(clientDipX * scale),
+			y = (int)(clientDipY * scale)
 		};
-		ClientToScreen(hwnd, ref point);
-		SetCursorPos(point.x, point.y);
+
+		if (hwnd == IntPtr.Zero)
+		{
+			return clientPixel;
+		}
+
+		var screenPoint = clientPixel;
+		ClientToScreen(hwnd, ref screenPoint);
+
+		// If the screen position is outside the virtual screen, SetCursorPos
+		// will clamp the cursor and touch injection will miss the target.
+		// This happens when the test runner window extends beyond the visible
+		// screen area (common in automated/CI environments or multi-monitor setups).
+		if (!IsPointOnVirtualScreen(screenPoint.x, screenPoint.y))
+		{
+			EnsureClientAreaOnScreen(hwnd);
+
+			// Recompute screen coordinates after the window move.
+			screenPoint = clientPixel;
+			ClientToScreen(hwnd, ref screenPoint);
+		}
+
+		return screenPoint;
+	}
+
+	private static bool IsPointOnVirtualScreen(int x, int y)
+	{
+		int left = GetSystemMetrics(SM_XVIRTUALSCREEN);
+		int top = GetSystemMetrics(SM_YVIRTUALSCREEN);
+		int width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+		int height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+		return x >= left && x < left + width && y >= top && y < top + height;
+	}
+
+	/// <summary>
+	/// Moves the top-level ancestor window so the given child HWND's client area
+	/// origin maps to screen (100, 100), ensuring elements near the top-left
+	/// of the client area are reachable by the OS cursor.
+	/// SetWindowPos on child windows only repositions them within their parent,
+	/// so we must find and move the root ancestor.
+	/// </summary>
+	private static void EnsureClientAreaOnScreen(IntPtr hwnd)
+	{
+		// Use Process.MainWindowHandle to reliably get the top-level window.
+		// GetActiveWindow returns a XAML-island child HWND, and GetAncestor(GA_ROOT)
+		// may not traverse the WinUI 3 HWND hierarchy correctly.
+		var rootHwnd = Process.GetCurrentProcess().MainWindowHandle;
+		if (rootHwnd == IntPtr.Zero)
+		{
+			rootHwnd = GetAncestor(hwnd, GA_ROOT);
+		}
+		if (rootHwnd == IntPtr.Zero)
+		{
+			return; // Cannot determine top-level window; skip repositioning.
+		}
+
+		var clientOrigin = new POINT();
+		ClientToScreen(hwnd, ref clientOrigin);
+
+		GetWindowRect(rootHwnd, out var windowRect);
+
+		// Shift the root window so the child's client area origin
+		// lands at screen (100, 100).
+		int newLeft = windowRect.left + (100 - clientOrigin.x);
+		int newTop = windowRect.top + (100 - clientOrigin.y);
+
+		SetWindowPos(rootHwnd, IntPtr.Zero, newLeft, newTop, 0, 0,
+			SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
+
+		// Allow the OS to fully process the window position change
+		// before subsequent ClientToScreen calls read updated coordinates.
+		System.Threading.Thread.Sleep(500);
 	}
 #endif
 }