List of Tables

Chapter 1. Introducing Ant

Table 1.1. The release history of Ant. Major revisions come out every one to two years; minor revisions release every three to six months.

Chapter 2. A first Ant build

Table 2.1. The initial steps to building and running a program

Table 2.2. An Ant project should split source files, compiled classes files, and distribution packages into separate directories. This makes them much easier to manage during the build process.

Table 2.3. Ant command-line options

Chapter 3. Understanding Ant datatypes and properties

Table 3.1. Sun’s javac compared to Ant’s wrapper <javac> task. Note the similarities between the parameters. Also note Ant’s way of using domain-specific terminology for concepts such as classpath.

Table 3.2. Patternset attributes. Including and excluding patterns allows filesets to be defined precisely to encompass only the files desired.

Table 3.3. Default exclude patterns, which are used in filesets to match files that aren’t used, copied or deleted by default. If you want to add files that match these patterns to a fileset, then set defaultexcludes="no".

Table 3.4. Ant’s built-in selectors. Any fileset can be restricted by these selectors to choose only those files that match the specific tests.

Table 3.5. Ant’s built-in properties. Build files can rely on these being set, although sometimes IDE-hosted Ant runs can find that this isn’t always the case.

Table 3.6. Ant’s conditions. The list of tests began in Ant 1.4 and has grown over time to let you test everything from Ant’s version to the availability of remote computers.

Table 3.7. Ant properties set by the <tstamp> task, unless you provide a specific pattern

Chapter 4. Testing with JUnit

Table 4.1. Assertions that you can make in a JUnit test case

Table 4.2. Ant <junit> result formatters can output the test results in different ways.

Table 4.3. Options for the forkMode attribute of <junit>, controlling how often a new JVM is created during the run. The once and perBatch modes are fastest.

Chapter 5. Packaging projects

Table 5.1. Mapper types. Mappers implement file-renaming algorithms, telling tasks like <copy> how files should be renamed during the operation.

Table 5.2. Ways to specify packages to include. The final option, packagelist, is not usually used; it exists to make it easier to migrate from Ant.

Table 5.3. Extra attributes in <zipfileset> compared to a <fileset>

Table 5.4. Attributes in a <tarfileset> to set the user and group owners of files

Table 5.5. Values for the longfile attribute. Although optional, setting this attribute shows that you have chosen an explicit policy. Of the options, fail, gnu, and warn make the most sense.

Table 5.6. Ant’s built-in resources

Table 5.7. Resource collections: ways to group resources

Chapter 6. Executing programs

Table 6.1. The attributes of the <arg> element of <java>

Table 6.2. Operating system families recognized by Ant. The <os> condition accepts these in its family attribute, as does the osfamily attribute of <exec> and its descendants.

Table 6.3. Attributes of <java> and <exec> for sharing data with Ant

Table 6.4. Ant’s built-in FilterReaders

Chapter 7. Distributing our application

Table 7.1. Ant tasks that can help with distribution

Table 7.2. Libraries you need for the distribution tasks

Table 7.3. FTP operations allowed in the action attribute of the <ftp> task

Table 7.4. <mail> task attributes

Table 7.5. The attributes of the <get> command. The usetimestamp attribute for dependency-based downloads is valid only with HTTP.

Chapter 8. Putting it all together

Table 8.1. Common application types, their deliverables, and deployment routes. Ant can handle all of this, with help from other tools.

Table 8.2. Steps to migrate an existing project to Ant

Chapter 9. Beyond Ant’s core tasks

Table 9.1. Ant’s optional tasks. Most of these tasks require installation of additional components.

Table 9.2. Ant-supported SCM systems and their common operations

Table 9.3. The Logic/Execution tasks offered by Ant-contrib

Table 9.4. Property tasks of Ant-contrib

Table 9.5. Extra Ant-contrib conditions to use in build files

Table 9.6. Ant-contrib’s other tasks

Chapter 10. Working with big projects

Table 10.1. Subprojects within our example project

Table 10.2. Our unified set of entry points. These are implemented across all child projects.

Table 10.3. Comparing XML entity inclusion with Ant’s <import>

Chapter 11. Managing dependencies

Table 11.1. Ant tasks provided by Ivy 1.4.1. Expect more tasks in later releases

Table 11.2. Maven2’s dependency configurations, as interpreted by Ivy

Chapter 12. Developing for the Web

Table 12.1. Common content in web applications

Table 12.2. The primary elements of the <war> task

Table 12.3. Attributes for the <waitfor> task. The maximum wait time often needs tuning for the particular use.

Chapter 13. Working with XML

Table 13.1. Ways of describing XML documents

Chapter 14. Enterprise Java

Table 14.1. The different types of Enterprise JavaBeans

Table 14.2. Class fields and types and their database equivalent

Table 14.3. The dependencies in the compile configuration

Table 14.4. The Ant tasks of Cactus

Chapter 15. Continuous integration

Table 15.1. Some of the continuous-integration tools that work with Ant.

Table 15.2. The options to configure an Ant builder

Chapter 16. Deployment

Table 16.1. Keep deployment under control by integrating it with the development process

Table 16.2. Lifecycle actions that SmartFrog components support, and how they react

Table 16.3. Packages of SmartFrog components

Table 16.4. The tasks built into the SmartFrog sf-tasks Antlib

Chapter 17. Writing Ant tasks

Table 17.1. The mapping from API log levels to build file output levels

Table 17.2. The Ant tasks and types that come with AntUnit, excluding the assertions

Table 17.3. The assertions that come with AntUnit. All but <assertTrue> are actually built from <macrodef> statements.

Table 17.4. Methods that tasks can implement to support nested elements

Table 17.5. Useful methods in the Path class. It’s a resource collection, from which iterator() and add() are useful methods.

Chapter 18. Extending Ant further

Table 18.1. Scripting languages. The language name is used in the language attributes of Ant’s scripting tasks.

Table 18.2. The different BuildListener callbacks and the BuildEvent data they can expect. For all the finished events, a non-null exception inside the BuildEvent implies that the task, target, or build failed.

Appendix B. XML Primer

Table B.1. How to escape common characters so that the XML parser or Ant can use them