Java MultiLoader类代码示例

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
private void testContextConfiguration(String profile, String springProfile) {
    GenericXmlApplicationContext context = createContext(profile, springProfile);
    AutowireCapableBeanFactory factory = context.getAutowireCapableBeanFactory();

    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    ResourceLoader resourceLoader = new MultiLoader(classLoader);
    ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
    Collection<Class<?>> descendants = classFinder.getDescendants(Object.class, "com.hotwire.test.steps");

    List<Throwable> throwables = new ArrayList<>();
    for (Class<?> clazz : descendants) {
        if (Utils.isInstantiable(clazz) & !clazz.isEnum()) {
            context.registerBeanDefinition(clazz.getName(),
                    BeanDefinitionBuilder.genericBeanDefinition(clazz).getBeanDefinition());
            try {
                factory.getBean(clazz.getName());
            }
            catch (Throwable t) {
                while (t.getCause() != null) {
                    t = t.getCause();
                }
                System.err.println(t.getMessage());
                throwables.add(t);
            }
        }
    }
    assertThat(throwables)
            .as("List of throwables should be empty!")
            .isEmpty();
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
/**
 * Constructor called by JUnit.
 *
 * @param clazz the class with the @RunWith annotation.
 * @throws java.io.IOException                         if there is a problem
 * @throws org.junit.runners.model.InitializationError if there is another problem
 */
public CucumberLoadRunner(Class clazz) throws InitializationError, IOException {
    super(clazz);

    System.setProperty(cukesProperty(CONTEXT_INFLATING_ENABLED), "false");
    System.setProperty(cukesProperty(ASSERTIONS_DISABLED), "true");
    System.setProperty(cukesProperty(LOADRUNNER_FILTER_BLOCKS_REQUESTS), "true");

    filter = SingletonObjectFactory.instance().getInstance(LoadRunnerFilter.class);

    ClassLoader classLoader = clazz.getClassLoader();
    Assertions.assertNoCucumberAnnotatedMethods(clazz);

    RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(clazz);
    RuntimeOptions runtimeOptions = runtimeOptionsFactory.create();

    ResourceLoader resourceLoader = new MultiLoader(classLoader);
    runtime = createRuntime(resourceLoader, classLoader, runtimeOptions);

    final List<CucumberFeature> cucumberFeatures = runtimeOptions.cucumberFeatures(resourceLoader);
    jUnitReporter = new JUnitReporter(runtimeOptions.reporter(classLoader),
        runtimeOptions.formatter(classLoader), runtimeOptions.isStrict(), new JUnitOptions(runtimeOptions.getJunitOptions()));
    addChildren(cucumberFeatures);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
private ResourceLoader getResourceLoader() {
	List<Path> fileSystemFeaturePaths = getFileSystemFeaturePaths();
	if (fileSystemFeaturePaths.size() == 0)
		return new MultiLoader(cucumberClassLoader);
	URL[] urls = new URL[fileSystemFeaturePaths.size()];
	int index = 0;
	for (Path featurePath : fileSystemFeaturePaths) {
		try {
			urls[index] = featurePath.toUri().toURL();
		} catch (MalformedURLException e) {
			throw new CucumberException(e);
		}
		index++;
	}
	URLClassLoader featuresLoader = new URLClassLoader(urls, cucumberClassLoader);
	return new MultiLoader(featuresLoader);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
@Override
public final void execute() throws MojoExecutionException, MojoFailureException {
    before();
    try {
        final RuntimeOptions runtimeOptions = new RuntimeOptions(new Env("cucumber-jvm", System.getProperties()), args());
        final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        final ResourceLoader resourceLoader = new MultiLoader(classLoader);
        final ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
        final Runtime runtime = new Runtime(resourceLoader, classFinder, classLoader, runtimeOptions);
        runtime.writeStepdefsJson();
        runtime.run();
        runtime.getErrors();
        if (runtime.exitStatus() != 0) {
            throw new MojoExecutionException("Got non-zero exit status " + runtime.exitStatus());
        }
    } catch (final IOException e) {
        throw new MojoExecutionException("Failure to write Json Stepdefs during Cucumber-JVM run", e);
    } finally {
        after();
    }
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
/**
 * Constructor called by JUnit.
 *
 * @param clazz
 *            the class with the @RunWith annotation.
 * @throws java.io.IOException
 *             if there is a problem
 * @throws org.junit.runners.model.InitializationError
 *             if there is another problem
 */
public EscCucumber(Class<?> clazz) throws InitializationError, IOException {
    super(clazz);
    ClassLoader classLoader = clazz.getClassLoader();
    Assertions.assertNoCucumberAnnotatedMethods(clazz);

    final List<String> argList = new ArrayList<String>();
    final EscCucumberArgs args = clazz.getAnnotation(EscCucumberArgs.class);
    if (args == null) {
        argList.add("NONE");
    } else {
        argList.addAll(EscSpiUtils.asList(args.value()));
    }

    RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(
            clazz);
    RuntimeOptions runtimeOptions = runtimeOptionsFactory.create();
    ResourceLoader resourceLoader = new MultiLoader(classLoader);
    ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader,
            classLoader);
    runtime = new Runtime(resourceLoader, classFinder, classLoader,
            runtimeOptions);
    jUnitReporter = new JUnitReporter(runtimeOptions.reporter(classLoader),
            runtimeOptions.formatter(classLoader),
            runtimeOptions.isStrict());

    for (final String arg : argList) {
        addChildren(runtimeOptions.cucumberFeatures(resourceLoader), arg);

    }

}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
private List<Path> getFileSystemFeaturePaths() {
	List<Path> fileSystemFeaturePaths = new ArrayList<Path>();
	for (String featurePath : runtimeConfiguration.featurePaths) {
		if (!featurePath.startsWith(MultiLoader.CLASSPATH_SCHEME))
			fileSystemFeaturePaths.add(Paths.get(featurePath));
	}
	return fileSystemFeaturePaths;
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
@Override
public List<Backend> getBackends() {
	wasInvoked = true;
	ResourceLoader resourceLoader = new MultiLoader(Thread.currentThread().getContextClassLoader());
	Backend backend = new JavaBackend(resourceLoader);
	return Arrays.asList(backend);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
@Override
public synchronized Runtime getRuntime(List<String> additionalCucumberArgs) {
	RuntimeOptions runtimeOptions = new RuntimeOptions(additionalCucumberArgs);
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	ResourceLoader resourceLoader = new MultiLoader(classLoader);
	ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
	byte exitCode = perInvocationExitCodes[invocationCount % perInvocationExitCodes.length];
	boolean shouldThrowException = perInvocationShouldThrowException[invocationCount % perInvocationExitCodes.length];
	invocationCount++;
	ThreadExecutionRecorder threadExecutionRecorder = new ThreadExecutionRecorder();
	return new FakeCucumberRuntime(exitCode, shouldThrowException, resourceLoader, classFinder, classLoader, runtimeOptions, threadExecutionRecorder);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
public void execute(ClassLoader classLoader, ResultCollector rc) {
    ResourceLoader resourceLoader = new MultiLoader(classLoader);

    // TODO threadlocal runtime cache using junitTestClass as a key
    ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
    RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(junitTestClass);
    RuntimeOptions runtimeOptions = runtimeOptionsFactory.create();
    Runtime runtime = new Runtime(resourceLoader, classFinder, classLoader, runtimeOptions);
    Reporter reporter = new ReporterAdapter(rc, getDescription());
    LOGGER.fine("Executing cucumber \"" + scenario.getVisualName() + "\"");
    scenario.run(nullFormatter(), reporter, runtime);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
@Test(groups = "cucumber", description = "Runs Cucumber Features")
public void CucumberRunner() throws Throwable {

    ClassLoader classLoader = getClass().getClassLoader();
    ResourceLoader resourceLoader = new MultiLoader(classLoader);

    RuntimeOptionsFactory roFactory = new RuntimeOptionsFactory(getClass());

    RuntimeOptions ro = roFactory.create();

    ro.getGlue().clear();
    ro.getGlue().add("classpath:");

    ro.getFeaturePaths().clear();
    ro.getFeaturePaths().add(feature);

    if (!tags.isEmpty()) {
        for (String s : tags.split("--tags")) {
            if (!s.trim().isEmpty()) {
                ro.getFilters().add(s.trim());
            }
        }
    }

    ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
    runtime = new cucumber.runtime.Runtime(resourceLoader, classFinder, classLoader, ro);
    try {
        ReporterNGExt.logBusiness(String.format("Run Feature - %s", feature));
        runtime.run();
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    if (!runtime.getErrors().isEmpty()) {
        ReporterNGExt.logBusiness(runtime.getErrors().toString());
        throw new CucumberException(runtime.getErrors().get(0));
    }

}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
protected ResourceLoader createResourceLoader(Class<?> clazz) {
    ClassLoader classLoader = clazz.getClassLoader();
    MultiLoader loader = new MultiLoader(classLoader);

    List<Filter<InputStream>> filters = instanciateFilters(clazz);
    if (filters.isEmpty())
        return loader;
    else
        return new ResourceLoaderWrapper(loader, Filters.chain(filters));
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
protected ResourceLoader createResourceLoader(Class<?> clazz) {
    ClassLoader classLoader = clazz.getClassLoader();
    MultiLoader loader = new MultiLoader(classLoader);

    List<Filter<InputStream>> filters = instanciateFilters(clazz);
    if(filters.isEmpty())
        return loader;
    else
        return new ResourceLoaderWrapper(loader, Filters.chain(filters));
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
public KarateRuntimeOptions(Class clazz) {
    classLoader = clazz.getClassLoader();
    RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(clazz);
    runtimeOptions = runtimeOptionsFactory.create();
    resourceLoader = new MultiLoader(classLoader);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
private Runtime createRuntime(RuntimeOptions runtimeOptions) {
    final ResourceLoader resourceLoader = new MultiLoader(classLoader);
    final ClassFinder classFinder = new ResourceLoaderClassFinder(resourceLoader, classLoader);
    return new Runtime(resourceLoader, classFinder, classLoader, runtimeOptions);
}
 

import cucumber.runtime.io.MultiLoader; //导入依赖的package包/类
public CourgetteFeatureLoader(CourgetteProperties courgetteProperties) {
    this.courgetteProperties = courgetteProperties;
    this.classLoader = Thread.currentThread().getContextClassLoader();
    this.resourceLoader = new MultiLoader(classLoader);
}