6 June, 2005 at 01:25 Leave a comment

  Home Download Getting Started JavaDocs Documentation Articles Books IDEs Extensions Get Involved Training
 
Blinky

Article News

as of February 22, 2004…

Automated Continuous Testing

Test-Driven Plug-In Development

Test First Challenges

as of February 16, 2004…

Approaches to Mocking

Test-Driven Development Is Not About Testing

as of February 07, 2004…

Using JUnit With Eclipse IDE

testdriven.com

as of January 22, 2004…

A Dozen Ways to Get the Testing Bug in the New Year

JUnit Automates Java Testing

as of January 11, 2004…

Testing Java Interfaces with JUnit

Build a Java Web Application Using HttpUnit and the Test-driven Methodology, Part II

as of December 31, 2003…

The Third State of your Binary JUnit Tests

Build a Java Web App Using HttpUnit and the Test-driven Methodology, Part I

as of December 26, 2003…

Multithreaded Tests with JUnit

as of December 19, 2003…

Increasing the Effectiveness of Automated Testing

Critical Success Factors for Automated Unit Testing

Test Automation Manifesto

Agile Regression Testing Using Record & Playback

Test-First Development with Mock J2EE, JMS, JNDI

as of December 03, 2003…

Subverting Java Access Protection for Unit Testing

JUnit HowTo

as of September 01, 2003…

Virtual Mock Objects using AspectJ with JUnit

Test First Guidelines

Test-Driven Development – The Coad Letters

as of July 26, 2003…

Virtual Clock

The Humble Dialog Box

as of April 29, 2003…

Bringing your Java Application to Mac OS X Part Two

as of February 08, 2003…

Two Critical Tips for Unit Testing in Java

as of January 27, 2003…

Unit testing with mock objects

as of November 08, 2002…

XP/Agile Universe 2002 Proceedings

as of September 21, 2002…

Developer Testing While Fixing a Bug

as of August 31, 2002…

Test networked code the easy way

as of August 21, 2002…

A Simple and Practical Approach to Unit Testing: The JML and JUnit Way.

as of August 15, 2002…

Prevent mistypings to the String class

as of June 19, 2002…

Installing and Running a JUnit Test — A Tutorial

Emergent Optimization In Test Driven Design

as of May 15, 2002…

Test flexibly with AspectJ and mock objects

as of May 03, 2002…

Evolution of an Inside-Outside Test

as of April 12, 2002…

Working Effectively With Legacy Code

as of March 30, 2002…

Refactoring Test Code

as of March 24, 2002…

The Saboteur Data bug pattern

as of March 22, 2002…

Diagnosing Java Code: The Liar View bug pattern

as of March 19, 2002…

Stop Over-Engineering!

as of March 18, 2002…

Implement Design by Contract for Java using dynamic proxies

as of March 17, 2002…

Discover Your Inner Classes

as of March 12, 2002…

XP junit tutorial using LinkedList

as of March 10, 2002…

Test First, Code Later

as of March 04, 2002…

JUnit: A Starter Guide

as of March 01, 2002…

Using JUnit at the Painter lab

as of February 13, 2002…

Testing Interface Compliance with Abstract Test

The Go-ForIt Chronicles: Memoirs of eXtreme DragonSlayers, Part 14

Learning to Love Unit Testing

Test-First Challenge

Test-driven development

as of December 23, 2001…

Introducing JUnit

java tools for eXtreme programming

Unit Testing Java Programs

Testing EJBs with JUnit

Aim Fire

as of October 26, 2001…

Running Java Applications on Mac OS X

as of October 26, 2001…

Developing JDBC applications test-first

as of September 21, 2001…

JUnit Featuring Dynamic Proxies

Unit Tests mit Java

as of August 31, 2001…

Automating the build and test process

Use your singletons wisely

Diagnosing Java Code: The Fictitious Implementation bug pattern, Part 1

Diagnosing Java Code: The Fictitious Implementation bug pattern, Part 2

Diagnosing Java Code : The Orphaned Thread bug pattern

