* or both. There are two basic kind of "root nodes":</p>
 * <ul>
 *     <li>
 *         A "requested task", which is a task requested on the command-line. For example given `gradle a b:` then all the tasks that match `a` are treated as a requested task group (with ordinal 0)
 *         and all the tasks that match `b` are treated as another requested task group (with ordinal 1).
 *     </li>

pluginManagement {
    repositories {
        google()
        gradlePluginPortal()
    }
    resolutionStrategy {
        eachPlugin {
            if (requested.id.namespace == "com.android") {
                useModule("com.android.tools.build:gradle:${requested.version}")
            }
        }
    }
}
// tag::android[]
include("lib", "app")
// end::android[]

rootProject.name = "android-build"

gradle.allprojects {

        def edge = Stub(DependencyGraphEdge)
        _ * edge.selector >> selector
        _ * edge.requested >> selector.requested
        _ * edge.reason >> requested()
        _ * edge.failure >> new ModuleVersionResolveException(selector.requested, failure)
        _ * edge.fromVariant >> fromVariant
        _ * edge.selectedVariant >> null
        return edge
    }

        if (!isolatedProjectsActive) {
            myOptionalPluginLogicIncompatibleWithIsolatedProjects();
        }
    }

    private String describeFeatureUsage(Boolean requested) {
        return requested == null ? "no preference" : requested ? "opt-in" : "opt-out";
    }

    private void myOptionalPluginLogicIncompatibleWithIsolatedProjects() {
    }
}
// end::my-plugin[]

class MyReport {

# Regression test for https://golang.org/issue/37438.
#
# If a path exists at the requested version, but does not exist at the
# version of the module that is already required and does not exist at
# the version that would be selected by 'go mod tidy', then
# 'go get foo@requested' should resolve the requested version,
# not error out on the (unrelated) latest one.

go get example.net/a/p@v0.2.0

-- go.mod --
module example

go 1.15

    def "executes normally when cancellation is not requested"() {
        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        1 * delegate.execute(work, context) >> delegateResult

        then:
        0 *_
    }

    def "cancels execution when cancellation is requested"() {
        given:
        cancellationToken.cancel()

  - 0.9
  - 0.10
Versions rejected by attribute matching:
  - 1.1:
      - Attribute 'color' matched. Requested 'red', was: 'red'
      - Attribute 'shape' didn't match. Requested 'square', was: 'circle'
  - 1.0:
      - Attribute 'color' didn't match. Requested 'red', was: 'green'
      - Attribute 'shape' didn't match. Requested 'square', was: 'circle'
Searched in the following locations:
  - http://somewhere
  - file:/somewhere""")

        }
    }

    private boolean matchesRequested(DependencyResult candidate) {
        ComponentSelector requested = candidate.getRequested();

        if (requested instanceof ModuleComponentSelector) {
            ModuleComponentSelector requestedSelector = (ModuleComponentSelector) requested;
            return requestedSelector.getGroup().equals(moduleIdentifier.getGroup())

        }
    }

    static class EdgeBuilder {
        final String requested
        final NodeBuilder from
        NodeBuilder selected
        boolean constraint

        EdgeBuilder(NodeBuilder from, String requested, NodeBuilder selected) {
            this.from = from
            this.requested = requested
            this.selected = selected
        }

            this.attribute = attribute;
            this.requested = requested;
            this.provided = provided;
        }

        public Attribute<T> getAttribute() {
            return attribute;
        }

        @Nullable
        public T getRequested() {
            return requested;
        }

        @Nullable