private Filter[] testFilters(Dispatcher dispatcher) {

            List<Filter<?>> filters = new ArrayList<>();

            if (!options.getExcludeTags().isEmpty()) {
                filters.add(excludeTags(options.getExcludeTags()));
            }

            if (!options.getIncludeTags().isEmpty()) {
                filters.add(includeTags(options.getIncludeTags()));
            }

            TestFilter.create(options.getTestFilters(), dispatcher).ifPresent(filters::add);
            GlobFilter.create(options.getGlobPatterns(), dispatcher).ifPresent(filters::add);

            return filters.toArray(new Filter[filters.size()]);
        }
 

private static Filter[] getFilters(JkTestSelection testSelection) {
    List<Filter> result = new LinkedList<>();
    if (!testSelection.getIncludePatterns().isEmpty()) {
        result.add(ClassNameFilter.includeClassNamePatterns(toArray(testSelection.getIncludePatterns())));
    }
    if (!testSelection.getExcludePatterns().isEmpty()) {
        result.add(ClassNameFilter.excludeClassNamePatterns(toArray(testSelection.getExcludePatterns())));
    }
    if (!testSelection.getIncludeTags().isEmpty()) {
        result.add(TagFilter.includeTags(toArray(testSelection.getIncludeTags())));
    }
    if (!testSelection.getExcludeTags().isEmpty()) {
        result.add(TagFilter.excludeTags(toArray(testSelection.getExcludeTags())));
    }
    return result.toArray(new Filter[0]);
}
 

private Predicate<JavaClass> isAllowedBy(EngineDiscoveryRequest discoveryRequest) {
    List<Predicate<String>> filters = Stream
            .concat(discoveryRequest.getFiltersByType(ClassNameFilter.class).stream(),
                    discoveryRequest.getFiltersByType(PackageNameFilter.class).stream())
            .map(Filter::toPredicate)
            .collect(toList());

    return javaClass -> filters.stream().allMatch(p -> p.test(javaClass.getName()));
}