Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

@AfterClass, Managing the Test Lifecycle
@AfterMethod, Creating Simple Unit Tests with TestNG
@AfterSuite, Managing the Test Lifecycle
@BeforeClass, Managing the Test Lifecycle
@BeforeMethod, Creating Simple Unit Tests with TestNG
@BeforeSuite, Managing the Test Lifecycle
@SuppressWarnings, Using FindBugs Annotations
@Test, Creating Simple Unit Tests with TestNG

A

Abbot, Introducing FEST
AccountManage plug-in, Managing User Accounts–Managing User Accounts
add-maven-repo, Using Maven in Eclipse
aggregation, Project Inheritance and Aggregation
agile development, Preface, Unit Testing, Tracking Progress with Milestones
Agnew, Brian, Contributing Authors, Manipulating XML with XMLTask
AJAX, Using the Selenium IDE
Almost Plain Text (APT), APT–APT
annotations, Managing the Test Lifecycle, Using FindBugs Annotations–Using FindBugs Annotations
Ant
bootstrapping, Bootstrapping Your Build Scripts–Bootstrapping Your Build Scripts
build scripts, Basic Ant Concepts, A Simple Ant Build File–Running Ant
Checkstyle and, Using Checkstyle with Ant–Using Checkstyle with Ant
Cobertura and, Running Cobertura with Ant–Running Cobertura with Ant, Running Cobertura from Ant–Running Cobertura from Ant, Enforcing High Code Coverage
code coverage in, Enforcing High Code Coverage
compiling Java code, Compiling Your Java Code in Ant–Compiling Your Java Code in Ant
Continuum and, Adding an Ant Project–Adding an Ant Project
CruiseControl and, Configuring an Ant Project–Configuring an Ant Project
DbUnit and, Exporting a Dataset with Ant–Importing a Dataset with Ant
dependencies, Dependencies Between Targets–Dependencies Between Targets
dependency management, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File, Using Maven in Ant–Using Maven in Ant
depends attribute, Dependencies Between Targets
deployment, Deploying Your Application–Other Deployment Techniques
described, Build Tools, Ant in the Build Process–Ant in the Build Process
description attribute, Documenting Your Project
directory structure, A Simple Ant Build File–A Simple Ant Build File
documenting, Documenting Your Project–Documenting Your Project
Doxygen and, Using Doxygen with Ant–Using Doxygen with Ant
in Eclipse, Using Ant in Eclipse–Using Ant in Eclipse
FindBugs in, Using FindBugs in Ant–Using FindBugs in Ant
functional testing in, Using Selenium with Ant–Using Selenium with Ant
Hudson and, Building a Freestyle Project–Building a Freestyle Project
installing, Installing Ant–ANT_OPTS and ANT_ARGS: Some Other Useful Environment Variables
Javadoc and, Generating Documentation with Javadoc–Generating Documentation with Javadoc
JUnit and
assertions, Using Asserts in Your Test Cases–Using Asserts in Your Test Cases
build file, Using JUnit 4 with Ant–Using JUnit 4 with Ant
compiling unit tests, Preparing Your Build for Automated Tests–Preparing Your Build for Automated Tests, Using JUnit 4 with Ant–Using JUnit 4 with Ant
conditional tests, Running Tests Conditionally–Running Tests Conditionally
directory structure, Preparing Your Build for Automated Tests–Preparing Your Build for Automated Tests
forking, Running Tests in a Separate JVM–Running Tests in a Separate JVM
formatters, Using the <junit> Task–Using the <junit> Task
generating reports, Generating HTML Test Reports–Generating HTML Test Reports
haltonfailure attribute, Using the <junit> Task, Generating HTML Test Reports–Generating HTML Test Reports
junit task, Using the <junit> Task–Using the <junit> Task, Using JUnit 4 with Ant–Running Tests Conditionally
multiple test cases, Running Multiple Tests–Running Multiple Tests
overview, Using JUnit in Ant–Using JUnit in Ant
single tests, Selectively Running JUnit 4 Tests in Ant–Running Individual Tests
JUnitPerf and, Separating Performance Tests from Unit Tests in Ant–Separating Performance Tests from Unit Tests in Ant
Maven in, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File, Using Maven in Ant–Generating Ant Script from a POM
in Maven, Using Ant in Maven–Making Ant Plug-Ins
Maven tasks, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File
Maven vs., Maven and Ant–Maven and Ant, Using Ant in Maven
Mojos, Making Ant Plug-Ins
in NetBeans, Using Ant in NetBeans–Using Ant in NetBeans
packaging applications, Packaging Your Application–Generating a WAR File or an EAR File, Packaging the Dependencies–Packaging the Dependencies
path definitions, Compiling Your Java Code in Ant–Compiling Your Java Code in Ant
performance testing, Separating Performance Tests from Unit Tests in Ant–Separating Performance Tests from Unit Tests in Ant
plug-ins, Making Ant Plug-Ins–Making Ant Plug-Ins
PMD in, Using PMD in Ant–Using PMD in Ant
POM files and, The Maven 2.0 Ant Tasks, Using an Existing Maven POM File, Embedding Ant Code in the POM–Embedding Ant Code in the POM, Generating Ant Script from a POM–Generating Ant Script from a POM
projects, Basic Ant Concepts
properties, Basic Ant Concepts, Customizing Your Build Script Using Properties–Customizing Your Build Script Using Properties
proxy connections, ANT_OPTS and ANT_ARGS: Some Other Useful Environment Variables, Bootstrapping Your Build Scripts
QAlab and, Using QALab in Ant–Using QALab in Ant
SchemaSpy in, Using SchemaSpy in Ant–Using SchemaSpy in Ant
Selenium and, Using Selenium with Ant–Using Selenium with Ant
SoapUI and, Running SoapUI from Ant–Running SoapUI from Ant, Continuous Testing
StatSVN, Statistics in Ant with StatSVN–Generating the StatSVN Reports
Subversion in, Using Subversion in Ant–Creating a New Tag
targets, Basic Ant Concepts
tasks, Basic Ant Concepts–Basic Ant Concepts
TestNG and, Using TestNG in Ant–Using TestNG in Ant, Using Test Groups
UmlGraph in, Using UmlGraph in Ant–Using UmlGraph in Ant
unit testing, Running Unit Tests in Ant–Running Unit Tests in Ant, Using JUnit 4 with Ant–Running Tests Conditionally, Using TestNG in Ant–Using TestNG in Ant, Using Test Groups, Running Cobertura from Ant–Running Cobertura from Ant
XMLTask
controlling builds with, Driving Ant via XMLTask–Driving Ant via XMLTask
editing XML, Manipulating XML with XMLTask–DTDs and XMLTask, Changing encodings–Conclusion
ANT_ARGS, ANT_OPTS and ANT_ARGS: Some Other Useful Environment Variables
ANT_HOME, Installing Ant on a Unix Machine, Installing Ant on Windows
ANT_OPTS, ANT_OPTS and ANT_ARGS: Some Other Useful Environment Variables
Apache BCEL library, FindBugs: A Specialized Bug Killer
Apache Derby, An Introduction to Continuum
Apache Velocity, Velocity Manipulation
APT (Almost Plain Text), APT–APT
archetype plug-in, Creating a Project Template with Archetypes–Creating a Project Template with Archetypes
Archiva
adding files, Manually Deploying a File to an Archiva Repository–Manually Deploying a File to an Archiva Repository
browsing repositories, Browsing the Repository–Browsing the Repository
changing ports, Running Archiva on Another Port
configuring Maven, Using Maven with Archiva–Using Maven with Archiva
configuring repositories, Configuring Repositories in Archiva–Configuring Repositories in Archiva
installing, Installing Archiva–Installing Archiva
managing users, User Management–User Management
proxy connections, Archiva Proxy Connectors–Archiva Proxy Connectors, Configuring Archiva Behind a Proxy–Configuring Archiva Behind a Proxy
remote repositories, Setting Up Remote Repositories–Setting Up Remote Repositories
artifactId element, Project Context and Artifacts
Artifactory
adding artifacts, Installing Artifacts to the Repository–Installing artifacts from Maven command line
adding repositories, Adding Other Remote Repositories–Adding Other Remote Repositories
as mirror, Configure Maven using settings.xml
backing up repositories, Backing Up the Repository–Backing Up the Repository
configuring Maven, Configuring Maven to Use the New Repository–Building using the new Maven repository
configuring repositories, Set up the Maven repositories–Set up the Maven repositories
described, Setting Up an Enterprise Repository Using Artifactory–Setting Up an Enterprise Repository Using Artifactory
installing, Setting Up the Maven Repository Using Artifactory–Deploy in Tomcat 6
proxy connections, Running Artifactory Through a Proxy–Running Artifactory Through a Proxy
on Tomcat, Deploy in Tomcat 6
artifacts, Project Context and Artifacts–Project Context and Artifacts, Installing Artifacts to the Repository–Installing artifacts from Maven command line
assemblies, Creating Assemblies–Assemblies with Profiles
assertions
in JUnit, Using Asserts in Your Test Cases–Using Asserts in Your Test Cases, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
in Selenium, Using the Selenium IDE, Using assertions–Using assertions
in SoapUI, Web Service Testing, Testing Web Services with SoapUI–Testing Web Services with SoapUI, Load-Testing with SoapUI–Load-Testing with SoapUI
in TestNG, Creating Simple Unit Tests with TestNG
Atlassian, What This Book Doesn’t Cover
atomic commits, An Introduction to CVS
atomic tests, Load-Testing Tests That Are Not Thread-Safe
atomic updates, Revision Numbers and Atomic Updates
available task, Bootstrapping Your Build Scripts

B

backups
Artifactory, Backing Up the Repository–Backing Up the Repository
Subversion, Backing Up and Restoring a Subversion Repository–Backing Up and Restoring a Subversion Repository
Bamboo, What This Book Doesn’t Cover, Continuous Integration
batchtest task, Running Multiple Tests, Running Tests Conditionally
Beck, Kent, Unit Testing with JUnit 4
Berkeley DB, Subversion Repository Types–Subversion Repository Types
Beust, Cédric, Introducing TestNG, Introducing Jupiter—A Code Review Tool for Eclipse
bootstrapping, Bootstrapping Your Build Scripts–Bootstrapping Your Build Scripts, Advanced Archetypes
branch coverage, Interpreting the Cobertura Report–Interpreting the Cobertura Report
Broadcast plug-in, Extended Functionality with Openfire Plug-Ins
bug patterns, FindBugs: A Specialized Bug Killer
Bugzilla
classifications, Managing Groups of Products with Classifications–Managing Groups of Products with Classifications
configuring, Setting Up Your Bugzilla Environment
creating an issue, Creating a New Bug–Creating a New Bug
customizing fields, Customizing Fields in Bugzilla–Customizing Fields in Bugzilla
described, An Introduction to Bugzilla–An Introduction to Bugzilla
installing, Installing Bugzilla–Configuring the Web Server
milestones, Tracking Progress with Milestones–Tracking Progress with Milestones
Mylyn and, Sharing Context with Other Developers
notification options, Scheduling Notifications (Whining)–Scheduling Notifications (Whining)
searching for bugs, Searching for Bugs–Searching for Bugs
setting up a product, Configuring a Product–Configuring a Product
user accounts, Managing User Accounts–Managing User Accounts
user groups, Restricting Access Using User Groups–Restricting Access Using User Groups
whining, Managing User Accounts, Scheduling Notifications (Whining)–Scheduling Notifications (Whining)
workflow, The Lifecycle of a Bugzilla Bug–The Lifecycle of a Bugzilla Bug
build environment, Introduction–Introduction
build lifecycle, Understanding the Maven 2 Lifecycle–Understanding the Maven 2 Lifecycle, Manipulating the Build Lifecycle–Manipulating the Build Lifecycle
build loop, An Introduction to CruiseControl
build process, Build Tools–Build Tools
build scripts, Basic Ant Concepts, A Simple Ant Build File–Running Ant, Documenting Your Project–Documenting Your Project, Bootstrapping Your Build Scripts–Bootstrapping Your Build Scripts
build statistics, Introduction–Introduction, Introduction, Source Code Management Metrics with StatSCM–Source Code Management Metrics with StatSCM, Statistics in Ant with StatSVN–Generating the StatSVN Reports
(see also QAlab)
build tools, Build Tools (see Ant) (see Maven)
builds, declarative, An Introduction to Declarative Build Management
builds, parallel, Configuring Hudson

