org.apache.commons.collections: public class: BulkTest

org.apache.commons.collections
public class: BulkTest [javadoc | source]

java.lang.Object
   junit.framework.TestCase
      org.apache.commons.collections.BulkTest

All Implemented Interfaces:
Cloneable

A TestCase that can define both simple and bulk test methods.

A simple test method is the type of test traditionally supplied by by TestCase . To define a simple test, create a public no-argument method whose name starts with "test". You can specify the the name of simple test in the constructor of BulkTest; a subsequent call to TestCase#run will run that simple test.

A bulk test method, on the other hand, returns a new instance of BulkTest, which can itself define new simple and bulk test methods. By using the #makeSuite method, you can automatically create a hierarchal suite of tests and child bulk tests.

For instance, consider the following two classes:

public class TestSet extends BulkTest {

private Set set;

public TestSet(Set set) {
this.set = set;
}

public void testContains() {
boolean r = set.contains(set.iterator().next()));
assertTrue("Set should contain first element, r);
}

public void testClear() {
set.clear();
assertTrue("Set should be empty after clear", set.isEmpty());
}
}


public class TestHashMap extends BulkTest {

private Map makeFullMap() {
HashMap result = new HashMap();
result.put("1", "One");
result.put("2", "Two");
return result;
}

public void testClear() {
Map map = makeFullMap();
map.clear();
assertTrue("Map empty after clear", map.isEmpty());
}

public BulkTest bulkTestKeySet() {
return new TestSet(makeFullMap().keySet());
}

public BulkTest bulkTestEntrySet() {
return new TestSet(makeFullMap().entrySet());
}
}

In the above examples, TestSet defines two simple test methods and no bulk test methods; TestHashMap defines one simple test method and two bulk test methods. When makeSuite(TestHashMap.class).run is executed, five simple test methods will be run, in this order:

TestHashMap.testClear()
TestHashMap.bulkTestKeySet().testContains();
TestHashMap.bulkTestKeySet().testClear();
TestHashMap.bulkTestEntrySet().testContains();
TestHashMap.bulkTestEntrySet().testClear();

In the graphical junit test runners, the tests would be displayed in the following tree:

TestHashMap

testClear
bulkTestKeySet
- testContains
- testClear
bulkTestEntrySet
- testContains
- testClear

A subclass can override a superclass's bulk test by returning null from the bulk test method. If you only want to override specific simple tests within a bulk test, use the #ignoredSimpleTests method.

Note that if you want to use the bulk test methods, you must define your suite() method to use #makeSuite . The ordinary TestSuite constructor doesn't know how to interpret bulk test methods.

author: Paul - Jack

version: $ - Id: BulkTest.java,v 1.2.2.1 2004/05/22 12:14:05 scolebourne Exp $

Field Summary
String	verboseName	The full name of this bulk test instance. This is the full name that is compared to #ignoredSimpleTests to see if this test should be ignored. It's also displayed in the text runner to ease debugging.

Constructor:

Constructor:
public BulkTest(String name) { super(name); this.verboseName = getClass().getName(); } Constructs a new `BulkTest` instance that will run the specified simple test. Parameters: `name` - the name of the simple test method to run

 public BulkTest(String name) {
        super(name);
        this.verboseName = getClass().getName();
}

BulkTest

Parameters:

name - the name of the simple test method to run

Method from org.apache.commons.collections.BulkTest Summary:
clone, ignoredSimpleTests, makeSuite, toString

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.apache.commons.collections.BulkTest Detail:
public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { throw new Error(); // should never happen } } Creates a clone of this `BulkTest`.
public String[] ignoredSimpleTests() { return null; } Returns an array of simple test names to ignore. If a simple test that's defined by this `BulkTest` or by one of its bulk test methods has a name that's in the returned array, then that simple test will not be executed. A simple test's name is formed by taking the class name of the root `BulkTest`, eliminating the package name, then appending the names of any bulk test methods that were invoked to get to the simple test, and then appending the simple test method name. The method names are delimited by periods: TestHashMap.bulkTestEntrySet.testClear is the name of one of the simple tests defined in the sample classes described above. If the sample `TestHashMap` class included this method: public String[] ignoredSimpleTests() { return new String[] { "TestHashMap.bulkTestEntrySet.testClear" }; } then the entry set's clear method wouldn't be tested, but the key set's clear method would.
public static TestSuite makeSuite(Class c) { if (Modifier.isAbstract(c.getModifiers())) { throw new IllegalArgumentException("Class must not be abstract."); } if (!BulkTest.class.isAssignableFrom(c)) { throw new IllegalArgumentException("Class must extend BulkTest."); } return new BulkTestSuiteMaker(c).make(); } Returns a TestSuite for testing all of the simple tests and all the bulk tests defined by the given class. The class is examined for simple and bulk test methods; any child bulk tests are also examined recursively; and the results are stored in a hierarchal TestSuite . The given class must be a subclass of `BulkTest` and must not be abstract.
public String toString() { return getName() + "(" + verboseName + ") "; } Returns the display name of this `BulkTest`.

Method from org.apache.commons.collections.BulkTest Detail:

 public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new Error(); // should never happen
        }
}

BulkTest

 public String[] ignoredSimpleTests() {
        return null;
}

If a simple test that's defined by this BulkTest or by one of its bulk test methods has a name that's in the returned array, then that simple test will not be executed.

A simple test's name is formed by taking the class name of the root BulkTest, eliminating the package name, then appending the names of any bulk test methods that were invoked to get to the simple test, and then appending the simple test method name. The method names are delimited by periods:

TestHashMap.bulkTestEntrySet.testClear

TestHashMap

public String[] ignoredSimpleTests() {
return new String[] { "TestHashMap.bulkTestEntrySet.testClear" };
}

 public static TestSuite makeSuite(Class c) {
        if (Modifier.isAbstract(c.getModifiers())) {
            throw new IllegalArgumentException("Class must not be abstract.");
        }
        if (!BulkTest.class.isAssignableFrom(c)) {
            throw new IllegalArgumentException("Class must extend BulkTest.");
        }
        return new BulkTestSuiteMaker(c).make();
}

TestSuite

and

The class is examined for simple and bulk test methods; any child bulk tests are also examined recursively; and the results are stored in a hierarchal TestSuite .

The given class must be a subclass of BulkTest and must not be abstract.

 public String toString() {
        return getName() + "(" + verboseName + ") ";
}

BulkTest