org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/performance/ScrollEditorTest.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * 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.eclipse.jdt.text.tests.performance;

 import org.eclipse.test.performance.Dimension;
 import org.eclipse.test.performance.Performance;
 import org.eclipse.test.performance.PerformanceMeter;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyledText;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;

 import org.eclipse.ui.texteditor.AbstractTextEditor;

 import org.eclipse.jdt.text.tests.performance.DisplayWaiter.Timeout;

 public abstract class ScrollEditorTest extends TextPerformanceTestCase {

 	private static final int WARM_UP_RUNS= 3;

 	private static final int MEASURED_RUNS= 3;

 	private static final String PAGE_SCROLLING_FILE= PerformanceTestSetup.STYLED_TEXT;

 	private static final String LINE_SCROLLING_FILE= PerformanceTestSetup.TEXT_LAYOUT;

 	private static final int[] CTRL_HOME= new int[] { SWT.CTRL, SWT.HOME };
 	private static final int[] CTRL_DOWN= new int[] { SWT.CTRL, SWT.ARROW_DOWN };
 	private static final int[] PG_DOWN= new int[] { SWT.PAGE_DOWN };
 	private static final int[] SHIFT_PG_DOWN= new int[] { SWT.SHIFT, SWT.PAGE_DOWN };
 	private static final int[] DOWN= new int[] { SWT.ARROW_DOWN };
 	private static final int[] SHIFT_DOWN= new int[] { SWT.SHIFT, SWT.ARROW_DOWN };
 	private static final int[] PG_UP= new int[] { SWT.PAGE_UP };

 	protected abstract static class ScrollingMode {
 		public ScrollingMode(int[] scroll_combo, int[] home_combo) {
 			super();
 			SCROLL_COMBO= scroll_combo;
 			HOME_COMBO= home_combo;
 		}
 		public final int[] SCROLL_COMBO;
 		public final int[] HOME_COMBO;
 		public abstract int computeOperations(int numberOfLines, int visibleLines);
 		public abstract String getFile();
 		public boolean isPressAndHoldCombo() {
 			return false;
 		}
 	}

 	protected static final ScrollingMode PAGE_WISE= new ScrollingMode(PG_DOWN, CTRL_HOME) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines / visibleLines;
 		}
 		public String getFile() {
 			return PAGE_SCROLLING_FILE;
 		}
 	};
 	protected static final ScrollingMode PAGE_WISE_SELECT= new ScrollingMode(SHIFT_PG_DOWN, CTRL_HOME) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines / visibleLines;
 		}
 		public String getFile() {
 			return PAGE_SCROLLING_FILE;
 		}
 	};
 	protected static final ScrollingMode LINE_WISE_NO_CARET_MOVE= new ScrollingMode(CTRL_DOWN, PG_UP) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines - visibleLines;
 		}
 		public String getFile() {
 			return LINE_SCROLLING_FILE;
 		}
 	};
 	protected static final ScrollingMode LINE_WISE_NO_CARET_MOVE_HOLD_KEYS= new ScrollingMode(CTRL_DOWN, PG_UP) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines - visibleLines;
 		}
 		public String getFile() {
 			return LINE_SCROLLING_FILE;
 		}
 		public boolean isPressAndHoldCombo() {
 			return true;
 		}
 	};
 	protected static final ScrollingMode LINE_WISE= new ScrollingMode(DOWN, CTRL_HOME) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines - 1;
 		}
 		public String getFile() {
 			return LINE_SCROLLING_FILE;
 		}
 	};
 	protected static final ScrollingMode LINE_WISE_SELECT= new ScrollingMode(SHIFT_DOWN, CTRL_HOME) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines - 1;
 		}
 		public String getFile() {
 			return LINE_SCROLLING_FILE;
 		}
 	};
 	protected static final ScrollingMode LINE_WISE_SELECT_HOLD_KEYS= new ScrollingMode(SHIFT_DOWN, CTRL_HOME) {
 		public int computeOperations(int numberOfLines, int visibleLines) {
 			return numberOfLines - 1;
 		}
 		public String getFile() {
 			return LINE_SCROLLING_FILE;
 		}
 		public boolean isPressAndHoldCombo() {
 			return true;
 		}
 	};

 	protected void setUp() throws Exception {
 		super.setUp();
 		EditorTestHelper.bringToTop();
 		setWarmUpRuns(WARM_UP_RUNS);
 		setMeasuredRuns(MEASURED_RUNS);
 	}

 	protected void tearDown() throws Exception {
 		// wait a little and consume any incoming events
 		DisplayHelper.sleep(Display.getCurrent(),8000);
 		super.tearDown();
 	}

 	protected void setUp(AbstractTextEditor editor) throws Exception { }

 	protected void measure(ScrollingMode mode) throws Exception {
 		measure(mode, createPerformanceMeter(), getWarmUpRuns(), getMeasuredRuns());
 	}

 	protected void measure(ScrollingMode mode, PerformanceMeter performanceMeter, int warmUpRuns, int measuredRuns) throws Exception {
 		AbstractTextEditor editor= null;
 		try {
 			editor= (AbstractTextEditor) EditorTestHelper.openInEditor(ResourceTestHelper.findFile(mode.getFile()), getEditor(), true);
 			setUp(editor);
 			StyledText text= (StyledText) editor.getAdapter(Control.class);
 			EditorTestHelper.joinBackgroundActivities(editor);
 			if (mode.isPressAndHoldCombo()) {
 				measureHolding(text, mode, getNullPerformanceMeter(), warmUpRuns);
 				measureHolding(text, mode, performanceMeter, measuredRuns);
 			} else {
 				measure(text, mode, getNullPerformanceMeter(), warmUpRuns);
 				measure(text, mode, performanceMeter, measuredRuns);
 			}
 			commitAllMeasurements();
 			if (mode.isPressAndHoldCombo()) {
 				// press&hold measurements depend on the system's typematic rate setting
 				// therefore, elapsed process (wall-clock) is not a good measurement -
 				// use CPU_TIME instead
 				Performance.getDefault().assertPerformanceInRelativeBand(performanceMeter, Dimension.CPU_TIME, -100, 110);
 			} else {
 				assertAllPerformance();
 			}
 		} finally {
 			EditorTestHelper.closeAllEditors();
 		}
 	}

 	protected abstract String getEditor();

 	private void measure(final StyledText text, ScrollingMode mode, PerformanceMeter performanceMeter, int runs) {
 		Display display= EditorTestHelper.getActiveDisplay();
 		final int numberOfLines= text.getLineCount();
 		final int visibleLinesInViewport= text.getClientArea().height / text.getLineHeight();
 		int operations= mode.computeOperations(numberOfLines, visibleLinesInViewport);

 		DisplayWaiter waiter= new DisplayWaiter(display, true);
 		try {
 			for (int i= 0; i < runs; i++) {
 				// 0: assert that we are at the top and the selection at 0
 				assertTrue("editor must be scrolled to the top before starting", text.getTopIndex() == 0);
 				assertTrue("selection must be at (0,0) before starting", text.getSelection().x == 0 && text.getSelection().y == 0);

 				// 1: post scroll events
 				long delay= 3000;
 				Timeout timeout= waiter.restart(delay);
 				performanceMeter.start();
 				for (int j= 0; j < operations && !timeout.hasTimedOut(); j++) {
 					// avoid overhead: assertTrue(text.getTopIndex() + visibleLinesInViewport < numberOfLines - 1);
 					SWTEventHelper.pressKeyCodeCombination(display, mode.SCROLL_COMBO, false);
 					sleepAndRun(display);
 					// average for select & scroll is 30ms/line
 					// - give it ten time as much to allow for GCs (300ms),
 					// check back every 10 lines == never wait longer than 3s.
 					if (j % 10 == 9)
 						timeout= waiter.restart(delay);
 				}
 				performanceMeter.stop();
 				waiter.hold();
 				assertFalse("Failed to receive event within " + delay + "ms.", timeout.hasTimedOut());

 				// 2: wait until the events have been swallowed
 				timeout= waiter.restart(2000);
 				while (!timeout.hasTimedOut() && text.getTopIndex() + visibleLinesInViewport < numberOfLines - 1) {
 					sleepAndRun(display);
 				}
 				waiter.hold();
 				assertFalse("Never scrolled to the bottom within 2000ms.\nTopIndex: " + text.getTopIndex() + " visibleLines: " + visibleLinesInViewport + " totalLines: " + numberOfLines + " operations: " + operations, timeout.hasTimedOut());

 				// 3: go back home
 				timeout= waiter.restart(2000);
 				SWTEventHelper.pressKeyCodeCombination(display, mode.HOME_COMBO, false);
 				while (!timeout.hasTimedOut() && text.getTopIndex() != 0) {
 					sleepAndRun(display);
 				}
 				waiter.hold();
 				assertFalse("Never went back to the top within 2000ms.", timeout.hasTimedOut());

 				waiter.hold();
 			}
 		} finally {
 			waiter.stop();
 		}
 	}

 	private void measureHolding(final StyledText text, ScrollingMode mode, PerformanceMeter performanceMeter, int runs) {
 		Display display= EditorTestHelper.getActiveDisplay();
 		final int numberOfLines= text.getLineCount();
 		final int visibleLinesInViewport= text.getClientArea().height / text.getLineHeight();

 		DisplayWaiter waiter= new DisplayWaiter(display, true);
 		try {
 			for (int i= 0; i < runs; i++) {
 				// 0: assert that we are at the top and the selection at 0
 				assertTrue("editor must be scrolled to the top before starting", text.getTopIndex() == 0);
 				assertTrue("selection must be at (0,0) before starting", text.getSelection().x == 0 && text.getSelection().y == 0);

 				// 1: post scroll events
 				long delay= 3000;
 				Timeout timeout= waiter.restart(delay);
 				performanceMeter.start();

 				final int[] keyCodes= mode.SCROLL_COMBO;
 				// press keys
 				for (int j= 0; j < keyCodes.length; j++) {
 					SWTEventHelper.keyCodeDown(display, keyCodes[j], false);
 				}

 				int topIndex= 0;
 				while (!timeout.hasTimedOut()) {
 					sleepAndRun(display);

 					final int currentTopIndex= text.getTopIndex();

 					// we're done when we've scrolled to the bottom
 					if (currentTopIndex >= numberOfLines - 1 - visibleLinesInViewport)
 						break;

 					// if a lot of events were processed in above loop
 					// we might have timed out. This is ok as long as the top
 					// index is moving, i.e. we're not stuck or someone else
 					// is eating our events -> restart the timer if the topindex
 					// was moved.
 					if (currentTopIndex > topIndex + 9) {
 						// average for select & scroll is 30ms/line
 						// - give it ten time as much to allow for GCs (300ms),
 						// check back every 10 lines == never wait longer for a failure than 3s
 						timeout= waiter.restart(delay);
 						topIndex= currentTopIndex;
 					}
 				}
 				waiter.hold();

 				// lift keys in reverse order
 				for (int j= keyCodes.length - 1; j >= 0; j--) {
 					SWTEventHelper.keyCodeUp(display, keyCodes[j], false);
 				}
 				sleepAndRun(display);

 				performanceMeter.stop();
 				assertFalse("Never scrolled to the bottom, last event received " + delay + "ms ago, topIndex: " + text.getTopIndex(), timeout.hasTimedOut());

 				// 2: go back home
 				timeout= waiter.restart(2000);
 				SWTEventHelper.pressKeyCodeCombination(display, mode.HOME_COMBO, false);
 				while (!timeout.hasTimedOut() && text.getTopIndex() != 0) {
 					sleepAndRun(display);
 				}
 				waiter.hold();

 				assertFalse("Never went back to the top within 2000ms.", timeout.hasTimedOut());
 			}
 		} finally {
 			waiter.stop();
 		}
 	}

 	private void sleepAndRun(Display display) {
 		if (display.sleep())
 			EditorTestHelper.runEventQueue(display);
 	}
 }
	/*******************************************************************************
	* 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.eclipse.jdt.text.tests.performance;

	import org.eclipse.test.performance.Dimension;
	import org.eclipse.test.performance.Performance;
	import org.eclipse.test.performance.PerformanceMeter;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.StyledText;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;

	import org.eclipse.ui.texteditor.AbstractTextEditor;

	import org.eclipse.jdt.text.tests.performance.DisplayWaiter.Timeout;

	public abstract class ScrollEditorTest extends TextPerformanceTestCase {

	private static final int WARM_UP_RUNS= 3;

	private static final int MEASURED_RUNS= 3;

	private static final String PAGE_SCROLLING_FILE= PerformanceTestSetup.STYLED_TEXT;

	private static final String LINE_SCROLLING_FILE= PerformanceTestSetup.TEXT_LAYOUT;

	private static final int[] CTRL_HOME= new int[] { SWT.CTRL, SWT.HOME };
	private static final int[] CTRL_DOWN= new int[] { SWT.CTRL, SWT.ARROW_DOWN };
	private static final int[] PG_DOWN= new int[] { SWT.PAGE_DOWN };
	private static final int[] SHIFT_PG_DOWN= new int[] { SWT.SHIFT, SWT.PAGE_DOWN };
	private static final int[] DOWN= new int[] { SWT.ARROW_DOWN };
	private static final int[] SHIFT_DOWN= new int[] { SWT.SHIFT, SWT.ARROW_DOWN };
	private static final int[] PG_UP= new int[] { SWT.PAGE_UP };

	protected abstract static class ScrollingMode {
	public ScrollingMode(int[] scroll_combo, int[] home_combo) {
	super();
	SCROLL_COMBO= scroll_combo;
	HOME_COMBO= home_combo;
	}
	public final int[] SCROLL_COMBO;
	public final int[] HOME_COMBO;
	public abstract int computeOperations(int numberOfLines, int visibleLines);
	public abstract String getFile();
	public boolean isPressAndHoldCombo() {
	return false;
	}
	}

	protected static final ScrollingMode PAGE_WISE= new ScrollingMode(PG_DOWN, CTRL_HOME) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines / visibleLines;
	}
	public String getFile() {
	return PAGE_SCROLLING_FILE;
	}
	};
	protected static final ScrollingMode PAGE_WISE_SELECT= new ScrollingMode(SHIFT_PG_DOWN, CTRL_HOME) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines / visibleLines;
	}
	public String getFile() {
	return PAGE_SCROLLING_FILE;
	}
	};
	protected static final ScrollingMode LINE_WISE_NO_CARET_MOVE= new ScrollingMode(CTRL_DOWN, PG_UP) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines - visibleLines;
	}
	public String getFile() {
	return LINE_SCROLLING_FILE;
	}
	};
	protected static final ScrollingMode LINE_WISE_NO_CARET_MOVE_HOLD_KEYS= new ScrollingMode(CTRL_DOWN, PG_UP) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines - visibleLines;
	}
	public String getFile() {
	return LINE_SCROLLING_FILE;
	}
	public boolean isPressAndHoldCombo() {
	return true;
	}
	};
	protected static final ScrollingMode LINE_WISE= new ScrollingMode(DOWN, CTRL_HOME) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines - 1;
	}
	public String getFile() {
	return LINE_SCROLLING_FILE;
	}
	};
	protected static final ScrollingMode LINE_WISE_SELECT= new ScrollingMode(SHIFT_DOWN, CTRL_HOME) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines - 1;
	}
	public String getFile() {
	return LINE_SCROLLING_FILE;
	}
	};
	protected static final ScrollingMode LINE_WISE_SELECT_HOLD_KEYS= new ScrollingMode(SHIFT_DOWN, CTRL_HOME) {
	public int computeOperations(int numberOfLines, int visibleLines) {
	return numberOfLines - 1;
	}
	public String getFile() {
	return LINE_SCROLLING_FILE;
	}
	public boolean isPressAndHoldCombo() {
	return true;
	}
	};

	protected void setUp() throws Exception {
	super.setUp();
	EditorTestHelper.bringToTop();
	setWarmUpRuns(WARM_UP_RUNS);
	setMeasuredRuns(MEASURED_RUNS);
	}

	protected void tearDown() throws Exception {
	// wait a little and consume any incoming events
	DisplayHelper.sleep(Display.getCurrent(),8000);
	super.tearDown();
	}

	protected void setUp(AbstractTextEditor editor) throws Exception { }

	protected void measure(ScrollingMode mode) throws Exception {
	measure(mode, createPerformanceMeter(), getWarmUpRuns(), getMeasuredRuns());
	}

	protected void measure(ScrollingMode mode, PerformanceMeter performanceMeter, int warmUpRuns, int measuredRuns) throws Exception {
	AbstractTextEditor editor= null;
	try {
	editor= (AbstractTextEditor) EditorTestHelper.openInEditor(ResourceTestHelper.findFile(mode.getFile()), getEditor(), true);
	setUp(editor);
	StyledText text= (StyledText) editor.getAdapter(Control.class);
	EditorTestHelper.joinBackgroundActivities(editor);
	if (mode.isPressAndHoldCombo()) {
	measureHolding(text, mode, getNullPerformanceMeter(), warmUpRuns);
	measureHolding(text, mode, performanceMeter, measuredRuns);
	} else {
	measure(text, mode, getNullPerformanceMeter(), warmUpRuns);
	measure(text, mode, performanceMeter, measuredRuns);
	}
	commitAllMeasurements();
	if (mode.isPressAndHoldCombo()) {
	// press&hold measurements depend on the system's typematic rate setting
	// therefore, elapsed process (wall-clock) is not a good measurement -
	// use CPU_TIME instead
	Performance.getDefault().assertPerformanceInRelativeBand(performanceMeter, Dimension.CPU_TIME, -100, 110);
	} else {
	assertAllPerformance();
	}
	} finally {
	EditorTestHelper.closeAllEditors();
	}
	}

	protected abstract String getEditor();

	private void measure(final StyledText text, ScrollingMode mode, PerformanceMeter performanceMeter, int runs) {
	Display display= EditorTestHelper.getActiveDisplay();
	final int numberOfLines= text.getLineCount();
	final int visibleLinesInViewport= text.getClientArea().height / text.getLineHeight();
	int operations= mode.computeOperations(numberOfLines, visibleLinesInViewport);

	DisplayWaiter waiter= new DisplayWaiter(display, true);
	try {
	for (int i= 0; i < runs; i++) {
	// 0: assert that we are at the top and the selection at 0
	assertTrue("editor must be scrolled to the top before starting", text.getTopIndex() == 0);
	assertTrue("selection must be at (0,0) before starting", text.getSelection().x == 0 && text.getSelection().y == 0);

	// 1: post scroll events
	long delay= 3000;
	Timeout timeout= waiter.restart(delay);
	performanceMeter.start();
	for (int j= 0; j < operations && !timeout.hasTimedOut(); j++) {
	// avoid overhead: assertTrue(text.getTopIndex() + visibleLinesInViewport < numberOfLines - 1);
	SWTEventHelper.pressKeyCodeCombination(display, mode.SCROLL_COMBO, false);
	sleepAndRun(display);
	// average for select & scroll is 30ms/line
	// - give it ten time as much to allow for GCs (300ms),
	// check back every 10 lines == never wait longer than 3s.
	if (j % 10 == 9)
	timeout= waiter.restart(delay);
	}
	performanceMeter.stop();
	waiter.hold();
	assertFalse("Failed to receive event within " + delay + "ms.", timeout.hasTimedOut());

	// 2: wait until the events have been swallowed
	timeout= waiter.restart(2000);
	while (!timeout.hasTimedOut() && text.getTopIndex() + visibleLinesInViewport < numberOfLines - 1) {
	sleepAndRun(display);
	}
	waiter.hold();
	assertFalse("Never scrolled to the bottom within 2000ms.\nTopIndex: " + text.getTopIndex() + " visibleLines: " + visibleLinesInViewport + " totalLines: " + numberOfLines + " operations: " + operations, timeout.hasTimedOut());

	// 3: go back home
	timeout= waiter.restart(2000);
	SWTEventHelper.pressKeyCodeCombination(display, mode.HOME_COMBO, false);
	while (!timeout.hasTimedOut() && text.getTopIndex() != 0) {
	sleepAndRun(display);
	}
	waiter.hold();
	assertFalse("Never went back to the top within 2000ms.", timeout.hasTimedOut());

	waiter.hold();
	}
	} finally {
	waiter.stop();
	}
	}

	private void measureHolding(final StyledText text, ScrollingMode mode, PerformanceMeter performanceMeter, int runs) {
	Display display= EditorTestHelper.getActiveDisplay();
	final int numberOfLines= text.getLineCount();
	final int visibleLinesInViewport= text.getClientArea().height / text.getLineHeight();

	DisplayWaiter waiter= new DisplayWaiter(display, true);
	try {
	for (int i= 0; i < runs; i++) {
	// 0: assert that we are at the top and the selection at 0
	assertTrue("editor must be scrolled to the top before starting", text.getTopIndex() == 0);
	assertTrue("selection must be at (0,0) before starting", text.getSelection().x == 0 && text.getSelection().y == 0);

	// 1: post scroll events
	long delay= 3000;
	Timeout timeout= waiter.restart(delay);
	performanceMeter.start();

	final int[] keyCodes= mode.SCROLL_COMBO;
	// press keys
	for (int j= 0; j < keyCodes.length; j++) {
	SWTEventHelper.keyCodeDown(display, keyCodes[j], false);
	}

	int topIndex= 0;
	while (!timeout.hasTimedOut()) {
	sleepAndRun(display);

	final int currentTopIndex= text.getTopIndex();

	// we're done when we've scrolled to the bottom
	if (currentTopIndex >= numberOfLines - 1 - visibleLinesInViewport)
	break;

	// if a lot of events were processed in above loop
	// we might have timed out. This is ok as long as the top
	// index is moving, i.e. we're not stuck or someone else
	// is eating our events -> restart the timer if the topindex
	// was moved.
	if (currentTopIndex > topIndex + 9) {
	// average for select & scroll is 30ms/line
	// - give it ten time as much to allow for GCs (300ms),
	// check back every 10 lines == never wait longer for a failure than 3s
	timeout= waiter.restart(delay);
	topIndex= currentTopIndex;
	}
	}
	waiter.hold();

	// lift keys in reverse order
	for (int j= keyCodes.length - 1; j >= 0; j--) {
	SWTEventHelper.keyCodeUp(display, keyCodes[j], false);
	}
	sleepAndRun(display);

	performanceMeter.stop();
	assertFalse("Never scrolled to the bottom, last event received " + delay + "ms ago, topIndex: " + text.getTopIndex(), timeout.hasTimedOut());

	// 2: go back home
	timeout= waiter.restart(2000);
	SWTEventHelper.pressKeyCodeCombination(display, mode.HOME_COMBO, false);
	while (!timeout.hasTimedOut() && text.getTopIndex() != 0) {
	sleepAndRun(display);
	}
	waiter.hold();

	assertFalse("Never went back to the top within 2000ms.", timeout.hasTimedOut());
	}
	} finally {
	waiter.stop();
	}
	}

	private void sleepAndRun(Display display) {
	if (display.sleep())
	EditorTestHelper.runEventQueue(display);
	}
	}