Eşittir yöntemi olmadan iki sınıfta eşitliği nasıl iddia ederim?

Diyelim ki, kaynağa sahip olmayan equals () yöntemi olmayan bir sınıfım var. Bu sınıfın iki örneğinde eşitlik olduğunu iddia etmek istiyorum.

Birden çok iddia yapabilirim:

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

Bu çözümü sevmiyorum çünkü erken bir iddia başarısız olursa tam eşitlik resmini elde edemiyorum.

Manuel olarak kendi başıma karşılaştırabilir ve sonucu takip edebilirim:

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);

Bu bana tam bir eşitlik resmi veriyor, ancak hantal (ve olası boş problemleri bile hesaba katmadım). Üçüncü bir seçenek, Comparator'ı kullanmaktır, ancak CompareTo () hangi alanların eşitlikte başarısız olduğunu bana söylemeyecek.

Nesneden istediğimi alt sınıflara ayırmadan ve eşittir (ugh) geçersiz kılmadan elde etmek için daha iyi bir uygulama var mı?

Mockito bir yansıma eşleştirici sunar:

Mockito'nun en son sürümü için:

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

Daha eski sürümler için şunları kullanın:

Assert.assertThat(actual, new ReflectionEquals(expected, excludeFields));

Burada pek çok doğru cevap var ama ben de kendi versiyonumu eklemek istiyorum. Bu, Assertj'e dayanmaktadır.

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

public class TestClass {

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

GÜNCELLEME: assertj v3.13.2'de bu yöntem, Woodz tarafından yorumda belirtildiği gibi kullanımdan kaldırılmıştır. Mevcut öneri

public class TestClass {

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

}

Bu usecase'i genellikle org.apache.commons.lang3.builder.EqualsBuilder kullanarak uygularım

Assert.assertTrue(EqualsBuilder.reflectionEquals(expected,actual));

Biraz eski olduğunu biliyorum ama umarım yardımcı olur.

Seninle aynı problemle karşılaşıyorum, bu yüzden, araştırmadan sonra, bundan çok az benzer soru buldum ve çözümü bulduktan sonra, başkalarına yardım edebileceğini düşündüğüm için bunlarda da aynı cevabı veriyorum.

Bu benzer sorunun en çok oylanan yanıtı (yazar tarafından seçilen değil) sizin için en uygun çözümdür.

Temel olarak Unitils adlı kitaplığı kullanmaktan ibarettir. .

Kullanım şudur:

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

Sınıf Useruygulanmasa bile geçecek equals(). Daha fazla örnek ve eğitimlerinde adı assertLenientEqualsgeçen gerçekten harika bir iddia görebilirsiniz .

Kullanabilirsiniz Apache commons lang ReflectionToStringBuilder

Tek tek test etmek istediğiniz öznitelikleri belirtebilir veya daha iyisi istemediklerinizi hariç tutabilirsiniz:

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

Daha sonra iki dizgiyi normal olarak karşılaştırırsınız. Düşünmenin yavaş olduğu noktasında, bunun sadece test için olduğunu varsayıyorum, bu yüzden çok önemli olmamalı.

İddialarınız (assertThat) için hamcrest kullanıyorsanız ve ek test kütüphaneleri eklemek istemiyorsanız, o zaman kullanabilirsiniz SamePropertyValuesAs.samePropertyValuesAs geçersiz kılınmış eşittir yöntemine sahip olmayan öğeleri ileri sürmek .

Bunun tersi, başka bir test çerçevesini kullanmak zorunda olmamanız ve gibi bir şey kullanmanız expected: field=<value> but was field=<something else>yerine assert ( ) başarısız olduğunda yararlı bir hata verecektir .expected: true but was falseEqualsBuilder.reflectionEquals()

Olumsuz tarafı, yüzeysel bir karşılaştırma olması ve alanları hariç tutma seçeneğinin olmamasıdır (EqualsBuilder'da olduğu gibi), bu nedenle iç içe geçmiş nesneler etrafında çalışmanız gerekir (örneğin, onları kaldırıp bağımsız olarak karşılaştırın).

En iyi senaryo:

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

Çirkin Vaka:

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)));

Öyleyse zehirini seç. Ek çerçeve (ör. Unitiller), yardımcı olmayan hata (ör. EqualsBuilder) veya sığ karşılaştırma (hamcrest).

