for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);
    Collections.shuffle(asList, new Random(0xdeadbeef));

    // do bulk gets with exactly 10 keys (possibly <10 stripes) (or less if numStripes is smaller)
    bulkGetSet = ImmutableList.copyOf(limit(cycle(asList), 10));
  }

  @Footprint
  Object sizeOfStriped() {
    return impl.get(numStripes);
  }

  }

  @Override
  protected Collection<Method> suppressForTreeSetNatural() {
    return asList(
        getAddNullUnsupportedMethod(),
        getAddAllNullUnsupportedMethod(),
        getCreateWithNullUnsupportedMethod());
  }

  @Override
  protected Collection<Method> suppressForCheckedSet() {
    return asList(getAddNullSupportedMethod(), getAddSupportedNullPresentMethod());
  }

    new EqualsTester()
        .addEqualityGroup(Hashing.concatenating(asList(Hashing.md5())))
        .addEqualityGroup(Hashing.concatenating(asList(Hashing.murmur3_32())))
        .addEqualityGroup(
            Hashing.concatenating(Hashing.md5(), Hashing.md5()),
            Hashing.concatenating(asList(Hashing.md5(), Hashing.md5())))
        .addEqualityGroup(

        ArtifactRepository rr1 = repositorySystem.createDefaultRemoteRepository();
        a1.setDependencyFilter(new ExcludesArtifactFilter(Arrays.asList("foo")));

        Artifact a2 = repositorySystem.createArtifact("testGroup", "testArtifact", "1.2.3", "jar");
        @SuppressWarnings("deprecation")

            if (name.equals("li")) {
                unwindTo(Arrays.asList("ul", "ol"), visitor);
            } else if (name.equals("dt") || name.endsWith("dd")) {
                unwindTo(Arrays.asList("dl"), visitor);
            } else if (name.equals("tr")) {
                unwindTo(Arrays.asList("table", "thead", "tbody"), visitor);
            } else if (name.equals("th") || name.endsWith("td")) {

  public void testReplaceValuesWithNullValue() {
    List<V> values = asList(v0(), null, v3());
    multimap().replaceValues(k0(), values);
    assertGet(k0(), values);
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE, ALLOWS_NULL_KEYS})
  public void testReplaceValuesWithNullKey() {
    List<V> values = asList(v0(), v2(), v3());
    multimap().replaceValues(null, values);
    assertGet(null, values);
  }

        ImmutableListMultimap.<Character, Character>builder()
            .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
            .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
            .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
            .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
            .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
            .build();

  public void testStreamToArrayUnknownOrder() {
    Helpers.assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testStreamToArrayKnownOrder() {
    assertEquals(getOrderedElements(), asList(collection.stream().toArray()));
  }

  public void testStreamCount() {

 */

package com.google.common.collect.testing.google;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.testing.Helpers.mapEntry;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.Ordering;
import com.google.common.collect.testing.SampleElements;

  static final LegacyComparable Y = new LegacyComparable("y");
  static final LegacyComparable Z = new LegacyComparable("z");

  static final Iterable<LegacyComparable> VALUES_FORWARD = asList(X, Y, Z);
  static final Iterable<LegacyComparable> VALUES_BACKWARD = asList(Z, Y, X);

  private final String value;

  LegacyComparable(String value) {
    this.value = value;
  }

  @Override
  public int compareTo(Object object) {