CountDownLatch Synchronization for RCPTestWorkbenchAdvisor

The flaky test was caused by a race condition in
RCPTestWorkbenchAdvisor.java. The test spawns 4 background threads
during preStartup() that schedule async/sync runnables on the display.

However, there was no guarantee these runnables would execute before
postStartup() marked the workbench as "started" (by setting started =
true).

This meant asyncWithDisplayAccess could still be null when the test
assertions ran, causing intermittent failures.

This change adds a CountDownLatch to ensure all 4 async/sync operations
complete before marking the workbench as started:

  Key changes to
/tests/org.eclipse.ui.tests.harness/src/org/eclipse/ui/tests/harness/util/RCPTestWorkbenchAdvisor.java:

  1. Added latch field (line 48):
    - private static java.util.concurrent.CountDownLatch asyncLatch =
null;
  2. Initialize latch in preStartup() (line 130):
    - asyncLatch = new java.util.concurrent.CountDownLatch(4); — tracks
4 operations
  3. Count down after each operation completes:
    - In setupSyncDisplayThread(): Added finally block (lines 179-183)
that calls asyncLatch.countDown()
    - In setupAsyncDisplayThread(): Added finally block (lines 205-209)
that calls asyncLatch.countDown()
  4. Wait for operations in postStartup() (lines 222-235):
    - Waits up to 5 seconds for all operations to complete
    - Logs warnings if timeout occurs or thread is interrupted
    - Only marks started = true after all operations complete

Fixes #1517

Author: vogella

tests/org.eclipse.ui.tests.harness/src/org/eclipse/ui/tests/harness/util/RCPTestWorkbenchAdvisor.java

@@ -44,6 +44,9 @@ public class RCPTestWorkbenchAdvisor extends WorkbenchAdvisor {
 
 	private static boolean started = false;
 
+	// Use a CountDownLatch to ensure async operations complete before postStartup
+	private static java.util.concurrent.CountDownLatch asyncLatch = null;
+
 	public static boolean isSTARTED() {
 		synchronized (RCPTestWorkbenchAdvisor.class) {
 			return started;
@@ -122,6 +125,10 @@ public void eventLoopIdle(final Display display) {
 	public void preStartup() {
 		super.preStartup();
 		final Display display = Display.getCurrent();
+
+		// Initialize a latch to track completion of the 4 async/sync operations
+		asyncLatch = new java.util.concurrent.CountDownLatch(4);
+
 		if (display != null) {
 			display.asyncExec(() -> {
 				if (isSTARTED())
@@ -169,6 +176,11 @@ public void run() {
 					// this can happen because we shut down the workbench just
 					// as soon as we're initialized - ie: when we're trying to
 					// run this runnable in the deferred case.
+				} finally {
+					// Signal that this operation has completed
+					if (asyncLatch != null) {
+						asyncLatch.countDown();
+					}
 				}
 			}
 		};
@@ -183,11 +195,18 @@ public void run() {
 				if (callDisplayAccess)
 					DisplayAccess.accessDisplayDuringStartup();
 				display.asyncExec(() -> {
-					synchronized (RCPTestWorkbenchAdvisor.class) {
-						if (callDisplayAccess)
-							asyncWithDisplayAccess = !isSTARTED() ? Boolean.TRUE : Boolean.FALSE;
-						else
-							asyncWithoutDisplayAccess = !isSTARTED() ? Boolean.TRUE : Boolean.FALSE;
+					try {
+						synchronized (RCPTestWorkbenchAdvisor.class) {
+							if (callDisplayAccess)
+								asyncWithDisplayAccess = !isSTARTED() ? Boolean.TRUE : Boolean.FALSE;
+							else
+								asyncWithoutDisplayAccess = !isSTARTED() ? Boolean.TRUE : Boolean.FALSE;
+						}
+					} finally {
+						// Signal that this operation has completed
+						if (asyncLatch != null) {
+							asyncLatch.countDown();
+						}
 					}
 				});
 			}
@@ -199,6 +218,22 @@ public void run() {
 	@Override
 	public void postStartup() {
 		super.postStartup();
+
+		// Wait for all async/sync operations to complete before marking as started
+		// This prevents a race condition where asyncWithDisplayAccess might not be set yet
+		if (asyncLatch != null) {
+			try {
+				// Wait up to 5 seconds for all operations to complete
+				boolean completed = asyncLatch.await(5, java.util.concurrent.TimeUnit.SECONDS);
+				if (!completed) {
+					System.err.println("Warning: Not all async/sync operations completed within timeout");
+				}
+			} catch (InterruptedException e) {
+				Thread.currentThread().interrupt();
+				System.err.println("Warning: Interrupted while waiting for async/sync operations");
+			}
+		}
+
 		synchronized (RCPTestWorkbenchAdvisor.class) {
 			started = true;
 		}