How to use filter method of net.serenitybdd.cucumber.suiteslicing.WeightedCucumberScenarios class

1package io.cucumber.junit;2import com.mengweijin.tester.serenity.SerenityCucumberMain;3import io.cucumber.core.eventbus.EventBus;4import io.cucumber.core.feature.FeatureParser;5import io.cucumber.core.filter.Filters;6import io.cucumber.core.gherkin.Feature;7import io.cucumber.core.gherkin.Pickle;8import io.cucumber.core.options.*;9import io.cucumber.core.plugin.PluginFactory;10import io.cucumber.core.plugin.Plugins;11import io.cucumber.core.plugin.SerenityReporter;12import io.cucumber.core.resource.ClassLoaders;13import io.cucumber.core.runtime.Runtime;14import io.cucumber.core.runtime.*;15import io.cucumber.plugin.Plugin;16import io.cucumber.tagexpressions.Expression;17import net.serenitybdd.cucumber.suiteslicing.CucumberSuiteSlicer;18import net.serenitybdd.cucumber.suiteslicing.ScenarioFilter;19import net.serenitybdd.cucumber.suiteslicing.TestStatistics;20import net.serenitybdd.cucumber.suiteslicing.WeightedCucumberScenarios;21import net.serenitybdd.cucumber.util.PathUtils;22import net.serenitybdd.cucumber.util.Splitter;23import net.thucydides.core.ThucydidesSystemProperty;24import net.thucydides.core.guice.Injectors;25import net.thucydides.core.util.EnvironmentVariables;26import net.thucydides.core.webdriver.Configuration;27import org.junit.runner.Description;28import org.junit.runner.manipulation.NoTestsRemainException;29import org.junit.runner.notification.RunNotifier;30import org.junit.runners.ParentRunner;31import org.junit.runners.model.InitializationError;32import org.junit.runners.model.RunnerScheduler;33import org.junit.runners.model.Statement;34import org.slf4j.Logger;35import org.slf4j.LoggerFactory;36import java.io.File;37import java.net.URI;38import java.time.Clock;39import java.util.*;40import java.util.concurrent.atomic.AtomicInteger;41import java.util.function.Function;42import java.util.function.Predicate;43import java.util.function.Supplier;44import static io.cucumber.junit.FileNameCompatibleNames.uniqueSuffix;45import static java.util.stream.Collectors.groupingBy;46import static java.util.stream.Collectors.toList;47import static net.thucydides.core.ThucydidesSystemProperty.*;48/**49 * Glue code for running Cucumber via Serenity.50 * Sets up Serenity reporting and instrumentation.51 */52public class CucumberSerenityRunner extends ParentRunner<ParentRunner<?>> {53    private static final Logger LOGGER = LoggerFactory.getLogger(CucumberSerenityRunner.class);54    private List<ParentRunner<?>> children = new ArrayList<ParentRunner<?>>();55    private final EventBus bus;56    private static ThreadLocal<RuntimeOptions> RUNTIME_OPTIONS = new ThreadLocal<>();57    private final List<Feature> features;58    private final Plugins plugins;59    private final CucumberExecutionContext context;60    private boolean multiThreadingAssumed = false;61    /**62     * Constructor called by JUnit.63     *64     * @param clazz the class with the @RunWith annotation.65     * @throws InitializationError if there is another problem66     */67    public CucumberSerenityRunner(Class clazz) throws InitializationError {68        super(clazz);69        Assertions.assertNoCucumberAnnotatedMethods(clazz);70        // Parse the options early to provide fast feedback about invalid options71        RuntimeOptions propertiesFileOptions = new CucumberPropertiesParser()72                .parse(CucumberProperties.fromPropertiesFile())73                .build();74        RuntimeOptions annotationOptions = new CucumberOptionsAnnotationParser()75                .withOptionsProvider(new JUnitCucumberOptionsProvider())76                .parse(clazz)77                .build(propertiesFileOptions);78        RuntimeOptions environmentOptions = new CucumberPropertiesParser()79                .parse(CucumberProperties.fromEnvironment())80                .build(annotationOptions);81        RuntimeOptions runtimeOptions = new CucumberPropertiesParser()82                .parse(CucumberProperties.fromSystemProperties())83                .addDefaultSummaryPrinterIfAbsent()84                .build(environmentOptions);85        RuntimeOptionsBuilder runtimeOptionsBuilder =  new RuntimeOptionsBuilder();86        Collection<String> tagFilters = environmentSpecifiedTags(runtimeOptions.getTagExpressions());87        for(String tagFilter : tagFilters ) {88            runtimeOptionsBuilder.addTagFilter(new LiteralExpression(tagFilter));89        }90        runtimeOptionsBuilder.build(runtimeOptions);91        // Next parse the junit options92        JUnitOptions junitPropertiesFileOptions = new JUnitOptionsParser()93                .parse(CucumberProperties.fromPropertiesFile())94                .build();95        JUnitOptions junitAnnotationOptions = new JUnitOptionsParser()96                .parse(clazz)97                .build(junitPropertiesFileOptions);98        JUnitOptions junitEnvironmentOptions = new JUnitOptionsParser()99                .parse(CucumberProperties.fromEnvironment())100                .build(junitAnnotationOptions);101        JUnitOptions junitOptions = new JUnitOptionsParser()102                .parse(CucumberProperties.fromSystemProperties())103                //.setStrict(runtimeOptions.isStrict())104                .build(junitEnvironmentOptions);105        this.bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);106        setRuntimeOptions(runtimeOptions);107        // Parse the features early. Don't proceed when there are lexer errors108        FeatureParser parser = new FeatureParser(bus::generateId);109        Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;110        FeaturePathFeatureSupplier featureSupplier = new FeaturePathFeatureSupplier(classLoader, runtimeOptions, parser);111        this.features = featureSupplier.get();112        // Create plugins after feature parsing to avoid the creation of empty files on lexer errors.113        this.plugins = new Plugins(new PluginFactory(), runtimeOptions);114        ExitStatus exitStatus = new ExitStatus(runtimeOptions);115        this.plugins.addPlugin(exitStatus);116        Configuration systemConfiguration = Injectors.getInjector().getInstance(Configuration.class);117        // customer change on 20201023118        systemConfiguration.setOutputDirectory(new File(System.getProperty(SerenityCucumberMain.REPORT_PROPERTY_NAME)));119        SerenityReporter reporter = new SerenityReporter(systemConfiguration);120        addSerenityReporterPlugin(plugins,reporter);121        ObjectFactoryServiceLoader objectFactoryServiceLoader = new ObjectFactoryServiceLoader(runtimeOptions);122        ObjectFactorySupplier objectFactorySupplier = new ThreadLocalObjectFactorySupplier(objectFactoryServiceLoader);123        BackendSupplier backendSupplier = new BackendServiceLoader(clazz::getClassLoader, objectFactorySupplier);124        TypeRegistryConfigurerSupplier typeRegistryConfigurerSupplier = new ScanningTypeRegistryConfigurerSupplier(classLoader, runtimeOptions);125        ThreadLocalRunnerSupplier runnerSupplier = new ThreadLocalRunnerSupplier(runtimeOptions, bus, backendSupplier, objectFactorySupplier, typeRegistryConfigurerSupplier);126        this.context = new CucumberExecutionContext(bus, exitStatus, runnerSupplier);127        Predicate<Pickle> filters = new Filters(runtimeOptions);128        Map<Optional<String>, List<Feature>> groupedByName = features.stream()129                .collect(groupingBy(Feature::getName));130        children = features.stream()131                .map(feature -> {132                    Integer uniqueSuffix = uniqueSuffix(groupedByName, feature, Feature::getName);133                    return FeatureRunner.create(feature, uniqueSuffix,filters, runnerSupplier, junitOptions);134                })135                .filter(runner -> !runner.isEmpty())136                .collect(toList());137    }138    private static RuntimeOptions DEFAULT_RUNTIME_OPTIONS;139    public static void setRuntimeOptions(RuntimeOptions runtimeOptions) {140        RUNTIME_OPTIONS.set(runtimeOptions);141        DEFAULT_RUNTIME_OPTIONS = runtimeOptions;142    }143    public static RuntimeOptions currentRuntimeOptions() {144        return (RUNTIME_OPTIONS.get() != null) ? RUNTIME_OPTIONS.get() : DEFAULT_RUNTIME_OPTIONS;145    }146    private static Collection<String> environmentSpecifiedTags(List<?> existingTags) {147        EnvironmentVariables environmentVariables = Injectors.getInjector().getInstance(EnvironmentVariables.class);148        String tagsExpression = ThucydidesSystemProperty.TAGS.from(environmentVariables,"");149        List<String> existingTagsValues = existingTags.stream().map(Object::toString).collect(toList());150        return Splitter.on(",").trimResults().omitEmptyStrings().splitToList(tagsExpression).stream()151                .map(CucumberSerenityRunner::toCucumberTag).filter(t -> !existingTagsValues.contains(t)).collect(toList());152    }153    private static String toCucumberTag(String from) {154        String tag = from.replaceAll(":","=");155        if (tag.startsWith("~@") || tag.startsWith("@")) { return tag; }156        if (tag.startsWith("~")) { return "~@" + tag.substring(1); }157        return "@" + tag;158    }159    public static Runtime createSerenityEnabledRuntime(/*ResourceLoader resourceLoader,*/160            Supplier<ClassLoader> classLoaderSupplier,161            RuntimeOptions runtimeOptions,162            Configuration systemConfiguration) {163        RuntimeOptionsBuilder runtimeOptionsBuilder = new RuntimeOptionsBuilder();164        Collection<String> allTagFilters = environmentSpecifiedTags(runtimeOptions.getTagExpressions());165        for(String tagFilter :  allTagFilters) {166            runtimeOptionsBuilder.addTagFilter(new LiteralExpression(tagFilter));167        }168        runtimeOptionsBuilder.build(runtimeOptions);169        setRuntimeOptions(runtimeOptions);170        EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);171        FeatureParser parser = new FeatureParser(bus::generateId);172        FeaturePathFeatureSupplier featureSupplier = new FeaturePathFeatureSupplier(classLoaderSupplier, runtimeOptions, parser);173        SerenityReporter serenityReporter = new SerenityReporter(systemConfiguration);174        Runtime runtime = Runtime.builder().withClassLoader(classLoaderSupplier).withRuntimeOptions(runtimeOptions).175                withAdditionalPlugins(serenityReporter).176                withEventBus(bus).withFeatureSupplier(featureSupplier).177                build();178        return runtime;179    }180    private static void addSerenityReporterPlugin(Plugins plugins, SerenityReporter plugin)181    {182        for(Plugin currentPlugin : plugins.getPlugins()){183            if (currentPlugin instanceof SerenityReporter) {184                return;185            }186        }187        plugins.addPlugin(plugin);188    }189    @Override190    protected Description describeChild(ParentRunner<?> child) {191        return child.getDescription();192    }193    @Override194    protected void runChild(ParentRunner<?> child, RunNotifier notifier) {195        child.run(notifier);196    }197    @Override198    protected Statement childrenInvoker(RunNotifier notifier) {199        Statement runFeatures = super.childrenInvoker(notifier);200        return new RunCucumber(runFeatures);201    }202    class RunCucumber extends Statement {203        private final Statement runFeatures;204        RunCucumber(Statement runFeatures) {205            this.runFeatures = runFeatures;206        }207        @Override208        public void evaluate() throws Throwable {209            if (multiThreadingAssumed) {210                plugins.setSerialEventBusOnEventListenerPlugins(bus);211            } else {212                plugins.setEventBusOnEventListenerPlugins(bus);213            }214            context.startTestRun();215            features.forEach(context::beforeFeature);216            try {217                runFeatures.evaluate();218            } finally {219                context.finishTestRun();220            }221        }222    }223    @Override224    public void setScheduler(RunnerScheduler scheduler) {225        super.setScheduler(scheduler);226        multiThreadingAssumed = true;227    }228    @Override229    public List<ParentRunner<?>> getChildren() {230        try {231            EnvironmentVariables environmentVariables = Injectors.getInjector().getInstance(EnvironmentVariables.class);232            RuntimeOptions runtimeOptions = currentRuntimeOptions();233            List<Expression> tagFilters = runtimeOptions.getTagExpressions();234            List<URI> featurePaths = runtimeOptions.getFeaturePaths();235            int batchNumber = environmentVariables.getPropertyAsInteger(SERENITY_BATCH_NUMBER, 1);236            int batchCount = environmentVariables.getPropertyAsInteger(SERENITY_BATCH_COUNT, 1);237            int forkNumber = environmentVariables.getPropertyAsInteger(SERENITY_FORK_NUMBER, 1);238            int forkCount = environmentVariables.getPropertyAsInteger(SERENITY_FORK_COUNT, 1);239            if ((batchCount == 1) && (forkCount == 1)) {240                return children;241            } else {242                LOGGER.info("Running slice {} of {} using fork {} of {} from feature paths {}", batchNumber, batchCount, forkNumber, forkCount, featurePaths);243                List<String> tagFiltersAsString =  tagFilters.stream().map(Expression::toString).collect(toList());244                WeightedCucumberScenarios weightedCucumberScenarios = new CucumberSuiteSlicer(featurePaths, TestStatistics.from(environmentVariables, featurePaths))245                        .scenarios(batchNumber, batchCount, forkNumber, forkCount, tagFiltersAsString);246                List<ParentRunner<?>> unfilteredChildren = children;247                AtomicInteger filteredInScenarioCount = new AtomicInteger();248                List<ParentRunner<?>> filteredChildren = unfilteredChildren.stream()249                        .filter(forIncludedFeatures(weightedCucumberScenarios))250                        .map(toPossibleFeatureRunner(weightedCucumberScenarios, filteredInScenarioCount))251                        .filter(Optional::isPresent)252                        .map(Optional::get)253                        .collect(toList());254                if (filteredInScenarioCount.get() != weightedCucumberScenarios.totalScenarioCount()) {255                    LOGGER.warn(256                            "There is a mismatch between the number of scenarios included in this test run ({}) and the expected number of scenarios loaded ({}). This suggests that the scenario filtering is not working correctly or feature file(s) of an unexpected structure are being run",257                            filteredInScenarioCount.get(),258                            weightedCucumberScenarios.scenarios.size());259                }260                LOGGER.info("Running {} of {} features", filteredChildren.size(), unfilteredChildren.size());261                return filteredChildren;262            }263        } catch (Exception e) {264            LOGGER.error("Test failed to start", e);265            throw e;266        }267    }268    private Function<ParentRunner<?>, Optional<ParentRunner<?>>> toPossibleFeatureRunner(WeightedCucumberScenarios weightedCucumberScenarios, AtomicInteger filteredInScenarioCount) {269        return featureRunner -> {270            int initialScenarioCount = featureRunner.getDescription().getChildren().size();271            String featureName = FeatureRunnerExtractors.extractFeatureName(featureRunner);272            try {273                ScenarioFilter filter = weightedCucumberScenarios.createFilterContainingScenariosIn(featureName);274                String featurePath = FeatureRunnerExtractors.featurePathFor(featureRunner);275                featureRunner.filter(filter);276                if (!filter.scenariosIncluded().isEmpty()) {277                    LOGGER.info("{} scenario(s) included for '{}' in {}", filter.scenariosIncluded().size(), featureName, featurePath);278                    filter.scenariosIncluded().forEach(scenario -> {279                        LOGGER.info("Included scenario '{}'", scenario);280                        filteredInScenarioCount.getAndIncrement();281                    });282                }283                if (!filter.scenariosExcluded().isEmpty()) {284                    LOGGER.debug("{} scenario(s) excluded for '{}' in {}", filter.scenariosExcluded().size(), featureName, featurePath);285                    filter.scenariosExcluded().forEach(scenario -> LOGGER.debug("Excluded scenario '{}'", scenario));286                }287                return Optional.of(featureRunner);288            } catch (NoTestsRemainException e) {289                LOGGER.info("Filtered out all {} scenarios for feature '{}'", initialScenarioCount, featureName);290                return Optional.empty();291            }292        };293    }294    private Predicate<ParentRunner<?>> forIncludedFeatures(WeightedCucumberScenarios weightedCucumberScenarios) {295        return featureRunner -> {296            String featureName = FeatureRunnerExtractors.extractFeatureName(featureRunner);297            String featurePath =  PathUtils.getAsFile(FeatureRunnerExtractors.featurePathFor(featureRunner)).getName();298            boolean matches = weightedCucumberScenarios.scenarios.stream().anyMatch(scenario -> featurePath.equals(scenario.featurePath));299            LOGGER.debug("{} in filtering '{}' in {}", matches ? "Including" : "Not including", featureName, featurePath);300            return matches;301        };302    }303}...

...88            } else {89                LOGGER.info("Running slice {} of {} using fork {} of {} from feature paths {}", batchNumber, batchCount, forkNumber, forkCount, featurePaths);90                WeightedCucumberScenarios weightedCucumberScenarios = new CucumberSuiteSlicer(featurePaths, TestStatistics.from(environmentVariables, featurePaths))91                        .scenarios(batchNumber, batchCount, forkNumber, forkCount, tagFilters);92                List<FeatureRunner> unfilteredChildren = super.getChildren();93                AtomicInteger filteredInScenarioCount = new AtomicInteger();94                List<FeatureRunner> filteredChildren = unfilteredChildren.stream()95                        .filter(forIncludedFeatures(weightedCucumberScenarios))96                        .map(toPossibleFeatureRunner(weightedCucumberScenarios, filteredInScenarioCount))97                        .filter(Optional::isPresent)98                        .map(Optional::get)99                        .collect(toList());100                if (filteredInScenarioCount.get() != weightedCucumberScenarios.totalScenarioCount()) {101                    LOGGER.warn(102                            "There is a mismatch between the number of scenarios included in this test run ({}) and the expected number of scenarios loaded ({}). This suggests that the scenario filtering is not working correctly or feature file(s) of an unexpected structure are being run",103                            filteredInScenarioCount.get(),104                            weightedCucumberScenarios.scenarios.size());105                }106                LOGGER.info("Running {} of {} features", filteredChildren.size(), unfilteredChildren.size());107                return filteredChildren;108            }109        } catch (Exception e) {110            LOGGER.error("Test failed to start", e);111            throw e;112        }113    }114    private Function<FeatureRunner, Optional<FeatureRunner>> toPossibleFeatureRunner(WeightedCucumberScenarios weightedCucumberScenarios, AtomicInteger filteredInScenarioCount) {115        return featureRunner -> {116            int initialScenarioCount = featureRunner.getDescription().getChildren().size();117            String featureName = FeatureRunnerExtractors.extractFeatureName(featureRunner);118            try {119                ScenarioFilter filter = weightedCucumberScenarios.createFilterContainingScenariosIn(featureName);120                String featurePath = FeatureRunnerExtractors.featurePathFor(featureRunner);121                featureRunner.filter(filter);122                if (!filter.scenariosIncluded().isEmpty()) {123                    LOGGER.info("{} scenario(s) included for '{}' in {}", filter.scenariosIncluded().size(), featureName, featurePath);124                    filter.scenariosIncluded().forEach(scenario -> {125                        LOGGER.info("Included scenario '{}'", scenario);126                        filteredInScenarioCount.getAndIncrement();127                    });128                }129                if (!filter.scenariosExcluded().isEmpty()) {130                    LOGGER.debug("{} scenario(s) excluded for '{}' in {}", filter.scenariosExcluded().size(), featureName, featurePath);131                    filter.scenariosExcluded().forEach(scenario -> LOGGER.debug("Excluded scenario '{}'", scenario));132                }133                return Optional.of(featureRunner);134            } catch (NoTestsRemainException e) {135                LOGGER.info("Filtered out all {} scenarios for feature '{}'", initialScenarioCount, featureName);136                return Optional.empty();137            }138        };139    }140    private Predicate<FeatureRunner> forIncludedFeatures(WeightedCucumberScenarios weightedCucumberScenarios) {141        return featureRunner -> {142            String featureName = FeatureRunnerExtractors.extractFeatureName(featureRunner);143            String featurePath = Paths.get(FeatureRunnerExtractors.featurePathFor(featureRunner)).getFileName().toString();144            boolean matches = weightedCucumberScenarios.scenarios.stream().anyMatch(scenario -> featurePath.equals(scenario.featurePath));145            LOGGER.debug("{} in filtering '{}' in {}", matches ? "Including" : "Not including", featureName, featurePath);146            return matches;147        };148    }149}...

