We are proud to announce the release of FEST-Swing 1.2a1!
FEST-Swing is a Java library that provides a fluent interface for functional Swing GUI testing. This library provides an easy-to-use API that makes creation and maintenance of GUI tests easy.
This is the first out of three alpha and three beta releases planned for version 1.2. This new version focuses on new features and improvements.
More details, please read the release notes.
Concordion is an open source tool for writing automated acceptance tests in Java.
"It’s similar to the Fit Framework but a lot more intuitive."
Kent Beck has released JUnitMax for Eclipse as paid beta – currently USD $2/month. JUnitMax is a selective testing tool – it chooses a subset of tests to run so you get feedback very fast. I especially like the fact that the results are written into the same window as compiler failures. Think of JUnitMax as the twin sister of the incremental compiler.
I’ve tested it with the latest version of Apache Commons Collections and it works quite well. Of course its usefulness depends on whether you have fast and reliable tests in the first place, but if your project can benefit from fast tests – you have one less excuse not to write them. 
David
Pillar has announced the availability of a new Software as a Service offering called Verde. We like the challenge of placing automated characterization tests around ancient legacy code. This old "Brown" and brittle code needs a jump start – a chance to turn "Green" again.
This technology produces real Junit code at run time. We have created a recorder that sits inside the JVM and can listen at the Jar, Class, or Method layer. It also produces Mock Objects as needed to create isolation layers as needed.
Please see more at www.pillartechnology.com
Instinct 0.1.8 has been released. This is a maintenance release resolving some minor bugs and packaging issues from the 0.1.7 release earlier this week.Instinct is a Behaviour Driven Development (BDD) framework for Java. Inspired by RSpec, Instinct provides flexible annotation of contexts, specifications and actors; automatic creation of test doubles and test subjects; a state and behaviour expectation API; JUnit test runner integration; Ant support and an IntelliJ IDEA plugin.
Downloads are available from the project site: http://instinct.googlecode.com/
Full list of changes:
Core Features
o Custom specification, before specification and after specification
annotations and naming conventions can be provided via the Context
annotation. This can also be used to turn off naming convention-based
detection (using NoNamingConvention).
Infrastructure
o Upgraded to: Functional Java 2.8.
Bugs
o (Issue 36) Abstract classes are being run as a result of specification runner refactoring.
o (Issue 37) Expected exceptions are being printed to console in Ant
runner even though spec passes.
o (Issue 38) Functional java jar is not included in release zip.
ClassMock is a framework that helps the creation of unit tests for components that use reflection or annotations. In this kind of classes, the behavior is dependent of the class structure. This way, each test case usually works with a different class created specifically for the test. With ClassMock is possible to define and generate classes in runtime, allowing a better test readability and logic sharing between tests.
ClassMock is available at http://classmock.sourceforge.net/
Java mocking is dominated by record-replay-verify libraries like EasyMock or jmock. Mockito offers simpler and more intuitive approach: you ask questions about interactions after execution. Using mockito, you verify what you want. Using expect-run-verify libraries you often look after irrelevant interactions. Mockito offers very natural test-drive: verification of interactions is just like plain old asserts. Syntax is similar to EasyMock, therefore you can refactor safely. Mockito doesn’t understand the notion of ‘expectation’: there is only stubbing or verifications.
Read more: http://mockito.googlecode.com
Concordion 1.1.0 released today, with support for JUnit 4.4.
Concordion is an alternative to the Fit Framework, for writing acceptance tests.
What users are saying: "a lot more intuitive than Fit", "we’ve rewritten all our existing Fit tests in Concordion", "impressive", "one to keep your eye on"
We are proud to announce that FEST-Swing 0.8 is out!
FEST-Swing is a Java library that provides a fluent interface for functional Swing GUI testing. This library provides an easy-to-use API that makes creation and maintenance of GUI tests easy.
Example:
| Code: |
|
dialog.comboBox("domain").select("Users"); dialog.textBox("username").enterText("leia.organa"); dialog.button("login").click(); dialog.optionPane().requireErrorMessage() .requireMessage("Please enter your password"); |
This release includes many new features and improvements. Release notes and more information can be found here.
You can download FEST-Swing 0.8 here.
Best regards,
-Alex Ruiz
Bredex GmbH has announced that version 2.0 of GUIdancer, the automated GUI test tool, will be released towards the end of this year. The tool has been extended to cover RCP, SWT and HTML applications as well as Swing. Tests for these toolkits are created without programming, scripts or code. Specification of flexible, reusable tests can begin before the application is ready and can keep up with frequent iterations – making GUIdancer particularly well-suited to test-driven-development and agile processes. GUIdancer is expanding. Now in its second year on the market, the upcoming release of the Eclipse-based tool supports testing on Java (Swing, SWT, RCP) and HTML applications. The new release, scheduled for December 2007 is a cost-effective way of testing GUI applications.
“Our recent experiences at the Eclipse Summit really reinforced the value of GUIdancer in modern development processes” explained Hans-J. Brede, Managing Director. “Specifically, GUIdancer offers a unique advantage in agile processes because tests are easy to specify yet do not require the application under test to be ready. Test creation begins early and continues alongside development”.
Tests with GUIdancer can be created early and reused extensively. Project experience has shown that maintenance efforts are minimum, even after changes in the GUI of an application. Based on a “building-block” approach, tests are conceptually easy to create, but powerful in action. No details must be “hard-coded” in tests – GUIdancer has a “one test fits all” approach whereby a single specification can be used to test an application with different data, languages, components and even implementations with different toolkits.
Hans-J. Brede stressed the importance of early and continuous testing: “We are of the opinion that test-driven-development is also possible for GUI tests. There is everything to be gained by testing early and often, and GUIdancer is the only tool for the job”.
For an example flash-demo showing how one test can be reused, visit:
http://www.bredex.de/en/guidancer/downloads.html and select the “one test fits all” demo.
BREDEX GmbH
Since 1987, BREDEX GmbH has been providing high quality information technology services in the areas of consultancy, analysis and design, software development and training. Based in Braunschweig, the company has a history of long term customer satisfaction and a focus on forward thinking, developing individual solutions that bring future standards to current project needs. BREDEX sells GUIdancer, which is a powerful and cost effective automatic test tool for java applications.
For more information: www.bredexsw.com.
This press release can be downloaded from: http://www.bredex.de/en/guidancer/downloads.html
FEST-Assert is another "assertThat" library that aims at making tests more readable. Here is an example:
| Code: |
|
import static org.fest.assertions.Assertions.assertThat; import org.testng.annotations.Test; public class SomeTest { |
We like this approach because:
1. Only one static import is needed (org.fest.assertions.Assertions.assertThat)
2. Allows us to use our IDE’s "auto-complete" feature: we only type "." and we get the possible assertion methods for the value passed to "assertThat"
3. We can chain related assertion methods:
| Code: |
| assertThat(yoda).isInstanceOf(Jedi.class).isEqualTo(foundJedi).isNotEqualTo(possibleSith); |
FEST-Assert can also be extended using Conditions. The following condition verifies that the characters in a String are in uppercase:
| Code: |
|
class UpperCaseCondition extends Condition<String> {
private UpperCaseCondition(String description) { @Override public boolean matches(String value) { public static UpperCaseCondition isUpperCase() { |
This example shows how to use such condition:
| Code: |
| assertThat("hello").as("Greeting").satisfies(isUpperCase()); |
which will fail with the message "[Greeting] expected:Uppercase but was:<’hello’>"
We would appreciate any feedback.
Amock is AspecJ based mock library.
It will give you java mock which you have dreamed.
With Amock, you
* Can mock static method and constructor.
-> You can unit test with singleton.
* Can create mock object of a class which have only private constructor.
* Can create mock instance of interface and normal class instance.
* Can create mock object without any parameter even if the class does not have default constructor.
-> You don’t need to create expensive object just for mock constructor.
* Can access private method and attribute easily.
* Can mock private and protected method.
* Can use argument checker (argument matcher ‘eq(). any()…’) only where it is needed.
* Don’t need extending specific class.Prerequisite
JDK 1.5 version
http://java.sun.com/javase/downloads/index_jdk5.jsp
Eclipse 3.2
http://www.eclipse.org/downloads/
AJDT 1.4.0
Download Amock libarary and documentation from
http://www.box.net/shared/rmlnpaq0n2
and CGlib no dependency 2.1_3
http://prdownloads.sourceforge.net/cglib/cglib-nodep-2.1_3.jar?download
Download Amock here
http://www.box.net/shared/rmlnpaq0n2
Home page
http://amock.blogspot.com/
Example
package my.amock.example;
import static my.amock.util.Will.*;
import static my.amock.util.A.*;
import static my.amock.check.Check.*;
import my.amock.bracket.Story;
import my.amock.util.A;
import my.amock.util.Will;
import junit.framework.TestCase;
public class SimpleExampleTest extends TestCase {
private DummyClass dummyMock;
//private DummyInterface dummyMock;
public void setUp() {
//private constructor need A.mock()
//and when you use it you don’t have to specify parameter even if constructor need parameter
dummyMock = mock(DummyClass.class);
// if it was public constructor
//dummyMock = new DummyClass();
// if it was interface
//dummyMock = mock(DummyInterface.class);
}
public void testSimple() {
new Story() {{
//Recording is done in this block.
//Record Method call
dummyMock.noReturn(3);
//Record Method call with expected return value;
a(dummyMock.returnThis(1)).ret(1);
//Record Method call with expected return value;
a(dummyMock.multiply(0,anyInt())).ret(1);
//Record Method call with expected expected calling times and expected Exception to throw;
a(dummyMock.devide(anyInt(),eq(0))).times(2).toss(new ArithmeticException());
//Record Method call with expected expected calling times;
dummyMock.noReturn(1);a().times(2);
//Record static method call with expected expected return value
call();a(DummyClass.staticReturnThis(1)).ret(1);
//Record constructor call with expected expected return value
call();a(new Integer(1)).ret(new Integer(3));
//Record static method call with expected expected return value
call();a(DummyClass.getInstance()).ret(dummyMock);
a(dummyMock.toString()).ret("dummy");
}};
dummyMock.noReturn(3);
assertEquals(1, dummyMock.returnThis(1));
assertEquals(1, dummyMock.multiply(0,7));
try {
dummyMock.devide(3,0);
fail("should not reach here");
} catch (ArithmeticException e) {}
try {
dummyMock.devide(5,0);
fail("should not reach here");
} catch (ArithmeticException e) {}
dummyMock.noReturn(1);
dummyMock.noReturn(1);
assertEquals(1, DummyClass.staticReturnThis(1));
assertEquals(3, new Integer(1).intValue());
assertEquals(dummyMock, DummyClass.getInstance());
assertEquals("dummy", dummyMock.toString());
}
public void testField() {
Object original = A.field(dummyMock, "privateFinal").get();
Object newOne = new Object();
A.field(dummyMock, "privateFinal").set(newOne);
Object changed = A.field(dummyMock, "privateFinal").get();
assertNotSame(original, changed);
assertEquals(newOne, changed);
}
public void testMethod() {
final my.amock.util.Method privateMethod = A.methodExact(dummyMock, "privateMethod", int.class);
new Story() {{
a(privateMethod.invoke(3)).ret(5);
}};
assertEquals(5, privateMethod.invoke(3));
}
public void testAssign() {
String a = "a";
String ab = "ab";
A.assign(a, ab);
assertEquals("ab", a);
}
}
This main release adds compatibility for Java 6 and Java EE 5. Changes include:
- Full JDBC 4.0 support including the SQL XML data type
- Full Servlet 2.5 and JSP 2.1 support
- Introduction of the JasperJspFactory which allows EL evaluation using the Unified Expression Language API
- Introduction of RuntimeAttribute to simulate scriptlets and EL expressions as tag attributes
- many small bug fixes
EJB 3.0 is not supported yet.
You can download this version from http://mockrunner.sourceforge.net
Codign is pleased to announce updates to CoViewManager and CoViewDeveloper, Eclipse plug-ins that help promote code testability, JUnit automation, and path coverage.Testability: You pick your metrics, your thresholds and severity levels. One click will tell you what methods/classes/packages exceed your thresholds. Error or warning decorators are displayed if you exceed your thresholds while you are coding. A great way to use metrics that apply to you and to help set code expectations! A brief demo is available.
JUnit Automation: Highlight each path through your methods and use wizards to creates either an advanced stub or complete JUnit test, depending on your code. A demo is available as well.
Coverage: Both path and branch coverage are measured.
Support: Eclipse 3.1, 3.2 (3.3 coming real soon!), JUnit 3.8 & 4.x, and JDK 1.4 & 5.
Cost: Free for open source developers and university students. $99/$199 per copy for everyone else.. Discounts may be available but you have to ask nicely.
30-day evals available – download a trial today or visit our website for more information- www.codign.com
Dear TestDriven Community,
I’m pleased to announce that JsTester version 1.4 has been released.
Download | Documentation | Faq | Changes
JsTester allows validation of javaScript code inside java. It provides a group of assert methods like JUnit’s Assert, it also supports the validations described in http://javascript.crockford.com/remedial.html, and the ability to use your own validations (unary & binary predicates).
Changes:
+ Added support for JDK6 javax.script
+ Made JsTestCase and GroovyTestCase abstract
JDave is a framework which provides an easy way to specify behavior of your classes. Key concepts are specification, which is a container for behaviors. Behaviors define the behavior of a class and they are always expressed within some context. Context defines the setting where particular behavior applies.
For example, we could specify a Stack by first identifying that it has (at least) three interesting states, an empty stack, a full stack and a stack which is neither empty nor full. We would then continue by specifying the behavior of a Stack when it is in these states. The behavior can then be expressed as:
Stack specification
Empty stack
– is empty
– is no longer empty after push
– …
Full stack
– is full
– complains on push
– contains all items
– …
Stack which is neither empty nor full
– adds to the top when pushing new item
– …
Hamburg, Germany – 2007-01-31 froglogic GmbH today announced the first release of Squish/Java. Squish/Java is a new edition of the powerful, automated GUI testing framework Squish. This new edition features the automatic creation and execution of tests for Java Swing, AWT, SWT RCP/Eclipse applications.
Squish is the leading, cross-platform and cross-browser automated GUI testing tool for applications based on a variety of GUI technologies such as Trolltech’s Qt library, Web/HTML/Ajax, Tk, Four J’s Genero and XView.
The new Squish/Java edition is based on the recently released version 3.1 of Squish and takes advantage of its mature testing framework while adding support for the standard Java GUI technologies Swing, AWT, SWT and Eclipse Rich Client Platform. Java classes, functions and fields are dynamically exposed as script interfaces in Squish thus enabling the development of sophisticated automated tests."We are very excited about this new release which is already in use by first customers. With Squish/Java we cover another major GUI technology after already supporting technologies such as the Qt toolkit and HTML and Ajax Web applications. This will further strengthen our leading position in the cross-platform GUI testing market", said Reginald Stadlbauer, CEO and co-founder of froglogic.
Squish offers a versatile testing framework with a choice of popular test scripting languages (Python, JavaScript, Tcl and Perl) extended by test-specific functions, open interfaces, add-ons, integrations into test management systems, an IDE that supports the creation and debugging of tests and a set of command line tools facilitating fully automated test runs.
Similar to preexisting Squish editions, tests for Java applications can be automatically recorded or written manually. Using Squish Spy, verification and synchronization points can be inserted as easily as in every other edition by visually exploring the structure of a Java application.
Squish/Java packages are available now. If you are interested in evaluating Squish/Java, or any other Squish edition, please visit http://www.froglogic.com/evaluate or contact squish@froglogic.com. For more information, visit http://squish.froglogic.com.
About froglogic
froglogic GmbH is a software company based in Hamburg, Germany. Their flagship product is Squish, the market-leading automated testing tool for GUI applications based on Qt, Tk or XView and for HTML/Ajax-based web applications running in different web browsers. froglogic also offers services in the areas QA/automated testing and Qt C++ programming and consulting. More about froglogic at http://www.froglogic.com.
Hamburg, Germany – 2007-01-24. Squish/Mac will become available as a new edition of the powerful, platform-independent testing framework Squish. This new edition will feature the automatic creation and execution of tests for native Mac OS X Carbon and Cocoa applications.
Squish is the market-leading cross-platform GUI testing tool for applications based on a variety of GUI technologies such as Swing/SWT/RCP/Eclipse, Trolltech’s Qt, Tk, Four J’s Genero and XView. Additionally, Squish supports automatically testing Web and Ajax applications running in different web browsers.
Squish is a cross-platform solution that runs natively on Windows, Linux/Unix, embedded Linux and Mac OS X. The new Squish/Mac edition takes advantage of Squish’s mature testing framework while adding test automation support for the native Mac OS X GUI technologies Carbon and Cocoa."While the popularity of Mac OS X is constantly growing, no tools for automated testing of native Mac OS X applications are available today. After the huge success of Squish with different GUI technologies, we are very excited to fill this gap by providing a solid and powerful test solution to companies targeting the Mac OS X market.", explained Rainer Schmid, froglogic’s Mac OS X Engineer.
Squish offers a versatile testing framework with a choice of popular test scripting languages (Python, JavaScript, Tcl and Perl) extended by test-specific functions, open interfaces, add-ons, integrations into test management systems, an IDE that supports the creation and debugging of tests and a set of command line tools facilitating fully automated test runs.
Similar to preexisting Squish editions, tests for Mac applications can be automatically recorded or written manually. Using Squish Spy, verification and synchronization points can be inserted as easily as in every other edition by visually exploring the internal structure of a Mac application.
Previews of Squish/Mac will become available in the next weeks. If you are interested in exploring and providing feedback for Squish/Mac, please contact us at squish@froglogic.com. If you would like to evaluate any other Squish edition, please visit http://www.froglogic.com/evaluate or contact squish@froglogic.com. For more information, visit http://squish.froglogic.com.
About froglogic
froglogic GmbH is a software company based in Hamburg, Germany. Their flagship product is Squish, the market-leading automated testing tool for GUI applications based on Qt, Tk or XView and for HTML/Ajax-based web applications running in different web browsers. froglogic also offers services in the areas QA/automated testing and Qt C++ programming and consulting. More about froglogic at http://www.froglogic.com.
JUnitFactory is a free experimental project from AgitarLabs. You send it Java code and it sends back JUnit characterization tests for your code.
We have made our technology freely available to academic institutions and test researchers, but some of them don’t have the spare computing or IT resources to set-up a test server, so we thought it would be a fun experiment to set-up a dozen CPUs and have students and researchers use the test generator over the web. As the experiment progresses, we plan to make APIs available so that researchers and anyone interested in automated test generation can experiment with their own characterization test generation algorithms and strategies.Before anyone starts complaining about the evil of automated test generation, let me restate that JUnitFactory can only generate characterization tests; and let me clarify what is meant by characterization tests for those that may not be familiar with the term or concept.
In "Working With Legacy Code", Michael Feathers defines characterization tests as tests that characterize and record what the code actually does – not what it’s *supposed* to do. They exercise the code with a range of inputs, and record return values, object state, etc., for each set of inputs.
Characterization tests are useful for working with legacy code which is defined, again by Michael Feathers, as any code without tests.
CTs can come in handy as change detectors when there is a large body of code with little or no tests and provide a safety net when you need to make some changes to it. If the same set of inputs results in different behavior between the original and the revised version of the code, some assertions in the characterization tests will fail. Some of those failures may point to unexpected and/or unwanted changes in behavior that you might want to know about and address.
Colloquially, and in the simplest possible terms, characterization tests will tell you things like the following:
—–
In the original version of the code, ‘Util.foobar("abc", 123)’ returned ’42′. After you made the change, it returns ’43′.
—–
The test has no idea whether the right return value is ’42′ or ’43′, but it lets you know that it has changed and you, the developer, has to decide which one is right and what to do about it. Sorry, no free lunch.
By now it should be amply clear that automatically generated characterization tests are NOT a replacement for TDD or Unit tests lovingly crafted by developers. But, especially with some user input in the selection of test data and test assertions (which is possible with JUnitFactory), they can give developers a valuable jump-start in working with legacy code and complement their manual testing efforts.
Unfortunately, for the time being, we only have a client plug-in for Eclipse. If enough people find the JUnitFactory useful, we plan to add support for other IDEs. As a matter of fact, if you want to help with that let us know – but keep in mind that JUnitFactory is designed to be a free service so all clients will have to be freely available or, better, open-source.
If you don’t use Eclipse, there’s a "toy" web-based demo of the CT generation also – but it only works on one class with no dependencies.
Anyway, if you have any interest in JUnit generation, go to the website, request an invitation and give it a try.
Remember, it’s still experimental and mostly for fun so don’t expect too much or bang on it too hard.
http://www.junitfactory.com
Alberto Savoia
Agitar Software Laboratories
A new version of the Eclipse plugin MoreUnit has been released with bug fixes and new features. Enjoy.
moreUnit is an Eclipse plugin to assist developers in writing more unit tests. It currently:
- Decorates classes which have a test case.
- Marks methods in the editor which are under test.
- Jumps to a test case in the editor via the menu or a shortcut
- Generates a test method stub for the method under cursor-position in the editor via the menu or a shortcut.
The first release of ClasspathSuite is available.
This JUnit 4 extensions allows you to run a suite of testcases that live anywhere in your classpath. This is useful e.g. in multi project settings in Eclipse 3.2 since the integrated test runner does not support multi project testing. ClasspathSuite uses the @RunWith annotation to build up test suites.
See this blog entry for details about usage.
We are pleased to announce that an initial version of the LiFT framework is now available as open source on java.net.
LiFT is a framework for Literate Functional Testing. LiFT allows writing automated tests in a style that makes them very readable, even for non-programmers. Using the LiFT API, we can write tests that read almost like natural language, allowing business requirements to be expressed very clearly. This aids communication amongst developers and customers, helping give all stakeholders confidence that the right things are being tested.
Robert Chatley and Tom White gave a presentation on Literate Functional Testing at the Google London Test Automation Conference, the slides and [url=http://video.google.com/videoplay?docid=1505469784301926538&q=label%3Altac]video[/url] are available online.
Still the most popular link on testdriven.com, Cédric Beust‘s versatile java unit-testing tool, TestNG, made the highlights on IBM DeveloperWorks last Tuesday, with Andrew Glover’s article, JUnit 4 vs. TestNG: Why TestNG is still the better framework for large-scale testing.
Abstract: "With its new, annotations-based framework, JUnit 4 has embraced some of the best features of TestNG, but does that mean it’s rendered TestNG obsolete? Andrew Glover considers what’s unique about each framework and reveals three high-level testing features you’ll still find only in TestNG."
Dear TestDriven Community, I’m pleased to announce that JsTester version 1.1 has been released.
JsTester allows validation of javaScript code inside java. It provides a group of assert methods like JUnit’s Assert, it also supports the validations described here, and the ability to use your own validations (unary & binary predicates). The project provides two ways of creating your tests: by inheritance (JsTestCase), and by composition (JsTester). Use JsTestCase as you would normally use any extension of TestCase. Use JsTester with JUnit4 and annotations, or inside another TestCase hierarchy.
Changes:
* Added JsTestCase for quick test implementations. Suggested by Cagatay Civici.
* Added all project TestSuite
* Updated the howto
Cédric Beust has announced the availability of the latest version of his versatile Java testing tool, TestNG. Here is a short list of changes that have appeared in version 5.0:
* Configuration annotations are now called @BeforeTest, @BeforeSuite, etc…
* Reports are now created in their own directory (one per suite) and a main index file shows a list of all the suites that were just run. They have also received a series of improvements in appearance and content.
* It is now possible to specify the suite and test names directly in the @Test annotations, which allows you to do without a testng.xml.
* expectedExceptions has moved inside @Test.
* TestNG shows friendly stack traces.
Much more information in Cédric’s full announcement. Download TestNG here.