[Junit-devel] CVS: junit/junit4.0/junit/tests/framework TestCaseTest.class,NONE,1.1 Failure.java,NON

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/junit/junit/junit4.0/junit/tests/framework
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13390/junit4.0/junit/tests/framework

Added Files:
	TestCaseTest$7.class Failure.java SuiteTest.java 
	DoublePrecisionAssertTest.java ComparisonCompactorTest.java 
	NotPublicTestCase.java TestCaseTest$6.class 
	NoTestCaseClass.java TestImplementorTest.java NoTestCases.java 
	NotVoidTestCase.java NoArgTestCaseTest.java AllTests.java 
	TestListenerTest$1.class TestCaseTest$2.class 
	TestImplementorTest$DoubleTestCase$1.class Success.java 
	TestCaseTest$4.class TestCaseTest.java OverrideTestCase.java 
	ComparisonFailureTest.java TestCaseTest$1.class 
	TestCaseTest$9.class TestCaseTest$5.class 
	TestListenerTest.java TestListenerTest$3.class 
	FloatAssertTest.java TestListenerTest$2.class 
	TestCaseTest$8.class InheritedTestCase.java 
	TestImplementorTest$1.class OneTestCase.java AssertTest.java 
	TestCaseTest$10.class TestCaseTest$3.class 
Log Message:
Merged with branch, Kent will make final changes and launch.

--- NEW FILE: TestCaseTest$7.class ---
Êþº¾

SourceFile
*+µ
*·

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

import junit.framework.TestCase;

/**
 * A test case testing the testing framework.
 *
 */
public class Failure extends TestCase {
	@Override
	public void runTest() {
		fail();
	}
}
--- NEW FILE: SuiteTest.java ---
package junit.tests.framework;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;

/**
 * A fixture for testing the "auto" test suite feature.
 *
 */
public class SuiteTest extends TestCase {
	protected TestResult fResult;
	public SuiteTest(String name) {
		super(name);
	}
	@Override
	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("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("testCreateSuiteFromArray"));

		return suite;
	}
	public void testInheritedTests() {
		TestSuite suite= new TestSuite(InheritedTestCase.class);
		suite.run(fResult);
		assertTrue(fResult.wasSuccessful());
		assertEquals(2, fResult.runCount());
	}
// This test case is obsolete, since the compiler will catch this error in 1.5
//	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());
	}
	public void testCreateSuiteFromArray() {
		TestSuite suite = new TestSuite(OneTestCase.class, DoublePrecisionAssertTest.class);
		assertEquals(2, suite.testCount());
		assertEquals("junit.tests.framework.DoublePrecisionAssertTest" , ((TestSuite)suite.testAt(1)).getName());
		assertEquals("junit.tests.framework.OneTestCase" , ((TestSuite)suite.testAt(0)).getName());
	}
}
--- NEW FILE: DoublePrecisionAssertTest.java ---
package junit.tests.framework;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

public class DoublePrecisionAssertTest extends TestCase {

	/**
		 * Test for the special Double.NaN value.
		 */
	public void testAssertEqualsNaNFails() {
		try {
			assertEquals(1.234, Double.NaN, 0.0);
			fail();
		} catch (AssertionFailedError e) {
		}
	}

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

	public void testAssertNaNEqualsNaN() {
		assertEquals(Double.NaN, Double.NaN, 0.0);
	}

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

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

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

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

}

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

import junit.framework.ComparisonCompactor;
import junit.framework.TestCase;

public class ComparisonCompactorTest extends TestCase {

	public void testMessage() {
		String failure= new ComparisonCompactor(0, "b", "c").compact("a");
		assertTrue("a expected:<[b]> but was:<[c]>".equals(failure));
	}

	public void testStartSame() {
		String failure= new ComparisonCompactor(1, "ba", "bc").compact(null);
		assertEquals("expected:<b[a]> but was:<b[c]>", failure);
	}

