1berry/openjdk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

8035889: jdk testlibrary - add printing of values of failed assertions

Browse Source 
Extend and cleanup testlibrary

Reviewed-by: mchung, sla
This commit is contained in:
Roger Riggs 2014-02-28 13:36:46 -05:00
parent c92ff7d5e7
commit e112d0032d
2 changed files with 277 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
jdk/test/lib/testlibrary/AssertsTest.java
View File

@ -25,7 +25,6 @@ import static jdk.testlibrary.Asserts.*;
/* @test /* @test
* @summary Tests the different assertions in the Assert class * @summary Tests the different assertions in the Assert class
* @library /testlibrary
*/ */
public class AssertsTest { public class AssertsTest {
private static class Foo implements Comparable<Foo> { private static class Foo implements Comparable<Foo> {
@ -37,6 +36,9 @@ public class AssertsTest {
public int compareTo(Foo f) { public int compareTo(Foo f) {
return new Integer(id).compareTo(new Integer(f.id)); return new Integer(id).compareTo(new Integer(f.id));
} }
public String toString() {
return "Foo(" + Integer.toString(id) + ")";
}
} }
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
@ -50,6 +52,7 @@ public class AssertsTest {
testNotNull(); testNotNull();
testTrue(); testTrue();
testFalse(); testFalse();
testFail();
} }
private static void testLessThan() throws Exception { private static void testLessThan() throws Exception {
@ -72,7 +75,7 @@ public class AssertsTest {
private static void testEquals() throws Exception { private static void testEquals() throws Exception {
expectPass(Assertion.EQ, 1, 1); expectPass(Assertion.EQ, 1, 1);
expectPass(Assertion.EQ, null, null); expectPass(Assertion.EQ, (Comparable)null, (Comparable)null);
Foo f1 = new Foo(1); Foo f1 = new Foo(1);
expectPass(Assertion.EQ, f1, f1); expectPass(Assertion.EQ, f1, f1);
@ -109,13 +112,13 @@ public class AssertsTest {
Foo f2 = new Foo(1); Foo f2 = new Foo(1);
expectPass(Assertion.NE, f1, f2); expectPass(Assertion.NE, f1, f2);
expectFail(Assertion.NE, null, null); expectFail(Assertion.NE, (Comparable)null, (Comparable)null);
expectFail(Assertion.NE, f1, f1); expectFail(Assertion.NE, f1, f1);
expectFail(Assertion.NE, 1, 1); expectFail(Assertion.NE, 1, 1);
} }
private static void testNull() throws Exception { private static void testNull() throws Exception {
expectPass(Assertion.NULL, null); expectPass(Assertion.NULL, (Comparable)null);
expectFail(Assertion.NULL, 1); expectFail(Assertion.NULL, 1);
} }
@ -123,7 +126,7 @@ public class AssertsTest {
private static void testNotNull() throws Exception { private static void testNotNull() throws Exception {
expectPass(Assertion.NOTNULL, 1); expectPass(Assertion.NOTNULL, 1);
expectFail(Assertion.NOTNULL, null); expectFail(Assertion.NOTNULL, (Comparable)null);
} }
private static void testTrue() throws Exception { private static void testTrue() throws Exception {
@ -138,6 +141,36 @@ public class AssertsTest {
expectFail(Assertion.FALSE, true); expectFail(Assertion.FALSE, true);
} }
private static void testFail() throws Exception {
try {
fail();
} catch (RuntimeException re) {
assertEquals("fail", re.getMessage());
}
try {
fail("Failure");
} catch (RuntimeException re) {
assertEquals("Failure", re.getMessage());
}
Exception e = new Exception("the cause");
try {
fail("Fail w/ cause", e);
} catch (RuntimeException re) {
assertEquals("Fail w/ cause", re.getMessage());
assertEquals(e, re.getCause(), "Cause mismatch");
}
try {
fail(1, 2, "Different", "vs");
} catch (RuntimeException re) {
assertEquals("Different <1> vs <2>", re.getMessage());
}
}
private static <T extends Comparable<T>> void expectPass(Assertion assertion, T ... args) private static <T extends Comparable<T>> void expectPass(Assertion assertion, T ... args)
throws Exception { throws Exception {
Assertion.run(assertion, args); Assertion.run(assertion, args);

339
jdk/test/lib/testlibrary/jdk/testlibrary/Asserts.java
View File

@ -23,16 +23,17 @@
package jdk.testlibrary; package jdk.testlibrary;
import java.util.Objects;
/** /**
* Asserts that can be used for verifying assumptions in tests. * Asserts that can be used for verifying assumptions in tests.
* *
* An assertion will throw a {@link RuntimeException} if the assertion isn't * An assertion will throw a {@link RuntimeException} if the assertion isn't true.
* valid. All the asserts can be imported into a test by using a static * All the asserts can be imported into a test by using a static import:
* import:
* *
* <pre> * <pre>
* {@code * {@code
* import static com.oracle.java.testlibrary.Asserts.*; * import static jdk.testlibrary.Asserts.*;
* } * }
* *
* Always provide a message describing the assumption if the line number of the * Always provide a message describing the assumption if the line number of the
@ -45,111 +46,147 @@ package jdk.testlibrary;
public class Asserts { public class Asserts {
/** /**
* Shorthand for {@link #assertLessThan(T, T)}. * Shorthand for {@link #assertLessThan(Comparable, Comparable)}.
* *
* @see #assertLessThan(T, T) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertLessThan(Comparable, Comparable)
*/ */
public static <T extends Comparable<T>> void assertLT(T lhs, T rhs) { public static <T extends Comparable<T>> void assertLT(T lhs, T rhs) {
assertLessThan(lhs, rhs); assertLessThan(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertLessThan(T, T, String)}. * Shorthand for {@link #assertLessThan(Comparable, Comparable, String)}.
* *
* @see #assertLessThan(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertLessThan(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertLT(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertLT(T lhs, T rhs, String msg) {
assertLessThan(lhs, rhs, msg); assertLessThan(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertLessThan(T, T, String)} with a default message. * Calls {@link #assertLessThan(Comparable, Comparable, String)} with a default message.
* *
* @see #assertLessThan(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertLessThan(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertLessThan(T lhs, T rhs) { public static <T extends Comparable<T>> void assertLessThan(T lhs, T rhs) {
String msg = "Expected that " + format(lhs) + " < " + format(rhs); assertLessThan(lhs, rhs, null);
assertLessThan(lhs, rhs, msg);
} }
/** /**
* Asserts that {@code lhs} is less than {@code rhs}. * Asserts that {@code lhs} is less than {@code rhs}.
* *
* @param <T> a type
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static <T extends Comparable<T>>void assertLessThan(T lhs, T rhs, String msg) { public static <T extends Comparable<T>>void assertLessThan(T lhs, T rhs, String msg) {
assertTrue(compare(lhs, rhs, msg) < 0, msg); if (!(compare(lhs, rhs, msg) < 0)) {
msg = Objects.toString(msg, "assertLessThan")
+ ": expected that " + Objects.toString(lhs)
+ " < " + Objects.toString(rhs);
fail(msg);
}
} }
/** /**
* Shorthand for {@link #assertLessThanOrEqual(T, T)}. * Shorthand for {@link #assertLessThanOrEqual(Comparable, Comparable)}.
* *
* @see #assertLessThanOrEqual(T, T) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertLessThanOrEqual(Comparable, Comparable)
*/ */
public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs) { public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs) {
assertLessThanOrEqual(lhs, rhs); assertLessThanOrEqual(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertLessThanOrEqual(T, T, String)}. * Shorthand for {@link #assertLessThanOrEqual(Comparable, Comparable, String)}.
* *
* @see #assertLessThanOrEqual(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertLessThanOrEqual(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs, String msg) {
assertLessThanOrEqual(lhs, rhs, msg); assertLessThanOrEqual(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertLessThanOrEqual(T, T, String)} with a default message. * Calls {@link #assertLessThanOrEqual(Comparable, Comparable, String)} with a default message.
* *
* @see #assertLessThanOrEqual(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertLessThanOrEqual(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs) { public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs) {
String msg = "Expected that " + format(lhs) + " <= " + format(rhs); assertLessThanOrEqual(lhs, rhs, null);
assertLessThanOrEqual(lhs, rhs, msg);
} }
/** /**
* Asserts that {@code lhs} is less than or equal to {@code rhs}. * Asserts that {@code lhs} is less than or equal to {@code rhs}.
* *
* @param <T> a type
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs, String msg) {
assertTrue(compare(lhs, rhs, msg) <= 0, msg); if (!(compare(lhs, rhs, msg) <= 0)) {
msg = Objects.toString(msg, "assertLessThanOrEqual")
+ ": expected that " + Objects.toString(lhs)
+ " <= " + Objects.toString(rhs);
fail(msg);
}
} }
/** /**
* Shorthand for {@link #assertEquals(T, T)}. * Shorthand for {@link #assertEquals(Object, Object)}.
* *
* @see #assertEquals(T, T) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertEquals(Object, Object)
*/ */
public static void assertEQ(Object lhs, Object rhs) { public static void assertEQ(Object lhs, Object rhs) {
assertEquals(lhs, rhs); assertEquals(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertEquals(T, T, String)}. * Shorthand for {@link #assertEquals(Object, Object, String)}.
* *
* @see #assertEquals(T, T, String) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertEquals(Object, Object, String)
*/ */
public static void assertEQ(Object lhs, Object rhs, String msg) { public static void assertEQ(Object lhs, Object rhs, String msg) {
assertEquals(lhs, rhs, msg); assertEquals(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertEquals(T, T, String)} with a default message. * Calls {@link #assertEquals(java.lang.Object, java.lang.Object, java.lang.String)} with a default message.
* *
* @see #assertEquals(T, T, String) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertEquals(Object, Object, String)
*/ */
public static void assertEquals(Object lhs, Object rhs) { public static void assertEquals(Object lhs, Object rhs) {
String msg = "Expected " + format(lhs) + " to equal " + format(rhs); assertEquals(lhs, rhs, null);
assertEquals(lhs, rhs, msg);
} }
/** /**
@ -157,125 +194,160 @@ public class Asserts {
* *
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertEquals(Object lhs, Object rhs, String msg) { public static void assertEquals(Object lhs, Object rhs, String msg) {
if (lhs == null) { if ((lhs != rhs) && ((lhs == null) || !(lhs.equals(rhs)))) {
if (rhs != null) { msg = Objects.toString(msg, "assertEquals")
error(msg); + ": expected " + Objects.toString(lhs)
} + " to equal " + Objects.toString(rhs);
} else { fail(msg);
assertTrue(lhs.equals(rhs), msg);
} }
} }
/** /**
* Shorthand for {@link #assertGreaterThanOrEqual(T, T)}. * Shorthand for {@link #assertGreaterThanOrEqual(Comparable, Comparable)}.
* *
* @see #assertGreaterThanOrEqual(T, T) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertGreaterThanOrEqual(Comparable, Comparable)
*/ */
public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs) { public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs) {
assertGreaterThanOrEqual(lhs, rhs); assertGreaterThanOrEqual(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertGreaterThanOrEqual(T, T, String)}. * Shorthand for {@link #assertGreaterThanOrEqual(Comparable, Comparable, String)}.
* *
* @see #assertGreaterThanOrEqual(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertGreaterThanOrEqual(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs, String msg) {
assertGreaterThanOrEqual(lhs, rhs, msg); assertGreaterThanOrEqual(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertGreaterThanOrEqual(T, T, String)} with a default message. * Calls {@link #assertGreaterThanOrEqual(Comparable, Comparable, String)} with a default message.
* *
* @see #assertGreaterThanOrEqual(T, T, String) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertGreaterThanOrEqual(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs) { public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs) {
String msg = "Expected that " + format(lhs) + " >= " + format(rhs); assertGreaterThanOrEqual(lhs, rhs, null);
assertGreaterThanOrEqual(lhs, rhs, msg);
} }
/** /**
* Asserts that {@code lhs} is greater than or equal to {@code rhs}. * Asserts that {@code lhs} is greater than or equal to {@code rhs}.
* *
* @param <T> a type
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs, String msg) {
assertTrue(compare(lhs, rhs, msg) >= 0, msg); if (!(compare(lhs, rhs, msg) >= 0)) {
msg = Objects.toString(msg, "assertGreaterThanOrEqual")
+ ": expected " + Objects.toString(lhs)
+ " >= " + Objects.toString(rhs);
fail(msg);
}
} }
/** /**
* Shorthand for {@link #assertGreaterThan(T, T)}. * Shorthand for {@link #assertGreaterThan(Comparable, Comparable)}.
* *
* @see #assertGreaterThan(T, T) * @param <T> a type
* @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertGreaterThan(Comparable, Comparable)
*/ */
public static <T extends Comparable<T>> void assertGT(T lhs, T rhs) { public static <T extends Comparable<T>> void assertGT(T lhs, T rhs) {
assertGreaterThan(lhs, rhs); assertGreaterThan(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertGreaterThan(T, T, String)}. * Shorthand for {@link #assertGreaterThan(Comparable, Comparable, String)}.
* *
* @see #assertGreaterThan(T, T, String) * @param <T> a type
* @param lhs the left hand value
* @param rhs the right hand value
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertGreaterThan(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertGT(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertGT(T lhs, T rhs, String msg) {
assertGreaterThan(lhs, rhs, msg); assertGreaterThan(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertGreaterThan(T, T, String)} with a default message. * Calls {@link #assertGreaterThan(Comparable, Comparable, String)} with a default message.
* *
* @see #assertGreaterThan(T, T, String) * @param <T> a type
* @param lhs the left hand value
* @param rhs the right hand value
* @see #assertGreaterThan(Comparable, Comparable, String)
*/ */
public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs) { public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs) {
String msg = "Expected that " + format(lhs) + " > " + format(rhs); assertGreaterThan(lhs, rhs, null);
assertGreaterThan(lhs, rhs, msg);
} }
/** /**
* Asserts that {@code lhs} is greater than {@code rhs}. * Asserts that {@code lhs} is greater than {@code rhs}.
* *
* @param <T> a type
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs, String msg) { public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs, String msg) {
assertTrue(compare(lhs, rhs, msg) > 0, msg); if (!(compare(lhs, rhs, msg) > 0)) {
msg = Objects.toString(msg, "assertGreaterThan")
+ ": expected " + Objects.toString(lhs)
+ " > " + Objects.toString(rhs);
fail(msg);
}
} }
/** /**
* Shorthand for {@link #assertNotEquals(T, T)}. * Shorthand for {@link #assertNotEquals(Object, Object)}.
* *
* @see #assertNotEquals(T, T) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertNotEquals(Object, Object)
*/ */
public static void assertNE(Object lhs, Object rhs) { public static void assertNE(Object lhs, Object rhs) {
assertNotEquals(lhs, rhs); assertNotEquals(lhs, rhs);
} }
/** /**
* Shorthand for {@link #assertNotEquals(T, T, String)}. * Shorthand for {@link #assertNotEquals(Object, Object, String)}.
* *
* @see #assertNotEquals(T, T, String) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @param msg A description of the assumption; {@code null} for a default message.
* @see #assertNotEquals(Object, Object, String)
*/ */
public static void assertNE(Object lhs, Object rhs, String msg) { public static void assertNE(Object lhs, Object rhs, String msg) {
assertNotEquals(lhs, rhs, msg); assertNotEquals(lhs, rhs, msg);
} }
/** /**
* Calls {@link #assertNotEquals(T, T, String)} with a default message. * Calls {@link #assertNotEquals(Object, Object, String)} with a default message.
* *
* @see #assertNotEquals(T, T, String) * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison.
* @see #assertNotEquals(Object, Object, String)
*/ */
public static void assertNotEquals(Object lhs, Object rhs) { public static void assertNotEquals(Object lhs, Object rhs) {
String msg = "Expected " + format(lhs) + " to not equal " + format(rhs); assertNotEquals(lhs, rhs, null);
assertNotEquals(lhs, rhs, msg);
} }
/** /**
@ -283,34 +355,34 @@ public class Asserts {
* *
* @param lhs The left hand side of the comparison. * @param lhs The left hand side of the comparison.
* @param rhs The right hand side of the comparison. * @param rhs The right hand side of the comparison.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertNotEquals(Object lhs, Object rhs, String msg) { public static void assertNotEquals(Object lhs, Object rhs, String msg) {
if (lhs == null) { if ((lhs == rhs) || (lhs != null && lhs.equals(rhs))) {
if (rhs == null) { msg = Objects.toString(msg, "assertNotEquals")
error(msg); + ": expected " + Objects.toString(lhs)
} + " to not equal " + Objects.toString(rhs);
} else { fail(msg);
assertFalse(lhs.equals(rhs), msg);
} }
} }
/** /**
* Calls {@link #assertNull(Object, String)} with a default message. * Calls {@link #assertNull(Object, String)} with a default message.
* *
* @param o The reference assumed to be null.
* @see #assertNull(Object, String) * @see #assertNull(Object, String)
*/ */
public static void assertNull(Object o) { public static void assertNull(Object o) {
assertNull(o, "Expected " + format(o) + " to be null"); assertNull(o, null);
} }
/** /**
* Asserts that {@code o} is null. * Asserts that {@code o} is null.
* *
* @param o The reference assumed to be null. * @param o The reference assumed to be null.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertNull(Object o, String msg) { public static void assertNull(Object o, String msg) {
assertEquals(o, null, msg); assertEquals(o, null, msg);
@ -319,18 +391,19 @@ public class Asserts {
/** /**
* Calls {@link #assertNotNull(Object, String)} with a default message. * Calls {@link #assertNotNull(Object, String)} with a default message.
* *
* @param o The reference assumed <i>not</i> to be null,
* @see #assertNotNull(Object, String) * @see #assertNotNull(Object, String)
*/ */
public static void assertNotNull(Object o) { public static void assertNotNull(Object o) {
assertNotNull(o, "Expected non null reference"); assertNotNull(o, null);
} }
/** /**
* Asserts that {@code o} is <i>not</i> null. * Asserts that {@code o} is <i>not</i> null.
* *
* @param o The reference assumed <i>not</i> to be null, * @param o The reference assumed <i>not</i> to be null,
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertNotNull(Object o, String msg) { public static void assertNotNull(Object o, String msg) {
assertNotEquals(o, null, msg); assertNotEquals(o, null, msg);
@ -339,57 +412,123 @@ public class Asserts {
/** /**
* Calls {@link #assertFalse(boolean, String)} with a default message. * Calls {@link #assertFalse(boolean, String)} with a default message.
* *
* @param value The value assumed to be false.
* @see #assertFalse(boolean, String) * @see #assertFalse(boolean, String)
*/ */
public static void assertFalse(boolean value) { public static void assertFalse(boolean value) {
assertFalse(value, "Expected value to be false"); assertFalse(value, null);
} }
/** /**
* Asserts that {@code value} is {@code false}. * Asserts that {@code value} is {@code false}.
* *
* @param value The value assumed to be false. * @param value The value assumed to be false.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertFalse(boolean value, String msg) { public static void assertFalse(boolean value, String msg) {
assertTrue(!value, msg); if (value) {
msg = Objects.toString(msg, "assertFalse")
+ ": expected false, was true";
fail(msg);
}
} }
/** /**
* Calls {@link #assertTrue(boolean, String)} with a default message. * Calls {@link #assertTrue(boolean, String)} with a default message.
* *
* @param value The value assumed to be true.
* @see #assertTrue(boolean, String) * @see #assertTrue(boolean, String)
*/ */
public static void assertTrue(boolean value) { public static void assertTrue(boolean value) {
assertTrue(value, "Expected value to be true"); assertTrue(value, null);
} }
/** /**
* Asserts that {@code value} is {@code true}. * Asserts that {@code value} is {@code true}.
* *
* @param value The value assumed to be true. * @param value The value assumed to be true.
* @param msg A description of the assumption. * @param msg A description of the assumption; {@code null} for a default message.
* @throws RuntimeException if the assertion isn't valid. * @throws RuntimeException if the assertion is not true.
*/ */
public static void assertTrue(boolean value, String msg) { public static void assertTrue(boolean value, String msg) {
if (!value) { if (!value) {
error(msg); msg = Objects.toString(msg, "assertTrue")
+ ": expected true, was false";
fail(msg);
} }
} }
private static <T extends Comparable<T>> int compare(T lhs, T rhs, String msg) { private static <T extends Comparable<T>> int compare(T lhs, T rhs, String msg) {
assertNotNull(lhs, msg); if (lhs == null || rhs == null) {
assertNotNull(rhs, msg); fail(lhs, rhs, msg + ": values must be non-null:", ",");
}
return lhs.compareTo(rhs); return lhs.compareTo(rhs);
} }
private static String format(Object o) { /**
return o == null? "null" : o.toString(); * Returns a string formatted with a message and expected and actual values.
* @param lhs the actual value
* @param rhs the expected value
* @param message the actual value
* @param relation the asserted relationship between lhs and rhs
* @return a formatted string
*/
public static String format(Object lhs, Object rhs, String message, String relation) {
StringBuilder sb = new StringBuilder(80);
if (message != null) {
sb.append(message);
sb.append(' ');
}
sb.append("<");
sb.append(Objects.toString(lhs));
sb.append("> ");
sb.append(Objects.toString(relation, ","));
sb.append(" <");
sb.append(Objects.toString(rhs));
sb.append(">");
return sb.toString();
} }
private static void error(String msg) { /**
throw new RuntimeException(msg); * Fail reports a failure with message fail.
*
* @throws RuntimeException always
*/
public static void fail() {
fail("fail");
}
/**
* Fail reports a failure with a message.
* @param message for the failure
* @throws RuntimeException always
*/
public static void fail(String message) {
throw new RuntimeException(message);
}
/**
* Fail reports a failure with a formatted message.
*
* @param lhs the actual value
* @param rhs the expected value
* @param message to be format before the expected and actual values
* @param relation the asserted relationship between lhs and rhs
* @throws RuntimeException always
*/
public static void fail(Object lhs, Object rhs, String message, String relation) {
throw new RuntimeException(format(lhs, rhs, message, relation));
}
/**
* Fail reports a failure with a message and a cause.
* @param message to be format before the expected and actual values
* @param cause the exception that caused this failure
* @throws RuntimeException always
*/
public static void fail(String message, Throwable cause) {
throw new RuntimeException(message, cause);
} }
} }