146

假设我有一个没有 equals() 方法的类，它没有源。我想在该类的两个实例上断言相等。

我可以做多个断言：

assertEquals(obj1.getFieldA(), obj2.getFieldA());
assertEquals(obj1.getFieldB(), obj2.getFieldB());
assertEquals(obj1.getFieldC(), obj2.getFieldC());
...

我不喜欢这种解决方案，因为如果早期断言失败，我将无法获得完整的平等图景。

我可以自己手动比较并跟踪结果：

String errorStr = "";
if(!obj1.getFieldA().equals(obj2.getFieldA())) {
    errorStr += "expected: " + obj1.getFieldA() + ", actual: " + obj2.getFieldA() + "\n";
}
if(!obj1.getFieldB().equals(obj2.getFieldB())) {
    errorStr += "expected: " + obj1.getFieldB() + ", actual: " + obj2.getFieldB() + "\n";
}
...
assertEquals("", errorStr);

这给了我完整的平等画面，但很笨拙（我什至没有考虑可能的空问题）。第三种选择是使用 Comparator，但 compareTo() 不会告诉我哪些字段不相等。

有没有更好的做法来从对象中获取我想要的东西，而不需要子类化和覆盖等于（呃）？

4

23 回答 23

90

这里有很多正确的答案，但我也想添加我的版本。这是基于 Assertj 的。

import static org.assertj.core.api.Assertions.assertThat;

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .isEqualToComparingFieldByFieldRecursively(expectedObject);
    }
}

更新：在 assertj v3.13.2 中，此方法已弃用，正如 Woodz 在评论中指出的那样。目前的建议是

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .usingRecursiveComparison()
            .isEqualTo(expectedObject);
    }

}
于 2017-06-27T13:41:42.490 回答
81

Mockito提供了一个反射匹配器：

对于最新版本的 Mockito，请使用：

Assert.assertTrue(new ReflectionEquals(expected, excludeFields).matches(actual));

对于旧版本，请使用：

Assert.assertThat(actual, new ReflectionEquals(expected, excludeFields));
于 2015-04-22T09:37:39.523 回答
52

我通常使用 org.apache.commons.lang3.builder.EqualsBuilder 来实现这个用例

Assert.assertTrue(EqualsBuilder.reflectionEquals(expected,actual));
于 2014-03-03T23:25:42.350 回答
14

我知道它有点旧，但我希望它有所帮助。

我遇到了和你一样的问题，所以，经过调查，我发现很少有与这个问题相似的问题，并且在找到解决方案后，我在这些问题中回答相同，因为我认为它可以帮助别人。

这个类似问题的投票最多的答案（不是作者选择的答案）是最适合您的解决方案。

基本上，它包括使用名为Unitils的库。

这是用途：

User user1 = new User(1, "John", "Doe");
User user2 = new User(1, "John", "Doe");
assertReflectionEquals(user1, user2);

即使类User没有实现，它也会通过equals()。assertLenientEquals您可以在他们的教程中看到更多示例和一个非常酷的断言。

于 2014-12-17T17:06:44.173 回答
12

如果您将 hamcrest 用于您的断言 (assertThat) 并且不想引入额外的测试库，那么您可以使用SamePropertyValuesAs.samePropertyValuesAs断言没有覆盖的 equals 方法的项目。

好处是你不必再引入另一个测试框架，当断言失败时它会给出一个有用的错误 ( expected: field=<value> but was field=<something else>) 而不是expected: true but was false如果你使用类似EqualsBuilder.reflectionEquals().

缺点是它是一个浅比较并且没有排除字段的选项（就像在 EqualsBuilder 中一样），因此您必须解决嵌套对象（例如删除它们并独立比较它们）。

最佳案例：

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
assertThat(actual, is(samePropertyValuesAs(expected)));

丑陋的案例：

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
SomeClass expected = buildExpected(); 
SomeClass actual = sut.doSomething();

assertThat(actual.getSubObject(), is(samePropertyValuesAs(expected.getSubObject())));    
expected.setSubObject(null);
actual.setSubObject(null);

assertThat(actual, is(samePropertyValuesAs(expected)));

所以，选择你的毒药。附加框架（例如 Unitils）、无用的错误（例如 EqualsBuilder）或浅比较（hamcrest）。

于 2018-03-01T03:52:09.400 回答
9

您可以使用Apache commons lang ReflectionToStringBuilder

您可以一一指定要测试的属性，或者更好地排除您不想要的属性：

String s = new ReflectionToStringBuilder(o, ToStringStyle.SHORT_PREFIX_STYLE)
                .setExcludeFieldNames(new String[] { "foo", "bar" }).toString()

然后，您可以正常比较这两个字符串。关于反射缓慢的观点，我认为这只是为了测试，所以不应该那么重要。

于 2012-08-28T07:33:43.317 回答
5

由于这个问题很老，我将建议使用 JUnit 5 的另一种现代方法。

我不喜欢这种解决方案，因为如果早期断言失败，我将无法获得完整的平等图景。

