void nameFilterAccepts(String acceptedName) throws Exception {
        // Arrange
        stubAcquireReturnsSelf();
        when(nameFilter.accept(any(), any())).thenReturn(false);
        when(nameFilter.accept(parent, acceptedName)).thenReturn(true);

        FileEntry initial = entry("first");

      }

    /**
     * Sets the default connect timeout for new connections. A value of 0 means no timeout,
     * otherwise values must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The connect timeout is applied when connecting a TCP socket to the target host. The default
     * value is 10 seconds.
     */
    fun connectTimeout(
      timeout: Long,
      unit: TimeUnit,

        // Assert
        assertEquals(msg, ex.getMessage(), "Constructor should preserve the provided message (including null)");
        assertNull(ex.getCause(), "No cause expected when only message is provided");

        // toString behavior mirrors Throwable: includes message when not null
        String ts = ex.toString();
        assertTrue(ts.contains("SmbUnsupportedOperationException"), "toString should contain class name");
        if (msg != null) {

    value: T?,
  ): Tags {
    // Create a copy of this `LinkedTags` that doesn't have a mapping for `key`.
    val thisMinusKey =
      when {
        key == this.key -> next // Subtract this!

        else -> {
          val nextMinusKey = next.plus(key, null)
          when {
            nextMinusKey === next -> this // Same as the following line, but with fewer allocations.

     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to
     * {@code workerRunningState} will be available synchronously, and behaviour will be
     * deterministic.

     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to
     * {@code workerRunningState} will be available synchronously, and behaviour will be
     * deterministic.

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        // Setup
    }

    public void test_method_scenario() throws Exception {
        // Given
        // When
        // Then
    }
}
```

**Coverage Goal**: >80% line coverage

### Contributing

1. Fork repo
2. Create feature branch (`feature/amazing-feature`)
3. Make focused commits
4. Add tests

    headers[":authority"]
      ?: headers["Host"]
      ?: when (val inetAddress = socket.localAddress) {
        is Inet6Address -> "[${inetAddress.hostAddress}]:${socket.localPort}"
        else -> "${inetAddress.hostAddress}:${socket.localPort}"
      }

  // For OPTIONS, the request target may be a '*', like 'OPTIONS * HTTP/1.1'.
  val path =
    when {
      requestLine.method == "OPTIONS" && requestLine.target == "*" -> "/"

    @DisplayName("openConnection returns SmbFile using provided CIFSContext")
    void testOpenConnection_UsesProvidedContext() throws MalformedURLException, IOException {
        // Arrange
        when(mockCtx.getConfig()).thenReturn(mockCfg);
        when(mockCfg.isTraceResourceUsage()).thenReturn(false);

        Handler handler = newHandlerWith(mockCtx);
        URL url = new URL(null, "smb://example-host/share/", new Handler());

        // Act

        assertTrue(resp.isLoggedInAsGuest(), "Guest/anonymous should be detected");

        // prepare should propagate session id when received
        CIFSContext mockCtx = mock(CIFSContext.class);
        when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));
        Smb2SessionSetupRequest nextReq = new Smb2SessionSetupRequest(mockCtx, 0, 0, 0L, null);