JFCUnit Test Coverage

Clover coverage report - JFCUnit Test Coverage
Coverage timestamp: Mon Dec 20 2004 23:38:10 MST
FRAMES NO FRAMES
file stats:	LOC:	826		Methods:	26
	NCLOC:	515		Classes:	1
Source file
Conditionals
Statements
Methods
TOTAL
TestHelperT.java
97.1%
99.2%
96.2%
98.9%
 package junit.extensions.jfcunit;
 
 import java.util.List;
 
 import java.awt.Component;
 import java.awt.FlowLayout;
 import java.awt.Frame;
 import java.awt.Point;
 import java.awt.Toolkit;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import javax.swing.JButton;
 import javax.swing.JDialog;
 import javax.swing.JFileChooser;
 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.JMenu;
 import javax.swing.JMenuItem;
 import javax.swing.JOptionPane;
 import javax.swing.JScrollPane;
 import javax.swing.JTabbedPane;
 import javax.swing.JTextField;
 import javax.swing.JToggleButton;
 import javax.swing.JToolBar;
 import javax.swing.SwingUtilities;
 import javax.swing.filechooser.FileSystemView;
 
 import org.apache.regexp.RESyntaxException;
 import junit.extensions.jfcunit.finder.AbstractButtonFinder;
 import junit.extensions.jfcunit.finder.ComponentFinder;
 import junit.extensions.jfcunit.finder.Finder;
 import junit.extensions.jfcunit.finder.NamedComponentFinder;
 import junit.swingui.TestRunner;
 import java.lang.reflect.InvocationTargetException;
 import junit.extensions.jfcunit.finder.FrameFinder;
 import junit.extensions.jfcunit.finder.DialogFinder;
 import junit.extensions.jfcunit.finder.JFileChooserFinder;
 
 /**
  * Title:        TestHelperT
  * Description:  Unit tests for the {@link TestHelper} class and it's methods.
  *               Designed to work with JUnit v3.7 or later.
  *
  * @author Greg Houston
  * @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
  */
 public class TestHelperT extends AbstractTestCase {
 
   /**
    * String litteral for something.
    */
     private static final String SOMETHING = "something";
     /**
      * Default constructor that accepts a String.
      *
      * @param   name      The name of the test method to execute.
      */
     public TestHelperT(final String name) {
         super(name);
     }
 
     /**
      * Overridden method that is used to setup the test fixtures.
      */
     public void setUp() {
         if (getHelper() == null) {
             setHelper(new TestHelperClass());
         }
         getHelper().cleanUp(this);
         assertEquals("No windows should be present", 0, getHelper().getWindows().size());
     }
 
     /**
      * The entry point for this class if it is to be run as a stand-alone application.
      *
      * @param   args      The command-line arguments.
      */
     public static void main(final String[] args) {
         TestRunner.run(TestHelperT.class);
     }
 
     /*
     // Uncomment for testing individual methods.
     public static junit.framework.Test suite() {
         junit.framework.TestSuite suite = new junit.framework.TestSuite();
         suite.addTest(new TestHelperT("testFindComponent"));
         return suite;
     }
     */
 
 
     /**
      * Tests that the findComponent() method works.
      */
     public void testFindComponent() {
         setWindow(createJFrame(getName()));
         getFrame().setName("frame");
         getFrame().getContentPane().setLayout(new FlowLayout());
 
         // have a component with no name set
         JMenuItem menuItem1 = new JMenuItem("MenuItem1");
         getFrame().getContentPane().add(menuItem1);
 
         // have a component with name set
         JMenuItem menuItem2 = new JMenuItem("MenuItem2");
         menuItem2.setName(SOMETHING);
         getFrame().getContentPane().add(menuItem2);
 
         // have a component with no name set
         JMenu menu1 = new JMenu("Menu1");
         getFrame().getContentPane().add(menu1);
 
         // have a component with name set
         JMenu menu2 = new JMenu("Menu2");
         menu2.setName(SOMETHING);
         getFrame().getContentPane().add(menu2);
 
         // have a component with no name set
         JToolBar toolBar1 = new JToolBar();
         getFrame().getContentPane().add(toolBar1);
 
         // have a component with name set
         JToolBar toolBar2 = new JToolBar();
         toolBar2.setName("SomeName");
         getFrame().getContentPane().add(toolBar2);
 
         // have a component with no name set
         JLabel label1 = new JLabel("label1");
         getFrame().getContentPane().add(label1);
 
         // have a component with name set
         JLabel label2 = new JLabel("label2");
         label2.setName(SOMETHING);
         getFrame().getContentPane().add(label2);
 
         // have a component with no name set
         JButton button1 = new JButton("button1");
         getFrame().getContentPane().add(button1);
 
         // have a component with name set
         JButton button2 = new JButton("button2");
         button2.setName(SOMETHING);
         getFrame().getContentPane().add(button2);
 
         // have a component with no name set
         JToggleButton toggleButton1 = new JToggleButton("toggleButton1");
         getFrame().getContentPane().add(toggleButton1);
 
         // have a component with name set
         JToggleButton toggleButton2 = new JToggleButton("toggleButton2");
         toggleButton2.setName(SOMETHING);
         getFrame().getContentPane().add(toggleButton2);
 
         packAndShow(getFrame());
 
         Component component;
 
         // Note: JMenu and JMenuItem are here to test that if the class specified
         // is a super class, the find call should not return that component
 
         // 1: find by specifying class
         component = new ComponentFinder(JMenuItem.class).find(getFrame(), 0);
         assertEquals("1: Component found should be menuItem1", menuItem1, component);
 
         // 2: find by specifying class
         component = new ComponentFinder(JMenuItem.class).find(getFrame(), 1);
         assertEquals("2: Component found should be menuItem2", menuItem2, component);
 
         // 1: find by specifying class
         component = new ComponentFinder(JMenu.class).find(getFrame(), 0);
         assertEquals("1: Component found should be menu1", menu1, component);
 
         // 2: find by specifying class
         Finder finder = new ComponentFinder(JMenu.class);
         finder.setDebug(true);
         component = finder.find(getFrame(), 1);
         assertEquals("2: Component found should be menu2", menu2, component);
 
         // 1: find by specifying class
         component = new ComponentFinder(JToolBar.class).find(getFrame(), 0);
         assertEquals("1: Component found should be toolBar1", toolBar1, component);
 
         // 2: find by specifying class
         component = new ComponentFinder(JToolBar.class).find(getFrame(), 1);
         assertEquals("2: Component found should be toolBar2", toolBar2, component);
 
         // 1: find by specifying class
         component = new ComponentFinder(JLabel.class).find(getFrame(), 0);
         assertEquals("1: Component found should be label1", label1, component);
 
         // 2: find by specifying class
         component = new ComponentFinder(JLabel.class).find(getFrame(), 1);
         assertEquals("2: Component found should be label2", label2, component);
 
         // 1: find by specifying class
         component = new ComponentFinder(JButton.class).find(getFrame(), 0);
         assertEquals("1: Component found should be button1", button1, component);
 
         // 2: find by specifying class
         component = new ComponentFinder(JButton.class).find(getFrame(), 1);
         assertEquals("2: Component found should be button2", button2, component);
 
         // 1: find by specifying class
         component = new ComponentFinder(JToggleButton.class).find(getFrame(), 0);
         assertEquals("1: Component found should be toggleButton1", toggleButton1, component);
 
         // 2: find by specifying class
         component = new ComponentFinder(JToggleButton.class).find(getFrame(), 1);
         assertEquals("2: Component found should be toggleButton2", toggleButton2, component);
 
         // using patterns to find components
         component = new AbstractButtonFinder("but[a-z]*1").find(getFrame(), 0);
         assertEquals("1: Component found should be button1", button1, component);
 
         component = new AbstractButtonFinder("but[a-z]*[0-9]").find(getFrame(), 1);
         assertEquals("2: Component found should be button2", button2, component);
     }
 
     /**
      * Creates a frame with an 'ok' button. Tries to find the button using it's
      * component name, asserts that it was found.  Also tries to find a component
      * that doesn't exist, asserts that null is returned.
      */
     public void testFindNamedComponent() {
         setWindow(createJFrame(getName()));
         getFrame().setName("frame");
         getFrame().getContentPane().setLayout(new FlowLayout());
 
         JButton button = new JButton("Ok Button");
         button.setName("Ok Button");
         getFrame().getContentPane().add(button);
 
         JButton button2 = new JButton("Ok Button #2");
         button2.setName("Ok Button #2");
         getFrame().getContentPane().add(button2);
 
         JLabel label = new JLabel("Ok Label");
         label.setName("Ok Label");
         getFrame().getContentPane().add(label);
 
         JLabel nullname = new JLabel("Null name");
         nullname.setName(null);
         getFrame().getContentPane().add(nullname);
 
         JMenuItem menuItem1 = new JMenuItem("MenuItem1");
         getFrame().getContentPane().add(menuItem1);
 
         JMenuItem menuItem2 = new JMenuItem("MenuItem2");
         menuItem2.setName("SomeName");
         getFrame().getContentPane().add(menuItem2);
 
         JMenu menu1 = new JMenu("Menu1");
         getFrame().getContentPane().add(menu1);
 
         JMenu menu2 = new JMenu("Menu2");
         menu2.setName("SomeName");
         getFrame().getContentPane().add(menu2);
 
         packAndShow(getFrame());
 
         Component component;
         Finder finder = new NamedComponentFinder(null, "notfound");
         finder.setWait(0);
         component = finder.find(getFrame(), 0);
         assertNull("Must not find 'notfound'", component);
 
         String ok = "Ok";
         component = new NamedComponentFinder(null, ok).find(getFrame(), 0);
         assertEquals("Must find 'Ok'", button, component);
 
         component = new NamedComponentFinder(null, ok).find(getFrame(), 1);
         assertEquals("Must find 'Ok' Button #2", button2, component);
 
         component = new NamedComponentFinder(label.getClass(), ok).find(getFrame(), 0);
         assertEquals("Must find 'Ok' label", label, component);
 
         component = new NamedComponentFinder(JLabel.class, null).find(getFrame(), 0);
         assertEquals("Must find label with null name", nullname, component);
 
         component = new NamedComponentFinder(JLabel.class, (String) null).find(getFrame(), 0);
         assertNull("Must find a component with null for name.", component.getName());
 
         component = new NamedComponentFinder(JMenu.class, null).find(getFrame(), 0);
         assertEquals("Must find menu with null name", menu1, component);
 
         component = new NamedComponentFinder(menu1.getClass(), menu1.getName()).find(getFrame(), 0);
         assertEquals("Must find '" + menu1.getName() + "' menu", menu1, component);
 
         component = new NamedComponentFinder(menu2.getClass(), menu2.getName()).find(getFrame(), 0);
         assertEquals("Must find '" + menu2.getName() + "' menu", menu2, component);
 
         component = new NamedComponentFinder(JMenuItem.class, null).find(getFrame(), 0);
         assertEquals("Must find menuItem with null name", menuItem1, component);
 
         component = new NamedComponentFinder(menuItem1.getClass(), menuItem1.getName()).find(getFrame(), 0);
         assertEquals("Must find '" + menuItem1.getName() + "' menuItem", menuItem1, component);
 
         component = new NamedComponentFinder(menuItem2.getClass(), menuItem2.getName()).find(getFrame(), 0);
         assertEquals("Must find '" + menuItem2.getName() + "' menuItem", menuItem2, component);
 
         // using patterns to find named components
         component = new NamedComponentFinder(null, "[a-zA-Z]* Button").find(getFrame(), 0);
         assertEquals("Must find 'Ok' Button #1", button, component);
 
         component = new NamedComponentFinder(null, "[a-zA-Z]* Button").find(getFrame(), 1);
         assertEquals("Must find 'Ok' Button #2", button2, component);
 
         component = new NamedComponentFinder(null, "[a-zA-Z]* Button .2").find(getFrame(), 0);
         assertEquals("Must find 'Ok' Button #2", button2, component);
     }
 
     /**
      * Checks that when finding a window using the complete title, we do find it.
      */
     public void testGetWindowByCompleteTitle() {
         String frameTitle = getName() + " 1";
         setWindow(createJFrame(frameTitle));
         packAndShow(getFrame());
 
         assertEquals("Must find window with '" + frameTitle + "' title", getFrame(), new FrameFinder(frameTitle).find());
     }
 
     /**
      * Checks that when finding a window using the complete title,
      * we do find it.
      */
     public void testGetWindowByPartialTitle() {
         String frameTitle = getName() + " 2";
         setWindow(createJFrame(frameTitle));
         packAndShow(getFrame());
 
         String subTitle = frameTitle.substring(frameTitle.length() - 7);
         assertEquals("Must find window with title containing '" + subTitle + "'",
                      getFrame(),
                      new FrameFinder(subTitle).find());
     }
 
     /**
      * Checks that when finding a window using the partial title,
      * we do find it.
      */
     public void testGetWindowByNullTitle() {
         setWindow(createJFrame(null));
         packAndShow(getFrame());
 
         Finder finder = new FrameFinder("Notfound");
         finder.setWait(0);
 
         assertNull("Window should not be found", finder.find());
         finder = new FrameFinder(null);
         assertEquals("null title should find frame", getFrame(), finder.find());
     }
 
     /**
      * Checks that when finding a window using the partial title,
      * we do find the correct number of multiple windows.
      */
     public void testGetWindowByPartialTitle2() {
         String frame1Title = getName() + " 1";
         setWindow(createJFrame(frame1Title));
         packAndShow(getFrame());
 
         String frame2Title = getName() + " 2";
         JFrame frame2 = createJFrame(frame2Title);
         packAndShow(frame2);
         flushAWT();
 
         try {
             Finder finder = new FrameFinder("");
             assertNotNull("Empty string must return a match", finder.find());
 
             List wins = new FrameFinder(getName()).findAll();
             assertEquals("getWindows must return two windows that matched title", 2, wins.size());
         } finally {
             TestHelper.disposeWindow(frame2, this);
         }
     }
 
     /**
      * Checks that when finding a set of windows using the title,
      * we do find them. Tests with partial title as well as complete title.
      */
     public void testGetWindows() {
         int number = 5;
         JFrame[] frames = new JFrame[number * 2];
         String duplicateTitle = "Duplicate";
         String frameTitle = getName();
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             frames[i] = createJFrame(frameTitle + " " + (i + 1));
 
             // don't center - all of the frames will overlap
             frames[i].setLocation(x + (i * 50), y + (i * 50));
             frames[i].pack();
             frames[i].setVisible(true);
 
             int dupIndex = i + number;
             frames[dupIndex] = createJFrame(duplicateTitle + " " + (i + 1));
 
             // don't center - all of the frames will overlap
             frames[dupIndex].setLocation(x + (dupIndex * 50), y + (dupIndex * 50));
             frames[dupIndex].pack();
             frames[dupIndex].setVisible(true);
         }
         flushAWT();
 
         try {
             List windows;
             // find by the method name set to null - all windows should show up
             windows = TestHelper.getWindows((String) null);
             assertEquals("(1)Could not find correct number of windows", number * 2, windows.size());
 
             // find by the method name as substring
             windows = TestHelper.getWindows(frameTitle);
             assertEquals("(2)Could not find correct number of windows", number, windows.size());
 
             // find by "Duplicate" as substring
             windows = TestHelper.getWindows(duplicateTitle);
             assertEquals("(3)Could not find correct number of windows", number, windows.size());
 
             // find by the integer part  as substring
             windows = TestHelper.getWindows(" 4");
             assertEquals("(4)Could not find correct number of windows", 2, windows.size());
 
             // find by the integer part  as substring
             windows = TestHelper.getWindows(duplicateTitle + " 2");
             assertEquals("(5)Could not find correct number of windows", 1, windows.size());
         } finally {
             for (int i = 0; i < frames.length; i++) {
                 TestHelper.disposeWindow(frames[i], this);
             }
         }
     }
 
     /**
      * Checks that when finding a set of dialogs without specifying the owner,
      * we do find them.
      */
     public void testGetShowingDialogsNotSpecifyingOwner() {
         setWindow(createJFrame(getName()));
         getFrame().setName("frame");
         getFrame().setVisible(true);
 
         int number = 5;
         JFrame[] frames = new JFrame[number];
         JDialog[] dialogs = new JDialog[number];
         String dialogTitle = getName();
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             frames[i] = createJFrame(getName() + " " + (i + 1));
             frames[i].setLocation(i * 25, i * 25);
             frames[i].setVisible(true);
 
             dialogs[i] = new JDialog(frames[i], dialogTitle + " " + (i + 1));
 
             // don't center - all of the dialogs will overlap
             dialogs[i].setLocation(x + (i * 50), y + (i * 50));
             dialogs[i].pack();
             dialogs[i].setVisible(true);
         }
 
         try {
             List windows = new DialogFinder(null).findAll();
             assertEquals("Could not find correct number of windows", number, windows.size());
         } finally {
             for (int i = 0; i < dialogs.length; i++) {
                 TestHelper.disposeWindow(frames[i], this);
             }
         }
     }
 
     /**
      * Checks that when finding a set of dialogs using the title,
      * we do find them. Tests with partial title as well as complete title.
      */
     public void testGetShowingDialogsSpecifyingTitle() {
         int number = 5;
         JDialog[] dialogs = new JDialog[number * 2];
         String duplicateTitle = "Duplicate";
         String dialogTitle = getName();
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             dialogs[i] = new JDialog((Frame) null, dialogTitle + " " + (i + 1));
 
             // don't center - all of the dialogs will overlap
             dialogs[i].setLocation(x + (i * 50), y + (i * 50));
             dialogs[i].pack();
             dialogs[i].setVisible(true);
 
             int dupIndex = i + number;
             dialogs[dupIndex] = new JDialog((Frame) null, duplicateTitle + " " + (i + 1));
 
             // don't center - all of the dialogs will overlap
             dialogs[dupIndex].setLocation(x + (dupIndex * 50), y + (dupIndex * 50));
             dialogs[dupIndex].pack();
             dialogs[dupIndex].setVisible(true);
         }
 
         flushAWT();
         try {
             List windows;
             // find by the method name set to null - all dialogs should show up
             windows = new DialogFinder((String) null).findAll();
             assertEquals("(1)Could not find correct number of windows", number * 2, windows.size());
 
             // find by the method name as substring
             windows = new DialogFinder(dialogTitle).findAll();
             assertEquals("(2)Could not find correct number of windows", number, windows.size());
 
             // find by "Duplicate" as substring
             windows = new DialogFinder(duplicateTitle).findAll();
             assertEquals("(3)Could not find correct number of windows", number, windows.size());
 
             // find by the integer part as substring
             windows = new DialogFinder(" 4").findAll();
             assertEquals("(4)Could not find correct number of windows", 2, windows.size());
 
             // find by the integer part as substring
             windows = new DialogFinder(duplicateTitle + " 2").findAll();
             assertEquals("(5)Could not find correct number of windows", 1, windows.size());
         } finally {
             for (int i = 0; i < dialogs.length; i++) {
                 TestHelper.disposeWindow(dialogs[i], this);
             }
         }
     }
 
 
     /**
      * This method is used to test that when dialogs are "buried" under (owned by) other
      * dialogs, they can still be found by the default getShowingDialogs() which does not
      * accept any arguments.
      */
     public void testGetShowingDialogsMultiLevelDeep() {
         int number = 5;
         JDialog[] dialogs = new JDialog[number];
         String levelTitle = "Level";
         String dialogTitle = getName();
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             if (i == 0) {
                 dialogs[i] = new JDialog((Frame) null, dialogTitle + ": " + levelTitle + ": " + (i + 1));
             } else {
                 dialogs[i] = new JDialog(dialogs[i - 1], dialogTitle + ": " + levelTitle + ": " + (i + 1));
             }
 
             // don't center - all of the dialogs will overlap
             dialogs[i].setLocation(x + (i * 50), y + (i * 50));
             dialogs[i].pack();
             dialogs[i].setVisible(true);
         }
 
         try {
             List windows;
             // find by the method name set to null - all dialogs should show up
             windows = new DialogFinder((String) null).findAll();
             assertEquals("(1)Could not find correct number of windows", number, windows.size());
 
             // find by the method name as substring
             windows = new DialogFinder(dialogTitle).findAll();
             assertEquals("(2)Could not find correct number of windows", number, windows.size());
 
             // find by "Level" as substring
             windows = new DialogFinder(levelTitle).findAll();
             assertEquals("(3)Could not find correct number of windows", number, windows.size());
 
             // find by the integer part as substring
             windows = new DialogFinder(" 3").findAll();
             assertEquals("(4)Could not find correct number of windows", 1, windows.size());
 
             // find by the integer part as substring
             windows = new DialogFinder(levelTitle + ": 4").findAll();
             assertEquals("(5)Could not find correct number of windows", 1, windows.size());
         } finally {
             for (int i = 0; i < dialogs.length; i++) {
                 TestHelper.disposeWindow(dialogs[i], this);
             }
         }
     }
 
     /**
      * Tests that the cleanUp() method works correctly.
      * No System Windows.
      */
     public void testCleanUp() {
         int number = 10;
         TestHelper.removeAllSystemWindows();
         JFrame[] frames = new JFrame[number];
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             frames[i] = createJFrame(getName() + " " + (i + 1));
 
             // don't center - all of the frames will overlap
             frames[i].setLocation(x + (i * 50), y + (i * 50));
             frames[i].pack();
             frames[i].setVisible(true);
             flushAWT();
         }
 
         assertEquals("(1)Number of windows is incorrect", number, TestHelper.getWindows().size());
 
         TestHelper.disposeWindow(frames[4], this);
         assertEquals("(2)Number of windows is incorrect", number - 1, TestHelper.getWindows().size());
 
         TestHelper.cleanUp(this);
         assertEquals("Number of windows is incorrect", 0, TestHelper.getWindows().size());
     }
 
     /**
      * Tests that the cleanUp() method works correctly.
      */
     public void testCleanUpWithSystemWindow() {
         int number = 10;
         TestHelper.removeAllSystemWindows();
         JFrame[] frames = new JFrame[number];
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             frames[i] = createJFrame(getName() + " " + (i + 1));
 
             // don't center - all of the frames will overlap
             frames[i].setLocation(x + (i * 50), y + (i * 50));
             frames[i].pack();
             frames[i].setVisible(true);
         }
         flushAWT();
 
         assertEquals("(1)Number of windows is incorrect", number, TestHelper.getWindows().size());
 
         try {
           TestHelper.addSystemWindow("^" + frames[4].getTitle() + "$");
         } catch (RESyntaxException ex) {
           fail("Exception while adding System Window");
         }
         TestHelper.cleanUp(this);
         assertEquals("(2)Number of windows is incorrect", 1, TestHelper.getWindows().size());
         TestHelper.removeSystemWindow("^" + frames[4].getTitle() + "$");
 
         TestHelper.cleanUp(this);
         assertEquals("Number of windows is incorrect", 0, TestHelper.getWindows().size());
     }
 
     /**
      * Tests that the disposeWindow() method works correctly.
      */
     public void testDisposeWindow() {
         JTextField textField = new JTextField(30);
 
         setWindow(createJFrame(getName()));
         getFrame().addWindowListener(new WindowAdapter() {
             public void windowOpened(final WindowEvent e) {
                 (new JDialog(getFrame(), "Dialog title")).setVisible(true);
             }
         });
         getFrame().getContentPane().add(textField);
         packAndShow(getFrame());
 
         // need this call here so that the dialog can also show
         flushAWT();
 
         DialogFinder finder = new DialogFinder(null);
         finder.setWait(0);
         List showingDialogs = finder.findAll(getFrame());
         assertEquals("(1)Number of showing dialogs is wrong", 1, showingDialogs.size());
 
         // check for dialog box with null owner
         TestHelper.disposeWindow(getFrame(), this);
         assertTrue("Frame is still showing", !getFrame().isShowing());
 
         // check that the call to dispose the frame also disposed of its open dialogs
         showingDialogs = finder.findAll(getFrame());
         assertEquals("(2)Number of showing dialogs is wrong", 0, showingDialogs.size());
     }
 
     /**
      * This method is used to test the getJFileChoosers() method.
      */
     public void testGetJFileChoosers() {
         setWindow(createJFrame(getName()));
         packAndShow(getFrame());
 
         JTabbedPane tabPane = null;
         JFileChooser fileChooser = null;
         JDialog dialog = null;
         int number = 5;
         String dialogTitle = "Testing JFileChooser ";
         int x = (int) (Math.random() * number);
         int y = (int) (Math.random() * number);
         for (int i = 0; i < number; i++) {
             tabPane = new JTabbedPane();
             // use the FileSystemView to get a directory - otherwise, some versions
             // of the JDK have problems finding the default directory.
             fileChooser = new JFileChooser(FileSystemView.getFileSystemView());
             tabPane.add(fileChooser);
             tabPane.setSize(200, 200);
 
             dialog = new JDialog(getFrame(), dialogTitle + (i + 1), false);
             dialog.getContentPane().add(new JScrollPane(tabPane));
             // don't center - all of the dialogs will overlap
             dialog.setLocation(x + (i * 50), y + (i * 50));
             dialog.pack();
             dialog.setVisible(true);
         }
 
         JFileChooserFinder finder = new JFileChooserFinder(null);
         finder.setWait(0);
         List returnedValues = finder.findAll(getFrame());
         assertEquals("(1) Number of showing JFileChoosers is wrong", number, returnedValues.size());
 
         // dispose of the last dialog and then try again
         TestHelper.disposeWindow(dialog, this);
 
         returnedValues = finder.findAll(getFrame());
         assertEquals("(2) Number of showing JFileChoosers is wrong", number - 1, returnedValues.size());
     }
 
     /**
      * Tests that the getMessageFromJDialog() method works.
      *
      * @exception InterruptedException  May be thrown from sleep.
      */
     public void testGetMessageFromJDialog() throws InterruptedException {
         final String msg = "Test Message";
 
         // call flushAWT so that any existing events in the EventQueue are processed
         flushAWT();
 
         SwingUtilities.invokeLater(new Runnable() {
             public void run() {
                 JOptionPane.showMessageDialog(null, msg, "title", JOptionPane.INFORMATION_MESSAGE);
             }
         });
 
         // call awtSleep so that the above call to SwingUtilities can be processed
         Thread.currentThread().sleep(100);
         flushAWT();
 
         List showingDialogs = new DialogFinder("title").findAll();
         assertEquals("Number of dialogs showing is incorrect", 1, showingDialogs.size());
         JDialog dialog = (JDialog) showingDialogs.iterator().next();
         String message = getHelper().getMessageFromJDialog(dialog);
         assertEquals("Could not find the correct message from the dialog box", msg, message);
         TestHelper.disposeWindow(dialog, this);
     }
 
     /**
      * Tests that the invokeAndWait() method works.
      *
      * @throws InterruptedException  May be thrown from sleep.
      * @throws InvocationTargetException from invokeAndWait.
      */
     public void testInvokeAndWait() throws InterruptedException, InvocationTargetException {
         Toolkit.getDefaultToolkit().getSystemEventQueue().invokeAndWait(new Runnable() {
             public void run() {
                 try {
                     Thread.currentThread().sleep(10);
                 } catch (Exception e) {
                   // This should not happen.
                   e.printStackTrace();
                 }
             }
         });
     }
 
     /**
      * Test the TestCase sleep method.
      */
     public void testSleep() {
         long tm = System.currentTimeMillis();
         sleep(500);
         long duration = System.currentTimeMillis() - tm;
         assertTrue("Duration not sufficient:", (duration > 500));
     }
 
     /**
      * Test the pause/resume methods for managing the
      * event queue.
      */
     public void testAWT() {
         assertTrue("isAWTRunning", isAWTRunning());
         pauseAWT();
         assertTrue("!isAwtRunning", !isAWTRunning());
         resumeAWT();
         assertTrue("isAWTRunning", isAWTRunning());
     }
 
     /**
      * This test is more for coverage.
      * There is no access to forced wait to validate that the
      * parameter has been established.
      */
     public void testForcedWait() {
         setForcedWait(true);
         setForcedWait(false);
         resetForcedWait();
     }
 
     /**
      * Test the generation of points when the mouse is moved.
      */
     public void testCalcNextPoint() {
       Point last = new Point(0, 0);
       Point dest = new Point(30, 30);
       while (last.x != dest.x || last.y != dest.y) {
         last = TestHelper.calcNextPoint(last, dest, 10);
       }
       dest = new Point(0, 0);
       while (last.x != dest.x || last.y != dest.y) {
         last = TestHelper.calcNextPoint(last, dest, 10);
       }
       dest = new Point(-50, 50);
       while (last.x != dest.x || last.y != dest.y) {
         last = TestHelper.calcNextPoint(last, dest, 5);
       }
       dest = new Point(0, 0);
       while (last.x != dest.x || last.y != dest.y) {
         last = TestHelper.calcNextPoint(last, dest, 5);
       }
     }
 }
 