delegate.requestedCapabilities

    override fun getVersionConstraint(): VersionConstraint =
        delegate.versionConstraint

    override fun getModule(): ModuleIdentifier =
        delegate.module

    override fun getArtifacts(): MutableSet<DependencyArtifact> =
        delegate.artifacts

    override fun setTargetConfiguration(name: String?) {

        return new DependencyResult() {
            @Override
            public ComponentSelector getRequested() {
                return DefaultModuleComponentSelector.newSelector(versionIdentifier.getModule(), versionIdentifier.getVersion());
            }

            @Override
            public ResolvedComponentResult getFrom() {
                return null;
            }

            @Override

    }

    @Override
    public void write(Encoder encoder, ModuleComponentSelector value) throws IOException {
        encoder.writeString(value.getGroup());
        encoder.writeString(value.getModule());
        writeVersionConstraint(encoder, value.getVersionConstraint());
        writeAttributes(encoder, ((AttributeContainerInternal)value.getAttributes()).asImmutable());

        publication.setAlias(true);
        publication.setOrganisation(pluginId);
        publication.setModule(pluginId + PLUGIN_MARKER_SUFFIX);

        Provider<String> organisation = getProviderFactory().provider(mainPublication::getOrganisation);
        Provider<String> module = getProviderFactory().provider(mainPublication::getModule);
        Provider<String> revision = getProviderFactory().provider(mainPublication::getRevision);

        }

        @Override
        public void testFixtures() {
            this.capabilitiesMutator = capabilities -> capabilities.requireCapability(new DefaultImmutableCapability(dep.getModule().getGroup(), dep.getModule().getName() + TEST_FIXTURES_CAPABILITY_APPENDIX, null));
        }

        @Override
        public void classifier(String classifier) {
            this.classifier = classifier;
        }

        for (Pair<ModuleVersionIdentifier, ProjectComponentIdentifier> replacement : replacements) {
            replacementMap.put(replacement.getLeft().getModule(), replacement.getRight());
        }
    }

    @Override
    public void execute(DependencySubstitution sub) {
        DependencySubstitutionInternal dependencySubstitution = (DependencySubstitutionInternal) sub;

        Mock(ComponentState) {
            getId() >> mvi
            getComponentId() >> DefaultModuleComponentIdentifier.newId(mvi)
            isCandidateForConflictResolution() >> true
            getModule() >> Mock(ModuleResolveState)
        }
    }

    CapabilityInternal capability(String group="org", String name="cap") {
        Mock(CapabilityInternal) {
            getGroup() >> group

        return ImmutableCapabilities.of(
            new ShadowedImmutableCapability(new DefaultImmutableCapability(
                    componentId.getGroup(),
                    componentId.getModule(),
                    componentId.getVersion()
            ), enforced ? "-derived-enforced-platform" : "-derived-platform")
        );
    }

            this.test = test
            if (dependencyNotation instanceof MavenModule) {
                module = dependencyNotation
            }
            createSpecs()
        }

        MavenModule getModule() {
            super.module
        }

        void validate() {
            singleValidation(false, withoutModuleMetadataSpec)
            singleValidation(true, withModuleMetadataSpec)
        }

        DefaultIvyArtifactName moduleMetadataArtifact = new DefaultIvyArtifactName(moduleComponentIdentifier.getModule(), "module", "module");
        DefaultModuleComponentArtifactMetadata artifactId = new DefaultModuleComponentArtifactMetadata(moduleComponentIdentifier, moduleMetadataArtifact);