assertTrue(
        "addAll(allPresent) should return true", getList().addAll(MinimalCollection.of(e0())));
    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedAllPresent() {
    try {
      getList().addAll(MinimalCollection.of(e0()));
      fail("addAll(allPresent) should throw");

            this.tasksToRun.addAll(Arrays.asList(taskToRun))
            this
        }

        InvocationBuilder tasksToRun(Iterable<String> taskToRun) {
            this.tasksToRun.addAll(taskToRun)
            this
        }

        InvocationBuilder jvmOpts(String... args) {
            this.jvmOpts.addAll(Arrays.asList(args))
            this
        }

        def dep2 = new SimpleDependency("dep2")
        def dep21 = new SimpleDependency("dep2.1")
        def dep22 = new SimpleDependency("dep2.2")

        root.children.addAll(dep1, dep2)
        dep1.children.addAll(dep11)
        dep2.children.addAll(dep21, dep22)

        when:
        renderer.render([root])
        renderer.complete()

        then:
        textOutput.value.readLines() == [

    override fun getPossibleCallableNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleCallableNames())
        addAll(secondWrappedScope.getPossibleCallableNames())
    }

    override fun getPossibleClassifierNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleClassifierNames())
        addAll(secondWrappedScope.getPossibleClassifierNames())
    }

    def baseline = new BaselineVersion("7.5")
    def current = new BaselineVersion("7.6")

    def "does consider changes with high confidence"() {
        baseline.results.addAll([millis(100)] * 10)
        current.results.addAll([millis(115)] * 10)
        def confidence = calculateConfidence(baseline, current)
        def minConfidence = confidence - 0.01

        expect:

    assertTrue(
        "addAll(allPresent) should return true", getList().addAll(MinimalCollection.of(e0())));
    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedAllPresent() {
    try {
      getList().addAll(MinimalCollection.of(e0()));
      fail("addAll(allPresent) should throw");

        return includeRoots;
    }

    @Override
    public void include(File... includeRoots) {
        Collections.addAll(this.includeRoots, includeRoots);
    }

    @Override
    public void include(Iterable<File> includeRoots) {
        addAll(this.includeRoots, includeRoots);
    }

    @Override
    public List<File> getSystemIncludeRoots() {
        return systemIncludeRoots;
    }

    }

    @Override
    public void objectFiles(Iterable<File> objectFiles) {
        addAll(this.objectFiles, objectFiles);
    }

    @Override
    public List<File> getLibraries() {
        return libraries;
    }

    @Override
    public void libraries(Iterable<File> libraries) {
        addAll(this.libraries, libraries);
    }

    @Override
    public List<File> getLibraryPath() {

        given:
        def property = multiValueProperty()
        Collection<String> collection = newCollection(property)

        when:
        property.add("first")
        property.addAll(["second", "third"])
        collection.addAll(["forth", "fifth"])

        then:
        collection.containsAll(["first", "second", "third", "forth", "fifth"])

        when:
        collection.remove("third")

        then:

        set.addAll(Arrays.asList(items));
        return set;
    }

    /**
     * Wraps the given items in a mutable ordered set.
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> Set<T> toLinkedSet(T... items) {
        logDeprecation(7);
        Set<T> coll = new LinkedHashSet<T>();
        Collections.addAll(coll, items);
        return coll;
    }