What's new in 2.08
What's new in 2.07
What's new in 2.06
What's new in 2.05
What's new in 2.04
What's new in 2.03
What's new in 2.02
What's new in 2.01
What's new in 2.00

What's new in 2.08:

  • Login Focus Example correction to use pauseAWT()/flushAWT()
  • Style Sheet correction to set foreground color.
  • AssertEqualsTagHandler java doc corrections.
  • AbstractEventData.equals() now insures classes are of same type.
  • Special thanks to those whom have submitted bugs.
  • 2.0 Branch merged with main branch.

What's new in 2.07:

  • scrolling moved to AWT Thread. Scrolling once done on the test thread has been moved to the AWT Thread. Running on the test thread could cause deadlocks in some situations where other locks are maintained by a application while running awt calls.

What's new in 2.06:

  • JInternalFrameFinderTagHandler now properly sets the class on the finder.
  • PathData now handles JSeparator appropriately.
  • JComboBoxMouseEventData for Win2K has been fixed.
  • JComboBoxMouseEventData no longer relies on a specific model.
  • JMenuMouseEventData menu now only accessed when needed.
  • AbstractMouseEventData now only populates clicks if the click count is greater than 0 and not the default value.
  • Finder.find() method now re-calculates the windows when windows are not yet shown.
  • JFCTestCase.pause() method added to allow for the pausing of a test case so that the developer may interact with the UI.

What's new in 2.05:

  • JTableMouseEventData now records the proper row.
  • pathdata element now properly configured.
  • Seucrity manager used in assert exit of the test case now delegates calls to the original security manager.
    Security manager is now only installed when assert exit is set to true.
  • Deprecated method usage have been cleaned up.
  • Many of the getShowingDialog, getWindows, ... method have been deprecated from TestHelper. Use the Finder implementations instead.
  • JFileChooserFinder has been added.
  • Link added for JBuilder plugin on installation page.
  • Finders now have methods for changing most parameters of the constructors.
  • Login Example code has been restructured removing deprecated methods.

What's new in 2.04:

  • Example test targets added. test.examples
  • Finder now has the methods for caseIndependent().
  • JPopupMenuFinder has been added.
  • Operator evaluation has been extracted from the finder so that it may be leveraged by other portions of JFCUnit.
  • Clean up all calls to deprecated methods. Most deprecated method calls have been corrected.
  • TestSwingSet now shows usage of TestSetup.
  • JComboBoxMouseEventData is now a composite event. A mouse event is now submitted to open the popup if it is not already open. Followed by a JListMouseEventData to select the item in the list.
  • Indexof XML tag has been corrected. No longer throws NPE when traversing over a null table cell.

What's new in 2.03

  • CheckStyle 3.3 integrated into build process. 
  • Now using Clover 1.2.4 for coverage of JFCUnit testing.
  • Most methods now have the final method applied to them. 
  • TestHelper.m_helper is now private must use get/setHelper().
  • WhileTagHandler added takes a test like the choose tag handler
  • TokenizeTagHandler added to break up strings.
  • Tag Handler test framework has been added to test tag handlers.
  • Testing of the Xml and xml.elements packages has been added.
  • Resolved defect dealing with the events being dropped on heavy weight components.
  • File Tag Handler now catches Out of memory exceptions.
  • File Tag handler may now be used for elements other than Suite as the root.
  • XMLExceptions now give the context of the error with reference to the XML Elements.
  • PathData can now generate TreePaths for passing to JTreeMouseEventData.
  • JTreeMouseEventDataTagHandler now has new optional attribute pathrefid. Create a path with the PathTagHandler and pass to the JTree mouse event data instead of nodeValue attribute.
  • The TestTagHandler and the SuiteTagHandlers have been standardized to take the element and the containing testcase or testsuite. Test cases are now extensible test cases other than JFCUnit TestCases can now simultaneously exist..
  • FileTagHandler now has a relative option which allows the loading of a XML file with a relative path to the current XML file.
  • Corrupted jfcunit.ppt now fixed.
  • AssertTableContains column attribute can now take a TableModel tableName or the index.
  • JTableMouseEventData can now click in the area below the table within the viewport by specifying -1, -1 as the row and column.

