Add explicit activation (by tester) to Clipboard tests on Wayland

On Wayland apps are not allowed to take ownership of the system
clipboard unless the Wayland compositer (e.g KWin, mutter or others)
believes that the user has initiated the request for ownership.

This means that activating and focusing the Shell may not be sufficient.

Therefore we require the person running the tests to press a button
in the shell so the compositer believes that the clipboard access
is legitimate.

This commit adds such a button, and a short timeout to press it. If
not pressed in time the tests requiring SWT to take ownership of
the clipboard will be skipped.

The button must be pressed multiple times throughout the test, therefore
we group the affected tests to run first with TestMethodOrder annotation.

On GitHub actions + Jenkins these tests are skipped by default.

Note: At the moment activating + focusing the shell is sufficient to
read from the system clipboard. In addition, X11 (and therefore the Swing
remote clipboard test app) run under Xwayland do not require such
explicit activation, so the key presses are only on the couple of
tests that require ownership of system clipboard to operate properly.

Part of #2126

Author: jonahgraham

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

@@ -205,4 +205,9 @@ public String getStringContents(int clipboardId) throws RemoteException {
 	public void waitUntilReady() throws RemoteException {
 		remote.waitUntilReady();
 	}
+
+	@Override
+	public void waitForButtonPress()  throws RemoteException {
+		remote.waitForButtonPress();
+	}
 }

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

@@ -125,6 +125,28 @@ public final static boolean isX11() {
 		throw new IllegalStateException("unreachable");
 	}
 
+	/**
+	 * Return whether running on Wayland. This is dynamically set at runtime and cannot
+	 * be accessed before the corresponding property is initialized in Display.
+	 *
+	 * <strong>Note:</strong> this method still must be called after the first
+	 * Display is created to be valid
+	 */
+	public final static boolean isWayland() {
+		if (!isGTK) {
+			return false;
+		}
+		String backend = System.getProperty("org.eclipse.swt.internal.gdk.backend");
+
+		if ("wayland".equals(backend)) {
+			return true;
+		} else if ("x11".equals(backend)) {
+			return false;
+		}
+		fail("org.eclipse.swt.internal.gdk.backend System property is not set yet. Create a new Display before calling isWayland");
+		throw new IllegalStateException("unreachable");
+	}
+
 	/**
 	 * Return whether running on GTK4. This is dynamically set at runtime and cannot
 	 * be accessed before the corresponding property is initialized in OS.

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

@@ -12,23 +12,32 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
 
+import org.eclipse.swt.SWT;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.dnd.DND;
 import org.eclipse.swt.dnd.RTFTransfer;
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.layout.RowLayout;
+import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Shell;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
+import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -40,8 +49,20 @@
  *      some clipboard tests
  */
 @Tag("clipboard")
