* under the License.
 */
package org.apache.maven.logging;

import org.apache.maven.execution.ExecutionEvent;
import org.eclipse.aether.transfer.TransferEvent;

/**
 * An abstract build event sink.
 */
public interface BuildEventListener {

    void sessionStarted(ExecutionEvent event);

    void projectStarted(String projectId);

    void projectLogMessage(String projectId, String event);

      private val timeout = Timeout()

      override fun close() {
        if (currentPart == this) {
          currentPart = null
        }
      }

      override fun read(
        sink: Buffer,
        byteCount: Long,
      ): Long {
        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
        check(currentPart == this) { "closed" }

      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("abc")
          sink.flush()
          makeFailingCall()
          sink.writeUtf8("def")
          sink.flush()
        }
      }
    val call =
      client.newCall(
        Request(
          url = server.url("/"),

import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import org.jspecify.annotations.NullUnmarked;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestByteSink extends ByteSink implements TestStreamSupplier {

import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSink extends CharSink implements TestStreamSupplier {

  private final TestByteSink byteSink;

    ) = error("unsupported")

    override fun take() = error("unsupported")

    override fun remainingCapacity() = error("unsupported")

    override fun drainTo(sink: MutableCollection<in T>) = error("unsupported")

    override fun drainTo(
      sink: MutableCollection<in T>,
      maxElements: Int,
    ) = error("unsupported")
  }

              override fun contentLength(): Long = postBytes.size.toLong()

              override fun writeTo(sink: BufferedSink) {
                sink.write(postBytes) // push bytes into the stream's buffer
                sink.flush() // Http2Connection.writeData subject to write window
                sink.close() // Http2Connection.writeData empty frame
              }
            },
        ),
      )

  private class CountingSource(
    source: Source,
  ) : ForwardingSource(source) {
    var bytesRead = 0L

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      val result = delegate.read(sink, byteCount)
      if (result == -1L) return -1L
      bytesRead += result
      return result
    }
  }

HSPLokio/AsyncTimeout$Watchdog;-><init>()V
HSPLokio/AsyncTimeout$Watchdog;->run()V
HSPLokio/AsyncTimeout$sink$1;-><init>(Lokio/AsyncTimeout;Lokio/Sink;)V
HSPLokio/AsyncTimeout$sink$1;->close()V
HSPLokio/AsyncTimeout$sink$1;->flush()V
HSPLokio/AsyncTimeout$sink$1;->write(Lokio/Buffer;J)V
HSPLokio/AsyncTimeout$source$1;-><init>(Lokio/AsyncTimeout;Lokio/Source;)V
HSPLokio/AsyncTimeout$source$1;->close()V

) : ResponseBody(),
  Source {
  override fun contentType() = mediaType

  override fun contentLength() = contentLength

  override fun source() = buffer()

  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long =
    throw IllegalStateException(
      """
      |Unreadable ResponseBody! These Response objects have bodies that are stripped:
      | * Response.cacheResponse