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) {

			}
			expectEmptyUpdate(t, ch)

			addFile := func() {
				// Add a file
				if symlink {
					testCase.writeToFile(linkedDirName, fileName, t)
					return
				}

				testCase.writeToFile(dirName, fileName, t)
			}

			go addFile()

			// For !watchDir: expect an update by SourceFile.reloadConfig().

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

                }

                genericArgs.add("-emit-object");

                File outputFileMapFile = new File(spec.getObjectFileDir(), "output-file-map.json");
                outputFileMap.writeToFile(outputFileMapFile);

                List<String> outputArgs = new ArrayList<>();
                outputArgs.add("-output-file-map");
                outputArgs.add(outputFileMapFile.getAbsolutePath());

            return importDeclarations
        }

        TestClass writeToFile(File file) {
            file.text = """
                package ${packageName};

                ${importDeclarations}

                ${body}
            """
            return this
        }

        TestClass writeToBuildSrc() {

    /**
     * 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() {