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,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,BoxSize);
        floatArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %.1f",BoxSize),data1,data2,BoxSize);
    }
    else
    {
        filter.filter(data2,BoxSize);
        floatArrayEquals(String.format("Arrays do not match: [%dx%d] @ %.1f",0);
    }
}

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

private void sumIsCorrect(int[] data,int BoxSize,BlockSumDataFilter filter) throws ArrayComparisonFailure
{
    int[] data1 = data.clone();
    int[] data2 = data.clone();

    sum(data1,BoxSize);
        intArrayEquals(String.format("Internal arrays do not match: [%dx%d] @ %d",BoxSize);
        intArrayEquals(String.format("Arrays do not match: [%dx%d] @ %d",0);
    }
}

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

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

    AverageFilterTest.average(data1,0);
    }
}

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

private void meanIsCorrect(float[] data,BlockMeanDataFilter filter)
        throws ArrayComparisonFailure
{
    float[] data1 = data.clone();
    float[] data2 = data.clone();

    mean(data1,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,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,final Object[] expecteds,final Object[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message,final short[] expecteds,final short[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message,final byte[] expecteds,final byte[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message,final long[] expecteds,final long[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message,final int[] expecteds,final int[] actuals) throws ArrayComparisonFailure {
    checkThread();
    try {
        Assert.assertArrayEquals(message,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;
}