web-dev-qa-db-fra.com

Liste des annotations dans JUnit

Récemment, j'ai étudié et implémenté le framework JUnit. Par conséquent, je connais quelques annotations utilisées dans JUnit: - @Test, @Before, @After, @Ignore, @BeforeClass , @AfterClass, @Runwith(Suite.class), @SuiteClasses({}), @Parameters, @RunWith(Parameterized.class) et @Rule.

Je suis sûr qu'il y a plus d'annotations qui sont utilisées dans JUnit. Quelqu'un peut-il me guider avec une liste d'autres annotations qui peuvent être utilisées et dans quelles circonstances elles sont utilisées?

Merci.

javajunit4
28
silver_noodles

Cette recherche Github (@interface) Vous donne la liste de toutes les annotations:

https://github.com/junit-team/junit/search?q=%22%40interface%22&type=Code

Annotations de base

@Test@Before@After@AfterClass@BeforeClass@Ignore@Runwith

Tests paramétrés

Pour les tests paramétrés, utilisez @Parameters Et @RunWith(Parameterized.class)
https://github.com/junit-team/junit/wiki/Parameterized-tests

Catégorie

@Category
Regroupement des tests en catégories. par exemple. Rapide, lent, etc.

https://github.com/junit-team/junit/wiki/Categories

@IncludeCategory
Exécute uniquement les classes et méthodes qui sont annotées soit avec la catégorie donnée avec l'annotation @IncludeCategory, Soit avec un sous-type de cette catégorie.

@ExcludeCategory
Inverse de @IncludeCategory

Règles

@Rule
Les règles permettent l'ajout ou la redéfinition très flexible du comportement de chaque méthode de test dans une classe de test. par exemple. Création d'une règle de dossier temporaire pour créer un dossier temporaire lors de l'exécution de tests.

https://github.com/junit-team/junit/wiki/Rules

Théorie et annotations associées

@Theory
Les théories donnent des assertions plus flexibles et expressives

https://github.com/junit-team/junit/wiki/Theories

@DataPoint
L'annotation d'un champ ou d'une méthode avec @DataPoint Entraînera l'utilisation de la valeur du champ ou de la valeur renvoyée par la méthode comme paramètre potentiel pour les théories de cette classe

@DataPoints

Extension de @Datapoint
L'annotation d'un tableau ou d'un champ ou d'une méthode de type itérable avec @DataPoints Provoquera l'utilisation des valeurs du tableau ou de l'itérable donné comme paramètres potentiels pour les théories de cette classe

@FromDataPoints

L'annotation d'un paramètre d'une méthode @Theory Avec @FromDataPoints Limitera les points de données considérés comme des valeurs potentielles pour ce paramètre à seulement @DataPoints Avec le nom donné

@ParametersSuppliedBy
L'annotation d'un paramètre de méthode @Theory Avec @ParametersSuppliedBy Lui donne des valeurs provenant du ParameterSupplier nommé lorsqu'il est exécuté en tant que théorie

@TestedOn

L'annotation @TestedOn Prend un tableau de valeurs à utiliser comme points de données pour le paramètre annoté.

par exemple.

@Theory
public void multiplyIsInverseOfDivideWithInlineDataPoints(
        @TestedOn(ints = {0, 5, 10}) int amount,
        @TestedOn(ints = {0, 1, 2}) int m
) {
    assumeThat(m, not(0));
    assertThat(new Dollar(amount).times(m).divideBy(m).getAmount(), is(amount));
}
55
Ajay George