result.assertTasksExecuted(':compileReleaseCpp', ':createRelease', ':assembleRelease')
        staticLibrary('build/lib/main/release/foo').assertExists()

        when:
        succeeds('assembleDebug')

        then:
        result.assertTasksExecuted(':compileDebugCpp', ':createDebug', ':assembleDebug')
        staticLibrary('build/lib/main/debug/foo').assertExists()
    }

    @ToBeFixedForConfigurationCache

        result.assertTasksExecuted(':compileDebugSwift', ':createDebug', ':assembleDebug')
        staticLibrary('build/lib/main/debug/Foo').assertExists()

        when:
        succeeds('assembleRelease')

        then:
        result.assertTasksExecuted(':compileReleaseSwift', ':createRelease', ':assembleRelease')
        staticLibrary('build/lib/main/release/Foo').assertExists()
    }

    def "can set output file"() {
        given:
        final binary = staticLibrary
        def outputFile = Mock(File)

        when:
        binary.staticLibraryFile = outputFile

        then:
        binary.staticLibraryFile == outputFile
    }

    def "can convert binary to a native dependency"() {
        final binary = staticLibrary
        given:
        def lifecycleTask = Stub(Task)

                apiElements.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, staticLibrary.getTargetMachine().getOperatingSystemFamily());
                apiElements.getOutgoing().artifact(staticLibrary.getModuleFile());
            });

            library.getBinaries().realizeNow();
        });
    }

            ":log:compileDebugSwift", ":log:createDebug",
            ":app:compileDebugSwift", ":app:linkDebug", ":app:installDebug", ":app:assemble")

        staticLibrary("hello/build/lib/main/debug/Hello").assertExists()
        staticLibrary("log/build/lib/main/debug/Log").assertExists()
        executable("app/build/exe/main/debug/App").assertExists()
        def installationDebug = installation("app/build/install/main/debug")

            } else if (binary instanceof CppStaticLibrary) {
                CppStaticLibrary staticLibrary = (CppStaticLibrary) binary;
                LaunchableGradleTask createTaskModel = buildLaunchableTask(projectIdentifier, staticLibrary.getLinkFileProducer().get());
                DefaultLinkageDetails linkageDetails = new DefaultLinkageDetails(createTaskModel, staticLibrary.getLinkFile().get().getAsFile(), Collections.<String>emptyList());

    }

    private static void assignToolsToStaticLibraryBinary(File buildDir, NativeBinarySpecInternal nativeBinary) {
        StaticLibraryBinarySpec staticLibrary = (StaticLibraryBinarySpec) nativeBinary;
        staticLibrary.setStaticLibraryFile(staticLibraryFileFor(nativeBinary, buildDir));
    }

    public static File executableFileFor(NativeBinarySpecInternal nativeBinary, File buildDir) {

        _ * 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:

    }

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

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

    NativeBinaryFixture resourceOnlyLibrary(Object path) {
        return toolChain.resourceOnlyLibrary(file(path))
    }

        debug.assertPublished()
        debug.assertArtifactsPublished(withStaticLibrarySuffix("test_debug-1.2"), "test_debug-1.2.pom", "test_debug-1.2.module")
        debug.artifactFile(type: staticLibraryExtension).assertIsCopyOf(staticLibrary("build/lib/main/debug/test").file)

        debug.parsedPom.scopes.isEmpty()

        def debugMetadata = debug.parsedModuleMetadata
        debugMetadata.variants.size() == 2