component2.add("k")
        component3.add("l")
        component4.add("m")

        then:
        calledFor == ["j", "k", "l", "m"]

        and:
        superComposite.toSet() == ["a", "j", "b", "k", "c", "l", "d", "m"].toSet()

        when:
        superComposite.whenObjectRemoved { calledFor << it }

        and:
        calledFor.clear()
        component1.remove("j")
        component2.remove("k")

        return getProjects().stream()
                .flatMap(it -> it.getConfigurations().stream().map(VisualStudioProjectConfigurationMetadata::getName))
                .collect(Collectors.toSet());
    }

    @Nested
    public List<Action<? super TextProvider>> getSolutionFileActions() {
        return solutionFile.getTextActions();
    }

    @Override

    public WrapUtil() {
        logDeprecation(7);
    }

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

    /**

    val apiMetadataJar = gradleApiJars.single { it.name.startsWith("gradle-api-metadata") }
    val classpathDependencies = distroJars - gradleApiJars.toSet()
    val gradleApiMetadata = gradleApiMetadataFrom(apiMetadataJar, gradleApiJars)
}


private
fun builtInPluginIdExtFileIn(outputDir: File): File =

        .groupingBy { it.key }
        .aggregate { _, accumulator: Set<String>?, element: Map.Entry<String, List<String>>, first ->
            if (first) {
                element.value.toSet()
            } else {
                accumulator!!.union(element.value)
            }

        if (fieldSet == null) {
            fieldSet = split(getIndexAdminArrayFields(), ",")
                    .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.toSet()));
            propMap.put(INDEX_ADMIN_ARRAY_FIELD_SET, fieldSet);
        }
        return fieldSet;
    }

    default boolean validateIndexArrayFields(final Map<String, Object> source) {

              "math",
              "net",
              "primitives",
              "reflect",
              "util.concurrent",
              "xml")
          .transform("com.google.common."::concat)
          .toSet();

  public void testClassesHaveOverrides() throws Exception {
    for (ClassInfo info : ClassPath.from(getClass().getClassLoader()).getAllClasses()) {
      if (!GUAVA_PACKAGES.contains(info.getPackageName())) {

        assertEquals(
            setOf(ErrorReason.UnresolvedFunctionCallSignature::class, ErrorReason.UnresolvedFunctionCallArguments::class),
            outerErrors.map { it.errorReason::class }.toSet()
        )

        val innerErrors = assertNotNull(resolver.trace.expressionResolution(arg).errors)
        assertIs<ErrorReason.UnresolvedReference>(innerErrors.single().errorReason)
    }

    @Test

        !addOpensArgs.isEmpty()
        addOpensArgs.every { it.matches("--add-opens=.*?/.*?=ALL-UNNAMED") }

        and: "The required --add-opens args should not contain duplicates"
        addOpensArgs.toSet().size() == addOpensArgs.size()
    }

    def "can configure debug mode"() {
        when:
        parameters.setDebug(parseBoolean(flag))

        then:

    }

    /**
     * @return a set of all the projects managed by the build
     */
    public Set<MavenProject> getProjects() {
        return items.stream().map(ProjectSegment::getProject).collect(Collectors.toSet());
    }