C

Cactus, Introduction
Cargo, Deploying an Application Using Cargo–Deploying an Application Using Cargo
cargo-maven2-plugin, Deploying an Application Using Cargo
change sets, Working with Your Files—Updating and Committing, Using the Eclipse Change Sets–Using the Eclipse Change Sets
Checkstyle
Ant and, Using Checkstyle with Ant–Using Checkstyle with Ant
customizing, Customizing Checkstyle Rules in Eclipse–Customizing Checkstyle Rules Using the XML Configuration Files
defining headers, Defining Rules for Source Code Headers with Checkstyle–Defining Rules for Source Code Headers with Checkstyle
described, Quality Metrics Tools–Quality Metrics Tools, Using Checkstyle to Enforce Coding Standards–Using Checkstyle to Enforce Coding Standards
IDE options, Using Checkstyle in Eclipse
installing, Using Checkstyle in Eclipse–Using Checkstyle in Eclipse
Maven and, Using Checkstyle with Maven–Using Checkstyle with Maven
rules, Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use–Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use
running, Using Checkstyle in Eclipse–Using Checkstyle in Eclipse
setting up a project, Using Checkstyle in Eclipse–Using Checkstyle in Eclipse
suppressing violations, Suppressing Checkstyle Tests–Suppressing Checkstyle Tests
classifier element, Project Context and Artifacts
ClearSilver, Installing Trac–Installing Trac
Clover, What This Book Doesn’t Cover
Cobertura
Ant and, Running Cobertura with Ant–Running Cobertura with Ant, Running Cobertura from Ant–Running Cobertura from Ant, Enforcing High Code Coverage
coverage types, Interpreting the Cobertura Report–Interpreting the Cobertura Report
described, Test Coverage–Test Coverage
Eclipse and, Code Coverage in Eclipse–Code Coverage in Eclipse
enforcing coverage, Enforcing High Code Coverage–Enforcing High Code Coverage, Integrating Coverage Tests into the Maven Build Process–Integrating Coverage Tests into the Maven Build Process
generating XML reports, Running Cobertura from Ant
Hudson and, Reporting on Code Coverage–Reporting on Code Coverage
installing, Running Cobertura from Ant
Luntbuild and, Reporting on Test Coverage in Luntbuild Using Cobertura–Using the Extension
Maven and, Testing Your Code, Generating Cobertura Reports in Maven–Integrating Coverage Tests into the Maven Build Process, Generating Cobertura Reports in Maven
TestNG and, Checking the Code Coverage of TestNG Tests–Checking the Code Coverage of TestNG Tests
viewing results, Interpreting the Cobertura Report–Interpreting the Cobertura Report
cobertura plug-in, Testing Your Code
cobertura-check task, Enforcing High Code Coverage
cobertura-maven-plugin, Generating Cobertura Reports in Maven
Cockburn, Alistair, Preface
code analysis, Quality Metrics Tools, Quality Metrics Tools, Quality Metrics Tools–Quality Metrics Tools, Code Analysis Reports–Code Analysis Reports
(see also FindBugs)
(see also PMD)
code coverage
in Ant, Enforcing High Code Coverage
described, Unit Testing, Test Coverage–Test Coverage
in Eclipse, Code Coverage in Eclipse–Code Coverage in Eclipse
enforcing, Enforcing High Code Coverage–Enforcing High Code Coverage, Integrating Coverage Tests into the Maven Build Process–Integrating Coverage Tests into the Maven Build Process
in Hudson, Reporting on Code Coverage–Reporting on Code Coverage
in LuntBuild, Introduction
in Maven, Generating Cobertura Reports in Maven–Integrating Coverage Tests into the Maven Build Process
on Maven project web site, Test Coverage Reports
TestNG and, Checking the Code Coverage of TestNG Tests–Checking the Code Coverage of TestNG Tests
in TPTP, Basic Profiling with TPTP, Displaying Coverage Statistics–Displaying Coverage Statistics
types of, Interpreting the Cobertura Report–Interpreting the Cobertura Report
code coverage tools (see Cobertura) (see Emma)
code metrics, Introduction, Source Code Management Metrics with StatSCM–Generating the StatSVN Reports
(see also QAlab)
code quality, Quality Metrics Tools, Keeping Track of Code Metrics–Keeping Track of Code Metrics, Quality Metrics Tools, Quality Metrics Tools
(see also FindBugs)
(see also PMD)
code review phases, Conducting Personal Code Reviews–Conducting Personal Code Reviews
code reviews, Quality Metrics Tools, Introducing Jupiter—A Code Review Tool for Eclipse, Introducing Jupiter—A Code Review Tool for Eclipse–Introducing Jupiter—A Code Review Tool for Eclipse, Configuration–Configuration, Conclusion
(see also Jupiter)
coding standards, Quality Metrics Tools, Quality Metrics Tools–Quality Metrics Tools, Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use
(see also Checkstyle)
Coenradie, Jettro, Contributing Authors
Cohen, Frank, Introduction
CollabNet, An Introduction to Subversion
collaboration diagrams, The Doxygen Reports
Conradie, Jettro, Reporting on Test Coverage in Luntbuild Using Cobertura, Integrating Luntbuild with Maven
context, Sharing Context with Other Developers–Sharing Context with Other Developers
context (Maven), Project Context and Artifacts–Project Context and Artifacts
context (Mylyn), Focusing on a Task with Context Management–Focusing on a Task with Context Management
continuous integration, Continuous Integration Tools, Continuous Integration–Continuous Integration, Continuous Integration, Continuous Integration, Continuous Integration, Continuous Integration
(see also Continuum)
(see also CruiseControl)
(see also Hudson)
(see also LuntBuild)
Continuum
Ant and, Adding an Ant Project–Adding an Ant Project
builds, Managing Your Project Builds–Managing Your Project Builds, Configuring and Scheduling Builds–Debugging Your Builds, Configuring a Manual Build Task–Configuring a Manual Build Task
checking status, Checking the Status of the Server–Checking the Status of the Server
console mode, Running the Continuum Server in Verbose Mode–Running the Continuum Server in Verbose Mode
custom projects, Adding a Shell Project–Adding a Shell Project
described, Continuous Integration, An Introduction to Continuum
installing, Installing a Continuum Server–Installing a Continuum Server
Maven in, Adding a Maven Project–Adding a Maven Project
Maven project website, Automatically Generating a Maven Site with Continuum–Automatically Generating a Maven Site with Continuum
notification options, Setting Up Notifiers–Setting Up Notifiers, Configuring the Continuum Mail Server–Configuring the Continuum Mail Server
Openfire and, Using Openfire with Continuum–Using Openfire with Continuum
ports, Configuring the Continuum Web Site Ports–Configuring the Continuum Web Site Ports
projects, Adding a Project Group–Adding a Shell Project
SoapUI and, Continuous Testing
starting/stopping, Installing a Continuum Server, Manually Starting and Stopping the Server–Manually Starting and Stopping the Server
user management, Managing Users–Managing Users
verbose mode, Running the Continuum Server in Verbose Mode–Running the Continuum Server in Verbose Mode
version control options, Adding a Maven Project–Adding a Maven Project
as Windows service, Installing a Continuum Server
copy task, Copying Files
Coughtrey, Keith, Contributing Authors, Introduction to Mylyn
CPD (Cut-and-Paste Detector), Detecting Cut-and-Paste with CPD–Detecting Cut-and-Paste with CPD
cron syntax, Configuring and Scheduling Builds
cross-browser compatibility, Introduction
Crucible, What This Book Doesn’t Cover, Conclusion
CruiseControl
adding projects, Configuring an Ant Project–Configuring an Ant Project
Ant and, Configuring an Ant Project–Configuring an Ant Project
build loop, An Introduction to CruiseControl
config.xml file, Configuring an Ant Project–Configuring an Ant Project
Configuration UI, CruiseControl Configuration Tool–CruiseControl Configuration Tool
configuring projects, Configuring an Ant Project–Configuring an Ant Project
dashboard, The CruiseControl Dashboard–The CruiseControl Dashboard
described, Continuous Integration, An Introduction to CruiseControl–An Introduction to CruiseControl
Firefox plug-in, Firefox and Thunderbird Integration
installing, Installing CruiseControl–Installing CruiseControl
JUnit and, Configuring an Ant Project
Maven and, Setting Up a Maven 2 Project in CruiseControl–Setting Up a Maven 2 Project in CruiseControl
monitoring builds, Configuring an Ant Project–Configuring an Ant Project, The CruiseControl Dashboard–The CruiseControl Dashboard
notification options, Keeping People Notified with Publishers–Keeping People Notified with Publishers
Openfire and, Using Openfire with CruiseControl–Using Openfire with CruiseControl
ports, Installing CruiseControl
properties, Configuring an Ant Project
scheduling builds, Configuring an Ant Project–Configuring an Ant Project
setting up projects, Configuring an Ant Project–Configuring an Ant Project
Thunderbird plug-in, Firefox and Thunderbird Integration
unit tests and, Configuring an Ant Project
version control options, Configuring an Ant Project
wrappers, Configuring an Ant Project
Cut-and-Paste Detector (CPD), Detecting Cut-and-Paste with CPD–Detecting Cut-and-Paste with CPD
CVS
binary file handling, Working with Binary Files–Working with Binary Files
branches, Creating Branches in CVS–Merging Changes from a Branch
change sets, Using the Eclipse Change Sets
checking out files, Checking Out a Project–Checking Out a Project
committing changes, Working with Your Files—Updating and Committing–Working with Your Files—Updating and Committing
creating a repository, Setting Up a CVS Repository–Setting Up a CVS Repository
deleting local copies, Working with Your Files—Updating and Committing
described, An Introduction to CVS–An Introduction to CVS
in Windows, Setting Up a CVS Repository
keyword substitution, Working with Keyword Substitution–Working with Keyword Substitution
projects, Creating a New Project in CVS–Creating a New Project in CVS
remote access, Checking Out a Project
resolving conflicts, Working with Your Files—Updating and Committing–Working with Your Files—Updating and Committing
reverting changes, Reverting Changes–Reverting Changes
tagging, Tags in CVS–Tags in CVS
tracking changes, Revision Numbers and Atomic Updates–Revision Numbers and Atomic Updates
unlocking a repository, Resolving a Locked Repository–Resolving a Locked Repository
updating local copies, Working with Your Files—Updating and Committing–Working with Your Files—Updating and Committing
viewing change history, Viewing Change History–Viewing Change History
vs. Subversion, An Introduction to CVS
in Windows, Using CVS in Windows–Using CVS in Windows
cvs add, Working with Your Files—Updating and Committing
cvs annotate, Viewing Change History
cvs checkout, Checking Out a Project
cvs diff, Reverting Changes
cvs import, Creating a New Project in CVS
cvs init, Setting Up a CVS Repository
cvs log, Viewing Change History
cvs login, Creating a New Project in CVS
cvs rm, Working with Your Files—Updating and Committing
cvs tag, Tags in CVS
cvs update, Working with Your Files—Updating and Committing, Reverting Changes
CVSNT, Setting Up a CVS Repository
CVSROOT (variable), Creating a New Project in CVS
cvswrappers file, Working with Binary Files

