Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

abbot.converter.* (6)abbot.editor.* (73)abbot.i18n.* (1)abbot.script.* (32)
abbot.tester.* (45)abbot.util.* (9)

abbot: Javadoc index of package abbot.

Package Samples:

abbot.tester.extensions: Miscellaneous examples demonstrating Abbot usage.  
abbot.editor.actions: Provides support for editing Abbot test scripts.  
abbot.editor.recorder: Provides support for editing Abbot test scripts.  
abbot.converter: Provide testing support for Java GUIs.  
abbot.editor: Provide testing support for Java GUIs.  
abbot.i18n: Provide testing support for Java GUIs.  
abbot.util: Provide testing support for Java GUIs.  


ComponentTester: Provide basic actions and assertions for anything of class Component. Derive from this class to implement actions and assertions specific to a given component class. Actions are generally user-driven actions such as menu selection, table selection, popup menus, etc. Assertions are either independent of any component (and should be implemented in this class), or take a component as the first argument, and perform some check on that component. Testers for any classes found in the JRE should be in the abbot.tester package. Extensions (testers for any Component subclasses not found in the JRE) must ...
Launch: Provides scripted static method invocation. Usage: <launch class="package.class" method="methodName" args="..." [classpath="..."] [delegate=false] [threaded=true]> The args attribute is a comma-separated list of arguments to pass to the class method, and may use square brackets to denote an array, e.g. "[one,two,three]" will be interpreted as an array length 3 of String. The square brackets may be escapted ('\[' or '\]') to include them literally in an argument. The class path attribute may use either colon or semicolon as a path separator, but should preferably use relative paths to avoid ...
ComponentRecorder: Record basic semantic events you might find on any component. This class handles the following actions: window actions popup menus click (based on coordinates) typed keys basic drag and drop (based on coordinates) InputMethod events (extended character input) Window Actions While these nominally might be handled in a WindowRecorder, they are so common that it's easier to handle here instead. Currently supports tracking show/hide/activate. TODO: move/resize/iconfify/deiconify. Popup Menus Currently only the click/select/click sequence is supported. The press/drag/release version shouldn't be hard ...
Log: Various logging, assertion, and debug routines. Typical usage is to include the following code public static void main(String[] args) {   args = Log.init(args)   ... } at an application's main entry point. This way the Log class can remove its options from the full set passed into the application. See the Log.init method for initialization options. General usage notes on public functions: warn Programmer warnings; things that you think shouldn't be happening or indicate something might be wrong. Warnings typically mean "Something happened that I didn't expect would happen". log Important ...
Assert: Encapsulate an assertion (or a wait). Usage: <assert method="[!]assertXXX" args="..." [class="..."]> <assert method="[!](get|is|has)XXX" component="component_id" value="..."> <wait ... [timeout="..."] [pollInterval="..."]> The first instance invokes a core assertion provided by the ComponentTester class; the class tag is required for assertions based on a class derived from ComponentTester; the class tag indicates the Component class, not the Tester class (the appropriate tester class will be derived automatically). The second format indicates a property check on the given component, ...
Action: Encapsulate an action. Usage: <action method="..." args="..."> <action method="..." args="component_id[,...]" class="..."> An Action reproduces a user semantic action (such as a mouse click, menu selection, or drag/drop action) on a particular component. The id of the component being operated on must be the first argument, and the class of that component must be identified by the class tag if the action is not provided by the base ComponentTester class. Note that the method name is the name of the actionXXX method, e.g. to click a button (actionClick on AbstractButtonTester), the XML ...
Robot: Provide a higher level of abstraction for user input (A Better Robot). The Robot's operation may be affected by the following properties: abbot.robot.auto_delay Set this to a value representing the millisecond count in between generated events. Usually just set to 100-200 if you want to slow down the playback to simulate actual user input. The default is zero delay. NOTE: Only use invokeAndWait when a subsequent robot-level action is being applied to the results of a prior action (e.g. focus, deiconify, menu selection). Otherwise, don't introduce a mandatory delay. NOTE: If a robot action isn't ...
AppClassLoader: A custom class loader which installs itself as if it were the application class loader, optionally preloading all classes. A classpath of null is equivalent to the system property java.class.path. The class loader may optionally load a class before the parent class loader gets a chance to look for the class (instead of the default behavior, which always delegates to the parent class loader first). This behavior enables the class to be reloaded simply by using a new instance of this class loader. This class mimics the behavior of sun.misc.Launcher$AppClassLoader as much as possible. Bootstrap classes ...
ComponentReference: Encapsulate as much information as is available to identify a GUI component. Usage: <component id="..." class="..." [...]> A number of optional tags are supported to provide an increasingly precise specification of the desired component: tag a class-specific identifier, e.g. the label on a JButton. name the Component name, as set by setName() . Note that auto-generated names for windows and frames are ignored and are considered to be null. parent the reference id of this component's parent. (This list subject to change as required by the DefaultComponentFinder ).
Recorder: The Recorder provides a mechanism for recording an event stream and generating one or more script steps from that stream. The base abstract Recorder class handles the logistics of capturing the events, cancellation and termination with proper synchronization. The concrete implementation tracks the individual events to produce the desired high level user action representations. NOTE: when writing a recorder, be very careful not to test for platform-specific behavior, and avoid being susceptible to platform-specific bugs. Please make sure the recorder works on both pointer-focus and click-to-focus ...
Converter: This interface provides a method for converting a String into some destination class type. This interface was designed as an extensible method of converting Strings into arbitrary target classes when parsing scripted arguments to methods. When a script is run and a method is resolved, the String arguments are converted to the classes required for the method invocation. Built-in conversions are provided for component references and all the basic types, including arrays. You might, for instance, write a Converter that takes some ID code and converts it to some data internal to your application.
Script: Provide a structure to encapsulate actions invoked on GUI components and tests performed on those components. Scripts need to be short and concise (and therefore easy to read/write). Extensions don't have to be. This takes a single filename as a constructor argument. Use ScriptTestCase and ScriptTestSuite to generate a suite (auto-generate the collection).
SemanticRecorder: Template for recording AWTEvents and converting them into an appropriate semantic event. The EventRecorder class decides which SemanticRecorder to use and handles cancel/termination. Implementations should be named AbstractButtonRecorder, JTableRecorder, etc. The semantic recorders will be dynamically loaded based on the component receiving a given event (compare to ComponentTester). See EventRecorder for implementation details.
EventRecorderTest: Unit test to verify proper capture of multiple user semantic events when parsed from a continuous event stream. FIXME add support to feed the event recorder an event sequence and have it do its cleanup FIXME add support to feed the event recorder an event sequence to record Still want to do the robot generation, 'cuz that'll catch errors on new platforms. Specific event sequences avoid having to throw up an IF.
ArgumentParser: Provide parsing of a String into an array of appropriately typed arguments. Arrays are indicated by square brackets, and arguments are separated by commas, e.g. An empty String array (length zero): "[]" Three arguments "one,two,three" An array of three arguments, with embedded comma: "[one\,one,two,three]" An argument with square brackets: "\[one\]" A single null argument: "null"
Step: Provides access to one step (line) from a script. A Step is the basic unit of execution. All derived classes should have a tag "sampleStep" with a corresponding class abbot.script.SampleStep. The class must supply at least a Constructor with the signature SampleStep(Resolver, HashMap). If the step has contents (e.g. Sequence), then it should also provide SampleStep(Resolver, Element, HashMap).
ScriptEditor: Costello, the editor for Abbot scripts. Acts as a resolver, using the currently in-context script as the component resolver. WARNING: The script editor must never spawn threads or load classes from the event dispatch thread while a script is either running or has been lauched, or risk having its classes loaded by the wrong class loader.
TesterTestSuite: Test suite of all available tests for ComponentTester classes. Note that the tester tests are set up to run multiple times when run standalone (the main method is invoked). This makes it easy to stress-test the tester to expose timing-related issues, while not overburdening the main suite() method used here.
EditorConstants: Common constants for editor actions. NOTE: to add a new editor action, define a constant for it here, add an action for it in abbot.editor.action.EditorActions, create a menu for it in ScriptEditorFrame, and handle it in ScriptEditor. I know that's a lot of entries, I'd like to clean it up.
ComponentRecorderTest: Unit test to verify proper capture of basic user semantic events. A ComponentTester is used to generate the appropriate events, which is significantly easier than reproducing the steps manually. These tests should be run after the ComponentTester tests.
PathClassLoader: Provide a class loader that loads from a custom path. Similar to sun.misc.Launcher$AppClassLoader (the usual application class loader), except that it doesn't do the security checks that AppClassLoader does. If path given is null, uses java.class.path.
EventExceptionHandler: Handler for uncaught exceptions on any event dispatch thread. Once this has been installed, it must be accessible by any subsequently launched dispatch thread. This handler is installed by setting the property sun.awt.exception.handler.
KeyStrokeMap: Map characters to the keycodes (and modifiers) required to generate them. FIXME OSX generates key_typed events for control and alt characters; other platforms might as well, so there needs to be a keystroke map entry for those characters.
TestSelector: A test class selector. A simple dialog to pick the name of a test suite. Thanks to JUnit for this code. FIXME this currently doesn't scan jar files, only bare classes, and depends on the class path established at application launch.
ReferencesModel: Formats a Script for display in a table. Keeps track of "open" nodes to create a tree-like display NOTE: this is a brute-force implementation with no attempts at optimization. But it's a very simple tree+table implementation.

Home | Contact Us | Privacy Policy | Terms of Service