Diagnosing Java Code: The Split Cleaner bug pattern

as of August 06, 2001…

Automatically Generating System Mock Objects

ObjectMother – Easing Test Object Creation in XP

as of July 20, 2001…

Unit Testing mit JUnit Automatisiertes Testen in Java

Diagnosing Java Code: The Broken Dispatch bug pattern

A J2EE Testing Primer

Evolution of Test and Code Via Test-First Design

Test First

as of July 04, 2001…

The ‘Self’-Shunt Unit Testing Pattern

Design Principles in Test First Programming

as of July 01, 2001…

Application Quality Assurance: Unit Testing

as of June 19, 2001…

Unit testing database code

TomcatBook: Chapter on Testing

Diagnosing Java Code: Recorders test for proper method invocation

Test First Programming — Some Personal Experiences

as of May 05, 2001…

Diagnosing Java Code: The Dangling Composite bug pattern

Diagnosing Java Code: The Double Descent bug pattern

Diagnosing Java Code: The Null Flag bug pattern

Bug patterns: An introduction

J2EE project dangers!

as of April 18, 2001…

Testing, fun, Really?

as of March 22, 2001…

Test First Design

as of March 21, 2001…

Engineering Notebook: An Extreme Programming Episode

as of February 14, 2001…

JUnit Best Practices

Continuous Integration

Is Design Dead?

Incremental development with Ant and JUnit

JUnit++ Testing Tool

Junit Primer

Testing for Programmers

The Test/Code Cycle in XP: Part 1, Model

The Test/Code Cycle in XP: Part 2, GUI

A UML Testing Framework

Testing in an Extreme Programming Setting

eXtreme Testing

sdrawkcaB gnikroW

JavaCon 2000 Presentation – Servlet Unit Testing

Test infect your Enterprise JavaBeans

Mock Objects

JUnit Articles

Bug Pattern Articles

J2EE Articles

Test Pattern Articles

Test First Articles

Automated Continuous Testing

Continuous testing uses excess cycles on a developer’s workstation to continuously run regression tests in the background, providing rapid feedback about test failures as source code is edited. It reduces the time and energy required to keep code well-tested, and prevents regression errors from persisting uncaught for long periods of time.
David Saff and Michael D. Ernst. , June 12, 2003

Approaches to Mocking

Everyone knows what a mock is, just from the name, but as with many seemingly simple ideas, there is more to them than first meets the eye. This article explores the two types of mocks that exist and covers some of the problems inherent in their use. Finally, it considers the reason why a developer might chose to use mocks. After all, common understanding holds that mocks are used for unit testing, a key part of Test Driven Design
Simon Stewart , February 11, 2004

Using JUnit With Eclipse IDE

This article is going to introduce you to JUnit, a tool for project testing and debugging. After introducing the theory of test-driven development, we’ll move on to a step-by-step explanation of how you can create your JUnit tests with the help of the popular Eclipse IDE. We’ll show how something as simple as a Hello World program can be exposed to a JUnit test.
Alexander Prohorenko and Olexiy Prohorenko, February 04, 2004

A Dozen Ways to Get the Testing Bug in the New Year

This article gives you 12 practical ways to start writing tests, and keep writing tests, regardless of your development process.
Mike Clark, January 22, 2004

JUnit Automates Java Testing

It doesn’t matter how much time you put into design and how careful you are when programming; mistakes are inevitable. Without automated testing, it is time consuming and difficult to ensure that changes will not break existing code. Fortunately, for Java programmers, JUnit makes such testing easy. JUnit makes it fast and easy to set up unit tests for your programs.
David Morris, November 06, 2003

Testing Java Interfaces with JUnit

JUnit does not provide an easy way to write tests for testing subclasses. Some developers cut-and-paste their tests between test classes, which makes the tests hard to maintain. Others attempt to subclass one test from another, which does not scale when interfaces need testing. If you intend to make your tests maintainable and robust, then they need a design just as much as the core system.
Matt Albrecht, February 28, 2003

The Third State of your Binary JUnit Tests

