JUnit-Tests für eine Ausnahme eines bestimmten Typs

Ich bin zu wollen wissen, wenn ich testen (mit JUnit), dass eine bestimmte Nachricht erzeugt, indem eine Ausnahme geworfen bekommt, anstatt nur "ob oder nicht" eine Ausnahme geworfen wurde.
Zum Beispiel die JunitTest.java code wird tatsächlich den test zu bestehen, weil eine exception geworfen wurde, aber wenn ich auch wollte, um zu testen, ob die Zeichenfolge erzeugt, die durch die Ausnahme war gleich: "Test Ausnahme: ganze Zahl kann nicht negativ sein.." ist das möglich?

TestException.java

public class TestException extends Exception {  
    /**
     * @param message informative message about the problem found
     */
    public TestException (String message) {
        super("Test Exception: " + message);
    }
}

Test.java

public void function(Integer mustBePositive) throws TestException {
    if (mustBePositive < 0) {
        throw new TestException("Integer may not be negative..");
    }
    else {
        mustBePositive = myNum
    }
}

JunitTest.java

import org.junit.*;

public class JUnitTest {

    @Test(expected = TestException.class)
    public void functionTest() throws TestException {
        function(-1);
    }
}
InformationsquelleAutor Samwisest | 2012-04-13
  1. 8

    Anmerkung: ich glaube @Matthew ' s Antwort überlegen ist.

    Können Sie die folgenden Struktur - tests, dass die richtige exception geworfen wurde (TestException.class) und, dass die Nachricht wie erwartet.

    @Test(expected = TestException.class)
public void test_function_negative() {
    try {
        function(-5);
    } catch (TestException ex) {
        assertEquals("Integer may not be negative..", ex.getMessage());
        throw ex;
    }
}

    BEARBEITEN

    Warum ich rethrow Ausnahme (ein Kommentar): der erste test unten geht, während die zweite nicht. Also es fügt eine zusätzliche Ebene der Validierung. Nun, Wenn ich gefangen ExceptionB in dem code unten, beide tests scheitern würden.

    @Test
public void test1() throws ExceptionB {
    try {
        throw new ExceptionA();
    } catch (ExceptionA e) {
        assertEquals("message", e.getMessage());
    }
}

@Test(expected=ExceptionB.class)
public void test2() throws ExceptionA {
    try {
        throw new ExceptionA();
    } catch (ExceptionA e) {
        assertEquals("message", e.getMessage());
        throw e;
    }
}

