// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapEntrySetTester<K, V> extends AbstractMapTester<K, V> {
  private enum IncomparableType {
    INSTANCE;
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  public void testIteratorRemoveOnly() {
    Set<Entry<K, V>> entrySet = getMap().entrySet();

    this.equivalence = checkNotNull(equivalence);
  }

  /**
   * Different orderings for combining the elements of an input array, which must all produce the
   * same result.
   */
  enum CollectStrategy {
    /** Get one accumulator and accumulate the elements into it sequentially. */
    SEQUENTIAL {
      @Override
      final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

   *       Some methods may have stronger guarantees.
   *   <li>INSERTION: insertion ordering is guaranteed.
   *   <li>SORTED: ordering according to a supplied comparator is guaranteed.
   * </ul>
   */
  public enum Type {
    UNORDERED,
    STABLE,
    INSERTION,
    SORTED
  }

  private ElementOrder(Type type, @Nullable Comparator<T> comparator) {
    this.type = checkNotNull(type);
    this.comparator = comparator;

    assertThat(ComparisonChain.start().compareTrueFirst(false, true).result()).isGreaterThan(0);
    assertThat(ComparisonChain.start().compareTrueFirst(false, false).result()).isEqualTo(0);
  }

  enum TriState {
    FALSE,
    MAYBE,
    TRUE,
  }

  static class Foo {
    private final String aString;
    private final int anInt;
    private final @Nullable TriState anEnum;

   *       Some methods may have stronger guarantees.
   *   <li>INSERTION: insertion ordering is guaranteed.
   *   <li>SORTED: ordering according to a supplied comparator is guaranteed.
   * </ul>
   */
  public enum Type {
    UNORDERED,
    STABLE,
    INSERTION,
    SORTED
  }

  private ElementOrder(Type type, @Nullable Comparator<T> comparator) {
    this.type = checkNotNull(type);
    this.comparator = comparator;

 *
 * <p>Note: the Apache benchmarks are not open sourced to avoid the extra dependency.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ApacheBenchmark {
  private enum Impl {
    GUAVA {
      @Override
      public double factorialDouble(int n) {
        return DoubleMath.factorial(n);
      }

      @Override
      public int gcdInt(int a, int b) {

        ClassOwnership.JVM_BEHAVIOR.getOwnerType(rawType), rawType, arguments);
  }

  /** Decides what owner type to use for constructing {@link ParameterizedType} from a raw class. */
  private enum ClassOwnership {
    OWNED_BY_ENCLOSING_CLASS {
      @Override
      @Nullable Class<?> getOwnerType(Class<?> rawType) {
        return rawType.getEnclosingClass();
      }
    },
    LOCAL_CLASS_HAS_NO_OWNER {

     * @param <V> the value type of {@link EnumMap}
     * @param keyType the class object of the key type for this {@literal enum} map
     * @return a new instance of {@link EnumMap}
     * @see EnumMap#EnumMap(Class)
     */
    public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(final Class<K> keyType) {
        return new EnumMap<>(keyType);
    }

    /**

        });
    }

    @Override
    public void visit(EnumDeclaration enumDeclaration, ClassMetaDataRepository<ClassMetaData> repository) {
        visitTypeDeclaration(enumDeclaration, repository, MetaType.ENUM, () -> {
            visitImplementedTypes(enumDeclaration);
            enumDeclaration.getEntries().forEach(entry -> getCurrentClass().addEnumConstant(entry.getNameAsString()));
            super.visit(enumDeclaration, repository);

     */
    protected GeoInfo createGeoInfo(final HttpServletRequest request) {
        return new GeoInfo(request);
    }

    /**
     * The search request type.
     */
    public enum SearchRequestType {
        /** Search request type. */
        SEARCH,
        /** Admin search request type. */
        ADMIN_SEARCH,
        /** JSON request type. */
        JSON,