1:57 a.m.
Author: dgolovin
Date: 2008-01-08 19:57:00 -0500 (Tue, 08 Jan 2008)
New Revision: 5532
Added:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayHelper.java
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayWaiter.java
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/EditorTestHelper.java
Log:
Test Utils to be able Join to background tasks and delay in UI threads. Classes were taken
from org.eclipse.ui.tests.navigator plugin on
:pserver:anonymous@dev.eclipse.org:/cvsroot/eclipse/org.eclipse.ui.tests.navigator
Added:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayHelper.java
===================================================================
---
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayHelper.java
(rev 0)
+++
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayHelper.java 2008-01-09
00:57:00 UTC (rev 5532)
@@ -0,0 +1,222 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.jboss.tools.test.util.xpl;
+
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * Runs the event loop of the given display until {@link #condition()} becomes
+ * <code>true</code> or no events have occurred for the supplied timeout.
+ * Between running the event loop, {@link Display#sleep()} is called.
+ * <p>
+ * There is a caveat: the given timeouts must be long enough that the calling
+ * thread can enter <code>Display.sleep()</code> before the timeout elapses,
+ * otherwise, the waiter may time out before <code>sleep</code> is called
and
+ * the sleeping thread may never be waken up.
+ * </p>
+ *
+ * @since 3.1
+ */
+public abstract class DisplayHelper {
+ /**
+ * Creates a new instance.
+ */
+ protected DisplayHelper() {
+ }
+
+ /**
+ * Until {@link #condition()} becomes <code>true</code> or the timeout
+ * elapses, call {@link Display#sleep()} and run the event loop.
+ * <p>
+ * If <code>timeout < 0</code>, the event loop is never driven and
+ * only the condition is checked. If <code>timeout == 0</code>, the event
+ * loop is driven at most once, but <code>Display.sleep()</code> is never
+ * invoked.
+ * </p>
+ *
+ * @param display the display to run the event loop of
+ * @param timeout the timeout in milliseconds
+ * @return <code>true</code> if the condition became
<code>true</code>,
+ * <code>false</code> if the timeout elapsed
+ */
+ public final boolean waitForCondition(Display display, long timeout) {
+ // if the condition already holds, succeed
+ if (condition())
+ return true;
+
+ if (timeout < 0)
+ return false;
+
+ // if driving the event loop once makes the condition hold, succeed
+ // without spawning a thread.
+ driveEventQueue(display);
+ if (condition())
+ return true;
+
+ // if the timeout is negative or zero, fail
+ if (timeout == 0)
+ return false;
+
+ // repeatedly sleep until condition becomes true or timeout elapses
+ DisplayWaiter waiter= new DisplayWaiter(display);
+ DisplayWaiter.Timeout timeoutState= waiter.start(timeout);
+ boolean condition;
+ try {
+ do {
+ if (display.sleep())
+ driveEventQueue(display);
+ condition= condition();
+ } while (!condition && !timeoutState.hasTimedOut());
+ } finally {
+ waiter.stop();
+ }
+ return condition;
+ }
+
+ /**
+ * Call {@link Display#sleep()} and run the event loop until the given
+ * timeout has elapsed.
+ * <p>
+ * If <code>timeout < 0</code>, nothing happens. If
+ * <code>timeout == 0</code>, the event loop is driven exactly once, but
+ * <code>Display.sleep()</code> is never invoked.
+ * </p>
+ *
+ * @param display the display to run the event loop of
+ * @param millis the timeout in milliseconds
+ */
+ public static void sleep(Display display, long millis) {
+ new DisplayHelper() {
+ public boolean condition() {
+ return false;
+ }
+ }.waitForCondition(display, millis);
+ }
+
+ /**
+ * Call {@link Display#sleep()} and run the event loop once if
+ * <code>sleep</code> returns before the timeout elapses. Returns
+ * <code>true</code> if any events were processed,
<code>false</code> if
+ * not.
+ * <p>
+ * If <code>timeout < 0</code>, nothing happens and false is
returned.
+ * If <code>timeout == 0</code>, the event loop is driven exactly once,
+ * but <code>Display.sleep()</code> is never invoked.
+ * </p>
+ *
+ * @param display the display to run the event loop of
+ * @param timeout the timeout in milliseconds
+ * @return <code>true</code> if any event was taken off the event queue,
+ * <code>false</code> if not
+ */
+ public static boolean runEventLoop(Display display, long timeout) {
+ if (timeout < 0)
+ return false;
+
+ if (timeout == 0)
+ return driveEventQueue(display);
+
+ // repeatedly sleep until condition becomes true or timeout elapses
+ DisplayWaiter waiter= new DisplayWaiter(display);
+ DisplayWaiter.Timeout timeoutState= waiter.start(timeout);
+ boolean events= false;
+ if (display.sleep() && !timeoutState.hasTimedOut()) {
+ driveEventQueue(display);
+ events= true;
+ }
+ waiter.stop();
+ return events;
+ }
+
+ /**
+ * The condition which has to be met in order for
+ * {@link #waitForCondition(Display, int)} to return before the timeout
+ * elapses.
+ *
+ * @return <code>true</code> if the condition is met,
<code>false</code>
+ * if the event loop should be driven some more
+ */
+ protected abstract boolean condition();
+
+ /**
+ * Runs the event loop on the given display.
+ *
+ * @param display the display
+ * @return if <code>display.readAndDispatch</code> returned
+ * <code>true</code> at least once
+ */
+ private static boolean driveEventQueue(Display display) {
+ boolean events= false;
+ while (display.readAndDispatch()) {
+ events= true;
+ }
+ return events;
+ }
+
+ /**
+ * Until {@link #condition()} becomes <code>true</code> or the timeout
+ * elapses, call {@link Display#sleep()} and run the event loop.
+ * <p>
+ * If <code>timeout < 0</code>, the event loop is never driven and
+ * only the condition is checked. If <code>timeout == 0</code>, the event
+ * loop is driven at most once, but <code>Display.sleep()</code> is never
+ * invoked.
+ * </p>
+ * <p>
+ * The condition gets rechecked every <code>interval</code> milliseconds,
even
+ * if no events were read from the queue.
+ * </p>
+ *
+ * @param display the display to run the event loop of
+ * @param timeout the timeout in milliseconds
+ * @param interval the interval to re-check the condition in milliseconds
+ * @return <code>true</code> if the condition became
<code>true</code>,
+ * <code>false</code> if the timeout elapsed
+ */
+ public final boolean waitForCondition(Display display, long timeout, long interval) {
+ // if the condition already holds, succeed
+ if (condition())
+ return true;
+
+ if (timeout < 0)
+ return false;
+
+ // if driving the event loop once makes the condition hold, succeed
+ // without spawning a thread.
+ driveEventQueue(display);
+ if (condition())
+ return true;
+
+ // if the timeout is negative or zero, fail
+ if (timeout == 0)
+ return false;
+
+ // repeatedly sleep until condition becomes true or timeout elapses
+ DisplayWaiter waiter= new DisplayWaiter(display, true);
+ long currentTimeMillis= System.currentTimeMillis();
+ long finalTimeout= timeout + currentTimeMillis;
+ if (finalTimeout < currentTimeMillis)
+ finalTimeout= Long.MAX_VALUE;
+ boolean condition;
+ try {
+ do {
+ waiter.restart(interval);
+ if (display.sleep())
+ driveEventQueue(display);
+ condition= condition();
+ } while (!condition && finalTimeout > System.currentTimeMillis());
+ } finally {
+ waiter.stop();
+ }
+ return condition;
+ }
+
+}
\ No newline at end of file
Property changes on:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayHelper.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayWaiter.java
===================================================================
---
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayWaiter.java
(rev 0)
+++
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayWaiter.java 2008-01-09
00:57:00 UTC (rev 5532)
@@ -0,0 +1,410 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.jboss.tools.test.util.xpl;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import junit.framework.Assert;
+
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * Implements the thread that will wait for the timeout and wake up the display
+ * so it does not wait forever. The thread may be restarted after it was stopped
+ * or timed out.
+ *
+ * @since 3.1
+ */
+final class DisplayWaiter {
+ /**
+ * Timeout state of a display waiter thread.
+ */
+ public final class Timeout {
+ boolean fTimeoutState= false;
+ /**
+ * Returns <code>true</code> if the timeout has been reached,
+ * <code>false</code> if not.
+ *
+ * @return <code>true</code> if the timeout has been reached,
+ * <code>false</code> if not
+ */
+ public boolean hasTimedOut() {
+ synchronized (fMutex) {
+ return fTimeoutState;
+ }
+ }
+ void setTimedOut(boolean timedOut) {
+ fTimeoutState= timedOut;
+ }
+ Timeout(boolean initialState) {
+ fTimeoutState= initialState;
+ }
+ }
+
+ // configuration
+ private final Display fDisplay;
+ private final Object fMutex= new Object();
+ private final boolean fKeepRunningOnTimeout;
+
+ /* State -- possible transitions:
+ *
+ * STOPPED -> RUNNING
+ * RUNNING -> STOPPED
+ * RUNNING -> IDLE
+ * IDLE -> RUNNING
+ * IDLE -> STOPPED
+ */
+ private static final int RUNNING= 1 << 1;
+ private static final int STOPPED= 1 << 2;
+ private static final int IDLE= 1 << 3;
+
+ /** The current state. */
+ private int fState;
+ /** The time in milliseconds (see Date) that the timeout will occur. */
+ private long fNextTimeout;
+ /** The thread. */
+ private Thread fCurrentThread;
+ /** The timeout state of the current thread. */
+ private Timeout fCurrentTimeoutState;
+
+ /**
+ * Creates a new instance on the given display and timeout.
+ *
+ * @param display the display to run the event loop of
+ */
+ public DisplayWaiter(Display display) {
+ this(display, false);
+ }
+
+ /**
+ * Creates a new instance on the given display and timeout.
+ *
+ * @param display the display to run the event loop of
+ * @param keepRunning <code>true</code> if the thread should be kept
+ * running after timing out
+ */
+ public DisplayWaiter(Display display, boolean keepRunning) {
+ Assert.assertNotNull(display);
+ fDisplay= display;
+ fState= STOPPED;
+ fKeepRunningOnTimeout= keepRunning;
+ }
+
+ /**
+ * Starts the timeout thread if it is not currently running. Nothing happens
+ * if a thread is already running.
+ *
+ * @param delay the delay from now in milliseconds
+ * @return the timeout state which can be queried for its timed out status
+ */
+ public Timeout start(long delay) {
+ Assert.assertTrue(delay > 0);
+ synchronized (fMutex) {
+ switch (fState) {
+ case STOPPED:
+ startThread();
+ setNextTimeout(delay);
+ break;
+ case IDLE:
+ unhold();
+ setNextTimeout(delay);
+ break;
+ }
+
+ return fCurrentTimeoutState;
+ }
+ }
+
+ /**
+ * Sets the next timeout to <em>current time</em> plus
<code>delay</code>.
+ *
+ * @param delay the delay until the next timeout occurs in milliseconds from
+ * now
+ */
+ private void setNextTimeout(long delay) {
+ long currentTimeMillis= System.currentTimeMillis();
+ long next= currentTimeMillis + delay;
+ if (next > currentTimeMillis)
+ fNextTimeout= next;
+ else
+ fNextTimeout= Long.MAX_VALUE;
+ }
+
+ /**
+ * Starts the thread if it is not currently running; resets the timeout if
+ * it is.
+ *
+ * @param delay the delay from now in milliseconds
+ * @return the timeout state which can be queried for its timed out status
+ */
+ public Timeout restart(long delay) {
+ Assert.assertTrue(delay > 0);
+ synchronized (fMutex) {
+ switch (fState) {
+ case STOPPED:
+ startThread();
+ break;
+ case IDLE:
+ unhold();
+ break;
+ }
+ setNextTimeout(delay);
+
+ return fCurrentTimeoutState;
+ }
+ }
+
+ /**
+ * Stops the thread if it is running. If not, nothing happens. Another
+ * thread may be started by calling {@link #start(long)} or
+ * {@link #restart(long)}.
+ */
+ public void stop() {
+ synchronized (fMutex) {
+ if (tryTransition(RUNNING | IDLE, STOPPED))
+ fMutex.notifyAll();
+ }
+ }
+
+ /**
+ * Puts the reaper thread on hold but does not stop it. It may be restarted
+ * by calling {@link #start(long)} or {@link #restart(long)}.
+ */
+ public void hold() {
+ synchronized (fMutex) {
+ // nothing to do if there is no thread
+ if (tryTransition(RUNNING, IDLE))
+ fMutex.notifyAll();
+ }
+ }
+
+ /**
+ * Transition to <code>RUNNING</code> and clear the timed out flag. Assume
+ * current state is <code>IDLE</code>.
+ */
+ private void unhold() {
+ checkedTransition(IDLE, RUNNING);
+ fCurrentTimeoutState= new Timeout(false);
+ fMutex.notifyAll();
+ }
+
+ /**
+ * Start the thread. Assume the current state is <code>STOPPED</code>.
+ */
+ private void startThread() {
+ checkedTransition(STOPPED, RUNNING);
+ fCurrentTimeoutState= new Timeout(false);
+ fCurrentThread= new Thread() {
+ /**
+ * Exception thrown when a thread notices that it has been stopped
+ * and a new thread has been started.
+ */
+ final class ThreadChangedException extends Exception {
+ private static final long serialVersionUID= 1L;
+ }
+
+ /*
+ * @see java.lang.Runnable#run()
+ */
+ public void run() {
+ try {
+ run2();
+ } catch (InterruptedException e) {
+ // ignore and end the thread - we never interrupt ourselves,
+ // so it must be an external entity that interrupted us
+ Logger.global.log(Level.FINE, "", e); //$NON-NLS-1$
+ } catch (ThreadChangedException e) {
+ // the thread was stopped and restarted before we got out
+ // of a wait - we're no longer used
+ // we might have been notified instead of the current thread,
+ // so wake it up
+ Logger.global.log(Level.FINE, "", e); //$NON-NLS-1$
+ synchronized (fMutex) {
+ fMutex.notifyAll();
+ }
+ }
+ }
+
+ /**
+ * Runs the thread.
+ *
+ * @throws InterruptedException if the thread was interrupted
+ * @throws ThreadChangedException if the thread changed
+ */
+ private void run2() throws InterruptedException, ThreadChangedException {
+ synchronized (fMutex) {
+ checkThread();
+ tryHold(); // wait / potential state change
+ assertStates(STOPPED | RUNNING);
+
+ while (isState(RUNNING)) {
+ waitForTimeout(); // wait / potential state change
+
+ if (isState(RUNNING))
+ timedOut(); // state change
+ assertStates(STOPPED | IDLE);
+
+ tryHold(); // wait / potential state change
+ assertStates(STOPPED | RUNNING);
+ }
+ assertStates(STOPPED);
+ }
+ }
+
+ /**
+ * Check whether the current thread is this thread, throw an
+ * exception otherwise.
+ *
+ * @throws ThreadChangedException if the current thread changed
+ */
+ private void checkThread() throws ThreadChangedException {
+ if (fCurrentThread != this)
+ throw new ThreadChangedException();
+ }
+
+ /**
+ * Waits until the next timeout occurs.
+ *
+ * @throws InterruptedException if the thread was interrupted
+ * @throws ThreadChangedException if the thread changed
+ */
+ private void waitForTimeout() throws InterruptedException, ThreadChangedException {
+ long delta;
+ while (isState(RUNNING) && (delta = fNextTimeout -
System.currentTimeMillis()) > 0) {
+ delta= Math.max(delta, 50); // wait at least 50ms in order to avoid timing out
before the display is going to sleep
+ Logger.global.finest("sleeping for " + delta + "ms");
//$NON-NLS-1$ //$NON-NLS-2$
+ fMutex.wait(delta);
+ checkThread();
+ }
+ }
+
+ /**
+ * Sets the timed out flag and wakes up the display. Transitions to
+ * <code>IDLE</code> (if in keep-running mode) or
+ * <code>STOPPED</code>.
+ */
+ private void timedOut() {
+ Logger.global.finer("timed out"); //$NON-NLS-1$
+ fCurrentTimeoutState.setTimedOut(true);
+ fDisplay.wake(); // wake up call!
+ if (fKeepRunningOnTimeout)
+ checkedTransition(RUNNING, IDLE);
+ else
+ checkedTransition(RUNNING, STOPPED);
+ }
+
+ /**
+ * Waits while the state is <code>IDLE</code>, then returns. The
+ * state must not be <code>RUNNING</code> when calling this
+ * method. The state is either <code>STOPPED</code> or
+ * <code>RUNNING</code> when the method returns.
+ *
+ * @throws InterruptedException if the thread was interrupted
+ * @throws ThreadChangedException if the thread has changed while on
+ * hold
+ */
+ private void tryHold() throws InterruptedException, ThreadChangedException {
+ while (isState(IDLE)) {
+ fMutex.wait(0);
+ checkThread();
+ }
+ assertStates(STOPPED | RUNNING);
+ }
+ };
+
+ fCurrentThread.start();
+ }
+
+ /**
+ * Transitions to <code>nextState</code> if the current state is one of
+ * <code>possibleStates</code>. Returns <code>true</code> if
the
+ * transition happened, <code>false</code> otherwise.
+ *
+ * @param possibleStates the states which trigger a transition
+ * @param nextState the state to transition to
+ * @return <code>true</code> if the transition happened,
+ * <code>false</code> otherwise
+ */
+ private boolean tryTransition(int possibleStates, int nextState) {
+ if (isState(possibleStates)) {
+ Logger.global.finer(name(fState) + " > " + name(nextState) + "
(" + name(possibleStates) + ")"); //$NON-NLS-1$ //$NON-NLS-2$
//$NON-NLS-3$
+ fState= nextState;
+ return true;
+ }
+ Logger.global.finest("noTransition" + name(fState) + " !> " +
name(nextState) + " (" + name(possibleStates) + ")"); //$NON-NLS-1$
//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ return false;
+ }
+
+ /**
+ * Checks the <code>possibleStates</code> and throws an assertion if it is
+ * not met, then transitions to <code>nextState</code>.
+ *
+ * @param possibleStates the allowed states
+ * @param nextState the state to transition to
+ */
+ private void checkedTransition(int possibleStates, int nextState) {
+ assertStates(possibleStates);
+ Logger.global.finer(name(fState) + " > " + name(nextState));
//$NON-NLS-1$
+ fState= nextState;
+ }
+
+ /**
+ * Implements state consistency checking.
+ *
+ * @param states the allowed states
+ * @throws junit.framework.AssertionFailedError if the current state is not
+ * in <code>states</code>
+ */
+ private void assertStates(int states) {
+ Assert.assertTrue("illegal state", isState(states)); //$NON-NLS-1$
+ }
+
+ /**
+ * Answers <code>true</code> if the current state is in the given
+ * <code>states</code>.
+ *
+ * @param states the possible states
+ * @return <code>true</code> if the current state is in the given states,
+ * <code>false</code> otherwise
+ */
+ private boolean isState(int states) {
+ return (states & fState) == fState;
+ }
+
+ /**
+ * Pretty print the given states.
+ *
+ * @param states the states
+ * @return a string representation of the states
+ */
+ private String name(int states) {
+ StringBuffer buf= new StringBuffer();
+ boolean comma= false;
+ if ((states & RUNNING) == RUNNING) {
+ buf.append("RUNNING"); //$NON-NLS-1$
+ comma= true;
+ }
+ if ((states & STOPPED) == STOPPED) {
+ if (comma)
+ buf.append(","); //$NON-NLS-1$
+ buf.append("STOPPED"); //$NON-NLS-1$
+ comma= true;
+ }
+ if ((states & IDLE) == IDLE) {
+ if (comma)
+ buf.append(","); //$NON-NLS-1$
+ buf.append("IDLE"); //$NON-NLS-1$
+ }
+ return buf.toString();
+ }
+
+}
\ No newline at end of file
Property changes on:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/DisplayWaiter.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/EditorTestHelper.java
===================================================================
---
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/EditorTestHelper.java
(rev 0)
+++
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/EditorTestHelper.java 2008-01-09
00:57:00 UTC (rev 5532)
@@ -0,0 +1,265 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2006 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.jboss.tools.test.util.xpl;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.jobs.IJobManager;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IEditorReference;
+import org.eclipse.ui.IViewReference;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.IWorkbenchPartSite;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.WorkbenchException;
+
+
+/**
+ * @since 3.1
+ */
+public class EditorTestHelper {
+
+
+
+ public static final String TEXT_EDITOR_ID= "org.eclipse.ui.DefaultTextEditor";
//$NON-NLS-1$
+
+ public static final String COMPILATION_UNIT_EDITOR_ID=
"org.eclipse.jdt.ui.CompilationUnitEditor"; //$NON-NLS-1$
+
+ public static final String RESOURCE_PERSPECTIVE_ID=
"org.eclipse.ui.resourcePerspective"; //$NON-NLS-1$
+
+ public static final String JAVA_PERSPECTIVE_ID=
"org.eclipse.jdt.ui.JavaPerspective"; //$NON-NLS-1$
+
+ public static final String OUTLINE_VIEW_ID=
"org.eclipse.ui.views.ContentOutline"; //$NON-NLS-1$
+
+ public static final String PACKAGE_EXPLORER_VIEW_ID=
"org.eclipse.jdt.ui.PackageExplorer"; //$NON-NLS-1$
+
+ public static final String NAVIGATOR_VIEW_ID=
"org.eclipse.ui.views.ResourceNavigator"; //$NON-NLS-1$
+
+ public static final String INTRO_VIEW_ID= "org.eclipse.ui.internal.introview";
//$NON-NLS-1$
+
+ public static void closeEditor(IEditorPart editor) {
+ IWorkbenchPartSite site;
+ IWorkbenchPage page;
+ if (editor != null && (site= editor.getSite()) != null && (page=
site.getPage()) != null)
+ page.closeEditor(editor, false);
+ }
+
+ public static void closeAllEditors() {
+ IWorkbenchWindow[] windows= PlatformUI.getWorkbench().getWorkbenchWindows();
+ for (int i= 0; i < windows.length; i++) {
+ IWorkbenchPage[] pages= windows[i].getPages();
+ for (int j= 0; j < pages.length; j++) {
+ IEditorReference[] editorReferences= pages[j].getEditorReferences();
+ for (int k= 0; k < editorReferences.length; k++)
+ closeEditor(editorReferences[k].getEditor(false));
+ }
+ }
+ }
+
+ /**
+ * Runs the event queue on the current display until it is empty.
+ */
+ public static void runEventQueue() {
+ IWorkbenchWindow window= getActiveWorkbenchWindow();
+ if (window != null)
+ runEventQueue(window.getShell());
+ }
+
+ public static void runEventQueue(IWorkbenchPart part) {
+ runEventQueue(part.getSite().getShell());
+ }
+
+ public static void runEventQueue(Shell shell) {
+ runEventQueue(shell.getDisplay());
+ }
+
+ public static void runEventQueue(Display display) {
+ while (display.readAndDispatch()) {
+ // do nothing
+ }
+ }
+
+ /**
+ * Runs the event queue on the current display and lets it sleep until the
+ * timeout elapses.
+ *
+ * @param millis the timeout in milliseconds
+ */
+ public static void runEventQueue(long millis) {
+ runEventQueue(getActiveDisplay(), millis);
+ }
+
+ public static void runEventQueue(IWorkbenchPart part, long millis) {
+ runEventQueue(part.getSite().getShell(), millis);
+ }
+
+ public static void runEventQueue(Shell shell, long millis) {
+ runEventQueue(shell.getDisplay(), millis);
+ }
+
+ public static void runEventQueue(Display display, long minTime) {
+ if (display != null) {
+ DisplayHelper.sleep(display, minTime);
+ } else {
+ sleep((int) minTime);
+ }
+ }
+
+ public static IWorkbenchWindow getActiveWorkbenchWindow() {
+ return PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+ }
+
+ public static void forceFocus() {
+ IWorkbenchWindow window= getActiveWorkbenchWindow();
+ if (window == null) {
+ IWorkbenchWindow[] wbWindows= PlatformUI.getWorkbench().getWorkbenchWindows();
+ if (wbWindows.length == 0)
+ return;
+ window= wbWindows[0];
+ }
+ Shell shell= window.getShell();
+ if (shell != null && !shell.isDisposed()) {
+ shell.forceActive();
+ shell.forceFocus();
+ }
+ }
+
+ public static IWorkbenchPage getActivePage() {
+ IWorkbenchWindow window= getActiveWorkbenchWindow();
+ return window != null ? window.getActivePage() : null;
+ }
+
+ public static Display getActiveDisplay() {
+ IWorkbenchWindow window= getActiveWorkbenchWindow();
+ return window != null ? window.getShell().getDisplay() : null;
+ }
+
+ public static void joinBackgroundActivities() throws CoreException {
+ // Join Building
+ Logger.global.entering("EditorTestHelper",
"joinBackgroundActivities"); //$NON-NLS-1$ //$NON-NLS-2$
+ Logger.global.finer("join builder"); //$NON-NLS-1$
+ boolean interrupted= true;
+ while (interrupted) {
+ try {
+ Platform.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null);
+ interrupted= false;
+ } catch (InterruptedException e) {
+ interrupted= true;
+ }
+ }
+ // Join jobs
+ joinJobs(0, 0, 500);
+ Logger.global.exiting("EditorTestHelper",
"joinBackgroundActivities"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ public static boolean joinJobs(long minTime, long maxTime, long intervalTime) {
+ Logger.global.entering("EditorTestHelper", "joinJobs");
//$NON-NLS-1$ //$NON-NLS-2$
+ runEventQueue(minTime);
+
+ DisplayHelper helper= new DisplayHelper() {
+ public boolean condition() {
+ return allJobsQuiet();
+ }
+ };
+ boolean quiet= helper.waitForCondition(getActiveDisplay(), maxTime > 0 ? maxTime :
Long.MAX_VALUE, intervalTime);
+ Logger.global.exiting("EditorTestHelper", "joinJobs", new
Boolean(quiet)); //$NON-NLS-1$ //$NON-NLS-2$
+ return quiet;
+ }
+
+ public static void sleep(int intervalTime) {
+ try {
+ Thread.sleep(intervalTime);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static boolean allJobsQuiet() {
+ IJobManager jobManager= Platform.getJobManager();
+ Job[] jobs= jobManager.find(null);
+ for (int i= 0; i < jobs.length; i++) {
+ Job job= jobs[i];
+ int state= job.getState();
+ if (state == Job.RUNNING || state == Job.WAITING) {
+ Logger.global.finest(job.getName());
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static boolean isViewShown(String viewId) {
+ return getActivePage().findViewReference(viewId) != null;
+ }
+
+ public static boolean showView(String viewId, boolean show) throws PartInitException {
+ IWorkbenchPage activePage= getActivePage();
+ IViewReference view= activePage.findViewReference(viewId);
+ boolean shown= view != null;
+ if (shown != show)
+ if (show)
+ activePage.showView(viewId);
+ else
+ activePage.hideView(view);
+ return shown;
+ }
+
+ public static void bringToTop() {
+ getActiveWorkbenchWindow().getShell().forceActive();
+ }
+
+ public static String showPerspective(String perspective) throws WorkbenchException {
+ String shownPerspective= getActivePage().getPerspective().getId();
+ if (!perspective.equals(shownPerspective)) {
+ IWorkbench workbench= PlatformUI.getWorkbench();
+ IWorkbenchWindow activeWindow= workbench.getActiveWorkbenchWindow();
+ workbench.showPerspective(perspective, activeWindow);
+ }
+ return shownPerspective;
+ }
+
+
+
+ public static IFile[] findFiles(IResource resource) throws CoreException {
+ List files= new ArrayList();
+ findFiles(resource, files);
+ return (IFile[]) files.toArray(new IFile[files.size()]);
+ }
+
+ private static void findFiles(IResource resource, List files) throws CoreException {
+ if (resource instanceof IFile) {
+ files.add(resource);
+ return;
+ }
+ if (resource instanceof IContainer) {
+ IResource[] resources= ((IContainer) resource).members();
+ for (int i= 0; i < resources.length; i++)
+ findFiles(resources[i], files);
+ }
+ }
+
+}
Property changes on:
trunk/tests/tests/org.jboss.tools.test/src/org/jboss/tools/test/util/xpl/EditorTestHelper.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain