final long offset;
    final long length;

    SlicedByteSource(long offset, long length) {
      checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
      checkArgument(length >= 0, "length (%s) may not be negative", length);
      this.offset = offset;
      this.length = length;
    }

    @Override
    public InputStream openStream() throws IOException {

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

}

// GetLength - get length of range
func (h *HTTPRangeSpec) GetLength(resourceSize int64) (rangeLength int64, err error) {
	switch {
	case resourceSize < 0:
		return 0, errors.New("Resource size cannot be negative")

	case h == nil:
		rangeLength = resourceSize

	case h.IsSuffixLength:
		specifiedLen := -h.Start
		rangeLength = min(specifiedLen, resourceSize)

	case h.Start >= resourceSize:

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

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(-1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("index (-1) must not be negative");
  }

  public void testCheckElementIndex_tooHigh() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(1, 1));

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(-1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("index (-1) must not be negative");
  }

  public void testCheckElementIndex_tooHigh() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(1, 1));

				},
			}},
			References: []Reference{{"ID", "User", "UserID", "user_friends", "", true}, {"ID", "User", "FriendID", "user_friends", "", false}},
		},
	}

	for _, relation := range relations {
		checkSchemaRelation(t, user, relation)
	}
}

func TestParseSchemaWithAdvancedDataType(t *testing.T) {
	user, err := schema.Parse(&AdvancedDataTypeUser{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {

  }

  private void assertSetCountNegativeOldCount() {
    try {
      getMultiset().setCount(e3(), -1, 1);
      fail("calling setCount() with a negative oldCount should throw IllegalArgumentException");
    } catch (IllegalArgumentException expected) {
    }
  }

  // Negative oldCount.

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSetCountConditional_negativeOldCount_addSupported() {

        assertTrue(result.contains("indexNumber=0"));
    }

    @Test
    @DisplayName("Test toString with negative index number")
    void testToStringWithNegativeIndexNumber() throws SMBProtocolDecodingException {
        // Setup test data with negative value
        byte[] buffer = new byte[8];
        long expectedIndexNumber = -9999999999L;
        SMBUtil.writeInt8(expectedIndexNumber, buffer, 0);

        // Test case 2: Negative value
        int negativeValue = -54321;
        NdrLong ndrLongNegative = new NdrLong(negativeValue);
        assertEquals(negativeValue, ndrLongNegative.value, "Constructor should correctly initialize with a negative value.");

        // Test case 3: Zero value
        int zeroValue = 0;