"""
        distro
    }

    def runWithGradleHome(TestFile gradleHome) {
        def copiedDistro = new DefaultGradleDistribution(executer.distribution.version, gradleHome, null)
        def daemonExecuter = new DaemonGradleExecuter(copiedDistro, executer.testDirectoryProvider)
        executer.copyTo(daemonExecuter)
        return daemonExecuter.run()
    }

        when:
        int attempts = 0
        Callable operation = {
            attempts++
            throw ex
        }
        NetworkOperationBackOffAndRetry executer = new NetworkOperationBackOffAndRetry(3, 1)
        executer.withBackoffAndRetry(operation)

        then:
        attempts == 3
        Exception failure = thrown()
        if (failure instanceof UncheckedIOException) {

        delegate = new BuildSessionActionExecutor() {
            @Override
            BuildActionRunner.Result execute(BuildAction action, BuildSessionContext context) {
                declareInput(file)
                return BuildActionRunner.Result.of(null)
            }
        }
        executer = executer()
    }

    private void buildDeclaresInputsAndTriggersChange() {

    @Rule
    MavenHttpPluginRepository pluginRepo = MavenHttpPluginRepository.asGradlePluginPortal(executer, mavenRepo)

    def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    def "error loading plugin"() {
        pluginBuilder.addUnloadablePlugin(PLUGIN_ID)
        pluginBuilder.publishAs(GROUP, ARTIFACT, VERSION, pluginRepo, executer).allowAll()

        buildScript applyPlugin()

        expect:

    }

    @Issue("https://github.com/gradle/gradle/issues/24979")

    def "cannot annotate type 'java.net.URL' with @Input"() {

        executer.beforeExecute {
            executer.noDeprecationChecks()
            executer.withArgument("-Dorg.gradle.internal.max.validation.errors=20")
        }

        given:
        buildFile << """
            interface NestedBean {

        keyStore.configureServerCert(executer)
        succeeds 'publish'

        then:
        verifyPublications()
    }

    def "publish with server and client certificate"() {
        given:
        keyStore.enableSslWithServerAndClientCerts(server)
        initBuild()

        when:
        expectPublication()
        keyStore.configureServerAndClientCerts(executer)
        succeeds 'publish'

class CacheMarkingStrategyIntegrationTest extends AbstractIntegrationSpec {
    @Override
    def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    def writeInitScript(String markingStrategy) {
        def initDir = new File(executer.gradleUserHomeDir, "init.d")
        initDir.mkdirs()
        new File(initDir, "cache-settings.gradle") << """
            beforeSettings { settings ->

        when:
        executer.withEnvironmentVars(['JAVA_MAIN_CLASS_1234': '1234'])
        succeeds("compileAll")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:
        assertOneCompilerDaemonIsRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()

import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult
import org.gradle.integtests.fixtures.executer.UnexpectedBuildFailure

        projectB.jar.expectGet()
        projectAInRepo1.ivy.expectGetMissing()
        projectAInRepo2.pom.expectGet()
        projectAInRepo2.artifact.expectGet()

        then: