and:
        server.resetExpectations()
        module.pom.expectHead()
        module.pom.sha1.expectGet()
        module.pom.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verify")

        where:
        condition                     | execArg
        "with --refresh-dependencies" | "--refresh-dependencies"

        server.resetExpectations()
        module.ivy.expectHead()
        module.ivy.sha1.expectGet()
        module.ivy.expectGet()
        sourceArtifact.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verifyRefresh")

        where:
        condition                     | execArg
//        "with --refresh-dependencies" | "--refresh-dependencies"

        core.rootMetaData.allowGetOrHead()
        util.allowAll()

        if (resolveDynamic) {
            mavenHttpRepo.module('org.readonly', 'core', '0.9').publish()
            executer.withArgument("--refresh-dependencies")
        }

        succeeds ':checkDeps', ':extraArtifacts'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {

        // This might hide issues with Groovy closures, as the methods referenced inside the closure are resolved dynamically.
        try {
            createExecuter(args, flags).withArgument("--rerun-tasks").run();
        } catch (UnexpectedBuildFailure e) {

    @Rule BlockingHttpServer server = new BlockingHttpServer()
    BuildOperationsFixture buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

    def setup() {
        executer.withArgument("--max-workers=4")
    }

    def cleanup() {
        server.stop()
    }

    void assertTaskIsParallel(String taskName) {

                additionalForkOptions = {
                    it.executable = launcher.executablePath.asFile
                }
            }
        """

        executer.withArgument("-Porg.gradle.java.installations.paths=" + target.javaHome.absolutePath)
    }

    def "useful error message when using incompatible java version: #version"() {
        given:
        configureForVersion(version)

class ForceRealizedMetadataIntegrationTest extends AbstractHttpDependencyResolutionTest {
    MavenHttpModule direct
    MavenHttpModule transitive

    def setup() {
        executer.withArgument("-Dorg.gradle.integtest.force.realize.metadata=true")

        buildFile << """
            plugins {
                id 'java'
            }

            repositories {

            }
            tasks.register("myTask")
            $usageCode
        """
        version(distribution)
            .inDirectory(file("consumer"))
            .withTasks("myTask")
            .withArgument("-s")
            .run()
    }

    private String getUsageCode() {
        return """

            // Accessing extensions

            the<MyExtension>().some.set("thing")

                    }
                }
            }
        """

        when:
        def handle = server.expectConcurrentAndBlock('longRunningStart', 'task1')
        def gradle = executer.withArgument('--parallel').withTasks('longRunning', 'task2').start()

        then:
        handle.waitForAllPendingCalls()
        assertOutputContains(gradle, "longRunning has started...")

        when:

 * {@code Pmd} tasks behave as expected.
 */
class PmdPluginToolchainsIntegrationTest extends AbstractPmdPluginVersionIntegrationTest implements JavaToolchainFixture {

    def setup() {
        executer.withArgument("--info")
    }

    def "uses jdk from toolchains set through java plugin"() {
        Assume.assumeTrue(fileLockingIssuesSolved())
        given:
        goodCode()
        def jdk = setupExecutorForToolchains()