Explore topic-wise InterviewSolutions in Current Affairs.

We can not MODIFY the PROPERTIES in ANT. The properties in ant are IMMUTABLE in NATURE.

We can not modify the properties in ant. The properties in ant are immutable in nature.

There is no need to use Runtime in ant. Because ant has Runtime COUNTERPART by name ExecTask. ExecTask is in the package org.apache.tools.ant.taskdefs. The TASK is CREATED by using the CODE in the customized ant Task. The code snippet is as FOLLOWS:

ExecTask execTask = (ExecTask)project.createTask (“exec”);

There is no need to use Runtime in ant. Because ant has Runtime counterpart by name ExecTask. ExecTask is in the package org.apache.tools.ant.taskdefs. The Task is created by using the code in the customized ant Task. The code snippet is as follows:

ExecTask execTask = (ExecTask)project.createTask (“exec”);

The following is an example to run a Java APPLICATION in using ANT:

<target name=”run” DEPENDS=”some.target”,some.other.target”>
<java CLASSNAME=”${run.class}” fork=”yes”>
<CLASSPATH>
<path refrid = “classpath” />
</classpath>
<jvmarg line=”${debug.jvmargs}”/>
<jvmarg line=”${my.jvmargs}”/> < BR>
<jvmarg line=”${run.jvmargs}”/>
<arg line=”${run.args}”/>
</java>
</target>

The following is an example to run a Java application in using ANT:

<target name=”run” depends=”some.target”,some.other.target”>
<java classname=”${run.class}” fork=”yes”>
<classpath>
<path refrid = “classpath” />
</classpath>
<jvmarg line=”${debug.jvmargs}”/>
<jvmarg line=”${my.jvmargs}”/> < BR>
<jvmarg line=”${run.jvmargs}”/>
<arg line=”${run.args}”/>
</java>
</target>

ANT script can be debugged in the following ways:

1. By echoing at the PLACE to debug. The problem is easily known. This is similar to printf() function in C and System.out.println() in Java.
2. By USING project.log (“MESSAGE”) in the java script or the customized ant task.
3. By RUNNING ANT with –verbose / -debug options. These options provide more information on what is the process going and at which location.

ANT script can be debugged in the following ways:

1. Copy the ant-contrib.jar to the DIRECTORY ant*/LIB. Copy ant-contrib.jar to your ant*/lib directory.
2. Append the FOLLOWING code snippet to avail all the ant-contrib tasks.

&LT;taskdef RESOURCE=”net/sf/antcontrib/antcontrib.properties”/>

<taskdef resource=”net/sf/antcontrib/antcontrib.properties”/>

The org.apache.tools.ant.input.InputHandler INTERFACE is used to implement the USER input. To PERFORM the user input, the application creates InputRequest object and this object will be passed to InputHandler. The user input will be rejected if it is invalid.

The InputHandler interface has exactly one METHOD, by name handleInput(InputRequest REQUEST). This method throws org.apache.tools.ant.BuildException, if the input is invalid.

The org.apache.tools.ant.input.InputHandler interface is used to implement the user input. To perform the user input, the application creates InputRequest object and this object will be passed to InputHandler. The user input will be rejected if it is invalid.

The InputHandler interface has exactly one method, by name handleInput(InputRequest request). This method throws org.apache.tools.ant.BuildException, if the input is invalid.

<target name="test" depends="-copytestresources, compile"&GT;
<mkdir dir="${build.dir}/junit-reports" />
<junit printsummary="false"
FORK="on"
haltonfailure="false"
failureproperty="test.failure">
<classpath refid="classpath.junit" />
<FORMATTER TYPE="plain" />
<batchtest todir="${build.dir}/junit-reports">
<fileset dir="${build.dir}/test-classes" includes="**/*Test.class" />
</batchtest>
</junit>
<junitreport tofile="target/junit-reports/TEST.xml">
<fileset dir="${target}/junit-reports" includes="TEST-*.xml" />
<report format="FRAMES" todir="${target}/junit-reports" />
</junitreport>
</target>

