return buf.toString();
    }

    public String getServer() {
        return server;
    }

    public void setServer(final String server) {
        this.server = server;
    }

    public int getPort() {
        return port;
    }

    public void setPort(final int port) {
        this.port = port;
    }

    public String getUsername() {
        return username;
    }

                abstract Property<String> getMessage()
                @Internal
                abstract Property<Double> getNumber()
                @Internal
                abstract ListProperty<Integer> getList()
                @Internal
                abstract SetProperty<Integer> getSet()
                @Internal
                abstract MapProperty<Integer, Boolean> getMap()

                @TaskAction

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull
    Optional<Artifact> getRootArtifact();

    @Nonnull
    Optional<DependencyCoordinate> getRoot();

    @Nonnull
    Collection<DependencyCoordinate> getDependencies();

    @Nonnull
    Collection<DependencyCoordinate> getManagedDependencies();

    boolean getVerbose();

    @Nullable

        encoder.writeLong(canonicalAddress.getMostSignificantBits());
        encoder.writeLong(canonicalAddress.getLeastSignificantBits());
        encoder.writeInt(address.getPort());
        encoder.writeSmallInt(address.getCandidates().size());
        for (InetAddress inetAddress : address.getCandidates()) {
            encoder.writeBinary(inetAddress.getAddress());
        }
    }

                    if (oldValue == null) {
                        return oldValue;
                    }
                    oldValue.removeInfo(((InetEndpoint)address).getPort());
                    return oldValue;
                }
            });
        } finally {
            lock.unlock();
        }
    }

    @Override

    }
    assertEquals(
        "A List's hashCode() should be computed from those of its elements.",
        expectedHashCode,
        getList().hashCode());
  }

  /**
   * Returns the {@link Method} instance for {@link #testHashCode()} so that list tests on
   * unhashable objects can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()}.

            return new URI(scheme.scheme + "://" + host + ":" + getPort());
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Returns the URI for the given resource.
     */
    public URI uri(String resource) {
        try {
            return new URI(scheme.scheme, null, scheme.host, getPort(), "/" + resource, null, null);

            collect.setTrace(RequestTrace.newChild(trace, depRequest));
            node = repoSystem.collectDependencies(session, collect).getRoot();
            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());
            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(

        builder.visitComponentVariants(Collections.emptyList());
        builder.endVisitComponent();
        ResolvedComponentResult root = builder.getRoot(0L);
        return new MinimalResolutionResult(() -> root, attributes);
    }

    public ResolvedComponentResult getRoot(long rootId) {
        return components.get(rootId);
    }

    @Override

     */
    @Override
    public String toRelativePath() {
        switch (segments.size()) {
            case 0:
                return "";
            case 1:
                return segments.getLast();
            default:
                int length = segments.size() - 1;
                for (String segment : segments) {
                    length += segment.length();
                }