// that happens, then we will have buffered bytes that are needed by the SSLSocket!
        // This check is imperfect: it doesn't tell us whether a handshake will succeed, just
        // that it will almost certainly fail because the proxy has sent unexpected data.
        if (!socket.source.buffer.exhausted() || !socket.sink.buffer.exhausted()) {

    void calculateMIC_nullData() {
        assertThrows(NullPointerException.class, () -> ctx.calculateMIC(null));
    }

    @Test
    @DisplayName("verifyMIC delegates to GSS and succeeds")
    void verifyMIC_success() throws Exception {
        byte[] data = new byte[] { 1, 2 };
        byte[] mic = new byte[] { 3 };
        // No exception means success

                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");
        executor.shutdown();

        assertEquals(threadCount * operationsPerThread, successCount.get(), "All operations should succeed");
    }

    @Test
    public void testRemoveSessionKeyWithArchives() throws GeneralSecurityException {
        String sessionId = "remove-with-archives";

            // Arrange
            doReturn(true).when(smbFile).exists();
            doReturn(true).when(smbFile).isDirectory();
            doNothing().when(smbFile).mkdir();

            // Act & Assert - mkdir should succeed silently if directory already exists
            smbFile.mkdir();
        }

        @Test
        void testRenameToSameFile() throws MalformedURLException, SmbException {
            // Arrange

        // This tests that the implementation properly handles list modifications
        try {
            notifications.clear();
            // If this succeeds, the implementation allows modification
            assertTrue(notifications.isEmpty());
        } catch (UnsupportedOperationException e) {
            // If this throws, the implementation returned an immutable list

            netServerEnum2.writeParametersWireFormat(dst, 0);
        });
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with large buffer succeeds")
    void testWriteParametersWireFormatLargeBuffer() {
        String domain = "DOMAIN";
        netServerEnum2 = new NetServerEnum2(realConfig, domain, NetServerEnum2.SV_TYPE_ALL);

    }

    @Test
    @DisplayName("getSmbSession creates and then reuses matching session")
    void getSmbSession_createAndReuse() {
        // Arrange: minimal credentials chain so SmbSessionImpl constructor succeeds
        CredentialsInternal creds = mock(CredentialsInternal.class);
        when(ctx.getCredentials()).thenReturn(creds);
        when(creds.unwrap(CredentialsInternal.class)).thenReturn(creds);

            onDependencyCancel = FailureAction.FAIL_TO_START
        }
    }
}

fun Dependencies.compileAllDependency(compileAllId: String) {
    // Compile All has to succeed before anything else is started
    dependsOn(RelativeId(compileAllId))
    // Get the build receipt from sanity check to reuse the timestamp
    artifacts(RelativeId(compileAllId)) {

            // Encode to different buffers
            int result1 = request.encode(buffer1, 0);
            int result2 = request.encode(buffer2, 50);

            // Both should succeed independently
            assertTrue(result1 > 0);
            assertTrue(result2 > 0);

            // Verify headers in both buffers
            for (int i = 0; i < 8; i++) {