if (iterable instanceof Collection) {
      Collection<? extends T> c = (Collection<? extends T>) iterable;
      if (c.isEmpty()) {
        return defaultValue;
      } else if (iterable instanceof List) {
        return getLastInNonemptyList((List<? extends T>) iterable);
      } else if (iterable instanceof SortedSet) {
        return ((SortedSet<? extends T>) iterable).last();

   * called on the {@code TypeVariable} instance has the same 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 who obtain an instance

    }

    public void test_inheritance() {
        DocList docList = new DocList();

        assertTrue(docList instanceof java.util.ArrayList);
        assertTrue(docList instanceof java.util.List);
        assertTrue(docList instanceof java.util.Collection);
    }

        if (src == null) {
            return null;
        }
        if (src instanceof java.sql.Date) {
            return (java.sql.Date) src;
        }
        if (src instanceof Date) {
            return new java.sql.Date(((Date) src).getTime());
        }
        if (src instanceof Calendar) {
            return new java.sql.Date(((Calendar) src).getTimeInMillis());
        }

  private static void rethrow(ExecutionException e) throws ExecutionException {
    Throwable wrapper = e.getCause();
    if (wrapper instanceof WrapperException) {
      Throwable cause = wrapper.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else if (cause instanceof Error) {
        throw (Error) cause;
      }
    }
    throw e;
  }

  @Override

    //            (__)\       )\/\
    //                ||----w |
    //                ||     ||
    Runnable state = get();
    Blocker blocker = null;
    while (state instanceof Blocker || state == PARKED) {
      if (state instanceof Blocker) {
        blocker = (Blocker) state;
      }
      spinCount++;
      if (spinCount > MAX_BUSY_WAIT_SPINS) {
        /*

        QueryBuilder queryBuilder = queryCommand.convertWildcardQuery(queryContext, wildcardQuery, 1.0f);
        assertNotNull(queryBuilder);
        assertTrue(queryBuilder instanceof DefaultQueryBuilder);

        // Query was processed successfully
    }

    public void test_convertWildcardQuery_defaultField_dismax() throws Exception {
        // Test with default field

        LdapOperationException exception = new LdapOperationException("Test");

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    public void test_serialVersionUID() {
        // Test that exception is serializable

    Iterable<? extends E> iterable = elements;
    return copyOf(iterable);
  }

  public static <E> ImmutableSet<E> copyOf(Iterable<? extends E> elements) {
    if (elements instanceof ImmutableSet && !(elements instanceof ImmutableSortedSet)) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableSet<E> set = (ImmutableSet<E>) elements;
      return set;
    }

        if (e.getCause() instanceof MultipleArtifactsNotFoundException) {
            return true;
        }
        return e.getCause() instanceof org.eclipse.aether.resolution.ArtifactResolutionException
                && e.getCause().getCause() instanceof ArtifactNotFoundException;
    }

    private boolean isNonTransferablePom(Exception e) {
        if (e.getCause() instanceof ArtifactResolutionException) {