在 JUnit 5 中，有一个名为的方法Assertions.assertAll()允许您将测试中的所有断言组合在一起，它将执行每个断言并在最后输出任何失败的断言。这意味着任何首先失败的断言都不会停止后面断言的执行。

assertAll("Test obj1 with obj2 equality",
    () -> assertEquals(obj1.getFieldA(), obj2.getFieldA()),
    () -> assertEquals(obj1.getFieldB(), obj2.getFieldB()),
    () -> assertEquals(obj1.getFieldC(), obj2.getFieldC()));
于 2020-01-29T03:51:15.463 回答
4

Hamcrest 1.3 Utility Matchers库有一个特殊的匹配器，它使用反射而不是等于。

assertThat(obj1, reflectEquals(obj2));
于 2015-01-07T10:48:15.127 回答
3

一些反射比较方法很浅

另一种选择是将对象转换为 json 并比较字符串。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;    
public static String getJsonString(Object obj) {
 try {
    ObjectMapper objectMapper = new ObjectMapper();
    return bjectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
     } catch (JsonProcessingException e) {
        LOGGER.error("Error parsing log entry", e);
        return null;
    }
}
...
assertEquals(getJsonString(MyexpectedObject), getJsonString(MyActualObject))
于 2018-03-26T21:31:13.013 回答
2

使用Shazamcrest，您可以：

assertThat(obj1, sameBeanAs(obj2));
于 2018-09-12T17:36:10.630 回答
1

逐个字段比较：

assertNotNull("Object 1 is null", obj1);
assertNotNull("Object 2 is null", obj2);
assertEquals("Field A differs", obj1.getFieldA(), obj2.getFieldA());
assertEquals("Field B differs", obj1.getFieldB(), obj2.getFieldB());
...
assertEquals("Objects are not equal.", obj1, obj2);
于 2012-08-27T18:23:11.567 回答
1

您可以使用反射来“自动化”完整的相等测试。您可以实现为单个字段编写的相等“跟踪”代码，然后使用反射在对象中的所有字段上运行该测试。

于 2012-08-27T18:50:17.383 回答
1

AssertJ 断言可用于在没有#equals正确覆盖方法的情况下比较值，例如：

import static org.assertj.core.api.Assertions.assertThat; 

// ...

assertThat(actual)
    .usingRecursiveComparison()
    .isEqualTo(expected);
于 2019-12-09T07:42:00.863 回答
0

在对 Android 应用程序进行单元测试时，我遇到了完全相同的难题，而我想出的最简单的解决方案就是使用Gson将我的实际值和期望值对象转换json为字符串并将它们作为字符串进行比较。

String actual = new Gson().toJson( myObj.getValues() );
String expected = new Gson().toJson( new MyValues(true,1) );

assertEquals(expected, actual);

与逐个字段手动比较相比，此方法的优点是您可以比较所有字段，因此即使您稍后在类中添加一个新字段，它也会自动测试，而不是使用assertEquals()一堆所有字段，如果您向班级添加更多字段，则需要更新这些字段。

jUnit 还为您显示字符串，以便您可以直接查看它们的不同之处。不确定字段排序的可靠性如何Gson，这可能是一个潜在的问题。

于 2018-04-07T09:29:13.120 回答
0

对于单元测试，我只是将对象序列化为 JSON 字符串并进行比较。以 Gson 为例：

import com.google.gson.GsonBuilder
import junit.framework.TestCase.assertEquals

class AssertEqualContent {
    companion object {
        val gson = GsonBuilder().create()

        fun assertEqualContent(message: String?, expected: Any?, actual: Any?) {
            assertEquals(message, gson.toJson(expected), gson.toJson(actual))
        }
    }
}

由于预期的和实际的对象应该是相同的类型，因此字段顺序将是相同的。

优点：

  • 你会得到一个很好的字符串比较，准确地指出差异在哪里。
  • 没有额外的库（前提是你已经有一个 JSON 库）

缺点：

  • 不同类型的对象可能会产生相同的 JSON（但如果有，您可能会考虑为什么对相同的数据有不同的类......以及它们最终如何在测试方法中进行比较 :-)
于 2021-05-20T13:44:51.003 回答
0

这是一个通用的比较方法，它比较同一类的两个对象的字段值（记住那些可以通过 get 方法访问）

public static <T> void compare(T a, T b) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    AssertionError error = null;
    Class A = a.getClass();
    Class B = a.getClass();
    for (Method mA : A.getDeclaredMethods()) {
        if (mA.getName().startsWith("get")) {
            Method mB = B.getMethod(mA.getName(),null );
            try {
                Assert.assertEquals("Not Matched = ",mA.invoke(a),mB.invoke(b));
            }catch (AssertionError e){
                if(error==null){
                    error = new AssertionError(e);
                }
                else {
                    error.addSuppressed(e);
                }
            }
        }
    }
    if(error!=null){
        throw error ;
    }
}
于 2017-02-01T19:19:02.333 回答
0

我偶然发现了一个非常相似的案例。

我想在测试中比较一个对象与另一个对象具有相同的属性值，但是由于我的对象在其属性中具有空值等原因，诸如is(),refEq()等方法将不起作用。id

所以这是我找到的解决方案（好吧，一位同事找到了）：

