[Junit-devel] CVS: junit/src/org/junit Ignore.java, 1.1, 1.2 Assert.java, 1.2, 1.3

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

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

Modified Files:
	Ignore.java Assert.java 
Log Message:
Can @Ignore classes
assertArrayEquals added


Index: Ignore.java
===================================================================
RCS file: /cvsroot/junit/junit/src/org/junit/Ignore.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- Ignore.java	21 Nov 2006 18:53:34 -0000	1.1
+++ Ignore.java	24 Jan 2007 16:32:59 -0000	1.2
@@ -22,7 +22,7 @@
  *
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
+@Target({ElementType.METHOD, ElementType.TYPE})
 public @interface Ignore {
 	/**
 	 * The optional reason why the test is ignored.

Index: Assert.java
===================================================================
RCS file: /cvsroot/junit/junit/src/org/junit/Assert.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- Assert.java	21 Nov 2006 19:52:30 -0000	1.2
+++ Assert.java	24 Jan 2007 16:32:59 -0000	1.3
@@ -1,5 +1,7 @@
 package org.junit;
 
+import java.lang.reflect.Array;
+
 import org.junit.internal.ArrayComparisonFailure;
 
 /**
@@ -87,7 +89,7 @@
 	static public void assertEquals(String message, Object expected, Object actual) {
 		if (expected == null && actual == null)
 			return;
-		if (expected != null && expected.equals(actual))
+		if (expected != null && isEquals(expected, actual))
 			return;
 		else if (expected instanceof String && actual instanceof String) {
 			String cleanMessage= message == null ? "" : message;
@@ -97,6 +99,12 @@
 			failNotEquals(message, expected, actual);
 	}
 
+	private static boolean isEquals(Object expected, Object actual) {
+		if (expected instanceof Number && actual instanceof Number)
+			return ((Number) expected).longValue() == ((Number) actual).longValue();
+		return expected.equals(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>
@@ -116,38 +124,11 @@
 	 * @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);
-				}
-		}
+	public static void assertArrayEquals(String message, Object[] expecteds,
+			Object[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
 	}
-
+	
 	/**
 	 * 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>, 
@@ -155,87 +136,183 @@
 	 * @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);
+	public static void assertArrayEquals(Object[] expecteds, Object[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
 
 	/**
-	 * Asserts that two longs are equal. If they are not
-	 * an {@link AssertionError} is thrown with the given message.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-	static public void assertEquals(String message, long expected, long actual) {
-	    assertEquals(message, Long.valueOf(expected), Long.valueOf(actual));
+	public static void assertArrayEquals(String message, byte[] expecteds,
+			byte[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
+	}
+
+	/**
+	 * TODO: fix javadoc
+	 * 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 assertArrayEquals(byte[] expecteds, byte[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
 	
 	/**
-	 * Asserts that two longs are equal.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-	static public void assertEquals(long expected, long actual) {
-	    assertEquals(null, expected, actual);
+	public static void assertArrayEquals(String message, char[] expecteds,
+			char[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
+	}
+
+	/**
+	 * TODO: fix javadoc
+	 * 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 assertArrayEquals(char[] expecteds, char[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
 	
 	/**
-	 * Asserts that two bytes are equal. If they are not
-	 * an {@link AssertionError} is thrown with the given message.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-  	static public void assertEquals(String message, byte expected, byte actual) {
-		assertEquals(message, Byte.valueOf(expected), Byte.valueOf(actual));
+	public static void assertArrayEquals(String message, short[] expecteds,
+			short[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
 	}
-  	
+
 	/**
-   	 * Asserts that two bytes are equal.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-	static public void assertEquals(byte expected, byte actual) {
-		assertEquals(null, expected, actual);
+	public static void assertArrayEquals(short[] expecteds, short[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
 	
 	/**
-	 * Asserts that two chars are equal. If they are not
-	 * an {@link AssertionError} is thrown with the given message.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-  	static public void assertEquals(String message, char expected, char actual) {
-    		assertEquals(message, Character.valueOf(expected), Character.valueOf(actual));
-  	}
-  	
+	public static void assertArrayEquals(String message, int[] expecteds,
+			int[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
+	}
+
 	/**
-	 * Asserts that two chars are equal.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-  	static public void assertEquals(char expected, char actual) {
-		assertEquals(null, expected, actual);
+	public static void assertArrayEquals(int[] expecteds, int[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
-  	
+
 	/**
-	 * Asserts that two shorts are equal. If they are not
-	 * an {@link AssertionError} is thrown with the given message.
+	 * TODO: fix javadoc
+	 * 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
 	 */
-	static public void assertEquals(String message, short expected, short actual) {
-    		assertEquals(message, Short.valueOf(expected), Short.valueOf(actual));
+	public static void assertArrayEquals(long[] expecteds, long[] actuals) {
+		assertArrayEquals(null, expecteds, actuals);
 	}
 	
-  	/**
-	 * Asserts that two shorts are equal.
+	/**
+	 * TODO: fix javadoc
+	 * 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
 	 */
-	static public void assertEquals(short expected, short actual) {
-		assertEquals(null, expected, actual);
+	public static void assertArrayEquals(String message, long[] expecteds,
+			long[] actuals) throws ArrayComparisonFailure {
+		internalArrayEquals(message, expecteds, actuals);
 	}
 	
 	/**
-	 * Asserts that two ints are equal. If they are not
-	 * an {@link AssertionError} is thrown with the given message.
-	 */
-  	static public void assertEquals(String message, int expected, int actual) {
-		assertEquals(message, Integer.valueOf(expected), Integer.valueOf(actual));
-  	}
-  	
-  	/**
-   	 * Asserts that two ints are equal.
+	 * 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
 	 */
-  	static public void assertEquals(int expected, int actual) {
-  		assertEquals(null, expected, actual);
-	}
+	private static void internalArrayEquals(String message, Object expecteds,
+			Object actuals) throws ArrayComparisonFailure {
+		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");
+		int actualsLength= Array.getLength(actuals);
+		int expectedsLength= Array.getLength(expecteds);
+		if (actualsLength != expectedsLength)
+			fail(header + "array lengths differed, expected.length=" + expectedsLength + " actual.length=" + actualsLength);
 	
+		for (int i= 0; i < expectedsLength; i++) {
+			Object expected= Array.get(expecteds, i);
+			Object actual= Array.get(actuals, i);
+			if (expected.getClass().isArray() && actual.getClass().isArray()) {
+				try {
+					internalArrayEquals(message, expected, actual);
+				} catch (ArrayComparisonFailure e) {
+					e.addDimension(i);
+					throw e;
+				}
+			} else
+				try {
+					assertEquals(expected, actual);
+				} catch (AssertionError e) {
+					throw new ArrayComparisonFailure(header, e, i);
+				}
+		}
+	}
+
 	/**
-	 * Asserts that two doubles are equal to within a positive delta. If they
+	 * Asserts that two doubles or 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:
@@ -254,7 +331,7 @@
 	}
 
 	/**
-	 * Asserts that two doubles are equal to within a positive delta. If they
+	 * Asserts that two doubles or 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.NaNs are
 	 * considered equal:
@@ -269,40 +346,6 @@
 	}
 
 	/**
-	 * 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}
@@ -411,4 +454,31 @@
 		return formatted + "expected:<" + expected + "> but was:<" + 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
+	 * @deprecated use assertArrayEquals
+	 */
+	@Deprecated
+	public static void assertEquals(String message, Object[] expecteds, Object[] actuals) {
+		assertArrayEquals(message, expecteds, actuals);
+	}
+
+	/**
+	 * 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
+	 * @deprecated use assertArrayEquals
+	 */
+	@Deprecated
+	public static void assertEquals(Object[] expecteds, Object[] actuals) {
+		assertArrayEquals(expecteds, actuals);
+	}
+
 }