this.sessionId = sessionId;
        if (!cachedIncludeSet.isEmpty()) {
            try {
                getUrlFilterService().addIncludeUrlFilter(sessionId, cachedIncludeSet.stream().collect(Collectors.toList()));
            } catch (final Exception e) {
                logger.warn("Failed to add include_urls on " + sessionId, e);
            }
            cachedIncludeSet.clear();
        }

                        linkedMapOf(
                            "plugin-a" to PluginTree.PluginSpec("my.plugin-a", "my.PluginA")
                        )
                    )
                )
            ).toList(),
            equalTo(
                listOf(
                    PluginDependencySpecAccessor.ForPlugin(
                        "my-plugin",
                        "my.Plugin",
                        ExtensionSpec(

    val projectLayout = layout
    doLast {
        val collection = projectLayout.files("src/file1.txt")

        // tag::usage[]
        // Iterate over the files in the collection
        collection.forEach { file: File ->
            println(file.name)
        }

        // Convert the collection to various types
        val set: Set<File> = collection.files
        val list: List<File> = collection.toList()

        return operations.records.values().find { it.displayName ==~ displayName }
    }

    @Override
    List<BuildOperationRecord> all() {
        return operations.records.values().toList()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return operations.records.values().findAll { it.displayName ==~ displayName }
    }

    @Override

        watchingNotSupportedVfs.afterBuildFinished()
        then:
        watchingNotSupportedVfs.root == emptySnapshotHierarchy

        where:
        watchMode << WatchMode.values().toList()
    }

        def publication = Stub(PublicationInternal)

        when:
        extension.publications.add(publication)

        then:
        extension.publications.size() == 1
        extension.publications.toList().first().is(publication)
    }

    def "lifecycle task created"() {
        expect:
        project.tasks[PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME] != null
    }

import org.gradle.util.internal.CollectionUtils;

import java.util.List;

public class CompositeGroovySystemLoader implements GroovySystemLoader {
    private final List<GroovySystemLoader> loaders;

    public CompositeGroovySystemLoader(GroovySystemLoader... loaders) {
        this.loaders = CollectionUtils.toList(loaders);
    }

    @Override
    public void shutdown() {

     * @param activeProjectSelectors A {@link List} of project selectors that must be activated.
     * @deprecated Use {@link #activateOptionalProject(String)} or {@link #activateRequiredProject(String)} instead.
     */
    @Deprecated
    public void overwriteActiveProjects(List<String> activeProjectSelectors) {
        List<ProjectActivationSettings> projects = getProjects(pa -> pa.active).collect(Collectors.toList());

        this.data = Arrays.asList(lines);
    }

    String getData() {
        return JsonOutput.toJson(data);
    }

    String getTicks() {
        List<List<Object>> ticks = IntStream.range(0, data.get(0).data.size())
            .mapToObj(index -> Arrays.<Object>asList(index, index))
            .collect(Collectors.toList());
        return JsonOutput.toJson(ImmutableMap.of("ticks", ticks));
    }

                    }
                    "a1" {}
                }
                withFile("root-f1")
            }
        }

        assertThat(
            folder("root").walkReproducibly().map { it.name }.toList(),
            equalTo(
                listOf(
                    "root",
                    "root-f1", "root-f2", "a", "b", "c",
                    "a1", "a2", "b-f1", "c1",