when(context.getConfig()).thenReturn(config);
        when(config.isDirectoryNotificationsEnabled()).thenReturn(false);

        // Create real lease manager for integration testing
        baseLeaseManager = new LeaseManager(context);
        directoryLeaseManager = new DirectoryLeaseManager(context, baseLeaseManager);
    }

    @AfterEach
    public void tearDown() throws Exception {

    class ImplementationTests {

        @Test
        @DisplayName("Test concrete implementation of FileNotifyInformation")
        void testConcreteImplementation() {
            // Create a simple implementation for testing
            FileNotifyInformation impl = new FileNotifyInformation() {
                private final int action = FileNotifyInformation.FILE_ACTION_MODIFIED;

        assertNotNull(readings);
        assertEquals(1, readings.size());
        assertEquals("TEST", readings.get(0));
    }

    /**
     * Test implementation of ReadingConverter for testing purposes
     */
    private static class TestReadingConverter implements ReadingConverter {

        private boolean initialized = false;
        private int initCount = 0;

        assertTrue(conn instanceof Handler.StorageURLConnection);
        Handler.StorageURLConnection storageConn = (Handler.StorageURLConnection) conn;

        // Use reflection to access private fields for testing
        assertEquals("mybucket", getField(storageConn, "bucketName"));
        assertEquals("path/to/object.txt", getField(storageConn, "objectName"));
    }

    /**

@ExtendWith(MockitoExtension.class)
@DisplayName("DcerpcMessage Tests")
class DcerpcMessageTest {

    @Mock
    private NdrBuffer mockBuffer;

    private TestDcerpcMessage message;

    // Concrete implementation for testing abstract DcerpcMessage
    private static class TestDcerpcMessage extends DcerpcMessage {
        private int opnumValue;

        public TestDcerpcMessage(int opnumValue) {
            this.opnumValue = opnumValue;

        // When/Then
        assertThrows(NullPointerException.class, () -> {
            new Type3Message((byte[]) null);
        });
    }

    /**
     * Helper method to create a mock Type 2 message for testing
     */
    private Type2Message createMockType2Message() {
        // Create a basic Type 2 message with challenge
        byte[] challenge = new byte[8];
        new SecureRandom().nextBytes(challenge);

                if (entry != null) {
                    entry.invalidate();
                }
                invalidateChildren(child);  // Recursive
            }
        }
    }
}
```

## 8. Testing Strategy

### 8.1 Unit Tests
```java
@Test
public void testDirectoryCacheEntry() {
    DirectoryCacheEntry entry = new DirectoryCacheEntry(

        Name mockRecordName = new Name(mockConfig);
        recordNameField.set(nameQueryResponse, mockRecordName);

        NbtAddress[] addresses = new NbtAddress[2];
        // Create dummy NbtAddress objects for testing toString
        addresses[0] = new NbtAddress(mockRecordName, 0xC0A80101, false, 0); // 192.168.1.1
        addresses[1] = new NbtAddress(mockRecordName, 0x0A000005, true, 1); // 10.0.0.5

        // Then
        assertEquals(0x71, command & 0xFF);
        assertEquals(ServerMessageBlock.SMB_COM_TREE_DISCONNECT, (byte) command);
    }

    /**
     * Nested class for testing buffer operations
     */
    @Nested
    @DisplayName("Buffer Operations Tests")
    class BufferOperationsTests {

        @Test
        @DisplayName("Test write operations with empty buffer")

class SmbComNtTransactionResponseTest {

    @Mock
    private Configuration mockConfig;

    private TestSmbComNtTransactionResponse response;

    // Concrete implementation for testing
    private static class TestSmbComNtTransactionResponse extends SmbComNtTransactionResponse {

        public TestSmbComNtTransactionResponse(Configuration config) {
            super(config);
        }