module(_,_) >> { args -> DefaultModuleIdentifier.newId(*args)}
    }
    def moduleComponentIdentifier = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("org.test", "testArtifact"), "1.0")
    def serializer = Mock(ModuleMetadataSerializer)
    @Subject ModuleMetadataStore store = new ModuleMetadataStore(pathKeyFileStore, serializer, moduleIdentifierFactory, SimpleMapInterner.notThreadSafe())

        def selected = results.select(selector, Mock(ArtifactSelectionSpec), false)

        expect:
        selected.getArtifacts() instanceof CompositeResolvedArtifactSet
        selected.getArtifacts().sets == [variant1Artifacts, variant2Artifacts]

        selected.getArtifactsWithId(0) == variant1Artifacts
        selected.getArtifactsWithId(1) == variant2Artifacts
    }

    void setUp() {
        repositorySystem = new TestRepositorySystem();
    }

    @Test
    void testCacheKey() throws Exception {
        Artifact a1 = repositorySystem.createArtifact("testGroup", "testArtifact", "1.2.3", "jar");
        @SuppressWarnings("deprecation")
        ArtifactRepository lr1 = new DelegatingLocalArtifactRepository(repositorySystem.createDefaultLocalRepository());

        result.addArtifact(artifact)

        when:
        artifact.type >> ArtifactOne

        then:
        result.getArtifacts(Artifact) == [artifact] as Set
        result.getArtifacts(ArtifactOne) == [artifact] as Set
        result.getArtifacts(ArtifactTwo) == [] as Set
    }

    interface ArtifactOne extends Artifact {}
    interface ArtifactTwo extends Artifact {}

        return new MavenDependencyMetadata(dependencyDescriptor, reason, isEndorsingStrictVersions(), getArtifacts());
    }

    @Override
    public ModuleDependencyMetadata withEndorseStrictVersions(boolean endorse) {
        return new MavenDependencyMetadata(dependencyDescriptor, getReason(), endorse, getArtifacts());
    }

    @Override

            fileCollection.getSelectedArtifacts().visitArtifacts(visitor, lenient);

            Set<ResolvedArtifactResult> artifactResults = visitor.getArtifacts();
            Set<Throwable> failures = visitor.getFailures();

            if (!lenient) {
                resolutionHost.rethrowFailure("artifacts", failures);
            }

        where:
        givenComponentTypeRegistry | selectedComponentType | selectedArtifactType | failureMessage
        testComponentTypeRegistry  | UnknownComponent      | TestArtifact         | "Not a registered component type: ${UnknownComponent.name}."

            .collect(Collectors.toList());

        Ordering<OriginalArtifactIdentifier> ordering = Ordering.explicit(identifiers);
        return Stream.concat(externalDependencies.getArtifacts().stream(), projectDependencies.getArtifacts().stream())
            .map(ClassPathTransformedArtifact::ofTransformedArtifact)
            // We sort based on the original classpath to we keep the original order,

     * are NOT recommended (code like {@code "pom".equals(project.getPackaging)} must be avoided). Use method
     * {@link #getArtifacts()} to gain access to POM or build artifact.
     *
     * @see #getArtifacts()
     */
    @Nonnull
    Packaging getPackaging();

    /**
     * Returns the project language. It is by default determined by {@link #getPackaging()}.
     *

                Provider<Set<ResolvedArtifactResult>> resolvedArtifacts = resolvableDependencies.getArtifacts().getResolvedArtifacts();

                task.getArtifactFiles().from(resolvableDependencies.getArtifacts().getArtifactFiles());
                task.getArtifactIdentifiers().set(resolvedArtifacts.map(result -> result.stream().map(ResolvedArtifactResult::getId).collect(toList())));