	public void testEndSame() {
		String  failure= new ComparisonCompactor(1, "ab", "cb").compact(null);
		assertEquals("expected:<[a]b> but was:<[c]b>", failure);
	}

	public void testSame() {
		String failure= new ComparisonCompactor(1, "ab", "ab").compact(null);
		assertEquals("expected:<ab> but was:<ab>", failure);
	}

	public void testNoContextStartAndEndSame() {
		String failure= new ComparisonCompactor(0, "abc", "adc").compact(null);
		assertEquals("expected:<...[b]...> but was:<...[d]...>", failure);
	}

	public void testStartAndEndContext() {
		String failure= new ComparisonCompactor(1, "abc", "adc").compact(null);
		assertEquals("expected:<a[b]c> but was:<a[d]c>", failure);
	}

	public void testStartAndEndContextWithEllipses() {
		String failure= new ComparisonCompactor(1, "abcde", "abfde").compact(null);
		assertEquals("expected:<...b[c]d...> but was:<...b[f]d...>", failure);
	}

	public void testComparisonErrorStartSameComplete() {
		String failure= new ComparisonCompactor(2, "ab", "abc").compact(null);
		assertEquals("expected:<ab[]> but was:<ab[c]>", failure);
	}

	public void testComparisonErrorEndSameComplete() {
		String failure= new ComparisonCompactor(0, "bc", "abc").compact(null);
		assertEquals("expected:<[]...> but was:<[a]...>", failure);
	}

	public void testComparisonErrorEndSameCompleteContext() {
		String failure= new ComparisonCompactor(2, "bc", "abc").compact(null);
		assertEquals("expected:<[]bc> but was:<[a]bc>", failure);
	}

	public void testComparisonErrorOverlapingMatches() {
		String failure= new ComparisonCompactor(0, "abc", "abbc").compact(null);
		assertEquals("expected:<...[]...> but was:<...[b]...>", failure);
	}

	public void testComparisonErrorOverlapingMatchesContext() {
		String failure= new ComparisonCompactor(2, "abc", "abbc").compact(null);
		assertEquals("expected:<ab[]c> but was:<ab[b]c>", failure);
	}

	public void testComparisonErrorOverlapingMatches2() {
		String failure= new ComparisonCompactor(0, "abcdde", "abcde").compact(null);
		assertEquals("expected:<...[d]...> but was:<...[]...>", failure);
	}

	public void testComparisonErrorOverlapingMatches2Context() {
		String failure= new ComparisonCompactor(2, "abcdde", "abcde").compact(null);
		assertEquals("expected:<...cd[d]e> but was:<...cd[]e>", failure);
	}

	public void testComparisonErrorWithActualNull() {
		String failure= new ComparisonCompactor(0, "a", null).compact(null);
		assertEquals("expected:<a> but was:<null>", failure);
	}

	public void testComparisonErrorWithActualNullContext() {
		String failure= new ComparisonCompactor(2, "a", null).compact(null);
		assertEquals("expected:<a> but was:<null>", failure);
	}

	public void testComparisonErrorWithExpectedNull() {
		String failure= new ComparisonCompactor(0, null, "a").compact(null);
		assertEquals("expected:<null> but was:<a>", failure);
	}

	public void testComparisonErrorWithExpectedNullContext() {
		String failure= new ComparisonCompactor(2, null, "a").compact(null);
		assertEquals("expected:<null> but was:<a>", failure);
	}

	public void testBug609972() {
		String failure= new ComparisonCompactor(10, "S&P500", "0").compact(null);
		assertEquals("expected:<[S&P50]0> but was:<[]0>", failure);
	}
}

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

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

public class NotPublicTestCase extends TestCase {
	protected void testNotPublic() {
	}
	public void testPublic() {
	}
}
--- NEW FILE: TestCaseTest$6.class ---
Êþº¾

SourceFile
*,·

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

/**
 * Test class used in SuiteTest
 */

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

