import cucumber.runtime.model.CucumberTagStatement; //导入依赖的package包/类
private static void filterOnTags(CucumberFeature feature) throws TagFilterException {
    final List<CucumberTagStatement> featureElements = feature.getFeatureElements();
    ServiceLoader<TagFilter> loader = ServiceLoader.load(TagFilter.class);
    for (Iterator<CucumberTagStatement> iterator = featureElements.iterator(); iterator.hasNext();) {
        CucumberTagStatement cucumberTagStatement = iterator.next();
        for (TagFilter implClass : loader) {
            logger.info("Tag filter found: {}", implClass.getClass().getSimpleName());
            final boolean isFiltered = implClass.filter(feature, cucumberTagStatement);
            if (isFiltered) {
                logger.info("skipping feature element {} of feature {} due to feature-tag-filter {} ",
                        cucumberTagStatement.getVisualName(),
                        feature.getPath(), implClass.getClass().getSimpleName());
                iterator.remove();
                break;
            }
        }
    }
}
 

import cucumber.runtime.model.CucumberTagStatement; //导入依赖的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.CucumberTagStatement; //导入依赖的package包/类
@Override
public boolean filter(CucumberFeature feature, CucumberTagStatement cucumberTagStatement) throws TagFilterException {
    String path = feature.getPath();
    if(path.endsWith(TAG_FILTER_FEATURE)) {
        throw new TagFilterException("Feature: "+TAG_FILTER_FEATURE+" failed due to tag filtering");
    }
    return false;
}
 

import cucumber.runtime.model.CucumberTagStatement; //导入依赖的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.CucumberTagStatement; //导入依赖的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.CucumberTagStatement; //导入依赖的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.CucumberTagStatement; //导入依赖的package包/类
/**
 * Method to be over-ridden to evaluate if a feature/scenario
 * should be skipped for execution
 *
 * @param feature
 * @param cucumberTagStatement
 * @return true - indicates feature should be skipped from
 *         execution, otherwise false
 * @throws TagFilterException - when thrown, stops
 *         execution of all features
 */
boolean filter(CucumberFeature feature, CucumberTagStatement cucumberTagStatement) throws TagFilterException;