Passing or failing: these are the usual states of JUnit tests. But discover a third state that many use but only few acknowledge, and how you can elegantly manage these tests with JUnit-addons Runner.
Vladimir Ritz Bossicard , April 23, 2003

Multithreaded Tests with JUnit

JUnit is the glue that holds many open source projects together. But JUnit has problems performing multithreaded unit tests. This creates considerable difficulty for middleware developers in the open source J2EE market. This article introduces GroboUtils, a JUnit extension library designed to address this problem and enable multithreaded unit testing in JUnit. A basic understanding of JUnit and threads is recommended but not necessary for readers of this article.
N. Alex Rupp, August 06, 2003

Increasing the Effectiveness of Automated Testing

This paper describes techniques that can be used to reduce the execution time and maintenence cost of the automated regression test suites that are used to drive development in eXtreme progamming (XP). Developers are likely to write and run tests, thus getting valuable feedback, if testing is as painless as possible.
ClearStream Consulting Inc., July 23, 2001

Critical Success Factors for Automated Unit Testing

This presentation focuses on identifying those critical success factors that are required to make automated testing a cost effective contributor to agile development and discusses a few of the techniques that can be used to achieve them.
ClearStream Consulting Inc., April 11, 2003

Test Automation Manifesto

Two key aspects of eXtreme Programming are automated testing and frequent refactoring. But is refactoring the best way to arrive at a set of tests that are both sufficient and maintainable? This paper builds on previously cataloged test smells, classifies these smells into two broad categories and introduces principles (or goals) for test automation. It also provides the start of a generative pattern language that helps guide the construction of automated tests that should not require extensive refactoring.
ClearStream Consulting Inc., January 01, 2000

Agile Regression Testing Using Record & Playback

There are times when it is not practical to hand-script automated tests for an existing system before one starts to modify it. In these circumstances, the use of “record & playback” testing may be a viable alternative to hand-writing all the tests. This paper describes experiences using this approach and summarizes key learnings applicable to other projects.
ClearStream Consulting Inc., August 11, 2003

Subverting Java Access Protection for Unit Testing

The Java Reflection API allows the program to introspect arbitrary classes at runtime, accessing members at will. Most competent Java programmers should know this much, but what many don’t know is that the security layer preventing you from accessing private members is only optional, and can be turned off. This allows the system code to be written without explicitly planning the unit tests, and if the unit tests really do need to access a private or protected member, they can.
Ross Burton, November 12, 2003

JUnit HowTo

The tutorials that I used to learn JUnit spent about 80% of my time learning the program that was to be tested as an example, and the resultant tutorial therefore took five times longer to digest than it should have. There is no need to learn to understand somebody elses’ data structures just to learn JUnit. If you have an hour to learn to use a terrific product, then proceed.
Blaine Simpson, November 01, 2003

Virtual Mock Objects using AspectJ with JUnit

True unit testing requires that you only test the unit itself and not any services that the unit may use from other units. In this paper we describe our experiences of using aspect-oriented programming techniques to isolate the unit under test. Instead of hand-crafting or using a tool to generate code for Mock Objects, the approach we take uses AspectJ to intercept calls to “real” objects returning mock values that are set within the test itself.
Simon Monk, Stephen Hall , October 01, 2002

Bringing your Java Application to Mac OS X Part Two

In this series we focus on tuning your cross-platform Java application so that it looks and feels more like a native application when running on Mac OS X without changing the look and feel on other platforms. In these articles, most of the examples are presented as small isolated instances of platform-specific improvements you can make. We continue to use the open source unit testing application JUnit for the examples. Last time we made JUnit more Mac-like by adjusting run-time properties. This time you make changes to the source code.
Daniel H. Steinberg, March 30, 2003

Two Critical Tips for Unit Testing in Java

There are two issues that often vex Java developers when they attempt to unit test their code. The first one is whether to design their systems in a manner that facilitates testing. The second is how to test non-deterministic code. This article offers helpful tips for handling these dilemmas.
Bryan Dollery, February 08, 2003

Unit testing with mock objects