D

data-driven testing, Test Parameters and Data-Driven Testing–Test Parameters and Data-Driven Testing, Web Service Testing
database schemas (see SchemaSpy)
database testing, Introduction, Basic Profiling with TPTP
(see also DbUnit)
DbUnit
Ant and, Exporting a Dataset with Ant–Importing a Dataset with Ant
base classes, DbUnit Structure–ITableMetaData
data types, Dealing with Custom Data Types–Specifying an INTERVALDS Data Type
datasets, IDataSet–IDataSet, Verifying Querying a Single Row, Using an XLS Dataset–Using an InlineDataSet
dependency injection, Injecting the Test Fixture–Injecting the Test Fixture
described, Introduction–Purpose of DbUnit
installing, Setting Up DbUnit–Running with DbUnit
priming the database, Priming the Database–Verifying Querying a Single Row, Specifying NULLs by Omission–Specifying NULLs by DTD
replacing values, Replacing Values–Using an Image ValueReplacer
testing stored procedures, Testing a Stored Procedure–Testing a Stored Procedure
testing views, Testing a View–Testing a View
transaction rollback teardown, Using Transaction Rollback Teardown–Using Transaction Rollback Teardown, Importing a Dataset with Ant
verifying database actions, Verifying Querying a Single Row–Verifying Querying Multiple Rows, Verifying an UPDATE–Verifying an INSERT, with the Key
deadlocks, Recording and Displaying Test Results, Detecting Deadlocks–Detecting Deadlocks
debugging, Compiling Your Java Code in Ant, Using the <junit> Task, Debugging Your Builds–Debugging Your Builds, Getting More Details with the View Results Tree Listener, Quality Metrics Tools
(see also FindBugs)
declarative builds, An Introduction to Declarative Build Management
decorator pattern, Measuring Performance with TimedTests
dependencies
declaring, Dependencies Between Targets–Dependencies Between Targets, An Introduction to Declarative Build Management, Declaring Dependencies–Declaring Dependencies, Refactoring Your Dependencies Using Properties–Refactoring Your Dependencies Using Properties
identifying, Looking for Dependencies with MvnRepository–Looking for Dependencies with MvnRepository
in plug-ins, External Dependencies–External Dependencies
packaging, Packaging the Dependencies–Packaging the Dependencies
proprietary, Handling Proprietary Dependencies–Handling Proprietary Dependencies
scope, Dependency Scope–Dependency Scope
in TestNG, Using TestNG with Maven 2, Managing the Test Lifecycle, Managing Dependencies–Managing Dependencies
transitive, Using Maven Dependencies in Ant with the Maven Tasks, Managing Dependencies, Managing Transitive Dependencies–Managing Transitive Dependencies
dependency graph, Dependencies Between Targets
dependency injection, Injecting the Test Fixture–Injecting the Test Fixture
dependency management
Ant, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File
Maven, Managing Dependencies–Managing Dependencies
TestNG, Managing Dependencies–Managing Dependencies
dependency rules, Build Tools
dependency tree, Managing Transitive Dependencies
depends attribute, Dependencies Between Targets
deployment
Ant, Deploying Your Application–Other Deployment Techniques
Cargo, Deploying an Application Using Cargo–Deploying an Application Using Cargo
Maven, Packaging and Deploying Your Application–Packaging and Deploying Your Application
diagrams, UML, The Doxygen Reports, Embedding UML Diagrams in Your Javadoc with UmlGraph–Using UmlGraph in Maven
directory structure
Ant, A Simple Ant Build File–A Simple Ant Build File
Maven, Maven and the Development Build Process, The Maven Directory Structure
Subversion, Setting Up a New Subversion Project–Setting Up a New Subversion Project, Working with Your Local Copy–Working with Your Local Copy
WAR files, Generating a WAR File or an EAR File
documentation, Technical Documentation Tools, Documenting Your Project–Documenting Your Project, Generating Documentation with Javadoc, Technical Documentation Tools, Technical Documentation Tools, Technical Documentation Tools, Technical Documentation Tools–Technical Documentation Tools, The Maven 2 Project Web Site As a Communication Tool, Introduction, Documenting packages–Documenting packages, Conclusion
(see also Doxygen)
(see also Javadoc)
(see also Maven project website)
(see also SchemaSpy)
(see also UmlGraph)
Doxia, Doxia, Using Snippets–Using Snippets
Doxygen
in Ant, Using Doxygen with Ant–Using Doxygen with Ant
coding tips, How to Make Your Java Classes Doxygen-Friendly–Documenting the home page
configuring, Configuring Doxygen–Configuring Doxygen
described, Introduction–The Doxygen Reports
Doxywizard, Configuring Doxygen–Configuring Doxygen
installing, Installing Doxygen–Installing Doxygen
running, Running Doxygen from the Command Line–Running Doxygen from the Command Line
DRY principle, Customizing Your Build Script Using Properties

E

EAR files, Generating a WAR File or an EAR File
EclEmma, Code Coverage in Eclipse–Code Coverage in Eclipse
Eclipse
Ant and, Using Ant in Eclipse–Using Ant in Eclipse
change sets, Using the Eclipse Change Sets–Using the Eclipse Change Sets
Checkstyle in, Using Checkstyle in Eclipse–Customizing Checkstyle Rules in Eclipse
Cobertura and, Code Coverage in Eclipse–Code Coverage in Eclipse
code coverage in, Code Coverage in Eclipse–Code Coverage in Eclipse
Findbugs in, Using FindBugs in Eclipse–Installing the FindBugs Plug-In
JUnit 4 and, Using JUnit 4 in Eclipse–Using JUnit 4 in Eclipse
Jupiter in, Installing Jupiter in Eclipse–Installing Jupiter in Eclipse
LuntBuild and, Using LuntBuild with Eclipse–Using LuntBuild with Eclipse
Maven and, Using Maven in Eclipse–Using Maven in Eclipse
Mylyn in, Installing Mylyn–Installing Mylyn
PMD in, Using PMD in Eclipse–Installing the PMD Plug-In, Configuring PMD Rules in Eclipse–Configuring PMD Rules in Eclipse
SoapUI in, Installing SoapUI
Subversion and, Working with Your Local Copy, Using Subversion in Eclipse–Branching and Merging
TestNG and, The TestNG Eclipse Plug-In–Running TestNG Tests
unit tests, Using JUnit 4 in Eclipse–Using JUnit 4 in Eclipse, The TestNG Eclipse Plug-In–Running TestNG Tests
eclipse (plug-in), Using Maven in Eclipse–Using Maven in Eclipse
Eclipse Test & Performance Tools Platform (TPTP) (see TPTP)
Emma, Code Coverage in Eclipse
errorproperty attribute, Generating HTML Test Reports
Eviware, Introduction
exceptions, Checking for Exceptions–Checking for Exceptions

F

failureproperty attribute, Generating HTML Test Reports
FAQ Markup Language, FML–FML
FEST
creating tests, Testing GUIs with FEST–Testing GUIs with FEST
described, Integration, Functional, Load, and Performance Testing, Introducing FEST–Introducing FEST
identifying GUI objects, Testing GUIs with FEST–Testing GUIs with FEST, Testing Legacy Applications–Testing Legacy Applications
JUnit and, Verifying Test Failures–Verifying Test Failures
specifying following windows, Following Windows with FEST–Following Windows with FEST
TestNG and, Testing GUIs with FEST, Verifying Test Failures–Verifying Test Failures
viewing failed tests, Verifying Test Failures–Verifying Test Failures
FindBugs
annotations, Using FindBugs Annotations–Using FindBugs Annotations
Ant and, Bootstrapping Your Build Scripts
in Ant, Using FindBugs in Ant–Using FindBugs in Ant
build integration, FindBugs: A Specialized Bug Killer
described, Quality Metrics Tools, FindBugs: A Specialized Bug Killer–FindBugs: A Specialized Bug Killer
filtering, Selectively Suppressing Rules with FindBug Filters–Selectively Suppressing Rules with FindBug Filters, Using FindBugs in Ant
increasing memory for, Using FindBugs in Maven
installing, Using FindBugs in Eclipse–Installing the FindBugs Plug-In
jvmArgs, Using FindBugs in Ant, Using FindBugs in Maven
in Maven, Using FindBugs in Maven–Using FindBugs in Maven
suppressing violations, Using FindBugs Annotations
viewing results, Detecting and Displaying Errors–Detecting and Displaying Errors
FireBug, Referring to objects on the web page
Firefox plug-in, Firefox and Thunderbird Integration
FishEye, What This Book Doesn’t Cover
fixture code, Managing the Test Lifecycle–Managing the Test Lifecycle, Managing Dependencies
Fixtures for Easy Software Testing (FEST) (see FEST)
FML, FML–FML
fork attribute, Running Tests in a Separate JVM
formatters, Using the <junit> Task–Using the <junit> Task
FSFS, Subversion Repository Types, Subversion Repository Types–Subversion Repository Types
ftp task, Other Deployment Techniques
functional testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing
(see also FEST)
(see also Selenium)
(see also SoapUI)
in Ant, Using Selenium with Ant–Using Selenium with Ant
described, Integration, Functional, Load, and Performance Testing–Integration, Functional, Load, and Performance Testing
in Maven, Using Selenium with Maven–Using Selenium with Maven
TestNG and, Verifying Test Failures–Verifying Test Failures

G

Gamma, Erich, Unit Testing with JUnit 4
get task, Bootstrapping Your Build Scripts
Glover, Andrew, Foreword, Checking the Code Coverage of TestNG Tests
graphs, Installing SchemaSpy, Embedding UML Diagrams in Your Javadoc with UmlGraph–Using UmlGraph in Maven
Graphviz, Installing SchemaSpy, Installing Doxygen
Groovy, Web Service Testing, Testing Web Services with SoapUI, Introducing FEST
groupId element, Project Context and Artifacts
GUI testing, Introduction, Introduction–Introduction, Testing Swing GUIs with FEST, Introduction–Testing GUIs Is Hard
(see also FEST)
(see also Selenium)
GUIs, Tips for Writing Testable GUIs–Tips for Writing Testable GUIs

H

