}
		w.Close()
		return errMoreData
	}

	// Only interested in flushing the size_t not mtime/atime
	if err = Fdatasync(w); err != nil {
		w.Close()
		return err
	}

	// Dealing with error returns from close() - 'man 2 close'
	//
	// A careful programmer will check the return value of close(), since it is quite possible that

	if savePointer, ok := db.Dialector.(SavePointerDialectorInterface); ok {
		// close prepared statement, because SavePoint not support prepared statement.
		// e.g. mysql8.0 doc: https://dev.mysql.com/doc/refman/8.0/en/sql-prepared-statements.html
		var (
			preparedStmtTx   *PreparedStmtTX
			isPreparedStmtTx bool
		)
		// close prepared statement, because SavePoint not support prepared statement.

   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.
   * - The coalesced connection is violently closed after servicing the first request.
   * - The second request discovers the coalesced connection is unhealthy just after acquiring it.
   */
  @Test

  public open fun enqueue(response: MockResponse) {
    responseQueue.add(response)
  }

  public open fun clear() {
    responseQueue.clear()
  }

  public override fun close() {
    responseQueue.add(DEAD_LETTER)
  }

  public open fun setFailFast(failFast: Boolean) {
    setFailFast(
      failFastResponse =
        when {

    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {
      list.clear();
    }
  }

  /** Returns a snapshot of the logged records. */
  /*

// When the returned WriteCloser is closed, it will wait for all data to be read before returning.
func (r *RingBuffer) WriteCloser() io.WriteCloser {
	return &writeCloser{RingBuffer: r}
}

type writeCloser struct {
	*RingBuffer
}

// Close provides a close method for the WriteCloser.
func (wc *writeCloser) Close() error {
	wc.CloseWriter()
	return wc.Flush()

          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val clone = call.clone() // Not cloneWithListener.

    val response = clone.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()
    assertThat(eventRecorder.recordedEventTypes()).isEmpty()
  }

        return lookup;
    }

    @Override
    public Optional<ClassLoader> currentThreadClassLoader() {
        return Optional.of(plexusContainer.getContainerRealm());
    }

    @Override
    public void close() {
        try {
            plexusContainer.dispose();
        } finally {
            Thread.currentThread().setContextClassLoader(previousClassLoader);
        }
    }

     */
    protected EventType convert(ExecutionEvent.Type type) {
        return EventType.values()[type.ordinal()];
    }

    @Override
    public void close() throws Exception {}

     */
    protected abstract void doReceiveFragment(byte[] buf, boolean isDirect) throws IOException;

    /**
     * Closes this DCERPC handle and releases resources
     * @throws IOException if an I/O error occurs during close
     */
    public abstract void close() throws IOException;