when:
        Sign signTask = signing.sign(jar).first()

        then:
        def outputPath = jar.outputs.files.singleFile.toPath().toAbsolutePath().toString()
        signTask.signaturesByKey.containsKey(outputPath)
        signTask.signaturesByKey.get(outputPath) == signTask.singleSignature
    }

    def "files to sign that do not exist are ignored"() {
        given:

	if err := i.Close(); err != nil {
		t.Fatal(err)
	}

	o, err := os.CreateTemp(t.TempDir(), "fds-output")
	if err != nil {
		t.Fatal(err)
	}
	outputPath := o.Name()
	if err := o.Close(); err != nil {
		t.Fatal(err)
	}

	env := []string{"TEST_OUTPUT=" + outputPath}
	for _, e := range os.Environ() {
		if strings.HasPrefix(e, "GODEBUG=") || strings.HasPrefix(e, "GOTRACEBACK=") {
			continue
		}
		env = append(env, e)

		for _, component := range kubeadmconstants.ControlPlaneComponents {
			realPath := kubeadmconstants.GetStaticPodFilepath(component, manifestDir)
			outputPath := kubeadmconstants.GetStaticPodFilepath(component, kubeadmconstants.GetStaticPodDirectory())
			files = append(files, NewFileToPrint(realPath, outputPath))
		}
	} else {
		fmt.Printf("[dryrun] Wrote certificates and kubeconfig files to the %q directory\n", manifestDir)
	}

                    }

                    private void recordOutputSnapshot(FileSystemLocationSnapshot snapshot) {
                        String outputPath = snapshot.getAbsolutePath();
                        File outputFile = new File(outputPath);
                        outputFiles.put(outputPath, OutputKind.OUTPUT);
                        File outputFileParent = outputFile.getParentFile();
                        while (outputFileParent != null) {

        }

        return sequenceOf(directory)
    }

    private
    fun aJar(sourceFiles: Sequence<Path>): Sequence<Path> {
        val outputPath = projectDir.resolve("mylib.jar")
        Files.newOutputStream(outputPath).use { outputStream ->
            JarOutputStream(outputStream).use { jarStream ->
                sourceFiles.forEach { dir ->

                final String tempPath = tempFile.getAbsolutePath();
                final String outputPath = outputFile.getAbsolutePath();
                final List<String> cmdList = new ArrayList<>();
                for (final String value : commandList) {
                    cmdList.add(expandPath(value.replace("${url}", tempPath).replace("${outputFile}", outputPath)));
                }

                executeCommand(thumbnailId, cmdList);

        this.inputHierarchy = inputHierarchy;
    }

    public void detectMissingDependencies(LocalTaskNode node, TypeValidationContext validationContext) {
        for (String outputPath : node.getMutationInfo().outputPaths) {
            inputHierarchy.getNodesAccessing(outputPath).stream()
                .filter(consumerNode -> hasNoSpecifiedOrder(node, consumerNode))
                .filter(MissingTaskDependencyDetector::isEnabled)

    }

    private void doTransform(File input, TransformOutputs outputs, Function<String, String> instrumentedEntryNameMapper) {
        String outputPath = getOutputPath(input, instrumentedEntryNameMapper);
        File output = input.isDirectory() ? outputs.dir(outputPath) : outputs.file(outputPath);
        InterceptorTypeRegistryAndFilter typeRegistryAndFilter = provideInterceptorTypeRegistryAndFilter();

func podOutputPath(workDir string, cluster cluster.Cluster, pod corev1.Pod, dumpName string) string {
	return outputPath(workDir, cluster, pod.Name, dumpName)
}

// outputPath gives a path in the form of workDir/cluster/<prefix>_<suffix>
func outputPath(workDir string, cluster cluster.Cluster, prefix, suffix string) string {
	dir := path.Join(workDir, cluster.StableName())

	for _, component := range constants.ControlPlaneComponents {
		realPath := constants.GetStaticPodFilepath(component, dryRunManifestDir)
		outputPath := constants.GetStaticPodFilepath(component, constants.GetStaticPodDirectory())
		files = append(files, dryrunutil.NewFileToPrint(realPath, outputPath))
	}

	return dryrunutil.PrintDryRunFiles(files, os.Stdout)
}