{"bytes=1-", false},

		{"bytes=0-9", false},
		{"bytes=1-10", false},
		{"bytes=1-1", false},
		{"bytes=2-5", false},

		{"bytes=-5", false},
		{"bytes=-1", false},
		{"bytes=-1000", false},
		{"bytes=", true},
		{"bytes= ", true},
		{"byte=", true},
		{"bytes=A-B", true},
		{"bytes=1-B", true},
		{"bytes=B-1", true},
		{"bytes=-1-1", true},
	}

    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS
          .toMillis(actualElapsedNs)
          .toDouble(),
      ).isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {
      takeEvent()
    }
  }

/* jcifs smb client library in Java
 * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,

        }
    }

    @Test
    @DisplayName("MonotonicClock should handle rapid successive calls")
    void testRapidCalls() {
        Instant[] instants = new Instant[1000];
        for (int i = 0; i < instants.length; i++) {
            instants[i] = MonotonicClock.now();
        }

        // Verify monotonic behavior across all measurements

/**
 * Single-threaded benchmark for {@link LoadingCache}.
 *
 * @author Charles Fry
 */
@NullUnmarked
public class LoadingCacheSingleThreadBenchmark {
  @Param({"1000", "2000"})
  int maximumSize;

  @Param("5000")
  int distinctKeys;

  @Param("4")
  int segments;

  // 1 means uniform likelihood of keys; higher means some keys are more popular
  // tweak this to control hit rate
  @Param("2.5")
  double concentration;

/* jcifs smb client library in Java
 * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,

COPY --from=build /go/bin/mc* /usr/bin/
COPY --from=build /go/bin/cur* /usr/bin/

COPY CREDITS /licenses/CREDITS
COPY LICENSE /licenses/LICENSE
COPY dockerscripts/docker-entrypoint.sh /usr/bin/docker-entrypoint.sh

EXPOSE 9000
VOLUME ["/data"]

ENTRYPOINT ["/usr/bin/docker-entrypoint.sh"]

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

/* jcifs smb client library in Java
 * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,

```mermaid
graph LR

browser("Browser")
proxy["Proxy on http://0.0.0.0:9999/api/v1/app"]
server["Server on http://127.0.0.1:8000/app"]

browser --> proxy
proxy --> server
```

/// tip | Dica

O IP `0.0.0.0` é comumente usado para significar que o programa escuta em todos os IPs disponíveis naquela máquina/servidor.

///