%0:2 = tf_executor.graph {

    @OutputFile
    abstract RegularFileProperty getOutputFile()

    @TaskAction
    void produce() {
        String message = 'Hello, World!'
        def output = outputFile.get().asFile
        output.text = message
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer extends DefaultTask {
    @InputFiles
    abstract ListProperty<RegularFile> getInputFiles()

    @TaskAction

  }
  if (!tensorflow::ParseOutputArrayInfo(output_arrays_flag, &outputs).ok()) {
    return emitError(loc, "parsing output array info failed ")
               << output_arrays_flag,
           nullptr;
  }
  return tflite::FlatBufferToMlir(
      absl::string_view(input->getBufferStart(), input->getBufferSize()),
      context, loc, use_external_constant, inputs, outputs,
      experimental_prune_unreachable_nodes_unconditionally,

        buildFile """
            task copy(type: SimpleCopy) {
                input = file("input.txt")
                output = file("output.txt")
            }
        """

        when:
        succeeds "copy"
        then:
        executedAndNotSkipped ":copy"

        file("output.txt").makeOlder()

        when:
        succeeds "copy"
        then:
        skipped ":copy"

       .Input("inputs: N * T")
       .Output("output: T")
       .Output("value_index: int32")

    For example:
      %2 = tf_executor.Merge %0, %1, %2, %3 : tensor<*xf32>

    Note: Additional result corresponds to the control output.
  }];

  let arguments = (ins
    Variadic<AnyType>:$inputs_and_control
  );

  let results = (outs
    AnyTensor:$output,
    TensorOf<[I32]>:$value_index,

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

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

        textFile.text = "text file as root"

        outputs.snapshot { run language.compileTaskName }

        when:
        file("extra/B.${language.name}").text = "class B { String change; }"
        executer.withArgument "--info"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B", "C")

        when:
        run("-q", ":printScriptOutput")

        then:
        outputContains("Script output")
    }

    def "task with providers.exec provider input is up to date for second run"() {
        given:
        def testScript = ShellScript.builder()
            .printText("Script output")
            .writeTo(testDirectory, "script")

        buildFile """

            println "src dir 1: " + srcDir.get()
            println "output dir 1: " + outputDir.get()
            buildDir = "output/some-dir"
            childDirName = "other-child"
            println "src dir 2: " + srcDir.get()
            println "output dir 2: " + outputDir.get()
"""

        when:
        run()

        then:

    TensorShape x_shape({1, 2, 2, 1});
    Tensor x_data = MakeData<T>(x_shape);
    Output x, y;
    MakeOp<T>(op_type, x_data, {4, 6}, align_corners, half_pixel_centers, &x,
              &y);

    ClientSession session(scope_);
    std::vector<Tensor> outputs;
    TF_ASSERT_OK(session.Run({y}, &outputs));
    EXPECT_EQ(outputs.size(), 1);
    EXPECT_EQ(outputs[0].shape(), TensorShape({1, 4, 6, 1}));
  }