Test de programme, JUnit. Test du code Java avec JUnit - Tutoriel Test de connaissances Java

A la recherche de problèmes de test pour les programmeurs java, je suis tombé sur un site intéressant (les utilisateurs d'Avast n'y vont pas, un cheval de Troie de script est détecté, le reste le peut probablement) - http://www.betterprogrammer.com. Il vérifie les qualifications des programmeurs Java de la manière la plus simple mais automatique: en proposant d'écrire plusieurs fonctions (méthodes) de complexité croissante et de copier le code dans TextArea. De plus, le moteur du site fait quelque chose avec les tâches (pas autrement qu'un test unitaire), calcule un certain indice de qualification selon les critères "vitesse-qualité" et donne la note finale sous cette forme:

Puis les questions commencent. J'ai moi-même programmé en Java pour la deuxième fois de ma vie (et donc je viens de bouillir sur des tâches difficiles), donc 82% sur ce test correspondent au niveau programmeur non-java... Combien faut-il alors recruter Java Junior, Java Programmer et plus encore Java Senior?! Quel résultat attendre de présent programmeur java - 90, 95, 99? Et enfin, que se passe-t-il si le "programmeur" obtient moins de 82, mais postule néanmoins pour une sorte de travail?!

Java est un langage de programmation orienté objet et fortement typé développé par Sun Microsystems en 1991. Le langage s'appelait à l'origine Oak et était destiné à la programmation de l'électronique grand public, mais a ensuite été renommé Java. La sortie officielle de Java en 1995 s'est avérée très fructueuse, et peu de temps après, Java a pris une position forte en tant qu'outil de développement d'applications serveur.

De nos jours, Java est utilisé dans tous les domaines du développement logiciel - applications serveur, applications de bureau, outils, applications Web - tous développés à l'aide de Java et des technologies associées.

Public cible du test Java

Le test Java contient des questions auxquelles la plupart des développeurs ayant une expérience minimale de la programmation Java connaissent les réponses. Le test sera utile à beaucoup, y compris aux personnes qui n'ont pas beaucoup d'expérience avec Java et qui souhaitent acquérir une compréhension minimale des concepts de base de ce langage de programmation populaire. En outre, ce test peut être utile pour les étudiants qui étudient Java, pour consolider les connaissances acquises dans les universités ou à la suite d'un travail indépendant.

Conditions préalables au test Java

On suppose qu'avant de passer le test Java Fundamentals, vous connaissez déjà les concepts de base tels que «variable», «boucle», «méthode» et connaissez la syntaxe des constructions de langage de base. Si ce n'est pas le cas, nous vous recommandons de vous familiariser d'abord avec les bases de Java en lisant le cours d'introduction.

Structure de test Java

Le test Java - Fundamentals couvre les sujets suivants:

Vous pouvez en savoir plus sur les sujets des questions du test ci-dessous:

• Objets et classes: les questions sur ce sujet couvrent des concepts tels que la classe, l'instance de classe (objet), les constructeurs, les méthodes et les champs de classe.
• Syntaxe: Les questions de cette section testeront votre connaissance des mots-clés de langage, des opérateurs, des types de base (primitives, String), des constructions de contrôle (if-else, while, for) et de votre compréhension de la gestion des exceptions (Exception).
• Autre: Cette section contient des questions concernant les concepts de base, les termes et abréviations, les conventions de dénomination des classes, les variables et les méthodes. Cette section couvre également les fichiers (.java, .class, .jar) et les packages, le cycle de vie des objets, le garbage collection.

Passer un test Java en ligne vous aide à tester et à consolider vos connaissances sur les principes fondamentaux de Java, et vous amène également à passer les tests les plus avancés de la section des tests Java.

Nous espérons que vous trouverez ce test utile et divertissant.

Poursuite du développement du test Java

Le test Java est constamment mis à jour avec de nouvelles questions.

Dans un proche avenir, l'équipe de Quizful prévoit de créer des tests Java de niveau expert. Peut-être que le test Java Puzzlers sera toujours créé, mais malheureusement, il se remplit très lentement de questions.

Si vous avez des commentaires sur les questions du test, n'hésitez pas à nous écrire. Bonne chance.

Les tests ne sont pas toujours amusants et intéressants. Ce processus est généralement assez long et parfois plein de travail monotone. Il semble qu'il n'y a pas si longtemps, les programmeurs utilisaient une sortie standard ou un débogueur pour tester les classes Java.

Dans cet article, je décrirai la bibliothèque JUnit 4, qui simplifie et automatise grandement le processus d'écriture des tests.

