Non capisco esattamente l'utilità del secondo pezzo di codice (@Before e @Test). Su Eclipse leggo Errori 0 quindi dovrebbe essere tutto a posto ma non capisco che tipo di test fa.
Cod 1
codice:
package lab1b;
public class Customer {
private String name;
private String address;
private double amountInvoiced;
void SetName(String x) {
this.name=x;
}
void SetAddress(String y) {
this.address=y;
}
void SetAmountInvoiced(double z) {
this.amountInvoiced=z;
}
String GetName() {
//posso anche scrivere 'return name;'
return this.name;
}
String GetAddress() {
return this.address;
}
double GetAmountInvoiced() {
return this.amountInvoiced;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((address == null) ? 0 : address.hashCode());
long temp;
temp = Double.doubleToLongBits(amountInvoiced);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Customer)) {
return false;
}
Customer other = (Customer) obj;
if (address == null) {
if (other.address != null) {
return false;
}
} else if (!address.equals(other.address)) {
return false;
}
if (Double.doubleToLongBits(amountInvoiced) != Double.doubleToLongBits(other.amountInvoiced)) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
return true;
}
}
Cod 2
codice:
package lab1b;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
public class CustomerTest {
private Customer c1, c2;
@Before
public void init() {
c1=new Customer();
c2=new Customer();
}
@Test
public void testEqualsOk() {
assertTrue(c1.equals(c2));
}
}
In pratica, se ho capito bene, il secondo codice verifica che il metodo equals() riscritto con @Override al passaggio precedente funzioni alla perfezione e non contenga errori ma non capisco quali test esegua?
Se scrivo:
codice:
@Override
public boolean equals(Object obj) {
return true;
}
i test passano tranquillamente dunque questo codice a che serve?
codice:
package lab1b;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
public class CustomerTest {
private Customer c1, c2;
@Before
public void init() {
c1=new Customer();
c2=new Customer();
}
@Test
public void testEqualsOk() {
assertTrue(c1.equals(c2));
}
}
Perché è così importante!?! jUnit non dovrebbe prendere tutti i possibili valori dei singoli oggetti e testare che l'equals() di @Override funzioni esattamente come l'equals() originale?
jUnit non dovrebbe fare qualcosa di più raffinato di quello che vi scrivo qui sotto?!?!
codice:
package lab1b;
public class TestSemplice {
public static void main( String[] args ) {
Customer A = new Customer();
A.SetName("Marco");
A.SetAddress("Rossi");
A.SetAmountInvoiced(12.695);
System.out.println(A.GetName());
System.out.println(A.GetAddress());
System.out.println(A.GetAmountInvoiced());
Customer B = new Customer();
B.SetName("Marco");
B.SetAddress("Rossi");
B.SetAmountInvoiced(12.695);
System.out.println(B.GetName());
System.out.println(B.GetAddress());
System.out.println(B.GetAmountInvoiced());
//Senza @Override i due oggetti sono diversi
System.out.println(A.equals(B));
System.out.println("%%% TEST 1 %%%");
if(A.equals(B) && A.hashCode()==B.hashCode()) {
System.out.println("Gli oggetti confrontati con equals() e hashCode() modificati con @Override coincidono.");
} else {
System.out.println("Gli oggetti confrontati sono differenti.");
}
//hash() genera un codice a partire da una serie di oggetti
//Se i 3 oggetti che compongono le 2 classi sono rispettivamente identici i codici hash coincidono
System.out.println(A.hashCode());
System.out.println(B.hashCode());
//Altro esempio
Customer C = new Customer();
Customer D = null;
System.out.println("%%% TEST 2 %%%");
if(C.equals(D) && C.hashCode()==D.hashCode()) {
System.out.println("Gli oggetti confrontati con equals() e hashCode() modificati con @Override coincidono.");
} else {
System.out.println("Gli oggetti confrontati sono differenti.");
}
}
}
ciao