// If the request context is canceled, the stream will no longer process requests.
	// Requests sent cannot be used any further by the called.
	Requests chan<- []byte

	muxID uint64
	ctx   context.Context
}

// Send a payload to the remote server.
func (s *Stream) Send(b []byte) error {
	if s.Requests == nil {
		return errors.New("stream does not accept requests")
	}
	select {

            stream.received(bytes)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested }
    }

    def "read byte returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)

        when:
        async {
            start {
                def b1 = stream.read()

//  done_event->Init();
//
//  XlaHostSendDeviceContext device_context(&stream, &gpu_dst,
//    shape, done_event);
//  device_context.CopyCPUTensorToDeviceSync(
//    &cpu_tensor, &device, &device_tensor);

class XlaHostSendDeviceContext : public DeviceContext {
 public:
  XlaHostSendDeviceContext(
      se::Stream* stream, se::DeviceMemoryBase* device_memory_base,

//
//  Device device;
//  stream_executor::Stream stream(executor);
//  Tensor device_tensor(device_allocator, DT_FLOAT, TensorShape({2, 2}));
//  se::DeviceMemoryBase gpu_dst{device_tensor.data(), 4 * sizeof(float)};
//  xla::Shape shape(xla::F32, {2, 2}, {}, {})
//  tsl::AsyncValueRef<std::unique_ptr<se::Event>> done_event =
//      tsl::MakeConstructedAsyncValueRef<std::unique_ptr<se::Event>>(stream.parent());
//  done_event->Init();

     */
    @Nonnull
    String asString();

    /**
     * Obtain a Stream containing this node and all its descendant.
     *
     * @return a stream containing this node and its descendant
     */
    @Nonnull
    default Stream<Node> stream() {
        return Stream.concat(Stream.of(this), getChildren().stream().flatMap(Node::stream));
    }

 */
package org.apache.maven.api.services;

import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.apache.maven.api.Lifecycle;

public interface LifecycleRegistry extends ExtensibleEnumRegistry<Lifecycle>, Iterable<Lifecycle> {

    default Stream<Lifecycle> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

      new XlaHostSendDeviceContext(stream.get(), &gpu_dst, shape, done_event);
  TF_ASSERT_OK(device_context->CopyCPUTensorToDeviceSync(
      &origin_cpu_tensor, device_.get(), &device_tensor));

  // Copy the GPU tensor back to CPU to check that copy worked.
  TF_ASSERT_OK(stream->Memcpy(dest_cpu_tensor.data(), gpu_dst, gpu_dst.size()));
  TF_ASSERT_OK(stream->BlockHostUntilDone());

        boolean hasCallerClassName = hasCallerClassName(request.getInterceptedCallable());
        Stream<CodeBlock> maybeZeroForKotlinDefault = hasKotlinDefaultMask ? Stream.of(CodeBlock.of("0")) : Stream.empty();
        Stream<CodeBlock> maybeCallerClassName = hasCallerClassName ? Stream.of(CodeBlock.of("consumer")) : Stream.empty();

  /**
   * A collector that converts a stream of zero or one elements to an {@code Optional}.
   *
   * @throws IllegalArgumentException if the stream consists of two or more elements.
   * @throws NullPointerException if any element in the stream is {@code null}.
   * @return {@code Optional.of(onlyElement)} if the stream has exactly one element (must not be

import com.google.common.collect.EvictingQueue;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Extracted utility methods to parse daemon logs.
 */
final class DaemonLogFileUtils {
    private DaemonLogFileUtils() {}

    /**