assertTrue(methodNames.contains("getConfig"), "Should contain getConfig method");
            assertTrue(methodNames.contains("unwrap"), "Should contain unwrap method");
            assertTrue(methodNames.contains("getContext"), "Should contain getContext method");
        }

        @Test
        @DisplayName("Should be a public interface")

        }

        @Test
        @DisplayName("Should throw exception on null buffer")
        void testEncodeWithNullBuffer() {
            assertThrows(IllegalArgumentException.class, () -> testRequest.encode(null, 0), "Should throw exception for null buffer");
        }

        @Test
        @DisplayName("Should throw exception on negative index")
        void testEncodeWithNegativeIndex() {

    }

    @Test
    @DisplayName("DCE/RPC flags should be set correctly")
    void testDcerpcFlags() {
        // Test individual flag checking
        assertTrue(dfsRootEnum.isFlagSet(DcerpcConstants.DCERPC_FIRST_FRAG));
        assertTrue(dfsRootEnum.isFlagSet(DcerpcConstants.DCERPC_LAST_FRAG));

        // Combined flags should equal FIRST_FRAG | LAST_FRAG

        }

        @Test
        @DisplayName("Should create instance with null ciphers")
        void testConstructorWithNullCiphers() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, null);

            assertNotNull(context);
            assertNull(context.getCiphers());
        }

        @Test
        @DisplayName("Should create instance with empty ciphers array")

        }

        @Test
        @DisplayName("Should initialize DfsReferralResponseBuffer")
        void testDfsResponseBufferInitialization() {
            assertNotNull(response.getDfsResponse());
            assertTrue(response.getDfsResponse() instanceof DfsReferralResponseBuffer);
        }

        @Test
        @DisplayName("Should throw NullPointerException with null configuration")

        assertEquals(4, written, "Setup should write 4 bytes");
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0], "First byte should be subCommand");
        assertEquals(0, dst[1], "Second byte should be 0");
        assertEquals(0, dst[2], "Third byte should be 0 (no FID)");
        assertEquals(0, dst[3], "Fourth byte should be 0 (no FID)");
    }

    @Test

        assertEquals(SmbComTransaction.SMB_COM_TRANSACTION2, cmd.command, "command should be TRANSACTION2");
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, cmd.subCommand, "subCommand should be QUERY_FS_INFORMATION");
        // the fields are set in the constructor – check that the counts match
        assertEquals(2, cmd.totalParameterCount, "totalParameterCount should be 2");
        assertEquals(0, cmd.totalDataCount, "totalDataCount should be 0");

        @Test
        @DisplayName("Should initialize remaining to zero")
        void testInitialRemainingValue() {
            assertEquals(0, response.getRemaining());
        }
    }

    @Nested
    @DisplayName("Getter Tests")
    class GetterTests {

        @Test
        @DisplayName("Should get count value")
        void testGetCount() {
            // Initial value should be 0

        LogStream instance2 = LogStream.getInstance();

        // Each setInstance should create a new LogStream
        assertNotNull(instance1);
        assertNotNull(instance2);
        // The second setInstance replaces the first, so they should not be the same
        assertNotSame(instance1, instance2);
        // Getting instance again should return the same as instance2
        assertSame(instance2, LogStream.getInstance());
    }

        // Manually unblock
        assertTrue(rateLimiter.unblockIp(ip), "Manual unblock should succeed");

        // Should be allowed again
        assertTrue(rateLimiter.checkAttempt("user7", ip), "Should be allowed after manual unblock");
    }

    @Test
    public void testNullUsername() throws Exception {
        // Null username should be handled gracefully