conf 'org.utils:impl:1.3', 'org.stuff:foo:2.0', 'org.stuff:bar:2.0'
            }

            List requested = new ${CopyOnWriteArrayList.name}()

            configurations.conf.resolutionStrategy {
                eachDependency {
                    requested << "\$it.requested.name:\$it.requested.version"
                }
            }

            task check {

     * a set of matching values from within the candidate set based on the provided {@code requested} value.
     *
     * @param attribute The attribute being disambiguated.
     * @param requested The requested attribute. If null, {@code attribute} is an extra attribute.
     * @param candidates All candidate values. If a remaining candidates does not include a value

    }

    private DependencyState(DependencyMetadata dependency, ComponentSelector requested, List<ComponentSelectionDescriptorInternal> ruleDescriptors, ComponentSelectorConverter componentSelectorConverter) {
        this.dependency = dependency;
        this.requested = requested;
        this.ruleDescriptors = ruleDescriptors;
        this.componentSelectorConverter = componentSelectorConverter;

    private final ComponentSelector requested;
    private final ResolvedComponentResult from;
    private boolean constraint;

    public AbstractDependencyResult(ComponentSelector requested, ResolvedComponentResult from, boolean constraint) {
        assert requested != null;
        assert from != null;

        this.from = from;
        this.requested = requested;
        this.constraint = constraint;
    }

                }
                rules.execute(result);
                if (result.hasResult()) {
                    return result.getMatches();
                }
            }

            if (requested != null && candidates.contains(requested)) {
                return Collections.singleton(requested);
            }

            return null;

        LOGGER.debug("No candidates for {}. Select nothing.", requested);
    }

    @Override
    public <T extends HasAttributes> void singleMatch(T candidate, Collection<? extends T> candidates, AttributeContainerInternal requested) {
        LOGGER.debug("Selected match {} from candidates {} for {}", candidate, candidates, requested);
    }

    @Override

	resourceScoringFunction := func(requested, capacity int64) int64 {
		if capacity == 0 || requested > capacity {
			return rawScoringFunction(maxUtilization)
		}

		return rawScoringFunction(requested * maxUtilization / capacity)
	}
	return func(requested, allocable []int64) int64 {
		var nodeScore, weightSum int64
		for i := range requested {
			if allocable[i] == 0 {
				continue
			}

			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: