Comment écrire un test unitaire ?

Question

J'ai une classe Java. Comment puis-je test unitaire ça ?

---

Dans mon cas, j'ai la classe fait une somme binaire. Elle prend deux byte[] les additionne, et renvoie un nouveau tableau binaire.

Answer 1

Je fournis ce poste pour les deux IntelliJ y Eclipse .

Eclipse :

Pour faire un test unitaire pour votre projet, veuillez suivre ces étapes (j'utilise Eclipse pour écrire ce test) :

1- Cliquez sur Nouveau -> Projet Java.

2- Inscrivez le nom de votre projet et cliquez sur terminer.

3- Faites un clic droit sur votre projet. Puis, cliquez sur Nouveau -> Classe.

4- Inscrivez le nom de votre classe et cliquez sur terminer.

Ensuite, complétez la classe comme ceci :

public class Math {
    int a, b;
    Math(int a, int b) {
        this.a = a;
        this.b = b;
    }
    public int add() {
        return a + b;
    }
}

5- Cliquez sur File -> New -> JUnit Test Case.

6- Vérifiez setUp() et cliquez sur terminer. SetUp() sera l'endroit où vous initialiserez votre test.

7- Cliquez sur OK.

8- Ici, j'ajoute simplement 7 et 10. Je m'attends donc à ce que la réponse soit 17. Complétez votre classe test comme ceci :

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class MathTest {
    Math math;
    @Before
    public void setUp() throws Exception {
        math = new Math(7, 10);
    }
    @Test
    public void testAdd() {
        Assert.assertEquals(17, math.add());
    }
}

9- Cliquez sur votre classe de test dans l'explorateur de paquets et cliquez sur Run as -> JUnit Test.

10- C'est le résultat du test.

IntelliJ : Notez que j'ai utilisé IntelliJ IDEA community 2020.1 pour les captures d'écran. De plus, vous devez configurer votre jre avant ces étapes. J'utilise le JDK 11.0.4.

1- Cliquez avec le bouton droit de la souris sur le dossier principal de votre projet-> nouveau -> répertoire. Vous devez l'appeler 'test'. 2- Cliquez avec le bouton droit de la souris sur le dossier de test et créez le paquet approprié. Je suggère de créer les mêmes noms de package que la classe originale. Ensuite, vous faites un clic droit sur le répertoire de test -> marquer le répertoire comme -> sources de test Root. 3- Dans le bon paquetage du répertoire test, vous devez créer une classe Java (je suggère d'utiliser Test.java). 4- Dans la classe créée, tapez '@Test'. Ensuite, parmi les options qu'IntelliJ vous propose, sélectionnez Add 'JUnitx' to classpath. 5- Ecrivez votre méthode de test dans votre classe de test. La signature de la méthode est la suivante :

@Test
public void test<name of original method>(){
...
}

Vous pouvez faire vos assertions comme ci-dessous :

Assertions.assertTrue(f.flipEquiv(node1_1, node2_1));

Ce sont les importations que j'ai ajoutées :

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

Voici le test que j'ai écrit :

Vous pouvez vérifier vos méthodes comme ci-dessous :

Assertions.assertEquals(<Expected>,<actual>);
Assertions.assertTrue(<actual>);
...

Pour exécuter vos tests unitaires, cliquez avec le bouton droit de la souris sur le test et cliquez sur Run .

Si votre test est réussi, le résultat sera comme ci-dessous :

J'espère que cela vous aidera. Vous pouvez voir la structure du projet dans GitHub https://github.com/m-vahidalizadeh/problem_solving_project .

Answer 2

1. Définir la sortie attendue et souhaitée pour un cas normal, avec une entrée correcte.

