web-dev-qa-db-fra.com

Comment écrire un test unitaire?

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

Dans mon cas, j'ai classe fait une somme binaire. Il faut deux tableaux byte[], les somme et renvoie un nouveau tableau binaire.

javaunit-testing
125
Tsundoku

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

    • Ecrivez une méthode et ajoutez au-dessus 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, cliquez avec le bouton droit de la souris, sélectionnez Exécuter en tant que → 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.

    • Vérifiez que votre somme binaire ne déclenche pas une exception inattendue s'il existe un dépassement d'entier.

    • Vérifiez que votre méthode gère correctement 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));
}
122
jayunit100

Pour réaliser des tests unitaires pour votre projet, procédez comme suit (J'utilise Eclipse pour écrire ce test):

1- Cliquez sur Nouveau -> Java Projet.

Create Project

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

Create Project

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

Create Class

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

Create Class

Ensuite, complétez le cours 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 -> Scénario de test JUnit.

Create JUnite Test

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

Check SetUp()

7- Cliquez sur OK.

Add JUnit

8- Ici, j'ajoute simplement 7 et 10. Donc, j'attends 17 comme réponse. Complétez votre classe de test de la manière suivante:

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- Écrire, cliquez sur votre classe de test dans le package Explorer et cliquez sur Exécuter en tant que -> JUnit Test.

Run JUnit Test

10- Ceci est le résultat du test.

Result of The Test

J'espère que ça aide.

83
Vahid

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 de testcase, puis créer des méthodes de test individuelles qui testent les fonctionnalités spécifiques de votre classe/module sous test (les classes de testcase individuelles sont généralement associées à une seule classe "de production" qui est en cours de test) et à l’intérieur de ces méthodes, exécutent diverses opérations et comparent les résultats avec ce qui serait correct. Il est particulièrement important d'essayer de couvrir autant de dossiers que possible.

Dans votre exemple spécifique, vous pouvez par exemple tester les éléments suivants:

  1. Un simple ajout entre deux nombres positifs. Ajoutez-les, puis vérifiez que le résultat correspond à vos attentes.
  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 deuxième argument).
  4. Un ajout entre deux nombres négatifs.
  5. Un ajout qui entraîne un débordement.

Pour vérifier les résultats, vous pouvez utiliser différentes méthodes assertXXX de la classe org.junit.Assert (pour des raisons de commodité, vous pouvez importer 'org.junit.Assert. *' Statique). Ces méthodes testent une condition particulière et échouent au test s'il ne se valide pas (avec un message spécifique, éventuellement).

Exemple de classe de test case dans votre cas (sans le contenu des méthodes 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'êtes pas habitué à écrire des tests unitaires, testez 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 affiche les résultats. - et puis vous continuez à entrer des valeurs et à vous valider si les résultats sont corrects), vous pouvez commencer par écrire ces 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 pourrez relancer le test beaucoup plus facilement que si vous deviez faire des tests manuels.

17
Seramme

Comme @CoolBeans mentionné, jetez un oeil à jUnit . Voici un court tutoriel pour vous familiariser é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 .

8
vladmore

D'autres réponses vous ont montré comment utiliser JUnit pour configurer des classes de test. JUnit n'est pas le seul framework de test Java. En vous concentrant sur les détails techniques de l’utilisation d’un cadre, vous vous écartez des concepts les plus importants qui devraient guider vos actions; je vais donc en parler.

  • Les tests (de toutes sortes de choses) comparent le comportement réel de quelque chose (le système testé, SUT) avec son comportement attend.

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

  • Un programme ou une partie de programme (une classe ou une méthode) est censé faire est son spécification. Le logiciel de test nécessite donc que vous ayez une spécification pour le SUT. Cela peut être une description explicite ou une spécification implicite dans votre tête de ce qui est attendu.

  • Le test unitaire automatisé nécessite 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 décidé d'écrire ce code. Donc, une partie de ce qu’est le test commence réellement avant même d’écrire une seule ligne du SUT. La technique de test de TDD (Test Driven Development) pousse cette idée à l'extrême et vous permet de créer le code de test unitaire avant d'écrire le code à tester.

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

  • Une technique utile pour exprimer une spécification sous forme d'assertions consiste à programmation par contrat. Ces spécifications sont en termes de postconditions. Une postcondition est une assertion sur l'état visible publiquement du SUT 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. On peut également dire que class possède des invariants, qui sont des post-conditions de chaque constructeur et méthode de la classe, et devraient donc toujours être vrais. Les postconditions (et les invariants) ne sont exprimées qu'en termes de publicité visible: public et protected champs, les valeurs renvoyées par retournées par public et protected méthodes (telles que getters ) et l’état visible publiquement des objets passés (par référence) aux méthodes.

Beaucoup de débutants posent des questions ici en demandant comment ils peuvent tester du code, en présentant le code mais sans préciser les spécifications de ce code. Comme le montre cette discussion, il est impossible pour quiconque de donner une bonne réponse à une telle question, car, au mieux, les répondants potentiels doivent deviner la spécification, et pourraient le faire de manière incorrecte. Le asker de la question ne comprend évidemment pas l'importance d'une spécification, et est donc un novice qui a besoin de comprendre les principes de base que j'ai décrits ici avant ​​essayer d'en écrire code de test.

2
Raedwald