Adopt testify/assert for all tests

.golangci.yml

@@ -19,12 +19,16 @@ linters-settings:
             recommendations:
               - errors
   forbidigo:
+    analyze-types: true
     forbid:
       - ^fmt.Print(f|ln)?$
       - ^log.(Panic|Fatal|Print)(f|ln)?$
       - ^os.Exit$
       - ^panic$
       - ^print(ln)?$
+      - p: ^testing.T.(Error|Errorf|Fatal|Fatalf|Fail|FailNow)$
+        pkg: ^testing$
+        msg: "use testify/assert instead"
   varnamelen:
     max-distance: 12
     min-name-length: 2
@@ -127,9 +131,12 @@ issues:
   exclude-dirs-use-default: false
   exclude-rules:
     # Allow complex tests and examples, better to be self contained
-    - path: (examples|main\.go|_test\.go)
+    - path: (examples|main\.go)
       linters:
+        - gocognit
         - forbidigo
+    - path: _test\.go
+      linters:
         - gocognit
 
     # Allow forbidden identifiers in CLI commands

abscapturetimeextension_test.go

@@ -6,81 +6,56 @@ package rtp
 import (
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestAbsCaptureTimeExtension_Roundtrip(t *testing.T) { //nolint:cyclop
 	t.Run("positive captureClockOffset", func(t *testing.T) {
 		t0 := time.Now()
 		e1 := NewAbsCaptureTimeExtension(t0)
-		b1, err1 := e1.Marshal()
-		if err1 != nil {
-			t.Fatal(err1)
-		}
+		b1, err := e1.Marshal()
+		assert.NoError(t, err)
 		var o1 AbsCaptureTimeExtension
-		if err := o1.Unmarshal(b1); err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, o1.Unmarshal(b1))
 		dt1 := o1.CaptureTime().Sub(t0).Seconds()
-		if dt1 < -0.001 || dt1 > 0.001 {
-			t.Fatalf("timestamp differs, want %v got %v (dt=%f)", t0, o1.CaptureTime(), dt1)
-		}
-		if o1.EstimatedCaptureClockOffsetDuration() != nil {
-			t.Fatalf("duration differs, want nil got %d", o1.EstimatedCaptureClockOffsetDuration())
-		}
+		assert.GreaterOrEqual(t, dt1, -0.001)
+		assert.LessOrEqual(t, dt1, 0.001)
+		assert.Nil(t, o1.EstimatedCaptureClockOffsetDuration())
 
 		e2 := NewAbsCaptureTimeExtensionWithCaptureClockOffset(t0, 1250*time.Millisecond)
-		b2, err2 := e2.Marshal()
-		if err2 != nil {
-			t.Fatal(err2)
-		}
+		b2, err := e2.Marshal()
+		assert.NoError(t, err)
 		var o2 AbsCaptureTimeExtension
-		if err := o2.Unmarshal(b2); err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, o2.Unmarshal(b2))
 		dt2 := o1.CaptureTime().Sub(t0).Seconds()
-		if dt2 < -0.001 || dt2 > 0.001 {
-			t.Fatalf("timestamp differs, want %v got %v (dt=%f)", t0, o2.CaptureTime(), dt2)
-		}
-		if *o2.EstimatedCaptureClockOffsetDuration() != 1250*time.Millisecond {
-			t.Fatalf("duration differs, want 250ms got %d", *o2.EstimatedCaptureClockOffsetDuration())
-		}
+		assert.GreaterOrEqual(t, dt2, -0.001)
+		assert.LessOrEqual(t, dt2, 0.001)
+		assert.Equal(t, 1250*time.Millisecond, *o2.EstimatedCaptureClockOffsetDuration())
 	})
 
 	// This test can verify the for for the issue 247
 	t.Run("negative captureClockOffset", func(t *testing.T) {
 		t0 := time.Now()
 		e1 := NewAbsCaptureTimeExtension(t0)
-		b1, err1 := e1.Marshal()
-		if err1 != nil {
-			t.Fatal(err1)
-		}
+		b1, err := e1.Marshal()
+		assert.NoError(t, err)
 		var o1 AbsCaptureTimeExtension
-		if err := o1.Unmarshal(b1); err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, o1.Unmarshal(b1))
 		dt1 := o1.CaptureTime().Sub(t0).Seconds()
-		if dt1 < -0.001 || dt1 > 0.001 {
-			t.Fatalf("timestamp differs, want %v got %v (dt=%f)", t0, o1.CaptureTime(), dt1)
-		}
-		if o1.EstimatedCaptureClockOffsetDuration() != nil {
-			t.Fatalf("duration differs, want nil got %d", o1.EstimatedCaptureClockOffsetDuration())
-		}
+		assert.GreaterOrEqual(t, dt1, -0.001)
+		assert.LessOrEqual(t, dt1, 0.001)
+		assert.Nil(t, o1.EstimatedCaptureClockOffsetDuration())
 
 		e2 := NewAbsCaptureTimeExtensionWithCaptureClockOffset(t0, -250*time.Millisecond)
-		b2, err2 := e2.Marshal()
-		if err2 != nil {
-			t.Fatal(err2)
-		}
+		b2, err := e2.Marshal()
+		assert.NoError(t, err)
+
 		var o2 AbsCaptureTimeExtension
-		if err := o2.Unmarshal(b2); err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, o2.Unmarshal(b2))
 		dt2 := o1.CaptureTime().Sub(t0).Seconds()
