Add Win32-specific tests for Cursor

CursorWin32Tests covers behaviour that is either Windows-only or
directly exercises the internal implementation paths changed in the
preceding cleanup commit:

- testHandleIsNonZeroForValidCursor: baseline sanity check that
  win32_getHandle() returns a non-zero OS handle for a live cursor.

- testDisposedCursorReturnsZeroHandle: verifies the isDisposed() guard
  at the top of win32_getHandle() returns 0L after disposal.

- testHandleIsCachedForSameZoomLevel: verifies the computeIfAbsent()
  caching - two calls with the same zoom must return the identical
  cached OS handle without re-creating it.

- testStyleCursorsWithSameStyleAreEqual: Windows-specific - LoadCursor()
  returns a shared system handle for the same cursor ID, so two
  independently created style cursors must satisfy equals(). This is a
  regression test for the previous Long-reference == comparison that
  could have silently returned false for handles outside the JVM integer
  cache range.

- testImageDataCursorProducesDifferentHandlesForDifferentZoomLevels:
  verifies that ImageDataCursorHandleProvider scales the source image
  and produces a distinct OS cursor handle for each zoom level.

- testDestroyHandlesExceptPreservesRetainedHandle: verifies that
  destroyHandlesExcept() leaves the retained zoom entry intact and
  does not mark the cursor as disposed.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: HeikoKlare

bundles/org.eclipse.swt/Eclipse SWT Tests/win32/org/eclipse/swt/graphics/CursorWin32Tests.java

@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.swt.graphics;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.internal.*;
+import org.eclipse.swt.widgets.*;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.extension.*;
+
+@ExtendWith(PlatformSpecificExecutionExtension.class)
+@ExtendWith(WithMonitorSpecificScalingExtension.class)
+class CursorWin32Tests {
+
+	private Display display;
+
+	@BeforeEach
+	void setUp() {
+		display = Display.getDefault();
+	}
+
+	@Test
+	void testHandleIsNonZeroForValidCursor() {
+		Cursor cursor = new Cursor(display, SWT.CURSOR_ARROW);
+		try {
+			assertNotEquals(0L, Cursor.win32_getHandle(cursor, 100),
+					"A non-disposed cursor must return a non-zero OS handle");
+		} finally {
+			cursor.dispose();
+		}
+	}
+
+	@Test
+	void testDisposedCursorReturnsZeroHandle() {
+		Cursor cursor = new Cursor(display, SWT.CURSOR_ARROW);
+		cursor.dispose();
+		assertEquals(0L, Cursor.win32_getHandle(cursor, 100),
+				"A disposed cursor must return a zero handle");
+	}
+
+	@Test
+	void testHandleIsCachedForSameZoomLevel() {
+		Cursor cursor = new Cursor(display, SWT.CURSOR_ARROW);
+		try {
+			long first  = Cursor.win32_getHandle(cursor, 100);
+			long second = Cursor.win32_getHandle(cursor, 100);
+			assertEquals(first, second,
+					"Repeated calls with the same zoom must return the cached handle");
+		} finally {
+			cursor.dispose();
+		}
+	}
+
+	/**
+	 * On Windows, LoadCursor() returns the same shared system handle for the same
+	 * cursor style, so two independently created style-based Cursor objects must be
+	 * considered equal. This is the Windows-specific behaviour noted in
+	 * Test_org_eclipse_swt_graphics_Cursor and exercises the equals/hashCode path
+	 * that previously compared boxed Long references with ==.
+	 */
+	@Test
+	void testStyleCursorsWithSameStyleAreEqual() {
+		Cursor cursor1 = new Cursor(display, SWT.CURSOR_WAIT);
+		Cursor cursor2 = new Cursor(display, SWT.CURSOR_WAIT);
+		try {
+			assertTrue(cursor1.equals(cursor2),
+					"On Windows, two cursors with the same style must be equal because LoadCursor reuses the shared OS handle");
+			assertEquals(cursor1.hashCode(), cursor2.hashCode(),
+					"Equal cursors must have the same hash code");
+		} finally {
+			cursor1.dispose();
+			cursor2.dispose();
+		}
+	}
+
+	@Test
+	void testImageDataCursorProducesDifferentHandlesForDifferentZoomLevels() {
+		// 32bpp image with uniform alpha — takes the ARGB path in setupCursorFromImageData
+		ImageData source = new ImageData(16, 16, 32,
+				new PaletteData(0xFF00, 0xFF0000, 0xFF000000));
+		source.alpha = 255;
+
+		Cursor cursor = new Cursor(display, source, 0, 0);
+		try {
+			long handle100 = Cursor.win32_getHandle(cursor, 100);
+			long handle200 = Cursor.win32_getHandle(cursor, 200);
+
+			assertNotEquals(0L, handle100, "Handle at 100% zoom must be non-zero");
+			assertNotEquals(0L, handle200, "Handle at 200% zoom must be non-zero");
+			assertNotEquals(handle100, handle200,
+					"Different zoom levels must produce distinct OS cursor handles (different physical sizes)");
+		} finally {
+			cursor.dispose();
+		}
+	}
+
+	@Test
+	void testDestroyHandlesExceptPreservesRetainedHandle() {
+		// 32bpp ARGB source so we get a unique, non-shared OS handle per zoom level
+		ImageData source = new ImageData(16, 16, 32,
+				new PaletteData(0xFF00, 0xFF0000, 0xFF000000));
+		source.alpha = 255;
+
+		Cursor cursor = new Cursor(display, source, 0, 0);
+		try {
+			long handle100 = Cursor.win32_getHandle(cursor, 100);
+			Cursor.win32_getHandle(cursor, 200); // populate a second zoom level
+
+			cursor.destroyHandlesExcept(Set.of(DPIUtil.getZoomForAutoscaleProperty(100)));
+
+			// The cursor itself must still be alive and the retained handle unchanged
+			assertFalse(cursor.isDisposed(), "Cursor must not be disposed after destroyHandlesExcept");
+			assertEquals(handle100, Cursor.win32_getHandle(cursor, 100),
+					"The handle for the retained zoom level must be unchanged after destroyHandlesExcept");
+		} finally {
+			cursor.dispose();
+		}
+	}
+}