public void testSize_populated() {
    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed
      List<Entry<Object, Object>> unused = warmUp(cache);
      assertThat(cache.size()).isEqualTo(WARMUP_SIZE);
      assertMapSize(cache.asMap(), WARMUP_SIZE);
      checkValidState(cache);
    }
  }

  public void testContainsKey_found() {

 */
public class ReferralTest {

    private Referral referral;
    private byte[] testBuffer;

    @BeforeEach
    public void setUp() {
        referral = new Referral();
        testBuffer = new byte[512];
    }

    // Version 3 Referral Tests

    @Test
    public void testDecodeVersion3WithoutNameList() {
        // Prepare test data

 *
 */
public class URLUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testEncode() throws Exception {
        assertEquals("Program+Files", URLUtil.encode("Program Files", "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testDecode() throws Exception {
        assertEquals("Program Files", URLUtil.decode("Program+Files", "UTF-8"));
    }

    /**

    private int expiredCount;

    protected void setUp() throws Exception {
        expiredCount = 0;
        TimeoutManager.getInstance().clear();
    }

    protected void tearDown() throws Exception {
        TimeoutManager.getInstance().clear();
    }

    /**
     * @throws Exception
     */
    public void testExpired() throws Exception {

/**
 * Tests {@code Relocation}.
 *
 */
class RelocationTest {

    @Test
    void testHashCodeNullSafe() {
        new Relocation().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Relocation().equals(null));

        new Relocation().equals(new Relocation());
    }

    @Test
    void testEqualsIdentity() {
        Relocation thing = new Relocation();

 * Tests {@code Contributor}.
 *
 */
class ContributorTest {

    @Test
    void testHashCodeNullSafe() {
        new Contributor().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Contributor().equals(null));

        new Contributor().equals(new Contributor());
    }

    @Test
    void testEqualsIdentity() {
        Contributor thing = new Contributor();

/**
 * Tests {@code Extension}.
 *
 */
class ExtensionTest {

    @Test
    void testHashCodeNullSafe() {
        new Extension().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Extension().equals(null));

        new Extension().equals(new Extension());
    }

    @Test
    void testEqualsIdentity() {
        Extension thing = new Extension();

 *
 */
class PluginContainerTest {

    @Test
    void testHashCodeNullSafe() {
        new PluginContainer().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new PluginContainer().equals(null));

        new PluginContainer().equals(new PluginContainer());
    }

    @Test
    void testEqualsIdentity() {
        PluginContainer thing = new PluginContainer();

    public void insert(WebAuthentication entity) {
        doInsert(entity, null);
    }

    public void insert(WebAuthentication entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    public void update(WebAuthentication entity) {
        doUpdate(entity, null);
    }

    return concat(strongImplementations(), weakImplementations());
  }

  public void testNull() throws Exception {
    for (Striped<?> striped : allImplementations()) {
      new NullPointerTester().testAllPublicInstanceMethods(striped);
    }
  }

  public void testSizes() {
    // not bothering testing all variations, since we know they share implementations