assertThat(cache.asMap().keySet()).containsExactly(2, 4);

    CacheTesting.processPendingNotifications(cache);
    assertThat(removalListener.getCount()).isEqualTo(2);

    // Should we pepper more of these calls throughout the above? Where?
    CacheTesting.checkValidState(cache);
  }

  /**
   * Tests that when a single entry exceeds the segment's max weight, the new entry is immediately
   * evicted and nothing else.

        @Test
        @DisplayName("Should execute bind operation successfully")
        void testBindSuccess() throws DcerpcException, IOException {
            // Given: Spy to intercept sendrecv calls
            TestDcerpcHandle spyHandle = spy(new TestDcerpcHandle(mockContext, mockBinding));
            doNothing().when(spyHandle).sendrecv(any(DcerpcMessage.class));

            // When: Binding the handle

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A map which forwards all its method calls to another map. Subclasses should override one or more
 * methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

        assertEquals(testWindowSize, queryRescorerBuilder.windowSize().intValue());
    }

    public void test_evaluate_multipleCallsWithDifferentConfigs() {
        // Test multiple calls with different configurations
        Map<String, Object> params = new HashMap<>();
        params.put("param", "value");

        // First call with model name

        assertEquals(0, responseLength);
    }

    @Test
    void testMultipleReadDataWireFormatCalls() throws SMBProtocolDecodingException {
        // Test multiple calls to readDataWireFormat to ensure buffer is overwritten
        byte[] firstData = "First data set".getBytes();
        byte[] secondData = "Second data set".getBytes();
        byte[] buffer1 = new byte[100];

	_, err := objAPI.DeleteObject(ctx, minioMetaBucket, configFile, ObjectOptions{
		DeletePrefix:       true,
		DeletePrefixObject: true, // use prefix delete on exact object (this is an optimization to avoid fan-out calls)
	})
	if err != nil && isErrObjectNotFound(err) {
		return errConfigNotFound
	}
	return err
}

        int result = response.readBytesWireFormat(buffer, bufferIndex);

        assertEquals(8, result);
        assertNotNull(response.getResults());
    }

    @Test
    @DisplayName("Test multiple calls to getResults return same instance")
    void testMultipleGetResultsCalls() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, (byte) 0x03);

        // Use reflection to set the results field

@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum CollectionFeature implements Feature<Collection> {
  /**
   * The collection must not throw {@code NullPointerException} on calls such as {@code
   * contains(null)} or {@code remove(null)}, but instead must return a simple {@code false}.
   */
  ALLOWS_NULL_QUERIES,
  ALLOWS_NULL_VALUES(ALLOWS_NULL_QUERIES),

  /**

      return uncheckedCastNullableTToT(peekedElement);
    }
  }

  /**
   * Returns a {@code PeekingIterator} backed by the given iterator.
   *
   * <p>Calls to the {@code peek} method with no intervening calls to {@code next} do not affect the
   * iteration, and hence return the same object each time. A subsequent call to {@code next} is
   * guaranteed to return the same object again. For example:
   *

        boolean found = activeResources.stream().anyMatch(desc -> desc.contains("TestResource"));
        assertTrue(found);
    }

    @Test
    @DisplayName("Test multiple close calls on managed resource")
    void testMultipleCloseOnManagedResource() throws Exception {
        TestResource resource = new TestResource("multiclose");