Marathon is a simple, flexible and extendable tool that assists in developing automated test suites for Java/Swing applications. Marathon provides an integrated environment in which you can create test suites. Marathon consists of a recorder, player, debugger and an editor. Marathon records test scripts in a language of your choice - either python or ruby. The power of whole script runtime is at the disposal of the testing professionals.

Marathon is used mainly for automating functional tests (also called as acceptance tests, end user tests or customer tests), though it can also be used to create developer test suites. Marathon, by itself, adds only a few well defined c

onstructs to the script runtime. It is possible to develop Marathon tests even before an application is fully developed.

Built for flexibility

Marathon is designed and developed to be the most flexible testing framework.

Using a vendor neutral scripting language allows you to inspect and act on almost any aspect of the application under test. Use Marathon's simple scripting elements to access the components available on the current screen. Use the control structures and conditional statements provided by the scripting language to automate any and all actions of your application. Where Marathon does not support one of your custom components, you can access the component directly and perform actions on it, lack of support for a component does not stop your test project.

Simple design

Built by people who are experts and interested in agile methodologies, Marathon embodies the value of simplicity. One of the primary goals of Marathon is the ability to write test cases even before the application under test is built. Marathon, itself, adds only a handful of well defined scripting elements to the script runtime - either Jython or JRuby.

Setting up Marathon to record scripts with your application is a breeze. Just create a new project, add required class path, set up the main class. Click ‘Record’ and start recording the scripts. When you need to run all the tests, use JUnit view to run all the tests and generate a report.

Cross platform

Marathon supports any platform where JDK 1.5+ is available. You can optionally choose to fire an appropriate command key code (Command on Mac and Control on Others) even when the script is recorded with Control or Command key depending on the recording platform.

Though you need Java 5 to use Marathon, you can still test your applications with Java 1.4.2.

Configurable desktop

Use the docking features of Marathon to configure your testing environment the way you want it.

Syntax aware editor

Marathon uses the text area package from jEdit editor for providing editing functionalities. Almost any aspect of the look and feel of the editor can be changed using Marathon preferences and editor settings. You can override the default keyboard shortcuts, setup folding to see the visual structure of your script code.

Color coded output pane

All output from the application under test is captured in an dockable output pane. The output is color coded to distinguish between standard error and standard output streams. The output pane can be optionally hidden.

Batch running of tests

You can execute Marathon test cases through the UI by using the JUnit view. Marathon’s JUnit view displays the tests in a hierarchical layout. Options are available to select a set of test cases and execute them as a single test suite or executing individual test cases. A command line option provides the facility to execute the tests as a batch.

Once your tests are run, you can generate a report from Marathon itself. The report is generated in HTML or text format depending on your system configuration.

Integrate testrunner into the build system

With some little effort, Marathon can be integrated into your current build system. Whichever tool you use - ant, maven, cruise control - it is trivial to integrate Marathon into your build system.

Check the User’s guide for details of how an ant build script can be written for running Marathon test suites. For those stubborn cases, Marathon can be executed in a batch mode and be used in a shell script.

Test reports

Marathon can create test reports in multiple formats - text, XML or HTML. Provide an option while running tests in batch mode, come back and check the report for errors. From the JUnit panel, select the test report option and Marathon will display a cleanly formatted report in your browser for the test run. Options are available for requesting Marathon to automatically generate screen shots whenever a test case fails. This will aid in diagnosing the problem and also for filing a bug report.

Reusable modules

Marathon supports the concept of Modules, ability to create a library of snippets from the recorded scripts. These snippets can be used while recording new test cases and can be shared across test cases. You can use any script function in the snippets (and for that matter in the test scripts).

Creating testing environment

A reproducible test case requires setting up proper environment. Marathon uses the concept of Fixtures borrowed from the xUnit family. Use fixtures to setup the initial environment for a test (like copying a file, setting up a database etc.). A fixture can be shared among multiple test cases. Marathon provides an easy mechanism for selecting an appropriate fixture when the recording is started.

Extending Marathon

You can extend Marathon to support custom components by developing component resolvers. Samples of component resolvers are provided in Marathon source distribution. Use them as a starting point. Marathon naming strategy should suffice for most cases. Where required a custom Naming Strategy can be used.

LINKS

Integrated Debugger

Marathon allows you run the scripts in debug mode. You can set breakpoints, step through the script line by line and inspect the application using script console.

Script Console

Anytime during recording a test script or when the play back is paused at a break point, you

can invoke the script console.

At the script console prompt, you can execute any script commands. These commands are evaluated in the application context, providing ability to inspect any aspect of the running application. Use Marathon script elements at the script console to access a component or any other script function.

Additional Script Models

Marathon uses a plugin model for identifying and using script models. Additional script models can be created by implementing some well defined interfaces and adding to Marathon. Once a model is added to Marathon, you can create scripts using the new script runtime. For details look at the User’s Guide.

(C) Jalian Systems 2008