Mock objects are a useful way to write unit tests for objects that act as mediators. Instead of calling the real domain objects, the tested object calls a mock domain object that merely asserts that the correct methods were called, with the expected parameters, in the correct order. However, when the tested object must create the domain object, we are faced with a problem. How does the tested object know to create a mock domain object instead of the true domain object?
Alexander Day Chaffee, William Pietri , November 30, 2002

XP/Agile Universe 2002 Proceedings

Purchase the XP/Agile Universe 2002 proceedings to recieve four to eleven testing articles (depending how you count them) and more.
September 27, 2002

Test networked code the easy way

Networked code proves difficult to test thoroughly because test suites work best as standalone processes unreliant on other servers. In this article, Nelson Minar describes two techniques for unit testing network code. First, he proposes that you design your code such that as much logic as possible works independently from the network. Second, he suggests using Java’s protocol handler classes to simulate network connections without actually using the network. By employing these principles, you’ll produce easily tested network software.
Nelson Minar, August 27, 2002

A Simple and Practical Approach to Unit Testing: The JML and JUnit Way.

In this paper we present a new approach that makes writing unit tests easier. It uses a formal specification language’s runtime assertion checker to decide whether methods are working correctly, thus automating the writing of unit test oracles. These oracles can be easily combined with hand-written test data. Instead of writing testing code, the programmer writes formal specifications (e.g., pre- and postconditions).
Yoonsik Cheon and Gary T. Leavens, August 19, 2002

Installing and Running a JUnit Test — A Tutorial

Effective testing is almost synonymous with effective programming. Java has available an excellent testing suite called JUnit. This guide will attempt to get you up and running with JUnit in the shortest amount of time possible.
Adam Monsen, May 06, 2002

Test flexibly with AspectJ and mock objects

Programmers who have incorporated unit testing into their development process know the advantages it brings: cleaner code, courage to refactor, and higher velocity. But even the most die-hard unit testers can falter when faced with testing a class that relies on system state for its behavior. Nicholas Lesiecki, a respected Java programmer and leader in the XP community, introduces the problems surrounding test-case isolation and shows us how to use mock objects and AspectJ to develop precise and robust unit tests.
Nicholas Lesiecki , May 01, 2002

Working Effectively With Legacy Code

The main thing that distinguishes legacy code from non-legacy code is tests, or rather a lack of tests. With tests, you can make things better. Without them, you don’t know whether things are getting better or worse.
Michael Feathers, Object Mentor, April 11, 2002

Refactoring Test Code

Two key aspects of extreme programming (XP) are unit testing and merciless refactoring. given the fact that the ideal test code / production code ratio approaches 1:1, it is not surprising that unit tests are being refactored. We describe a set of bad smells that indicate trouble in test code, and a collection of test refactorings to remove these smells.
Arie van Deursen, Leon Moonen, Alex van den Berg, and Gerard Kok, July 01, 2001

Implement Design by Contract for Java using dynamic proxies

The Design by Contract (DBC) theory can dramatically raise software quality and reusability levels by forcing you to think in terms of contracts. Contracts formally specify the responsibility relationship between a client (class user) and a supplier (class). Additionally, DBC clearly separates specification (what) from implementation (how). This article explains DBC’s importance in object-oriented development and describes a DBCProxy framework that achieves DBC transparently in Java using dynamic proxy classes.
Anders Eliasson , February 15, 2002

Discover Your Inner Classes

Unit testing driving you nuts? Learn how using inner classes with the JUnit testing framework can bring you inner peace
Harris W. Kirk , January 01, 2002

XP junit tutorial using LinkedList

This is an introduction/tutorial for using junit as part of the XP (Extreme Programming) style of software development. It uses the example of a simple linked list containing Person objects.
Paraclete, January 01, 2002

JUnit: A Starter Guide

JUnit is an open source testing framework for Java. It provides a very simple way to express the way you intend your code to work. By expressing your intentions in code, you can use the JUnit test runners to verify that your code behaves according to your intentions. This document should provide enough information for you to get started writing tests with JUnit.
Diaspar Software Services, January 01, 2001

