dependency buildC, "org.test:b1:1.0"

        when:
        buildA.buildFile << """
task run {
    dependsOn gradle.includedBuild('buildC').task(':jar')
}
"""
        buildB.buildFile << """
            println 'Configured buildB'
"""

        then:
        execute(buildA, ":run", buildArgs)

        and:
        output.count('Configured buildB') == 1
    }

            """.stripIndent()
        }
        includedBuilds << buildB

        buildA.file('version.txt') << '3.3'
        buildB.file('version.txt') << '3.4'

        executer.withGradleUserHomeDir(file('gradle-user-home'))

        expect:
        execute(buildA, "doStringOp")
        execute(buildA, "doStringOp")
    }

    }
}
'''
        builder.resourceFile('META-INF/gradle-plugins/custom.properties') << '''
implementation-class=CustomPlugin
'''
        builder.buildJar(file('external.jar'))

        and:
        file('build.gradle') << '''
buildscript {
    dependencies {
        classpath files('external.jar')
    }
}
apply plugin: 'custom'
assert 'value' == prop

@TargetGradleVersion(">=3.1")
class AdHocCompositeDependencySubstitutionCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    TestFile buildA
    TestFile buildB

    def setup() {

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java'
                dependencies {

            println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """

        when:
        execute(buildA, ":assemble")

        then:
        outputContains("> Configure project :buildB:buildSrc")
        result.groupedOutput.task(":buildB:buildSrc:classes").output.contains("classes of :classes")

        where:

            """
        }
        includedBuilds << buildB

        def staleFiles = [
            file("buildA/build/classes/java/main/stale"),
            file("buildB/build/classes/java/main/stale")]
        staleFiles*.touch()

        when:
        execute(buildA, 'build')
        then:
        staleFiles*.assertDoesNotExist()
    }

    TestFile sourceFile(String path);

    TestFile resourceFile(String path);

    void manifestAttributes(Map<String, String> attributes);

    void preserveTimestamps(boolean preserveTimestamps);

    void buildJar(File jarFile);

		b.logger.AppendDebugf("built %d HTTP filters for ALLOW action", len(configs.http))
		filters = append(filters, configs.http...)
	}
	return filters
}

// BuildTCP returns the TCP filters built from the authorization policy.
func (b Builder) BuildTCP() []*listener.Filter {
	b.logger = &AuthzLogger{}
	defer b.logger.Report()
	if b.option.IsCustomBuilder {

}

var passAnalyzersToVet = map[string]bool{
	"appends":          true,
	"asmdecl":          true,
	"assign":           true,
	"atomic":           true,
	"bool":             true,
	"bools":            true,
	"buildtag":         true,
	"buildtags":        true,
	"cgocall":          true,
	"composites":       true,
	"copylocks":        true,
	"defers":           true,
	"directive":        true,
	"errorsas":         true,

		option := fuzz.Struct[Option](fg)
		b := New(bundle, push, policies, option)
		if b == nil {
			fg.T().Skip()
			return // To help linter
		}
		b.BuildTCP()
	})
}

func validatePush(in *model.PushContext) bool {
	if in == nil {
		return false
	}
	if in.AuthzPolicies == nil {
		return false
	}
	return true