succeeds taskName
        outputFile.text.contains inputFileName

        cleanup:
        cleanupSubst(drive)
    }

    def "up to date check works from filesystem's root - input file to output folder copy"() {
        def drive = 'Y:'
        substRoot(drive)

        def inputFileName = "input.txt"
        def inputFile = file(inputFileName)
        inputFile << 'content'

  llvm::InitLLVM y(argc, argv);
  llvm::cl::ParseCommandLineOptions(argc, argv);
  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(inputFileName.c_str());
  if (std::error_code error = file_or_err.getError()) {
    llvm::errs() << argv[0] << ": could not open input file '" << inputFileName
                 << "': " << error.message() << "\n";
    return 1;
  }
  auto buffer = file_or_err->get();
  std::string output_buffer;

                }
            }
"""
    }

    def "reuses compiler daemons across continuous build instances" () {
        def inputFileName = sourceFileName
        def inputFile = file(inputFileName).createFile()
        def compilerDaemonIdentityFileName = "build/compilerId"
        def compilerDaemonIdentityFile = file(compilerDaemonIdentityFileName)

        buildFile << """

  llvm::InitLLVM y(argc, argv);
  llvm::cl::ParseCommandLineOptions(argc, argv);
  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(inputFileName.c_str());
  if (std::error_code error = file_or_err.getError()) {
    llvm::errs() << argv[0] << ": could not open input file '" << inputFileName
                 << "': " << error.message() << "\n";
    return 1;
  }
  auto buffer = file_or_err->get();
  auto maybe_module =

        def inputDir2 = file("input2").createDir()
        def inputFileName = "inputFile.txt"
        def inputFile = inputDir1.file(inputFileName)
        inputFile.text = "input"

        when:
        run "customTask"
        then:
        executedAndNotSkipped(":customTask")

        when:
        Files.move(inputFile.toPath(), inputDir2.file(inputFileName).toPath())
        run "customTask"
        then:

namespace tflite {
namespace {
std::unique_ptr<mlir::TFL::tac::TacImporter> CreateTfLiteImporter(
    const std::string input_file_name) {
  mlir::TFL::tac::TfLiteImporter::Options options;
  options.file_name = input_file_name;
  options.input_mlir = false;
  return std::make_unique<mlir::TFL::tac::TfLiteImporter>(options);
}

std::unique_ptr<mlir::TFL::tac::TacExporter> CreateTfLiteExporter(

#include "tensorflow/compiler/mlir/tensorflow/utils/error_util.h"
#include "tensorflow/core/platform/init_main.h"

using llvm::cl::opt;

// NOLINTNEXTLINE
opt<std::string> input_file_name(llvm::cl::Positional,
                                 llvm::cl::desc("<input file>"),
                                 llvm::cl::init("-"));

// NOLINTNEXTLINE

    module = tensorflow::ImportSavedModel(
        input_file_name, saved_model_version, tags, extra_opdefs,
        exported_names, specs, /*enable_variable_lifting=*/true, &context,
        &bundle);
  } else if (import_hlo) {
    // HLO import path.
    std::string error;
    std::unique_ptr<llvm::MemoryBuffer> buffer =
        mlir::openInputFile(input_file_name, &error);
    if (buffer == nullptr) {

//
// Please see the implementation file for documentation of details of these
// options.
// TODO(jpienaar): Revise the command line option parsing here.
extern llvm::cl::opt<std::string> input_file_name;
extern llvm::cl::opt<std::string> output_file_name;
extern llvm::cl::opt<bool> use_splatted_constant;
extern llvm::cl::opt<bool> input_mlir;
extern llvm::cl::opt<bool> output_mlir;

			failOnError: true,
			expectErr:   false,
			expectCount: 0,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			inputFileName := fmt.Sprintf("testdata/%s.yaml", tc.input)
			inputFile, err := os.Open(inputFileName)
			if err != nil {
				t.Errorf("error opening test data file: %v", err)
			}
			defer inputFile.Close()
			manifest, err := io.ReadAll(inputFile)