Using JUnit at the Painter lab

JUnit tutorial for The University of Texas’s CS315.
Alan Oursland, February 28, 2002

Testing Interface Compliance with Abstract Test

Interfaces and Abstract Classes are language constructs that appear over and over in many design patterns and even just in good design techniques. It is common for a single interface or abstract class to have many different descendants or implementations. A good example of this scenario is the Strategy Pattern which relies heavily on many implementations of the same interface. It is desirable to have one test suite that tests functional compliance with the interface that could be applied to each of the implementing classes.
Eric George, February 05, 2002

The Go-ForIt Chronicles: Memoirs of eXtreme DragonSlayers, Part 14

The DragonSlaying technical consulting team’s Willy Farrell describes how they used the JUnit framework within VisualAge for Java to unit test the Java classes, including Enterprise JavaBeans (EJB) components, for the Go-ForIt project. This article gives a brief overview of the JUnit framework, describes the team’s overall unit testing strategy, and discusses testing considerations for EJBs.
Willy Farrell, January 01, 2002

Learning to Love Unit Testing

If you’re a developer who isn’t currently using unit tests, then this article will show you some reasons to start and, we hope, convince you that writing tests for everything you do will actually make your job easier and your systems better. And if you’re a developer who is testing as you code, then maybe the article will help you feel just a little smug.
Dave Thomas and Andy Hunt , February 01, 2002

Introducing JUnit

This article is based on an overview that I wrote to help introduce developers on a pilot project to unit testing. It covers the strategic reasons for using unit tests and the tactics of writing a unit test harness using the freely available JUnit framework to minimise the work involved. It does not cover all the options for using JUnit.
Alan Griffiths, 2001 , January 01, 2001

java tools for eXtreme programming

Java Tools for eXtreme Programming describes techniques for implementing the Extreme Programming practices of Automated Testing and Continuous Integration using Open Source tools, e.g., Ant, JUnit, HttpUnit, JMeter, and much more.
Richard Hightower, Nicholas Lesiecki, November 09, 2001

Unit Testing Java Programs

Testing programs can be very boring. Especially testing other people’s programs. And especially if you’re a programmer. But programmers love to write programs, so why not let the programmers write some programs that’ll do the testing for them? This is the idea behind automated testing, and this is what this article is about.
Keld H. Hansen, November 01, 2001

Running Java Applications on Mac OS X

In this article we’ll look at how to take a Swing application that was never designed to run on the Mac and run it in progressively easier ways. As our example, we’ll look at the JUnit developer tool available from JUnit.org.
Daniel H. Steinberg, July 06, 2001

JUnit Featuring Dynamic Proxies

I’m currently using Junit to do integration testing (or functional testing), rather than unit testing. This involves a number of differences from what the standard Junit methodology would suggest. It’s important to understand that the modifications I’ve made aren’t necessarily applicable to everyone who’s doing unit testing, but for those of you out there who feel that sometimes Junit gets in the way of doing other sorts of testing this may help.
Shane Celis, August 21, 2001

Unit Tests mit Java

(translated from German) Is important to tests. Although concerning this with many developers agreement exists, persistent adjustments hold themselves like ” a testing of software are function of the test department ” or ” I do not have time for testing “. For a qualitatively high-quality software however even developer tests on module level – unit so mentioned test – are indispensable.
Johannes Link, September 01, 2001

Automating the build and test process

Incremental testing and continuous builds are two of the cornerstones of the Extreme Programming methodology. Combine the two in a single, automated process — and throw in automatically generated e-mail reports — and you’ll be well on your way to XP nirvana. Follow along as Erik Hatcher shows you how he has modified the popular Ant 1.3 and the JUnit test framework for complete, customized automation of the build and test process.
Erik Hatcher, August 14, 2001

Use your singletons wisely

The programming community discourages using global data and objects. Still, there are times when an application needs a single instance of a given class and a global point of access to that class. The general solution is the design pattern known as singletons. However, singletons are unnecessarily difficult to test and may make strong assumptions about the applications that will use them. In this article I discuss strategies for avoiding the singleton pattern for that majority of cases where it is not appropriate. I also describe the properties of some classes that are truly singletons.
J. B. Rainsberger, July 01, 2001

