package junit.extensions.abbot;

 import java.awt.*;

 import java.awt.event.*;

 import java.lang.reflect.*;

 import java.util.Iterator;

 import javax.swing.*;

 import javax.swing.border.EmptyBorder;

 import junit.framework.TestCase;

 import abbot.*;

 import abbot.finder.*;

 import abbot.finder.ComponentFinder;

 import abbot.finder.matchers.*;

 import abbot.script.*;

 import abbot.script.Resolver;

 import abbot.tester.*;

 import abbot.tester.Robot;

 import abbot.util.*;

 /** Simple wrapper for testing components under JUnit.  Ensures proper setup

  * and cleanup for a GUI environment.  Provides methods for automatically

  * placing a GUI component within a frame and properly handling Window

  * showing/hiding (including modal dialogs).  Catches exceptions thrown on the

  * event dispatch thread and rethrows them as test failures.<p> 

  * Use {@link #showFrame(Component)}

  * when testing individual components, or 

  * {@link #showWindow(Window)}

  * when testing a {@link Frame}, {@link Dialog}, or {@link Window}.<p>

  * Any member fields you define which are classes derived from any of the

  * classes in {@link #DISPOSE_CLASSES} will be automatically set to null after

  * the test is run.<p>

  * <bold>WARNING:</bold> Any tests which use significant or scarce resources

  * and reference them in member fields should explicitly null those fields in

  * the tearDown method.  Otherwise the resources will not be subject to GC

  * until the {@link TestCase} itself and any containing

  * {@link junit.framework.TestSuite} is 

  * disposed (which, in the case of the standard JUnit test runners, is

  * <i>never</i>). 

  */

     /** Typical delay to wait for a robot event to be translated into a Java

         event. */

     public static final int EVENT_GENERATION_DELAY = 5000;

     public static final int WINDOW_DELAY = 20000; // for slow systems

     public static final int POPUP_DELAY = 10000;

     /** Any member data derived from these classes will be automatically set

         to <code>null</code> after the test has run.  This enables GC of said

         classes without GC of the test itself (the default JUnit runners never

         release their references to the tests) or requiring explicit

         <code>null</code>-setting in the {@link TestCase#tearDown()} method.

     */

     protected static final Class[] DISPOSE_CLASSES = {

         Component.class,

         ComponentTester.class

     };

     private static Robot robot;

     private static WindowTracker tracker;

     private AWTFixtureHelper savedState;

     private Throwable edtException;

     private long edtExceptionTime;

     /** Return an Abbot {@link abbot.tester.Robot} for basic event generation.

      */ 

     /** Return a WindowTracker instance. */

     /** This method should be invoked to display the component under test.

      * The frame's size will be its preferred size.  This method will return

      * with the enclosing {@link Frame} is showing and ready for input.

      */

     }

     /** This method should be invoked to display the component under test,

      * when a specific size of frame is desired.  The method will return when

      * the enclosing {@link Frame} is showing and ready for input.  

      * @param comp

      * @param size Desired size of the enclosing frame, or <code>null</code>

      * to make no explicit adjustments to its size.

      */

     }

     /** Safely display a window with proper EDT synchronization.   This method

      * blocks until the {@link Window} is showing and ready for input.

      */

     }

     /** Safely display a window with proper EDT synchronization.   This method

      * blocks until the {@link Window} is showing and ready for input.

      */

     }

     /** Safely display a window with proper EDT synchronization.   This method

      * blocks until the window is showing.  This method will return even when

      * the window is a modal dialog, since the show method is called on the

      * event dispatch thread.  The window will be packed if the pack flag is

      * set, and set to the given size if it is non-<code>null</code>.<p>

      * Modal dialogs may be shown with this method without blocking.

      */

                               final boolean pack) {

                     // Make sure the window is positioned away from

                     // any toolbars around the display borders

                 }

             }

         });

         // Ensure the window is visible before returning

     }

     /** Return when the window is ready for input or times out waiting.

      * @param w

      */

                                            + " (" + timer.elapsed() + "ms)");

         }

     }

     /** Synchronous, safe hide of a window.  The window is ensured to be

      * hidden ({@link java.awt.event.ComponentEvent#COMPONENT_HIDDEN} or

      * equivalent has been posted) when this method returns.  Note that this

      * will <em>not</em> trigger a 

      * {@link java.awt.event.WindowEvent#WINDOW_CLOSING} event; use

      * {@link abbot.tester.WindowTester#actionClose(Component)}

      * if a window manager window close operation is required. 

      */

             }

         });

         // Not strictly required, but if a test is depending on a window

         // event listener's actions on window hide/close, better to wait.

     }

     /** Synchronous, safe dispose of a window.  The window is ensured to be

      * disposed ({@link java.awt.event.WindowEvent#WINDOW_CLOSED} has been

      * posted) when this method returns. 

      */

     }

     /** Install the given popup on the given component.  Takes care of

      * installing the appropriate mouse handler to activate the popup.

      */

             }

                 }

             }

         });

     }

     /** Safely install and display a popup in the center of the given

      * component, returning when it is visible.  Does not install any mouse

      * handlers not generate any mouse events. 

      */

     }

     /** Safely install and display a popup, returning when it is visible.

         Does not install any mouse handlers not generate any mouse events.

      */

                              final int x, final int y) {

             }

         });

         }

     }

     /** Display a modal dialog and wait for it to show.  Useful for things

      * like {@link JFileChooser#showOpenDialog(Component)} or

      * {@link JOptionPane#showInputDialog(Component,Object)}, or any

      * other instance where the dialog contents are not predefined and

      * displaying the dialog involves anything more than 

      * {@link Window#show()} (if {@link Window#show()} is all that is

      * required, use the {@link #showWindow(Window)} method instead).<p>

      * The given {@link Runnable} should contain the code which will show the

      * modal {@link Dialog} (and thus block); it will be run on the event

      * dispatch thread.<p>

      * This method will return when a {@link Dialog} becomes visible which

      * contains the given component (which may be any component which will

      * appear on the {@link Dialog}), or the standard timeout (10s) is

      * reached, at which point a {@link RuntimeException} will be thrown.<p>

      * For example,<br>

      <pre><code>

      Frame parent = ...;

      showModalDialog(new Runnable) {

          public void run() {

              JOptionPane.showInputDialog(parent, "Hit me");

          }

      });

      </code></pre> 

      @see #showWindow(java.awt.Window)

      @see #showWindow(java.awt.Window,java.awt.Dimension)

      @see #showWindow(java.awt.Window,java.awt.Dimension,boolean)

      */

         // Wait for a modal dialog to appear

                     && ((Dialog)c).isModal();

             }

         };

             }

             catch(ComponentSearchException e) {

             }

         }

     }

     /** Similar to {@link #showModalDialog(Runnable)},

      * but provides for the case where some of the {@link Dialog}'s contents

      * are known beforehand.<p>

      * @deprecated Use {@link #showModalDialog(Runnable)} instead.

      */

         throws Exception {

     }

     /** Returns whether a Component is showing.  The ID may be the component

      * name or, in the case of a Frame or Dialog, the title.  Regular

      * expressions may be used, but must be delimited by slashes, e.g. /expr/.

      * Returns if one or more matches is found.

      */

         }

         catch(ComponentNotFoundException e) {

         }

         catch(MultipleComponentsFoundException m) {

             // Might not be the one you want, but that's what the docs say

         }

     }

     /** Construct a test case with the given name.  */

     }

     /** Default Constructor.  The name will be automatically set from the

         selected test method.

     */ 

     /** Ensure proper test harness setup and teardown that won't

      * be inadvertently overridden by a derived class. 

      */

     }

     /** Handles restoration of system state.  Automatically disposes of any

         Components used in the test.

     */

             }

             // TODO: release any extant pressed keys

         }

     }

     /** Clears all non-static {@link TestCase} fields which are instances of

      * any class found in {@link #DISPOSE_CLASSES}.

      */

                         }

                     }

                 }

             }

         }

         catch(Exception e) {

         }

     }

     /** If any exceptions are thrown on the event dispatch thread, they count

         as errors.  They will not, however supersede any failures/errors

         thrown by the test itself.

     */

         }

         catch(Throwable e) {

         }

         finally {

             // Cf. StepRunner.runStep()

             // Any EDT exception which occurred *prior* to when the

             // exception on the main thread was thrown should be used

             // instead.

                 && (exception == null

                     || edtExceptionTime < exceptionTime)) {

                 // TODO wrap this somehow with an additional message that

                 // says "this was thrown on the EDT"

             }

         }

         }

     }

 }