}
  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"

        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 """

  if FLAGS.gen_register_op:
    assert FLAGS.output.endswith('.cc')
    generated_code = gen_register_op(sys.modules[__name__], '_composite_')
  else:
    assert FLAGS.output.endswith('.mlir')
    generated_code = tfr_gen_from_module(sys.modules[__name__], '_composite_')

  dirname = os.path.dirname(FLAGS.output)
  if not os.path.exists(dirname):
    os.makedirs(dirname)
  with open(FLAGS.output, 'w') as f:
    f.write(generated_code)

            logger3.log(it, "Test");
        }
        redirector.stop()

        then:
        0 * _

        System.out == outputs.stdOutPrintStream
        System.err == outputs.stdErrPrintStream
    }

    def "start and stop output with redirection and default logging"() {
        when:
        redirector.redirectStandardOutputTo(stdOutListener)

                def outputFile = new File(buildDir, "output")
                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = "done"
                }
            }
"""
        def cacheDir = file("task-output-cache")
        settingsFile << """

        result.assertTaskSkipped(":createEmpty")
    }

    @Issue("https://github.com/gradle/gradle/issues/13554")
    def "removing an empty output directory is detected even when it existed before the first task execution"() {
        buildFile """
            task createEmptyDir {
                outputs.dir("empty")
                doLast {
                    // do nothing, since Gradle does create the empty directory for us.
                }

     * as this does not include overlapping outputs not produced by the work.
     */
    ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork();

    /**
     * The origin metadata of the outputs captured.
     */
    OriginMetadata getOriginMetadata();

    /**
     * Whether the outputs come from a previous execution.
     */
    boolean isReused();