// Overridden to prevent a ton of boxing
      return (target instanceof Short) && Shorts.indexOf(array, (Short) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Short) {
        int i = Shorts.indexOf(array, (Short) target, start, end);
        if (i >= 0) {

  }

  @WeakOuter
  private final class CellSet extends AbstractSet<Cell<R, C, V>> {
    @Override
    public boolean contains(@Nullable Object o) {
      if (o instanceof Cell) {
        Cell<?, ?, ?> cell = (Cell<?, ?, ?>) o;
        Map<C, V> row = safeGet(rowMap(), cell.getRowKey());
        return row != null
            && Collections2.safeContains(

     */
    static <T> @Nullable ObjectCountHashMap<T> tryGetMap(Iterable<T> multiset) {
      if (multiset instanceof RegularImmutableMultiset) {
        return ((RegularImmutableMultiset<T>) multiset).contents;
      } else if (multiset instanceof AbstractMapBasedMultiset) {
        return ((AbstractMapBasedMultiset<T>) multiset).backingMap;
      } else {
        return null;
      }
    }

    public void test_instanceOfFessSystemException() {
        // Test that ContainerNotAvailableException is an instance of FessSystemException
        ContainerNotAvailableException exception = new ContainerNotAvailableException("test");
        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
    }

    @Test
    public void test_serialVersionUID() {

      if (error instanceof ExecutionException) {
        /*
         * Cast to ExecutionException to satisfy our nullness checker, which (unsoundly but
         * *usually* safely) assumes that getCause() returns non-null on an ExecutionException.
         */
        CombinedFuture.this.setException(((ExecutionException) error).getCause());
      } else if (error instanceof CancellationException) {
        cancel(false);

      Collection<E> collection) {
    if (collection instanceof NavigableSet) {
      return unmodifiableNavigableSet((NavigableSet<E>) collection);
    } else {
      return unmodifiableSortedSet((SortedSet<E>) collection);
    }
  }

  @Override
  Collection<V> wrapCollection(@ParametricNullness K key, Collection<V> collection) {
    if (collection instanceof NavigableSet) {

 *
 * @author Ben Yu
 */
abstract class TypeCapture<T> {

  /** Returns the captured type. */
  final Type capture() {
    Type superclass = getClass().getGenericSuperclass();
    checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass);
    return ((ParameterizedType) superclass).getActualTypeArguments()[0];
  }

      ImmutableEntry<E> bucketHead = hashTable[bucket];
      ImmutableEntry<E> newEntry;
      if (bucketHead == null) {
        boolean canReuseEntry =
            entry instanceof ImmutableEntry && !(entry instanceof NonTerminalEntry);
        newEntry =
            canReuseEntry ? (ImmutableEntry<E>) entry : new ImmutableEntry<E>(element, count);
      } else {

    // implementation, it _may_ require iteration over the entire collection (e.g., a
    // FilteredCollection), which we want to avoid.
    if (values instanceof List || values instanceof ImmutableCollection) {
      return uniqueIndex(
          values.iterator(),
          keyFunction,
          ImmutableMap.builderWithExpectedSize(((Collection<?>) values).size()));
    }

    public boolean isOrdered() {
      return true;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj == this) {
        return true;
      }
      if (!(obj instanceof EndpointPair)) {
        return false;
      }

      EndpointPair<?> other = (EndpointPair<?>) obj;
      if (isOrdered() != other.isOrdered()) {
        return false;
      }