@Override
      public boolean equals(@CheckForNull Object that) {
        if (that instanceof Pred) {
          return this.node.equals(((Pred<?>) that).node);
        } else {
          return false;
        }
      }

      @Override
      public int hashCode() {
        // Adding the class hashCode to avoid a clash with Succ instances.
        return Pred.class.hashCode() + node.hashCode();
      }
    }

    checkNotNull(type);
    if (type instanceof TypeVariable) {
      return typeTable.resolve((TypeVariable<?>) type);
    } else if (type instanceof ParameterizedType) {
      return resolveParameterizedType((ParameterizedType) type);
    } else if (type instanceof GenericArrayType) {
      return resolveGenericArrayType((GenericArrayType) type);
    } else if (type instanceof WildcardType) {

        if (member instanceof JApiClass) {
            return isIncubatingClass((JApiClass) member)
        }
        if (member instanceof JApiMethod) {
            return isIncubatingOrOverrideMethod((JApiMethod) member)
        }
        if (member instanceof JApiField) {
            return isIncubatingField((JApiField) member)
        }
        if (member instanceof JApiConstructor) {

                return oldDocList;
            }

            @Override
            public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {
                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {
                    termsQueryBuilder.values().stream().forEach(o -> deletedDocIdList.add(o.toString()));
                }
                return deletedDocIdList.size();

        .addEqualityGroup(Predicates.instanceOf(Number.class))
        .addEqualityGroup(Predicates.instanceOf(Float.class))
        .testEquals();
  }

  @J2ktIncompatible
  @GwtIncompatible // Predicates.instanceOf, SerializableTester
  public void testIsInstanceOf_serialization() {
    checkSerialization(Predicates.instanceOf(Integer.class));
  }

  @J2ktIncompatible

   * name as one of the public methods of {@link TypeVariableImpl}, the proxy calls the same method
   * on its instance of {@code TypeVariableImpl}. Otherwise it throws {@link
   * UnsupportedOperationException}; this should only apply to {@code getAnnotatedBounds()}. This
   * does mean that users on Java 8 who obtain an instance of {@code TypeVariable} from {@link

      return indexOf(target) >= 0;
    }

    @Override
    public int indexOf(@CheckForNull Object target) {
      return target instanceof Long ? parent.indexOf((Long) target) : -1;
    }

    @Override
    public int lastIndexOf(@CheckForNull Object target) {
      return target instanceof Long ? parent.lastIndexOf((Long) target) : -1;
    }

    @Override
    public List<Long> subList(int fromIndex, int toIndex) {

    }

    @Override
    public int indexOf(@CheckForNull Object target) {
      return target instanceof Integer ? parent.indexOf((Integer) target) : -1;
    }

    @Override
    public int lastIndexOf(@CheckForNull Object target) {
      return target instanceof Integer ? parent.lastIndexOf((Integer) target) : -1;
    }

    @Override

    return !disjoint(a, b);
  }

  private static Method extractMethod(Test test) {
    if (test instanceof AbstractTester) {
      AbstractTester<?> tester = (AbstractTester<?>) test;
      return getMethod(tester.getClass(), tester.getTestMethodName());
    } else if (test instanceof TestCase) {
      TestCase testCase = (TestCase) test;
      return getMethod(testCase.getClass(), testCase.getName());

        final List<String[]> readings = new ArrayList<>();
        for (int i = 0;; i++) {
            final Object readingObj = source.get(FieldNames.READING_PREFIX + i);
            if (!(readingObj instanceof List)) {
                break;
            }
            @SuppressWarnings("unchecked")
            final List<String> list = (List<String>) readingObj;
            readings.add(list.toArray(new String[list.size()]));