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

  /**

        entries.addAll(getEntriesFromSourceDirs(wtp));
        for (WbResource element : wtp.getResources()) {
            if (wtp.getProject().file(element.getSourcePath()).isDirectory()) {
                entries.add(element);
            }
        }
        entries.addAll(wtp.getProperties());
        Project project = wtp.getProject();

    assertTrue(
        "add(somePresent) should return true", getSet().addAll(MinimalCollection.of(e3(), e0())));
    expectAdded(e3());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_withDuplicates() {
    MinimalCollection<E> elementsToAdd = MinimalCollection.of(e3(), e4(), e3(), e4());
    assertTrue("add(hasDuplicates) should return true", getSet().addAll(elementsToAdd));
    expectAdded(e3(), e4());
  }

        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) {
        Set<T> coll = new LinkedHashSet<T>();
        Collections.addAll(coll, items);
        return coll;
    }

    /**