What's new in 2.02:

  • Enhanced finder to take a operation. The operation can be startswith, endswith, contains, equals, or match where match compares a regular expression.
  • Fix key recording to record modifiers.
  • Echo tag handler now supports a block attribute when set to false, the GUI is free to be operated upon. If set to true the dialog displayed will be modal and the GUI will not be usable until the question is answered. The default value for block is true. This may be used for manual tested or visual confirmations.
  • Recorded finders now use the Equals operator for relocating the frame. Previously the match of a RE was used and this would cause strings with special characters to fail.
  • System properties are the root of the property tree. For example: <echo message="Version: ${java.version}"/>
  • awtthread has been deprecated. awteventqueue and sleep tags are the replacements.
  • JInternalFrameFinder has been added.
  • Finder implementations now support find(int index) and find(Container c, int index). No longer need to go through the TestHelper (these have been deprecated).
  • All finders now support the wait concept. Which can be used to eliminate the need to sleep. The finds are executed if a suitable result is found then the result is returned. Otherwise the find will wait and retry the find until the wait time has elapsed. Setting the wait to zero will return immediately if no suitable objects are found.
  • Finder.setShowDebug(true) posts a Message dialog with the index, and moves the cursor to the item. (show=true on a finder XML line performs the same operation)
  • Training Power Point presentation added to docs.
  • Step size of the TestHelper is now observed. A defect caused the step size to always be 1. This caused performance issues in the tests.
  • Documentation links between docs and API's have been added.
  • Refactor Exception handling to reduce the need to declare throws Exception.
  • Robot performance improvements.

Acknowledgements, Thanks to all of those at HP whom have provided valuable feedback and testing.

What's new in 2.01:

  • XMLRoot added to interface XML test case into JUnit framework without java coding. See junit.extensions.jfcunit.tools.XMLRoot for integration options.
  • for-each tag handler added to iterate over JLists, JComboBoxes, and JTables
  • choose/when/default tag handler added to do branching logic.
  • dump tag handler added to dump the component hierarchy.
  • echo tag handler added to echo progress of test case.
  • assertenabled tag handler added.
  • asserttextfieldcontains tag handler added.
  • asserttablecellcontains tag handler added.
  • taghandlers tag handler added to allow XML to specify custom tag handlers. May be specified in both test suites and test cases.
  • indexof taghandler defined to locate listitems and table cells within components.
  • evaluate tag handler added to evaluate a method on a component using reflection. (Supports only methods with no arguments). May be used to a
  • attribute values now scanned for variable substitution from found objects variable format ${variablename}
  • fixed combo box recording.
  • fixed initial index when re-recording.
  • forced requestFocus() on the components has been removed. This caused unnecessary events generated within the UI.
  • XML Found Object repository is now scoped by the test case. Access and storage  to a parent test case/suite is possible by prefixing the name with ../. Getting objects by name will follow the scope up if the current scope does not have the value.
  • procedure tag handler added. This allows definition of procedures to perform repetitive tasks at the test suite or test case level of XML.
  • Properties tag handler added for defining properties at the test suite or test case levels. 
  • noop tag handler added to allow the canceling out of specific tags. 
  • Recording will not output attributes which are default values.
  • Recording position and modifiers are now done in text format to make the XML script more readable.
  • JMenuMouseEventData now supported for easier navigation and recording of Menu clicks.
  • PathTagHandler/PathData added to allow conversion of <string, index> to the actual index in the GUI object. 
  • setUp/tearDown procedures are called if they are defined in the test case or a parent/grandparent test suites.

What's new in 2.00:

  • XML Recording now supported. See Example
  • Asserting System Exit is now optional on the JFCTestCase.setAssertExit(true). When assertExit is true the System.exit() will throw a ExitException. This allows the exit call to be captured without causing the test case or application to exit. If state is torn down in a application prior to calling system.exit() then the test should be run in a separate JVM. These replace the former versions of setIgnoreExit().
  • Stopwatch has been added as a available TagHandler. 

What's new in 1.05:

  • Web page titles have been fixed to include jfcUnit.
  • IconMatcher which is used by several of the finders now matches icons properly.
  • Fix ClassCastException on getWindow when accessing a dialog.
  • The duration between lock checks can now be configured from the JFCTestCase or extensions of the JFCTestCase. See JFCTestCase.setLockWait(long time) and JFCTestCase.getLockWait(). This enhancement can be used to speed up GUI Testing. 

