new TestFileHelper(this).tgzTo(tarFile, readOnly);
        return this;
    }

    public TestFile tbzTo(TestFile tarFile) {
        return tbzTo(tarFile, false);
    }

    public TestFile tbzTo(TestFile tarFile, boolean readOnly) {
        new TestFileHelper(this).tbzTo(tarFile, readOnly);
        return this;
    }

                def testFile = file("$buildDir/out.txt")
                outputs.file testFile
                executable = org.gradle.internal.jvm.Jvm.current().getJavaExecutable()
                args '-cp', sourceSets.main.runtimeClasspath.asPath, 'org.gradle.TestMain', projectDir, testFile
                doLast {
                    assert testFile.exists()
                }
            }

        testFile("build/classes/java/test/test.resource").assertDoesNotExist()

        testFile("build/classes/java/main/Main.class").assertExists()
        testFile("build/classes/java/test/TestFoo.class").assertExists()
    }

    @Test
    void generatesArtifactsWhenVersionIsEmpty() {
        testFile("settings.gradle") << "rootProject.name = 'empty'"
        def buildFile = testFile("build.gradle")

    }

    def "instrumentation for #factory preserves classes"() {
        given:
        def testFile = jar(testDir.file("thing.jar")) {
            manifest {}
            entry("Foo.class", classOne())
        }

        expect:
        with(transformJar(factory, testFile)) {
            if (expectManifest) {
                assertManifestPresentAndFirstEntry()
            }

				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,

        }
    }

    static interface Scenario {

        void setup(AbstractIntegrationSpec spec)

        void createInitialBuildLayoutIn(TestFile dir, ScriptLanguage scriptLanguage)

        TestFile addMissingScript(TestFile dir, ScriptLanguage scriptLanguage)

        String getDisplayName(String scriptExtension)
    }

    static class MissingBuild implements Scenario {

    }

    @Test
    public void canDetermineRootProjectAndDefaultProjectBasedOnBuildFile() {
        testFile("settings.gradle").write("include('child')");

        TestFile rootBuildFile = testFile("build.gradle");
        rootBuildFile.write("task('do-stuff')");

        TestFile childBuildFile = testFile("child/build.gradle");
        childBuildFile.write("task('do-stuff')");

    fun hasTestsOf(testType: TestType) = (unitTests && testType.unitTests) || (functionalTests && testType.functionalTests) || (crossVersionTests && testType.crossVersionTests)
}

data class Stage(
    val stageName: StageName,
    val specificBuilds: List<SpecificBuild> = emptyList(),

    TestFile testFile
    TestFile testFileLock
    TestFile testDir
    TestFile testDirLock

    List<Closeable> openedLocks = []

    def setup() {
        testFile = tmpDir.createFile("state.bin")
        testFileLock = tmpDir.file(testFile.name + ".lock")
        testDir = tmpDir.createDir("lockable-dir")

        }
        setUpAgentIfNeeded(testType, executer)
        disableIfNeeded(testType, executer)
    }


internal
fun IntegrationTest.disableIfNeeded(testType: TestType, executer: String) {
    if (testType == TestType.INTEGRATION && executer == "isolatedProjects") {
        isEnabled = false
    }
}


private
fun IntegrationTest.setUpAgentIfNeeded(testType: TestType, executer: String) {