Pourquoi utiliser JUnit pour tester ?

Question

Peut-être que ma question est un newbie, mais je ne peux pas vraiment comprendre les circonstances dans lesquelles je voudrais utiliser junit?

Si j'écris des applications simples ou les plus grandes, je les tester avec l' System.out états et il semble assez facile pour moi.

Pourquoi créer le test-classes avec JUnit, les dossiers inutiles dans le projet si nous avons encore à appeler les mêmes méthodes, vérifier ce qu'ils reviennent et nous avons ensuite une surcharge de l'annotation de tout?

Pourquoi ne pas écrire une classe et de le tester à la fois avec System.out mais de ne pas créer de Test-classes?

PS. Je n'ai jamais travaillé sur de grands projets je suis juste de l'apprentissage.

Alors, quel est le but?

Answer 1

Ce n'est pas les tests, c'est "à la recherche manuellement au niveau de la sortie" (connu dans le biz comme LMAO). Plus formellement connu sous le nom de "chercher manuellement anormaux de sortie" (LMFAO).

Chaque fois que vous modifiez le code, vous devez exécuter l'application et de LMFAO pour tous les code touchés par ces changements. Même dans les petits projets, c'est problématique et sujette à erreur.

Maintenant échelle jusqu'à 50k, 250k, 1m de LOC ou plus, et LMFAO chaque fois que vous apportez une modification du code. Non seulement c'est désagréable, c'est impossible: vous avez mis à l'échelle de la combinaisons des entrées, des sorties, des drapeaux, des conditions, et il est difficile d'exercer tous les possibles branches.

Pire, LMFAO pourrait signifier la visite des pages et des pages de web app, l'exécution des rapports, penché sur des millions de lignes de log dans des dizaines de fichiers et les machines, lecture de création et de livraison des emails, de la vérification des messages texte, vérifier le chemin d'un robot, le remplissage d'une bouteille de soda, de l'agrégation des données à partir d'une centaine de services web, la vérification de la piste d'audit d'une opération financière... vous voyez l'idée. "Sortie" ne signifie pas que quelques lignes de texte, de "sortie" signifie globale du comportement du système.

Enfin, l'unité et le comportement des tests de définir le comportement du système. Les Tests peuvent être exécutés par un serveur d'intégration continue et vérifie qu'il est correct. Assurez-vous, donc, peut - System.outs, mais le serveur CI n'est pas de savoir si l'un d'eux est faux–et si elle le fait, ils sont les tests unitaires, et vous pourriez aussi bien utiliser un framework.

Peu importe la façon dont nous pensons, nous, les humains ne sont pas de bonnes infrastructures de test unitaire ou serveurs CI.

Answer 2

Nous écrire des tests pour vérifier l'exactitude d'un programme de comportement.

Vérification de l'exactitude d'un programme de comportement en inspectant le contenu de la production des déclarations à l'aide de vos yeux est un manuel, ou plus précisément, un visuel processus.

On pourrait dire que l'

l'inspection visuelle des œuvres, je vérifie que le code fait ce qu'il doit à faire, pour ces scénarios, et une fois que je peux voir, c'est correct, nous sommes bons pour aller.

Maintenant, tout d'abord, c'est formidable que vous êtes intéressé à savoir si ou non le code fonctionne correctement. C'est une bonne chose. Vous êtes en avance de la courbe! Malheureusement, il y a des problèmes avec cette approche.

Le premier problème avec l'inspection visuelle, c'est que vous êtes un mauvais soudage accident à l'extérieur de ne jamais être en mesure de vérifier votre code de la justesse de nouveau.

Le deuxième problème est que la paire d'yeux utilisée est étroitement couplé avec le cerveau de la propriétaire de la yeux. Si l'auteur du code détient également les yeux utilisé dans l'inspection visuelle du processus, le processus de vérification de l'exactitude a une dépendance sur les connaissances sur le programme intériorisée dans le visuel de l'inspecteur du cerveau.

Il est difficile pour une nouvelle paire d'yeux à venir et de vérifier l'exactitude du code, simplement parce qu'ils ne sont pas associés avec le cerveau de l'original codeur. Le propriétaire de la deuxième paire d'yeux auront à converser avec l'auteur original du code, afin de bien comprendre le code en question. Conversation comme un moyen de partage de la connaissance est notoirement peu fiables. Un point qui est discutable si le Codeur est pas disponible pour la nouvelle paire d'yeux. En l'occurrence la nouvelle paire de yeux a lire le code d'origine.

