private void pruneTree(TestDescriptor rootDescriptor) { rootDescriptor.accept(TestDescriptor::prune); }
void applyClassNamePredicate(Predicate<String> classNamePredicate, TestDescriptor engineDescriptor) { TestDescriptor.Visitor filteringVisitor = descriptor -> { if (descriptor instanceof ClassTestDescriptor && !includeClass((ClassTestDescriptor) descriptor, classNamePredicate)) { descriptor.removeFromHierarchy(); } }; engineDescriptor.accept(filteringVisitor); }
private void pruneTree(TestDescriptor rootDescriptor) { rootDescriptor.accept(TestDescriptor::prune); }
private List<AbstractBenchmarkDescriptor> collectBenchmarkMethods(TestDescriptor testDescriptor) { List<AbstractBenchmarkDescriptor> methods = new ArrayList<>(); testDescriptor.accept(it -> { if (it instanceof BenchmarkMethodDescriptor || it instanceof ParametrizedBenchmarkMethodDescriptor) { methods.add((AbstractBenchmarkDescriptor) it); } }); return methods; }
private void notifyFinishedRecursively(TestDescriptor descriptor, Consumer<TestDescriptor> visitor) { Optional<TestDescriptor> parent = descriptor.getParent(); while (parent.isPresent()) { TestDescriptor actualParent = parent.get(); AtomicInteger integer = expectedContainerCount.computeIfAbsent(actualParent, it -> { AtomicInteger childCount = new AtomicInteger(0); it.accept(item -> { if (item instanceof BenchmarkMethodDescriptor || item instanceof BenchmarkFixtureDescriptor) { childCount.incrementAndGet(); } }); return childCount; }); if (integer.decrementAndGet() == 0) { visitor.accept(actualParent); } parent = actualParent.getParent(); } }
void applyClassNamePredicate(Predicate<String> classNamePredicate, TestDescriptor engineDescriptor) { TestDescriptor.Visitor filteringVisitor = descriptor -> { if (descriptor instanceof BenchmarkClassDescriptor && !includeClass((BenchmarkClassDescriptor) descriptor, classNamePredicate)) { descriptor.removeFromHierarchy(); } }; engineDescriptor.accept(filteringVisitor); }
private int count(TestDescriptor root, Predicate<TestDescriptor> descriptorTester) { AtomicInteger counter = new AtomicInteger(); root.accept(d -> { if (descriptorTester.test(d)) counter.incrementAndGet(); }); return counter.intValue(); }
@SuppressWarnings("unchecked") private List<AbstractBenchmarkDescriptor> getIncludes(TestDescriptor testDescriptor) { String tests = Environment.getProperty("benchmark"); List<BenchmarkClassDescriptor> classes = new ArrayList<>(); testDescriptor.accept(it -> { if (it instanceof BenchmarkClassDescriptor) { classes.add((BenchmarkClassDescriptor) it); } }); if (!StringUtils.hasText(tests)) { return (List) classes; } return classes.stream().filter(it -> { Class<?> javaClass = it.getJavaClass(); return tests.contains(javaClass.getName()) || tests.contains(javaClass.getSimpleName()); }).flatMap(it -> { if (tests.contains("#")) { String[] split = tests.split("#"); String methodNameFilter = split[1]; return it.getChildren().stream() .filter(MethodAware.class::isInstance) .map(MethodAware.class::cast) .filter(member -> member.getMethod().getName().equals(methodNameFilter)); } else { return Stream.of(it); } }).map(AbstractBenchmarkDescriptor.class::cast).collect(Collectors.toList()); }
/** * Accept a {@link Visitor} to the subtree starting with this descriptor. * * @param visitor the {@code Visitor} to accept; never {@code null} */ default void accept(Visitor visitor) { Preconditions.notNull(visitor, "Visitor must not be null"); visitor.visit(this); // Create a copy of the set in order to avoid a ConcurrentModificationException new LinkedHashSet<>(this.getChildren()).forEach(child -> child.accept(visitor)); }