}
    }

    private static void rollbackStashedFiles(List<StashedFile> stashedFiles) {
        stashedFiles.forEach(StashedFile::unstash);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Restoring stashed files: {}", stashedFiles.stream().map(f -> f.sourceFile.getAbsolutePath()).sorted().collect(Collectors.toList()));
        }
    }

    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
    }

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

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() {

                        performanceResults.setTasks(ResultsStoreHelper.toList(testExecutions.getObject(5)));
                        performanceResults.setArgs(ResultsStoreHelper.toList(testExecutions.getObject(6)));
                        performanceResults.setGradleOpts(ResultsStoreHelper.toList(testExecutions.getObject(7)));
                        performanceResults.setDaemon((Boolean) testExecutions.getObject(8));

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

import java.util.zip.ZipOutputStream
import javax.inject.Inject
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.set
import kotlin.streams.toList


typealias LeftoverFiles = Map<File, List<String>>


abstract class TestFilesCleanupService @Inject constructor(
    private val fileSystemOperations: FileSystemOperations