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')
            }

    }

    def "should report changes when quiet logging used"() {
        given:
        def inputFile = inputDir.file("input.txt")

        when:
        executer.withArgument("-q")
        succeeds("theTask")
        inputFile.createFile()

        then:
        buildTriggeredAndSucceeded()
        sendEOT()
        assertReportsChanges([new ChangeEntry('new file', inputFile)])

                (DefaultTimeoutHandler.SLOW_STOP_LOG_STACKTRACE_FREQUENCY_PROPERTY): slowStopLogStacktraceFrequencyMs
            ].each { k, v ->
                executer.withArgument("-D$k=$v".toString())
            }
        }
    }

    def "fails when negative timeout is specified"() {
        given:
        buildFile << """
            task broken() {
                doLast {

        if (JavaVersion.current().isJava9Compatible() && GradleContextualExecuter.isConfigCache()) {
            // For java.util.concurrent.CountDownLatch being serialized reflectively by configuration cache
            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/java.util.concurrent.locks=ALL-UNNAMED')
        }