Java Extreme Programming Cookbook

Print $34.95

Safari Books Online

What is this?

Print £26.99

What is this?

Java Extreme Programming Cookbook

By: Eric M. Burke, Brian M. Coyner
Publisher:: O'Reilly Media
Released:: March 2003
Pages:: 288

Description

Brimming with over 100 "recipes" for getting down to business and actually doing XP, the Java Extreme Programming Cookbook doesn't try to "sell" you on XP; it succinctly documents the most important features of popular open source tools for XP in Java-- including Ant, Junit, HttpUnit, Cactus, Tomcat, XDoclet-- and then digs right in, providing recipes for implementing the tools in real-world environments.

Full Description

Extreme Programming does not mean programming naked while rollerblading down the side of the Grand Canyon. It does mean a new approach to software development that is both radical and common-sense. Unlike many software development methodologies, XP has been accepted quickly because its core practices--particularly code sharing, test-first development, and continuous integration--resonated immediately with software developers everywhere. Instead of impressing developers with a body of theory, XP got programmers to say, "Yeah, that's how I'd like to work." Oddly enough, although most developers turn to Extreme Programming methods in order to code real, hands-on, and extensible projects quickly ("Code comes first"), most books on Extreme Programming insist on focusing on the theory and not the practice. Not the Java Extreme Programming Cookbook. Brimming with over 100 "recipes" for getting down to business and actually doing XP, the Java Extreme Programming Cookbook doesn't try to "sell" you on XP; it succinctly documents the most important features of popular open source tools for XP in Java--including Ant, Junit, HttpUnit, Cactus, Tomcat, XDoclet--and then digs right in, providing recipes for implementing the tools in real-world environments. Each recipe offers solutions that help you put an extreme programming environment together: then provides code for automating the build process and testing. Although the time saved using any one of these solutions will more than pay for the book, Java Extreme Programming Cookbook offers more than just a collection of cut-and-paste code. Each recipe also includes explanations of how and why the approach works, so you can adapt the techniques to similar situations. One of the biggest challenges facing developers today is sorting through the wide variety of tools available form various source and figuring out how to them effectively. The recipes in Java Extreme Programming Cookbook showcase how to use the most important features of these XP tools. Many of these tools are geared towards unit testing, while others are invaluable for continuous integration; with these practical examples, you'll be able to choose the most effective tools to accomplish your goals, then implement them in a cohesive development environment quickly. If you want to set up a test-driven development environment that allows you to focus on writing testable code--now--this book will prove invaluable.

Table of Contents

Chapter 1 XP Tools
1. Java and XP
2. Tools and Philosophies
3. Open Source Toolkit
Chapter 2 XP Overview
1. What Is XP?
2. Coding
3. Unit Testing
4. Refactoring
5. Design
6. Builds
Chapter 3 Ant
1. Introduction
2. Writing a Basic Buildfile
3. Running Ant
4. Providing Help
5. Using Environment Variables
6. Passing Arguments to a Buildfile
7. Checking for the Existence of Properties
8. Defining a Classpath
9. Defining Platform-Independent Paths
10. Including and Excluding Files
11. Implementing Conditional Logic
12. Defining a Consistent Environment
13. Preventing Build Breaks
14. Building JAR Files
15. Installing JUnit
16. Running Unit Tests
17. Running Specific Tests
18. Generating a Test Report
19. Checking Out Code from CVS
20. Bootstrapping a Build
Chapter 4 JUnit
1. Introduction
2. Getting Started
3. Running JUnit
4. assertXXX( ) Methods
5. Unit Test Granularity
6. Set Up and Tear Down
7. One-Time Set Up and Tear Down
8. Organizing Tests into Test Suites
9. Running a Test Class Directly
10. Repeating Tests
11. Test Naming Conventions
12. Unit Test Organization
13. Exception Handling
14. Running Tests Concurrently
15. Testing Asynchronous Methods
16. Writing a Base Class for Your Tests
17. Testing Swing Code
18. Avoiding Swing Threading Problems
19. Testing with the Robot
20. Testing Database Logic
21. Repeatedly Testing the Same Method
Chapter 5 HttpUnit
1. Introduction
2. Installing HttpUnit
3. Preparing for Test-First Development
4. Checking a Static Web Page
5. Following Hyperlinks
6. Writing Testable HTML
7. Testing HTML Tables
8. Testing a Form Tag and Refactoring Your Tests
9. Testing for Elements on HTML Forms
10. Submitting Form Data
11. Testing Through a Firewall
12. Testing Cookies
13. Testing Secure Pages
Chapter 6 Mock Objects
1. Introduction
2. Event Listener Testing
3. Mock Object Self-Validation
4. Writing Testable JDBC Code
5. Testing JDBC Code
6. Generating Mock Objects with MockMaker
7. Breaking Up Methods to Avoid Mock Objects
8. Testing Server-Side Business Logic
Chapter 7 Cactus
1. Introduction
2. Configuring Cactus
3. Setting Up a Stable Build Environment
4. Creating the cactus.properties File
5. Generating the cactus.properties File Automatically
6. Writing a Cactus Test
7. Submitting Form Data
8. Testing Cookies
9. Testing Session Tracking Using HttpSession
10. Testing Servlet Initialization Parameters
11. Testing Servlet Filters
12. Securing Cactus Tests
13. Using HttpUnit to Perform Complex Assertions
14. Testing the Output of a JSP
15. When Not to Use Cactus
16. Designing Testable JSPs
Chapter 8 JUnitPerf
1. Introduction
2. When to Use JUnitPerf
3. Creating a Timed Test
4. Creating a LoadTest
5. Creating a Timed Test for Varying Loads
6. Testing Individual Response Times Under Load
7. Running a TestSuite with Ant
8. Generating JUnitPerf Tests
Chapter 9 XDoclet
1. Introduction
2. Setting Up a Development Environment for Generated Files
3. Setting Up Ant to Run XDoclet
4. Regenerating Files That Have Changed
5. Generating the EJB Deployment Descriptor
6. Specifying Different EJB Specifications
7. Generating EJB Home and Remote Interfaces
8. Creating and Executing a Custom Template
9. Extending XDoclet to Generate Custom Files
10. Creating an Ant XDoclet Task
11. Creating an XDoclet Tag Handler
12. Creating a Template File
13. Creating an XDoclet xdoclet.xml File
14. Creating an XDoclet Module
Chapter 10 Tomcat and JBoss
1. Introduction
2. Managing Web Applications Deployed to Tomcat
3. Hot-Deploying to Tomcat
4. Removing a Web Application from Tomcat
5. Checking If a Web Application Is Deployed
6. Starting Tomcat with Ant
7. Stopping Tomcat with Ant
8. Setting Up Ant to Use Tomcat's Manager Web Application
9. Hot-Deploying to JBoss
10. Hot-Deploying a Web Application to JBoss
11. Testing Against Multiple Servers
Chapter 11 Additional Topics
1. Introduction
2. Testing XML Files
3. Enterprise JavaBeans Testing Tools
4. Avoiding EJB Testing
5. Testing Swing GUIs
6. Testing Private Methods

