Java CucumberScenarioOutline类代码示例

import cucumber.runtime.model.CucumberScenarioOutline; //导入依赖的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.CucumberScenarioOutline; //导入依赖的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.CucumberScenarioOutline; //导入依赖的package包/类
private Map<CucumberFeature, Integer> cucumberScenarios(List<CucumberFeature> cucumberFeatures, RuntimeOptions runtimeOptions) {
    final Map<CucumberFeature, Integer> scenarios = new HashMap<>();

    if (cucumberFeatures != null) {
        cucumberFeatures.forEach(cucumberFeature -> cucumberFeature.getFeatureElements().forEach(featureElement -> {

            final List<Integer> lineIds = new ArrayList<>();

            if (featureElement instanceof CucumberScenarioOutline) {
                ((CucumberScenarioOutline) featureElement).getCucumberExamplesList()
                        .forEach(c -> c.getExamples().getRows().stream().skip(1).forEach(row -> {
                            lineIds.add(row.getLine());
                        }));
            } else {
                lineIds.add(featureElement.getGherkinModel().getLine());
            }

            lineIds.forEach(lineId -> {
                final AtomicBoolean alreadyAdded = new AtomicBoolean(Boolean.FALSE);

                runtimeOptions.getFeaturePaths().forEach(resourcePath -> {
                    if (!alreadyAdded.get()) {
                        final List<String> scenarioPath = new ArrayList<>();
                        addScenario(scenarioPath, cucumberFeature, resourcePath, lineId);

                        try {
                            scenarios.put(
                                    CucumberFeature.load(resourceLoader, scenarioPath, new ArrayList<>()).stream().findFirst().orElse(null),
                                    lineId);
                            alreadyAdded.set(Boolean.TRUE);
                        } catch (IllegalArgumentException e) {
                            alreadyAdded.set(Boolean.FALSE);
                        }
                    }
                });
            });
        }));
    }
    return scenarios;
}
 

import cucumber.runtime.model.CucumberScenarioOutline; //导入依赖的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.CucumberScenarioOutline; //导入依赖的package包/类
public RestScenarioOutlineRunner(RestRuntime runtime,
   CucumberScenarioOutline cucumberScenarioOutline, RestJUnitReporter jUnitReporter,
   CucumberFeature cucumberFeature) throws InitializationError {
   super(null, buildRunners(runtime, cucumberScenarioOutline, jUnitReporter,
      cucumberFeature));
   this.cucumberScenarioOutline = cucumberScenarioOutline;
   this.jUnitReporter = jUnitReporter;
   this.runtime = runtime;
   this.cucumberFeature = cucumberFeature;
}
 

import cucumber.runtime.model.CucumberScenarioOutline; //导入依赖的package包/类
private static List<Runner> buildRunners(RestRuntime runtime,
   CucumberScenarioOutline cucumberScenarioOutline, RestJUnitReporter jUnitReporter,
   CucumberFeature cucumberFeature) throws InitializationError {
   List<Runner> runners = new ArrayList<Runner>();
   for (CucumberExamples cucumberExamples : cucumberScenarioOutline
      .getCucumberExamplesList()) {
      runners.add(new RestExampleRunner(runtime, cucumberExamples, jUnitReporter,
         cucumberFeature));
   }
   return runners;
}
 

import cucumber.runtime.model.CucumberScenarioOutline; //导入依赖的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.CucumberScenarioOutline; //导入依赖的package包/类
@Test
public void testLoadExternalWithExamples() throws IOException {
    List<CucumberFeature> features = new ArrayList<CucumberFeature>();
    try (MiniumFeatureBuilder builder = new MiniumFeatureBuilder(features)) {
        Resource resource = createResourceMock("example-with-comments.feature");
        builder.parse(resource, NO_FILTERS);
    }

    CucumberScenarioOutline cucumberScenarioOutline = (CucumberScenarioOutline) features.get(0).getFeatureElements().get(0);
    assertEquals(8, cucumberScenarioOutline.getCucumberExamplesList().get(0).getExamples().getRows().size());
}
 

import cucumber.runtime.model.CucumberScenarioOutline; //导入依赖的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.CucumberScenarioOutline; //导入依赖的package包/类
public CucumberScenarioOutline getScenarioOutline() {
    return scenarioOutline;
}
 

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