}

    @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;
    }

        result1.version('5.0-mockbaseline-1').results.addAll(measuredOperations([1]))
        result1.version('master').results.addAll(measuredOperations([2]))

        CrossVersionPerformanceResults result2 = crossVersionResults([startTime: 200])
        result2.version('5.0-mockbaseline-2').results.addAll(measuredOperations([2, 2]))
        result2.version('master').results.addAll(measuredOperations([1, 1]))

        buildFile << """
            container.all {
                println "all called on " + it
            }
            def list = objects.listProperty(Base)
            list.addAll(create(Base))
            container.addAllLater(list)
        """
        expect:
        succeeds("help")
        outputContains("all called on ")
    }

    override fun getResolutionScope(module: KtModule): GlobalSearchScope {
        val allModules = topologicalSort(listOf(module)) {
            buildList {
                addAll(directDependsOnDependencies)
                addAll(directFriendDependencies)
                addAll(directRegularDependencies)
            }
        }

        return GlobalSearchScope.union(allModules.map { it.contentScope })
    }

        return nestedReferences;
    }

    public void addNestedReferences(InputReferences inputReferences) {
        nestedReferences.addAll(inputReferences.getOwnReferences());
        nestedReferences.addAll(inputReferences.getNestedReferences());
    }

    /**
     * Used from generated code, see {@link RuleVisitor#visitGeneratedClosure(org.codehaus.groovy.ast.ClassNode)}
     */

            SetWithFewActions<T> compositeSet = Cast.uncheckedNonnullCast(action);
            return addAll(compositeSet);
        }
        if (action instanceof SetWithManyActions) {
            SetWithManyActions<T> compositeSet = Cast.uncheckedNonnullCast(action);
            return addAll(compositeSet);
        }
        return addOne(action);
    }

        expect:
        def dispatch1 = BroadcastDispatch.empty(TestListener)
        dispatch1.addAll([]).is(dispatch1)

        def dispatch2 = dispatch1.add(listener1)
        dispatch2.addAll([listener1, listener1]).is(dispatch2)

        def dispatch3 = dispatch2.add(listener2)
        dispatch3.addAll([listener2, listener1]).is(dispatch3)
    }

    def "can remove multiple listeners as a batch"() {

  }

  /**
   * Adds the given values to the dataset. The stream will be completely consumed by this method.
   *
   * @param values a series of values
   * @since 28.2
   */
  public void addAll(IntStream values) {
    addAll(values.collect(StatsAccumulator::new, StatsAccumulator::add, StatsAccumulator::addAll));
  }

  /**