En lisant d'autres personnes de code qui n'est pas couvert par les tests unitaires est plus difficile que la lecture de code qui est associé à des tests unitaires. Au mieux, en lisant d'autres peuples code est le travail délicat, au pire c'est le plus turgescents tâche dans l'ingénierie du logiciel. Il ya une raison que les employeurs, lors de la publication des offres d'emploi, de stress qu'un projet est un nouveau (ou nouvelle marque). L'écriture de code à partir de zéro est plus simple que de modifier le code existant et, de ce fait, le poste à pourvoir apparaître plus attrayant pour les employés.

Avec les tests unitaires nous diviser le code en fonction de ses composantes. Pour chaque composante, nous avons ensuite défini notre stand indiquant comment le programme doit se comporter. Chaque unité de test raconte une histoire de la façon dont cette partie du programme doit agir dans un scénario spécifique. Chaque unité de test est comme une clause dans un contrat qui décrit ce qui doit arriver du code de client du point de vue.

Ensuite, cela signifie qu'une nouvelle paire de yeux a deux brins de vivre et précise de la documentation sur le code en question.

Ils ont d'abord le code lui-même, la mise en œuvre, la façon dont le code a été fait; deuxièmement, ils ont toutes les connaissances que l'original codeur décrit dans une série de déclarations officielles qui racontent l'histoire de la façon dont ce code est censé se comporter.

Les tests unitaires de capture et de décrire formellement les connaissances que l'auteur original possédait quand ils ont mis la classe. Fournir une description de la façon dont cette classe se comporte lorsqu'il est utilisé par un client.

Vous avez raison de s'interroger sur l'utilité de faire cela parce qu'il est possible d'écrire des tests unitaires qui sont inutiles, ne couvrent pas tout le code en question, devenue obsolète ou hors de date et ainsi de suite. Comment nous assurer que les tests unitaires non seulement imite, mais améliore le processus de compétent, consciencieux auteur inspecter visuellement leur code de sortie instructions au moment de l'exécution? Écrire le test de l'unité d'abord, puis d'écrire le code pour faire ce test. Lorsque vous avez terminé, laissez les ordinateurs exécutent les tests, ils sont rapides, ils sont grands à faire des tâches répétitives, ils sont parfaitement adaptés pour le travail.

Assurer la qualité des tests en examinant chaque fois que vous touchez désactiver le code de test et exécuter les tests pour chaque construction. Si un test échoue, le corriger immédiatement.

Nous automatiser le processus de l'exécution de tests, de sorte qu'ils sont à exécuter à chaque fois que nous faisons un build du projet. Nous avons également automatiser la génération de rapports de couverture de code que les détails quel est le pourcentage de code qui est couvert et exercé par des tests. Nous nous efforçons d'atteindre des pourcentages élevés. Certaines sociétés de prévenir les changements de code de contrôle pour le contrôle de code source si elles n'ont pas suffisamment de tests unitaires écrits pour décrire les changements dans le comportement du code. Généralement, une deuxième paire d'yeux examinera les changements de code en conjonction avec l'auteur de la modification. L'examinateur va passer par les changements s'assurer que les changements compréhensible et suffisamment couverts par des tests. De sorte que le processus d'examen est manuel, mais lorsque les tests (tests unitaires et d'intégration et, éventuellement, user acceptance tests) passer ce manuel processus d'examen, deviennent partie intégrante du processus de construction automatique. Ces actions sont exécutées chaque fois qu'une modification est activée dans. Un continu-l'intégration de serveur s'acquitte de cette tâche en tant que partie du processus de construction.

Les Tests qui sont automatiquement exploiter, de maintenir l'intégrité du code du comportement et aider à prévenir de futures modifications de la base de code de casser le code.

Enfin, fournir des tests permet d'être agressive re-facteur de code parce que vous pouvez faire de gros code des améliorations en toute sécurité en sachant que vos modifications ne cassent pas les tests existants.

Il y a une mise en garde de Développement Piloté par les tests , et c'est que vous devez écrire du code en vue de la rendre testable. Cela comprend le codage des interfaces et des cours à l'aide de techniques telles que l'Injection de Dépendance pour instancier la collaboration des objets. Découvrez le travail de Kent Beck qui décrit TDD très bien. Regarder le codage des interfaces et de l'étude et de la conception des modèles