import junit.framework.Protectable;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;

/**
 * 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);
		}
	}

	private DoubleTestCase fTest;

	public TestImplementorTest() {
		TestCase testCase= new TestCase() {
			@Override
			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: NoTestCases.java ---
package junit.tests.framework;

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

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

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

public class NotVoidTestCase extends TestCase {
	public int testNotVoid() {
		return 1;
	}
	public void testVoid() {
	}
}
--- NEW FILE: NoArgTestCaseTest.java ---

package junit.tests.framework;

import junit.framework.TestCase;

public class NoArgTestCaseTest extends TestCase {
	public void testNothing() { // If this compiles, the no arg ctor is there
	}
}

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

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * 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);
		suite.addTestSuite(NoArgTestCaseTest.class);
		suite.addTestSuite(ComparisonCompactorTest.class);
		suite.addTestSuite(ComparisonFailureTest.class);
		suite.addTestSuite(DoublePrecisionAssertTest.class);
		suite.addTestSuite(FloatAssertTest.class);
		return suite;
	}

}
--- NEW FILE: TestListenerTest$1.class ---
Êþº¾

SourceFile
*,·

--- NEW FILE: TestCaseTest$2.class ---
Êþº¾

SourceFile
*+µ
*·

--- NEW FILE: TestImplementorTest$DoubleTestCase$1.class ---
Êþº¾

Exceptions

SourceFile

*+µ

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

import junit.framework.TestCase;

/**
 * A test case testing the testing framework.
 *
 */
public class Success extends TestCase {

	@Override
	public void runTest() {
	}

	public void testSuccess() {
	}
}
--- NEW FILE: TestCaseTest$4.class ---
Êþº¾

SourceFile
*,·

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

import junit.framework.AssertionFailedError;
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() {};
		try {
			t.run();
			fail();
		} catch (AssertionFailedError e) {
		}
	}

	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: OverrideTestCase.java ---
package junit.tests.framework;

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

import junit.framework.ComparisonFailure;
import junit.framework.TestCase;

public class ComparisonFailureTest extends TestCase {

	// Most of the tests are in ComparisonCompactorTest
	public void testConnection() {
		ComparisonFailure failure= new ComparisonFailure("warning", "Mary had a little lamb", "Mary had the little lamb");
		assertEquals("warning expected:<Mary had [a] little lamb> but was:<Mary had [the] little lamb>", failure.getMessage());
	}

	// This is like an instanceof test.
	public void testThrowing() {
		try {
			assertEquals("a", "b");
		} catch (ComparisonFailure e) {
			return;
		}
		fail();
	}
}

--- NEW FILE: TestCaseTest$1.class ---
Êþº¾

SourceFile
*,·

--- NEW FILE: TestCaseTest$9.class ---
Êþº¾

Exceptions

SourceFile

»

--- NEW FILE: TestCaseTest$5.class ---
Êþº¾

SourceFile
*,·

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

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

public class TestListenerTest extends TestCase implements TestListener {
	private TestResult fResult;
	private int fStartCount;
	private int fEndCount;
	private int fFailureCount;
	private int fErrorCount;

	public void addError(Test test, Throwable t) {
		fErrorCount++;
	}
	public void addFailure(Test test, AssertionFailedError t) {
		fFailureCount++;
	}
	public void endTest(Test test) {
		fEndCount++;
	}
	@Override
	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") {
			@Override
			public void runTest() {
				throw new Error();
			}
		};
		test.run(fResult);
		assertEquals(1, fErrorCount);
		assertEquals(1, fEndCount);
	}
	public void testFailure() {
		TestCase test= new TestCase("noop") {
			@Override
			public void runTest() {
				fail();
			}
		};
		test.run(fResult);
		assertEquals(1, fFailureCount);
		assertEquals(1, fEndCount);
	}
	public void testStartStop() {
		TestCase test= new TestCase("noop") {
			@Override
			public void runTest() {
			}
		};
		test.run(fResult);
		assertEquals(1, fStartCount);
		assertEquals(1, fEndCount);
	}
}
--- NEW FILE: TestListenerTest$3.class ---
Êþº¾

