}

    private boolean isClassFieldConstructorOrMethod(JApiCompatibility member) {
        return member instanceof JApiClass || member instanceof JApiField || member instanceof JApiConstructor || member instanceof JApiMethod;
    }

    private boolean isInject(JApiCompatibility member) {
        return member instanceof JApiHasAnnotations && isInject((JApiHasAnnotations) member);
    }

        if (o == null) {
            return null;
        } else if (o instanceof Long) {
            return (Long) o;
        } else if (o instanceof Number) {
            return ((Number) o).longValue();
        } else if (o instanceof String) {
            return toLong((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

        if (o == null) {
            return null;
        } else if (o instanceof Double) {
            return (Double) o;
        } else if (o instanceof Number) {
            return new Double(((Number) o).doubleValue());
        } else if (o instanceof String) {
            return toDouble((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

            final Object searchFieldObj = source.get("searchField");
            if (searchFieldObj instanceof Map) {
                ((Map<String, ?>) searchFieldObj).entrySet().stream().forEach(e -> {
                    if (e.getValue() instanceof String[]) {
                        final String[] values = (String[]) e.getValue();
                        for (final String v : values) {

        super(params);
    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {
        if (member instanceof JApiMethod || member instanceof JApiField || member instanceof JApiClass || member instanceof JApiConstructor) {
            if (!isIncubating((JApiHasAnnotations) member) && !isInject((JApiHasAnnotations) member)) {
                return violationError(member);
            }

      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
    }
  }

  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
    private static final long serialVersionUID = 1L;

    @Override
    public boolean equals(@Nullable Object other) {
      return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
    }

    @Override

        }
        if (clazz.isAssignableFrom(Date.class)) {
            if (value instanceof Date) {
                return (T) value;
            }
            return (T) FessFunctions.parseDate(value.toString());
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (value instanceof Long) {
                return (T) value;
            }

    assertTrue(descendingSet instanceof SynchronizedNavigableSet);
    assertSame(set, ((SynchronizedNavigableSet<String>) descendingSet).mutex);
  }

  public void testHeadSet_E() {
    NavigableSet<String> set = create();
    SortedSet<String> headSet = set.headSet("a");
    assertTrue(headSet instanceof SynchronizedSortedSet);

  public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);
    assertTrue(multimap.get("foo") instanceof RandomAccess);
    assertTrue(multimap.get("bar") instanceof RandomAccess);
  }

  /** Confirm that removeAll() returns a List implementing RandomAccess. */
  public void testRemoveAllRandomAccess() {
    Multimap<String, Integer> multimap = create();

     */
    @Override
    public InetAddress toInetAddress () throws UnknownHostException {
        if ( this.addr instanceof Address ) {
            return ( (Address) this.addr ).toInetAddress();
        }
        else if ( this.addr instanceof InetAddress ) {
            return (InetAddress) this.addr;
        }
        return null;
    }


    /**
     * {@inheritDoc}
     *