when:
        libObjects.snapshot()
        appObjects.snapshot()

        run installApp

        then:
        allSkipped()

        and:
        libObjects.noneRecompiled()
        appObjects.noneRecompiled()
    }

    @ToBeFixedForConfigurationCache
    def "considers only those headers that are reachable from source files as inputs"() {
        given:

        when:
        impl.snapshot()
        source api: ["class A { /* change */ }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled() //because after earlier change to B, class A is no longer a dependency
    }

    def "doesn't recompile if external dependency has ABI incompatible change but not on class we use"() {
        given:

        runAndFail language.compileTaskName

        then:
        outputs.noneRecompiled()
        outputs.hasFiles(file("A.class"), file("B.class"))

        when:
        a.text = "class A {}"
        run language.compileTaskName

        then:
        outputs.noneRecompiled()
    }

        when:
        file("api/src/main/${language.name}/A.${language.name}").delete()
        run "app:${language.compileTaskName}", "-x", "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
        app.recompiledClasses("C")
    }

    def "deletion of jar without dependents does not recompile any classes"() {
        source api: ["class A {}"], impl: ["class SomeImpl {}"]

        outputs.snapshot { run "compileGroovy" }

        when: 'first build'
        applyGroovyFileSet(firstChange)
        runAndFail "compileGroovy", "--info"

        then:
        outputs.noneRecompiled()

        when: 'second build'
        outputs.snapshot { applyGroovyFileSet(secondChange) }
        run "compileGroovy", "--info"

        then:
        upToDateOrMessage(secondBuildMessage)

        impl.recompiledClasses( 'X', 'Y')

        when:
        impl.snapshot()
        // No change, so we expect no recompilation
        run "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
    }

    def "change in an upstream class with non-private constant causes rebuild if constant is referenced in method body (#constantType)"() {

        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class A { int method1() { return 1; } }"]
        fails "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
    }

    // This behavior is kept for backward compatibility - may be removed in the future
    @Requires(UnitTestPreconditions.Jdk9OrLater)

            // Some extra content
"""
        and:
        run "mainExecutable"

        then:
        executed compileTask
        skipped compileTask

        and:
        outputs.noneRecompiled()
    }

    @ToBeFixedForConfigurationCache
    def "recompiles when include path is changed so that replacement header file occurs before previous header"() {
        given:

        outputs.snapshot { run "compileJava" }

        when:
        a.text = "@Helper class A { public String bar() { return 0; } }"
        runAndFail "compileJava", "-d"

        then:
        outputs.noneRecompiled()
        outputContains("Deleting generated files: [${file("build/classes/java/main/AHelperResource.txt")}, " +
            "${file("build/generated/sources/annotationProcessor/java/main/AHelper.java")}]"
        )

        outputs.snapshot { run "compileJava" }

        when:
        a.text = "@Service class A { public String foo() { return 0; } }"
        runAndFail "compileJava", "-d"

        then:
        outputs.noneRecompiled()
        outputContains("Deleting generated files: [${file("build/classes/java/main/ServiceRegistryResource.txt")}, " +
            "${file("build/generated/sources/annotationProcessor/java/main/ServiceRegistry.java")}]")