buildFile << """
                println "Configured buildC"
                apply plugin: 'java'
"""
        }
        includedBuilds << buildC

    }

    def "references but does not build substituted dependency resolved at configuration time"() {
        configurationTimeDependency 'org.test:buildB:1.0'

        when:
        execute buildA, ":resolve"

        then:
        executed ":resolve"

package types

import (
	"go/token"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.
func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
	assert(len(tpars) == len(targs))
	proj := make(substMap, len(tpars))
	for i, tpar := range tpars {
		proj[tpar] = targs[i]
	}
	return proj
}

     * configurations.main.resolutionStrategy.dependencySubstitution {
     *   // Substitute project and module dependencies
     *   substitute module('org.gradle:api') using project(':api')
     *   substitute project(':util') using module('org.gradle:util:3.0')
     *
     *   // Substitute one module dependency for another
     *   substitute module('org.gradle:api:2.0') using module('org.gradle:api:2.1')
     * }
     * </pre>

package types2

import (
	"cmd/compile/internal/syntax"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.
func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
	assert(len(tpars) == len(targs))
	proj := make(substMap, len(tpars))
	for i, tpar := range tpars {
		proj[tpar] = targs[i]
	}
	return proj
}

 */
public abstract class KaFunctionLikeSignature<out S : KaFunctionLikeSymbol> : KaCallableSignature<S>() {
    /**
     * The use-site-substituted value parameters.
     */
    public abstract val valueParameters: List<KaVariableLikeSignature<KaValueParameterSymbol>>

    abstract override fun substitute(substitutor: KaSubstitutor): KaFunctionLikeSignature<S>
}

                    }
                }
"""
        }
        includeBuild(buildB)
    }

    @ToBeFixedForConfigurationCache
    def "builds IDEA metadata with substituted dependency"() {
        given:
        dependency 'org.test:buildB:1.0'

        when:
        idea()

        then:

     *
     * E.g., if we have `A.foo` overrides `B.foo` overrides `C.foo`, all two super declarations `B.foo`, `C.foo` will be returned
     *
     * Unwraps substituted overridden symbols

            val superClassSymbol = superClass.getClassOrObjectSymbol()!!
            val substitutor = createInheritanceTypeSubstitutor(baseClass.getClassOrObjectSymbol()!!, superClassSymbol)
            prettyPrint {
                appendLine("Substitutor: ${stringRepresentation(substitutor)}")
                if (substitutor != null) {
                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()

/**
 * Provides support for replacing the interceptors for the current thread.
 * Make sure that the call sites that should be affected by the change are only reached after the interceptors have been substituted.
 *
 * The interceptors are substituted per-thread because other threads may be executing unrelated tests.
 */
abstract class TestInterceptorsSubstitution<T> {
    private final T substitution

    }
}
"""

        when:
        fails 'resolve'

        then:
        failureHasCause("Did not resolve 'org:test:1.1' which has been forced / substituted to a different version: '1.0'")
    }

    def "fails when a substitute overwrites a locked version"() {
        given:
        mavenRepo.module('org', 'test', '1.0').publish()
        mavenRepo.module('org', 'test', '1.1').publish()