* @return The artifact files of the specified dependencies.
     * @throws ResolveException when the resolve was not successful.
     *
     * @deprecated Use an {@link ArtifactView} with a {@code componentFilter} instead.
     */
    @Deprecated
    Set<File> getFiles(Spec<? super Dependency> dependencySpec) throws ResolveException;

    /**

        given:
        mainProjectDir.file("app/build.gradle") << """
            tasks.register("resolve", Resolve) {
                artifactFiles.from(configurations.getByName("compileClasspath").incoming.artifactView {
                    lenient = true
                }.getFiles())
            }
        """

        expect:
        succeeds "resolve"
    }

                }
            }

            dependencies {
                zipped files('evil.zip')
            }

            println(
                configurations.zipped.incoming.artifactView {
                    attributes.attribute(compressed, false)
                }.artifacts.artifactFiles.files
            )
        """

        when:
        fails 'help'

        then:

    fun Project.allDistributionSpec() = copySpec {
        val sourcesPath by configurations.getting
        val docsPath by configurations.getting

        with(binDistributionSpec())
        from(sourcesPath.incoming.artifactView { lenient(true) }.files) {
            eachFile {
                val subprojectFolder = file.containingSubprojectFolder(listOf("src", "main", "java").size + relativeSourcePath.segments.size)

    public Set<File> getFiles(final Spec<? super Dependency> dependencySpec) throws ResolveException {
        DeprecationLogger.deprecateMethod(ResolvedConfiguration.class, "getFiles(Spec)")
            .withAdvice("Use an ArtifactView with a componentFilter instead.")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "deprecate_filtered_configuration_file_and_filecollection_methods")
            .nagUser();

        to.attribute(filteredAttribute, Filtering.PUBLIC_API)
    }
}

val task = tasks.register<Jar>("jarGradleApi") {
    from(distributionClasspath.map { configuration ->
        configuration.incoming.artifactView {
            attributes {
                attribute(filteredAttribute, Filtering.PUBLIC_API)
            }
            componentFilter { componentId -> componentId is ProjectComponentIdentifier }
        }.files

                println(it)
            }

            val components =
                configurations
                    .compileClasspath.get()
                    .incoming
                    .artifactView { lenient(true) }
                    .artifacts
                    .map { it.id.componentIdentifier }

            val resolvedComponents =
                dependencies

            report.getReportTask().configure(task -> {
                Callable<FileCollection> testResults = () ->
                    testResultsConf.getIncoming().artifactView(view -> {
                        view.withVariantReselection();
                        view.componentFilter(id -> id instanceof ProjectComponentIdentifier);
                        view.attributes(attributes -> {

            runner.expectDeprecationWarning("The LenientConfiguration.getArtifacts(Spec) method has been deprecated. This is scheduled to be removed in Gradle 9.0. Use a lenient ArtifactView with a componentFilter instead. Consult the upgrading guide for further information: https://docs.gradle.org/${GradleVersion.current().version}/userguide/upgrading_version_8.html#deprecate_filtered_configuration_file_and_filecollection_methods",...

            }
        """
    }

    def createResolveTask(String attribute = "size") {
        """
            task resolve(type: Copy) {
                from configurations.runtimeClasspath.incoming.artifactView {
                    attributes { it.attribute(artifactType, '$attribute') }
                }.artifacts.artifactFiles
                into "\$buildDir/libs"
            }
        """
    }