implementation 'test:direct:1.0'
            }

            abstract class Resolve extends DefaultTask {
                @InputFiles
                abstract ConfigurableFileCollection getArtifacts()

                @InputFiles
                abstract ConfigurableFileCollection getArtifactCollection()

                @Internal
                List<String> expectedFiles = []

                @TaskAction

     *
     * @param parent A parent of the ResolvedDependency. Must not be null.
     * @throws org.gradle.api.InvalidUserDataException If the parent is unknown or null
     */
    Set<ResolvedArtifact> getArtifacts(ResolvedDependency parent);

    /**
     * Returns the parent artifacts of this dependency and its children. Never returns null.
     *
     * @param parent A parent of the ResolvedDependency. Must not be null.

                classpath = files()
            }

            dependencies {
                api('org.test:non-transitive:1.0') { transitive = false }
                api 'org.test:artifact-only:1.0@jar'
            }

            publishing {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }
                publications {

                    viewConfiguration.lenient(true);
                    viewConfiguration.componentFilter(getComponentFilter(visitor));
                }
            }).getArtifacts();
        }

        private Spec<ComponentIdentifier> getComponentFilter(IdeDependencyVisitor visitor) {
            return visitor.isOffline() ? NOT_A_MODULE : Specs.<ComponentIdentifier>satisfyAll();
        }

    @Override
    public ConfigurationVariant attributes(Action<? super AttributeContainer> action) {
        action.execute(attributes);
        return this;
    }

    @Override
    public PublishArtifactSet getArtifacts() {
        if (lazyArtifacts != null) {
            artifacts.addAll(lazyArtifacts.create());
            lazyArtifacts = null;
        }
        return artifacts;
    }

    @Override

 *                                  .execute()
 *
 *         for (component in result.resolvedComponents) {
 *             component.getArtifacts(SourcesArtifact).each { println "Source artifact for ${component.id}: ${it.file}" }
 *         }
 *     }
 * }
 * </pre>
 *
 * @since 2.0
 */
public interface ArtifactResolutionQuery {
    /**

public interface PluginRealmCache {
    /**
     * CacheRecord
     */
    class CacheRecord {
        public ClassRealm getRealm() {
            return realm;
        }

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

        private final ClassRealm realm;

        private final List<Artifact> artifacts;

        public CacheRecord(ClassRealm realm, List<Artifact> artifacts) {

     */
    @Internal
    public ListProperty<Publication> getPublications() {
        return publications.get();
    }

    @InputFiles
    @PathSensitive(PathSensitivity.NAME_ONLY)
    FileCollection getArtifacts() {
        return variantFiles;
    }

    /**
     * Returns the {@link FileCollectionFactory} to use for generation.
     *
     * @since 4.4
     */
    @Inject

        MavenSession session = createMavenSession(pom, eps);
        MavenProject project = session.getCurrentProject();

        project.setArtifacts(resolver.resolve(project, Collections.singleton(Artifact.SCOPE_COMPILE), session));

        List<String> elements = project.getCompileClasspathElements();
        assertEquals(2, elements.size());

        visitedArtifacts.select(configuration.getImplicitSelectionSpec()).visitArtifacts(visitor, false);
        resolutionHost.rethrowFailure("artifacts", visitor.getFailures());
        return visitor.getArtifacts();
    }