*/
    String getProjectPath();

    /**
     * The name of the required library.
     */
    String getLibraryName();

    /**
     * The required linkage.
     */
    String getLinkage();

    /**
     * Creates a copy of this requirement with the specified project path
     */
    NativeLibraryRequirement withProjectPath(String projectPath);

            targetPlatform "x64"
        }
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            targetPlatform "x64"
            sources {
                cpp.lib library: 'hello', linkage: 'static'
            }
        }
    }
}
// end::target-platforms[]

// Apply arguments for debug binaries (these options are not yet set automatically)
// tag::build-type-config[]
model {
    binaries {

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>linkage</td>
            </tr>
            <tr>
                <td>publicHeaders</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

        });
    }

    static class LinkageSelectionRule implements AttributeDisambiguationRule<Linkage> {
        @Override
        public void execute(MultipleCandidatesDetails<Linkage> details) {
            if (details.getCandidateValues().contains(Linkage.SHARED)) {
                details.closestMatch(Linkage.SHARED);
            }
        }
    }

     */
    NativeLibraryRequirement getStatic();

    /**
     * Converts this library to a native library requirement that uses the api library linkage.
     */
    NativeLibraryRequirement getApi();

                }
            }
            project(':lib2') {
                apply plugin: 'cpp-library'
                library.linkage = [Linkage.STATIC]
            }
            project(':lib3') {
                apply plugin: 'cpp-library'
                library.linkage = [Linkage.STATIC]
            }
        """
        app.deck.writeToProject(file("lib1"))
        app.card.writeToProject(file("lib2"))

        assertMainSymbolIsAbsent(sharedLibrary("build/lib/main/debug/Greeter"))
    }

    def "fails when no linkage is specified"() {
        def library = new SwiftLib()
        buildFile << """
            apply plugin: 'swift-library'

            library {
                linkage = []
            }
        """
        settingsFile << """
            rootProject.name = 'foo'
        """

 * limitations under the License.
 */

package org.gradle.tooling.model.cpp;

import org.gradle.tooling.model.Task;

import java.io.File;
import java.util.List;

/**
 * Represents the linkage details for a binary.
 *
 * @since 4.10
 */
public interface LinkageDetails {
    /**

import org.gradle.language.internal.NativeComponentFactory;
import org.gradle.language.nativeplatform.internal.Dimensions;
import org.gradle.language.nativeplatform.internal.toolchains.ToolChainSelector;
import org.gradle.nativeplatform.Linkage;
import org.gradle.nativeplatform.TargetMachineFactory;
import org.gradle.nativeplatform.platform.internal.Architectures;
import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform;

import javax.inject.Inject;

            testing $.components.operators
        }
    }
}
// tag::configure-test-binary[]
model {
    binaries {
        withType(GoogleTestTestSuiteBinarySpec) {
            lib library: "googleTest", linkage: "static"

            if (flavor == flavors.failing) {
                cppCompiler.define "PLUS_BROKEN"
            }

            if (targetPlatform.operatingSystem.linux) {