<target name="test" depends="-copytestresources, compile">
<mkdir dir="${build.dir}/junit-reports" />
<junit printsummary="false"
fork="on"
haltonfailure="false"
failureproperty="test.failure">
<classpath refid="classpath.junit" />
<formatter type="plain" />
<batchtest todir="${build.dir}/junit-reports">
<fileset dir="${build.dir}/test-classes" includes="**/*Test.class" />
</batchtest>
</junit>
<junitreport tofile="target/junit-reports/TEST.xml">
<fileset dir="${target}/junit-reports" includes="TEST-*.xml" />
<report format="frames" todir="${target}/junit-reports" />
</junitreport>
</target>

&LT;target name="compile" depends="-init">
<MKDIR dir="${build.dir}/classes" />
<javac destdir="${build.dir}/classes" includeantruntime="FALSE" debug="true" OPTIMIZE="true" verbose="false" DEPRECATION="false" source="1.5" target="1.5">
<classpath refid="classpath.base" />
<src path="${src.dir}/main/java" />
</javac>
</target>

<target name="compile" depends="-init">
<mkdir dir="${build.dir}/classes" />
<javac destdir="${build.dir}/classes" includeantruntime="false" debug="true" optimize="true" verbose="false" deprecation="false" source="1.5" target="1.5">
<classpath refid="classpath.base" />
<src path="${src.dir}/main/java" />
</javac>
</target>

<TARGET NAME="validate" depends="-init"&GT;
<mkdir dir="${build.dir}/pmd-reports" />
<pmd shortFilenames="true" rulesetfiles="${basedir}/.ruleset">
<formatter type="xml" tofile="${build.dir}/pmd-reports/report.xml" />
<fileset dir="${src.dir}/main/java/com/" INCLUDES="**/*.java" />
<fileset dir="${src.dir}/test/java" includes="**/*.java" />
</pmd>
<xslt style="${ant.home}/etc/xslt/pmd-report-per-class.xslt"
in="${build.dir}/pmd-reports/report.xml"
out="${build.dir}/pmd-reports/report.html" />
</target>

<target name="validate" depends="-init">
<mkdir dir="${build.dir}/pmd-reports" />
<pmd shortFilenames="true" rulesetfiles="${basedir}/.ruleset">
<formatter type="xml" tofile="${build.dir}/pmd-reports/report.xml" />
<fileset dir="${src.dir}/main/java/com/" includes="**/*.java" />
<fileset dir="${src.dir}/test/java" includes="**/*.java" />
</pmd>
<xslt style="${ant.home}/etc/xslt/pmd-report-per-class.xslt"
in="${build.dir}/pmd-reports/report.xml"
out="${build.dir}/pmd-reports/report.html" />
</target>

<TARGET name="clean" DEPENDS="-clean" />
<target name="-clean">
<delete dir="${build.dir}/*" />
<delete dir="${build.dir}/classes" />
<delete dir="${build.dir}/test-classes" />
<delete dir="${build.dir}/release" />
<delete file="${build.dir}/*.JAR" />
<delete file="${build.dir}/VERSION.txt" />
</target>

<target name="clean" depends="-clean" />
<target name="-clean">
<delete dir="${build.dir}/*" />
<delete dir="${build.dir}/classes" />
<delete dir="${build.dir}/test-classes" />
<delete dir="${build.dir}/release" />
<delete file="${build.dir}/*.jar" />
<delete file="${build.dir}/VERSION.txt" />
</target>

&LT;path id="classpath.base">
<pathelement location="${glassfish.home}/lib/javaee.jar" />
<FILESET dir="${lib.dir}">
<INCLUDE NAME="log4j-1.2.15.jar" />
<include name="el-impl-1.0.jar" />
</fileset>
</path>

<path id="classpath.base">
<pathelement location="${glassfish.home}/lib/javaee.jar" />
<fileset dir="${lib.dir}">
<include name="log4j-1.2.15.jar" />
<include name="el-impl-1.0.jar" />
</fileset>
</path>

Before start using ANT, we should be CLEAR about the project name and the .java files and most importantly, the PATH where the .class files are to be placed.

For example, we want the application HelloWorld to be used with ant. The Java source files are in a subdirectory called Dirhelloworld, and the .class files are to put into a SUB directory called Helloworldclassfiles.

1. The build file by name build.xml is to be written. The script is as follows

<project name=”HelloWorld” default=”compiler” basedir=”.”> 
<target name=”compiler”> 
<mkdir dir = “Helloworldclassfiles”> 
<javac srcdir=”Dirhelloworld” destdir=”Helloworldclassfiles”> 
</target> 
</project>