SourceFile
*,·

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

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

public class FloatAssertTest extends TestCase {

	/**
		 * Test for the special Double.NaN value.
		 */
	public void testAssertEqualsNaNFails() {
		try {
			assertEquals(1.234f, Float.NaN, 0.0);
			fail();
		} catch (AssertionFailedError e) {
		}
	}

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

	public void testAssertNaNEqualsNaN() {
		assertEquals(Float.NaN, Float.NaN, 0.0);
	}

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

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

	public void testAssertPosInfinityEqualsInfinity() {
		assertEquals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 0.0);
	}

	public void testAssertNegInfinityEqualsInfinity() {
		assertEquals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 0.0);
	}

	public void testAllInfinities() {
		try {
			assertEquals(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY);
			fail();
		} catch (AssertionFailedError e) {
		}
	}

}

--- NEW FILE: TestListenerTest$2.class ---
Êþº¾

SourceFile
*,·

--- NEW FILE: TestCaseTest$8.class ---
Êþº¾

SourceFile
*+µ
*·

»

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

/**
 * Test class used in SuiteTest
 */
public class InheritedTestCase extends OneTestCase { 
	public void test2() {
	}
}
--- NEW FILE: TestImplementorTest$1.class ---
Êþº¾

SourceFile
*+µ
*·

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

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

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

import junit.framework.AssertionFailedError;
import junit.framework.ComparisonFailure;
import junit.framework.TestCase;

public class AssertTest extends TestCase {

	/* In the tests that follow, we can't use standard formatting
	 * for exception tests:
	 *     try {
	 *         somethingThatShouldThrow();
	 *         fail();
	 *     catch (AssertionFailedError e) {
	 *     }
	 * because fail() would never be reported.
	 */
	public void testFail() {
		// Also, we are testing fail, so we can't rely on fail() working.
		// We have to throw the exception manually, .
		try {
			fail();
		} catch (AssertionFailedError e) {
			return;
		}
		throw new AssertionFailedError();
	}

	public void testAssertEquals() {
		Object o= new Object();
		assertEquals(o, o);
		try {
			assertEquals(new Object(), new Object());
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertEqualsNull() {
		assertEquals((Object) null, (Object) null);
	}

	public void testAssertStringEquals() {
		assertEquals("a", "a");
	}

	public void testAssertNullNotEqualsString() {
		try {
			assertEquals(null, "foo");
			fail();
		} catch (ComparisonFailure e) {
		}
	}

	public void testAssertStringNotEqualsNull() {
		try {
			assertEquals("foo", null);
			fail();
		} catch (ComparisonFailure e) {
			e.getMessage(); // why no assertion?
		}
	}

	public void testAssertNullNotEqualsNull() {
		try {
			assertEquals(null, new Object());
		} catch (AssertionFailedError e) {
			e.getMessage(); // why no assertion?
			return;
		}
		fail();
	}

	public void testAssertNull() {
		assertNull(null);
		try {
			assertNull(new Object());
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertNotNull() {
		assertNotNull(new Object());
		try {
			assertNotNull(null);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertTrue() {
		assertTrue(true);
		try {
			assertTrue(false);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertFalse() {
		assertFalse(false);
		try {
			assertFalse(true);
		} catch (AssertionFailedError e) {
			return;
		}
		fail();
	}

	public void testAssertSame() {
		Object o= new Object();
		assertSame(o, o);
		try {
			assertSame(new Integer(1), new Integer(1));
		} 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));
		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: TestCaseTest$10.class ---
Êþº¾

SourceFile
*+µ
*·

--- NEW FILE: TestCaseTest$3.class ---
Êþº¾

SourceFile
*,·