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:

        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class B { /* change */ }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
    }

    def "detects that changed class still has the same constants so no recompile is necessary"() {
        source api: ["class A { public static final int FOO = 123;}"],

        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)"() {

                    }
                }
            }
        }
    }
"""
        and:
        run "mainExecutable"

        then:
        skipped compileTask

        and:
        outputs.noneRecompiled()

        where:
        testCase                       | headerDirs
        "extra header dir after"       | '"src/main/headers", "src/additional-headers"'

        outputs.snapshot { succeeds language.compileTaskName }

        when:
        resource.text = 'bar'

        then:
        succeeds language.compileTaskName
        outputs.noneRecompiled()
    }

                    }
                }
            }
        }
    }
"""
        and:
        run "mainExecutable"

        then:
        skipped compileTask
        outputs.noneRecompiled()

        where:
        testCase                       | headerDirs
        "extra header dir after"       | '"src/main/headers", "src/additional-headers"'