J'ai une méthode de clonage dans ma classe Student et j'essaie de tester si elle fonctionne comme prévu (dob et adresse et cloné en profondeur et bien sûr cloné peu profond)

J'ai besoin d'aide avec le deuxième morceau de code, je ne sais pas comment tester correctement si l'adresse et le dob sont clonés en profondeur et bien sûr sont clonés peu profonds

...

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())
}
1
oneman 21 avril 2017 à 11:47

3 réponses

Meilleure réponse

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-il approprié et efficace de remplacer equals() et hashcode() par tous les champs si une information plus élémentaire peut identifier une instance Student?

Une autre manière serait de comparer que les valeurs des champs sont les mêmes avec les accesseurs de champ.
En outre, les champs avec clonage profond devraient également être affirmés en vérifiant que les objets ne sont pas les mêmes et les champs avec clonage superficiel pourraient être simplement affirmés en vérifiant que les objets sont les mêmes.

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());
}
4
davidxxx 21 avril 2017 à 09:05

Vous pouvez vérifier avec une combinaison de equals et ==.

Lorsque vous effectuez un clonage profond, vous voulez avoir un nouvel objet, qui équivaut à l'ancien. Avec une copie superficielle, l'objet doit être le même. Ainsi, vous pouvez vérifier comme suit:

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());
}

Puisque equals doit retourner true (s'il est implémenté correctement), vous n'avez pas à rechercher equals avec des clones superficiels.

0
SilverNak 21 avril 2017 à 09:00

J'essaie de tester si cela fonctionne comme prévu (dob et adresse et cloné en profondeur et bien sûr cloné peu profond)

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

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

Une implémentation significative renverra true si les deux objets Student comparés ont le même contenu dans leurs variables membres, qu'ils partagent les mêmes objets ou les clones. Pour cela, vous devez vérifier vos besoins (également cloner le contenu de la variable membre) en vérifiant explicitement que les membres du cloné Student 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...
}
0
Timothy Truckle 21 avril 2017 à 09:05