// Act & Assert
        assertTrue(transport.hasCapability(SmbConstants.CAP_DFS));
        verify(nego, times(1)).haveCapabilitiy(SmbConstants.CAP_DFS);
    }

    @Test
    @DisplayName("SMB version detection via flag or response type")
    void isSMB2_variants() throws Exception {
        // 1) smb2 flag set
        setField(transport, "smb2", true);
        assertTrue(transport.isSMB2());

  }

  @Test
  fun setResponseMockReason() {
    val reasons =
      arrayOf(
        "Mock Response",
        "Informational",
        "OK",
        "Redirection",
        "Client Error",
        "Server Error",
        "Mock Response",
      )
    for (i in 0..599) {
      val response = MockResponse().setResponseCode(i)
      val expectedReason = reasons[i / 100]

 *
 * <p>Features:
 * <ul>
 *   <li>Automatic initialization of MinIO client</li>
 *   <li>Support for HEAD and GET operations</li>
 *   <li>Content length validation</li>
 *   <li>MIME type detection</li>
 *   <li>Handling of large files through temporary file storage</li>
 *   <li>Object metadata and tags retrieval</li>
 *   <li>Directory listing capabilities</li>
 * </ul>
 *

			req.Header.Set(k, v)
		}
		if testCase.metadataReplace {
			req.Header.Set("X-Amz-Metadata-Directive", "REPLACE")
		}
		if testCase.metadataCopy {
			req.Header.Set("X-Amz-Metadata-Directive", "COPY")
		}
		if testCase.metadataGarbage {
			req.Header.Set("X-Amz-Metadata-Directive", "Unknown")
		}
		// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.

		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrInvalidMetadataDirective: {
		Code:           "InvalidArgument",
		Description:    "Unknown metadata directive.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrInvalidStorageClass: {
		Code:           "InvalidStorageClass",
		Description:    "Invalid storage class.",
		HTTPStatusCode: http.StatusBadRequest,
	},

But before setting the *CLI Option* `--forwarded-allow-ips` it could redirect to `http://localhost:8000/items/`.

But maybe your application is hosted at `https://mysuperapp.com`, and the redirection should be to `https://mysuperapp.com/items/`.

By setting `--proxy-headers` now FastAPI would be able to redirect to the right location. 😎

```
https://mysuperapp.com/items/
```

/// tip

      //
      // We use two volatile reads. We could reduce this to one by
      // putting our fields into a holder class, but (at least on x86)
      // the extra memory consumption and indirection are more
      // expensive than the extra volatile reads.
      long nanos = expirationNanos;
      long now = System.nanoTime();
      if (nanos == 0 || now - nanos >= 0) {
        synchronized (lock) {

        assertTrue(locator("smb://server/IPC$/").isIPC());
        assertTrue(locator("smb://server/").isIPC());
        assertFalse(locator("smb://server/share/").isIPC());
    }

    @Test
    @DisplayName("Type detection covers filesystem/share/IPC/workgroup/server")
    void testGetType() throws Exception {
        // Filesystem when there is a path beyond share

  }

  @Test
  fun setResponseMockReason() {
    val reasons =
      arrayOf<String?>(
        "Mock Response",
        "Informational",
        "OK",
        "Redirection",
        "Client Error",
        "Server Error",
        "Mock Response",
      )
    for (i in 0..599) {
      val builder = MockResponse.Builder().code(i)
      val expectedReason = reasons[i / 100]

    /**
     * Execute an operation with circuit breaker protection and custom error handling
     *
     * @param <T> return type
     * @param operation the operation to execute
     * @param isFailure custom failure detection
     * @return operation result
     * @throws CIFSException if circuit is open or operation fails
     */