Différence entre les théories JUnit et les tests paramétrés
Quelle est la différence entre une théorie et un test paramétré?
Je ne m'intéresse pas aux différences de mise en œuvre lors de la création des classes de test, mais uniquement au moment de choisir l'une ou l'autre.
D'après ce que j'ai compris: Avec les tests paramétrés, vous pouvez fournir une série d'entrées statiques à un scénario de test.
Les théories sont similaires mais de concept différent. L'idée sous-jacente est de créer des scénarios de test fondés sur des hypothèses plutôt que sur des valeurs statiques. Ainsi, si les données de test fournies sont vraies d'après certaines hypothèses, l'assertion résultante est toujours déterministe. L’une des idées maîtresses derrière cette idée est que vous seriez en mesure de fournir un nombre infini de données de test et que votre scénario de test serait toujours vrai; En outre, il est souvent nécessaire de tester un univers de possibilités dans des données d'entrée de test, telles que des nombres négatifs. Si vous testez cela statiquement, c’est-à-dire que vous fournissez quelques nombres négatifs, il n’est pas garanti que votre composant fonctionnera contre tous les nombres négatifs, même s’il est hautement probable que cela se produise.
D'après ce que je peux dire, les frameworks xUnit essayent d'appliquer les concepts des théories en créant toutes les combinaisons possibles des données de test fournies.
Les deux doivent être utilisés lors de l'approche d'un scénario dans un scénario basé sur les données (c'est-à-dire que seules les entrées changent, mais le test fait toujours les mêmes assertions encore et encore).
Mais comme les théories semblent expérimentales, je ne les utiliserais que si je devais tester une série de combinaisons dans mes données d'entrée. Pour tous les autres cas, j'utiliserais des tests paramétrés.
Parameterized.class teste les tests "paramétrisés" avec une seule variable, tandis que Theories.class "paramétre" avec toutes les combinaisons de plusieurs variables.
Pour des exemples, veuillez lire:
http://blogs.Oracle.com/jacobc/entry/parameterized_unit_tests_with_junit
http://blog.schauderhaft.de/2010/02/07/junit-theories/
http://blogs.Oracle.com/jacobc/entry/junit_theories
Theories.class est similaire à Haskell QuickCheck:
http://en.wikibooks.org/wiki/Haskell/Testing
mais QuickCheck génère automatiquement des combinaisons de paramètres
En plus des réponses ci-dessus: Sur une entrée avec 4 valeurs et 2 méthodes de test
@RunWith (Theories.class) - générera 2 tests JUnit
@RunWith (Parameterized.class) - générera 8 tests (4 entrées x 2 méthodes) JUnit
Si je comprends bien, la différence est qu’un test paramétré est utilisé lorsque tout ce que vous voulez faire est de tester un ensemble d’entrées différent (testez-les individuellement), une théorie étant un cas particulier d’un test paramétré dans lequel vous testez chaque entrée un tout (chaque paramètre doit être vrai).
Un peu tard pour répondre. Mais cela serait utile aux futurs testeurs.
Tests paramétrés vs théories
- Classe annotée avec "@RunWith (Parameterized.class)" VS "@RunWith (Theories.class)"
- Les entrées de test sont extraites d'une méthode statique retournant Collection et annotées avec @Parameters vs champs statiques annotés avec @DataPoints ou @DataPoint.
- Les entrées sont transmises au constructeur (obligatoire) et utilisées par la méthode de test, tandis que les entrées sont directement transmises à la méthode de test.
- La méthode de test est annotée avec @Test et ne prend pas d'arguments vs La méthode de test est annotée avec @Theory et peut prendre des arguments