Java Extreme Programming Cookbook

Larger Cover

By Eric M. Burke, Brian M. Coyner

Publisher: O'Reilly Media

Released: March 2003

Pages: 288

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.

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

Title:

Java Extreme Programming Cookbook

By:

Eric M. Burke, Brian M. Coyner

Publisher:

O'Reilly Media

Formats:

Print
Safari Books Online

Print:

March 2003

Pages:

288

Print ISBN:

978-0-596-00387-6

| ISBN 10:

0-596-00387-0

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.

Description

Table of Contents

Product Details

Colophon

Recommended for You

Recently Viewed

MongoDB: The Definitive Guide

Powerful and Scalable Data Storage

By Kristina Chodorow, Michael Dirolf

September 2010

Ebook: $31.99

Print & Ebook: $43.99

Print: $39.99

Your Body: The Missing Manual

By Matthew MacDonald

July 2009

Ebook: $19.99

Print & Ebook: $27.49

Print: $24.99

CouchDB: The Definitive Guide

Time to Relax

By J. Chris Anderson, Jan Lehnardt, Noah Slater

January 2010

Ebook: $31.99

Print & Ebook: $43.99

Print: $39.99

Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews

oreilly Java Extreme Programming Cookbook

5.0

(based on 2 reviews)

Reviews

Reviewed by 2 customers

Sort by

Displaying reviews 1-2

4/13/2004

5.0

Perfect cookbook for the novice

By FreeSoul

from Undisclosed

Comments about oreilly Java Extreme Programming Cookbook:

Great ! In short that is the all I can use with regards to this book. Comment holding good for all aspects

Content

Presentation of concepts

Examples that can be used in real time

I should admit here, I had almost no prior experience to XP. All I had in terms of XP exposure was literary confirmatio that it was something of benefit. Using this book I am glad to state that I have actually beging to reap the actual benefits in real time. Now to go back and look the learning curve was not very steep. A lot has to do with this book.

Thanks for the wonderful book. Introduces a lot of practical concepts. I personally found the testing sections to be extremely helpful.

6/30/2003

5.0

Java Extreme Programming Cookbook Review

By Mitch Lowry from the Columbia Java Users Group

from Undisclosed

Comments about oreilly Java Extreme Programming Cookbook:

Instead of digging through the documentation of your open-source tool, take a look at this book. The first two chapters give an overview of extreme programming (XP), but the rest of the chapters are focused on the tools of XP. Each of the chapters on the tools begin with a brief description of the tool (and I mean brief). The rest of the chapter is sub divided into sections. Within each section, a problem that one might encounter with the tool is introduced, then a solution is proposed and discussion of the solutions follows (with an example).

The tools covered are Ant, Junit, HttpUnit, Mock Objects, Cactus, JunitPerf and Xdoclet. Tomcat and JBoss are addressed in a chapter together. Because of the brevity and focus of the book, probably not everything that you want to know about a tool is mentioned. After you already know why and when to use a tool, this book can help with the how.

The book is a good reference tool and could save someone a lot of time, but look elsewhere for more in-depth explanations.

Displaying reviews 1-2

Save a Tree - Go Digital what is this?

Print: $34.95

Safari Books Online - Read now >

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

Introduction

Configuring Cactus