Junit est un cadre de test de régression écrit par Erich Gamma et Kent Beck. Le test JUnit est un test du programmeur, c'est-à-dire un test de boîte blanche. La page d'accueil du projet: http://www.junit.org/
Lorsque vous utilisez JUnit, vous écrivez principalement des cas de test en héritant de la catégorie TestCase et utilisez le nom testxxx () pour écrire des tests unitaires.
Il y a trois choses qui doivent vraiment écrire des tests avec Junit:
1. Une instruction d'importation présente toutes les classes sous Junit.framework. *.
2. Une instruction EXTENSE permet à votre classe de hériter de TestCase.
3. Un constructeur qui appelle Super (String).
Mathtool fonctionnel
package com.zj.c01; classe publique MathTool {public static int gcd (int num1, int num2) {int r = 0; while (num2! = 0) {r = num1% num2; num1 = num2; num2 = r; } return num1; }}Classe de test MathTooltest
package com.zj.c01; importer junit.framework.testcase; classe publique MathToolTest étend TestCase {public MathToolTest (nom de chaîne) {super (nom); } public void testgcd () {asserTequals (5, mathtool.gcd (10, 5)); }} Lorsque nous utilisons JUnit pour tester les exceptions, la façon la plus simple de penser est d'utiliser Try ... Catch pour attraper l'exception. Nous devons affirmer les conditions suivantes:
1. Exception qui est effectivement jetée 2. Type de classe de l'exception lancée 3. Le type spécifique de l'exception est lancé. Généralement, vérifiez la détermination de la chaîne contenue dans l'attribut de message de l'exception. Vous pouvez donc écrire le code commun comme ceci:
@Test public void testBizexception () {try {mot de passe.Validate ("123"); échoue ("Pas d'exception lancée."); } catch (exception ex) {assertTrue (ex instanceof bizexception); assertTrue (ex.getMessage (). Contient ("erreur")); }} La méthode testée ici est de savoir si la méthode Password.Validate () lance l'exception correspondante. Veuillez noter que l'échec ("Aucune exception lancée.") Dans l'essai, il n'est pas manqué ici.
Ligne de code, sinon si la méthode testée ne lance pas d'exception, ce cas d'utilisation passera et ce que vous attendez est de lancer une exception.
Dans Junit 4, il n'est pas nécessaire de tester des exceptions de méthode comme celle-ci. Bien que cela puisse également déterminer si l'exception attendue est exécutée, elle a toujours des inconvénients. Vous le saurez après l'avoir comparé. JUnit ne peut pas vous montrer la raison détaillée de l'échec de l'affirmation dans la méthode Try ... Catch.
Voyons donc comment tester les exceptions depuis Junit 4? Utilisez simplement @Test (exectted = exception.class) Annotation, reportez-vous au code suivant:
@Test (attendu = bizexception.class) public void testBizexception () {mot de passe.validate (null); }
Si la méthode testée a le type Bizexception lancé, l'affirmation est réussie. Soit dit en passant, @Test (attendu = bizexception.class) ne peut déterminer que le type de l'exception, et il n'y a pas d'annotation correspondante pour affirmer des informations plus spécifiques sur l'exception, c'est-à-dire qu'elle ne peut pas déterminer l'attribut de message de l'exception lancée.
Ensuite, parfois, nous lançons une exception d'un type plusieurs fois dans une méthode, mais les raisons sont différentes, c'est-à-dire que les informations de message de l'exception sont différentes. Par exemple, lorsqu'une Bizexception se produit, il y aura les deux exceptions suivantes:
Nouveau Bizexception ("Le mot de passe doit contenir au moins 6 lettres.") New Bizexception ("Longueur de mot de passe moins de 15 lettres") Cela nécessite un moyen d'affirmer le message d'exception. Pour cette raison, depuis Junit 4.7, nous avons donné un choix plus parfait, qui est le code suivant:
@Rule public attendException attendEx = attendException.none (); @Test public void testBizexception () lève invalidpasswordException {attendEx.expect (bizexception.class); attendEx.ExpectMessage ("requis"); Mot de passe.Validate (""); } Le code ci-dessus doit être concentré sur:
1. @Rule Déclaration de variables annotées ExpectException, ce doit être public
2. Chez @Test, il ne peut pas être écrit comme @Test (attendu = bizexception.class), sinon il ne peut pas être testé correctement. C'est-à-dire que la méthode @Test (attendu = bizexception.class) et la méthode attendEx.Expectxxx () dans la méthode de test ne peuvent pas coexister en même temps. 3. Les paramètres dans attendEx.ExpectMessage () sont un matchur ou une sous-chaîne, ce qui signifie que des expressions régulières peuvent être utilisées pour déterminer ou déterminer si une sous-chaîne est incluse. 4. Une autre chose est très lourde, écrivez la méthode testée derrière la méthode attendEx.Expectxxx (), sinon l'exception qui ne peut pas être testée correctement 5. La dernière est que tant que la méthode de test lance directement l'exception de la méthode testée, elle n'affectera pas l'exception qui vous concerne. Comme mentionné précédemment, l'utilisation de la méthode Try… Catch peut également tester correctement l'exception. Quels sont les avantages de comparer le @Test (attendu =…) ou @rule et essayez… Méthode de capture? De toute évidence, la méthode recommandée par Junit 4 est concise et claire. Voyons ce que Junit vous invitera lorsque le test échoue?
L'invite que vous obtenez lorsque le test a échoué anormalement:
Quand il n'y a pas d'exception:
Java.lang.AissertionError: Aucune exception lancée. sur org.junit.assersert.fail (assert.java:91) sur cc.unmi.passwordTest.PasswordLengthleshanSThan6letterStHrowSexception (PasswordTest.java:20)
Lorsque le type d'exception est mauvais ou que le message d'exception est mauvais:
java.lang.assetionError: at org.junit.assert.fail (assert.java:91) sur org.junit.assert.asserttrue (assert.java:43) à org.junit.assert.asserttrue (assert.java:54) à org.junit.assert.assertrue (assert.java:54) à Org.Junit.Assert.AssertTrue (assert.java:54) à Org.Junit.Sersert. cc.unmi.passwordTest.PasswordLengthlessThan6letTrsThrowSException (PasswordTest.java:22)
L'aide ci-dessus pour les erreurs de positionnement n'est pas particulièrement grande. Regardez les invites lorsque le test échoue lorsque @Test (attendu = bizexception.class):
java.lang.assetionError: exception attendue: cc.test.bizexception à org.junit.internal.runners.statements.expectexception.evaluate (attenduxception.java:32) à org.Junit.rules.ExpectionException)
Utilisez @Rules attendException pour tester les exceptions. Conseils lors de l'échec:
java.lang.assetionError: attendu: (exception avec message une chaîne contenant "oui. requise" et une instance de java.lang.nullpointerException) a obtenu: sur org.junit.assert.assertThat (assert.java:778) sur org.junit.asser.asserthat (assert.java:736) sur Org.Junit. org.junit.rules.ExpectionException $ attendExceptionStatement.evaluate (attendException.java:114)
En particulier, la méthode @rules attendException est clairement consciente de l'échec du test. Quelle exception est attendue, quelle chaîne est contenue dans le message d'exception, quel type d'exception est réellement obtenu et quel est le message dans l'exception. Avec cela, vous saurez comment réparer votre programme dès que vous le verrez.