class A2{}
"""
        file('src/main/groovy/org/gradle/B.groovy') << 'package org.gradle; class B{}'
        outputs.snapshot { run "compileGroovy" }

        when:
        a.text = 'package org.gradle; class A1 {}'
        run "compileGroovy"

        then:
        outputs.recompiledClasses('A1')
        outputs.deletedClasses('A2')
    }

    def 'only recompile removed packages'() {
        given:

    def delegateCompiler = Mock(Compiler)
    def outputs = Mock(TaskOutputsInternal)
    def compileStateCache = Mock(ObjectHolder)
    def incrementalCompilation = Mock(IncrementalCompilation)
    def deleter = TestFiles.deleter()
    def compiler = new IncrementalNativeCompiler(outputs, delegateCompiler, deleter, compileStateCache, incrementalCompilation)

    from("src/main/webapp")
    // Copy a single file
    from("src/staging/index.html")
    // Copy the output of a task
    from(copyTask)
    // Copy the output of a task using Task outputs explicitly.
    from(tasks["copyTaskWithPatterns"].outputs)
    // Copy the contents of a Zip file
    from(zipTree("src/main/assets.zip"))
    // Determine the destination directory later

        1 * task.getOutputs() >> outputs
        1 * outputs.getFiles() >> fileCollection
        1 * fileCollection.getSingleFile() >> Stub(File)
        0 * _
    }

    def "fails resolving lazy IvyArtifact for Provider<Task> notation when task has a multiple output files"() {
        def task = Mock(Task)
        def taskProvider = Mock(TestTaskProvider)
        def outputs = Mock(TaskOutputsInternal)

    @PathSensitive(PathSensitivity.RELATIVE)
    @InputArtifact
    abstract Provider<FileSystemLocation> getInput()

    @Override
    void transform(TransformOutputs outputs) {
        def outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.incremental}")

        then:
        output.toString().contains("task logging")
        output.toString().contains("warn logging")
        output.toString().contains("lifecycle logging")
        output.toString().contains("quiet logging")
        if (targetVersion.baseVersion >= GradleVersion.version('4.7')) {
            // Changed handling of error log messages
            output.toString().contains("error logging")
        } else {

        when:
        outputs.snapshot { run "compileJava" }
        a.text = "class A { public void foo() {} }"
        run "compileJava", "--info"

        then:
        outputs.recompiledClasses("A")
    }

    def "generated files and classes are deleted when processor is removed"() {
        given:
        java "@Thing class A {}"

        when:
        outputs.snapshot { run "compileJava" }

                absl::Span<AbstractTensorHandle*> outputs, bool use_function) {
  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;
    // Returning null tensors from a tf.function is not supported, so we keep
    // track of indices in the model's outputs are nullptr in this set.
    // The FunctionDef only outputs the non-null tensors. We later pad the

     * {@inheritDoc}
     */
    @Override
    ImmutableSortedMap<String, CurrentFileCollectionFingerprint> getInputFileProperties();

    /**
     * Snapshots of the roots of output properties.
     *
     * This includes snapshots for the whole output {@link org.gradle.api.file.FileCollection}.
     *
     * @see PreviousExecutionState#getOutputFilesProducedByWork()
     * @see AfterExecutionResult#getAfterExecutionOutputState()
     */

        // If there are different output properties compared to the previous execution, then we do have output changes
        if (!previous.keySet().equals(current.keySet())) {
            return true;
        }

        // Otherwise, do deep compare of outputs
        ChangeDetectorVisitor visitor = new ChangeDetectorVisitor();