[Junit-devel] CVS: junit/junit/tests/framework AllTests.java,NONE,1.1 AssertTest.java,NONE,1.1 Failure.java,NONE,1.1 InheritedTestCase.java,NONE,1.1 NoTestCaseClass.java,NONE,1.1 NoTestCases.java,NONE,1.1 NotPublicTestCase.java,NONE,1.1 NotVoidTestCase.java,NONE,1.1 OneTestCase.java,NONE,1.1 OverrideTestCase.java,NONE,1.1 Success.java,NONE,1.1 SuiteTest.java,NONE,1.1 TestCaseTest.java,NONE,1.1 TestImplementorTest.java,NONE,1.1 TestListenerTest.java,NONE,1.1

[Kent B. <kb...@us...>]

Update of /cvsroot/junit/junit/junit/tests/framework
In directory usw-pr-cvs1:/tmp/cvs-serv14225/junit/tests/framework

Added Files:
	AllTests.java AssertTest.java Failure.java 
	InheritedTestCase.java NoTestCaseClass.java NoTestCases.java 
	NotPublicTestCase.java NotVoidTestCase.java OneTestCase.java 
	OverrideTestCase.java Success.java SuiteTest.java 
	TestCaseTest.java TestImplementorTest.java 
	TestListenerTest.java 
Log Message:
Still trying to release the new test packages

--- NEW FILE: AllTests.java ---
package junit.tests.framework;

import junit.framework.*;
import junit.runner.BaseTestRunner;

/**
 * TestSuite that runs all the sample tests
 *
 */
public class AllTests {

	public static void main(String[] args) {
		junit.textui.TestRunner.run(suite());
	}
	
	public static Test suite() {
		TestSuite suite= new TestSuite("Framework Tests");
		suite.addTestSuite(TestCaseTest.class);
		suite.addTest(SuiteTest.suite()); // Tests suite building, so can't use automatic test extraction 
		suite.addTestSuite(TestListenerTest.class);
		suite.addTestSuite(AssertTest.class);
		suite.addTestSuite(TestImplementorTest.class);
		return suite;
	}
	
	static boolean isJDK11() {
		String version= System.getProperty("java.version");
		return version.startsWith("1.1");
	}
}
--- NEW FILE: AssertTest.java ---
package junit.tests.framework;

import junit.framework.*;

public class AssertTest extends TestCase {
	public AssertTest(String name) {
		super(name);
	}
	