Pour démontrer les fonctionnalités de base de JUnit Framework, nous allons écrire une classe primitive dans le langage Java et la simuler. Cette classe aura deux méthodes - trouver la factorielle d'un nombre non négatif et la somme de deux nombres. De plus, l'instance de classe contiendra un compteur d'appels de méthode.

Classe publique MathFunc (int calls; public int getCalls () (return calls;) public long factorial (int number) (calls ++; if (number 1) (for (int i \u003d 1; i

Maintenant, écrivons des tests unitaires. Pour ce faire, nous allons créer une classe avec un certain nombre de méthodes de test. Naturellement, la classe peut également contenir des méthodes d'assistance régulières. Pour que le testeur puisse déterminer qui est qui, les méthodes de test doivent être annotées avec @Test.

Une annotation peut avoir les paramètres suivants:

• attendu - indique quel type d'exception sera levé par la méthode (voir l'exemple ci-dessous);
• timeout - après quelle heure, en millisecondes, pour arrêter l'exécution du test et le compter comme un échec.

Si vous souhaitez indiquer qu'un certain test doit être ignoré, marquez-le avec l'annotation @Ignore. Bien qu'il soit possible de supprimer simplement l'annotation @Test.

Il arrive que vous ayez besoin d'un certain contexte pour exécuter chaque scénario de test, par exemple, des instances de classe pré-créées. Et après l'exécution, vous devez libérer les ressources réservées. Dans ce cas, vous avez besoin des annotations @Before et @After. La méthode marquée @Before sera exécutée avant chaque cas de test, et la méthode marquée @After sera exécutée après chaque cas de test.

Si vous avez besoin d'initialiser et de libérer des ressources une seule fois - avant et après tous les tests, respectivement - utilisez alors quelques annotations @BeforeClass et @AfterClass.

Et voici la classe de test elle-même avec plusieurs cas de test:

Classe publique MathFuncTest (private MathFunc math; @Before public void init () (math \u003d new MathFunc ();) @After public void tearDown () (math \u003d null;) @Test public void calls () (assertEquals (0, math .getCalls ()); math.factorial (1); assertEquals (1, math.getCalls ()); math.factorial (1); assertEquals (2, math.getCalls ());) @Test public void factorial () (assertTrue (math.factorial (0) \u003d\u003d 1); assertTrue (math.factorial (1) \u003d\u003d 1); assertTrue (math.factorial (5) \u003d\u003d 120);) @Test (attendu \u003d IllegalArgumentException.class) public void factorialNegative () (math.factorial (-1);) @Ignore @Test public void todo () (assertTrue (math.plus (1, 1) \u003d\u003d 3);))

La méthode des appels teste l'exactitude du compteur d'appels. La méthode factorielle vérifie que la factorielle est calculée correctement pour certaines valeurs standard. La méthode factorialNegative vérifie qu'une IllegalArgumentException sera lancée pour les valeurs factorielles négatives. La méthode todo sera ignorée. Essayez de supprimer l'annotation @Ignore lorsque vous testez votre code.

La méthode assertTrue vérifie si le résultat de l'expression est correct. Quelques autres méthodes qui pourraient être utiles:

• assertEquals - le résultat attendu et le résultat reçu sont les mêmes;
• assertNull - l'expression est évaluée à null;
• assertNotNull - le résultat de l'expression est non nul;
• assertSame - les objets attendus et reçus sont le même objet.
• fail - la méthode lève une exception AssertionError - ajoutez-la là où l'exécution du programme ne doit pas atteindre.

Dans notre monde moderne, les IDE savent comment trouver et exécuter simplement des tests dans un projet. Mais que faire si vous souhaitez les démarrer manuellement à l'aide du code de programme. Pour ce faire, vous pouvez utiliser le Runner. Il existe des versions texte - junit.textui.TestRunner, des versions graphiques - junit.swingui.TestRunner, junit.awtui.TestRunner.

Mais une méthode légèrement plus moderne consiste à utiliser la classe JUnitCore. Ajoutez la méthode principale suivante à la classe MathFuncTest:

Public static void main (String args) jette une exception (JUnitCore runner \u003d new JUnitCore (); Result result \u003d runner.run (MathFuncTest.class); System.out.println ("run tests:" + result.getRunCount ()) System.out.println ("tests échoués:" + result.getFailureCount ()); System.out.println ("tests ignorés:" + result.getIgnoreCount ()); System.out.println ("succès:" + résultat .était un succès ());)

Et le résultat de l'exécution:

Exécuter les tests: 3 tests échoués: 0 tests ignorés: 1 succès: vrai

Dans les versions antérieures de JUnit, pour écrire une classe de test, vous deviez créer un héritier de junit.framework.TestCase. Ensuite, il était nécessaire de définir un constructeur qui prend un String comme paramètre - le nom de la méthode - et de le passer à la classe parente. Chaque méthode de test devait commencer par le préfixe de test. Les méthodes setUp et tearDown ont été utilisées pour initialiser et libérer des ressources. Bref, l'horreur. Eh bien, maintenant, tout est simple, oui.

C'est tout pour aujourd'hui. Je suis sûr que le Framework JUnit vous aidera beaucoup. Les commentaires et questions sur l'article sont les bienvenus.

JUnit est une bibliothèque de tests unitaires de programmes Java. Créé par Kent Beck et Eric Gamma, JUnit appartient à la famille de frameworks xUnit pour divers langages de programmation, originaire de SUnit pour Smalltalk de Kent Beck. JUnit a engendré un écosystème d'extensions - JMock, EasyMock, DbUnit, HttpUnit, etc.

Bibliothèque JUnit a été porté dans d'autres langages dont PHP (PHPUnit), C # (NUnit), Python (PyUnit), Fortran (fUnit), Delphi (DUnit), Free Pascal (FPCUnit), Perl (Test :: Unit), C ++ (CPPUnit) , Flex (FlexUnit), JavaScript (JSUnit).

JUnit Est un framework Java pour tester, c'est-à-dire tester des morceaux de code individuels, tels que des méthodes ou des classes. L'expérience acquise en travaillant avec JUnit est importante dans le développement de concepts de test logiciel.

Exemple de test JUnit

Importez org.junit.Test; import junit.framework.Assert; public class MathTest (@Test public void testEquals () (Assert.assertEquals (4, 2 + 2); Assert.assertTrue (4 \u003d\u003d 2 + 2);) @Test public void testNotEquals () (Assert.assertFalse (5 \u003d \u003d 2 + 2);))

La nécessité d'utiliser JUnit

JUnit vous permet de vérifier rapidement que votre code fonctionne à tout moment. Si le programme n'est pas très simple et comprend de nombreuses classes et méthodes, le test peut prendre beaucoup de temps. Naturellement, ce processus est mieux automatisé. En utilisant JUnit vous permet de vérifier le code du programme sans effort important et ne prend pas beaucoup de temps.

Tests unitaires les classes et les fonctions sont une sorte de documentation de ce qui est attendu suite à leur exécution. Et pas seulement de la documentation, mais une documentation qui permet de vérifier automatiquement la conformité du code avec les fonctions présentées. C'est pratique, et souvent les tests sont développés ensemble et avant que les classes ne soient implémentées. Le développement piloté par les tests est une technologie extrêmement populaire pour créer des logiciels sérieux.

Types de tests et place des tests JUnit dans la classification

Les tests logiciels peuvent être divisés en deux types:

• essai de boîte noire;
• test de boîte blanche.

Lors du test d'un programme sous forme de boîte noire, la structure interne de l'application n'est pas prise en compte. Tout ce qui compte, c'est la fonctionnalité que l'application doit fournir. Lors du test d'un programme sous forme de boîte blanche, la structure interne est prise en compte, c'est-à-dire classe et méthodes. De plus, les tests peuvent être divisés en quatre niveaux:

• tests unitaires - test de sections individuelles du code;
• test d'intégration - test de l'interaction et de la collaboration des composants;
• test du système - test de l'ensemble du système dans son ensemble;
• test d'acceptation - le test final du système fini pour la conformité aux exigences.

Les tests unitaires sont par définition des tests en boîte blanche.

Les tests unitaires sont utilisés dans deux versions - JUnit 3 et JUnit 4. Considérons les deux versions, car les projets plus anciens utilisent toujours la version 3, qui prend en charge Java 1.4.

JUnit 3

Pour créer un test, vous devez hériter de la classe de test TestCase, remplacer les méthodes setUp et tearDown, si nécessaire, et surtout, développer des méthodes de test dont les noms doivent commencer par l'abréviation "test". Lors du démarrage d'un test, une instance de la classe de test est d'abord créée (pour chaque test de la classe, une instance distincte de la classe), puis la méthode setUp est exécutée, le test lui-même est lancé et enfin la méthode tearDown est exécutée. Si l'une des méthodes lève une exception, le test est considéré comme ayant échoué.

Remarque: les méthodes de test doivent être public void, elles peuvent être statiques.

Les tests consistent à exécuter du code et à vérifier. Les vérifications sont le plus souvent effectuées en utilisant la classe Affirmer bien que le mot-clé assert soit parfois utilisé.

À titre d'exemple, considérons un utilitaire de chaîne qui inclut des méthodes pour vérifier une chaîne vide et représenter une séquence d'octets sous forme de chaîne hexadécimale:

La classe publique JUnit3StringUtilsTest étend TestCase (Private final Map toHexStringData \u003d new HashMap (); protected void setUp () throws Exception (toHexStringData.put ("", new byte); toHexStringData.put ("01020d112d7f", new byte (1,2 13,17,45,127)); toHexStringData.put ("00fff21180", new byte (0, -1, -14,17, -128)); // ...) protected void tearDown () jette Exception (toHexStringData. clear ();) public void testToHexString () (for (Iterator iterator \u003d toHexStringData.keySet (). iterator (); iterator.hasNext ();) (chaîne finale attendue \u003d (String) iterator.next (); octet final testData \u003d (octet) toHexStringData.get (attendu); final String actual \u003d StringUtils.toHexString (testData); assertEquals (attendu, réel);)) // ...)

Fonctionnalités supplémentaires, TestSuite

JUnit 3 a plusieurs fonctionnalités supplémentaires. Par exemple, vous pouvez regrouper les tests. Pour ce faire, vous devez utiliser la classe Suite de tests:

Classe publique JUnit3StringUtilsTestSuite étend TestSuite (public JUnit3StringUtilsTestSuite () (addTestSuite (StringUtilsJUnit3Test.class); addTestSuite (OtherTest1.class); addTestSuite (OtherTest) .class);

Vous pouvez répéter l'exécution du test plusieurs fois. Pour cela, RepeatedTest est utilisé:

Classe publique JUnit3StringUtilsRepeatedTest étend RepeatedTest (public JUnit3StringUtilsRepeatedTest () (super (new JUnit3StringUtilsTest (), 100);))

En héritant de la classe de test d'ExceptionTestCase, vous pouvez vérifier le code pour lever une exception:

Classe publique JUnit3StringUtilsExceptionTest étend ExceptionTestCase (public JUnit3StringUtilsExceptionTest (final String name) (super (name, NullPointerException.class);) public void testToHexString () (StringUtils.toHexString (null);))

Comme vous pouvez le voir dans les exemples, tout est assez simple et rien de superflu - un minimum de code pour les tests JUnit.

JUnit 4

JUnit 4 ajoute la prise en charge des nouvelles fonctionnalités de Java 5.0; les tests peuvent être déclarés à l'aide d'annotations. Dans le même temps, il existe une compatibilité descendante avec la version précédente du framework. Presque tous les exemples discutés ci-dessus fonctionneront également dans JUnit 4, à l'exception de RepeatedTest, qui manque dans la nouvelle version.

Quelles modifications ont été apportées à JUnit 4? Prenons le même exemple, mais en utilisant les nouvelles fonctionnalités:

La classe publique JUnit4StringUtilsTest étend Assert (Private Final Map toHexStringData \u003d nouveau HashMap (); @Before public static void setUpToHexStringData () (toHexStringData.put ("", nouvel octet); toHexStringData.put ("01020d112d7f", nouvel octet (1,2,13,17,45,127)); toHexStringData.put ("00fff2) , new byte (0, -1, -14,17, -128)); // ...) @After public static void tearDownToHexStringData () (toHexStringData.clear ();) @Test public void testToHexString () (pour (Carte.Entrée entry: toHexStringData.entrySet ()) (octet final testData \u003d entry.getValue (); final String attendu \u003d entry.getKey (); final String actual \u003d StringUtils.toHexString (testData); assertEquals (attendu, réel);)))

Qu'est-ce qui a changé dans JUnit 4?

• Pour simplifier le travail, vous pouvez hériter de la classe Affirmerbien que cela soit facultatif.
• annotation @Avant désigne les méthodes à appeler avant d'exécuter les tests. Les méthodes doivent être vide public... C'est là que les préréglages pour le test sont généralement placés, dans notre cas, il s'agit de la génération des données de test (méthode setUpToHexStringData).
• Peut utiliser l'annotation @Avant les cours, qui désigne les méthodes qui seront appelées avant de créer une instance de la classe de test; les méthodes devraient être vide public statique... Il est logique d'utiliser cette annotation (méthode) pour les tests dans le cas où la classe contient plusieurs tests utilisant des préréglages différents, ou lorsque plusieurs tests utilisent les mêmes données, afin de ne pas perdre de temps à les créer pour chaque test.
• annotation @Après désigne les méthodes à appeler après l'exécution des tests. Les méthodes doivent être vide public... C'est là que sont placées les opérations de libération des ressources après le test; dans notre cas, effacement des données de test (méthode tearDownToHexStringData).
• annotation @Après les cours significativement lié à @Avant les coursmais exécute les méthodes après avoir testé la classe. Comme avec @Avant les cours, les méthodes doivent être vide public statique.
• annotation @Tester désigne des méthodes d'essai. Comme auparavant, ces méthodes doivent être vide public... Les chèques eux-mêmes sont placés ici. En outre, cette annotation peut utiliser deux paramètres, attendu - spécifie l'exception attendue et le délai d'expiration - spécifie le délai après lequel le test est considéré comme échouant.

Exemples d'utilisation d'annotations avec des paramètres, JUnit Test:

@Test (attendu \u003d NullPointerException.class) public void testToHexStringWrong () (StringUtils.toHexString (null);) @Test (timeout \u003d 1000) public void infinity () (while (true);)

Ignorer l'exécution du test, JUnit Ignorer

Si l'un des tests doit être désactivé pour une raison sérieuse, par exemple, le test échoue continuellement. La correction du test peut être reportée à un avenir radieux en annotant @Ignorer... Si vous placez cette annotation sur une classe, tous les tests de cette classe seront désactivés.

@Ignore @Test (timeout \u003d 1000) public void infinity () (while (true);)

Règles de dégustation, règle JUnit

JUnit vous permet d'utiliser des règles définies par le développeur avant et après l'exécution du test, ce qui étend la fonctionnalité. Par exemple, il existe des règles intégrées pour définir un délai pour un test (Timeout), pour définir les exceptions attendues (ExpectedException), pour travailler avec des fichiers temporaires (TemporaryFolder), etc.

Pour déclarer une règle, vous devez créer publique ne pas statique un champ de type dérivé de MethodRule et annotez-le avec un mot-clé Règle.

Classe publique JUnitOtherTest (@Rule public final TemporaryFolder folder \u003d new TemporaryFolder (); @Rule public final Timeout timeout \u003d new Timeout (1000); @Rule public final ExpectedException thrown \u003d ExpectedException.none (); @Ignore @Test public void anotherInfinity ( ) (while (true);) @Test public void testFileWriting () jette IOException (fichier final log \u003d folder.newFile ("debug.log"); final FileWriter logWriter \u003d new FileWriter (journal); logWriter.append ("Bonjour, "); logWriter.append (" World !!! "); logWriter.flush (); logWriter.close ();) @Test public void testExpectedException () lève IOException (thrown.expect (NullPointerException.class); StringUtils.toHexString (nul);))

Suites de tests, JUnit Suite, SuiteClasses

Le test de fonctionnement peut être configuré à l'aide d'une annotation @Courir avec... Les classes de test qui contiennent des méthodes de test peuvent être combinées dans des suites de tests. Par exemple, deux classes de tests d'objets ont été créées: TestFilter, TestConnect. Ces deux classes de test peuvent être combinées en une seule classe de test TestWidgets.java:

Package com.objects; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith (Suite.class) @ Suite.SuiteClasses ((TestFilter.class, TestConnect.class)) classe publique TestWidgets ()

L'annotation @SuiteClasses est utilisée pour configurer les tests à exécuter, ce qui inclut les classes de test.

Catégories abstraites

annotation Catégories vous permet de combiner les tests en catégories (groupes). Pour ce faire, le test définit une catégorie @Catégorie, après quoi les catégories de test de démarrage dans la Suite sont configurées. Cela pourrait ressembler à ceci:

Classe publique JUnitStringUtilsCategoriesTest étend Assert (// ... @Category (Unit.class) @Test public void testIsEmpty () (// ...) // ...) @RunWith (Categories.class) @ Categories.IncludeCategory ( Unit.class) @ Suite.SuiteClasses ((JUnitOtherTest.class, JUnitStringUtilsCategoriesTest.class)) classe publique JUnitTestSuite ()

Résumé, JUnit paramétré

annotation Paramétré vous permet d'utiliser des tests paramétrés. Pour ce faire, une méthode statique est déclarée dans la classe de test qui renvoie une liste de données qui seront utilisées comme arguments du constructeur de classe.

@RunWith (Parameterized.class) classe publique JUnitStringUtilsParameterizedTest étend Assert (Private final CharSequence testData; private final boolean expected; public JUnitStringUtilsParameterizedTest (final CharSequence testData, final boolean expected) (this.testData this.testData attendu; this.testData. public void testIsEmpty () (final boolean actual \u003d StringUtils.isEmpty (testData); assertEquals (expected, actual);) @ Parameterized.Parameters public static List