given:
        substitutions.all({ it.useTarget("1.0") } as Action)
        substitutions.all({ it.useTarget("2.0") } as Action)
        substitutions.all({ it.useTarget("3.0") } as Action)
        def details = Mock(DependencySubstitutionInternal)

        when:
        substitutions.ruleAction.execute(details)

        then:
        1 * details.useTarget("1.0")
        then:

                @Override
                public void useTarget(Object notation, ComponentSelectionDescriptor ruleDescriptor) {
                    ds.useTarget(addImplicitRequestAttributesAndCapabilities(notation), ruleDescriptor);
                }

                @Override
                public void useTarget(Object notation) {
                    ds.useTarget(addImplicitRequestAttributesAndCapabilities(notation));

        declaredReplacements 'a->b'
        buildFile << """
            configurations.all { resolutionStrategy.eachDependency { dep ->
                if (dep.requested.name == 'c') { dep.useTarget 'org:a:1' }
                if (dep.requested.name == 'd') { dep.useTarget 'org:b:1' }
            }}
        """
        expect:
        resolvedModules 'b'
    }

        @Override
        public ComponentSelector getRequested() {
            return selector;
        }

        @Override
        public void useTarget(Object notation) {
            didSubstitute = true;
        }

        @Override
        public void useTarget(Object notation, String reason) {
            didSubstitute = true;
        }

        @Override

                conf 'org.utils:a:1.2', 'org.utils:b:2.0'
            }

            configurations.conf.resolutionStrategy.eachDependency {
                if (it.requested.name == 'a') {
                    it.useTarget(it.requested.group + ':b:2.1')
                }
            }
"""
        resolve.prepare("conf")

        expect:
        succeeds("checkDeps")
        resolve.expectGraph {

                        if (it.requested.group.startsWith("org") && it.requested.module.startsWith("foo") && selector.accept(it.requested.version)) {
                            it.useTarget("org:foo:2.3", "bad version")
                        }
                    }
                }
            }

            dependencies {
                constraints {

        _ * details.getRequested() >> DefaultModuleComponentSelector.newSelector(mid, new DefaultMutableVersionConstraint("1.0"))
        _ * details.getOldRequested() >> newSelector(mid, "1.0")
        1 * details.useTarget(DefaultModuleComponentSelector.newSelector(mid, "2.0"), ComponentSelectionReasons.FORCED)
        0 * details._
    }

    def "eachDependency calls through to substitution rules"() {
        given:

                                    if (it.requested.module == 'leaf' && it.requested.version == '0.9') {
                                        it.useTarget("substitute 0.9 with 1.0", group: 'org.test', name: it.requested.module, version: '1.0')
                                    }
                                }
                            }
                        }

                            all { DependencySubstitution dependency ->
                                if (dependency.requested.module == 'bar') {
                                    dependency.useTarget dependency.requested.group + ':foo:' + dependency.requested.version
                                }
                            }
                        }""", """resolutionStrategy.dependencySubstitution {

        substitutionAction.execute(_ as DependencySubstitution) >> { DependencySubstitution ds ->
            if (ds.requested.displayName.contains('foo')) {
                ds.useTarget(null)
            }
        }
        provider = newProvider()
        writeLockFile(['org:bar:1.1', 'org:foo:1.1'], unique)

        when:
        def result = provider.loadLockState('conf', owner)