Java 类org.junit.internal.ExactComparisonCriteria 实例源码

/**
 * Asserts that two objects (including arrays) are equal.
 * If they are not, an {@link AssertionError} is thrown with
 * the given message. If`expected` and `actual` are `null`,
 * they are considered equal.
 *
 * @param expected
 *              expected value, could be any object including array
 * @param actual
 *              actual value
 * @param message
 *              the failure message. `null` Okay
 * @param messageArgs
 *              the failure message arguments
 */
public static void eq(Object expected, Object actual, String message, Object ... messageArgs) {
    if (null == expected) {
        isNull(actual, message, messageArgs);
        return;
    }
    Class<?> expectedClass = expected.getClass();
    String userMessage = fmt(message, messageArgs);
    if (expectedClass.isArray()) {
        Class<?> actualClass = actual.getClass();
        if (!expectedClass.equals(actualClass)) {
            if (null == message || "".equals(message.trim())) {
                fail("arrays type differed\nExpected: %s\nActual  : %s",
                        expectedClass.getName(), actualClass.getName());
            } else {
                fail("%s: arrays type differed\nExpected: %s\nActual  : %s",
                        userMessage, expectedClass.getName(), actualClass.getName());
            }
        }
        new ExactComparisonCriteria().arrayEquals(fmt(message, messageArgs), expected, actual);
    } else {
        assertEquals(fmt(message, messageArgs), expected, actual);
    }
}

/**
 * Asserts that two objects (including arrays) are equal.
 * If they are not, an {@link AssertionError} is thrown with
 * the given message. If`expected` and `actual` are `null`,
 * they are considered equal.
 *
 * @param expected
 *              expected value, could be any object including array
 * @param actual
 *              actual value
 */
public static void eq(Object expected, Object actual) {
    if (null == expected) {
        isNull(actual);
        return;
    }
    Class<?> expectedClass = expected.getClass();
    if (expectedClass.isArray()) {
        Class<?> actualClass = actual.getClass();
        if (!expectedClass.equals(actualClass)) {
            fail("arrays type differed\nExpected: %s\nActual  : %s", expectedClass.getName(), actualClass.getName());
        }
        new ExactComparisonCriteria().arrayEquals(null, expected, actual);
    } else {
        assertEquals(null, expected, actual);
    }
}

public static <T> CapturingSerialWriter roundtripArray(Serializer<T> serializer, T value)
  throws IOException {
  final CapturingSerialWriter out = new CapturingSerialWriter();
  serializer.serialize(out, value);
  final T result = serializer.deserialize(out.toSerialReader());
  new ExactComparisonCriteria().arrayEquals(null, value, result);
  return out;
}

/**
 * Compares two given values for equality, doing a recursive test if both values are arrays of
 * the same type.
 *
 * @param message the identifying message for the {@link AssertionError}
 * @param delta the maximum delta between two doubles or floats for which both numbers are still
 *            considered equal.
 */
protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
    if (expected != null && actual != null) {
        Class<?> expectedClass = expected.getClass();
        Class<?> actualClass = actual.getClass();
        if (expectedClass.isArray()) {
            Assert.assertEquals(message, expectedClass, actual.getClass());
            if (expected instanceof int[]) {
                Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
            } else if (expected instanceof byte[]) {
                Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
            } else if (expected instanceof char[]) {
                Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
            } else if (expected instanceof short[]) {
                Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
            } else if (expected instanceof float[]) {
                Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
            } else if (expected instanceof long[]) {
                Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
            } else if (expected instanceof double[]) {
                Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
            } else if (expected instanceof boolean[]) {
                new ExactComparisonCriteria().arrayEquals(message, expected, actual);
            } else if (expected instanceof Object[]) {
                new ComparisonCriteria() {
                    @Override
                    protected void assertElementsEqual(Object e, Object a) {
                        assertDeepEquals(message, e, a, delta);
                    }
                }.arrayEquals(message, expected, actual);
            } else {
                Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
            }
        } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
            Assert.assertEquals((double) expected, (double) actual, delta);
        } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
            Assert.assertEquals((float) expected, (float) actual, delta);
        } else {
            Assert.assertEquals(message, expected, actual);
        }
    } else {
        Assert.assertEquals(message, expected, actual);
    }
}

/**
 * Compares two given values for equality, doing a recursive test if both values are arrays of
 * the same type.
 *
 * @param message the identifying message for the {@link AssertionError}
 * @param delta the maximum delta between two doubles or floats for which both numbers are still
 *            considered equal.
 */
protected void assertDeepEquals(String message, Object expected, Object actual, double delta) {
    if (expected != null && actual != null) {
        Class<?> expectedClass = expected.getClass();
        Class<?> actualClass = actual.getClass();
        if (expectedClass.isArray()) {
            Assert.assertEquals(message, expectedClass, actual.getClass());
            if (expected instanceof int[]) {
                Assert.assertArrayEquals(message, (int[]) expected, (int[]) actual);
            } else if (expected instanceof byte[]) {
                Assert.assertArrayEquals(message, (byte[]) expected, (byte[]) actual);
            } else if (expected instanceof char[]) {
                Assert.assertArrayEquals(message, (char[]) expected, (char[]) actual);
            } else if (expected instanceof short[]) {
                Assert.assertArrayEquals(message, (short[]) expected, (short[]) actual);
            } else if (expected instanceof float[]) {
                Assert.assertArrayEquals(message, (float[]) expected, (float[]) actual, (float) delta);
            } else if (expected instanceof long[]) {
                Assert.assertArrayEquals(message, (long[]) expected, (long[]) actual);
            } else if (expected instanceof double[]) {
                Assert.assertArrayEquals(message, (double[]) expected, (double[]) actual, delta);
            } else if (expected instanceof boolean[]) {
                new ExactComparisonCriteria().arrayEquals(message, expected, actual);
            } else if (expected instanceof Object[]) {
                new ComparisonCriteria() {
                    @Override
                    protected void assertElementsEqual(Object e, Object a) {
                        assertDeepEquals(message, e, a, delta);
                    }
                }.arrayEquals(message, expected, actual);
            } else {
                Assert.fail((message == null ? "" : message) + "non-array value encountered: " + expected);
            }
        } else if (expectedClass.equals(double.class) && actualClass.equals(double.class)) {
            Assert.assertEquals((double) expected, (double) actual, delta);
        } else if (expectedClass.equals(float.class) && actualClass.equals(float.class)) {
            Assert.assertEquals((float) expected, (float) actual, delta);
        } else {
            Assert.assertEquals(message, expected, actual);
        }
    } else {
        Assert.assertEquals(message, expected, actual);
    }
}

private void internalArrayEquals(final String message, final Object expecteds, final Object actuals)
        throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 * expected values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with
 * actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 * expected values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with
 * actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 *                  expected values.
 * @param actuals   Object array or array of arrays (multi-dimensional array) with
 *                  actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
                                        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 * expected values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with
 * actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 * expected values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with
 * actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}