Perché asserireEquals e assertSame in junit restituiscono lo stesso risultato per due istanze della stessa classe?

Question

Secondo la documentazione

assertEquals() asserisce che due oggetti sono uguali.

assertSame() Asserisce che due oggetti si riferiscono allo stesso oggetto.

Quindi mi aspetto che se ho una classe come sotto

class SomeClass {} 

poi

SomeClass someClass1= new SomeClass(); 
SomeClass someClass2= new SomeClass(); 
assertSame(someClass1,someClass2); // fail 
assertEquals(someClass1,someClass2); // fail 

le assertEquals passare e assertSame fallire. poiché il valore di entrambe le classi è uguale ma hanno una posizione di riferimento diversa.

Come risultato negativo in entrambi i casi, quindi la mia domanda è quali sono le differenze tra questi due?

Answer 1

Poiché non è stato eseguito l'override degli uguali nella classe, assertEquals si comporta come assertSame poiché il valore predefinito corrisponde ai riferimenti di confronto dell'implementazione.

150 public boolean equals(Object obj) { 
151  return (this == obj); 
152 } 

Se si fornisce un imperativo muto di eguali:

class SomeClass { 
    @Override 
    public boolean equals(Object o) { 
     return true; 
    } 
} 

vedrai che assertEquals riesce.

Answer 2

assertEquals usa equals() metodo (che si dovrebbe ignorare nella classe di confrontare realmente le sue istanze) per confrontare gli oggetti, mentre assertSame usa == operatore per confrontarli. Quindi la differenza è esattamente la stessa compresa tra == (confronta per valore) e equals (confronta identità).

Answer 3

Il primo asserimento non riesce perché someClass1 e sameClass2 non sono le stesse istanze. La seconda affermazione fallisce perché il metodo equals(Object) non è stato definito in SomeClass e il suo super equals(Object) fa uguaglianza di riferimento. Poiché due diverse istanze vengono confrontate per l'uguaglianza, questa fallisce per la stessa ragione della prima.

Answer 4

Ufficiale documentazione JUnit:

assertEquals: afferma che due oggetti sono uguali .

assertSame: asserisce che due oggetti si riferiscono allo stesso oggetto .

In altre parole

assertEquals: utilizza l'uguale() metodo, o se eguali() metodo è stato ignorato, confronta il riferimento tra le 2 oggetti.

assertSame: confronta il riferimento tra i 2 oggetti.

Esempio 1: uguale metodo era non override, così assertSame e assertEquals restituiscono lo stesso risultato, poiché confronta riferimento degli oggetti.

public class A {  
    private int i; 
    public A(int i){ this.i = i; } 
} 

public class TestA { 
    final A a1 = new A(0); 
    final A a2 = new A(0); 

    @Test 
    public void assertsame_testAssertSame(){ 
     assertSame(a1, a2); // AssertionError: expected:<test2.A@7f13d6e> but was:<test2.A@51cdd8a> 
    } 

    @Test 
    public void assertsame_testAssertEquals(){ 
     assertEquals(a1, a2); // AssertionError: expected:<test2.A@7f13d6e> but was:<test2.A@51cdd8a> 
    } 
} 

Esempio 2: uguale metodo è stato ignorato, così assertSame e assertEquals restituiscono lo stesso risultato non, in quanto il metodo equals verrà utilizzato da assertEquals questo momento.

public class A { 
    private int i; 
    public A(int i){ this.i = i; } 

    @Override 
    public boolean equals(Object o){ 
     // self check 
     if(this == o){ return true; } else 
     // null check 
     if(o == null){ return false;} else 
     // type check and cast 
     if(getClass() != o.getClass()){ return false; } else { 
      final A a = (A) o; 
      // field comparison 
      return Objects.equals(a, a); 
     } 
    } 
} 
public class TestA { 
    final A a1 = new A(0); 
    final A a2 = new A(0); 

    @Test 
    public void assertsame_testAssertSame(){ 
     assertSame(a1, a2); // AssertionError: expected:<test2.A@7f13d6e> but was:<test2.A@51cdd8a> 
    } 

    @Test 
    public void assertsame_testAssertEquals(){ 
     assertEquals(a1, a2); // OK 
    } 
}