@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));
      }
    }

        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));
      }
    }

   * is empty.
   *
   * <p>This is equivalent to checking if this range set {@link #encloses} each range in {@code
   * other}.
   *
   * @since 21.0
   */
  default boolean enclosesAll(Iterable<Range<C>> other) {
    for (Range<C> range : other) {
      if (!encloses(range)) {
        return false;
      }
    }
    return true;
  }

                            || type.getName().equals("java.util.Collection")
                            || type.getName().equals("java.util.Set")
                            || type.getName().equals("java.util.Iterable")) {
                        type = type.getTypeArgs().get(0);
                        multiValued = true;
                    }
                    classDoc.addClassBlock(new BlockDoc(methodDoc, property, type, multiValued));

            return "UNRESOLVED";
        }

        @Override
        public Optional<String> option() {
            return Optional.empty();
        }

        @Override
        public String[] option(Iterable<? extends Path> paths) {
            return new String[0];
        }
    };

    /**
     * Returns the unique name of this path type, including the module to patch if any.

    assertEquals(1, iterable.count);
  }

  public void testCopyOf_hashMultiset() {
    Multiset<String> iterable = HashMultiset.create(asList("a", "b", "a"));
    Multiset<String> multiset = ImmutableMultiset.copyOf(iterable);
    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
  }

  public void testCopyOf_treeMultiset() {
    Multiset<String> iterable = TreeMultiset.create(asList("a", "b", "a"));

import java.util.NavigableSet;

public final class SetsFilterNavigableSetTest extends AbstractFilteredNavigableSetTest {
  @Override
  NavigableSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Sets.newTreeSet(contents);
  }

  @Override
  NavigableSet<Integer> filter(
      NavigableSet<Integer> elements, Predicate<? super Integer> predicate) {

import java.util.Set;

public final class SetsFilterHashSetTest extends AbstractFilteredSetTest<Set<Integer>> {
  @Override
  Set<Integer> createUnfiltered(Iterable<Integer> contents) {
    return newHashSet(contents);
  }

  @Override
  Set<Integer> filter(Set<Integer> elements, Predicate<? super Integer> predicate) {
    return Sets.filter(elements, predicate);
  }

  }

  // 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")