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();

        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) {

            assertEquals(1, result.intValue());
        } catch (Exception e) {
            // Expected behavior when components are not fully initialized
            assertTrue(e.getCause() instanceof NullPointerException || e.getCause() instanceof ContainerNotAvailableException);
        } finally {
            tempPropFile.delete();
        }
    }

    @Test

                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();

      return new short[buckets];
    } else {
      return new int[buckets];
    }
  }

  static void tableClear(Object table) {
    if (table instanceof byte[]) {
      Arrays.fill((byte[]) table, (byte) 0);
    } else if (table instanceof short[]) {
      Arrays.fill((short[]) table, (short) 0);
    } else {
      Arrays.fill((int[]) table, 0);
    }
  }

  /**

  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();

        // Test that DictionaryException is instance of FessSystemException
        DictionaryException exception = new DictionaryException("Test");

        assertTrue(exception instanceof org.codelibs.fess.exception.FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test

    public void testFromClass_FileSystem() throws Exception {
        final Traverser traverser = TraversalUtil.getTraverser(DummyTest.class);
        assertThat(traverser, is(notNullValue()));
        assertThat(traverser instanceof FileSystemTraverser, is(true));

        assertThat(traverser.isExistClass(DummyTest.class.getName()), is(true));
        assertThat(traverser.isExistClass(TestCase.class.getName()), is(not(true)));

    assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  public void testTreeKeys_gwtCompatible() {
    ListMultimap<String, Integer> multimap =
        rawtypeToWildcard(MultimapBuilder.treeKeys()).arrayListValues().<String, Integer>build();
    assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);

    assertTrue(descendingKeySet instanceof SynchronizedNavigableSet);
    assertThat(((SynchronizedNavigableSet<String>) descendingKeySet).mutex).isSameInstanceAs(mutex);
  }

  public void testDescendingMap() {
    NavigableMap<String, Integer> map = create();
    NavigableMap<String, Integer> descendingMap = map.descendingMap();
    assertTrue(descendingMap instanceof SynchronizedNavigableMap);