// CHECK:             buffer: 3,
// CHECK:             name: "outputs",
// CHECK:             quantization: {
// CHECK:             },
// CHECK:             has_rank: true
// CHECK:           } ],
// CHECK:           inputs: [ 0 ],
// CHECK:           outputs: [ 2 ],
// CHECK:           operators: [ {
// CHECK:             inputs: [ 1, 0 ],
// CHECK:             outputs: [ 2 ],
// CHECK:             builtin_options_type: AddOptions,

    }

    @get:PathSensitive(PathSensitivity.NONE)
    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val outputDirectory = outputs.dir("shadedClasses")
        val classesDir = outputDirectory.resolve(relocatedClassesDirName)
        classesDir.mkdir()
        val manifestFile = outputDirectory.resolve(manifestFileName)

                inputs.files("input-1.txt", "input-2.txt")
                inputs.dir("input-dir")

                outputs.file("output.txt")
                outputs.files("output-1.txt", "output-2.txt")
                outputs.dir("output-dir")
                outputs.dirs("output-dir-1", "output-dir-2")
            }
        """ << printProperties("myTask")
        when:
        run "printProperties"

        void transform(TransformOutputs outputs) {
            INVOCATION_COUNT.incrementAndGet()
            outputs.file(new File(inputArtifact.get().asFile, SELECTED_PATH))
            outputs.file("produced-file-1.txt").text = "produced1"
            outputs.dir(inputArtifact)
            outputs.file("produced-file-2.txt").text = "produced2"
        }
    }

// CHECK-NEXT:      shape: [  ],
// CHECK-NEXT:      buffer: 2,
// CHECK-NEXT:      name: "outputs",
// CHECK-NEXT:      quantization: {
// CHECK:           }
// CHECK-NEXT:    } ],
// CHECK-NEXT:    inputs: [ 0 ],
// CHECK-NEXT:    outputs: [ 1 ],
// CHECK-NEXT:    operators: [ {
// CHECK-NEXT:      inputs: [ 0, 0 ],
// CHECK-NEXT:      outputs: [ 1 ],
// CHECK-NEXT:      builtin_options_type: AddOptions,

    %0 = "tf.Mul"(%arg1, %arg0) : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
    func.return %0 : tensor<1xf32>
  }
// CHECK: func private @mul1(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) -> tensor<1xf32> attributes {tf.entry_function = {inputs = "mul1_y:0,mul1_x:0", outputs = "PartitionedCall:0"}}

        visitor.add { null }

        then:
        0 * context._
    }

    def "resolves tasks outputs to its output files"() {
        def content = Mock(FileCollectionInternal)
        def outputs = Mock(TaskOutputs)

        when:
        visitor.add outputs

        then:
        1 * outputs.files >> content
        1 * context.accept(content)
        0 * context._
    }

            task custom {
                outputs.dir 'build/outputs'
                doLast {} }
        """.stripIndent()

        file('build/outputs/some-stale-file').text = "Stale file"

        when:
        runCustomTask()

        then:
        def task = events.operation("Task :custom")
        task.descendant('Clean stale outputs')
    }

public class OutputSnapshotUtil {

    /**
     * Finds outputs that are still present since the last execution when overlapping outputs are present.
     *
     * Note: when there are no overlapping outputs, all outputs currently existing in the output locations
     * are considered outputs of the work.
     *
     * If a property did not exist after the previous execution then all the outputs for it will be ignored.
     *

    %0:4 = tf_executor.graph {
      %outputs:4, %control = tf_executor.island wraps "tf.PartitionedCall"(%arg0) {config = "", config_proto = "", executor_type = "", f = @_tpu_v1_compat_outlined::@_tpu_v1_compat_outlined_func0} : (tensor<i1>) -> (tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>)
      tf_executor.fetch %outputs#0, %outputs#1, %outputs#2, %outputs#3 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
    }