then:
        visited == 0

        when:
        def deps = dependencies.getDependencies(task)

        then:
        visited == 1
        deps as List == [dependency]

        when:
        deps = dependencies.getDependencies(Stub(Task))

        then:
        visited == 2
        deps as List == [dependency]
    }

    @Shared ivyMetadataFactory = DependencyManagementTestUtil.ivyMetadataFactory()
    @Shared defaultVariant

    private ivyComponentMetadata(String[] deps) {
        def dependencies = deps.collect { name ->
            new IvyDependencyDescriptor(newSelector(DefaultModuleIdentifier.newId('org.test', name), '1.0'), ImmutableListMultimap.of('runtime', 'runtime'))
        }

env MODFMT='{{.Path}}'


# 'go list -deps' lists packages and tests in the main module,
# along with their transitive dependencies.

go list -f $PKGFMT -deps ./...
stdout -count=4 '^.'
stdout '^example.com/a$'
stdout '^example.com/b$'
stdout '^example.com/main$'
stdout '^example.com/main/testonly'


# 'go list -deps -test' lists transitive imports of tests and non-tests in the
# main module.

        Collection<NodeBuilder> getNodes() {
            return nodes.values()
        }

        Collection<NodeBuilder> getNodesWithoutRoot() {
            def nodes = new HashSet<>()
            visitDeps(this.root.deps, nodes, new HashSet<>())
            return nodes
        }

        void virtualConfiguration(String id) {
            virtualConfigurations << id
        }

        conf "org:explicit-dependency:1.0"
    }
}
"""
    }

    def "can use defaultDependencies to specify default dependencies"() {
        buildFile << """
configurations.conf.defaultDependencies { deps ->
    deps.add project.dependencies.create("org:default-dependency:1.0")
}
"""
        resolve.prepare {
            config("conf", "checkDeps")
            config("child", "checkChild")
        }

        when:

            }

            dependencies {
                deps "androidx.appcompat:appcompat:1.3.0"
                deps "androidx.fragment:fragment-testing:1.4.1"

                constraints {
                    deps project(":lifecycle:lifecycle-livedata-core")
                    deps project(":lifecycle:lifecycle-viewmodel")
                    deps project(":lifecycle:lifecycle-viewmodel-savedstate")
                }

        javaLibrary.parsedPom.scope("runtime") {
            assert dependencies.size() == 1
            def deps = dependencies.values()
            assert deps[0].artifactId == 'b' // because of substitution
            assert deps[0].groupId == 'com.second'
            assert deps[0].version == '1.2'
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {

                doLast {
                    def deps = configurations.conf.incoming.resolutionResult.allDependencies as List
                    assert deps.size() == 1
                    assert deps[0].attempted.group == 'org.utils'
                    assert deps[0].attempted.module == 'api'
                    assert deps[0].attempted.version == '1.123.15'
                    assert deps[0].attemptedReason.selectedByRule

// returns immediately.
func runFuzzing(deps testDeps, fuzzTests []InternalFuzzTarget) (ok bool) {
	if len(fuzzTests) == 0 || *matchFuzz == "" {
		return true
	}
	m := newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz", *skip)
	tctx := newTestContext(1, m)
	tctx.isFuzzing = true
	fctx := &fuzzContext{
		deps: deps,
	}
	root := common{w: os.Stdout}
	if *isFuzzWorker {

            println "Rule executed on \${context.details.id}"
            context.details.allVariants {
                println("Variant \$it")
                withDependencies { deps ->
                    deps.each {
                       println "See dependency: \$it"
                    }
                }
            }
    }
}

dependencies {
    components {
        all(CachedRule)
    }