Answer 3

Lorsque vous testez à l'aide de quelque chose comme Système., vous êtes seulement de tester un petit sous-ensemble de possibles cas d'utilisation. Ce n'est pas très approfondie lorsque vous avez affaire à des systèmes qui pourraient accepter une quasi-infinité de différentes entrées.

Les tests unitaires sont conçus pour vous permettre d'exécuter rapidement des tests sur votre application à l'aide d'un très large éventail de données différentes entrées. En outre, le meilleur des tests unitaires également compte des limites de cas, telles que les données d'entrées qui se trouvent à droite sur le bord de ce qui est considéré comme valide.

Pour un être humain pour tester l'ensemble de ces différents intrants pourrait prendre des semaines, alors qu'il pourrait prendre quelques minutes pour une machine.

Pensez-y comme ça: Vous n'êtes pas "test" quelque chose qui va être statique. Votre application est plus probable par le biais de changements constants. Par conséquent, ces tests sont conçus pour fonctionner à différents points de la compilation ou de cycle de déploiement. Peut-être le plus grand avantage est ceci:

Si vous cassez quelque chose dans votre code, vous saurez à ce sujet dès maintenant, pas après que vous avez déployés, pas quand un testeur qualité attrape un bug, pas lorsque vos clients ont annulé. Vous aurez également une meilleure chance de fixer le problème immédiatement, car il est clair que la chose qui a fait déborder le une partie du code en question le plus probable est passé depuis votre dernière compilation. Ainsi, la quantité de travail d'investigation nécessaire pour résoudre le problème est considérablement réduit.

Answer 4

Les tests unitaires de s'assurer que le code fonctionne comme prévu. Ils sont également très utiles pour s'assurer que le code fonctionne toujours comme prévu dans le cas où vous avez à changer plus tard pour construire de nouvelles fonctionnalités pour corriger un bug. Ayant une grande couverture de test de votre code vous permet de continuer à développer les fonctionnalités sans avoir à effectuer beaucoup de tests manuels.

Votre manuel de l'approche par System.out est bon mais pas le meilleur.C'est à ce moment des tests que vous effectuez. Dans le monde réel, les besoins évoluent et la plupart du temps, vous faites beaucoup de modificaiotns aux fonctions existantes et des classes. Donc... pas tout le temps de tester la déjà écrit morceau de code.

il y a aussi quelques fonctionnalités plus avancées sont en JUnit comme comme

Affirmer états

JUnit fournit des méthodes pour tester certaines conditions, ces méthodes commencent généralement à s'affirme et qui vous permettent de spécifier le message d'erreur, l'attendu et le résultat réel

Certaines de ces méthodes sont

1. fail(String) - Laisser l'échec de la méthode. Peut être utilisé pour vérifier qu'une certaine partie du code n'est pas atteint. Ou d'avoir à défaut de tests avant le code de test est mis en œuvre.
2. assertTrue(true) / assertTrue(faux) -Sera toujours vrai / faux. Peut être utilisé pour enregistrer les résultats d'un test, si le test n'est pas encore mis en œuvre.
3. assertTrue([message], condition booléenne) - Vérifie que la condition booléenne est vraie.
4. assertsEquals([String message], attendue, réel) -Tests que les deux valeurs sont les mêmes. Remarque: pour les tableaux de référence n'est pas vérifié le contenu des tableaux.
5. assertsEquals([String message], attendue, réelle, de la tolérance) -Test de float ou double des valeurs correspondent. La tolérance est le nombre de décimales qui doit être la même.
6. assertNull([message], objet) -Vérifie que l'objet est null

et ainsi de suite

JUnit Testsuite Par ce que vous pouvez combiner tous les tester dans une suite et exicute comme une seule unité. ici, je vais vous en donner un exemple simple

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({ MyClassTest.class, MySecondClassTest.class })
public class AllTests {

  } 

Answer 5

Le principal avantage de JUnit, c’est qu’il est automatisé plutôt que de vous avoir manuellement à vérifier avec votre impression outs. Chaque essai que vous écrivez reste avec votre système. Cela signifie que si vous faites un changement qui a un effet secondaire inattendu votre test sera l’attraper et échouer plutôt que de vous devoir se souvenir de tout tester manuellement après chaque changement.