import cucumber.runtime.RuntimeOptionsFactory; //导入依赖的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.RuntimeOptionsFactory; //导入依赖的package包/类
private RuntimeOptions getCucumberOptions(ITestResult testResult) {
    try {
        return new RuntimeOptionsFactory(Class.forName(testResult.getTestClass().getName())).create();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}
 

import cucumber.runtime.RuntimeOptionsFactory; //导入依赖的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.RuntimeOptionsFactory; //导入依赖的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.RuntimeOptionsFactory; //导入依赖的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.RuntimeOptionsFactory; //导入依赖的package包/类
public KarateRuntimeOptions(Class clazz) {
    classLoader = clazz.getClassLoader();
    RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(clazz);
    runtimeOptions = runtimeOptionsFactory.create();
    resourceLoader = new MultiLoader(classLoader);
}
 

import cucumber.runtime.RuntimeOptionsFactory; //导入依赖的package包/类
public RestRuntimeOptionsFactory(Class<?> clazz) {
   runtimeOptionsFactory = new RuntimeOptionsFactory(clazz);
}