-		if dt2 < -0.001 || dt2 > 0.001 {
-			t.Fatalf("timestamp differs, want %v got %v (dt=%f)", t0, o2.CaptureTime(), dt2)
-		}
-		if *o2.EstimatedCaptureClockOffsetDuration() != -250*time.Millisecond {
-			t.Fatalf("duration differs, want -250ms got %v", *o2.EstimatedCaptureClockOffsetDuration())
-		}
+		assert.GreaterOrEqual(t, dt2, -0.001)
+		assert.LessOrEqual(t, dt2, 0.001)
+		assert.Equal(t, -250*time.Millisecond, *o2.EstimatedCaptureClockOffsetDuration())
 	})
 }

abssendtimeextension_test.go

@@ -6,6 +6,8 @@ package rtp
 import (
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 const absSendTimeResolution = 3800 * time.Nanosecond
@@ -24,20 +26,22 @@ func TestNtpConversion(t *testing.T) {
 
 	for i, in := range tests {
 		out := toNtpTime(in.t)
-		if out != in.n {
-			t.Errorf("[%d] Converted NTP time from time.Time differs, expected: %d, got: %d",
-				i, in.n, out,
-			)
-		}
+		assert.Equalf(
+			t, in.n, out,
+			"[%d] Converted NTP time from time.Time differs", i,
+		)
 	}
 	for i, in := range tests {
 		out := toTime(in.n)
 		diff := in.t.Sub(out)
-		if diff < -absSendTimeResolution || absSendTimeResolution < diff {
-			t.Errorf("[%d] Converted time.Time from NTP time differs, expected: %v, got: %v",
-				i, in.t.UTC(), out.UTC(),
-			)
-		}
+		assert.GreaterOrEqualf(
+			t, diff, -absSendTimeResolution,
+			"[%d] Converted time.Time from NTP time differs", i,
+		)
+		assert.LessOrEqual(
+			t, diff, absSendTimeResolution,
+			"[%d] Converted time.Time from NTP time differs", i,
+		)
 	}
 }
 
@@ -52,16 +56,14 @@ func TestAbsSendTimeExtension_Roundtrip(t *testing.T) {
 	}
 	for i, in := range tests {
 		b, err := in.Marshal()
-		if err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, err)
+
 		var out AbsSendTimeExtension
-		if err = out.Unmarshal(b); err != nil {
-			t.Fatal(err)
-		}
-		if in.Timestamp != out.Timestamp {
-			t.Errorf("[%d] Timestamp differs, expected: %d, got: %d", i, in.Timestamp, out.Timestamp)
-		}
+		assert.NoError(t, out.Unmarshal(b))
+		assert.Equalf(
+			t, in.Timestamp, out.Timestamp,
+			"[%d] Timestamp differs", i,
+		)
 	}
 }
 