Unit Testing mit JUnit Automatisiertes Testen in Java

(translated from German) JUnit is a small, yet powerful Java framework for writing and running automatic unit tests. Simply because the tests are written directly in the Java language itself, testing with JUnit is as simple as compiling your code. The tests are self-verifying and therefore repeatable.
Copyright 2000-2001 Frank Westphal, Letzte Anderungen, July 16, 2001

Unit testing database code

The problem is this: you have a SQL database, some stored procedures, and a layer of code sitting between your application and the database. How can you put tests in place to make sure your code really is reading and writing the right data from the database?
Richard Dallaway, May 01, 2001

TomcatBook: Chapter on Testing

This is a preliminary chapter from the TomcatBook
Armin Roehrl, May 01, 2001

Testing, fun, Really?

Testing. Yuck! Puh! Aagh! I’ve always hated testing. Testing, both unit and functional, is something that gets in the way of the “real” work. Everyone knows that their code is perfect, right? In the unlikely event that the code does need to change, the comments are so well written that anyone could figure it out. Wow, am I in need of growth (maybe some counseling as well.)
Jeff Canna, RoleModel Software, Inc., March 01, 2001

JUnit Best Practices

Techniques for building resilient, relocatable, multithreaded JUnit tests.
Andy Schneider, December 01, 2000

Continuous Integration

Software development is full of best practices which are often talked about but seem to be rarely done. One of the most basic, and valuable, of these is a fully automated build and test process that allows a team to build and test their software many times a day.
Martin Fowler, Chief Scientist, ThoughtWorks and Matthew Foemmel, ThoughtWorks, January 01, 2001

Is Design Dead?

XP2000 keynote.
Martin Fowler, Chief Scientist, ThoughtWorks, July 01, 2000

Incremental development with Ant and JUnit

Using unit test to improve your code in small steps.
Malcolm Davis, Consultant, November 01, 2000

JUnit++ Testing Tool

Featured in Dr Dobb’s: JUnit++ is a freely available Java unit test framework that includes a test data repository, command-line arguments, and a TestRunner class that supports a built-in repetition counter and multithreading at the command line.
Siegfried Goeschl, February 01, 2001

Junit Primer

This article demonstrates how to write and run simple test cases and test suites using the JUnit testing framework.
Mike Clark, Clarkware Consulting, October 07, 2000

Testing for Programmers

Brain Marick, January 01, 2000

The Test/Code Cycle in XP: Part 1, Model

This paper shows how unit tests and simple design work together while programming.
Copyright 2000, 2001, William C. Wake, February 01, 2000

The Test/Code Cycle in XP: Part 2, GUI

A small but plausible example, giving the flavor of testing and programming using JUnit for testing the user interface.
Copyright 2000, 2001, William C. Wake, January 01, 2000

A UML Testing Framework

When using the UML to explain how a system works, the key to clear communication is to keep your diagrams simple, yet expressive.
Martin Fowler, Chief Scientist, ThoughtWorks, April 01, 1999

Testing in an Extreme Programming Setting

An introduction to writing TestCases
Joseph Bergin, Pace University, September 01, 2000

eXtreme Testing

Eric Burke covers JUnit code examples, including the (barely documented) JUnit extension classes which allow repeated tests and multi-threaded tests, at the St. Louis Java User’s Group.
Eric Burke, October 01, 2000

sdrawkcaB gnikroW

This is a preliminary chapter from XP in Practice Copyright 2001 by Addison Wesley. All rights reserved.
James Newkirk and Robert C. Martin, Object Mentor, January 01, 2001

Advertisements

Entry filed under: Uncategorized.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Trackback this post  |  Subscribe to the comments via RSS Feed


Calendar

June 2005
M T W T F S S
« May   Jul »
 12345
6789101112
13141516171819
20212223242526
27282930  

Tweets


%d bloggers like this: