junit-devel — junit developers

[Junit-devel] CVS: junit/src/junit/extensions RepeatedTest.java, NONE, 1.1 ActiveTestSuite.java, NONE, 1.1 TestSetup.java, NONE, 1.1 package-info.java, NONE, 1.1 TestDecorator.java, NONE, 1.1

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/extensions
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/src/junit/extensions

Added Files:
	RepeatedTest.java ActiveTestSuite.java TestSetup.java 
	package-info.java TestDecorator.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- NEW FILE: RepeatedTest.java ---
package junit.extensions;

import junit.framework.Test;
import junit.framework.TestResult;

/**
 * A Decorator that runs a test repeatedly.
 * 
 */
public class RepeatedTest extends TestDecorator {
	private int fTimesRepeat;

	public RepeatedTest(Test test, int repeat) {
		super(test);
		if (repeat < 0)
			throw new IllegalArgumentException("Repetition count must be > 0");
		fTimesRepeat= repeat;
	}

	@Override
	public int countTestCases() {
		return super.countTestCases() * fTimesRepeat;
	}

	@Override
	public void run(TestResult result) {
		for (int i= 0; i < fTimesRepeat; i++) {
			if (result.shouldStop())
				break;
			super.run(result);
		}
	}

	@Override
	public String toString() {
		return super.toString() + "(repeated)";
	}
}
--- NEW FILE: ActiveTestSuite.java ---
package junit.extensions;

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

/**
 * A TestSuite for active Tests. It runs each
 * test in a separate thread and waits until all
 * threads have terminated.
 * -- Aarhus Radisson Scandinavian Center 11th floor
 */ 
public class ActiveTestSuite extends TestSuite {
	private volatile int fActiveTestDeathCount;

	public ActiveTestSuite() {
	}
		
	public ActiveTestSuite(Class<? extends TestCase> theClass) {
		super(theClass);
	}
	
	public ActiveTestSuite(String name) {
		super (name);
	}
	
	public ActiveTestSuite(Class<? extends TestCase> theClass, String name) {
		super(theClass, name);
	}
	
	@Override
	public void run(TestResult result) {
		fActiveTestDeathCount= 0;
		super.run(result);
		waitUntilFinished();
	}
	
	@Override
	public void runTest(final Test test, final TestResult result) {
		Thread t= new Thread() {
			@Override
			public void run() {
				try {
					// inlined due to limitation in VA/Java 
					//ActiveTestSuite.super.runTest(test, result);
					test.run(result);
				} finally {
					ActiveTestSuite.this.runFinished();
				}
			}
		};
		t.start();
	}

	synchronized void waitUntilFinished() {
		while (fActiveTestDeathCount < testCount()) {
			try {
				wait();
			} catch (InterruptedException e) {
				return; // ignore
			}
		}
	}
	
	synchronized public void runFinished() {
		fActiveTestDeathCount++;
		notifyAll();
	}
}
--- NEW FILE: TestSetup.java ---
package junit.extensions;

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

/**
 * A Decorator to set up and tear down additional fixture state. Subclass
 * TestSetup and insert it into your tests when you want to set up additional
 * state once before the tests are run.
 */
public class TestSetup extends TestDecorator {

	public TestSetup(Test test) {
		super(test);
	}

	@Override
	public void run(final TestResult result) {
		Protectable p= new Protectable() {
			public void protect() throws Exception {
				setUp();
				basicRun(result);
				tearDown();
			}
		};
		result.runProtected(this, p);
	}

	/**
	 * Sets up the fixture. Override to set up additional fixture state.
	 */
	protected void setUp() throws Exception {
	}

	/**
	 * Tears down the fixture. Override to tear down the additional fixture
	 * state.
	 */
	protected void tearDown() throws Exception {
	}
}
--- NEW FILE: package-info.java ---
/**
 * Provides extended functionality for JUnit v3.x.
 */
package junit.extensions;
--- NEW FILE: TestDecorator.java ---
package junit.extensions;

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestResult;

/**
 * A Decorator for Tests. Use TestDecorator as the base class for defining new
 * test decorators. Test decorator subclasses can be introduced to add behaviour
 * before or after a test is run.
 * 
 */
public class TestDecorator extends Assert implements Test {
	protected Test fTest;

	public TestDecorator(Test test) {
		fTest= test;
	}

	/**
	 * The basic run behaviour.
	 */
	public void basicRun(TestResult result) {
		fTest.run(result);
	}

	public int countTestCases() {
		return fTest.countTestCases();
	}

	public void run(TestResult result) {
		basicRun(result);
	}

	@Override
	public String toString() {
		return fTest.toString();
	}

	public Test getTest() {
		return fTest;
	}
}

[Junit-devel] CVS: junit/src/org/junit Ignore.java, NONE, 1.1 package-info.java, NONE, 1.1 Test.java, NONE, 1.1 After.java, NONE, 1.1 BeforeClass.java, NONE, 1.1 Before.java, NONE, 1.1 ComparisonFailure.java, NONE, 1.1 AfterClass.java, NONE, 1.1 Assert.java, NONE, 1.1

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/src/org/junit

Added Files:
	Ignore.java package-info.java Test.java After.java 
	BeforeClass.java Before.java ComparisonFailure.java 
	AfterClass.java Assert.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- NEW FILE: Ignore.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>Sometimes you want to temporarily disable a test. Methods annotated with {@link org.junit.Test}
 * that are also annotated with <code>&#064;Ignore</code> will not be executed as tests. Native JUnit 4 test runners
 * should report the number of ignored tests along with the number of tests that ran and the
 * number of tests that failed.</p>
 * 
 * For example:
 * <pre>
 *    &#064;Ignore &#064;Test public void something() { ...
 * </pre>
 * &#064;Ignore takes an optional default parameter if you want to record why a test is being ignored:<br/>
 * <pre>
 *    &#064;Ignore("not ready yet") &#064;Test public void something() { ...
 * </pre>
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Ignore {
	/**
	 * The optional reason why the test is ignored.
	 */
	String value() default ""; 
}

--- NEW FILE: package-info.java ---
/**
 * Provides JUnit core classes and annotations. 
 * 
 * Corresponds to junit.framework in Junit 3.x.
 *
 * @since 4.0
 */
