* new TypeVisitor() {
 *   protected void visitParameterizedType(ParameterizedType t) {
 *     visit(t.getOwnerType());
 *     visit(t.getActualTypeArguments());
 *   }
 *   protected void visitGenericArrayType(GenericArrayType t) {
 *     visit(t.getGenericComponentType());
 *   }
 *   protected void visitTypeVariable(TypeVariable<?> t) {
 *     throw new IllegalArgumentException("Cannot contain type variable.");
 *   }

      void visitParameterizedType(ParameterizedType t) {
        visit(t.getActualTypeArguments());
      }

      @Override
      void visitTypeVariable(TypeVariable<?> t) {
        visit(t.getBounds());
      }
    }.visit(type);
  }

  private static void assertVisited(Type type) {
    TypeVisitor visitor = new BaseTypeVisitor();
    try {
      visitor.visit(type);
      fail("Type not visited");

        map(new TypeVariableKey(vars[i]), typeArgs[i]);
      }
      visit(rawClass);
      visit(parameterizedType.getOwnerType());
    }

    @Override
    void visitTypeVariable(TypeVariable<?> t) {
      visit(t.getBounds());
    }

    @Override
    void visitWildcardType(WildcardType t) {
      visit(t.getUpperBounds());
    }

    private void map(TypeVariableKey var, Type arg) {

      void visitParameterizedType(ParameterizedType t) {
        visit(t.getActualTypeArguments());
      }

      @Override
      void visitTypeVariable(TypeVariable<?> t) {
        visit(t.getBounds());
      }
    }.visit(type);
  }

  private static void assertVisited(Type type) {
    TypeVisitor visitor = new BaseTypeVisitor();
    try {
      visitor.visit(type);
      fail("Type not visited");

        visit(type.getLowerBounds());
        visit(type.getUpperBounds());
      }

      @Override
      void visitParameterizedType(ParameterizedType type) {
        visit(type.getActualTypeArguments());
        visit(type.getOwnerType());
      }

      @Override
      void visitGenericArrayType(GenericArrayType type) {
        visit(type.getGenericComponentType());
      }

    int nTasks = 1000;
    int nSeededEntries = 100;
    Set<String> expectedKeys = Sets.newHashSetWithExpectedSize(nTasks + nSeededEntries);
    // seed the map, so its segments have a count>0; otherwise, clear() won't visit the in-progress
    // entries
    for (int i = 0; i < nSeededEntries; i++) {
      String s = "b" + i;
      cache.getUnchecked(s);
      expectedKeys.add(s);
    }
    computationShouldWait.set(true);

 *
 * @author Kevin Bourrillion
 */
public class SetContainsBenchmark {
  // Start at 4.88 then multiply by 2*2^phi <evil cackle> - The goal is be uniform
  // yet visit a variety of "values-relative-to-the-next-power-of-2"
  @Param({"5", "30", "180", "1100", "6900", "43000", "260000"}) // "1600000", "9800000"
  private int size;

  // TODO(kevinb): look at exact (==) hits vs. equals() hits?

 *
 * @author Kevin Bourrillion
 */
public class SetContainsBenchmark {
  // Start at 4.88 then multiply by 2*2^phi <evil cackle> - The goal is be uniform
  // yet visit a variety of "values-relative-to-the-next-power-of-2"
  @Param({"5", "30", "180", "1100", "6900", "43000", "260000"}) // "1600000", "9800000"
  private int size;

  // TODO(kevinb): look at exact (==) hits vs. equals() hits?

        result.set(t.getGenericComponentType());
      }

      @Override
      void visitClass(Class<?> t) {
        result.set(t.getComponentType());
      }
    }.visit(type);
    return result.get();
  }

  /**
   * Returns {@code ? extends X} if any of {@code bounds} is a subtype of {@code X[]}; or null
   * otherwise.
   */
  @CheckForNull

        private int indexToRemove = ABSENT;
        private int expectedModCount = biMap.modCount;

        // Calls to setValue on inverse entries can move already-visited entries to the end.
        // Make sure we don't visit those.
        private int remaining = biMap.size;

        private void checkForComodification() {
          if (biMap.modCount != expectedModCount) {
            throw new ConcurrentModificationException();