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(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);

// another n bytes. After Grow(n), at least n bytes can be written to the
// buffer without another allocation.
// If n is negative, Grow will panic.
// If the buffer can't grow it will panic with [ErrTooLarge].
func (b *Buffer) Grow(n int) {
	if n < 0 {
		panic("bytes.Buffer.Grow: negative count")
	}
	m := b.grow(n)
	b.buf = b.buf[:m]
}

// Write appends the contents of p to the buffer, growing the buffer as

        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(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

        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"),

    @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");

 * 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

    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonnegative(long value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

     */
    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);
        }
    }

    /**