*/

    /**
     * Determines the address of a host given its host name.
     *
     * @param hostname the hostname to resolve
     * @return the resolved UniAddress
     * @throws UnknownHostException if the host cannot be resolved
     */
    public static UniAddress getByName(final String hostname) throws UnknownHostException {
        return getByName(hostname, false);
    }

     *
     * @param url the SMB URL of the named pipe
     * @param pipeType the type of the pipe
     * @throws MalformedURLException if the URL is malformed
     * @throws UnknownHostException if the host cannot be resolved
     */
    public SmbNamedPipe(final String url, final int pipeType) throws MalformedURLException, UnknownHostException {
        super(url);
        this.pipeType = pipeType;
        type = TYPE_NAMED_PIPE;
    }

    TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass());
    ParameterizedType resolved =
        (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType());
    assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType());
    assertEquals(Bar.class, resolved.getRawType());
    assertThat(resolved.getActualTypeArguments()).asList().contains(String.class);
  }

    TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass());
    ParameterizedType resolved =
        (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType());
    assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType());
    assertEquals(Bar.class, resolved.getRawType());
    assertThat(resolved.getActualTypeArguments()).asList().contains(String.class);
  }

        // TODO figure out way to avoid duplicated message
        if (getLogger().isDebugEnabled()) {
            if (!version.equals(artifact.getBaseVersion())) {
                String message = artifact.getArtifactId() + ": resolved to version " + version;
                if (artifact.getRepository() != null) {
                    message += " from repository " + artifact.getRepository().getId();
                } else {

    public RequestBuilder(final Client client, final Req request) {
        this.client = client;
        this.request = request;
    }

    /**
     * Executes the request.
     * @return A Promise that will be resolved with the response or rejected with an error.
     */
    public Deferred<Res>.Promise execute() {
        return request.execute(client);
    }

     * <strong>Important:</strong> This method returns the target path as specified in the configuration,
     * which may be relative or absolute. It does <strong>not</strong> perform any path resolution.
     * For the fully resolved absolute path, use {@link #targetPath(Project)} instead.
     * </p>
     * <p>
     * <strong>Return Value Semantics:</strong>
     * </p>
     * <ul>

     * @param version The version of the POM, must not be {@code null}.
     * @return The source of the requested POM, never {@code null}.
     * @throws UnresolvableModelException If the POM could not be resolved from any configured repository.
     */
    ModelSource resolveModel(String groupId, String artifactId, String version) throws UnresolvableModelException;

    /**

        with:
          dirtyLabel: "conflicts"
          repoToken: "${{ secrets.GITHUB_TOKEN }}"

    /**
     * Internal: for testing only
     *
     * @param dr the DFS referral data to process
     * @param reqPath the requested path to resolve
     * @return resolved unc path
     */
    String handleDFSReferral(DfsReferralData dr, String reqPath);