private <T> Collection<T> getExtensionComponents(Collection<MavenProject> projects, Class<T> role) {
        Collection<T> foundComponents = new LinkedHashSet<>();
        foundComponents.addAll(lookup.lookupList(role));
        foundComponents.addAll(getProjectScopedExtensionComponents(projects, role));
        return foundComponents;
    }

    def quiet(String... msgs) {
        quietMessages.addAll(msgs)
    }
    def error(String... msgs) {
        errorMessages.addAll(msgs)
    }
    def warning(String... msgs) {
        warningMessages.addAll(msgs)
    }
    def lifecycle(String... msgs) {
        warningMessages.addAll(msgs)
    }
    def info(String... msgs) {
        infoMessages.addAll(msgs)
    }
    def debug(String... msgs) {

        return new GroovyClass(concat(files, other));
    }

    private Iterable<File> concat(List<File> files1, Collection<File> files2) {
        List<File> result = new ArrayList<File>();
        result.addAll(files1);
        result.addAll(files2);
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }

                .addAll(additional.applicationClasspath)
                .addAll(additional.applicationModulepath)
                .build();
            List<TestFrameworkDistributionModule> additionalImplementationClasspath = ImmutableList.<TestFrameworkDistributionModule>builder()
                .addAll(additional.implementationClasspath)
                .addAll(additional.implementationModulepath)

            Set<MavenProject> selectedProjects = new HashSet<>(requiredSelectors.size() + optionalSelectors.size());
            selectedProjects.addAll(
                    projectSelector.getRequiredProjectsBySelectors(request, allSortedProjects, requiredSelectors));
            selectedProjects.addAll(
                    projectSelector.getOptionalProjectsBySelectors(request, allSortedProjects, optionalSelectors));

            return parent.containsAll(c);
        }

        @Override
        public boolean addAll(final Collection<? extends E> c) {
            return parent.addAll(c);
        }

        @Override
        public boolean addAll(final int index, final Collection<? extends E> c) {
            return parent.addAll(index, c);
        }

        @Override
        public boolean removeAll(final Collection<?> c) {

        Collection<String> versions = new LinkedHashSet<>();

        if (buildReactor != null) {
            versions.addAll(buildReactor.findVersions(artifact));
        }

        if (ideWorkspace != null) {
            versions.addAll(ideWorkspace.findVersions(artifact));
        }

        versions.addAll(userLocalArtifactRepository.findVersions(artifact));

        return Collections.unmodifiableList(new ArrayList<>(versions));

    @Override
    public void setEvents(Iterable<?> events) {
        this.events = toEnumSet(TestLogEvent.class, events);
    }

    @Override
    public void events(Object... events) {
        this.events.addAll(toEnumSet(TestLogEvent.class, events));
    }

    @Override
    public int getMinGranularity() {
        return minGranularity;
    }

    @Override
    public void setMinGranularity(int granularity) {

    final List<String> includes = []
    final List<String> includeBuilds = []

    SettingsBuilder include(String... other) {
        includes.addAll(other)
        this
    }

    SettingsBuilder includeBuild(String... other) {
        includeBuilds.addAll(other)
        this
    }

    void generate(GradleDsl dsl, TestFile projectDir) {
        switch (dsl) {
            case GradleDsl.GROOVY:

        ImmutableList.Builder<DependencyMetadata> allDependencies = ImmutableList.builderWithExpectedSize(expectedSize);
        allDependencies.addAll(superDependencies);
        allDependencies.addAll(syntheticDependencies);
        return allDependencies.build();
    }