}

    @Override
    public boolean contains(final Object o) {
        return map.containsKey(o);
    }

    @Override
    public boolean add(final String o) {
        return map.put(o, PRESENT) == null;
    }

    @Override
    public boolean remove(final Object o) {
        return map.remove(o) == PRESENT;
    }

    @Override
    public void clear() {
        map.clear();
    }

        this.delegates = delegates;
        this.coreArtifacts = coreExports.getExportedArtifacts();
    }

    private synchronized Set<String> getExcludedArtifacts() {
        if (excludedArtifacts == null) {
            excludedArtifacts = new LinkedHashSet<>(coreArtifacts);
        }
        return excludedArtifacts;
    }

    /**
     * Returns the artifact filter for the core + extension artifacts.
     *

        this.topologicallySortedProjects = topologicallySortedProjects;

        return this;
    }

    public List<MavenProject> getTopologicallySortedProjects() {
        return null == topologicallySortedProjects
                ? Collections.emptyList()
                : Collections.unmodifiableList(topologicallySortedProjects);
    }

                onDependencyFailure = FailureAction.FAIL_TO_START
                onDependencyCancel = FailureAction.FAIL_TO_START
            }
        }

        if (******@****.***sk != null) {
            steps {
                buildStep(
                    ******@****.***arameters,
                    ******@****.***rName,

            .build();

    assertThat(graph.nodes()).containsExactly("A", "B");
    assertThat(graph.edges()).containsExactly(EndpointPair.ordered("A", "B"));
    assertThat(graph.edgeValueOrDefault("A", "B", null)).isEqualTo(10);
  }

  @Test
  public void immutableValueGraphBuilder_putEdgeFromEndpointPair() {
    ImmutableValueGraph<String, Integer> graph =
        ValueGraphBuilder.directed()

    BufferedReader r = new BufferedReader(getChunkedReader(input, chunk));
    List<String> lines = Lists.newArrayList();
    String line;
    while ((line = r.readLine()) != null) {
      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

    BufferedReader r = new BufferedReader(getChunkedReader(input, chunk));
    List<String> lines = Lists.newArrayList();
    String line;
    while ((line = r.readLine()) != null) {
      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {