this
    }

    void createVerifyTaskModuleComponentIdentifier() {
        buildFile << """
task verify {
    doLast {
        def deps = configurations.${config}.incoming.resolutionResult.allDependencies as List
        assert deps.size() == 1
        def componentId = deps[0].selected.id

        def result = dependencies.createArtifactResolutionQuery()

import org.gradle.api.artifacts.component.ComponentSelector
import org.gradle.api.artifacts.component.ModuleComponentSelector
import org.gradle.api.artifacts.result.ComponentSelectionReason
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.ResolvedVariantResult
import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
import org.gradle.api.internal.artifacts.DefaultModuleVersionIdentifier

                    result = IncludeFileResolutionResult.HasMacroIncludes;
                }
                SourceIncludesResolver.IncludeResolutionResult resolutionResult = sourceIncludesResolver.resolveInclude(file, include, visibleMacros);
                if (!resolutionResult.isComplete()) {
                    LOGGER.info("Cannot locate header file for '{}' in source file '{}'. Assuming changed.", include.getAsSourceText(), file.getName());

import org.gradle.api.internal.attributes.ImmutableAttributes;

import java.util.function.Supplier;

/**
 * Contains the minimal data required to construct a complete {@link org.gradle.api.artifacts.result.ResolutionResult}.
 */
public class MinimalResolutionResult {

    private final Supplier<ResolvedComponentResult> rootSource;
    private final ImmutableAttributes requestedAttributes;

    public MinimalResolutionResult(

import org.gradle.api.artifacts.result.ArtifactResolutionResult
import org.gradle.api.artifacts.result.ArtifactResult
import org.gradle.api.artifacts.result.ComponentArtifactsResult
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.UnresolvedComponentResult
import org.gradle.api.artifacts.type.ArtifactTypeContainer
import org.gradle.api.attributes.AttributeMatchingStrategy

"""
        if (GradleContextualExecuter.configCache) {
            buildFile << """
task $taskName {
    def root = configurations.${config}.incoming.resolutionResult.rootComponent
    def result = root.map {
        def deps = it.dependencies
        $resolveAndCheck
        failures
    }
    doLast {
        def failures = result.get()

        repo.createLightWeightTag("1.2")
        dependency(dependencyName)

        buildFile << """
            classes.doLast {
                def components = configurations.runtimeClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 3
                assert components[0].build.buildPath == ':'
                assert components[0].build.name == ':'

            }

            loggingCapabilities {
                enforceLogback()
            }

            tasks.register("resolve") {
                def root = configurations.runtimeClasspath.incoming.resolutionResult.rootComponent
                doLast {
                    println root.get()
                }
            }
        """

        expect:
        succeeds("resolve", "--stacktrace")
    }

                implementation "org.scala-lang:scala-library:2.10.7"
            }
            task assertZincVersion {
                dependsOn configurations.zinc
                def result = configurations.zinc.incoming.resolutionResult.rootComponent

                doLast {

        return DocumentWithResolution(document, resolutionContainer)
    }

    fun AnalysisStepResult.usedSoftwareTypeNames(): Set<String> =
        findUsedSoftwareTypeNames(resolutionResult)

    fun AnalysisSequenceResult.extractConventionsDocument(forSoftwareTypes: Set<String>): DocumentWithResolution? {