null
+ * 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}
+ * (null
+ * 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}
+ * (null
+ * 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}
+ * (null
+ * okay)
+ * @param object Object to check or null
+ */
+ 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 null
+ */
+ 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}
+ * (null
+ * okay)
+ * @param object Object to check or null
+ */
+ 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 null
+ */
+ 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:
+ * assertEquals(Double.NaN, Double.NaN, *) passes
+ *
+ * @param message the identifying message for the {@link AssertionError}
+ * (null
+ * okay)
+ * @param expected expected value
+ * @param actual the value to check against expected
+ * @param delta the maximum delta between expected and
+ * actual 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:
+ * assertEquals(Float.NaN, Float.NaN, *) passes
+ *
+ * @param message the identifying message for the {@link AssertionError}
+ * (null
+ * okay)
+ * @param expected expected value
+ * @param actual the value to check against expected
+ * @param delta the maximum delta between expected and
+ * actual 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}
+ * (null
+ * 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
+ * assertEquals(double expected, double actual, double
+ * delta) instead
+ */
+ @Deprecated
+ public static void assertEquals(double expected, double actual) {
+ assertEquals(null, expected, actual);
+ }
+
+ /**
+ * @deprecated Use
+ * assertEquals(String message, double expected, double
+ * actual, double delta) 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: assertEquals(Double.NaN, Double.NaN, *) passes
+ *
+ * @param expected expected value
+ * @param actual the value to check against expected
+ * @param delta the maximum delta between expected and
+ * actual 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: assertEquals(Float.NaN, Float.NaN, *) passes
+ *
+ * @param expected expected value
+ * @param actual the value to check against expected
+ * @param delta the maximum delta between expected and
+ * actual 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
+ * expected and actual are null,
+ * they are considered equal.
+ *
+ * @param expected expected value
+ * @param actual the value to check against expected
+ */
+ 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 null
+ * 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
+ * See examples in javadoc for the {@link Mockito} class.
+ *
+ * @param reified don't pass any values to it. It's a trick to detect the
+ * class/interface you
+ * want to mock.
+ * @return the mock object.
+ * @since 4.10.0
+ */
+ @SafeVarargs
+ public static
+ * See examples in javadoc for the {@link Mockito} class.
+ *
+ * @param defaultAnswer the default answer to use.
+ * @param reified don't pass any values to it. It's a trick to detect the
+ * class/interface you
+ * want to mock.
+ * @return the mock object.
+ * @since 5.1.0
+ */
+ @SafeVarargs
+ public static
+ * See examples in javadoc for the {@link Mockito} class.
+ *
+ * @param name the mock name to use.
+ * @param reified don't pass any values to it. It's a trick to detect the
+ * class/interface you
+ * want to mock.
+ * @return the mock object.
+ * @since 5.1.0
+ */
+ @SafeVarargs
+ public static
+ * See examples in javadoc for the {@link Mockito} class.
+ *
+ * @param settings the mock settings to use.
+ * @param reified don't pass any values to it. It's a trick to detect the
+ * class/interface you
+ * want to mock.
+ * @return the mock object.
+ * @since 5.1.0
+ */
+ @SafeVarargs
+ public static
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface to mock
+ * @return mock object
+ */
+ public static
+ * Beware that naming mocks is not a solution for complex code which uses too
+ * many mocks or collaborators.
+ * If you have too many mocks then refactor the code so that it's easy to
+ * test/debug without necessity of naming mocks.
+ *
+ * If you use
+ *
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface to mock
+ * @param name of the mock
+ * @return mock object
+ */
+ public static
+ * It is the default answer so it will be used only when you don't stub
+ * the method call.
+ *
+ *
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * The number of configuration points for a mock will grow,
+ * so we need a fluent way to introduce new configuration without adding more
+ * and more overloaded Mockito.mock() methods.
+ * Hence {@link MockSettings}.
+ *
+ *
+ * See also {@link Mockito#withSettings()}
+ *
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface to mock
+ * @param mockSettings additional mock settings
+ * @return mock object
+ */
+ public static @Mock annotation then you've got naming mocks
+ * for free! @Mock uses field name as mock name.
+ * {@link Mock Read more.}
+ *
+ *
+ *
+ *
+ * Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
+ * Foo mockTwo = mock(Foo.class, new YourOwnAnswer());
+ *
+ *
+ *
+ *
+ * Use it carefully and occasionally. What might be reason your test
+ * needs non-standard mocks?
+ * Is the code under test so complicated that it requires non-standard mocks?
+ * Wouldn't you prefer to refactor the code under test, so that it is testable
+ * in a simple way?
+ *
+ * Listener mock = mock(Listener.class, withSettings()
+ * .name("firstListner").defaultBehavior(RETURNS_SMART_NULLS));
+ * );
+ *
+ *