// the cert was just issued and the client requested a duration
			requested.WithLabelValues(signer).Inc()

			certs, err := cert.ParseCertsPEM(issuedCert)
			if err != nil {
				utilruntime.HandleError(fmt.Errorf("metrics recording failed to parse certificate for CSR %s: %w", oldCSR.Name, err))
				return
			}

			// now we check to see if the signer honored the requested duration
			certificate := certs[0]

 * @since 4.4
 */
public interface VcsMapping {
    /**
     * The requested dependency, before it is resolved.
     * The requested dependency does not change even if there are multiple dependency substitution rules
     * that manipulate the dependency metadata.
     */
    ComponentSelector getRequested();

    /**
     * Specifies the VCS location for the requested component.
     *
     * @since 4.6
     */

        return Collections.emptyList();
    }

    protected boolean exactMatch(ComponentSelector requested, ComponentIdentifier selected) {
        if (requested instanceof ModuleComponentSelector) {
            VersionConstraint versionConstraint = ((ModuleComponentSelector) requested).getVersionConstraint();
            if (!(versionConstraint.getRequiredVersion().isEmpty()

            return new DetachedResolvedGraphDependency(requested, selectedId, null, null, constraint, fromVariant, selectedVariantId);
        } else if (resultByte == SUCCESSFUL_NOTHING_SELECTED) {
            long selectedId = decoder.readSmallLong();
            return new DetachedResolvedGraphDependency(requested, selectedId, null, null, constraint, fromVariant, null);
        } else if (resultByte == FAILED) {

	rawScoringFunction := helper.BuildBrokenLinearFunction(scoringFunctionShape)
	f := func(requested, capacity int64) int64 {
		if capacity == 0 || requested > capacity {
			return rawScoringFunction(maxUtilization)
		}

		return rawScoringFunction(requested * maxUtilization / capacity)
	}
	return func(classResources classResourceMap) int64 {
		var nodeScore int64

        then:
        _ * moduleDetails.target >> moduleTarget
        _ * moduleDetails.requested >> moduleTarget
        1 * componentSelectorConverter.getSelector(moduleTarget) >> moduleOldRequested
        1 * action.execute({ DefaultDependencyResolveDetails details ->
            details.requested == moduleOldRequested
        })
        1 * moduleDetails.artifactSelection(Actions.doNothing())
        0 * _

            println "I'm here"
          }
        """

        and:
        useCustomRepository("""
            resolutionStrategy.eachPlugin {
                if(requested.id.name == 'plugin') {
                    useVersion('1.0')
                }
            }
        """)

        when:
        succeeds("pluginTask")

        then:
        output.contains("I'm here")

     * <p>
     * If the descriptor type requested does not exist for the module under selection, {@code null} is returned.
     *
     * @param descriptorClass the descriptor class
     * @param <T> the descriptor type
     *
     * @return a descriptor fo the requested type, or {@code null} if there was none of the requested type.
     *

 * The {@link #getRequested() requested} property shows whether the user opted in or opted out from the feature.
 *
 * @see BuildFeatures
 * @since 8.5
 */
@Incubating
public interface BuildFeature {

    /**
     * Whether the feature was requested for the build.
     * <p>

  // Flag is turned on, some device is allowlisted, but the requested one isn't.
  rollout_config.AllowForDeviceInXlaLaunch(DeviceType(DEVICE_GPU));
  EXPECT_FALSE(UsePjRtForSingleDeviceCompilation(DeviceType(DEVICE_CPU)));

  // Flag is turned on and the requested device is allowlisted.
  rollout_config.AllowForDeviceInXlaLaunch(DeviceType(DEVICE_CPU));