bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative offset: " + offset);
        }

        if (length < 0) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative length: " + length);
        }

        // Check for integer overflow

        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // The implementation reads values as signed integers and stores them as long
        // Negative values remain negative when stored in long fields
        // The calculations will result in negative values
        long expectedCapacity = (long) alloc * sectPerAlloc * bytesPerSect;
        assertEquals(expectedCapacity, smbInfoAllocation.getCapacity());

            assertEquals(0, ndrShort.value);
        }

        @Test
        @DisplayName("Should decode negative value correctly")
        void testDecodeNegativeValue() throws NdrException {
            // Given: NdrShort and mock returning negative value
            int negativeValue = -1;
            NdrShort ndrShort = new NdrShort(0);

        assertEquals(10, searchRenderData.getPageSize());

        searchRenderData.setPageSize(100);
        assertEquals(100, searchRenderData.getPageSize());

        // Test with negative value
        searchRenderData.setPageSize(-1);
        assertEquals(-1, searchRenderData.getPageSize());
    }

    public void test_setAndGetCurrentPageNumber() {
        // Test with zero

        assertEquals(22, bytesDecoded);
        assertEquals(minLong, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test decode with negative values")
    void testDecodeWithNegativeValues() throws SMBProtocolDecodingException {
        // Prepare test data with negative values
        byte[] buffer = new byte[22];
        long negativeLong = -1L;
        int negativeInt = -1;

        // Encode test data

 * parameter word (the session identifier) is written in little‑endian form
 * and that the {@code toString} helper contains the expected values.
 *
 * <p>The tests also exercise edge cases such as negative (wrap‑around) session
 * identifiers and confirm that the writer does not alter any internal state.
 *</p>
 */
@ExtendWith(MockitoExtension.class)
class SmbComFindClose2Test {

    @Mock

    /**
     * Sets the maximum age of a cached response. If the cache response's age exceeds [maxAge], it
     * will not be used and a network request will be made.
     *
     * @param maxAge a non-negative duration. This is stored and transmitted with [TimeUnit.SECONDS]
     *     precision; finer precision will be lost.
     */
    fun maxAge(maxAge: Duration) =
      apply {

    @DisplayName("Test edge case with minimum/negative values")
    void testMinimumValues() {
        // Given
        long negativeMid = -1L;
        long negativeAsyncId = -1L;

        // When
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, negativeMid, negativeAsyncId);

        // Then
        assertEquals(negativeMid, request.getMid(), "Should handle negative MID");

        return Stream.of(Arguments.of((LongGetter) FileEntry::createTime, -1L, "negative createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, 0L, "zero createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, Long.MAX_VALUE, "max createTime"),

                Arguments.of((LongGetter) FileEntry::lastModified, -2L, "negative lastModified"),

     */
    public static void validateBufferSize(int size, int maxSize, String fieldName) {
        if (size < 0) {
            throw new IllegalArgumentException(fieldName + " size cannot be negative: " + size);
        }
        if (size > maxSize) {
            throw new IllegalArgumentException(fieldName + " size exceeds maximum (" + maxSize + "): " + size);
        }
    }

    /**