@Override
public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest,
        UniqueId uniqueId) {
    // Discover test(s) and return a TestDescriptor object
    TestDescriptor testDescriptor = new EngineDescriptor(uniqueId,
            "My test");
    return testDescriptor;
}
 

@Override
public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest,
        UniqueId uniqueId) {
    // Discover test(s) and return a TestDescriptor object
    TestDescriptor testDescriptor = new EngineDescriptor(uniqueId,
            "My test");
    return testDescriptor;
}
 

@Override
public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId) {
    ArchUnitEngineDescriptor result = new ArchUnitEngineDescriptor(uniqueId);

    resolveRequestedClasspathRoot(discoveryRequest, uniqueId, result);
    resolveRequestedPackages(discoveryRequest, uniqueId, result);
    resolveRequestedClasses(discoveryRequest, uniqueId, result);
    resolveRequestedMethods(discoveryRequest, uniqueId, result);
    resolveRequestedFields(discoveryRequest, uniqueId, result);
    resolveRequestedUniqueIds(discoveryRequest, uniqueId, result);

    return result;
}
 

private void resolveRequestedClasspathRoot(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    Stream<JavaClass> classes = discoveryRequest.getSelectorsByType(ClasspathRootSelector.class).stream()
            .flatMap(this::getContainedClasses);
    filterCandidatesAndLoadClasses(classes, discoveryRequest)
            .forEach(clazz -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, clazz), cache.get()));
}
 

private void resolveRequestedPackages(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    String[] packages = discoveryRequest.getSelectorsByType(PackageSelector.class).stream()
            .map(PackageSelector::getPackageName)
            .toArray(String[]::new);
    Stream<JavaClass> classes = getContainedClasses(packages);

    filterCandidatesAndLoadClasses(classes, discoveryRequest)
            .forEach(clazz -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, clazz), cache.get()));
}
 

private void resolveRequestedClasses(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    discoveryRequest.getSelectorsByType(ClassSelector.class).stream()
            .map(ClassSelector::getJavaClass)
            .filter(this::isArchUnitTestCandidate)
            .forEach(clazz -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, clazz), cache.get()));
}
 

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()));
}
 

private Stream<Class<?>> filterCandidatesAndLoadClasses(Stream<JavaClass> classes, EngineDiscoveryRequest discoveryRequest) {
    return classes
            .filter(isAllowedBy(discoveryRequest))
            .filter(this::isArchUnitTestCandidate)
            .flatMap(this::safelyReflect);
}
 

private void resolveRequestedMethods(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    discoveryRequest.getSelectorsByType(MethodSelector.class).stream()
            .filter(s -> s.getJavaMethod().isAnnotationPresent(ArchTest.class))
            .forEach(selector -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, selector.getJavaClass(), selector.getJavaMethod()), cache.get()));
}
 

private void resolveRequestedFields(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    discoveryRequest.getSelectorsByType(FieldSelector.class).stream()
            .filter(s -> s.getJavaField().isAnnotationPresent(ArchTest.class))
            .forEach(selector -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, selector.getJavaClass(), selector.getJavaField()), cache.get()));
}
 

private void resolveRequestedUniqueIds(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId, ArchUnitEngineDescriptor result) {
    discoveryRequest.getSelectorsByType(UniqueIdSelector.class).stream()
            .filter(selector -> selector.getUniqueId().getEngineId().equals(Optional.of(getId())))
            .forEach(selector -> ArchUnitTestDescriptor.resolve(
                    result, ElementResolver.create(result, uniqueId, selector.getUniqueId()), cache.get()));
}