mirror of
https://github.com/github/codeql.git
synced 2026-04-15 03:54:02 +02:00
473 lines
17 KiB
Java
Generated
473 lines
17 KiB
Java
Generated
package org.junit;
|
|
|
|
import org.junit.function.ThrowingRunnable;
|
|
|
|
//BSD License
|
|
//
|
|
//Copyright (c) 2000-2006, www.hamcrest.org
|
|
//All rights reserved.
|
|
//
|
|
//Redistribution and use in source and binary forms, with or without
|
|
//modification, are permitted provided that the following conditions are met:
|
|
//
|
|
//Redistributions of source code must retain the above copyright notice, this list of
|
|
//conditions and the following disclaimer. Redistributions in binary form must reproduce
|
|
//the above copyright notice, this list of conditions and the following disclaimer in
|
|
//the documentation and/or other materials provided with the distribution.
|
|
//
|
|
//Neither the name of Hamcrest nor the names of its contributors may be used to endorse
|
|
//or promote products derived from this software without specific prior written
|
|
//permission.
|
|
//
|
|
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
//EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
//OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
//SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
|
//TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
//BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
//CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
|
|
//WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
|
//DAMAGE.
|
|
|
|
/*
|
|
* MODIFIED version of JUnit 4.13 as available at
|
|
* https://search.maven.org/remotecontent?filepath=junit/junit/4.13/junit-4.13-sources.jar
|
|
* Only parts of this file have been retained for test purposes.
|
|
*/
|
|
|
|
public class 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 for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @param condition condition to be checked
|
|
*/
|
|
static public void assertTrue(String message, boolean condition) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Asserts that a condition is false. If it isn't it throws an
|
|
* {@link AssertionError} with the given message.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @param condition condition to be checked
|
|
*/
|
|
static public void assertFalse(String message, boolean condition) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Fails a test with the given message.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @see AssertionError
|
|
*/
|
|
static public void fail(String message) {
|
|
if (message == null) {
|
|
throw new AssertionError();
|
|
}
|
|
throw new AssertionError(message);
|
|
}
|
|
|
|
/**
|
|
* Asserts that an object isn't null. If it is an {@link AssertionError} is
|
|
* thrown with the given message.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @param object Object to check or <code>null</code>
|
|
*/
|
|
static public void assertNotNull(String message, Object object) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Asserts that an object is null. If it is not, an {@link AssertionError}
|
|
* is thrown with the given message.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @param object Object to check or <code>null</code>
|
|
*/
|
|
static public void assertNull(String message, Object object) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
return;
|
|
}
|
|
|
|
private static boolean equalsRegardingNull(Object expected, Object actual) {
|
|
if (expected == null) {
|
|
return actual == null;
|
|
}
|
|
|
|
return isEquals(expected, actual);
|
|
}
|
|
|
|
private static boolean isEquals(Object expected, Object actual) {
|
|
return expected.equals(actual);
|
|
}
|
|
|
|
/**
|
|
* 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 for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @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.
|
|
*/
|
|
public static void assertEquals(String message, double expected,
|
|
double actual, double delta) {
|
|
return;
|
|
}
|
|
|
|
private static 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 && !"".equals(message)) {
|
|
formatted = message + " ";
|
|
}
|
|
String expectedString = String.valueOf(expected);
|
|
String actualString = String.valueOf(actual);
|
|
if (equalsRegardingNull(expectedString, actualString)) {
|
|
return formatted + "expected: "
|
|
+ formatClassAndValue(expected, expectedString)
|
|
+ " but was: " + formatClassAndValue(actual, actualString);
|
|
} else {
|
|
return formatted + "expected:<" + expectedString + "> but was:<"
|
|
+ actualString + ">";
|
|
}
|
|
}
|
|
|
|
private static String formatClass(Class<?> value) {
|
|
String className = value.getCanonicalName();
|
|
return className == null ? value.getName() : className;
|
|
}
|
|
|
|
private static String formatClassAndValue(Object value, String valueString) {
|
|
String className = value == null ? "null" : value.getClass().getName();
|
|
return className + "<" + valueString + ">";
|
|
}
|
|
|
|
/**
|
|
* 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 for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @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.
|
|
*/
|
|
public static void assertEquals(String message, float expected, float actual,
|
|
float delta) {
|
|
if (floatIsDifferent(expected, actual, delta)) {
|
|
failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
|
|
}
|
|
}
|
|
|
|
private static boolean doubleIsDifferent(double d1, double d2, double delta) {
|
|
if (Double.compare(d1, d2) == 0) {
|
|
return false;
|
|
}
|
|
if ((Math.abs(d1 - d2) <= delta)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static boolean floatIsDifferent(float f1, float f2, float delta) {
|
|
if (Float.compare(f1, f2) == 0) {
|
|
return false;
|
|
}
|
|
if ((Math.abs(f1 - f2) <= delta)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Asserts that two longs are equal. If they are not, an
|
|
* {@link AssertionError} is thrown.
|
|
*
|
|
* @param expected expected long value.
|
|
* @param actual actual long value
|
|
*/
|
|
public static void assertEquals(long expected, long actual) {
|
|
assertEquals(null, expected, actual);
|
|
}
|
|
|
|
/**
|
|
* Asserts that two longs are equal. If they are not, an
|
|
* {@link AssertionError} is thrown with the given message.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError}
|
|
* (<code>null</code>
|
|
* okay)
|
|
* @param expected long expected value.
|
|
* @param actual long actual value
|
|
*/
|
|
public static void assertEquals(String message, long expected, long actual) {
|
|
if (expected != actual) {
|
|
failNotEquals(message, Long.valueOf(expected), Long.valueOf(actual));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use
|
|
* <code>assertEquals(double expected, double actual, double
|
|
* delta)</code> instead
|
|
*/
|
|
@Deprecated
|
|
public static void assertEquals(double expected, double actual) {
|
|
assertEquals(null, expected, actual);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use
|
|
* <code>assertEquals(String message, double expected, double
|
|
* actual, double delta)</code> instead
|
|
*/
|
|
@Deprecated
|
|
public static void assertEquals(String message, double expected,
|
|
double actual) {
|
|
fail("Use assertEquals(expected, actual, delta) to compare " +
|
|
"floating-point numbers");
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
public static 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. 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 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.
|
|
*/
|
|
public static void assertEquals(float expected, float actual, float delta) {
|
|
assertEquals(null, expected, actual, delta);
|
|
}
|
|
|
|
/**
|
|
* 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>
|
|
*/
|
|
public static void assertEquals(Object expected, Object actual) {
|
|
assertEquals(null, expected, actual);
|
|
}
|
|
|
|
public static void assertEquals(String message, Object expected,
|
|
Object actual) {
|
|
}
|
|
|
|
public static void assertNotEquals(String message, Object unexpected, Object actual) {
|
|
return;
|
|
}
|
|
|
|
public static void assertNotEquals(Object unexpected, Object actual) {
|
|
assertNotEquals(null, unexpected, actual);
|
|
}
|
|
|
|
public static void assertNotEquals(String message, long unexpected, long actual) {
|
|
return;
|
|
}
|
|
|
|
public static void assertNotEquals(long unexpected, long actual) {
|
|
assertNotEquals(null, unexpected, actual);
|
|
}
|
|
|
|
public static void assertNotEquals(String message, double unexpected, double actual, double delta) {
|
|
return;
|
|
}
|
|
|
|
public static void assertNotEquals(double unexpected, double actual, double delta) {
|
|
assertNotEquals(null, unexpected, actual, delta);
|
|
}
|
|
|
|
public static void assertNotEquals(String message, float unexpected, float actual, float delta) {
|
|
return;
|
|
}
|
|
|
|
public static void assertNotEquals(float unexpected, float actual, float delta) {
|
|
assertNotEquals(null, unexpected, actual, delta);
|
|
}
|
|
|
|
public static void assertNotSame(String message, Object unexpected, Object actual) {
|
|
return;
|
|
}
|
|
|
|
public static void assertNotSame(Object unexpected, Object actual) {
|
|
assertNotSame(null, unexpected, actual);
|
|
}
|
|
|
|
public static void assertSame(String message, Object expected, Object actual) {
|
|
return;
|
|
}
|
|
|
|
public static void assertSame(Object expected, Object actual) {
|
|
assertSame(null, expected, actual);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
|
|
* executed. If it does, the exception object is returned. If it does not throw an exception, an
|
|
* {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
|
|
* AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
|
|
* be obtained by calling {@link AssertionError#getCause}.
|
|
*
|
|
* @param expectedThrowable the expected type of the exception
|
|
* @param runnable a function that is expected to throw an exception when executed
|
|
* @return the exception thrown by {@code runnable}
|
|
* @since 4.13
|
|
*/
|
|
public static <T extends Throwable> T assertThrows(Class<T> expectedThrowable,
|
|
ThrowingRunnable runnable) {
|
|
return assertThrows(null, expectedThrowable, runnable);
|
|
}
|
|
|
|
/**
|
|
* Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
|
|
* executed. If it does, the exception object is returned. If it does not throw an exception, an
|
|
* {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
|
|
* AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
|
|
* be obtained by calling {@link AssertionError#getCause}.
|
|
*
|
|
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
|
|
* okay)
|
|
* @param expectedThrowable the expected type of the exception
|
|
* @param runnable a function that is expected to throw an exception when executed
|
|
* @return the exception thrown by {@code runnable}
|
|
* @since 4.13
|
|
*/
|
|
public static <T extends Throwable> T assertThrows(String message, Class<T> expectedThrowable,
|
|
ThrowingRunnable runnable) {
|
|
try {
|
|
runnable.run();
|
|
} catch (Throwable actualThrown) {
|
|
if (expectedThrowable.isInstance(actualThrown)) {
|
|
@SuppressWarnings("unchecked") T retVal = (T) actualThrown;
|
|
return retVal;
|
|
} else {
|
|
String expected = formatClass(expectedThrowable);
|
|
Class<? extends Throwable> actualThrowable = actualThrown.getClass();
|
|
String actual = formatClass(actualThrowable);
|
|
if (expected.equals(actual)) {
|
|
// There must be multiple class loaders. Add the identity hash code so the message
|
|
// doesn't say "expected: java.lang.String<my.package.MyException> ..."
|
|
expected += "@" + Integer.toHexString(System.identityHashCode(expectedThrowable));
|
|
actual += "@" + Integer.toHexString(System.identityHashCode(actualThrowable));
|
|
}
|
|
String mismatchMessage = buildPrefix(message)
|
|
+ format("unexpected exception type thrown;", expected, actual);
|
|
|
|
// The AssertionError(String, Throwable) ctor is only available on JDK7.
|
|
AssertionError assertionError = new AssertionError(mismatchMessage);
|
|
assertionError.initCause(actualThrown);
|
|
throw assertionError;
|
|
}
|
|
}
|
|
String notThrownMessage = buildPrefix(message) + String
|
|
.format("expected %s to be thrown, but nothing was thrown",
|
|
formatClass(expectedThrowable));
|
|
throw new AssertionError(notThrownMessage);
|
|
}
|
|
|
|
private static String buildPrefix(String message) {
|
|
return message != null && message.length() != 0 ? message + ": " : "";
|
|
}
|
|
|
|
}
|