Comment écrire un test unitaire?

1. Définissez 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, nommez-le n'importe quoi (généralement quelque chose comme TestAddingModule) et ajoutez-y la méthode testAdd (c'est-à-dire comme celle ci-dessous):

   • Écrivez une méthode, et au-dessus, 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 cas comme vous le souhaitez.

   • Testez que votre somme binaire ne lève pas d'exception inattendue s'il y a un dépassement d'entier.

   • Testez que votre méthode gère gracieusement les entrées Null (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));
     }
     

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

1 - Cliquez sur Nouveau -> Projet Java.

2 - Notez le nom de votre projet et cliquez sur Terminer.

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

4 - Notez le nom de votre classe et cliquez sur Terminer.

Alors, 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 Fichier -> Nouveau -> Cas de test JUnit.

6 - Cochez setUp() et cliquez sur terminer. SetUp () sera l'endroit où vous initialisez votre test.

7 - Cliquez sur OK.

8 - Ici, j'ajoute simplement 7 et 10. Donc, je m'attends à ce que la réponse soit 17. Complétez votre classe de 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-Ecrire cliquez sur votre classe de test dans l'explorateur de paquets et cliquez sur Exécuter en tant que - > Test JUnit.

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

J'espère que ça aide.

C'est une question très générique et il y a beaucoup de façons d'y répondre.

Si vous souhaitez utiliser JUnit pour créer les tests, vous devez créer votre classe testcase, puis créer des méthodes de test individuelles qui testent des fonctionnalités spécifiques de votre classe/module sous tests (les classes testcase uniques sont généralement associées à une seule classe "production" en cours de test) et à l'intérieur de ces méthodes, exécutez diverses opérations et comparez Il est particulièrement important d'essayer de couvrir le plus de cas de coin que possible.

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

1. Une addition simple entre deux nombres positifs. Ajouter, puis vérifier le résultat est 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 positif et un nombre négatif (qui renvoie un résultat avec la signe du deuxième argument).
4. Une addition entre deux nombres négatifs.
5. Une addition qui entraîne un débordement.

Pour vérifier les résultats, vous pouvez utiliser différentes méthodes assertXXX de l'organisation.junit.Assert class (pour plus de commodité, vous pouvez faire 'importer une organisation statique.junit.Affirmer.*'). Ces méthodes testent une condition particulière et échouent le test si elle ne valide pas (avec un message spécifique, éventuellement).

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

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 principale simple qui accepte les arguments saisis à l'aide du clavier, puis imprime les résultats - et ensuite vous continuez à entrer des valeurs et à vous valider si les résultats sont corrects), alors vous pouvez commencer par écrire de tels tests dans le format ci-dessus et valider les résultats avec le bon Méthode assertXXX 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.

Comme @CoolBeans mentionné, jetez un oeil à JUnit. Voici un court tutoriel pour vous aider à démarrer aussi bien 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 jeter un œil au livre suivant de Kent Beck: Test-Driven Development By Example.

public class FirtJunit {

    @BeforeClass
    public static void startUp() {
        System.out.println("BeforeClass");
    }
    @AfterClass
    public static void shutDown() {
        System.out.println("AfterClass");
    }
    @Before
    public void setup() {
        System.out.println("Before");
    }
    @After
    public void tearDown() {
        System.out.println("After");
    }
    @Test
    public void mul() {
        System.out.println("Test for mul");
    }
    @Test
    public void div() {
        System.out.println("Test for div");
    }




}