}

    private fun computeExtraDetails(
        declared: Set<TargetRuntime>,
        computed: Map<TargetRuntime, Set<String>>
    ): List<String> {
        return (declared.toSet() + computed.keys).mapNotNull {
            if (declared.contains(it) && computed.containsKey(it)) {
                null
            } else if (declared.contains(it)) {
                "Unnecessary declaration $it"

    abstract val requiredRuntimes: ModuleTargetRuntimes

    fun requiredRuntimes(action: ModuleTargetRuntimes.() -> Unit) {
        action(requiredRuntimes)
    }

    /**
     * The set of runtimes for this module, computed based on the required target
     * runtimes of this module and the required target runtimes of all modules
     * that depend on this module. This set contains a runtime if it is required

    // don't check cache.size() until we know the get("b") call is complete
    computationComplete.await();

    // At this point, the listener should be holding the seed value (a -> a), and the map should
    // contain the computed value (b -> b), since the clear() happened before the computation
    // completed.
    assertThat(listener).hasSize(1);
    RemovalNotification<String, String> notification = listener.remove();

    // don't check cache.size() until we know the get("b") call is complete
    computationComplete.await();

    // At this point, the listener should be holding the seed value (a -> a), and the map should
    // contain the computed value (b -> b), since the clear() happened before the computation
    // completed.
    assertThat(listener).hasSize(1);
    RemovalNotification<String, String> notification = listener.remove();

@GwtCompatible
public final class Suppliers {
  private Suppliers() {}

  /**
   * Returns a new supplier which is the composition of the provided function and supplier. In other
   * words, the new supplier's value will be computed by retrieving the value from {@code supplier},
   * and then applying {@code function} to that value. Note that the resulting supplier will not
   * call {@code supplier} or invoke {@code function} until it is called.
   */

@GwtCompatible
public final class Suppliers {
  private Suppliers() {}

  /**
   * Returns a new supplier which is the composition of the provided function and supplier. In other
   * words, the new supplier's value will be computed by retrieving the value from {@code supplier},
   * and then applying {@code function} to that value. Note that the resulting supplier will not
   * call {@code supplier} or invoke {@code function} until it is called.
   */

 *
 * <h3>Examples</h3>
 *
 * <p>To compute the median:
 *
 * {@snippet :
 * double myMedian = median().compute(myDataset);
 * }
 *
 * where {@link #median()} has been statically imported.
 *
 * <p>To compute the 99th percentile:
 *
 * {@snippet :
 * double myPercentile99 = percentiles().index(99).compute(myDataset);
 * }
 *

  }

  public void testHashCodeForBooleanOperations() {
    Predicate<@Nullable Integer> p1 = Predicates.isNull();
    Predicate<@Nullable Integer> p2 = isOdd();

    // Make sure that hash codes are not computed per-instance.
    assertEqualHashCode(Predicates.not(p1), Predicates.not(p1));

    assertEqualHashCode(Predicates.and(p1, p2), Predicates.and(p1, p2));

      // meant that sometimes a too-large threshold is calculated. However, this new threshold is
      // independent of the initial capacity, except that it won't be lower than the threshold
      // computed from that capacity. Because the internal table is only allocated on the first
      // write, we won't see copying because of the new threshold. So it is always OK to use the
      // calculation here.

  }

  /**
   * Returns an immutable map whose keys are the distinct elements of this {@code FluentIterable}
   * and whose value for each key was computed by {@code valueFunction}. The map's iteration order
   * is the order of the first appearance of each key in this iterable.
   *
   * <p>When there are multiple instances of a key in this iterable, it is unspecified whether