assertEquals(Long.MAX_VALUE, DiscreteDomain.longs().offset(0L, Long.MAX_VALUE).longValue());
  }

  public void testLongsOffsetExceptions() {
    assertThrows(IllegalArgumentException.class, () -> DiscreteDomain.longs().offset(0L, -1));
    assertThrows(
        IllegalArgumentException.class, () -> DiscreteDomain.longs().offset(Long.MAX_VALUE, 1));
  }

  public void testBigIntegersOffset() {

   * Returns the total number of chars read. Does not close the stream.
   *
   * @since 20.0
   */
  @CanIgnoreReturnValue
  public static long exhaust(Readable readable) throws IOException {
    long total = 0;
    long read;
    CharBuffer buf = createBuffer();
    while ((read = readable.read(buf)) != -1) {
      total += read;
      Java8Compatibility.clear(buf);
    }
    return total;

    @Test
    public void test_setCrawlingExecutionInterval() {
        long interval = 100L; // Keep test intervals short
        dataIndexHelper.setCrawlingExecutionInterval(interval);

        try {
            Field field = DataIndexHelper.class.getDeclaredField("crawlingExecutionInterval");
            field.setAccessible(true);
            long actualInterval = (Long) field.get(dataIndexHelper);

            this.response = (TestResponse) msg;
        }

        @Override
        public long getMid() {
            return mid;
        }

        @Override
        public void setMid(long mid) {
            this.mid = mid;
        }

        @Override
        public int getCommand() {
            return command;
        }

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })
    public void testEncodeWithVariousValues(long val) throws NdrException {
        NdrHyper hyper = new NdrHyper(val);
        // Create buffer with extra space for alignment
        NdrBuffer buf = new NdrBuffer(new byte[16], 0);

    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue

@NullUnmarked
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {

            // Then
            assertEquals(24, bytesConsumed);
            // Note: multiplication may overflow, but that's expected behavior
            long expectedCapacity = Long.MAX_VALUE * (long) Integer.MAX_VALUE * (long) Integer.MAX_VALUE;
            assertEquals(expectedCapacity, fileFsSizeInfo.getCapacity());
        }

        @Test
        @DisplayName("Should decode buffer with offset correctly")

        }

        public String format(long size) {
            return format(size, null);
        }

        public String format(long size, ScaleUnit unit) {
            return format(size, unit, false);
        }

        public String format(long size, ScaleUnit unit, boolean omitSymbol) {
            if (size < 0L) {

    }

    @ParameterizedTest
    @DisplayName("Test with various timeout values")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1000L, -1000L })
    void testWithVariousTimeoutValues(long timeout) {
        // Setup
        String pipeName = "TestPipe";
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName, timeout);