Hamcrest 1.3 Utility Matchers kütüphanesi , eşitler yerine yansıma kullanan özel bir eşleştiriciye sahiptir.

assertThat(obj1, reflectEquals(obj2));

Yansıma karşılaştırma yöntemlerinden bazıları sığdır

Diğer bir seçenek, nesneyi bir json'a dönüştürmek ve dizeleri karşılaştırmaktır.

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))

Shazamcrest kullanarak şunları yapabilirsiniz:

assertThat(obj1, sameBeanAs(obj2));

Alan bazında karşılaştırın:

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);

AssertJ iddiaları, #equalsmetot uygun şekilde geçersiz kılınmadan değerleri karşılaştırmak için kullanılabilir , örneğin:

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

// ...

assertThat(actual)
    .usingRecursiveComparison()
    .isEqualTo(expected);

Bu soru eski olduğu için JUnit 5 kullanarak başka bir modern yaklaşım önereceğim.

Bu çözümü sevmiyorum çünkü erken bir iddia başarısız olursa tam eşitlik resmini elde edemiyorum.

JUnit 5 ile, Assertions.assertAll()testinizdeki tüm iddiaları bir arada gruplandırmanıza izin verecek ve her birini çalıştıracak ve sonunda başarısız olan tüm iddiaları çıkaracak bir yöntem vardır . Bu, ilk önce başarısız olan herhangi bir iddianın sonraki iddiaların yürütülmesini durdurmayacağı anlamına gelir.

assertAll("Test obj1 with obj2 equality",
    () -> assertEquals(obj1.getFieldA(), obj2.getFieldA()),
    () -> assertEquals(obj1.getFieldB(), obj2.getFieldB()),
    () -> assertEquals(obj1.getFieldC(), obj2.getFieldC()));

Tam eşitlik testini "otomatikleştirmek" için yansımayı kullanabilirsiniz. Tek bir alan için yazdığınız eşitlik "izleme" kodunu uygulayabilir, ardından bu testi nesnedeki tüm alanlarda çalıştırmak için yansımayı kullanabilirsiniz.

Bu, aynı sınıftaki iki nesneyi kendi alanlarının değerleri için karşılaştıran genel bir karşılaştırma yöntemidir (bunlara get yöntemi ile erişilebilir olduğunu unutmayın)

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 ;
    }
}

Ben de çok benzer bir vakaya rastladım.

Ben bir nesne başka aynı özellik değerlerine sahip olduğu bir sınavda karşılaştırmak istedim, ama gibi yöntemler is(), refEq()vb onun içinde boş değeri olan benim nesne gibi nedenlerle iş olmaz idözniteliği.

Demek bulduğum çözüm buydu (bir iş arkadaşım bulundu):

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

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

Elde edilen değer reflectionCompare0 ise, eşit oldukları anlamına gelir. -1 veya 1 ise, bazı niteliklerde farklılık gösterirler.

AssertJ ile ortak bir durumda, özel karşılaştırma stratejisi oluşturabilirsiniz:

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

İddialarda özel bir karşılaştırma stratejisi kullanma

AssertJ örnekleri

Bir Android uygulamasını birim test ederken tam olarak aynı muammayı yaşadım ve bulduğum en kolay çözüm, gerçek ve beklenen değer nesnelerimi jsondizelere dönüştürmek ve bunları dizeler olarak karşılaştırmak için Gson'u kullanmaktı .

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

assertEquals(expected, actual);

Bunun manuel olarak alan bazında karşılaştırmaya göre avantajları, tüm alanlarınızı karşılaştırmanızdır , böylece daha sonra sınıfınıza yeni bir alan ekleseniz bile, bir grup kullanıyor olmanıza kıyasla, otomatik olarak test edilecektir.assertEquals() . sınıfınıza daha fazla alan eklerseniz güncellenmesi gereken tüm alanlar.

jUnit ayrıca dizeleri sizin için görüntüler, böylece nerede farklı olduklarını doğrudan görebilirsiniz. GsonYine de saha siparişinin ne kadar güvenilir olduğundan emin değilim , bu potansiyel bir sorun olabilir.

Tüm cevapları denedim ve hiçbir şey benim için gerçekten işe yaramadı.

