assertEquals("junit-4.13.1.jar", modules.get(0).getFileName().toString());
        assertTrue(paths.containsAll(classes));
        assertTrue(paths.containsAll(modules));

        // If caller wants only a classpath, JUnit shall move there.
        dispatched = session.resolveDependencies(coord, PathScope.TEST_COMPILE, Arrays.asList(JavaPathType.CLASSES));
        classes = dispatched.get(JavaPathType.CLASSES);

 */
@Named("jdk-version")
@Singleton
public class JdkVersionProfileActivator implements ProfileActivator {

    private static final Pattern FILTER_1 = Pattern.compile("[^\\d._-]");
    private static final Pattern FILTER_2 = Pattern.compile("[._-]");
    private static final Pattern FILTER_3 = Pattern.compile("\\."); // used for split now

    @Override

        ScopeArtifactFilter filter;
        if (Artifact.SCOPE_PROVIDED.equals(expectedScope)) {
            filter = new ScopeArtifactFilter(Artifact.SCOPE_COMPILE);
        } else if (Artifact.SCOPE_SYSTEM.equals(expectedScope)) {
            filter = new ScopeArtifactFilter(Artifact.SCOPE_COMPILE);
        } else {
            filter = new ScopeArtifactFilter(expectedScope);
        }

                        Set<Binding<Object>> res3 = res2 != null ? new HashSet<>(res2) : new HashSet<>();
                        Map<String, Supplier<Object>> map = res3.stream()
                                .filter(b -> b.getOriginalKey() == null
                                        || b.getOriginalKey().getQualifier() == null
                                        || b.getOriginalKey().getQualifier() instanceof String)

                    foreignImports,
                    filter,
                    project.getRemotePluginRepositories(),
                    session.getRepositorySession());

            PluginRealmCache.CacheRecord cacheRecord = pluginRealmCache.get(cacheKey, () -> {
                createPluginRealm(pluginDescriptor, session, parent, foreignImports, filter);

                return new PluginRealmCache.CacheRecord(

                .getOrDefault(artifact.getGroupId(), Collections.emptyMap())
                .getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
                .values()
                .stream()
                .filter(p -> Objects.nonNull(findArtifact(p, artifact)))
                .map(MavenProject::getVersion)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
    }

            this.relocations = relocations;
        }

        private Relocation getRelocation(Artifact artifact) {
            return relocations.stream()
                    .filter(r -> r.predicate.test(artifact))
                    .findFirst()
                    .orElse(null);
        }
    }

    private Relocations parseRelocations(RepositorySystemSession session) {

                .filter(p -> p.getArtifactId().equals(artifactId))
                .findFirst()
                .orElse(null);
        assertNotNull(plugin, "Unable to find plugin with artifactId: " + artifactId);
        List<PluginExecution> pluginExecutions = plugin.getExecutions();
        PluginExecution pluginExecution = pluginExecutions.stream()
                .filter(pe -> pe.getId().equals(expectedId))

     * filter is applied (like in Maven 3).
     * <p>
     * Supported filters:
     * <ul>
     *     <li>"h" or "h(num)" - highest version or top list of highest ones filter</li>
     *     <li>"l" or "l(num)" - lowest version or bottom list of lowest ones filter</li>
     *     <li>"s" - contextual snapshot filter</li>

                        FAMILY_TANDEM,
                        FAMILY_UNIX,
                        FAMILY_WIN9X,
                        FAMILY_WINDOWS,
                        FAMILY_ZOS)
                .filter(Os::isFamily)
                .findFirst()
                .orElse(null);
    }