Ausschließen eines Nicht-Param-Tests in parametrisierter Testklasse

Gibt es eine Anmerkung in JUnit auszuschließen non param test in parametrisierten test-Klasse?

InformationsquelleAutor der Frage user405516 | 2010-07-29

JUnit 5

Als der Junit-5.0.0 können Sie jetzt Anmerkungen in Ihren test-Methoden mit @ParameterizedTest. So dass keine Notwendigkeit für innere Klassen. Es gibt viele Möglichkeiten, liefern die Argumente, um die parametrisierten test abgesehen von ValueSource wie unten gezeigt. Finden Sie die offizielle junit-Benutzerhandbuch details:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class ComponentTest {

    @ParameterizedTest
    @ValueSource(strings = { "racecar", "radar", "able was I ere I saw elba" })
    public void testCaseUsingParams(String candidate) throws Exception {
    }

    @Test
    public void testCaseWithoutParams() throws Exception {
    }
}

JUnit 4

Wenn Sie noch mit Junit 4 (ich habe das getestet mit v4.8.2) verwenden Sie die Beiliegenden Läufer in Verbindung mit inneren Klassen und die Parametrisierte Läufer:

import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

@RunWith(Enclosed.class)
public class ComponentTest {

    @RunWith(Parameterized.class)
    public static class ComponentParamTests {

        @Parameters
        ...

        @Test
        public void testCaseUsingParams() throws Exception {
        }
    }

    public static class ComponentSingleTests {

        @Test
        public void testCaseWithoutParams() throws Exception {
        }
    }
}

InformationsquelleAutor der Antwort Matthew Madson

11

Ich gerade herausgefunden die man nutzen kann,JUnitParams.
Ich konvertiert eine von meinen tests, jetzt zu verwenden, und es funktioniert wunderbar.

InformationsquelleAutor der Antwort AmanicA
5

Nicht. Die beste Praxis ist, sich zu bewegen, als die nicht-parametrisierten tests in eine andere Klasse (.java-Datei)

InformationsquelleAutor der Antwort Jeanne Boyarsky
2

Zohhak test runner ist ein einfacher Weg, um das parametrisieren von spezifischen tests.
Danke Piotr!

InformationsquelleAutor der Antwort AmanicA

War ich in der Lage, etwas zu tun, sehr ähnlich wie Matthew Madson Antwort und fand es nützlich, um eine Basis-Klasse zu Kapseln, setup-und Allgemeine Hilfsfunktionen zwischen den Einzel-und param-tests. Dies funktioniert ohne die Verwendung Enclosed.class.

 @RunWith(Suite.class)
 @SuiteClasses({ComponentTest.ComponentParamTests.class, ComponentTest.ComponentSingleTests.class})
 public class ComponentTest {

    public static class TestBase {
        @Spy
        ...
        @Before
        ...
    }

    @RunWith(Parameterized.class)
    public static class ComponentParamTests extends TestBase{
        @Parameter
        ...
        @Parameters
        ...
        @Test
        ...
    }
    public static class ComponentSingleTests extends TestBase{
        @Test
        ...
    }
}

InformationsquelleAutor der Antwort Phil Ninan

Scheint es, dass TestNG nicht leiden unter diesem problem.
Ich bin nicht so verzweifelt, so dass ich veränderte die builtin-Parametrisierte Klasse, die diese Funktion unterstützen. Einfach kommentieren entsprechenden Prüfungen, wie @NonParameterized.
Beachten Sie, dass diese Klasse funktioniert nur mit Ihren Anmerkungen, d.h. überprüfen Sie Ihre Importe.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.junit.Test;
import org.junit.runner.Runner;
import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.Suite;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;
import org.junit.runners.model.TestClass;

/**
 * <p>
 * The custom runner <code>Parameterized</code> implements parameterized tests.
 * When running a parameterized test class, instances are created for the
 * cross-product of the test methods and the test data elements.
 * </p>
 * For example, to test a Fibonacci function, write:
 *
 * <pre>
 * &#064;RunWith(Parameterized.class)
 * public class FibonacciTest {
 *     &#064;Parameters
 *     public static List&lt;Object[]&gt; data() {
 *         return Arrays.asList(new Object[][] {
 *                 Fibonacci,
 *                 { {0, 0}, {1, 1}, {2, 1}, {3, 2}, {4, 3}, {5, 5},
 *                         {6, 8}}});
 *     }
 *
 *     private int fInput;
 *
 *     private int fExpected;
 *
 *     public FibonacciTest(int input, int expected) {
 *         fInput = input;
 *         fExpected = expected;
 *     }
 *
 *     &#064;Test
 *     public void test() {
 *         assertEquals(fExpected, Fibonacci.compute(fInput));
 *     }
 * }
 * </pre>
 * <p>
 * Each instance of <code>FibonacciTest</code> will be constructed using the
 * two-argument constructor and the data values in the
 * <code>&#064;Parameters</code> method.
 * </p>
 */
public class Parameterized extends Suite {

