this.incidentEdgeOrder = incidentEdgeOrder;
  }

  @Override
  public MutableGraph<Integer> createGraph() {
    return GraphBuilder.undirected()
        .allowsSelfLoops(allowsSelfLoops)
        .incidentEdgeOrder(incidentEdgeOrder)
        .build();
  }

  @Override
  final void addNode(Integer n) {
    graphAsMutableGraph.addNode(n);
  }

  @Override
  final void putEdge(Integer n1, Integer n2) {

  @Override
  protected ListenableFuture<String> buildChainingFuture(ListenableFuture<Integer> inputFuture) {
    return transform(inputFuture, new ComposeFunction(), directExecutor());
  }

  @Override
  protected String getSuccessfulResult() {
    return RESULT_DATA;
  }

  private class ComposeFunction implements Function<Integer, String> {
    @Override
    public String apply(Integer input) {

        && nodes().equals(other.nodes())
        && edges().equals(other.edges());
  }

  @Override
  public final int hashCode() {
    return edges().hashCode();
  }

  /** Returns a string representation of this graph. */
  @Override
  public String toString() {
    return "isDirected: "
        + isDirected()
        + ", allowsSelfLoops: "
        + allowsSelfLoops()

/**
 * An implementation of I/O for `PublicSuffixDatabase` by directly passing in ByteStrings.
 */
internal class ConfiguredPublicSuffixList : PublicSuffixList {
  override fun ensureLoaded() {
  }

  override var bytes: ByteString = ByteString.EMPTY

  override var exceptionBytes: ByteString = ByteString.EMPTY

    unfiltered.put("badkey", 1);
    return Multimaps.filterEntries(unfiltered, PREDICATE);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    Multimap<String, Integer> multimap = createMultimap();
    return multimap.asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> multimap = createMultimap();

        this.excludes = excludes;
    }

    @Override
    public boolean include(Artifact artifact) {
        String id = artifact.getArtifactId();

        if (excludes.contains(id)) {
            return false;
        }

        id = artifact.getGroupId() + ':' + id;

        return !excludes.contains(id);
    }

    @Override
    public int hashCode() {
        int hash = 17;

    private static final String CI = "CI";

    @Override
    public Optional<CIInfo> detectCI() {
        String ciEnv = System.getenv(CI);
        if (ciEnv != null && !"false".equals(ciEnv)) {
            return Optional.of(new CIInfo() {
                @Override
                public String name() {
                    return NAME;
                }

                @Override
                public String message() {

    @SuppressWarnings("rawtypes") // class literals
    @Override
    protected List<Class<? extends AbstractTester>> getTesters() {
      return Collections.<Class<? extends AbstractTester>>singletonList(MyTester.class);
    }
  }

  public void testLifecycle() {
    boolean[] setUp = {false};
    Runnable setUpRunnable =
        new Runnable() {
          @Override
          public void run() {
            setUp[0] = true;

     * element.
     */
    NEXT_LOWER {
      @Override
      int resultIndex(int higherIndex) {
        return higherIndex - 1;
      }
    },
    /**
     * Return the index of the next higher element in the list, or {@code list.size()} if there is
     * no such element.
     */
    NEXT_HIGHER {
      @Override
      public int resultIndex(int higherIndex) {
        return higherIndex;

    List<Object> invalidated = new ArrayList<>();
    Cache<Integer, Integer> cache =
        new AbstractCache<Integer, Integer>() {
          @Override
          public Integer getIfPresent(Object key) {
            throw new UnsupportedOperationException();
          }

          @Override
          public void invalidate(Object key) {
            invalidated.add(key);
          }
        };