Ant task/script for generating TestNg report

Here is an example explaining an ant task for generating TestNG report after execution of classes defined in TestNG xml file.

1. <property name="src.dir" value="src" />
2. <property name="lib.dir" value="lib" />
3. <property name="log.dir" value="logs" />
4. <property name="build.loc" value="build" />
5. <property name="classes.dir" value="${build.loc}/classes" />
6. <property name="reports.dir" value="${build.loc}/reports" />
7. <property name="testNG.report" value="${reports.dir}/TestNG" />
8. <property name="suite.dir" value="suite" />
10. <!-- Class-Path -->
11. <path id="classpath">
12.     <pathelement location="${classes.dir}"/>
13.     <fileset dir="${lib.dir}" includes="*.jar"/>
14. </path>
16. <!-- Delete directories that are not needed -->
17. <target name="delete-dir" >
18.         <delete dir="${build.loc}"/>
19.         <echo> /* Deleted existing Compiled Directory Classes */ </echo>
20. </target>
22. <!-- Create Directories -->
23. <target name="create-source-dir" depends="delete-dir">
24.     <mkdir dir="${classes.dir}"/>
25.     <mkdir dir="${testNG.report}"/>
26.     <echo> /* Created Directories */ </echo>
27. </target>
29. <!-- Compiling Tests -->
30. <target name="compile-classes" depends="create-source-dir">
31.     <javac destdir="${classes.dir}" includeantruntime="false" debug="true" srcdir="${src.dir}">
32.         <classpath refid="classpath"/>
33.     </javac>
34.     <echo> /* Compiled Directory Classes */ </echo>
35. </target>
37. <!-- Running Tests and TestNG report generation -->
38. <target name="testNGreport" depends="compile-classes">
39.     <taskdef resource="testngtasks" classpathref="classpath"/>
40.     <testng classpathref="classpath" outputDir="${testNG.report}" haltOnfailure="true">
41.           <xmlfileset dir="." includes="${suite.dir}/testng.xml" />
42.     </testng>
43.     <echo> /* Run Directory Classes */ </echo>
44. </target>

By the above target 'testNGreport' you can load TestNG task in ant and execute you selenium tests. It is just that ant would access your testng.xml file to execute tests. This is same as how you be executing tests from with eclipse using TestNG - Eclipse plugin. 
Below is the testNG file that is used in the above build file.
//TestNG.xml

1. <suite name="Suite1" verbose="1" >
2.   <test name="Regression1">
3.     <classes>
4.       <class name="test.sample.ExampleTest1"/>
5.       <class name="test.sample.ExampleTest2"/>
6.     </classes>
7.   </test>
8. </suite>

Ant task/script for generating JUnit report

Here is an example explaining an ant task for running compiled classes and generating JUnit report after execution of classes.

1. <target name="run-classes" depends="compile-classes">
2.     <!-- Define the Ant tasks for running classes -->
3.     <junit fork="yes" printsummary="no" haltonfailure="no">    
4.         <batchtest fork="yes" todir="${build.loc}/reports" >
5.           <fileset dir="${classes.dir}">
6.             <include name="**/.class" />
7.           </fileset>
8.         </batchtest>
9.         <formatter type="xml" />
10.         <classpath refid="classpath" />
11.     </junit>
12.    
13.     <!-- Ant task for generating reports -->
14.     <junitreport todir="${build.loc}/reports">
15.         <fileset dir="${build.loc}/reports">
16.             <include name="TEST-*.xml"/>
17.         </fileset>
18.         <report todir="${build.loc}/reports"/>
19.     </junitreport>     
21.     <echo> Genereated JUnit Reports </echo>
22. </target>

In the above ant target there are 2 sub-tasks i.e junit and junitreport.The junit task is for running test classes and junitreport is for generating JUnit report.

Explanation:

fork: 

     if true, it 'll run the tests in separate virtual machine.

printsummary:

     if yes, at the end of the test, a one-line summary will be printed.

haltonfailure:

     if yes, the build process will be stopped if the test fails.

The batchtest defines a number of tests based on pattern matching.