package org.junit;
--- NEW FILE: Test.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>The <code>Test</code> annotation tells JUnit that the <code>public void</code> method
 * to which it is attached can be run as a test case. To run the method,
 * JUnit first constructs a fresh instance of the class then invokes the
 * annotated method. Any exceptions thrown by the test will be reported
 * by JUnit as a failure. If no exceptions are thrown, the test is assumed
 * to have succeeded.</p>
 * 
 * <p>A simple test looks like this:
 * <pre>
 * public class Example {
 *    <b>&#064;Test</b> 
 *    public void method() {
 *       org.junit.Assert.assertTrue( new ArrayList().isEmpty() );
 *    }
 * }
 * </pre>
 * </p>
 * 
 * <p>The <code>Test</code> annotation supports two optional parameters.
 * The first, <code>expected</code>, declares that a test method should throw
 * an exception. If it doesn't throw an exception or if it throws a different exception
 * than the one declared, the test fails. For example, the following test succeeds:
 * <pre>
 *    &#064;Test(<b>expected=IndexOutOfBoundsException.class</b>) public void outOfBounds() {
 *       new ArrayList&lt;Object&gt;().get(1);
 *    }
 * </pre></p>
 * 
 * <p>The second optional parameter, <code>timeout</code>, causes a test to fail if it takes 
 * longer than a specified amount of clock time (measured in milliseconds). The following test fails:
 * <pre>
 *    &#064;Test(<b>timeout=100</b>) public void infinity() {
 *       while(true);
 *    }
 * </pre></p>
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
	
	/**
	 * Default empty exception
	 */
	static class None extends Throwable {
		private static final long serialVersionUID= 1L;		
		private None() {
		}
	}
	
	/**
	 * Optionally specify <code>expected</code>, a Throwable, to cause a test method to succeed iff 
	 * an exception of the specified class is thrown by the method.
	 */
	Class<? extends Throwable> expected() default None.class;
	
	/** 
	 * Optionally specify <code>timeout</code> in milliseconds to cause a test method to fail if it
	 * takes longer than that number of milliseconds.*/
	long timeout() default 0L; 
}

--- NEW FILE: After.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>If you allocate external resources in a {@link org.junit.Before} method you need to release them
 * after the test runs. Annotating a <code>public void</code> method
 * with <code>&#064;After</code> causes that method to be run after the {@link org.junit.Test} method. All <code>&#064;After</code>
 * methods are guaranteed to run even if a {@link org.junit.Before} or {@link org.junit.Test} method throws an 
 * exception. The <code>&#064;After</code> methods declared in superclasses will be run after those of the current
 * class.</p>
 * 
 * Here is a simple example:
* <pre>
 * public class Example {
 *    File output;
 *    &#064;Before public void createOutputFile() {
 *          output= new File(...);
 *    }
 *    &#064;Test public void something() {
 *          ...
 *    }
 *    &#064;After public void deleteOutputFile() {
 *          output.delete();
 *    }
 * }
 * </pre>
 * 
 * @see org.junit.Before
 * @see org.junit.Test
 */

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface After {
}


--- NEW FILE: BeforeClass.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>Sometimes several tests need to share computationally expensive setup
 * (like logging into a database). While this can compromise the independence of 
 * tests, sometimes it is a necessary optimization. Annotating a <code>public static void</code> no-arg method
 * with <code>@BeforeClass</code> causes it to be run once before any of 
 * the test methods in the class. The <code>@BeforeClass</code> methods of superclasses
 * will be run before those the current class.</p>
 * 
 * For example:
 * <pre>
 * public class Example {
 *    &#064;BeforeClass public static void onlyOnce() {
 *       ...
 *    }
 *    &#064;Test public void one() {
 *       ...
 *    }
 *    &#064;Test public void two() {
 *       ...
 *    }
 * }
 * </pre>
 * @see org.junit.AfterClass
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeforeClass {
}

--- NEW FILE: Before.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>When writing tests, it is common to find that several tests need similar 
 * objects created before they can run. Annotating a <code>public void</code> method
 * with <code>&#064;Before</code> causes that method to be run before the {@link org.junit.Test} method.
 * The <code>&#064;Before</code> methods of superclasses will be run before those of the current class.</p>
 * 
 * Here is a simple example:
 * <pre>
 * public class Example {
 *    List empty;
 *    &#064;Before public static void initialize() {
 *       empty= new ArrayList();
 *    }
 *    &#064;Test public void size() {
 *       ...
 *    }
 *    &#064;Test public void remove() {
 *       ...
 *    }
 * }
 * </pre>
 * 
 * @see org.junit.BeforeClass
 * @see org.junit.After
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Before {
}


--- NEW FILE: ComparisonFailure.java ---
package org.junit;

/**
 * Thrown when an {@link org.junit.Assert#assertEquals(Object, Object) assertEquals(String, String)} fails. Create and throw
 * a <code>ComparisonFailure</code> manually if you want to show users the difference between two complex 
 * strings.
 * 
 * Inspired by a patch from Alex Chaffee (al...@pu...)
 */
public class ComparisonFailure extends AssertionError {	
	/** 
	 * The maximum length for fExpected and fActual. If it is exceeded, the strings should be shortened. 
	 * @see ComparisonCompactor
	 */
	private static final int MAX_CONTEXT_LENGTH= 20;
	private static final long serialVersionUID= 1L;
	
	private String fExpected;
	private String fActual;

	/**
	 * Constructs a comparison failure.
	 * @param message the identifying message or null
	 * @param expected the expected string value
	 * @param actual the actual string value
	 */
	public ComparisonFailure (String message, String expected, String actual) {
		super (message);
		fExpected= expected;
		fActual= actual;
	}
	
	/**
	 * Returns "..." in place of common prefix and "..." in
	 * place of common suffix between expected and actual.
	 * 
	 * @see Throwable#getMessage()
	 */
	@Override
	public String getMessage() {
		return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
	}
	
	/**
	 * Returns the actual string value
	 * @return the actual string value
	 */
	public String getActual() {
		return fActual;
	}
	/**
	 * Returns the expected string value
	 * @return the expected string value
	 */
	public String getExpected() {
		return fExpected;
	}
	
	private static class ComparisonCompactor {
		private static final String ELLIPSIS= "...";
		private static final String DELTA_END= "]";
		private static final String DELTA_START= "[";
		
		/**
		 * The maximum length for <code>expected</code> and <code>actual</code>. When <code>contextLength</code> 
		 * is exceeded, the Strings are shortened
		 */
		private int fContextLength;
		private String fExpected;
		private String fActual;
		private int fPrefix;
		private int fSuffix;

		/**
		 * @param contextLength the maximum length for <code>expected</code> and <code>actual</code>. When contextLength 
		 * is exceeded, the Strings are shortened
		 * @param expected the expected string value
		 * @param actual the actual string value
		 */
		public ComparisonCompactor(int contextLength, String expected, String actual) {
			fContextLength= contextLength;
			fExpected= expected;
			fActual= actual;
		}

		public String compact(String message) {
			if (fExpected == null || fActual == null || areStringsEqual())
				return Assert.format(message, fExpected, fActual);

			findCommonPrefix();
			findCommonSuffix();
			String expected= compactString(fExpected);
			String actual= compactString(fActual);
			return Assert.format(message, expected, actual);
		}

		private String compactString(String source) {
			String result= DELTA_START + source.substring(fPrefix, source.length() - fSuffix + 1) + DELTA_END;
			if (fPrefix > 0)
				result= computeCommonPrefix() + result;
			if (fSuffix > 0)
				result= result + computeCommonSuffix();
			return result;
		}