@@ -77,20 +79,21 @@ func TestAbsSendTimeExtension_Estimate(t *testing.T) {
 		inTime := toTime(in.sendNTP)
 		send := &AbsSendTimeExtension{in.sendNTP >> 14}
 		b, err := send.Marshal()
-		if err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, err)
 		var received AbsSendTimeExtension
-		if err = received.Unmarshal(b); err != nil {
-			t.Fatal(err)
-		}
+		assert.NoError(t, received.Unmarshal(b))
 
 		estimated := received.Estimate(toTime(in.receiveNTP))
 		diff := estimated.Sub(inTime)
-		if diff < -absSendTimeResolution || absSendTimeResolution < diff {
-			t.Errorf("[%d] Estimated time differs, expected: %v, estimated: %v (receive time: %v)",
-				i, inTime.UTC(), estimated.UTC(), toTime(in.receiveNTP).UTC(),
-			)
-		}
+		assert.GreaterOrEqualf(
+			t, diff, -absSendTimeResolution,
+			"[%d] Estimated time differs, expected: %v, estimated: %v (receive time: %v)",
+			i, inTime.UTC(), estimated.UTC(), toTime(in.receiveNTP).UTC(),
+		)
+		assert.LessOrEqual(
+			t, diff, absSendTimeResolution,
+			"[%d] Estimated time differs, expected: %v, estimated: %v (receive time: %v)",
+			i, inTime.UTC(), estimated.UTC(), toTime(in.receiveNTP).UTC(),
+		)
 	}
 }

audiolevelextension_test.go

@@ -4,71 +4,49 @@
 package rtp
 
 import (
-	"bytes"
-	"errors"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestAudioLevelExtensionTooSmall(t *testing.T) {
 	a := AudioLevelExtension{}
-
 	rawData := []byte{}
-
-	if err := a.Unmarshal(rawData); !errors.Is(err, errTooSmall) {
-		t.Fatal("err != errTooSmall")
-	}
+	assert.ErrorIs(t, a.Unmarshal(rawData), errTooSmall)
 }
 
 func TestAudioLevelExtensionVoiceTrue(t *testing.T) {
 	a1 := AudioLevelExtension{}
-
 	rawData := []byte{
 		0x88,
 	}
-
-	if err := a1.Unmarshal(rawData); err != nil {
-		t.Fatal("Unmarshal error on extension data")
-	}
+	assert.NoError(t, a1.Unmarshal(rawData))
 
 	a2 := AudioLevelExtension{
 		Level: 8,
 		Voice: true,
 	}
-
-	if a1 != a2 {
-		t.Error("Unmarshal failed")
-	}
+	assert.Equal(t, a2, a1)
 
 	dstData, _ := a2.Marshal()
-	if !bytes.Equal(dstData, rawData) {
-		t.Error("Marshal failed")
-	}
+	assert.Equal(t, rawData, dstData)
 }
 
 func TestAudioLevelExtensionVoiceFalse(t *testing.T) {
 	a1 := AudioLevelExtension{}
-
 	rawData := []byte{
 		0x8,
 	}
-
-	if err := a1.Unmarshal(rawData); err != nil {
-		t.Fatal("Unmarshal error on extension data")
-	}
+	assert.NoError(t, a1.Unmarshal(rawData))
 
 	a2 := AudioLevelExtension{
 		Level: 8,
 		Voice: false,
 	}
-
-	if a1 != a2 {
-		t.Error("Unmarshal failed")
-	}
+	assert.Equal(t, a2, a1)
 
 	dstData, _ := a2.Marshal()
-	if !bytes.Equal(dstData, rawData) {
-		t.Error("Marshal failed")
-	}
+	assert.Equal(t, rawData, dstData)
 }
 
 func TestAudioLevelExtensionLevelOverflow(t *testing.T) {
@@ -77,7 +55,6 @@ func TestAudioLevelExtensionLevelOverflow(t *testing.T) {
 		Voice: false,
 	}
 
-	if _, err := a.Marshal(); !errors.Is(err, errAudioLevelOverflow) {
-		t.Fatal("err != errAudioLevelOverflow")
-	}
+	_, err := a.Marshal()
+	assert.ErrorIs(t, err, errAudioLevelOverflow)
 }