    /**
     * Annotation for a method which provides parameters to be injected into the
     * test class constructor by <code>Parameterized</code>
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public static @interface Parameters {
    }

    /**
     * Annotation for a methods which should not be parameterized
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public static @interface NonParameterized {
    }

    private class TestClassRunnerForParameters extends
            BlockJUnit4ClassRunner {
        private final int fParameterSetNumber;

        private final List<Object[]> fParameterList;

        TestClassRunnerForParameters(Class<?> type,
                List<Object[]> parameterList, int i) throws InitializationError {
            super(type);
            fParameterList = parameterList;
            fParameterSetNumber = i;
        }

        @Override
        public Object createTest() throws Exception {
            return getTestClass().getOnlyConstructor().newInstance(
                    computeParams());
        }

        private Object[] computeParams() throws Exception {
            try {
                return fParameterList.get(fParameterSetNumber);
            } catch (ClassCastException e) {
                throw new Exception(String.format(
                        "%s.%s() must return a Collection of arrays.",
                        getTestClass().getName(), getParametersMethod(
                                getTestClass()).getName()));
            }
        }

        @Override
        protected String getName() {
            return String.format("[%s]", fParameterSetNumber);
        }

        @Override
        protected String testName(final FrameworkMethod method) {
            return String.format("%s[%s]", method.getName(),
                    fParameterSetNumber);
        }

        @Override
        protected void validateConstructor(List<Throwable> errors) {
            validateOnlyOneConstructor(errors);
        }

        @Override
        protected Statement classBlock(RunNotifier notifier) {
            return childrenInvoker(notifier);
        }

        @Override
        protected List<FrameworkMethod> computeTestMethods() {
            List<FrameworkMethod> ret = super.computeTestMethods();
            for (Iterator<FrameworkMethod> i = ret.iterator(); i.hasNext();) {
                FrameworkMethod frameworkMethod =
                    (FrameworkMethod) i.next();
                if (isParameterized() ^
                    !frameworkMethod.getMethod().isAnnotationPresent(
                        NonParameterized.class)) {
                    i.remove();
                }
            }
            return ret;
        }

        protected boolean isParameterized() {
            return true;
        }
    }

    private class TestClassRunnerForNonParameterized extends
        TestClassRunnerForParameters {

        TestClassRunnerForNonParameterized(Class<?> type,
            List<Object[]> parameterList, int i)
            throws InitializationError {
            super(type, parameterList, i);
        }

        protected boolean isParameterized() {
            return false;
        }
    }

    private final ArrayList<Runner> runners = new ArrayList<Runner>();

    /**
     * Only called reflectively. Do not use programmatically.
     */
    public Parameterized(Class<?> klass) throws Throwable {
        super(klass, Collections.<Runner> emptyList());
        List<Object[]> parametersList = getParametersList(getTestClass());
        if (parametersList.size() > 0) {
            try {
                runners.add(new TestClassRunnerForNonParameterized(
                    getTestClass()
                        .getJavaClass(), parametersList, 0));
            } catch (Exception e) {
                System.out.println("No non-parameterized tests.");
            }
        }
        try {
            for (int i = 0; i < parametersList.size(); i++) {
                runners.add(new TestClassRunnerForParameters(getTestClass()
                    .getJavaClass(),
                    parametersList, i));
            }
        } catch (Exception e) {
            System.out.println("No parameterized tests.");
        }
    }

    @Override
    protected List<Runner> getChildren() {
        return runners;
    }

    @SuppressWarnings("unchecked")
    private List<Object[]> getParametersList(TestClass klass)
            throws Throwable {
        return (List<Object[]>) getParametersMethod(klass).invokeExplosively(
                null);
    }

    private FrameworkMethod getParametersMethod(TestClass testClass)
            throws Exception {
        List<FrameworkMethod> methods = testClass
                .getAnnotatedMethods(Parameters.class);
        for (FrameworkMethod each : methods) {
            int modifiers = each.getMethod().getModifiers();
            if (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))
                return each;
        }

        throw new Exception("No public static parameters method on class "
                + testClass.getName());
    }

}

Update: Ich versuche, diese Art der Sache Hinzugefügt junit.

InformationsquelleAutor der Antwort AmanicA

0

Vorausgesetzt, Sie verwenden Parametrized.class führen Sie Ihre test-Klasse - markieren Sie alle nicht-parametrisierten tests wie @Ignoriert. Ansonsten können Sie eine statische innere Klasse, um alle Ihre parametrisierten tests und anderen - für nicht-eingestellt.

InformationsquelleAutor der Antwort Artem Oboturov
0

Habe ich etwas ähnliches wie das Matthäus-Lösung. Allerdings, ich habe zwei neue java-Dateien, erweitert die aktuelle Datei, so dass die ComponentSingleTests nicht zweimal ausgeführt. Auf diese Weise können Sie gemeinsame member-Variablen und Hilfsmethoden aus der übergeordneten Klasse. Das problem hatte ich mit Matthew, der die Lösung war, dass mein single-test wurde ausgeführt, zweimal, statt einmal, wie die Enclosed.class (der erweitert die Suite.class) machen Ihren test zweimal ausgeführt wird, wie in diesem link
Verhindern, dass junit tests ausgeführt zweimal

ComponentTest.java
```
public class ComponentTest {
    public int sharedMemberVariables; 
    ... 
}
```
ComponentParamTests.java
```
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

@RunWith(Parameterized.class)
public class ComponentParamTests extends ComponentTest {

    @Parameters
    ...

    @Test
    public void testCaseUsingParams() throws Exception {
    }
}
```
ComponentSingleTests.java
```
import org.junit.Test;

public class ComponentSingleTests {

    @Test
    public void testCaseWithoutParams() throws Exception {
        ...
    }
}
```
InformationsquelleAutor der Antwort Chee Loong Soon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.