// DiSNI components - these would be actual DiSNI objects in a real implementation
    private Object endpointGroup; // RdmaActiveEndpointGroup<DisniRdmaEndpoint>
    private Object endpoint; // RdmaActiveEndpoint
    private boolean initialized = false;

    @Override
    public boolean isAvailable() {
        try {
            // Check if DiSNI is available on the classpath

  @Test
  fun testOkHttpDirect() {
    testRequest {
      val client = OkHttpClient()

      val response =
        client
          .newCall(
            Request((mockServer.endpoint + "/person?name=peter").toHttpUrl()),
          ).execute()

      assertThat(response.body.string()).contains("Peter the person")
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
    }
  }

- The endpointslice mirroring controller mirrors endpoints annotations and labels to the generated endpoint slices, it also ensures that updates on any of these fields on the endpoints are mirrored. 

	byHostName := globalMinioAddr
	if len(opts.hosts) > 0 {
		server := getLocalServerProperty(globalEndpoints, &http.Request{
			Host: globalLocalNodeName,
		}, false)
		if _, ok := opts.hosts[server.Endpoint]; ok {
			byHostName = server.Endpoint
		} else {
			return m
		}
	}

	if strings.HasPrefix(byHostName, ":") && !strings.HasPrefix(globalLocalNodeName, ":") {
		byHostName = globalLocalNodeName
	}

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/url"
	"time"

	"github.com/minio/minio-go/v7"
	cr "github.com/minio/minio-go/v7/pkg/credentials"
)

var (
	// LDAP integrated Minio endpoint
	stsEndpoint string

	// token to use with AssumeRoleWithCustomToken
	token string

	// Role ARN to use
	roleArn string

	// Display credentials flag
	displayCreds bool

    /**
     * Sends a request to the remote endpoint.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSend(Request request) throws IOException;

    /**
     * Receives a response from the remote endpoint.
     *
     * @param response the response object to populate

        final String endpoint = getInitParameter("endpoint", null, String.class);
        if (StringUtil.isNotBlank(endpoint)) {
            // For fake-gcs-server or custom endpoint
            builder.setHost(endpoint);
            builder.setCredentials(NoCredentials.getInstance());
            if (logger.isDebugEnabled()) {
                logger.debug("Using custom GCS endpoint: {}", endpoint);
            }

        }

        if (StringUtil.isNotBlank(endpoint)) {
            // For fake-gcs-server or custom endpoint
            builder.setHost(endpoint);
            builder.setCredentials(NoCredentials.getInstance());
            if (logger.isDebugEnabled()) {
                logger.debug("Using custom GCS endpoint: {}", endpoint);
            }
        } else {

	}
	resp, err := client.Do(req)
	if err != nil {
		result.Error = err.Error()
		return result
	}
	defer xhttp.DrainBody(resp.Body)
	err = gob.NewDecoder(resp.Body).Decode(&result)
	// endpoint have been overwritten
	result.Endpoint = rp.String()
	if err != nil {
		result.Error = err.Error()
	}
	return result

from fastapi import FastAPI
from fastapi.testclient import TestClient


def main(some_arg, q: str | None = None):
    return {"some_arg": some_arg, "q": q}


endpoint = partial(main, "foo")

app = FastAPI()

app.get("/")(endpoint)


client = TestClient(app)


def test_partial():
    response = client.get("/?q=bar")
    data = response.json()