Ghidra is a software reverse engineering (SRE) framework
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package generic.test;
import static org.junit.Assert.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;
import javax.swing.*;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.text.JTextComponent;
import javax.swing.tree.*;
import org.junit.Assert;
import generic.timer.ExpiringSwingTimer;
import ghidra.framework.ApplicationConfiguration;
import ghidra.util.*;
import ghidra.util.datastruct.WeakSet;
import ghidra.util.exception.AssertException;
import ghidra.util.task.AbstractSwingUpdateManager;
import ghidra.util.task.SwingUpdateManager;
import junit.framework.AssertionFailedError;
import sun.awt.AppContext;
import utility.function.ExceptionalCallback;
/**
* Base class for tests that need swing support methods. Tests that don't involve Swing/Gui elements
* should use AbstractGenericTest instead
*/
public class AbstractGuiTest extends AbstractGenericTest {
@Override
protected ApplicationConfiguration createApplicationConfiguration() {
// A simple way to signal that Gui tests are not headless
return new ApplicationConfiguration() {
@Override
public boolean isHeadless() {
return false;
}
};
}
/**
* Gets all windows in the system (including Frames).
*
* @return all windows
*/
public static Set<Window> getAllWindows() {
Set<Window> set = new HashSet<>();
Frame sharedOwnerFrame = (Frame) AppContext.getAppContext()
.get(new StringBuffer("SwingUtilities.sharedOwnerFrame"));
if (sharedOwnerFrame != null) {
set.addAll(getAllWindows(sharedOwnerFrame));
}
for (Frame frame : Frame.getFrames()) {
set.addAll(getAllWindows(frame));
}
Window[] windows = Window.getWindows();
for (Window window : windows) {
set.add(window);
}
return set;
}
private static List<Window> getAllWindows(Window parent) {
List<Window> list = new ArrayList<>();
list.add(parent);
for (Window w : parent.getOwnedWindows()) {
list.add(w);
}
return list;
}
/**
* Waits for all system tasks to complete. These tasks are tracked by the
* SystemUtilities during testing only.
*
* @throws AssertionFailedError if the timeout period expires while waiting
* for tasks
*/
public static void waitForTasks() {
waitForTasks(PRIVATE_LONG_WAIT_TIMEOUT);
}
public static void waitForTasks(long timeout) {
waitForSwing();
long time = 0;
while (TaskUtilities.isExecutingTasks()) {
time += sleep(DEFAULT_WAIT_DELAY);
if (time >= timeout) {
Msg.error(AbstractGenericTest.class, createStackTraceForAllThreads());
throw new AssertionFailedError("Time expired waiting for tasks to complete.");
}
}
// let any pending Swing work finish
waitForSwing();
}
public static <T extends Component> T findComponent(Container parent, Class<T> desiredClass) {
return findComponent(parent, desiredClass, false);
}
public static <T extends Component> T findComponent(Container parent, Class<T> desiredClass,
boolean checkOwnedWindows) {
Component[] comps = parent.getComponents();
for (Component element : comps) {
if (element == null) {
continue;// this started happening in 1.6, not sure why
}
if (desiredClass.isAssignableFrom(element.getClass())) {
return desiredClass.cast(element);
}
else if (element instanceof Container) {
T c = findComponent((Container) element, desiredClass, checkOwnedWindows);
if (c != null) {
return desiredClass.cast(c);
}
}
}
if (checkOwnedWindows && (parent instanceof Window)) {
Window[] windows = ((Window) parent).getOwnedWindows();
for (int i = windows.length - 1; i >= 0; i--) {
Component c = findComponent(windows[i], desiredClass, checkOwnedWindows);
if (c != null) {
return desiredClass.cast(c);
}
}
}
return null;
}
public static <T extends Component> List<T> findComponents(Container parent,
Class<T> desiredClass) {
return findComponents(parent, desiredClass, false);
}
public static <T extends Component> List<T> findComponents(Container parent,
Class<T> desiredClass, boolean checkOwnedWindows) {
Component[] comps = parent.getComponents();
List<T> list = new ArrayList<>();
for (Component element : comps) {
if (element == null) {
continue;// this started happening in 1.6, not sure why
}
if (desiredClass.isAssignableFrom(element.getClass())) {
list.add(desiredClass.cast(element));
}
else if (element instanceof Container) {
T c = findComponent((Container) element, desiredClass, checkOwnedWindows);
if (c != null) {
list.add(desiredClass.cast(c));
}
}
}
if (checkOwnedWindows && (parent instanceof Window)) {
Window[] windows = ((Window) parent).getOwnedWindows();
for (int i = windows.length - 1; i >= 0; i--) {
Component c = findComponent(windows[i], desiredClass, checkOwnedWindows);
if (c != null) {
list.add(desiredClass.cast(c));
}
}
}
return list;
}
public static void findOwnedWindows(Window win, Set<Window> winList) {
Window[] children = win.getOwnedWindows();
for (Window element : children) {
winList.add(element);
findOwnedWindows(element, winList);
}
}
/**
* Finds the button with the indicated TEXT that is a sub-component of the
* indicated container, and then programmatically presses the button. <BR>
* The following is a sample JUnit test use:
*
* <PRE>
* env.showTool();
* OptionDialog dialog = (OptionDialog) env.waitForDialog(OptionDialog.class, 1000);
* assertNotNull(dialog);
* pressButtonByText(dialog, "OK");
* </PRE>
*
* @param container the container to search. (Typically a dialog.)
* @param buttonText the text on the desired JButton.
* @throws AssertionError if the button isn't found, isn't showing or isn't
* enabled
*/
public static void pressButtonByText(Container container, String buttonText) {
pressButtonByText(container, buttonText, true);
}
/**
* Finds the button with the indicated TEXT that is a sub-component of the
* indicated container, and then programmatically presses the button.
*
* @param container the container to search. (Typically a dialog.)
* @param buttonText the text on the desired JButton.
* @param waitForCompletion if true wait for action to complete before
* returning, otherwise schedule action to be performed and
* return immediately.
* @throws AssertionError if the button isn't found, isn't showing or isn't
* enabled
*/
public static void pressButtonByText(Container container, String buttonText,
boolean waitForCompletion) {
AbstractButton button = findAbstractButtonByText(container, buttonText);
if (button == null) {
throw new AssertionError("Couldn't find button " + buttonText + ".");
}
if (!runSwing(() -> button.isShowing())) {
throw new AssertionError("Button " + buttonText + " is not showing.");
}
if (!runSwing(() -> button.isEnabled())) {
throw new AssertionError("Button " + buttonText + " is not enabled.");
}
pressButton(button, waitForCompletion);
}
/**
* Finds the button with the indicated NAME that is a subcomponent of the
* indicated container, and then programmatically presses the button.
*
* @param container the container to search. (Typically a dialog)
* @param buttonName the name on the desired AbstractButton (see
* Component.setName())
*/
public static void pressButtonByName(Container container, String buttonName) {
pressButtonByName(container, buttonName, true);
}
/**
* Finds the button with the indicated NAME that is a subcomponent of the
* indicated container, and then programmatically presses the button.
*
* @param container the container to search. (Typically a dialog.)
* @param buttonName the name on the desired AbstractButton (see
* Component.setName()).
* @param waitForCompletion if true wait for action to complete before
* returning, otherwise schedule action to be performed and
* return immediately
*/
public static void pressButtonByName(Container container, String buttonName,
boolean waitForCompletion) {
AbstractButton button = (AbstractButton) findComponentByName(container, buttonName);
if (button == null) {
throw new AssertionError("Couldn't find button " + buttonName + ".");
}
if (!runSwing(() -> button.isShowing())) {
throw new AssertionError("Button " + buttonName + " is not showing.");
}
if (!runSwing(() -> button.isEnabled())) {
throw new AssertionError("Button " + buttonName + " is not enabled.");
}
pressButton(button, waitForCompletion);
}
/**
* Programmatically presses the indicated button.
*
* @param button the button
*/
public static void pressButton(AbstractButton button) {
if (!button.isEnabled()) {
throw new AssertException("Attempted to press a disabled button");
}
pressButton(button, true);
}
/**
* Programmatically presses the indicated button.
*
* @param button the button
* @param waitForCompletion if true wait for action to complete before
* returning, otherwise schedule action to be performed and
* return immediately.
*/
public static void pressButton(AbstractButton button, boolean waitForCompletion) {
Runnable r = () -> button.doClick(0); // 0 means no sleeping
runSwing(r, waitForCompletion);
}
/**
* Searches the subcomponents of the indicated container and returns the
* component with the specified name.
*
* @param container the container to search
* @param componentName the name of the desired component
*
* @return the component, or null if not found
*/
public static Component findComponentByName(Container container, String componentName) {
return findComponentByName(container, componentName, false);
}
public static Component findComponentByName(Container container, String componentName,
boolean checkOwnedWindows) {
String containerName = container.getName();
if (containerName != null && container.getName().equals(componentName)) {
return container;
}
Component[] comps = container.getComponents();
for (Component element : comps) {
if (element == null) {
continue;// this started happening in 1.6, not sure why
}
String name = element.getName();
if (name != null && name.equals(componentName)) {
return element;
}
else if (element instanceof Container) {
Component comp =
findComponentByName((Container) element, componentName, checkOwnedWindows);
if (comp != null) {
return comp;
}
}
}
if (checkOwnedWindows && (container instanceof Window)) {
Window[] windows = ((Window) container).getOwnedWindows();
for (int i = windows.length - 1; i >= 0; i--) {
Component c = findComponentByName(windows[i], componentName, checkOwnedWindows);
if (c != null) {
return c;
}
}
}
return null;
}
public static JButton findButtonByIcon(Container container, Icon icon) {
Component[] comps = container.getComponents();
for (Component element : comps) {
if (element instanceof JButton) {
JButton button = (JButton) element;
Icon buttonIcon = button.getIcon();
if (icon.equals(buttonIcon)) {
return button;
}
}
else if (element instanceof Container) {
JButton button = findButtonByIcon((Container) element, icon);
if (button != null) {
return button;
}
}
}
return null;
}
/**
* Searches the subcomponents of the given container and returns the
* JButton that has the specified text.
*
* @param container the container to search
* @param text the button text
* @return the JButton, or null the button was not found
*/
public static JButton findButtonByText(Container container, String text) {
Component[] comps = container.getComponents();
for (Component element : comps) {
if (element instanceof JButton) {
JButton button = (JButton) element;
if (button.getText() != null && button.getText().equals(text)) {
return button;
}
}
else if (element instanceof Container) {
JButton button = findButtonByText((Container) element, text);
if (button != null) {
return button;
}
}
}
return null;
}
/**
* Searches the sub-components of the given container and returns the AbstractButton that has
* the specified name.
*
* @param container container to search
* @param name the button name
* @return null if the button was not found
*/
public static AbstractButton findButtonByName(Container container, String name) {
return findAbstractButtonByName(container, name);
}
/**
* Searches the sub-components of the given container and returns the
* AbstractButton that has the specified text.
* <p>
* This differs from {@link #findButtonByText(Container, String)} in that
* this method will find buttons that do not extend from {@link JButton}.
* That method is convenient when you do not wish to cast the result from
* AbstractButton to JButton. Other than that, this method can handle all
* cases the other method cannot.
*
* @param container container to search
* @param text button text
* @return null if the button was not found
*/
public static AbstractButton findAbstractButtonByText(Container container, String text) {
Component[] comp = container.getComponents();
for (Component element : comp) {
if ((element instanceof AbstractButton) &&
text.equals(((AbstractButton) element).getText())) {
return (AbstractButton) element;
}
else if (element instanceof Container) {
AbstractButton b = findAbstractButtonByText((Container) element, text);
if (b != null) {
return b;
}
}
}
return null;
}
/**
* Searches the sub-components of the given container and returns the
* AbstractButton that has the specified name.
*
* @param container container to search
* @param name the button name (you must set this manually).
* @return null if the button was not found
*/
public static AbstractButton findAbstractButtonByName(Container container, String name) {
Component[] comp = container.getComponents();
for (Component element : comp) {
if ((element instanceof AbstractButton button) &&
name.equals(button.getName())) {
return button;
}
else if (element instanceof Container subContainer) {
AbstractButton b = findAbstractButtonByName(subContainer, name);
if (b != null) {
return b;
}
}
}
return null;
}
public static void leftClick(JComponent comp, int x, int y) {
clickMouse(comp, MouseEvent.BUTTON1, x, y, 1, 0);
}
public static void middleClick(JComponent comp, int x, int y) {
clickMouse(comp, MouseEvent.BUTTON2, x, y, 1, 0);
}
public static void rightClick(JComponent comp, int x, int y) {
clickMouse(comp, MouseEvent.BUTTON3, x, y, 1, 0, true);
}
public static void doubleClick(JComponent comp, int x, int y) {
clickMouse(comp, MouseEvent.BUTTON1, x, y, 2, 0);
}
/**
* Simulates click the mouse button.
*
* @param comp the component to click on.
* @param button the mouse button (1, 2, or 3)
* @param x the x coordinate of the click location
* @param y the y coordinate of the click location
* @param clickCount the number of clicks (2 = double click)
* @param modifiers additional modifiers (e.g. MouseEvent.SHIFT_MASK)
* @param popupTrigger a boolean, true if this event is a trigger for a
* popup menu
*/
public static void clickMouse(Component comp, int button, int x, int y, int clickCount,
int modifiers, boolean popupTrigger) {
int nonRelesedModifiers = convertToExtendedModifiers(modifiers, button, false);
int relesedModifiers = convertToExtendedModifiers(modifiers, button, true);
for (int cnt = 1; cnt <= clickCount; ++cnt) {
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_PRESSED, System.currentTimeMillis(),
nonRelesedModifiers, x, y, cnt, false, button));
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_CLICKED, System.currentTimeMillis(),
nonRelesedModifiers, x, y, cnt, false, button));
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_RELEASED, System.currentTimeMillis(),
relesedModifiers, x, y, cnt, popupTrigger, button));
}
}
/**
* Simulates click the mouse button.
*
* @param comp the component to click on.
* @param button the mouse button (1, 2, or 3)
* @param x the x coordinate of the click location
* @param y the y coordinate of the click location
* @param clickCount the number of clicks (2 = double click)
* @param modifiers additional modifiers (e.g. MouseEvent.SHIFT_MASK)
*/
public static void clickMouse(Component comp, int button, int x, int y, int clickCount,
int modifiers) {
clickMouse(comp, button, x, y, clickCount, modifiers, false);
}
/**
* Simulates a mouse drag action
*
* @param comp the component to drag on.
* @param button the mouse button (1, 2, or 3)
* @param startX the x coordinate of the start drag location
* @param startY the y coordinate of the start drag location
* @param endX the x coordinate of the end drag location
* @param endY the y coordinate of the end drag location
* @param modifiers additional modifiers (e.g. MouseEvent.SHIFT_MASK)
*/
public static void dragMouse(final Component comp, int button, final int startX,
final int startY, final int endX, final int endY, int modifiers) {
int nonRelesedModifiers = convertToExtendedModifiers(modifiers, button, false);
int relesedModifiers = convertToExtendedModifiers(modifiers, button, true);
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_PRESSED, System.currentTimeMillis(),
nonRelesedModifiers, startX, startY, 1, false, button));
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_DRAGGED, System.currentTimeMillis(),
nonRelesedModifiers, endX, endY, 1, false, button));
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_RELEASED, System.currentTimeMillis(),
relesedModifiers, endX, endY, 1, false, button));
}
/**
* Fire a mouse moved event for the given component.
*
* @param comp source of the event.
* @param x x position relative to the component
* @param y y position relative to the component
*/
public static void moveMouse(Component comp, int x, int y) {
postEvent(new MouseEvent(comp, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, x, y,
0, false));
}
@SuppressWarnings("deprecation")
private static int convertToExtendedModifiers(int modifiers, int button, boolean isRelease) {
// TODO: Eliminate duplication of similar modifier modification logic
// which exists in KeyBindingData
// remove system-dependent control key mask and transform deprecated modifiers
int controlMask = Toolkit.getDefaultToolkit().getMenuShortcutKeyMaskEx();
if ((modifiers & InputEvent.CTRL_DOWN_MASK) == InputEvent.CTRL_DOWN_MASK) {
modifiers = modifiers ^ InputEvent.CTRL_DOWN_MASK;
modifiers = modifiers | controlMask;
}
if ((modifiers & InputEvent.CTRL_MASK) == InputEvent.CTRL_MASK) {
modifiers = modifiers ^ InputEvent.CTRL_MASK;
modifiers = modifiers | controlMask;
}
if ((modifiers & ActionEvent.CTRL_MASK) == ActionEvent.CTRL_MASK) {
modifiers = modifiers ^ ActionEvent.CTRL_MASK;
modifiers = modifiers | controlMask;
}
if ((modifiers & InputEvent.SHIFT_MASK) == InputEvent.SHIFT_MASK) {
modifiers = modifiers ^ InputEvent.SHIFT_MASK;
modifiers = modifiers | InputEvent.SHIFT_DOWN_MASK;
}
if ((modifiers & InputEvent.ALT_MASK) == InputEvent.ALT_MASK) {
modifiers = modifiers ^ InputEvent.ALT_MASK;
modifiers = modifiers | InputEvent.ALT_DOWN_MASK;
}
if ((modifiers & InputEvent.META_MASK) == InputEvent.META_MASK) {
modifiers = modifiers ^ InputEvent.META_MASK;
modifiers = modifiers | InputEvent.META_DOWN_MASK;
}
if (!isRelease) {
//
// There are no mouse buttons down on a 'release' in Java's extended event processing.
// (The original non-extended events did include the button in the release event.)
//
switch (button) {
case 1:
modifiers |= InputEvent.BUTTON1_DOWN_MASK;
break;
case 2:
modifiers |= InputEvent.BUTTON2_DOWN_MASK;
break;
case 3:
modifiers |= InputEvent.BUTTON3_DOWN_MASK;
break;
}
}
return modifiers;
}
public static void postEvent(final AWTEvent ev) {
runSwing(() -> {
EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
eq.postEvent(ev);
});
waitForSwing();
}
/**
* Returns the value from the given {@link Supplier}, invoking the call in
* the Swing thread. This is useful when you may have values that are being
* changed on the Swing thread and you need the test thread to see the
* changes.
*
* @param s the supplier
* @return the value returned by the supplier
*/
public static <T> T getSwing(Supplier<T> s) {
AtomicReference<T> ref = new AtomicReference<>();
runSwing(() -> ref.set(s.get()));
return ref.get();
}
/**
* Returns the value from the given {@link Supplier}, invoking the call in
* the Swing thread. This is useful when you may have values that are being
* changed on the Swing thread and you need the test thread to see the
* changes.
*
* @param s the supplier
* @return the value returned by the supplier
* @see #getSwing(Supplier)
*/
public static <T> T runSwing(Supplier<T> s) {
return getSwing(s);
}
/**
* Run the given code snippet on the Swing thread and wait for it to finish
* @param r the runnable code snippet
*/
public static void runSwing(Runnable r) {
runSwing(r, true);
}
/**
* Run the given code snippet on the Swing thread later, not blocking the current thread. Use
* this if the code snippet causes a blocking operation.
*
* <P>This is a shortcut for <code>runSwing(r, false);</code>.
*
* @param r the runnable code snippet
*/
public void runSwingLater(Runnable r) {
runSwing(r, false);
}
/**
* Call this version of {@link #runSwing(Runnable)} when you expect your runnable <b>may</b>
* throw exceptions
*
* @param callback the runnable code snippet to call
* @throws Exception any exception that is thrown on the Swing thread
*/
public static <E extends Exception> void runSwingWithException(ExceptionalCallback<E> callback)
throws Exception {
if (Swing.isSwingThread()) {
throw new AssertException("Unexpectedly called from the Swing thread");
}
ExceptionHandlingRunner exceptionHandlingRunner = new ExceptionHandlingRunner(callback);
Throwable throwable = exceptionHandlingRunner.getException();
if (throwable == null) {
return;
}
if (throwable instanceof Exception) {
// this is what the client expected
throw (Exception) throwable;
}
// a runtime exception; re-throw
throw new AssertException(throwable);
}
public static void runSwing(Runnable runnable, boolean wait) {
//
// Special Case: this check handled re-entrant test code. That is, an calls to runSwing()
// that are made from within a runSwing() call. Most clients do not do
// this, but it can happen when a client makes a test API call (which itself
// calls runSwing()) from within a runSwing() call.
//
// Calling the run method directly here ensures that the order of client
// requests is preserved.
//
if (SwingUtilities.isEventDispatchThread()) {
runnable.run();
return;
}
if (wait) {
runSwingAndWait(runnable);
return;
}
// don't wait; invoke later; catch any exceptions ourselves in order to fail-fast
Runnable swingExceptionCatcher = () -> {
try {
runnable.run();
}
catch (Throwable t) {
// submit this failure directly to the handler; fail the test
ConcurrentTestExceptionHandler.handle(Thread.currentThread(), t);
}
};
SwingUtilities.invokeLater(swingExceptionCatcher);
}
protected static class ExceptionHandlingRunner {
private final ExceptionalCallback<? extends Exception> delegateCallback;
private Throwable exception;
ExceptionHandlingRunner(Runnable delegateRunnable) {
this.delegateCallback = () -> {
delegateRunnable.run();
};
run();
}
ExceptionHandlingRunner(ExceptionalCallback<? extends Exception> delegateCallback) {
this.delegateCallback = delegateCallback;
run();
}
Throwable getException() {
return exception;
}
String getExceptionMessage() {
Throwable throwable = getException();
String message = throwable.getMessage();
if (message != null) {
return message;
}
return getCauseExceptionMessage(throwable);
}
protected String getCauseExceptionMessage(Throwable t) {
if (t == null) {
return "<No Exception Message>";
}
if (t instanceof AssertionError) {
return t.getMessage();
}
String message = t.getMessage();
if (message != null) {
return message;
}
return getCauseExceptionMessage(t.getCause());
}
private void run() {
Runnable swingExceptionCatcher = () -> {
try {
delegateCallback.call();
}
catch (Throwable t) {
exception = t;
}
};
try {
doRun(swingExceptionCatcher);
}
catch (InterruptedException e) {
// Typically, this InterrruptedException that is caused by our test harness when it
// is interrupting the test thread after a previous Swing exception that we have
// detected--we don't care to throw the InterruptedException, as we caused it.
// Log a message to signal that unusual things may happen when in this state.
Msg.debug(this, "\n>>>>>>>>>>>>>>>> Test thread interrupted. Unusual/unexpected " +
"errors may follow.\n\n");
}
catch (InvocationTargetException e) {
// Assume that if we have an exception reported by our catcher above, then that is
// the root cause of this exception and do not report this one. This should not
// happen, as we are catching the exception above.
}
}
private void doRun(Runnable runnable)
throws InvocationTargetException, InterruptedException {
if (SwingUtilities.isEventDispatchThread()) {
runnable.run();
}
else {
SwingUtilities.invokeAndWait(runnable);
}
}
}
private static void runSwingAndWait(Runnable runnable) {
ExceptionHandlingRunner exceptionHandlingRunner = new ExceptionHandlingRunner(runnable);
Throwable throwable = exceptionHandlingRunner.getException();
if (throwable == null) {
return;
}
//
// Handle the exception
//
if (!TestThread.isTestThread()) {
// we have plumbing that checks for this in headed environments
ConcurrentTestExceptionHandler.handle(Thread.currentThread(), throwable);
return;
}
//
// When not in batch mode, Eclipse and Gradle will show the exception we build here,
// which is the most helpful.
//
String message = "Exception in Swing thread via runSwingAndWait():";
if (!BATCH_MODE) {
TestReportingException exception =
TestReportingException.fromSwingThread(message, throwable);
throw exception;
}
//
// When running in batch mode, the report generated by Gradle will not correctly show
// the stack trace if we throw the exception, so we will trigger a failure instead,
// which looks good in the test report.
//
String string = TestReportingException.getSwingThreadTraceString(throwable);
Assert.fail(message + "\n" + string + "\nTest Thread stack at that time:");
}
/**
* Launches the runnable on a new thread so as to not block the calling
* thread. This is very useful for performing actions on the Swing thread
* that show modal dialogs, which would otherwise block the calling thread,
* such as a testing thread.
*
* @param runnable The runnable that will be executed in a new Thread that
* will place the runnable on the Swing thread.
*/
public static void executeOnSwingWithoutBlocking(Runnable runnable) {
AtomicBoolean didRun = new AtomicBoolean();
(new Thread() {
@Override
public void run() {
didRun.set(true);
runSwing(runnable);
}
}).start();
// we can make this call, since any potential modal dialogs are not blocking in the Swing
// thread, but in the new event queue created by the modal dialog (this is how repainting
// still works when a modal dialog is shown)
waitForSwing();
waitForCondition(() -> didRun.get());
// pause a bit to let the swing thread process
sleep(DEFAULT_WAIT_DELAY);
// make sure any pending Swing events have been processed
waitForSwing();
}
public static void clickTableCell(final JTable table, final int row, final int col,
int clickCount) {
runSwing(() -> table.setRowSelectionInterval(row, row));
waitForSwing();
Rectangle rect = table.getCellRect(row, col, true);
clickMouse(table, MouseEvent.BUTTON1, rect.x + 10, rect.y + 10, clickCount, 0);
waitForSwing();
}
/**
* Clicks a range of items in a list (simulates holding SHIFT and selecting
* each item in the range in-turn)
*
* @param list the list to select from
* @param row the initial index
* @param count the number of rows to select
*/
public static void clickListRange(final JList<?> list, final int row, int count) {
waitForSwing();
for (int i = row; i < row + count; i++) {
Rectangle rect = list.getCellBounds(i, i);
clickMouse(list, MouseEvent.BUTTON1, rect.x + 10, rect.y + 10, 1,
InputEvent.SHIFT_DOWN_MASK);
}
waitForSwing();
}
/**
* Clicks a range of items in a table (simulates holding SHIFT and selecting
* each item in the range)
*
* @param table the table to select
* @param row the starting row index
* @param count the number of rows to select
*/
public static void clickTableRange(final JTable table, final int row, int count) {
waitForSwing();
for (int i = row; i < row + count; i++) {
Rectangle rect = table.getCellRect(i, 0, true);
clickMouse(table, MouseEvent.BUTTON1, rect.x + 10, rect.y + 10, 1,
InputEvent.SHIFT_DOWN_MASK);
}
waitForSwing();
}
public static TableCellEditor editCell(final JTable table, final int row, final int col) {
waitForSwing();
runSwing(() -> table.setRowSelectionInterval(row, row));
waitForSwing();
runSwing(() -> table.editCellAt(row, col));
waitForSwing();
TableCellEditor editor = table.getCellEditor(row, col);
assertNotNull("Unable to edit table cell at " + row + ", " + col, editor);
return editor;
}
/**
* Gets the rendered value for the specified table cell. The actual value at the cell may
* not be a String. This method will get the String display value, as created by the table.
*
* @param table the table to query
* @param row the row to query
* @param column the column to query
* @return the String value
* @throws IllegalArgumentException if there is no renderer or the rendered component is
* something from which this method can get a String (such as a JLabel)
*/
public static String getRenderedTableCellValue(JTable table, int row, int column) {
return runSwing(() -> {
TableCellRenderer renderer = table.getCellRenderer(row, column);
if (renderer == null) {
throw new IllegalArgumentException(
"No renderer registered for row/col: " + row + '/' + column);
}
Component component = table.prepareRenderer(renderer, row, column);
if (!(component instanceof JLabel)) {
throw new IllegalArgumentException(
"Do not know how to get text from a renderer " + "that is not a JLabel");
}
return ((JLabel) component).getText();
});
}
public static <T> void setComboBoxSelection(final JComboBox<T> comboField, final T selection) {
runSwing(() -> comboField.setSelectedItem(selection));
waitForSwing();
}
public static void setText(final JTextComponent field, final String text) {
runSwing(() -> field.setText(text));
waitForSwing();
}
public static String getText(final JTextComponent field) {
return runSwing(() -> field.getText());
}
/**
* Finds the path of a tree node in the indicated tree with the specified
* text. The matching tree node is determined by comparing the specified
* text with the string returned by the tree node's toString() method. <br>
* Note: This method affects the expansion state of the tree. It will expand
* nodes starting at the root until a match is found or all of the tree is
* checked.
*
* @param tree the tree
* @param text the tree node's text
* @return the tree path
*/
public static TreePath findTreePathToText(JTree tree, String text) {
TreeModel tm = tree.getModel();
TreeNode rootNode = (TreeNode) tm.getRoot();
TreePath rootPath = new TreePath(rootNode);
return findPathToText(tree, rootPath, text);
}
/**
* Performs a depth first search for the named tree node.
*
* @param tree the tree to search
* @param startTreePath path indicating node to begin searching from in the
* tree
* @param text the name of the node to find
* @return the path to the named node or null if it can't be found.
*/
protected static TreePath findPathToText(JTree tree, TreePath startTreePath, String text) {
if (text.equals(startTreePath.getLastPathComponent().toString())) {
return startTreePath;
}
tree.expandPath(startTreePath);
int len = startTreePath.getPathCount();
Object[] tpObjects = new Object[len + 1];
System.arraycopy(startTreePath.getPath(), 0, tpObjects, 0, len);
TreeNode treeNode = (TreeNode) startTreePath.getLastPathComponent();
int num = treeNode.getChildCount();
for (int i = 0; i < num; i++) {
TreeNode childNode = treeNode.getChildAt(i);
tpObjects[len] = childNode;
TreePath childPath = new TreePath(tpObjects);
TreePath treePath = findPathToText(tree, childPath, text);
if (treePath != null) {
return treePath;
}
}
return null;
}
/**
* Invoke <code>fixupGUI</code> at the beginning of your JUnit test or in
* its setup() method to make your GUI for the JUnit test appear using the
* system Look and Feel. The system look and feel is the default that Ghidra
* uses. This will also change the default fonts for the JUnit test to be
* the same as those in Ghidra.
*
* @exception InterruptedException if we're interrupted while waiting for
* the event dispatching thread to finish excecuting
* <code>doRun.run()</code>
* @exception InvocationTargetException if an exception is thrown while
* running <code>doRun</code>
*/
public static void fixupGUI() throws InterruptedException, InvocationTargetException {
// here to prevent compiler errors; should not be needed now that we have theming
}
/**
* Asserts that the two colors have the same rgb values (handles GColor)
* @param expected the expected color
* @param actual the actual color
*/
public void assertColorsEqual(Color expected, Color actual) {
if (expected.getRGB() == actual.getRGB()) {
return;
}
fail("Expected: [" + expected.getClass().getSimpleName() + "]" + expected + ", but got: [" +
actual.getClass().getSimpleName() + "]" + actual);
}
public static void printMemory() {
yieldToSwing();
System.gc();
yieldToSwing();
System.gc();
yieldToSwing();
System.gc();
Runtime runTime = Runtime.getRuntime();
long max = runTime.maxMemory() / 1000;
long total = runTime.totalMemory() / 1000;
long free = runTime.freeMemory() / 1000;
long used = (runTime.totalMemory() - runTime.freeMemory()) / 1000;
String msg = """
----------------------
Max: %,10dK
Total: %,10dK
Free: %,10dK
Used: %,10dK
""".formatted(max, total, free, used);
Msg.debug(AbstractGuiTest.class, msg);
}
//==================================================================================================
// Swing Methods
//==================================================================================================
public static boolean waitForExpiringSwingTimers() {
if (SwingUtilities.isEventDispatchThread()) {
throw new AssertException("Can't wait for swing from within the swing thread!");
}
// Note: this is based on the waitForSwing() timeout; this can be adjusted
boolean waited = false;
int MAX_SWING_TIMEOUT = 15000;
int totalTime = 0;
while (totalTime < MAX_SWING_TIMEOUT) {
@SuppressWarnings("unchecked")
Set<ExpiringSwingTimer> timers = runSwing(() -> {
return (Set<ExpiringSwingTimer>) getInstanceField("instances",
ExpiringSwingTimer.class);
});
if (timers.isEmpty()) {
return waited;
}
waited = true;
totalTime += sleep(DEFAULT_WAIT_DELAY);
}
if (totalTime >= MAX_SWING_TIMEOUT) {
Msg.debug(AbstractGenericTest.class,
"Timed-out waitinig for ExpiringSwingTimerc after " + totalTime + " ms. ");
return true;
}
return true;
}
/**
* Waits for the Swing thread to process any pending events. This method
* also waits for any {@link SwingUpdateManager}s that have pending events
* to be flushed.
*
* @return true if the any {@link SwingUpdateManager}s were busy.
*/
public static boolean waitForSwing() {
if (SwingUtilities.isEventDispatchThread()) {
throw new AssertException("Can't wait for swing from within the swing thread!");
}
Set<AbstractSwingUpdateManager> set = new HashSet<>();
runSwing(() -> {
@SuppressWarnings("unchecked")
WeakSet<SwingUpdateManager> s =
(WeakSet<SwingUpdateManager>) getInstanceField("instances",
SwingUpdateManager.class);
for (AbstractSwingUpdateManager manager : s) {
set.add(manager);
}
});
/*
long start = System.nanoTime();
boolean wasEverBusy = waitForSwing(set, true);
long end = System.nanoTime();
Msg.debug(AbstractGuiTest.class, "\twaitForSwing() - " +
TimeUnit.MILLISECONDS.convert(end - start, TimeUnit.NANOSECONDS));
*/
boolean wasEverBusy = waitForSwing(set, true);
return wasEverBusy;
}
private static boolean waitForSwing(Set<AbstractSwingUpdateManager> managers, boolean flush) {
// Note: not sure how long is too long to wait for the Swing thread and update managers
// to finish. This is usually less than a second. We have seen a degenerate
// case where this took minutes. This method is called often, so don't wait too
// long. This will have to be changed through trial-and-error.
int MAX_SWING_TIMEOUT = 15000;
int totalTime = 0;
// flush all managers up front to get them started before we check them
flushAllManagers(managers, flush);
boolean wasEverBusy = false;
boolean keepGoing = true;
while (keepGoing) {
// let swing paint and maybe schedule more work on the update managers
yieldToSwing();
keepGoing = false;
for (AbstractSwingUpdateManager manager : managers) {
if (!manager.isBusy()) {
// no current or pending work
continue;
}
// Msg.out("busy manager: " + manager.toStringDebug());
doFlush(flush, manager);
boolean isBusy = true;
while (isBusy) {
keepGoing = true; // true, since we had a busy signal
wasEverBusy = true;
totalTime += sleep(DEFAULT_WAIT_DELAY);
if (totalTime >= MAX_SWING_TIMEOUT) {
// eject!
Msg.debug(AbstractGenericTest.class,
"Timed-out waitinig for Swing after " + totalTime + " ms. " +
"The currently waited SwingUpdateManager:\n" +
manager.toStringDebug());
return true;
}
isBusy = manager.isBusy();
}
}
// let any resulting swing events finish
yieldToSwing();
}
return wasEverBusy;
}
private static void flushAllManagers(Set<AbstractSwingUpdateManager> managers, boolean flush) {
//
// Some update managers will make an update that causes another manager to schedule an
// update. In order to *not* have to wait for each of these, one-at-a-time, loop a
// few times so that any follow-up scheduling events will be executed as well. These
// calls all execute in the Swing thread in a blocking fashion, so when we are done
// flushing, there should be no more work scheduled due to us flushing. Due to other
// potential background threads though, more work may be scheduled as we are working.
// Thus, for fast tests, you should not have background work happening that is not
// directly related to your code being tested.
//
// arbitrary; we have at least one level of a manager triggering another manager,
// which would be 2
int n = 3;
for (int i = 0; i < n; i++) {
for (AbstractSwingUpdateManager manager : managers) {
doFlush(flush, manager);
}
}
}
private static void doFlush(boolean doFlush, AbstractSwingUpdateManager manager) {
if (!doFlush) {
return;
}
runSwing(() -> {
manager.flush();
}, false);
yieldToSwing();
}
/**
* This is only for internal use. If you need to wait for the Swing thread
* from your test, then use {@link #waitForSwing()}.
*
* @deprecated This is not a test writer's method, but instead an
* infrastructure method.
*/
@Deprecated
public static void privatewaitForSwing_SwingSafe() {
yieldToSwing();
}
protected static void yieldToSwing() {
if (SwingUtilities.isEventDispatchThread()) {
Msg.error(AbstractGenericTest.class,
"Incorrectly called yieldToSwing() from the Swing thread");
return; // shouldn't happen
}
Runnable empty = () -> {
// do nothing...this is just a placeholder runnable that gets put onto the stack
};
//
// Note: the calls below are designed to ignore being interrupted. Further, if one of
// the calls is interrupted, the others will still work as expected.
//
for (int i = 0; i < 3; i++) {
try {
SwingUtilities.invokeAndWait(empty);
}
catch (Exception e) {
// Assumption: since our runnable is empty, this can only an interrupted
// exception, which can happen if our test framework decides to
// shut the operation down.
return;
}
}
}
}