	/**
  	 * Test for the special Double.NaN value.
  	 */
 	public void testAssertEqualsNaNFails() {
		try {
			assertEquals(1.234, Double.NaN, 0.0);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertNaNEqualsFails() {
		try {
			assertEquals(Double.NaN, 1.234, 0.0);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertNaNEqualsNaNFails() {
		try {
			assertEquals(Double.NaN, Double.NaN, 0.0);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertPosInfinityNotEqualsNegInfinity() {
		try {
			assertEquals(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertPosInfinityNotEquals() {
		try {
			assertEquals(Double.POSITIVE_INFINITY, 1.23, 0.0);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertPosInfinityEqualsInfinity() {
		assertEquals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 0.0);
	}
	
	public void testAssertNegInfinityEqualsInfinity() {
		assertEquals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0);
	}

	public void testAssertEquals() {
		Object o= new Object();
		assertEquals(o, o);
	}
	
	public void testAssertEqualsNull() {
		assertEquals(null, null);
	}
	
	public void testAssertNull() {
		assertNull(null);
	}
	
	public void testAssertNullNotEqualsNull() {
 		try {
			assertEquals(null, new Object());
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}
	
	public void testAssertSame() {
		Object o= new Object();
		assertSame(o, o);
	}
	
	public void testAssertSameFails() {
		try {
			assertSame(new Integer(1), new Integer(1));
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testFail() {
		try {
			fail();
		} catch (AssertionFailedError e) {
			return;
		}
		throw new AssertionFailedError(); // You can't call fail() here
	}
	
	public void testFailAssertNotNull() {
		try {
			assertNotNull(null);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}
	
	public void testSucceedAssertNotNull() {
		assertNotNull(new Object());
	}
	
	public void testAssertFalse() {
		assertFalse(false);
		try {
			assertFalse(true);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}
 
	public void testAssertNotSame() {
		assertNotSame(new Integer(1), null);
		assertNotSame(null, new Integer(1));
		assertNotSame(new Integer(1), new Integer(1));
	}

	public void testAssertNotSameFails() {
		try {
			Integer obj = new Integer(1);
			assertNotSame(obj, obj);
		} catch (AssertionFailedError e) {
 			return;
		}
		fail();
	}

	public void testAssertNotSameFailsNull() {
		try {
			assertNotSame(null, null);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}
}
--- NEW FILE: Failure.java ---
package junit.tests.framework;

import java.util.Vector;
import junit.framework.*;

/**
 * A test case testing the testing framework.
 *
 */
public class Failure extends TestCase {
	
	public Failure(String name) {
		super(name);
	}
	public void test() {
		fail();
	}
}
--- NEW FILE: InheritedTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
public class InheritedTestCase extends OneTestCase {
	public InheritedTestCase(String name) {
		super(name);
	}
	public void test2() {
	}
}
--- NEW FILE: NoTestCaseClass.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.TestCase;

public class NoTestCaseClass extends Object {
	public NoTestCaseClass(String name) {
	}
	public void testSuccess() {
	}
}
--- NEW FILE: NoTestCases.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.TestCase;

public class NoTestCases extends TestCase {
	public NoTestCases(String name) {
		super(name);
	}
	public void noTestCase() {
	}
}
--- NEW FILE: NotPublicTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.TestCase;

public class NotPublicTestCase extends TestCase {
	public NotPublicTestCase(String name) {
		super(name);
	}
	protected void testNotPublic() {
	}
	public void testPublic() {
	}
}
--- NEW FILE: NotVoidTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.TestCase;

public class NotVoidTestCase extends TestCase {
	public NotVoidTestCase(String name) {
		super(name);
	}
	public int testNotVoid() {
		return 1;
	}
	public void testVoid() {
	}
}
--- NEW FILE: OneTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.TestCase;

public class OneTestCase extends TestCase {
	public OneTestCase(String name) {
		super(name);
	}
	public void noTestCase() {
	}
	public void testCase() {
	}
	public void testCase(int arg) {
	}
}
--- NEW FILE: OverrideTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
public class OverrideTestCase extends OneTestCase {
	public OverrideTestCase(String name) {
		super(name);
	}
	public void testCase() {
	}
}
--- NEW FILE: Success.java ---
package junit.tests.framework;

import java.util.Vector;
import junit.framework.*;

/**
 * A test case testing the testing framework.
 *
 */
public class Success extends TestCase {
	
	public Success(String name) {
		super(name);
	}
	public void test() {
	}
}
--- NEW FILE: SuiteTest.java ---
package junit.tests.framework;

import java.util.Vector;
import junit.framework.*;

/**
 * A fixture for testing the "auto" test suite feature.
 *
 */
public class SuiteTest extends TestCase {
	protected TestResult fResult;
	public SuiteTest(String name) {
		super(name);
	}
	protected void setUp() {
		fResult= new TestResult();
	}
	public static Test suite() {
		TestSuite suite= new TestSuite("Suite Tests");
		// build the suite manually, because some of the suites are testing
		// the functionality that automatically builds suites
		suite.addTest(new SuiteTest("testNoTestCaseClass"));
		suite.addTest(new SuiteTest("testNoTestCases"));
		suite.addTest(new SuiteTest("testOneTestCase"));
		suite.addTest(new SuiteTest("testNotPublicTestCase"));
		suite.addTest(new SuiteTest("testNotVoidTestCase"));
		suite.addTest(new SuiteTest("testNotExistingTestCase"));
		suite.addTest(new SuiteTest("testInheritedTests"));
		suite.addTest(new SuiteTest("testShadowedTests"));
		suite.addTest(new SuiteTest("testAddTestSuite"));
		suite.addTest(new SuiteTest("testDisplayName"));
		
		return suite;
	}
	public void testInheritedTests() {
		TestSuite suite= new TestSuite(InheritedTestCase.class);
		suite.run(fResult);
		assertTrue(fResult.wasSuccessful());
		assertEquals(2, fResult.runCount());
	}
	public void testNoTestCaseClass() {
		Test t= new TestSuite(NoTestCaseClass.class);
		t.run(fResult);
		assertEquals(1, fResult.runCount());  // warning test
		assertTrue(! fResult.wasSuccessful());
	}
	public void testNoTestCases() {
		Test t= new TestSuite(NoTestCases.class);
		t.run(fResult);
		assertTrue(fResult.runCount() == 1);  // warning test
		assertTrue(fResult.failureCount() == 1);
		assertTrue(! fResult.wasSuccessful());
	}
	public void testNotExistingTestCase() {
		Test t= new SuiteTest("notExistingMethod");
		t.run(fResult);
		assertTrue(fResult.runCount() == 1);  
		assertTrue(fResult.failureCount() == 1);
		assertTrue(fResult.errorCount() == 0);
	}
	public void testNotPublicTestCase() {
		TestSuite suite= new TestSuite(NotPublicTestCase.class);
		// 1 public test case + 1 warning for the non-public test case
		assertEquals(2, suite.countTestCases());
	}
	public void testNotVoidTestCase() {
		TestSuite suite= new TestSuite(NotVoidTestCase.class);
		assertTrue(suite.countTestCases() == 1);
	}
	public void testOneTestCase() {
		Test t= new TestSuite(OneTestCase.class);
		t.run(fResult);
		assertTrue(fResult.runCount() == 1);  
		assertTrue(fResult.failureCount() == 0);
		assertTrue(fResult.errorCount() == 0);
		assertTrue(fResult.wasSuccessful());
	}
	public void testShadowedTests() {
		TestSuite suite= new TestSuite(OverrideTestCase.class);
		suite.run(fResult);
		assertEquals(1, fResult.runCount());
	}
	public void testAddTestSuite() {
		TestSuite suite= new TestSuite();
		suite.addTestSuite(OneTestCase.class);
		suite.run(fResult);
		assertEquals(1, fResult.runCount());
	}
}
--- NEW FILE: TestCaseTest.java ---
package junit.tests.framework;

import java.util.Vector;
import junit.framework.*;
import junit.tests.WasRun;

/**
 * A test case testing the testing framework.
 *
 */
public class TestCaseTest extends TestCase {
	
	static class TornDown extends TestCase {
		boolean fTornDown= false;
		
		TornDown(String name) {
			super(name);
		}
		protected void tearDown() {
			fTornDown= true;
		}
		protected void runTest() {
			throw new Error();
		}
	}

	public TestCaseTest(String name) {
		super(name);
	}
	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") {
			protected void runTest() {
				throw new Error();
			}
		};
		verifyError(error);
	}
	public void testRunAndTearDownFails() {
		TornDown fails= new TornDown("fails") {
			protected void tearDown() {
				super.tearDown();
				throw new Error();
			}
			protected void runTest() {
				throw new Error();
			}
		};
		verifyError(fails);
		assertTrue(fails.fTornDown);
	}
	public void testSetupFails() {
		TestCase fails= new TestCase("success") {
			protected void setUp() {
				throw new Error();
			}
			protected void runTest() {
			}
		};
		verifyError(fails);
	}
	public void testSuccess() {
		TestCase success= new TestCase("success") {
			protected void runTest() {
			}
		};
		verifySuccess(success);
	}
	public void testFailure() {
		TestCase failure= new TestCase("failure") {
			protected void runTest() {
				fail();
			}
		};
		verifyFailure(failure);
	}

	public void testTearDownAfterError() {
		TornDown fails= new TornDown("fails");
		verifyError(fails);
		assertTrue(fails.fTornDown);
	}
	
	public void testTearDownFails() {
		TestCase fails= new TestCase("success") {
			protected void tearDown() {
				throw new Error();
			}
			protected void runTest() {
			}
		};
		verifyError(fails);
	}
	public void testTearDownSetupFails() {
		TornDown fails= new TornDown("fails") {
			protected void setUp() {
				throw new Error();
			}
		};
		verifyError(fails);
		assertTrue(!fails.fTornDown);
	}
	public void testWasRun() {
		WasRun test= new WasRun("");
		test.run();
		assertTrue(test.fWasRun);
	}
	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);
	}


}
--- NEW FILE: TestImplementorTest.java ---
package junit.tests.framework;

import junit.framework.*;

/**
 * Test an implementor of junit.framework.Test other than TestCase or TestSuite
 */
public class TestImplementorTest extends TestCase {
	public static class DoubleTestCase implements Test {
		private TestCase fTestCase;
		
		public DoubleTestCase(TestCase testCase) {
			fTestCase= testCase;
		}
		
		public int countTestCases() {
			return 2;
		}
		
		public void run(TestResult result) {
			result.startTest(this);
			Protectable p= new Protectable() {
				public void protect() throws Throwable {
					fTestCase.runBare();
					fTestCase.runBare();
				}
			};
			result.runProtected(this, p);
			result.endTest(this);
		}
		
		public String getDisplayName() {
			return "";
		}
	}
	
	private DoubleTestCase fTest;
	
	public TestImplementorTest(String name) {
		super(name);
		TestCase testCase= new TestCase("noop") {
			public void runTest() {
			}
		};
		fTest= new DoubleTestCase(testCase);
	}
	
	public void testSuccessfulRun() {
		TestResult result= new TestResult();
		fTest.run(result);
		assertEquals(fTest.countTestCases(), result.runCount());
		assertEquals(0, result.errorCount());
		assertEquals(0, result.failureCount());
	}
}

--- NEW FILE: TestListenerTest.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
import junit.framework.*;

public class TestListenerTest extends TestCase implements TestListener {
	private TestResult fResult;
	private int fStartCount;
	private int fEndCount;
	private int fFailureCount;
	private int fErrorCount;
	public TestListenerTest(String name) {
		super(name);
	}
	public void addError(Test test, Throwable t) {
		fErrorCount++;
	}
	public void addFailure(Test test, AssertionFailedError t) {
		fFailureCount++;
	}
	public void endTest(Test test) {
		fEndCount++;
	}
	protected void setUp() {
		fResult= new TestResult();
		fResult.addListener(this);
	
		fStartCount= 0;
		fEndCount= 0;
		fFailureCount= 0;
	}
	public void startTest(Test test) {
		fStartCount++;
	}
	public void testError() {
		TestCase test= new TestCase("noop") {
			public void runTest() {
				throw new Error();
			}
		};
		test.run(fResult);
		assertEquals(1, fErrorCount);
		assertEquals(1, fEndCount);
	}
	public void testFailure() {
		TestCase test= new TestCase("noop") {
			public void runTest() {
				fail();
			}
		};
		test.run(fResult);
		assertEquals(1, fFailureCount);
		assertEquals(1, fEndCount);
	}
	public void testStartStop() {
		TestCase test= new TestCase("noop") {
			public void runTest() {
			}
		};
		test.run(fResult);
		assertEquals(1, fStartCount);
		assertEquals(1, fEndCount);
	}
}