		private void findCommonPrefix() {
			fPrefix= 0;
			int end= Math.min(fExpected.length(), fActual.length());
			for (; fPrefix < end; fPrefix++) {
				if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix))
					break;
			}
		}

		private void findCommonSuffix() {
			int expectedSuffix= fExpected.length() - 1;
			int actualSuffix= fActual.length() - 1;
			for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
				if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix))
					break;
			}
			fSuffix=  fExpected.length() - expectedSuffix;
		}

		private String computeCommonPrefix() {
			return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength), fPrefix);
		}

		private String computeCommonSuffix() {
			int end= Math.min(fExpected.length() - fSuffix + 1 + fContextLength, fExpected.length());
			return fExpected.substring(fExpected.length() - fSuffix + 1, end) + (fExpected.length() - fSuffix + 1 < fExpected.length() - fContextLength ? ELLIPSIS : "");
		}

		private boolean areStringsEqual() {
			return fExpected.equals(fActual);
		}
	}
}
--- NEW FILE: AfterClass.java ---
package org.junit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <p>If you allocate expensive external resources in a {@link org.junit.BeforeClass} method you need to release them
 * after all the tests in the class have run. Annotating a <code>public static void</code> method
 * with <code>&#064;AfterClass</code> causes that method to be run after all the tests in the class have been run. All <code>&#064;AfterClass</code>
 * methods are guaranteed to run even if a {@link org.junit.BeforeClass} method throws an 
 * exception. The <code>&#064;AfterClass</code> methods declared in superclasses will be run after those of the current
 * class.</p>
 * 
 * Here is a simple example:
* <pre>
 * public class Example {
 *    DatabaseConnection database;
 *    &#064;BeforeClass public void login() {
 *          database= ...;
 *    }
 *    &#064;Test public void something() {
 *          ...
 *    }
 *    &#064;Test public void somethingElse() {
 *          ...
 *    }
 *    &#064;AfterClass public void logout() {
 *          database.logout();
 *    }
 * }
 * </pre>
 * 
 * @see org.junit.BeforeClass
 * @see org.junit.Test
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterClass {
}

--- NEW FILE: Assert.java ---
package org.junit;

import org.junit.internal.ArrayComparisonFailure;

/**
 * A set of assertion methods useful for writing tests. Only failed assertions are recorded.
 * These methods can be used directly: <code>Assert.assertEquals(...)</code>, however, they
 * read better if they are referenced through static import:<br/>
 * <pre>
 * import static org.junit.Assert.*;
 *    ...
 *    assertEquals(...);
 * </pre>
 *   
 * @see AssertionError
 */
public class Assert {
	/**
	 * Protect constructor since it is a static only class
	 */
	protected Assert() {
	}
	
	/**
	 * Asserts that a condition is true. If it isn't it throws an
	 * {@link AssertionError} with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param condition condition to be checked
	 */
	static public void assertTrue(String message, boolean condition) {
		if (!condition)
			fail(message);
	}

	/**
	 * Asserts that a condition is true. If it isn't it throws an
	 * {@link AssertionError} without a message.
	 * @param condition condition to be checked
	 */
	static public void assertTrue(boolean condition) {
		assertTrue(null, condition);
	}

	/**
	 * Asserts that a condition is false. If it isn't it throws an
	 * {@link AssertionError} with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param condition condition to be checked
	 */
	static public void assertFalse(String message, boolean condition) {
		assertTrue(message, !condition);
	}

	/**
	 * Asserts that a condition is false. If it isn't it throws an
	 * {@link AssertionError} without a message.
	 * @param condition condition to be checked
	 */
	static public void assertFalse(boolean condition) {
		assertFalse(null, condition);
	}

	/**
	 * Fails a test with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @see AssertionError
	 */
	static public void fail(String message) {
		throw new AssertionError(message == null ? "" : message);
	}

	/**
	 * Fails a test with no message.
	 */
	static public void fail() {
		fail(null);
	}
	
	/**
	 * Asserts that two objects are equal. If they are not, an {@link AssertionError} 
	 * is thrown with the given message. If <code>expected</code> and <code>actual</code>
	 * are <code>null</code>, they are considered equal.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param expected expected value
	 * @param actual actual value
	 */
	static public void assertEquals(String message, Object expected, Object actual) {
		if (expected == null && actual == null)
			return;
		if (expected != null && expected.equals(actual))
			return;
		else if (expected instanceof String && actual instanceof String) {
			String cleanMessage= message == null ? "" : message;
			throw new ComparisonFailure(cleanMessage, (String)expected, (String)actual);
		}
		else
			failNotEquals(message, expected, actual);
	}

	/**
	 * Asserts that two objects are equal. If they are not, an {@link AssertionError} 
	 * without a message is thrown. If <code>expected</code> and <code>actual</code>
	 * are <code>null</code>, they are considered equal.
	 * @param expected expected value
	 * @param actual the value to check against <code>expected</code>
	 */
	static public void assertEquals(Object expected, Object actual) {
		assertEquals(null, expected, actual);
	}

	/**
	 * Asserts that two object arrays are equal. If they are not, an
	 * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
	 *  <code>actuals</code> are <code>null</code>, they are considered equal.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
	 * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
	 */
	public static void assertEquals(String message, Object[] expecteds, Object[] actuals) {
		if (expecteds == actuals)
			return;
		String header = message == null ? "" : message + ": ";
		if (expecteds == null)
			fail(header + "expected array was null");
		if (actuals == null)
			fail(header + "actual array was null");
		if (actuals.length != expecteds.length)
			fail(header + "array lengths differed, expected.length=" + expecteds.length + " actual.length=" + actuals.length);

		for (int i= 0; i < expecteds.length; i++) {
			Object o1= expecteds[i];
			Object o2= actuals[i];
			if (o1.getClass().isArray() && o2.getClass().isArray()) {
				Object[] expected= (Object[]) o1;
				Object[] actual= (Object[]) o2;
				try {
					assertEquals(message, expected, actual);
				} catch (ArrayComparisonFailure e) {
					e.addDimension(i);
					throw e;
				}
			} else
				try {
					assertEquals(o1, o2);
				} catch (AssertionError e) {
					throw new ArrayComparisonFailure(header, e, i);
				}
		}
	}

	/**
	 * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
	 * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
	 * they are considered equal.
	 * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
	 * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
	 */
	public static void assertEquals(Object[] expecteds, Object[] actuals) {
		assertEquals(null, expecteds, actuals);
	}

	/**
	 * Asserts that two doubles are equal to within a positive delta. If they
	 * are not, an {@link AssertionError} is thrown with the given message. If the
	 * expected value is infinity then the delta value is ignored. NaNs are
	 * considered equal:
	 * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param expected expected value
	 * @param actual the value to check against <code>expected</code>
	 * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
	 * both numbers are still considered equal.
	 */
	static public void assertEquals(String message, double expected, double actual, double delta) {
		if (Double.compare(expected, actual) == 0)
			return;
		if (!(Math.abs(expected - actual) <= delta))
			failNotEquals(message, new Double(expected), new Double(actual));
	}

	/**
	 * Asserts that two doubles are equal to within a positive delta. If they
	 * are not, an {@link AssertionError} is thrown. If the
	 * expected value is infinity then the delta value is ignored.NaNs are
	 * considered equal:
	 * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
	 * @param expected expected value
	 * @param actual the value to check against <code>expected</code>
	 * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
	 * both numbers are still considered equal.
	 */
	static public void assertEquals(double expected, double actual, double delta) {
		assertEquals(null, expected, actual, delta);
	}