public class ExceptionA extends Exception{
    @Override
    public String getMessage() {
        return "message";
    }
}
public class ExceptionB extends ExceptionA{}
    • Danke, das war genau das, was ich nach 🙂
    • Sollte assertTrue in diesem Fall.
    • Es funktioniert, aber ich habe geändert, um Ihre version, die ist besser.
    • Es würde brennen meine Seele zum Zustand der exception-Klasse in den code, und dann haben Sie es wieder tun in @Test.
    • Eigentlich habe ich nicht ganz Zustimmen - Wenn Sie eine Ausnahme, die Unterklassen anderen, Ihre test könnte passieren, während mir nicht.
    • aber dann den Klassennamen in 'bei'Test und der code würde nicht passen, und damit meine Seele bliebe 72 Grad.
    • Ihre Seele erhitzt eine Menge 😉

    InformationsquelleAutor assylias
  2. 6

    Können Sie das standard-JUnit -TestRule ExpectedException. Dies ermöglicht Ihnen zu testen, dass eine Ausnahme geworfen wird, und auch testen Sie die Nachricht, die Sie begleitet, die Ausnahme. Zum Beispiel:

    public static class HasExpectedException {
  @Rule
  public ExpectedException thrown= ExpectedException.none();

  @Test
  public void throwsNothing() {
    //no exception expected, none thrown: passes.
  }

  @Test
  public void throwsNullPointerException() {
    thrown.expect(NullPointerException.class);
    throw new NullPointerException();
  }

  @Test
  public void throwsNullPointerExceptionWithMessage() {
    thrown.expect(NullPointerException.class);
    thrown.expectMessage("happened?");
    thrown.expectMessage(startsWith("What"));
    throw new NullPointerException("What happened?");
  }
}

    Den expectMessage() nimmt entweder einen String (einen substring der Nachricht) oder ein Matcher, so können Sie den regulären Ausdruck zu prüfen oder was auch immer.

    InformationsquelleAutor Matthew Farwell
  3. 2
    assertEquals("Test Exception: Integer may not be negative..", e.getMessage());
    InformationsquelleAutor Oh Chin Boon
  4. 1

    Ich es so machen:

      @Test
  public void functionTest() throws TestException {
    try {
        function(-1);
        fail("This should have thrown an exception.");
    } catch (TextException e) {
       assertEquals("exception test produced an unexpected message", EXPECTED_TEXT, e.getMessage());
    }
  }

    Dies ist vielleicht nicht elegant, aber es ist leicht zu verstehen und deckt alle Grundlagen. disclaimer - ich habe es nicht kompiliert.

    InformationsquelleAutor Tony Ennis
  5. 1

    Andere haben schon darauf hingewiesen, die Struktur, die Sie verwenden können, um dies zu testen, aber ich würde nicht testen, die Nachricht selbst als das kann ziemlich spröde.

    Sollten Sie erstellen Sie eine benutzerdefinierte Ausnahme, dass bekommt erhält alle erforderlichen Daten-und nur behaupten, dass die Daten vorhanden sind. Wenn Sie wirklich über die Nachricht dann können Sie unit-Tests, die separat auf die Ausnahme selbst.

    Angesichts Ihrer Beispiel:

    public void function(Integer mustBePositive) throws TestException {
    if (mustBePositive < 0) {
        throw new TestException("Integer may not be negative..");
    }
    else {
        mustBePositive = myNum
    }

    Konnte Sie nur werfen eine NegativeNumberException. Wenn Sie wirklich wollen, zu wissen, was die Zahl ist, könnte man den code so ändern, das als das argument:

    public void function(Integer mustBePositive) throws TestException {
    if (mustBePositive < 0) {
        throw new NegativeNumberException(mustBePositive);
    }
    else {
        mustBePositive = myNum
    }

    Dann in Ihrem test:

     @Test(expected = NegativeNumberException.class)
 public void functionTest() throws TestException {
    try {
        function(-1);
    } catch (NegativeNumberException nne) {
        assertThat(nne.getNumber(), equalTo(-1));
    }
 }

    Ihre Ausnahme, erzeugt die Nachricht jedoch es für richtig hält, und änderungen an diesem Ausgang nicht die welligkeit durch den rest der test-code

    • Wenn der string war wichtig, ich würde es testen. Es sei denn, der string ist dynamisch, ich würde das nicht als solches zu testen, die mehr spröde als jeder andere test. In jedem Fall sollte der string sein, eine öffentliche Konstante in TestJava. Dann ist der test (und der eigentliche code) könnte beziehen sich auf die Konstante.
    • Wenn der string ist wichtig genug, um zu testen, dann, nachdem es als eine Konstante verwiesen wird, die von Ihrer test-code und Ihre Produktions-code führt zu einem sinnlosen test. Alle sind Sie dann testen ist, dass Sie verweisen auf den gleichen string, aber nichts um zu überprüfen, dass die tatsächliche Zeichenfolge korrekt ist
    InformationsquelleAutor tddmonkey
  6. 1

    catch-Ausnahme gemacht wird, um dieses Szenario zu unterstützen:

    import static com.googlecode.catchexception.CatchException.*;

public void testFunction() throws Exception {
    verifyException(obj).function(-1);
    assertEquals("Integer may not be negative..", 
                 caughtException().getMessage());
}
    InformationsquelleAutor rwitzel
  7. -1

    import org.junit. * ;

    public class JUnitTest {

    @Test
public void functionTest() throws TestException {
    try {
        function (-1);
        fail("");
    } catch (TestException e) {
        if (!e.getMessage().equals("Integer may not be negative..")) 
          fail("");
    }
}
    • Wenn du gehst, um dies zu tun, sollten Sie Sie verwenden assertEquals oder assertThat. Wenn dieser test fehlschlägt, gibt es keine Ausgabe, warum
    InformationsquelleAutor clevertension
Schreibe einen Kommentar