private final ComponentSelector requested;
    private final ComponentIdentifier actual;
    private final boolean resolvable;
    private final Set<RenderableDependency> children = new LinkedHashSet<>();

    public RequestedVersion(ComponentSelector requested, ComponentIdentifier actual, boolean resolvable) {
        this.requested = requested;
        this.actual = actual;
        this.resolvable = resolvable;

			continue
		}

		// Get the list of available devices, for which TopologyHints should be generated.
		available := m.getAvailableDevices(resource)
		if available.Len() < requested {
			klog.ErrorS(nil, "Unable to generate topology hints: requested number of devices unavailable", "resource", resource, "request", requested, "available", available.Len())

                def b2 = stream.read()
                assert b2 == bytes[1]
            }
            thread.blockUntil.requested
            thread.block()
            stream.received(bytes)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested }
    }

    def "read byte returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)

        reason.isExpected()
    }

    def "requested with other selection reason is not expected"() {
        given:
        def reason = ComponentSelectionReasons.requested()

        when:
        addCause(reason, ComponentSelectionCause.CONFLICT_RESOLUTION, "test")

        then:
        !reason.isExpected()
    }

    def "other selection reason and requested is not expected"() {
        when:

        then:
        _ * details.requested >> DefaultModuleComponentSelector.newSelector(requested)
        _ * details.getOldRequested() >> requested
        1 * details.useTarget(DefaultModuleComponentSelector.newSelector(mid(requested.group, requested.name), forcedVersion), ComponentSelectionReasons.FORCED)
        0 * details._

        where:
        requested                                            | forcedVersion

        for (Attribute<?> requested : requestedAttributes.keySet()) {
            Object requestedValue = requestedAttributes.getAttribute(requested);
            if (requested.getName().equals(actualAttribute.getName())) {
                // found an attribute with the same name, but they do not necessarily have the same type
                if (requested.equals(actualAttribute)) {

        return getActual();
    }

    @Override
    public String getName() {
        ComponentSelector requested = getRequested();
        ComponentIdentifier selected = getActual();

        if(exactMatch(requested, selected)) {
            return getSimpleName();
        }

        if(requested instanceof ModuleComponentSelector && selected instanceof ModuleComponentIdentifier) {

        extraAttributes = AttributeSelectionUtils.collectExtraAttributes(schema, candidates.toArray(new ImmutableAttributes[0]), requested.asImmutable()).toList()
    }

    @CompileStatic
    void requested(@DelegatesTo(value=AttributeContainerInternal, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {
        configureAttributes(requested, spec)
    }

    @CompileStatic

                        assert it.target == it.requested
                        it.useTarget group: it.requested.group, name: it.requested.module, version: '1.4'
                    }
                    all {
                        assert it.target.version == '1.4'
                        assert it.target.module == it.requested.module
                        assert it.target.group == it.requested.group

    private final Provider<Boolean> requested;
    private final Provider<Boolean> active;

    public DefaultBuildFeature(Provider<Boolean> requested, Provider<Boolean> active) {
        this.requested = requested;
        this.active = active;
    }

    @Override
    public Provider<Boolean> getRequested() {
        return requested;
    }

    @Override