}

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

        and:
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
            }
        }
        executer.withTasks('help').start().waitForFinish()

        then:
        resource.assertDoesNotExist()

        succeeds("showMissing")

        when:
        moduleInRepo1.publish()
        server.resetExpectations()
        then:
        succeeds("showMissing")

        when:
        executer.withArgument("--refresh-dependencies")
        moduleInRepo1.ivy.expectHead()
        moduleInRepo1.ivy.sha1.expectGet()
        moduleInRepo1.jar.expectHead()
        moduleInRepo1.jar.sha1.expectGet()

        then:

    def setup() {
        server.start()

        setupBuild(new BuildTestFile(testDirectory, "root"))

        executer.beforeExecute {
            withArgument("--max-workers=10")
        }
    }

    private void setupBuild(BuildTestFile buildTestFile) {
        buildTestFile.with {
            settingsFile << """
                rootProject.name = '${rootProjectName}'

                    username = "correct-username"
                    password = "correct-password"
                }
            }
        """

        when:
        executer.withArgument("--info")
        withBuildCache().run "assemble"
        then:
        outputDoesNotContain("correct-username")
        outputDoesNotContain("correct-password")
    }

        dependencies = parseIml("two/two.iml").dependencies
        assert dependencies.libraries*.jarName as Set == [someLib2Jar.name] as Set

        executer.withArgument("-PstrictDeps=true").withTasks("idea").run()

        //then
        dependencies = parseIml("one/one.iml").dependencies
        assert dependencies.modules.size() == 1

        outputs.snapshot { run "mainExecutable" }

        when:
        directoryHeader.deleteDir()
        directoryHeader << '#pragma message("NEW directory named header")'
        and:
        executer.withArgument("--info")
        run "mainExecutable"
        then:
        executedAndNotSkipped compileTask
        and:
        outputs.recompiledFile sourceFile
        outputContains("NEW directory named header")

        given:
        buildFile << publicationBuildWithoutCredentials(version, group, mavenRemoteRepo.uri)

        if (!extraChecksums) {
            executer.withArgument("-Dorg.gradle.internal.publish.checksums.insecure=true")
            module.withoutExtraChecksums()
        }
        expectModulePublish(module, extraChecksums)

        when:
        succeeds 'publish'