testdriven.com Wrangling quality out of chaos

Archive for July, 2003

Software Test Automation Conference and Expo

07.23.2003 · Posted in News

Learn the Techniques, Deliver the Results
Software Quality Engineering is proud to bring together a select group of industry experts combined with leading tools and service providers to show you how to deploy your resources to better achieve your organization’s test automation goals.

See below, list of conferences in the [url=http://www.cmpevents.com/SDxE/a.asp?option=C&V=1&CPid=24&Regid=0&scTKs=130&SB=4]Testing and Quality track[/url] which pertain to test-driven development.

Dates: August 19-22, 2003
Location: Boston, MA

Software Test Automation Conference and EXPOApplying Continuous Integration and Automated Testing to J2EE
Speaker: Richard Hightower
Date: Thursday, 9:45 am – 11:00 am, 11:15 am – 12:30 pm
This session is designed for developers who want to apply the Extreme Programming (XP) practices of Automated Testing and Continuous Integration to Java and J2EE using Ant, XDoclet, JUnit, HttpUnit, JMeter, Cactus, JunitPerf to automatically build, deploy, configure and test J2EE applications. This class includes examples and tutorials on each tool. The examples cover building, deploying and testing Java and J2EE applications. The focus is how to use these tools to assemble and test components that can be assembled into many different applications that can be deployed on many application servers, operating systems and RDBMS. The class will show how to create an environment that supports the rapid construction of quality Java/J2EE software.

Test-Driven Development using Java and JUnit
Speaker: David Astels
Date: Tuesday, 3:45 pm – 5:00 pm
Test-driven Development (TDD) is a cornerstore of eXtreme Programming (XP). Without TDD in place, most of the other practices are difficult or impossible (e.g. refactoring, continuous integration. While writing a complete suite of programmer tests for your software is good, writing them first is better. However, the benefits of practicing TDD are not limited to XP, and can be realized in any Agile, and even some non-Agile, contexts. TDD helps make our code better, regardless of what amount of design or modeling has been done before programming begins. It’s a generally useful technique to have in our bag of tricks. This class will provide an introduction to TDD showing how it works and what benefits it provides. The class will be conducted using Java and JUNIT. You will gain an understanding of how writing tests can drive development, resulting in cleaner, simpler, more correct, extendable, maintainable, and robust code. You will also get a chance to do some TDD, allowing you to get a feel for the flow of it.

JSig Seminar on Quality Development and Agile Modeling

07.20.2003 · Posted in News

Topics of the one-day seminar:

Quality Development
On average, 30% of total project cost is spent on rework. Attempts at reducing project cost focus on improving developer productivity and all too often forget the critical issues of improving quality and maintainability. This session will cover some of the techniques and tools that can allow the developer to improve quality, maintainability and productivity.

Agile Modelling with collaborativeAID

CollaborativeAID was designed to overcome specific issues faced by a lack of tooling in the Agile Development space. The design principles behind the product development, gives an insight into to the uniqueness of CollaborativeAID Tooling.

Date: Tuesday July 29 2003 12:00-14:00
Location: London, UK
Subjects covered include:

Profiling: Look inside the JVM & J2EE black boxes and regain control.
Unit Testing: Integrate Unit Testing earlier into the development cycle.
Visualisation: Multiple ways to visualise runtime and static behaviour
Communication: Effective communication between development and testing teams.
Code Analysis: Static analysis of code to enforce coding standards and collect metrics.
Design & Documentation: Realistic ways to get design & documentation up to date and maintain it.
Project Visibility: Developers need to be able to understand the requirement and reasoning behind a piece of code.

High Collaboration: Pure updateable access from any Internet browser.
Virtual Wall Of Wonder (WOW): A virtual canvas to draw and design ideas.
Lightweight Communication: No client software required.
Open & Extendable Architecture: Internally developed or open source compilers to be included into the cAID architecture.
Wiki Wiki Metaphor: Updateable from anywhere by anyone.

If you would like to attend this seminar please send your name and company name, e.g. John Smith-ACME Corp, in the body of the message to london-seminars@jsig.com with the title: Quality-Agile July 29 2003.

http://209.235.197.109/seminars/2003/London/29July2003.html

AgileData.org: Test-Driven Development

07.20.2003 · Posted in Links

TDD completely turns traditional development around. Instead of writing functional code first and then your testing code as an afterthought, if you write it at all, you instead write your test code before your functional code. Furthermore, you do so in very small steps – one test and a small bit of corresponding functional code at a time. A programmer taking a TDD approach refuses to write a new function until there is first a test that fails because that function isn’t present. In fact, they refuse to add even a single line of code until a test exists for it.

Author: Scott Ambler
Published: 2003
link

Tags:

Learning to Love Unit-Testing [PDF]

07.03.2003 · Posted in Links

Let’s look at unit testing by first sitting in on a development session as a programmer starts to attack a particular problem. We’ll watch her use tests to give herself confidence, and to break her work into bite-sized chunks. We’ll see how simple it is to write tests, and how the process of “test a little, code a little” makes our developer more productive. Then we’ll look at some of the reasons developers give for not writing unit tests, along with our counter arguments. Finally, we’ll look at some surprising benefits that come from unit testing—things
that have nothing to do with testing itself.

Authors: Dave Thomas & Andy Hunt (Pragmatic Programmer)
Published: STQE Magazine, January/February 2002

link

Tags:

Diving in Test-First

07.03.2003 · Posted in Links

When I first heard about the idea of writing tests before writing the code, I thought it was crazy, because I thought it referred to independent testers, i.e., people who focus on testing other people’s code. Developers always change the spec while they’re coding, so why bother to code the tests to a spec that will be out of date in nanoseconds? But test-first applies to testing done by developers, and in that context it makes great sense. The test development is tightly intertwingled with the coding.

A discussion of the five-step cycle of test-driven development, with Perl examples.

Author: Danny R. Faught (Tejas Consulting)
Published: April 2003

link

Smalltalk Solutions 2003: The Toronto Conference

07.02.2003 · Posted in News

Smalltalk Solutions is the premier forum for bringing together Smalltalk users, developers, and enthusiasts. A number of conferences will cover test-driven development using Smalltalk; they are indicated below.

Last day to register by fax or online: Monday, 7 July 2003. Past this date, you can register only at the Conference.

Location: Toronto, Canada
Dates: July 14-16
e-mail: jjones@stic.org
Phone: (919) 789-8549
Fax: (919) 789-8615
Theme: Test-Driven Development (Tutorial)
Speaker: Dave Astels (Adaption Software, Inc.)
Date: Wednesday 2:00:00 pm to 5:30:00 pm

This will be a very pragmatic tutorial, with a mix of lecture, demonstration, and hands-on exercises. Background, tools, and techniques of TDD would be covered, as well conceptual topics such as refactoring tests, building tests around fixtures, what makes for a good test, approaches to writing tests to maximize the benefit, etc. Hands-on means programming, so make sure to bring a laptop and be prepared to pair-up.

Theme: An open-source acceptance testing application
Speaker: Sean Morrison (OTPP)
Date: Tuesday 9:15:00 am to 10:00:00 am

The development environment at OTPP includes a large number of non-technical business analysts who validate the correctness of applications developed in-house. These businesspeople use an internally developed testing application named BRITE to run acceptance level tests against our applications to validate new features and to guard against regression. Traditionally, BRITE was used to test applications written in Smalltalk. It has recently been extended to include the ability to testapplications written in other languages and applications that run within a server environment (as opposed to on client PCs).

Theme: Unit-testing Web Applications
Speaker: Colin Putney (Whistler.com)
Date: Wednesday 2:00:00 pm to 2:45:00 pm

The talk describes the templating system we’ve been using at Whistler.com and the testing methodology we use with it. The templating system follows an MVC pattern where templates are parsed into a DOM-like tree of views, which are manipulated by the component using LISP-like macros. The first part of the talk describes the framework and explore the motivations behind its design. The second part describes the requirements for testing web-based UIs, how this template system has allowed us to write testable UIs and the test patterns we’ve found effective.

Theme: VWUnit – An Open Source Framework for Unit Testing VisualWorks GUIs
Speaker: David Buck (Simberon)
Date: Tuesday 8:30:00 am to 9:15:00 am

NUnitASP: ASP .NET Unit-testing

07.02.2003 · Posted in Links

NUnitAsp is based on the principle that testing web pages should use the same concepts as creating them. When you use NUnitAsp, you use classes and IDs similar to those you used when creating the web page you are testing.

In this tutorial, we’ll walk you through the process of creating a simple one-page web application and tests.

Authors: Jim Little and Andrew Enfield
See also: Quick Start Guide

link

JUnitEE: HTML output for Servlets

07.02.2003 · Posted in Links

JUnitEE provides a TestRunner which outputs HTML and a servlet which can be used as an entry point to your test cases. Building your test harness as a standard J2EE web application means:

– Your tests are packaged conveniently into a .war file which can easily be moved between servers; you can leave the .war file in the main .ear file and simply avoid enabling the test web application on the production server.

– Your test classes will be dynamically reloaded by the app server (assuming your server supports this).

– Your test cases look just like your production code, and can use the same beans (or whatever) you use as a facade for your EJBs.
link

TagUnit: Unit-testing custom JSP tags

07.02.2003 · Posted in Links

In the same way that JUnit allows us to write unit tests for Java classes, TagUnit allows us to unit test JSP custom tags, inside the container. In essence, TagUnit is a tag library for testing custom tags within JSP pages.

Even with tools like Cactus, JUnitEE and HttpUnit, testing Java Servlets and JSP pages is hard, particularly if they contain specific business or presentation logic that needs to be tested. Best practices around J2EE development suggest that logic should be encapsulated in JavaBeans or JSP custom tags for better separation of concerns, maintainability, reusability and to facilitate easier testing. Although JUnit can be used to test JavaBeans, testing custom tags by simply invoking their methods doesn’t make sense. Custom tags are components and therefore need to be tested at that level, in the way that they would normally be used from within a JSP page.

TagUnit provides a way to perform assertions on the content that custom tags generate and the side-effects that they have on the environment such as the introduction of scoped (request/page/session/application) attributes, cookies and so on. In addition to this, assertions can be made on the constraints specified within the tag library descriptor file that give us a way to verify the contract that a tag provides. In just a four line JSP page, TagUnit can automatically perform tests such as asserting whether the tag handler class is loadable and that it has setter methods for all declared attributes. To supplement this, user defined tests provide a way to perform assertions on the description of a tag, such as its body content and the details of any attributes.
link

Exploring Programmer Tests

07.02.2003 · Posted in News

This workshop will focus on Programmer Tests as defined in Test-Driven Development and the XP literature. Such tests are written by programmers to drive the development of software, demonstrate step-by-step progress towards the completion of a task and provide a safety net for refactoring.

We will explore specific strategies and techniques that participants can apply in their work, in addition to considering the "big picture" of testing.

Location: XP Universe 2003 Conference, New Orleans, Louisiana
First half-day of workshop: Monday 11th August, 1.30 – 5.00pm
Submissions due: 10th July 2003

Organizers: J. B. Rainsberger, Ron Jeffries & Rick Mugridge The goal of the workshop is to advance the art of writing programmer tests through the sharing of experience, practical advice and techniques.

Enthusiasts and practitioners of test-oriented programming are invited to participate to explore issues related to programmers writing tests. Participants will share their experiences and learn through multiple group discussions on the topics that interest them most.

Here is a list of possible topics to help define the workshop’s mandate:

Code:
The role of Programmer Tests
What not to try to do in Programmer Tests
Programmer Testing Strategies
Selecting the next test in TDD
Tests as documentation
Mock objects
Programmer Testing Techniques
Domain or application-specific techniques
Introducing tests to legacy code
Programmer Testing Tools and Frameworks
XUnit extensions and relations
Ward Cunningham’s Fit
Fitnesse
The role of testers in XP

Programmer Tests for "non-functional” concerns: execution speed, response time, security, scalability, memory footprint, logging, etc.
Let’s write some tests!

Feel free to propose additional topics in your submissions and at the workshop.