Jubula vs QF-Test

Jubula is a free tool for functional testing through the GUI. It supports Java (Swing,SWT,RCP) and HTML as well as .NET and mobile testing. Test specification with Jubula does not involve writing any code, nor are tests recorded. Instead, a powerful library of reusable keywords is provided.

QFTest is an automated testing tool to create automated regression and load tests for Swing, SWT, Eclipse plugins and RCP applications, ULC, CaptainCasa, Java applets and Java WebStart - on Windows and Unix

Below table summarizes the feature differences between Jubula and QF-Test.  You can see the details below.

Feature	Jubula	QF-Test
Test Execution Debugging	No	Yes
Regular Expression	Yes	Yes
Recording	Yes	Yes
Loops	No(Can be done but not always)	Yes
Try/Catch	Yes (but not at step level)	Yes
Exception types	Limited	Detailed
If/elseif/else	No (it can be done though)	Yes
Procedures	No	Yes
Components as parameters	No (Can use unbound modules)	Yes
Documentation of testcases	Not	Yes
Speed	Fast	Mostly Faster
Multiple application under test	No	Yes
Distributed Test Development	Yes	Yes
Command Line Testing	Yes	Yes
Scripting	Yes (Python)	Yes(Jython and groovy)
Host OS	Windows, Linux, MAC OSX	Windows and Linux

Test Execution Debugging:

Jubula: No debugging support is available in jubula.

    Test execution can be set to pause on errors or by inserting “Application->Pause Test Execution” anywhere in a test case.  This is analogous to setting a breakpoint in a conventional programing debug session.  You can then examine or change the AUT state if required and resume execution from that point.

QF-Test: Complete debugging support is available in QF-Test.

Regular Expression:

               Both tools support regular expression.

Recording

               Both tools support recording.

Control structures

               Jubula: It doesn’t have loops and it is not always possible to implement all types of loops. Jubula doesn’t support if/else but we can implement it using event handlers but no support for if/else or nested elseif.

Jubula does not have any scripting language (no if/else/for/while, etc.).  You can loop any test case using data sets.  You can simulate conditional test case execution using event handlers.  This may be regarded as pro and not a con since there isn't any confusing code to maintain, learn, document, etc., etc…

               QF-Test: It supports all types of control structures (for and while loops, if/else/elseif, break, try/catch/throw/rethrow).

Try/Catch

               Jubula: It doesn't support try/catch at each step level but only at test case level..

               QF-Test: It supports try/catch at each level.

Exception Types:

               Jubula: It supports only 4 types of exceptions.

               QF-Test: It supports detailed exceptions.

Procedures:

               Jubula: Doesn't support procedures.

                         Workaround : Test cases can be thought of as procedures.  They can be referenced from other test cases.  Jubula also supports variables so a test case can set a variable if you want to return a value.

               

               QF-Test: Supports procedures which can return values.

Components as Parametes:

               Jubula: It doesn’t allow passing component name as parameters.

This may be called as good.  That means that when a particular GUI component changes that will not break every test case.

               QF-Test: It allows components to be passed as parameters to procedures.

Test Case Documentation

               Jubula: No support to document test cases.

This can be counted as pro or strength.  The keyword-driven approach lets testers design, automate and maintain tests by dragging and dropping from a library of test actions. Test creation is quick and code-free, tests are easy to read, and the modular structure makes them easy to maintain (despite changes in the application GUI).  Also test cases have a comment field that can be used for documentation purposes…

               QF-Test: Has option to create docs similar to javadoc for testcases.

Multiple Applications under Test:

               Jubula: Supports multiple AUTs. The AUT agent supports a non-strict mode that can be used when an AUT starts other AUTs and that also need to be tested.  There is also the option to start multiple AUT agents on different ports and therefore different AUTs can be started and tested that way or on multiple machines for distributed testing.

               QF-Test: Supports multiple applications testing simultaneously.

Distributed Test Development:

               Both tools don’t support it fully but QF-Test documentation mentions a way to achieve it.