What's new in 1.04:

  • WindowMonitor now primes itself on startup with all of the windows open at the time the manager is started. This increases the ease of use by allowing applications to be started previous to the window manager starting. The window manager must still be started before any popups are displayed in HeavyWeight container. 
  • TestHelper findComponent(Class cls, int index) now works properly by traversing the open window list from the window manager. 
  • AssertNotNull now implements the proper constructor with IXMLTestCase instead of XMLTestCase. 
  • AWTThreadTagHandler now reads the appropriate attribute for Duration.
  • XMLTagResourceBundle now prints the exception consistently when encountering problems in creating resources.
  • Fix javadoc for AbstractKeyEventData, and KeyEventData these mistakenly reference Mouse events in javadoc. 
  • More examples added. Menu navigation example. How to fail a test case from another thread.
  • JFCTestCase would previously hang on a fail("..."). 
  • Fix resources for AbstractButtonFinderT, so that the resources are carried in the JAR. Previously, the images directory would need to be moved for the test cases to run properly.
  • JFCTestCase now has void setIgnoreExit(boolean) and boolean getIgnoreExit() which allow the developer to change the default behaviour of JFCUnit which ignores the exit of the application to allow the test cases to complete.

What's new in 1.03:

  • jfcUnit now supports script definitions in XML. A testing infrastructure has been built around JUnit to define the test in XML. This testing infrastructure has been extended to provide a implementation for running JFCUnit testing. The infrastructure can easily be extended by providing additional tag mappings and classes to execute. A new example has been added which shows how the XML infrastructure can be used to write test cases. 
  • jfcUnit has been refactored. The API's in the junit.extensions.jfcunit package have been split into sub packages: junit.extensions.jfcunit.eventdata contains all of the classes related to specific events. junit.extensions.jfcunit.finder contains all of the classes related to finding objects. junit.extensions.jfcunit.keyboard contains all of the keyboard related classes.
  • TestHelper now provides methods for excluding windows from the cleanUp process. addSystemWindow(regularExpressionString), removeSystemWindow(...), removeAllSystemWindows(). Sample usage would be when running inside of JBuilder: TestHelper.addSystemWindow("JBuilder"); This would prevent the cleanup from sending close messages to the JBuilder window.
  • Fixed JTreeMouseEventData to use TreeNode instead of DefaultMutableTreeNode
  • While matching patterns (search components using strings) we now specify whether the matching is case insensitive or not.
  • All sub-classes of JFCTestCase use an instance of TestHelper to perform the tests, so JFCTestCase now has a reference placeholder for it.
  • Added a new example to show how to deal with modal dialogs.
  • Regular expression matcher was created inside the 'matchPattern' method for each component being tested. This is now created once inside the Finder (in the constructor) and reused. This can lead to some amount of performance enhancement.
  • jfcUnit now has a security manager installed which will "block" calls to System.exit() while the tests are running. While running from ant's junit task, there will be stack traces showing all the places where such calls are made - and these can be ignored.
  • AbstractButtonFinder and JMenuItemFinder now support filtering components by image icons as well.

What's new in 1.02:

  • Added JBuilder Integration.
  • Created a new class (JFCUtilities) which contains goodies for Swing programmers
  • Created a new class (AbstractTestCase) so that common code between the TestHelperT and ImplTestHelperBase can be moved to a common area.
  • JSpinner support if using jdk 1.4.
  • Equals methods implemented on all XXXEventData classes.
  • A new JWindowFinder class has been added to the framework to find sub-classes of javax.swing.JWindow.
  • PopupMonitor has been moved to WindowMonitor. It now monitors all window open and close events.
  • KeyEventData which emit F2 - F9 keys incorrectly emitted F1 key.
  • Duplicated code in JFCTestHelper and RobotTestHelper have moved to TestHelper.
  • Drag and Drop now supports non-linear movement.
  • Mouse movements may entered by using enterDragAndLeave by using a modifier of '0' (zero).
  • Deprecated TestHelper methods sendString(JFCTestCase ...) and sendKeyAction(JFCTestCase ...). These have been replaced by constructor methods on StringEventData and KeyEventData. These methods will be removed in later releases.
  • Deprecated TestHelper methods enterJListClickAndLeave(...) and enterDropDownClickAndLeave(...). These have been replaced by constructor methods on JListMouseEventData and JComboBoxMouseEventData.
  • Mouse Wheel support for jdk 1.4
  • Regression Testing for jdk 1.2.2, 1.3.1, 1.4 into 'build.xml'
  • Fixed bug in calculating screen locations based on PERCENT position.

Known Bugs:

  • JPopupMenu's and their contents are not locateable in Java 1.2.2. This is due to the fact that window handles are not readily available. To work around this issue, the application must expose these to the test framework in Java 1.2.2.

