for (SourceFile sourceFile : getFiles()) {
            sourceFile.writeToDir(srcDir);
        }
    }

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

        resolve() == [header]
    }

    def resolve() {
        def directives = parser.parseSource(sourceFile)
        directives = serialize(directives, serializer)
        def macros = new CollectingMacroLookup()
        macros.append(sourceFile, directives)
        def result = resolver.resolveInclude(sourceFile, directives.all.first(), macros)
        assert result.complete
        result.files.file as List
    }

        def outputDir = file("unpack")
        def sourceFile = file(source)

        buildFile << """
            task unpack(type: Sync) {
                from($type(resources.$resourceType("${sourceFile.toURI()}")))
                into("unpack")
            }
        """

        when:
        packDir.file("A").text = "original"
        packDir."$packType"(sourceFile)

        then:
        succeeds("unpack")

        this.objectFileNameSuffix = suffix;
        return this;
    }

    public File map(File sourceFile) {
        final String baseName = FilenameUtils.removeExtension(sourceFile.getName());
        final String uniqueName = generateUniqueNameFor(sourceFile);
        File hashDirectory = new File(outputBaseFolder, uniqueName);
        return new File(hashDirectory, baseName + objectFileNameSuffix);
    }

            #endif
        """)
    }

    @Override
    SourceFile getCommonHeader() {
        sourceFile("headers", "common.h", """
            #ifndef COMMON_H
            #define COMMON_H
            #include "hello.h"
            #include <iostream>
            #endif
        """)
    }

    List<SourceFile> librarySources = [
        new SourceFile("objcpp", "hello.mm", """
            #define __STDC_LIMIT_MACROS

        and:
        outputs.recompiledFile sourceFile
    }

    @ToBeFixedForConfigurationCache
    def "source is always recompiled if it imported header via complex macro"() {
        given:
        def notIncluded = file("src/main/headers/notIncluded.h")
        notIncluded.text = """#pragma message("should not be used")"""
        sourceFile << """
            #define _MY_HEADER(X) #X

package org.gradle.nativeplatform.fixtures.app

import org.gradle.integtests.fixtures.SourceFile


class CppMainUsesGreeter extends SourceFileElement implements AppElement {
    final GreeterElement greeter

    CppMainUsesGreeter(GreeterElement greeter) {
        this.greeter = greeter
    }

    final SourceFile sourceFile = new SourceFile("cpp", "main.cpp", """
    #include "greeter.h"

    int main(int argc, char** argv) {

import org.gradle.integtests.fixtures.SourceFile

/**
 * A single module Swift app, with several source files, and an optional compile time feature.
 */
class SwiftAppWithOptionalFeature extends SourceElement {
    final greeter = new SwiftGreeterWithOptionalFeature()
    final main = new SwiftMainWithOptionalFeature(greeter.withFeatureDisabled())
    final List<SourceFile> files = [main.sourceFile, greeter.sourceFile]

            public SourceFile getLibraryHeader() {
                return getAlternateLibraryHeader();
            }

            @Override
            public List<SourceFile> getLibrarySources() {
                return getAlternateLibrarySources();
            }
        };
    }
    private SourceFile getAlternateLibraryHeader() {
        return getLibraryHeader();
    }

    public abstract SourceFile getAlternateMainSource();

        assert includes == []
        true
    }

    def noImports() {
        assert imports == []
        true
    }

    def useDirective(String directive) {
        sourceFile.text = sourceFile.text.replace("include", directive)
    }

    Expression expression(String value) {
        return RegexBackedCSourceParser.parseExpression(value)
    }

    Expression token(String value) {