हैमक्रिस्ट क्यों कहता है कि बाइट 0 int 0 के बराबर नहीं है?

Question

मानक का उपयोग निम्नलिखित परीक्षण मामले पर विचार करें JUnit का दावा है और hamcrest के 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 
} 

कि इतने क्यों है? मान JVM के लिए स्पष्ट रूप से बराबर हैं क्योंकि b == itrue है, तो hamcrest क्यों विफल हो जाता है?

Answer 1

Assert#assertThat एक सामान्य विधि है। आदिम प्रकार जेनेरिक के साथ काम नहीं करते हैं। इस मामले में, byte और int को क्रमश: Byte और Integer पर बॉक्स किया गया है।

यह तो (assertThat भीतर)

Byte b = 0; 
Integer i = 0; 

b.equals(i); 

Byte#equals(Object) के कार्यान्वयन की जाँच करता हो जाता है तर्क प्रकार Byte की है, false तुरंत लौटने अगर यह नहीं है।

दूसरी ओर, assertEqualsAssert#assertEquals(long, long) जो मामले में दोनों byte और int तर्क long मूल्यों करने के लिए प्रोत्साहित कर रहे हैं। आंतरिक रूप से, यह दो प्राइमेटिव long मानों पर == का उपयोग करता है जो बराबर हैं।

---

ध्यान दें कि यह मुक्केबाजी रूपांतरण काम करता है क्योंकि assertThat

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

जहां byteT के लिए एक Byte को बॉक्सिंग के रूप में घोषित किया जाता है, और int एक (करने के लिए कॉल के भीतर एक Integer को बॉक्सिंग है equalTo), लेकिन के रूप में अनुमानित Matcher<? super T> से मेल खाता है।

यह जावा 8 के बेहतर जेनेरिक अनुमान के साथ काम करता है। आप इसे

Answer 2

जावा 7 में काम करते हैं यह इसलिए होता है क्योंकि int और byteInteger और Byte को बॉक्सिंग कर रहे हैं के रूप में hamcrest matchers वस्तुओं पर, पुरातन पर नहीं संचालित करने के लिए स्पष्ट प्रकार तर्क आवश्यकता होगी। तो तुम एक Byte के साथ एक Integer तुलना कर रहे हैं, और Byte.equals() के कार्यान्वयन है:

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

और Integer.equals():

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

दूसरे शब्दों में, एक Integer और Byte हमेशा असमान हैं। प्राइमेटिव की तुलना करते समय, बस इसके बजाय Assert.assertEquals का उपयोग करें। हैमक्रिस्ट मैचर्स शक्तिशाली हैं, लेकिन ज्यादातर (जटिल) ऑब्जेक्ट दावे के लिए लक्षित हैं।