+@TestMethodOrder(OrderAnnotation.class) // run tests needing button presses first
 public class Test_org_eclipse_swt_dnd_Clipboard {
 
+	/**
+	 * See {@link #openAndFocusShell(boolean)} - some tests require user to actually
+	 * interact with the shell.
+	 *
+	 * Default to skipping tests requiring "real" activation on GHA and Jenkins.
+	 *
+	 * <code>true</code>: skip tests <code>false</code>: don't skip tests
+	 * <code>null</code>: unknown whether to skip tests yet
+	 */
+	private static Boolean skipTestsRequiringButtonPress = (Boolean.parseBoolean(System.getenv("GITHUB_ACTIONS"))
+			|| System.getenv("JOB_NAME") != null) ? true : null;
 	private static int uniqueId = 1;
 	private Display display;
 	private Shell shell;
@@ -65,21 +86,86 @@ public void setUp() {
 	 * Note: Wayland backend does not allow access to system clipboard from
 	 * non-focussed windows. So we have to create/open and focus a window here so
 	 * that clipboard operations work.
+	 *
+	 * Additionally, if we want to provide data to the clipboard, we require user
+	 * interaction on the created shell. Therefore if forSetContents is true the
+	 * tester needs to press a button for test to work.
+	 *
+	 * If there is no user interaction (button not pressed) then the test is
+	 * skipped, rather than failed, and subsequent tests requiring user interaction
+	 * as skipped too. See {@link #skipTestsRequiringButtonPress}
 	 */
-	private void openAndFocusShell() {
+	private void openAndFocusShell(boolean forSetContents) throws InterruptedException {
+		assertNull(shell);
 		shell = new Shell(display);
-		SwtTestUtil.openShell(shell);
+
+		boolean requireUserPress = forSetContents && SwtTestUtil.isWayland();
+		if (requireUserPress) {
+			assumeFalse(skipTestsRequiringButtonPress != null && skipTestsRequiringButtonPress,
+					"Skipping tests that require user input");
+
+			AtomicBoolean pressed = new AtomicBoolean(false);
+			shell.setLayout(new RowLayout(SWT.VERTICAL));
+			Button button = new Button(shell, SWT.PUSH);
+			button.setText("Press me!");
+			button.addListener(SWT.Selection, (e) -> pressed.set(true));
+			button.setSize(200, 50);
+			Label label = new Label(shell, SWT.NONE);
+			label.setText("""
+					Press the button to tell Wayland that you really want this window to have access to clipboard.
+					This is needed on Wayland because only really focussed programs are allowed to write to the
+					global keyboard.
+
+					If you don't press this button soon, the test will be skipped and you won't be asked again.
+					""");
+			Label timeleft = new Label(shell, SWT.NONE);
+			timeleft.setText("Time left to press button: XXXXXXXXXXXXXXXXXXXX seconds");
+
+			SwtTestUtil.openShell(shell);
+
+			// If we know there is a tester pressing the buttons, allow them
+			// a little grace on the timeout. If we don't know if there is a
+			// tester around, skip tests fairly quickly and don't
+			// ask again.
+			int timeout = skipTestsRequiringButtonPress == null ? 1500 : 10000;
+			long startTime = System.nanoTime();
+			SwtTestUtil.processEvents(timeout, () -> {
+				long nowTime = System.nanoTime();
+				long timeLeft = nowTime - startTime;
+				long timeLeftMs = timeout - (timeLeft / 1_000_000);
+				double timeLeftS = timeLeftMs / 1_000.0d;
+				timeleft.setText("Time left to press button: " + timeLeftS + " seconds");
+				return pressed.get();
+			});
+			boolean userPressedButton = pressed.get();
+			if (userPressedButton) {
+				skipTestsRequiringButtonPress = false;
+			} else {
+				skipTestsRequiringButtonPress = true;
+				assumeTrue(false, "Skipping tests that require user input");
+			}
+		} else {
+			SwtTestUtil.openShell(shell);
+		}
+
 	}
 
 	/**
 	 * Note: Wayland backend does not allow access to system clipboard from
 	 * non-focussed windows. So we have to open and focus remote here so that
 	 * clipboard operations work.
 	 */
-	public void openAndFocusRemote() throws Exception {
+	private void openAndFocusRemote() throws Exception {
 		assertNull(remote);
 		remote = new RemoteClipboard();
 		remote.start();
+
+		/*
+		 * If/when OpenJDK Project Wakefield gets merged then we may need to wait for
+		 * button pressed on the swing app just like the SWT app. This may also be
+		 * needed if Wayland implementations get more restrictive on X apps too.
+		 */
+		// remote.waitForButtonPress();
 	}
 
 	@AfterEach
@@ -138,8 +224,8 @@ public void test_Remote(int clipboardId) throws Exception {
 	 */
 	@ParameterizedTest
 	@MethodSource("supportedClipboardIds")
-	public void test_LocalClipboard(int clipboardId) {
-		openAndFocusShell();
+	public void test_LocalClipboard(int clipboardId) throws InterruptedException {
+		openAndFocusShell(false);
 
 		String helloWorld = getUniqueTestString();
 		clipboard.setContents(new Object[] { helloWorld }, new Transfer[] { textTransfer }, clipboardId);
@@ -179,10 +265,11 @@ public void test_LocalClipboard(int clipboardId) {
 		assertEquals(helloWorldRtf, clipboard.getContents(rtfTransfer, clipboardId));
 	}
 
+	@Order(2)
 	@ParameterizedTest
 	@MethodSource("supportedClipboardIds")
 	public void test_setContents(int clipboardId) throws Exception {
-		openAndFocusShell();
+		openAndFocusShell(true);
 		String helloWorld = getUniqueTestString();
 
 		clipboard.setContents(new Object[] { helloWorld }, new Transfer[] { textTransfer }, clipboardId);
@@ -199,11 +286,10 @@ public void test_getContents(int clipboardId) throws Exception {
 		String helloWorld = getUniqueTestString();
 		remote.setContents(helloWorld, clipboardId);
 
-		openAndFocusShell();
+		openAndFocusShell(false);
 		assertEquals(helloWorld, clipboard.getContents(textTransfer, clipboardId));
 	}
 
-
 	@Test
 	public void test_getContentsBothClipboards() throws Exception {
 		assumeTrue(SwtTestUtil.isGTK);
@@ -214,16 +300,17 @@ public void test_getContentsBothClipboards() throws Exception {
 		String helloWorldSelection = getUniqueTestString();
 		remote.setContents(helloWorldSelection, DND.SELECTION_CLIPBOARD);
 
-		openAndFocusShell();
+		openAndFocusShell(false);
 		assertEquals(helloWorldClipboard, clipboard.getContents(textTransfer, DND.CLIPBOARD));
 		assertEquals(helloWorldSelection, clipboard.getContents(textTransfer, DND.SELECTION_CLIPBOARD));
 	}
 
+	@Order(1)
 	@Test
 	public void test_setContentsBothClipboards() throws Exception {
 		assumeTrue(SwtTestUtil.isGTK);
 
-		openAndFocusShell();
+		openAndFocusShell(true);
 		String helloWorldClipboard = getUniqueTestString();
 		clipboard.setContents(new Object[] { helloWorldClipboard }, new Transfer[] { textTransfer }, DND.CLIPBOARD);
 		String helloWorldSelection = getUniqueTestString();
@@ -244,7 +331,7 @@ public void test_getContentsAsync(int clipboardId) throws Exception {
 		String helloWorld = getUniqueTestString();
 		remote.setContents(helloWorld, clipboardId);
 
-		openAndFocusShell();
+		openAndFocusShell(false);
 
 		// Multiple ways of using the API
 		// 1: Spin the event loop manually waiting for future to complete

tests/org.eclipse.swt.tests/data/clipboard/ClipboardCommands.java

@@ -43,4 +43,6 @@ public interface ClipboardCommands extends Remote {
 	String getStringContents(int clipboardId) throws RemoteException;
 
 	void waitUntilReady() throws RemoteException;
+
+	void waitForButtonPress() throws RemoteException;
 }

tests/org.eclipse.swt.tests/data/clipboard/ClipboardCommandsImpl.java

@@ -18,12 +18,15 @@
 import java.rmi.RemoteException;
 import java.rmi.server.UnicastRemoteObject;
 import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 import javax.swing.SwingUtilities;
 
 public class ClipboardCommandsImpl extends UnicastRemoteObject implements ClipboardCommands {
 	private static final long serialVersionUID = 330098269086266134L;
 	private ClipboardTest clipboardTest;
+	CountDownLatch buttonPressed;
 
 	protected ClipboardCommandsImpl(ClipboardTest clipboardTest) throws RemoteException {
 		super();
@@ -107,6 +110,23 @@ public void setFocus() throws RemoteException {
 		});
 	}
 
+	@Override
+	public void waitForButtonPress() throws RemoteException {
+		clipboardTest.log("waitForButtonPress() - START");
+		buttonPressed = new CountDownLatch(1);
+		try {
+			if (buttonPressed.await(10, TimeUnit.SECONDS)) {
+				clipboardTest.log("waitForButtonPress() - SUCCESS");
+			} else {
+				clipboardTest.log("waitForButtonPress() - FAILED Timeout");
+				throw new RemoteException("Button not pressed in time");
+			}
+		} catch (InterruptedException e) {
+			clipboardTest.log("waitForButtonPress() - FAILED Interrupted");
+			throw new RemoteException("Interrupted while waiting for button press", e);
+		}
+	}
+
 	private void invokeAndWait(Runnable run) throws RemoteException {
 		try {
 			SwingUtilities.invokeAndWait(run);

tests/org.eclipse.swt.tests/data/clipboard/ClipboardTest.java

@@ -56,7 +56,7 @@ public Socket createSocket(String host, int port) throws IOException {
 
 	private static Registry rmiRegistry;
 	private JTextArea textArea;
-	private ClipboardCommands commands;
+	private ClipboardCommandsImpl commands;
 
 	public ClipboardTest() throws RemoteException {
 		super("ClipboardTest");
@@ -68,6 +68,7 @@ public ClipboardTest() throws RemoteException {
 
 		JButton copyButton = new JButton("Copy");
 		JButton pasteButton = new JButton("Paste");
+		JButton pressToContinue = new JButton("Press To Continue Test");
 
 		copyButton.addActionListener(e -> {
 			String text = textArea.getSelectedText();
@@ -88,9 +89,14 @@ public ClipboardTest() throws RemoteException {
 			}
 		});
 
+		pressToContinue.addActionListener(e -> {
+			commands.buttonPressed.countDown();
+		});
+
 		JPanel buttonPanel = new JPanel();
 		buttonPanel.add(copyButton);
 		buttonPanel.add(pasteButton);
+		buttonPanel.add(pressToContinue);
 
 		add(scrollPane, BorderLayout.CENTER);
 		add(buttonPanel, BorderLayout.SOUTH);