it.children.each { transitive ->
                assert transitive.moduleGroup == "org.gradle.111"
                assert transitive.moduleName == "module_111"
                assert transitive.moduleVersion == "v_111"
            }
        }
        assert configurations.compile.collect { it.name } == ['test-1.45.jar', 'module_111-v_111.jar']
    }
}
"""
        resolve.prepare()

        when:

    def repo = Mock(ExternalResourceRepository)
    def module = new DefaultModuleIdentifier("org.acme", "testproject")
    def result = new DefaultBuildableModuleVersionListingResolveResult()
    def moduleVersion = new DefaultModuleVersionIdentifier(module, "1.0")
    def artifact = new DefaultIvyArtifactName("testproject", "jar", "jar")

    def resourceAccessor = Mock(CacheAwareExternalResourceAccessor)

    }

    private static class TestResolvedDependency implements ResolvedDependency, DependencyGraphNodeResult {
        String name
        String moduleGroup
        String moduleName
        String moduleVersion
        String configuration
        ResolvedModuleVersion module
        Set<ResolvedDependency> children = []
        Set<ResolvedDependency> parents
        Set<ResolvedArtifact> moduleArtifacts

import spock.lang.Specification

class ResourceVersionListerTest extends Specification {

    def repo = Mock(ExternalResourceRepository)
    def module = new DefaultModuleIdentifier("org.acme", "proj1")
    def moduleVersion = new DefaultModuleVersionIdentifier(module, "1.0")
    def artifact = new DefaultIvyArtifactName("proj1", "jar", "jar")
    def result = new DefaultBuildableModuleVersionListingResolveResult()

                        }
                        else if(it.id instanceof ProjectComponentIdentifier) {
                            println it.moduleVersion.name + ":" + it.moduleVersion.version + " " + it.selectionReason
                        }
                    }
                }
            }
        """

        when:
        run "resolutionResult"

        then:

            type = "other"
        }
        String variants = result.variants.collect { variant ->
            "variant:${formatVariant(variant)}"
        }.join('@@')
        "[$type][id:${result.id}][mv:${result.moduleVersion}][reason:${formatReason(result.selectionReason as ComponentSelectionReasonInternal)}][$variants]"
    }

    protected String formatVariant(ResolvedVariantResult variant) {

        then:
        resolvedDependency.name == someGroup + ":" + someName + ":" + someVersion
        resolvedDependency.moduleGroup == someGroup
        resolvedDependency.moduleName == someName
        resolvedDependency.moduleVersion == someVersion
        resolvedDependency.configuration == someConfiguration
        resolvedDependency.moduleArtifacts.empty
        resolvedDependency.children.empty
        resolvedDependency.parents.empty
    }

                    assert resolved.collect { "\${it.moduleName}:\${it.moduleVersion}" } == ['bar:1', 'foo:2']

                    resolved = compile.getFirstLevelModuleDependencies { true }
                    assert resolved.collect { "\${it.moduleName}:\${it.moduleVersion}" } == ['bar:1', 'foo:2']

                    def files = compile.files

                    assert files.size() == 2

        if (result.getId() instanceof ModuleComponentIdentifier) {
            ModuleVersionIdentifier moduleVersion = result.getModuleVersion();
            DefaultDependencyConstraint constraint = DefaultDependencyConstraint.strictly(
                moduleVersion.getGroup(),
                moduleVersion.getName(),
                moduleVersion.getVersion());
            constraint.because(consistentResolutionReason);
            return constraint;

        void start(RootGraphNode root) {
            this.root = root
        }

        @Override
        void visitNode(DependencyGraphNode node) {
            components.add(node.owner.moduleVersion)
        }

        @Override
        void visitEdges(DependencyGraphNode node) {
            node.outgoingEdges.each {
                if (it.failure) {