byte[] data = new byte[8];
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);

        // Test with a positive value
        buffer.putInt(0, 0x12345678);
        assertEquals(0x12345678, NtlmMessage.readULong(data, 0), "Should read positive ULong correctly.");

        // Test with zero
        buffer.putInt(0, 0);

        verifyNoMoreInteractions(smbFile);
    }

    @Test
    @DisplayName("accept: length-based filter evaluates negative/zero/positive sizes")
    void accept_lengthBasedFilter_handlesNumericEdges() throws Exception {
        // Arrange: filter that accepts only strictly positive length
        SmbFileFilter filter = f -> f.length() > 0;

        // negative size -> reject
        when(smbFile.length()).thenReturn(-1L);

            // Test that other generic rights are positive
            assertTrue(ACE.GENERIC_ALL > 0, "GENERIC_ALL should be positive");
            assertTrue(ACE.GENERIC_EXECUTE > 0, "GENERIC_EXECUTE should be positive");
            assertTrue(ACE.GENERIC_WRITE > 0, "GENERIC_WRITE should be positive");

            // Test ordering (corrected for actual bit values)

import org.junit.jupiter.api.Test;

public class AvFlagsTest {

    /**
     * Test constructor with raw bytes.
     */
    @Test
    void testAvFlagsByteArrayConstructor() {
        // Test with a positive integer
        byte[] rawBytes = new byte[] { 0x01, 0x02, 0x03, 0x04 }; // Represents 0x04030201 (little-endian)
        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");

        assertEquals(AvPair.MsvAvTimestamp, avTimestamp.getType());
        assertEquals(timestamp, avTimestamp.getTimestamp()); // Verify encoding and decoding
    }

    /**
     * Test getTimestamp method with a positive timestamp.
     */
    @Test
    public void testGetTimestampPositive() {
        long expectedTimestamp = 123456789012345L;
        byte[] rawBytes = new byte[8];

    }

    @Test
    void constructor_shouldInitializeValueCorrectly() {
        // Test case 1: Positive value
        int positiveValue = 12345;
        NdrLong ndrLongPositive = new NdrLong(positiveValue);
        assertEquals(positiveValue, ndrLongPositive.value, "Constructor should correctly initialize with a positive value.");

        // Test case 2: Negative value
        int negativeValue = -54321;

     */
    int getLineNumber();

    /**
     * Gets the one-based index of the column containing the problem. The column number should refer to some text file
     * that is given by {@link #getSource()}.
     *
     * @return The one-based index of the column containing the problem or non-positive value if unknown.
     */
    int getColumnNumber();

        for (Field field : fields) {
            if (field.getType() == int.class) {
                int value = field.getInt(null);
                // All values should be positive
                assertTrue(value > 0, "Constant " + field.getName() + " should have positive value");
                // Values should be within reasonable range for security flags

        // Verify latency calculations
        assertTrue(stats.getAverageReadLatencyMicros() > 0, "Read latency should be positive");
        assertTrue(stats.getAverageWriteLatencyMicros() > 0, "Write latency should be positive");

        System.out.println("RDMA Statistics: " + stats);

        // Test statistics reset functionality
        stats.reset();

        RdmaMemoryRegion region = bufferManager.getReceiveRegion();
        assertNotNull(region, "Receive region should not be null");
        assertTrue(region.getSize() > 0, "Region should have positive size");
        assertTrue(region.hasAccess(RdmaAccess.LOCAL_WRITE), "Should have local write access");
        assertTrue(region.hasAccess(RdmaAccess.REMOTE_WRITE), "Should have remote write access");