def setup() {
        file = new RandomAccessFile(tmpDir.file("test.bin"), "rw")
        input = new ByteInput(file)
    }

    def cleanup() {
        file.close()
    }

    def "can reuse to read from multiple locations in file"() {
        given:
        file.seek(0)
        file.writeInt(123)
        file.writeInt(321)
        file.writeInt(456)

        expect:
        def stream = input.start(0)

		return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1))
	}
	return nil
}

func setDefaultListenerSockopts(s syscall.Handle) error {
	// Windows will reuse recently-used addresses by default.
	// SO_REUSEADDR should not be used here, as it allows
	// a socket to forcibly bind to a port in use by another socket.
	// This could lead to a non-deterministic behavior, where

public class JavaHomeBasedJavaCompilerFactory implements Factory<ContextAwareJavaCompiler>, Serializable {
    private final List<File> compilerPluginsClasspath;
    // We use a static cache here because we want to reuse classloaders in compiler workers as
    // it has a huge impact on performance. Previously there was a single, JdkTools.current()
    // instance, but we can have different "compiler plugins" classpath. For this reason we use

Status CompileGraph(GraphDef graph_def, const tf2xla::Config& config,
                    const MainFlags& flags, CompileResult* compile_result);

// The full compilation method, for reuse in a library setting.
Status Main(const MainFlags& flags);

}  // namespace tfcompile
}  // namespace tensorflow

  }

  override fun isOutputShutdown(): Boolean {
    return delegate!!.isOutputShutdown
  }

  @Throws(SocketException::class)
  override fun setReuseAddress(reuse: Boolean) {
    delegate!!.reuseAddress = reuse
  }

  @Throws(SocketException::class)
  override fun getReuseAddress(): Boolean {
    return delegate!!.reuseAddress
  }

  @Throws(SocketException::class)

		// for checking that terminal state
	}
	if terminal {
		return
	}

	reqs = v1resource.PodRequests(pod, v1resource.PodResourcesOptions{Reuse: reuseReqs})
	limits = v1resource.PodLimits(pod, v1resource.PodResourcesOptions{Reuse: reuseLimits})
	return

)

// TestMain defines the entrypoint for pilot tests using a standard Istio installation.
// If a test requires a custom install it should go into its own package, otherwise it should go
// here to reuse a single install across tests.
func TestMain(m *testing.M) {
	framework.
		NewSuite(m).
		Setup(istio.Setup(&i, nil)).
		Setup(deployment.SetupSingleNamespace(&apps, deployment.Config{})).

    @Rule final SFTPServer sftpServer = new SFTPServer(temporaryFolder)
    @Rule final BlockingHttpServer coordinator = new BlockingHttpServer()

    def "does not attempt to reuse a client that has been disconnected"() {
        coordinator.start()

        buildFile << """
            ${sftpTask}

            task firstUse(type: SftpTask) {
                credentials = creds
            }

     * Note that the state may not be immutable, so should be made isolated to reuse in another context. The state can also be fingerprinted to generate a fingerprint of this object.
     *

        def firstBuild = old(runningCompilerDaemons)
        def secondBuild = runningCompilerDaemons
        def diff = firstBuild - secondBuild
        // We should reuse one daemon from the first build
        diff.size() == 1
    }

    def "reuses compiler daemons across multiple builds when enabled"() {
        withSingleProjectSources()
        buildFile << """
            tasks.compileMain2Java {