Comment tester les types enum?

Je suis en train d'essayer de construire une plus ou moins ensemble complet de tests unitaires pour une petite bibliothèque. Puisque nous voulons permettre des implémentations différentes d'exister nous voulons que cette série de tests pour être (un) générique, de sorte que nous pouvons l'utiliser pour tester les différentes implémentations et (b) la plus complète possible. Pour le b) de la partie j'aimerais savoir si il y a de meilleur-pratique pour tester les types d'énumérations. Ainsi, par exemple, j'ai un enum comme suit:

public enum Month {
    January,
    February,
    ...
    December;
}

Ici, je veux m'assurer que tous les types enum existent vraiment. C'est que même nécessaire? Actuellement, je suis en utilisant Hamcrests assertThat comme dans l'exemple suivant:

assertThat(Month.January, is(notNullValue()));

Manque de "janvier" enum résultat serait une erreur de compilation qui l'on peut résoudre par la création, le manque d'un type enum.

Je suis à l'aide de Java ici, mais je n'ai pas l'esprit si votre réponse est pour une autre langue..

Edit:

Comme mkato et Mark Heath ont tous les deux souligné les tests enums peut ne pas être nécessaire puisque le compilateur ne compile pas lorsque vous utilisez un type d'énumération qui n'est pas là. Mais j'ai encore envie de tester ces énumérations, puisque nous voulons construire une salle de TCK-comme test.jar qui va exécuter le même test sur les différentes implémentations. Donc ma question était plus destiné à être comme: Quelle est la meilleure façon de tester les types enum?

Après y avoir réfléchi un peu plus, j'ai changé le Hamcrest déclaration ci-dessus:

assertThat(Month.valueOf("January"), is(notNullValue()));

Cette déclaration jette un NPE lors de janvier n'existe pas (encore). Il n'y a rien de mal avec cette approche?

source d'informationauteur seb

17

Pour les enums, je test uniquement quand ils ont en fait des méthodes en eux. Si c'est une pure valeur d'enum comme votre exemple, je dirais: ne vous embêtez pas.

Mais puisque vous êtes désireux de le tester, allez avec votre deuxième option est beaucoup mieux que le premier. Le problème avec la première est que si vous utilisez un IDE, tout renommage sur les enums serait également renommer celles qui sont dans votre classe de test.
8

Je suis d'accord avec aberrant80.

Pour les enums, je test uniquement quand ils ont en fait des méthodes en eux.
Si c'est une pure valeur d'enum comme votre exemple, je dirais: ne pas
la peine.

Mais puisque vous êtes désireux de le tester, allez avec votre deuxième option est
bien mieux que le premier. Le problème avec la première est que si vous
utiliser un IDE, tout renommage sur les enums serait également renommer ceux dans
votre classe de test.

Je voudrais étendre sur elle, en ajoutant que l'unité des tests d'un Enum peut être très utile. Si vous travaillez dans une grande base de code, le temps de construction commence à monter et d'une unité de test peut être un moyen plus rapide pour vérifier les fonctions (tests seulement de construire leurs dépendances). Un autre grand avantage est que les autres développeurs ne peuvent pas modifier les fonctionnalités de votre code involontairement (un énorme problème avec de très grandes équipes).

Et avec tout le Développement Piloté par les tests, essais autour d'un Enums Méthodes de réduire le nombre de bugs dans votre base de code.

Exemple Simple
```
public enum Multiplier {
    DOUBLE(2.0),
    TRIPLE(3.0);

    private final double multiplier;

    Multiplier(double multiplier) {
        this.multiplier = multiplier;
    }

    Double applyMultiplier(Double value) {
        return multiplier * value;
    }

}

public class MultiplierTest {

    @Test
    public void should() {
        assertThat(Multiplier.DOUBLE.applyMultiplier(1.0), is(2.0));
        assertThat(Multiplier.TRIPLE.applyMultiplier(1.0), is(3.0));
    }
}
```
4

Généralement, je dirais que c'est exagéré, mais il y a parfois des raisons pour écrire des tests unitaires pour les enums.

Parfois les valeurs attribuées aux membres de l'énumération ne doit pas modifier ou le chargement d'héritage des données persistantes échouera. De même, apparemment inutilisés doivent pas être supprimés. Les tests unitaires peuvent être utilisés pour se prémunir contre un développeur de faire des changements sans tirer toutes les conséquences.
3

Si vous utilisez tous les mois dans votre code, votre IDE ne vous laisseront pas de les compiler, donc je pense que vous n'avez pas besoin de tests unitaires.

Mais si vous les utilisez avec réflexion, même si vous supprimez un mois, il va compiler, donc c'est valable pour mettre un test unitaire.

vous pouvez tester si vous avez exactement certaines valeurs, par exemple:

for(MyBoolean b : MyBoolean.values()) {
    switch(b) {
    case TRUE:
        break;
    case FALSE:
        break;
    default:
        throw new IllegalArgumentException(b.toString());
}

for(String s : new String[]{"TRUE", "FALSE" }) {
    MyBoolean.valueOf(s);
}

Si quelqu'un enlève ou ajoute une valeur, certains de test échoue.

Vous devez vous connecter pour publier un commentaire.