haltonfailure attribute, Using the <junit> Task, Generating HTML Test Reports
Hamcrest library, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
headless testing, Web Service Testing
heap dumps, Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat–Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat
heap memory, Detecting and Identifying Memory Leaks with the JDK Tools–Detecting and Identifying Memory Leaks with the JDK Tools
Heesch, Dimitri van, Introduction
Hoare, Tony, Introducing JUnitPerf
hook scripts, Customizing Subversion with Hook Scripts–Customizing Subversion with Hook Scripts, Updating Trac Issues from Subversion
HSQLDB, Basic Profiling with TPTP
HTTP error codes, Getting More Details with the View Results Tree Listener
HttpUnit, Introduction
Hudson
Ant and, Building a Freestyle Project–Building a Freestyle Project
Cobertura and, Reporting on Code Coverage–Reporting on Code Coverage
code coverage options, Reporting on Code Coverage–Reporting on Code Coverage
code quality options, Keeping Track of Code Metrics–Keeping Track of Code Metrics
configuring, Configuring Hudson–Configuring Hudson
creating build projects, Adding a New Build Job–Adding a New Build Job
described, Continuous Integration, An Introduction to Hudson–An Introduction to Hudson
home directory, Managing the Hudson Home Directory–Managing the Hudson Home Directory
installing, Installing Hudson–Managing the Hudson Home Directory
issue management options, Viewing Changes
JUnit and, Keeping Track of Test Results–Keeping Track of Test Results
managing builds, Organizing Your Jobs–Monitoring Your Builds
Maven and, Building a Maven Project–Building a Maven Project
monitoring builds, Monitoring Your Builds–Monitoring Your Builds
notification options, Building a Freestyle Project
parallel builds, Configuring Hudson
plug-ins, Hudson Plug-Ins–Hudson Plug-Ins, Keeping Track of Code Metrics–Keeping Track of Code Metrics
ports, Installing Hudson
scheduling builds, Building a Freestyle Project–Building a Freestyle Project
security, Configuring Hudson, Authentication and Security–Authentication and Security
tagging, Building a Freestyle Project, Viewing and Promoting a Particular Build–Viewing and Promoting a Particular Build
unit tests in, Keeping Track of Test Results–Keeping Track of Test Results
upgrades, Installing Upgrades–Installing Upgrades
user management, Managing Users–Managing Users
version control options, Configuring Hudson
viewing build details, Viewing and Promoting a Particular Build–Viewing and Promoting a Particular Build
viewing changes, Viewing Changes–Viewing Changes
Hurst, John, Contributing Authors, Introduction

I

infinite loops, Simple Performance Testing Using Timeouts
integrated development environment (IDE), Build Tools
“Integration Hell”, Continuous Integration
integration testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing
(see also DbUnit)
(see also StrutsTestCase)
described, Integration, Functional, Load, and Performance Testing–Integration, Functional, Load, and Performance Testing
JUnit 4, Integration Tests–Integration Tests
Maven and, Integration Tests
IntelliJ, What This Book Doesn’t Cover, The TestNG Eclipse Plug-In, Installing SoapUI
interactive test cases, Web Service Testing
interval notation, Declaring Dependencies
issue management, Issue Management Tools, Issue Management Tools
(see also Bugzilla)
(see also Trac)
described, Issue Management Tools, Issue Management Tools–Issue Management Tools
in Hudson, Viewing Changes
in Mylyn, Interacting with Task Repositories–Interacting with Task Repositories
in Mylyn, Sharing Context with Other Developers
in Subversion, Defect Tracking and Change Control–Defect Tracking and Change Control
Ivy, Using Maven Dependencies in Ant with the Maven Tasks

J

J2EE application architecture, Testing a Struts Application–Testing a Struts Application
Jabber (XMPP protocol), Instant Messaging in a Development Project, Using Openfire with CruiseControl–Sending Jabber Messages from a Java Application Using the Smack API
JAR files, Generating a JAR File–Generating a JAR File
jar task, Generating a JAR File
Java code, compiling, Compiling Your Java Code in Ant–Compiling Your Java Code in Ant, Customizing Your Build Process, Compiling Code–Compiling Code
Java Monitoring and Management Console (see jConsole)
Java Power Tools web site, Source Code
JavaBeans, Extending Luntbuild with Extension Points–Extending Luntbuild with Extension Points, More on the PMD Rulesets, Suppressing PMD Rules
javac task, Compiling Your Java Code in Ant–Compiling Your Java Code in Ant
JavaDB/Derby, Basic Profiling with TPTP
Javadoc
Ant and, Generating Documentation with Javadoc–Generating Documentation with Javadoc
in Checkstyle, Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use
on Maven project web site, Javadocs–Javadocs
SoapUI and, Running SoapUI from Ant–Running SoapUI from Ant
UML diagrams in, Embedding UML Diagrams in Your Javadoc with UmlGraph–Using UmlGraph in Maven
javadoc task, Generating Documentation with Javadoc
JAVA_HOME, Installing Ant on a Unix Machine
JCommon library, Using QALab in Ant
jConsole
detecting deadlocks, Detecting Deadlocks–Detecting Deadlocks
detecting memory leaks, Detecting and Identifying Memory Leaks with the JDK Tools–Detecting and Identifying Memory Leaks with the JDK Tools
finding process IDs, Connecting To and Monitoring a Java Application with jConsole–Connecting To and Monitoring a Java Application with jConsole
monitoring Java applications, Connecting To and Monitoring a Java Application with jConsole–Connecting To and Monitoring a Java Application with jConsole
monitoring Tomcat applications, Monitoring a Remote Tomcat Application with jConsole–Monitoring a Remote Tomcat Application with jConsole
JetBrains, What This Book Doesn’t Cover
Jetty web server, An Introduction to Continuum, Installing CruiseControl
JFreeChart library, Using QALab in Ant
jhat, Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat–Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat
JIRA, What This Book Doesn’t Cover, Issue Management Tools
jmap, Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat–Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat
JMeter
configuration elements, Setting Up the HTTP Request Configuration Elements–Setting Up the HTTP Request Configuration Elements
described, Introduction–Introduction, Introduction
HTTP requests, Setting Up the HTTP Request Configuration Elements–Adding an HTTP Request
installing, Installing JMeter–Installing JMeter
listeners, Recording and Displaying Test Results–Getting the Executive Summary
Logic Controllers, Structuring Your Test Case–Structuring Your Test Case
recording test cases, Using the JMeter Proxy to Record a Test Case–Using the JMeter Proxy to Record a Test Case
samplers, Adding an HTTP Request
scheduling tests, Scheduling Your Tests–Scheduling Your Tests
testing on multiple machines, Testing on Multiple Machines–Testing on Multiple Machines
thread groups, Setting Up a Thread Group–Setting Up a Thread Group
timer controllers, Structuring Your Test Case–Structuring Your Test Case
variables, Testing Using Variables–Testing Using Variables
viewing results, Recording and Displaying Test Results–Getting the Executive Summary
web application testing, Testing a Simple Web Application–Adding an HTTP Request
JProbe, Conclusion
JUnit 4
@After, Setting Up and Optimizing Your Unit Test Cases
@AfterClass, Setting Up and Optimizing Your Unit Test Cases
@Before, Setting Up and Optimizing Your Unit Test Cases
@BeforeClass, Setting Up and Optimizing Your Unit Test Cases
@Test, Simple Performance Testing Using Timeouts
in Ant
assertions, Using Asserts in Your Test Cases–Using Asserts in Your Test Cases
build file, Using JUnit 4 with Ant–Using JUnit 4 with Ant
compiling unit tests, Preparing Your Build for Automated Tests–Preparing Your Build for Automated Tests, Using JUnit 4 with Ant–Using JUnit 4 with Ant
conditional tests, Running Tests Conditionally–Running Tests Conditionally
directory structure, Preparing Your Build for Automated Tests–Preparing Your Build for Automated Tests
forking, Running Tests in a Separate JVM–Running Tests in a Separate JVM
formatters, Using the <junit> Task–Using the <junit> Task
generating reports, Generating HTML Test Reports–Generating HTML Test Reports
haltonfailure attribute, Using the <junit> Task, Generating HTML Test Reports–Generating HTML Test Reports
junit task, Using the <junit> Task–Using the <junit> Task, Using JUnit 4 with Ant–Running Tests Conditionally
multiple test cases, Running Multiple Tests–Running Multiple Tests
overview, Using JUnit in Ant–Using JUnit in Ant
single tests, Selectively Running JUnit 4 Tests in Ant–Running Individual Tests
assertions, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
CruiseControl and, Configuring an Ant Project
Eclipse and, Using JUnit 4 in Eclipse–Using JUnit 4 in Eclipse
exceptions, Checking for Exceptions the Easy Way–Checking for Exceptions the Easy Way
FEST and, Verifying Test Failures–Verifying Test Failures
generating reports, Generating HTML Test Reports–Generating HTML Test Reports
Hamcrest library, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
Hudson and, Keeping Track of Test Results–Keeping Track of Test Results
integration tests, Integration Tests–Integration Tests
vs. JUnit 3, Running Multiple Tests
vs. JUnit 3, JUnit 3.8 and JUnit 4–Unit Testing with JUnit 4
LuntBuild and, Introduction
matchers, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
Maven and, Testing Your Code, Using JUnit 4 with Maven 2–Using JUnit 4 with Maven 2, Integration Tests
parameterized tests, Running Multiple Tests, Using Parameterized Tests–Using Parameterized Tests
test cases, Setting Up and Optimizing Your Unit Test Cases–Setting Up and Optimizing Your Unit Test Cases
test libraries, Using JUnit 4 with Maven 2
theories, JUnit 4 Theories–JUnit 4 Theories
timeouts, Simple Performance Testing Using Timeouts–Simple Performance Testing Using Timeouts
junit task, Using JUnit in Ant, Using the <junit> Task–Using the <junit> Task, Using JUnit 4 with Ant–Running Tests Conditionally
JUnitPerf
Ant and, Separating Performance Tests from Unit Tests in Ant–Separating Performance Tests from Unit Tests in Ant
decorator pattern, Measuring Performance with TimedTests
described, Introducing JUnitPerf–Introducing JUnitPerf
load tests, SimulatingLoad with LoadTests–Load-Testing Tests That Are Not Thread-Safe
in Maven, Separating Performance Tests from Unit Tests in Maven–Separating Performance Tests from Unit Tests in Maven
test suites, Measuring Performance with TimedTests
timed tests, Measuring Performance with TimedTests–Measuring Performance with TimedTests
TPTP and, Basic Profiling with TPTP–Basic Profiling with TPTP
junitreport task, Generating HTML Test Reports–Generating HTML Test Reports
Jupiter
code review phases, Conducting Personal Code Reviews–Conducting Personal Code Reviews, Individual Reviews–Rework Phase
configuring reviews, Configuration–Configuration
described, Quality Metrics Tools, Introducing Jupiter—A Code Review Tool for Eclipse
individual reviews, Individual Reviews–Individual Reviews
installing, Installing Jupiter in Eclipse–Installing Jupiter in Eclipse
personal reviews, Conducting Personal Code Reviews–Conducting Personal Code Reviews
review checklist, Conducting Personal Code Reviews
review files, Jupiter Behind the Scenes–Jupiter Behind the Scenes
review process, Understanding the Jupiter Code Review Process–Understanding the Jupiter Code Review Process
rework phase, Rework Phase–Rework Phase
setting defaults, Setting Up Default Configuration Values–Setting Up Default Configuration Values
team reviews, Team Review–Team Review
JVM profiling interface (JVMPI), TPTP and Java 6
JVM tool interface (JVMTI), TPTP and Java 6

K

Kalali, Masoud, Contributing Authors, An Introduction to SoapUI, An Overview of SchemaSpy, Using SchemaSpy
Kawaguchi, Kohsuke, An Introduction to Hudson
Kumar, Karthik, Using Doxygen with Ant

L

