org.junit.runners.parameterized.TestWithParameters Java Examples

ParameterizedBehaviorTestRunner(TestWithParameters test) throws InitializationError {
  super(test);

  FeatureSet features = FluentIterable
      .from(test.getParameters())
      .filter(FeatureSet.class)
      .first()
      .orNull();
  checkState(features != null, "No FeatureSet parameter found");

  // JDK-8 bug: Cannot use `super::` if the superclass method is protected; see
  //     https://bugs.openjdk.java.net/browse/JDK-8139836
  testing = new SharedBehaviorTesting(
      notifier -> super.childrenInvoker(notifier),
      (method, notifier) -> super.runChild(method, notifier),
      super::createTest,
      super::getDescription,
      super::getTestClass,
      (cls, name) -> Description.createTestDescription(cls, name + test.getParameters()),
      features);
}
 

private List<Runner> createRunnersForParameters(
        Iterable<Object> allParameters, String namePattern,
        ParametersRunnerFactory runnerFactory) throws Exception {
    try {
        List<TestWithParameters> tests = createTestsForParameters(
                allParameters, namePattern);
        List<Runner> runners = new ArrayList<Runner>();
        for (TestWithParameters test : tests) {
            runners.add(runnerFactory
                    .createRunnerForTestWithParameters(test));
        }
        return runners;
    } catch (ClassCastException e) {
        throw parametersMethodReturnedWrongType();
    }
}
 

private List<Runner> createRunnersForParameters(
        Iterable<Object> allParameters, String namePattern,
        ParametersRunnerFactory runnerFactory) throws Exception {
    try {
        List<TestWithParameters> tests = createTestsForParameters(
                allParameters, namePattern);
        List<Runner> runners = new ArrayList<Runner>();
        for (TestWithParameters test : tests) {
            runners.add(runnerFactory
                    .createRunnerForTestWithParameters(test));
        }
        return runners;
    } catch (ClassCastException e) {
        throw parametersMethodReturnedWrongType();
    }
}
 

protected List<Runner> createRunners(Class<?> klass) throws InitializationError {
  List<Runner> result = new ArrayList<Runner>();
  TestWithParameters test = new TestWithParameters(graph.manager().toString(), getTestClass(),
                                                   Arrays.<Object>asList(graph.manager()));
  result.add(new BlockJUnit4ClassRunnerWithParameters(test));
  return Collections.unmodifiableList(result);
}
 

public CustomParameterizedBlockJUnit4Runner(TestWithParameters test)
        throws InitializationError {
    super(test.getTestClass().getJavaClass());
    parameters = test.getParameters().toArray(
            new Object[test.getParameters().size()]);
    name = test.getName();
}
 

private TestWithParameters createTestWithParameters(
        TestClass testClass, String pattern, int index,
        Object[] parameters) {
    String finalPattern = pattern.replaceAll("\\{index\\}",
            Integer.toString(index));
    String name = MessageFormat.format(finalPattern, parameters);
    return new TestWithParameters("[" + name + "]", testClass,
            Arrays.asList(parameters));
}
 

private List<TestWithParameters> createTestsForParameters(
        Iterable<Object> allParameters, String namePattern)
        throws Exception {
    int i = 0;
    List<TestWithParameters> children = new ArrayList<TestWithParameters>();
    for (Object parametersOfSingleTest : allParameters) {
        children.add(createTestWithNotNormalizedParameters(namePattern,
                i++, parametersOfSingleTest));
    }
    return children;
}
 

private TestWithParameters createTestWithNotNormalizedParameters(
        String pattern, int index, Object parametersOrSingleParameter) {
    Object[] parameters = (parametersOrSingleParameter instanceof Object[]) ? (Object[]) parametersOrSingleParameter
            : new Object[] { parametersOrSingleParameter };
    return createTestWithParameters(testClass, pattern, index,
            parameters);
}
 

public CustomParameterizedBlockJUnit4Runner(TestWithParameters test)
        throws InitializationError {
    super(test.getTestClass().getJavaClass());
    parameters = test.getParameters().toArray(
            new Object[test.getParameters().size()]);
    name = test.getName();
}
 

private TestWithParameters createTestWithParameters(
        TestClass testClass, String pattern, int index,
        Object[] parameters) {
    String finalPattern = pattern.replaceAll("\\{index\\}",
            Integer.toString(index));
    String name = MessageFormat.format(finalPattern, parameters);
    return new TestWithParameters("[" + name + "]", testClass,
            Arrays.asList(parameters));
}
 

private List<TestWithParameters> createTestsForParameters(
        Iterable<Object> allParameters, String namePattern)
        throws Exception {
    int i = 0;
    List<TestWithParameters> children = new ArrayList<TestWithParameters>();
    for (Object parametersOfSingleTest : allParameters) {
        children.add(createTestWithNotNormalizedParameters(namePattern,
                i++, parametersOfSingleTest));
    }
    return children;
}
 

private static TestWithParameters createTestWithParameters(
        final TestClass testClass, final String pattern, final int index, final Object[] parameters) {
    final String finalPattern = pattern.replaceAll("\\{index\\}",
            Integer.toString(index));
    final String name = MessageFormat.format(finalPattern, parameters);
    return new TestWithParameters("[" + name + "]", testClass,
            Arrays.asList(parameters));
}
 

private List<TestWithParameters> createTestsForParameters(
        final Iterable<Object> allParameters, final String namePattern) {
    int i = 0;
    final List<TestWithParameters> children = new ArrayList<>();
    for (final Object parametersOfSingleTest : allParameters) {
        children.add(createTestWithNotNormalizedParameters(namePattern,
                i++, parametersOfSingleTest));
    }
    return children;
}
 

