*
     * <p>The lazy aspect depends on what is done with the returned {@code ResolutionResult}.</p>
     *
     * This will resolve the dependency graph but will not resolve or download the artifacts.
     *
     * <p>You should note that when resolution fails, the exceptions are included in the {@link ResolutionResult} returned from this method. This method will not throw these exceptions.</p>
     *

            def resolutionResult = AbstractIvyPublishIntegTest.this.doResolveArtifacts(params)
            expectationSpec.with {
                if (expectSuccess) {
                    assert resolutionResult == expectedFileNames
                } else {
                    failureExpectations.each {

               foo 'org.springframework.boot:spring-boot-starter-web:2.2.2.RELEASE'
            }

            tasks.register("resolve") {
               doLast {
                  configurations.foo.incoming.resolutionResult.allComponents {
                      assert it instanceof ResolvedComponentResult
                      if (id instanceof ModuleComponentIdentifier) {
                          variants.each {

        schema.resolve("lambdaNotAllowed(0) { }").isError(ErrorReason.UnresolvedFunctionCallSignature::class)
    }

    private
    fun ResolutionResult.isSuccessful() {
        assertTrue { errors.isEmpty() }
        assertTrue { additions.size == 1 }
    }

    private
    fun ResolutionResult.isError(errorReason: KClass<out ErrorReason>) {
        assertTrue { errors.any { errorReason.isInstance(it.errorReason) } }
    }

 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.mappingToJvm

import org.gradle.declarative.dsl.schema.AnalysisSchema
import org.gradle.internal.declarativedsl.analysis.ResolutionResult
import org.gradle.internal.declarativedsl.analysis.SchemaTypeRefContext
import org.gradle.internal.declarativedsl.demo.assignmentTrace
import org.gradle.internal.declarativedsl.objectGraph.ReflectionContext

        """

        buildA.buildFile << """
            def runtimeClasspath = configurations.runtimeClasspath
            def rootProvider = runtimeClasspath.incoming.resolutionResult.rootComponent
            classes.doLast {
                def rootComponent = rootProvider.get()
                assert rootComponent.id.build.buildPath == ':'
                assert rootComponent.id.build.name == ':'

"""
    }

    def "downloads only the metadata when dependency graph is queried"() {
        given:
        buildFile << """
            task graph {
                def root = configurations.compile.incoming.resolutionResult.rootComponent
                doLast {
                    root.get()
                }
            }
"""

        when:
        module.pom.expectGet()
        module2.pom.expectGet()

                    def detached = project.configurations.detachedConfiguration(project.configurations.foo.dependencies as Dependency[])
                    result = detached.incoming.resolutionResult.rootComponent
                    declared = provider { project.configurations.foo.dependencies*.name }
                }
            }
            project(":a") {
                dependencies {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice;

import org.gradle.api.artifacts.result.ResolutionResult;
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.internal.artifacts.ResolveContext;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.DependencyGraphComponent;

            def resolutionResult = test.doResolveArtifacts(params)
            expectationSpec.with {
                if (expectSuccess) {
                    assert resolutionResult == expectedFileNames
                } else {
                    failureExpectations.each {