Improve Clipboard tests

As I prepare my final Clipboard PR for #2126 I split out this test
simplification and refactor to ensure that the tests still work
as expected before my Clipboard changes land.

Changes include:

- Splitting out RemoteClipboard wrapper so that we can test other controls
clipboard fully by remotely controlling the clipboard.
- Moving some useful test methods (runOperationInThread and waitAllEvents)
to SwtTestUtil
- Improving SwtTestUtil.openShell on GTK4 so that all events needed to
ensure shell is fully opened are received. In particular we used to just
wait for SWT.Paint, however some operations, such as clipboard, cannot
happen until SWT.Activate are also received.
- Added SwtTestUtil.waitAllEvents to support SwtTestUtil.openShell change
- Cleaned up Test_org_eclipse_swt_dnd_Clipboard now that I have better
understanding how Clipboard works
- Added tests for selection clipboard by parameterizing most tests and
adding new tests that check interaction between selection and normal
clipboard
- Remove unneeded processEvents calls from Test_org_eclipse_swt_dnd_Clipboard

Part of #2126

Author: jonahgraham

tests/org.eclipse.swt.tests/JUnit Tests/org/eclipse/swt/tests/junit/RemoteClipboard.java

@@ -0,0 +1,208 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Kichwa Coders Canada, Inc.
+ *
+ * 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.tests.junit;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.ProcessBuilder.Redirect;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.rmi.NotBoundException;
+import java.rmi.RemoteException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.registry.Registry;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import clipboard.ClipboardCommands;
+
+public class RemoteClipboard implements ClipboardCommands {
+	private ClipboardCommands remote;
+	private Process remoteClipboardProcess;
+	private Path remoteClipboardTempDir;
+
+	public void start() throws Exception {
+		assertNull(remote, "Create a new instance to restart");
+		/*
+		 * The below copy using getPath may be redundant (i.e. it may be possible to run
+		 * the class files from where they currently reside in the bin folder or the
+		 * jar), but this method of setting up the class files is very simple and is
+		 * done the same way that other files are extracted for tests.
+		 *
+		 * If the ClipboardTest starts to get more complicated, or other tests want to
+		 * replicate this design element, then refactoring this is an option.
+		 */
+		remoteClipboardTempDir = Files.createTempDirectory("swt-test-Clipboard");
+		List.of( //
+				"ClipboardTest", //
+				"ClipboardCommands", //
+				"ClipboardCommandsImpl", //
+				"ClipboardTest$LocalHostOnlySocketFactory" //
+		).forEach((f) -> {
+			// extract the files and put them in the temp directory
+			SwtTestUtil.copyFile("/clipboard/" + f + ".class",
+					remoteClipboardTempDir.resolve("clipboard/" + f + ".class"));
+		});
+
+		String javaHome = System.getProperty("java.home");
+		String javaExe = javaHome + "/bin/java" + (SwtTestUtil.isWindowsOS ? ".exe" : "");
+		assertTrue(Files.exists(Path.of(javaExe)));
+
+		ProcessBuilder pb = new ProcessBuilder(javaExe, "clipboard.ClipboardTest")
+				.directory(remoteClipboardTempDir.toFile());
+		pb.inheritIO();
+		pb.redirectOutput(Redirect.PIPE);
+		remoteClipboardProcess = pb.start();
+
+		// Read server output to find the port
+		int port = SwtTestUtil.runOperationInThread(() -> {
+			BufferedReader reader = new BufferedReader(new InputStreamReader(remoteClipboardProcess.getInputStream()));
+			String line;
+			while ((line = reader.readLine()) != null) {
+				if (line.startsWith(ClipboardCommands.PORT_MESSAGE)) {
+					String[] parts = line.split(":");
+					return Integer.parseInt(parts[1].trim());
+				}
+			}
+			throw new RuntimeException("Failed to get port");
+		});
+		assertNotEquals(0, port);
+		try {
+			Registry reg = LocateRegistry.getRegistry("127.0.0.1", port);
+			long stopTime = System.currentTimeMillis() + 10000;
+			do {
+				try {
+					remote = (ClipboardCommands) reg.lookup(ClipboardCommands.ID);
+					break;
+				} catch (NotBoundException e) {
+					// try again because the remote app probably hasn't bound yet
+				}
+			} while (System.currentTimeMillis() < stopTime);
+		} catch (RemoteException e) {
+
+			Integer exitValue = null;
+			boolean waitFor = false;
+			try {
+				waitFor = remoteClipboardProcess.waitFor(5, TimeUnit.SECONDS);
+				if (waitFor) {
+					exitValue = remoteClipboardProcess.exitValue();
+				}
+			} catch (InterruptedException e1) {
+				Thread.interrupted();
+			}
+
+			String message = "Failed to get remote clipboards command, this seems to happen on macOS on I-build tests. Exception: "
+					+ e.toString() + " waitFor: " + waitFor + " exitValue: " + exitValue;
+
+			// Give some diagnostic information to help track down why this fails on build
+			// machine. We only hard error on Linux, for other platforms we allow test to
+			// just be skipped until we track down what is causing
+			// https://github.com/eclipse-platform/eclipse.platform.swt/issues/2553
+			assumeTrue(SwtTestUtil.isGTK, message);
+			throw new RuntimeException(message, e);
+		}
+		assertNotNull(remote);
+
+		// Run a no-op on the Swing event loop so that we know it is idle
+		// and we can continue startup
+		remote.waitUntilReady();
+		remote.setFocus();
+		remote.waitUntilReady();
+	}
+
+	@Override
+	public void stop() throws RemoteException {
+		try {
+			stopProcess();
+		} catch (InterruptedException e) {
+			Thread.interrupted();
+		} finally {
+			deleteRemoteTempDir();
+		}
+	}
+
+	private void stopProcess() throws RemoteException, InterruptedException {
+		try {
+			if (remote != null) {
+				remote.stop();
+				remote = null;
+			}
+		} finally {
+			if (remoteClipboardProcess != null) {
+				try {
+					remoteClipboardProcess.destroy();
+					assertTrue(remoteClipboardProcess.waitFor(10, TimeUnit.SECONDS));
+				} finally {
+					remoteClipboardProcess.destroyForcibly();
+					assertTrue(remoteClipboardProcess.waitFor(10, TimeUnit.SECONDS));
+					remoteClipboardProcess = null;
+				}
+			}
+		}
+	}
+
+	private void deleteRemoteTempDir() {
+		if (remoteClipboardTempDir != null) {
+			// At this point the process is ideally destroyed - or at least the test will
+			// report a failure if it isn't. Clean up the extracted files, but don't
+			// fail test if we fail to delete
+			try {
+				Files.walkFileTree(remoteClipboardTempDir, new SimpleFileVisitor<Path>() {
+					@Override
+					public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+						Files.delete(file);
+						return FileVisitResult.CONTINUE;
+					}
+
+					@Override
+					public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+						Files.delete(dir);
+						return FileVisitResult.CONTINUE;
+					}
+				});
+			} catch (IOException e) {
+				System.err.println("SWT Warning: Failed to clean up temp directory " + remoteClipboardTempDir
+						+ " Error:" + e.toString());
+				e.printStackTrace();
+			}
+		}
+	}
+
+	@Override
+	public void setContents(String string, int clipboardId) throws RemoteException {
+		remote.setContents(string, clipboardId);
+	}
+
+	@Override
+	public void setFocus() throws RemoteException {
+		remote.setFocus();
+	}
+
+	@Override
+	public String getStringContents(int clipboardId) throws RemoteException {
+		return remote.getStringContents(clipboardId);
+	}
+
+	@Override
+	public void waitUntilReady() throws RemoteException {
+		remote.waitUntilReady();
+	}
+}