Bu yüzden basit java nesnelerini iç içe geçmiş yapıların derinliklerine inmeden karşılaştıran kendi yöntemimi yarattım ...

Yöntem, tüm alanlar eşleşirse veya uyuşmayan ayrıntılar içeren dizeler varsa null döndürür.

Yalnızca alıcı yöntemi olan özellikler karşılaştırılır.

Nasıl kullanılır

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

Uyumsuzluk varsa örnek çıktı

Çıktı, karşılaştırılan nesnelerin özellik adlarını ve ilgili değerlerini gösterir

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

Kod (Java 8 ve üzeri):

 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);
    }

Yalnızca junit için bir alternatif olarak, eşittir iddiasından önce alanları null olarak ayarlayabilirsiniz:

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

    assertEquals(expected, actual);

Gönderdiğiniz karşılaştırma kodunu statik bir yardımcı program yöntemine koyabilir misiniz?

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;
}

Bu yöntemi JUnit'te şu şekilde kullanabilirsiniz:

assertEquals ("Nesneler eşit değildir", "", findDifferences (obj1, obj));

Bu hantal değildir ve eğer varlarsa, farklılıklar hakkında size tam bilgi verir (tam olarak normal bir assertEqual biçiminde olmasa da tüm bilgileri alırsınız, böylece iyi olmalıdır).

Bu, OP'ye yardımcı olmayacak, ancak burada sona eren herhangi bir C # geliştiricisine yardımcı olabilir ...

Gibi Enrique yayınlanmıştır , sen eşittir yöntemini geçersiz kılar.

Nesneden istediğimi alt sınıflara ayırmadan ve eşittir (ugh) geçersiz kılmadan elde etmek için daha iyi bir uygulama var mı?

Önerim, bir alt sınıf kullanmamaktır. Kısmi bir sınıf kullanın.

Kısmi Sınıf Tanımları (MSDN)

Yani sınıfınız şuna benzeyecektir ...

public partial class TheClass
{
    public override bool Equals(Object obj)
    {
        // your implementation here
    }
}

Java için, yansımayı kullanma önerisine katılıyorum. Mümkün olduğunca yansımayı kullanmaktan kaçınmanız gerektiğini unutmayın. Yavaştır, hata ayıklaması zordur ve gelecekte bakımı daha da zordur, çünkü IDE'ler bir alanı yeniden adlandırarak veya buna benzer bir şey yaparak kodunuzu bozabilir. Dikkatli ol!

Yorumlarınızdan diğer cevaplara, ne istediğinizi anlamıyorum.

Sırf tartışma adına, sınıfın eşittir yöntemini geçersiz kıldığını varsayalım.

Böylece UT'niz şuna benzer:

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

Assert.assertEquals(expected, actual). 

Ve bitirdiniz. Dahası, iddia başarısız olursa "tam eşitlik resmi" ni elde edemezsiniz.

Anladığım kadarıyla, tür eşittir geçersiz kılmış olsa bile, "tam eşitlik resmini" elde etmek istediğiniz için onunla ilgilenmeyeceğinizi söylüyorsunuz. Yani eşitleri genişletmenin ve geçersiz kılmanın da bir anlamı yok.

Yani seçeneklere sahip olmalısınız: ya mülkü mülke göre, yansıtma kullanarak ya da sabit kodlanmış kontroller kullanarak karşılaştırırsanız, ikincisini öneririm. Veya: bu nesnelerin insan tarafından okunabilir temsillerini karşılaştırın .

Örneğin, karşılaştırmak istediğiniz türü bir XML belgesiyle serileştiren ve daha sonra ortaya çıkan XML'i karşılaştıran bir yardımcı sınıf oluşturabilirsiniz! bu durumda tam olarak neyin eşit olup neyin olmadığını görsel olarak görebilirsiniz.

Bu yaklaşım size resmin tamamına bakma fırsatı verecektir, ancak aynı zamanda nispeten külfetli (ve ilk başta biraz hataya meyillidir).

Sınıfın eşittir yöntemini şu şekilde geçersiz kılabilirsiniz:

@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;
    }
}

Bir sınıftan iki nesneyi karşılaştırmak istiyorsanız, bir şekilde eşittir ve karma kod yöntemini uygulamalısınız.