What's new in 1.01:

  • jfcUnit now uses the Jakarta RegExp package set to determine matches while finding components. So you need this package as well in your classpath to run. The RegExp package uses POSIX style patterns which are explained in detail at their site.
    Caveat: Due to this addition, if the search string matches two or more components, existing tests might break.
  • KeyMappings have been introduced to allow users to create special keyboard mappings for generating International characters. See the new classes: KeyMapping, AbstractKeyMapping, and DefaultKeyMapping.
  • A JFCKeyStroke class has been introduced to aid in the processing of key events.
  • The Key events for special keys was previously broken emitting bogus key press and key release events.
  • Unix shell script counterparts to the windows batch files have been added.
  • Create unix style '*.tar.gz' files for distribution when running the 'package' target.
  • The AWT Event queue is now only stopped when it is required for safely performing tasks. Three API's have been added to the test case to help the user manage the AWT Event queue. pauseAWT() will pause the AWT Event queue until the end of the test case or the API resumeAWT() is called. The third new API flushes the AWT event queue. If the Event queue was previously paused it will resume the queue's operation.
  • It is now safe to run applications that perform invokeAndWait() on the event queue. To make sure that all events are processed, you might want to call flushAWT(), both before and after the call to SwingUtilities.invokeAndWait().
  • The drag operation has been fixed to no longer emit MOUSE_CLICK events. This caused failures of some drag operations in Java 1.4. The list of JVMs that are now supported are: jdk 1.2.2, jdk 1.3.0, jdk 1.3.1 and jdk 1.4.
  • The drag operation did not work when Window location was something other than 0,0.
  • When the isPopupTrigger is specified, the default button is now button 3.
  • Testing has been added for all XXXEventData constructors.
  • Popup modifiers were incorrectly processed causing modifier events not to be sent properly.
  • It was previously imposible to locate Menu items of a JPopupMenu when the menu was heavy weight. This has been solved by introduction of a new class PopupMonitor which monitors the event queue for popup window creations, then tracks the pointers. It is essential that the PopupMonitor.start() be called before any popup windows are opened.
  • Drag and Drop example now works properly. The drag and drop behaviors of java.awt.dnd.* are implemented in the Peer layer and are tightly coupled with the OS drag and drop support. Thus the only RobotTestHelper works with the drag and drop example.

What's new in 1.0:

  • Support for java.awt.Robot: to use this, just use junit.extensions.jfcunit.RobotTestHelper instead of junit.extensions.jfcunit.JFCTestHelper
  • New class JFCEventManager - which is used to log events (for recording and playback).
  • Added a sleep(long delay) to JFCTestCase. This forces a sleep in the test case until the delay time is reached, while allowing the AWT thread to continue processing.
  • Named the thread created in JFCTestCase to be the name of the test case to assist in better diagnosis of threading issues.
  • The test case structure has been simplified so that there is only one implementation of the test cases which is run with both the RobotTestHelper and the JFCTestHelper. JFCTestHelperT and RobotTestHelperT both extend ImplTestHelper.
  • Modified all test cases to call JFCTestCase.sleep(delay). The delay used in the JFCTestHelperT is 0. The delay used in the RobotTestHelper is 300. Shorter delays on the Robot seem to cause a missinterpretation of a event as a double click.
  • Debugging may be turned on for the test cases by setting debug=true in the ImplTestCase.

Known Bugs:

  • Key modifiers are not processed correctly if using the RobotTestHelper (only for special characters). Alphabets and numbers are still working correctly.
  • Actions on Swing components which result in invokeAndWait cause deadlock if executed from the test thread.
  • Impossible to detect menu items in a JPopupMenu.

What's new in 0.4 beta:

  • sendString() and sendKeyAction() no longer automatically call requestFocus() on the component. This was done to be able to remain consistent when supporting java.awt.Robot
  • Fixed bugs with sendString() and sendKeyAction().
  • Support for Drag and Drop - Code submitted by Kevin Wilson.
  • Firing the mouse events on the component itself instead of the ultimate parent - since the parent window itself delegates the events back to the component itself anyways.
  • Added code to fire the mouse events at the center of the components' rectangle.
  • Added a new attribute in JTreeMouseEventData for the treepath which will override the nodeValue (if present). Code submitted by Charles Lowell , ThoughtWorks, USA.
  • Modified the 'build.xml' for better javadoc creation - both api and examples.
  • All of the helper methods that deal with firing events now throw Exception - for future support with java.awt.Robot.

What's new in 0.3 beta:

  • Exposed findComponent() which accepts a Finder so that custom finders can be used.
  • All the enterXXXClickAndLeave() have been deprecated. This was done, since by adding even one more parameter, the number of overloaded copies was increasing rapidly due to number of parameter-combinations possible. There is a new data container class called AbstractMouseEventData which will be the only parameter passed in. The constructors for this class' children can be overloaded as needed with new parameters and parameter-combinations. For eg: Old code: enterDropDownClickAndLeave(arg1, arg2, arg3, arg4) New code: enterClickAndLeave(new JComboBoxMouseEventData(arg1, arg2, arg3, arg4))
  • Added jars, resources, etc for a new class which can be an example of how to use jfcUnit
  • We can now get a reference to individual tabs in a JTabbedPane using the text instead of just the index.
  • New support for modifier keys during mouse clicks.

