withProjectConfig("b") {
            outputFileName = "new"
        }
        succeeds(":a:resolve")

        then: // no change, should be up-to-date
        result.assertTasksNotSkipped(":a:resolve")
        transformed()
        outputContains("result = [b-dir.green, c-dir.green]")

        when:
        withProjectConfig("b") {
            outputFileName = "new"
            outputFileContent = "new"

    // We will export the runtime metadata with the same name under the same
    // directory except with a different extention ".rtmeta".
    llvm::SmallString<128> metadata_filename(options_.output_file_name);
    const char kRuntimeMetadataName[] = "rtmeta";
    llvm::sys::path::replace_extension(metadata_filename, kRuntimeMetadataName);

    std::string error_msg;

class TfLiteExporter : public mlir::TFL::tac::TacExporter {
 public:
  // Exporter configuration options.
  struct Options {
    bool export_runtime_metadata = false;
    bool output_mlir = false;
    std::string output_file_name;
    std::vector<std::string> target_hardware_backends;
  };

  explicit TfLiteExporter(const Options& options) : options_(options) {}

  absl::Status Export(mlir::ModuleOp module) override;

 private:

        then:
        1 * projectReportGenerator.execute(project)

        then:
        1 * renderer.completeProject(projectDetails)

        then:
        1 * renderer.complete()
    }

    def 'sets outputFileName on renderer before generation'() {
        setup:
        final File file = temporaryFolder.getTestDirectory().file("report.txt");
        def generator = createReportGenerator(file)

        when:

// 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;
extern llvm::cl::list<std::string> custom_opdefs;

				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
			assert.Equal(t, tc.expectCount, len(objects))
			if tc.expectOut {
				outputFileName := fmt.Sprintf("testdata/%s.out.yaml", tc.input)
				outputFile, err := os.Open(outputFileName)
				if err != nil {
					t.Errorf("error opening test data file: %v", err)
				}
				defer outputFile.Close()
				expectedYAML, err := io.ReadAll(outputFile)

            executer.withArgument("-D${projectName}OutputDir=${buildDirPath}")
        }

        void setOutputFileName(String outputFileName) {
            executer.withArgument("-D${projectName}FileName=${outputFileName}")
        }

        void setOutputDirName(String outputDirName) {
            executer.withArgument("-D${projectName}DirName=${outputDirName}")
        }

    llvm::cl::desc("Names to export from SavedModel, separated by ','. Empty "
                   "(the default) means export all."),
    llvm::cl::init(""));

// NOLINTNEXTLINE
opt<std::string> output_file_name("o", llvm::cl::desc("<output file>"),
                                  llvm::cl::value_desc("filename"),
                                  llvm::cl::init("-"));
// NOLINTNEXTLINE
opt<bool> use_splatted_constant(

  if (!status.ok()) {
    llvm::errs() << status.message() << '\n';
    return kTrFailure;
  }

  std::string error_msg;
  auto output = mlir::openOutputFile(output_file_name, &error_msg);
  if (output == nullptr) {
    llvm::errs() << error_msg << '\n';
    return kTrFailure;
  }
  output->os() << result;
  output->keep();