*/
    void architecture(String name);

    /**
     * The operating system being targeted.
     * Defaults to the default operating system targeted by the tool chain (normally the current operating system).
     */
    @Nested
    OperatingSystem getOperatingSystem();

    /**
     * Sets the operating system being targeted.
     * <p>

        rules.withModule("group:module") { }

        then:
        e = thrown(InvalidUserCodeException)
        e.message == "bad targeted closure"

        and:
        1 * adapter.createFromClosure(ComponentSelection, _) >> { throw new InvalidUserCodeException("bad targeted closure") }
    }

    def "propagates error creating rule for rule source" () {
        when:
        rules.all ruleSource

    /**
     * Returns the group of the module that is targeted by this dependency or dependency constraint.
     * The group allows the definition of modules of the same name in different organizations or contexts.
     */
    String getGroup();

    /**
     * Returns the name of the module that is targeted by this dependency or dependency constraint.
     */
    String getName();

    /**

    }

    public DependencyState withTarget(ComponentSelector target, List<ComponentSelectionDescriptorInternal> ruleDescriptors) {
        DependencyMetadata targeted = dependency.withTarget(target);
        return new DependencyState(targeted, requested, ruleDescriptors, componentSelectorConverter);
    }

 */
public interface PlatformAwareComponentSpecInternal extends PlatformAwareComponentSpec, HasIntermediateOutputsComponentSpec {
    /**
     * Get the names of the targeted platforms that this component should be built for.
     *
     * @return the list of targeted platforms, may be empty but never null.
     */
    List<PlatformRequirement> getTargetPlatforms();

tasks.register('printMetadataRulesConfig') {
    FileCollection metadataRulesConfig = configurations.metadataRulesConfig
    doLast {
        metadataRulesConfig.each { println "Resolved: ${it.name}" }
    }
}

// tag::targeted-component-selection[]
configurations {
    targetConfig {
        resolutionStrategy {
            componentSelection {
                withModule("org.sample:api") { ComponentSelection selection ->

tasks.register("printMetadataRulesConfig") {
    val metadataRulesConfig: FileCollection = configurations["metadataRulesConfig"]
    doLast {
        metadataRulesConfig.forEach { println("Resolved: ${it.name}") }
    }
}

// tag::targeted-component-selection[]
configurations {
    create("targetConfig") {
        resolutionStrategy {
            componentSelection {
                withModule("org.sample:api") {

        apply(metadataProvider)

        then:
        !componentSelection.rejected
        // rules are called in order
        closureCalled == 0..3
    }

    def "can call both targeted and untargeted rules"() {
        metadataProvider.isUsable() >> true
        metadataProvider.getComponentMetadata() >> Mock(ComponentMetadata)
        metadataProvider.getIvyModuleDescriptor() >> Mock(IvyModuleDescriptor)

    }

    def "fails when targeted component is not found"() {
        given:
        buildScript simpleCppBuild()

        when:
        fails 'dependentComponents', '--component', 'unknown'

        then:
        failure.assertHasCause "Component 'unknown' not found."
    }

    def "fails when some of the targeted components are not found"() {
        given:

 * limitations under the License.
 */
package org.gradle.nativeplatform;

import org.gradle.api.Incubating;

import java.io.File;

/**
 * A binary artifact for a {@link NativeExecutable}, targeted at a particular platform with specific configuration.
 */
@Incubating
public interface NativeExecutableBinary extends NativeBinary {
    /**
     * The executable file.
     */
    File getExecutableFile();