What's new in 0.2.3 beta:

  • Added support for clicking with specifying the popupTrigger on JList.
  • Overloaded all the enterXXXClickAndLeave() methods to accept a boolean for isPopupTrigger.
  • Added a utility method getMessageFromDialog() which can be used to find the text message in a visible JDialog.
  • Overloaded getShowingDialogs() to return a list of all the dialogs for all open, visible windows.
  • disposewindow() will now dispose any open dialogs for the window specified.
  • Important:
    1. The method signatures for sendKeyAction() and sendString() have changed. This has been done so as to accept a new parameter (modifiers - of type int) to pass on to the KeyEvent and MouseEvent respectively.
    2. Specialized support for each class in ComponentFinder will be removed - this can become unwieldy VERY quickly.
    3. TestHelper.enterClickAndLeave() will be removed which would accept a buttonLabel - due to above (specialized handling - should not be done in a framework).
    4. Exposed the findComponent() method accepting a Finder so that the user can extend Finder and put in their specialized handling there and call this method.
    Sorry for the sudden change in the API.
  • Overloaded getShowingDialogs() so that only the title of the required dialog is enough to find it. Also handles a sub-string of the actual title.
  • Extracted some methods into an abstract super class (TestHelper) so that anyone wanting to implement using java.awt.Robot can extend from that super class.
  • Used a method setNumRows() instead of setRowCount() so that it is compatible with jdk 1.2.2
  • The api docs are zipped up - so that the distribution zip is smaller. If anyone is interested, they can unzip the docs.
  • Overloaded sendString() so as to work without needing the awtSleepTime().

What's new in 0.2.2 beta:

  • Added new method to JFCTestHelper to handle sending key action events to specified components.
  • Support for mouse clicks (including multi-clicks) on JTable cells and column header cells.
  • Support for mouse clicks (including multi-clicks) on JTabbedPane.
  • Tests for new functionality in JFCTestHelper
  • Added tests to show that the generic enterClickAndLeave() method is enough for mouse events on JRadioButton, JCheckBox, JToggleButton.
  • Removed custom event queue listener which was used to listen to window open/close events to keep track of opened windows. Now we use 'Frame.getFrames()'.
  • The sleep time specified while calling awtSleep() is now the maximum sleep time. So the thread will not sleep for that period if the event has already been posted. This improves performance a lot.
  • There is a new method: setForcedWait(boolean forcedWait) which can be used to force the thread to wait for the time specified in the call to awtSleep()
  • All methods in JFCTestHelper are now instance methods.
  • A test-development tool has been included in the junit.extensions.jfcunit.tools package.
  • Fixed a bug in getJFileChoosers() where a component would be included in the return list only if the component hierarchy of the container dialog followed a set pattern.
  • Added windows batch files used for building the package.

What's new in 0.2.1 pre-beta:

  • Overloaded methods to work without accepting awtsleeptime in JFCTestHelper
  • Overloaded enterDropDownClickAndLeave() method to process by either index or element itself.
  • Don't call awtSleep() if sending multiple events - do it once at the end.
  • Generate javadoc for api while running 'package' target in 'build.xml'.
  • Bug: enterJTreeClickAndLeave: Needed the node to be currently selected one: Code now accepts the node's userObject and tries to find the node using that. If found, it sets the selected node/path on the tree and then performs the mouse click event.
  • Removed custom event queue which was replacing the AWTEventQueue. Now other apps which need to replace the AWTEventQueue with their own version can also use jfcUnit for testing of their Swing classes.
  • Tests: All methods in JFCTestHelper now have unit tests.

What's new in 0.2 pre-beta:

  • Fixed bug: getWindows() does not check for component being null
  • Method overloading: Methods with the same names, but different signatures now call one of the others (the main one) with default values for the missing parameters. So, behavior will remain consistent
  • Multiple if (comp.isShowing() checks have been replaced with a single check - at the beginning of the method. This has decreased (DONT KNOW HOW MUCH) the time for the method to return.
  • Incorporated a method for multi-clicking of a Component.
  • Tests: A bunch of the methods in JFCTestHelper now have unit tests.
  • Added new methods in JFCTestHelper.
  • Upgraded 'build.xml' to use Ant ver 1.4
  • Upgraded JFCTestHelperT to use jUnit ver 3.7
  • General code cleanup