Java: test d'exception avec Junit 3

Je voudrais écrire un test pour IndexOutOfBoundsException. Gardez à l'esprit que nous sommes censés utiliser JUnit 3.

Mon code:

public boolean ajouter(int indice, T element) {
    if (indice < 0 || indice > (maListe.size() - 1)) {
        throw new IndexOutOfBoundsException();
    } else if (element != null && !maListe.contains(element)) {
        maListe.set(indice, element);
        return true;
    }
}

Après quelques recherches, j'ai trouvé que vous pouvez faire cela avec JUnit 4 à l'aide de @Test(expected = IndexOutOfBoundsException.class) mais pas où j'ai trouver comment faire cela dans JUnit 3.

Comment puis-je tester cette utilisation de JUnit 3?

source d'informationauteur Mobidoy

  1. 31

    Tests exceptions dans JUnit 3 utilise ce modèle:

    try {
     ... code that should throw an exception ...

     fail( "Missing exception" );
} catch( IndexOutOfBoundsException e ) {
     assertEquals( "Expected message", e.getMessage() ); //Optionally make sure you get the correct message, too
}

    La fail() permet de s'assurer que vous obtenez un message d'erreur si le code n'est pas de lever une exception.

    - Je utiliser ce modèle dans JUnit 4, car j'ai l'habitude de voulez vous assurer que les valeurs correctes sont visibles dans le message d'exception et @Test peux pas le faire.

  2. 14

    Fondamentalement, vous avez besoin d'appeler votre méthode et d'échouer si elle n'est pas jeter l'exception au droit, ou s'il jette quelque chose d'autre:

    try {
  subject.ajouter(10, "foo");
  fail("Expected exception");
} catch (IndexOutOfBoundException expect) {
  //We should get here. You may assert things about the exception, if you want.
}
  3. 2

    Une solution simple est d'ajouter un try catch pour le unittest et de laisser le test échoue lors de l'exception n'est pas levée

    public void testAjouterFail() {
  try {
    ajouter(-1,null);
    JUnit.fail();
  catch (IndexOutOfBoundException()) {
    //success
  }
}
  4. 2

    Une chose que vous pouvez faire est d'utiliser un booléen pour exécuter le test jusqu'à la fin et puis vous pouvez utiliser assert pour valider la levée de l'exception:

    boolean passed = false;
try
{
    //the line that throws exception
    //i.e. illegal argument exception
    //if user tries to set the property to null:
    myObject.setProperty(null);
}
catch (IllegalArgumentException iaex)
{
    passed = true;
}
assertTrue("The blah blah blah exception was not thrown as expected"
              , passed);

    Par l'utilisation de ce test, le test ne sera jamais ne parviennent pas à exécuter et vous pouvez valider qu'un type d'exception est levée.

  5. 1

    Dans votre méthode de test, l'appel ajouter() à l'intérieur d'un try..catch bloc, ce qui donne une valeur de indice qui devrait provoquer l'exception levée, avec

    • un catch clause qui attire IndexOutOfBoundsException: dans ce cas de retour de votre méthode d'essai et donc indiquer un laissez-passer.
    • un deuxième catch clause qui attire Throwable: dans ce cas, déclarer une défaillance (appel fail()), en raison de la mauvaise nature de l'exception a été levée
    • après la try..catch déclarer une défaillance (appel fail()), car aucune exception a été levée.
  6. 1

    L'extension @Aaron solution avec (statiques import) sucre syntaxique permet d'écrire:

        expected(MyException.class,
        new Testable() {
            public void test() {
            ... do thing that's supposed to throw MyException ...
            }
        });

    Testable est comme un Exécutable qui utilise le test() signature lancer à Lancer.

    public class TestHelper {
    public static void expected(Class<? extends Throwable> expectedClass, Testable testable) {
        try {
            testable.test();
            fail("Expected "+ expectedClass.getCanonicalName() +" not thrown.");
        } catch (Throwable actual) {
            assertEquals("Expected "+ expectedClass.getCanonicalName() +" to be thrown.", expectedClass, actual.getClass());
        }
    }

    interface Testable {
        public void test() throws Throwable;
    }
}

    Vous pouvez ajouter la vérification de l'exception message comme requis.