	/**
	 * Asserts that two floats are equal to within a positive delta. If they
	 * are not, an {@link AssertionError} is thrown with the given message. If the
	 * expected value is infinity then the delta value is ignored. NaNs are
	 * considered equal:
	 * <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param expected the expected float value
	 * @param actual the float value to check against <code>expected</code>
	 * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
	 * both numbers are still considered equal.
	 */
	static public void assertEquals(String message, float expected, float actual, float delta) {
		if (Float.compare(expected, actual) == 0)
			return;
		if (!(Math.abs(expected - actual) <= delta))
			failNotEquals(message, new Float(expected), new Float(actual));
	}

	/**
	 * Asserts that two floats are equal to within a positive delta. If they
	 * are not, an {@link AssertionError} is thrown. If the
	 * expected value is infinity then the delta value is ignored. {@link Float#NaN NaNs} are
	 * considered equal:
	 * <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
	 * @param expected the expected value
	 * @param actual the value to check against <code>expected</code>
	 * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
	 * both numbers are still considered equal.
	 */
	static public void assertEquals(float expected, float actual, float delta) {
		assertEquals(null, expected, actual, delta);
	}

	/**
	 * Asserts that an object isn't null. If it is an {@link AssertionError} is
	 * thrown with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param object Object to check or <code>null</code>
	 */
	static public void assertNotNull(String message, Object object) {
		assertTrue(message, object != null);
	}

	/**
	 * Asserts that an object isn't null. If it is an {@link AssertionError} is
	 * thrown.
	 * @param object Object to check or <code>null</code>
	 */
	static public void assertNotNull(Object object) {
		assertNotNull(null, object);
	}
	
	/**
	 * Asserts that an object is null. If it is not, an {@link AssertionError} is
	 * thrown with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param object Object to check or <code>null</code>
	 */
	static public void assertNull(String message, Object object) {
		assertTrue(message, object == null);
	}

	/**
	 * Asserts that an object is null. If it isn't an {@link AssertionError} is
	 * thrown.
	 * @param object Object to check or <code>null</code>
	 */
	static public void assertNull(Object object) {
		assertNull(null, object);
	}
	
	/**
	 * Asserts that two objects refer to the same object. If they are not, an
	 * {@link AssertionError} is thrown with the given message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param expected the expected object
	 * @param actual the object to compare to <code>expected</code>
	 */
	static public void assertSame(String message, Object expected, Object actual) {
		if (expected == actual)
			return;
		failNotSame(message, expected, actual);
	}

	/**
	 * Asserts that two objects refer to the same object. If they are not the
	 * same, an {@link AssertionError} without a message is thrown.
	 * @param expected the expected object
	 * @param actual the object to compare to <code>expected</code>
	 */
	static public void assertSame(Object expected, Object actual) {
		assertSame(null, expected, actual);
	}

	/**
	 * Asserts that two objects do not refer to the same object. If they do
	 * refer to the same object, an {@link AssertionError} is thrown with the given
	 * message.
	 * @param message the identifying message or <code>null</code> for the {@link AssertionError}
	 * @param unexpected the object you don't expect
	 * @param actual the object to compare to <code>unexpected</code>
	 */
	static public void assertNotSame(String message, Object unexpected, Object actual) {
		if (unexpected == actual)
			failSame(message);
	}

	/**
	 * Asserts that two objects do not refer to the same object. If they do
	 * refer to the same object, an {@link AssertionError} without a message is thrown.
	 * @param unexpected the object you don't expect
	 * @param actual the object to compare to <code>unexpected</code>
	 */
	static public void assertNotSame(Object unexpected, Object actual) {
		assertNotSame(null, unexpected, actual);
	}

	static private void failSame(String message) {
		String formatted= "";
		if (message != null)
			formatted= message + " ";
		fail(formatted + "expected not same");
	}

	static private void failNotSame(String message, Object expected, Object actual) {
		String formatted= "";
		if (message != null)
			formatted= message + " ";
		fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
	}

	static private void failNotEquals(String message, Object expected, Object actual) {
		fail(format(message, expected, actual));
	}

	static String format(String message, Object expected, Object actual) {
		String formatted= "";
		if (message != null && ! message.equals(""))
			formatted= message + " ";
		return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
	}

}

[Junit-devel] CVS: junit/src/junit/tests/framework NotPublicTestCase.java, NONE, 1.1 package-info.java, NONE, 1.1 TestCaseTest.java, NONE, 1.1 AssertTest.java, NONE, 1.1 TestListenerTest.java, NONE, 1.1 AllTests.java, NONE, 1.1 Success.java, NONE, 1.1 NoTestCases.java, NONE, 1.1 InheritedTestCase.java, NONE, 1.1 DoublePrecisionAssertTest.java, NONE, 1.1 NoTestCaseClass.java, NONE, 1.1 OneTestCase.java, NONE, 1.1 SuiteTest.java, NONE, 1.1 FloatAssertTest.java, NONE, 1.1 NoArgTestCaseTest.java, NONE, 1.1 TestImplementorTest.java, NONE, 1.1 ComparisonFailureTest.java, NONE, 1.1 NotVoidTestCase.java, NONE, 1.1 Failure.java, NONE, 1.1 ComparisonCompactorTest.java, NONE, 1.1 OverrideTestCase.java, NONE, 1.1

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/tests/framework
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/src/junit/tests/framework

Added Files:
	NotPublicTestCase.java package-info.java TestCaseTest.java 
	AssertTest.java TestListenerTest.java AllTests.java 
	Success.java NoTestCases.java InheritedTestCase.java 
	DoublePrecisionAssertTest.java NoTestCaseClass.java 
	OneTestCase.java SuiteTest.java FloatAssertTest.java 
	NoArgTestCaseTest.java TestImplementorTest.java 
	ComparisonFailureTest.java NotVoidTestCase.java Failure.java 
	ComparisonCompactorTest.java OverrideTestCase.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- 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: package-info.java ---
/**
 * Tests the JUnit v3.x core classes.
 */
package junit.tests.framework;
--- NEW FILE: TestCaseTest.java ---
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);
	}
}
--- 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: 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: 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: 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: 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: InheritedTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
public class InheritedTestCase extends OneTestCase { 
	public void test2() {
	}
}
--- 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: NoTestCaseClass.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */

public class NoTestCaseClass extends Object {
	public void testSuccess() {
	}
}
--- 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: 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: 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: 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: 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: 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: 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: 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: 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: OverrideTestCase.java ---
package junit.tests.framework;

/**
 * Test class used in SuiteTest
 */
public class OverrideTestCase extends OneTestCase {
	@Override
	public void testCase() {
	}
}

[Junit-devel] CVS: junit/org/junit/runner/manipulation Filterable.java, 1.4, NONE Filter.java, 1.4, NONE Sortable.java, 1.4, NONE Sorter.java, 1.4, NONE NoTestsRemainException.java, 1.3, NONE package-info.java, 1.1, NONE

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/org/junit/runner/manipulation
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/org/junit/runner/manipulation

Removed Files:
	Filterable.java Filter.java Sortable.java Sorter.java 
	NoTestsRemainException.java package-info.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- Filterable.java DELETED ---

--- Filter.java DELETED ---

--- Sortable.java DELETED ---

--- Sorter.java DELETED ---

--- NoTestsRemainException.java DELETED ---

--- package-info.java DELETED ---