libraries
Hamcrest, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
JCommon, Using QALab in Ant
JFreeChart, Using QALab in Ant
JUnit tests, Using JUnit 4 with Maven 2
Maven, Dependency Management in Maven 2
line coverage, Interpreting the Cobertura Report
listeners (JMeter), Recording and Displaying Test Results–Getting the Executive Summary
load testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing, Introduction–Introduction
(see also JMeter)
(see also SoapUI)
LuntBuild
build languages, Builders
Cobertura and, Reporting on Test Coverage in Luntbuild Using Cobertura–Using the Extension
code coverage options, Introduction
configuring, Configuring the LuntBuild Server–Configuring the LuntBuild Server
configuring a build, Builders–Builders
configuring a project, Configuring the Project Basics–VCS Adaptors
creating a project, Adding a Project–Adding a Project
described, Continuous Integration, An Introduction to LuntBuild
Eclipse and, Using LuntBuild with Eclipse–Using LuntBuild with Eclipse
extending with JavaBean, Extending Luntbuild with Extension Points–Extending Luntbuild with Extension Points
installing, Installing LuntBuild–Installing LuntBuild
JUnit and, Introduction
logfiles, Build Results Diagnostics
Maven project website and, Integrating Luntbuild with Maven–Luntbuild Configuration
modules, VCS Adaptors
naming builds, Scheduling, Using Project Variables for Version Numbering–Using Project Variables for Version Numbering
notification options, Configuring the LuntBuild Server–Configuring the LuntBuild Server, Configuring the Project Basics–Configuring the Project Basics
Openfire and, Using Openfire with Luntbuild–Using Openfire with Luntbuild
project variables, Configuring the Project Basics, Using Project Variables for Version Numbering–Using Project Variables for Version Numbering
quiet time, VCS Adaptors
scheduling a build, Scheduling–Scheduling
tracking revisions, Build Results Diagnostics–Build Results Diagnostics
unit test options, Introduction
user management, Configuring the LuntBuild Server–Configuring the LuntBuild Server, Configuring the Project Basics–Configuring the Project Basics
version control integration, Build Results Diagnostics–Build Results Diagnostics
version control options, VCS Adaptors–VCS Adaptors, Login Mapping–Login Mapping
viewing build results, Build Results Diagnostics–Build Results Diagnostics
Luntclipse plug-in, Using LuntBuild with Eclipse–Using LuntBuild with Eclipse

M

m2eclipse plug-in, Using Maven in Eclipse
M2_REPO, Using Maven in Eclipse
makefiles, Build Tools–Build Tools
Mangat, Avneet, Contributing Authors, Setting Up an Enterprise Repository Using Artifactory
MANIFEST.MF file, Generating a JAR File, Generating a WAR File or an EAR File
matchers, Using assertThat and the Hamcrest Library–Using assertThat and the Hamcrest Library
Maven
aggregation, Project Inheritance and Aggregation
Ant in, Using Ant in Maven–Making Ant Plug-Ins
in Ant, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File, Using Maven in Ant–Generating Ant Script from a POM
Ant vs., Maven and Ant–Maven and Ant, Using Ant in Maven
archetypes, Creating a Project Template with Archetypes–Creating a Project Template with Archetypes, Advanced Archetypes–Creating Your Own Archetypes
artifacts, Project Context and Artifacts–Project Context and Artifacts
assemblies, Creating Assemblies–Assemblies with Profiles
bootstrapping, Advanced Archetypes
build customization, Customizing Your Build Process–Customizing Your Build Process, Defining Build Profiles–Defining Build Profiles, Understanding the Maven 2 Lifecycle, Defining Arbitrary Environment-Specific Variables
build lifecycle, Manipulating the Build Lifecycle–Manipulating the Build Lifecycle
build scripts (see POM files)
Cargo and, Deploying an Application Using Cargo–Deploying an Application Using Cargo
Checkstyle and, Using Checkstyle with Maven–Using Checkstyle with Maven
Cobertura and, Testing Your Code, Generating Cobertura Reports in Maven–Integrating Coverage Tests into the Maven Build Process
code coverage in, Generating Cobertura Reports in Maven–Integrating Coverage Tests into the Maven Build Process
compiling Java code, Customizing Your Build Process, Compiling Code–Compiling Code
configuring, Configuring Maven to Your Environment–Defining Arbitrary Environment-Specific Variables
context, Project Context and Artifacts–Project Context and Artifacts
Continuum and, Adding a Maven Project–Adding a Maven Project
CruiseControl and, Setting Up a Maven 2 Project in CruiseControl–Setting Up a Maven 2 Project in CruiseControl
declarative builds, An Introduction to Declarative Build Management
dependencies
in Ant, Using Maven Dependencies in Ant with the Maven Tasks–Using an Existing Maven POM File
declaring, An Introduction to Declarative Build Management, Declaring Dependencies–Declaring Dependencies, Refactoring Your Dependencies Using Properties–Refactoring Your Dependencies Using Properties
identifying, Looking for Dependencies with MvnRepository–Looking for Dependencies with MvnRepository
managing, Managing Dependencies–Managing Dependencies, Dependency Management in Maven 2
proprietary, Handling Proprietary Dependencies–Handling Proprietary Dependencies
scope, Dependency Scope–Dependency Scope
transitive, Managing Transitive Dependencies–Managing Transitive Dependencies
deployment, Packaging and Deploying Your Application–Packaging and Deploying Your Application, Deploying an Application Using Cargo–Deploying an Application Using Cargo
described, Build Tools, Maven and the Development Build Process–Maven and the Development Build Process
directory structure, Maven and the Development Build Process, The Maven Directory Structure
documentation (see Maven project web site)
Eclipse and, Using Maven in Eclipse–Using Maven in Eclipse
environmental variables, Defining Arbitrary Environment-Specific Variables–Defining Arbitrary Environment-Specific Variables
FindBugs in, Using FindBugs in Maven–Using FindBugs in Maven
functional testing in, Using Selenium with Maven–Using Selenium with Maven
Hudson and, Building a Maven Project–Building a Maven Project
installing, Installing Maven–Installing Maven on a Windows Machine
integration tests, Integration Tests
JUnit 4 and, Using JUnit 4 with Maven 2–Using JUnit 4 with Maven 2, Integration Tests
JUnitPerf and, Separating Performance Tests from Unit Tests in Maven–Separating Performance Tests from Unit Tests in Maven
lifecycle phases, Understanding the Maven 2 Lifecycle–Understanding the Maven 2 Lifecycle
local repository, Changing Your Maven Cache Location
Mojos, Creating a Plug-In–Creating a Plug-In, Extending Maven to Support LuntBuild
MvnRepository, Looking for Dependencies with MvnRepository–Looking for Dependencies with MvnRepository
in NetBeans, Using Maven in NetBeans–Using Maven in NetBeans
packaging options, Project Context and Artifacts, Packaging and Deploying Your Application
performance testing, Separating Performance Tests from Unit Tests in Maven–Separating Performance Tests from Unit Tests in Maven
and Plexus, Creating a Plug-In
plug-ins, Using Plug-Ins to Customize the Build Process
(see also plug-ins main entry)
adding to build lifecycle, Manipulating the Build Lifecycle–Manipulating the Build Lifecycle
creating, Creating a Plug-In–Creating a Plug-In
described, Using Plug-Ins to Customize the Build Process–Using Plug-Ins to Customize the Build Process
Maven parameters in, Hooking into Maven–Hooking into Maven
Plexus components in, Using Plexus Components–Using Plexus Components
PMD in, Using PMD in Maven–Using PMD in Maven
POM files (see POM files)
profiles, Defining Build Profiles–Defining Build Profiles, Defining Arbitrary Environment-Specific Variables
project inheritance, Project Inheritance and Aggregation–Project Inheritance and Aggregation
project templates, Creating a Project Template with Archetypes–Creating a Project Template with Archetypes, Advanced Archetypes–Creating Your Own Archetypes
project web site (see Maven project web site)
proxy connections, Using a Proxy–Using a Proxy
QAlab in, Using QALab in Maven–Using QALab in Maven
remote repositories (see Archiva) (see Artifactory)
Selenium and, Using Selenium with Maven–Using Selenium with Maven
settings.xml file, Configuring Maven to Your Environment
SoapUI and, Running SoapUI from Maven–Running SoapUI from Maven, Continuous Testing
StatSCM, Source Code Management Metrics with StatSCM–Source Code Management Metrics with StatSCM
Super POM, An Introduction to Declarative Build Management
test coverage, Testing Your Code
TestNG and, Using TestNG with Maven 2–Using TestNG with Maven 2
unit tests, Testing Your Code–Testing Your Code, Using JUnit 4 with Maven 2–Using JUnit 4 with Maven 2, Using TestNG with Maven 2–Using TestNG with Maven 2
Maven project web site
adding reports, Integrating Reports into Your Site–Code Analysis Reports
continous integration and, The Continuous Integration System–The Continuous Integration System
customizing, Creating a Dedicated Maven Site Project–Defining the Site Outline, Customizing the Look and Feel of Your Site–Velocity Manipulation
described, The Maven 2 Project Web Site As a Communication Tool–The Maven 2 Project Web Site As a Communication Tool
developers section, The Project Team–The Project Team
formatting content, Doxia–XDoc
generating, Setting Up a Maven Site Project–Describing the Project
issue management and, Linking into the Issue Tracking System–Linking into the Issue Tracking System
mailing lists, Mailing Lists–Mailing Lists
publishing, Distributing Your Site–Distributing Your Site
site outline, Defining the Site Outline
skins, Changing Skins
snippets, Using Snippets–Using Snippets
templates, Velocity Manipulation
tracking changes, Change and Configuration Management–Change and Configuration Management
tracking releases, Change and Configuration Management–Change and Configuration Management
version control integration, The Source Repository–The Source Repository
Maven project website
adding reports, Generating Cobertura Reports in Maven
Cobertura and, Generating Cobertura Reports in Maven
Continuum and, Automatically Generating a Maven Site with Continuum–Automatically Generating a Maven Site with Continuum
generating reports, Setting Up Reporting–Setting Up Reporting
LuntBuild and, Integrating Luntbuild with Maven–Luntbuild Configuration
project description, A Human-Readable Project Description–A Human-Readable Project Description
SchemaSpy in, Using SchemaSpy in Maven–Using SchemaSpy in Maven
source files, The Maven Directory Structure
templates, Creating a Project Template with Archetypes
UmlGraph in, Using UmlGraph in Maven–Using UmlGraph in Maven
maven-ant-plugin, Generating Ant Script from a POM
maven-antrun-plugin, Using Existing build.xml Files
maven-assembly-plugin, Creating Assemblies
maven-checkstyle-plugin, Setting Up Reporting
maven-compiler-plugin, Customizing Your Build Process, Compiling Code
maven-plugin-plugin, Making Ant Plug-Ins
McCabe cyclomatic complexity, Interpreting the Cobertura Report–Interpreting the Cobertura Report, Customizing Checkstyle: Common Rules That You Can Do Without, and Some That You Could Use
memory leaks, Recording and Displaying Test Results, Detecting and Identifying Memory Leaks with the JDK Tools–Detecting and Identifying Memory Leaks with the JDK Tools, Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat–Diagnosing Memory Leaks Using Heap Dumps, jmap, and jhat, Studying Memory Use with the Basic Memory Analysis Results–Studying Memory Use with the Basic Memory Analysis Results
method coverage, Interpreting the Cobertura Report
mirrors, Using a Local Mirror–Using a Local Mirror, Configure Maven using settings.xml
Mojos, Creating a Plug-In–Creating a Plug-In, Making Ant Plug-Ins, Extending Maven to Support LuntBuild
Mozilla plug-ins, Firefox and Thunderbird Integration
multithreaded testing, Parallel Testing
MVC (Model-View-Controller) architecture, Introduction
mvn clean, Compiling Code
mvn compile, Compiling Code
mvn deploy, Packaging and Deploying Your Application
mvn eclipse, Using Maven in Eclipse
mvn install, Packaging and Deploying Your Application
mvn integration-test, Integration Tests
mvn site, Setting Up a Maven Site Project
mvn test, Testing Your Code
MvnRepository, Looking for Dependencies with MvnRepository–Looking for Dependencies with MvnRepository
Mylyn
change sets, Using the Eclipse Change Sets–Using the Eclipse Change Sets
context, Focusing on a Task with Context Management–Focusing on a Task with Context Management
context (Mylyn), Sharing Context with Other Developers–Sharing Context with Other Developers
described, Quality Metrics Tools, Introduction to Mylyn–Introduction to Mylyn
installing, Installing Mylyn–Installing Mylyn
issue management options, Interacting with Task Repositories–Interacting with Task Repositories, Sharing Context with Other Developers
task repositories, Interacting with Task Repositories–Interacting with Task Repositories, Sharing Context with Other Developers
Trac and, Managing User Accounts
tracking tasks, Tracking Tasks and Issues–Tracking Tasks and Issues

