package junit.tests.framework;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestFailure;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import junit.tests.WasRun;
/**
* A test case testing the testing framework.
*
*/
public class TestCaseTest extends TestCase {
static class TornDown extends TestCase {
boolean fTornDown= false;
@Override
protected void tearDown() {
fTornDown= true;
}
@Override
protected void runTest() {
throw new Error("running");
}
}
public void testCaseToString() {
// This test wins the award for twisted snake tail eating while
// writing self tests. And you thought those weird anonymous
// inner classes were bad...
assertEquals("testCaseToString(junit.tests.framework.TestCaseTest)", toString());
}
public void testError() {
TestCase error= new TestCase("error") {
@Override
protected void runTest() {
throw new Error();
}
};
verifyError(error);
}
public void testRunAndTearDownFails() {
TornDown fails= new TornDown() {
@Override
protected void tearDown() {
super.tearDown();
throw new Error();
}
@Override
protected void runTest() {
throw new Error();
}
};
verifyError(fails);
assertTrue(fails.fTornDown);
}
public void testSetupFails() {
TestCase fails= new TestCase("success") {
@Override
protected void setUp() {
throw new Error();
}
@Override
protected void runTest() {
}
};
verifyError(fails);
}
public void testSuccess() {
TestCase success= new TestCase("success") {
@Override
protected void runTest() {
}
};
verifySuccess(success);
}
public void testFailure() {
TestCase failure= new TestCase("failure") {
@Override
protected void runTest() {
fail();
}
};
verifyFailure(failure);
}
public void testTearDownAfterError() {
TornDown fails= new TornDown();
verifyError(fails);
assertTrue(fails.fTornDown);
}
public void testTearDownFails() {
TestCase fails= new TestCase("success") {
@Override
protected void tearDown() {
throw new Error();
}
@Override
protected void runTest() {
}
};
verifyError(fails);
}
public void testTearDownSetupFails() {
TornDown fails= new TornDown() {
@Override
protected void setUp() {
throw new Error();
}
};
verifyError(fails);
assertTrue(!fails.fTornDown);
}
public void testWasRun() {
WasRun test= new WasRun();
test.run();
assertTrue(test.fWasRun);
}
public void testExceptionRunningAndTearDown() {
// With 1.4, we should
// wrap the exception thrown while running with the exception thrown
// while tearing down
Test t= new TornDown() {
@Override
public void tearDown() {
throw new Error("tearingDown");
}
};
TestResult result= new TestResult();
t.run(result);
TestFailure failure= result.errors().nextElement();
assertEquals("running", failure.thrownException().getMessage());
}
public void testErrorTearingDownDoesntMaskErrorRunning() {
final Exception running= new Exception("Running");
TestCase t= new TestCase() {
@Override
protected void runTest() throws Throwable {
throw running;
}
@Override
protected void tearDown() throws Exception {
throw new Error("Tearing down");
}
};
try {
t.runBare();
} catch (Throwable thrown) {
assertSame(running, thrown);
}
}
public void testNoArgTestCasePasses() {
Test t= new TestSuite(NoArgTestCaseTest.class);
TestResult result= new TestResult();
t.run(result);
assertTrue(result.runCount() == 1);
assertTrue(result.failureCount() == 0);
assertTrue(result.errorCount() == 0);
}
public void testNamelessTestCase() {
TestCase t= new TestCase() {};
TestResult result = t.run();
assertEquals(1, result.failureCount());
}
void verifyError(TestCase test) {
TestResult result= test.run();
assertTrue(result.runCount() == 1);
assertTrue(result.failureCount() == 0);
assertTrue(result.errorCount() == 1);
}
void verifyFailure(TestCase test) {
TestResult result= test.run();
assertTrue(result.runCount() == 1);
assertTrue(result.failureCount() == 1);
assertTrue(result.errorCount() == 0);
}
void verifySuccess(TestCase test) {
TestResult result= test.run();
assertTrue(result.runCount() == 1);
assertTrue(result.failureCount() == 0);
assertTrue(result.errorCount() == 0);
}
}