In this step we will introduce the usage of the JUnit [3] test framework in combination with Ant. Because Ant has a built-in JUnit 4.13.1 you could start directly using it. Write a test class in src\oata\HelloWorldTest.java:
package oata;
import org.junit.Test;
import static org.junit.Assert.fail;
public class HelloWorldTest {
@Test
public void testNothing() {
}
@Test
public void testWillAlwaysFail() {
fail("An error message");
}
}Because we don't have real business logic to test, this test class is very small: just showing how to start. For further information see the JUnit documentation [3] and the manual of junit task. Now we add a junit instruction to our buildfile:
...
<path id="application" location="${jar.dir}/${ant.project.name}.jar"/>
<target name="run" depends="jar">
<java fork="true" classname="${main-class}">
<classpath>
<path refid="classpath"/>
<path refid="application"/>
</classpath>
</java>
</target>
<target name="junit" depends="jar">
<junit printsummary="yes">
<classpath>
<path refid="classpath"/>
<path refid="application"/>
</classpath>
<batchtest fork="yes">
<fileset dir="${src.dir}" includes="**/*Test.java"/>
</batchtest>
</junit>
</target>
...We reuse the path to our own jar file as defined in run
-target by giving it an id and making it globally available. The printsummary=yes
lets us see more detailed information than just a "FAILED" or "PASSED" message. How much tests failed? Some errors? printsummary lets us know. The classpath is set up to find our classes. To run tests the batchtest here is used, so you could easily add more test classes in the future just by naming them *Test.java. This is a common naming scheme.
After a ant junit you'll get:
...
junit:
[junit] Running oata.HelloWorldTest
[junit] Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0,01 sec
[junit] Test oata.HelloWorldTest FAILED
BUILD SUCCESSFUL
...We can also produce a report. Something that you (and others) could read after closing the shell ... There are two steps: 1. let <junit> log the information and 2. convert these log files to something readable (browsable).
...
<property name="report.dir" value="${build.dir}/junitreport"/>
...
<target name="junit" depends="jar">
<mkdir dir="${report.dir}"/>
<junit printsummary="yes">
<classpath>
<path refid="classpath"/>
<path refid="application"/>
</classpath>
<formatter type="xml"/>
<batchtest fork="yes" todir="${report.dir}">
<fileset dir="${src.dir}" includes="**/*Test.java"/>
</batchtest>
</junit>
</target>
<target name="junitreport">
<junitreport todir="${report.dir}">
<fileset dir="${report.dir}" includes="TEST-*.xml"/>
<report todir="${report.dir}"/>
</junitreport>
</target>Because we would produce a lot of files and these files would be written to the current directory by default, we define a report directory, create it before running the junit
and redirect the logging to it. The log format is XML so junitreport
could parse it. In a second target junitreport
should create a browsable HTML report for all generated XML log files in the report directory. Now you can open the ${report.dir}\index.html and see the result (looks something like JavaDoc).
Personally I use two different targets for <junit> and <junitreport>. Generating the HTML report needs some time and you don't need the HTML report just for testing, e.g. if you are fixing an error or a integration server is doing a job.
