454 lines
15 KiB
Java
454 lines
15 KiB
Java
/*
|
|
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.oracle.java.testlibrary;
|
|
|
|
/**
|
|
* Asserts that can be used for verifying assumptions in tests.
|
|
*
|
|
* An assertion will throw a {@link RuntimeException} if the assertion isn't
|
|
* valid. All the asserts can be imported into a test by using a static
|
|
* import:
|
|
*
|
|
* <pre>
|
|
* {@code
|
|
* import static com.oracle.java.testlibrary.Asserts.*;
|
|
* }
|
|
*
|
|
* Always provide a message describing the assumption if the line number of the
|
|
* failing assertion isn't enough to understand why the assumption failed. For
|
|
* example, if the assertion is in a loop or in a method that is called
|
|
* multiple times, then the line number won't provide enough context to
|
|
* understand the failure.
|
|
* </pre>
|
|
*/
|
|
public class Asserts {
|
|
|
|
/**
|
|
* Shorthand for {@link #assertLessThan(T, T)}.
|
|
*
|
|
* @see #assertLessThan(T, T)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLT(T lhs, T rhs) {
|
|
assertLessThan(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertLessThan(T, T, String)}.
|
|
*
|
|
* @see #assertLessThan(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLT(T lhs, T rhs, String msg) {
|
|
assertLessThan(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertLessThan(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertLessThan(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLessThan(T lhs, T rhs) {
|
|
String msg = "Expected that " + format(lhs) + " < " + format(rhs);
|
|
assertLessThan(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is less than {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static <T extends Comparable<T>>void assertLessThan(T lhs, T rhs, String msg) {
|
|
assertTrue(compare(lhs, rhs, msg) < 0, msg);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertLessThanOrEqual(T, T)}.
|
|
*
|
|
* @see #assertLessThanOrEqual(T, T)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs) {
|
|
assertLessThanOrEqual(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertLessThanOrEqual(T, T, String)}.
|
|
*
|
|
* @see #assertLessThanOrEqual(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs, String msg) {
|
|
assertLessThanOrEqual(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertLessThanOrEqual(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertLessThanOrEqual(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs) {
|
|
String msg = "Expected that " + format(lhs) + " <= " + format(rhs);
|
|
assertLessThanOrEqual(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is less than or equal to {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs, String msg) {
|
|
assertTrue(compare(lhs, rhs, msg) <= 0, msg);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertEquals(T, T)}.
|
|
*
|
|
* @see #assertEquals(T, T)
|
|
*/
|
|
public static void assertEQ(Object lhs, Object rhs) {
|
|
assertEquals(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertEquals(T, T, String)}.
|
|
*
|
|
* @see #assertEquals(T, T, String)
|
|
*/
|
|
public static void assertEQ(Object lhs, Object rhs, String msg) {
|
|
assertEquals(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertEquals(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertEquals(T, T, String)
|
|
*/
|
|
public static void assertEquals(Object lhs, Object rhs) {
|
|
String msg = "Expected " + format(lhs) + " to equal " + format(rhs);
|
|
assertEquals(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is equal to {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertEquals(Object lhs, Object rhs, String msg) {
|
|
if (lhs == null) {
|
|
if (rhs != null) {
|
|
error(msg);
|
|
}
|
|
} else {
|
|
assertTrue(lhs.equals(rhs), msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertGreaterThanOrEqual(T, T)}.
|
|
*
|
|
* @see #assertGreaterThanOrEqual(T, T)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs) {
|
|
assertGreaterThanOrEqual(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertGreaterThanOrEqual(T, T, String)}.
|
|
*
|
|
* @see #assertGreaterThanOrEqual(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs, String msg) {
|
|
assertGreaterThanOrEqual(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertGreaterThanOrEqual(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertGreaterThanOrEqual(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs) {
|
|
String msg = "Expected that " + format(lhs) + " >= " + format(rhs);
|
|
assertGreaterThanOrEqual(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is greater than or equal to {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs, String msg) {
|
|
assertTrue(compare(lhs, rhs, msg) >= 0, msg);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertGreaterThan(T, T)}.
|
|
*
|
|
* @see #assertGreaterThan(T, T)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGT(T lhs, T rhs) {
|
|
assertGreaterThan(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertGreaterThan(T, T, String)}.
|
|
*
|
|
* @see #assertGreaterThan(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGT(T lhs, T rhs, String msg) {
|
|
assertGreaterThan(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertGreaterThan(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertGreaterThan(T, T, String)
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs) {
|
|
String msg = "Expected that " + format(lhs) + " > " + format(rhs);
|
|
assertGreaterThan(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is greater than {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs, String msg) {
|
|
assertTrue(compare(lhs, rhs, msg) > 0, msg);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertNotEquals(T, T)}.
|
|
*
|
|
* @see #assertNotEquals(T, T)
|
|
*/
|
|
public static void assertNE(Object lhs, Object rhs) {
|
|
assertNotEquals(lhs, rhs);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link #assertNotEquals(T, T, String)}.
|
|
*
|
|
* @see #assertNotEquals(T, T, String)
|
|
*/
|
|
public static void assertNE(Object lhs, Object rhs, String msg) {
|
|
assertNotEquals(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertNotEquals(T, T, String)} with a default message.
|
|
*
|
|
* @see #assertNotEquals(T, T, String)
|
|
*/
|
|
public static void assertNotEquals(Object lhs, Object rhs) {
|
|
String msg = "Expected " + format(lhs) + " to not equal " + format(rhs);
|
|
assertNotEquals(lhs, rhs, msg);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code lhs} is not equal to {@code rhs}.
|
|
*
|
|
* @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.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertNotEquals(Object lhs, Object rhs, String msg) {
|
|
if (lhs == null) {
|
|
if (rhs == null) {
|
|
error(msg);
|
|
}
|
|
} else {
|
|
assertFalse(lhs.equals(rhs), msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertNull(Object, String)} with a default message.
|
|
*
|
|
* @see #assertNull(Object, String)
|
|
*/
|
|
public static void assertNull(Object o) {
|
|
assertNull(o, "Expected " + format(o) + " to be null");
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code o} is null.
|
|
*
|
|
* @param o The reference assumed to be null.
|
|
* @param msg A description of the assumption.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertNull(Object o, String msg) {
|
|
assertEquals(o, null, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertNotNull(Object, String)} with a default message.
|
|
*
|
|
* @see #assertNotNull(Object, String)
|
|
*/
|
|
public static void assertNotNull(Object o) {
|
|
assertNotNull(o, "Expected non null reference");
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code o} is <i>not</i> null.
|
|
*
|
|
* @param o The reference assumed <i>not</i> to be null,
|
|
* @param msg A description of the assumption.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertNotNull(Object o, String msg) {
|
|
assertNotEquals(o, null, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertFalse(boolean, String)} with a default message.
|
|
*
|
|
* @see #assertFalse(boolean, String)
|
|
*/
|
|
public static void assertFalse(boolean value) {
|
|
assertFalse(value, "Expected value to be false");
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code value} is {@code false}.
|
|
*
|
|
* @param value The value assumed to be false.
|
|
* @param msg A description of the assumption.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertFalse(boolean value, String msg) {
|
|
assertTrue(!value, msg);
|
|
}
|
|
|
|
/**
|
|
* Calls {@link #assertTrue(boolean, String)} with a default message.
|
|
*
|
|
* @see #assertTrue(boolean, String)
|
|
*/
|
|
public static void assertTrue(boolean value) {
|
|
assertTrue(value, "Expected value to be true");
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code value} is {@code true}.
|
|
*
|
|
* @param value The value assumed to be true.
|
|
* @param msg A description of the assumption.
|
|
* @throws RuntimeException if the assertion isn't valid.
|
|
*/
|
|
public static void assertTrue(boolean value, String msg) {
|
|
if (!value) {
|
|
error(msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Asserts that two strings are equal.
|
|
*
|
|
* If strings are not equals, then exception message
|
|
* will contain {@code msg} followed by list of mismatched lines.
|
|
*
|
|
* @param str1 First string to compare.
|
|
* @param str2 Second string to compare.
|
|
* @param msg A description of the assumption.
|
|
* @throws RuntimeException if strings are not equal.
|
|
*/
|
|
public static void assertStringsEqual(String str1, String str2,
|
|
String msg) {
|
|
String lineSeparator = System.getProperty("line.separator");
|
|
String str1Lines[] = str1.split(lineSeparator);
|
|
String str2Lines[] = str2.split(lineSeparator);
|
|
|
|
int minLength = Math.min(str1Lines.length, str2Lines.length);
|
|
String longestStringLines[] = ((str1Lines.length == minLength) ?
|
|
str2Lines : str1Lines);
|
|
|
|
boolean stringsAreDifferent = false;
|
|
|
|
StringBuilder messageBuilder = new StringBuilder(msg);
|
|
|
|
messageBuilder.append("\n");
|
|
|
|
for (int line = 0; line < minLength; line++) {
|
|
if (!str1Lines[line].equals(str2Lines[line])) {
|
|
messageBuilder.append(String.
|
|
format("[line %d] '%s' differs " +
|
|
"from '%s'\n",
|
|
line,
|
|
str1Lines[line],
|
|
str2Lines[line]));
|
|
stringsAreDifferent = true;
|
|
}
|
|
}
|
|
|
|
if (minLength < longestStringLines.length) {
|
|
String stringName = ((longestStringLines == str1Lines) ?
|
|
"first" : "second");
|
|
messageBuilder.append(String.format("Only %s string contains " +
|
|
"following lines:\n",
|
|
stringName));
|
|
stringsAreDifferent = true;
|
|
for(int line = minLength; line < longestStringLines.length; line++) {
|
|
messageBuilder.append(String.
|
|
format("[line %d] '%s'", line,
|
|
longestStringLines[line]));
|
|
}
|
|
}
|
|
|
|
if (stringsAreDifferent) {
|
|
error(messageBuilder.toString());
|
|
}
|
|
}
|
|
|
|
private static <T extends Comparable<T>> int compare(T lhs, T rhs, String msg) {
|
|
assertNotNull(lhs, msg);
|
|
assertNotNull(rhs, msg);
|
|
return lhs.compareTo(rhs);
|
|
}
|
|
|
|
private static String format(Object o) {
|
|
return o == null? "null" : o.toString();
|
|
}
|
|
|
|
private static void error(String msg) {
|
|
throw new RuntimeException(msg);
|
|
}
|
|
|
|
}
|