def canCopyToOutputStream() {
        given:
        def src = writeToFile("src", "content")

        when:
        def outstr = new ByteArrayOutputStream()
        new TestFileTreeElement(src, chmod).copyTo(outstr)

        then:
        new String(outstr.toByteArray()) == "content"
    }

    def canCopyToFile() {
        given:
        def src = writeToFile("src", "content")
        def dest = temporaryFolder.file("dir/dest")

    private File sourceDir;
    private File headerDir;

    @TaskAction
    public void generate() {
        writeToFile(sourceDir, "gradle_cunit_main.c");
        writeToFile(headerDir, "gradle_cunit_register.h");
    }

    private void writeToFile(File directory, String fileName) {
        final File file = new File(directory, fileName);

            newInputArtifact,
            outputDir,
            newInputArtifact
        )

        when:
        def initialResults = buildTransformExecutionResult(resultFiles)
        serializer.writeToFile(resultFile, initialResults)
        then:
        resultFile.exists()
        initialResults.resolveForWorkspace(outputDir).resolveForInputArtifact(inputArtifact) == resultFiles

    }

    public TestFile writeToDir(TestFile base) {
        TestFile file = base.file(path, name);
        writeToFile(file);
        return file;
    }

    public void writeToFile(TestFile file) {
        if (file.exists()) {
            file.write("");
        }
        file.write(content);
    }

    public String withPath(String basePath) {

        return writeToDir(base, name);
    }

    public TestFile writeToDir(TestFile base, String name) {
        TestFile file = base.file(path, name);
        writeToFile(file);
        return file;
    }

    public void writeToFile(TestFile file) {
        if (file.exists()) {
            file.write("");
        }
        file.write(content);
    }

    public String withPath(String basePath) {

public class TransformExecutionResultSerializer {
    private static final String INPUT_FILE_PATH_PREFIX = "i/";
    private static final String OUTPUT_FILE_PATH_PREFIX = "o/";

    public void writeToFile(File target, TransformExecutionResult result) {
        List<String> resultFileContents = new ArrayList<>(result.size());

        result.visitOutputs(new TransformExecutionResult.OutputVisitor() {
            @Override

    /**
     * Writes the source files of this element to the given source directory.
     */
    public void writeToSourceDir(TestFile sourceDir) {
        for (SourceFile sourceFile : getFiles()) {
            sourceFile.writeToFile(sourceDir.file(sourceFile.getName()));
        }
    }

    public static SourceElement empty() {
        return new SourceElement() {
            @Override
            public List<SourceFile> getFiles() {

                    }
                }
            }
        }
    }
}
        """

        and:
        helloWorldApp.files.each { SourceFile sourceFile ->
            sourceFile.writeToFile(file("src/main/flat/${sourceFile.name}"))
        }

        when:
        run "mainExecutable"

        then:
        def mainExecutable = executable("build/exe/main/main")
        mainExecutable.assertExists()

	info.ClientKeyData = []byte{}
	info.ClientCertificateData = []byte{}
	info.ClientKey = pemPath
	info.ClientCertificate = pemPath

	// Writes the kubeconfig back to disk.
	if err = clientcmd.WriteToFile(*kubeconfig, kubeconfigPath); err != nil {
		return errors.Wrapf(err, "failed to serialize %q", kubeconfigPath)
	}

	// Restart the kubelet.

    }

    @ToBeFixedForConfigurationCache
    def "uses headers co-located with sources"() {
        given:
        // Write headers so they sit with sources
        helloWorldApp.files.each {
            it.writeToFile(file("src/main/c/${it.name}"))
        }
        buildFile << """
model {
    components {
        main(NativeExecutableSpec) {
            sources {
                c.source.include "**/*.c"