N

NetBeans, Using Ant in NetBeans–Using Ant in NetBeans, Using Maven in NetBeans–Using Maven in NetBeans, Using Subversion in NetBeans–Branching and Merging, Installing SoapUI
Norddahl, Magnus, Installing Subversion As a Windows Service
notification options
in Bugzilla, Scheduling Notifications (Whining)–Scheduling Notifications (Whining)
in Continuum, Setting Up Notifiers–Setting Up Notifiers, Configuring the Continuum Mail Server–Configuring the Continuum Mail Server
in CruiseControl, Keeping People Notified with Publishers–Keeping People Notified with Publishers
in Hudson, Building a Freestyle Project
in LuntBuild, Configuring the LuntBuild Server–Configuring the LuntBuild Server, Configuring the Project Basics–Configuring the Project Basics
in Trac, Setting Up Email Notifications–Setting Up Email Notifications, Using RSS and ICalendar–Using RSS and ICalendar

O

object-relational mapping (ORM), Purpose of DbUnit
OGNL (Object-Graph Navigation Language), Using Project Variables for Version Numbering
Openfire
authentication, Authenticating Users in an External Database–Authenticating Users Against a POP3 Server
Continuum and, Using Openfire with Continuum–Using Openfire with Continuum
CruiseControl and, Using Openfire with CruiseControl–Using Openfire with CruiseControl
described, Continuous Integration, Instant Messaging in a Development Project–Instant Messaging in a Development Project
group chats, Virtual Team Meetings with the Group Chat–Virtual Team Meetings with the Group Chat
installation, Installing Openfire–Installing Openfire
LuntBuild and, Using Openfire with Luntbuild–Using Openfire with Luntbuild
plug-ins, Extended Functionality with Openfire Plug-Ins
user accounts, Setting Up Users and Accounts on Openfire–Setting Up Users and Accounts on Openfire
optimization, Introducing JUnitPerf, SimulatingLoad with LoadTests, The Eclipse Test & Performance Tools Platform
OptimizeIt, Conclusion
ORM (object-relational mapping), Purpose of DbUnit

P

packages, Documenting packages–Documenting packages
packaging applications
Ant, Packaging Your Application–Generating a WAR File or an EAR File, Packaging the Dependencies–Packaging the Dependencies
Maven, Project Context and Artifacts, Packaging and Deploying Your Application
packaging element, Project Context and Artifacts
parallel builds, Configuring Hudson
parallel testing, Parallel Testing–Parallel Testing
parameterized tests, Running Multiple Tests, Using Parameterized Tests–Using Parameterized Tests
parent POMs, Project Inheritance and Aggregation–Project Inheritance and Aggregation
path definitions, Compiling Your Java Code in Ant–Compiling Your Java Code in Ant
performance monitoring (see jConsole)
performance testing, Integration, Functional, Load, and Performance Testing–Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing, Integration, Functional, Load, and Performance Testing, Introducing JUnitPerf–Introducing JUnitPerf, Introduction–Introduction, Introduction, Profiling Applications from Within an IDE
(see also JMeter)
(see also JUnitPerf)
(see also SoapUI)
(see also TPTP)
Personal Software Process, Conducting Personal Code Reviews
Plain Old Java Object (POJO), Creating a Plug-In
Plexus, Creating a Plug-In, Using Plexus Components–Using Plexus Components, An Introduction to Continuum
plug-ins
AccountManager, Managing User Accounts–Managing User Accounts
adding dependencies, External Dependencies–External Dependencies
adding to build lifecycle, Manipulating the Build Lifecycle–Manipulating the Build Lifecycle
in Ant, Making Ant Plug-Ins–Making Ant Plug-Ins
archetype, Creating a Project Template with Archetypes–Creating a Project Template with Archetypes
Broadcast, Extended Functionality with Openfire Plug-Ins
cargo-maven2-plugin, Deploying an Application Using Cargo
cobertura, Testing Your Code
cobertura-maven-plugin plug-in, Generating Cobertura Reports in Maven
creating, Creating a Plug-In–Creating a Plug-In
described, Using Plug-Ins to Customize the Build Process–Using Plug-Ins to Customize the Build Process
EclEmma, Code Coverage in Eclipse–Code Coverage in Eclipse
eclipse, Using Maven in Eclipse–Using Maven in Eclipse
FireBug, Referring to objects on the web page
Firefox, Firefox and Thunderbird Integration
for Hudson, Hudson Plug-Ins–Hudson Plug-Ins
Luntclipse, Using LuntBuild with Eclipse–Using LuntBuild with Eclipse
m2eclipse, Using Maven in Eclipse
Maven parameters in, Hooking into Maven–Hooking into Maven
maven-ant-plugin, Generating Ant Script from a POM
maven-antrun-plugin, Using Existing build.xml Files
maven-assembly-plugin, Creating Assemblies
maven-compiler-plugin, Compiling Code
maven-plugin-plugin, Making Ant Plug-Ins
Plexus components, Using Plexus Components–Using Plexus Components
Surefire, Using JUnit 4 with Maven 2, Integration Tests, Using TestNG with Maven 2, Using Selenium with Maven, Unit Test Reports
Thunderbird, Firefox and Thunderbird Integration
User Import Export, Extended Functionality with Openfire Plug-Ins
User Service, Extended Functionality with Openfire Plug-Ins
Violations, Keeping Track of Code Metrics–Keeping Track of Code Metrics
PMD
in Ant, Using PMD in Ant–Using PMD in Ant
customizing, Configuring PMD Rules in Eclipse–Configuring PMD Rules in Eclipse, Writing Your Own PMD Ruleset–Writing Your Own PMD Ruleset
cut and paste detection, Detecting Cut-and-Paste with CPD–Detecting Cut-and-Paste with CPD
described, Quality Metrics Tools, PMD and Static Code Analysis
generating reports, Generating a PMD Report in Eclipse–Generating a PMD Report in Eclipse, Using PMD in Ant
IDE options, PMD and Static Code Analysis
installing, Using PMD in Eclipse–Installing the PMD Plug-In
in Maven, Using PMD in Maven–Using PMD in Maven
rulesets, Configuring PMD Rules in Eclipse–Writing Your Own PMD Ruleset
running, Detecting and Displaying Errors–Detecting and Displaying Errors
setting up a project, Installing the PMD Plug-In–Installing the PMD Plug-In
suppressing violations, Suppressing PMD Rules–Suppressing PMD Rules
POJO (Plain Old Java Object), Creating a Plug-In
POM files
Ant code in, Embedding Ant Code in the POM–Embedding Ant Code in the POM
Ant script from, Generating Ant Script from a POM–Generating Ant Script from a POM
artifacts, Project Context and Artifacts–Project Context and Artifacts
build section, Customizing Your Build Process–Customizing Your Build Process
ciManagement section, Declaring your Continuous Integration Server–Declaring your Continuous Integration Server, Adding a Maven Project, The Continuous Integration System
context, Project Context and Artifacts–Project Context and Artifacts
Continuum and, Adding a Maven Project–Adding a Maven Project
dependencies section, Managing Dependencies–Managing Dependencies, Declaring Dependencies–Declaring Dependencies
described, An Introduction to Declarative Build Management–An Introduction to Declarative Build Management
developers section, Defining the Development Team–Defining the Development Team, The Project Team
distributionManagement section, Packaging and Deploying Your Application
issueManagement section, Linking into the Issue Tracking System
mailingLists section, Mailing Lists
parent POMs, Project Inheritance and Aggregation–Project Inheritance and Aggregation
profiles section, Defining Build Profiles–Defining Build Profiles
project description, A Human-Readable Project Description–A Human-Readable Project Description
properties, Refactoring Your Dependencies Using Properties–Refactoring Your Dependencies Using Properties
properties section, Using SchemaSpy in Maven
reading from Ant, The Maven 2.0 Ant Tasks, Using an Existing Maven POM File
reporting section, Setting Up Reporting–Setting Up Reporting, Integrating Reports into Your Site–Code Analysis Reports, Javadocs–Unit Test Reports, Using UmlGraph in Maven
scm section, Adding a Maven Project, The Source Repository
Super POM, An Introduction to Declarative Build Management
Popescu, Alexandru, Introducing TestNG
Price, Yvonne Wang, Testing Swing GUIs with FEST
process IDs, listing, Connecting To and Monitoring a Java Application with jConsole–Connecting To and Monitoring a Java Application with jConsole
profiles, Defining Build Profiles–Defining Build Profiles, Defining Arbitrary Environment-Specific Variables
profiling tools (see jConsole) (see TPTP)
project inheritance, Project Inheritance and Aggregation–Project Inheritance and Aggregation
Project Object Model (see POM files)
project web site (see Maven project web site)
properties
Ant, Basic Ant Concepts, Customizing Your Build Script Using Properties–Customizing Your Build Script Using Properties
CruiseControl, Configuring an Ant Project
Maven, Refactoring Your Dependencies Using Properties–Refactoring Your Dependencies Using Properties
proxy connections
Ant, ANT_OPTS and ANT_ARGS: Some Other Useful Environment Variables, Bootstrapping Your Build Scripts
Artifactory, Running Artifactory Through a Proxy–Running Artifactory Through a Proxy
Maven, Using a Proxy–Using a Proxy
pserver, Creating a New Project in CVS, Checking Out a Project
Pulse, Continuous Integration
Python, Installing Trac–Installing Trac, Customizing a Wiki Page with Python–Customizing a Wiki Page with Python

Q

Qalab
described, Quality Metrics Tools
QAlab
in Ant, Using QALab in Ant–Using QALab in Ant
described, Introduction–QALab
in Maven, Using QALab in Maven–Using QALab in Maven
QuickBuild, An Introduction to LuntBuild
quiet time, VCS Adaptors, Configuring Hudson

R

Redmond, Eric
bio, Contributing Authors
on Archiva, Setting Up an Enterprise Repository with Archiva
on Maven, Using Plug-Ins to Customize the Build Process, Using Ant in Maven, Advanced Archetypes, Using Assemblies
on snippets, Using Snippets
on the Maven project web site, The Maven 2 Project Web Site As a Communication Tool, Creating a Dedicated Maven Site Project, Defining the Site Outline, The Maven Site Generation Architecture, Customizing the Look and Feel of Your Site, Distributing Your Site
regression testing, Running Unit Tests in Ant, Unit Testing
replace task, Manipulating XML with XMLTask
Ruiz, Alex, Contributing Authors, Testing Swing GUIs with FEST, Testing Swing GUIs with FEST

S

