assertEquals(STRING, sink.getString());
  }

  public void testWriteFromStream_doesNotCloseThatStream() throws IOException {
    TestReader in = new TestReader();
    assertFalse(in.closed());
    sink.writeFrom(in);
    assertFalse(in.closed());
  }

  public void testWriteLines_withSpecificSeparator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz"), "\n");

		}
	}
}

type closeChecker struct {
	io.Reader
	closed bool
}

func (rc *closeChecker) Close() error {
	rc.closed = true
	return nil
}

// TestRequestWriteClosesBody tests that Request.Write closes its request.Body.
// It also indirectly tests NewRequest and that it doesn't wrap an existing Closer
// inside a NopCloser, and that it serializes it correctly.

@SafeVarargs
internal fun <T> immutableListOf(vararg elements: T): List<T> {
  return Collections.unmodifiableList(listOf(*elements.clone()))
}

/** Closes this, ignoring any checked exceptions. */
internal fun Socket.closeQuietly() {
  try {
    close()
  } catch (e: AssertionError) {
    throw e
  } catch (rethrown: RuntimeException) {
    if (rethrown.message == "bio == null") {

	// that it won't add a terminal in the middle, but that would be pretty weird.)
	t.Run("pipe", func(t *testing.T) {
		r, w, err := os.Pipe()
		if err != nil {
			t.Fatalf("pipe failed: %s", err)
		}
		defer r.Close()
		defer w.Close()
		stdout, stderr := runTerminalPassthrough(t, r, w)
		if stdout {
			t.Errorf("stdout is unexpectedly a terminal")
		}
		if stderr {
			t.Errorf("stderr is unexpectedly a terminal")
		}
	})

// The value will not be sent if the context is closed or the receiver
// is freed.
func (s *Sender[Elem]) Send(ctx context.Context, v Elem) bool {
	select {
	case <-ctx.Done():
		return false
	case s.values <- v:
		return true
	case <-s.done:
		return false
	}
}

// Close tells the receiver that no more values will arrive.
// After Close is called, the Sender may no longer be used.

import (
	"testing"
)

func NewCloser(t *testing.T) *Closer {
	return &Closer{
		t: t,
	}
}

type Closer struct {
	wasCalled bool
	t         *testing.T
}

func (c *Closer) Close() error {
	c.wasCalled = true
	return nil
}

func (c *Closer) Check() *Closer {
	c.t.Helper()

	if !c.wasCalled {
		c.t.Error("expected closer to have been called")
	}

	return c

  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(

	for _, s := range conn.channels {
		s.Close()
	}
	var err error
	if conn.ws != nil {
		err = conn.ws.Close()
	}
	return err
}

// Close is only valid after Open has been called
func (conn *Conn) Close() error {
	<-conn.ready
	return conn.closeNonThreadSafe()
}

// protocolSupportsStreamClose returns true if the passed protocol
// supports the stream close signal (currently only V5 remotecommand);

 * Such as when an anonymous inner class or closure “closes over” the subject.
 */
@Incubating
public class ModelViewClosedException extends ReadOnlyModelViewException {
    public ModelViewClosedException(ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {
        super(createMessage("closed", path, type, ruleDescriptor));
    }

      )

    val part = parts.nextPart()!!
    parts.close()

    assertFailsWith<IllegalStateException> {
      part.body.request(10)
    }.also { expected ->
      assertThat(expected).hasMessage("closed")
    }
  }

  @Test fun `cannot call nextPart after calling close`() {
    val parts =
      MultipartReader(
        boundary = "simple boundary",