requireDaemon().requireIsolatedDaemons().
                        withGradleUserHomeDir(workspace.file("user-home"))
                8.times {
                    executer.inDirectory(buildDir).withArgument("--refresh-dependencies").withTasks('check').run()
                }
            }
        }
        concurrent.finished()
    }

    static class StressHttpServer extends ExternalResource {

    }

    def previousExecution() {
        run "incremental"
    }

    def failedExecution() {
        executer.withArgument("-DforceFail=yep")
        assert fails("incremental")
        executer.withArguments()
    }

    void executesIncrementally(Map changes) {
        executesIncrementalTask(incremental: true, *:changes)
    }

            barrier.expectConcurrent("child-build-finished", "1-finished", "2-finished")
        }

        when:
        runs.times {
            executer.withArgument("--parallel")
            run 'otherBuild'
        }

        then:
        noExceptionThrown()

        and:
        def runNestedBuildOps = buildOperations.all(RunNestedBuildBuildOperationType)

        result.testClass('org.gradle.JUnitTest').assertTestPassed('mySystemClassLoaderIsUsed')
    }

    def "can run tests with custom security manager"() {
        executer
                .withArgument("-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}")
                .withToolchainDetectionEnabled()

        given:

    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 {
                @Input
                Property<URL> getNested()

        given:
        executer.requireIsolatedDaemons() // because we want to reuse Gradle user home services
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
            }
        }
        requireOwnGradleUserHomeDir() // because we delete caches and distributions
        alwaysCleanupCaches()

        and:

                }
            }
        """.stripIndent()

        when:
        executer.withDefaultCharacterEncoding('windows-1252').withTasks('jar')
        executer.withArgument("--stacktrace")
        executer.run()

        then:
        def jar = new JarFile(file('dest/test.jar'))
        try {
            def manifest = jar.manifest

            }
        """

        expect:
        2.times {
            succeeds(":build-logic:jar", ":app:assemble")
        }
        2.times {
            executer.withArgument("--configure-on-demand")
            succeeds(":build-logic:jar", ":app:assemble")
        }
    }

            }
        }
    }
}
project(":lib") {
    model {
        components {
            hello(NativeLibrarySpec)
        }
    }
}
"""

        when:
        executer.withArgument('--configure-on-demand')
        succeeds ":exe:installMainExecutable"

        then:
        installation("exe/build/install/main").exec().out == app.englishOutput
    }

    @ToBeFixedForConfigurationCache

    def setup() {
        buildFile << """
dependencies {
    conf 'org.test:projectA:1.0'
}

task resolve(type: Sync) {
    from configurations.conf
    into 'libs'
}
"""
        executer.withArgument("-Ddebug.modulesource=true")
    }

    def "rule is cached across builds"() {
        repository {
            'org.test:projectA:1.0' {
                dependsOn('org.test:projectB:1.0')
            }