private:
  bool UseMultipleStreams() const { return stream_ != host_to_device_stream_; }

  // The main compute stream of the device, used to synchronize the transfer
  // streams if they are set.
  std::shared_ptr<se::Stream> stream_;
  // The stream to use for transferring data from host to device. Can be
  // idential to stream_, but must not be nullptr.

     */
    ExecHandleBuilder setDaemon(boolean daemon);

    /**
     * Sets a handler for the output streams of the process.
     */
    ExecHandleBuilder streamsHandler(StreamsHandler streamsHandler);

    /**
     * Sets the start-up timeout, when spawning a process. Not used when forking a process (the default).
     */

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.cache.internal.streams;

/**
 * An opaque (outside this package) pointer to a block in a file.
 */
public class BlockAddress {
    final int fileId;
    final long pos;
    final long length;

	// Close resets all streams and closes the connection.
	Close() error
	// CloseChan returns a channel that is closed when the underlying connection is closed.
	CloseChan() <-chan bool
	// SetIdleTimeout sets the amount of time the connection may remain idle before
	// it is automatically closed.
	SetIdleTimeout(timeout time.Duration)
	// RemoveStreams can be used to remove a set of streams from the Connection.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

/**
 * Interface for a supplier of streams that can report whether a stream was opened and whether that
 * stream was closed. Intended for use in a test where only a single stream should be opened and
 * possibly closed.
 *
 * @author Colin Decker
 */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

/**
 * Interface for a supplier of streams that can report whether a stream was opened and whether that
 * stream was closed. Intended for use in a test where only a single stream should be opened and
 * possibly closed.
 *
 * @author Colin Decker
 */

 * limitations under the License.
 */

package org.gradle.tooling.events.test;

import java.io.Serializable;

/**
 * Enumerates possible output streams for {@link TestOutputEvent}.
 *
 * @since 6.0
 */
public enum Destination implements Serializable {

    StdOut(0),
    StdErr(1);

    private final int code;

     Destination(int code) {

import org.jetbrains.kotlin.test.util.KtTestUtil
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import kotlin.io.path.absolutePathString
import kotlin.io.path.extension
import kotlin.streams.asSequence

internal fun testDataPath(path: String): Path {
    return Paths.get("analysis/analysis-api-standalone/analysis-api-standalone-native/testData/nativeSessionBuilder").resolve(path)
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.models

import org.gradle.cache.internal.streams.BlockAddress
import org.gradle.cache.internal.streams.ValueStore
import org.gradle.internal.cc.impl.CheckedFingerprint
import org.gradle.internal.cc.impl.ConfigurationCacheStateStore
import org.gradle.internal.cc.impl.StateType

#### Framed protocols

Framed protocols like http/2 don't lend themselves to blocking APIs. Each application-layer thread wants to do blocking I/O for a specific stream, but the streams are multiplexed on the socket. You can't just talk to the socket, you need to cooperate with the other application-layer threads that you're sharing it with.