Namen von parametrisierten Tests ändern

Diese Funktion hat es in JUnit 4.11.

Verwenden, ändern Sie den Namen des parametrisierten tests, sagen Sie:

@Parameters(name="namestring")

namestring ist eine Zeichenfolge, die die folgenden Platzhalter:

• {index} - index-dieser Satz von Argumenten. Die Standard - namestring ist {index}.
• {0} - der erste parameter mit dem Wert aus dieser Aufruf der test.
• {1} - der zweite parameter Wert
• und so weiter

Der endgültige name der Prüfung der name der Prüfung Methode, gefolgt von der namestring in Klammern, wie unten gezeigt.

Beispiel (adaptiert von den unit-test für die Parameterized Anmerkung):

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

    @Parameters( name = "{index}: fib({0})={1}" )
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
                { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
    }

    private final int fInput;
    private final int fExpected;

    public FibonacciTest(int input, int expected) {
        fInput= input;
        fExpected= expected;
    }

    @Test
    public void testFib() {
        assertEquals(fExpected, fib(fInput));
    }

    private int fib(int x) {
        //TODO: actually calculate Fibonacci numbers
        return 0;
    }
}

geben Namen wie testFib[1: fib(1)=1] und testFib[4: fib(4)=3]. (Die testFib Teil des namens ist der name der Methode der @Test).

InformationsquelleAutor der Antwort rescdsk

Kurzem stieß ich auf das gleiche problem bei der Verwendung von JUnit 4.3.1. Ich habe implementiert eine neue Klasse, die sich Parametrisiert aufgerufen LabelledParameterized. Es wurde getestet mit JUnit 4.3.1, 4.4 und 4.5. Es rekonstruiert die Beschreibung Instanz, die mit der Zeichenkette des ersten Arguments, jedes Parameters array aus den @ - Parameter-Methode. Sehen Sie den code für diese:

http://code.google.com/p/migen/source/browse/trunk/java/src/.../LabelledParameterized.java?r=3789

und ein Beispiel für seine Verwendung bei:

http://code.google.com/p/migen/source/browse/trunk/java/src/.../ServerBuilderTest.java?r=3789

Den test Beschreibung-Formate gut in Eclipse, die ist, was ich wollte, da macht das fehlgeschlagene tests viel einfacher zu finden! Ich werde wohl weiter zu verfeinern und dokumentieren die Klassen in den nächsten Tagen/Wochen. Tropfen der '? ' - Teil des URLs, wenn Sie wollen, dass die bleeding edge. 🙂

Um es zu verwenden, alles, was Sie tun müssen ist, kopieren Sie die Klasse (GPL v3), und ändern Sie @RunWith(Parameterized.class) @RunWith(LabelledParameterized.class) vorausgesetzt, das erste element der parameter-Liste ist eine sinnvolle Bezeichnung.

Ich weiß nicht, ob spätere Versionen von JUnit-Adresse dieses Problem, aber selbst wenn Sie es Taten, ich kann nicht aktualisieren, JUnit da alle meine co-Entwickler müssten update auch, und wir haben höhere Prioritäten als re-tooling. Damit die Arbeit in der Klasse zu kompilierbar sein, die von mehreren Versionen von JUnit.

Hinweis: es gibt einige Reflexion jiggery-pokery, so dass es läuft über die verschiedenen JUnit-Versionen, wie oben aufgeführt. Die version speziell für JUnit 4.3.1 gefunden werden kann hier und für JUnit 4.4 und 4.5, hier.

InformationsquelleAutor der Antwort darrenp

von junit4.8.2 erstellen Sie Ihre eigenen MyParameterized Klasse, indem Sie einfach kopieren Parametrisierten Klasse. ändern Sie die getName () - und testName () - Methoden in TestClassRunnerForParameters.

InformationsquelleAutor der Antwort yliang

Können Sie eine Methode erstellen, wie