[Junit-devel] CVS: junit/org/junit/tests JUnitCoreTest.java, 1.4, NONE AnnotationTest.java, 1.2, NONE ParameterizedTestMethodTest.java, 1.2, NONE SuiteTest.java, 1.3, NONE InitializationErrorForwardCompatibilityTest.java, 1.3, NONE ListenerTest.java, 1.1, NONE ForwardCompatibilityTest.java, 1.3, NONE InaccessibleBaseClassTest.java, 1.1, NONE ParameterizedTestTest.java, 1.3, NONE TextListenerTest.java, 1.3, NONE TestMethodTest.java, 1.3, NONE PreJUnit4TestCaseRunnerTest.java, 1.2, NONE OldTests.java, 1.2, NONE CommandLineTest.java, 1.2, NONE UserStopTest.java, 1.2, NONE ExpectedTest.java, 1.2, NONE AssertionTest.java, 1.10, NONE SingleMethodTest.java, 1.3, NONE FailedConstructionTest.java, 1.2, NONE TimeoutTest.java, 1.3, NONE package-info.java, 1.1, NONE SuiteDescriptionTest.java, 1.2, NONE RunnerTest.java, 1.2, NONE ValidationTest.java, 1.3, NONE SortableTest.java, 1.5, NONE TestListenerTest.java, 1.2, NONE ForwardCompatibilityPrintingTest.java, 1.2, NONE RunWithTest.java, 1.3, NONE CustomRunnerTest.java, 1.2, NONE TestDescriptionTest.java, 1.2, NONE OldTestClassRunnerTest.java, 1.2, NONE TestClassMethodsRunnerTest.java, 1.1, NONE EnclosedTest.java, 1.4, NONE AllTestsTest.java, 1.2, NONE AllTests.java, 1.6, NONE

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/org/junit/tests
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/org/junit/tests

Removed Files:
	JUnitCoreTest.java AnnotationTest.java 
	ParameterizedTestMethodTest.java SuiteTest.java 
	InitializationErrorForwardCompatibilityTest.java 
	ListenerTest.java ForwardCompatibilityTest.java 
	InaccessibleBaseClassTest.java ParameterizedTestTest.java 
	TextListenerTest.java TestMethodTest.java 
	PreJUnit4TestCaseRunnerTest.java OldTests.java 
	CommandLineTest.java UserStopTest.java ExpectedTest.java 
	AssertionTest.java SingleMethodTest.java 
	FailedConstructionTest.java TimeoutTest.java package-info.java 
	SuiteDescriptionTest.java RunnerTest.java ValidationTest.java 
	SortableTest.java TestListenerTest.java 
	ForwardCompatibilityPrintingTest.java RunWithTest.java 
	CustomRunnerTest.java TestDescriptionTest.java 
	OldTestClassRunnerTest.java TestClassMethodsRunnerTest.java 
	EnclosedTest.java AllTestsTest.java AllTests.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- JUnitCoreTest.java DELETED ---

--- AnnotationTest.java DELETED ---

--- ParameterizedTestMethodTest.java DELETED ---

--- SuiteTest.java DELETED ---

--- InitializationErrorForwardCompatibilityTest.java DELETED ---

--- ListenerTest.java DELETED ---

--- ForwardCompatibilityTest.java DELETED ---

--- InaccessibleBaseClassTest.java DELETED ---

--- ParameterizedTestTest.java DELETED ---

--- TextListenerTest.java DELETED ---

--- TestMethodTest.java DELETED ---

--- PreJUnit4TestCaseRunnerTest.java DELETED ---

--- OldTests.java DELETED ---

--- CommandLineTest.java DELETED ---

--- UserStopTest.java DELETED ---

--- ExpectedTest.java DELETED ---

--- AssertionTest.java DELETED ---

--- SingleMethodTest.java DELETED ---

--- FailedConstructionTest.java DELETED ---

--- TimeoutTest.java DELETED ---

--- package-info.java DELETED ---

--- SuiteDescriptionTest.java DELETED ---

--- RunnerTest.java DELETED ---

--- ValidationTest.java DELETED ---

--- SortableTest.java DELETED ---

--- TestListenerTest.java DELETED ---

--- ForwardCompatibilityPrintingTest.java DELETED ---

--- RunWithTest.java DELETED ---

--- CustomRunnerTest.java DELETED ---

--- TestDescriptionTest.java DELETED ---

--- OldTestClassRunnerTest.java DELETED ---

--- TestClassMethodsRunnerTest.java DELETED ---

--- EnclosedTest.java DELETED ---

--- AllTestsTest.java DELETED ---

--- AllTests.java DELETED ---

[Junit-devel] CVS: junit/src/junit/samples/money MoneyBag.java, NONE, 1.1 Money.java, NONE, 1.1 MoneyTest.java, NONE, 1.1 IMoney.java, NONE, 1.1 package-info.java, NONE, 1.1

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/samples/money
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/src/junit/samples/money

Added Files:
	MoneyBag.java Money.java MoneyTest.java IMoney.java 
	package-info.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- NEW FILE: MoneyBag.java ---
package junit.samples.money;

import java.util.ArrayList;
import java.util.List;

/**
 * A MoneyBag defers exchange rate conversions. For example adding 
 * 12 Swiss Francs to 14 US Dollars is represented as a bag 
 * containing the two Monies 12 CHF and 14 USD. Adding another
 * 10 Swiss francs gives a bag with 22 CHF and 14 USD. Due to 
 * the deferred exchange rate conversion we can later value a 
 * MoneyBag with different exchange rates.
 *
 * A MoneyBag is represented as a list of Monies and provides 
 * different constructors to create a MoneyBag. 
 */ 
public class MoneyBag implements IMoney {
	private List<Money> fMonies= new ArrayList<Money>(5);

	public static IMoney create(IMoney m1, IMoney m2) {
		MoneyBag result= new MoneyBag();
		m1.appendTo(result);
		m2.appendTo(result);
		return result.simplify();
	}
	public IMoney add(IMoney m) {
		return m.addMoneyBag(this);
	}
	public IMoney addMoney(Money m) { 
		return MoneyBag.create(m, this);
	}
	public IMoney addMoneyBag(MoneyBag s) {
		return MoneyBag.create(s, this);
	}
	void appendBag(MoneyBag aBag) {
		for (Money each : aBag.fMonies)
			appendMoney(each);
	}
	void appendMoney(Money aMoney) {
		if (aMoney.isZero()) return;
		IMoney old= findMoney(aMoney.currency());
		if (old == null) {
			fMonies.add(aMoney);
			return;
		}
		fMonies.remove(old);
		Money sum= (Money) old.add(aMoney);
		if (sum.isZero()) 
			return;
		fMonies.add(sum);
	}
	@Override
	public boolean equals(Object anObject) {
		if (isZero())
			if (anObject instanceof IMoney)
				return ((IMoney)anObject).isZero();

		if (anObject instanceof MoneyBag) {
			MoneyBag aMoneyBag= (MoneyBag)anObject;
			if (aMoneyBag.fMonies.size() != fMonies.size())
				return false;

		    for (Money each : fMonies)
		        if (! aMoneyBag.contains(each))
					return false;
			return true;
		}
		return false;
	}
	private Money findMoney(String currency) {
		for (Money each : fMonies)
			if (each.currency().equals(currency))
				return each;
		return null;
	}
	private boolean contains(Money m) {
		Money found= findMoney(m.currency());
		if (found == null) return false;
		return found.amount() == m.amount();
	}
	@Override
	public int hashCode() {
		int hash= 0;
	    for (Money each : fMonies)
	        hash^= each.hashCode();
	    return hash;
	}
	public boolean isZero() {
		return fMonies.size() == 0;
	}
	public IMoney multiply(int factor) {
		MoneyBag result= new MoneyBag();
		if (factor != 0)
			for (Money each : fMonies)
				result.appendMoney((Money) each.multiply(factor));
		return result;
	}
	public IMoney negate() {
		MoneyBag result= new MoneyBag();
	    for (Money each : fMonies)
	        result.appendMoney((Money) each.negate());
		return result;
	}
	private IMoney simplify() {
		if (fMonies.size() == 1)
			return fMonies.iterator().next();
		return this;
	}
	public IMoney subtract(IMoney m) {
		return add(m.negate());
	}
	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("{");
		for (Money each : fMonies)
		    buffer.append(each);
		buffer.append("}");
		return buffer.toString();
	}
	public void appendTo(MoneyBag m) {
		m.appendBag(this);
	}
}
--- NEW FILE: Money.java ---
package junit.samples.money;

