helloStatic();
                helloShared();
                return 0;
            }
        """

        when:
        succeeds "installMainExecutable"

        then:
        staticLibrary("build/libs/helloStatic/static/helloStatic").assertExistsAndDelete()
        sharedLibrary("build/libs/helloShared/shared/helloShared").assertExistsAndDelete()
        installation("build/install/main")

        staticLibrary("deck/build/lib/main/debug/deck").assertExists()
        staticLibrary("card/build/lib/main/debug/card").assertExists()
        staticLibrary("shuffle/build/lib/main/debug/shuffle").assertExists()
        executable("app/build/exe/main/debug/app").assertExists()

    }

    @Override
    TestFile getVariantSourceFile(String module, VariantContext variantContext) {
        return staticLibrary("${module}/build/lib/main/${variantContext.asPath}${module}").file
    }

    @Override
    Map<String, String> getVariantFileInformation(String linkage, String module, String variantModuleNameWithVersion) {

        libProject.projectConfigurations.values().each {
            assert it.includePath == filePath("src/hello/headers")
            assert it.buildCommand.endsWith("gradle\" -p \"..\" :lib:hello${it.name.capitalize()}StaticLibrary")
        }

        and:
        final mainSolution = solutionFile("app.sln")
        mainSolution.assertHasProjects("exe_mainExe", "lib_helloDll", "lib_helloLib")

        }

        and:
        StaticLibraryBinarySpec staticLibraryBinary = binaries.testStaticLibrary as StaticLibraryBinarySpec
        with(staticLibraryBinary) {
            name == 'staticLibrary'
            component == library

            toolChain.name == "tc"
            targetPlatform.name == "platform"
            buildType.name == "bt"
            flavor.name == "flavor1"
        }

        tool chain: Tool chain 'clang' (Clang)
        static library file: build/libs/someLib/static/libsomeLib.a
        source sets:
            C++ source 'someLib:staticLibrary:moreCpp'
                srcDir: src/staticLibrary/moreCpp
"""
    }

    @RequiresInstalledToolChain
    @ToBeFixedForConfigurationCache(because = ":components")
    def "shows details of native C++ library that is not buildable"() {
        given:

        debugStaticBinary.compilationDetails.compileTask.path == ":compileDebugStaticCpp"
        debugStaticBinary.linkageDetails.outputLocation == toolchain.staticLibrary(file("build/lib/main/debug/static/some-lib")).file
        debugStaticBinary.linkageDetails.additionalArgs.empty
        debugStaticBinary.linkageDetails.linkTask.path == ":createDebugStatic"

        sample cppLib
        run "mainStaticLibrary"

        then:
        executedAndNotSkipped ":compileMainStaticLibraryMainCpp", ":createMainStaticLibrary", ":mainStaticLibrary"

        and:
        staticLibrary(cppLib.dir.file("build/libs/main/static/main")).assertExists()
    }

    @ToBeFixedForConfigurationCache
    def flavors() {
        given:
        sample flavors

        when:

        and:
        executedAndNotSkipped ":greetingsSharedLibrary", ":greetingsStaticLibrary"
        sharedLibrary("build/libs/greetings/shared/greetings").assertExists()
        staticLibrary("build/libs/greetings/static/greetings").assertExists()

        and:
        try {
            println executable("build/exe/main/main").binaryInfo.listLinkedLibraries()

    }

    @Requires(IntegTestPreconditions.HasMsBuild)
    def "can build library from visual studio"() {
        useMsbuildTool()
        def debugBinaryLib = staticLibrary("build/lib/main/debug/static/lib")
        def debugBinaryDll = sharedLibrary("build/lib/main/debug/shared/lib")

        given:
        app.library.writeSources(file("src/main"))
        settingsFile << """