def "determines name and extension from file name #inputFileName with version #version"() {
        when:
        def artifactFile = new ArtifactFile(new File(inputFileName), version)

        then:
        artifactFile.name == name
        artifactFile.extension == extension
        artifactFile.classifier == null

        where:
        inputFileName       | name              | extension | version

	}
}

func processFile(inputFileName string, privateKey []byte) {
	// Calculate the output file name
	var outputFileName string
	switch {
	case strings.HasSuffix(inputFileName, ".enc"):
		outputFileName = strings.TrimSuffix(inputFileName, ".enc") + ".zip"
	case strings.HasSuffix(inputFileName, ".zip"):
		outputFileName = strings.TrimSuffix(inputFileName, ".zip") + ".decrypted.zip"

        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:

			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)

    }

    def "can use up-to-date predicate to force task to execute"() {
        def inputFileName = 'src.txt'

        buildFile << """
def isUpToDate = providers.gradleProperty('uptodate').map { true }.orElse(false)

task inputsAndOutputs {
    def inputFile = file('${inputFileName}')
    def outputFile = file('src.a.txt')
    inputs.files inputFile
    outputs.file outputFile