Comment JUnit tester ma méthode de clonage?

Question

J'ai une méthode clone dans ma Student classe et je suis en train de tester si elle fonctionne comme prévu (DOB et adresse et profonde clonés et bien sûr est peu profonde clonée)

J'ai besoin d'aide avec le deuxième morceau de code Je ne suis pas sûr de savoir comment tester correctement si l'adresse et date de naissance sont profondes clonés et bien sûr est peu profonde clonée

...

public Student clone() { 
    Student clone = new Student(); 
    clone.dob = (Date) this.dob.clone(); 
    clone.address = this.address.clone(); 
    clone.course = this.course; 
    return clone; 
} 

...

public void testCloning() { 
    Student test = clone? 
    assertEquals(Student, Student.clone()) 
} 

Answer 1

Si vous souhaitez tester de cette manière, vous devez remplacer les méthodes equals() et hashcode() en spécifiant tous les champs que vous souhaitez cloner.

Maintenant, est adapté et efficace pour remplacer equals() et hashcode() avec tous les champs si une information plus élémentaire peut identifier un Student exemple? Comme alternative serait de comparer que les valeurs des champs sont les mêmes avec les accesseurs de champ. En outre, les champs avec un clonage profond doivent également être confirmés en vérifiant que les objets ne sont pas identiques et les champs avec un clonage superficiel peuvent être simplement affirmés en vérifiant que les objets sont identiques.

Vous pouvez le faire par exemple:

@Test 
public void cloning() { 
    Student original = new Student(....); // 
    ... 
    Student cloned = original.clone(); 
    // deep check 
    assertEquals(original.getDob(), cloned.getDob()); 
    assertEquals(original.getAddress(), cloned.getAddress()); 
    assertNotSame(original.getDob(), cloned.getDob()); 
    assertNotSame(original.getAddress(), cloned.getAddress()); 

    // shallow check  
    assertSame(original.getCourse(), cloned.getCourse()); 
} 

Answer 2

Vous pouvez vérifier avec une combinaison de equals et ==. Quand vous faites un clone profond, vous voulez avoir un nouvel objet, qui est égal à l'ancien. Avec une copie superficielle, l'objet devrait être le même. Donc, vous pouvez vérifier la façon suivante:

public void testCloning() { 
    Student original = new Student(); 
    //Fill in values for original 
    Student clone = original.clone(); 
    assertEquals(Student, Student.clone()); 

    //Check like this for all deep cloned values 
    assertTrue(student.getAddress().equals(clone.getAddress())); 
    assertFalse(student.getAddress() == clone.getAddress()); 

    //Check like this for all shallow cloned values 
    assertTrue(student.getCourse() == clone.getCourse()); 
} 

Depuis equals doit retourner vrai (si elle est correctement mise en œuvre), vous ne devez pas vérifier equals avec des clones peu profonds.

Answer 3

Je suis en train de tester si elle fonctionne comme prévu (DOB et adresse et profonde clonés et bien sûr est peu profonde clonée)

public void testCloning() { 
    Student test = clone? 
    assertEquals(Student, Student.clone()) 
} 

assertEquals() dépend de la mise en œuvre de equals() dans le Student classe. Si vous ne l'avez pas implémenté, deux objets de la classe Student renverront false.

Une implémentation significative retournera true si les deux objets par rapport Student ont un contenu égal dans leurs variables membres, peu importe si elles partagent les mêmes objets en eux ou clones. Pour cela vous devez vérifier vos besoins (également membre clone de contenu variable) en vérifiant explicitement que les membres du Student clonés sont des objets différents:

@Test 
public void cloneCreatesDeepCopy() { 
    // arrange 
    Student original = new Student(/*any properties*/); 

    // act 
    Student cloned = original.clone(); 

    // assert 
    assertEquals("a clone should be equal to its original" ,original , cloned); 

    assertEquals("name is equal" ,original.getName() , cloned.getName()); 
    assertFalse("Name is a different string object", original.getName() == cloned.getName()); 

    assertEquals("last name is equal" ,original.getLastName() , cloned.getLastName()); 
    assertFalse("last Name is a different string object", original.getLastName() == cloned.getLastName()); 
    // and so on... 
}