private JvmInterceptorsSubstitution jvmInterceptorsSubstitution
    private GroovyInterceptorsSubstitution groovyInterceptorsSubstitution

    def setup() {
        // Substitutions should be set before the InstrumentedClasses is constructed
        jvmInterceptorsSubstitution = new JvmInterceptorsSubstitution(jvmBytecodeInterceptorSet())
        jvmInterceptorsSubstitution.setupForCurrentThread()

     * so it can be called on an instance of [subClass].
     *
     * Basically, it's a composition of inheritance-based substitutions for all the inheritance chain.
     *
     * On the following code:
     * ```
     * class A : B<String>
     * class B<T> : C<T, Int>
     * class C<X, Y>
     * ```
     *

        includedBuild.includedBuilds.empty
    }

    @Issue("https://github.com/gradle/gradle/issues/5167")
    @TargetGradleVersion(">=3.3")
    def "Included builds are present in the model when substitutions are used"() {
        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                rootProject.name = 'root'
                includeBuild('includedBuild') {

        // attaches root project
        buildLoader.load(gradle.getSettings(), gradle);

        // Makes included build substitutions available for this build
        coordinator.registerSubstitutionsAvailableFor(gradle.getOwner());

        // Build buildSrc and export classpath to root project

        }
    }

    public void registerSubstitutionsProvidedBy(BuildState build) {
        if (build instanceof RootBuildState && registerRootSubstitutions) {
            // Make root build substitutions available
            doRegisterSubstitutions((RootBuildState) build);
        }
    }

    public void prepareForPluginResolution(IncludedBuildState build) {
        if (!registering.add(build)) {

            val allSubstitutors = buildList {
                combinations.forEach { typesPermutation ->
                    add(buildSubstitutor { substitutions(typeParameters.zip(typesPermutation).toMap()) })
                }
            }

            allSubstitutors.forEach { substitutor ->
                testContractsOnDeclarationSymbol(symbol, substitutor, testServices)

            fileChanged("libs/build.gradle")
            projectConfigured(":plugins")
            projectsConfigured(":libs:a", ":libs:b") // TODO - should not be configured, but this currently happens to calculate the dependency substitutions
            modelsCreated(":libs")
            modelsReused(":", ":plugins", ":libs:a", ":libs:b")
        }
    }

				}
				pNum++
				partition = append(partition, f)
			}
			changed = true
		}

		if !changed {
			break
		}
	}

	sdom := f.Sdom()

	// Compute substitutions we would like to do. We substitute v for w
	// if v and w are in the same equivalence class and v dominates w.
	rewrite := f.Cache.allocValueSlice(f.NumValues())
	defer f.Cache.freeValueSlice(rewrite)

  while True:
    func_match = re.search(compiled_regex, module)
    if func_match is None:
      break

    try:
      value_list = ast.literal_eval(func_match.group(1))
      # Escapes template $-based substitutions for attributes containing $.
      # $$ is replaced with a single $.
      func_template = string.Template(
          func_match.group(2).replace('tfdtype$DT_', 'tfdtype$$DT_'))

	// (256) and thus requires fixLongPath to be correctly interpreted in I/O syscalls.
	veryLong := "l" + strings.Repeat("o", 500) + "ng"
	for _, test := range []struct{ in, want string }{
		// Test cases use word substitutions:
		//   * "long" is replaced with a very long pathname
		//   * "c:" or "C:" are replaced with the drive of the current directory (preserving case)
		//   * "cwd" is replaced with the current directory

		// Drive Absolute