when(filterConfig.getInitParameter(anyString())).thenAnswer(invocation -> initParams.get(invocation.getArgument(0)));

        filter.init(filterConfig);

        // Test request over insecure connection
        when(request.getHeader("Authorization")).thenReturn(null);
        when(request.isSecure()).thenReturn(false);
        when(httpSession.getAttribute("NtlmHttpAuth")).thenReturn(null);

 * HTTP/2 support allows all requests to the same host to share a socket.
 * Connection pooling reduces request latency (if HTTP/2 isn’t available).
 * Transparent GZIP shrinks download sizes.
 * Response caching avoids the network completely for repeat requests.

OkHttp perseveres when the network is troublesome: it will silently recover from common connection

          else -> "GET"
        },
        body,
      ),
  )

  init {
    val connectionHeader = headers["Connection"]
    require(body == null || !"upgrade".equals(connectionHeader, ignoreCase = true)) {
      "expected a null request body with 'Connection: upgrade'"
    }
  }

  fun header(name: String): String? = headers[name]

  fun headers(name: String): List<String> = headers.values(name)

        }
    }
    
    // Request new durable handle if configured
    if (context.getConfig().isUseDurableHandles()) {
        requestDurableHandle();
    }
    
    // ... rest of normal connection logic ...
}

private void requestDurableHandle() {
    Configuration config = context.getConfig();
    
    // Determine handle type based on configuration and server capabilities

    if (witnessClient != null) {
        witnessClient.close();
    }
    super.logoff();
}
```

### 5.2 Tree Connection Integration
```java
// In SmbTree.java
public void connectWithWitnessSupport() throws IOException {
    // Perform normal tree connection
    super.connect();
    
    // Register for witness notifications for this share
    if (session.isWitnessEnabled()) {

    int RPC_PT_CANCEL = 0x12;
    /**
     * Acknowledgment packet type
     */
    int RPC_PT_ACK = 0x13;
    /**
     * Reject packet type
     */
    int RPC_PT_REJECT = 0x14;
    /**
     * Connection-oriented cancel packet type
     */
    int RPC_PT_CO_CANCEL = 0x15;
    /**
     * Orphaned packet type
     */
    int RPC_PT_ORPHANED = 0x16;

    // RPC_C_PF_ flags (packet flags)
    /**

                clientSocket.close();
            } catch (IOException e) {
                if (running.get()) {
                    log.debug("Error accepting client connection", e);
                }
            }
        }
    }

    @Override
    public void close() {
        stop();
    }

    /**

        SearchEngineClient searchEngineClient = new SearchEngineClient() {
            @Override
            public PingResponse ping() {
                throw new RuntimeException("Connection failed");
            }
        };

        SystemHelper systemHelper = new SystemHelper() {
            @Override
            public String getHostname() {
                return "test-hostname";

     * Default buffer size for change notification responses.
     */
    int DEFAULT_NOTIFY_BUF_SIZE = 1024;

    /**
     * Default maximum number of sessions per transport connection.
     */
    int DEFAULT_SSN_LIMIT = 250;
    /**
     * Default connection timeout in milliseconds.
     */
    int DEFAULT_CONN_TIMEOUT = 35000;

    /**
     * No flags set in SMB header.
     */
    int FLAGS_NONE = 0x00;
    /**

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import assertk.assertThat
import assertk.assertions.containsExactlyInAnyOrder
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isTrue