private TestWithParameters createTestWithNotNormalizedParameters(
        final String pattern, final int index, final Object parametersOrSingleParameter) {
    final Object[] parameters = (parametersOrSingleParameter instanceof Object[])
            ? (Object[]) parametersOrSingleParameter
            : new Object[] {parametersOrSingleParameter};
    return createTestWithParameters(getTestClass(), pattern, index,
            parameters);
}
 

private TestWithParameters createTestWithNotNormalizedParameters(
        String pattern, int index, Object parametersOrSingleParameter) {
    Object[] parameters = (parametersOrSingleParameter instanceof Object[]) ? (Object[]) parametersOrSingleParameter
            : new Object[] { parametersOrSingleParameter };
    return createTestWithParameters(testClass, pattern, index,
            parameters);
}
 

private MixinAwareRunnerWithParameters(final TestWithParameters test) throws InitializationError {
    super(test);
}
 

@Override
public Runner createRunnerForTestWithParameters(final TestWithParameters testWithParameters)
        throws InitializationError {
    return new MixinAwareRunnerWithParameters(testWithParameters);
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
    return new ParameterizedRunner(test);
}
 

public ParameterizedRunner(TestWithParameters test) throws InitializationError {
    super(test);
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test)
    throws InitializationError {
  return new KurentoBlockJUnit4ClassRunnerWithParameters(test);
}
 

public KurentoBlockJUnit4ClassRunnerWithParameters(TestWithParameters test)
    throws InitializationError {
  super(test);
}
 

public OrcasBlockJUnit4ClassRunnerWithParameters( TestWithParameters pTest ) throws InitializationError
{
  super( pTest );

  testName = (String)pTest.getParameters().get( 0 );
}
 

public Runner createRunnerForTestWithParameters( TestWithParameters pTest ) throws InitializationError
{
  return new OrcasBlockJUnit4ClassRunnerWithParameters( pTest );
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
	return new PtlBlockJUnit4ClassRunnerWithParameters(test);
}
 

protected VertxUnitRunnerWithParameters(TestWithParameters test) throws InitializationError {
  super(test.getTestClass().getJavaClass());
  parameters = test.getParameters().toArray(
      new Object[test.getParameters().size()]);
  name = test.getName();
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
  return new VertxUnitRunnerWithParameters(test);
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test)
    throws InitializationError {
  return new ParameterizedBehaviorTestRunner(test);
}
 

/**
 * Only called reflectively. Do not use programmatically.
 * @param klass the class
 * @throws Throwable if an error occurs
 */
public BrowserParameterizedRunner(final Class<WebTestCase> klass) throws Throwable {
    super(klass, Collections.<Runner>emptyList());

    verifyDefaultMEthod();

    final Parameters parameters = getParametersMethod().getAnnotation(Parameters.class);

    final List<TestWithParameters> tests = createTestsForParameters(
            allParameters(), parameters.name());

    if (BrowserVersionClassRunner.containsTestMethods(klass)) {
        final Set<String> browsers = WebDriverTestCase.getBrowsersProperties();
        if (WebDriverTestCase.class.isAssignableFrom(klass)) {
            if (browsers.contains("chrome")) {
                runners_.add(new BrowserVersionClassRunnerWithParameters(
                        klass, BrowserVersion.CHROME, true, tests));
            }
            if (browsers.contains("ff")) {
                runners_.add(new BrowserVersionClassRunnerWithParameters(
                        klass, BrowserVersion.FIREFOX, true, tests));
            }
            if (browsers.contains("ff68")) {
                runners_.add(new BrowserVersionClassRunnerWithParameters(
                        klass, BrowserVersion.FIREFOX_68, true, tests));
            }
            if (browsers.contains("ff60")) {
                runners_.add(new BrowserVersionClassRunnerWithParameters(
                        klass, BrowserVersion.FIREFOX_60, true, tests));
            }
            if (browsers.contains("ie")) {
                runners_.add(new BrowserVersionClassRunnerWithParameters(
                        klass, BrowserVersion.INTERNET_EXPLORER, true, tests));
            }
        }

        if (browsers.contains("hu-chrome")) {
            runners_.add(new BrowserVersionClassRunnerWithParameters(
                    klass, BrowserVersion.CHROME, false, tests));
        }
        if (browsers.contains("hu-ff")) {
            runners_.add(new BrowserVersionClassRunnerWithParameters(
                    klass, BrowserVersion.FIREFOX, false, tests));
        }
        if (browsers.contains("hu-ff68")) {
            runners_.add(new BrowserVersionClassRunnerWithParameters(
                    klass, BrowserVersion.FIREFOX_68, false, tests));
        }
        if (browsers.contains("hu-ff60")) {
            runners_.add(new BrowserVersionClassRunnerWithParameters(
                    klass, BrowserVersion.FIREFOX_60, false, tests));
        }
        if (browsers.contains("hu-ie")) {
            runners_.add(new BrowserVersionClassRunnerWithParameters(
                    klass, BrowserVersion.INTERNET_EXPLORER, false, tests));
        }
    }
    else {
        throw new IllegalStateException("No @Test method found");
    }
}
 

public Runner createRunnerForTestWithParameters(TestWithParameters test)
        throws InitializationError {
    return new CustomParameterizedBlockJUnit4Runner(test);
}
 

@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
	return new ParameterizedXtextRunner(test);
}