*/
public interface LocalOriginDependencyMetadata extends ForcingDependencyMetadata {

    @Override
    LocalOriginDependencyMetadata withTarget(ComponentSelector target);

    @Override
    LocalOriginDependencyMetadata withTargetAndArtifacts(ComponentSelector target, List<IvyArtifactName> artifacts);

    @Override
    LocalOriginDependencyMetadata forced();

    /**

        def mid = DefaultModuleIdentifier.newId("org.utils", "api")

        given:
        def matchingSubstitute = Mock(ComponentSelector)
        def nonMatchingSubstitute = Mock(ComponentSelector)
        def moduleDetails = Mock(DependencySubstitutionInternal)

        with(substitutions) {
            substitute module(matchingModule) using matchingSubstitute

    private final Map<ComponentSelector, SubstitutionResult> cache = new HashMap<>();

    public CachingDependencySubstitutionApplicator(DependencySubstitutionApplicator delegate) {
        this.delegate = delegate;
    }


    @Override
    public SubstitutionResult apply(DependencyMetadata dependency) {
        ComponentSelector selector = dependency.getSelector();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.result;

import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.result.ComponentSelectionReason;
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.artifacts.result.UnresolvedDependencyResult;

    private static class SelectorCacheKey {
        private final ComponentSelector componentSelector;
        private final boolean ignoreVersion;
        private final boolean virtualPlatformEdge;

        private SelectorCacheKey(ComponentSelector componentSelector, boolean ignoreVersion, boolean virtualPlatformEdge) {
            this.componentSelector = componentSelector;
            this.ignoreVersion = ignoreVersion;

    }

    public ResolvedGraphDependency read(Decoder decoder, Map<Long, ComponentSelector> selectors, Map<ComponentSelector, ModuleVersionResolveException> failures) throws IOException {
        long selectorId = decoder.readSmallLong();
        ComponentSelector requested = selectors.get(selectorId);
        boolean constraint = decoder.readBoolean();

        builder.addAll(extraFailures);
        for (Map.Entry<ComponentSelector, BrokenDependency> entry : failuresByRevisionId.entrySet()) {
            Collection<List<ComponentIdentifier>> paths = DependencyGraphPathResolver.calculatePaths(entry.getValue().requiredBy, root);

            ComponentSelector key = entry.getKey();

    private final ComponentSelector requested;
    private final Long selected;
    private final ComponentSelectionReason reason;
    private final ModuleVersionResolveException failure;
    private final boolean constraint;
    private final Long fromVariant;
    private final Long targetVariant;

    public DetachedResolvedGraphDependency(ComponentSelector requested,

    }

    static DefaultResolvedDependencyResult newDependency(ComponentSelector componentSelector, String group='a', String module='a', String selectedVersion='1') {
        new DefaultResolvedDependencyResult(componentSelector, false, newModule(group, module, selectedVersion), newVariant("variant"), newModule())
    }

 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.result;

import com.google.common.collect.Lists;
import org.gradle.api.artifacts.UnresolvedDependency;
import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.DependencyGraphComponent;