<html>
<head>
<title>Jubula 1.1.0 Release Documentation</title>
</head>
<h1>Jubula 1.1.0 Release Documentation</h1>
<h1>Content</h1>
This pages provide the required docuware for the Jubula 1.1.0
Release Review as part of the upcoming Indigo SR1
Release
<br> Contact: Achim L&ouml;rke (Achim.Loerke@bredex.de)
<br> Release Review: September 2011
<br> Communication Channels: 
<ul>
<li>Eclipse Bugzilla</li>
<li>Jubula Newsgroup</li>
<li>Jubula Mailing List jubula-dev@eclipse.org
</ul>
<br> Process Documentation :
http://www.eclipse.org/projects/dev_process/development_process.php
<h1>Overview</h1>
<p>Jubula provides automated functional GUI testing for Java and HTML
applications. It is aimed at teams who want their automated tests to be written by 
test experts from the user perspective, without requiring any coding effort. Jubula 
tests incorporate best practices from software development to ensure long-term 
maintainablity of the automated tests.  
</p>
Technical details
<ul>
<li>Supports Swing, SWT/RCP/GEF and HTML applications</li>
<li>Platform independent testing on Windows, Linux/Unix and Mac</li>
<li>Client-server architecture for distributed testing</li>
<li>Heuristic object recognition</li>
<li>Command line client for continuous integration</li>
<li>Testing of multiple applications supported</li>
<li>Context-sensitive help in client</li>
<li>Projects stored in multi-user database</li>
<li>Portability and version control via exports in XML format</li>
</ul>

<h1>Features</h1>
This release of Jubula enables developers to view and develop GUI based
tests. It also allows interaction with the test infrastructure and 
execution of test suites.
<p>
New in the 1.1.0 release:
<ul>
<li>The AUTagent used for controlling AUTs has been repackaged as Equinox 
bundles. The application itself is now an Equinox app. The bundles have been
included in the Jubula feature. This allows controlling the AUT from inside
an IDE or from the Eclipse for Testers package.
</li>
<li>The Remote Control components (which are used to instrument the AUT)
are now packaged as OSGi bundles.</li>
<li>The AUTrun application has been repacked as an Equinox application.</li>
<li>Launch Configurations for Swing and RCP applications have been provided
as new optional features. They allow starting AUTs from inside a Java or RCP
development IDEs with the instrumentation for test execution applied.</li>
<li>Refactoring of Test Cases has been extended. It is now possible to
change the tests signature during refactoring.</li>
<li>The Migration Wizard for database updates between version has been re-enabled
and now supports EclipseLink/JPA.</li>
</ul>
</p>
<h1>Non-Code Aspects</h1>
Documentation, Cheat Sheets and Online Help have been provided to 
allow beginners a painless start.
<h1>Testing and Packaging</h1>
Jubula is build using Hudson, Maven and Tycho.
<br>
Since Jubula is a GUI test tool it is tested by itself. There are 
currently about 7000 high level test steps executed for a complete test. This
test include happy path checking, low level GUI component checking and
cross application checks. All tests are performed nightly on five test
instances covering MS Windows XP, Vista and 7, CentOS 5.5 
and Mac OSX 10.6.
<br>
Jubula is part of the Indigo Release Train and maintains a Testing Package
at the EPP.
<br>
The EPP Testing package itself is tested by Jubula. There is a proposal
from the Jubula team to develop and maintain tests for other interested
EPP packages.

<h1>Community and Support</h1>
<ul>
	<li>Eclipse Forum: about 10 entries per day</li>

	<li>Mailing Lists:
		<ul>
			<li>jubula-dev@eclipse.org</li>
			<li>Agile Testing, Agile Functional Testing Tools @ Yahoo Groups
			</li>
		</ul>
	<li>blog.bredex.de syndicated at Planet Eclipse</li>
</ul>

<h2>Bugzilla</h2>
Current state:
<!-- 
<br>
<img alt="Bugzilla Diagram" src="./bugzilla.png" width="600">
<br>
 -->
<a href="https://bugs.eclipse.org/bugs/report.cgi?x_axis_field=bug_status&y_axis_field=bug_severity&z_axis_field=&query_format=report-table&short_desc_type=allwordssubstr&short_desc=&classification=Technology&product=Jubula&longdesc_type=allwordssubstr&longdesc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=&bug_severity=blocker&bug_severity=critical&bug_severity=major&bug_severity=normal&bug_severity=minor&bug_severity=trivial&emailtype1=substring&email1=&emailtype2=substring&email2=&bug_id_type=anyexact&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&format=table&action=wrap&field0-0-0=noop&type0-0-0=noop&value0-0-0=">Link to Bugzilla entries, will be replaced with table on final version</a>

<h1>IP Issues</h1>
The component leadership verifies that:
<br>
<ul>
	<li>the about files and use licenses are in place as per the
		Guidelines to Legal Documentation.</li>
	<li>all contributions (code, documentation, images, etc) have been
		committed by individuals who are either Members of the Foundation, or
		have signed the appropriate Committer Agreement. In either case, these
		are individuals who have signed, and are abiding by, the Eclipse IP
		Policy.</li>
	<li>all significant contributions have been reviewed by the
		Foundation's legal staff.</li>
	<li>all non-Committer code contributions, including third-party
		libraries, have been documented in the release and reviewed by the
		Foundation's legal staff.</li>
	<li>all Contribution Questionnaires have been completed.</li>
</ul>
The Jubula IP Log is available from <br>
<a href="http://www.eclipse.org/projects/ip_log.php?projectid=technology.jubula">http://www.eclipse.org/projects/ip_log.php?projectid=technology.jubula</a>
<h1>Contributors and Committers</h1>
Contributors:
<table>
<tr><td>Marc Steffens</td><td>Ostfalia Hochschule f&uuml;r angewandte Wissenschaften</td></tr>
<tr><td>Marcel Salvage</td><td>Ostfalia Hochschule f&uuml;r angewandte Wissenschaften</td></tr>
<tr><td>Tobias Eiss</td><td>BREDEX GmbH</td></tr>
</table>
<p></p>
Committers:
<table>
<tr><td>Zeb Ford-Reitz</td><td>BREDEX GmbH</td></tr>
<tr><td>Alexandra Imrie</td><td>BREDEX GmbH</td></tr>
<tr><td>Achim L&ouml;rke</td><td>BREDEX GmbH</td></tr>
<tr><td>Tim Winselmann</td><td>BREDEX GmbH</td></tr>
<tr><td>Markus Tiede</td><td>BREDEX GmbH</td></tr>
</table>
<h1>Project Plan</h1>
The current project plan is available from <br>
<a href="http://www.eclipse.org/projects/project-plan.php?projectid=technology.jubula">http://www.eclipse.org/projects/project-plan.php?projectid=technology.jubula</a>
</html>