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 + ": " : "";

}

}