samplers, Adding an HTTP Request
SchemaSpy
in Ant, Using SchemaSpy in Ant–Using SchemaSpy in Ant
described, Introduction–An Overview of SchemaSpy
installing, Installing SchemaSpy–Installing SchemaSpy
in Maven project website, Using SchemaSpy in Maven–Using SchemaSpy in Maven
running from command line, Using SchemaSpy–Using SchemaSpy
scp task, Other Deployment Techniques
SDLC (Software Development Life Cycle), Introduction
Selenium
AJAX and, Using the Selenium IDE
Ant and, Using Selenium with Ant–Using Selenium with Ant
assertions, Using the Selenium IDE, Using assertions–Using assertions
browsers supported, Writing JUnit Tests with Selenium
described, Integration, Functional, Load, and Performance Testing, Introduction–Introduction
identifying GUI objects, Referring to objects on the web page–Referring to objects on the web page
installing, Using the Selenium IDE
Maven and, Using Selenium with Maven–Using Selenium with Maven
ports, Using Selenium with Maven
programming language APIs, Writing JUnit Tests with Selenium
recording test scripts, Using the Selenium IDE–Using the Selenium IDE
test scripts, Writing Selenium Test Scripts–An introduction to Selenese
test suites, Running a Selenium Test Suite with Selenium Core
variables, Using variables–Using variables
writing tests, Writing JUnit Tests with Selenium–Writing JUnit Tests with Selenium
Selenium Core, Running a Selenium Test Suite with Selenium Core–Running a Selenium Test Suite with Selenium Core
Selenium Remote Control, Writing JUnit Tests with Selenium–Writing JUnit Tests with Selenium
setproxy task, Bootstrapping Your Build Scripts
settings.xml file, Configuring Maven to Your Environment, Configure Maven using settings.xml–Configure Maven using settings.xml
skins, Changing Skins
Smack API, Sending Jabber Messages from a Java Application Using the Smack API–Receiving Messages Using the Smack API
snippets, Using Snippets–Using Snippets
SoapUI
Ant and, Running SoapUI from Ant–Running SoapUI from Ant, Continuous Testing
assertions, Web Service Testing, Testing Web Services with SoapUI–Testing Web Services with SoapUI, Load-Testing with SoapUI–Load-Testing with SoapUI
command-line options, Running SoapUI from the Command Line–Running SoapUI from the Command Line
continuous testing, Continuous Testing–Continuous Testing
Continuum and, Continuous Testing
described, Introduction–When Is SoapUI Appropriate?
in Eclipse, Installing SoapUI
installing, Installing SoapUI–Installing a Local Web Service
in IntelliJ, Installing SoapUI
Javadoc reports, Running SoapUI from Ant–Running SoapUI from Ant
load testing, Load-Testing with SoapUI–Load-Testing with SoapUI
Maven and, Running SoapUI from Maven–Running SoapUI from Maven, Continuous Testing
in NetBeans, Installing SoapUI
projects, Testing Web Services with SoapUI–Testing Web Services with SoapUI
requests, Testing Web Services with SoapUI–Testing Web Services with SoapUI
test cases, Testing Web Services with SoapUI–Testing Web Services with SoapUI
test statistics, Load-Testing with SoapUI–Load-Testing with SoapUI
test suites, Testing Web Services with SoapUI, Testing Web Services with SoapUI–Testing Web Services with SoapUI
software CM vs. version control, An Introduction to Subversion, Defect Tracking and Change Control
Software Development Life Cycle (SDLC), Introduction
Spinellis, Diomidis D., Embedding UML Diagrams in Your Javadoc with UmlGraph
Spring, Injecting the Test Fixture–Injecting the Test Fixture, Using Transaction Rollback Teardown, Introduction
SSH tunneling, Setting Up a Secure svnserve Server
StatSCM, Quality Metrics Tools, Source Code Management Metrics with StatSCM–Source Code Management Metrics with StatSCM
StatSVN, Statistics in Ant with StatSVN–Generating the StatSVN Reports
stress testing (see load testing)
Struts, Introduction–Testing a Struts Application
StrutsTestCase
configuring, Customizing the Test Environment
described, Introduction–Introducing StrutsTestCase
error-handling tests, Testing Struts Error Handling–Testing Struts Error Handling
mock tests, Mock Tests Using StrutsTestCase–Mock Tests Using StrutsTestCase
performance testing, First-Level Performance Testing–First-Level Performance Testing
Subversion
adding files, Working with Your Local Copy
in Ant, Using Subversion in Ant–Creating a New Tag
atomic updates, Revision Numbers and Atomic Updates
backing up files, Backing Up and Restoring a Subversion Repository–Backing Up and Restoring a Subversion Repository
binary files, Handling Binary Files, Importing Existing Files into Subversion, Using File Locking with Binary Files–Using File Locking with Binary Files
branches, Fast Branching and Tagging, Using Tags, Branches, and Merges–Using Tags, Branches, and Merges
change sets, Using the Eclipse Change Sets
checking out files, Checking Out Your Working Copy–Checking Out Your Working Copy
commenting revisions, Committing Your Work–Committing Your Work
committing changes, Committing Your Work–Committing Your Work
copying files, Working with Your Local Copy
creating a repository, Setting Up a Subversion Repository–Setting Up a Subversion Repository, Setting Up a New Subversion Project–Setting Up a New Subversion Project
creating directories, Importing Existing Files into Subversion
customizing, Customizing Subversion with Hook Scripts–Customizing Subversion with Hook Scripts
CVS vs., An Introduction to Subversion–Handling Binary Files
deleting files, Working with Your Local Copy
directory structure, Setting Up a New Subversion Project–Setting Up a New Subversion Project
Eclipse and, Working with Your Local Copy
Eclipse and, Using Subversion in Eclipse–Branching and Merging
executable files, Preserving the Executable Flag using svn:executable–Preserving the Executable Flag using svn:executable
ignoring files, Making Subversion Ignore Files with svn:ignore–Making Subversion Ignore Files with svn:ignore
importing files, Importing Existing Files into Subversion–Importing Existing Files into Subversion
in Windows (see TortoiseSVN)
installing, Installing Subversion–Installing Subversion
internet access, Setting Up a WebDAV/DeltaV Enabled Subversion Server–Setting Up a Secure WebDAV/DeltaV Server
issue management options, Defect Tracking and Change Control–Defect Tracking and Change Control
keyword substitution, Working with Keyword Substitution
line feeds, Handling OS-Specific End-of-Lines with svn:eol-style–Handling OS-Specific End-of-Lines with svn:eol-style
listing changes, Seeing Where You’re At: The Status Command–Seeing Where You’re At: The Status Command, Using Tags, Branches, and Merges
listing contents, Importing Existing Files into Subversion
locking files, Using File Locking with Binary Files–Using File Locking with Binary Files, Making Locked Files Read-Only with the svn:needs-lock Property–Handling OS-Specific End-of-Lines with svn:eol-style
moving files, Working with Your Local Copy
in NetBeans, Using Subversion in NetBeans–Branching and Merging
network access, Setting Up a Subversion Server with svnserve
network load, Lightweight Network Transactions
network protocols, Setting Up a Subversion Server with svnserve
projects, Setting Up a New Subversion Project–Setting Up a New Subversion Project
properties, Making Locked Files Read-Only with the svn:needs-lock Property–Handling OS-Specific End-of-Lines with svn:eol-style
renaming files, Working with Your Local Copy
repository URLs, Understanding Subversion Repository URLs–Understanding Subversion Repository URLs
resolving conflicts, Resolving Conflicts–Resolving Conflicts
restoring files, Backing Up and Restoring a Subversion Repository–Backing Up and Restoring a Subversion Repository
reverting changes, Seeing Where You’re At: The Status Command, Rolling Back to a Previous Revision–Rolling Back to a Previous Revision
revision trees, Revision Numbers and Atomic Updates
server setup, Setting Up a Subversion Server with svnserve–Setting Up a Secure svnserve Server
setting file types, Forcing the File Type with svn:mime-type–Forcing the File Type with svn:mime-type
storage options, Subversion Repository Types–Subversion Repository Types
structural changes, Working with Your Local Copy–Working with Your Local Copy
tagging, Fast Branching and Tagging, Using Tags, Branches, and Merges–Using Tags, Branches, and Merges
Trac and, Defect Tracking and Change Control–Defect Tracking and Change Control, Updating Trac Issues from Subversion–Updating Trac Issues from Subversion
tracking revisions, Revision Numbers and Atomic Updates–Revision Numbers and Atomic Updates
unlocking files, Breaking and Stealing Locks–Breaking and Stealing Locks
updating local copies, Updating Your Work Directory–Updating Your Work Directory
viewing change history, Change History in Subversion: Logging and Blaming–Change History in Subversion: Logging and Blaming
vs. CVS, An Introduction to CVS
as Windows Service, Installing Subversion As a Windows Service–Installing Subversion As a Windows Service
successPercentage parameter, Handling Partial Failures
Super POM, An Introduction to Declarative Build Management
Surefire plug-in, Using JUnit 4 with Maven 2, Integration Tests, Using TestNG with Maven 2, Using Selenium with Maven, Unit Test Reports
svn add, Working with Your Local Copy
svn annotate, Change History in Subversion: Logging and Blaming
svn blame, Change History in Subversion: Logging and Blaming
svn checkout, Checking Out Your Working Copy
svn commit, Committing Your Work
svn copy, Working with Your Local Copy
svn delete, Working with Your Local Copy
svn diff, Seeing Where You’re At: The Status Command
svn import, Setting Up a New Subversion Project, Importing Existing Files into Subversion
svn info, Using Tags, Branches, and Merges
svn list, Importing Existing Files into Subversion
svn lock, Using File Locking with Binary Files
svn log, Using Tags, Branches, and Merges, Change History in Subversion: Logging and Blaming
svn merge, Using Tags, Branches, and Merges
svn mkdir, Importing Existing Files into Subversion
svn move, Working with Your Local Copy
svn praise, Change History in Subversion: Logging and Blaming
svn propset, Making Locked Files Read-Only with the svn:needs-lock Property
svn resolved, Resolving Conflicts
svn revert, Seeing Where You’re At: The Status Command
svn status, Seeing Where You’re At: The Status Command
svn switch, Using Tags, Branches, and Merges
svn task, Installing the <svn> Task–Installing the <svn> Task
svn unlock, Using File Locking with Binary Files
svn update, Updating Your Work Directory
svn+ssh protocol, Setting Up a Secure svnserve Server
svn:eol-style, Handling OS-Specific End-of-Lines with svn:eol-style
svn:executable, Preserving the Executable Flag using svn:executable
svn:ignore, Making Subversion Ignore Files with svn:ignore
svn:mime-type, Forcing the File Type with svn:mime-type
svn:needs-lock, Making Locked Files Read-Only with the svn:needs-lock Property
svnadmin create, Setting Up a Subversion Repository
svnadmin dump, Backing Up and Restoring a Subversion Repository
svnadmin load, Backing Up and Restoring a Subversion Repository
svnadmin lslocks, Breaking and Stealing Locks
svnadmin rmlocks, Breaking and Stealing Locks
SVNParentPath, Setting Up a WebDAV/DeltaV Enabled Subversion Server
svnserve server, Setting Up a Subversion Server with svnserve–Setting Up a Secure svnserve Server
SVNService, Installing Subversion As a Windows Service
Swing, CruiseControl Configuration Tool
synchronization issues, Recording and Displaying Test Results

T

