Node: statsapi.NodeStats{
					CPU: &statsapi.CPUStats{
						Time:                 testTime,
						UsageCoreNanoSeconds: uint64Ptr(10000000000),
					},
					Memory: &statsapi.MemoryStats{
						Time:            testTime,
						WorkingSetBytes: uint64Ptr(1000),
					},
					Swap: &statsapi.SwapStats{
						Time:           testTime,
						SwapUsageBytes: uint64Ptr(500),
					},
				},
			},
			summaryErr: nil,

        def treeWithNoIncludesOrExcludes = new DirectoryFileTree(temporaryFolder.getTestDirectory(), new PatternSet(), TestFiles.fileSystem(), false)
        def includesOnly = new PatternSet()
        includesOnly.include("a/b", "c")
        def treeWithIncludes = new DirectoryFileTree(temporaryFolder.getTestDirectory(), includesOnly, TestFiles.fileSystem(), false)
        def excludesOnly = new PatternSet()
        excludesOnly.exclude("a/b", "c")

import org.gradle.api.internal.file.TestFiles
import org.gradle.api.tasks.SourceSet
import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultSourceSetContainerTest extends Specification {

    def "can create a source set"() {
        given:

							slog.Any("error", testError),
							slog.String("string", testString),
							slog.Int("status", testInt),
							slog.Duration("duration", testDuration),
							slog.Time("time", testTime),
							slog.Any("error", testError),
							slog.String("string", testString),
							slog.Int("status", testInt),
							slog.Duration("duration", testDuration),
							slog.Time("time", testTime),

 */

package org.gradle.workers.internal

import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.classloader.ClassLoaderSpec
import org.gradle.process.JavaForkOptions
import spock.lang.Specification

import static org.gradle.api.internal.file.TestFiles.execFactory
import static org.gradle.api.internal.file.TestFiles.systemSpecificAbsolutePath

class DaemonForkOptionsTest extends Specification {

                    : temporaryFolder.file(it)
            }
            def snapshot = snapshotter.snapshot(TestFiles.fixed(files)).snapshot
            builder.put(propertyName, snapshot)
        }
        return builder.build()
    }

    FileSystemLocationSnapshot snapshot(File file) {
        snapshotter.snapshot(TestFiles.fixed(file)).snapshot as FileSystemLocationSnapshot
    }

            resourceHandlerFactory,
            fileCollectionFactory,
            TestUtil.objectFactory(),
            TestFiles.fileSystem(),
            TestFiles.patternSetFactory,
            TestFiles.deleter(),
            TestFiles.documentationRegistry(),
            TestFiles.taskDependencyFactory(),
            TestUtil.providerFactory(),

    @Override
    protected List<DirectoryWalker> getWalkers() {
        return [
            new DefaultDirectoryWalker(TestFiles.fileSystem()),
            new ReproducibleDirectoryWalker(TestFiles.fileSystem())
        ]
    }

    def "both DirectoryWalker implementations return same set of files and attributes"() {
        given:
        def rootDir = tmpDir.createDir("root")

    }

    static String[] removeAllParentheses(String... testNames) {
        testNames.collect { removeParentheses(it) } as String[]
    }

    static String[][] removeAllParentheses(String[]... testNames) {
        testNames.collect { [removeParentheses(it[0]), it[1]] } as String[][]
    }

    static TestCase testCase(String name) {

     */
    default TestClassExecutionResult assertTestOutcomes(TestOutcome status, String... testNames) {
        if (status == TestOutcome.SKIPPED) {
            return assertTestsSkipped(testNames);
        }
        for (String testName : testNames) {
            switch (status) {
                case PASSED:
                    assertTestPassed(testName);
                    break;