package org.gradle.nativeplatform.fixtures.app;

import org.gradle.integtests.fixtures.SourceFile;

import java.util.Collections;
import java.util.List;

/**
 * A single source file.
 */
public abstract class SourceFileElement extends SourceElement {
    public abstract SourceFile getSourceFile();

    @Override
    public List<SourceFile> getFiles() {
        return Collections.singletonList(getSourceFile());
    }

        getSource().each { sourceFile ->
            String markdown = sourceFile.getText(encoding)
            String html = processor.markdownToHtml(markdown)
            File outputFile = new File(destinationDir, sourceFile.name.replace(".md", ".html"))
            outputFile.write(html, encoding)
        }
        if (generateIndex) {

    def setup() {
        objCppPCHCompile = TestUtil.createTask(ObjectiveCppPreCompiledHeaderCompile, project)
    }

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

package org.gradle.nativeplatform.fixtures.app

import org.gradle.integtests.fixtures.SourceFile

class SwiftCompilerDetectingApp extends SourceFileElement implements AppElement {
    def swiftVersion

    SwiftCompilerDetectingApp(swiftVersion) {
        this.swiftVersion = swiftVersion
    }

    @Override
    SourceFile getSourceFile() {
        return sourceFile('swift', 'main.swift', """
            #if swift(>=5.0)

    def setup() {
        cppPCHCompile = TestUtil.createTask(CppPreCompiledHeaderCompile, project)
    }

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

    SwiftLib() {
        this("greeter")
    }

    SwiftLib(String projectName) {
        super(projectName)
    }

    @Override
    List<SourceFile> getFiles() {
        return [greeter.sourceFile, sum.sourceFile, multiply.sourceFile]
    }

    @Override
    String getExpectedOutput() {
        return greeter.expectedOutput
    }

    @Override
    int sum(int a, int b) {

        greeter = new SwiftGreeterUsingCppFunction(cppGreeter)
        sum = new SwiftSum()
        multiply = new SwiftMultiply()
    }

    @Override
    List<SourceFile> getFiles() {
        return [greeter.sourceFile, sum.sourceFile, multiply.sourceFile]
    }

    @Override
    String getExpectedOutput() {
        return greeter.expectedOutput
    }

    @Override
    int sum(int a, int b) {

    }

    def parse(File sourceFile, ClassMetaDataRepository<gradlebuild.docs.dsl.source.model.ClassMetaData> repository) {
        if (!sourceFile.name.endsWith('.java')) {
            throw new DocGenerationException("Parsing non-Java files is not supported: $sourceFile")
        }
        try {
            new JavaParser().parse(sourceFile).getResult().get().accept(new SourceMetaDataVisitor(), repository)

                fflush(stdout);
                return 0;
            }

            """),
            sourceFile("asm", "foo1/sum.s", getAsmSource("sum1")),
            sourceFile("asm", "foo2/sum.s", getAsmSource("sum2"))
        ]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        []
    }

    protected def getAsmSource(String methodName) {
        if (toolChain.isVisualCpp()) {

    def setup() {
        cPCHCompile = TestUtil.createTask(CPreCompiledHeaderCompile, project)
    }

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