configurations.all {
    resolutionStrategy.dependencySubstitution.all { DependencySubstitution dependency ->
        if (dependency.requested instanceof ModuleComponentSelector && dependency.requested.group == "org.example") {
            def targetProject = findProject(":${dependency.requested.module}")
            if (targetProject != null) {
                dependency.useTarget targetProject
            }
        }
    }
}

        Set<Attribute<?>> extraAttributes = new LinkedHashSet<>();
        for (ImmutableAttributes attributes : candidateAttributeSets) {
            extraAttributes.addAll(attributes.keySet());
        }
        removeSameAttributes(requested, extraAttributes);

        new DefaultMutableVersionConstraint(version)
    }

    abstract ExternalDependencyDescriptor create(ModuleComponentSelector selector)

    def "creates a copy with new requested version"() {
        def metadata = create(requested)

        given:

        when:
        def target = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("org", "module"), v("1.3+"))
        def copy = metadata.withRequested(target)

     *   all { DependencySubstitution dependency ->
     *     if (dependency.requested instanceof ModuleComponentSelector && dependency.requested.module == 'groovy-all') {
     *       dependency.useTarget dependency.requested.group + ':groovy:' + dependency.requested.version
     *     }
     *   }
     *   // Use a rule to replace all missing projects with module dependencies

                                         ComponentSelector requested,
                                         List<IvyArtifactName> artifacts) {
        this.componentSelectionDescriptorFactory = componentSelectionDescriptorFactory;
        this.requested = requested;
        this.target = requested;
        this.artifactSelectionDetails = new DefaultArtifactSelectionDetails(this, artifacts);
    }

        def metadata = createWithArtifacts(requested, [artifact1, artifact2, artifact3])

        expect:
        metadata.getConfigurationArtifacts(fromConfiguration) == [artifact1.artifactName, artifact3.artifactName]
    }

    def "excludes nothing when no exclude rules provided"() {
        def dep = createWithExcludes(requested, [])
        def moduleExclusions = new ModuleExclusions()

        this.schema = schema;
        this.candidates = candidates;
        this.requested = requested;
        this.explanationBuilder = explanationBuilder;

        this.requestedAttributes = requested.keySet().asList();

const (
	// Pod resources resize has been requested and will be evaluated by node.
	PodResizeStatusProposed PodResizeStatus = "Proposed"
	// Pod resources resize has been accepted by node and is being actuated.
	PodResizeStatusInProgress PodResizeStatus = "InProgress"
	// Node cannot resize the pod at this time and will keep retrying.
	PodResizeStatusDeferred PodResizeStatus = "Deferred"

import javax.annotation.Nullable;
import java.util.List;

/**
 * Details about artifact dependency substitution: this class gives access to the
 * original dependency requested artifacts, if any, and gives the opportunity to
 * replace the original requested artifacts with other artifacts.
 *
 * This can typically be used whenever you need to substitute a dependency with

            Strings.repeat(' ', 4),
            ["Attribute Name", "Provided", "Requested"],
            attributes.collect { new StyledTable.Row([it.key, it.value.provided, it.value.requested], StyledTextOutput.Style.Normal) }
        ))
    }

    @Immutable
    private static class AttributeValueTuple {
        final String provided
        final String requested