assertDoesNotThrow(() -> {
            // Validate that witness client configuration is properly set up
            assertTrue(mockConfig.isUseWitness() || !mockConfig.isUseWitness()); // Either state is valid
            assertTrue(mockConfig.getWitnessHeartbeatTimeout() > 0);
            assertTrue(mockConfig.getWitnessRegistrationTimeout() > 0);
            assertTrue(mockConfig.getWitnessReconnectDelay() >= 0);

        verify(mockConnection).connect();
        // Connection should be established after connect
    }

    /**
     * Test that disconnect() calls disconnect() on the underlying connection and resets state.
     */
    @Test
    void testDisconnect() throws Exception {
        // Act
        ntlmConnection.disconnect();

        // Assert
        verify(mockConnection).disconnect();

            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("getters and basic state (happy path)")
    void testGettersAndState() {
        SmbSessionImpl session = newSession();

        // Basic getters
        assertSame(configuration, session.getConfig(), "getConfig delegates to transportContext");

                this.usageCount.set(0);

                // Clear mutable references to free memory
                // Note: Some fields may be final and cannot be nulled

                // Clear any other mutable state would go here
            }
        } catch (Exception e) {
            log.error("Failed to perform emergency file handle cleanup", e);
        }
    }

    /**

     * Test for close() idempotency.
     * Verifies that calling close multiple times has the same effect as calling it once.
     */
    @Test
    void testClose_idempotency() {
        // Mock a tree that tracks close state
        SmbTree idempotentTree = mock(SmbTree.class);
        doNothing().when(idempotentTree).close();

        // Close multiple times
        idempotentTree.close();
        idempotentTree.close();

        this.fileProtocols = fileProtocols;
    }

    /**
     * Returns a string representation of this parser's current state.
     * Includes information about parsed label types and configuration objects.
     *
     * @return a string representation of the parser state
     */
    @Override
    public String toString() {

            this.createContexts = newContexts;
        }
    }

    /**
     * Add a lease V1 context to this request
     * @param leaseKey the lease key
     * @param requestedState the requested lease state
     */
    public void addLeaseV1Context(Smb2LeaseKey leaseKey, int requestedState) {
        LeaseV1CreateContextRequest leaseContext = new LeaseV1CreateContextRequest(leaseKey, requestedState);

        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join();
        }

        // All threads should see the initialized state
        for (boolean result : initResults) {
            assertTrue("Client should be initialized after concurrent access", result);
        }
    }

    public void test_accessTimeout_null_safety() {

        assertEquals("server.example.com", testImplementation.getServer());
    }

    @Test
    @DisplayName("Test resolve in DFS flag toggles")
    void testResolveInDfsToggle() {
        // Initial state should be false
        assertFalse(testImplementation.isResolveInDfs());

        // Toggle to true
        testImplementation.setResolveInDfs(true);
        assertTrue(testImplementation.isResolveInDfs());

     * Test that pre-auth hash is reset on error
     */
    @Test
    @DisplayName("Pre-auth integrity hash should reset on error")
    void testPreauthHashResetOnError() throws Exception {
        // Setup invalid SMB2 state to trigger error
        setPrivateField(transport, "smb2", false);

        // Try to update preauth hash - should fail and reset