HttpRequest.newBuilder(server.url("/").toUri())
        .header("Accept", "text/plain")
        .build()

    val response = httpClient.send(request, BodyHandlers.ofString())
    assertThat(response.statusCode()).isEqualTo(200)
    assertThat(response.body()).isEqualTo("hello, Java HTTP Client")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")

		return so.Err
	}
	sw.stats.getLocked(so.Cookie).Listened++
	return nil
}

// Accept wraps syscall.Accept.
func (sw *Switch) Accept(s int) (ns int, sa syscall.Sockaddr, err error) {
	so := sw.sockso(s)
	if so == nil {
		return syscall.Accept(s)
	}
	sw.fmu.RLock()
	f := sw.fltab[FilterAccept]
	sw.fmu.RUnlock()

	af, err := f.apply(so)
	if err != nil {

        this.executorFactory = executorFactory;
        this.addressFactory = addressFactory;
        this.idGenerator = idGenerator;
    }

    @Override
    public ConnectionAcceptor accept(Action<ConnectCompletion> action, boolean allowRemote) {
        final ServerSocketChannel serverSocket;
        int localPort;
        try {
            serverSocket = ServerSocketChannel.open();

            handler.accept(JavaReflectionUtil.extractNestedType((TypeToken<Provider<?>>) node, Provider.class, 0));
        }

        @SuppressWarnings("unchecked")
        @Override
        protected void walkNestedMap(TypeToken<?> node, String qualifiedName, BiConsumer<String, TypeToken<?>> handler) {
            handler.accept(
                "<key>",

        schema.attribute(usage)
        schema.accept(usage, "requested", "compatible")
        schema.accept(usage, "requested", "best")
        schema.prefer(usage, "best")
        def other = Attribute.of('other', String)
        schema.attribute(other)
        schema.accept(other, "requested", "compatible")
        schema.accept(other, "requested", "best")
        schema.prefer(other, "best")

        expect:
        collector.format() == """Type ${fullyQualifiedNameOf(WithConstructor)} is not a valid <thing>:
- Constructor FormattingValidationProblemCollectorTest.WithConstructor(java.lang.String) is not valid: doesn't do anything
- Constructor FormattingValidationProblemCollectorTest.WithConstructor(java.lang.String) is not valid: should accept an int"""
    }

    protected AbstractStringVersionSelector(String selector) {
        super(selector);
    }

    @Override
    public boolean accept(Version candidate) {
        return accept(candidate.getSource());
    }

		}
		config.Header.Add("Accept", accept)
		ws, err := websocket.DialConfig(config)
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		return ws, "__default__"
	}

	testCases := []struct {
		Accept              string
		ExpectedContentType string
		MediaType           string
	}{
		{
			Accept:              "application/json",

 */
@FunctionalInterface
public interface IoConsumer<T> {
    void accept(@Nullable T payload) throws IOException;

    static <T> Consumer<T> wrap(IoConsumer<T> consumer) {
        return payload -> {
            try {
                consumer.accept(payload);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        };

        this.executable = executable;
        this.delegate = delegate;
    }

    @Override
    public boolean accept(ChangeVisitor visitor) {
        try {
            return delegate.accept(visitor);
        } catch (Exception ex) {
            throw new GradleException(String.format("Cannot determine changes for %s", executable.getDisplayName()), ex);
        }
    }