Colophon

Product Details

Title:

Java Extreme Programming Cookbook

By:

Eric M. Burke, Brian M. Coyner

Publisher:

O'Reilly Media

Formats:

Print
Safari Books Online

Print Release:

March 2003

Pages:

288

Print ISBN:

978-0-596-00387-6

| ISBN 10:

0-596-00387-0

Customer Reviews

Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Java Extreme Programming Cookbook is a bison. American Bison (Bison bison) are the largest land mammals in North America. Prior to European colonization, an estimated 30 to 70 million animals roamed the continent in vast herds. Bison were recklessly overhunted until, in the late 1800s, approximately 1,500 remained. Now bison are legally protected in Yellowstone National Park and on preserves such as the National Bison Refuge in Montana. The development of commerical bison ranching has also played a role in increasing the North American Bison population, which has grown to over 350,000 animals. Colleen Gorman was the production editor and the copyeditor for Java Extreme Programming Cookbook. Mary Brady, Brian Sawyer, and Mary Anne Weeks Mayo provided quality control. Tom Dinse wrote the index.

Hanna Dyer designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

Bret Kerr designed the interior layout, based on a series design by David Futato. This book was converted by Joe Wizda to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XMLtechnologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. This colophon was written by Colleen Gorman.

Service and support by Satisfaction

O'Reilly Books & Videos

Java Extreme Programming Cookbook

Chapter 1 XP Tools

Java and XP

Tools and Philosophies

Open Source Toolkit

Chapter 2 XP Overview

What Is XP?

Coding

Unit Testing

Refactoring

Design

Builds

Chapter 3 Ant

Introduction

Writing a Basic Buildfile

Running Ant

Providing Help

Using Environment Variables

Passing Arguments to a Buildfile

Checking for the Existence of Properties

Defining a Classpath

Defining Platform-Independent Paths

Including and Excluding Files

Implementing Conditional Logic

Defining a Consistent Environment

Preventing Build Breaks

Building JAR Files

Installing JUnit

Running Unit Tests

Running Specific Tests

Generating a Test Report

Checking Out Code from CVS

Bootstrapping a Build

Chapter 4 JUnit

Introduction

Getting Started

Running JUnit

assertXXX( ) Methods

Unit Test Granularity

Set Up and Tear Down

One-Time Set Up and Tear Down

Organizing Tests into Test Suites

Running a Test Class Directly

Repeating Tests

Test Naming Conventions

Unit Test Organization

Exception Handling

Running Tests Concurrently

Testing Asynchronous Methods

Writing a Base Class for Your Tests

Testing Swing Code

Avoiding Swing Threading Problems

Testing with the Robot

Testing Database Logic

Repeatedly Testing the Same Method

Chapter 5 HttpUnit

Introduction

Installing HttpUnit

Preparing for Test-First Development

Checking a Static Web Page

Following Hyperlinks

Writing Testable HTML

Testing HTML Tables

Testing a Form Tag and Refactoring Your Tests

Testing for Elements on HTML Forms

Submitting Form Data

Testing Through a Firewall

Testing Cookies

Testing Secure Pages

Chapter 6 Mock Objects

Introduction

Event Listener Testing

Mock Object Self-Validation

Writing Testable JDBC Code

Testing JDBC Code

Generating Mock Objects with MockMaker

Breaking Up Methods to Avoid Mock Objects

Testing Server-Side Business Logic

Chapter 7 Cactus