* 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)
}

  /**
   * Returns a view of the given {@code path} as a {@link ByteSource}.
   *
   * <p>Any {@linkplain OpenOption open options} provided are used when opening streams to the file
   * and may affect the behavior of the returned source and the streams it provides. See {@link
   * StandardOpenOption} for the standard options that may be provided. Providing no options is

 * 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.

  %r = "tf.AddV2"(%w, %v) : (tensor<i32>, tensor<i32>) -> tensor<i32>
  func.return %r : tensor<i32>
}

// -----

// Test inputs to the child streams are merged to the parent streams

// CHECK-LABEL: func private @main_stream_1
// CHECK-SAME: ([[INPUT0:%.*]]: tensor<i32>, [[INPUT1:%.*]]: tensor<i32>
// CHECK: tf.Sub
// CHECK: tf.Sub
// CHECK: mlrt.async({{%.*}}, [[INPUT1]]