}

// ReadAt implements the [io.ReaderAt] interface.
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
	// cannot modify state - see io.ReaderAt
	if off < 0 {
		return 0, errors.New("bytes.Reader.ReadAt: negative offset")
	}
	if off >= int64(len(r.s)) {
		return 0, io.EOF
	}
	n = copy(b, r.s[off:])
	if n < len(b) {
		err = io.EOF
	}
	return
}

// ReadByte implements the [io.ByteReader] interface.

    @Test
    @DisplayName("encode() throws when dstIndex is negative")
    void encodeThrowsWhenDstIndexNegative() {
        byte[] src = makeSeq(3);
        Encodable enc = new ByteEncodable(src, 0, 3);
        byte[] dst = new byte[3];

        assertThrows(ArrayIndexOutOfBoundsException.class, () -> enc.encode(dst, -1),
                "System.arraycopy should throw for negative dstIndex");
    }

        super();
    }

    /**
     * Resolves the given host name to an array of IP addresses.
     * The host name is first converted to ASCII using IDN before resolution.
     * IPv6 addresses in bracket notation (e.g., [::1] or [2001:db8::1]) are
     * handled specially by removing the brackets before resolution.
     *
     * @param host the host name to resolve
     * @return an array of IP addresses for the host

        // Test that BoostQuery constructor doesn't allow negative boost values
        Term term = new Term("field", "negative");
        TermQuery termQuery = new TermQuery(term);

        try {
            BoostQuery boostQuery = new BoostQuery(termQuery, -1.5f);
            fail("Should have thrown IllegalArgumentException for negative boost");
        } catch (IllegalArgumentException e) {

   * @return a new, empty {@code ObjectCountHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  static <K extends @Nullable Object> ObjectCountHashMap<K> createWithExpectedSize(
      int expectedSize) {
    return new ObjectCountHashMap<K>(expectedSize);
  }

						if reflect.Indirect(obj).Kind() != reflect.Struct {
							break
						}
						if _, zero := rel.Field.ValueOf(db.Statement.Context, obj); !zero { // check belongs to relation value
							rv := rel.Field.ReflectValueOf(db.Statement.Context, obj) // relation reflect value
							if !isPtr {
								rv = rv.Addr()
							}
							objs = append(objs, obj)
							elems = reflect.Append(elems, rv)

						} else {
							db.AddError(fmt.Errorf("relation %s not found", association))
							return nil
						}
					}
				} else {
					db.AddError(fmt.Errorf("relation %s not found", association))
					return nil
				}
			}

			if q.limitPerRecord > 0 {
				if relation.JoinTable != nil {
					tx.AddError(fmt.Errorf("many2many relation %s don't support LimitPerRecord", association))

	RegisterNumber func(string, int16) (int16, bool)
	// Instruction is a jump.
	IsJump func(word string) bool
}

// nilRegisterNumber is the register number function for architectures
// that do not accept the R(N) notation. It always returns failure.
func nilRegisterNumber(name string, n int16) (int16, bool) {
	return 0, false
}

// Set configures the architecture specified by GOARCH and returns its representation.

    public void test_byteCountToDisplaySize_edgeCases() {
        // Test negative values - should throw NullPointerException in private method via BigInteger.valueOf
        try {
            MemoryUtil.byteCountToDisplaySize(-1L);
            // If no exception, verify it handles negative as expected
        } catch (Exception e) {
            // Expected for negative values
        }

        // Test boundary values

		"Invalid value for batch key rotation workers wait",
		"Please input a non-negative duration",
		"keyrotation_workers_wait should be > 0ms",
	)
	ErrInvalidBatchReplicationWorkersWait = newErrFn(
		"Invalid value for batch replication workers wait",
		"Please input a non-negative duration",
		"replication_workers_wait should be > 0ms",
	)
	ErrInvalidBatchExpirationWorkersWait = newErrFn(