STACKTRACE_MESSAGE,
            INFO_DEBUG,
            SCAN,
            GET_HELP
        )
    }

    void "dependency substitution rules are applied to dependency constraints"() {
        given:
        buildFile << """
            dependencies {
                conf 'org:bar:1.0'
                constraints {

     * ```
     * interface A<T> { fun x(): T }
     * interface B : A<Int> { }
     * ```
     *
     * The B will have a member B.foo(): Int, this member is generated inside interface B with substitution T -> Int,
     * such members are SUBSTITUTION_OVERRIDE
     */
    SUBSTITUTION_OVERRIDE,

    /**
     * Member symbol which was generated by compiler when using `by` interface delegation
     * e.g,

        b1Model.projectDependencies.isEmpty()
        b1Model.classpath.collect { it.file.name }.sort() == ['buildC-1.0.jar']
    }

    def "Closed project tasks are run in composite with substitution"() {
        setup:
        def projectsLoadedHandler = new IntermediateResultHandlerCollector<Void>()
        def buildFinishedHandler = new IntermediateResultHandlerCollector<List<EclipseProject>>()

      [(UnsignedIntTensor $r)]>;

// Performs a substitution of FloorDiv, pseudo code below:
//
//  return floor(div(x, y))
def : Pat<(TF_FloorDivOp AnyTensor:$l, AnyTensor:$r),
          (MHLO_FloorOp
           (CHLO_BroadcastDivOp $l, $r, (BinBroadcastDimensions $l, $r))),
          [(IEEEFloatTensor $l)]>;

// Performs a substitution of FloorDiv for integer tensors, which required

        classpath2.libs.size() == 2
        classpath2.lib("myartifact-1.2.3.jar")
        classpath2.lib("myartifactdep-1.0.jar")
    }

    @Test
    @ToBeFixedForConfigurationCache
    void "respects dependency substitution rules"() {
        // given:
        mavenRepo.module("gradle", "foo").publish()
        mavenRepo.module("gradle", "bar").publish()
        mavenRepo.module("gradle", "baz").publish()

        // when:

                        }
                    }
                }
                configurations.implementation.resolutionStrategy.dependencySubstitution.all {
                    // To trigger the substitution: include dependency substitution rule to include external dependencies in the execution graph calculation
                }

                tasks.resolveArtifacts.collection = configurations.implementation.incoming.artifactView {

                            substitute module('org:foo') because "SUBSTITUTION 1" using module('org:foo:3.0')
                            substitute module('org:foo') because "SUBSTITUTION 2" using module('org:bar:2.0')
                            all {
                                it.useTarget('org:bar:2.0', "SUBSTITUTION 3")
                            }
                        }

        if (preferProjectModules) {
            preferProjectModulesOption = 'preferProjectModules()'
        }
        if (!autoDependencySubstitution) { //only interpret depSubstitution in scenario without auto substitution (multi-project builds)
            depSubstitutionOption = depSubstitution;
        } else {
            winner = 'projectId("ModuleC")'
        }

        buildFile << """
            task check {

        if (target instanceof ModuleComponentSelector) {
            return ((ModuleComponentSelector) target).getModule();
        }
        throw new IllegalStateException("Substitution with artifacts for something else than a module is not supported");
    }


    public boolean isForced() {
        if (!ruleDescriptors.isEmpty()) {

import org.gradle.tooling.model.eclipse.EclipseProject
import org.gradle.tooling.model.idea.IdeaModuleDependency
import org.gradle.tooling.model.idea.IdeaProject

/**
 * Dependency substitution is performed for models in a composite build
 */
@TargetGradleVersion(">=3.1")
class PersistentCompositeDependencySubstitutionCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {