def "clean assemble for abi change with local cache"() {
        given:
        setupTestProject(runner)
        def testProject = JavaTestProject.projectFor(runner.testProject)
        runner.addBuildMutator { new ApplyAbiChangeToJavaSourceFileMutator(new File(it.projectDir, testProject.config.fileToChangeByScenario['assemble'])) }
        runner.args += "--parallel"
        pushToRemote = false

        when:

TESTNAME=${1:-IdeIntegrationPerformanceTest}
TESTPROJECT=${2:-multi}
./gradlew clean
[ -d ~/.gradle-bisect-override ] && cp -Rdvp ~/.gradle-bisect-override/* .
[ -x ~/.gradle-bisect-override-script ] && ~/.gradle-bisect-override-script $TESTNAME $TESTPROJECT

    }

    @Override
    GradleVsMavenBuildPerformanceResults run() {
        def commonBaseDisplayName = "${gradleTasks.join(' ')} on $testProject"
        baseline {
            warmUpCount = warmUpRuns
            invocationCount = runs
            projectName(testProject).displayName("Gradle $commonBaseDisplayName").invocation {
                tasksToRun(gradleTasks).jvmArgs(jvmOpts.collect { it.toString() })
            }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    static String determineFileToChange(String testProject) {
        switch (testProject) {
            case 'mediumSwiftMulti':

    inline fun <reified T : Task> registerTestProject(testProject: String, noinline configuration: T.() -> Unit): TaskProvider<T> =
        registerTestProject(testProject, T::class.java, configuration)

    fun <T : Task> registerTestProject(testProject: String, type: Class<T>, configurationAction: Action<in T>): TaskProvider<T> {
        return doRegisterTestProject(testProject, type, configurationAction)
    }

            testClass: testClassName,
            testId: testId,
            previousTestIds: previousTestIds.collect { it.toString() }, // Convert GString instances
            testProject: testProject,
            tasks: tasksToRun.collect { it.toString() },
            cleanTasks: cleanTasks.collect { it.toString() },
            args: args.collect { it.toString() },
            gradleOpts: resolveGradleOpts(),

               testClass,
               testId,
               testProject,
               '${os.name()}' as os,
               avg(TIMESTAMPDIFF(SECOND, testExecution.startTime, testExecution.endTime)) as duration
            from testExecution
           where startTime > ?
             and (channel in (?, ?))
              or channel like ?
             and testProject is not null
           group by testClass, testId, testProject

     */
    def "run Android Studio sync"() {
        given:
        runner.args = [AndroidGradlePluginVersions.OVERRIDE_VERSION_CHECK]
        def testProject = AndroidTestProject.projectFor(runner.testProject)
        testProject.configure(runner)
        AndroidTestProject.useAgpLatestStableOrRcVersion(runner)
        AndroidTestProject.useKotlinLatestStableOrRcVersion(runner)
        runner.warmUpRuns = 20

    def resolve = new ResolveTestFixture(buildFile, "conf")

    def setup() {
        resolve.prepare()
        resolve.addDefaultVariantDerivationStrategy()
        settingsFile << """
            rootProject.name = 'testproject'
        """
        buildFile << """
            repositories {
                maven { url '${mavenRepo.uri}' }
                ivy { url '${ivyRepo.uri}' }
            }
            configurations {

    static JavaTestProject projectFor(String testProject) {
        def javaTestProject = findProjectFor(testProject)
        if (javaTestProject == null) {
            throw new IllegalArgumentException("Cannot find Java test project for ${testProject}")
        }
        return javaTestProject
    }

    @Nullable
    static JavaTestProject findProjectFor(String testProject) {