import org.gradle.test.fixtures.file.TestFile

class ExeWithLibraryUsingLibraryHelloWorldApp extends HelloWorldApp {

    void writeSources(TestFile mainSourceDir, TestFile librarySourceDir, TestFile greetingsLibrarySourceDir) {
        getExecutable().writeSources(mainSourceDir)
        getLibrary().writeSources(librarySourceDir)
        getGreetingsHeader().writeToDir(greetingsLibrarySourceDir)
        for (SourceFile sourceFile : greetingsSources) {

    @ToBeFixedForConfigurationCache
    def "executable with build type depends on library with matching build type"() {
        when:
        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.library.writeSources(file("src/hello"))

        and:
        buildFile << """
apply plugin: 'cpp'
model {
    buildTypes {
        debug
        release
    }
    components {

                    }
                }
            }
        """
    }

    @ToBeFixedForConfigurationCache
    def "visual studio tasks re-execute when source files are added"() {
        app.writeSources(file("src/main"))

        when:
        run "visualStudio"

        then:
        executedAndNotSkipped ":appVisualStudioSolution"
        executedAndNotSkipped getComponentTasks("main")

        when:

                            buildable = false
                        }
                    }
                }
            }
        """

        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/mainLib"))
    }

    String oppositeLibType(String libType) {
        return libType.toLowerCase() == "static" ? "shared" : "static"
    }

    @ToBeFixedForConfigurationCache
    def "can add action to tool chain that modifies tool arguments prior to execution"() {
        when:
        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.writeSources(file("src/main"))
        buildFile << """
apply plugin: 'cpp'

model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {

            }
        """
        writeBuildLogicPlugin()
        writeGreetTask "GreetTask", ORIGINAL_GREETING
        switch (kind) {
            case Kind.CHANGE_RESOURCE:
                writeResource ""
                break
        }
    }

    void applyChange() {
        switch (kind) {
            case Kind.CHANGE_SOURCE:
                writeGreetTask "GreetTask", CHANGED_GREETING

                }
            }
        }
        hello(NativeLibrarySpec)
    }
}
"""
        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/hello"))
        succeeds 'helloStaticLibrary'

        when:
        succeeds 'mainExe'

        then:
        executable('build/exe/main/main').exec().out == app.englishOutput

                lib library: 'hello', linkage: 'static'
            }
        }
        hello(NativeLibrarySpec)
    }
}
"""

        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.library.writeSources(file("src/hello"))
    }

    @ToBeFixedForConfigurationCache
    def "uses naming scheme of target platform when cross-compiling"() {

            ${toolChain.platformSpecificToolChainConfiguration()}
        }
    }
    components {
        main(NativeExecutableSpec)
    }
}
        """

        and:
        helloWorldApp.writeSources(file("src/main"))

        when:
        run "mainExecutable"

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

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        main(NativeExecutableSpec)
    }
}
"""

        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.library.writeSources(file("src/main"))
    }

    def "tool chain is not available when visual studio install is not available"() {
        when:
        buildFile << """
model {
    toolChains {