assertEquals(12345L, size);

        // Verify precise interactions
        verify(mockEntry, times(1)).getName();
        verify(mockEntry, times(2)).getType();
        verify(mockEntry, times(1)).getAttributes();
        verify(mockEntry, times(1)).createTime();
        verify(mockEntry, times(1)).lastModified();
        verify(mockEntry, times(1)).lastAccess();
        verify(mockEntry, times(1)).length();

        ndrLong.decode(mockNdrBuffer);

        // Verify that dec_ndr_long was called exactly once
        verify(mockNdrBuffer, times(1)).dec_ndr_long();
        // Verify that the value field was updated correctly
        assertEquals(decodedValue, ndrLong.value, "Decode should correctly assign the value returned by dec_ndr_long.");
        // Verify that no other interactions occurred with the mock buffer

        // Unwrap then close both
        CustomSmbTree unwrapped = smbTree.unwrap(CustomSmbTree.class);
        smbTree.close();
        unwrapped.close();

        verify(smbTree).unwrap(CustomSmbTree.class);
        verify(smbTree).close();
        verify(customTree).close();
    }

    /**
     * Custom SmbTree interface for testing unwrap functionality.
     */
    interface CustomSmbTree extends SmbTree {

            strategy.apply(context, pomMap);

            // Verify child groupId was removed (matches parent, can be inferred)
            assertNull(childRoot.child("groupId").orElse(null));
            // Verify child version was kept (differs from parent, cannot be inferred)
            assertNotNull(childRoot.child("version").orElse(null));
            // Verify child artifactId was kept (always required)

        // Create buffer for encoding
        byte[] buffer = new byte[16];
        int bytesWritten = info.encode(buffer, 0);

        // Verify bytes written
        assertEquals(8, bytesWritten);

        // Verify encoded value
        long decodedValue = SMBUtil.readInt8(buffer, 0);
        assertEquals(endOfFile, decodedValue);
    }

    @Test

        NdrSmall ndrSmall = new NdrSmall(0);

        // Call the decode method
        ndrSmall.decode(mockNdrBuffer);

        // Verify that dec_ndr_small was called
        verify(mockNdrBuffer, times(1)).dec_ndr_small();
        // Verify that the value field was updated correctly
        assertEquals(decodedValue, ndrSmall.value, "Value should be updated after decoding.");

        // Verify bytes written
        assertEquals(24, written);

        // Verify structure size (should be 24)
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

        // Verify Reserved1 (2 bytes at offset+2, should be 0)
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved2 (4 bytes at offset+4, should be 0)

        // Create exception with default constructor
        TransportException exception = new TransportException();

        // Verify the exception is created and has no message
        assertNotNull(exception);
        assertNull(exception.getMessage());
        assertNull(exception.getCause());

        // Verify it's an instance of CIFSException
        assertTrue(exception instanceof CIFSException);
    }

    @Test

        assertArrayEquals(testKey.getKey(), encodedKey);

        // Verify lease state at offset 40 (24 + 16 for key)
        assertEquals(testState, SMBUtil.readInt4(buffer, 40));

        // Verify lease flags at offset 44 (40 + 4 for state)
        assertEquals(0, SMBUtil.readInt4(buffer, 44));

        // Verify lease duration at offset 48 (44 + 4 for flags) - should be 0 (reserved)

            assertEquals(Integer.MAX_VALUE, request3.getContextType());
        }

        @Test
        @DisplayName("Should verify interface is Encodable")
        void testEncodableInterface() {
            NegotiateContextRequest request = new TestNegotiateContextRequest(1);

            // Verify the interface extends Encodable
            assertNotNull(request);
            assertTrue(request instanceof jcifs.Encodable);
        }