when:
        run "mainSharedLibrary"

        then:
        executedAndNotSkipped ":compileMainSharedLibraryMainCpp", ":linkMainSharedLibrary", ":mainSharedLibrary"

        and:
        sharedLibrary(cppLib.dir.file("build/libs/main/shared/main")).assertExists()

        when:
        sample cppLib
        run "mainStaticLibrary"

        then:

        debugX86Binary.compilationDetails.compileTask.path == ":compileDebugX86Cpp"
        debugX86Binary.compilationDetails.compileTask.name == "compileDebugX86Cpp"
        debugX86Binary.linkageDetails.outputLocation == toolchain.sharedLibrary(file("build/lib/main/debug/x86/lib")).linkFile
        debugX86Binary.linkageDetails.additionalArgs.empty
        debugX86Binary.linkageDetails.linkTask.path == ":linkDebugX86"

        sharedLibrary("build/libs/greetings/shared/greetings").assertExists()
        staticLibrary("build/libs/greetings/static/greetings").assertExists()

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

        then:
        failure.assertHasDescription("Execution failed for task ':linkMainSharedLibrary'.");
        failure.assertHasCause("A build operation failed.")
        def libName = sharedLibrary("build/binaries/mainSharedLibrary/main").file.name
        failure.assertThatCause(containsText("Linker failed while linking ${libName}"))
    }

    @ToBeFixedForConfigurationCache

        debugBinary.compilationDetails.compileTask.path == ":compileDebugCpp"
        debugBinary.compilationDetails.compileTask.name == "compileDebugCpp"
        debugBinary.linkageDetails.outputLocation == toolchain.sharedLibrary(file("build/lib/main/debug/lib")).linkFile
        debugBinary.linkageDetails.additionalArgs.empty
        debugBinary.linkageDetails.linkTask.path == ":linkDebug"
        debugBinary.linkageDetails.linkTask.name == "linkDebug"

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

        and:
        final libProject = projectFile("lib/lib_helloLib.vcxproj")
        libProject.assertHasComponentSources(app.library, "src/hello")

        SharedLibraryBinarySpec sharedLibraryBinary = binaries.testSharedLibrary as SharedLibraryBinarySpec
        with(sharedLibraryBinary) {
            name == 'sharedLibrary'
            component == library

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

        then:
        def modPath = { TestFile file -> new TestFile("${file.parentFile}/new_output/_${file.name}") }
        modPath(executable("build/exe/main/main").file).assertExists()
        modPath(sharedLibrary("build/libs/hello/shared/hello").file).assertExists()
        modPath(staticLibrary("build/libs/hello/static/hello").file).assertExists()
    }

    @Issue("https://github.com/gradle/gradle-native/issues/368")

    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 << """
            rootProject.name = 'lib'
        """
        buildFile << """

    def "can build library from visual studio"() {
        useMsbuildTool()
        def debugBinaryLib = staticLibrary("build/libs/main/static/win32/debug/main")
        def debugBinaryDll = sharedLibrary("build/libs/main/shared/win32/debug/main")

        given:
        app.library.writeSources(file("src/main"))
        buildFile << """
model {
    components {
        main(NativeLibrarySpec)
    }