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

                            lib library: 'hello'
                        }
                    }
                }
            }
        '''.stripIndent()

        helloWorldApp.writeSources(file("src/main"), file("src/hello"), file("src/greetings"))
    }

    def "creates #taskPrefix dependents tasks"() {
        when:
        succeeds 'tasks'

        then:

    def helloWorld = new CppCompilerDetectingTestApp()

    def setup() {
        buildFile << """
plugins { id 'cpp' }
"""

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

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @RequiresInstalledToolChain(ToolChainRequirement.GCC)
    @ToBeFixedForConfigurationCache

        URL resource = getClass().getResource("$baseDir/$path/$name");
        File file = new File(resource.toURI())
        return new SourceFile(path, name, file.text);
    }

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