}

  public <A> void testSerializable_typeVariableNotSupported() {
    assertThrows(RuntimeException.class, () -> new ITryToSerializeMyTypeVariable<String>().go());
  }

  private static class ITryToSerializeMyTypeVariable<T> {
    void go() {
      SerializableTester.reserialize(TypeToken.of(new TypeCapture<T>() {}.capture()));
    }
  }

  @CanIgnoreReturnValue

    }

    // Guarded By Segment.this
    <K, V> void copyAccessEntry(ReferenceEntry<K, V> original, ReferenceEntry<K, V> newEntry) {
      // TODO(fry): when we link values instead of entries this method can go
      // away, as can connectAccessOrder, nullifyAccessOrder.
      newEntry.setAccessTime(original.getAccessTime());

      connectAccessOrder(original.getPreviousInAccessQueue(), newEntry);

    /** The key of the message: CSS */
    public static final String LABELS_facet_filetype_css = "{labels.facet_filetype_css}";

    /** The key of the message: Go */
    public static final String LABELS_facet_filetype_go = "{labels.facet_filetype_go}";

    /** The key of the message: Groovy */
    public static final String LABELS_facet_filetype_groovy = "{labels.facet_filetype_groovy}";

     * type. So why even make that error possible by giving callers the choice?
     *
     * On the other hand, the current signature is consistent with the similar allAsList method. And
     * eventually this method may go away entirely in favor of an API like
     * whenAllComplete().collectSuccesses(). That API would have a signature more like the current
     * one.
     */
    return new ListFuture<V>(ImmutableList.copyOf(futures), false);

      }
      return next;
    }
  }

  private static class ConcatenatedIterator<T extends @Nullable Object> implements Iterator<T> {
    /* The last iterator to return an element.  Calls to remove() go to this iterator. */
    @CheckForNull private Iterator<? extends T> toRemove;

    /* The iterator currently returning elements. */
    private Iterator<? extends T> iterator;

    /*

 * <p>
 * Note that this is different from calling <tt>getSecurity</tt> on a
 * share. There are actually two different ACLs for shares - the ACL on
 * the share and the ACL on the folder being shared.
 * Go to <i>Computer Management</i>
 * &gt; <i>System Tools</i> &gt; <i>Shared Folders</i> &gt <i>Shares</i> and
 * look at the <i>Properties</i> for a share. You will see two tabs - one