/**
 * A simple Money.
 *
 */
public class Money implements IMoney {

	private int fAmount;
	private String fCurrency;

	/**
	 * Constructs a money from the given amount and currency.
	 */
	public Money(int amount, String currency) {
		fAmount= amount;
		fCurrency= currency;
	}
	/**
	 * Adds a money to this money. Forwards the request to the addMoney helper.
	 */
	public IMoney add(IMoney m) {
		return m.addMoney(this);
	}
	public IMoney addMoney(Money m) {
		if (m.currency().equals(currency()) )
			return new Money(amount()+m.amount(), currency());
		return MoneyBag.create(this, m);
	}
	public IMoney addMoneyBag(MoneyBag s) {
		return s.addMoney(this);
	}
	public int amount() {
		return fAmount;
	}
	public String currency() {
		return fCurrency;
	}
	@Override
	public boolean equals(Object anObject) {
		if (isZero()) 
			if (anObject instanceof IMoney)
				return ((IMoney)anObject).isZero();
		if (anObject instanceof Money) {
			Money aMoney= (Money)anObject;
			return aMoney.currency().equals(currency())
							 && amount() == aMoney.amount();
		}
		return false;
	}
	@Override
	public int hashCode() {
		if (fAmount == 0)
			return 0;
		return fCurrency.hashCode()+fAmount;
	}
	public boolean isZero() {
		return amount() == 0;
	}
	public IMoney multiply(int factor) {
		return new Money(amount()*factor, currency());
	}
	public IMoney negate() {
		return new Money(-amount(), currency());
	}
	public IMoney subtract(IMoney m) {
		return add(m.negate());
	}
	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("["+amount()+" "+currency()+"]");
		return buffer.toString();
	}
	public /*this makes no sense*/ void appendTo(MoneyBag m) {
		m.appendMoney(this);
	}
}
--- NEW FILE: MoneyTest.java ---
package junit.samples.money;

import junit.framework.TestCase;

public class MoneyTest extends TestCase {
	private Money f12CHF;
	private Money f14CHF;
	private Money f7USD;
	private Money f21USD;

	private IMoney fMB1;
	private IMoney fMB2;

	public static void main(String args[]) {
		junit.textui.TestRunner.run(MoneyTest.class);
	}
	@Override
	protected void setUp() {
		f12CHF= new Money(12, "CHF");
		f14CHF= new Money(14, "CHF");
		f7USD= new Money( 7, "USD");
		f21USD= new Money(21, "USD");

		fMB1= MoneyBag.create(f12CHF, f7USD);
		fMB2= MoneyBag.create(f14CHF, f21USD);
	}
	public void testBagMultiply() {
		// {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}
		IMoney expected= MoneyBag.create(new Money(24, "CHF"), new Money(14, "USD"));
		assertEquals(expected, fMB1.multiply(2)); 
		assertEquals(fMB1, fMB1.multiply(1));
		assertTrue(fMB1.multiply(0).isZero());
	}
	public void testBagNegate() {
		// {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}
		IMoney expected= MoneyBag.create(new Money(-12, "CHF"), new Money(-7, "USD"));
		assertEquals(expected, fMB1.negate());
	}
	public void testBagSimpleAdd() {
		// {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}
		IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
		assertEquals(expected, fMB1.add(f14CHF));
	}
	public void testBagSubtract() {
		// {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}
		IMoney expected= MoneyBag.create(new Money(-2, "CHF"), new Money(-14, "USD"));
		assertEquals(expected, fMB1.subtract(fMB2));
	}
	public void testBagSumAdd() {
		// {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}
		IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(28, "USD"));
		assertEquals(expected, fMB1.add(fMB2));
	}
	public void testIsZero() {
		assertTrue(fMB1.subtract(fMB1).isZero()); 
		assertTrue(MoneyBag.create(new Money (0, "CHF"), new Money (0, "USD")).isZero());
	}
	public void testMixedSimpleAdd() {
		// [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
		IMoney expected= MoneyBag.create(f12CHF, f7USD);
		assertEquals(expected, f12CHF.add(f7USD));
	}
	public void testBagNotEquals() {
		IMoney bag= MoneyBag.create(f12CHF, f7USD);
		assertFalse(bag.equals(new Money(12, "DEM").add(f7USD)));
	}
	public void testMoneyBagEquals() {
		assertTrue(!fMB1.equals(null)); 

		assertEquals(fMB1, fMB1);
		IMoney equal= MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
		assertTrue(fMB1.equals(equal));
		assertTrue(!fMB1.equals(f12CHF));
		assertTrue(!f12CHF.equals(fMB1));
		assertTrue(!fMB1.equals(fMB2));
	}
	public void testMoneyBagHash() {
		IMoney equal= MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
		assertEquals(fMB1.hashCode(), equal.hashCode());
	}
	public void testMoneyEquals() {
		assertTrue(!f12CHF.equals(null)); 
		Money equalMoney= new Money(12, "CHF");
		assertEquals(f12CHF, f12CHF);
		assertEquals(f12CHF, equalMoney);
		assertEquals(f12CHF.hashCode(), equalMoney.hashCode());
		assertTrue(!f12CHF.equals(f14CHF));
	}
	public void testMoneyHash() {
		assertTrue(!f12CHF.equals(null)); 
		Money equal= new Money(12, "CHF");
		assertEquals(f12CHF.hashCode(), equal.hashCode());
	}
	public void testSimplify() {
		IMoney money= MoneyBag.create(new Money(26, "CHF"), new Money(28, "CHF"));
		assertEquals(new Money(54, "CHF"), money);
	}
	public void testNormalize2() {
		// {[12 CHF][7 USD]} - [12 CHF] == [7 USD]
		Money expected= new Money(7, "USD");
		assertEquals(expected, fMB1.subtract(f12CHF));
	}
	public void testNormalize3() {
		// {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]
		IMoney ms1= MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
		Money expected= new Money(4, "USD");
		assertEquals(expected, fMB1.subtract(ms1));
	}
	public void testNormalize4() {
		// [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]
		IMoney ms1= MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
		Money expected= new Money(-3, "USD");
		assertEquals(expected, f12CHF.subtract(ms1));
	}
	public void testPrint() {
		assertEquals("[12 CHF]", f12CHF.toString());
	}
	public void testSimpleAdd() {
		// [12 CHF] + [14 CHF] == [26 CHF]
		Money expected= new Money(26, "CHF");
		assertEquals(expected, f12CHF.add(f14CHF));
	}
	public void testSimpleBagAdd() {
		// [14 CHF] + {[12 CHF][7 USD]} == {[26 CHF][7 USD]}
		IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
		assertEquals(expected, f14CHF.add(fMB1));
	}
	public void testSimpleMultiply() {
		// [14 CHF] *2 == [28 CHF]
		Money expected= new Money(28, "CHF");
		assertEquals(expected, f14CHF.multiply(2));
	}
	public void testSimpleNegate() {
		// [14 CHF] negate == [-14 CHF]
		Money expected= new Money(-14, "CHF");
		assertEquals(expected, f14CHF.negate());
	}
	public void testSimpleSubtract() {
		// [14 CHF] - [12 CHF] == [2 CHF]
		Money expected= new Money(2, "CHF");
		assertEquals(expected, f14CHF.subtract(f12CHF));
	}
}
--- NEW FILE: IMoney.java ---
package junit.samples.money;

