ByteBuffer buffer = ByteBuffer.allocate(24);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(Long.MAX_VALUE);
            buffer.putLong(Long.MAX_VALUE);
            buffer.putInt(Integer.MAX_VALUE);
            buffer.putInt(Integer.MAX_VALUE);
            byte[] bufferArray = buffer.array();

            // When

            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 8); // Max times
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 16);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 24);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 32);
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 40); // Max allocation size
            SMBUtil.writeInt8(Long.MAX_VALUE, buffer, 48); // Max end of file

    void testDecodeWithMaxValues() throws SMBProtocolDecodingException {
        // Prepare test data with maximum values
        byte[] buffer = new byte[22];
        long maxLong = Long.MAX_VALUE;
        int maxInt = Integer.MAX_VALUE;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt8(maxLong, buffer, offset);
        offset += 8;
        SMBUtil.writeInt8(maxLong, buffer, offset);

        // Test case 4: Max int value
        int maxIntValue = Integer.MAX_VALUE;
        NdrLong ndrLongMax = new NdrLong(maxIntValue);
        assertEquals(maxIntValue, ndrLongMax.value, "Constructor should correctly initialize with Integer.MAX_VALUE.");

        // Test case 5: Min int value
        int minIntValue = Integer.MIN_VALUE;

    private final AtomicLong totalBackpressureRejections = new AtomicLong(0);

    // Enhanced metrics
    private final AtomicLong minResponseTime = new AtomicLong(Long.MAX_VALUE);
    private final AtomicLong maxResponseTime = new AtomicLong(0);
    private final AtomicInteger consecutiveFailures = new AtomicInteger(0);
    private final AtomicInteger consecutiveSuccesses = new AtomicInteger(0);

        }

        @Test
        @DisplayName("Should create lock with maximum values")
        void testConstructorWithMaxValues() {
            long maxOffset = Long.MAX_VALUE;
            long maxLength = Long.MAX_VALUE;
            int flags = 0xFFFFFFFF;

            lock = new Smb2Lock(maxOffset, maxLength, flags);

            assertNotNull(lock);
        }

        @Test

    void testWithEdgeCaseTimeValues() {
        // Test with various time values including edge cases
        long[][] timeValues = { { 0L, 0L, 0L, 0L }, // All zeros
                { Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE }, // Max values
                { 1L, 2L, 3L, 4L }, // Small values
                { -1L, -2L, -3L, -4L } // Negative values (though unusual for file times)
        };

        when(config.getNotifyBufferSize()).thenReturn(Integer.MAX_VALUE);
        Smb2ChangeNotifyRequest req = new Smb2ChangeNotifyRequest(config, testFileId);

        // When
        byte[] buffer = new byte[512];
        req.writeBytesWireFormat(buffer, 0);

        // Then
        int readBufferSize = SMBUtil.readInt4(buffer, 4);
        assertEquals(Integer.MAX_VALUE, readBufferSize);
    }

    @Test

        byte[] buffer = new byte[100];

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, Integer.MAX_VALUE));
        assertEquals(0, response.readParametersWireFormat(buffer, 0, Integer.MAX_VALUE));
        assertEquals(0, response.readDataWireFormat(buffer, 0, Integer.MAX_VALUE));
    }

        // Given
        Integer largeTimeout = Integer.MAX_VALUE;
        when(request.getOverrideTimeout()).thenReturn(largeTimeout);

        // When
        Integer result = request.getOverrideTimeout();

        // Then
        assertNotNull(result);
        assertEquals(Integer.MAX_VALUE, result.intValue());
        verify(request, times(1)).getOverrideTimeout();
    }