// after consuming (and discarding) the end-of-sequence line.
func (r *Reader) DotReader() io.Reader {
	r.closeDot()
	r.dot = &dotReader{r: r}
	return r.dot
}

type dotReader struct {
	r     *Reader
	state int
}

// Read satisfies reads by decoding dot-encoded data read from d.r.
func (d *dotReader) Read(b []byte) (n int, err error) {
	// Run data through a simple state machine to

// translating line-ending \n into \r\n, and adding the final .\r\n line
// when the DotWriter is closed. The caller should close the
// DotWriter before the next call to a method on w.
//
// See the documentation for the [Reader.DotReader] method for details about dot-encoding.
func (w *Writer) DotWriter() io.WriteCloser {
	w.closeDot()
	w.dot = &dotWriter{w: w}
	return w.dot
}

func (w *Writer) closeDot() {
	if w.dot != nil {

		cycle:          atomic.NewInt32(0),
	}
	gotLeader := atomic.NewBool(false)
	l.AddRunFunction(func(stop <-chan struct{}) {
		gotLeader.Store(true)
	})
	stop := make(chan struct{})
	go l.Run(stop)
	t.Cleanup(func() {
		close(stop)
	})

	// Need to retry until Run() starts to execute in the goroutine.

		{"ServerInfo.Auth", Field, 0},
		{"ServerInfo.Name", Field, 0},
		{"ServerInfo.TLS", Field, 0},
	},
	"net/textproto": {
		{"(*Conn).Close", Method, 0},
		{"(*Conn).Cmd", Method, 0},
		{"(*Conn).DotReader", Method, 0},
		{"(*Conn).DotWriter", Method, 0},
		{"(*Conn).EndRequest", Method, 0},
		{"(*Conn).EndResponse", Method, 0},
		{"(*Conn).Next", Method, 0},
		{"(*Conn).PrintfLine", Method, 0},

		events = make([]Event, 0, n)
	}

	gotHeader := false
	var raw rawEvent
	var ev Event
	for {
		err := p.readRawEvent(0, &raw)
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		if raw.typ == EvNone || raw.typ == EvCPUSample {
			continue
		}
		if raw.typ == EvBatch {
			if gotHeader {
				break
			} else {
				gotHeader = true
			}

		if err == nil {
			if tt.err != "" {
				t.Errorf("#%d: got nil err; want %q", i, tt.err)
			}

			if !reflect.DeepEqual(tt.header, req.Header) {
				t.Errorf("#%d: gotHeader: %q wantHeader: %q", i, req.Header, tt.header)
			}
			continue
		}

		if tt.err == "" || !strings.Contains(err.Error(), tt.err) {
			t.Errorf("%d: got error = %v; want %v", i, err, tt.err)
		}
	}
}

pkg net/textproto, func NewWriter(*bufio.Writer) *Writer
pkg net/textproto, method (*Conn) Close() error
pkg net/textproto, method (*Conn) Cmd(string, ...interface{}) (uint, error)
pkg net/textproto, method (*Conn) DotReader() io.Reader
pkg net/textproto, method (*Conn) DotWriter() io.WriteCloser
pkg net/textproto, method (*Conn) EndRequest(uint)
pkg net/textproto, method (*Conn) EndResponse(uint)