2. Now run the ant script to perform the compilation:

C :\> ant 
Buildfile: build.xml

and see the results in the extra files and directory created:

c:\>dir Dirhelloworld 
c:\>dir Helloworldclassfiles

All the .java files are in Dirhelloworld directory and all the corresponding .class are in Helloworldclassfiles directory.

Before start using ANT, we should be clear about the project name and the .java files and most importantly, the path where the .class files are to be placed.

For example, we want the application HelloWorld to be used with ant. The Java source files are in a subdirectory called Dirhelloworld, and the .class files are to put into a sub directory called Helloworldclassfiles.

1. The build file by name build.xml is to be written. The script is as follows

<project name=”HelloWorld” default=”compiler” basedir=”.”> 
<target name=”compiler”> 
<mkdir dir = “Helloworldclassfiles”> 
<javac srcdir=”Dirhelloworld” destdir=”Helloworldclassfiles”> 
</target> 
</project>

2. Now run the ant script to perform the compilation:

C :\> ant 
Buildfile: build.xml

and see the results in the extra files and directory created:

c:\>dir Dirhelloworld 
c:\>dir Helloworldclassfiles

All the .java files are in Dirhelloworld directory and all the corresponding .class are in Helloworldclassfiles directory.

• Ant is an OPEN source project AVAILABLE under the Apache license. Therefore, its source code can be downloaded and modified. 
• Additionally, Ant uses XML build files which MAKE its development easy.
• Cross Platform.
• Use of XML along with Java makes Ant makes it the perfect solution for developing programs designed to run or be built across a range of different OPERATING systems.
• Extensible.
• New tasks are used to extend the capabilities of the build process, while build listeners are used to help hook into the build process to add extra error tracking functionality.
• As Ant is extensible and open, it can be integrated with any editor or development environment EASILY.

ANT does not NEED to SET CLASS PATH.

Ant does not need to set class path.

IVY is a popular dependency manager .IVY is basically focused on flexibility and simplicity.

The latest version of Ivy is 2.1.0.

Key features of the 2.1.0 RELEASE are

• The Key features of Ivy is ENHANCED Maven2 compatibility, with several bug fixes and more pom features covered.
• new options for the Ivy Ant tasks and commandline
• configuration intersections and configuration groups
• numerous bug fixes &AMP; improvements as documented in Jira and in the release NOTES

Ivy is a popular dependency manager .IVY is basically focused on flexibility and simplicity.

The latest version of Ivy is 2.1.0.

Key features of the 2.1.0 release are

The most IMPORTANT difference between Ant and Make is that Ant USES XML to describe the build PROCESS and its dependencies, WHEREAS Make uses its Makefile format. By DEFAULT the ant XML file is named build.xml.

The most important difference between Ant and Make is that Ant uses XML to describe the build process and its dependencies, whereas Make uses its Makefile format. By default the ant XML file is named build.xml.

We can prepare a project by making a build.xml as a build FILE and using following tag. INSIDE this tag we have defined standard targets (such as build, CLEAN ETC), etc.

We can prepare a project by making a build.xml as a build file and using following tag. Inside this tag we have defined standard targets (such as build, clean etc), etc.

To make a jar of classes we NEED SET target as jar. In this target we need to make directory in which jar will stored. Then we need jar tag to make the jar .In this tag we have pass two attributes FIRST is name of destination directory and SECOND ONE is the name of base directory where our all class files are stored .We need a manifest to create a jar file. In manifest tag we have pass two attributes first is name of manifest file name and second is its value.

To make a jar of classes we need set target as jar. In this target we need to make directory in which jar will stored. Then we need jar tag to make the jar .In this tag we have pass two attributes first is name of destination directory and second one is the name of base directory where our all class files are stored .We need a manifest to create a jar file. In manifest tag we have pass two attributes first is name of manifest file name and second is its value.

DEPENDENCIES are do something when COMPLETE it. In ant we are using dependencies by using an attribute “depends” .In this attribute we have pass VALUES for which the target depends .This mean we first need to EXECUTE the target which is passed into this attribute.

Dependencies are do something when complete it. In ant we are using dependencies by using an attribute “depends” .In this attribute we have pass values for which the target depends .This mean we first need to execute the target which is passed into this attribute.

