add fuzz tests to all headers (#522)

pkg/headers/range_test.go

@@ -131,136 +131,6 @@ func TestRangeUnmarshal(t *testing.T) {
 	}
 }
 
-func TestRangeUnmarshalErrors(t *testing.T) {
-	for _, ca := range []struct {
-		name string
-		hv   base.HeaderValue
-		err  string
-	}{
-		{
-			"empty",
-			base.HeaderValue{},
-			"value not provided",
-		},
-		{
-			"2 values",
-			base.HeaderValue{"a", "b"},
-			"value provided multiple times ([a b])",
-		},
-		{
-			"invalid keys",
-			base.HeaderValue{`key1="k`},
-			"apexes not closed (key1=\"k)",
-		},
-		{
-			"value not found",
-			base.HeaderValue{``},
-			"value not found ()",
-		},
-		{
-			"smpte without values",
-			base.HeaderValue{`smpte=`},
-			"invalid value ()",
-		},
-		{
-			"smtpe end invalid",
-			base.HeaderValue{`smpte=00:00:01-123`},
-			"invalid SMPTE time (123)",
-		},
-		{
-			"smpte invalid 1",
-			base.HeaderValue{`smpte=123-`},
-			"invalid SMPTE time (123)",
-		},
-		{
-			"smpte invalid 2",
-			base.HeaderValue{`smpte=aa:00:00-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"smpte invalid 3",
-			base.HeaderValue{`smpte=00:aa:00-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"smpte invalid 4",
-			base.HeaderValue{`smpte=00:00:aa-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"smpte invalid 5",
-			base.HeaderValue{`smpte=00:00:00:aa-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"smpte invalid 6",
-			base.HeaderValue{`smpte=00:00:00:aa.00-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"smpte invalid 7",
-			base.HeaderValue{`smpte=00:00:00:00.aa-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"npt without values",
-			base.HeaderValue{`npt=`},
-			"invalid value ()",
-		},
-		{
-			"npt end invalid",
-			base.HeaderValue{`npt=00:00:00-aa`},
-			"strconv.ParseFloat: parsing \"aa\": invalid syntax",
-		},
-		{
-			"npt invalid 1",
-			base.HeaderValue{`npt=00:00:00:00-`},
-			"invalid NPT time (00:00:00:00)",
-		},
-		{
-			"npt invalid 2",
-			base.HeaderValue{`npt=aa-`},
-			"strconv.ParseFloat: parsing \"aa\": invalid syntax",
-		},
-		{
-			"npt invalid 3",
-			base.HeaderValue{`npt=aa:00-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"npt invalid 4",
-			base.HeaderValue{`npt=aa:00:00-`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"clock without values",
-			base.HeaderValue{`clock=`},
-			"invalid value ()",
-		},
-		{
-			"clock end invalid",
-			base.HeaderValue{`clock=20060102T150405Z-aa`},
-			"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
-		},
-		{
-			"clock invalid 1",
-			base.HeaderValue{`clock=aa-`},
-			"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
-		},
-		{
-			"time invalid",
-			base.HeaderValue{`time=aa`},
-			"parsing time \"aa\" as \"20060102T150405Z\": cannot parse \"aa\" as \"2006\"",
-		},
-	} {
-		t.Run(ca.name, func(t *testing.T) {
-			var h Range
-			err := h.Unmarshal(ca.hv)
-			require.EqualError(t, err, ca.err)
-		})
-	}
-}
-
 func TestRangeMarshal(t *testing.T) {
 	for _, ca := range casesRange {
 		t.Run(ca.name, func(t *testing.T) {
@@ -269,3 +139,32 @@ func TestRangeMarshal(t *testing.T) {
 		})
 	}
 }
+
+func FuzzRangeUnmarshal(f *testing.F) {
+	for _, ca := range casesRange {
+		f.Add(ca.vin[0])
+	}
+
+	f.Add("smtpe=")
+	f.Add("npt=")
+	f.Add("clock=")
+
+	f.Fuzz(func(t *testing.T, b string) {
+		var h Range
+		h.Unmarshal(base.HeaderValue{b}) //nolint:errcheck
+	})
+}
+
+func TestRangeAdditionalErrors(t *testing.T) {
+	func() {
+		var h Range
+		err := h.Unmarshal(base.HeaderValue{})
+		require.Error(t, err)
+	}()
+
+	func() {
+		var h Range
+		err := h.Unmarshal(base.HeaderValue{"a", "b"})
+		require.Error(t, err)
+	}()
+}

pkg/headers/rtpinfo.go

@@ -39,10 +39,13 @@ func (h *RTPInfo) Unmarshal(v base.HeaderValue) error {
 			return err
 		}
 
+		urlReceived := false
+
 		for k, v := range kvs {
 			switch k {
 			case "url":
 				e.URL = v
+				urlReceived = true
 
 			case "seq":
 				vi, err := strconv.ParseUint(v, 10, 16)
@@ -65,7 +68,7 @@ func (h *RTPInfo) Unmarshal(v base.HeaderValue) error {
 			}
 		}
 
-		if e.URL == "" {
+		if !urlReceived {
 			return fmt.Errorf("URL is missing")
 		}
 

pkg/headers/rtpinfo_test.go

@@ -142,51 +142,6 @@ func TestRTPInfoUnmarshal(t *testing.T) {
 	}
 }
 
-func TestRTPInfoUnmarshalErrors(t *testing.T) {
-	for _, ca := range []struct {
-		name string
-		hv   base.HeaderValue
-		err  string
-	}{
-		{
-			"empty",
-			base.HeaderValue{},
-			"value not provided",
-		},
-		{
-			"2 values",
-			base.HeaderValue{"a", "b"},
-			"value provided multiple times ([a b])",
-		},
-		{
-			"invalid key-value",
-			base.HeaderValue{"test=\"a"},
-			"apexes not closed (test=\"a)",
-		},
-		{
-			"invalid sequence",
-			base.HeaderValue{`url=rtsp://127.0.0.1/test.mkv/track1;seq=aa;rtptime=717574556`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"invalid rtptime",
-			base.HeaderValue{`url=rtsp://127.0.0.1/test.mkv/track1;seq=35243;rtptime=aa`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"missing URL",
-			base.HeaderValue{`seq=35243;rtptime=717574556`},
-			"URL is missing",
-		},
-	} {
-		t.Run(ca.name, func(t *testing.T) {
-			var h RTPInfo
-			err := h.Unmarshal(ca.hv)
-			require.EqualError(t, err, ca.err)
-		})
-	}
-}
-
 func TestRTPInfoMarshal(t *testing.T) {
 	for _, ca := range casesRTPInfo {
 		t.Run(ca.name, func(t *testing.T) {
@@ -195,3 +150,28 @@ func TestRTPInfoMarshal(t *testing.T) {
 		})
 	}
 }
+
+func FuzzRTPInfoUnmarshal(f *testing.F) {
+	for _, ca := range casesRTPInfo {
+		f.Add(ca.vin[0])
+	}
+
+	f.Fuzz(func(t *testing.T, b string) {
+		var h RTPInfo
+		h.Unmarshal(base.HeaderValue{b}) //nolint:errcheck
+	})
+}
+
+func TestRTPInfoAdditionalErrors(t *testing.T) {
+	func() {
+		var h RTPInfo
+		err := h.Unmarshal(base.HeaderValue{})
+		require.Error(t, err)
+	}()
+
+	func() {
+		var h RTPInfo
+		err := h.Unmarshal(base.HeaderValue{"a", "b"})
+		require.Error(t, err)
+	}()
+}

pkg/headers/session_test.go

@@ -53,41 +53,6 @@ func TestSessionUnmarshal(t *testing.T) {
 	}
 }
 
-func TestSessionUnmarshalErrors(t *testing.T) {
-	for _, ca := range []struct {
-		name string
-		hv   base.HeaderValue
-		err  string
-	}{
-		{
-			"empty",
-			base.HeaderValue{},
-			"value not provided",
-		},
-		{
-			"2 values",
-			base.HeaderValue{"a", "b"},
-			"value provided multiple times ([a b])",
-		},
-		{
-			"invalid key-value",
-			base.HeaderValue{"A3eqwsafq3rFASqew;test=\"a"},
-			"apexes not closed (test=\"a)",
-		},
-		{
-			"invalid timeout",
-			base.HeaderValue{`A3eqwsafq3rFASqew;timeout=aaa`},
-			"strconv.ParseUint: parsing \"aaa\": invalid syntax",
-		},
-	} {
-		t.Run(ca.name, func(t *testing.T) {
-			var h Session
-			err := h.Unmarshal(ca.hv)
-			require.EqualError(t, err, ca.err)
-		})
-	}
-}
-
 func TestSessionMarshal(t *testing.T) {
 	for _, ca := range casesSession {
 		t.Run(ca.name, func(t *testing.T) {
@@ -96,3 +61,30 @@ func TestSessionMarshal(t *testing.T) {
 		})
 	}
 }
+
+func FuzzSessionUnmarshal(f *testing.F) {
+	for _, ca := range casesSession {
+		f.Add(ca.vin[0])
+	}
+
+	f.Add("timeout=")
+
+	f.Fuzz(func(t *testing.T, b string) {
+		var h Session
+		h.Unmarshal(base.HeaderValue{b}) //nolint:errcheck
+	})
+}
+
+func TestSessionAdditionalErrors(t *testing.T) {
+	func() {
+		var h Session
+		err := h.Unmarshal(base.HeaderValue{})
+		require.Error(t, err)
+	}()
+
+	func() {
+		var h Session
+		err := h.Unmarshal(base.HeaderValue{"a", "b"})
+		require.Error(t, err)
+	}()
+}

pkg/headers/testdata/fuzz/FuzzRTPInfoUnmarshal/15422aae47040b82

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("=\"")

pkg/headers/testdata/fuzz/FuzzRTPInfoUnmarshal/4230da86ed7bbb89

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("seq")

pkg/headers/testdata/fuzz/FuzzRTPInfoUnmarshal/771e938e4458e983

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("0")

pkg/headers/testdata/fuzz/FuzzRTPInfoUnmarshal/fde7322eb8d3199e

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("rtptime")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/004943ecb339bfe3

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("clock=-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/058576b517a900ab

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0::-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/094e8699a2b0498e

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0:0:0-0:0:0:0.")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/0be015f3a8e9d205

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/15422aae47040b82

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("=\"")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/279c27b15659ed37

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("npt=0-A")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/377ba66160e60e9d

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0:0:0:-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/48015f85af9b7d4c

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("npt=-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/4b087c92430c42c2

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("npt=::-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/4e251d9d33f8ea08

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0:0:A-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/5b813a5623dcc9a2

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("npt=:::-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/631898e223f2e221

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("clock=00000101T000000Z-0")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/76d86663b6246d0d

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0:0:0-0")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/8aaf8b24c6ebaaaf

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("npt=:-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/b66fc0a00769691e

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=::-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/c974b74859131d56

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=0:0:0-0:0:0:.0")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/dd46188692c3868a

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("smpte=-")

pkg/headers/testdata/fuzz/FuzzRangeUnmarshal/f9816bb07c5c49ca

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("time")

pkg/headers/testdata/fuzz/FuzzSessionUnmarshal/c06a455eda3af1e0

@@ -0,0 +1,2 @@
+go test fuzz v1
+string(";=\"")

pkg/headers/testdata/fuzz/FuzzSessionUnmarshal/c143b4412cbdbe78

@@ -0,0 +1,2 @@
+go test fuzz v1
+string(";timeout")

pkg/headers/testdata/fuzz/FuzzTransportsUnmarshal/15422aae47040b82

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("=\"")

pkg/headers/testdata/fuzz/FuzzTransportsUnmarshal/771e938e4458e983

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("0")

pkg/headers/testdata/fuzz/FuzzTransportsUnmarshal/f5028a7b96853c01

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("source=0:0:0::0%0")

pkg/headers/transport_test.go

@@ -181,91 +181,6 @@ func TestTransportUnmarshal(t *testing.T) {
 	}
 }
 
-func TestTransportUnmarshalErrors(t *testing.T) {
-	for _, ca := range []struct {
-		name string
-		hv   base.HeaderValue
-		err  string
-	}{
-		{
-			"empty",
-			base.HeaderValue{},
-			"value not provided",
-		},
-		{
-			"2 values",
-			base.HeaderValue{"a", "b"},
-			"value provided multiple times ([a b])",
-		},
-		{
-			"invalid keys",
-			base.HeaderValue{`key1="k`},
-			"apexes not closed (key1=\"k)",
-		},
-		{
-			"protocol not found",
-			base.HeaderValue{`invalid;unicast;client_port=14186-14187`},
-			"protocol not found (invalid;unicast;client_port=14186-14187)",
-		},
-		{
-			"invalid interleaved port",
-			base.HeaderValue{`RTP/AVP;unicast;interleaved=aa-14187`},
-			"invalid ports (aa-14187)",
-		},
-		{
-			"invalid ttl",
-			base.HeaderValue{`RTP/AVP;unicast;ttl=aa`},
-			"strconv.ParseUint: parsing \"aa\": invalid syntax",
-		},
-		{
-			"invalid destination",
-			base.HeaderValue{`RTP/AVP;unicast;destination=aa`},
-			"invalid destination (aa)",
-		},
-		{
-			"invalid ports 1",
-			base.HeaderValue{`RTP/AVP;unicast;port=aa`},
-			"invalid ports (aa)",
-		},
-		{
-			"invalid ports 2",
-			base.HeaderValue{`RTP/AVP;unicast;port=aa-bb-cc`},
-			"invalid ports (aa-bb-cc)",
-		},
-		{
-			"invalid ports 3",
-			base.HeaderValue{`RTP/AVP;unicast;port=aa-14187`},
-			"invalid ports (aa-14187)",
-		},
-		{
-			"invalid ports 4",
-			base.HeaderValue{`RTP/AVP;unicast;port=14186-aa`},
-			"invalid ports (14186-aa)",
-		},
-		{
-			"invalid client port",
-			base.HeaderValue{`RTP/AVP;unicast;client_port=aa-14187`},
-			"invalid ports (aa-14187)",
-		},
-		{
-			"invalid server port",
-			base.HeaderValue{`RTP/AVP;unicast;server_port=aa-14187`},
-			"invalid ports (aa-14187)",
-		},
-		{
-			"invalid mode",
-			base.HeaderValue{`RTP/AVP;unicast;mode=aa`},
-			"invalid transport mode: 'aa'",
-		},
-	} {
-		t.Run(ca.name, func(t *testing.T) {
-			var h Transport
-			err := h.Unmarshal(ca.hv)
-			require.EqualError(t, err, ca.err)
-		})
-	}
-}
-
 func TestTransportMarshal(t *testing.T) {
 	for _, ca := range casesTransport {
 		t.Run(ca.name, func(t *testing.T) {
@@ -312,36 +227,6 @@ func TestTransportsUnmarshal(t *testing.T) {
 	}
 }
 
-func TestTransportsUnmarshalErrors(t *testing.T) {
-	for _, ca := range []struct {
-		name string
-		hv   base.HeaderValue
-		err  string
-	}{
-		{
-			"empty",
-			base.HeaderValue{},
-			"value not provided",
-		},
-		{
-			"2 values",
-			base.HeaderValue{"a", "b"},
-			"value provided multiple times ([a b])",
-		},
-		{
-			"invalid",
-			base.HeaderValue{"aasd"},
-			"protocol not found (aasd)",
-		},
-	} {
-		t.Run(ca.name, func(t *testing.T) {
-			var h Transports
-			err := h.Unmarshal(ca.hv)
-			require.EqualError(t, err, ca.err)
-		})
-	}
-}
-
 func TestTransportsMarshal(t *testing.T) {
 	for _, ca := range casesTransports {
 		t.Run(ca.name, func(t *testing.T) {
@@ -350,3 +235,41 @@ func TestTransportsMarshal(t *testing.T) {
 		})
 	}
 }
+
+func FuzzTransportsUnmarshal(f *testing.F) {
+	for _, ca := range casesTransports {
+		f.Add(ca.vin[0])
+	}
+
+	for _, ca := range casesTransport {
+		f.Add(ca.vin[0])
+	}
+
+	f.Add("source=aa-14187")
+	f.Add("destination=aa")
+	f.Add("interleaved=")
+	f.Add("ttl=")
+	f.Add("port=")
+	f.Add("client_port=")
+	f.Add("server_port=")
+	f.Add("mode=")
+
+	f.Fuzz(func(t *testing.T, b string) {
+		var h Transports
+		h.Unmarshal(base.HeaderValue{b}) //nolint:errcheck
+	})
+}
+
+func TestTransportAdditionalErrors(t *testing.T) {
+	func() {
+		var h Transport
+		err := h.Unmarshal(base.HeaderValue{})
+		require.Error(t, err)
+	}()
+
+	func() {
+		var h Transport
+		err := h.Unmarshal(base.HeaderValue{"a", "b"})
+		require.Error(t, err)
+	}()
+}