Différence entre les théories JUnit et les tests paramétrés

Quelle est la différence entre un test théorique et un test paramétré?

Je ne suis pas intéressé par les différences d’implémentation lors de la création des classes de test, juste au moment où vous choisiriez l’une sur 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 cas de test.

Les théories sont similaires mais conceptuelles différentes. L’idée est de créer des cas de test qui testent des hypothèses plutôt que des valeurs statiques. Donc, si les données de test fournies sont vraies selon certaines hypothèses, l’assertion qui en résulte est toujours déterministe. L’une des idées principales 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. De plus, vous devez souvent tester un univers de possibilités dans une donnée de test, comme les nombres négatifs. Si vous testez cela statiquement, c’est-à-dire fournissez quelques nombres négatifs, il n’est pas garanti que votre composant fonctionnera contre tous les nombres négatifs, même si cela est hautement probable.

D’après ce que je peux dire, les frameworks xUnit tentent d’appliquer les concepts des théories en créant toutes les combinaisons possibles de vos données de test fournies.

Les deux doivent être utilisés lorsqu’on aborde un scénario dans un scénario basé sur des données (c’est-à-dire que seules les entrées changent, mais le test effectue toujours les mêmes assertions).

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 “paramesortingze” avec une seule variable, alors que Theories.class “paramesortingze” 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 parameters

D’après ce que je comprends, la différence est qu’un test paramétré est utilisé lorsque tout ce que vous voulez faire est de tester un ensemble différent d’entrées (testez-les individuellement), une théorie est un cas particulier de test paramétré dans lequel vous testez chaque entrée comme un tout (chaque paramètre doit être vrai).

Un peu tard pour répondre. Mais cela serait utile pour les 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 renvoyant Collection et annotées avec des champs @Parameters vs statiques annotés avec @DataPoints ou @DataPoint.
  • Les entrées sont transmises au constructeur (obligatoire) et utilisées par la méthode de test contre les entrées 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

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 (4 méthodes x 2 méthodes) Tests JUnit