@Test
public void name() {
    Assert.assertEquals("", inboundFileName);
}

Während ich würde nicht verwenden es die ganze Zeit, es wäre nützlich, um genau herauszufinden, welche Nummer 143 ist.

InformationsquelleAutor der Antwort

Keiner es war, für mich zu arbeiten, daher hab ich die Quelle für Parametriert und modifiziert es schaffen eine neue test-runner. Ich habe nicht zu viel ändern, aber ES FUNKTIONIERT!!!

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.junit.Assert;
import org.junit.internal.runners.ClassRoadie;
import org.junit.internal.runners.CompositeRunner;
import org.junit.internal.runners.InitializationError;
import org.junit.internal.runners.JUnit4ClassRunner;
import org.junit.internal.runners.MethodValidator;
import org.junit.internal.runners.TestClass;
import org.junit.runner.notification.RunNotifier;

public class LabelledParameterized extends CompositeRunner {
static class TestClassRunnerForParameters extends JUnit4ClassRunner {
    private final Object[] fParameters;

    private final String fParameterFirstValue;

    private final Constructor<?> fConstructor;

    TestClassRunnerForParameters(TestClass testClass, Object[] parameters, int i) throws InitializationError {
        super(testClass.getJavaClass()); //todo
        fParameters = parameters;
        if (parameters != null) {
            fParameterFirstValue = Arrays.asList(parameters).toString();
        } else {
            fParameterFirstValue = String.valueOf(i);
        }
        fConstructor = getOnlyConstructor();
    }

    @Override
    protected Object createTest() throws Exception {
        return fConstructor.newInstance(fParameters);
    }

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

    @Override
    protected String testName(final Method method) {
        return String.format("%s%s", method.getName(), fParameterFirstValue);
    }

    private Constructor<?> getOnlyConstructor() {
        Constructor<?>[] constructors = getTestClass().getJavaClass().getConstructors();
        Assert.assertEquals(1, constructors.length);
        return constructors[0];
    }

    @Override
    protected void validate() throws InitializationError {
        //do nothing: validated before.
    }

    @Override
    public void run(RunNotifier notifier) {
        runMethods(notifier);
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public static @interface Parameters {
}

private final TestClass fTestClass;

public LabelledParameterized(Class<?> klass) throws Exception {
    super(klass.getName());
    fTestClass = new TestClass(klass);

    MethodValidator methodValidator = new MethodValidator(fTestClass);
    methodValidator.validateStaticMethods();
    methodValidator.validateInstanceMethods();
    methodValidator.assertValid();

    int i = 0;
    for (final Object each : getParametersList()) {
        if (each instanceof Object[])
            add(new TestClassRunnerForParameters(fTestClass, (Object[]) each, i++));
        else
            throw new Exception(String.format("%s.%s() must return a Collection of arrays.", fTestClass.getName(), getParametersMethod().getName()));
    }
}

@Override
public void run(final RunNotifier notifier) {
    new ClassRoadie(notifier, fTestClass, getDescription(), new Runnable() {
        public void run() {
            runChildren(notifier);
        }
    }).runProtected();
}

private Collection<?> getParametersList() throws IllegalAccessException, InvocationTargetException, Exception {
    return (Collection<?>) getParametersMethod().invoke(null);
}

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

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

public static Collection<Object[]> eachOne(Object... params) {
    List<Object[]> results = new ArrayList<Object[]>();
    for (Object param : params)
        results.add(new Object[] { param });
    return results;
}
}

InformationsquelleAutor der Antwort Christian

Check-out JUnitParams als dsaff erwähnt, funktioniert mit ant zu bauen parametrisierte Testmethode Beschreibungen in der html-Bericht.

Dieser war nach dem Versuch LabelledParameterized und finden, dass es, obwohl es funktioniert mit eclipse funktioniert es nicht mit der Ameise so weit wie der html-Bericht ist besorgt.

Cheers,

InformationsquelleAutor der Antwort quarkonium