headerStartField.setAccessible(true);
        headerStartField.set(response, 0);

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

        // Then
        // When dataLength is 0, it returns max(16, dataOffset + 0 - bodyStart) = max(16, 80) = 80
        assertEquals(80, bytesRead);
        assertEquals(0, response.getDataLength());

            // When/Then: Should throw DcerpcException for invalid URLs
            assertThrows(DcerpcException.class, () -> DcerpcHandle.parseBinding(url));
        }

        @Test
        @DisplayName("Should handle binding URLs without endpoints correctly")
        void testParseBindingWithoutEndpoint() {
            // When/Then: URLs without proper endpoints should fail

        lenient().when(mockSmbNamedPipe.openPipe()).thenReturn(mockSmbPipeHandle);
        lenient().when(mockSmbPipeHandle.unwrap(SmbPipeHandleInternal.class)).thenReturn(mockSmbPipeHandleInternal);
        lenient().when(mockSmbNamedPipe.getContext()).thenReturn(mockContext);
        lenient().when(mockSmbNamedPipe.getLocator()).thenReturn(mockSmbResourceLocator);

        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then
        assertDoesNotThrow(() -> {
            mockBufferCache.releaseBuffer(buffer);
        }, "releaseBuffer should handle valid buffers");
    }

    @Test
    @DisplayName("getBuffer should return buffers for use")
    void testGetBufferBasicUsage() {
        // When
        byte[] buffer1 = testCache.getBuffer();

    void testMessageConstructor() {
        // Given & When
        CIFSUnsupportedCryptoException exception = new CIFSUnsupportedCryptoException(CRYPTO_ERROR_MESSAGE);

        // Then
        assertEquals(CRYPTO_ERROR_MESSAGE, exception.getMessage(), "Message should be preserved");
        assertNull(exception.getCause(), "Cause should be null when not specified");
    }

    @ParameterizedTest

        when:
        def p = propertyMetaData.overriddenProperty

        then:
        p == null
    }

    def hasNoOverriddenPropertyWhenGetterAndSetterDoNotOverrideAnything() {
        when:
        def p = propertyMetaData.overriddenProperty

        then:
        p == null
    }

    def "is deprecated when @Deprecated is attached to property"() {

    def hasNoOverriddenMethodWhenNoSuperClass() {
        when:
        def m = method.overriddenMethod

        then:
        m == null
        _ * owner.superClass >> null
        _ * owner.interfaces >> []
    }

    def hasNoOverriddenMethodWhenMethodDoesNotOverrideMethodInSuperClass() {
        ClassMetaData superClassMetaData = Mock()

        when:
        def m = method.overriddenMethod

    void testInterfaceMock() {
        // Given
        when(mockBasicFileInfo.getAttributes()).thenReturn(TEST_ATTRIBUTES);
        when(mockBasicFileInfo.getCreateTime()).thenReturn(TEST_CREATE_TIME);
        when(mockBasicFileInfo.getLastWriteTime()).thenReturn(TEST_LAST_WRITE_TIME);
        when(mockBasicFileInfo.getLastAccessTime()).thenReturn(TEST_LAST_ACCESS_TIME);
        when(mockBasicFileInfo.getSize()).thenReturn(1024L);

        // Given
        String filename = "testFile.txt";
        int informationLevel = 0x0100; // SMB_QUERY_FILE_BASIC_INFO

        // When
        Trans2QueryPathInformation trans = new Trans2QueryPathInformation(filename, informationLevel);

        // Then
        assertEquals(filename, trans.path, "The path should be set correctly.");

        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true);
        when(pipe.openUnshared(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(fileHandle);
        when(fileHandle.acquire()).thenReturn(fileHandle);
        when(fileHandle.getTree()).thenReturn(tree);