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

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

    @ToBeFixedForConfigurationCache
    def "can build when language tools that are not required are not available"() {
        when:
        buildFile << """

    List<SourceFile> getFiles() {
        return sourceFiles + headerFiles
    }

    abstract List<SourceFile> getSourceFiles()

    abstract List<SourceFile> getHeaderFiles()

    void writeSources(TestFile sourceDir) {
        for (SourceFile srcFile : files) {
            srcFile.writeToDir(sourceDir)
        }
    }

    final app = new CppHelloWorldApp()

    def "setup"() {
        settingsFile << "rootProject.name = 'test'"
        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("libs/src/hello"))

        file("libs/build.gradle") << """
apply plugin: 'cpp'
model {
    flavors {
        english
        french
    }
    components {

            plugins {
                id 'java'
            }

            ${mavenCentralRepository()}

            check.dependsOn testing.suites
        """
    }

    abstract void writeSources(TestFile sourcePath)

    void assertTestsWereExecutedAndExcluded() {
        DefaultTestExecutionResult result = new DefaultTestExecutionResult(testDirectory)

        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
        """

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

        when:
        fails "compileMainExecutableMainObjcpp"

        then:
        failure.assertThatCause(containsString("Objective-C++ is not available on the Visual C++ toolchain"))
    }

        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
        """

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

        when:
        fails "compileMainExecutableMainObjc"

        then:
        failure.assertThatCause(containsString("Objective-C is not available on the Visual C++ toolchain"))
    }

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

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

    @RequiresInstalledToolChain(SUPPORTS_32)
    @ToBeFixedForConfigurationCache
    def "can configure platform specific args"() {
        when:

                    }
                }
            }
        }
    }
}
"""

        and:
        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/helloLib"))

        when:
        succeeds "installMainExecutable"

        then:
        installation("build/install/main").exec().out == app.englishOutput
    }

class SharedLibrarySoNameIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {
    def "setup"() {
        settingsFile << "rootProject.name = 'test'"

        def app = new CppHelloWorldApp()
        app.library.writeSources(file("src/hello"))

        buildFile << """
apply plugin: 'cpp'
model {
    components {
        hello(NativeLibrarySpec)
    }
}
"""
    }

    @ToBeFixedForConfigurationCache

    def setup() {
        buildFile << """
plugins {
    id 'cpp'
}
model {
    components {
        main(NativeExecutableSpec)
    }
}
"""

        testApp.writeSources(file("src/main"))
    }

    @ToBeFixedForConfigurationCache
    def "can create installation for a different os than the current one"() {
        String installOS
        if (os.windows) {