verify(transport, times(1)).acquire();
    }

    @Test
    @DisplayName("close/release manage usage and transport lifecycle")
    void testReleaseLifecycle() {
        SmbSessionImpl session = newSession();

        // First release drops usage to zero and releases transport
        session.release();
        verify(transport, times(1)).release();

        assertEquals(testScope, mockNetbiosName.getScope());
        assertEquals(testType, mockNetbiosName.getNameType());

        // Verify all methods were called
        verify(mockNetbiosName).getName();
        verify(mockNetbiosName).getScope();
        verify(mockNetbiosName).getNameType();
    }

    @Test
    @DisplayName("Should handle interface method contracts")
    void testMethodContracts() {

        int dstIndex = 5; // Start at offset 5
        int bytesEncoded = fileInternalInfo.encode(destinationBuffer, dstIndex);

        // Verify
        assertEquals(8, bytesEncoded);
        assertEquals(expectedIndexNumber, SMBUtil.readInt8(destinationBuffer, dstIndex));

        // Verify surrounding bytes are untouched
        for (int i = 0; i < dstIndex; i++) {
            assertEquals(0, destinationBuffer[i]);
        }

        verify(request, times(1)).isResponseAsync();
        verify(request, times(1)).getNext();
        verify(request, times(1)).split();
        verify(request, times(1)).allowChain(nextRequest);
        verify(request, times(1)).createCancel();
        verify(request, times(1)).size();
        verify(request, times(1)).getOverrideTimeout();
    }

    @Test

        assertEquals(3, entries.length);

        // Verify disk share
        assertEquals("DiskShare", entries[0].getName());
        assertEquals(8, entries[0].getType()); // TYPE_SHARE

        // Verify printer share
        assertEquals("PrinterShare", entries[1].getName());
        assertEquals(32, entries[1].getType()); // TYPE_PRINTER (0x20)

        // Verify named pipe

	// Get the encoded query.
	encodedQuery := query.Encode()

	// Verify if date query is same.
	if req.Form.Get(xhttp.AmzDate) != query.Get(xhttp.AmzDate) {
		return ErrSignatureDoesNotMatch
	}
	// Verify if expires query is same.
	if req.Form.Get(xhttp.AmzExpires) != query.Get(xhttp.AmzExpires) {
		return ErrSignatureDoesNotMatch
	}
	// Verify if signed headers query is same.

        // Prepare test data
        byte[] buffer = createValidBuffer("testfile.txt", "TEST~1.TXT", true);

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify
        assertEquals("testfile.txt", fileBothDirectoryInfo.getName());
    }

    @Test
    @DisplayName("Test getType returns TYPE_FILESYSTEM")
    void testGetType() {

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import java.util.function.Supplier;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;

        // Act
        boolean result = filter.accept(smbFile);

        // Assert
        assertTrue(result, "Directory should be accepted");
        verify(smbFile, times(1)).isDirectory();
        verify(smbFile, never()).getName();
        verifyNoMoreInteractions(smbFile);
    }

    @Test
    @DisplayName("accept: returns false for non-directories")

            assertEquals(0x01, SMBUtil.readInt4(buffer, headerStart + 44)); // Write flags

            // Verify data offset is written correctly
            int dataOffsetValue = SMBUtil.readInt2(buffer, headerStart + 2);
            assertEquals(headerStart - 0 + 48, dataOffsetValue); // Assuming getHeaderStart() returns 0

            // Verify data is copied