In this case formatter type is xml so an XML result will be output to result xml file

        The batchtest task of junit task 'll run all the tests classes that are in ${classes.dir} directory and produce xml files in the ${build.loc}/reports directory then the junitreport task take all the xml files that are starting with 'TEST-' and 'll generate report in the same directory.

Ant task for compiling classes

The following build.xml file contains 3 targets for deleting unnecessary directories, creating required directories and compiling classes in a specified directory.

//build.xml

1. <project name="SampleBuildFile" default="compile-classes" basedir=".">
2.     <property name="src.dir" value="src" />
3.     <property name="lib.dir" value="lib" />
4.     <property name="build.loc" value="E:/temp/build" />
5.     <property name="classes.dir" value="${build.loc}/classes" />
7.     <!-- Setting ClassPath -->
8.     <path id="classpath">
9.         <pathelement location="${classes.dir}"/>
10.         <fileset dir="${lib.dir}" includes="*.jar"/>
11.     </path>
13.     <!-- Delete directories that are not needed -->
14.     <target name="delete-dir" >
15.             <delete dir="${build.loc}"/>
16.             <echo> /* Deleted existing Directories */ </echo>
17.     </target>
19.     <!-- Create Directories -->
20.     <target name="create-dir" depends="delete-dir">
21.         <mkdir dir="${classes.dir}"/>
22.         <echo> /* Created Directories */ </echo>
23.     </target>
25.     <target name="compile-classes" depends="create-dir">
26.         <javac destdir="${classes.dir}" includeantruntime="false" debug="true" srcdir="${src.dir}">
27.             <classpath refid="classpath"/>
28.         </javac>
29.         <echo> /* Compiled Classes */ </echo>
30.     </target>
31. </project>

In the above build file,

              Property task is used to set a property by name and value which are case sensitive.The attribute 'name' represents name of property and 'value' represents value to the property. By using this we can have an advantage when we want any modification further on property values because value represented by property name is used through out the build file so no need to change the property value for all.

Path task is used to building class path required to execute different ant targets in the build file.

             Here by default the 'compile-classes' target 'll call first when the build file 'll run, but this target depends on 'create-dir' target so it 'll call 'create-dir' target before it run.Again the 'create-dir' depends upon 'delete-dir' so it 'll call the 'delete-dir' target before 'create-dir' run.Clearly, the order of execution 'll be 
                       delete-dir   =>  create-dir   => compile-classes

             In the 3rd target the 'javac' task 'll compile all the java classes that are in the directory specified by 'srcdir' attribute i.e 'src' directory and all the compiles classes 'll be stored in the directory specified by 'destdir' attribute i.e 'E:/temp/build/classes'

The <classpath> is used to specify the PATH references using path tasks 'id' attribute value.

Ant script for create or delete directory

Ant Task for Deleting directories:

Below is an ant task that deletes the directory specified to 'dir' attribute of delete tag.

1. <target name="delete-dir" >
2.     <delete dir="build}"/>
3.     <echo> /* Deleted existing directory */ </echo>
4. </target>

The delete task deletes 'build' directory including all the files and subdirectories of 'build'.

The echo task just prints the message in console.

1. <target name="delete-dir" >
2.     <delete>
3.         <fileset dir="." includes="**/*.java"/>
4.     </delete>
5. </target>

Here the delete task deletes all files with the extension '.java' from the current directory(represented by '.') and any subdirectories of it.

1. <target name="delete-dir" >
2.     <delete includeEmptyDirs="true">
3.         <fileset dir="build"/>
4.     </delete>
5. </target>

Here the deletetask deletes all files and subdirectories of 'build', including build itself.

1. <target name="delete-dir" >
2.     <delete includeEmptyDirs="true">
3.         <fileset dir="build" includes="**/*"/>
4.     </delete>
5. </target>

Here the delete task deletes all files and subdirectories of build, without build itself.

Ant Task for Making Directory:

Below is an ant task for making required directories specified to 'dir' attribute of 'mkdir' task.

1. <target name="create-dir" >
2.     <mkdir dir="build"/>
3.     <echo> /* Created Directory */ </echo>
4. </target>

The mkdir task creates a directory 'build' in to the root directory.

Note: mkdir creates the directory if not exists only, if exists it does nothing.