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

项目：VersionLib 文件：TestUtils.java

@SuppressWarnings("unchecked")
public static <T> void assertSortsCorrectly(T[] expectedOrder, Comparator<T> comparator)
        throws ArrayComparisonFailure {
    List<T> versions = new ArrayList<>(Arrays.asList(expectedOrder));
    T[] sortedVersions;

    for (int i = 0; i < SHUFFLES; ++i) {
        Collections.shuffle(versions);
        sortedVersions = (T[]) versions.stream().sorted(comparator).toArray(Object[]::new);

        try {
            assertArrayEquals(expectedOrder, sortedVersions);
        } catch (ArrayComparisonFailure e) {
            assertArrayEquals("Sorting failed for shuffle:\n" + versions + "\nSorted result:\n"
                    + Arrays.toString(sortedVersions) + '\n', expectedOrder, sortedVersions);
        }
    }
}

项目：TacTex 文件：BrokerUtilsTest.java

/**
 * as assert function I added that compares hash maps
 * @param msg 
 * 
 * @param twoLevelMap
 * @param expectedMap
 * @throws ArrayComparisonFailure
 */ 
private  <K1, K2, V> void myAssertMapsEqual(
    String msg, 
    HashMap<K1, HashMap<K2, V>> expectedMap, 
    HashMap<K1, HashMap<K2, V>> revertedTwoLevelMap
    )
    throws ArrayComparisonFailure {

  // compare key1
  assertTrue(msg, expectedMap.keySet().equals(revertedTwoLevelMap.keySet()));

  // for each key1, compare all <key2, value>s
  for (K1 key1 : expectedMap.keySet()) {

    assertTrue(msg + " comparing key2", expectedMap.get(key1).keySet().equals(revertedTwoLevelMap.get(key1).keySet()));

    for (K2 key2 : expectedMap.get(key1).keySet()) {
      assertEquals(msg + " comparing values", expectedMap.get(key1).get(key2), revertedTwoLevelMap.get(key1).get(key2));
    }
  }
}

项目：GDSC-SMLM 文件：BlockSumFilterTest.java

private void sumIsCorrect(float[] data, int width, int height, float boxSize, boolean internal,
        BlockSumDataFilter filter) throws ArrayComparisonFailure
{
    float[] data1 = data.clone();
    float[] data2 = data.clone();

    sum(data1, width, height, boxSize);
    if (internal)
    {
        filter.filterInternal(data2, width, height, boxSize);
        floatArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %.1f", width, height, boxSize),
                data1, data2, width, height, boxSize);
    }
    else
    {
        filter.filter(data2, width, height, boxSize);
        floatArrayEquals(String.format("Arrays do not match: [%dx%d] @ %.1f", width, height, boxSize), data1, data2,
                width, height, 0);
    }
}

项目：GDSC-SMLM 文件：IntBlockSumFilterTest.java

private void sumIsCorrect(int[] data, int width, int height, int boxSize, boolean internal,
        BlockSumDataFilter filter) throws ArrayComparisonFailure
{
    int[] data1 = data.clone();
    int[] data2 = data.clone();

    sum(data1, width, height, boxSize);
    if (internal)
    {
        filter.filterInternal(data2, width, height, boxSize);
        intArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %d", width, height, boxSize), data1,
                data2, width, height, boxSize);
    }
    else
    {
        filter.filter(data2, width, height, boxSize);
        intArrayEquals(String.format("Arrays do not match: [%dx%d] @ %d", width, height, boxSize), data1, data2,
                width, height, 0);
    }
}

项目：GDSC-SMLM 文件：AverageFilterTest.java

private void averageIsCorrect(int width, int height, float boxSize, boolean internal, DataFilter filter)
        throws ArrayComparisonFailure
{
    rand = new gdsc.core.utils.Random(-30051976);
    float[] data1 = createData(width, height);
    float[] data2 = data1.clone();

    AverageFilterTest.average(data1, width, height, boxSize);
    if (internal)
    {
        filter.filterInternal(data2, width, height, boxSize);
        floatArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %.1f", width, height, boxSize),
                data1, data2, width, height, boxSize);
    }
    else
    {
        filter.filter(data2, width, height, boxSize);
        floatArrayEquals(String.format("Arrays do not match: [%dx%d] @ %.1f", width, height, boxSize), data1,
                data2, width, height, 0);
    }
}

项目：GDSC-SMLM 文件：BlockMeanFilterTest.java

private void meanIsCorrect(float[] data, int width, int height, float boxSize, boolean internal, BlockMeanDataFilter filter)
        throws ArrayComparisonFailure
{
    float[] data1 = data.clone();
    float[] data2 = data.clone();

    mean(data1, width, height, boxSize);
    if (internal)
    {
        filter.filterInternal(data2, width, height, boxSize);
        floatArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %.1f", width, height, boxSize),
                data1, data2, width, height, boxSize);
    }
    else
    {
        filter.filter(data2, width, height, boxSize);
        floatArrayEquals(String.format("Arrays do not match: [%dx%d] @ %.1f", width, height, boxSize), data1, data2,
                width, height, 0);
    }
}

项目：java-unit 文件：TestBase.java

private static void arrayNotEquals(String message, Object expecteds, Object actuals)
        throws ArrayComparisonFailure {
    if (expecteds == actuals
            || Arrays.deepEquals(new Object[] {expecteds}, new Object[] {actuals})) {
        // The reflection-based loop below is potentially very slow, especially for primitive
        // arrays. The deepEquals check allows us to circumvent it in the usual case where
        // the arrays are exactly equal.
        fail(message);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final char[] expecteds, final char[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final float[] expecteds, final float[] actuals, final float delta) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals, delta);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final double[] expecteds, final double[] actuals, final double delta) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals, delta);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final Object[] expecteds, final Object[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final short[] expecteds, final short[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final byte[] expecteds, final byte[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final long[] expecteds, final long[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：vertx-zero 文件：AsyncTestBase.java

protected void assertArrayEquals(final String message, final int[] expecteds, final int[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message, expecteds, actuals);
    } catch (final AssertionError e) {
        handleThrowable(e);
    }
}

项目：hashsdn-controller 文件：LLDPTest.java

private static int checkTLV(final byte[] serializedData, final int offset, final byte typeTLVBits, final String typeTLVName,
        final short lengthTLV, final byte[] valueTLV, final byte... bytesBeforeValue) throws ArrayComparisonFailure {
    byte[] concreteTlvAwaited = awaitedBytes(typeTLVBits, lengthTLV, valueTLV, bytesBeforeValue);
    int concreteTlvAwaitLength = concreteTlvAwaited.length;
    assertArrayEquals("Serialization problem " + typeTLVName, concreteTlvAwaited,
            ArrayUtils.subarray(serializedData, offset, offset + concreteTlvAwaitLength));
    return offset + concreteTlvAwaitLength;
}