...18import static org.apache.commons.lang3.builder.EqualsBuilder.reflectionEquals;19/**20 * Represents a collection of cucumber scenarios.21 * Can split itself up into a number of smaller WeightedCucumberScenarios.22 * Can return a new WeightedCucumberScenarios that has some scenarios filtered out.23 */24public class WeightedCucumberScenarios {25    private static final Logger LOGGER = LoggerFactory.getLogger(WeightedCucumberScenarios.class);26    public final BigDecimal totalWeighting;27    public final List<WeightedCucumberScenario> scenarios;28    public WeightedCucumberScenarios(List<WeightedCucumberScenario> scenarios) {29        this.scenarios = scenarios;30        this.totalWeighting = scenarios.stream().map(WeightedCucumberScenario::weighting).reduce(ZERO, BigDecimal::add);31    }32    public SliceBuilder slice(int sliceNumber) {33        return new SliceBuilder(sliceNumber, this);34    }35    public List<WeightedCucumberScenarios> sliceInto(int sliceCount) {36        BigDecimal totalWeight = scenarios.stream().map(WeightedCucumberScenario::weighting).reduce(ZERO, BigDecimal::add);37        BigDecimal averageWeightPerSlice = totalWeight.divide(new BigDecimal(sliceCount), 2, RoundingMode.HALF_UP);38        LOGGER.debug("Total weighting for {} scenarios is {}, split across {} slices provides average weighting per slice of {}", scenarios.size(), totalWeight, sliceCount, averageWeightPerSlice);39        List<List<WeightedCucumberScenario>> allScenarios = IntStream.rangeClosed(1, sliceCount).mapToObj(initialiseAs -> new ArrayList<WeightedCucumberScenario>()).collect(toList());40        scenarios.stream()41            .sorted(bySlowestFirst())42            .forEach(scenario -> allScenarios.stream().min(byLowestSumOfDurationFirst()).get().add(scenario));43        return allScenarios.stream().map(WeightedCucumberScenarios::new).collect(toList());44    }45    public ScenarioFilter createFilterContainingScenariosIn(String featureName) {46        LOGGER.debug("Filtering for scenarios in feature {}", featureName);47        List<String> scenarios = this.scenarios.stream()48            .filter(scenario -> {49                boolean matches = scenario.feature.equals(featureName);50                LOGGER.debug("Scenario {} matches {} -> {}", scenario.feature, featureName, matches);51                return matches;52            })53            .map(scenario -> scenario.scenario)54            .collect(toList());55        if (scenarios.isEmpty()) {56            throw new IllegalArgumentException("Can't find feature '" + featureName + "' in this slice");57        }58        return ScenarioFilter.onScenarios(scenarios);59    }60    public WeightedCucumberScenarios filter(Predicate<WeightedCucumberScenario> predicate) {61        return new WeightedCucumberScenarios(scenarios.stream().filter(predicate).collect(toList()));62    }63    @Override64    public int hashCode() {65        return HashCodeBuilder.reflectionHashCode(this);66    }67    @Override68    public boolean equals(Object obj) {69        return reflectionEquals(this, obj);70    }71    @Override72    public String toString() {73        return ToStringBuilder.reflectionToString(this);74    }75    private static Comparator<WeightedCucumberScenario> bySlowestFirst() {...

...44        return cucumberFeature -> {45            try {46                return (cucumberFeature.getGherkinFeature().getFeature() == null) ? Collections.emptyList() : cucumberFeature.getGherkinFeature().getFeature().getChildren()47                    .stream()48                    .filter(child -> asList(ScenarioOutline.class, Scenario.class).contains(child.getClass()))49                    .map(scenarioDefinition -> new WeightedCucumberScenario(50                        PathUtils.getAsFile(cucumberFeature.getUri()).getName(),51                        cucumberFeature.getGherkinFeature().getFeature().getName(),52                        scenarioDefinition.getName(),53                        scenarioWeightFor(cucumberFeature, scenarioDefinition),54                        tagsFor(cucumberFeature, scenarioDefinition),55                        scenarioCountFor(scenarioDefinition)))56                    .collect(toList());57            } catch (Exception e) {58                throw new IllegalStateException(String.format("Could not extract scenarios from %s", cucumberFeature.getUri()), e);59            }60        };61    }62    private int scenarioCountFor(ScenarioDefinition scenarioDefinition) {...

...12        this.statistics = statistics;13    }14    public WeightedCucumberScenarios scenarios(int batchNumber, int batchCount, int forkNumber, int forkCount, List<String> tagFilters) {15        return new CucumberScenarioLoader(featurePaths, statistics).load()16            .filter(forSuppliedTags(tagFilters))17            .slice(batchNumber).of(batchCount).slice(forkNumber).of(forkCount);18    }19    private Predicate<WeightedCucumberScenario> forSuppliedTags(List<String> tagFilters) {20        return cucumberScenario -> TagParser.parseFromTagFilters(tagFilters).evaluate(newArrayList(cucumberScenario.tags));21    }22}...