@AndroidIncompatible
@RunWith(Parameterized.class)
@NullUnmarked
public final class StandardImmutableUndirectedGraphTest
    extends AbstractStandardUndirectedGraphTest {

  @Parameters(name = "allowsSelfLoops={0}")
  public static Collection<Object[]> parameters() {
    return Arrays.asList(new Object[][] {{false}, {true}});
  }

  private final boolean allowsSelfLoops;
  private ImmutableGraph.Builder<Integer> graphBuilder;

    private static final long serialVersionUID = 1L;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    private static final long serialVersionUID = 1L;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

   *
   * @since 10.0
   */
  public static final class SimpleStatsCounter implements StatsCounter {
    private final LongAddable hitCount = LongAddables.create();
    private final LongAddable missCount = LongAddables.create();
    private final LongAddable loadSuccessCount = LongAddables.create();
    private final LongAddable loadExceptionCount = LongAddables.create();
    private final LongAddable totalLoadTime = LongAddables.create();

 * anyway, so we just need to get by without the annotations here until Kotlin better understands
 * our other nullness annotations.
 */
final class Synchronized {
  private Synchronized() {}

  private static class SynchronizedObject implements Serializable {
    final Object delegate;
    final Object mutex;

    SynchronizedObject(Object delegate, @Nullable Object mutex) {
      this.delegate = checkNotNull(delegate);

 * anyway, so we just need to get by without the annotations here until Kotlin better understands
 * our other nullness annotations.
 */
final class Synchronized {
  private Synchronized() {}

  private static class SynchronizedObject implements Serializable {
    final Object delegate;
    final Object mutex;

    SynchronizedObject(Object delegate, @Nullable Object mutex) {
      this.delegate = checkNotNull(delegate);

     */
    public CIFSUnsupportedCryptoException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a CIFS unsupported crypto exception with the specified detail message.
     *
     * @param message the detail message
     */
    public CIFSUnsupportedCryptoException(final String message) {
        super(message);
    }

    /**

     */
    public TransportException(final Throwable rootCause) {
        super(rootCause);
    }

    /**
     * Constructs a new TransportException with the specified detail message and cause.
     * @param msg the detail message
     * @param rootCause the cause of this exception
     */
    public TransportException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

     */
    public SMBProtocolDowngradeException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a new SMBProtocolDowngradeException with the specified detail message.
     *
     * @param message the detail message
     */
    public SMBProtocolDowngradeException(final String message) {
        super(message);
    }

    /**

    /** The original stopword. */
    private final String input;

    /** The new stopword, if updated. */
    private String newInput;

    /**
     * Constructs a new stopword item.
     *
     * @param id    The unique identifier of the item.
     * @param input The stopword.
     */
    public StopwordsItem(final long id, final String input) {
        this.id = id;
        this.input = input;