tests/org.eclipse.swt.tests/JUnit Tests/org/eclipse/swt/tests/junit/SwtTestUtil.java

@@ -24,6 +24,9 @@
 import java.io.PrintStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BooleanSupplier;
 
@@ -203,7 +206,12 @@ public static boolean isBidi() {
 public static void openShell(Shell shell) {
 	if (shell != null && !shell.getVisible()) {
 		if (isGTK) {
-			waitEvent(() -> shell.open(), shell, SWT.Paint, 1000);
+			if (isGTK4()) {
+				waitAllEvents(() -> shell.open(), shell, Set.of(SWT.Paint, SWT.Activate, SWT.FocusIn), 1000);
+			} else {
+				waitEvent(() -> shell.open(), shell, SWT.Paint, 1000);
+			}
+			processEvents();
 		} else {
 			shell.open();
 		}
@@ -485,6 +493,45 @@ public static boolean waitEvent(Runnable trigger, Control control, int swtEvent,
 	return true;
 }
 
+/**
+ * Wait until specified control receives all the specified event.
+ *
+ * @param trigger       may be null. Code that is expected to send event.
+ *                      Note that if you trigger it outside, then event may
+ *                      arrive *before* you call this function, and it will
+ *                      fail to receive event.
+ * @param control       control expected to receive the event
+ * @param swtEvents     events, such as SWT.Paint
+ * @param timeoutMsec   how long to wait for event
+ * @return <code>true</code> if event was received
+ */
+public static boolean waitAllEvents(Runnable trigger, Control control, Set<Integer> swtEvents, int timeoutMsec) {
+	Map<Integer, Listener> eventsLeftToReceive = new HashMap<>();
+	for (Integer swtEvent : swtEvents) {
+		Listener listener = event -> {
+			control.removeListener(swtEvent, eventsLeftToReceive.get(swtEvent));
+			eventsLeftToReceive.remove(swtEvent);
+		};
+		eventsLeftToReceive.put(swtEvent, listener);
+		control.addListener(swtEvent, listener);
+	}
+	try {
+		if (trigger != null)
+			trigger.run();
+
+		long start = System.currentTimeMillis();
+		while (!eventsLeftToReceive.isEmpty()) {
+			if (System.currentTimeMillis() - start > timeoutMsec)
+				return false;
+			processEvents();
+		}
+	} finally {
+		eventsLeftToReceive.forEach((swtEvent, listener) -> control.removeListener(swtEvent, listener));
+	}
+
+	return true;
+}
+
 /**
  * Wait until specified Shell becomes active, or internal timeout elapses.
  *
@@ -642,4 +689,57 @@ public static Path copyFile(String sourceFilename, Path destinationPath) {
 	return destinationPath;
 }
 
+@FunctionalInterface
+public interface ExceptionalSupplier<T> {
+	T get() throws Exception;
+}
+
+/**
+ * When running some operations, such as requesting remote process read the
+ * clipboard, we need to have the event queue processing otherwise the remote
+ * won't be able to read our clipboard contribution.
+ *
+ * This method starts the supplier in a new thread and runs the event loop until
+ * the thread completes, or until a timeout is reached.
+ */
+static <T> T runOperationInThread(ExceptionalSupplier<T> supplier) throws RuntimeException {
+	return runOperationInThread(10000, supplier);
+}
+
+/**
+ * When running some operations, such as requesting remote process read the
+ * clipboard, we need to have the event queue processing otherwise the remote
+ * won't be able to read our clipboard contribution.
+ *
+ * This method starts the supplier in a new thread and runs the event loop until
+ * the thread completes, or until a timeout is reached.
+ */
+static <T> T runOperationInThread(int timeoutMs, ExceptionalSupplier<T> supplier) throws RuntimeException {
+	Object[] supplierValue = new Object[1];
+	Exception[] supplierException = new Exception[1];
+	Runnable task = () -> {
+		try {
+			supplierValue[0] = supplier.get();
+		} catch (Exception e) {
+			supplierValue[0] = null;
+			supplierException[0] = e;
+		}
+	};
+	Thread thread = new Thread(task, SwtTestUtil.class.getName() + ".runOperationInThread");
+	thread.setDaemon(true);
+	thread.start();
+	BooleanSupplier done = () -> !thread.isAlive();
+	try {
+		processEvents(timeoutMs, done);
+	} catch (InterruptedException e) {
+		throw new RuntimeException("Failed while running thread", e);
+	}
+	assertTrue(done.getAsBoolean());
+	if (supplierException[0] != null) {
+		throw new RuntimeException("Failed while running thread", supplierException[0]);
+	}
+	@SuppressWarnings("unchecked")
+	T result = (T) supplierValue[0];
+	return result;
+}
 }