def "caches result from backing cache and reuses for other instances with the same cache id"() {
        given:
        def cache = cacheFactory.decorator(100, true).decorate("path/fileSnapshots.bin", "fileSnapshots", target, crossProcessCacheAccess, asyncCacheAccess)

        when:
        def result = cache.getIfPresent("key")

        then:
        result == "result"

        and:

class PluginTestPreconditions {
    static File locate(String shellCommand) {
        return [
            new File("/bin/$shellCommand"),
            new File("/usr/bin/$shellCommand"),
            new File("/usr/local/bin/$shellCommand"),
            new File("/opt/local/bin/$shellCommand")
        ].find { it.exists() }
    }

    static class BashAvailable implements TestPrecondition {
        @Override

        given:
        def jdkHome = temporaryFolder.createDir("jdk")
        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        // Make it look like a macOS installation
        def macOsJdkHomeBinDir = jdkHome.createDir("Contents/Home/bin")
        macOsJdkHomeBinDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        when:

# go env -w rejects relative CC values
[!GOOS:windows] go env -w CC=/usr/bin/clang
go env -w CC=clang
[!GOOS:windows] ! go env -w CC=./clang
[!GOOS:windows] ! go env -w CC=bin/clang
[!GOOS:windows] stderr 'go: CC entry is relative; must be absolute path'

[GOOS:windows] go env -w CC=$WORK\bin\clang
[GOOS:windows] ! go env -w CC=.\clang
[GOOS:windows] ! go env -w CC=bin\clang

			Servers: []*networking.Server{
				{
					Hosts: []string{host},
					Port:  &networking.Port{Name: portName, Number: portNumber, Protocol: portProtocol},
					Bind:  bind,
					Tls:   &networking.ServerTLSSettings{Mode: mode},
				},
			},
		},
	}
	return c
}

func BenchmarkParseGatewayRDSRouteName(b *testing.B) {
	for range b.N {

                                        "PATH+MAVEN=${ tool "$jdkName" }/bin:${tool "$mvnName"}/bin",
                                        "MAVEN_OPTS=-Xms2g -Xmx4g -Djava.awt.headless=true"]) {                                               
                                String cmd = "${runITscommand} -Dmaven.repo.local=$WORK_DIR/it-local-repo -DmavenDistro=$WORK_DIR/dists/apache-maven-bin.zip -Dmaven.test.failure.ignore"

# kubekins-test container with a kubernetes repo mapped in. See
# k8s.io/test-infra/scenarios/kubernetes_verify.py

export PATH=${GOPATH}/bin:${PWD}/third_party/etcd:/usr/local/go/bin:${PATH}

# Until all GOPATH references are removed from all build scripts as well,
# explicitly disable module mode to avoid picking up user-set GO111MODULE preferences.

	if gccgo == "" {
		gccgo = "gccgo"
	}
	bin, err := exec.LookPath(gccgo)
	if err != nil {
		return
	}

	allDirs, err := exec.Command(bin, "-print-search-dirs").Output()
	if err != nil {
		return
	}
	versionB, err := exec.Command(bin, "-dumpversion").Output()
	if err != nil {
		return
	}
	version := strings.TrimSpace(string(versionB))
	machineB, err := exec.Command(bin, "-dumpmachine").Output()
	if err != nil {

	}

	return passthroughBindIPAddresses
}

// getSidecarInboundBindIPs returns the IP that the proxy can bind to along with the sidecar specified port.
// It looks for an unicast address, if none found, then the default wildcard address is used.
// This will make the inbound listener bind to instance_ip:port instead of 0.0.0.0:port where applicable.
func getSidecarInboundBindIPs(node *model.Proxy) []string {

printf "%s download complete!\n" "${filename}"

# setup istioctl
mkdir -p "$HOME/.istioctl/bin"
mv "${tmp}/istioctl" "$HOME/.istioctl/bin/istioctl"
chmod +x "$HOME/.istioctl/bin/istioctl"
rm -r "${tmp}"

# Print message
printf "\n"
printf "Add the istioctl to your path with:"
printf "\n"
printf "  export PATH=\$HOME/.istioctl/bin:\$PATH \n"
printf "\n"
printf "Begin the Istio pre-installation check by running:\n"