cache.put(10, 20);
    assertThat(cache.getIfPresent(10)).isEqualTo(20);

    fakeTicker.advance(1000, MILLISECONDS);
    assertThat(cache.getIfPresent(10)).isNull();
  }

  @Test
  public void expireAfterWriteAndAccess() {
    Cache<Integer, Integer> cache =
        CacheBuilder.newBuilder()
            .expireAfterWrite(1000, MILLISECONDS)

    assertMinSize(difference(setSizeRange(1, 2), setSizeRange(10, 20)), 0);
    assertMinSize(difference(setSizeRange(10, 20), setSizeRange(11, 12)), 0);
    assertMinSize(difference(setSizeRange(11, 12), setSizeRange(10, 20)), 0);
  }

  public void testDifference_maxSize() {
    assertMaxSize(difference(emptySet(), emptySet()), 0);

        void testBinaryConstructorAndToByteArray() {
            // Arrange: revision=1, count=2, identAuth zeros except last byte, subauth 10, 20
            byte[] ident = new byte[] { 0, 0, 0, 0, 0, 5 };
            rpc.sid_t st = buildSidT((byte) 1, ident, 10, 20);

            byte[] bytes = SID.toByteArray(st);

            // Act: construct from bytes and re-encode
            SID sid = new SID(bytes, 0);

  public void testJoin() throws Exception {
    joinHelper(0);
    joinHelper(1);
    joinHelper(0, 0, 0);
    joinHelper(10, 20);
    joinHelper(10, 0, 20);
    joinHelper(0, 10, 20);
    joinHelper(10, 20, 0);
    joinHelper(10, 20, 1);
    joinHelper(1, 1, 1, 1, 1, 1, 1, 1);
    joinHelper(1, 0, 1, 0, 1, 0, 1, 0);
  }

  public void testOnlyOneOpen() throws Exception {

func (lrw *ResponseRecorder) Body() []byte {
	if lrw.Header().Get("Content-Encoding") == "gzip" {
		if lrw.body.Len() > 1<<20 {
			return gzippedBody
		}
		r, err := gzip.NewReader(&lrw.body)
		if err != nil {
			return gzippedBody
		}
		defer r.Close()
		b, _ := io.ReadAll(io.LimitReader(r, 10<<20))
		return b
	}
	// If there was an error response or body logging is enabled
	// then we return the body contents

  public void testJoin() {
    assertThat(Doubles.join(",", EMPTY)).isEmpty();
    assertThat(Doubles.join(",", ARRAY1)).isEqualTo("1.0");
    assertThat(Doubles.join(",", 1.0, 2.0)).isEqualTo("1.0,2.0");
    assertThat(Doubles.join("", 1.0, 2.0, 3.0)).isEqualTo("1.02.03.0");
  }

  public void testJoinNonTrivialDoubles() {
    assertThat(Doubles.join(",", EMPTY)).isEmpty();

    public void testBufferAccessOutOfBounds() throws Exception {
        byte[] buffer = new byte[100];
        assertThrows(SmbException.class, () -> {
            validator.validateBufferAccess(buffer, 90, 20);
        });
    }

    @Test
    public void testBufferAccessIntegerOverflow() throws Exception {
        byte[] buffer = new byte[100];
        assertThrows(SmbException.class, () -> {

    }

    @Test
    @DisplayName("Large message is read correctly")
    void largeMessageIsReadCorrectly() throws IOException {
        // Create a message with 1000 bytes
        int size = 1000;
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }

        byte[] fullData = concat(messageHeader(size), data);

}

func (z *erasureServerPools) listAndSave(ctx context.Context, o *listPathOptions) (entries metaCacheEntriesSorted, err error) {
	// Use ID as the object name...
	o.pool = z.getAvailablePoolIdx(ctx, minioMetaBucket, o.ID, 10<<20)
	if o.pool < 0 {
		// No space or similar, don't persist the listing.
		o.pool = 0
		o.Create = false
		o.ID = ""
		o.Transient = true
		return entries, errDiskFull
	}

        ArtifactSpec a = createArtifactSpec("a", "1.0");
        a.addDependency("b", "[1.0, 2.0)");
        a.addDependency("c", "[3.3.0,4.0.0)");

        ArtifactSpec b = createArtifactSpec("b", "1.0.0");
        b.addDependency("c", "3.3.0-v3346");

        ArtifactSpec c = createArtifactSpec("c", "3.2.1-v3235e");