Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Merge pull request #500 from awulder/issue-473

Issue #473 Implemented suggestions by kcooney
  • Loading branch information...
commit b9e14f64327e052e161c451bc2eaa854c9adcea4 2 parents a01caef + dde798f
@dsaff dsaff authored
View
54 src/main/java/junit/framework/Assert.java
@@ -2,8 +2,10 @@
/**
* A set of assert methods. Messages are only displayed when an assert fails.
+ *
+ * @deprecated Please use {@link org.junit.Assert} instead.
*/
-
+@Deprecated
public class Assert {
/**
* Protect constructor since it is a static only class
@@ -71,7 +73,7 @@ static public void assertEquals(String message, Object expected, Object actual)
* an AssertionFailedError is thrown.
*/
static public void assertEquals(Object expected, Object actual) {
- assertEquals(null, expected, actual);
+ assertEquals(null, expected, actual);
}
/**
* Asserts that two Strings are equal.
@@ -88,7 +90,7 @@ static public void assertEquals(String message, String expected, String actual)
* Asserts that two Strings are equal.
*/
static public void assertEquals(String expected, String actual) {
- assertEquals(null, expected, actual);
+ assertEquals(null, expected, actual);
}
/**
* Asserts that two doubles are equal concerning a delta. If they are not
@@ -106,7 +108,7 @@ static public void assertEquals(String message, double expected, double actual,
* value is infinity then the delta value is ignored.
*/
static public void assertEquals(double expected, double actual, double delta) {
- assertEquals(null, expected, actual, delta);
+ assertEquals(null, expected, actual, delta);
}
/**
* Asserts that two floats are equal concerning a positive delta. If they
@@ -117,7 +119,7 @@ static public void assertEquals(String message, float expected, float actual, fl
if (Float.compare(expected, actual) == 0)
return;
if (!(Math.abs(expected - actual) <= delta))
- failNotEquals(message, new Float(expected), new Float(actual));
+ failNotEquals(message, new Float(expected), new Float(actual));
}
/**
* Asserts that two floats are equal concerning a delta. If the expected
@@ -131,24 +133,24 @@ static public void assertEquals(float expected, float actual, float delta) {
* an AssertionFailedError is thrown with the given message.
*/
static public void assertEquals(String message, long expected, long actual) {
- assertEquals(message, new Long(expected), new Long(actual));
+ assertEquals(message, new Long(expected), new Long(actual));
}
/**
* Asserts that two longs are equal.
*/
static public void assertEquals(long expected, long actual) {
- assertEquals(null, expected, actual);
+ assertEquals(null, expected, actual);
}
/**
* Asserts that two booleans are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
static public void assertEquals(String message, boolean expected, boolean actual) {
- assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
- }
+ assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
+ }
/**
* Asserts that two booleans are equal.
- */
+ */
static public void assertEquals(boolean expected, boolean actual) {
assertEquals(null, expected, actual);
}
@@ -156,11 +158,11 @@ static public void assertEquals(boolean expected, boolean actual) {
* Asserts that two bytes are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
- static public void assertEquals(String message, byte expected, byte actual) {
+ static public void assertEquals(String message, byte expected, byte actual) {
assertEquals(message, new Byte(expected), new Byte(actual));
}
/**
- * Asserts that two bytes are equal.
+ * Asserts that two bytes are equal.
*/
static public void assertEquals(byte expected, byte actual) {
assertEquals(null, expected, actual);
@@ -169,13 +171,13 @@ static public void assertEquals(byte expected, byte actual) {
* Asserts that two chars are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
- static public void assertEquals(String message, char expected, char actual) {
- assertEquals(message, new Character(expected), new Character(actual));
- }
+ static public void assertEquals(String message, char expected, char actual) {
+ assertEquals(message, new Character(expected), new Character(actual));
+ }
/**
* Asserts that two chars are equal.
*/
- static public void assertEquals(char expected, char actual) {
+ static public void assertEquals(char expected, char actual) {
assertEquals(null, expected, actual);
}
/**
@@ -183,9 +185,9 @@ static public void assertEquals(char expected, char actual) {
* an AssertionFailedError is thrown with the given message.
*/
static public void assertEquals(String message, short expected, short actual) {
- assertEquals(message, new Short(expected), new Short(actual));
+ assertEquals(message, new Short(expected), new Short(actual));
}
- /**
+ /**
* Asserts that two shorts are equal.
*/
static public void assertEquals(short expected, short actual) {
@@ -195,14 +197,14 @@ static public void assertEquals(short expected, short actual) {
* Asserts that two ints are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
- static public void assertEquals(String message, int expected, int actual) {
+ static public void assertEquals(String message, int expected, int actual) {
assertEquals(message, new Integer(expected), new Integer(actual));
- }
- /**
- * Asserts that two ints are equal.
+ }
+ /**
+ * Asserts that two ints are equal.
*/
- static public void assertEquals(int expected, int actual) {
- assertEquals(null, expected, actual);
+ static public void assertEquals(int expected, int actual) {
+ assertEquals(null, expected, actual);
}
/**
* Asserts that an object isn't null.
@@ -221,7 +223,7 @@ static public void assertNotNull(String message, Object object) {
* Asserts that an object is null. If it isn't an {@link AssertionError} is
* thrown.
* Message contains: Expected: <null> but was: object
- *
+ *
* @param object
* Object to check or <code>null</code>
*/
@@ -250,7 +252,7 @@ static public void assertSame(String message, Object expected, Object actual) {
* the same an AssertionFailedError is thrown.
*/
static public void assertSame(Object expected, Object actual) {
- assertSame(null, expected, actual);
+ assertSame(null, expected, actual);
}
/**
* Asserts that two objects do not refer to the same object. If they do
View
372 src/main/java/junit/framework/TestCase.java
@@ -36,7 +36,7 @@
* assertTrue(result == 5.0);
* }
* </pre>
- *
+ *
* Once the methods are defined you can run them. The framework supports
* both a static type safe and more dynamic way to run a test.
* In the static way you override the runTest method and define the method to
@@ -49,7 +49,6 @@
* };
* test.run();
* </pre>
- *
* The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
* and invokes a method.
* In this case the name of the test case has to correspond to the test method
@@ -58,7 +57,7 @@
* TestCase test= new MathTest("testAdd");
* test.run();
* </pre>
- *
+ *
* The tests to be run can be collected into a TestSuite. JUnit provides
* different <i>test runners</i> which can run a test suite and collect the results.
* A test runner either expects a static method <code>suite</code> as the entry
@@ -70,6 +69,7 @@
* return suite;
* }
* </pre>
+ *
* @see TestResult
* @see TestSuite
*/
@@ -86,26 +86,30 @@
public TestCase() {
fName= null;
}
+
/**
* Constructs a test case with the given name.
*/
public TestCase(String name) {
fName= name;
}
+
/**
* Counts the number of test cases executed by run(TestResult result).
*/
public int countTestCases() {
return 1;
}
+
/**
* Creates a default TestResult object
*
* @see TestResult
*/
protected TestResult createResult() {
- return new TestResult();
+ return new TestResult();
}
+
/**
* A convenience method to run this test, collecting the results with a
* default TestResult object.
@@ -117,14 +121,17 @@ public TestResult run() {
run(result);
return result;
}
+
/**
* Runs the test case and collects the results in TestResult.
*/
public void run(TestResult result) {
result.run(this);
}
+
/**
* Runs the bare test sequence.
+ *
* @throws Throwable if any exception is thrown
*/
public void runBare() throws Throwable {
@@ -132,20 +139,21 @@ public void runBare() throws Throwable {
setUp();
try {
runTest();
- } catch (Throwable running) {
- exception= running;
- }
- finally {
+ } catch(Throwable running) {
+ exception = running;
+ } finally {
try {
tearDown();
- } catch (Throwable tearingDown) {
- if (exception == null) exception= tearingDown;
+ } catch(Throwable tearingDown) {
+ if (exception == null) exception = tearingDown;
}
}
if (exception != null) throw exception;
}
+
/**
* Override to run the test and assert its state.
+ *
* @throws Throwable if any exception is thrown
*/
protected void runTest() throws Throwable {
@@ -156,54 +164,380 @@ protected void runTest() throws Throwable {
// methods. getDeclaredMethods returns all
// methods of this class but excludes the
// inherited ones.
- runMethod= getClass().getMethod(fName, (Class[])null);
- } catch (NoSuchMethodException e) {
- fail("Method \""+fName+"\" not found");
+ runMethod = getClass().getMethod(fName, (Class[]) null);
+ } catch(NoSuchMethodException e) {
+ fail("Method \"" + fName + "\" not found");
}
if (!Modifier.isPublic(runMethod.getModifiers())) {
- fail("Method \""+fName+"\" should be public");
+ fail("Method \"" + fName + "\" should be public");
}
try {
runMethod.invoke(this);
- }
- catch (InvocationTargetException e) {
+ } catch(InvocationTargetException e) {
e.fillInStackTrace();
throw e.getTargetException();
- }
- catch (IllegalAccessException e) {
+ } catch(IllegalAccessException e) {
e.fillInStackTrace();
throw e;
}
}
+
+ /**
+ * Asserts that a condition is true. If it isn't it throws
+ * an AssertionFailedError with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertTrue(String message, boolean condition) {
+ Assert.assertTrue(message, condition);
+ }
+
+ /**
+ * Asserts that a condition is true. If it isn't it throws
+ * an AssertionFailedError.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertTrue(boolean condition) {
+ Assert.assertTrue(condition);
+ }
+
+ /**
+ * Asserts that a condition is false. If it isn't it throws
+ * an AssertionFailedError with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertFalse(String message, boolean condition) {
+ Assert.assertFalse(message, condition);
+ }
+
+ /**
+ * Asserts that a condition is false. If it isn't it throws
+ * an AssertionFailedError.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertFalse(boolean condition) {
+ Assert.assertFalse(condition);
+ }
+
+ /**
+ * Fails a test with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void fail(String message) {
+ Assert.fail(message);
+ }
+
+ /**
+ * Fails a test with no message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void fail() {
+ Assert.fail();
+ }
+
+ /**
+ * Asserts that two objects are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, Object expected, Object actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two objects are equal. If they are not
+ * an AssertionFailedError is thrown.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(Object expected, Object actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two Strings are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, String expected, String actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two Strings are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String expected, String actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two doubles are equal concerning a delta. If they are not
+ * an AssertionFailedError is thrown with the given message. If the expected
+ * value is infinity then the delta value is ignored.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, double expected, double actual, double delta) {
+ Assert.assertEquals(message, expected, actual, delta);
+ }
+
+ /**
+ * Asserts that two doubles are equal concerning a delta. If the expected
+ * value is infinity then the delta value is ignored.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(double expected, double actual, double delta) {
+ Assert.assertEquals(expected, actual, delta);
+ }
+
+ /**
+ * Asserts that two floats are equal concerning a positive delta. If they
+ * are not an AssertionFailedError is thrown with the given message. If the
+ * expected value is infinity then the delta value is ignored.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, float expected, float actual, float delta) {
+ Assert.assertEquals(message, expected, actual, delta);
+ }
+
+ /**
+ * Asserts that two floats are equal concerning a delta. If the expected
+ * value is infinity then the delta value is ignored.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(float expected, float actual, float delta) {
+ Assert.assertEquals(expected, actual, delta);
+ }
+
+ /**
+ * Asserts that two longs are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, long expected, long actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two longs are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(long expected, long actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two booleans are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, boolean expected, boolean actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two booleans are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(boolean expected, boolean actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two bytes are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, byte expected, byte actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two bytes are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(byte expected, byte actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two chars are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, char expected, char actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two chars are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(char expected, char actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two shorts are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, short expected, short actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two shorts are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(short expected, short actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that two ints are equal. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(String message, int expected, int actual) {
+ Assert.assertEquals(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two ints are equal.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertEquals(int expected, int actual) {
+ Assert.assertEquals(expected, actual);
+ }
+
+ /**
+ * Asserts that an object isn't null.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNotNull(Object object) {
+ Assert.assertNotNull(object);
+ }
+
+ /**
+ * Asserts that an object isn't null. If it is
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNotNull(String message, Object object) {
+ Assert.assertNotNull(message, object);
+ }
+
+ /**
+ * Asserts that an object is null. If it isn't an {@link AssertionError} is
+ * thrown.
+ * Message contains: Expected: <null> but was: object
+ *
+ * @param object Object to check or <code>null</code>
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNull(Object object) {
+ Assert.assertNull(object);
+ }
+
+ /**
+ * Asserts that an object is null. If it is not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNull(String message, Object object) {
+ Assert.assertNull(message, object);
+ }
+
+ /**
+ * Asserts that two objects refer to the same object. If they are not
+ * an AssertionFailedError is thrown with the given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertSame(String message, Object expected, Object actual) {
+ Assert.assertSame(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two objects refer to the same object. If they are not
+ * the same an AssertionFailedError is thrown.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertSame(Object expected, Object actual) {
+ Assert.assertSame(expected, actual);
+ }
+
+ /**
+ * Asserts that two objects do not refer to the same object. If they do
+ * refer to the same object an AssertionFailedError is thrown with the
+ * given message.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNotSame(String message, Object expected, Object actual) {
+ Assert.assertNotSame(message, expected, actual);
+ }
+
+ /**
+ * Asserts that two objects do not refer to the same object. If they do
+ * refer to the same object an AssertionFailedError is thrown.
+ */
+ @SuppressWarnings("deprecation")
+ public static void assertNotSame(Object expected, Object actual) {
+ Assert.assertNotSame(expected, actual);
+ }
+
+ @SuppressWarnings("deprecation")
+ public static void failSame(String message) {
+ Assert.failSame(message);
+ }
+
+ @SuppressWarnings("deprecation")
+ public static void failNotSame(String message, Object expected, Object actual) {
+ Assert.failNotSame(message, expected, actual);
+ }
+
+ @SuppressWarnings("deprecation")
+ public static void failNotEquals(String message, Object expected, Object actual) {
+ Assert.failNotEquals(message, expected, actual);
+ }
+
+ @SuppressWarnings("deprecation")
+ public static String format(String message, Object expected, Object actual) {
+ return Assert.format(message, expected, actual);
+ }
+
/**
* Sets up the fixture, for example, open a network connection.
* This method is called before a test is executed.
*/
protected void setUp() throws Exception {
}
+
/**
* Tears down the fixture, for example, close a network connection.
* This method is called after a test is executed.
*/
protected void tearDown() throws Exception {
}
+
/**
* Returns a string representation of the test case
*/
@Override
public String toString() {
- return getName() + "(" + getClass().getName() + ")";
+ return getName() + "(" + getClass().getName() + ")";
}
+
/**
* Gets the name of a TestCase
+ *
* @return the name of the TestCase
*/
public String getName() {
return fName;
}
+
/**
* Sets the name of a TestCase
+ *
* @param name the name to set
*/
public void setName(String name) {

0 comments on commit b9e14f6

Please sign in to comment.
Something went wrong with that request. Please try again.