Bonne pratique de développement JUnit

Bonjour,

J'aurais une question vis-à-vis des bonnes pratiques de développement pour les tests unitaires avec JUnit. Bien que je n'ai trouvé aucun article à ce sujet (il existe sans doute des livres), je suis face à un problème :

Il est souvent nécessaire d'écrire plusieurs tests pour un même bloc unitaire (que l'on appellera ici fonction). Plutôt que de tout mettre dans une fonction de test, il est judicieux d'en écrire plusieurs pour avoir une meilleure séparation des tests et un meilleur suivi en cas d'échec de l'un d'eux.

Exemple :

class Addition {
  public int additionner(int a, int b){
    return a + b;
  }
}

class AdditionTest {
  private Addition addition;

  @Before
  public void setup(){
   this.addition = new Addition();
  }

  @Test
  public void additionnerDeuxPositifs(){
    // Test addition deux nombres positifs
    assertEqual(2, this.addition.additionner(1,1);
  }

  @Test
  public void additionnerDeuxNegatifs(){
    // Test addition deux nombres négatifs
    assertEqual(-2, this.addition.additionner(-1, -1);
  }

  @Test
  public void additionnerPositifEtNegatif(){
    // Test addition un nombre négatif et positif
    assertEqual(0, this.addition.additionner(-1, 1);
  }
}

Maintenant, considérons que je développe 5 tests unitaires par fonction pour une classe qui contient une dizaine de fonction. Cela fait une cinquantaine de tests unitaires dans la même classe. Ne serait-il pas plus judicieux de créer une classe par test de fonction ? Plutôt que d'avoir une classe avec 50 tests unitaires, ne serait-il pas mieux d'avoir 10 classes avec 5 tests unitaires ? Par "mieux", j'entend la maintenance et l'évolutivité du code.

Exemple :

class Operation {
  public int additionner(int a, int b){
    return a + b;
  }

  public int soustraire(int a, int b){
    return a - b;
  }
}

class OperationAdditionnerTest{
   private Operation operation;

  @Before
  public void setup(){
   this.operation = new Operation();
  }

  @Test
  public void additionnerDeuxPositifs(){
    // Test addition deux nombres positifs
    assertEqual(2, this.addition.additionner(1,1);
  }

  @Test
  public void additionnerDeuxNegatifs(){
    // Test addition deux nombres négatifs
    assertEqual(-2, this.addition.additionner(-1, -1);
  }

  @Test
  public void additionnerPositifEtNegatif(){
    // Test addition un nombre négatif et positif
    assertEqual(0, this.addition.additionner(-1, 1);
  }
}

class OperationSoustraireTest{
   private Operation operation;

  @Before
  public void setup(){
   this.operation = new Operation();
  }

  @Test
  public void soustraireDeuxPositifs(){
    // Test soustraction deux nombres positifs
    assertEqual(0, this.operation.soustraire(1,1);
  }

  @Test
  public void soustraireDeuxNegatifs(){
    // Test soustraction deux nombres négatifs
    assertEqual(0, this.operation.soustraire(-1, -1);
  }

  @Test
  public void soustrairePositifEtNegatif(){
    // Test soustraction un nombre négatif et positif
    assertEqual(-2, this.operation.soustraire(-1, 1);
  }
}

Il y a des inconvénients à faire ça : nom de classe trop long pour les décrire précisément, peut-être problème de performance (car 10 instances de classe plutôt qu'une), des classes parfois trop courtes (si j'écris un test unitaire pour une fonction).