Perché hamcrest dice che un byte 0 non è uguale a un int 0?

Question

Si consideri il seguente caso di test con lo standard JUnit afferma e hamcrest di assertThat:

byte b = 0; 
int i = 0; 

assertEquals(b, i); // success 
assertThat(b, equalTo(i)); // java.lang.AssertionError: Expected: <0> but: was <0> 

if (b == i) { 
    fail(); // test fails, so b == i is true for the JVM 
} 

Perché è così? I valori sono apparentemente uguali per JVM perché b == i è true, quindi perché hamcrest non riesce?

Answer 1

Assert#assertThat è un metodo generico. I tipi primitivi non funzionano con i generici. In questo caso, lo e sono inseriti rispettivamente in Byte e Integer.

diventa quindi (entro assertThat)

Byte b = 0; 
Integer i = 0; 

b.equals(i); 

s' Byte#equals(Object) controlli di implementazione se l'argomento è di tipo Byte, tornando false immediatamente se non lo è.

D'altra parte, è assertEqualsAssert#assertEquals(long, long) nel qual caso entrambe le byte e int argomenti sono promossi al long valori. Internamente, questo utilizza == su due valori primitivi long uguali.

---

Si noti che questa conversione boxe funziona perché assertThat è dichiarato come

public static <T> void assertThat(T actual, Matcher<? super T> matcher) { 

dove il byte è inscatolato ad un Byte per T, e il int è una scatola a un Integer (all'interno della chiamata a equalTo), ma dedotto come Number per corrispondere allo Matcher<? super T>.

Questo funziona con inferenza generica migliorata di Java 8. Avreste bisogno di argomenti di tipo esplicite per farlo funzionare in Java 7.

Answer 2

Questo accade perché la int e byte sono boxed per Integer e Byte come matchers hamcrest operano su oggetti, non su primitive. Così si sta confrontando un Integer con un Byte, e l'implementazione di Byte.equals() è:

public boolean equals(Object obj) { 
    if (obj instanceof Byte) { 
     return value == ((Byte)obj).byteValue(); 
    } 
    return false; 
} 

e Integer.equals():

public boolean equals(Object obj) { 
    if (obj instanceof Integer) { 
     return value == ((Integer)obj).intValue(); 
    } 
    return false; 
} 

In altre parole, un Integer e Byte sono sempre disuguale. Quando si confrontano le primitive, utilizzare invece Assert.assertEquals. Gli hamcrest matcher sono potenti, ma principalmente pensati per (complesse) asserzioni di oggetti.