A PROJECT can have a SET of PROPERTIES .A property has name and value .The name is case sensitive and Properties are immutable this mean once set property its will not change. Properties MAY be USED in the value of task attributes.

A project can have a set of properties .A property has name and value .The name is case sensitive and Properties are immutable this mean once set property its will not change. Properties may be used in the value of task attributes.

There are six WAYS to set properties:

1. SUPPLYING both the name and value attribute.<PROPERTY name=”src.dir” value=”src”/&GT;
2. Supplying both the name and refid attribute.
3. Setting the file attribute with the filename of the property file to load.
4. Setting the url attribute with the url from which to load the properties.
5. Setting the resource attribute with the resource name of the property file to load.
6. Setting the environment attribute with a prefix to use.

We can use the combinations of all above in our build files .But only one should be used at a time.

There are six ways to set properties:

We can use the combinations of all above in our build files .But only one should be used at a time.

Ant is great build tool due to following REASON:

1. Ant is a Java-based build tool designed to be cross-platform, easy to use, extensible, and scalable.
2. Ant can be used in a small personal project as well as ant can be used in a LARGE, multi-team SOFTWARE project.
3. Ant syntax is very easy to learn.
4. Ant syntax used XML format .We need only specifies our task only on build.xml file.
5. Ant is easy to use .eliminating the full-time make file engineer common on large Make-based software projects.

Ant is great build tool due to following reason:

ANT tool is extended by using java classes. The configuration files are XML-based. Each TASK of building directory TREE is executed by using the object that implements the Task interface.

ANT PROVIDES the cross-PLATFORM deployment that can RUN on any platform.

ANT tool is extended by using java classes. The configuration files are XML-based. Each task of building directory tree is executed by using the object that implements the Task interface.

ANT provides the cross-platform deployment that can run on any platform.

Ant is a build tool that is java based. A build tool performs the following tasks:

Open: Ant is an open source project available under the Apache license. Therefore, its source code can be downloaded and modified.

ADDITIONALLY, Ant uses XML build files which make its development easy.

Cross Platform: Use of XML along with Java makes Ant makes it the perfect solution for developing programs designed to run or be built across a range of different operating systems.

Extensible: NEW tasks are used to extend the capabilities of the build process, while build listeners are used to help hook into the build process to add EXTRA error tracking functionality.

INTEGRATION: As Ant is extensible and open, it can be integrated with any editor or development ENVIRONMENT easily.

Ant is a build tool that is java based. A build tool performs the following tasks:

Open: Ant is an open source project available under the Apache license. Therefore, its source code can be downloaded and modified.

Additionally, Ant uses XML build files which make its development easy.

Cross Platform: Use of XML along with Java makes Ant makes it the perfect solution for developing programs designed to run or be built across a range of different operating systems.

Extensible: New tasks are used to extend the capabilities of the build process, while build listeners are used to help hook into the build process to add extra error tracking functionality.

Integration: As Ant is extensible and open, it can be integrated with any editor or development environment easily.

A built tool is software which is used to BUILD project, directory STRUCTURE, copy necessary files to that directory ,compile files ,CREATE jars, set path and class-path ,Build the documentation ,Validate the source code, deploy, debug, and RUN, clear the workspace.

A built tool is software which is used to build project, directory structure, copy necessary files to that directory ,compile files ,create jars, set path and class-path ,Build the documentation ,Validate the source code, deploy, debug, and run, clear the workspace.

The ant is ACRONYM of ”Another Neat Tool” according to JAMES DUNCAN Davidson. Ants are very small and can carry heavy weight. So as JOB of Apache ant. Its name is CALLED ANT.

The ant is acronym of ”Another Neat Tool” according to James Duncan Davidson. Ants are very small and can carry heavy weight. So as Job of Apache ant. Its name is called ANT.

Ant is an open SOURCE code .It is Java-based build tool sponsored by Apache Software Foundation. It is a PROGRAM for putting all the pieces of a program TOGETHER. A simple definition might state that “Ant is a Java-based build tool from Apache Software Foundation”. Ant is kind of like MAKE.

Ant is an open source code .It is Java-based build tool sponsored by Apache Software Foundation. It is a program for putting all the pieces of a program together. A simple definition might state that “Ant is a Java-based build tool from Apache Software Foundation”. Ant is kind of like Make.