def detector = new TrivialChangeDetector(itemComparator, changeFactory, delegate)

    def change = Mock(Change)
    def visitor = Mock(ChangeVisitor)

    def "detects no change between empty current and previous"() {
        when:
        detector.visitChangesSince([:], [:], "test", visitor)
        then:
        0 * _
    }

    def "detects no change between the same one item"() {

            "output", FileSystemSnapshot.EMPTY
        )
        expect:
        detector.detect(previousOutputFiles, outputFilesBeforeExecution) == null
    }

    def "detects overlap when there is a stale root"() {

        virtualFileSystem.invalidateAll()
        graph.remove(sourceFile)
        sourceFile.delete()
    }

    def "detects unchanged source files"() {
        given:
        initialFiles()

        expect:
        checkCompile recompiled: [], removed: []
    }

    def "detects new source files"() {
        given:
        initialFiles()

        when:
        def file3 = sourceFile("file3")

    }

    def "detects change of an isolated class"() {
        source "class A {}", "class B {}"

        outputs.snapshot { run language.compileTaskName }

        when:
        source "class A { /* change */ }"
        run language.compileTaskName

        then:
        outputs.recompiledClasses 'A'
    }

    def "detects deletion of an inner class"() {

    def setup() {
        buildFile << """
            dependencies {
                api 'org:moda:1.0'
            }
        """
    }

    def "detects changes in module-info file"() {
        when:
        publishJavaModule('moda')
        consumingModuleInfo()
        consumingModuleClass('moda.ModaClass')

        then:
        fails ':compileJava'

        0 * _
    }

    AnnotationProcessorDetector detector = new AnnotationProcessorDetector(new TestFileContentCacheFactory(), logger, true)

    def "detects no processors in broken jars"() {
        given:
        def jar = tmpDir.file("classes.jar")
        jar << "broken"
        def cp = files(jar)

        when:
        def processors = detector.detectProcessors(cp)

        then:
        processors == [:]

func NewMetricsBlock(device string) MetricsProvider {
	return &metricsBlock{device}
}

// See MetricsProvider.GetMetrics
// GetMetrics detects the size of the BlockMode volume for the device node
// where the Volume is attached.
//
// Note that only the capacity of the device can be detected with standard
// tools. Storage systems may have more information that they can provide by
// going through specialized APIs.

import org.gradle.integtests.fixtures.DirectoryBuildCacheFixture

@LocalOnly
class ChangesByGradleFileWatchingIntegrationTest extends AbstractFileSystemWatchingIntegrationTest implements DirectoryBuildCacheFixture {

    def "detects when outputs are removed for tasks without sources"() {
        buildFile << """
            apply plugin: 'base'

            abstract class Producer extends DefaultTask {
                @InputDirectory

    private static final String INCREMENTAL_TASK_NAME = "incrementalTask"

    @Issue("https://github.com/gradle/gradle/issues/9320")
    def "incremental task with NAME_ONLY input (matching file names and content) detects changed input"() {
        def inputs = folderNames().collect { file("${it}/input.txt").createFile() }
        def modifiedInput = inputs[1]

        buildFile << incrementalTaskWithNameOnlyInputFiles(inputs)

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
- 29607
releaseNotes:
- |