});
    }

    @Test
    @DisplayName("Should get server")
    void testGetServer() {
        // Given
        String server = "testserver";
        when(mockReferralData.getServer()).thenReturn(server);

        // When
        String result = mockReferralData.getServer();

        // Then
        assertEquals(server, result);
        verify(mockReferralData).getServer();
    }

    @Test

            if (expandedNames.length > 0) {
                dr.server = expandedNames[0].substring(1).toLowerCase();
            } else {
                dr.server = ref.getSpecialName().substring(1).toLowerCase();
            }
            if (log.isDebugEnabled()) {
                log.debug("Server " + dr.server + " path " + reqPath + " remain " + reqPath.substring(consumed) + " path consumed "

    participant Proxy as Proxy/Loadbalancer
    participant Server as FastAPI Server

    Client->>Proxy: HTTPS-Request<br/>Host: mysuperapp.com<br/>Pfad: /items

    Note over Proxy: Proxy fügt Forwarded-Header hinzu

    Proxy->>Server: HTTP-Request<br/>X-Forwarded-For: [client IP]<br/>X-Forwarded-Proto: https<br/>X-Forwarded-Host: mysuperapp.com<br/>Pfad: /items

	}
	return hosts, listeners, err
}

func startHTTPServer(listener net.Listener, handler http.Handler) (server *httptest.Server) {
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener
	server.Start()
	return server
}

func dummyRequestValidate(r *http.Request) error {
	return nil
}

```
curl http://minio1:9001/minio/health/cluster?maintenance=true
HTTP/1.1 412 Precondition Failed
Accept-Ranges: bytes
Content-Length: 0
Server: MinIO
Vary: Origin
X-Amz-Bucket-Region: us-east-1
X-Amz-Request-Id: 16239D63820C6E76

        LsaPolicyHandle handle = new LsaPolicyHandle(mockDcerpcHandle, server, access);

        // Assert
        assertNotNull(handle);
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
    }

    @Test
    void constructor_shouldHandleNullServerSuccessfully() throws IOException {
        // Arrange
        String server = null;
        int access = 123;

        doAnswer(invocation -> {

  @StartStop
  private val server = MockWebServer()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private val listener = EventSourceRecorder()
  private val client = clientTestRule.newClient()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun processResponse() {
    server.enqueue(
      MockResponse
        .Builder()

class DcerpcBindingTest {

    private DcerpcBinding dcerpcBinding;
    private static final String PROTO = "ncacn_np";
    private static final String SERVER = "testServer";

    @BeforeEach
    void setUp() {
        dcerpcBinding = new DcerpcBinding(PROTO, SERVER);
        // Initialize static INTERFACES map for tests
        DcerpcBinding.addInterface("srvsvc", "4B324FC8-1670-01D3-1278-5A47BF6EE188:3.0");

## Explore Further

- [Use `mc` with MinIO Server](https://docs.min.io/community/minio-object-store/reference/minio-mc.html)
- [Use `aws-cli` with MinIO Server](https://docs.min.io/community/minio-object-store/integrations/aws-cli-with-minio.html)
- [Use `minio-go` SDK with MinIO Server](https://docs.min.io/community/minio-object-store/developers/go/minio-go.html)

     * @param server the server data containing security information
     * @param path the UNC path to the shared resource
     * @param service the service type (e.g., "A:" for disk share, "LPT1:" for printer)
     * @param andx the next command in the AndX chain, or null
     */
    public SmbComTreeConnectAndX(final CIFSContext ctx, final ServerData server, final String path, final String service,