}

  public void testEviction_weightedLru() {
    // test weighted lru within a single segment
    IdentityLoader<Integer> loader = identityLoader();
    LoadingCache<Integer, Integer> cache =
        CacheBuilder.newBuilder()
            .concurrencyLevel(1)
            .maximumWeight(45)
            .weigher(intKeyWeigher())
            .build(loader);
    CacheTesting.warmUp(cache, 0, 10);

  }

  public void testEviction_weightedLru() {
    // test weighted lru within a single segment
    IdentityLoader<Integer> loader = identityLoader();
    LoadingCache<Integer, Integer> cache =
        CacheBuilder.newBuilder()
            .concurrencyLevel(1)
            .maximumWeight(45)
            .weigher(intKeyWeigher())
            .build(loader);
    CacheTesting.warmUp(cache, 0, 10);

  }

  @J2ktIncompatible
  @GwtIncompatible // weigher
  public void testWeigher_withoutMaximumWeight() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().weigher(constantWeigher(42));
    assertThrows(IllegalStateException.class, () -> builder.build(identityLoader()));
  }

  @J2ktIncompatible
  @GwtIncompatible // weigher
  public void testWeigher_withMaximumSize() {
    assertThrows(

  }

  @J2ktIncompatible
  @GwtIncompatible // weigher
  public void testWeigher_withoutMaximumWeight() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().weigher(constantWeigher(42));
    assertThrows(IllegalStateException.class, () -> builder.build(identityLoader()));
  }

  @J2ktIncompatible
  @GwtIncompatible // weigher
  public void testWeigher_withMaximumSize() {
    assertThrows(

    assertWithMessage("removalListener")
        .that(actual.removalListener)
        .isEqualTo(expected.removalListener);
    assertWithMessage("weigher").that(actual.weigher).isEqualTo(expected.weigher);
    assertWithMessage("valueEquivalence")
        .that(actual.valueEquivalence)
        .isEqualTo(expected.valueEquivalence);

            urlQueue.setWeight(i); // Higher number = higher weight
            urlQueueList.add(urlQueue);
        }

        urlQueueService.offerAll(sessionId, urlQueueList);

        // Poll - items should be ordered by weight (descending)
        final OpenSearchUrlQueue first = urlQueueService.poll(sessionId);
        assertNotNull(first);
        // Weight should be highest

 * Double#POSITIVE_INFINITY POSITIVE_INFINITY} sort to the beginning and the end of the dataset, as
 * you would expect.
 *
 * <p>If required to do a weighted average between an infinity and a finite value, or between an
 * infinite value and itself, the infinite value is returned. If required to do a weighted average
 * between {@link Double#NEGATIVE_INFINITY NEGATIVE_INFINITY} and {@link Double#POSITIVE_INFINITY

        if (this.equivalence.equals(that.equivalence)) {
          /*
           * We'll accept that as sufficient "proof" that either equivalence should be able to
           * handle either reference, so it's safe to circumvent compile-time type checking.
           */
          @SuppressWarnings("unchecked")

        if (argValue == null) {
            throw new NullArgumentException(argName);
        }
    }

    /**
     * Asserts that the argument is neither <code>null</code> nor an empty string.
     *
     * @param argName
     *            The name of the argument that must not be {@code null} or an empty string.
     * @param argValue

        if (this.equivalence.equals(that.equivalence)) {
          /*
           * We'll accept that as sufficient "proof" that either equivalence should be able to
           * handle either reference, so it's safe to circumvent compile-time type checking.
           */
          @SuppressWarnings("unchecked")