def results = new CrossVersionPerformanceResults()
        results.testClass = "org.gradle.performance.MyPerformanceTest"
        results.testId = "test-id"
        results.previousTestIds = []
        results.testProject = "test-project"
        results.tasks = ["build"]
        results.cleanTasks = ["clean"]
        results.args = []
        results.gradleOpts = []
        results.daemon = false

        testProject()

        when:
        def mixedCaseDir = new File(testDirectory, "JAVA/QuickStart")
        executer.inDirectory(mixedCaseDir).run()

        then:
        noExceptionThrown()
    }

    @Requires(UnitTestPreconditions.Windows)
    def "canonicalizes working directory for short windows path"() {
        testProject()

        when:

        List<JUnitTestCase> testCases = testSuite.testCases ?: []
        return testCases.findAll { !it.skipped }.collect {
            def agentName = System.getenv("BUILD_AGENT_NAME") ?: null
            new ScenarioBuildResultData(
                scenarioName: it.name,
                scenarioClass: it.className,
                testProject: testProject,

    def setup() {
        resolve.prepare()
        resolve.addDefaultVariantDerivationStrategy()
        settingsFile << """
            rootProject.name = 'testproject'
        """
    }

    @Requires(UnitTestPreconditions.Online)
    def "resolves dependencies on real projects"() {
        // Real but ancient projects

     * in the flakiness detection builds divided by the total number of runs of the scenario.
     *
     * <pre>
     *  SELECT TESTID, TESTPROJECT, AVG(CONVERT(CASEWHEN(DIFFCONFIDENCE &gt; 0.97, 1, 0), DECIMAL)) AS FAILURE_RATE,
     *  FROM TESTEXECUTION
     *  WHERE (CHANNEL = 'flakiness-detection-master' OR CHANNEL = 'flakiness-detection-release')
     *  GROUP BY TESTID

        given:
        def repo1 = ivyHttpRepo('ivy-repo-a')
        def module1 = repo1.module('org.gradle', 'testproject', '1.0').publish()
        def repo2 = ivyHttpRepo('ivy-repo-b')
        def module2 = repo2.module('org.gradle', 'testproject', '1.0').publishWithChangedContent()

        and:
        createDirs("a", "b")
        settingsFile << "include 'a','b'"
        buildFile << """

        container.addComponentDescriptor(cd);

        Maven maven = container.lookup(Maven.class);
        File pom = getProject(testProject);
        MavenExecutionRequest request = createMavenExecutionRequest(pom);
        request.setGoals(Arrays.asList("validate"));
        MavenExecutionResult result = maven.execute(request);

        return "$scenarioName | $testProject | ${scenarioClass.substring(scenarioClass.lastIndexOf(".") + 1)}"
    }

    String getScenarioName() {
        return performanceExperiment.scenario.testName
    }

    String getScenarioClass() {
        return performanceExperiment.scenario.className
    }

    String getTestProject() {
        return performanceExperiment.testProject
    }

    boolean isCrossVersion() {

import model.CIBuildModel
import model.Stage

class TestPerformanceTest(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage, init = {
    val os = Os.LINUX
    val buildTypeThis = this
    val testProject = "smallJavaMultiProject"

    fun BuildSteps.gradleStep(tasks: List<String>) {
        gradleWrapper {
            name = "GRADLE_RUNNER"
            gradleParams = (
                tasks +

import static org.gradle.performance.results.OperatingSystem.LINUX

@RunFor([
    @Scenario(type = PER_COMMIT, operatingSystems = [LINUX], testProjects = ["largeJavaMultiProject", "largeMonolithicJavaProject", "mediumJavaCompositeBuild"]),
    @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects = ["mediumJavaPredefinedCompositeBuild"])
])
class JavaCleanAssemblePerformanceTest extends AbstractCrossVersionPerformanceTest {