given:
        operatingSystem.internalOs >> OperatingSystem.WINDOWS

        expect:
        def actual = toolProvider.getSharedLibraryLinkFileName("sharedLibrary")
        actual == "sharedLibrary.lib"
    }

    def "system libraries contain union of VC++ and Windows SDK and UCRT"() {
        given:
        def dir1 = new File("1")
        def dir2 = new File("2")

        return swiftToolChain.executable(file(path))
    }

    SharedLibraryFixture swiftLibrary(Object path) {
        return swiftToolChain.sharedLibrary(file(path))
    }

    SharedLibraryFixture cppLibrary(Object path) {
        return cppToolChain.sharedLibrary(file(path))
    }

    StaticLibraryFixture staticCppLibrary(Object path) {
        return cppToolChain.staticLibrary(file(path))
    }

        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:

        then:
        _ * component.targetPlatforms >> [platformRequirement]
        1 * platforms.resolve(NativePlatform, requirement("platform1")) >> platform
        createdBinaries == ([
            "sharedLibrary",
            "staticLibrary",
        ] as SortedSet)
    }

    def "does not use variant dimension names when component targets a single point on dimension"() {
        when:

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

        when:
        run "installMainExecutable"

        then:
        sharedLibrary("build/libs/hello/shared/hello").assertExists()
        executable("build/exe/main/main").assertExists()

        def install = installation("build/install/main")
        install.assertInstalled()

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

    }

    String getSharedLibraryExtension() {
        return OperatingSystem.current().sharedLibrarySuffix.substring(1)
    }

    SharedLibraryFixture sharedLibrary(Object path) {
        return toolChain.sharedLibrary(file(path))
    }

    StaticLibraryFixture staticLibrary(Object path) {
        return toolChain.staticLibrary(file(path))
    }

        """
        library.writeToProject(testDirectory)

        when:
        succeeds('assemble')

        then:
        result.assertTasksExecuted(':compileDebugCpp', ':linkDebug', ':assemble')
        sharedLibrary('build/lib/main/debug/foo').assertExists()
    }

        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