/**
 * The common interface for simple Monies and MoneyBags
 *
 */
public interface IMoney {
	/**
	 * Adds a money to this money.
	 */
	public abstract IMoney add(IMoney m);
	/**
	 * Adds a simple Money to this money. This is a helper method for
	 * implementing double dispatch
	 */
	public abstract IMoney addMoney(Money m);
	/**
	 * Adds a MoneyBag to this money. This is a helper method for
	 * implementing double dispatch
	 */
	public abstract IMoney addMoneyBag(MoneyBag s);
	/**
	 * Tests whether this money is zero
	 */
	public abstract boolean isZero();
	/**
	 * Multiplies a money by the given factor.
	 */
	public abstract IMoney multiply(int factor);
	/**
	 * Negates this money.
	 */
	public abstract IMoney negate();
	/**
	 * Subtracts a money from this money.
	 */
	public abstract IMoney subtract(IMoney m);
	/**
	 * Append this to a MoneyBag m.
	 * appendTo() needs to be public because it is used
	 * polymorphically, but it should not be used by clients
	 * because it modifies the argument m.
	 */
	public abstract void appendTo(MoneyBag m);
}
--- NEW FILE: package-info.java ---
/**
 * Example "Money" for JUnit v3.x.
 */
package junit.samples.money;

[Junit-devel] CVS: junit/junit/samples/money IMoney.java, 1.5, NONE MoneyBag.java, 1.6, NONE package-info.java, 1.1, NONE Money.java, 1.4, NONE MoneyTest.java, 1.8, NONE

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/junit/samples/money
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/junit/samples/money

Removed Files:
	IMoney.java MoneyBag.java package-info.java Money.java 
	MoneyTest.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- IMoney.java DELETED ---

--- MoneyBag.java DELETED ---

--- package-info.java DELETED ---

--- Money.java DELETED ---

--- MoneyTest.java DELETED ---

[Junit-devel] CVS: junit/junit/tests/framework SuiteTest.java, 1.8, NONE TestImplementorTest.java, 1.5, NONE OneTestCase.java, 1.3, NONE Failure.java, 1.6, NONE ComparisonCompactorTest.java, 1.1, NONE NotPublicTestCase.java, 1.3, NONE TestListenerTest.java, 1.5, NONE NotVoidTestCase.java, 1.3, NONE NoArgTestCaseTest.java, 1.1, NONE DoublePrecisionAssertTest.java, 1.4, NONE TestCaseTest.java, 1.10, NONE NoTestCases.java, 1.3, NONE Success.java, 1.6, NONE InheritedTestCase.java, 1.3, NONE FloatAssertTest.java, 1.2, NONE ComparisonFailureTest.java, 1.2, NONE package-info.java, 1.1, NONE OverrideTestCase.java, 1.4, NONE NoTestCaseClass.java, 1.4, NONE AssertTest.java, 1.11, NONE AllTests.java, 1.9, NONE

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/junit/tests/framework
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/junit/tests/framework

Removed Files:
	SuiteTest.java TestImplementorTest.java OneTestCase.java 
	Failure.java ComparisonCompactorTest.java 
	NotPublicTestCase.java TestListenerTest.java 
	NotVoidTestCase.java NoArgTestCaseTest.java 
	DoublePrecisionAssertTest.java TestCaseTest.java 
	NoTestCases.java Success.java InheritedTestCase.java 
	FloatAssertTest.java ComparisonFailureTest.java 
	package-info.java OverrideTestCase.java NoTestCaseClass.java 
	AssertTest.java AllTests.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- SuiteTest.java DELETED ---

--- TestImplementorTest.java DELETED ---

--- OneTestCase.java DELETED ---

--- Failure.java DELETED ---

--- ComparisonCompactorTest.java DELETED ---

--- NotPublicTestCase.java DELETED ---

--- TestListenerTest.java DELETED ---

--- NotVoidTestCase.java DELETED ---

--- NoArgTestCaseTest.java DELETED ---

--- DoublePrecisionAssertTest.java DELETED ---

--- TestCaseTest.java DELETED ---

--- NoTestCases.java DELETED ---

--- Success.java DELETED ---

--- InheritedTestCase.java DELETED ---

--- FloatAssertTest.java DELETED ---

--- ComparisonFailureTest.java DELETED ---

--- package-info.java DELETED ---

--- OverrideTestCase.java DELETED ---

--- NoTestCaseClass.java DELETED ---

--- AssertTest.java DELETED ---

--- AllTests.java DELETED ---

[Junit-devel] CVS: junit/src/org/junit/internal/requests SortingRequest.java, NONE, 1.1 ClassRequest.java, NONE, 1.1 FilterRequest.java, NONE, 1.1 ClassesRequest.java, NONE, 1.1 ErrorReportingRequest.java, NONE, 1.1 package-info.java, NONE, 1.1

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/internal/requests
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19867/src/org/junit/internal/requests

Added Files:
	SortingRequest.java ClassRequest.java FilterRequest.java 
	ClassesRequest.java ErrorReportingRequest.java 
	package-info.java 
Log Message:
Created a separate src folder for sources, and adjusted Eclipse classpath and build file accordingly

--- NEW FILE: SortingRequest.java ---
package org.junit.internal.requests;

import java.util.Comparator;

import org.junit.runner.Description;
import org.junit.runner.Request;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Sorter;

public class SortingRequest extends Request {
	private final Request fRequest;
	private final Comparator<Description> fComparator;

	public SortingRequest(Request request, Comparator<Description> comparator) {
		fRequest= request;
		fComparator= comparator;
	}

	@Override
	public Runner getRunner() {
		Runner runner= fRequest.getRunner();
		new Sorter(fComparator).apply(runner);
		return runner;
	}
}

--- NEW FILE: ClassRequest.java ---
package org.junit.internal.requests;

import java.lang.reflect.Constructor;

