Java Test Code Generator

Introduction

Yes, you guessed it, yet another Java test code generator!

This goes a little further than just generating the JUnit framework template and method stubs though. It will also generate code to apply different values to the method under test. Objects can also be defined in a global property file so that you can easily provide valid and invalid creations of your own objects.

What on earth prompted me to write my own generator? Well, I used a test code generator some time ago to create some test code. No big suprises there ... then I had to fill in the content which I found boring and repetitive. What was going on that writing test code was boring? It was because I was bombarding all the public methods in an API with valid and invalid values to create tests that would show up a number of errors that had caused problems inside a system due to incorrect input and/or configuration. These were quite straight forward errors to pick up on and, due to the reflection api, quite easy to generate code for so that you only have to fill in the actual test data.

So, I ended up writing a simple, straight forward generator. Now, it's nothing special to look at ... it is a work in progress. Direct lines of thought, no layers for the sake of having layers ... basically I'm saying that I just coded it without trying to follow any pattern, but creating (hopefully) plain, understandable Java code.

Features

• Generation
• creates the standard JUnit framework code
• creates test code for multiple constructors - creating clear method names for each one
• creates test code for overloaded methods - creating clear method names for each one
• creates a list of parameters to be passed to the method and the code to run through that list
• can create code for non primitive types as parameters through use of a property file
• uses the smallest constructor when instantiating an object
• creates a fail call at the start of each test method to ensure that you at least look at it
• adds a comment to the source when an Exception should be thrown and checked for
• Regeneration
• updates existing test code with any new methods
• warns of test methods in the test code that are no longer in the production code
• Configuration
• property file containing non primitive objects for use within the generated code
• output location
• Execution
• command line parameters
• as an ANT task

ANT

Description
To use this as an ANT task, you will need to add a taskdef to your build file:

<taskdef name="jtcg" classname="net.sourceforge.jtcg.JUnitTCGTask"
	classpath="c:/my/location/jtcg.jar"/>

Parameters


Attribute	Description	Required
propertyFile	The property file to be used that contains the object definitions. Eg: c:/my/location/myprops.properties	Yes
classname	The qualified name of the class that you want to create test code for. Eg: com.foo.bar.MyClass	Yes
classpath	A path that contains the class given in classname	Yes
destination	Where to put the generated test code. The code will be generated to the same package structure as given for classname. Eg: classname="com.foo.bar.MyClass" destination="${project.root}/test" would lead to ${project.root}/test/com/foo/bar/MyClassTest.java	Yes

Example

<target name="Generate.Test.Code">
    <jtcg propertyFile="c:/my/location/myprops.properties" 
        classname="com.foo.bar.MyClass" classpath="${classes.dir}"
        destination="${test.source.dir}"/>
</target>

Property File

Property file
The properties file is a Java property file and is a list of how to instantiate each object. Eg:

Date = null; new Date(10, 10, 1999)
MyObj = null; new MyObj("Hello World"); new MyObj("XYZ")

Future development

Come on! This can be taken further:

• plugins for different IDEs
• different ways to accept data
• generation for different test frameworks
• use of templates
• creation and maintainence of suites
• maybe even (if it gets far enough) compiling and running the code that it generates