val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        withClassLoaderFor(binDir) {
            // when:
            buildAccessorsFromSourceFor(
                schema,
                testRuntimeClassPath,
                srcDir,
                binDir
            )

            val binaryAccessorsDir = File(binDir, "org/gradle/kotlin/dsl")

            // then:

        def binDir = file('fake-bin')

        then:
        def path
        if (OperatingSystem.current().windows) {
            path = ''
        } else {
            // Set up a fake bin directory, containing the things that the script needs, minus any java that might be in /usr/bin
            links.each { linkToBinary(it, binDir) }
            path = binDir.absolutePath
        }

        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.current().getExecutableName("java"))
        return jdkHome
    }

    private TestFile createJreInstallation(String version) {
        def jdkHome = temporaryFolder.createDir("jdk-$version")
        def jreHome = jdkHome.file("jre").createDir()
        def binDir = jreHome.createDir("bin")

    }

    def "can attach result dirs"() {
        def binDir = temporaryFolder.file("other")

        when:
        reportTask.testResults.from(binDir)

        then:
        reportTask.testResults.files as List == [binDir]
    }

    def test(String name) {
        def test = TestUtil.createTask(Test, project, name)

// for each version in the bundledVersions list.
func validateBundledVersions(bundledVersions SupportedVersions, binDir string) error {
	for _, v := range bundledVersions {
		for _, binaryName := range []string{"etcd", "etcdctl"} {
			fn := filepath.Join(binDir, fmt.Sprintf("%s-%s", binaryName, v))
			if _, err := os.Stat(fn); err != nil {

        def result = []

        when:
        finder.findScripts(result)

        then:
        1 * target1.findScripts(result)
        1 * target2.findScripts(result)
    }

        )

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        // when:
        withSynchronousIO {
            buildPluginDependencySpecAccessorsFor(
                pluginDescriptorsClassPath = classPathOf(pluginsJar),
                srcDir = srcDir,
                binDir = binDir
            )
        }

        // then:

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 * </p>
 * <strong>Note:</strong> This interface is part of work in progress and can be changed or removed without notice.
 */
public interface Builder {
    //

	}}},
}

// General setting to control behavior
type Option struct {
	IsCustomBuilder bool
	UseFilterState  bool
	UseExtendedJwt  bool
}

// Builder builds Istio authorization policy to Envoy filters.
type Builder struct {
	trustDomainBundle trustdomain.Bundle
	option            Option

	// populated when building for CUSTOM action.
	customPolicies []model.AuthorizationPolicy

// limitations under the License.

package headers

import (
	"net/http"
)

// Builder for HTTP headers.
type Builder struct {
	headers http.Header
}

// New Builder for HTTP headers.
func New() *Builder {
	return &Builder{
		headers: make(http.Header),
	}
}

// Get returns the current value for the key.
func (b *Builder) Get(key string) string {