diff --git a/README.md b/README.md
index d0bbcb89..9299317d 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 [![CodeCov](https://codecov.io/gh/bluenviron/gortsplib/branch/main/graph/badge.svg)](https://app.codecov.io/gh/bluenviron/gortsplib/branch/main)
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/bluenviron/gortsplib/v3)](https://pkg.go.dev/github.com/bluenviron/gortsplib/v3#pkg-index)
 
-RTSP 1.0 client and server library for the Go programming language, written for [rtsp-simple-server](https://github.com/aler9/rtsp-simple-server).
+RTSP 1.0 client and server library for the Go programming language, written for [MediaMTX](https://github.com/aler9/mediamtx).
 
 Go ≥ 1.18 is required.
 
diff --git a/server_play_test.go b/server_play_test.go
index 932e60c1..9ca240e2 100644
--- a/server_play_test.go
+++ b/server_play_test.go
@@ -3,7 +3,6 @@ package gortsplib
 import (
 	"bytes"
 	"crypto/tls"
-	"errors"
 	"net"
 	"strconv"
 	"strings"
@@ -63,7 +62,7 @@ func absoluteControlAttribute(md *psdp.MediaDescription) string {
 	return v
 }
 
-func doDescribe(conn *conn.Conn) (*sdp.SessionDescription, error) {
+func doDescribe(t *testing.T, conn *conn.Conn) *sdp.SessionDescription {
 	res, err := writeReqReadRes(conn, base.Request{
 		Method: base.Describe,
 		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
@@ -71,21 +70,65 @@ func doDescribe(conn *conn.Conn) (*sdp.SessionDescription, error) {
 			"CSeq": base.HeaderValue{"1"},
 		},
 	})
-	if err != nil {
-		return nil, err
-	}
-
-	if res.StatusCode != base.StatusOK {
-		return nil, errors.New("bad status code")
-	}
+	require.NoError(t, err)
+	require.Equal(t, base.StatusOK, res.StatusCode)
 
 	var desc sdp.SessionDescription
 	err = desc.Unmarshal(res.Body)
-	if err != nil {
-		return nil, err
-	}
+	require.NoError(t, err)
+	return &desc
+}
 
-	return &desc, err
+func doSetup(t *testing.T, conn *conn.Conn, u string, inTH *headers.Transport) (*base.Response, *headers.Transport) {
+	res, err := writeReqReadRes(conn, base.Request{
+		Method: base.Setup,
+		URL:    mustParseURL(u),
+		Header: base.Header{
+			"CSeq":      base.HeaderValue{"1"},
+			"Transport": inTH.Marshal(),
+		},
+	})
+	require.NoError(t, err)
+	require.Equal(t, base.StatusOK, res.StatusCode)
+
+	var th headers.Transport
+	err = th.Unmarshal(res.Header["Transport"])
+	require.NoError(t, err)
+
+	return res, &th
+}
+
+func doPlay(t *testing.T, conn *conn.Conn, u string, session string) {
+	res, err := writeReqReadRes(conn, base.Request{
+		Method: base.Play,
+		URL:    mustParseURL(u),
+		Header: base.Header{
+			"CSeq":    base.HeaderValue{"1"},
+			"Session": base.HeaderValue{session},
+		},
+	})
+	require.NoError(t, err)
+	require.Equal(t, base.StatusOK, res.StatusCode)
+}
+
+func doPause(t *testing.T, conn *conn.Conn, u string, session string) {
+	res, err := writeReqReadRes(conn, base.Request{
+		Method: base.Pause,
+		URL:    mustParseURL(u),
+		Header: base.Header{
+			"CSeq":    base.HeaderValue{"1"},
+			"Session": base.HeaderValue{session},
+		},
+	})
+	require.NoError(t, err)
+	require.Equal(t, base.StatusOK, res.StatusCode)
+}
+
+func readSession(t *testing.T, res *base.Response) string {
+	var sx headers.Session
+	err := sx.Unmarshal(res.Header["Session"])
+	require.NoError(t, err)
+	return sx.Session
 }
 
 func TestServerPlayPath(t *testing.T) {
@@ -188,8 +231,7 @@ func TestServerPlayPath(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			th := &headers.Transport{
 				Protocol: headers.TransportProtocolTCP,
@@ -204,32 +246,14 @@ func TestServerPlayPath(t *testing.T) {
 				InterleavedIDs: &[2]int{0, 1},
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL: mustParseURL(strings.ReplaceAll(ca.setupURL, "[control]", "/"+
-					relativeControlAttribute(desc.MediaDescriptions[1]))),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": th.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ := doSetup(t, conn,
+				strings.ReplaceAll(ca.setupURL, "[control]", "/"+
+					relativeControlAttribute(desc.MediaDescriptions[1])),
+				th)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL(ca.playURL),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, ca.playURL, session)
 		})
 	}
 }
@@ -288,8 +312,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			th := &headers.Transport{
 				Protocol: headers.TransportProtocolTCP,
@@ -318,9 +341,8 @@ func TestServerPlaySetupErrors(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, base.StatusOK, res.StatusCode)
 
-				var sx headers.Session
-				err = sx.Unmarshal(res.Header["Session"])
-				require.NoError(t, err)
+				session := readSession(t, res)
+
 				th.InterleavedIDs = &[2]int{2, 3}
 
 				res, err = writeReqReadRes(conn, base.Request{
@@ -329,7 +351,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
 					Header: base.Header{
 						"CSeq":      base.HeaderValue{"3"},
 						"Transport": th.Marshal(),
-						"Session":   base.HeaderValue{sx.Session},
+						"Session":   base.HeaderValue{session},
 					},
 				})
 				require.NoError(t, err)
@@ -339,9 +361,8 @@ func TestServerPlaySetupErrors(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, base.StatusOK, res.StatusCode)
 
-				var sx headers.Session
-				err = sx.Unmarshal(res.Header["Session"])
-				require.NoError(t, err)
+				session := readSession(t, res)
+
 				th.InterleavedIDs = &[2]int{2, 3}
 
 				res, err = writeReqReadRes(conn, base.Request{
@@ -350,7 +371,7 @@ func TestServerPlaySetupErrors(t *testing.T) {
 					Header: base.Header{
 						"CSeq":      base.HeaderValue{"4"},
 						"Transport": th.Marshal(),
-						"Session":   base.HeaderValue{sx.Session},
+						"Session":   base.HeaderValue{session},
 					},
 				})
 				require.NoError(t, err)
@@ -425,8 +446,7 @@ func TestServerPlaySetupErrorSameUDPPortsAndIP(t *testing.T) {
 			ClientPorts: &[2]int{35466, 35467},
 		}
 
-		desc, err := doDescribe(conn)
-		require.NoError(t, err)
+		desc := doDescribe(t, conn)
 
 		res, err := writeReqReadRes(conn, base.Request{
 			Method: base.Setup,
@@ -566,8 +586,7 @@ func TestServerPlay(t *testing.T) {
 
 			<-nconnOpened
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			inTH := &headers.Transport{
 				Mode: func() *headers.TransportMode {
@@ -595,20 +614,7 @@ func TestServerPlay(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{4, 5}
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
-
-			var th headers.Transport
-			err = th.Unmarshal(res.Header["Transport"])
-			require.NoError(t, err)
+			res, th := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
 			var l1 net.PacketConn
 			var l2 net.PacketConn
@@ -665,20 +671,9 @@ func TestServerPlay(t *testing.T) {
 
 			<-sessionOpened
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, "rtsp://"+listenIP+":8554/teststream", session)
 
 			// server -> client (direct)
 			switch transport {
@@ -765,7 +760,7 @@ func TestServerPlay(t *testing.T) {
 					URL:    mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
 					Header: base.Header{
 						"CSeq":    base.HeaderValue{"4"},
-						"Session": base.HeaderValue{sx.Session},
+						"Session": base.HeaderValue{session},
 					},
 				})
 				require.NoError(t, err)
@@ -777,7 +772,7 @@ func TestServerPlay(t *testing.T) {
 					URL:    mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
 					Header: base.Header{
 						"CSeq":    base.HeaderValue{"5"},
-						"Session": base.HeaderValue{sx.Session},
+						"Session": base.HeaderValue{session},
 					},
 				})
 				require.NoError(t, err)
@@ -789,7 +784,7 @@ func TestServerPlay(t *testing.T) {
 				URL:    mustParseURL("rtsp://" + listenIP + ":8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"6"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -867,8 +862,7 @@ func TestServerPlayDecodeErrors(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			inTH := &headers.Transport{
 				Mode: func() *headers.TransportMode {
@@ -889,20 +883,7 @@ func TestServerPlayDecodeErrors(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{0, 1}
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
-
-			var resTH headers.Transport
-			err = resTH.Unmarshal(res.Header["Transport"])
-			require.NoError(t, err)
+			res, resTH := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
 			var l1 net.PacketConn
 			var l2 net.PacketConn
@@ -917,20 +898,9 @@ func TestServerPlayDecodeErrors(t *testing.T) {
 				defer l2.Close()
 			}
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 			switch { //nolint:dupl
 			case ca.proto == "udp" && ca.name == "rtcp invalid":
@@ -1004,8 +974,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			inTH := &headers.Transport{
 				Mode: func() *headers.TransportMode {
@@ -1026,16 +995,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{0, 1}
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
 			var l1 net.PacketConn
 			var l2 net.PacketConn
@@ -1049,20 +1009,9 @@ func TestServerPlayRTCPReport(t *testing.T) {
 				defer l2.Close()
 			}
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 			for i := 0; i < 2; i++ {
 				stream.WritePacketRTP(stream.Medias()[0], &rtp.Packet{
@@ -1110,7 +1059,7 @@ func TestServerPlayRTCPReport(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"4"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -1226,45 +1175,26 @@ func TestServerPlayTCPResponseBeforeFrames(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
+
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 	_, err = conn.ReadInterleavedFrame()
 	require.NoError(t, err)
@@ -1306,56 +1236,27 @@ func TestServerPlayPlayPlay(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolUDP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				ClientPorts: &[2]int{30450, 30451},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolUDP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		ClientPorts: &[2]int{30450, 30451},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"4"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 }
 
 func TestServerPlayPlayPausePlay(t *testing.T) {
@@ -1424,67 +1325,28 @@ func TestServerPlayPlayPausePlay(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Pause,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
-
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
+	doPause(t, conn, "rtsp://localhost:8554/teststream", session)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 }
 
 func TestServerPlayPlayPausePause(t *testing.T) {
@@ -1549,73 +1411,30 @@ func TestServerPlayPlayPausePause(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
 
-	err = conn.WriteRequest(&base.Request{
-		Method: base.Pause,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"4"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
-	res, err = conn.ReadResponseIgnoreFrames()
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	doPause(t, conn, "rtsp://localhost:8554/teststream", session)
 
-	err = conn.WriteRequest(&base.Request{
-		Method: base.Pause,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"5"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-
-	res, err = conn.ReadResponseIgnoreFrames()
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	doPause(t, conn, "rtsp://localhost:8554/teststream", session)
 }
 
 func TestServerPlayTimeout(t *testing.T) {
@@ -1677,8 +1496,7 @@ func TestServerPlayTimeout(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			inTH := &headers.Transport{
 				Mode: func() *headers.TransportMode {
@@ -1700,31 +1518,11 @@ func TestServerPlayTimeout(t *testing.T) {
 				inTH.Protocol = headers.TransportProtocolUDP
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 			<-sessionClosed
 		})
@@ -1786,8 +1584,7 @@ func TestServerPlayWithoutTeardown(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
 			inTH := &headers.Transport{
 				Delivery: func() *headers.TransportDelivery {
@@ -1808,31 +1605,11 @@ func TestServerPlayWithoutTeardown(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{0, 1}
 			}
 
-			res, err := writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Play,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-				Header: base.Header{
-					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 			nconn.Close()
 
@@ -1886,8 +1663,7 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		desc, err := doDescribe(conn)
-		require.NoError(t, err)
+		desc := doDescribe(t, conn)
 
 		inTH := &headers.Transport{
 			Delivery: func() *headers.TransportDelivery {
@@ -1902,33 +1678,13 @@ func TestServerPlayUDPChangeConn(t *testing.T) {
 			ClientPorts: &[2]int{35466, 35467},
 		}
 
-		res, err := writeReqReadRes(conn, base.Request{
-			Method: base.Setup,
-			URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-			Header: base.Header{
-				"CSeq":      base.HeaderValue{"2"},
-				"Transport": inTH.Marshal(),
-			},
-		})
-		require.NoError(t, err)
-		require.Equal(t, base.StatusOK, res.StatusCode)
+		res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-		var sx headers.Session
-		err = sx.Unmarshal(res.Header["Session"])
-		require.NoError(t, err)
+		session := readSession(t, res)
 
-		res, err = writeReqReadRes(conn, base.Request{
-			Method: base.Play,
-			URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-			Header: base.Header{
-				"CSeq":    base.HeaderValue{"3"},
-				"Session": base.HeaderValue{sx.Session},
-			},
-		})
-		require.NoError(t, err)
-		require.Equal(t, base.StatusOK, res.StatusCode)
+		doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
-		sxID = sx.Session
+		sxID = session
 	}()
 
 	func() {
@@ -1990,8 +1746,7 @@ func TestServerPlayPartialMedias(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
 	inTH := &headers.Transport{
 		Delivery: func() *headers.TransportDelivery {
@@ -2006,31 +1761,11 @@ func TestServerPlayPartialMedias(t *testing.T) {
 		InterleavedIDs: &[2]int{4, 5},
 	}
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[1])),
-		Header: base.Header{
-			"CSeq":      base.HeaderValue{"2"},
-			"Transport": inTH.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	session := readSession(t, res)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 	f, err := conn.ReadInterleavedFrame()
 	require.NoError(t, err)
@@ -2045,8 +1780,7 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		desc, err := doDescribe(conn)
-		require.NoError(t, err)
+		desc := doDescribe(t, conn)
 
 		inTH := &headers.Transport{
 			Delivery: func() *headers.TransportDelivery {
@@ -2061,20 +1795,8 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
 			InterleavedIDs: &[2]int{0, 1},
 		}
 
-		res, err := writeReqReadRes(conn, base.Request{
-			Method: base.Setup,
-			URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-			Header: base.Header{
-				"CSeq":      base.HeaderValue{"2"},
-				"Transport": inTH.Marshal(),
-			},
-		})
-		require.NoError(t, err)
-		require.Equal(t, base.StatusOK, res.StatusCode)
+		res, th := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-		var th headers.Transport
-		err = th.Unmarshal(res.Header["Transport"])
-		require.NoError(t, err)
 		ssrcs := make([]*uint32, 2)
 		ssrcs[0] = th.SSRC
 
@@ -2091,9 +1813,7 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
 			InterleavedIDs: &[2]int{2, 3},
 		}
 
-		var sx headers.Session
-		err = sx.Unmarshal(res.Header["Session"])
-		require.NoError(t, err)
+		session := readSession(t, res)
 
 		res, err = writeReqReadRes(conn, base.Request{
 			Method: base.Setup,
@@ -2101,27 +1821,18 @@ func TestServerPlayAdditionalInfos(t *testing.T) {
 			Header: base.Header{
 				"CSeq":      base.HeaderValue{"3"},
 				"Transport": inTH.Marshal(),
-				"Session":   base.HeaderValue{sx.Session},
+				"Session":   base.HeaderValue{session},
 			},
 		})
 		require.NoError(t, err)
 		require.Equal(t, base.StatusOK, res.StatusCode)
 
-		th = headers.Transport{}
+		th = &headers.Transport{}
 		err = th.Unmarshal(res.Header["Transport"])
 		require.NoError(t, err)
 		ssrcs[1] = th.SSRC
 
-		res, err = writeReqReadRes(conn, base.Request{
-			Method: base.Play,
-			URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-			Header: base.Header{
-				"CSeq":    base.HeaderValue{"4"},
-				"Session": base.HeaderValue{sx.Session},
-			},
-		})
-		require.NoError(t, err)
-		require.Equal(t, base.StatusOK, res.StatusCode)
+		doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 		var ri headers.RTPInfo
 		err = ri.Unmarshal(res.Header["RTP-Info"])
diff --git a/server_record_test.go b/server_record_test.go
index 434bf94c..dbc78283 100644
--- a/server_record_test.go
+++ b/server_record_test.go
@@ -276,27 +276,16 @@ func TestServerRecordPath(t *testing.T) {
 				InterleavedIDs: &[2]int{0, 1},
 			}
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL(ca.setupURL),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": th.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ = doSetup(t, conn, ca.setupURL, th)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
 			res, err = writeReqReadRes(conn, base.Request{
 				Method: base.Record,
 				URL:    mustParseURL(ca.announceURL),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -351,31 +340,22 @@ func TestServerRecordErrorSetupMediaTwice(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, base.StatusOK, res.StatusCode)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModeRecord
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModeRecord
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
+
+	session := readSession(t, res)
 
 	res, err = writeReqReadRes(conn, base.Request{
 		Method: base.Setup,
@@ -394,7 +374,7 @@ func TestServerRecordErrorSetupMediaTwice(t *testing.T) {
 				}(),
 				InterleavedIDs: &[2]int{2, 3},
 			}.Marshal(),
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)
@@ -471,7 +451,7 @@ func TestServerRecordErrorRecordPartialMedias(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, base.StatusOK, res.StatusCode)
 
-	th := &headers.Transport{
+	inTH := &headers.Transport{
 		Protocol: headers.TransportProtocolTCP,
 		Delivery: func() *headers.TransportDelivery {
 			v := headers.TransportDeliveryUnicast
@@ -484,27 +464,16 @@ func TestServerRecordErrorRecordPartialMedias(t *testing.T) {
 		InterleavedIDs: &[2]int{0, 1},
 	}
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-		Header: base.Header{
-			"CSeq":      base.HeaderValue{"2"},
-			"Transport": th.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	session := readSession(t, res)
 
 	res, err = writeReqReadRes(conn, base.Request{
 		Method: base.Record,
 		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 		Header: base.Header{
 			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)
@@ -648,7 +617,7 @@ func TestServerRecord(t *testing.T) {
 
 			var l1s [2]net.PacketConn
 			var l2s [2]net.PacketConn
-			var sx headers.Session
+			var session string
 			var serverPorts [2]*[2]int
 
 			for i := 0; i < 2; i++ {
@@ -679,19 +648,9 @@ func TestServerRecord(t *testing.T) {
 					inTH.InterleavedIDs = &[2]int{2 + i*2, 3 + i*2}
 				}
 
-				res, err = writeReqReadRes(conn, base.Request{
-					Method: base.Setup,
-					URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[i].Control),
-					Header: base.Header{
-						"CSeq":      base.HeaderValue{"2"},
-						"Transport": inTH.Marshal(),
-					},
-				})
-				require.NoError(t, err)
-				require.Equal(t, base.StatusOK, res.StatusCode)
+				res, _ := doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[i].Control, inTH)
 
-				err = sx.Unmarshal(res.Header["Session"])
-				require.NoError(t, err)
+				session = readSession(t, res)
 
 				var th headers.Transport
 				err = th.Unmarshal(res.Header["Transport"])
@@ -707,7 +666,7 @@ func TestServerRecord(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -780,7 +739,7 @@ func TestServerRecord(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -861,20 +820,9 @@ func TestServerRecordErrorInvalidProtocol(t *testing.T) {
 		ClientPorts: &[2]int{35466, 35467},
 	}
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-		Header: base.Header{
-			"CSeq":      base.HeaderValue{"2"},
-			"Transport": inTH.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	session := readSession(t, res)
 
 	var th headers.Transport
 	err = th.Unmarshal(res.Header["Transport"])
@@ -885,7 +833,7 @@ func TestServerRecordErrorInvalidProtocol(t *testing.T) {
 		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 		Header: base.Header{
 			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)
@@ -957,31 +905,22 @@ func TestServerRecordRTCPReport(t *testing.T) {
 	require.NoError(t, err)
 	defer l2.Close()
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"2"},
-			"Transport": headers.Transport{
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModeRecord
-					return &v
-				}(),
-				Protocol:    headers.TransportProtocolUDP,
-				ClientPorts: &[2]int{34556, 34557},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModeRecord
+			return &v
+		}(),
+		Protocol:    headers.TransportProtocolUDP,
+		ClientPorts: &[2]int{34556, 34557},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
+
+	session := readSession(t, res)
 
 	var th headers.Transport
 	err = th.Unmarshal(res.Header["Transport"])
@@ -992,7 +931,7 @@ func TestServerRecordRTCPReport(t *testing.T) {
 		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 		Header: base.Header{
 			"CSeq":    base.HeaderValue{"3"},
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)
@@ -1143,20 +1082,9 @@ func TestServerRecordTimeout(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{0, 1}
 			}
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
 			var th headers.Transport
 			err = th.Unmarshal(res.Header["Transport"])
@@ -1167,7 +1095,7 @@ func TestServerRecordTimeout(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -1266,20 +1194,9 @@ func TestServerRecordWithoutTeardown(t *testing.T) {
 				inTH.InterleavedIDs = &[2]int{0, 1}
 			}
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
 			var th headers.Transport
 			err = th.Unmarshal(res.Header["Transport"])
@@ -1290,7 +1207,7 @@ func TestServerRecordWithoutTeardown(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
@@ -1373,33 +1290,22 @@ func TestServerRecordUDPChangeConn(t *testing.T) {
 			ClientPorts: &[2]int{35466, 35467},
 		}
 
-		res, err = writeReqReadRes(conn, base.Request{
-			Method: base.Setup,
-			URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-			Header: base.Header{
-				"CSeq":      base.HeaderValue{"2"},
-				"Transport": inTH.Marshal(),
-			},
-		})
-		require.NoError(t, err)
-		require.Equal(t, base.StatusOK, res.StatusCode)
+		res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-		var sx headers.Session
-		err = sx.Unmarshal(res.Header["Session"])
-		require.NoError(t, err)
+		session := readSession(t, res)
 
 		res, err = writeReqReadRes(conn, base.Request{
 			Method: base.Record,
 			URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 			Header: base.Header{
 				"CSeq":    base.HeaderValue{"3"},
-				"Session": base.HeaderValue{sx.Session},
+				"Session": base.HeaderValue{session},
 			},
 		})
 		require.NoError(t, err)
 		require.Equal(t, base.StatusOK, res.StatusCode)
 
-		sxID = sx.Session
+		sxID = session
 	}()
 
 	func() {
@@ -1550,20 +1456,9 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 				defer l2.Close()
 			}
 
-			res, err = writeReqReadRes(conn, base.Request{
-				Method: base.Setup,
-				URL:    mustParseURL("rtsp://localhost:8554/teststream/" + medias[0].Control),
-				Header: base.Header{
-					"CSeq":      base.HeaderValue{"2"},
-					"Transport": inTH.Marshal(),
-				},
-			})
-			require.NoError(t, err)
-			require.Equal(t, base.StatusOK, res.StatusCode)
+			res, _ = doSetup(t, conn, "rtsp://localhost:8554/teststream/"+medias[0].Control, inTH)
 
-			var sx headers.Session
-			err = sx.Unmarshal(res.Header["Session"])
-			require.NoError(t, err)
+			session := readSession(t, res)
 
 			var resTH headers.Transport
 			err = resTH.Unmarshal(res.Header["Transport"])
@@ -1574,7 +1469,7 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 				URL:    mustParseURL("rtsp://localhost:8554/teststream"),
 				Header: base.Header{
 					"CSeq":    base.HeaderValue{"3"},
-					"Session": base.HeaderValue{sx.Session},
+					"Session": base.HeaderValue{session},
 				},
 			})
 			require.NoError(t, err)
diff --git a/server_test.go b/server_test.go
index 60b3accb..82d9778d 100644
--- a/server_test.go
+++ b/server_test.go
@@ -358,42 +358,34 @@ func TestServerErrorMethodNotImplemented(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
-			var sx headers.Session
+			var session string
 
 			if ca == "inside session" {
-				res, err := writeReqReadRes(conn, base.Request{
-					Method: base.Setup,
-					URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-					Header: base.Header{
-						"CSeq": base.HeaderValue{"1"},
-						"Transport": headers.Transport{
-							Protocol: headers.TransportProtocolTCP,
-							Delivery: func() *headers.TransportDelivery {
-								v := headers.TransportDeliveryUnicast
-								return &v
-							}(),
-							Mode: func() *headers.TransportMode {
-								v := headers.TransportModePlay
-								return &v
-							}(),
-							InterleavedIDs: &[2]int{0, 1},
-						}.Marshal(),
-					},
-				})
-				require.NoError(t, err)
+				inTH := &headers.Transport{
+					Protocol: headers.TransportProtocolTCP,
+					Delivery: func() *headers.TransportDelivery {
+						v := headers.TransportDeliveryUnicast
+						return &v
+					}(),
+					Mode: func() *headers.TransportMode {
+						v := headers.TransportModePlay
+						return &v
+					}(),
+					InterleavedIDs: &[2]int{0, 1},
+				}
 
-				err = sx.Unmarshal(res.Header["Session"])
-				require.NoError(t, err)
+				res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
+
+				session = readSession(t, res)
 			}
 
 			headers := base.Header{
 				"CSeq": base.HeaderValue{"2"},
 			}
 			if ca == "inside session" {
-				headers["Session"] = base.HeaderValue{sx.Session}
+				headers["Session"] = base.HeaderValue{session}
 			}
 
 			res, err := writeReqReadRes(conn, base.Request{
@@ -408,7 +400,7 @@ func TestServerErrorMethodNotImplemented(t *testing.T) {
 				"CSeq": base.HeaderValue{"3"},
 			}
 			if ca == "inside session" {
-				headers["Session"] = base.HeaderValue{sx.Session}
+				headers["Session"] = base.HeaderValue{session}
 			}
 
 			res, err = writeReqReadRes(conn, base.Request{
@@ -461,53 +453,33 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
 	defer nconn1.Close()
 	conn1 := conn.NewConn(nconn1)
 
-	desc1, err := doDescribe(conn1)
-	require.NoError(t, err)
+	desc1 := doDescribe(t, conn1)
 
-	res, err := writeReqReadRes(conn1, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc1.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"1"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn1, absoluteControlAttribute(desc1.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn1, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
+
+	doPlay(t, conn1, "rtsp://localhost:8554/teststream", session)
 
 	nconn2, err := net.Dial("tcp", "localhost:8554")
 	require.NoError(t, err)
 	defer nconn2.Close()
 	conn2 := conn.NewConn(nconn2)
 
-	desc2, err := doDescribe(conn2)
-	require.NoError(t, err)
+	desc2 := doDescribe(t, conn2)
 
 	res, err = writeReqReadRes(conn2, base.Request{
 		Method: base.Setup,
@@ -526,7 +498,7 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
 				}(),
 				InterleavedIDs: &[2]int{0, 1},
 			}.Marshal(),
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)
@@ -572,45 +544,26 @@ func TestServerErrorTCPOneConnTwoSessions(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"1"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
-	res, err = writeReqReadRes(conn, base.Request{
-		Method: base.Play,
-		URL:    mustParseURL("rtsp://localhost:8554/teststream"),
-		Header: base.Header{
-			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	session := readSession(t, res)
+
+	doPlay(t, conn, "rtsp://localhost:8554/teststream", session)
 
 	res, err = writeReqReadRes(conn, base.Request{
 		Method: base.Setup,
@@ -664,8 +617,7 @@ func TestServerSetupMultipleTransports(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
 	inTHS := headers.Transports{
 		{
@@ -775,43 +727,34 @@ func TestServerGetSetParameter(t *testing.T) {
 			defer nconn.Close()
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
-			var sx headers.Session
+			var session string
 
 			if ca == "inside session" {
-				res, err := writeReqReadRes(conn, base.Request{
-					Method: base.Setup,
-					URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-					Header: base.Header{
-						"CSeq": base.HeaderValue{"2"},
-						"Transport": headers.Transport{
-							Protocol: headers.TransportProtocolTCP,
-							Delivery: func() *headers.TransportDelivery {
-								v := headers.TransportDeliveryUnicast
-								return &v
-							}(),
-							Mode: func() *headers.TransportMode {
-								v := headers.TransportModePlay
-								return &v
-							}(),
-							InterleavedIDs: &[2]int{0, 1},
-						}.Marshal(),
-					},
-				})
-				require.NoError(t, err)
-				require.Equal(t, base.StatusOK, res.StatusCode)
+				inTH := &headers.Transport{
+					Protocol: headers.TransportProtocolTCP,
+					Delivery: func() *headers.TransportDelivery {
+						v := headers.TransportDeliveryUnicast
+						return &v
+					}(),
+					Mode: func() *headers.TransportMode {
+						v := headers.TransportModePlay
+						return &v
+					}(),
+					InterleavedIDs: &[2]int{0, 1},
+				}
 
-				err = sx.Unmarshal(res.Header["Session"])
-				require.NoError(t, err)
+				res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
+
+				session = readSession(t, res)
 			}
 
 			headers := base.Header{
 				"CSeq": base.HeaderValue{"3"},
 			}
 			if ca == "inside session" {
-				headers["Session"] = base.HeaderValue{sx.Session}
+				headers["Session"] = base.HeaderValue{session}
 			}
 
 			res, err := writeReqReadRes(conn, base.Request{
@@ -827,7 +770,7 @@ func TestServerGetSetParameter(t *testing.T) {
 				"CSeq": base.HeaderValue{"4"},
 			}
 			if ca == "inside session" {
-				headers["Session"] = base.HeaderValue{sx.Session}
+				headers["Session"] = base.HeaderValue{session}
 			}
 
 			res, err = writeReqReadRes(conn, base.Request{
@@ -929,30 +872,22 @@ func TestServerSessionClose(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"1"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
+
+	doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
 
 	session.Close()
 	session.Close()
@@ -1010,30 +945,37 @@ func TestServerSessionAutoClose(t *testing.T) {
 			require.NoError(t, err)
 			conn := conn.NewConn(nconn)
 
-			desc, err := doDescribe(conn)
-			require.NoError(t, err)
+			desc := doDescribe(t, conn)
 
-			_, err = writeReqReadRes(conn, base.Request{
+			inTH := &headers.Transport{
+				Protocol: headers.TransportProtocolTCP,
+				Delivery: func() *headers.TransportDelivery {
+					v := headers.TransportDeliveryUnicast
+					return &v
+				}(),
+				Mode: func() *headers.TransportMode {
+					v := headers.TransportModePlay
+					return &v
+				}(),
+				InterleavedIDs: &[2]int{0, 1},
+			}
+
+			res, err := writeReqReadRes(conn, base.Request{
 				Method: base.Setup,
 				URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
 				Header: base.Header{
-					"CSeq": base.HeaderValue{"1"},
-					"Transport": headers.Transport{
-						Protocol: headers.TransportProtocolTCP,
-						Delivery: func() *headers.TransportDelivery {
-							v := headers.TransportDeliveryUnicast
-							return &v
-						}(),
-						Mode: func() *headers.TransportMode {
-							v := headers.TransportModePlay
-							return &v
-						}(),
-						InterleavedIDs: &[2]int{0, 1},
-					}.Marshal(),
+					"CSeq":      base.HeaderValue{"1"},
+					"Transport": inTH.Marshal(),
 				},
 			})
 			require.NoError(t, err)
 
+			if ca == "200" {
+				require.Equal(t, base.StatusOK, res.StatusCode)
+			} else {
+				require.Equal(t, base.StatusBadRequest, res.StatusCode)
+			}
+
 			nconn.Close()
 
 			<-sessionClosed
@@ -1070,41 +1012,31 @@ func TestServerSessionTeardown(t *testing.T) {
 	defer nconn.Close()
 	conn := conn.NewConn(nconn)
 
-	desc, err := doDescribe(conn)
-	require.NoError(t, err)
+	desc := doDescribe(t, conn)
 
-	res, err := writeReqReadRes(conn, base.Request{
-		Method: base.Setup,
-		URL:    mustParseURL(absoluteControlAttribute(desc.MediaDescriptions[0])),
-		Header: base.Header{
-			"CSeq": base.HeaderValue{"1"},
-			"Transport": headers.Transport{
-				Protocol: headers.TransportProtocolTCP,
-				Delivery: func() *headers.TransportDelivery {
-					v := headers.TransportDeliveryUnicast
-					return &v
-				}(),
-				Mode: func() *headers.TransportMode {
-					v := headers.TransportModePlay
-					return &v
-				}(),
-				InterleavedIDs: &[2]int{0, 1},
-			}.Marshal(),
-		},
-	})
-	require.NoError(t, err)
-	require.Equal(t, base.StatusOK, res.StatusCode)
+	inTH := &headers.Transport{
+		Protocol: headers.TransportProtocolTCP,
+		Delivery: func() *headers.TransportDelivery {
+			v := headers.TransportDeliveryUnicast
+			return &v
+		}(),
+		Mode: func() *headers.TransportMode {
+			v := headers.TransportModePlay
+			return &v
+		}(),
+		InterleavedIDs: &[2]int{0, 1},
+	}
 
-	var sx headers.Session
-	err = sx.Unmarshal(res.Header["Session"])
-	require.NoError(t, err)
+	res, _ := doSetup(t, conn, absoluteControlAttribute(desc.MediaDescriptions[0]), inTH)
+
+	session := readSession(t, res)
 
 	res, err = writeReqReadRes(conn, base.Request{
 		Method: base.Teardown,
 		URL:    mustParseURL("rtsp://localhost:8554/"),
 		Header: base.Header{
 			"CSeq":    base.HeaderValue{"2"},
-			"Session": base.HeaderValue{sx.Session},
+			"Session": base.HeaderValue{session},
 		},
 	})
 	require.NoError(t, err)