given:
        def metadata = create(requested)

        when:
        ComponentSelector componentSelector = metadata.getSelector()

        then:
        componentSelector instanceof ModuleComponentSelector
        componentSelector.group == 'org'
        componentSelector.module == 'module'
        componentSelector.version == '1.2+'
    }

                traverseDependencies(level + 1, componentResult.dependencies)
            } else if (result is UnresolvedDependencyResult) {
                val componentSelector: ComponentSelector = result.attempted
                val node: String = "${calculateIndentation(level)}- ${componentSelector.displayName} (failed)"
                logger.quiet(node)
            }
        }
    }

                traverseDependencies(level + 1, componentResult.dependencies)
            } else if (result instanceof UnresolvedDependencyResult) {
                ComponentSelector componentSelector = result.attempted
                String node = calculateIndentation(level) + "- $componentSelector.displayName (failed)"
                logger.quiet node
            }
        }
    }

    private String calculateIndentation(int level) {

        ComponentSelector componentSelector = dependency.getSelector();
        if (componentSelector instanceof ModuleComponentSelector) {
            ModuleComponentSelector module = (ModuleComponentSelector) componentSelector;
            if (acceptor.isDynamic()) {

import org.gradle.api.artifacts.component.ComponentSelector;

/**
 * Adapts the new `ComponentSelector` types to legacy types.
 * Note that for `ProjectComponentSelector` this requires looking up the target project in order
 * to determine the project coordinates.
 */
public interface ComponentSelectorConverter {
    ModuleIdentifier getModule(ComponentSelector selector);

    }

    public DependencyState withTarget(ComponentSelector target, List<ComponentSelectionDescriptorInternal> ruleDescriptors) {
        DependencyMetadata targeted = dependency.withTarget(target);
        return new DependencyState(targeted, requested, ruleDescriptors, componentSelectorConverter);
    }

        return delegate.getArtifacts();
    }

    @Override
    public DependencyMetadata withTarget(ComponentSelector target) {
        return delegate.withTarget(target);
    }

    @Override
    public DependencyMetadata withTargetAndArtifacts(ComponentSelector target, List<IvyArtifactName> artifacts) {
        return delegate.withTargetAndArtifacts(target, artifacts);
    }

    @Override

class DefaultDependencySubstitutionSpec extends Specification {
    ComponentSelector componentSelector = Mock(ComponentSelector)
    List<IvyArtifactName> artifacts = []
    def details = newSubstitution()

    private DefaultDependencySubstitution newSubstitution() {
        new DefaultDependencySubstitution(DependencyManagementTestUtil.componentSelectionDescriptorFactory(), componentSelector, artifacts)
    }

 */
package org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution;

import org.gradle.api.Action;
import org.gradle.api.artifacts.ArtifactSelectionDetails;
import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.result.ComponentSelectionDescriptor;
import org.gradle.api.internal.artifacts.DependencySubstitutionInternal;

    # The following deprecation is coming from the Android plugin
    #> Task :app:javaPreCompileDebug
    #The Substitution.with(ComponentSelector) method has been deprecated. This is scheduled to be removed in Gradle 8.0. Please use the using(ComponentSelector) method instead. Consult the upgrading guide for further information: https://docs.gradle.org/7.1-20210406210000+0000/userguide/upgrading_version_7.html#dependency_substitutions_with