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]

    def setup() {
        objCppCompile = TestUtil.createTask(ObjectiveCppCompile, project)
    }

    def "executes using the objCppCompiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCppCompile.toolChain = toolChain
        objCppCompile.targetPlatform = platform
        objCppCompile.compilerArgs = ["arg"]

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

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

    public abstract SourceFile getAlternateMainSource();

 */

package org.gradle.nativeplatform.fixtures.app

import org.gradle.integtests.fixtures.SourceFile

class CppSimpleUnitTest extends CppSourceElement {
    final sum = new CppSum()
    final sumTest = new CppSumTest()

    List<SourceFile> sourceFiles = [
        new SourceFile("cpp", "test.cpp", """
            int main(int argc, char **argv) {
              if (42 == 42) {
                return 0;

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

import org.gradle.integtests.fixtures.SourceFile;
import org.gradle.util.internal.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

public abstract class CppSourceElement extends SourceElement {
    public abstract SourceElement getHeaders();

    public abstract SourceElement getSources();

    @Override
    public List<SourceFile> getFiles() {

        when:
        def sourceFile = file("src/main/java/Thing.java") << "class Thing {} /* broken compile "

        then:
        fails("build")

        when:
        sourceFile << "*/"

        then:
        buildTriggeredAndSucceeded()
    }

    def "can run tests"() {
        when:
        def sourceFile = file("src/main/java/Thing.java") << "class Thing {}"

        when:
        final newFile = file("src/main/${app.sourceType}/changed.${app.sourceExtension}")
        newFile << sourceFile.text
        sourceFile.delete()

        and:
        run "mainExecutable"

        then:
        outputs.recompiledFile newFile
        objectFileFor(sourceFile).assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache

import org.gradle.integtests.fixtures.SourceFile

class CppMain extends SourceFileElement implements AppElement {
    final GreeterElement greeter
    final SumElement sum

    CppMain(GreeterElement greeter, SumElement sum) {
        this.greeter = greeter
        this.sum = sum
    }

    final SourceFile sourceFile = new SourceFile("cpp", "main.cpp", """
    #include <iostream>
    #include "sum.h"

package org.gradle.nativeplatform.fixtures.app

import org.gradle.integtests.fixtures.SourceFile

class CppMainWithOptionalFeature extends SourceFileElement implements AppElement {
    final GreeterElement greeter

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

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