Java junit数组不相等测试

我试图编写一个测试用例，其中我的场景是两个字节数组应该不相等

我可以用junit做这个吗

或者我必须使用像Hamcrest这样的外部设备

请提供样品。

您可以使用

assertFalse(Arrays.equals(array1, array2));

如果您想检查它们是否相等，我将使用以下内容

assertEquals(Arrays.toString(array1), Arrays.toString(array2));

---

因为这会产生一个可读的输出，说明什么是不同的，而不仅仅是失败。

我更喜欢用Hamcrest的方式，它更具表现力：

Assert.assertThat(array1, IsNot.not(IsEqual.equalTo(array2)));

或具有静态导入的短版本：

assertThat(array1, not(equalTo(array2)));

（幸运的是，

IsEqual

matcher足够聪明，能够理解数组。）

---

请注意，Hamcrest的有限版本是JUnit 4.x发行版的一部分，因此您不需要添加外部库。

JUnit的较新版本提供了

org.JUnit.Assert.assertArrayEquals（byte[]，byte[]）

，并为其他数组类型提供重载。失败显示第一个索引不匹配以及该索引处的不同元素

---

我还喜欢

assertEquals（Arrays.asList（预期）、Arrays.asList（实际））

。上面提到的Hamcrest支持的格式副本可能是最好的。

这里有一个可能的替代方案，其优点是使用与

AssertArrayQuals（）相同的代码。

：

---

抱歉，这有点长，但很容易调试，您可以将其剪切并粘贴到单元测试中

private int span = 10;

private boolean equal(byte[] expected, byte[] got) {
    final boolean result;

    String message = null;
    int offset = -1;
    int length = -1;
    if(expected == null && got == null) {
        result = true;
    } else if(expected == null || got == null) {
        message = "One array is null: " + (expected == null ? "expected" : "got");
        result = false;
    } else if(expected.length != got.length) {
        message = "Lengths differ: expected = " + expected.length + ", got = " + got.length;
        result = false;
    } else {
        length = expected.length;
        for(int i = 0; i < length; i++) {
            if(expected[i] != got[i]) {
                offset = i;
                break;
            }
        }
        result = offset == -1;
        if(!result) {
            message = "Contents differ";
        }
    }

    if(!result) {
        System.err.println(message);
        if(offset >= 0) {
            hexDump("Expected: ", expected, offset, length);
            hexDump("     Got: ", got, offset, length);
        }
    }
    return result;
}

private void hexDump(String label, byte[] ba, int offset, int length) {
    System.err.print(label);
    if(ba == null) {
        System.err.println("<null>");
    } else if(ba.length == 0) {
        System.err.println("<zero-length-array>");
    } else {
        // <span> bytes either side

        final int from = Math.max(0, offset - span);
        final int to = Math.min(length, offset + span);
        if(from != 0) {
            System.err.print("(offset:" + from + ") ");
        }
        for(int i = from; i < to; i++) {
            System.err.printf("%02X ", new Byte(ba[i]));
        }
        System.err.println();
    }
}

@Test
public void testExample() {
    assertTrue(equal(new byte[] { 1, 2, 3 }, new byte[] { 1, 8, 3 }));
}

private int span=10；
专用布尔值相等（需要字节[]，得到字节[]）{
最终布尔结果；
字符串消息=null；
整数偏移量=-1；
整数长度=-1；
if（预期==null&&get==null）{
结果=真；
}else if（预期==null | | get==null）{
message=“一个数组为null:”+（预期==null？“预期”：“got”）；
结果=假；
}else if（expected.length！=get.length）{
message=“长度不同：expected=“+expected.length+”，got=“+got.length；
结果=假；
}否则{
长度=预期长度；
for（int i=0；i=0）{
hextump（“预期：”，预期，偏移，长度）；
hextump（“Got:”，Got，offset，length）；
}
}
返回结果；
}
私有void hextump（字符串标签，字节[]ba，整数偏移量，整数长度）{
系统错误打印（标签）；
if（ba==null）{
System.err.println（“”）；
}else if（ba.length==0）{
System.err.println（“”）；
}否则{
//两侧的字节数
最终整数from=Math.max（0，偏移量-span）；
最终int to=数学最小值（长度、偏移量+跨度）；
如果（从！=0）{
系统错误打印（（偏移量：“+自+”）；
}
for（int i=from；i

你是说Arrays.equals（）？@Peter是的，但我还是喜欢Hamcrest方法。简短的版本看起来更可读。我更倾向于表现狂。。。我假设IsEquals对数组有特殊的处理，并且没有使用

equals（）

，这是一个好主意，但是这个答案并不是按原样编译的，如果它可用的话，那么如何使用它并不明显。从try catch（将其视为成功）捕获并忽略一个

AssertionError

，也将从

fail

捕获断言错误，并将其视为成功。建议更新代码或删除此答案。@Krease你是对的，我不知道我在发布时是怎么想的。我已经更正了代码。问题是测试数组不等于，对吗？不使用Hamcrest的情况如何？有办法吗？

private int span = 10;

private boolean equal(byte[] expected, byte[] got) {
    final boolean result;

    String message = null;
    int offset = -1;
    int length = -1;
    if(expected == null && got == null) {
        result = true;
    } else if(expected == null || got == null) {
        message = "One array is null: " + (expected == null ? "expected" : "got");
        result = false;
    } else if(expected.length != got.length) {
        message = "Lengths differ: expected = " + expected.length + ", got = " + got.length;
        result = false;
    } else {
        length = expected.length;
        for(int i = 0; i < length; i++) {
            if(expected[i] != got[i]) {
                offset = i;
                break;
            }
        }
        result = offset == -1;
        if(!result) {
            message = "Contents differ";
        }
    }

    if(!result) {
        System.err.println(message);
        if(offset >= 0) {
            hexDump("Expected: ", expected, offset, length);
            hexDump("     Got: ", got, offset, length);
        }
    }
    return result;
}

private void hexDump(String label, byte[] ba, int offset, int length) {
    System.err.print(label);
    if(ba == null) {
        System.err.println("<null>");
    } else if(ba.length == 0) {
        System.err.println("<zero-length-array>");
    } else {
        // <span> bytes either side

        final int from = Math.max(0, offset - span);
        final int to = Math.min(length, offset + span);
        if(from != 0) {
            System.err.print("(offset:" + from + ") ");
        }
        for(int i = from; i < to; i++) {
            System.err.printf("%02X ", new Byte(ba[i]));
        }
        System.err.println();
    }
}

@Test
public void testExample() {
    assertTrue(equal(new byte[] { 1, 2, 3 }, new byte[] { 1, 8, 3 }));
}