* @param location identification of a path in the {@code javax.tool} API
     * @return Java path type associated to the given location
     */
    public static Optional<JavaPathType> valueOf(JavaFileManager.Location location) {
        for (JavaPathType type : JavaPathType.values()) {
            if (location.equals(type.location)) {
                return Optional.of(type);
            }
        }
        return Optional.empty();

                // 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),

     */
    @Test
    public void testEqualsHashCode() {
        JavaPathType.Modular foo1 = JavaPathType.patchModule("foo");
        JavaPathType.Modular foo2 = JavaPathType.patchModule("foo");
        JavaPathType.Modular bar = JavaPathType.patchModule("bar");
        assertEquals(foo1, foo2);
        assertEquals(foo1.hashCode(), foo2.hashCode());
        assertNotEquals(foo1, bar);

                        handler.isIncludesDependencies(),
                        handler.isAddedToClasspath()
                                ? new JavaPathType[] {JavaPathType.CLASSES, JavaPathType.MODULES}
                                : new JavaPathType[] {});
            }
            return type;
        });
    }

        Map<PathType, List<Path>> dispatched = session.resolveDependencies(
                coords, 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());

        }
    };

    /**
     * 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"}.
     *

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.Language;
import org.apache.maven.api.PathType;
import org.apache.maven.api.Type;
import org.apache.maven.repository.internal.artifact.MavenArtifactProperties;

import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.apache.maven.api.Dependency;
import org.apache.maven.api.DependencyScope;
import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.Node;
import org.apache.maven.api.PathType;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.Type;
import org.apache.maven.api.services.TypeRegistry;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.handler.DefaultArtifactHandler;

     * and the user may have provided no instruction about which type to use. In such
     * case, the plugin may apply rules for choosing a path. See for example
     * {@link JavaPathType#CLASSES} and {@link JavaPathType#MODULES}.</p>
     */
    @Nonnull
    Set<PathType> getPathTypes();