}

  @Override
  public boolean enclosesAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {
      if (!encloses(range)) {
        return false;
      }
    }
    return true;
  }

  @Override
  public void addAll(RangeSet<C> other) {
    addAll(other.asRanges());
  }

  @Override
  public void addAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {

  }

  public void testNewTreeSetFromIterableDerived() {
    Iterable<Derived> iterable = asList(new Derived("foo"), new Derived("bar"));
    TreeSet<Derived> set = Sets.newTreeSet(iterable);
    assertThat(set).containsExactly(new Derived("bar"), new Derived("foo")).inOrder();
  }

  public void testNewTreeSetFromIterableNonGeneric() {
    Iterable<LegacyComparable> iterable =

  }

  // Unsafe, see ImmutableSortedSetFauxverideShim.
  @SuppressWarnings("unchecked")
  public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> elements) {
    return copyOfInternal((Ordering<E>) Ordering.natural(), (Iterable<E>) elements, false);
  }

  // Unsafe, see ImmutableSortedSetFauxverideShim.
  @SuppressWarnings("unchecked")

     *
     * @return The number of {@link PropertyDesc}
     */
    int getPropertyDescSize();

    /**
     * Returns an {@link Iterable} of {@link PropertyDesc}.
     *
     * @return An {@link Iterable} of {@link PropertyDesc}
     */
    Iterable<PropertyDesc> getPropertyDescs();

    /**
     * Returns whether the {@link FieldDesc} exists.
     *
     * @param fieldName

  }

  @Override
  public <E extends T> E min(Iterator<E> iterator) {
    return forwardOrder.max(iterator);
  }

  @Override
  public <E extends T> E min(Iterable<E> iterable) {
    return forwardOrder.max(iterable);
  }

  @Override
  public <E extends T> E max(@ParametricNullness E a, @ParametricNullness E b) {
    return forwardOrder.min(a, b);
  }

  @Override

  CacheBuilderFactory withValueStrengths(Set<Strength> valueStrengths) {
    this.valueStrengths = new LinkedHashSet<>(valueStrengths);
    return this;
  }

  Iterable<CacheBuilder<Object, Object>> buildAllPermutations() {
    Iterable<List<Object>> combinations =
        buildCartesianProduct(
            concurrencyLevels,
            initialCapacities,
            maximumSizes,
            expireAfterWrites,

     * @return an {@link Iterable} wrapping a {@link ClassLoaderIterator}
     */
    public static Iterable<ClassLoader> iterable(final ClassLoader classLoader) {
        return () -> new ClassLoaderIterator(classLoader);
    }

    /**
     * Constructs an instance.
     *
     * @param classLoader the class loader (must not be {@literal null})
     */

  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.
  // For the same reason, we need to skip create(Iterable, Class).
  private static class EnumMultisetFactory {
    @Keep // used reflectively by testEquals
    public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
      return EnumMultiset.create(elements);
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection

    @SuppressWarnings("unchecked")
    @Override
    public Entry<String, Integer>[] createArray(int length) {
      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public List<Entry<String, Integer>> create(Object... elements) {

        for (int i = 0; i < objectsNum; i++) {
          objects.add(new Object());
        }

        Iterable<?> locks = striped.bulkGet(objects);
        assertTrue(Ordering.natural().onResultOf(Functions.forMap(indexByLock)).isOrdered(locks));

        // check idempotency
        Iterable<?> locks2 = striped.bulkGet(objects);
        assertEquals(Lists.newArrayList(locks), Lists.newArrayList(locks2));
      }
    }