*/
        @Inject
        protected abstract ObjectFactory getObjectFactory();

        /**
         * {@inheritDoc}
         *
         * Selects the platform variant of the given dependency.
         */
        @Override
        protected void modifyImplementation(ModuleDependency dependency) {
            dependency.endorseStrictVersions();

					<select id="as_filetype" name="as.filetype" class="form-control">
						<option value=""><la:message key="labels.advance_search_filetype_default" /></option>
						<option value="html" <c:if test="${as.filetype.contains('html')}">selected</c:if>><la:message
								key="labels.advance_search_filetype_html"
							/></option>
						<option value="pdf" <c:if test="${as.filetype.contains('pdf')}">selected</c:if>><la:message

        failure.assertHasCause("""Module 'org:test' has been rejected:
   Cannot select module with conflict on capability 'org:test:1.0' also provided by [org:test:1.0(api), org:test:1.0(runtime)]""")
    }

    @Unroll("can select distinct variants of the same component by using different attributes with capabilities (conflict=#conflict)")
    void "can select distinct variants of the same component by using different attributes with capabilities"() {

public interface VisitedArtifactResults {
    /**
     * Selects the artifacts for the matching variant of each node seen during traversal.
     * The implementation should attempt to select artifacts eagerly, but may be lazy where
     * the selection cannot happen until the results are queried.
     *
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected

                def distinguishingValues = distinguisher == 'flavor' ? "\n  - Value: 'paid' selects variant: 'bar'\n  - Value: 'free' selects variant: 'foo'" : "\n  - Value: 'bar' selects variant: 'bar'\n  - Value: 'foo' selects variant: 'foo'"

    ) {
        // If a specific variant is requested by name, select it.
        if (dependencyConfiguration != null) {
            VariantGraphResolveState selected = variantSelector.selectVariantByConfigurationName(dependencyConfiguration, consumerAttributes, targetComponentState, consumerSchema);
            return new GraphVariantSelectionResult(Collections.singletonList(selected), false);
        }

					tx = tx.Unscoped()
				}

				if len(db.Statement.Selects) > 0 {
					selects := make([]string, 0, len(db.Statement.Selects))
					for _, s := range db.Statement.Selects {
						if s == clause.Associations {
							selects = append(selects, s)
						} else if columnPrefix := column + "."; strings.HasPrefix(s, columnPrefix) {
							selects = append(selects, strings.TrimPrefix(s, columnPrefix))
						}
					}

                // If there is a single constructor, and that constructor is public or package private we select it.
                return constructor;
            }
            if (constructor.getAnnotation(Inject.class) != null) {
                // Otherwise, if there is a single constructor that is annotated with `@Inject`, we select it (short-circuit).
                return constructor;
            }
        }

        def spec = new ArtifactSelectionSpec(ImmutableAttributes.EMPTY, { false }, selectFromAll, false, ResolutionStrategy.SortOrder.DEFAULT)
        def selected = artifactSet.select(selector, spec)

        then:
        0 * selector.select(_, _, _, _)
        selected == ResolvedArtifactSet.EMPTY

        where:
        selectFromAll << [true, false]
    }

import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider;

public interface ToolChainSelector {
    /**
     * Selects a platform of the given type that can run on the host machine, and a toolchain to build for this platform.
     */
    <T> Result<T> select(Class<T> platformType, T requestedPlatform);

    interface Result<T> {
        NativeToolChainInternal getToolChain();

        T getTargetPlatform();