Fortsetzen der Testausführung in junit4, selbst wenn eine der Assertionen fehlschlägt

Ich habe mein vorhandenes Framework mit Jfunc aufgebaut, das eine Möglichkeit bietet, die Ausführung fortzusetzen, selbst wenn einer der Asserts im Testfall fehlschlägt. Jfunc verwendet das Junit 3.x-Framework. Aber jetzt migrieren wir auf junit4, sodass ich Jfunc nicht mehr verwenden kann und es durch junit 4.10 jar ersetzt habe.
Das Problem besteht nun darin, dass wir jfunc in unserem Framework ausgiebig verwendet haben und mit junit 4 unseren Code dazu bringen wollen, die Ausführung fortzusetzen, selbst wenn eines der Asserts in einem Testfall fehlschlägt.
Hat jemand einen Vorschlag/eine Idee dafür, ich weiß im Juni, dass die Tests atomarer sein müssen, dh eine Bestätigung pro Testfall, aber wir können das aus irgendeinem Grund in unserem Framework nicht tun.

Sie können dies mit einem tun ErrorCollector Regel.

Um sie zu verwenden, fügen Sie zuerst die Regel als Feld in Ihrer Testklasse hinzu:

public class MyTest {
    @Rule
    public ErrorCollector collector = new ErrorCollector();

    //...tests...
}

Ersetzen Sie dann Ihre Asserts durch Aufrufe von collector.checkThat(...).

z.B

@Test
public void myTest() {
    collector.checkThat("a", equalTo("b"));
    collector.checkThat(1, equalTo(2));
}

Ich verwende auch den ErrorCollector, verwende aber auch assertThat und platziere sie in einem Try-Catch-Block.

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;

@Rule
public ErrorCollector collector = new ErrorCollector();

@Test
public void calculatedValueShouldEqualExpected() {
    try {
        assertThat(calculatedValue(), is(expected));
    } catch (Throwable t) {
        collector.addError
        // do something
    }
}

Sie können auch verwenden assertj – weiche Behauptung

@Test
public void testCollectErrors(){
   SoftAssertions softly = new SoftAssertions();
   softly.assertThat(true).isFalse();
   softly.assertThat(false).isTrue();
   // Don't forget to call SoftAssertions global verification !
   softly.assertAll();
}

Es gibt auch andere Möglichkeiten, es zu verwenden, ohne softly.assertAll();

1. mit Regel
2. mit automatischem Verschluss
3. Verwenden der statischenasserSoftly-Methode

Verwenden Sie try/finally-Blöcke. Das hat in meinem Fall funktioniert:

...
try {
    assert(...)
} finally {
    // code to be executed after assert
}
...

Try – catch, in “try” die Assertion verwenden, in “catch” den möglichen Fehler zur Sammlung hinzufügen. Lösen Sie dann die Ausnahme am Ende des Tests in tearDown() aus. Wenn es also einen Fehler/Fehler beim Assertion gibt, wird es abgefangen und der Test wird fortgesetzt. (Die Sammlung im Beispiel ist statisch, Sie können auch für jeden @Test eine neue Instanz in setUp() erstellen.)

    public static List<String> errors = new ArrayList<>();


    try {
        //some assert...
    }
    catch (AssertionError error) {
        errors.add(error.toString());
    }



    @After
    public void tearDown() {

        try {
            if (!errors.isEmpty()) {
                throw new AssertionError(errors);
            }
        }
        finally {
            //empty list because it's static, alternatively make instance for each test in setUp()
            errors.clear();
        }
    }

Ich habe meine eigene Klasse für einfache Behauptungen erstellt. Einfach mit Ihren Anwendungsfällen zu erweitern:

public class MyEquals {

public static void checkTestSummary(MyTestSummary myTestSummary) {
    final List<MyTestResult> conditions = myTestSummary.getTestResults();
    final int total = conditions.size();

    final boolean isSuccessful = myTestSummary.isSuccessful();
    if (isSuccessful) {
        System.out.println(format("All [%s] conditions are successful!", total));
    } else {
        final List<MyTestResult> failedConditions = conditions.stream().filter(MyTestResult::isTestResult).collect(Collectors.toList());
        System.out.println(format("\nNot yet.. [%s out of %s] conditions are failed", failedConditions.size(), total));
    }

    if (!isSuccessful) {
        for (int i = 0; i < total; i++) {
            final MyTestResult myTestResult = conditions.get(i);
            if (myTestResult.isTestResult()) {
                System.out.println(format("  Success [%s of %s] => Expected %s Actual %s Good!", i + 1, total, myTestResult.getExpected(), myTestResult.getActual()));
            } else {
                System.out.println(format("!! Failed [%s of %s] => Expected %s Actual %s", i + 1, total, myTestResult.getExpected(), myTestResult.getActual()));
            }
        }
    }

    assertTrue(isSuccessful);
}

public static void myAssertEquals(MyTestSummary myTestSummary, Object expected, Object actual) {
    if (checkEquals(expected, actual)) {
        assertEquals(expected, actual);
        myTestSummary.addSuccessfulResult(expected, actual);
    } else {
        myTestSummary.addFailedResult(expected, actual);
        myTestSummary.setSuccessful(false);
    }
}

public static boolean checkEquals(Object value1, Object value2) {
    if (value1 == null && value2 == null) {
        return true;
    } else if (value1 != null && value2 == null) {
        return false;
    } else if (value1 == null && value2 != null) {
        return false;
    } else if (value1 != null && value2 != null) {
        return value1.equals(value2);
    }
    return false;
}

}

@Builder
@Value
public class MyTestResult {

    String expected;

    String actual;

    boolean testResult;

 }



@Data
public class MyTestSummary {

private boolean successful = true;

private List<MyTestResult> testResults = new ArrayList<>();

public MyTestSummary() {
}

public void addSuccessfulResult(Object expected, Object actual) {
    getTestResults().add(MyTestResult.builder()
        .expected(String.valueOf(expected))
        .actual(String.valueOf(actual))
        .testResult(true)
        .build()
    );
}

public void addFailedResult(Object expected, Object actual) {
    getTestResults().add(MyTestResult.builder()
        .expected(String.valueOf(expected))
        .actual(String.valueOf(actual))
        .testResult(false)
        .build()
    );
}
}

Verwendung im Junit-Test

@Test
public void testThat() {
    MyTestSummary myTestSummary = new MyTestSummary();
    myAssertEquals(myTestSummary, 10, 5 + 5);
    myAssertEquals(myTestSummary, "xxx", "x" + "x");
    checkTestSummary(myTestSummary);
}

Ausgabe:

Not yet.. [1 out of 2] conditions are failed
Success [1 of 2] => Expected 10 Actual 10 Good!
!! Failed [2 of 2] => Expected xxx Actual xx

 org.opentest4j.AssertionFailedError: expected: <true> but was: <false>
 Expected :true
 Actual   :false

Eine weitere Option ist das beobachtbare Muster in Verbindung mit Lambda-Ausdrücken. Sie können so etwas wie das obige verwenden.

public class MyTestClass {

    private final List<Consumer<MyTestClass>> AFTER_EVENT = new ArrayList<>();

    @After
    public void tearDown() {
        AFTER_EVENT.stream().forEach(c -> c.accept(this));
    }

    @Test
    public void testCase() {
        //=> Arrange
        AFTER_EVENT.add((o) -> {
            // do something after an assertion fail.
        }));

        //=> Act

        //=> Assert
        Assert.assertTrue(false);
    }
}