public String id() {
            return JavaPathType.this.name() + ":" + moduleName;
        }

        /**
         * Returns the type of path without indication about the target module.
         * This is usually {@link #PATCH_MODULE}.
         *
         * @return type of path without indication about the target module
         */
        @Nonnull
        public JavaPathType rawType() {

        boolean modules = false;
        boolean unknown = false;
        for (PathType type : types) {
            if (filter.test(type)) {
                if (JavaPathType.CLASSES.equals(type)) {
                    classes = true;
                } else if (JavaPathType.MODULES.equals(type)) {
                    modules = true;
                } else {
                    unknown = true;
                }

                // Java types
                new DefaultType(
                        Type.JAR, Language.JAVA_FAMILY, "jar", null, false, JavaPathType.CLASSES, JavaPathType.MODULES),
                new DefaultType(Type.JAVADOC, Language.JAVA_FAMILY, "jar", "javadoc", false, JavaPathType.CLASSES),

     */
    private boolean containsPatches(Set<PathType> types) {
        for (PathType type : types) {
            if (type instanceof JavaPathType.Modular) {
                type = ((JavaPathType.Modular) type).rawType();
            }
            if (JavaPathType.PATCH_MODULE.equals(type)) {
                return true;
            }
        }
        return false;
    }

    /**

     * Returns the type of path detected. The return value is {@link JavaPathType#MODULES}
     * if the dependency is a modular JAR file or a directory containing module descriptor(s),
     * or {@link JavaPathType#CLASSES} otherwise. A JAR file without module descriptor but with
     * an "Automatic-Module-Name" manifest attribute is considered modular.
     */
    public JavaPathType getPathType() {

        Map<PathType, List<Path>> dispatched = session.resolveDependencies(
                coord, PathScope.TEST_COMPILE, Arrays.asList(JavaPathType.CLASSES, JavaPathType.MODULES));
        List<Path> classes = dispatched.get(JavaPathType.CLASSES);
        List<Path> modules = dispatched.get(JavaPathType.MODULES);
        List<Path> unresolved = dispatched.get(PathType.UNRESOLVED);
        assertEquals(3, dispatched.size());

        boolean modules = false;
        boolean unknown = false;
        for (PathType type : types) {
            if (filter.test(type)) {
                if (JavaPathType.CLASSES.equals(type)) {
                    classes = true;
                } else if (JavaPathType.MODULES.equals(type)) {
                    modules = true;
                } else {
                    unknown = true;
                }

        }
    };

    /**
     * Returns the unique name of this path type, including the module to patch if any.
     * For example, if this type is {@link JavaPathType#MODULES}, then this method returns {@code "MODULES"}.
     * But if this type was created by {@code JavaPathType.patchModule("foo.bar")}, then this method returns
     * {@code "PATCH_MODULE:foo.bar"}.
     *

                        handler.getExtension(),
                        handler.getClassifier(),
                        handler.isIncludesDependencies(),
                        JavaPathType.CLASSES,
                        JavaPathType.MODULES);
            }
            return type;
        });
    }

     * Returns the type of path detected. The return value is {@link JavaPathType#MODULES}
     * if the dependency is a modular JAR file or a directory containing module descriptor(s),
     * or {@link JavaPathType#CLASSES} otherwise. A JAR file without module descriptor but with
     * an "Automatic-Module-Name" manifest attribute is considered modular.
     */
    public JavaPathType getPathType() {