// Given
        when(request.isResponseAsync()).thenReturn(true);
        when(request.getNext()).thenReturn(nextRequest);
        when(request.split()).thenReturn(nextRequest);
        when(request.allowChain(nextRequest)).thenReturn(true);
        when(request.createCancel()).thenReturn(nextRequest);
        when(request.size()).thenReturn(1024);
        when(request.getOverrideTimeout()).thenReturn(5000);

        // Ensure environment variables are not set (in real scenario)
        // In this test, we expect IOException when project ID is blank
        try {
            conn.connect();
            fail("Should throw IOException when project ID is not set");
        } catch (IOException e) {
            assertTrue(e.getMessage().contains("GCS_PROJECT_ID is blank"));
        }
    }

        // Given
        Configuration mockConfig = mock(Configuration.class);
        CIFSContext mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When
        Smb2TreeDisconnectResponse response = request.createResponse(mockContext, request);

        // Then
        assertNotNull(response);

        @DisplayName("Should return root cause when set")
        void testGetRootCause() {
            Exception rootCause = new IllegalStateException("Test root cause");
            TransportException exception = new TransportException("Message", rootCause);

            assertEquals(rootCause, exception.getRootCause());
        }

        @Test
        @DisplayName("Should return null when no root cause")

        SMBUtil.writeInt2(4, buffer, 0);
        SMBUtil.writeInt2(0, buffer, 2);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then
        assertEquals(4, bytesRead);
    }

    @Test
    @DisplayName("Should throw exception when buffer too small for reading")
    void testReadBytesWireFormatBufferTooSmall() {
        // Given

     */
    @Test
    @DisplayName("Test constructor with mock configuration")
    public void testConstructorWithMockConfig() {
        // Setup mock to return a valid PID
        when(mockConfig.getPid()).thenReturn(1234);

        // When
        smbComTreeDisconnect = new SmbComTreeDisconnect(mockConfig);

        // Then
        assertNotNull(smbComTreeDisconnect);

    @Test
    @DisplayName("Should create SmbException with NT status code")
    void testSmbExceptionWithNTStatus() {
        // Given
        int ntStatus = NtStatus.NT_STATUS_ACCESS_DENIED;

        // When
        SmbException exception = new SmbException(ntStatus, false);

        // Then
        assertNotNull(exception);
        assertEquals(ntStatus, exception.getNtStatus());

        List<UrlQueueImpl<Long>> newUrlList = new ArrayList<>();
        newUrlList.add(newUrl1);
        newUrlList.add(newUrl2);

        when(dataHelper.getUrlQueueList(sessionId)).thenReturn(existingQueue);
        when(dataHelper.getAccessResultMap(sessionId)).thenReturn(accessResultMap);

        // Execute
        service.offerAll(sessionId, newUrlList);

        // Verify

import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

        new SecureRandom().nextBytes(signature);

        // When
        transformHeader.setSignature(signature);

        // Then
        assertArrayEquals(signature, transformHeader.getSignature());
    }

    @Test
    @DisplayName("Should set and get nonce")
    void testNonce() {
        // When
        transformHeader.setNonce(testNonce);

        // Then