- artifact selection via the link:{javadocPath}/org/gradle/api/artifacts/DependencySubstitution.html#artifactSelection-org.gradle.api.Action-[DependencySubstitution API]
- artifact selection via the link:{javadocPath}/org/gradle/api/artifacts/ResolutionStrategy.html#dependencySubstitution-org.gradle.api.Action-[ResolutionStrategy API]

                    extendsFrom conf
                }
            }
            configurations.forced.resolutionStrategy.force 'org:leaf:1.0'
            configurations.substituted.resolutionStrategy.dependencySubstitution {
                substitute module('org:leaf') using module('org:leaf:1.0')
            }
            dependencies {
                conf 'org:foo:1.0', 'org:bar:1.0'
            }
        """

    lockAllConfigurations()
}

repositories {
    maven {
        name 'repo'
        url '${mavenRepo.uri}'
    }
}
configurations {
    lockedConf {
        resolutionStrategy.dependencySubstitution {
            substitute module('org:test') using module('org:test:1.0')
        }
    }
}

dependencies {
    lockedConf 'org:test:[1.0,2.0)'
}

task resolve {

                dependencies {
                    compile group: 'org.utils', name: 'api', version: '1.3', configuration: 'compile'
                }

                configurations.compile.resolutionStrategy.dependencySubstitution {
                    substitute module('org.utils:api:1.3') using project(':api2')
                }
            }
"""

        when:
        run(":impl:dependencies")

        then:

                if (config.compositeBuild.usePredefinedPublications()) {
                    """

                    includeBuild("project$it") {
                        dependencySubstitution {
                            substitute(module("org.gradle.test.performance:project${it}")).using(project(":"))
                        }
                    }
                    """
                } else {

import org.gradle.api.internal.artifacts.configurations.ConflictResolution;
import org.gradle.api.internal.artifacts.dependencies.DefaultResolvedVersionConstraint;
import org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionApplicator;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.Version;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionComparator;

                doLast {
                    println("JAR = \${Foo.bar}")
                }
            }
        """)
        settingsFile("""
            includeBuild("mrjar") {
                dependencySubstitution {
                    substitute module('org.gradle.test:mrjar') using project(':')
                }
            }
        """)

        def java8Home = AvailableJavaHomes.getJdk8().javaHome

        given:
        buildFile << """
configurations {
    conf {
        exclude group: 'b', module: 'b'
        resolutionStrategy {
            dependencySubstitution {
                all {
                    if (it.requested instanceof ModuleComponentSelector) {
                        if (it.requested.group == 'c' && it.requested.module == 'c') {

        buildFile << """
            configurations { a }
            configurations.a.resolve()
            configurations.a.resolutionStrategy.dependencySubstitution.all {}
        """


        when: fails()
        then: failure.assertHasCause("Cannot change resolution strategy of dependency configuration ':a' after it has been resolved")
    }

        given:
        settingsFile << """
            rootProject.name = "root-changed"
            includeBuild('unused') {
                dependencySubstitution {
                    substitute(module("none:none:infinity")).using(project(":"))
                }
            }
        """
        file("unused/settings.gradle").createFile()

        when: