}

    @Override
    public DependencyMetadata withTargetAndArtifacts(ComponentSelector target, List<IvyArtifactName> artifacts) {
        if (target.equals(selector) && delegate.getArtifacts().equals(artifacts)) {
            return this;
        }
        return delegate.withTargetAndArtifacts(target, artifacts);
    }

    @Override
    public boolean isForce() {

            throw new UnsupportedOperationException("NameOnlyVariantResolveMetadata cannot be used that way");
        }

        @Override
        public ImmutableList<? extends ComponentArtifactMetadata> getArtifacts() {
            throw new UnsupportedOperationException("NameOnlyVariantResolveMetadata cannot be used that way");
        }

        @Override
        public ImmutableCapabilities getCapabilities() {

        InternalSession.associate(session, iSession);

        ArtifactResolutionResult result = repositorySystem.resolve(request);
        resolutionErrorHandler.throwErrors(request, result);
        assertEquals(2, result.getArtifacts().size());

        //
        // System scoped version which should
        //
        d.setScope(Artifact.SCOPE_SYSTEM);

        return mainArtifacts.artifact(source, config);
    }

    @Override
    public MavenArtifactSet getArtifacts() {
        populateFromComponent();
        return mainArtifacts;
    }

    @Override
    public void setArtifacts(Iterable<?> sources) {
        artifactsOverridden = true;
        mainArtifacts.clear();
        for (Object source : sources) {

        }

        CacheRecord(LifecycleExecutionException exception) {
            this.artifacts = null;
            this.exception = exception;
        }

        public Set<Artifact> getArtifacts() {
            return artifacts;
        }

        public LifecycleExecutionException getException() {
            return exception;
        }
    }

    Key createKey(

    }

    public Artifact getPomArtifact() {
        return pomArtifact;
    }

    public Artifact getRelocatedArtifact() {
        return relocatedArtifact;
    }

    public Set<Artifact> getArtifacts() {
        return artifacts;
    }

    public List<ArtifactRepository> getResolutionRepositories() {
        return resolutionRepositories;
    }

    public Map<String, Artifact> getManagedVersions() {

        LocalComponentDependencyMetadata dependencyMetaData = new LocalComponentDependencyMetadata(
            selector,
            projectDependency.getTargetConfiguration(),
            convertArtifacts(dependency.getArtifacts()),
            excludes,
            false, false, dependency.isTransitive(), false, dependency.isEndorsingStrictVersions(), dependency.getReason());

    }

    private ImmutableList<? extends ModuleComponentArtifactMetadata> getOriginalArtifacts() {
        return super.getArtifacts();
    }

    @Override
    public ImmutableList<? extends ModuleComponentArtifactMetadata> getArtifacts() {
        if (calculatedArtifacts == null) {

        }

        if (result.hasMissingArtifacts()) {
            throw new MultipleArtifactsNotFoundException(
                    request.getArtifact(),
                    toList(result.getArtifacts()),
                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        } catch (Exception t) {
            failures.add(t);
        }
    }

    @Override
    public boolean requireArtifactFiles() {
        return true;
    }

    public Set<ResolvedArtifactResult> getArtifacts() {
        return artifacts;
    }

    public Set<Throwable> getFailures() {
        return failures;
    }