2. Maintenant, implémentez le test en déclarant une classe, donnez-lui un nom quelconque (généralement quelque chose comme TestAddingModule), et ajoutez-lui la méthode testAdd (c'est-à-dire comme celle ci-dessous) :

   • Ecrivez une méthode, et au-dessus d'elle, ajoutez l'annotation @Test.
   • Dans la méthode, exécutez votre somme binaire et assertEquals(expectedVal,calculatedVal) .

   • Testez votre méthode en l'exécutant (dans Eclipse, faites un clic droit, sélectionnez Exécuter comme → Test JUnit).

     //for normal addition 
     @Test
     public void testAdd1Plus1() 
     {
         int x  = 1 ; int y = 1;
         assertEquals(2, myClass.add(x,y));
     }

3. Ajoutez d'autres caisses si vous le souhaitez.

   • Testez que votre somme binaire ne lève pas une exception inattendue en cas de dépassement d'un nombre entier.

   • Vérifiez que votre méthode traite les entrées Null de manière élégante (exemple ci-dessous).

     //if you are using 0 as default for null, make sure your class works in that case.
     @Test
     public void testAdd1Plus1() 
     {
         int y = 1;
         assertEquals(0, myClass.add(null,y));
     }

Answer 3

Il s'agit d'une question très générale à laquelle il est possible de répondre de nombreuses façons.

Si vous souhaitez utiliser JUnit pour créer les tests, vous devez créer votre classe de testcase, puis créer des méthodes de test individuelles qui testent la fonctionnalité spécifique de votre classe/module testé (les classes de testcase uniques sont généralement associées à une seule classe de "production" qui est testée) et à l'intérieur de ces méthodes, exécuter diverses opérations et comparer les résultats avec ce qui serait correct. Il est particulièrement important d'essayer de couvrir autant de cas de figure que possible.

Dans votre exemple spécifique, vous pourriez par exemple tester ce qui suit :

1. Une addition simple entre deux nombres positifs. Additionnez-les, puis vérifiez que le résultat est conforme à ce que vous attendez.
2. Une addition entre un nombre positif et un nombre négatif (qui renvoie un résultat avec le signe du premier argument).
3. Une addition entre un nombre positif et un nombre négatif (qui renvoie un résultat avec le signe du second argument).
4. Une addition entre deux nombres négatifs.
5. Une addition qui entraîne un dépassement.

Pour vérifier les résultats, vous pouvez utiliser diverses méthodes assertXXX de la classe org.junit.Assert (par commodité, vous pouvez faire 'import static org.junit.Assert.*'). Ces méthodes testent une condition particulière et échouent le test s'il n'est pas validé (avec un message spécifique, facultatif).

Exemple de classe testcase dans votre cas (sans le contenu des méthodes définies) :

import static org.junit.Assert.*;

public class AdditionTests {
    @Test
    public void testSimpleAddition() { ... }

    @Test
    public void testPositiveNegativeAddition() { ... }

    @Test
    public void testNegativePositiveAddition() { ... }

    @Test
    public void testNegativeAddition() { ... }

    @Test
    public void testOverflow() { ... }
}

Si vous n'avez pas l'habitude d'écrire des tests unitaires mais que vous testez plutôt votre code en écrivant des tests ad-hoc que vous validez ensuite "visuellement" (par exemple, vous écrivez une méthode main simple qui accepte des arguments saisis au clavier puis imprime les résultats - et vous continuez ensuite à saisir des valeurs et à valider vous-même si les résultats sont corrects), vous pouvez commencer par écrire de tels tests dans le format ci-dessus et valider les résultats avec la méthode assertXXX correcte au lieu de le faire manuellement. De cette façon, vous pouvez ré-exécuter le test beaucoup plus facilement que si vous deviez faire des tests manuels.

Answer 4

Comme @CoolBeans l'a mentionné, jetez un coup d'oeil à jUnit . Voici une courte tutoriel pour vous permettre de démarrer également avec jUnit 4.x

Enfin, si vous voulez vraiment en savoir plus sur les tests et le développement piloté par les tests (TDD), je vous recommande de consulter le livre suivant de Kent Beck : Développement piloté par les tests par exemple .

Answer 5

D'autres réponses vous ont montré comment utiliser JUnit pour mettre en place des classes de test. JUnit n'est pas le seul cadre de test Java. Cependant, se concentrer sur les détails techniques de l'utilisation d'un framework détourne l'attention des concepts les plus importants qui devraient guider vos actions, c'est pourquoi je vais en parler.

• Les essais (de toutes sortes de choses) comparent les réel comportement de quelque chose (le système à tester, SUT) avec son attendu comportement.

• Les tests automatisés peuvent être effectués à l'aide d'un programme informatique. Comme cette comparaison est effectuée par un programme informatique inflexible et inintelligent, le comportement attendu doit être connu avec précision et sans ambiguïté.

• Ce que l'on attend d'un programme ou d'une partie d'un programme (une classe ou une méthode) est son spécification . Tester un logiciel nécessite donc de disposer d'une spécification pour le SUT. Il peut s'agir d'une description explicite, ou d'une spécification implicite dans votre tête de ce qui est attendu.

• Les tests unitaires automatisés nécessitent donc une spécification précise et sans ambiguïté de la classe ou de la méthode que vous testez.

• Mais vous aviez besoin de cette spécification lorsque vous avez commencé à écrire ce code. Ainsi, une partie des tests commence en fait avant même que vous n'écriviez une seule ligne du SUT. La technique de test Test Driven Development (TDD) pousse cette idée à l'extrême et vous fait créer le code de test unitaire avant d'écrire le code à tester.

• Les cadres de test unitaire testent votre SUT en utilisant assertions . Une assertion est une expression logique (une expression avec un boolean type de résultat ; un prédicat ) qui doivent être true si le SUT se comporte correctement. La spécification doit donc être exprimée (ou réexprimée) sous forme d'assertions.

• Une technique utile pour exprimer une spécification sous forme d'assertions est la suivante Conception par contrat . Ces spécifications sont en termes de postconditions . Une postcondition est une assertion sur l'état publiquement visible de l'USE après le retour d'une méthode ou d'un constructeur. Certaines méthodes ont des postconditions qui sont invariants qui sont des prédicats qui sont vrais avant et après l'exécution de la méthode. A classe peut aussi être considérée comme ayant des invariants, qui sont des postconditions de chaque constructeur et méthode de la classe, et qui doivent donc toujours être vrai. Les postconditions (et les invariants) sont exprimés uniquement en termes d'état visible de la publicité : public y protected les valeurs renvoyées par public y protected (comme les getters), et l'état publiquement visible des objets passés (par référence) aux méthodes.

---

De nombreux débutants postent des questions ici pour demander comment ils peuvent tester un certain code, en présentant le code mais sans indiquer la spécification de ce code. Comme le montre cette discussion, il est impossible pour quelqu'un de donner une bonne réponse à une telle question, car au mieux les réponses potentielles doivent devinez la spécification, et pourrait le faire de manière incorrecte. Le site demander de la question ne comprend manifestement pas l'importance d'un cahier des charges et est donc un novice qui doit comprendre les principes fondamentaux que j'ai décrits ici. avant J'essaie d'écrire un code de test.