Tanenbaum, Andrew S., Quality Metrics Tools
targets, Basic Ant Concepts
taskdef task, Using TestNG in Ant
tasks, Basic Ant Concepts–Basic Ant Concepts
TeamCity, What This Book Doesn’t Cover, Continuous Integration
template-driven testing, Web Service Testing
test coverage (see code coverage)
Test Maker, Introduction
test task, Running Multiple Tests
test-driven development, Preparing Your Build for Automated Tests, Unit Testing
TestCase class, JUnit 3.8 and JUnit 4
testing, multithreaded, Parallel Testing
testing, parallel, Parallel Testing–Parallel Testing
TestNG
@AfterClass, Managing the Test Lifecycle
@AfterMethod, Creating Simple Unit Tests with TestNG
@AfterSuite, Managing the Test Lifecycle
@BeforeClass, Managing the Test Lifecycle
@BeforeMethod, Creating Simple Unit Tests with TestNG
@BeforeSuite, Managing the Test Lifecycle
@Test, Creating Simple Unit Tests with TestNG
annotations, Managing the Test Lifecycle
Ant and, Using TestNG in Ant–Using TestNG in Ant, Using Test Groups
assertions, Creating Simple Unit Tests with TestNG
Cobertura and, Checking the Code Coverage of TestNG Tests–Checking the Code Coverage of TestNG Tests
code coverage of, Checking the Code Coverage of TestNG Tests–Checking the Code Coverage of TestNG Tests
creating tests, Creating Simple Unit Tests with TestNG–Creating Simple Unit Tests with TestNG
data-driven testing, Test Parameters and Data-Driven Testing–Test Parameters and Data-Driven Testing
dependencies, Using TestNG with Maven 2, Managing the Test Lifecycle, Managing Dependencies–Managing Dependencies
described, Introducing TestNG
Eclipse and, The TestNG Eclipse Plug-In–Running TestNG Tests
exceptions, Checking for Exceptions–Checking for Exceptions
failure handling, Handling Partial Failures–Rerunning Failed Tests
FEST and, Testing GUIs with FEST, Verifying Test Failures–Verifying Test Failures
fixture code, Managing the Test Lifecycle–Managing the Test Lifecycle, Managing Dependencies
functional testing and, Verifying Test Failures–Verifying Test Failures
IntelliJ and, The TestNG Eclipse Plug-In
Maven and, Testing Your Code, Using TestNG with Maven 2–Using TestNG with Maven 2
parallel testing, Parallel Testing–Parallel Testing
successPercentage, Handling Partial Failures
test groups, Using Test Groups–Using Test Groups
test lifecycle, Managing the Test Lifecycle–Managing the Test Lifecycle
test suites, Defining TestNG Test Suites–Defining TestNG Test Suites, Using Test Groups
tests, atomic, Load-Testing Tests That Are Not Thread-Safe
tests, on multiple machines, Testing on Multiple Machines–Testing on Multiple Machines
tests, parameterized, Running Multiple Tests, Using Parameterized Tests–Using Parameterized Tests
tests, recording, Using the JMeter Proxy to Record a Test Case–Using the JMeter Proxy to Record a Test Case, Using the Selenium IDE–Using the Selenium IDE
tests, timed, Structuring Your Test Case–Structuring Your Test Case
theories (JUnit), JUnit 4 Theories–JUnit 4 Theories
Thunderbird plug-in, Firefox and Thunderbird Integration
timed tests, Measuring Performance with TimedTests–Measuring Performance with TimedTests, Structuring Your Test Case–Structuring Your Test Case, Basic Profiling with TPTP, Analyzing Execution Time–Analyzing Execution Time
TortoiseCVS, Using CVS in Windows–Using CVS in Windows
TortoiseSVN
browsing a repository, Exploring the Repository–Exploring the Repository
checking out files, Obtaining a Working Copy–Obtaining a Working Copy
committing changes, Committing Your Changes with TortoiseSVN–Committing Your Changes with TortoiseSVN
importing a project, Importing a New Project into the Repository–Importing a New Project into the Repository
revision graph, Exploring the Repository–Exploring the Repository
updating local copies, Updating Your Working Copy
Windows Explorer interface, Using Subversion in Windows–Using TortoiseSVN in Windows Explorer
TPTP
coverage statistics, Displaying Coverage Statistics–Displaying Coverage Statistics
described, Profiling Applications from Within an IDE–The Eclipse Test & Performance Tools Platform
filtering results, Using Filters to Refine Your Results–Using Filters to Refine Your Results
installing, Installing TPTP–Installing TPTP
Java version compatibility, TPTP and Java 6–TPTP and Java 6
JUnitPerf in, Basic Profiling with TPTP–Basic Profiling with TPTP
memory analysis, Studying Memory Use with the Basic Memory Analysis Results–Studying Memory Use with the Basic Memory Analysis Results
performance testing, Basic Profiling with TPTP–Basic Profiling with TPTP
profiles, Basic Profiling with TPTP–Basic Profiling with TPTP
timed tests, Analyzing Execution Time–Analyzing Execution Time
web application testing, Profiling a Web Application–Profiling a Web Application
Trac
on Apache server, Installing Trac on an Apache Server–Installing Trac on an Apache Server
browsing repository, Browsing the Source Code Repository–Browsing the Source Code Repository
closing tickets, The Lifecycle of a Trac Ticket
creating reports, Reporting Using Trac Queries and Reports–Reporting Using Trac Queries and Reports
creating tickets, Using the Trac Ticket Management System–Creating a New Ticket
customizing, Tailoring the Trac Web Site: Using the Wiki Function–Tailoring the Trac Web Site: Using the Wiki Function, Customizing Trac Ticket Fields–Customizing Trac Ticket Fields, Customizing a Wiki Page with Python–Customizing a Wiki Page with Python
described, An Introduction to Trac–An Introduction to Trac
installing, Installing Trac–Installing Trac
monitoring progress, Managing Progress with Trac Roadmaps and Timelines–The Timeline View
Mylyn and, Managing User Accounts
notification options, Setting Up Email Notifications–Setting Up Email Notifications, Using RSS and ICalendar–Using RSS and ICalendar
setting up a project, Setting Up a Trac Project–Setting Up a Trac Project
Subversion and, Defect Tracking and Change Control–Defect Tracking and Change Control, Updating Trac Issues from Subversion–Updating Trac Issues from Subversion, Browsing the Source Code Repository–Browsing the Source Code Repository
ticket lifecycle, The Lifecycle of a Trac Ticket–The Lifecycle of a Trac Ticket
trac-admin, Setting Up a Trac Project
tracd webserver, Running Trac on the Standalone Server–Running Trac on the Standalone Server
TracLink syntax, Tailoring the Trac Web Site: Using the Wiki Function
updating tickets, Updating Trac Issues from Subversion–Updating Trac Issues from Subversion
user management, Administrating the Trac Site–Managing User Accounts
as Windows service, Setting Up Tracd As a Windows Service–Setting Up Tracd As a Windows Service
trac-admin, Setting Up a Trac Project
tracd webserver, Running Trac on the Standalone Server–Running Trac on the Standalone Server
TracLink, Tailoring the Trac Web Site: Using the Wiki Function
transaction rollback teardown, Using Transaction Rollback Teardown–Using Transaction Rollback Teardown
transitive dependencies, Using Maven Dependencies in Ant with the Maven Tasks, Managing Dependencies, Managing Transitive Dependencies–Managing Transitive Dependencies
tstamp task, Generating a JAR File

U

UML diagrams, The Doxygen Reports, Embedding UML Diagrams in Your Javadoc with UmlGraph–Using UmlGraph in Maven
UmlGraph, Embedding UML Diagrams in Your Javadoc with UmlGraph–Using UmlGraph in Maven
unit tests
Ant and, Running Cobertura from Ant–Running Cobertura from Ant
in Ant, Using JUnit 4 with Ant–Running Tests Conditionally, Using TestNG in Ant–Using TestNG in Ant, Using Test Groups
in CruiseControl, Configuring an Ant Project
described, Unit Testing, Unit Testing–Unit Testing
in Eclipse, Using JUnit 4 in Eclipse–Using JUnit 4 in Eclipse, The TestNG Eclipse Plug-In–Running TestNG Tests
in Hudson, Keeping Track of Test Results–Keeping Track of Test Results
JUnitPerf and, Introducing JUnitPerf–Introducing JUnitPerf
in LuntBuild, Introduction
in Maven, Testing Your Code–Testing Your Code, Using JUnit 4 with Maven 2–Using JUnit 4 with Maven 2, Using TestNG with Maven 2–Using TestNG with Maven 2
on Maven project web site, Unit Test Reports–Unit Test Reports
unzip task, Bootstrapping Your Build Scripts
URLs, repository, Understanding Subversion Repository URLs–Understanding Subversion Repository URLs
User Import Export plug-in, Extended Functionality with Openfire Plug-Ins
user interface testing, Introduction, Introduction–Introduction, Testing Swing GUIs with FEST, Introduction–Testing GUIs Is Hard
(see also FEST)
(see also Selenium)
user interfaces, Tips for Writing Testable GUIs–Tips for Writing Testable GUIs
User Service plug-in, Extended Functionality with Openfire Plug-Ins

V

version control
benefits, Version Control Tools
in Continuum, Adding a Maven Project–Adding a Maven Project
in CruiseControl, Configuring an Ant Project
described, Version Control Tools
in Hudson, Configuring Hudson
in LuntBuild, VCS Adaptors–VCS Adaptors
in Maven project web site, The Source Repository–The Source Repository
vs. software CM, An Introduction to Subversion
vs. software CM, Defect Tracking and Change Control
version element, Project Context and Artifacts
Violations plug-in, Keeping Track of Code Metrics–Keeping Track of Code Metrics

W

Walnes, Joe, Using assertThat and the Hamcrest Library
WAR files, Generating a WAR File or an EAR File–Generating a WAR File or an EAR File
war task, Generating a WAR File or an EAR File
web application testing, Introduction, Testing a Simple Web Application–Adding an HTTP Request, Profiling a Web Application–Profiling a Web Application, Introduction
(see also Seleni)
(see also StrutsTestCase)
Web Service Definition Language (WSDL), Testing Web Services with SoapUI
web services testing (see SoapUI)
web site, Java Power Tools, Source Code
web site, Maven (see Maven project web site)
WebDAV/DeltaV
accessing a repository, Setting Up a WebDAV/DeltaV Enabled Subversion Server–Setting Up a WebDAV/DeltaV Enabled Subversion Server
Basic authentication, Setting Up a WebDAV/DeltaV Enabled Subversion Server–Setting Up a WebDAV/DeltaV Enabled Subversion Server
Digest authentication, Setting Up a WebDAV/DeltaV Enabled Subversion Server–Setting Up a WebDAV/DeltaV Enabled Subversion Server
encryption (HTTPS), Setting Up a Secure WebDAV/DeltaV Server
setup, Setting Up a WebDAV/DeltaV Enabled Subversion Server–Setting Up a WebDAV/DeltaV Enabled Subversion Server
whining, Managing User Accounts, Scheduling Notifications (Whining)–Scheduling Notifications (Whining)
wikis, Tailoring the Trac Web Site: Using the Wiki Function–Tailoring the Trac Web Site: Using the Wiki Function
WSDL (Web Service Definition Language), Testing Web Services with SoapUI

X

XDoc, XDoc
xmlcatalog task, DTDs and XMLTask
XMLTask
controlling Ant builds, Driving Ant via XMLTask–Driving Ant via XMLTask
editing XML, Manipulating XML with XMLTask–DTDs and XMLTask, Changing encodings–Conclusion
XMPP (Jabber) protocol, Instant Messaging in a Development Project, Using Openfire with CruiseControl–Sending Jabber Messages from a Java Application Using the Smack API
XPath, Examples, Referring to objects on the web page
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.139.80.209