* Shortcut for {@code getService(VersionResolver.class).resolve(...)}
     *
     * @param artifact the artifact for which to resolve the version
     * @return resolved version of the given artifact
     * @throws org.apache.maven.api.services.VersionResolverException if the resolution failed
     *
     * @see org.apache.maven.api.services.VersionResolver#resolve(Session, ArtifactCoordinates) (String)
     */
    @Nonnull

 * encoding for URL decoding.</p>
 *
 * <p>Example usage:</p>
 * <pre>
 * {@code
 * IdnDnsResolver resolver = new IdnDnsResolver();
 * resolver.setFlag(IDN.ALLOW_UNASSIGNED);
 * resolver.setEncoding("UTF-8");
 * InetAddress[] addresses = resolver.resolve("example.com");
 * }
 * </pre>
 *
 */
public class IdnDnsResolver implements DnsResolver {

    /** Flag for IDN conversion. */

import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
import org.apache.maven.artifact.resolver.ResolutionErrorHandler;

        // The root artifact may, or may not be resolved so we need to check before we attempt to resolve.
        // This is often an artifact like a POM that is taken from disk and we already have hold of the
        // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository
        // as well as its dependencies.

        assertEquals(path.normalize(), source.getPath());
        assertEquals(path.toString(), source.getLocation());

        Source resolved = source.resolve("subdir");
        assertNotNull(resolved);
        assertEquals(path.resolve("subdir").normalize(), resolved.getPath());
    }

    @Test
    void testBuildPathSourceFunctionality() {
        // Test build source functionality

        public Path getPath() {
            return path;
        }

        @Override
        public Source resolve(@Nonnull String relative) {
            return new BuildPathSource(path.resolve(relative));
        }

        @Override
        @Nullable
        public ModelSource resolve(@Nonnull ModelLocator locator, @Nonnull String relative) {

    }

    /**
     * Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
     * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
     * doesn't try to resolve any type variable on generic declarations that are already being
     * resolved.
     *
     * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
     */

        value = null;
        assertNull(ResourceUtil.resolve(value));

        value = "";
        assertEquals("", ResourceUtil.resolve(value));

        value = "a";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "${a}";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "$a";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "${a";

    assertThat(url.resolve("")).isEqualTo(parse("http://a/b/c/d;p?q"))
    assertThat(url.resolve(".")).isEqualTo(parse("http://a/b/c/"))
    assertThat(url.resolve("./")).isEqualTo(parse("http://a/b/c/"))
    assertThat(url.resolve("..")).isEqualTo(parse("http://a/b/"))
    assertThat(url.resolve("../")).isEqualTo(parse("http://a/b/"))

    /**
     * Sets whether to resolve this request path in DFS.
     *
     * @param resolve true to enable DFS resolution
     */
    void setResolveInDfs(boolean resolve);

    /**
     * Checks if this request should be resolved in DFS.
     *
     * @return whether to resolve the request path in DFS
     */
    boolean isResolveInDfs();