import static org.apache.commons.lang.builder.CompareToBuilder.reflectionCompare;

assertThat(reflectionCompare(expectedObject, actualObject, new String[]{"fields","to","be","excluded"}), is(0));

如果从中获得的reflectionCompare值为0，则表示它们相等。如果是 -1 或 1，则它们在某些属性上有所不同。

于 2017-05-19T16:45:01.500 回答
0

在 AssertJ 的常见情况下，您可以创建自定义比较器策略：

assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam)
assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator).contains(sauron);

在断言中使用自定义比较策略

AssertJ 示例

于 2017-10-02T21:39:09.023 回答
0

我尝试了所有答案，但没有什么对我真正有用。

所以我创建了自己的方法来比较简单的 java 对象而不深入嵌套结构......

如果所有字段都匹配或包含不匹配详细信息的字符串，则方法返回 null。

仅比较具有 getter 方法的属性。

如何使用

        assertNull(TestUtils.diff(obj1,obj2,ignore_field1, ignore_field2));

不匹配时的示例输出

输出显示比较对象的属性名称和各自的值

alert_id(1:2), city(Moscow:London)

代码（Java 8 及以上）：

 public static String diff(Object x1, Object x2, String ... ignored) throws Exception{
        final StringBuilder response = new StringBuilder();
        for (Method m:Arrays.stream(x1.getClass().getMethods()).filter(m->m.getName().startsWith("get")
        && m.getParameterCount()==0).collect(toList())){

            final String field = m.getName().substring(3).toLowerCase();
            if (Arrays.stream(ignored).map(x->x.toLowerCase()).noneMatch(ignoredField->ignoredField.equals(field))){
                Object v1 = m.invoke(x1);
                Object v2 = m.invoke(x2);
                if ( (v1!=null && !v1.equals(v2)) || (v2!=null && !v2.equals(v1))){
                    response.append(field).append("(").append(v1).append(":").append(v2).append(")").append(", ");
                }
            }
        }
        return response.length()==0?null:response.substring(0,response.length()-2);
    }
于 2019-02-01T16:58:17.310 回答
-1

您可以将发布的比较代码放入一些静态实用程序方法中吗？

public static String findDifference(Type obj1, Type obj2) {
    String difference = "";
    if (obj1.getFieldA() == null && obj2.getFieldA() != null
            || !obj1.getFieldA().equals(obj2.getFieldA())) {
        difference += "Difference at field A:" + "obj1 - "
                + obj1.getFieldA() + ", obj2 - " + obj2.getFieldA();
    }
    if (obj1.getFieldB() == null && obj2.getFieldB() != null
            || !obj1.getFieldB().equals(obj2.getFieldB())) {
        difference += "Difference at field B:" + "obj1 - "
                + obj1.getFieldB() + ", obj2 - " + obj2.getFieldB();
        // (...)
    }
    return difference;
}

你可以像这样在 JUnit 中使用这个方法：

assertEquals("对象不相等", "", findDifferences(obj1, obj));

这并不笨拙，并且可以为您提供有关差异的完整信息（如果存在差异）（通过不完全采用 assertEqual 的正常形式，但您可以获得所有信息，所以它应该是好的）。

于 2012-08-27T18:33:24.140 回答
-1

作为 junit-only 的替代方案，您可以在 equals 断言之前将字段设置为 null：

    actual.setCreatedDate(null); // excludes date assertion
    expected.setCreatedDate(null);

    assertEquals(expected, actual);
于 2020-04-01T09:02:59.157 回答
-2

从您的评论到其他答案，我不明白您想要什么。

只是为了讨论，假设该类确实覆盖了 equals 方法。

所以你的 UT 看起来像：

SomeType expected = // bla
SomeType actual = // bli

Assert.assertEquals(expected, actual).

你完成了。此外，如果断言失败，您将无法获得“完全平等的画面”。

据我了解，您是说即使类型确实覆盖了equals，您也不会对此感兴趣，因为您想获得“完全相等的图片”。因此，扩展和覆盖 equals 也没有任何意义。

所以你必须选择：要么逐个比较属性，使用反射或硬编码检查，我建议后者。或者：比较这些对象的人类可读表示。

例如，您可以创建一个帮助类，将您希望与 XML 文档比较的类型序列化，然后比较生成的 XML！在这种情况下，您可以直观地看到什么是完全相等的，什么不是。

这种方法将使您有机会查看全貌，但它也相对繁琐（起初容易出错）。

于 2012-08-27T19:28:33.913 回答
-3

您可以覆盖类的 equals 方法，例如：

@Override
public int hashCode() {
    int hash = 0;
    hash += (app != null ? app.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    HubRule other = (HubRule) object;

    if (this.app.equals(other.app)) {
        boolean operatorHubList = false;

        if (other.operator != null ? this.operator != null ? this.operator
                .equals(other.operator) : false : true) {
            operatorHubList = true;
        }

        if (operatorHubList) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

好吧，如果你想比较一个类中的两个对象，你必须以某种方式实现 equals 和 hash code 方法

于 2012-08-27T18:20:00.173 回答