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

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

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

    /**

        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

// f(NewDummyDataGen(100, 0)) == f(NewDummyDataGen(50, 0)) + f(NewDummyDataGen(50, 50))
func NewDummyDataGen(totalLength, skipOffset int64) io.ReadSeeker {
	if totalLength < 0 {
		panic("Negative length passed to DummyDataGen!")
	}
	if skipOffset < 0 {
		panic("Negative rotations are not allowed")
	}

	skipOffset %= int64(len(alphabets))
	const multiply = 100
	as := bytes.Repeat(alphabets, multiply)

    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);
        assertFalse(filter.accept(smbFile), "Negative size should be rejected");

   *
   * @param a the first {@code boolean} to compare
   * @param b the second {@code boolean} to compare
   * @return a positive number if only {@code a} is {@code true}, a negative number if only {@code
   *     b} is true, or zero if {@code a == b}
   */
  @InlineMe(replacement = "Boolean.compare(a, b)")
  public static int compare(boolean a, boolean b) {
    return Boolean.compare(a, b);

   *
   * @param a the first {@code boolean} to compare
   * @param b the second {@code boolean} to compare
   * @return a positive number if only {@code a} is {@code true}, a negative number if only {@code
   *     b} is true, or zero if {@code a == b}
   */
  @InlineMe(replacement = "Boolean.compare(a, b)")
  public static int compare(boolean a, boolean b) {
    return Boolean.compare(a, b);

        assertEquals(123, ex.getNtStatus());
    }

    /**
     * Parameterised test covering many error codes.
     * - Error code 0 returns 0 (NT_STATUS_SUCCESS)
     * - Negative values with 0xC0000000 bits set are returned as-is
     * - Positive values not in DOS_ERROR_CODES map to NT_STATUS_UNSUCCESSFUL
     */
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 123, -7 })

 *   if (value < 0) {
 *     throw new IllegalArgumentException("input is negative: " + value);
 *   }
 *   // calculate square root
 * }
 * }
 *
 * <p>to be replaced with the more compact
 *
 * {@snippet :
 * public static double sqrt(double value) {
 *   checkArgument(value >= 0, "input is negative: %s", value);
 *   // calculate square root
 * }
 * }
 *