junit.framework
Class TestCase
java.lang.Object
|
+--junit.framework.Assert
|
+--junit.framework.TestCase
All Implemented Interfaces:
TestKnown Direct Subclasses:
ExceptionTestCase
public abstract class
TestCaseextends
Assertimplements
Test A test case defines the fixture to run multiple tests. To define a test case
1) implement a subclass of TestCase
2) define instance variables that store the state of the fixture
3) initialize the fixture state by overriding
setUp
4) clean-up after a test by overriding
tearDown
.
Each test runs in its own fixture so there
can be no side effects among test runs.
Here is an example:
public class MathTest extends TestCase {
protected double fValue1;
protected double fValue2;
protected void setUp() {
fValue1= 2.0;
fValue2= 3.0;
}
}
For each test implement a method which interacts
with the fixture. Verify the expected results with assertions specified
by calling
assertTrue
with a boolean.
public void testAdd() {
double result= fValue1 + fValue2;
assertTrue(result == 5.0);
}
Once the methods are defined you can run them. The framework supports
both a static type safe and more dynamic way to run a test.
In the static way you override the runTest method and define the method to
be invoked. A convenient way to do so is with an anonymous inner class.
TestCase test= new MathTest("add") {
public void runTest() {
testAdd();
}
};
test.run();
The dynamic way uses reflection to implement
runTest
. It dynamically finds
and invokes a method.
In this case the name of the test case has to correspond to the test method
to be run.
TestCase= new MathTest("testAdd");
test.run();
The tests to be run can be collected into a TestSuite. JUnit provides
different
test runners which can run a test suite and collect the results.
A test runner either expects a static method
suite
as the entry
point to get a test to run or it will extract the suite automatically.
public static Test suite() {
suite.addTest(new MathTest("testAdd"));
suite.addTest(new MathTest("testDivideByZero"));
return suite;
}
TestResult
TestSuite
TestCase
public TestCase()
No-arg constructor to enable serialization. This method
is not intended to be used by mere mortals without calling setName().
TestCase
public TestCase(String name)
Constructs a test case with the given name.
- name
countTestCases
public int countTestCases()
Counts the number of test cases executed by run(TestResult result).
createResult
protected TestResult createResult()
Creates a default TestResult object
TestResult
getName
public String getName()
Gets the name of a TestCase
- returns a String
run
public TestResult run()
A convenience method to run this test, collecting the results with a
default TestResult object.
TestResult
run
public void run(TestResult result)
Runs the test case and collects the results in TestResult.
- result
runBare
public void runBare()
Runs the bare test sequence.
- if any exception is thrown
runTest
protected void runTest()
Override to run the test and assert its state.
- if any exception is thrown
setName
public void setName(String name)
Sets the name of a TestCase
- name - The name to set
setUp
protected void setUp()
Sets up the fixture, for example, open a network connection.
This method is called before a test is executed.
tearDown
protected void tearDown()
Tears down the fixture, for example, close a network connection.
This method is called after a test is executed.
toString
public String toString()
Returns a string representation of the test case
1) implement a subclass of TestCase
2) define instance variables that store the state of the fixture
3) initialize the fixture state by overriding
setUp
4) clean-up after a test by overriding
tearDown
.Each test runs in its own fixture so there can be no side effects among test runs. Here is an example: For each test implement a method which interacts with the fixture. Verify the expected results with assertions specified by calling
assertTrue
with a boolean. Once the methods are defined you can run them. The framework supports both a static type safe and more dynamic way to run a test. In the static way you override the runTest method and define the method to be invoked. A convenient way to do so is with an anonymous inner class. The dynamic way uses reflection to implementrunTest
. It dynamically finds and invokes a method. In this case the name of the test case has to correspond to the test method to be run. The tests to be run can be collected into a TestSuite. JUnit provides different test runners which can run a test suite and collect the results. A test runner either expects a static methodsuite
as the entry point to get a test to run or it will extract the suite automatically.