import org.junit.internal.runners.OldTestClassRunner;
import org.junit.internal.runners.TestClassRunner;
import org.junit.runner.Request;
import org.junit.runner.RunWith;
import org.junit.runner.Runner;

public class ClassRequest extends Request {
	private final Class<?> fTestClass;

	public ClassRequest(Class<?> each) {
		fTestClass= each;
	}
	
	@Override
	public Runner getRunner() {
		Class<? extends Runner> runnerClass= getRunnerClass(fTestClass);
		try {
			Constructor<? extends Runner> constructor= runnerClass.getConstructor(Class.class); // TODO good error message if no such constructor
			return constructor.newInstance(new Object[] { fTestClass });
		} catch (StackOverflowError e) {
			throw new RuntimeException();
		} catch (Exception e) {
			return Request.errorReport(fTestClass, e).getRunner();
		} 
	}

	Class<? extends Runner> getRunnerClass(Class<?> testClass) {
		RunWith annotation= testClass.getAnnotation(RunWith.class);
		if (annotation != null) {
			return annotation.value();
		} else if (isPre4Test(testClass)) {
			return OldTestClassRunner.class; 
		} else {
			return TestClassRunner.class;
		}
	}
	
	boolean isPre4Test(Class<?> testClass) {
		return junit.framework.TestCase.class.isAssignableFrom(testClass);
	}
}
--- NEW FILE: FilterRequest.java ---
/**
 * 
 */
package org.junit.internal.requests;

import org.junit.runner.Request;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
import org.junit.runner.manipulation.NoTestsRemainException;

/**
 * A filtered {@link Request}.
 */
public final class FilterRequest extends Request {
	private final Request fRequest;
	private final Filter fFilter;

	/**
	 * Creates a filtered Request
	 * @param classRequest a {@link Request} describing your Tests
	 * @param filter {@link Filter} to apply to the Tests described in 
	 * <code>classRequest</code>
	 */
	public FilterRequest(Request classRequest, Filter filter) {
		fRequest= classRequest;
		fFilter= filter;
	}

	/** @inheritDoc */
	@Override 
	public Runner getRunner() {
		try {
			Runner runner= fRequest.getRunner();
			fFilter.apply(runner);
			return runner;
		} catch (NoTestsRemainException e) {
			return Request.errorReport(Filter.class, new Exception(String
					.format("No tests found matching %s from %s", fFilter
							.describe(), fRequest.toString()))).getRunner();
		}
	}
}
--- NEW FILE: ClassesRequest.java ---
package org.junit.internal.requests;

import org.junit.internal.runners.CompositeRunner;
import org.junit.runner.Request;
import org.junit.runner.Runner;

public class ClassesRequest extends Request {
	private final Class<?>[] fClasses;
	private final String fName;
	
	public ClassesRequest(String name, Class<?>... classes) {
		fClasses= classes;
		fName= name;
	}

	/** @inheritDoc */
	@Override 
	public Runner getRunner() {
		CompositeRunner runner= new CompositeRunner(fName);
		for (Class<?> each : fClasses) {
			Runner childRunner= Request.aClass(each).getRunner();
			if (childRunner != null)
				runner.add(childRunner);
		}
		return runner;
	}
}
--- NEW FILE: ErrorReportingRequest.java ---
package org.junit.internal.requests;

import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.List;

import org.junit.internal.runners.CompositeRunner;
import org.junit.internal.runners.ErrorReportingRunner;
import org.junit.internal.runners.InitializationError;
import org.junit.runner.Description;
import org.junit.runner.Request;
import org.junit.runner.Runner;

public class ErrorReportingRequest extends Request {

	private final Class<?> fClass;
	private final Throwable fCause;

	public ErrorReportingRequest(Class<?> klass, Throwable cause) {
		fClass= klass;
		fCause= cause;
	}

	@Override
	public Runner getRunner() {
		List<Throwable> goofs= getCauses(fCause);
		CompositeRunner runner= new CompositeRunner(fClass.getName());
		for (int i= 0; i < goofs.size(); i++) {
			final Description description= Description.createTestDescription(fClass, "initializationError" + i);
			final Throwable throwable= goofs.get(i);
			runner.add(new ErrorReportingRunner(description, throwable));
		}
		return runner;
	}
	
	private List<Throwable> getCauses(Throwable cause) {
		if (cause instanceof InvocationTargetException)
			return getCauses(cause.getCause());
		if (cause instanceof InitializationError)
			return ((InitializationError) cause).getCauses();
		// TODO: untested
		return Arrays.asList(cause);	
	}
}

--- NEW FILE: package-info.java ---
/**
 * Provides implementations of {@link org.junit.runner.Request}.
 *
 * @since 4.0
 */
package org.junit.internal.requests;

[Junit-devel] CVS: junit/src/org/junit/runner/manipulation - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/runner/manipulation
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/runner/manipulation

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/runner/manipulation added to the repository

[Junit-devel] CVS: junit/src/org/junit/internal/runners - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/internal/runners
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/internal/runners

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/internal/runners added to the repository

[Junit-devel] CVS: junit/src/org/junit/runner - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/runner
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/runner

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/runner added to the repository

[Junit-devel] CVS: junit/src/org/junit/tests - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/tests
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/tests

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/tests added to the repository

[Junit-devel] CVS: junit/src/org - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org

Log Message:
Directory /cvsroot/junit/junit/src/org added to the repository

[Junit-devel] CVS: junit/src/org/junit/internal - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/internal
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/internal

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/internal added to the repository

[Junit-devel] CVS: junit/src/junit/tests/runner - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/tests/runner
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/junit/tests/runner

Log Message:
Directory /cvsroot/junit/junit/src/junit/tests/runner added to the repository

[Junit-devel] CVS: junit/src/org/junit/runners - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/runners
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/runners

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/runners added to the repository

[Junit-devel] CVS: junit/src/org/junit/samples/money - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/samples/money
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/samples/money

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/samples/money added to the repository

[Junit-devel] CVS: junit/src/org/junit/tests/anotherpackage - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/tests/anotherpackage
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/tests/anotherpackage

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/tests/anotherpackage added to the repository

[Junit-devel] CVS: junit/src/org/junit/internal/requests - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/internal/requests
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/internal/requests

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/internal/requests added to the repository

[Junit-devel] CVS: junit/src/junit/samples/money - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/samples/money
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/junit/samples/money

Log Message:
Directory /cvsroot/junit/junit/src/junit/samples/money added to the repository

[Junit-devel] CVS: junit/src/org/junit - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit

Log Message:
Directory /cvsroot/junit/junit/src/org/junit added to the repository

[Junit-devel] CVS: junit/src/junit/runner - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/runner
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/junit/runner

Log Message:
Directory /cvsroot/junit/junit/src/junit/runner added to the repository

[Junit-devel] CVS: junit/src/junit/tests - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/junit/tests
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/junit/tests

Log Message:
Directory /cvsroot/junit/junit/src/junit/tests added to the repository

[Junit-devel] CVS: junit/src/org/junit/samples - New directory

[David S. <ds...@us...>]

Update of /cvsroot/junit/junit/src/org/junit/samples
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv19673/src/org/junit/samples

Log Message:
Directory /cvsroot/junit/junit/src/org/junit/samples added to the repository