import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public static void setFeatures(List<CucumberFeature> cucumberFeatures) {
    int numberOfScenarios = 0;
    for (CucumberFeature feature : cucumberFeatures) {
        for (CucumberTagStatement scenario : feature.getFeatureElements()) {
            if (scenario instanceof CucumberScenario) {
                numberOfScenarios++;
            } else if (scenario instanceof CucumberScenarioOutline) {
                for (CucumberExamples examples : ((CucumberScenarioOutline) scenario).getCucumberExamplesList()) {
                    numberOfScenarios += examples.getExamples().getRows().size() - 1;
                }
            }
        }
    }
    ExecutionProgress currentContextProgress = getCurrent().getProgress();
    currentContextProgress.setNumberOfFeatures(cucumberFeatures.size());
    currentContextProgress.setNumberOfScenarios(numberOfScenarios);
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public ScenarioOutlineWrapper(FeatureWrapper feature, CucumberScenarioOutline scenarioOutline) {
    this.feature = feature;
    this.scenarioOutline = scenarioOutline;
    this.scenarios = new ArrayList<>();
    for (CucumberExamples examples : scenarioOutline.getCucumberExamplesList()) { // TODO can this be more than 1
        List<CucumberScenario> exampleScenarios = examples.createExampleScenarios();
        int count = exampleScenarios.size();
        for (int i = 0; i < count; i++) {
            CucumberScenario scenario = exampleScenarios.get(i);
            ScenarioWrapper sw = new ScenarioWrapper(feature, i, scenario, this);
            scenarios.add(sw);
        }
    }         
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
private void addFeatureElements(CucumberFeature feature) {
	for (CucumberTagStatement tagStatement : feature.getFeatureElements()) {
		if (tagStatement instanceof CucumberScenarioOutline)
			addScenarioOutline((CucumberScenarioOutline) tagStatement);
		else if (tagStatement instanceof CucumberScenario)
			addScenario((CucumberScenario) tagStatement);
	}
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
private void addScenario(CucumberScenario cucumberScenario) {
	Scenario scenario = (Scenario) cucumberScenario.getGherkinModel();
	formatter.startOfScenarioLifeCycle(scenario);
	formatter.scenario(scenario);
	reporter.result(new Result(Result.FAILED, 0L, ""));
	formatter.endOfScenarioLifeCycle(scenario);
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
private static List<Runner> buildRunners(RestRuntime runtime,
   CucumberExamples cucumberExamples, RestJUnitReporter jUnitReporter,
   CucumberFeature cucumberFeature) {
   List<Runner> runners = new ArrayList<Runner>();
   List<CucumberScenario> exampleScenarios = cucumberExamples.createExampleScenarios();
   for (CucumberScenario scenario : exampleScenarios) {
      try {
         ExecutionUnitRunner exampleScenarioRunner =
            new RestExecutionUnitRunner(runtime, scenario, jUnitReporter,
               cucumberFeature);
         runners.add(exampleScenarioRunner);
      } catch (InitializationError e) {
         throw new CucumberInitException(e);
      }
   }
   return runners;
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public RestExecutionUnitRunner(RestRuntime runtime,
   CucumberTagStatement cucumberScenario, RestJUnitReporter jUnitReporter,
   CucumberFeature cucumberFeature) throws InitializationError {
   super(runtime.getRuntime(), (CucumberScenario) cucumberScenario, jUnitReporter);
   this.runtime = Validate.notNull(runtime);
   this.cucumberFeature = Validate.notNull(cucumberFeature);
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
/**
 * @param pjp ProceedingJoinPoint
 * @param formatter formatter
 * @param reporter reporter
 * @param runtime runtime
 * @throws Throwable exception
 */
@Around(value = "addIgnoreTagPointcutScenario(formatter, reporter, runtime)")
public void aroundAddIgnoreTagPointcut(ProceedingJoinPoint pjp, Formatter formatter, Reporter reporter,
                                       Runtime runtime) throws Throwable {

    CucumberScenario scen = (CucumberScenario) pjp.getThis();
    Scenario scenario = (Scenario) scen.getGherkinModel();

    Class<?> sc = scen.getClass();
    Method tt = sc.getSuperclass().getDeclaredMethod("tagsAndInheritedTags");
    tt.setAccessible(true);
    Set<Tag> tags = (Set<Tag>) tt.invoke(scen);

    List<String> tagList = new ArrayList<>();
    String scenarioName = scenario.getName();
    tagList = tags.stream().map(Tag::getName).collect(Collectors.toList());

    ignoreReasons exitReason = manageTags(tagList, scenarioName);
    if (exitReason.equals(NOREASON)) {
        logger.error("Scenario '" + scenario.getName() + "' failed due to wrong use of the @ignore tag. ");
    }

    if ((!(exitReason.equals(NOTIGNORED))) && (!(exitReason.equals(NOREASON)))) {
        runtime.buildBackendWorlds(reporter, tags, scenario.getName());
        formatter.startOfScenarioLifeCycle(scenario);
        formatter.endOfScenarioLifeCycle(scenario);
        runtime.disposeBackendWorlds();
    } else {
        pjp.proceed();
    }
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public Feature convert(CucumberFeature cucumberFeature) {
    Feature feature = new Feature(cucumberFeature.getUri());
    for (CucumberTagStatement featureElement : cucumberFeature.getFeatureElements()) {
        if (featureElement instanceof CucumberScenario) {
            feature.add(convert((CucumberScenario) featureElement));
        } else if (featureElement instanceof CucumberScenarioOutline) {
            feature.add(convert((CucumberScenarioOutline) featureElement));
        }
    }
    return feature;
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
@Test
public void testLoadDataWithDataTable() throws IOException {
    List<CucumberFeature> features = new ArrayList<CucumberFeature>();
    try (MiniumFeatureBuilder builder = new MiniumFeatureBuilder(features)) {
        Resource resource = createResourceMock("example-with-data-table.feature");
        builder.parse(resource, NO_FILTERS);
    }

    CucumberScenario cucumberScenario = (CucumberScenario) features.get(0).getFeatureElements().get(0);
    assertEquals(4, cucumberScenario.getSteps().get(1).getRows().size());
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
@Test
public void testNormalFeatureWithoutLoadData() throws IOException {
    List<CucumberFeature> features = new ArrayList<CucumberFeature>();
    try (MiniumFeatureBuilder builder = new MiniumFeatureBuilder(features)) {
        Resource resource = createResourceMock("example-without-comments.feature");
        builder.parse(resource, NO_FILTERS);
    }
    CucumberScenarioOutline cucumberScenarioOutline = (CucumberScenarioOutline) features.get(0).getFeatureElements().get(0);
    assertEquals(4, cucumberScenarioOutline.getCucumberExamplesList().get(0).getExamples().getRows().size());

    CucumberScenario cucumberScenario = (CucumberScenario) features.get(0).getFeatureElements().get(1);
    assertEquals(3, cucumberScenario.getSteps().get(1).getRows().size());
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public CucumberScenario getScenario() {
    return scenario;
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
private void addScenarioOutline(CucumberScenarioOutline cucumberScenarioOutline) {
	for (CucumberExamples cucumberExamples : cucumberScenarioOutline.getCucumberExamplesList())
		for (CucumberScenario cucumberScenario : cucumberExamples.createExampleScenarios())
			addScenario(cucumberScenario);
}
 

import cucumber.runtime.model.CucumberScenario; //导入依赖的package包/类
public ScenarioTestUnit(Class<?> junitTestClass, CucumberScenario scenario) {
    this.junitTestClass = junitTestClass;
    this.scenario = scenario;
}