v3(tests): use testify for assertion (#2036)

* replace

* write

* rewrite more

* rewrite

* rewrite

* fix

* rewrite

addon/retry/exponential_backoff_test.go

@@ -2,9 +2,10 @@ package retry
 
 import (
 	"fmt"
-	"github.com/gofiber/fiber/v3/utils"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestExponentialBackoff_Retry(t *testing.T) {
@@ -59,7 +60,7 @@ func TestExponentialBackoff_Retry(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			err := tt.expBackoff.Retry(tt.f)
-			utils.AssertEqual(t, tt.expErr, err)
+			require.Equal(t, tt.expErr, err)
 		})
 	}
 }

bind_test.go

@@ -12,7 +12,7 @@ import (
 	"time"
 
 	"github.com/gofiber/fiber/v3/binder"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -31,23 +31,23 @@ func Test_Bind_Query(t *testing.T) {
 	c.Request().Header.SetContentType("")
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=basketball&hobby=football")
 	q := new(Query)
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
-	utils.AssertEqual(t, 2, len(q.Hobby))
+	require.Nil(t, c.Bind().Query(q))
+	require.Equal(t, 2, len(q.Hobby))
 
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=basketball,football")
 	q = new(Query)
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
-	utils.AssertEqual(t, 2, len(q.Hobby))
+	require.Nil(t, c.Bind().Query(q))
+	require.Equal(t, 2, len(q.Hobby))
 
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=scoccer&hobby=basketball,football")
 	q = new(Query)
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
-	utils.AssertEqual(t, 3, len(q.Hobby))
+	require.Nil(t, c.Bind().Query(q))
+	require.Equal(t, 3, len(q.Hobby))
 
 	empty := new(Query)
 	c.Request().URI().SetQueryString("")
-	utils.AssertEqual(t, nil, c.Bind().Query(empty))
-	utils.AssertEqual(t, 0, len(empty.Hobby))
+	require.Nil(t, c.Bind().Query(empty))
+	require.Equal(t, 0, len(empty.Hobby))
 
 	type Query2 struct {
 		Bool            bool
@@ -64,30 +64,30 @@ func Test_Bind_Query(t *testing.T) {
 	q2 := new(Query2)
 	q2.Bool = true
 	q2.Name = "hello world"
-	utils.AssertEqual(t, nil, c.Bind().Query(q2))
-	utils.AssertEqual(t, "basketball,football", q2.Hobby)
-	utils.AssertEqual(t, true, q2.Bool)
-	utils.AssertEqual(t, "tom", q2.Name) // check value get overwritten
-	utils.AssertEqual(t, []string{"milo", "coke", "pepsi"}, q2.FavouriteDrinks)
+	require.Nil(t, c.Bind().Query(q2))
+	require.Equal(t, "basketball,football", q2.Hobby)
+	require.True(t, q2.Bool)
+	require.Equal(t, "tom", q2.Name) // check value get overwritten
+	require.Equal(t, []string{"milo", "coke", "pepsi"}, q2.FavouriteDrinks)
 	var nilSlice []string
-	utils.AssertEqual(t, nilSlice, q2.Empty)
-	utils.AssertEqual(t, []string{""}, q2.Alloc)
-	utils.AssertEqual(t, []int64{1}, q2.No)
+	require.Equal(t, nilSlice, q2.Empty)
+	require.Equal(t, []string{""}, q2.Alloc)
+	require.Equal(t, []int64{1}, q2.No)
 
 	type RequiredQuery struct {
 		Name string `query:"name,required"`
 	}
 	rq := new(RequiredQuery)
 	c.Request().URI().SetQueryString("")
-	utils.AssertEqual(t, "name is empty", c.Bind().Query(rq).Error())
+	require.Equal(t, "name is empty", c.Bind().Query(rq).Error())
 
 	type ArrayQuery struct {
 		Data []string
 	}
 	aq := new(ArrayQuery)
 	c.Request().URI().SetQueryString("data[]=john&data[]=doe")
-	utils.AssertEqual(t, nil, c.Bind().Query(aq))
-	utils.AssertEqual(t, 2, len(aq.Data))
+	require.Nil(t, c.Bind().Query(aq))
+	require.Equal(t, 2, len(aq.Data))
 }
 
 // go test -run Test_Bind_Query_Map -v
@@ -101,32 +101,32 @@ func Test_Bind_Query_Map(t *testing.T) {
 	c.Request().Header.SetContentType("")
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=basketball&hobby=football")
 	q := make(map[string][]string)
-	utils.AssertEqual(t, nil, c.Bind().Query(&q))
-	utils.AssertEqual(t, 2, len(q["hobby"]))
+	require.Nil(t, c.Bind().Query(&q))
+	require.Equal(t, 2, len(q["hobby"]))
 
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=basketball,football")
 	q = make(map[string][]string)
-	utils.AssertEqual(t, nil, c.Bind().Query(&q))
-	utils.AssertEqual(t, 2, len(q["hobby"]))
+	require.Nil(t, c.Bind().Query(&q))
+	require.Equal(t, 2, len(q["hobby"]))
 
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=scoccer&hobby=basketball,football")
 	q = make(map[string][]string)
-	utils.AssertEqual(t, nil, c.Bind().Query(&q))
-	utils.AssertEqual(t, 3, len(q["hobby"]))
+	require.Nil(t, c.Bind().Query(&q))
+	require.Equal(t, 3, len(q["hobby"]))
 
 	c.Request().URI().SetQueryString("id=1&name=tom&hobby=scoccer")
 	qq := make(map[string]string)
-	utils.AssertEqual(t, nil, c.Bind().Query(&qq))
-	utils.AssertEqual(t, "1", qq["id"])
+	require.Nil(t, c.Bind().Query(&qq))
+	require.Equal(t, "1", qq["id"])
 
 	empty := make(map[string][]string)
 	c.Request().URI().SetQueryString("")
-	utils.AssertEqual(t, nil, c.Bind().Query(&empty))
-	utils.AssertEqual(t, 0, len(empty["hobby"]))
+	require.Nil(t, c.Bind().Query(&empty))
+	require.Equal(t, 0, len(empty["hobby"]))
 
 	em := make(map[string][]int)
 	c.Request().URI().SetQueryString("")
-	utils.AssertEqual(t, binder.ErrMapNotConvertable, c.Bind().Query(&em))
+	require.Equal(t, binder.ErrMapNotConvertable, c.Bind().Query(&em))
 }
 
 // go test -run Test_Bind_Query_WithSetParserDecoder -v
@@ -166,20 +166,20 @@ func Test_Bind_Query_WithSetParserDecoder(t *testing.T) {
 	q := new(NonRFCTimeInput)
 
 	c.Request().URI().SetQueryString("date=2021-04-10&title=CustomDateTest&Body=October")
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
+	require.Nil(t, c.Bind().Query(q))
 	fmt.Println(q.Date, "q.Date")
-	utils.AssertEqual(t, "CustomDateTest", q.Title)
+	require.Equal(t, "CustomDateTest", q.Title)
 	date := fmt.Sprintf("%v", q.Date)
-	utils.AssertEqual(t, "{0 63753609600 <nil>}", date)
-	utils.AssertEqual(t, "October", q.Body)
+	require.Equal(t, "{0 63753609600 <nil>}", date)
+	require.Equal(t, "October", q.Body)
 
 	c.Request().URI().SetQueryString("date=2021-04-10&title&Body=October")
 	q = &NonRFCTimeInput{
 		Title: "Existing title",
 		Body:  "Existing Body",
 	}
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
-	utils.AssertEqual(t, "", q.Title)
+	require.Nil(t, c.Bind().Query(q))
+	require.Equal(t, "", q.Title)
 }
 
 // go test -run Test_Bind_Query_Schema -v
@@ -198,19 +198,19 @@ func Test_Bind_Query_Schema(t *testing.T) {
 	c.Request().Header.SetContentType("")
 	c.Request().URI().SetQueryString("name=tom&nested.age=10")
 	q := new(Query1)
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
+	require.Nil(t, c.Bind().Query(q))
 
 	c.Request().URI().SetQueryString("namex=tom&nested.age=10")
 	q = new(Query1)
-	utils.AssertEqual(t, "name is empty", c.Bind().Query(q).Error())
+	require.Equal(t, "name is empty", c.Bind().Query(q).Error())
 
 	c.Request().URI().SetQueryString("name=tom&nested.agex=10")
 	q = new(Query1)
-	utils.AssertEqual(t, nil, c.Bind().Query(q))
+	require.Nil(t, c.Bind().Query(q))
 
 	c.Request().URI().SetQueryString("name=tom&test.age=10")
 	q = new(Query1)
-	utils.AssertEqual(t, "nested is empty", c.Bind().Query(q).Error())
+	require.Equal(t, "nested is empty", c.Bind().Query(q).Error())
 
 	type Query2 struct {
 		Name   string `query:"name"`
@@ -220,19 +220,19 @@ func Test_Bind_Query_Schema(t *testing.T) {
 	}
 	c.Request().URI().SetQueryString("name=tom&nested.age=10")
 	q2 := new(Query2)
-	utils.AssertEqual(t, nil, c.Bind().Query(q2))
+	require.Nil(t, c.Bind().Query(q2))
 
 	c.Request().URI().SetQueryString("nested.age=10")
 	q2 = new(Query2)
-	utils.AssertEqual(t, nil, c.Bind().Query(q2))
+	require.Nil(t, c.Bind().Query(q2))
 
 	c.Request().URI().SetQueryString("nested.agex=10")
 	q2 = new(Query2)
-	utils.AssertEqual(t, "nested.age is empty", c.Bind().Query(q2).Error())
+	require.Equal(t, "nested.age is empty", c.Bind().Query(q2).Error())
 
 	c.Request().URI().SetQueryString("nested.agex=10")
 	q2 = new(Query2)
-	utils.AssertEqual(t, "nested.age is empty", c.Bind().Query(q2).Error())
+	require.Equal(t, "nested.age is empty", c.Bind().Query(q2).Error())
 
 	type Node struct {
 		Value int   `query:"val,required"`
@@ -240,20 +240,20 @@ func Test_Bind_Query_Schema(t *testing.T) {
 	}
 	c.Request().URI().SetQueryString("val=1&next.val=3")
 	n := new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Query(n))
-	utils.AssertEqual(t, 1, n.Value)
-	utils.AssertEqual(t, 3, n.Next.Value)
+	require.Nil(t, c.Bind().Query(n))
+	require.Equal(t, 1, n.Value)
+	require.Equal(t, 3, n.Next.Value)
 
 	c.Request().URI().SetQueryString("next.val=2")
 	n = new(Node)
-	utils.AssertEqual(t, "val is empty", c.Bind().Query(n).Error())
+	require.Equal(t, "val is empty", c.Bind().Query(n).Error())
 
 	c.Request().URI().SetQueryString("val=3&next.value=2")
 	n = new(Node)
 	n.Next = new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Query(n))
-	utils.AssertEqual(t, 3, n.Value)
-	utils.AssertEqual(t, 0, n.Next.Value)
+	require.Nil(t, c.Bind().Query(n))
+	require.Equal(t, 3, n.Value)
+	require.Equal(t, 0, n.Next.Value)
 
 	type Person struct {
 		Name string `query:"name"`
@@ -266,21 +266,21 @@ func Test_Bind_Query_Schema(t *testing.T) {
 
 	c.Request().URI().SetQueryString("data[0][name]=john&data[0][age]=10&data[1][name]=doe&data[1][age]=12")
 	cq := new(CollectionQuery)
-	utils.AssertEqual(t, nil, c.Bind().Query(cq))
-	utils.AssertEqual(t, 2, len(cq.Data))
-	utils.AssertEqual(t, "john", cq.Data[0].Name)
-	utils.AssertEqual(t, 10, cq.Data[0].Age)
-	utils.AssertEqual(t, "doe", cq.Data[1].Name)
-	utils.AssertEqual(t, 12, cq.Data[1].Age)
+	require.Nil(t, c.Bind().Query(cq))
+	require.Equal(t, 2, len(cq.Data))
+	require.Equal(t, "john", cq.Data[0].Name)
+	require.Equal(t, 10, cq.Data[0].Age)
+	require.Equal(t, "doe", cq.Data[1].Name)
+	require.Equal(t, 12, cq.Data[1].Age)
 
 	c.Request().URI().SetQueryString("data.0.name=john&data.0.age=10&data.1.name=doe&data.1.age=12")
 	cq = new(CollectionQuery)
-	utils.AssertEqual(t, nil, c.Bind().Query(cq))
-	utils.AssertEqual(t, 2, len(cq.Data))
-	utils.AssertEqual(t, "john", cq.Data[0].Name)
-	utils.AssertEqual(t, 10, cq.Data[0].Age)
-	utils.AssertEqual(t, "doe", cq.Data[1].Name)
-	utils.AssertEqual(t, 12, cq.Data[1].Age)
+	require.Nil(t, c.Bind().Query(cq))
+	require.Equal(t, 2, len(cq.Data))
+	require.Equal(t, "john", cq.Data[0].Name)
+	require.Equal(t, 10, cq.Data[0].Age)
+	require.Equal(t, "doe", cq.Data[1].Name)
+	require.Equal(t, 12, cq.Data[1].Age)
 }
 
 // go test -run Test_Bind_Header -v
@@ -301,19 +301,19 @@ func Test_Bind_Header(t *testing.T) {
 	c.Request().Header.Add("Name", "John Doe")
 	c.Request().Header.Add("Hobby", "golang,fiber")
 	q := new(Header)
-	utils.AssertEqual(t, nil, c.Bind().Header(q))
-	utils.AssertEqual(t, 2, len(q.Hobby))
+	require.Nil(t, c.Bind().Header(q))
+	require.Equal(t, 2, len(q.Hobby))
 
 	c.Request().Header.Del("hobby")
 	c.Request().Header.Add("Hobby", "golang,fiber,go")
 	q = new(Header)
-	utils.AssertEqual(t, nil, c.Bind().Header(q))
-	utils.AssertEqual(t, 3, len(q.Hobby))
+	require.Nil(t, c.Bind().Header(q))
+	require.Equal(t, 3, len(q.Hobby))
 
 	empty := new(Header)
 	c.Request().Header.Del("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(empty))
-	utils.AssertEqual(t, 0, len(empty.Hobby))
+	require.Nil(t, c.Bind().Query(empty))
+	require.Equal(t, 0, len(empty.Hobby))
 
 	type Header2 struct {
 		Bool            bool
@@ -337,22 +337,22 @@ func Test_Bind_Header(t *testing.T) {
 	h2 := new(Header2)
 	h2.Bool = true
 	h2.Name = "hello world"
-	utils.AssertEqual(t, nil, c.Bind().Header(h2))
-	utils.AssertEqual(t, "go,fiber", h2.Hobby)
-	utils.AssertEqual(t, true, h2.Bool)
-	utils.AssertEqual(t, "Jane Doe", h2.Name) // check value get overwritten
-	utils.AssertEqual(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
+	require.Nil(t, c.Bind().Header(h2))
+	require.Equal(t, "go,fiber", h2.Hobby)
+	require.True(t, h2.Bool)
+	require.Equal(t, "Jane Doe", h2.Name) // check value get overwritten
+	require.Equal(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
 	var nilSlice []string
-	utils.AssertEqual(t, nilSlice, h2.Empty)
-	utils.AssertEqual(t, []string{""}, h2.Alloc)
-	utils.AssertEqual(t, []int64{1}, h2.No)
+	require.Equal(t, nilSlice, h2.Empty)
+	require.Equal(t, []string{""}, h2.Alloc)
+	require.Equal(t, []int64{1}, h2.No)
 
 	type RequiredHeader struct {
 		Name string `header:"name,required"`
 	}
 	rh := new(RequiredHeader)
 	c.Request().Header.Del("name")
-	utils.AssertEqual(t, "name is empty", c.Bind().Header(rh).Error())
+	require.Equal(t, "name is empty", c.Bind().Header(rh).Error())
 }
 
 // go test -run Test_Bind_Header_Map -v
@@ -369,19 +369,19 @@ func Test_Bind_Header_Map(t *testing.T) {
 	c.Request().Header.Add("Name", "John Doe")
 	c.Request().Header.Add("Hobby", "golang,fiber")
 	q := make(map[string][]string, 0)
-	utils.AssertEqual(t, nil, c.Bind().Header(&q))
-	utils.AssertEqual(t, 2, len(q["Hobby"]))
+	require.Nil(t, c.Bind().Header(&q))
+	require.Equal(t, 2, len(q["Hobby"]))
 
 	c.Request().Header.Del("hobby")
 	c.Request().Header.Add("Hobby", "golang,fiber,go")
 	q = make(map[string][]string, 0)
-	utils.AssertEqual(t, nil, c.Bind().Header(&q))
-	utils.AssertEqual(t, 3, len(q["Hobby"]))
+	require.Nil(t, c.Bind().Header(&q))
+	require.Equal(t, 3, len(q["Hobby"]))
 
 	empty := make(map[string][]string, 0)
 	c.Request().Header.Del("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(&empty))
-	utils.AssertEqual(t, 0, len(empty["Hobby"]))
+	require.Nil(t, c.Bind().Query(&empty))
+	require.Equal(t, 0, len(empty["Hobby"]))
 }
 
 // go test -run Test_Bind_Header_WithSetParserDecoder -v
@@ -424,20 +424,20 @@ func Test_Bind_Header_WithSetParserDecoder(t *testing.T) {
 	c.Request().Header.Add("Title", "CustomDateTest")
 	c.Request().Header.Add("Body", "October")
 
-	utils.AssertEqual(t, nil, c.Bind().Header(r))
+	require.Nil(t, c.Bind().Header(r))
 	fmt.Println(r.Date, "q.Date")
-	utils.AssertEqual(t, "CustomDateTest", r.Title)
+	require.Equal(t, "CustomDateTest", r.Title)
 	date := fmt.Sprintf("%v", r.Date)
-	utils.AssertEqual(t, "{0 63753609600 <nil>}", date)
-	utils.AssertEqual(t, "October", r.Body)
+	require.Equal(t, "{0 63753609600 <nil>}", date)
+	require.Equal(t, "October", r.Body)
 
 	c.Request().Header.Add("Title", "")
 	r = &NonRFCTimeInput{
 		Title: "Existing title",
 		Body:  "Existing Body",
 	}
-	utils.AssertEqual(t, nil, c.Bind().Header(r))
-	utils.AssertEqual(t, "", r.Title)
+	require.Nil(t, c.Bind().Header(r))
+	require.Equal(t, "", r.Title)
 }
 
 // go test -run Test_Bind_Header_Schema -v
@@ -458,21 +458,21 @@ func Test_Bind_Header_Schema(t *testing.T) {
 	c.Request().Header.Add("Name", "tom")
 	c.Request().Header.Add("Nested.Age", "10")
 	q := new(Header1)
-	utils.AssertEqual(t, nil, c.Bind().Header(q))
+	require.Nil(t, c.Bind().Header(q))
 
 	c.Request().Header.Del("Name")
 	q = new(Header1)
-	utils.AssertEqual(t, "Name is empty", c.Bind().Header(q).Error())
+	require.Equal(t, "Name is empty", c.Bind().Header(q).Error())
 
 	c.Request().Header.Add("Name", "tom")
 	c.Request().Header.Del("Nested.Age")
 	c.Request().Header.Add("Nested.Agex", "10")
 	q = new(Header1)
-	utils.AssertEqual(t, nil, c.Bind().Header(q))
+	require.Nil(t, c.Bind().Header(q))
 
 	c.Request().Header.Del("Nested.Agex")
 	q = new(Header1)
-	utils.AssertEqual(t, "Nested is empty", c.Bind().Header(q).Error())
+	require.Equal(t, "Nested is empty", c.Bind().Header(q).Error())
 
 	c.Request().Header.Del("Nested.Agex")
 	c.Request().Header.Del("Name")
@@ -488,17 +488,17 @@ func Test_Bind_Header_Schema(t *testing.T) {
 	c.Request().Header.Add("Nested.Age", "10")
 
 	h2 := new(Header2)
-	utils.AssertEqual(t, nil, c.Bind().Header(h2))
+	require.Nil(t, c.Bind().Header(h2))
 
 	c.Request().Header.Del("Name")
 	h2 = new(Header2)
-	utils.AssertEqual(t, nil, c.Bind().Header(h2))
+	require.Nil(t, c.Bind().Header(h2))
 
 	c.Request().Header.Del("Name")
 	c.Request().Header.Del("Nested.Age")
 	c.Request().Header.Add("Nested.Agex", "10")
 	h2 = new(Header2)
-	utils.AssertEqual(t, "Nested.age is empty", c.Bind().Header(h2).Error())
+	require.Equal(t, "Nested.age is empty", c.Bind().Header(h2).Error())
 
 	type Node struct {
 		Value int   `header:"Val,required"`
@@ -507,22 +507,22 @@ func Test_Bind_Header_Schema(t *testing.T) {
 	c.Request().Header.Add("Val", "1")
 	c.Request().Header.Add("Next.Val", "3")
 	n := new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Header(n))
-	utils.AssertEqual(t, 1, n.Value)
-	utils.AssertEqual(t, 3, n.Next.Value)
+	require.Nil(t, c.Bind().Header(n))
+	require.Equal(t, 1, n.Value)
+	require.Equal(t, 3, n.Next.Value)
 
 	c.Request().Header.Del("Val")
 	n = new(Node)
-	utils.AssertEqual(t, "Val is empty", c.Bind().Header(n).Error())
+	require.Equal(t, "Val is empty", c.Bind().Header(n).Error())
 
 	c.Request().Header.Add("Val", "3")
 	c.Request().Header.Del("Next.Val")
 	c.Request().Header.Add("Next.Value", "2")
 	n = new(Node)
 	n.Next = new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Header(n))
-	utils.AssertEqual(t, 3, n.Value)
-	utils.AssertEqual(t, 0, n.Next.Value)
+	require.Nil(t, c.Bind().Header(n))
+	require.Equal(t, 3, n.Value)
+	require.Equal(t, 0, n.Next.Value)
 }
 
 // go test -run Test_Bind_Resp_Header -v
@@ -543,19 +543,19 @@ func Test_Bind_RespHeader(t *testing.T) {
 	c.Response().Header.Add("Name", "John Doe")
 	c.Response().Header.Add("Hobby", "golang,fiber")
 	q := new(Header)
-	utils.AssertEqual(t, nil, c.Bind().RespHeader(q))
-	utils.AssertEqual(t, 2, len(q.Hobby))
+	require.Nil(t, c.Bind().RespHeader(q))
+	require.Equal(t, 2, len(q.Hobby))
 
 	c.Response().Header.Del("hobby")
 	c.Response().Header.Add("Hobby", "golang,fiber,go")
 	q = new(Header)
-	utils.AssertEqual(t, nil, c.Bind().RespHeader(q))
-	utils.AssertEqual(t, 3, len(q.Hobby))
+	require.Nil(t, c.Bind().RespHeader(q))
+	require.Equal(t, 3, len(q.Hobby))
 
 	empty := new(Header)
 	c.Response().Header.Del("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(empty))
-	utils.AssertEqual(t, 0, len(empty.Hobby))
+	require.Nil(t, c.Bind().Query(empty))
+	require.Equal(t, 0, len(empty.Hobby))
 
 	type Header2 struct {
 		Bool            bool
@@ -579,22 +579,22 @@ func Test_Bind_RespHeader(t *testing.T) {
 	h2 := new(Header2)
 	h2.Bool = true
 	h2.Name = "hello world"
-	utils.AssertEqual(t, nil, c.Bind().RespHeader(h2))
-	utils.AssertEqual(t, "go,fiber", h2.Hobby)
-	utils.AssertEqual(t, true, h2.Bool)
-	utils.AssertEqual(t, "Jane Doe", h2.Name) // check value get overwritten
-	utils.AssertEqual(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
+	require.Nil(t, c.Bind().RespHeader(h2))
+	require.Equal(t, "go,fiber", h2.Hobby)
+	require.True(t, h2.Bool)
+	require.Equal(t, "Jane Doe", h2.Name) // check value get overwritten
+	require.Equal(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
 	var nilSlice []string
-	utils.AssertEqual(t, nilSlice, h2.Empty)
-	utils.AssertEqual(t, []string{""}, h2.Alloc)
-	utils.AssertEqual(t, []int64{1}, h2.No)
+	require.Equal(t, nilSlice, h2.Empty)
+	require.Equal(t, []string{""}, h2.Alloc)
+	require.Equal(t, []int64{1}, h2.No)
 
 	type RequiredHeader struct {
 		Name string `respHeader:"name,required"`
 	}
 	rh := new(RequiredHeader)
 	c.Response().Header.Del("name")
-	utils.AssertEqual(t, "name is empty", c.Bind().RespHeader(rh).Error())
+	require.Equal(t, "name is empty", c.Bind().RespHeader(rh).Error())
 }
 
 // go test -run Test_Bind_RespHeader_Map -v
@@ -611,19 +611,19 @@ func Test_Bind_RespHeader_Map(t *testing.T) {
 	c.Response().Header.Add("Name", "John Doe")
 	c.Response().Header.Add("Hobby", "golang,fiber")
 	q := make(map[string][]string, 0)
-	utils.AssertEqual(t, nil, c.Bind().RespHeader(&q))
-	utils.AssertEqual(t, 2, len(q["Hobby"]))
+	require.Nil(t, c.Bind().RespHeader(&q))
+	require.Equal(t, 2, len(q["Hobby"]))
 
 	c.Response().Header.Del("hobby")
 	c.Response().Header.Add("Hobby", "golang,fiber,go")
 	q = make(map[string][]string, 0)
-	utils.AssertEqual(t, nil, c.Bind().RespHeader(&q))
-	utils.AssertEqual(t, 3, len(q["Hobby"]))
+	require.Nil(t, c.Bind().RespHeader(&q))
+	require.Equal(t, 3, len(q["Hobby"]))
 
 	empty := make(map[string][]string, 0)
 	c.Response().Header.Del("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(&empty))
-	utils.AssertEqual(t, 0, len(empty["Hobby"]))
+	require.Nil(t, c.Bind().Query(&empty))
+	require.Equal(t, 0, len(empty["Hobby"]))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Query -benchmem -count=4
@@ -645,7 +645,7 @@ func Benchmark_Bind_Query(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Query(q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Query(q))
+	require.Nil(b, c.Bind().Query(q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Query_Map -benchmem -count=4
@@ -662,7 +662,7 @@ func Benchmark_Bind_Query_Map(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Query(&q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Query(&q))
+	require.Nil(b, c.Bind().Query(&q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Query_WithParseParam -benchmem -count=4
@@ -690,7 +690,7 @@ func Benchmark_Bind_Query_WithParseParam(b *testing.B) {
 		c.Bind().Query(cq)
 	}
 
-	utils.AssertEqual(b, nil, c.Bind().Query(cq))
+	require.Nil(b, c.Bind().Query(cq))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Query_Comma -benchmem -count=4
@@ -713,7 +713,7 @@ func Benchmark_Bind_Query_Comma(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Query(q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Query(q))
+	require.Nil(b, c.Bind().Query(q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Header -benchmem -count=4
@@ -739,7 +739,7 @@ func Benchmark_Bind_Header(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Header(q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Header(q))
+	require.Nil(b, c.Bind().Header(q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Header_Map -benchmem -count=4
@@ -760,7 +760,7 @@ func Benchmark_Bind_Header_Map(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Header(&q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Header(&q))
+	require.Nil(b, c.Bind().Header(&q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_RespHeader -benchmem -count=4
@@ -786,7 +786,7 @@ func Benchmark_Bind_RespHeader(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().RespHeader(q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().RespHeader(q))
+	require.Nil(b, c.Bind().RespHeader(q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_RespHeader_Map -benchmem -count=4
@@ -807,7 +807,7 @@ func Benchmark_Bind_RespHeader_Map(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().RespHeader(&q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().RespHeader(&q))
+	require.Nil(b, c.Bind().RespHeader(&q))
 }
 
 // go test -run Test_Bind_Body
@@ -831,8 +831,8 @@ func Test_Bind_Body(t *testing.T) {
 		c.Request().SetBody(gzipJSON.Bytes())
 		c.Request().Header.SetContentLength(len(gzipJSON.Bytes()))
 		d := new(Demo)
-		utils.AssertEqual(t, nil, c.Bind().Body(d))
-		utils.AssertEqual(t, "john", d.Name)
+		require.Nil(t, c.Bind().Body(d))
+		require.Equal(t, "john", d.Name)
 		c.Request().Header.Del(HeaderContentEncoding)
 	}
 
@@ -841,8 +841,8 @@ func Test_Bind_Body(t *testing.T) {
 		c.Request().SetBody([]byte(body))
 		c.Request().Header.SetContentLength(len(body))
 		d := new(Demo)
-		utils.AssertEqual(t, nil, c.Bind().Body(d))
-		utils.AssertEqual(t, "john", d.Name)
+		require.Nil(t, c.Bind().Body(d))
+		require.Equal(t, "john", d.Name)
 	}
 
 	testDecodeParser(MIMEApplicationJSON, `{"name":"john"}`)
@@ -854,7 +854,7 @@ func Test_Bind_Body(t *testing.T) {
 		c.Request().Header.SetContentType(contentType)
 		c.Request().SetBody([]byte(body))
 		c.Request().Header.SetContentLength(len(body))
-		utils.AssertEqual(t, false, c.Bind().Body(nil) == nil)
+		require.False(t, c.Bind().Body(nil) == nil)
 	}
 
 	testDecodeParserError("invalid-content-type", "")
@@ -869,20 +869,20 @@ func Test_Bind_Body(t *testing.T) {
 	c.Request().SetBody([]byte("data[0][name]=john&data[1][name]=doe"))
 	c.Request().Header.SetContentLength(len(c.Body()))
 	cq := new(CollectionQuery)
-	utils.AssertEqual(t, nil, c.Bind().Body(cq))
-	utils.AssertEqual(t, 2, len(cq.Data))
-	utils.AssertEqual(t, "john", cq.Data[0].Name)
-	utils.AssertEqual(t, "doe", cq.Data[1].Name)
+	require.Nil(t, c.Bind().Body(cq))
+	require.Equal(t, 2, len(cq.Data))
+	require.Equal(t, "john", cq.Data[0].Name)
+	require.Equal(t, "doe", cq.Data[1].Name)
 
 	c.Request().Reset()
 	c.Request().Header.SetContentType(MIMEApplicationForm)
 	c.Request().SetBody([]byte("data.0.name=john&data.1.name=doe"))
 	c.Request().Header.SetContentLength(len(c.Body()))
 	cq = new(CollectionQuery)
-	utils.AssertEqual(t, nil, c.Bind().Body(cq))
-	utils.AssertEqual(t, 2, len(cq.Data))
-	utils.AssertEqual(t, "john", cq.Data[0].Name)
-	utils.AssertEqual(t, "doe", cq.Data[1].Name)
+	require.Nil(t, c.Bind().Body(cq))
+	require.Equal(t, 2, len(cq.Data))
+	require.Equal(t, "john", cq.Data[0].Name)
+	require.Equal(t, "doe", cq.Data[1].Name)
 }
 
 // go test -run Test_Bind_Body_WithSetParserDecoder
@@ -925,11 +925,11 @@ func Test_Bind_Body_WithSetParserDecoder(t *testing.T) {
 			Title: "Existing title",
 			Body:  "Existing Body",
 		}
-		utils.AssertEqual(t, nil, c.Bind().Body(&d))
+		require.Nil(t, c.Bind().Body(&d))
 		date := fmt.Sprintf("%v", d.Date)
-		utils.AssertEqual(t, "{0 63743587200 <nil>}", date)
-		utils.AssertEqual(t, "", d.Title)
-		utils.AssertEqual(t, "New Body", d.Body)
+		require.Equal(t, "{0 63743587200 <nil>}", date)
+		require.Equal(t, "", d.Title)
+		require.Equal(t, "New Body", d.Body)
 	}
 
 	testDecodeParser(MIMEApplicationForm, "date=2020-12-15&title=&body=New Body")
@@ -956,8 +956,8 @@ func Benchmark_Bind_Body_JSON(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		_ = c.Bind().Body(d)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Body(d))
-	utils.AssertEqual(b, "john", d.Name)
+	require.Nil(b, c.Bind().Body(d))
+	require.Equal(b, "john", d.Name)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Bind_Body_XML -benchmem -count=4
@@ -980,8 +980,8 @@ func Benchmark_Bind_Body_XML(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		_ = c.Bind().Body(d)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Body(d))
-	utils.AssertEqual(b, "john", d.Name)
+	require.Nil(b, c.Bind().Body(d))
+	require.Equal(b, "john", d.Name)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Bind_Body_Form -benchmem -count=4
@@ -1004,8 +1004,8 @@ func Benchmark_Bind_Body_Form(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		_ = c.Bind().Body(d)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Body(d))
-	utils.AssertEqual(b, "john", d.Name)
+	require.Nil(b, c.Bind().Body(d))
+	require.Equal(b, "john", d.Name)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Bind_Body_MultipartForm -benchmem -count=4
@@ -1029,8 +1029,8 @@ func Benchmark_Bind_Body_MultipartForm(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		_ = c.Bind().Body(d)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Body(d))
-	utils.AssertEqual(b, "john", d.Name)
+	require.Nil(b, c.Bind().Body(d))
+	require.Equal(b, "john", d.Name)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Bind_Body_Form_Map -benchmem -count=4
@@ -1050,8 +1050,8 @@ func Benchmark_Bind_Body_Form_Map(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		_ = c.Bind().Body(&d)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Body(&d))
-	utils.AssertEqual(b, "john", d["name"])
+	require.Nil(b, c.Bind().Body(&d))
+	require.Equal(b, "john", d["name"])
 }
 
 // go test -run Test_Bind_URI
@@ -1070,8 +1070,8 @@ func Test_Bind_URI(t *testing.T) {
 		if err := c.Bind().URI(d); err != nil {
 			t.Fatal(err)
 		}
-		utils.AssertEqual(t, uint(111), d.UserID)
-		utils.AssertEqual(t, uint(222), d.RoleID)
+		require.Equal(t, uint(111), d.UserID)
+		require.Equal(t, uint(222), d.RoleID)
 		return nil
 	})
 	app.Test(httptest.NewRequest(MethodGet, "/test1/111/role/222", nil))
@@ -1089,8 +1089,8 @@ func Test_Bind_URI_Map(t *testing.T) {
 		if err := c.Bind().URI(&d); err != nil {
 			t.Fatal(err)
 		}
-		utils.AssertEqual(t, uint(111), d["userId"])
-		utils.AssertEqual(t, uint(222), d["roleId"])
+		require.Equal(t, uint(111), d["userId"])
+		require.Equal(t, uint(222), d["roleId"])
 		return nil
 	})
 	app.Test(httptest.NewRequest(MethodGet, "/test1/111/role/222", nil))
@@ -1125,10 +1125,10 @@ func Benchmark_Bind_URI(b *testing.B) {
 		c.Bind().URI(&res)
 	}
 
-	utils.AssertEqual(b, "john", res.Param1)
-	utils.AssertEqual(b, "doe", res.Param2)
-	utils.AssertEqual(b, "is", res.Param3)
-	utils.AssertEqual(b, "awesome", res.Param4)
+	require.Equal(b, "john", res.Param1)
+	require.Equal(b, "doe", res.Param2)
+	require.Equal(b, "is", res.Param3)
+	require.Equal(b, "awesome", res.Param4)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Bind_URI_Map -benchmem -count=4
@@ -1154,10 +1154,10 @@ func Benchmark_Bind_URI_Map(b *testing.B) {
 		c.Bind().URI(&res)
 	}
 
-	utils.AssertEqual(b, "john", res["param1"])
-	utils.AssertEqual(b, "doe", res["param2"])
-	utils.AssertEqual(b, "is", res["param3"])
-	utils.AssertEqual(b, "awesome", res["param4"])
+	require.Equal(b, "john", res["param1"])
+	require.Equal(b, "doe", res["param2"])
+	require.Equal(b, "is", res["param3"])
+	require.Equal(b, "awesome", res["param4"])
 }
 
 // go test -run Test_Bind_Cookie -v
@@ -1179,19 +1179,19 @@ func Test_Bind_Cookie(t *testing.T) {
 	c.Request().Header.SetCookie("Name", "John Doe")
 	c.Request().Header.SetCookie("Hobby", "golang,fiber")
 	q := new(Cookie)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(q))
-	utils.AssertEqual(t, 2, len(q.Hobby))
+	require.Nil(t, c.Bind().Cookie(q))
+	require.Equal(t, 2, len(q.Hobby))
 
 	c.Request().Header.DelCookie("hobby")
 	c.Request().Header.SetCookie("Hobby", "golang,fiber,go")
 	q = new(Cookie)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(q))
-	utils.AssertEqual(t, 3, len(q.Hobby))
+	require.Nil(t, c.Bind().Cookie(q))
+	require.Equal(t, 3, len(q.Hobby))
 
 	empty := new(Cookie)
 	c.Request().Header.DelCookie("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(empty))
-	utils.AssertEqual(t, 0, len(empty.Hobby))
+	require.Nil(t, c.Bind().Query(empty))
+	require.Equal(t, 0, len(empty.Hobby))
 
 	type Cookie2 struct {
 		Bool            bool
@@ -1215,22 +1215,22 @@ func Test_Bind_Cookie(t *testing.T) {
 	h2 := new(Cookie2)
 	h2.Bool = true
 	h2.Name = "hello world"
-	utils.AssertEqual(t, nil, c.Bind().Cookie(h2))
-	utils.AssertEqual(t, "go,fiber", h2.Hobby)
-	utils.AssertEqual(t, true, h2.Bool)
-	utils.AssertEqual(t, "Jane Doe", h2.Name) // check value get overwritten
-	utils.AssertEqual(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
+	require.Nil(t, c.Bind().Cookie(h2))
+	require.Equal(t, "go,fiber", h2.Hobby)
+	require.True(t, h2.Bool)
+	require.Equal(t, "Jane Doe", h2.Name) // check value get overwritten
+	require.Equal(t, []string{"milo", "coke", "pepsi"}, h2.FavouriteDrinks)
 	var nilSlice []string
-	utils.AssertEqual(t, nilSlice, h2.Empty)
-	utils.AssertEqual(t, []string{""}, h2.Alloc)
-	utils.AssertEqual(t, []int64{1}, h2.No)
+	require.Equal(t, nilSlice, h2.Empty)
+	require.Equal(t, []string{""}, h2.Alloc)
+	require.Equal(t, []int64{1}, h2.No)
 
 	type RequiredCookie struct {
 		Name string `cookie:"name,required"`
 	}
 	rh := new(RequiredCookie)
 	c.Request().Header.DelCookie("name")
-	utils.AssertEqual(t, "name is empty", c.Bind().Cookie(rh).Error())
+	require.Equal(t, "name is empty", c.Bind().Cookie(rh).Error())
 }
 
 // go test -run Test_Bind_Cookie_Map -v
@@ -1247,19 +1247,19 @@ func Test_Bind_Cookie_Map(t *testing.T) {
 	c.Request().Header.SetCookie("Name", "John Doe")
 	c.Request().Header.SetCookie("Hobby", "golang,fiber")
 	q := make(map[string][]string)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(&q))
-	utils.AssertEqual(t, 2, len(q["Hobby"]))
+	require.Nil(t, c.Bind().Cookie(&q))
+	require.Equal(t, 2, len(q["Hobby"]))
 
 	c.Request().Header.DelCookie("hobby")
 	c.Request().Header.SetCookie("Hobby", "golang,fiber,go")
 	q = make(map[string][]string)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(&q))
-	utils.AssertEqual(t, 3, len(q["Hobby"]))
+	require.Nil(t, c.Bind().Cookie(&q))
+	require.Equal(t, 3, len(q["Hobby"]))
 
 	empty := make(map[string][]string)
 	c.Request().Header.DelCookie("hobby")
-	utils.AssertEqual(t, nil, c.Bind().Query(&empty))
-	utils.AssertEqual(t, 0, len(empty["Hobby"]))
+	require.Nil(t, c.Bind().Query(&empty))
+	require.Equal(t, 0, len(empty["Hobby"]))
 }
 
 // go test -run Test_Bind_Cookie_WithSetParserDecoder -v
@@ -1302,20 +1302,20 @@ func Test_Bind_Cookie_WithSetParserDecoder(t *testing.T) {
 	c.Request().Header.SetCookie("Title", "CustomDateTest")
 	c.Request().Header.SetCookie("Body", "October")
 
-	utils.AssertEqual(t, nil, c.Bind().Cookie(r))
+	require.Nil(t, c.Bind().Cookie(r))
 	fmt.Println(r.Date, "q.Date")
-	utils.AssertEqual(t, "CustomDateTest", r.Title)
+	require.Equal(t, "CustomDateTest", r.Title)
 	date := fmt.Sprintf("%v", r.Date)
-	utils.AssertEqual(t, "{0 63753609600 <nil>}", date)
-	utils.AssertEqual(t, "October", r.Body)
+	require.Equal(t, "{0 63753609600 <nil>}", date)
+	require.Equal(t, "October", r.Body)
 
 	c.Request().Header.SetCookie("Title", "")
 	r = &NonRFCTimeInput{
 		Title: "Existing title",
 		Body:  "Existing Body",
 	}
-	utils.AssertEqual(t, nil, c.Bind().Cookie(r))
-	utils.AssertEqual(t, "", r.Title)
+	require.Nil(t, c.Bind().Cookie(r))
+	require.Equal(t, "", r.Title)
 }
 
 // go test -run Test_Bind_Cookie_Schema -v
@@ -1337,21 +1337,21 @@ func Test_Bind_Cookie_Schema(t *testing.T) {
 	c.Request().Header.SetCookie("Name", "tom")
 	c.Request().Header.SetCookie("Nested.Age", "10")
 	q := new(Cookie1)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(q))
+	require.Nil(t, c.Bind().Cookie(q))
 
 	c.Request().Header.DelCookie("Name")
 	q = new(Cookie1)
-	utils.AssertEqual(t, "Name is empty", c.Bind().Cookie(q).Error())
+	require.Equal(t, "Name is empty", c.Bind().Cookie(q).Error())
 
 	c.Request().Header.SetCookie("Name", "tom")
 	c.Request().Header.DelCookie("Nested.Age")
 	c.Request().Header.SetCookie("Nested.Agex", "10")
 	q = new(Cookie1)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(q))
+	require.Nil(t, c.Bind().Cookie(q))
 
 	c.Request().Header.DelCookie("Nested.Agex")
 	q = new(Cookie1)
-	utils.AssertEqual(t, "Nested is empty", c.Bind().Cookie(q).Error())
+	require.Equal(t, "Nested is empty", c.Bind().Cookie(q).Error())
 
 	c.Request().Header.DelCookie("Nested.Agex")
 	c.Request().Header.DelCookie("Name")
@@ -1367,17 +1367,17 @@ func Test_Bind_Cookie_Schema(t *testing.T) {
 	c.Request().Header.SetCookie("Nested.Age", "10")
 
 	h2 := new(Cookie2)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(h2))
+	require.Nil(t, c.Bind().Cookie(h2))
 
 	c.Request().Header.DelCookie("Name")
 	h2 = new(Cookie2)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(h2))
+	require.Nil(t, c.Bind().Cookie(h2))
 
 	c.Request().Header.DelCookie("Name")
 	c.Request().Header.DelCookie("Nested.Age")
 	c.Request().Header.SetCookie("Nested.Agex", "10")
 	h2 = new(Cookie2)
-	utils.AssertEqual(t, "Nested.Age is empty", c.Bind().Cookie(h2).Error())
+	require.Equal(t, "Nested.Age is empty", c.Bind().Cookie(h2).Error())
 
 	type Node struct {
 		Value int   `cookie:"Val,required"`
@@ -1386,22 +1386,22 @@ func Test_Bind_Cookie_Schema(t *testing.T) {
 	c.Request().Header.SetCookie("Val", "1")
 	c.Request().Header.SetCookie("Next.Val", "3")
 	n := new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(n))
-	utils.AssertEqual(t, 1, n.Value)
-	utils.AssertEqual(t, 3, n.Next.Value)
+	require.Nil(t, c.Bind().Cookie(n))
+	require.Equal(t, 1, n.Value)
+	require.Equal(t, 3, n.Next.Value)
 
 	c.Request().Header.DelCookie("Val")
 	n = new(Node)
-	utils.AssertEqual(t, "Val is empty", c.Bind().Cookie(n).Error())
+	require.Equal(t, "Val is empty", c.Bind().Cookie(n).Error())
 
 	c.Request().Header.SetCookie("Val", "3")
 	c.Request().Header.DelCookie("Next.Val")
 	c.Request().Header.SetCookie("Next.Value", "2")
 	n = new(Node)
 	n.Next = new(Node)
-	utils.AssertEqual(t, nil, c.Bind().Cookie(n))
-	utils.AssertEqual(t, 3, n.Value)
-	utils.AssertEqual(t, 0, n.Next.Value)
+	require.Nil(t, c.Bind().Cookie(n))
+	require.Equal(t, 3, n.Value)
+	require.Equal(t, 0, n.Next.Value)
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Cookie -benchmem -count=4
@@ -1428,7 +1428,7 @@ func Benchmark_Bind_Cookie(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Cookie(q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Cookie(q))
+	require.Nil(b, c.Bind().Cookie(q))
 }
 
 // go test -v  -run=^$ -bench=Benchmark_Bind_Cookie_Map -benchmem -count=4
@@ -1450,7 +1450,7 @@ func Benchmark_Bind_Cookie_Map(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		c.Bind().Cookie(&q)
 	}
-	utils.AssertEqual(b, nil, c.Bind().Cookie(&q))
+	require.Nil(b, c.Bind().Cookie(&q))
 }
 
 // custom binder for testing
@@ -1486,10 +1486,10 @@ func Test_Bind_CustomBinder(t *testing.T) {
 	c.Request().Header.SetContentLength(len(body))
 	d := new(Demo)
 
-	utils.AssertEqual(t, nil, c.Bind().Body(d))
-	utils.AssertEqual(t, nil, c.Bind().Custom("custom", d))
-	utils.AssertEqual(t, ErrCustomBinderNotFound, c.Bind().Custom("not_custom", d))
-	utils.AssertEqual(t, "john", d.Name)
+	require.Nil(t, c.Bind().Body(d))
+	require.Nil(t, c.Bind().Custom("custom", d))
+	require.Equal(t, ErrCustomBinderNotFound, c.Bind().Custom("not_custom", d))
+	require.Equal(t, "john", d.Name)
 }
 
 // go test -run Test_Bind_Must
@@ -1503,8 +1503,8 @@ func Test_Bind_Must(t *testing.T) {
 	rq := new(RequiredQuery)
 	c.Request().URI().SetQueryString("")
 	err := c.Bind().Must().Query(rq)
-	utils.AssertEqual(t, StatusBadRequest, c.Response().StatusCode())
-	utils.AssertEqual(t, "Bad request: name is empty", err.Error())
+	require.Equal(t, StatusBadRequest, c.Response().StatusCode())
+	require.Equal(t, "Bad request: name is empty", err.Error())
 }
 
 // simple struct validator for testing
@@ -1536,9 +1536,9 @@ func Test_Bind_StructValidator(t *testing.T) {
 
 	rq := new(simpleQuery)
 	c.Request().URI().SetQueryString("name=efe")
-	utils.AssertEqual(t, "you should have entered right name!", c.Bind().Query(rq).Error())
+	require.Equal(t, "you should have entered right name!", c.Bind().Query(rq).Error())
 
 	rq = new(simpleQuery)
 	c.Request().URI().SetQueryString("name=john")
-	utils.AssertEqual(t, nil, c.Bind().Query(rq))
+	require.Nil(t, c.Bind().Query(rq))
 }

binder/mapping_test.go

@@ -4,28 +4,28 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_EqualFieldType(t *testing.T) {
 	var out int
-	utils.AssertEqual(t, false, equalFieldType(&out, reflect.Int, "key"))
+	require.False(t, equalFieldType(&out, reflect.Int, "key"))
 
 	var dummy struct{ f string }
-	utils.AssertEqual(t, false, equalFieldType(&dummy, reflect.String, "key"))
+	require.False(t, equalFieldType(&dummy, reflect.String, "key"))
 
 	var dummy2 struct{ f string }
-	utils.AssertEqual(t, false, equalFieldType(&dummy2, reflect.String, "f"))
+	require.False(t, equalFieldType(&dummy2, reflect.String, "f"))
 
 	var user struct {
 		Name    string
 		Address string `query:"address"`
 		Age     int    `query:"AGE"`
 	}
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.String, "name"))
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.String, "Name"))
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.String, "address"))
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.String, "Address"))
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.Int, "AGE"))
-	utils.AssertEqual(t, true, equalFieldType(&user, reflect.Int, "age"))
+	require.True(t, equalFieldType(&user, reflect.String, "name"))
+	require.True(t, equalFieldType(&user, reflect.String, "Name"))
+	require.True(t, equalFieldType(&user, reflect.String, "address"))
+	require.True(t, equalFieldType(&user, reflect.String, "Address"))
+	require.True(t, equalFieldType(&user, reflect.Int, "AGE"))
+	require.True(t, equalFieldType(&user, reflect.Int, "age"))
 }

client_test.go

@@ -19,7 +19,7 @@ import (
 	"encoding/json"
 
 	"github.com/gofiber/fiber/v3/internal/tlstest"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp/fasthttputil"
 )
 
@@ -34,7 +34,7 @@ func Test_Client_Invalid_URL(t *testing.T) {
 		return c.SendString(c.Hostname())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	a := Get("http://example.com\r\n\r\nGET /\r\n\r\n")
 
@@ -42,9 +42,9 @@ func Test_Client_Invalid_URL(t *testing.T) {
 
 	_, body, errs := a.String()
 
-	utils.AssertEqual(t, "", body)
-	utils.AssertEqual(t, 1, len(errs))
-	utils.AssertEqual(t, "missing required Host header in request", errs[0].Error())
+	require.Equal(t, "", body)
+	require.Equal(t, 1, len(errs))
+	require.Equal(t, "missing required Host header in request", errs[0].Error())
 }
 
 func Test_Client_Unsupported_Protocol(t *testing.T) {
@@ -54,10 +54,11 @@ func Test_Client_Unsupported_Protocol(t *testing.T) {
 
 	_, body, errs := a.String()
 
-	utils.AssertEqual(t, "", body)
-	utils.AssertEqual(t, 1, len(errs))
-	utils.AssertEqual(t, `unsupported protocol "ftp". http and https are supported`,
+	require.Equal(t, "", body)
+	require.Equal(t, 1, len(errs))
+	require.Equal(t, `unsupported protocol "ftp". http and https are supported`,
 		errs[0].Error())
+
 }
 
 func Test_Client_Get(t *testing.T) {
@@ -71,7 +72,7 @@ func Test_Client_Get(t *testing.T) {
 		return c.SendString(c.Hostname())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		a := Get("http://example.com")
@@ -80,9 +81,9 @@ func Test_Client_Get(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "example.com", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "example.com", body)
+		require.Equal(t, 0, len(errs))
 	}
 }
 
@@ -97,7 +98,7 @@ func Test_Client_Head(t *testing.T) {
 		return c.SendString(c.Hostname())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		a := Head("http://example.com")
@@ -106,9 +107,9 @@ func Test_Client_Head(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "", body)
+		require.Equal(t, 0, len(errs))
 	}
 }
 
@@ -124,7 +125,7 @@ func Test_Client_Post(t *testing.T) {
 			SendString(c.FormValue("foo"))
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		args := AcquireArgs()
@@ -138,9 +139,9 @@ func Test_Client_Post(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusCreated, code)
-		utils.AssertEqual(t, "bar", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusCreated, code)
+		require.Equal(t, "bar", body)
+		require.Equal(t, 0, len(errs))
 
 		ReleaseArgs(args)
 	}
@@ -157,7 +158,7 @@ func Test_Client_Put(t *testing.T) {
 		return c.SendString(c.FormValue("foo"))
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		args := AcquireArgs()
@@ -171,9 +172,9 @@ func Test_Client_Put(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "bar", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "bar", body)
+		require.Equal(t, 0, len(errs))
 
 		ReleaseArgs(args)
 	}
@@ -190,7 +191,7 @@ func Test_Client_Patch(t *testing.T) {
 		return c.SendString(c.FormValue("foo"))
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		args := AcquireArgs()
@@ -204,9 +205,9 @@ func Test_Client_Patch(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "bar", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "bar", body)
+		require.Equal(t, 0, len(errs))
 
 		ReleaseArgs(args)
 	}
@@ -224,7 +225,7 @@ func Test_Client_Delete(t *testing.T) {
 			SendString("deleted")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		args := AcquireArgs()
@@ -235,9 +236,9 @@ func Test_Client_Delete(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusNoContent, code)
-		utils.AssertEqual(t, "", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusNoContent, code)
+		require.Equal(t, "", body)
+		require.Equal(t, 0, len(errs))
 
 		ReleaseArgs(args)
 	}
@@ -254,7 +255,7 @@ func Test_Client_UserAgent(t *testing.T) {
 		return c.Send(c.Request().Header.UserAgent())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	t.Run("default", func(t *testing.T) {
 		for i := 0; i < 5; i++ {
@@ -264,9 +265,9 @@ func Test_Client_UserAgent(t *testing.T) {
 
 			code, body, errs := a.String()
 
-			utils.AssertEqual(t, StatusOK, code)
-			utils.AssertEqual(t, defaultUserAgent, body)
-			utils.AssertEqual(t, 0, len(errs))
+			require.Equal(t, StatusOK, code)
+			require.Equal(t, defaultUserAgent, body)
+			require.Equal(t, 0, len(errs))
 		}
 	})
 
@@ -281,9 +282,9 @@ func Test_Client_UserAgent(t *testing.T) {
 
 			code, body, errs := a.String()
 
-			utils.AssertEqual(t, StatusOK, code)
-			utils.AssertEqual(t, "ua", body)
-			utils.AssertEqual(t, 0, len(errs))
+			require.Equal(t, StatusOK, code)
+			require.Equal(t, "ua", body)
+			require.Equal(t, 0, len(errs))
 			ReleaseClient(c)
 		}
 	})
@@ -396,21 +397,21 @@ func Test_Client_Agent_Host(t *testing.T) {
 		return c.SendString(c.Hostname())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	a := Get("http://1.1.1.1:8080").
 		Host("example.com").
 		HostBytes([]byte("example.com"))
 
-	utils.AssertEqual(t, "1.1.1.1:8080", a.HostClient.Addr)
+	require.Equal(t, "1.1.1.1:8080", a.HostClient.Addr)
 
 	a.HostClient.Dial = func(addr string) (net.Conn, error) { return ln.Dial() }
 
 	code, body, errs := a.String()
 
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "example.com", body)
-	utils.AssertEqual(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "example.com", body)
+	require.Equal(t, 0, len(errs))
 }
 
 func Test_Client_Agent_QueryString(t *testing.T) {
@@ -432,7 +433,7 @@ func Test_Client_Agent_BasicAuth(t *testing.T) {
 		auth := c.Get(HeaderAuthorization)
 		// Decode the header contents
 		raw, err := base64.StdEncoding.DecodeString(auth[6:])
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		return c.Send(raw)
 	}
@@ -492,7 +493,7 @@ func Test_Client_Agent_Custom_Response(t *testing.T) {
 		return c.SendString("custom")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		a := AcquireAgent()
@@ -502,17 +503,17 @@ func Test_Client_Agent_Custom_Response(t *testing.T) {
 		req.Header.SetMethod(MethodGet)
 		req.SetRequestURI("http://example.com")
 
-		utils.AssertEqual(t, nil, a.Parse())
+		require.Nil(t, a.Parse())
 
 		a.HostClient.Dial = func(addr string) (net.Conn, error) { return ln.Dial() }
 
 		code, body, errs := a.SetResponse(resp).
 			String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "custom", body)
-		utils.AssertEqual(t, "custom", string(resp.Body()))
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "custom", body)
+		require.Equal(t, "custom", string(resp.Body()))
+		require.Equal(t, 0, len(errs))
 
 		ReleaseResponse(resp)
 	}
@@ -529,7 +530,7 @@ func Test_Client_Agent_Dest(t *testing.T) {
 		return c.SendString("dest")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	t.Run("small dest", func(t *testing.T) {
 		dest := []byte("de")
@@ -540,10 +541,10 @@ func Test_Client_Agent_Dest(t *testing.T) {
 
 		code, body, errs := a.Dest(dest[:0]).String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "dest", body)
-		utils.AssertEqual(t, "de", string(dest))
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "dest", body)
+		require.Equal(t, "de", string(dest))
+		require.Equal(t, 0, len(errs))
 	})
 
 	t.Run("enough dest", func(t *testing.T) {
@@ -555,10 +556,10 @@ func Test_Client_Agent_Dest(t *testing.T) {
 
 		code, body, errs := a.Dest(dest[:0]).String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "dest", body)
-		utils.AssertEqual(t, "destar", string(dest))
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "dest", body)
+		require.Equal(t, "destar", string(dest))
+		require.Equal(t, 0, len(errs))
 	})
 }
 
@@ -593,7 +594,7 @@ func Test_Client_Agent_RetryIf(t *testing.T) {
 
 	app := New(Config{DisableStartupMessage: true})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	a := Post("http://example.com").
 		RetryIf(func(req *Request) bool {
@@ -618,13 +619,13 @@ func Test_Client_Agent_RetryIf(t *testing.T) {
 	}
 
 	_, _, errs := a.String()
-	utils.AssertEqual(t, dialsCount, 4)
-	utils.AssertEqual(t, 0, len(errs))
+	require.Equal(t, dialsCount, 4)
+	require.Equal(t, 0, len(errs))
 }
 
 func Test_Client_Agent_Json(t *testing.T) {
 	handler := func(c Ctx) error {
-		utils.AssertEqual(t, MIMEApplicationJSON, string(c.Request().Header.ContentType()))
+		require.Equal(t, MIMEApplicationJSON, string(c.Request().Header.ContentType()))
 
 		return c.Send(c.Request().Body())
 	}
@@ -643,14 +644,14 @@ func Test_Client_Agent_Json_Error(t *testing.T) {
 
 	_, body, errs := a.String()
 
-	utils.AssertEqual(t, "", body)
-	utils.AssertEqual(t, 1, len(errs))
-	utils.AssertEqual(t, "json: unsupported type: complex128", errs[0].Error())
+	require.Equal(t, "", body)
+	require.Equal(t, 1, len(errs))
+	require.Equal(t, "json: unsupported type: complex128", errs[0].Error())
 }
 
 func Test_Client_Agent_XML(t *testing.T) {
 	handler := func(c Ctx) error {
-		utils.AssertEqual(t, MIMEApplicationXML, string(c.Request().Header.ContentType()))
+		require.Equal(t, MIMEApplicationXML, string(c.Request().Header.ContentType()))
 
 		return c.Send(c.Request().Body())
 	}
@@ -668,14 +669,14 @@ func Test_Client_Agent_XML_Error(t *testing.T) {
 
 	_, body, errs := a.String()
 
-	utils.AssertEqual(t, "", body)
-	utils.AssertEqual(t, 1, len(errs))
-	utils.AssertEqual(t, "xml: unsupported type: complex128", errs[0].Error())
+	require.Equal(t, "", body)
+	require.Equal(t, 1, len(errs))
+	require.Equal(t, "xml: unsupported type: complex128", errs[0].Error())
 }
 
 func Test_Client_Agent_Form(t *testing.T) {
 	handler := func(c Ctx) error {
-		utils.AssertEqual(t, MIMEApplicationForm, string(c.Request().Header.ContentType()))
+		require.Equal(t, MIMEApplicationForm, string(c.Request().Header.ContentType()))
 
 		return c.Send(c.Request().Body())
 	}
@@ -701,16 +702,16 @@ func Test_Client_Agent_MultipartForm(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true})
 
 	app.Post("/", func(c Ctx) error {
-		utils.AssertEqual(t, "multipart/form-data; boundary=myBoundary", c.Get(HeaderContentType))
+		require.Equal(t, "multipart/form-data; boundary=myBoundary", c.Get(HeaderContentType))
 
 		mf, err := c.MultipartForm()
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, "bar", mf.Value["foo"][0])
+		require.NoError(t, err)
+		require.Equal(t, "bar", mf.Value["foo"][0])
 
 		return c.Send(c.Request().Body())
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	args := AcquireArgs()
 
@@ -724,9 +725,9 @@ func Test_Client_Agent_MultipartForm(t *testing.T) {
 
 	code, body, errs := a.String()
 
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "--myBoundary\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\nbar\r\n--myBoundary--\r\n", body)
-	utils.AssertEqual(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "--myBoundary\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\nbar\r\n--myBoundary--\r\n", body)
+	require.Equal(t, 0, len(errs))
 	ReleaseArgs(args)
 }
 
@@ -744,7 +745,7 @@ func Test_Client_Agent_MultipartForm_Errors(t *testing.T) {
 	a.FileData(ff1, ff2).
 		MultipartForm(args)
 
-	utils.AssertEqual(t, 4, len(a.errs))
+	require.Equal(t, 4, len(a.errs))
 	ReleaseArgs(args)
 }
 
@@ -756,31 +757,31 @@ func Test_Client_Agent_MultipartForm_SendFiles(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true})
 
 	app.Post("/", func(c Ctx) error {
-		utils.AssertEqual(t, "multipart/form-data; boundary=myBoundary", c.Get(HeaderContentType))
+		require.Equal(t, "multipart/form-data; boundary=myBoundary", c.Get(HeaderContentType))
 
 		fh1, err := c.FormFile("field1")
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, fh1.Filename, "name")
+		require.NoError(t, err)
+		require.Equal(t, fh1.Filename, "name")
 		buf := make([]byte, fh1.Size)
 		f, err := fh1.Open()
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 		defer func() { _ = f.Close() }()
 		_, err = f.Read(buf)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, "form file", string(buf))
+		require.NoError(t, err)
+		require.Equal(t, "form file", string(buf))
 
 		fh2, err := c.FormFile("index")
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 		checkFormFile(t, fh2, ".github/testdata/index.html")
 
 		fh3, err := c.FormFile("file3")
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 		checkFormFile(t, fh3, ".github/testdata/index.tmpl")
 
 		return c.SendString("multipart form files")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	for i := 0; i < 5; i++ {
 		ff := AcquireFormFile()
@@ -798,9 +799,9 @@ func Test_Client_Agent_MultipartForm_SendFiles(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, "multipart form files", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, "multipart form files", body)
+		require.Equal(t, 0, len(errs))
 
 		ReleaseFormFile(ff)
 	}
@@ -810,18 +811,18 @@ func checkFormFile(t *testing.T, fh *multipart.FileHeader, filename string) {
 	t.Helper()
 
 	basename := filepath.Base(filename)
-	utils.AssertEqual(t, fh.Filename, basename)
+	require.Equal(t, fh.Filename, basename)
 
 	b1, err := os.ReadFile(filename)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	b2 := make([]byte, fh.Size)
 	f, err := fh.Open()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	defer func() { _ = f.Close() }()
 	_, err = f.Read(b2)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, b1, b2)
+	require.NoError(t, err)
+	require.Equal(t, b1, b2)
 }
 
 func Test_Client_Agent_Multipart_Random_Boundary(t *testing.T) {
@@ -832,7 +833,7 @@ func Test_Client_Agent_Multipart_Random_Boundary(t *testing.T) {
 
 	reg := regexp.MustCompile(`multipart/form-data; boundary=\w{30}`)
 
-	utils.AssertEqual(t, true, reg.Match(a.req.Header.Peek(HeaderContentType)))
+	require.True(t, reg.Match(a.req.Header.Peek(HeaderContentType)))
 }
 
 func Test_Client_Agent_Multipart_Invalid_Boundary(t *testing.T) {
@@ -842,8 +843,8 @@ func Test_Client_Agent_Multipart_Invalid_Boundary(t *testing.T) {
 		Boundary("*").
 		MultipartForm(nil)
 
-	utils.AssertEqual(t, 1, len(a.errs))
-	utils.AssertEqual(t, "mime: invalid boundary character", a.errs[0].Error())
+	require.Equal(t, 1, len(a.errs))
+	require.Equal(t, "mime: invalid boundary character", a.errs[0].Error())
 }
 
 func Test_Client_Agent_SendFile_Error(t *testing.T) {
@@ -852,8 +853,8 @@ func Test_Client_Agent_SendFile_Error(t *testing.T) {
 	a := Post("http://example.com").
 		SendFile("non-exist-file!", "")
 
-	utils.AssertEqual(t, 1, len(a.errs))
-	utils.AssertEqual(t, true, strings.Contains(a.errs[0].Error(), "open non-exist-file!"))
+	require.Equal(t, 1, len(a.errs))
+	require.True(t, strings.Contains(a.errs[0].Error(), "open non-exist-file!"))
 }
 
 func Test_Client_Debug(t *testing.T) {
@@ -871,12 +872,12 @@ func Test_Client_Debug(t *testing.T) {
 
 	str := output.String()
 
-	utils.AssertEqual(t, true, strings.Contains(str, "Connected to example.com(pipe)"))
-	utils.AssertEqual(t, true, strings.Contains(str, "GET / HTTP/1.1"))
-	utils.AssertEqual(t, true, strings.Contains(str, "User-Agent: fiber"))
-	utils.AssertEqual(t, true, strings.Contains(str, "Host: example.com\r\n\r\n"))
-	utils.AssertEqual(t, true, strings.Contains(str, "HTTP/1.1 200 OK"))
-	utils.AssertEqual(t, true, strings.Contains(str, "Content-Type: text/plain; charset=utf-8\r\nContent-Length: 5\r\n\r\ndebug"))
+	require.True(t, strings.Contains(str, "Connected to example.com(pipe)"))
+	require.True(t, strings.Contains(str, "GET / HTTP/1.1"))
+	require.True(t, strings.Contains(str, "User-Agent: fiber"))
+	require.True(t, strings.Contains(str, "Host: example.com\r\n\r\n"))
+	require.True(t, strings.Contains(str, "HTTP/1.1 200 OK"))
+	require.True(t, strings.Contains(str, "Content-Type: text/plain; charset=utf-8\r\nContent-Length: 5\r\n\r\ndebug"))
 }
 
 func Test_Client_Agent_Timeout(t *testing.T) {
@@ -891,7 +892,7 @@ func Test_Client_Agent_Timeout(t *testing.T) {
 		return c.SendString("timeout")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	a := Get("http://example.com").
 		Timeout(time.Millisecond * 50)
@@ -900,9 +901,9 @@ func Test_Client_Agent_Timeout(t *testing.T) {
 
 	_, body, errs := a.String()
 
-	utils.AssertEqual(t, "", body)
-	utils.AssertEqual(t, 1, len(errs))
-	utils.AssertEqual(t, "timeout", errs[0].Error())
+	require.Equal(t, "", body)
+	require.Equal(t, 1, len(errs))
+	require.Equal(t, "timeout", errs[0].Error())
 }
 
 func Test_Client_Agent_Reuse(t *testing.T) {
@@ -916,7 +917,7 @@ func Test_Client_Agent_Reuse(t *testing.T) {
 		return c.SendString("reuse")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	a := Get("http://example.com").
 		Reuse()
@@ -925,29 +926,29 @@ func Test_Client_Agent_Reuse(t *testing.T) {
 
 	code, body, errs := a.String()
 
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "reuse", body)
-	utils.AssertEqual(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "reuse", body)
+	require.Equal(t, 0, len(errs))
 
 	code, body, errs = a.String()
 
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "reuse", body)
-	utils.AssertEqual(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "reuse", body)
+	require.Equal(t, 0, len(errs))
 }
 
 func Test_Client_Agent_InsecureSkipVerify(t *testing.T) {
 	t.Parallel()
 
 	cer, err := tls.LoadX509KeyPair("./.github/testdata/ssl.pem", "./.github/testdata/ssl.key")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	serverTLSConf := &tls.Config{
 		Certificates: []tls.Certificate{cer},
 	}
 
 	ln, err := net.Listen(NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln = tls.NewListener(ln, serverTLSConf)
 
@@ -957,26 +958,26 @@ func Test_Client_Agent_InsecureSkipVerify(t *testing.T) {
 		return c.SendString("ignore tls")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	code, body, errs := Get("https://" + ln.Addr().String()).
 		InsecureSkipVerify().
 		InsecureSkipVerify().
 		String()
 
-	utils.AssertEqual(t, 0, len(errs))
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "ignore tls", body)
+	require.Equal(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "ignore tls", body)
 }
 
 func Test_Client_Agent_TLS(t *testing.T) {
 	t.Parallel()
 
 	serverTLSConf, clientTLSConf, err := tlstest.GetTLSConfigs()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln, err := net.Listen(NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln = tls.NewListener(ln, serverTLSConf)
 
@@ -986,15 +987,15 @@ func Test_Client_Agent_TLS(t *testing.T) {
 		return c.SendString("tls")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	code, body, errs := Get("https://" + ln.Addr().String()).
 		TLSConfig(clientTLSConf).
 		String()
 
-	utils.AssertEqual(t, 0, len(errs))
-	utils.AssertEqual(t, StatusOK, code)
-	utils.AssertEqual(t, "tls", body)
+	require.Equal(t, 0, len(errs))
+	require.Equal(t, StatusOK, code)
+	require.Equal(t, "tls", body)
 }
 
 func Test_Client_Agent_MaxRedirectsCount(t *testing.T) {
@@ -1014,7 +1015,7 @@ func Test_Client_Agent_MaxRedirectsCount(t *testing.T) {
 		return c.SendString("redirect")
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	t.Run("success", func(t *testing.T) {
 		a := Get("http://example.com?foo").
@@ -1024,9 +1025,9 @@ func Test_Client_Agent_MaxRedirectsCount(t *testing.T) {
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, 200, code)
-		utils.AssertEqual(t, "redirect", body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, 200, code)
+		require.Equal(t, "redirect", body)
+		require.Equal(t, 0, len(errs))
 	})
 
 	t.Run("error", func(t *testing.T) {
@@ -1037,9 +1038,9 @@ func Test_Client_Agent_MaxRedirectsCount(t *testing.T) {
 
 		_, body, errs := a.String()
 
-		utils.AssertEqual(t, "", body)
-		utils.AssertEqual(t, 1, len(errs))
-		utils.AssertEqual(t, "too many redirects detected when doing the request", errs[0].Error())
+		require.Equal(t, "", body)
+		require.Equal(t, 1, len(errs))
+		require.Equal(t, "too many redirects detected when doing the request", errs[0].Error())
 	})
 }
 
@@ -1058,7 +1059,7 @@ func Test_Client_Agent_Struct(t *testing.T) {
 		return c.SendString(`{"success"`)
 	})
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	t.Run("success", func(t *testing.T) {
 		t.Parallel()
@@ -1071,10 +1072,10 @@ func Test_Client_Agent_Struct(t *testing.T) {
 
 		code, body, errs := a.Struct(&d)
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, `{"success":true}`, string(body))
-		utils.AssertEqual(t, 0, len(errs))
-		utils.AssertEqual(t, true, d.Success)
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, `{"success":true}`, string(body))
+		require.Equal(t, 0, len(errs))
+		require.True(t, d.Success)
 	})
 
 	t.Run("pre error", func(t *testing.T) {
@@ -1087,10 +1088,10 @@ func Test_Client_Agent_Struct(t *testing.T) {
 		var d data
 		_, body, errs := a.Struct(&d)
 
-		utils.AssertEqual(t, "", string(body))
-		utils.AssertEqual(t, 1, len(errs))
-		utils.AssertEqual(t, "pre errors", errs[0].Error())
-		utils.AssertEqual(t, false, d.Success)
+		require.Equal(t, "", string(body))
+		require.Equal(t, 1, len(errs))
+		require.Equal(t, "pre errors", errs[0].Error())
+		require.False(t, d.Success)
 	})
 
 	t.Run("error", func(t *testing.T) {
@@ -1102,10 +1103,10 @@ func Test_Client_Agent_Struct(t *testing.T) {
 
 		code, body, errs := a.JSONDecoder(json.Unmarshal).Struct(&d)
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, `{"success"`, string(body))
-		utils.AssertEqual(t, 1, len(errs))
-		utils.AssertEqual(t, "unexpected end of JSON input", errs[0].Error())
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, `{"success"`, string(body))
+		require.Equal(t, 1, len(errs))
+		require.Equal(t, "unexpected end of JSON input", errs[0].Error())
 	})
 }
 
@@ -1114,12 +1115,12 @@ func Test_Client_Agent_Parse(t *testing.T) {
 
 	a := Get("https://example.com:10443")
 
-	utils.AssertEqual(t, nil, a.Parse())
+	require.Nil(t, a.Parse())
 }
 
 func Test_AddMissingPort_TLS(t *testing.T) {
 	addr := addMissingPort("example.com", true)
-	utils.AssertEqual(t, "example.com:443", addr)
+	require.Equal(t, "example.com:443", addr)
 }
 
 func testAgent(t *testing.T, handler Handler, wrapAgent func(agent *Agent), excepted string, count ...int) {
@@ -1131,7 +1132,7 @@ func testAgent(t *testing.T, handler Handler, wrapAgent func(agent *Agent), exce
 
 	app.Get("/", handler)
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	c := 1
 	if len(count) > 0 {
@@ -1147,9 +1148,9 @@ func testAgent(t *testing.T, handler Handler, wrapAgent func(agent *Agent), exce
 
 		code, body, errs := a.String()
 
-		utils.AssertEqual(t, StatusOK, code)
-		utils.AssertEqual(t, excepted, body)
-		utils.AssertEqual(t, 0, len(errs))
+		require.Equal(t, StatusOK, code)
+		require.Equal(t, excepted, body)
+		require.Equal(t, 0, len(errs))
 	}
 }
 

error_test.go

@@ -7,61 +7,61 @@ import (
 	jerrors "encoding/json"
 
 	"github.com/gofiber/fiber/v3/internal/schema"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func TestConversionError(t *testing.T) {
 	ok := errors.As(ConversionError{}, &schema.ConversionError{})
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestUnknownKeyError(t *testing.T) {
 	ok := errors.As(UnknownKeyError{}, &schema.UnknownKeyError{})
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestEmptyFieldError(t *testing.T) {
 	ok := errors.As(EmptyFieldError{}, &schema.EmptyFieldError{})
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestMultiError(t *testing.T) {
 	ok := errors.As(MultiError{}, &schema.MultiError{})
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestInvalidUnmarshalError(t *testing.T) {
 	var e *jerrors.InvalidUnmarshalError
 	ok := errors.As(&InvalidUnmarshalError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestMarshalerError(t *testing.T) {
 	var e *jerrors.MarshalerError
 	ok := errors.As(&MarshalerError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestSyntaxError(t *testing.T) {
 	var e *jerrors.SyntaxError
 	ok := errors.As(&SyntaxError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestUnmarshalTypeError(t *testing.T) {
 	var e *jerrors.UnmarshalTypeError
 	ok := errors.As(&UnmarshalTypeError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestUnsupportedTypeError(t *testing.T) {
 	var e *jerrors.UnsupportedTypeError
 	ok := errors.As(&UnsupportedTypeError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func TestUnsupportedValeError(t *testing.T) {
 	var e *jerrors.UnsupportedValueError
 	ok := errors.As(&UnsupportedValueError{}, &e)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }

go.mod

@@ -7,6 +7,7 @@ require (
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.16
 	github.com/savsgio/dictpool v0.0.0-20220406081701-03de5edb2e6d
+	github.com/stretchr/testify v1.8.0
 	github.com/tinylib/msgp v1.1.6
 	github.com/valyala/bytebufferpool v1.0.0
 	github.com/valyala/fasthttp v1.39.0
@@ -15,9 +16,12 @@ require (
 
 require (
 	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/klauspost/compress v1.15.9 // indirect
 	github.com/philhofer/fwd v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/savsgio/gotils v0.0.0-20220530130905-52f3993e8d6d // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
 	golang.org/x/sys v0.0.0-20220817070843-5a390386f1f2 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,5 +1,8 @@
 github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
 github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/klauspost/compress v1.15.0/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
@@ -11,11 +14,18 @@ github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peK
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/philhofer/fwd v1.1.1 h1:GdGcTjf5RNAxwS4QLsiMzJYj5KEvPJD3Abr261yRQXQ=
 github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/savsgio/dictpool v0.0.0-20220406081701-03de5edb2e6d h1:ICMDEgNgR5xFW6ZDeMKTtmh07YiLr7GkDw897I2DwKg=
 github.com/savsgio/dictpool v0.0.0-20220406081701-03de5edb2e6d/go.mod h1:jrsy/bTK2n5uybo7bAvtLGzmuzAbxp+nKS8bzgrZURE=
 github.com/savsgio/gotils v0.0.0-20220401102855-e56b59f40436/go.mod h1:Gy+0tqhJvgGlqnTF8CVGP0AaGRjwBtXs/a5PA0Y3+A4=
 github.com/savsgio/gotils v0.0.0-20220530130905-52f3993e8d6d h1:Q+gqLBOPkFGHyCJxXMRqtUgUbTjI8/Ze8vu8GGyNFwo=
 github.com/savsgio/gotils v0.0.0-20220530130905-52f3993e8d6d/go.mod h1:Gy+0tqhJvgGlqnTF8CVGP0AaGRjwBtXs/a5PA0Y3+A4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/tinylib/msgp v1.1.6 h1:i+SbKraHhnrf9M5MYmvQhFnbLhAXSDWF8WWsuyRdocw=
 github.com/tinylib/msgp v1.1.6/go.mod h1:75BAfg2hauQhs3qedfdDZmWAPcFMAvJE5b9rGOMufyw=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
@@ -62,3 +72,8 @@ golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

helpers_test.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -20,7 +21,7 @@ func Test_Utils_UniqueRouteStack(t *testing.T) {
 	route1 := &Route{}
 	route2 := &Route{}
 	route3 := &Route{}
-	utils.AssertEqual(
+	require.Equal(
 		t,
 		[]*Route{
 			route1,
@@ -40,32 +41,32 @@ func Test_Utils_UniqueRouteStack(t *testing.T) {
 			route1,
 			route2,
 			route3,
-		}),
-	)
+		}))
+
 }
 
 func Test_Utils_getGroupPath(t *testing.T) {
 	t.Parallel()
 	res := getGroupPath("/v1", "/")
-	utils.AssertEqual(t, "/v1", res)
+	require.Equal(t, "/v1", res)
 
 	res = getGroupPath("/v1/", "/")
-	utils.AssertEqual(t, "/v1/", res)
+	require.Equal(t, "/v1/", res)
 
 	res = getGroupPath("/v1", "/")
-	utils.AssertEqual(t, "/v1", res)
+	require.Equal(t, "/v1", res)
 
 	res = getGroupPath("/", "/")
-	utils.AssertEqual(t, "/", res)
+	require.Equal(t, "/", res)
 
 	res = getGroupPath("/v1/api/", "/")
-	utils.AssertEqual(t, "/v1/api/", res)
+	require.Equal(t, "/v1/api/", res)
 
 	res = getGroupPath("/v1/api", "group")
-	utils.AssertEqual(t, "/v1/api/group", res)
+	require.Equal(t, "/v1/api/group", res)
 
 	res = getGroupPath("/v1/api", "")
-	utils.AssertEqual(t, "/v1/api", res)
+	require.Equal(t, "/v1/api", res)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Utils_ -benchmem -count=3
@@ -78,7 +79,7 @@ func Benchmark_Utils_getGroupPath(b *testing.B) {
 		_ = getGroupPath("/v1", "/api")
 		res = getGroupPath("/v1", "/api/register/:project")
 	}
-	utils.AssertEqual(b, "/v1/api/register/:project", res)
+	require.Equal(b, "/v1/api/register/:project", res)
 }
 
 func Benchmark_Utils_Unescape(b *testing.B) {
@@ -92,7 +93,7 @@ func Benchmark_Utils_Unescape(b *testing.B) {
 		unescaped = utils.UnsafeString(pathBytes)
 	}
 
-	utils.AssertEqual(b, "/créer", unescaped)
+	require.Equal(b, "/créer", unescaped)
 }
 
 func Test_Utils_Parse_Address(t *testing.T) {
@@ -106,22 +107,22 @@ func Test_Utils_Parse_Address(t *testing.T) {
 
 	for _, c := range testCases {
 		host, port := parseAddr(c.addr)
-		utils.AssertEqual(t, c.host, host, "addr host")
-		utils.AssertEqual(t, c.port, port, "addr port")
+		require.Equal(t, c.host, host, "addr host")
+		require.Equal(t, c.port, port, "addr port")
 	}
 }
 
 func Test_Utils_GetOffset(t *testing.T) {
-	utils.AssertEqual(t, "", getOffer("hello"))
-	utils.AssertEqual(t, "1", getOffer("", "1"))
-	utils.AssertEqual(t, "", getOffer("2", "1"))
+	require.Equal(t, "", getOffer("hello"))
+	require.Equal(t, "1", getOffer("", "1"))
+	require.Equal(t, "", getOffer("2", "1"))
 }
 
 func Test_Utils_TestConn_Deadline(t *testing.T) {
 	conn := &testConn{}
-	utils.AssertEqual(t, nil, conn.SetDeadline(time.Time{}))
-	utils.AssertEqual(t, nil, conn.SetReadDeadline(time.Time{}))
-	utils.AssertEqual(t, nil, conn.SetWriteDeadline(time.Time{}))
+	require.Nil(t, conn.SetDeadline(time.Time{}))
+	require.Nil(t, conn.SetReadDeadline(time.Time{}))
+	require.Nil(t, conn.SetWriteDeadline(time.Time{}))
 }
 
 func Test_Utils_IsNoCache(t *testing.T) {
@@ -141,8 +142,9 @@ func Test_Utils_IsNoCache(t *testing.T) {
 
 	for _, c := range testCases {
 		ok := isNoCache(c.string)
-		utils.AssertEqual(t, c.bool, ok,
+		require.Equal(t, c.bool, ok,
 			fmt.Sprintf("want %t, got isNoCache(%s)=%t", c.bool, c.string, ok))
+
 	}
 }
 
@@ -157,48 +159,48 @@ func Benchmark_Utils_IsNoCache(b *testing.B) {
 		_ = isNoCache("no-cache, public")
 		ok = isNoCache("max-age=30, no-cache,public")
 	}
-	utils.AssertEqual(b, true, ok)
+	require.True(b, ok)
 }
 
 func Test_Utils_lnMetadata(t *testing.T) {
 	t.Run("closed listen", func(t *testing.T) {
 		ln, err := net.Listen(NetworkTCP, ":0")
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
-		utils.AssertEqual(t, nil, ln.Close())
+		require.Nil(t, ln.Close())
 
 		addr, config := lnMetadata(NetworkTCP, ln)
 
-		utils.AssertEqual(t, ln.Addr().String(), addr)
-		utils.AssertEqual(t, true, config == nil)
+		require.Equal(t, ln.Addr().String(), addr)
+		require.True(t, config == nil)
 	})
 
 	t.Run("non tls", func(t *testing.T) {
 		ln, err := net.Listen(NetworkTCP, ":0")
 
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		addr, config := lnMetadata(NetworkTCP4, ln)
 
-		utils.AssertEqual(t, ln.Addr().String(), addr)
-		utils.AssertEqual(t, true, config == nil)
+		require.Equal(t, ln.Addr().String(), addr)
+		require.True(t, config == nil)
 	})
 
 	t.Run("tls", func(t *testing.T) {
 		cer, err := tls.LoadX509KeyPair("./.github/testdata/ssl.pem", "./.github/testdata/ssl.key")
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		config := &tls.Config{Certificates: []tls.Certificate{cer}}
 
 		ln, err := net.Listen(NetworkTCP4, ":0")
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		ln = tls.NewListener(ln, config)
 
 		addr, config := lnMetadata(NetworkTCP4, ln)
 
-		utils.AssertEqual(t, ln.Addr().String(), addr)
-		utils.AssertEqual(t, true, config != nil)
+		require.Equal(t, ln.Addr().String(), addr)
+		require.True(t, config != nil)
 	})
 }
 
@@ -213,7 +215,7 @@ func Benchmark_SlashRecognition(b *testing.B) {
 				result = true
 			}
 		}
-		utils.AssertEqual(b, true, result)
+		require.True(b, result)
 	})
 	b.Run("forEach", func(b *testing.B) {
 		result = false
@@ -226,7 +228,7 @@ func Benchmark_SlashRecognition(b *testing.B) {
 				}
 			}
 		}
-		utils.AssertEqual(b, true, result)
+		require.True(b, result)
 	})
 	b.Run("IndexRune", func(b *testing.B) {
 		result = false
@@ -234,7 +236,7 @@ func Benchmark_SlashRecognition(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			result = IndexRune(search, c)
 		}
-		utils.AssertEqual(b, true, result)
+		require.True(b, result)
 	})
 }
 

hooks_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/bytebufferpool"
 )
 
@@ -20,7 +20,7 @@ func Test_Hook_OnRoute(t *testing.T) {
 	app := New()
 
 	app.Hooks().OnRoute(func(r Route) error {
-		utils.AssertEqual(t, "", r.Name)
+		require.Equal(t, "", r.Name)
 
 		return nil
 	})
@@ -55,7 +55,7 @@ func Test_Hook_OnName(t *testing.T) {
 
 	app.Mount("/sub", subApp)
 
-	utils.AssertEqual(t, "index", buf.String())
+	require.Equal(t, "index", buf.String())
 }
 
 func Test_Hook_OnName_Error(t *testing.T) {
@@ -64,7 +64,7 @@ func Test_Hook_OnName_Error(t *testing.T) {
 	app := New()
 	defer func() {
 		if err := recover(); err != nil {
-			utils.AssertEqual(t, "unknown error", fmt.Sprintf("%v", err))
+			require.Equal(t, "unknown error", fmt.Sprintf("%v", err))
 		}
 	}()
 
@@ -92,7 +92,7 @@ func Test_Hook_OnGroup(t *testing.T) {
 	grp := app.Group("/x").Name("x.")
 	grp.Group("/a")
 
-	utils.AssertEqual(t, "/x/x/a", buf.String())
+	require.Equal(t, "/x/x/a", buf.String())
 }
 
 func Test_Hook_OnGroupName(t *testing.T) {
@@ -113,7 +113,7 @@ func Test_Hook_OnGroupName(t *testing.T) {
 	grp.Get("/test", testSimpleHandler)
 	grp.Get("/test2", testSimpleHandler)
 
-	utils.AssertEqual(t, "x.", buf.String())
+	require.Equal(t, "x.", buf.String())
 }
 
 func Test_Hook_OnGroupName_Error(t *testing.T) {
@@ -122,7 +122,7 @@ func Test_Hook_OnGroupName_Error(t *testing.T) {
 	app := New()
 	defer func() {
 		if err := recover(); err != nil {
-			utils.AssertEqual(t, "unknown error", fmt.Sprintf("%v", err))
+			require.Equal(t, "unknown error", fmt.Sprintf("%v", err))
 		}
 	}()
 
@@ -148,8 +148,8 @@ func Test_Hook_OnShutdown(t *testing.T) {
 		return nil
 	})
 
-	utils.AssertEqual(t, nil, app.Shutdown())
-	utils.AssertEqual(t, "shutdowning", buf.String())
+	require.Nil(t, app.Shutdown())
+	require.Equal(t, "shutdowning", buf.String())
 }
 
 func Test_Hook_OnListen(t *testing.T) {
@@ -170,11 +170,11 @@ func Test_Hook_OnListen(t *testing.T) {
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
-	utils.AssertEqual(t, nil, app.Listen(":9000"))
+	require.Nil(t, app.Listen(":9000"))
 
-	utils.AssertEqual(t, "ready", buf.String())
+	require.Equal(t, "ready", buf.String())
 }
 
 func Test_Hook_OnHook(t *testing.T) {
@@ -186,13 +186,13 @@ func Test_Hook_OnHook(t *testing.T) {
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
 	app.Hooks().OnFork(func(pid int) error {
-		utils.AssertEqual(t, 1, pid)
+		require.Equal(t, 1, pid)
 		return nil
 	})
 
-	utils.AssertEqual(t, nil, app.prefork(NetworkTCP4, ":3000", nil))
+	require.Nil(t, app.prefork(NetworkTCP4, ":3000", nil))
 }

internal/schema/doc.go

@@ -60,14 +60,14 @@ certain fields, use a dash for the name and it will be ignored:
 
 The supported field types in the destination struct are:
 
-	* bool
-	* float variants (float32, float64)
-	* int variants (int, int8, int16, int32, int64)
-	* string
-	* uint variants (uint, uint8, uint16, uint32, uint64)
-	* struct
-	* a pointer to one of the above types
-	* a slice or a pointer to a slice of one of the above types
+  - bool
+  - float variants (float32, float64)
+  - int variants (int, int8, int16, int32, int64)
+  - string
+  - uint variants (uint, uint8, uint16, uint32, uint64)
+  - struct
+  - a pointer to one of the above types
+  - a slice or a pointer to a slice of one of the above types
 
 Non-supported types are simply ignored, however custom types can be registered
 to be converted.

listen_test.go

@@ -16,7 +16,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp/fasthttputil"
 )
 
@@ -24,14 +24,14 @@ import (
 func Test_App_Listen(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true})
 
-	utils.AssertEqual(t, false, app.Listen(":99999") == nil)
+	require.False(t, app.Listen(":99999") == nil)
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.Listen(":4003"))
+	require.Nil(t, app.Listen(":4003"))
 }
 
 // go test -run Test_App_Listen_Prefork
@@ -40,7 +40,7 @@ func Test_App_Listen_Prefork(t *testing.T) {
 
 	app := New(Config{DisableStartupMessage: true, Prefork: true})
 
-	utils.AssertEqual(t, nil, app.Listen(":99999"))
+	require.Nil(t, app.Listen(":99999"))
 }
 
 // go test -run Test_App_ListenTLS
@@ -48,16 +48,16 @@ func Test_App_ListenTLS(t *testing.T) {
 	app := New()
 
 	// invalid port
-	utils.AssertEqual(t, false, app.ListenTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key") == nil)
+	require.False(t, app.ListenTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key") == nil)
 	// missing perm/cert file
-	utils.AssertEqual(t, false, app.ListenTLS(":0", "", "./.github/testdata/ssl.key") == nil)
+	require.False(t, app.ListenTLS(":0", "", "./.github/testdata/ssl.key") == nil)
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.ListenTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key"))
+	require.Nil(t, app.ListenTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key"))
 }
 
 // go test -run Test_App_ListenTLS_Prefork
@@ -67,9 +67,9 @@ func Test_App_ListenTLS_Prefork(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true, Prefork: true})
 
 	// invalid key file content
-	utils.AssertEqual(t, false, app.ListenTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/template.tmpl") == nil)
+	require.False(t, app.ListenTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/template.tmpl") == nil)
 
-	utils.AssertEqual(t, nil, app.ListenTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key"))
+	require.Nil(t, app.ListenTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key"))
 }
 
 // go test -run Test_App_ListenMutualTLS
@@ -77,16 +77,16 @@ func Test_App_ListenMutualTLS(t *testing.T) {
 	app := New()
 
 	// invalid port
-	utils.AssertEqual(t, false, app.ListenMutualTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem") == nil)
+	require.False(t, app.ListenMutualTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem") == nil)
 	// missing perm/cert file
-	utils.AssertEqual(t, false, app.ListenMutualTLS(":0", "", "./.github/testdata/ssl.key", "") == nil)
+	require.False(t, app.ListenMutualTLS(":0", "", "./.github/testdata/ssl.key", "") == nil)
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.ListenMutualTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem"))
+	require.Nil(t, app.ListenMutualTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem"))
 }
 
 // go test -run Test_App_ListenMutualTLS_Prefork
@@ -96,9 +96,9 @@ func Test_App_ListenMutualTLS_Prefork(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true, Prefork: true})
 
 	// invalid key file content
-	utils.AssertEqual(t, false, app.ListenMutualTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/template.html", "") == nil)
+	require.False(t, app.ListenMutualTLS(":0", "./.github/testdata/ssl.pem", "./.github/testdata/template.html", "") == nil)
 
-	utils.AssertEqual(t, nil, app.ListenMutualTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem"))
+	require.Nil(t, app.ListenMutualTLS(":99999", "./.github/testdata/ssl.pem", "./.github/testdata/ssl.key", "./.github/testdata/ca-chain.cert.pem"))
 }
 
 // go test -run Test_App_Listener
@@ -107,11 +107,11 @@ func Test_App_Listener(t *testing.T) {
 
 	go func() {
 		time.Sleep(500 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
 	ln := fasthttputil.NewInmemoryListener()
-	utils.AssertEqual(t, nil, app.Listener(ln))
+	require.Nil(t, app.Listener(ln))
 }
 
 // go test -run Test_App_Listener_Prefork
@@ -121,28 +121,28 @@ func Test_App_Listener_Prefork(t *testing.T) {
 	app := New(Config{DisableStartupMessage: true, Prefork: true})
 
 	ln := fasthttputil.NewInmemoryListener()
-	utils.AssertEqual(t, nil, app.Listener(ln))
+	require.Nil(t, app.Listener(ln))
 }
 
 func Test_App_Listener_TLS_Listener(t *testing.T) {
 	// Create tls certificate
 	cer, err := tls.LoadX509KeyPair("./.github/testdata/ssl.pem", "./.github/testdata/ssl.key")
 	if err != nil {
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 	}
 	config := &tls.Config{Certificates: []tls.Certificate{cer}}
 
 	ln, err := tls.Listen(NetworkTCP4, ":0", config)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	app := New()
 
 	go func() {
 		time.Sleep(time.Millisecond * 500)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.Listener(ln))
+	require.Nil(t, app.Listener(ln))
 }
 
 func captureOutput(f func()) string {
@@ -181,11 +181,11 @@ func Test_App_Master_Process_Show_Startup_Message(t *testing.T) {
 			startupMessage(":3000", true, strings.Repeat(",11111,22222,33333,44444,55555,60000", 10))
 	})
 	fmt.Println(startupMessage)
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "https://127.0.0.1:3000"))
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "(bound on host 0.0.0.0 and port 3000)"))
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "Child PIDs"))
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "11111, 22222, 33333, 44444, 55555, 60000"))
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "Prefork ........ Enabled"))
+	require.True(t, strings.Contains(startupMessage, "https://127.0.0.1:3000"))
+	require.True(t, strings.Contains(startupMessage, "(bound on host 0.0.0.0 and port 3000)"))
+	require.True(t, strings.Contains(startupMessage, "Child PIDs"))
+	require.True(t, strings.Contains(startupMessage, "11111, 22222, 33333, 44444, 55555, 60000"))
+	require.True(t, strings.Contains(startupMessage, "Prefork ........ Enabled"))
 }
 
 func Test_App_Master_Process_Show_Startup_MessageWithAppName(t *testing.T) {
@@ -194,8 +194,8 @@ func Test_App_Master_Process_Show_Startup_MessageWithAppName(t *testing.T) {
 		app.startupMessage(":3000", true, strings.Repeat(",11111,22222,33333,44444,55555,60000", 10))
 	})
 	fmt.Println(startupMessage)
-	utils.AssertEqual(t, "Test App v1.0.1", app.Config().AppName)
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, app.Config().AppName))
+	require.Equal(t, "Test App v1.0.1", app.Config().AppName)
+	require.True(t, strings.Contains(startupMessage, app.Config().AppName))
 }
 
 func Test_App_Master_Process_Show_Startup_MessageWithAppNameNonAscii(t *testing.T) {
@@ -205,7 +205,7 @@ func Test_App_Master_Process_Show_Startup_MessageWithAppNameNonAscii(t *testing.
 		app.startupMessage(":3000", false, "")
 	})
 	fmt.Println(startupMessage)
-	utils.AssertEqual(t, true, strings.Contains(startupMessage, "│        Serveur de vérification des données        │"))
+	require.True(t, strings.Contains(startupMessage, "│        Serveur de vérification des données        │"))
 }
 
 func Test_App_print_Route(t *testing.T) {
@@ -215,10 +215,10 @@ func Test_App_print_Route(t *testing.T) {
 		app.printRoutesMessage()
 	})
 	fmt.Println(printRoutesMessage)
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "GET"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "emptyHandler"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "routeName"))
+	require.True(t, strings.Contains(printRoutesMessage, "GET"))
+	require.True(t, strings.Contains(printRoutesMessage, "/"))
+	require.True(t, strings.Contains(printRoutesMessage, "emptyHandler"))
+	require.True(t, strings.Contains(printRoutesMessage, "routeName"))
 }
 
 func Test_App_print_Route_with_group(t *testing.T) {
@@ -234,14 +234,14 @@ func Test_App_print_Route_with_group(t *testing.T) {
 		app.printRoutesMessage()
 	})
 
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "GET"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "emptyHandler"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/v1/test"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "POST"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/v1/test/fiber"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "PUT"))
-	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/v1/test/fiber/*"))
+	require.True(t, strings.Contains(printRoutesMessage, "GET"))
+	require.True(t, strings.Contains(printRoutesMessage, "/"))
+	require.True(t, strings.Contains(printRoutesMessage, "emptyHandler"))
+	require.True(t, strings.Contains(printRoutesMessage, "/v1/test"))
+	require.True(t, strings.Contains(printRoutesMessage, "POST"))
+	require.True(t, strings.Contains(printRoutesMessage, "/v1/test/fiber"))
+	require.True(t, strings.Contains(printRoutesMessage, "PUT"))
+	require.True(t, strings.Contains(printRoutesMessage, "/v1/test/fiber/*"))
 }
 
 func emptyHandler(c Ctx) error {

middleware/basicauth/basicauth_test.go

@@ -9,7 +9,7 @@ import (
 	b64 "encoding/base64"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -25,8 +25,8 @@ func Test_BasicAuth_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 func Test_Middleware_BasicAuth(t *testing.T) {
@@ -80,15 +80,15 @@ func Test_Middleware_BasicAuth(t *testing.T) {
 		req := httptest.NewRequest("GET", "/testauth", nil)
 		req.Header.Add("Authorization", "Basic "+creds)
 		resp, err := app.Test(req)
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		body, err := io.ReadAll(resp.Body)
 
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, tt.statusCode, resp.StatusCode)
+		require.NoError(t, err)
+		require.Equal(t, tt.statusCode, resp.StatusCode)
 
 		if tt.statusCode == 200 {
-			utils.AssertEqual(t, fmt.Sprintf("%s%s", tt.username, tt.password), string(body))
+			require.Equal(t, fmt.Sprintf("%s%s", tt.username, tt.password), string(body))
 		}
 	}
 }
@@ -120,5 +120,5 @@ func Benchmark_Middleware_BasicAuth(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
+	require.Equal(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
 }

middleware/cache/cache_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/internal/storage/memory"
 	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -35,11 +36,11 @@ func Test_Cache_CacheControl(t *testing.T) {
 	})
 
 	_, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "public, max-age=10", resp.Header.Get(fiber.HeaderCacheControl))
+	require.NoError(t, err)
+	require.Equal(t, "public, max-age=10", resp.Header.Get(fiber.HeaderCacheControl))
 }
 
 func Test_Cache_Expired(t *testing.T) {
@@ -53,17 +54,17 @@ func Test_Cache_Expired(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	// Sleep until the cache is expired
 	time.Sleep(3 * time.Second)
 
 	respCached, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	bodyCached, err := io.ReadAll(respCached.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if bytes.Equal(body, bodyCached) {
 		t.Errorf("Cache should have expired: %s, %s", body, bodyCached)
@@ -71,9 +72,9 @@ func Test_Cache_Expired(t *testing.T) {
 
 	// Next response should be also cached
 	respCachedNextRound, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	bodyCachedNextRound, err := io.ReadAll(respCachedNextRound.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if !bytes.Equal(bodyCachedNextRound, bodyCached) {
 		t.Errorf("Cache should not have expired: %s, %s", bodyCached, bodyCachedNextRound)
@@ -93,18 +94,18 @@ func Test_Cache(t *testing.T) {
 
 	req := httptest.NewRequest("GET", "/", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	cachedReq := httptest.NewRequest("GET", "/", nil)
 	cachedResp, err := app.Test(cachedReq)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	cachedBody, err := io.ReadAll(cachedResp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
-	utils.AssertEqual(t, cachedBody, body)
+	require.Equal(t, cachedBody, body)
 }
 
 func Test_Cache_WithSeveralRequests(t *testing.T) {
@@ -125,18 +126,18 @@ func Test_Cache_WithSeveralRequests(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			func(id int) {
 				rsp, err := app.Test(httptest.NewRequest(http.MethodGet, fmt.Sprintf("/%d", id), nil))
-				utils.AssertEqual(t, nil, err)
+				require.NoError(t, err)
 
 				defer rsp.Body.Close()
 
 				idFromServ, err := io.ReadAll(rsp.Body)
-				utils.AssertEqual(t, nil, err)
+				require.NoError(t, err)
 
 				a, err := strconv.Atoi(string(idFromServ))
-				utils.AssertEqual(t, nil, err)
+				require.NoError(t, err)
 
 				// SomeTimes,The id is not equal with a
-				utils.AssertEqual(t, id, a)
+				require.Equal(t, id, a)
 			}(i)
 		}
 	}
@@ -156,18 +157,18 @@ func Test_Cache_Invalid_Expiration(t *testing.T) {
 
 	req := httptest.NewRequest("GET", "/", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	cachedReq := httptest.NewRequest("GET", "/", nil)
 	cachedResp, err := app.Test(cachedReq)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	cachedBody, err := io.ReadAll(cachedResp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
-	utils.AssertEqual(t, cachedBody, body)
+	require.Equal(t, cachedBody, body)
 }
 
 func Test_Cache_Invalid_Method(t *testing.T) {
@@ -186,28 +187,28 @@ func Test_Cache_Invalid_Method(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("POST", "/?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "123", string(body))
+	require.NoError(t, err)
+	require.Equal(t, "123", string(body))
 
 	resp, err = app.Test(httptest.NewRequest("POST", "/?cache=12345", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "12345", string(body))
+	require.NoError(t, err)
+	require.Equal(t, "12345", string(body))
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/get?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "123", string(body))
+	require.NoError(t, err)
+	require.Equal(t, "123", string(body))
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/get?cache=12345", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "123", string(body))
+	require.NoError(t, err)
+	require.Equal(t, "123", string(body))
 }
 
 func Test_Cache_NothingToCache(t *testing.T) {
@@ -222,16 +223,16 @@ func Test_Cache_NothingToCache(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	time.Sleep(500 * time.Millisecond)
 
 	respCached, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	bodyCached, err := io.ReadAll(respCached.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if bytes.Equal(body, bodyCached) {
 		t.Errorf("Cache should have expired: %s, %s", body, bodyCached)
@@ -259,23 +260,23 @@ func Test_Cache_CustomNext(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	respCached, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	bodyCached, err := io.ReadAll(respCached.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, bytes.Equal(body, bodyCached))
-	utils.AssertEqual(t, true, respCached.Header.Get(fiber.HeaderCacheControl) != "")
+	require.NoError(t, err)
+	require.True(t, bytes.Equal(body, bodyCached))
+	require.True(t, respCached.Header.Get(fiber.HeaderCacheControl) != "")
 
 	_, err = app.Test(httptest.NewRequest("GET", "/error", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	errRespCached, err := app.Test(httptest.NewRequest("GET", "/error", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, errRespCached.Header.Get(fiber.HeaderCacheControl) == "")
+	require.NoError(t, err)
+	require.True(t, errRespCached.Header.Get(fiber.HeaderCacheControl) == "")
 }
 
 func Test_CustomKey(t *testing.T) {
@@ -294,8 +295,8 @@ func Test_CustomKey(t *testing.T) {
 
 	req := httptest.NewRequest("GET", "/", nil)
 	_, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, called)
+	require.NoError(t, err)
+	require.True(t, called)
 }
 
 func Test_CustomExpiration(t *testing.T) {
@@ -317,20 +318,20 @@ func Test_CustomExpiration(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, called)
-	utils.AssertEqual(t, 1, newCacheTime)
+	require.NoError(t, err)
+	require.True(t, called)
+	require.Equal(t, 1, newCacheTime)
 
 	// Sleep until the cache is expired
 	time.Sleep(1 * time.Second)
 
 	cachedResp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	cachedBody, err := io.ReadAll(cachedResp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if bytes.Equal(body, cachedBody) {
 		t.Errorf("Cache should have expired: %s, %s", body, cachedBody)
@@ -338,9 +339,9 @@ func Test_CustomExpiration(t *testing.T) {
 
 	// Next response should be cached
 	cachedRespNextRound, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	cachedBodyNextRound, err := io.ReadAll(cachedRespNextRound.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if !bytes.Equal(cachedBodyNextRound, cachedBody) {
 		t.Errorf("Cache should not have expired: %s, %s", cachedBodyNextRound, cachedBody)
@@ -362,13 +363,13 @@ func Test_AdditionalE2EResponseHeaders(t *testing.T) {
 
 	req := httptest.NewRequest("GET", "/", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "foobar", resp.Header.Get("X-Foobar"))
+	require.NoError(t, err)
+	require.Equal(t, "foobar", resp.Header.Get("X-Foobar"))
 
 	req = httptest.NewRequest("GET", "/", nil)
 	resp, err = app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "foobar", resp.Header.Get("X-Foobar"))
+	require.NoError(t, err)
+	require.Equal(t, "foobar", resp.Header.Get("X-Foobar"))
 }
 
 func Test_CacheHeader(t *testing.T) {
@@ -396,20 +397,20 @@ func Test_CacheHeader(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, cacheMiss, resp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, cacheMiss, resp.Header.Get("X-Cache"))
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, cacheHit, resp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, cacheHit, resp.Header.Get("X-Cache"))
 
 	resp, err = app.Test(httptest.NewRequest("POST", "/?cache=12345", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, cacheUnreachable, resp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, cacheUnreachable, resp.Header.Get("X-Cache"))
 
 	errRespCached, err := app.Test(httptest.NewRequest("GET", "/error", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, cacheUnreachable, errRespCached.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, cacheUnreachable, errRespCached.Header.Get("X-Cache"))
 }
 
 func Test_Cache_WithHead(t *testing.T) {
@@ -425,18 +426,18 @@ func Test_Cache_WithHead(t *testing.T) {
 
 	req := httptest.NewRequest("HEAD", "/", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, cacheMiss, resp.Header.Get("X-Cache"))
+	require.Equal(t, cacheMiss, resp.Header.Get("X-Cache"))
 
 	cachedReq := httptest.NewRequest("HEAD", "/", nil)
 	cachedResp, err := app.Test(cachedReq)
-	utils.AssertEqual(t, cacheHit, cachedResp.Header.Get("X-Cache"))
+	require.Equal(t, cacheHit, cachedResp.Header.Get("X-Cache"))
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	cachedBody, err := io.ReadAll(cachedResp.Body)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
-	utils.AssertEqual(t, cachedBody, body)
+	require.Equal(t, cachedBody, body)
 }
 
 func Test_Cache_WithHeadThenGet(t *testing.T) {
@@ -449,32 +450,32 @@ func Test_Cache_WithHeadThenGet(t *testing.T) {
 	})
 
 	headResp, err := app.Test(httptest.NewRequest("HEAD", "/?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	headBody, err := io.ReadAll(headResp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "", string(headBody))
-	utils.AssertEqual(t, cacheMiss, headResp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, "", string(headBody))
+	require.Equal(t, cacheMiss, headResp.Header.Get("X-Cache"))
 
 	headResp, err = app.Test(httptest.NewRequest("HEAD", "/?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	headBody, err = io.ReadAll(headResp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "", string(headBody))
-	utils.AssertEqual(t, cacheHit, headResp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, "", string(headBody))
+	require.Equal(t, cacheHit, headResp.Header.Get("X-Cache"))
 
 	getResp, err := app.Test(httptest.NewRequest("GET", "/?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	getBody, err := io.ReadAll(getResp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "123", string(getBody))
-	utils.AssertEqual(t, cacheMiss, getResp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, "123", string(getBody))
+	require.Equal(t, cacheMiss, getResp.Header.Get("X-Cache"))
 
 	getResp, err = app.Test(httptest.NewRequest("GET", "/?cache=123", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	getBody, err = io.ReadAll(getResp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "123", string(getBody))
-	utils.AssertEqual(t, cacheHit, getResp.Header.Get("X-Cache"))
+	require.NoError(t, err)
+	require.Equal(t, "123", string(getBody))
+	require.Equal(t, cacheHit, getResp.Header.Get("X-Cache"))
 }
 
 func Test_CustomCacheHeader(t *testing.T) {
@@ -491,8 +492,8 @@ func Test_CustomCacheHeader(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, cacheMiss, resp.Header.Get("Cache-Status"))
+	require.NoError(t, err)
+	require.Equal(t, cacheMiss, resp.Header.Get("Cache-Status"))
 }
 
 // Because time points are updated once every X milliseconds, entries in tests can often have
@@ -538,8 +539,8 @@ func Test_Cache_MaxBytesOrder(t *testing.T) {
 
 	for idx, tcase := range cases {
 		rsp, err := app.Test(httptest.NewRequest("GET", tcase[0], nil))
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, tcase[1], rsp.Header.Get("X-Cache"), fmt.Sprintf("Case %v", idx))
+		require.NoError(t, err)
+		require.Equal(t, tcase[1], rsp.Header.Get("X-Cache"), fmt.Sprintf("Case %v", idx))
 	}
 }
 
@@ -572,8 +573,8 @@ func Test_Cache_MaxBytesSizes(t *testing.T) {
 
 	for idx, tcase := range cases {
 		rsp, err := app.Test(httptest.NewRequest("GET", tcase[0], nil))
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, tcase[1], rsp.Header.Get("X-Cache"), fmt.Sprintf("Case %v", idx))
+		require.NoError(t, err)
+		require.Equal(t, tcase[1], rsp.Header.Get("X-Cache"), fmt.Sprintf("Case %v", idx))
 	}
 }
 
@@ -601,8 +602,8 @@ func Benchmark_Cache(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
-	utils.AssertEqual(b, true, len(fctx.Response.Body()) > 30000)
+	require.Equal(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
+	require.True(b, len(fctx.Response.Body()) > 30000)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Cache_Storage -benchmem -count=4
@@ -631,8 +632,8 @@ func Benchmark_Cache_Storage(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
-	utils.AssertEqual(b, true, len(fctx.Response.Body()) > 30000)
+	require.Equal(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
+	require.True(b, len(fctx.Response.Body()) > 30000)
 }
 
 func Benchmark_Cache_AdditionalHeaders(b *testing.B) {
@@ -659,8 +660,8 @@ func Benchmark_Cache_AdditionalHeaders(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
-	utils.AssertEqual(b, []byte("foobar"), fctx.Response.Header.Peek("X-Foobar"))
+	require.Equal(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
+	require.Equal(b, []byte("foobar"), fctx.Response.Header.Peek("X-Foobar"))
 }
 
 func Benchmark_Cache_MaxSize(b *testing.B) {
@@ -691,7 +692,7 @@ func Benchmark_Cache_MaxSize(b *testing.B) {
 				h(fctx)
 			}
 
-			utils.AssertEqual(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
+			require.Equal(b, fiber.StatusTeapot, fctx.Response.Header.StatusCode())
 		})
 	}
 }

middleware/compress/compress_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 var filedata []byte
@@ -37,14 +37,14 @@ func Test_Compress_Gzip(t *testing.T) {
 	req.Header.Set("Accept-Encoding", "gzip")
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "gzip", resp.Header.Get(fiber.HeaderContentEncoding))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
+	require.Equal(t, "gzip", resp.Header.Get(fiber.HeaderContentEncoding))
 
 	// Validate that the file size has shrunk
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, len(body) < len(filedata))
+	require.NoError(t, err)
+	require.True(t, len(body) < len(filedata))
 }
 
 // go test -run Test_Compress_Different_Level
@@ -65,14 +65,14 @@ func Test_Compress_Different_Level(t *testing.T) {
 			req.Header.Set("Accept-Encoding", "gzip")
 
 			resp, err := app.Test(req)
-			utils.AssertEqual(t, nil, err, "app.Test(req)")
-			utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
-			utils.AssertEqual(t, "gzip", resp.Header.Get(fiber.HeaderContentEncoding))
+			require.NoError(t, err, "app.Test(req)")
+			require.Equal(t, 200, resp.StatusCode, "Status code")
+			require.Equal(t, "gzip", resp.Header.Get(fiber.HeaderContentEncoding))
 
 			// Validate that the file size has shrunk
 			body, err := io.ReadAll(resp.Body)
-			utils.AssertEqual(t, nil, err)
-			utils.AssertEqual(t, true, len(body) < len(filedata))
+			require.NoError(t, err)
+			require.True(t, len(body) < len(filedata))
 		})
 	}
 }
@@ -90,14 +90,14 @@ func Test_Compress_Deflate(t *testing.T) {
 	req.Header.Set("Accept-Encoding", "deflate")
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "deflate", resp.Header.Get(fiber.HeaderContentEncoding))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
+	require.Equal(t, "deflate", resp.Header.Get(fiber.HeaderContentEncoding))
 
 	// Validate that the file size has shrunk
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, len(body) < len(filedata))
+	require.NoError(t, err)
+	require.True(t, len(body) < len(filedata))
 }
 
 func Test_Compress_Brotli(t *testing.T) {
@@ -113,14 +113,14 @@ func Test_Compress_Brotli(t *testing.T) {
 	req.Header.Set("Accept-Encoding", "br")
 
 	resp, err := app.Test(req, 10000)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "br", resp.Header.Get(fiber.HeaderContentEncoding))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
+	require.Equal(t, "br", resp.Header.Get(fiber.HeaderContentEncoding))
 
 	// Validate that the file size has shrunk
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, len(body) < len(filedata))
+	require.NoError(t, err)
+	require.True(t, len(body) < len(filedata))
 }
 
 func Test_Compress_Disabled(t *testing.T) {
@@ -136,14 +136,14 @@ func Test_Compress_Disabled(t *testing.T) {
 	req.Header.Set("Accept-Encoding", "br")
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderContentEncoding))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderContentEncoding))
 
 	// Validate the file size is not shrunk
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, len(body) == len(filedata))
+	require.NoError(t, err)
+	require.True(t, len(body) == len(filedata))
 }
 
 func Test_Compress_Next_Error(t *testing.T) {
@@ -159,13 +159,13 @@ func Test_Compress_Next_Error(t *testing.T) {
 	req.Header.Set("Accept-Encoding", "gzip")
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 500, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderContentEncoding))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 500, resp.StatusCode, "Status code")
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderContentEncoding))
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "next error", string(body))
+	require.NoError(t, err)
+	require.Equal(t, "next error", string(body))
 }
 
 // go test -run Test_Compress_Next
@@ -178,6 +178,6 @@ func Test_Compress_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }

middleware/cors/cors_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -33,18 +33,18 @@ func testDefaultOrEmptyConfig(t *testing.T, app *fiber.App) {
 	ctx.Request.Header.SetMethod(fiber.MethodGet)
 	h(ctx)
 
-	utils.AssertEqual(t, "*", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
-	utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
-	utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlExposeHeaders)))
+	require.Equal(t, "*", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+	require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
+	require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlExposeHeaders)))
 
 	// Test default OPTIONS (preflight) response headers
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod(fiber.MethodOptions)
 	h(ctx)
 
-	utils.AssertEqual(t, "GET,POST,HEAD,PUT,DELETE,PATCH", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowMethods)))
-	utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowHeaders)))
-	utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlMaxAge)))
+	require.Equal(t, "GET,POST,HEAD,PUT,DELETE,PATCH", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowMethods)))
+	require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowHeaders)))
+	require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlMaxAge)))
 }
 
 // go test -run -v Test_CORS_Wildcard
@@ -72,18 +72,18 @@ func Test_CORS_Wildcard(t *testing.T) {
 	handler(ctx)
 
 	// Check result
-	utils.AssertEqual(t, "localhost", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
-	utils.AssertEqual(t, "true", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
-	utils.AssertEqual(t, "3600", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlMaxAge)))
-	utils.AssertEqual(t, "Authentication", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowHeaders)))
+	require.Equal(t, "localhost", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+	require.Equal(t, "true", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
+	require.Equal(t, "3600", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlMaxAge)))
+	require.Equal(t, "Authentication", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowHeaders)))
 
 	// Test non OPTIONS (preflight) response headers
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod(fiber.MethodGet)
 	handler(ctx)
 
-	utils.AssertEqual(t, "true", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
-	utils.AssertEqual(t, "X-Request-ID", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlExposeHeaders)))
+	require.Equal(t, "true", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowCredentials)))
+	require.Equal(t, "X-Request-ID", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlExposeHeaders)))
 }
 
 // go test -run -v Test_CORS_Subdomain
@@ -106,7 +106,7 @@ func Test_CORS_Subdomain(t *testing.T) {
 	handler(ctx)
 
 	// Allow-Origin header should be "" because http://google.com does not satisfy http://*.example.com
-	utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+	require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
 
 	ctx.Request.Reset()
 	ctx.Response.Reset()
@@ -118,7 +118,7 @@ func Test_CORS_Subdomain(t *testing.T) {
 
 	handler(ctx)
 
-	utils.AssertEqual(t, "http://test.example.com", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+	require.Equal(t, "http://test.example.com", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
 }
 
 func Test_CORS_AllowOriginScheme(t *testing.T) {
@@ -215,9 +215,9 @@ func Test_CORS_AllowOriginScheme(t *testing.T) {
 		handler(ctx)
 
 		if tt.shouldAllowOrigin {
-			utils.AssertEqual(t, tt.reqOrigin, string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+			require.Equal(t, tt.reqOrigin, string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
 		} else {
-			utils.AssertEqual(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
+			require.Equal(t, "", string(ctx.Response.Header.Peek(fiber.HeaderAccessControlAllowOrigin)))
 		}
 	}
 }
@@ -232,6 +232,6 @@ func Test_CORS_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }

middleware/csrf/csrf_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -34,7 +35,7 @@ func Test_CSRF(t *testing.T) {
 		ctx.Response.Reset()
 		ctx.Request.Header.SetMethod("POST")
 		h(ctx)
-		utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+		require.Equal(t, 403, ctx.Response.StatusCode())
 
 		// Empty/invalid CSRF token
 		ctx.Request.Reset()
@@ -42,7 +43,7 @@ func Test_CSRF(t *testing.T) {
 		ctx.Request.Header.SetMethod("POST")
 		ctx.Request.Header.Set("X-CSRF-Token", "johndoe")
 		h(ctx)
-		utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+		require.Equal(t, 403, ctx.Response.StatusCode())
 
 		// Valid CSRF token
 		ctx.Request.Reset()
@@ -57,7 +58,7 @@ func Test_CSRF(t *testing.T) {
 		ctx.Request.Header.SetMethod("POST")
 		ctx.Request.Header.Set("X-CSRF-Token", token)
 		h(ctx)
-		utils.AssertEqual(t, 200, ctx.Response.StatusCode())
+		require.Equal(t, 200, ctx.Response.StatusCode())
 	}
 }
 
@@ -71,13 +72,13 @@ func Test_CSRF_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 func Test_CSRF_Invalid_KeyLookup(t *testing.T) {
 	defer func() {
-		utils.AssertEqual(t, "[CSRF] KeyLookup must in the form of <source>:<key>", recover())
+		require.Equal(t, "[CSRF] KeyLookup must in the form of <source>:<key>", recover())
 	}()
 	app := fiber.New()
 
@@ -109,7 +110,7 @@ func Test_CSRF_From_Form(t *testing.T) {
 	ctx.Request.Header.SetMethod("POST")
 	ctx.Request.Header.Set(fiber.HeaderContentType, fiber.MIMEApplicationForm)
 	h(ctx)
-	utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+	require.Equal(t, 403, ctx.Response.StatusCode())
 
 	// Generate CSRF token
 	ctx.Request.Reset()
@@ -123,7 +124,7 @@ func Test_CSRF_From_Form(t *testing.T) {
 	ctx.Request.Header.Set(fiber.HeaderContentType, fiber.MIMEApplicationForm)
 	ctx.Request.SetBodyString("_csrf=" + token)
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, 200, ctx.Response.StatusCode())
 }
 
 func Test_CSRF_From_Query(t *testing.T) {
@@ -142,7 +143,7 @@ func Test_CSRF_From_Query(t *testing.T) {
 	ctx.Request.Header.SetMethod("POST")
 	ctx.Request.SetRequestURI("/?_csrf=" + utils.UUID())
 	h(ctx)
-	utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+	require.Equal(t, 403, ctx.Response.StatusCode())
 
 	// Generate CSRF token
 	ctx.Request.Reset()
@@ -158,8 +159,8 @@ func Test_CSRF_From_Query(t *testing.T) {
 	ctx.Request.SetRequestURI("/?_csrf=" + token)
 	ctx.Request.Header.SetMethod("POST")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "OK", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "OK", string(ctx.Response.Body()))
 }
 
 func Test_CSRF_From_Param(t *testing.T) {
@@ -178,7 +179,7 @@ func Test_CSRF_From_Param(t *testing.T) {
 	ctx.Request.Header.SetMethod("POST")
 	ctx.Request.SetRequestURI("/" + utils.UUID())
 	h(ctx)
-	utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+	require.Equal(t, 403, ctx.Response.StatusCode())
 
 	// Generate CSRF token
 	ctx.Request.Reset()
@@ -194,8 +195,8 @@ func Test_CSRF_From_Param(t *testing.T) {
 	ctx.Request.SetRequestURI("/" + token)
 	ctx.Request.Header.SetMethod("POST")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "OK", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "OK", string(ctx.Response.Body()))
 }
 
 func Test_CSRF_From_Cookie(t *testing.T) {
@@ -215,7 +216,7 @@ func Test_CSRF_From_Cookie(t *testing.T) {
 	ctx.Request.SetRequestURI("/")
 	ctx.Request.Header.Set(fiber.HeaderCookie, "csrf="+utils.UUID()+";")
 	h(ctx)
-	utils.AssertEqual(t, 403, ctx.Response.StatusCode())
+	require.Equal(t, 403, ctx.Response.StatusCode())
 
 	// Generate CSRF token
 	ctx.Request.Reset()
@@ -232,15 +233,15 @@ func Test_CSRF_From_Cookie(t *testing.T) {
 	ctx.Request.Header.Set(fiber.HeaderCookie, "csrf="+token+";")
 	ctx.Request.SetRequestURI("/")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "OK", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "OK", string(ctx.Response.Body()))
 }
 
 func Test_CSRF_ErrorHandler_InvalidToken(t *testing.T) {
 	app := fiber.New()
 
 	errHandler := func(ctx fiber.Ctx, err error) error {
-		utils.AssertEqual(t, errTokenNotFound, err)
+		require.Equal(t, errTokenNotFound, err)
 		return ctx.Status(419).Send([]byte("invalid CSRF token"))
 	}
 
@@ -263,15 +264,15 @@ func Test_CSRF_ErrorHandler_InvalidToken(t *testing.T) {
 	ctx.Request.Header.SetMethod("POST")
 	ctx.Request.Header.Set("X-CSRF-Token", "johndoe")
 	h(ctx)
-	utils.AssertEqual(t, 419, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "invalid CSRF token", string(ctx.Response.Body()))
+	require.Equal(t, 419, ctx.Response.StatusCode())
+	require.Equal(t, "invalid CSRF token", string(ctx.Response.Body()))
 }
 
 func Test_CSRF_ErrorHandler_EmptyToken(t *testing.T) {
 	app := fiber.New()
 
 	errHandler := func(ctx fiber.Ctx, err error) error {
-		utils.AssertEqual(t, errMissingHeader, err)
+		require.Equal(t, errMissingHeader, err)
 		return ctx.Status(419).Send([]byte("empty CSRF token"))
 	}
 
@@ -293,6 +294,6 @@ func Test_CSRF_ErrorHandler_EmptyToken(t *testing.T) {
 	ctx.Response.Reset()
 	ctx.Request.Header.SetMethod("POST")
 	h(ctx)
-	utils.AssertEqual(t, 419, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "empty CSRF token", string(ctx.Response.Body()))
+	require.Equal(t, 419, ctx.Response.StatusCode())
+	require.Equal(t, "empty CSRF token", string(ctx.Response.Body()))
 }

middleware/encryptcookie/encryptcookie_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -36,39 +36,39 @@ func Test_Middleware_Encrypt_Cookie(t *testing.T) {
 	ctx := &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("GET")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "value=", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "value=", string(ctx.Response.Body()))
 
 	// Test invalid cookie
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("GET")
 	ctx.Request.Header.SetCookie("test", "Invalid")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "value=", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "value=", string(ctx.Response.Body()))
 	ctx.Request.Header.SetCookie("test", "ixQURE2XOyZUs0WAOh2ehjWcP7oZb07JvnhWOsmeNUhPsj4+RyI=")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "value=", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "value=", string(ctx.Response.Body()))
 
 	// Test valid cookie
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("POST")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, 200, ctx.Response.StatusCode())
 
 	encryptedCookie := fasthttp.Cookie{}
 	encryptedCookie.SetKey("test")
-	utils.AssertEqual(t, true, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
+	require.True(t, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
 	decryptedCookieValue, _ := DecryptCookie(string(encryptedCookie.Value()), testKey)
-	utils.AssertEqual(t, "SomeThing", decryptedCookieValue)
+	require.Equal(t, "SomeThing", decryptedCookieValue)
 
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("GET")
 	ctx.Request.Header.SetCookie("test", string(encryptedCookie.Value()))
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "value=SomeThing", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "value=SomeThing", string(ctx.Response.Body()))
 }
 
 func Test_Encrypt_Cookie_Next(t *testing.T) {
@@ -90,8 +90,8 @@ func Test_Encrypt_Cookie_Next(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "SomeThing", resp.Cookies()[0].Value)
+	require.NoError(t, err)
+	require.Equal(t, "SomeThing", resp.Cookies()[0].Value)
 }
 
 func Test_Encrypt_Cookie_Except(t *testing.T) {
@@ -122,18 +122,18 @@ func Test_Encrypt_Cookie_Except(t *testing.T) {
 	ctx := &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("GET")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, 200, ctx.Response.StatusCode())
 
 	rawCookie := fasthttp.Cookie{}
 	rawCookie.SetKey("test1")
-	utils.AssertEqual(t, true, ctx.Response.Header.Cookie(&rawCookie), "Get cookie value")
-	utils.AssertEqual(t, "SomeThing", string(rawCookie.Value()))
+	require.True(t, ctx.Response.Header.Cookie(&rawCookie), "Get cookie value")
+	require.Equal(t, "SomeThing", string(rawCookie.Value()))
 
 	encryptedCookie := fasthttp.Cookie{}
 	encryptedCookie.SetKey("test2")
-	utils.AssertEqual(t, true, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
+	require.True(t, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
 	decryptedCookieValue, _ := DecryptCookie(string(encryptedCookie.Value()), testKey)
-	utils.AssertEqual(t, "SomeThing", decryptedCookieValue)
+	require.Equal(t, "SomeThing", decryptedCookieValue)
 }
 
 func Test_Encrypt_Cookie_Custom_Encryptor(t *testing.T) {
@@ -167,18 +167,18 @@ func Test_Encrypt_Cookie_Custom_Encryptor(t *testing.T) {
 	ctx := &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("POST")
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, 200, ctx.Response.StatusCode())
 
 	encryptedCookie := fasthttp.Cookie{}
 	encryptedCookie.SetKey("test")
-	utils.AssertEqual(t, true, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
+	require.True(t, ctx.Response.Header.Cookie(&encryptedCookie), "Get cookie value")
 	decodedBytes, _ := base64.StdEncoding.DecodeString(string(encryptedCookie.Value()))
-	utils.AssertEqual(t, "SomeThing", string(decodedBytes))
+	require.Equal(t, "SomeThing", string(decodedBytes))
 
 	ctx = &fasthttp.RequestCtx{}
 	ctx.Request.Header.SetMethod("GET")
 	ctx.Request.Header.SetCookie("test", string(encryptedCookie.Value()))
 	h(ctx)
-	utils.AssertEqual(t, 200, ctx.Response.StatusCode())
-	utils.AssertEqual(t, "value=SomeThing", string(ctx.Response.Body()))
+	require.Equal(t, 200, ctx.Response.StatusCode())
+	require.Equal(t, "value=SomeThing", string(ctx.Response.Body()))
 }

middleware/etag/etag_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -21,8 +21,8 @@ func Test_ETag_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 // go test -run Test_ETag_SkipError
@@ -36,8 +36,8 @@ func Test_ETag_SkipError(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusForbidden, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusForbidden, resp.StatusCode)
 }
 
 // go test -run Test_ETag_NotStatusOK
@@ -51,8 +51,8 @@ func Test_ETag_NotStatusOK(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusCreated, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusCreated, resp.StatusCode)
 }
 
 // go test -run Test_ETag_NoBody
@@ -66,8 +66,8 @@ func Test_ETag_NoBody(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 }
 
 // go test -run Test_ETag_NewEtag
@@ -104,19 +104,19 @@ func testETagNewEtag(t *testing.T, headerIfNoneMatch, matched bool) {
 	}
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if !headerIfNoneMatch || !matched {
-		utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-		utils.AssertEqual(t, `"13-1831710635"`, resp.Header.Get(fiber.HeaderETag))
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
+		require.Equal(t, `"13-1831710635"`, resp.Header.Get(fiber.HeaderETag))
 		return
 	}
 
 	if matched {
-		utils.AssertEqual(t, fiber.StatusNotModified, resp.StatusCode)
+		require.Equal(t, fiber.StatusNotModified, resp.StatusCode)
 		b, err := io.ReadAll(resp.Body)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, 0, len(b))
+		require.NoError(t, err)
+		require.Equal(t, 0, len(b))
 	}
 }
 
@@ -154,19 +154,19 @@ func testETagWeakEtag(t *testing.T, headerIfNoneMatch, matched bool) {
 	}
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if !headerIfNoneMatch || !matched {
-		utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-		utils.AssertEqual(t, `W/"13-1831710635"`, resp.Header.Get(fiber.HeaderETag))
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
+		require.Equal(t, `W/"13-1831710635"`, resp.Header.Get(fiber.HeaderETag))
 		return
 	}
 
 	if matched {
-		utils.AssertEqual(t, fiber.StatusNotModified, resp.StatusCode)
+		require.Equal(t, fiber.StatusNotModified, resp.StatusCode)
 		b, err := io.ReadAll(resp.Body)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, 0, len(b))
+		require.NoError(t, err)
+		require.Equal(t, 0, len(b))
 	}
 }
 
@@ -208,19 +208,19 @@ func testETagCustomEtag(t *testing.T, headerIfNoneMatch, matched bool) {
 	}
 
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	if !headerIfNoneMatch || !matched {
-		utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-		utils.AssertEqual(t, `"custom"`, resp.Header.Get(fiber.HeaderETag))
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
+		require.Equal(t, `"custom"`, resp.Header.Get(fiber.HeaderETag))
 		return
 	}
 
 	if matched {
-		utils.AssertEqual(t, fiber.StatusNotModified, resp.StatusCode)
+		require.Equal(t, fiber.StatusNotModified, resp.StatusCode)
 		b, err := io.ReadAll(resp.Body)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, 0, len(b))
+		require.NoError(t, err)
+		require.Equal(t, 0, len(b))
 	}
 }
 
@@ -241,8 +241,8 @@ func Test_ETag_CustomEtagPut(t *testing.T) {
 	req := httptest.NewRequest("PUT", "/", nil)
 	req.Header.Set(fiber.HeaderIfMatch, `"non-match"`)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusPreconditionFailed, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusPreconditionFailed, resp.StatusCode)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Etag -benchmem -count=4
@@ -268,6 +268,6 @@ func Benchmark_Etag(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, 200, fctx.Response.Header.StatusCode())
-	utils.AssertEqual(b, `"13-1831710635"`, string(fctx.Response.Header.Peek(fiber.HeaderETag)))
+	require.Equal(b, 200, fctx.Response.Header.StatusCode())
+	require.Equal(b, `"13-1831710635"`, string(fctx.Response.Header.Peek(fiber.HeaderETag)))
 }

middleware/expvar/expvar_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_Non_Expvar_Path(t *testing.T) {
@@ -20,12 +20,12 @@ func Test_Non_Expvar_Path(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "escaped", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "escaped", string(b))
 }
 
 func Test_Expvar_Index(t *testing.T) {
@@ -38,14 +38,14 @@ func Test_Expvar_Index(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/vars", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
-	utils.AssertEqual(t, fiber.MIMEApplicationJSONCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
+	require.Equal(t, fiber.MIMEApplicationJSONCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, bytes.Contains(b, []byte("cmdline")))
-	utils.AssertEqual(t, true, bytes.Contains(b, []byte("memstat")))
+	require.NoError(t, err)
+	require.True(t, bytes.Contains(b, []byte("cmdline")))
+	require.True(t, bytes.Contains(b, []byte("memstat")))
 }
 
 func Test_Expvar_Filter(t *testing.T) {
@@ -58,14 +58,14 @@ func Test_Expvar_Filter(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/vars?r=cmd", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
-	utils.AssertEqual(t, fiber.MIMEApplicationJSONCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
+	require.Equal(t, fiber.MIMEApplicationJSONCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, bytes.Contains(b, []byte("cmdline")))
-	utils.AssertEqual(t, false, bytes.Contains(b, []byte("memstat")))
+	require.NoError(t, err)
+	require.True(t, bytes.Contains(b, []byte("cmdline")))
+	require.False(t, bytes.Contains(b, []byte("memstat")))
 }
 
 func Test_Expvar_Other_Path(t *testing.T) {
@@ -78,8 +78,8 @@ func Test_Expvar_Other_Path(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/vars/302", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 302, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 302, resp.StatusCode)
 }
 
 // go test -run Test_Expvar_Next
@@ -95,6 +95,6 @@ func Test_Expvar_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/vars", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 404, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 404, resp.StatusCode)
 }

middleware/favicon/favicon_test.go

@@ -5,10 +5,10 @@ import (
 	"os"
 	"testing"
 
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
 )
 
 // go test -run Test_Middleware_Favicon
@@ -23,21 +23,21 @@ func Test_Middleware_Favicon(t *testing.T) {
 
 	// Skip Favicon middleware
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusOK, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/favicon.ico", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusNoContent, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusNoContent, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest("OPTIONS", "/favicon.ico", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusOK, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest("PUT", "/favicon.ico", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusMethodNotAllowed, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "GET, HEAD, OPTIONS", resp.Header.Get(fiber.HeaderAllow))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusMethodNotAllowed, resp.StatusCode, "Status code")
+	require.Equal(t, "GET, HEAD, OPTIONS", resp.Header.Get(fiber.HeaderAllow))
 }
 
 // go test -run Test_Middleware_Favicon_Not_Found
@@ -67,10 +67,10 @@ func Test_Middleware_Favicon_Found(t *testing.T) {
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/favicon.ico", nil))
 
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
-	utils.AssertEqual(t, "public, max-age=31536000", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusOK, resp.StatusCode, "Status code")
+	require.Equal(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
+	require.Equal(t, "public, max-age=31536000", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
 }
 
 // go test -run Test_Middleware_Favicon_FileSystem
@@ -83,10 +83,10 @@ func Test_Middleware_Favicon_FileSystem(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/favicon.ico", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
-	utils.AssertEqual(t, "public, max-age=31536000", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusOK, resp.StatusCode, "Status code")
+	require.Equal(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
+	require.Equal(t, "public, max-age=31536000", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
 }
 
 // go test -run Test_Middleware_Favicon_CacheControl
@@ -99,10 +99,10 @@ func Test_Middleware_Favicon_CacheControl(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/favicon.ico", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode, "Status code")
-	utils.AssertEqual(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
-	utils.AssertEqual(t, "public, max-age=100", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, fiber.StatusOK, resp.StatusCode, "Status code")
+	require.Equal(t, "image/x-icon", resp.Header.Get(fiber.HeaderContentType))
+	require.Equal(t, "public, max-age=100", resp.Header.Get(fiber.HeaderCacheControl), "CacheControl Control")
 }
 
 // go test -v -run=^$ -bench=Benchmark_Middleware_Favicon -benchmem -count=4
@@ -134,6 +134,6 @@ func Test_Favicon_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }

middleware/filesystem/filesystem_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 // go test -run Test_FileSystem
@@ -118,12 +118,12 @@ func Test_FileSystem(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			resp, err := app.Test(httptest.NewRequest("GET", tt.url, nil))
-			utils.AssertEqual(t, nil, err)
-			utils.AssertEqual(t, tt.statusCode, resp.StatusCode)
+			require.NoError(t, err)
+			require.Equal(t, tt.statusCode, resp.StatusCode)
 
 			if tt.contentType != "" {
 				ct := resp.Header.Get("Content-Type")
-				utils.AssertEqual(t, tt.contentType, ct)
+				require.Equal(t, tt.contentType, ct)
 			}
 		})
 	}
@@ -140,8 +140,8 @@ func Test_FileSystem_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 func Test_FileSystem_NonGetAndHead(t *testing.T) {
@@ -152,8 +152,8 @@ func Test_FileSystem_NonGetAndHead(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodPost, "/test", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 404, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 404, resp.StatusCode)
 }
 
 func Test_FileSystem_Head(t *testing.T) {
@@ -165,13 +165,13 @@ func Test_FileSystem_Head(t *testing.T) {
 
 	req, _ := http.NewRequest(fiber.MethodHead, "/test", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 }
 
 func Test_FileSystem_NoRoot(t *testing.T) {
 	defer func() {
-		utils.AssertEqual(t, "filesystem: Root cannot be nil", recover())
+		require.Equal(t, "filesystem: Root cannot be nil", recover())
 	}()
 
 	app := fiber.New()
@@ -188,8 +188,8 @@ func Test_FileSystem_UsingParam(t *testing.T) {
 
 	req, _ := http.NewRequest(fiber.MethodHead, "/index", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 }
 
 func Test_FileSystem_UsingParam_NonFile(t *testing.T) {
@@ -201,6 +201,6 @@ func Test_FileSystem_UsingParam_NonFile(t *testing.T) {
 
 	req, _ := http.NewRequest(fiber.MethodHead, "/template", nil)
 	resp, err := app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 404, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 404, resp.StatusCode)
 }

middleware/helmet/helmet_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_Default(t *testing.T) {
@@ -22,13 +22,13 @@ func Test_Default(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "1; mode=block", resp.Header.Get(fiber.HeaderXXSSProtection))
-	utils.AssertEqual(t, "nosniff", resp.Header.Get(fiber.HeaderXContentTypeOptions))
-	utils.AssertEqual(t, "SAMEORIGIN", resp.Header.Get(fiber.HeaderXFrameOptions))
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderReferrerPolicy))
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderPermissionsPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "1; mode=block", resp.Header.Get(fiber.HeaderXXSSProtection))
+	require.Equal(t, "nosniff", resp.Header.Get(fiber.HeaderXContentTypeOptions))
+	require.Equal(t, "SAMEORIGIN", resp.Header.Get(fiber.HeaderXFrameOptions))
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderReferrerPolicy))
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderPermissionsPolicy))
 }
 
 func Test_Filter(t *testing.T) {
@@ -49,12 +49,12 @@ func Test_Filter(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "no-referrer", resp.Header.Get(fiber.HeaderReferrerPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "no-referrer", resp.Header.Get(fiber.HeaderReferrerPolicy))
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/filter", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderReferrerPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderReferrerPolicy))
 }
 
 func Test_ContentSecurityPolicy(t *testing.T) {
@@ -69,8 +69,8 @@ func Test_ContentSecurityPolicy(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "default-src 'none'", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "default-src 'none'", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
 }
 
 func Test_ContentSecurityPolicyReportOnly(t *testing.T) {
@@ -86,9 +86,9 @@ func Test_ContentSecurityPolicyReportOnly(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "default-src 'none'", resp.Header.Get(fiber.HeaderContentSecurityPolicyReportOnly))
-	utils.AssertEqual(t, "", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "default-src 'none'", resp.Header.Get(fiber.HeaderContentSecurityPolicyReportOnly))
+	require.Equal(t, "", resp.Header.Get(fiber.HeaderContentSecurityPolicy))
 }
 
 func Test_PermissionsPolicy(t *testing.T) {
@@ -103,6 +103,6 @@ func Test_PermissionsPolicy(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "microphone=()", resp.Header.Get(fiber.HeaderPermissionsPolicy))
+	require.NoError(t, err)
+	require.Equal(t, "microphone=()", resp.Header.Get(fiber.HeaderPermissionsPolicy))
 }

middleware/limiter/limiter_test.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/internal/storage/memory"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -34,12 +34,12 @@ func Test_Limiter_Concurrency_Store(t *testing.T) {
 	singleRequest := func(wg *sync.WaitGroup) {
 		defer wg.Done()
 		resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+		require.NoError(t, err)
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 		body, err := io.ReadAll(resp.Body)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, "Hello tester!", string(body))
+		require.NoError(t, err)
+		require.Equal(t, "Hello tester!", string(body))
 	}
 
 	for i := 0; i <= 49; i++ {
@@ -50,14 +50,14 @@ func Test_Limiter_Concurrency_Store(t *testing.T) {
 	wg.Wait()
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 429, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 429, resp.StatusCode)
 
 	time.Sleep(3 * time.Second)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 }
 
 // go test -run Test_Limiter_Concurrency -race -v
@@ -79,12 +79,12 @@ func Test_Limiter_Concurrency(t *testing.T) {
 	singleRequest := func(wg *sync.WaitGroup) {
 		defer wg.Done()
 		resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+		require.NoError(t, err)
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 		body, err := io.ReadAll(resp.Body)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, "Hello tester!", string(body))
+		require.NoError(t, err)
+		require.Equal(t, "Hello tester!", string(body))
 	}
 
 	for i := 0; i <= 49; i++ {
@@ -95,14 +95,14 @@ func Test_Limiter_Concurrency(t *testing.T) {
 	wg.Wait()
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 429, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 429, resp.StatusCode)
 
 	time.Sleep(3 * time.Second)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 }
 
 // go test -run Test_Limiter_No_Skip_Choices -v
@@ -124,16 +124,16 @@ func Test_Limiter_No_Skip_Choices(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/fail", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 400, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 400, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 429, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 429, resp.StatusCode)
 }
 
 // go test -run Test_Limiter_Skip_Failed_Requests -v
@@ -154,22 +154,22 @@ func Test_Limiter_Skip_Failed_Requests(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/fail", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 400, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 400, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 429, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 429, resp.StatusCode)
 
 	time.Sleep(3 * time.Second)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 }
 
 // go test -run Test_Limiter_Skip_Successful_Requests -v
@@ -192,22 +192,22 @@ func Test_Limiter_Skip_Successful_Requests(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/success", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/fail", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 400, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 400, resp.StatusCode)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/fail", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 429, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 429, resp.StatusCode)
 
 	time.Sleep(3 * time.Second)
 
 	resp, err = app.Test(httptest.NewRequest(http.MethodGet, "/fail", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 400, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 400, resp.StatusCode)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Limiter_Custom_Store -benchmem -count=4
@@ -247,8 +247,8 @@ func Test_Limiter_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 func Test_Limiter_Headers(t *testing.T) {
@@ -269,7 +269,7 @@ func Test_Limiter_Headers(t *testing.T) {
 
 	app.Handler()(fctx)
 
-	utils.AssertEqual(t, "50", string(fctx.Response.Header.Peek("X-RateLimit-Limit")))
+	require.Equal(t, "50", string(fctx.Response.Header.Peek("X-RateLimit-Limit")))
 	if v := string(fctx.Response.Header.Peek("X-RateLimit-Remaining")); v == "" {
 		t.Errorf("The X-RateLimit-Remaining header is not set correctly - value is an empty string.")
 	}
@@ -321,11 +321,11 @@ func Test_Sliding_Window(t *testing.T) {
 	singleRequest := func(shouldFail bool) {
 		resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
 		if shouldFail {
-			utils.AssertEqual(t, nil, err)
-			utils.AssertEqual(t, 429, resp.StatusCode)
+			require.NoError(t, err)
+			require.Equal(t, 429, resp.StatusCode)
 		} else {
-			utils.AssertEqual(t, nil, err)
-			utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+			require.NoError(t, err)
+			require.Equal(t, fiber.StatusOK, resp.StatusCode)
 		}
 	}
 

middleware/logger/logger_test.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/middleware/requestid"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/bytebufferpool"
 	"github.com/valyala/fasthttp"
 )
@@ -34,9 +34,9 @@ func Test_Logger(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusInternalServerError, resp.StatusCode)
-	utils.AssertEqual(t, "some random error", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusInternalServerError, resp.StatusCode)
+	require.Equal(t, "some random error", buf.String())
 }
 
 // go test -run Test_Logger_locals
@@ -66,23 +66,23 @@ func Test_Logger_locals(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "johndoe", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "johndoe", buf.String())
 
 	buf.Reset()
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/int", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "55", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "55", buf.String())
 
 	buf.Reset()
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/empty", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "", buf.String())
 }
 
 // go test -run Test_Logger_Next
@@ -95,8 +95,8 @@ func Test_Logger_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 // go test -run Test_Logger_ErrorTimeZone
@@ -107,8 +107,8 @@ func Test_Logger_ErrorTimeZone(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 type fakeOutput int
@@ -127,10 +127,10 @@ func Test_Logger_ErrorOutput(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 
-	utils.AssertEqual(t, 2, int(*o))
+	require.Equal(t, 2, int(*o))
 }
 
 // go test -run Test_Logger_All
@@ -148,11 +148,11 @@ func Test_Logger_All(t *testing.T) {
 	colors := app.Config().ColorScheme
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/?foo=bar", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 
 	expected := fmt.Sprintf("%dHost=example.comhttpHTTP/1.10.0.0.0example.com/?foo=bar/%s%s%s%s%s%s%s%s%sCannot GET /", os.Getpid(), colors.Black, colors.Red, colors.Green, colors.Yellow, colors.Blue, colors.Magenta, colors.Cyan, colors.White, colors.Reset)
-	utils.AssertEqual(t, expected, buf.String())
+	require.Equal(t, expected, buf.String())
 }
 
 // go test -run Test_Query_Params
@@ -167,11 +167,11 @@ func Test_Query_Params(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/?foo=bar&baz=moz", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 
 	expected := "foo=bar&baz=moz"
-	utils.AssertEqual(t, expected, buf.String())
+	require.Equal(t, expected, buf.String())
 }
 
 // go test -run Test_Response_Body
@@ -194,18 +194,18 @@ func Test_Response_Body(t *testing.T) {
 	})
 
 	_, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	expectedGetResponse := "Sample response body"
-	utils.AssertEqual(t, expectedGetResponse, buf.String())
+	require.Equal(t, expectedGetResponse, buf.String())
 
 	buf.Reset() // Reset buffer to test POST
 
 	_, err = app.Test(httptest.NewRequest("POST", "/test", nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	expectedPostResponse := "Post in test"
-	utils.AssertEqual(t, expectedPostResponse, buf.String())
+	require.Equal(t, expectedPostResponse, buf.String())
 }
 
 // go test -run Test_Logger_AppendUint
@@ -225,9 +225,9 @@ func Test_Logger_AppendUint(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "0 5 200", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "0 5 200", buf.String())
 }
 
 // go test -run Test_Logger_Data_Race -race
@@ -256,10 +256,10 @@ func Test_Logger_Data_Race(t *testing.T) {
 	resp2, err2 = app.Test(httptest.NewRequest("GET", "/", nil))
 	wg.Wait()
 
-	utils.AssertEqual(t, nil, err1)
-	utils.AssertEqual(t, fiber.StatusOK, resp1.StatusCode)
-	utils.AssertEqual(t, nil, err2)
-	utils.AssertEqual(t, fiber.StatusOK, resp2.StatusCode)
+	require.Nil(t, err1)
+	require.Equal(t, fiber.StatusOK, resp1.StatusCode)
+	require.Nil(t, err2)
+	require.Equal(t, fiber.StatusOK, resp2.StatusCode)
 }
 
 // go test -v -run=^$ -bench=Benchmark_Logger -benchmem -count=4
@@ -287,7 +287,7 @@ func Benchmark_Logger(b *testing.B) {
 		h(fctx)
 	}
 
-	utils.AssertEqual(b, 200, fctx.Response.Header.StatusCode())
+	require.Equal(b, 200, fctx.Response.Header.StatusCode())
 }
 
 // go test -run Test_Response_Header
@@ -312,9 +312,9 @@ func Test_Response_Header(t *testing.T) {
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
 
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "Hello fiber!", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "Hello fiber!", buf.String())
 }
 
 // go test -run Test_Req_Header
@@ -334,9 +334,9 @@ func Test_Req_Header(t *testing.T) {
 	headerReq.Header.Add("test", "Hello fiber!")
 	resp, err := app.Test(headerReq)
 
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "Hello fiber!", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "Hello fiber!", buf.String())
 }
 
 // go test -run Test_ReqHeader_Header
@@ -356,7 +356,7 @@ func Test_ReqHeader_Header(t *testing.T) {
 	reqHeaderReq.Header.Add("test", "Hello fiber!")
 	resp, err := app.Test(reqHeaderReq)
 
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, "Hello fiber!", buf.String())
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, "Hello fiber!", buf.String())
 }

middleware/pprof/pprof_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_Non_Pprof_Path(t *testing.T) {
@@ -20,12 +20,12 @@ func Test_Non_Pprof_Path(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "escaped", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "escaped", string(b))
 }
 
 func Test_Pprof_Index(t *testing.T) {
@@ -38,13 +38,13 @@ func Test_Pprof_Index(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/pprof/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 200, resp.StatusCode)
-	utils.AssertEqual(t, fiber.MIMETextHTMLCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
+	require.NoError(t, err)
+	require.Equal(t, 200, resp.StatusCode)
+	require.Equal(t, fiber.MIMETextHTMLCharsetUTF8, resp.Header.Get(fiber.HeaderContentType))
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, bytes.Contains(b, []byte("<title>/debug/pprof/</title>")))
+	require.NoError(t, err)
+	require.True(t, bytes.Contains(b, []byte("<title>/debug/pprof/</title>")))
 }
 
 func Test_Pprof_Subs(t *testing.T) {
@@ -68,8 +68,8 @@ func Test_Pprof_Subs(t *testing.T) {
 				target += "?seconds=1"
 			}
 			resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, target, nil), 5000)
-			utils.AssertEqual(t, nil, err)
-			utils.AssertEqual(t, 200, resp.StatusCode)
+			require.NoError(t, err)
+			require.Equal(t, 200, resp.StatusCode)
 		})
 	}
 }
@@ -84,8 +84,8 @@ func Test_Pprof_Other(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/pprof/302", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 302, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 302, resp.StatusCode)
 }
 
 // go test -run Test_Pprof_Next
@@ -101,6 +101,6 @@ func Test_Pprof_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/debug/pprof/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 404, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, 404, resp.StatusCode)
 }

middleware/proxy/proxy_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/internal/tlstest"
 	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func createProxyTestServer(handler fiber.Handler, t *testing.T) (*fiber.App, string) {
@@ -22,10 +23,10 @@ func createProxyTestServer(handler fiber.Handler, t *testing.T) (*fiber.App, str
 	target.Get("/", handler)
 
 	ln, err := net.Listen(fiber.NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	go func() {
-		utils.AssertEqual(t, nil, target.Listener(ln))
+		require.Nil(t, target.Listener(ln))
 	}()
 
 	time.Sleep(2 * time.Second)
@@ -40,7 +41,7 @@ func Test_Proxy_Empty_Upstream_Servers(t *testing.T) {
 
 	defer func() {
 		if r := recover(); r != nil {
-			utils.AssertEqual(t, "Servers cannot be empty", r)
+			require.Equal(t, "Servers cannot be empty", r)
 		}
 	}()
 	app := fiber.New()
@@ -60,8 +61,8 @@ func Test_Proxy_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 // go test -run Test_Proxy
@@ -73,8 +74,8 @@ func Test_Proxy(t *testing.T) {
 	)
 
 	resp, err := target.Test(httptest.NewRequest("GET", "/", nil), 2000)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusTeapot, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusTeapot, resp.StatusCode)
 
 	app := fiber.New(fiber.Config{DisableStartupMessage: true})
 
@@ -83,8 +84,8 @@ func Test_Proxy(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", nil)
 	req.Host = addr
 	resp, err = app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusTeapot, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusTeapot, resp.StatusCode)
 }
 
 // go test -run Test_Proxy_Balancer_WithTlsConfig
@@ -92,10 +93,10 @@ func Test_Proxy_Balancer_WithTlsConfig(t *testing.T) {
 	t.Parallel()
 
 	serverTLSConf, _, err := tlstest.GetTLSConfigs()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln, err := net.Listen(fiber.NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln = tls.NewListener(ln, serverTLSConf)
 
@@ -114,13 +115,13 @@ func Test_Proxy_Balancer_WithTlsConfig(t *testing.T) {
 		TlsConfig: clientTLSConf,
 	}))
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	code, body, errs := fiber.Get("https://" + addr + "/tlsbalaner").TLSConfig(clientTLSConf).String()
 
-	utils.AssertEqual(t, 0, len(errs))
-	utils.AssertEqual(t, fiber.StatusOK, code)
-	utils.AssertEqual(t, "tls balancer", body)
+	require.Equal(t, 0, len(errs))
+	require.Equal(t, fiber.StatusOK, code)
+	require.Equal(t, "tls balancer", body)
 }
 
 // go test -run Test_Proxy_Forward_WithTlsConfig_To_Http
@@ -132,10 +133,10 @@ func Test_Proxy_Forward_WithTlsConfig_To_Http(t *testing.T) {
 	}, t)
 
 	proxyServerTLSConf, _, err := tlstest.GetTLSConfigs()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	proxyServerLn, err := net.Listen(fiber.NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	proxyServerLn = tls.NewListener(proxyServerLn, proxyServerTLSConf)
 
@@ -145,16 +146,16 @@ func Test_Proxy_Forward_WithTlsConfig_To_Http(t *testing.T) {
 
 	app.Use(Forward("http://" + targetAddr))
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(proxyServerLn)) }()
+	go func() { require.Nil(t, app.Listener(proxyServerLn)) }()
 
 	code, body, errs := fiber.Get("https://" + proxyAddr).
 		InsecureSkipVerify().
 		Timeout(5 * time.Second).
 		String()
 
-	utils.AssertEqual(t, 0, len(errs))
-	utils.AssertEqual(t, fiber.StatusOK, code)
-	utils.AssertEqual(t, "hello from target", body)
+	require.Equal(t, 0, len(errs))
+	require.Equal(t, fiber.StatusOK, code)
+	require.Equal(t, "hello from target", body)
 }
 
 // go test -run Test_Proxy_Forward
@@ -170,12 +171,12 @@ func Test_Proxy_Forward(t *testing.T) {
 	app.Use(Forward("http://" + addr))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "forwarded", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "forwarded", string(b))
 }
 
 // go test -run Test_Proxy_Forward_WithTlsConfig
@@ -183,10 +184,10 @@ func Test_Proxy_Forward_WithTlsConfig(t *testing.T) {
 	t.Parallel()
 
 	serverTLSConf, _, err := tlstest.GetTLSConfigs()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln, err := net.Listen(fiber.NetworkTCP4, "127.0.0.1:0")
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	ln = tls.NewListener(ln, serverTLSConf)
 
@@ -203,13 +204,13 @@ func Test_Proxy_Forward_WithTlsConfig(t *testing.T) {
 	WithTlsConfig(clientTLSConf)
 	app.Use(Forward("https://" + addr + "/tlsfwd"))
 
-	go func() { utils.AssertEqual(t, nil, app.Listener(ln)) }()
+	go func() { require.Nil(t, app.Listener(ln)) }()
 
 	code, body, errs := fiber.Get("https://" + addr).TLSConfig(clientTLSConf).String()
 
-	utils.AssertEqual(t, 0, len(errs))
-	utils.AssertEqual(t, fiber.StatusOK, code)
-	utils.AssertEqual(t, "tls forward", body)
+	require.Equal(t, 0, len(errs))
+	require.Equal(t, fiber.StatusOK, code)
+	require.Equal(t, "tls forward", body)
 }
 
 // go test -run Test_Proxy_Modify_Response
@@ -230,12 +231,12 @@ func Test_Proxy_Modify_Response(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "modified response", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "modified response", string(b))
 }
 
 // go test -run Test_Proxy_Modify_Request
@@ -257,12 +258,12 @@ func Test_Proxy_Modify_Request(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "modified request", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "modified request", string(b))
 }
 
 // go test -run Test_Proxy_Timeout_Slow_Server
@@ -281,12 +282,12 @@ func Test_Proxy_Timeout_Slow_Server(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil), 5000)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "fiber is awesome", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "fiber is awesome", string(b))
 }
 
 // go test -run Test_Proxy_With_Timeout
@@ -305,12 +306,12 @@ func Test_Proxy_With_Timeout(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil), 2000)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusInternalServerError, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusInternalServerError, resp.StatusCode)
 
 	b, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "timeout", string(b))
+	require.NoError(t, err)
+	require.Equal(t, "timeout", string(b))
 }
 
 // go test -run Test_Proxy_Buffer_Size_Response
@@ -327,8 +328,8 @@ func Test_Proxy_Buffer_Size_Response(t *testing.T) {
 	app.Use(Balancer(Config{Servers: []string{addr}}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusInternalServerError, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusInternalServerError, resp.StatusCode)
 
 	app = fiber.New()
 	app.Use(Balancer(Config{
@@ -337,8 +338,8 @@ func Test_Proxy_Buffer_Size_Response(t *testing.T) {
 	}))
 
 	resp, err = app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 }
 
 // go test -race -run Test_Proxy_Do_RestoreOriginalURL
@@ -353,15 +354,15 @@ func Test_Proxy_Do_RestoreOriginalURL(t *testing.T) {
 		if err := Do(c, "/proxy"); err != nil {
 			return err
 		}
-		utils.AssertEqual(t, originalURL, c.OriginalURL())
+		require.Equal(t, originalURL, c.OriginalURL())
 		return c.SendString("ok")
 	})
 	_, err1 := app.Test(httptest.NewRequest("GET", "/test", nil))
 	// This test requires multiple requests due to zero allocation used in fiber
 	_, err2 := app.Test(httptest.NewRequest("GET", "/test", nil))
 
-	utils.AssertEqual(t, nil, err1)
-	utils.AssertEqual(t, nil, err2)
+	require.Nil(t, err1)
+	require.Nil(t, err2)
 }
 
 func Test_Proxy_Do_HTTP_Prefix_URL(t *testing.T) {
@@ -376,7 +377,7 @@ func Test_Proxy_Do_HTTP_Prefix_URL(t *testing.T) {
 		path := c.OriginalURL()
 		url := strings.TrimPrefix(path, "/")
 
-		utils.AssertEqual(t, "http://"+addr, url)
+		require.Equal(t, "http://"+addr, url)
 		if err := Do(c, url); err != nil {
 			return err
 		}
@@ -385,8 +386,8 @@ func Test_Proxy_Do_HTTP_Prefix_URL(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(http.MethodGet, "/http://"+addr, nil))
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	s, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, "hello world", string(s))
+	require.NoError(t, err)
+	require.Equal(t, "hello world", string(s))
 }

middleware/recover/recover_test.go

@@ -5,14 +5,14 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 // go test -run Test_Recover
 func Test_Recover(t *testing.T) {
 	app := fiber.New(fiber.Config{
 		ErrorHandler: func(c fiber.Ctx, err error) error {
-			utils.AssertEqual(t, "Hi, I'm an error!", err.Error())
+			require.Equal(t, "Hi, I'm an error!", err.Error())
 			return c.SendStatus(fiber.StatusTeapot)
 		},
 	})
@@ -24,8 +24,8 @@ func Test_Recover(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/panic", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusTeapot, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusTeapot, resp.StatusCode)
 }
 
 // go test -run Test_Recover_Next
@@ -38,8 +38,8 @@ func Test_Recover_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 func Test_Recover_EnableStackTrace(t *testing.T) {
@@ -53,6 +53,6 @@ func Test_Recover_EnableStackTrace(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/panic", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusInternalServerError, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusInternalServerError, resp.StatusCode)
 }

middleware/requestid/requestid_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 // go test -run Test_RequestID
@@ -19,19 +19,19 @@ func Test_RequestID(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 	reqid := resp.Header.Get(fiber.HeaderXRequestID)
-	utils.AssertEqual(t, 36, len(reqid))
+	require.Equal(t, 36, len(reqid))
 
 	req := httptest.NewRequest("GET", "/", nil)
 	req.Header.Add(fiber.HeaderXRequestID, reqid)
 
 	resp, err = app.Test(req)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
-	utils.AssertEqual(t, reqid, resp.Header.Get(fiber.HeaderXRequestID))
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
+	require.Equal(t, reqid, resp.Header.Get(fiber.HeaderXRequestID))
 }
 
 // go test -run Test_RequestID_Next
@@ -44,9 +44,9 @@ func Test_RequestID_Next(t *testing.T) {
 	}))
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, resp.Header.Get(fiber.HeaderXRequestID), "")
-	utils.AssertEqual(t, fiber.StatusNotFound, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, resp.Header.Get(fiber.HeaderXRequestID), "")
+	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
 // go test -run Test_RequestID_Locals
@@ -70,6 +70,6 @@ func Test_RequestID_Locals(t *testing.T) {
 	})
 
 	_, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, reqId, ctxVal)
+	require.NoError(t, err)
+	require.Equal(t, reqId, ctxVal)
 }

middleware/session/session.go

@@ -14,7 +14,7 @@ import (
 type Session struct {
 	id         string        // session id
 	fresh      bool          // if new session
-	ctx        fiber.Ctx    // fiber context
+	ctx        fiber.Ctx     // fiber context
 	config     *Store        // store configuration
 	data       *data         // key value data
 	byteBuffer *bytes.Buffer // byte buffer for the en- and decode

middleware/session/session_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/internal/storage/memory"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -28,55 +28,55 @@ func Test_Session(t *testing.T) {
 
 	// get session
 	sess, err := store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.NoError(t, err)
+	require.True(t, sess.Fresh())
 
 	// get keys
 	keys := sess.Keys()
-	utils.AssertEqual(t, []string{}, keys)
+	require.Equal(t, []string{}, keys)
 
 	// get value
 	name := sess.Get("name")
-	utils.AssertEqual(t, nil, name)
+	require.Nil(t, name)
 
 	// set value
 	sess.Set("name", "john")
 
 	// get value
 	name = sess.Get("name")
-	utils.AssertEqual(t, "john", name)
+	require.Equal(t, "john", name)
 
 	keys = sess.Keys()
-	utils.AssertEqual(t, []string{"name"}, keys)
+	require.Equal(t, []string{"name"}, keys)
 
 	// delete key
 	sess.Delete("name")
 
 	// get value
 	name = sess.Get("name")
-	utils.AssertEqual(t, nil, name)
+	require.Nil(t, name)
 
 	// get keys
 	keys = sess.Keys()
-	utils.AssertEqual(t, []string{}, keys)
+	require.Equal(t, []string{}, keys)
 
 	// get id
 	id := sess.ID()
-	utils.AssertEqual(t, "123", id)
+	require.Equal(t, "123", id)
 
 	// save the old session first
 	err = sess.Save()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	// requesting entirely new context to prevent falsy tests
 	ctx = app.NewCtx(&fasthttp.RequestCtx{})
 
 	sess, err = store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.NoError(t, err)
+	require.True(t, sess.Fresh())
 
 	// this id should be randomly generated as session key was deleted
-	utils.AssertEqual(t, 36, len(sess.ID()))
+	require.Equal(t, 36, len(sess.ID()))
 
 	// when we use the original session for the second time
 	// the session be should be same if the session is not expired
@@ -85,9 +85,9 @@ func Test_Session(t *testing.T) {
 	// request the server with the old session
 	ctx.Request().Header.SetCookie(store.sessionName, id)
 	sess, err = store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, false, sess.Fresh())
-	utils.AssertEqual(t, sess.id, id)
+	require.NoError(t, err)
+	require.False(t, sess.Fresh())
+	require.Equal(t, sess.id, id)
 }
 
 // go test -run Test_Session_Types
@@ -108,8 +108,8 @@ func Test_Session_Types(t *testing.T) {
 
 	// get session
 	sess, err := store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.NoError(t, err)
+	require.True(t, sess.Fresh())
 
 	// the session string is no longer be 123
 	newSessionIDString := sess.ID()
@@ -166,34 +166,34 @@ func Test_Session_Types(t *testing.T) {
 
 	// save session
 	err = sess.Save()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	// get session
 	sess, err = store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, false, sess.Fresh())
+	require.NoError(t, err)
+	require.False(t, sess.Fresh())
 
 	// get value
-	utils.AssertEqual(t, vuser, sess.Get("vuser").(User))
-	utils.AssertEqual(t, vbool, sess.Get("vbool").(bool))
-	utils.AssertEqual(t, vstring, sess.Get("vstring").(string))
-	utils.AssertEqual(t, vint, sess.Get("vint").(int))
-	utils.AssertEqual(t, vint8, sess.Get("vint8").(int8))
-	utils.AssertEqual(t, vint16, sess.Get("vint16").(int16))
-	utils.AssertEqual(t, vint32, sess.Get("vint32").(int32))
-	utils.AssertEqual(t, vint64, sess.Get("vint64").(int64))
-	utils.AssertEqual(t, vuint, sess.Get("vuint").(uint))
-	utils.AssertEqual(t, vuint8, sess.Get("vuint8").(uint8))
-	utils.AssertEqual(t, vuint16, sess.Get("vuint16").(uint16))
-	utils.AssertEqual(t, vuint32, sess.Get("vuint32").(uint32))
-	utils.AssertEqual(t, vuint64, sess.Get("vuint64").(uint64))
-	utils.AssertEqual(t, vuintptr, sess.Get("vuintptr").(uintptr))
-	utils.AssertEqual(t, vbyte, sess.Get("vbyte").(byte))
-	utils.AssertEqual(t, vrune, sess.Get("vrune").(rune))
-	utils.AssertEqual(t, vfloat32, sess.Get("vfloat32").(float32))
-	utils.AssertEqual(t, vfloat64, sess.Get("vfloat64").(float64))
-	utils.AssertEqual(t, vcomplex64, sess.Get("vcomplex64").(complex64))
-	utils.AssertEqual(t, vcomplex128, sess.Get("vcomplex128").(complex128))
+	require.Equal(t, vuser, sess.Get("vuser").(User))
+	require.Equal(t, vbool, sess.Get("vbool").(bool))
+	require.Equal(t, vstring, sess.Get("vstring").(string))
+	require.Equal(t, vint, sess.Get("vint").(int))
+	require.Equal(t, vint8, sess.Get("vint8").(int8))
+	require.Equal(t, vint16, sess.Get("vint16").(int16))
+	require.Equal(t, vint32, sess.Get("vint32").(int32))
+	require.Equal(t, vint64, sess.Get("vint64").(int64))
+	require.Equal(t, vuint, sess.Get("vuint").(uint))
+	require.Equal(t, vuint8, sess.Get("vuint8").(uint8))
+	require.Equal(t, vuint16, sess.Get("vuint16").(uint16))
+	require.Equal(t, vuint32, sess.Get("vuint32").(uint32))
+	require.Equal(t, vuint64, sess.Get("vuint64").(uint64))
+	require.Equal(t, vuintptr, sess.Get("vuintptr").(uintptr))
+	require.Equal(t, vbyte, sess.Get("vbyte").(byte))
+	require.Equal(t, vrune, sess.Get("vrune").(rune))
+	require.Equal(t, vfloat32, sess.Get("vfloat32").(float32))
+	require.Equal(t, vfloat64, sess.Get("vfloat64").(float64))
+	require.Equal(t, vcomplex64, sess.Get("vcomplex64").(complex64))
+	require.Equal(t, vcomplex128, sess.Get("vcomplex128").(complex128))
 }
 
 // go test -run Test_Session_Store_Reset
@@ -209,7 +209,7 @@ func Test_Session_Store_Reset(t *testing.T) {
 	// get session
 	sess, _ := store.Get(ctx)
 	// make sure its new
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.True(t, sess.Fresh())
 	// set value & save
 	sess.Set("hello", "world")
 	ctx.Request().Header.SetCookie(store.sessionName, sess.ID())
@@ -220,8 +220,8 @@ func Test_Session_Store_Reset(t *testing.T) {
 
 	// make sure the session is recreated
 	sess, _ = store.Get(ctx)
-	utils.AssertEqual(t, true, sess.Fresh())
-	utils.AssertEqual(t, nil, sess.Get("hello"))
+	require.True(t, sess.Fresh())
+	require.Nil(t, sess.Get("hello"))
 }
 
 // go test -run Test_Session_Save
@@ -243,7 +243,7 @@ func Test_Session_Save(t *testing.T) {
 
 		// save session
 		err := sess.Save()
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("save to header", func(t *testing.T) {
@@ -263,9 +263,9 @@ func Test_Session_Save(t *testing.T) {
 
 		// save session
 		err := sess.Save()
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, store.getSessionID(ctx), string(ctx.Response().Header.Peek(store.sessionName)))
-		utils.AssertEqual(t, store.getSessionID(ctx), string(ctx.Request().Header.Peek(store.sessionName)))
+		require.NoError(t, err)
+		require.Equal(t, store.getSessionID(ctx), string(ctx.Response().Header.Peek(store.sessionName)))
+		require.Equal(t, store.getSessionID(ctx), string(ctx.Request().Header.Peek(store.sessionName)))
 	})
 }
 
@@ -290,18 +290,18 @@ func Test_Session_Save_Expiration(t *testing.T) {
 
 		// save session
 		err := sess.Save()
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		// here you need to get the old session yet
 		sess, _ = store.Get(ctx)
-		utils.AssertEqual(t, "john", sess.Get("name"))
+		require.Equal(t, "john", sess.Get("name"))
 
 		// just to make sure the session has been expired
 		time.Sleep(time.Second * 5)
 
 		// here you should get a new session
 		sess, _ = store.Get(ctx)
-		utils.AssertEqual(t, nil, sess.Get("name"))
+		require.Nil(t, sess.Get("name"))
 	})
 }
 
@@ -323,7 +323,7 @@ func Test_Session_Reset(t *testing.T) {
 		sess.Set("name", "fenny")
 		sess.Destroy()
 		name := sess.Get("name")
-		utils.AssertEqual(t, nil, name)
+		require.Nil(t, name)
 	})
 
 	t.Run("reset from header", func(t *testing.T) {
@@ -345,9 +345,9 @@ func Test_Session_Reset(t *testing.T) {
 		sess, _ = store.Get(ctx)
 
 		err := sess.Destroy()
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, "", string(ctx.Response().Header.Peek(store.sessionName)))
-		utils.AssertEqual(t, "", string(ctx.Request().Header.Peek(store.sessionName)))
+		require.NoError(t, err)
+		require.Equal(t, "", string(ctx.Response().Header.Peek(store.sessionName)))
+		require.Equal(t, "", string(ctx.Request().Header.Peek(store.sessionName)))
 	})
 }
 
@@ -356,11 +356,11 @@ func Test_Session_Custom_Config(t *testing.T) {
 	t.Parallel()
 
 	store := New(Config{Expiration: time.Hour, KeyGenerator: func() string { return "very random" }})
-	utils.AssertEqual(t, time.Hour, store.Expiration)
-	utils.AssertEqual(t, "very random", store.KeyGenerator())
+	require.Equal(t, time.Hour, store.Expiration)
+	require.Equal(t, "very random", store.KeyGenerator())
 
 	store = New(Config{Expiration: 0})
-	utils.AssertEqual(t, ConfigDefault.Expiration, store.Expiration)
+	require.Equal(t, ConfigDefault.Expiration, store.Expiration)
 }
 
 // go test -run Test_Session_Cookie
@@ -378,7 +378,7 @@ func Test_Session_Cookie(t *testing.T) {
 	sess.Save()
 
 	// cookie should be set on Save ( even if empty data )
-	utils.AssertEqual(t, 84, len(ctx.Response().Header.PeekCookie(store.sessionName)))
+	require.Equal(t, 84, len(ctx.Response().Header.PeekCookie(store.sessionName)))
 }
 
 // go test -run Test_Session_Cookie_In_Response
@@ -393,15 +393,15 @@ func Test_Session_Cookie_In_Response(t *testing.T) {
 	// get session
 	sess, _ := store.Get(ctx)
 	sess.Set("id", "1")
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.True(t, sess.Fresh())
 	sess.Save()
 
 	sess, _ = store.Get(ctx)
 	sess.Set("name", "john")
-	utils.AssertEqual(t, true, sess.Fresh())
+	require.True(t, sess.Fresh())
 
-	utils.AssertEqual(t, "1", sess.Get("id"))
-	utils.AssertEqual(t, "john", sess.Get("name"))
+	require.Equal(t, "1", sess.Get("id"))
+	require.Equal(t, "john", sess.Get("name"))
 }
 
 // go test -run Test_Session_Deletes_Single_Key
@@ -414,21 +414,21 @@ func Test_Session_Deletes_Single_Key(t *testing.T) {
 	ctx := app.NewCtx(&fasthttp.RequestCtx{})
 
 	sess, err := store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	ctx.Request().Header.SetCookie(store.sessionName, sess.ID())
 
 	sess.Set("id", "1")
-	utils.AssertEqual(t, nil, sess.Save())
+	require.Nil(t, sess.Save())
 
 	sess, err = store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 	sess.Delete("id")
-	utils.AssertEqual(t, nil, sess.Save())
+	require.Nil(t, sess.Save())
 
 	sess, err = store.Get(ctx)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, false, sess.Fresh())
-	utils.AssertEqual(t, nil, sess.Get("id"))
+	require.NoError(t, err)
+	require.False(t, sess.Fresh())
+	require.Nil(t, sess.Get("id"))
 }
 
 // go test -run Test_Session_Regenerate
@@ -446,29 +446,29 @@ func Test_Session_Regenerate(t *testing.T) {
 
 		// now the session is in the storage
 		freshSession, err := store.Get(ctx)
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		originalSessionUUIDString = freshSession.ID()
 
 		err = freshSession.Save()
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		// set cookie
 		ctx.Request().Header.SetCookie(store.sessionName, originalSessionUUIDString)
 
 		// as the session is in the storage, session.fresh should be false
 		acquiredSession, err := store.Get(ctx)
-		utils.AssertEqual(t, nil, err)
-		utils.AssertEqual(t, false, acquiredSession.Fresh())
+		require.NoError(t, err)
+		require.False(t, acquiredSession.Fresh())
 
 		err = acquiredSession.Regenerate()
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 
 		if acquiredSession.ID() == originalSessionUUIDString {
 			t.Fatal("regenerate should generate another different id")
 		}
 		// acquiredSession.fresh should be true after regenerating
-		utils.AssertEqual(t, true, acquiredSession.Fresh())
+		require.True(t, acquiredSession.Fresh())
 	})
 }
 

middleware/session/store_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -25,7 +25,7 @@ func TestStore_getSessionID(t *testing.T) {
 		// set cookie
 		ctx.Request().Header.SetCookie(store.sessionName, expectedID)
 
-		utils.AssertEqual(t, expectedID, store.getSessionID(ctx))
+		require.Equal(t, expectedID, store.getSessionID(ctx))
 	})
 
 	t.Run("from header", func(t *testing.T) {
@@ -39,7 +39,7 @@ func TestStore_getSessionID(t *testing.T) {
 		// set header
 		ctx.Request().Header.Set(store.sessionName, expectedID)
 
-		utils.AssertEqual(t, expectedID, store.getSessionID(ctx))
+		require.Equal(t, expectedID, store.getSessionID(ctx))
 	})
 
 	t.Run("from url query", func(t *testing.T) {
@@ -53,7 +53,7 @@ func TestStore_getSessionID(t *testing.T) {
 		// set url parameter
 		ctx.Request().SetRequestURI(fmt.Sprintf("/path?%s=%s", store.sessionName, expectedID))
 
-		utils.AssertEqual(t, expectedID, store.getSessionID(ctx))
+		require.Equal(t, expectedID, store.getSessionID(ctx))
 	})
 }
 
@@ -73,7 +73,7 @@ func TestStore_Get(t *testing.T) {
 		ctx.Request().Header.SetCookie(store.sessionName, unexpectedID)
 
 		acquiredSession, err := store.Get(ctx)
-		utils.AssertEqual(t, err, nil)
+		require.NoError(t, err)
 
 		if acquiredSession.ID() != unexpectedID {
 			t.Fatal("server should not accept the unexpectedID which is not in the store")

middleware/skip/skip_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/middleware/skip"
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 // go test -run Test_Skip
@@ -17,8 +17,8 @@ func Test_Skip(t *testing.T) {
 	app.Get("/", helloWorldHandler)
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusOK, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusOK, resp.StatusCode)
 }
 
 // go test -run Test_SkipFalse
@@ -29,8 +29,8 @@ func Test_SkipFalse(t *testing.T) {
 	app.Get("/", helloWorldHandler)
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusTeapot, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusTeapot, resp.StatusCode)
 }
 
 // go test -run Test_SkipNilFunc
@@ -41,8 +41,8 @@ func Test_SkipNilFunc(t *testing.T) {
 	app.Get("/", helloWorldHandler)
 
 	resp, err := app.Test(httptest.NewRequest("GET", "/", nil))
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, fiber.StatusTeapot, resp.StatusCode)
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusTeapot, resp.StatusCode)
 }
 
 func helloWorldHandler(c fiber.Ctx) error {

path_test.go

@@ -8,7 +8,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 // go test -race -run Test_Path_parseRoute
@@ -16,7 +16,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	var rp routeParser
 
 	rp = parseRoute("/shop/product/::filter/color::color/size::size")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/shop/product/:", Length: 15},
 			{IsParam: true, ParamName: "filter", ComparePart: "/color:", PartCount: 1},
@@ -29,7 +29,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/api/v1/:param/abc/*")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/api/v1/", Length: 8},
 			{IsParam: true, ParamName: "param", ComparePart: "/abc", PartCount: 1},
@@ -41,7 +41,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/v1/some/resource/name\\:customVerb")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/v1/some/resource/name:customVerb", Length: 33, IsLast: true},
 		},
@@ -49,7 +49,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/v1/some/resource/:name\\:customVerb")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/v1/some/resource/", Length: 18},
 			{IsParam: true, ParamName: "name", ComparePart: ":customVerb", PartCount: 1},
@@ -60,7 +60,7 @@ func Test_Path_parseRoute(t *testing.T) {
 
 	// heavy test with escaped charaters
 	rp = parseRoute("/v1/some/resource/name\\\\:customVerb?\\?/:param/*")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/v1/some/resource/name:customVerb??/", Length: 36},
 			{IsParam: true, ParamName: "param", ComparePart: "/", PartCount: 1},
@@ -72,7 +72,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/api/*/:param/:param2")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/api/", Length: 5, HasOptionalSlash: true},
 			{IsParam: true, ParamName: "*1", IsGreedy: true, IsOptional: true, ComparePart: "/", PartCount: 2},
@@ -86,7 +86,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/test:optional?:optional2?")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/test", Length: 5},
 			{IsParam: true, ParamName: "optional", IsOptional: true, Length: 1},
@@ -96,7 +96,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/config/+.json")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/config/", Length: 8},
 			{IsParam: true, ParamName: "+1", IsGreedy: true, IsOptional: false, ComparePart: ".json", PartCount: 1},
@@ -107,7 +107,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/api/:day.:month?.:year?")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/api/", Length: 5},
 			{IsParam: true, ParamName: "day", IsOptional: false, ComparePart: ".", PartCount: 2},
@@ -120,7 +120,7 @@ func Test_Path_parseRoute(t *testing.T) {
 	}, rp)
 
 	rp = parseRoute("/*v1*/proxy")
-	utils.AssertEqual(t, routeParser{
+	require.Equal(t, routeParser{
 		segs: []*routeSegment{
 			{Const: "/", Length: 1, HasOptionalSlash: true},
 			{IsParam: true, ParamName: "*1", IsGreedy: true, IsOptional: true, ComparePart: "v1", PartCount: 1},
@@ -131,6 +131,7 @@ func Test_Path_parseRoute(t *testing.T) {
 		params:        []string{"*1", "*2"},
 		wildCardCount: 2,
 	}, rp)
+
 }
 
 // go test -race -run Test_Path_matchParams
@@ -147,9 +148,9 @@ func Test_Path_matchParams(t *testing.T) {
 		parser := parseRoute(r)
 		for _, c := range cases {
 			match := parser.getMatch(c.url, c.url, &ctxParams, c.partialCheck)
-			utils.AssertEqual(t, c.match, match, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+			require.Equal(t, c.match, match, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 			if match && len(c.params) > 0 {
-				utils.AssertEqual(t, c.params[0:len(c.params)], ctxParams[0:len(c.params)], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+				require.Equal(t, c.params[0:len(c.params)], ctxParams[0:len(c.params)], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 			}
 		}
 	}
@@ -554,25 +555,25 @@ func Test_Path_matchParams(t *testing.T) {
 func Test_Utils_GetTrimmedParam(t *testing.T) {
 	t.Parallel()
 	res := GetTrimmedParam("")
-	utils.AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 	res = GetTrimmedParam("*")
-	utils.AssertEqual(t, "*", res)
+	require.Equal(t, "*", res)
 	res = GetTrimmedParam(":param")
-	utils.AssertEqual(t, "param", res)
+	require.Equal(t, "param", res)
 	res = GetTrimmedParam(":param1?")
-	utils.AssertEqual(t, "param1", res)
+	require.Equal(t, "param1", res)
 	res = GetTrimmedParam("noParam")
-	utils.AssertEqual(t, "noParam", res)
+	require.Equal(t, "noParam", res)
 }
 
 func Test_Utils_RemoveEscapeChar(t *testing.T) {
 	t.Parallel()
 	res := RemoveEscapeChar(":test\\:bla")
-	utils.AssertEqual(t, ":test:bla", res)
+	require.Equal(t, ":test:bla", res)
 	res = RemoveEscapeChar("\\abc")
-	utils.AssertEqual(t, "abc", res)
+	require.Equal(t, "abc", res)
 	res = RemoveEscapeChar("noEscapeChar")
-	utils.AssertEqual(t, "noEscapeChar", res)
+	require.Equal(t, "noEscapeChar", res)
 }
 
 // go test -race -run Test_Path_matchParams
@@ -599,9 +600,9 @@ func Benchmark_Path_matchParams(t *testing.B) {
 						matchRes = true
 					}
 				}
-				utils.AssertEqual(t, c.match, matchRes, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+				require.Equal(t, c.match, matchRes, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 				if matchRes && len(c.params) > 0 {
-					utils.AssertEqual(t, c.params[0:len(c.params)-1], ctxParams[0:len(c.params)-1], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+					require.Equal(t, c.params[0:len(c.params)-1], ctxParams[0:len(c.params)-1], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 				}
 			})
 
@@ -770,9 +771,9 @@ func Test_Path_matchParams0(t *testing.T) {
 		parser := parseRoute(r)
 		for _, c := range cases {
 			match := parser.getMatch(c.url, c.url, &ctxParams, c.partialCheck)
-			utils.AssertEqual(t, c.match, match, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+			require.Equal(t, c.match, match, fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 			if match && len(c.params) > 0 {
-				utils.AssertEqual(t, c.params[0:len(c.params)], ctxParams[0:len(c.params)], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
+				require.Equal(t, c.params[0:len(c.params)], ctxParams[0:len(c.params)], fmt.Sprintf("route: '%s', url: '%s'", r, c.url))
 			}
 		}
 	}

prefork_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_App_Prefork_Child_Process(t *testing.T) {
@@ -24,28 +24,28 @@ func Test_App_Prefork_Child_Process(t *testing.T) {
 	app := New()
 
 	err := app.prefork(NetworkTCP4, "invalid", nil)
-	utils.AssertEqual(t, false, err == nil)
+	require.False(t, err == nil)
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.prefork(NetworkTCP6, "[::1]:", nil))
+	require.Nil(t, app.prefork(NetworkTCP6, "[::1]:", nil))
 
 	// Create tls certificate
 	cer, err := tls.LoadX509KeyPair("./.github/testdata/ssl.pem", "./.github/testdata/ssl.key")
 	if err != nil {
-		utils.AssertEqual(t, nil, err)
+		require.NoError(t, err)
 	}
 	config := &tls.Config{Certificates: []tls.Certificate{cer}}
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.prefork(NetworkTCP4, "127.0.0.1:", config))
+	require.Nil(t, app.prefork(NetworkTCP4, "127.0.0.1:", config))
 }
 
 func Test_App_Prefork_Master_Process(t *testing.T) {
@@ -56,15 +56,15 @@ func Test_App_Prefork_Master_Process(t *testing.T) {
 
 	go func() {
 		time.Sleep(1000 * time.Millisecond)
-		utils.AssertEqual(t, nil, app.Shutdown())
+		require.Nil(t, app.Shutdown())
 	}()
 
-	utils.AssertEqual(t, nil, app.prefork(NetworkTCP4, ":3000", nil))
+	require.Nil(t, app.prefork(NetworkTCP4, ":3000", nil))
 
 	dummyChildCmd = "invalid"
 
 	err := app.prefork(NetworkTCP4, "127.0.0.1:", nil)
-	utils.AssertEqual(t, false, err == nil)
+	require.False(t, err == nil)
 }
 
 func Test_App_Prefork_Child_Process_Never_Show_Startup_Message(t *testing.T) {
@@ -75,27 +75,27 @@ func Test_App_Prefork_Child_Process_Never_Show_Startup_Message(t *testing.T) {
 	defer func() { os.Stdout = rescueStdout }()
 
 	r, w, err := os.Pipe()
-	utils.AssertEqual(t, nil, err)
+	require.NoError(t, err)
 
 	os.Stdout = w
 
 	New().startupProcess().startupMessage(":3000", false, "")
 
-	utils.AssertEqual(t, nil, w.Close())
+	require.Nil(t, w.Close())
 
 	out, err := io.ReadAll(r)
-	utils.AssertEqual(t, nil, err)
-	utils.AssertEqual(t, 0, len(out))
+	require.NoError(t, err)
+	require.Equal(t, 0, len(out))
 }
 
 func setupIsChild(t *testing.T) {
 	t.Helper()
 
-	utils.AssertEqual(t, nil, os.Setenv(envPreforkChildKey, envPreforkChildVal))
+	require.Nil(t, os.Setenv(envPreforkChildKey, envPreforkChildVal))
 }
 
 func teardownIsChild(t *testing.T) {
 	t.Helper()
 
-	utils.AssertEqual(t, nil, os.Setenv(envPreforkChildKey, ""))
+	require.Nil(t, os.Setenv(envPreforkChildKey, ""))
 }

router_test.go

@@ -17,6 +17,7 @@ import (
 	"testing"
 
 	"github.com/gofiber/fiber/v3/utils"
+	"github.com/stretchr/testify/require"
 	"github.com/valyala/fasthttp"
 )
 
@@ -40,21 +41,21 @@ func Test_Route_Match_SameLength(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/:param", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, ":param", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, ":param", app.getString(body))
 
 	// with param
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/test", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "test", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "test", app.getString(body))
 }
 
 func Test_Route_Match_Star(t *testing.T) {
@@ -65,21 +66,21 @@ func Test_Route_Match_Star(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/*", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "*", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "*", app.getString(body))
 
 	// with param
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/test", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "test", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "test", app.getString(body))
 
 	// without parameter
 	route := Route{
@@ -89,18 +90,18 @@ func Test_Route_Match_Star(t *testing.T) {
 	}
 	params := [maxParams]string{}
 	match := route.match("", "", &params)
-	utils.AssertEqual(t, true, match)
-	utils.AssertEqual(t, [maxParams]string{}, params)
+	require.True(t, match)
+	require.Equal(t, [maxParams]string{}, params)
 
 	// with parameter
 	match = route.match("/favicon.ico", "/favicon.ico", &params)
-	utils.AssertEqual(t, true, match)
-	utils.AssertEqual(t, [maxParams]string{"favicon.ico"}, params)
+	require.True(t, match)
+	require.Equal(t, [maxParams]string{"favicon.ico"}, params)
 
 	// without parameter again
 	match = route.match("", "", &params)
-	utils.AssertEqual(t, true, match)
-	utils.AssertEqual(t, [maxParams]string{}, params)
+	require.True(t, match)
+	require.Equal(t, [maxParams]string{}, params)
 }
 
 func Test_Route_Match_Root(t *testing.T) {
@@ -111,12 +112,12 @@ func Test_Route_Match_Root(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "root", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "root", app.getString(body))
 }
 
 func Test_Route_Match_Parser(t *testing.T) {
@@ -129,21 +130,21 @@ func Test_Route_Match_Parser(t *testing.T) {
 		return c.SendString(c.Params("*"))
 	})
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/foo/bar", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "bar", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "bar", app.getString(body))
 
 	// with star
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/Foobar/test", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "test", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "test", app.getString(body))
 }
 
 func Test_Route_Match_Middleware(t *testing.T) {
@@ -154,21 +155,21 @@ func Test_Route_Match_Middleware(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/foo/*", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "*", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "*", app.getString(body))
 
 	// with param
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo/bar/fasel", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "bar/fasel", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "bar/fasel", app.getString(body))
 }
 
 func Test_Route_Match_UnescapedPath(t *testing.T) {
@@ -179,22 +180,22 @@ func Test_Route_Match_UnescapedPath(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/cr%C3%A9er", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "test", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "test", app.getString(body))
 	// without special chars
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/créer", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 
 	// check deactivated behavior
 	app.config.UnescapePath = false
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/cr%C3%A9er", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusNotFound, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")
 }
 
 func Test_Route_Match_WithEscapeChar(t *testing.T) {
@@ -215,30 +216,30 @@ func Test_Route_Match_WithEscapeChar(t *testing.T) {
 
 	// check static route
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/v1/some/resource/name:customVerb", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "static", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "static", app.getString(body))
 
 	// check group route
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/v2/:firstVerb/:customVerb", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "group", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "group", app.getString(body))
 
 	// check param route
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/v3/awesome/name:customVerb", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "awesome", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "awesome", app.getString(body))
 }
 
 func Test_Route_Match_Middleware_HasPrefix(t *testing.T) {
@@ -249,12 +250,12 @@ func Test_Route_Match_Middleware_HasPrefix(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/foo/bar", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "middleware", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "middleware", app.getString(body))
 }
 
 func Test_Route_Match_Middleware_Root(t *testing.T) {
@@ -265,19 +266,19 @@ func Test_Route_Match_Middleware_Root(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/everything", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, "middleware", app.getString(body))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, "middleware", app.getString(body))
 }
 
 func Test_Router_Register_Missing_Handler(t *testing.T) {
 	app := New()
 	defer func() {
 		if err := recover(); err != nil {
-			utils.AssertEqual(t, "missing handler in route: /doe\n", fmt.Sprintf("%v", err))
+			require.Equal(t, "missing handler in route: /doe\n", fmt.Sprintf("%v", err))
 		}
 	}()
 	app.register("USE", "/doe")
@@ -286,11 +287,11 @@ func Test_Router_Register_Missing_Handler(t *testing.T) {
 func Test_Ensure_Router_Interface_Implementation(t *testing.T) {
 	var app any = (*App)(nil)
 	_, ok := app.(Router)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 
 	var group any = (*Group)(nil)
 	_, ok = group.(Router)
-	utils.AssertEqual(t, true, ok)
+	require.True(t, ok)
 }
 
 func Test_Router_Handler_Catch_Error(t *testing.T) {
@@ -307,7 +308,7 @@ func Test_Router_Handler_Catch_Error(t *testing.T) {
 
 	app.Handler()(c)
 
-	utils.AssertEqual(t, StatusInternalServerError, c.Response.Header.StatusCode())
+	require.Equal(t, StatusInternalServerError, c.Response.Header.StatusCode())
 }
 
 func Test_Route_Static_Root(t *testing.T) {
@@ -318,31 +319,31 @@ func Test_Route_Static_Root(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 
 	app = New()
 	app.Static("/", dir)
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 404, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 404, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 }
 
 func Test_Route_Static_HasPrefix(t *testing.T) {
@@ -353,20 +354,20 @@ func Test_Route_Static_HasPrefix(t *testing.T) {
 	})
 
 	resp, err := app.Test(httptest.NewRequest(MethodGet, "/static", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err := io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 
 	app = New()
 	app.Static("/static/", dir, Static{
@@ -374,58 +375,58 @@ func Test_Route_Static_HasPrefix(t *testing.T) {
 	})
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 
 	app = New()
 	app.Static("/static", dir)
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 404, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 404, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 404, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 404, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 
 	app = New()
 	app.Static("/static/", dir)
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 404, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 404, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 404, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 404, resp.StatusCode, "Status code")
 
 	resp, err = app.Test(httptest.NewRequest(MethodGet, "/static/style.css", nil))
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, 200, resp.StatusCode, "Status code")
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, 200, resp.StatusCode, "Status code")
 
 	body, err = io.ReadAll(resp.Body)
-	utils.AssertEqual(t, nil, err, "app.Test(req)")
-	utils.AssertEqual(t, true, strings.Contains(app.getString(body), "color"))
+	require.NoError(t, err, "app.Test(req)")
+	require.True(t, strings.Contains(app.getString(body), "color"))
 }
 
 //////////////////////////////////////////////
@@ -460,9 +461,9 @@ func Benchmark_App_MethodNotAllowed(b *testing.B) {
 		appHandler(c)
 	}
 	b.StopTimer()
-	utils.AssertEqual(b, 405, c.Response.StatusCode())
-	utils.AssertEqual(b, "GET, HEAD", string(c.Response.Header.Peek("Allow")))
-	utils.AssertEqual(b, utils.StatusMessage(StatusMethodNotAllowed), string(c.Response.Body()))
+	require.Equal(b, 405, c.Response.StatusCode())
+	require.Equal(b, "GET, HEAD", string(c.Response.Header.Peek("Allow")))
+	require.Equal(b, utils.StatusMessage(StatusMethodNotAllowed), string(c.Response.Body()))
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Router_NotFound -benchmem -count=4
@@ -482,8 +483,8 @@ func Benchmark_Router_NotFound(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		appHandler(c)
 	}
-	utils.AssertEqual(b, 404, c.Response.StatusCode())
-	utils.AssertEqual(b, "Cannot DELETE /this/route/does/not/exist", string(c.Response.Body()))
+	require.Equal(b, 404, c.Response.StatusCode())
+	require.Equal(b, "Cannot DELETE /this/route/does/not/exist", string(c.Response.Body()))
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Router_Handler -benchmem -count=4
@@ -597,9 +598,9 @@ func Benchmark_Router_Next(b *testing.B) {
 		c.indexRoute = -1
 		res, err = app.next(c, false)
 	}
-	utils.AssertEqual(b, nil, err)
-	utils.AssertEqual(b, true, res)
-	utils.AssertEqual(b, 4, c.indexRoute)
+	require.NoError(b, err)
+	require.True(b, res)
+	require.Equal(b, 4, c.indexRoute)
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Route_Match -benchmem -count=4
@@ -627,8 +628,8 @@ func Benchmark_Route_Match(b *testing.B) {
 		match = route.match("/user/keys/1337", "/user/keys/1337", &params)
 	}
 
-	utils.AssertEqual(b, true, match)
-	utils.AssertEqual(b, []string{"1337"}, params[0:len(parsed.params)])
+	require.True(b, match)
+	require.Equal(b, []string{"1337"}, params[0:len(parsed.params)])
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Route_Match_Star -benchmem -count=4
@@ -657,8 +658,8 @@ func Benchmark_Route_Match_Star(b *testing.B) {
 		match = route.match("/user/keys/bla", "/user/keys/bla", &params)
 	}
 
-	utils.AssertEqual(b, true, match)
-	utils.AssertEqual(b, []string{"user/keys/bla"}, params[0:len(parsed.params)])
+	require.True(b, match)
+	require.Equal(b, []string{"user/keys/bla"}, params[0:len(parsed.params)])
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Route_Match_Root -benchmem -count=4
@@ -688,8 +689,8 @@ func Benchmark_Route_Match_Root(b *testing.B) {
 		match = route.match("/", "/", &params)
 	}
 
-	utils.AssertEqual(b, true, match)
-	utils.AssertEqual(b, []string{}, params[0:len(parsed.params)])
+	require.True(b, match)
+	require.Equal(b, []string{}, params[0:len(parsed.params)])
 }
 
 // go test -v ./... -run=^$ -bench=Benchmark_Router_Handler_CaseSensitive -benchmem -count=4
@@ -778,8 +779,8 @@ func Benchmark_Router_Github_API(b *testing.B) {
 			app.ReleaseCtx(ctx)
 		}
 
-		utils.AssertEqual(b, nil, err)
-		utils.AssertEqual(b, true, match)
+		require.NoError(b, err)
+		require.True(b, match)
 	}
 }
 

utils/assertions.go

@@ -1,67 +0,0 @@
-// ⚡️ Fiber is an Express inspired web framework written in Go with ☕️
-// 🤖 Github Repository: https://github.com/gofiber/fiber
-// 📌 API Documentation: https://docs.gofiber.io
-
-package utils
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"testing"
-	"text/tabwriter"
-)
-
-// AssertEqual checks if values are equal
-func AssertEqual(tb testing.TB, expected, actual any, description ...string) {
-	if tb != nil {
-		tb.Helper()
-	}
-
-	if reflect.DeepEqual(expected, actual) {
-		return
-	}
-
-	aType := "<nil>"
-	bType := "<nil>"
-
-	if expected != nil {
-		aType = reflect.TypeOf(expected).String()
-	}
-	if actual != nil {
-		bType = reflect.TypeOf(actual).String()
-	}
-
-	testName := "AssertEqual"
-	if tb != nil {
-		testName = tb.Name()
-	}
-
-	_, file, line, _ := runtime.Caller(1)
-
-	var buf bytes.Buffer
-	w := tabwriter.NewWriter(&buf, 0, 0, 5, ' ', 0)
-	fmt.Fprintf(w, "\nTest:\t%s", testName)
-	fmt.Fprintf(w, "\nTrace:\t%s:%d", filepath.Base(file), line)
-	if len(description) > 0 {
-		fmt.Fprintf(w, "\nDescription:\t%s", description[0])
-	}
-	fmt.Fprintf(w, "\nExpect:\t%v\t(%s)", expected, aType)
-	fmt.Fprintf(w, "\nResult:\t%v\t(%s)", actual, bType)
-
-	result := ""
-	if err := w.Flush(); err != nil {
-		result = err.Error()
-	} else {
-		result = buf.String()
-	}
-
-	if tb != nil {
-		tb.Fatal(result)
-	} else {
-		log.Fatal(result)
-	}
-}

utils/assertions_test.go

@@ -1,14 +0,0 @@
-// ⚡️ Fiber is an Express inspired web framework written in Go with ☕️
-// 🤖 Github Repository: https://github.com/gofiber/fiber
-// 📌 API Documentation: https://docs.gofiber.io
-
-package utils
-
-import "testing"
-
-func Test_AssertEqual(t *testing.T) {
-	t.Parallel()
-	AssertEqual(nil, []string{}, []string{})
-	AssertEqual(t, []string{}, []string{})
-	AssertEqual(t, []byte("aq"), []byte("aq"))
-}

utils/bytes_test.go

@@ -7,15 +7,18 @@ package utils
 import (
 	"bytes"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ToLowerBytes(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, []byte("/my/name/is/:param/*"), ToLowerBytes([]byte("/MY/NAME/IS/:PARAM/*")))
-	AssertEqual(t, []byte("/my1/name/is/:param/*"), ToLowerBytes([]byte("/MY1/NAME/IS/:PARAM/*")))
-	AssertEqual(t, []byte("/my2/name/is/:param/*"), ToLowerBytes([]byte("/MY2/NAME/IS/:PARAM/*")))
-	AssertEqual(t, []byte("/my3/name/is/:param/*"), ToLowerBytes([]byte("/MY3/NAME/IS/:PARAM/*")))
-	AssertEqual(t, []byte("/my4/name/is/:param/*"), ToLowerBytes([]byte("/MY4/NAME/IS/:PARAM/*")))
+
+	require.Equal(t, []byte("/my/name/is/:param/*"), ToLowerBytes([]byte("/MY/NAME/IS/:PARAM/*")))
+	require.Equal(t, []byte("/my1/name/is/:param/*"), ToLowerBytes([]byte("/MY1/NAME/IS/:PARAM/*")))
+	require.Equal(t, []byte("/my2/name/is/:param/*"), ToLowerBytes([]byte("/MY2/NAME/IS/:PARAM/*")))
+	require.Equal(t, []byte("/my3/name/is/:param/*"), ToLowerBytes([]byte("/MY3/NAME/IS/:PARAM/*")))
+	require.Equal(t, []byte("/my4/name/is/:param/*"), ToLowerBytes([]byte("/MY4/NAME/IS/:PARAM/*")))
 }
 
 func Benchmark_ToLowerBytes(b *testing.B) {
@@ -26,23 +29,24 @@ func Benchmark_ToLowerBytes(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = ToLowerBytes(path)
 		}
-		AssertEqual(b, want, res)
+		require.Equal(b, bytes.Equal(want, res), true)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = bytes.ToLower(path)
 		}
-		AssertEqual(b, want, res)
+		require.Equal(b, bytes.Equal(want, res), true)
 	})
 }
 
 func Test_ToUpperBytes(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, []byte("/MY/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my/name/is/:param/*")))
-	AssertEqual(t, []byte("/MY1/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my1/name/is/:param/*")))
-	AssertEqual(t, []byte("/MY2/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my2/name/is/:param/*")))
-	AssertEqual(t, []byte("/MY3/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my3/name/is/:param/*")))
-	AssertEqual(t, []byte("/MY4/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my4/name/is/:param/*")))
+
+	require.Equal(t, []byte("/MY/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my/name/is/:param/*")))
+	require.Equal(t, []byte("/MY1/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my1/name/is/:param/*")))
+	require.Equal(t, []byte("/MY2/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my2/name/is/:param/*")))
+	require.Equal(t, []byte("/MY3/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my3/name/is/:param/*")))
+	require.Equal(t, []byte("/MY4/NAME/IS/:PARAM/*"), ToUpperBytes([]byte("/my4/name/is/:param/*")))
 }
 
 func Benchmark_ToUpperBytes(b *testing.B) {
@@ -53,12 +57,12 @@ func Benchmark_ToUpperBytes(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = ToUpperBytes(path)
 		}
-		AssertEqual(b, want, res)
+		require.Equal(b, want, res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = bytes.ToUpper(path)
 		}
-		AssertEqual(b, want, res)
+		require.Equal(b, want, res)
 	})
 }

utils/byteseq_test.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Benchmark_EqualFoldBytes(b *testing.B) {
@@ -14,34 +16,16 @@ func Benchmark_EqualFoldBytes(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = EqualFold(left, right)
 		}
-		AssertEqual(b, true, res)
+		require.True(b, res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = bytes.EqualFold(left, right)
 		}
-		AssertEqual(b, true, res)
+		require.True(b, res)
 	})
 }
 
-func Test_EqualFoldBytes(t *testing.T) {
-	t.Parallel()
-	res := EqualFold([]byte("/MY/NAME/IS/:PARAM/*"), []byte("/my/name/is/:param/*"))
-	AssertEqual(t, true, res)
-	res = EqualFold([]byte("/MY1/NAME/IS/:PARAM/*"), []byte("/MY1/NAME/IS/:PARAM/*"))
-	AssertEqual(t, true, res)
-	res = EqualFold([]byte("/my2/name/is/:param/*"), []byte("/my2/name"))
-	AssertEqual(t, false, res)
-	res = EqualFold([]byte("/dddddd"), []byte("eeeeee"))
-	AssertEqual(t, false, res)
-	res = EqualFold([]byte("\na"), []byte("*A"))
-	AssertEqual(t, false, res)
-	res = EqualFold([]byte("/MY3/NAME/IS/:PARAM/*"), []byte("/my3/name/is/:param/*"))
-	AssertEqual(t, true, res)
-	res = EqualFold([]byte("/MY4/NAME/IS/:PARAM/*"), []byte("/my4/nAME/IS/:param/*"))
-	AssertEqual(t, true, res)
-}
-
 // go test -v -run=^$ -bench=Benchmark_EqualFold -benchmem -count=4 ./utils/
 func Benchmark_EqualFold(b *testing.B) {
 	var res bool
@@ -49,13 +33,13 @@ func Benchmark_EqualFold(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = EqualFold(upperStr, lowerStr)
 		}
-		AssertEqual(b, true, res)
+		require.True(b, res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = strings.EqualFold(upperStr, lowerStr)
 		}
-		AssertEqual(b, true, res)
+		require.True(b, res)
 	})
 }
 
@@ -78,9 +62,9 @@ func Test_EqualFold(t *testing.T) {
 
 	for _, tc := range testCases {
 		res := EqualFold[string](tc.S1, tc.S2)
-		AssertEqual(t, tc.Expected, res, "string")
+		require.Equal(t, tc.Expected, res, "string")
 
 		res = EqualFold[[]byte]([]byte(tc.S1), []byte(tc.S2))
-		AssertEqual(t, tc.Expected, res, "bytes")
+		require.Equal(t, tc.Expected, res, "bytes")
 	}
 }

utils/common_test.go

@@ -8,23 +8,25 @@ import (
 	"crypto/rand"
 	"fmt"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_FunctionName(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, "github.com/gofiber/fiber/v3/utils.Test_UUID", FunctionName(Test_UUID))
+	require.Equal(t, "github.com/gofiber/fiber/v3/utils.Test_UUID", FunctionName(Test_UUID))
 
-	AssertEqual(t, "github.com/gofiber/fiber/v3/utils.Test_FunctionName.func1", FunctionName(func() {}))
+	require.Equal(t, "github.com/gofiber/fiber/v3/utils.Test_FunctionName.func1", FunctionName(func() {}))
 
 	dummyint := 20
-	AssertEqual(t, "int", FunctionName(dummyint))
+	require.Equal(t, "int", FunctionName(dummyint))
 }
 
 func Test_UUID(t *testing.T) {
 	t.Parallel()
 	res := UUID()
-	AssertEqual(t, 36, len(res))
-	AssertEqual(t, true, res != "00000000-0000-0000-0000-000000000000")
+	require.Equal(t, 36, len(res))
+	require.True(t, res != "00000000-0000-0000-0000-000000000000")
 }
 
 func Test_UUID_Concurrency(t *testing.T) {
@@ -42,14 +44,14 @@ func Test_UUID_Concurrency(t *testing.T) {
 		res = <-ch
 		results[res] = res
 	}
-	AssertEqual(t, iterations, len(results))
+	require.Equal(t, iterations, len(results))
 }
 
 func Test_UUIDv4(t *testing.T) {
 	t.Parallel()
 	res := UUIDv4()
-	AssertEqual(t, 36, len(res))
-	AssertEqual(t, true, res != "00000000-0000-0000-0000-000000000000")
+	require.Equal(t, 36, len(res))
+	require.True(t, res != "00000000-0000-0000-0000-000000000000")
 }
 
 func Test_UUIDv4_Concurrency(t *testing.T) {
@@ -67,7 +69,7 @@ func Test_UUIDv4_Concurrency(t *testing.T) {
 		res = <-ch
 		results[res] = res
 	}
-	AssertEqual(t, iterations, len(results))
+	require.Equal(t, iterations, len(results))
 }
 
 // go test -v -run=^$ -bench=Benchmark_UUID -benchmem -count=2
@@ -78,7 +80,7 @@ func Benchmark_UUID(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = UUID()
 		}
-		AssertEqual(b, 36, len(res))
+		require.Equal(b, 36, len(res))
 	})
 	b.Run("default", func(b *testing.B) {
 		rnd := make([]byte, 16)
@@ -86,32 +88,32 @@ func Benchmark_UUID(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = fmt.Sprintf("%x-%x-%x-%x-%x", rnd[0:4], rnd[4:6], rnd[6:8], rnd[8:10], rnd[10:])
 		}
-		AssertEqual(b, 36, len(res))
+		require.Equal(b, 36, len(res))
 	})
 }
 
 func Test_ConvertToBytes(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, 0, ConvertToBytes(""))
-	AssertEqual(t, 42, ConvertToBytes("42"))
-	AssertEqual(t, 42, ConvertToBytes("42b"))
-	AssertEqual(t, 42, ConvertToBytes("42B"))
-	AssertEqual(t, 42, ConvertToBytes("42 b"))
-	AssertEqual(t, 42, ConvertToBytes("42 B"))
+	require.Equal(t, 0, ConvertToBytes(""))
+	require.Equal(t, 42, ConvertToBytes("42"))
+	require.Equal(t, 42, ConvertToBytes("42b"))
+	require.Equal(t, 42, ConvertToBytes("42B"))
+	require.Equal(t, 42, ConvertToBytes("42 b"))
+	require.Equal(t, 42, ConvertToBytes("42 B"))
 
-	AssertEqual(t, 42*1000, ConvertToBytes("42k"))
-	AssertEqual(t, 42*1000, ConvertToBytes("42K"))
-	AssertEqual(t, 42*1000, ConvertToBytes("42kb"))
-	AssertEqual(t, 42*1000, ConvertToBytes("42KB"))
-	AssertEqual(t, 42*1000, ConvertToBytes("42 kb"))
-	AssertEqual(t, 42*1000, ConvertToBytes("42 KB"))
+	require.Equal(t, 42*1000, ConvertToBytes("42k"))
+	require.Equal(t, 42*1000, ConvertToBytes("42K"))
+	require.Equal(t, 42*1000, ConvertToBytes("42kb"))
+	require.Equal(t, 42*1000, ConvertToBytes("42KB"))
+	require.Equal(t, 42*1000, ConvertToBytes("42 kb"))
+	require.Equal(t, 42*1000, ConvertToBytes("42 KB"))
 
-	AssertEqual(t, 42*1000000, ConvertToBytes("42M"))
-	AssertEqual(t, int(42.5*1000000), ConvertToBytes("42.5MB"))
-	AssertEqual(t, 42*1000000000, ConvertToBytes("42G"))
+	require.Equal(t, 42*1000000, ConvertToBytes("42M"))
+	require.Equal(t, int(42.5*1000000), ConvertToBytes("42.5MB"))
+	require.Equal(t, 42*1000000000, ConvertToBytes("42G"))
 
-	AssertEqual(t, 0, ConvertToBytes("string"))
-	AssertEqual(t, 0, ConvertToBytes("MB"))
+	require.Equal(t, 0, ConvertToBytes("string"))
+	require.Equal(t, 0, ConvertToBytes("MB"))
 }
 
 // go test -v -run=^$ -bench=Benchmark_ConvertToBytes -benchmem -count=2
@@ -121,6 +123,6 @@ func Benchmark_ConvertToBytes(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = ConvertToBytes("42B")
 		}
-		AssertEqual(b, 42, res)
+		require.Equal(b, 42, res)
 	})
 }

utils/convert_test.go

@@ -4,12 +4,16 @@
 
 package utils
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
 
 func Test_UnsafeString(t *testing.T) {
 	t.Parallel()
 	res := UnsafeString([]byte("Hello, World!"))
-	AssertEqual(t, "Hello, World!", res)
+	require.Equal(t, "Hello, World!", res)
 }
 
 // go test -v -run=^$ -bench=UnsafeString -benchmem -count=2
@@ -21,20 +25,20 @@ func Benchmark_UnsafeString(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = UnsafeString(hello)
 		}
-		AssertEqual(b, "Hello, World!", res)
+		require.Equal(b, "Hello, World!", res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = string(hello)
 		}
-		AssertEqual(b, "Hello, World!", res)
+		require.Equal(b, "Hello, World!", res)
 	})
 }
 
 func Test_UnsafeBytes(t *testing.T) {
 	t.Parallel()
 	res := UnsafeBytes("Hello, World!")
-	AssertEqual(t, []byte("Hello, World!"), res)
+	require.Equal(t, []byte("Hello, World!"), res)
 }
 
 // go test -v -run=^$ -bench=UnsafeBytes -benchmem -count=4
@@ -46,30 +50,30 @@ func Benchmark_UnsafeBytes(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = UnsafeBytes(hello)
 		}
-		AssertEqual(b, []byte("Hello, World!"), res)
+		require.Equal(b, []byte("Hello, World!"), res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = []byte(hello)
 		}
-		AssertEqual(b, []byte("Hello, World!"), res)
+		require.Equal(b, []byte("Hello, World!"), res)
 	})
 }
 
 func Test_CopyString(t *testing.T) {
 	t.Parallel()
 	res := CopyString("Hello, World!")
-	AssertEqual(t, "Hello, World!", res)
+	require.Equal(t, "Hello, World!", res)
 }
 
 func Test_ToString(t *testing.T) {
 	t.Parallel()
 	res := ToString([]byte("Hello, World!"))
-	AssertEqual(t, "Hello, World!", res)
+	require.Equal(t, "Hello, World!", res)
 	res = ToString(true)
-	AssertEqual(t, "true", res)
+	require.Equal(t, "true", res)
 	res = ToString(uint(100))
-	AssertEqual(t, "100", res)
+	require.Equal(t, "100", res)
 }
 
 // go test -v -run=^$ -bench=ToString -benchmem -count=2

utils/http_test.go

@@ -8,24 +8,26 @@ import (
 	"mime"
 	"net/http"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_GetMIME(t *testing.T) {
 	t.Parallel()
 	res := GetMIME(".json")
-	AssertEqual(t, "application/json", res)
+	require.Equal(t, "application/json", res)
 
 	res = GetMIME(".xml")
-	AssertEqual(t, "application/xml", res)
+	require.Equal(t, "application/xml", res)
 
 	res = GetMIME("xml")
-	AssertEqual(t, "application/xml", res)
+	require.Equal(t, "application/xml", res)
 
 	res = GetMIME("unknown")
-	AssertEqual(t, MIMEOctetStream, res)
+	require.Equal(t, MIMEOctetStream, res)
 	// empty case
 	res = GetMIME("")
-	AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 }
 
 // go test -v -run=^$ -bench=Benchmark_GetMIME -benchmem -count=2
@@ -39,7 +41,7 @@ func Benchmark_GetMIME(b *testing.B) {
 			res = GetMIME(".exe")
 			res = GetMIME(".json")
 		}
-		AssertEqual(b, "application/json", res)
+		require.Equal(b, "application/json", res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
@@ -49,7 +51,7 @@ func Benchmark_GetMIME(b *testing.B) {
 			res = mime.TypeByExtension(".exe")
 			res = mime.TypeByExtension(".json")
 		}
-		AssertEqual(b, "application/json", res)
+		require.Equal(b, "application/json", res)
 	})
 }
 
@@ -57,25 +59,25 @@ func Test_ParseVendorSpecificContentType(t *testing.T) {
 	t.Parallel()
 
 	cType := ParseVendorSpecificContentType("application/json")
-	AssertEqual(t, "application/json", cType)
+	require.Equal(t, "application/json", cType)
 
 	cType = ParseVendorSpecificContentType("multipart/form-data; boundary=dart-http-boundary-ZnVy.ICWq+7HOdsHqWxCFa8g3D.KAhy+Y0sYJ_lBADypu8po3_X")
-	AssertEqual(t, "multipart/form-data", cType)
+	require.Equal(t, "multipart/form-data", cType)
 
 	cType = ParseVendorSpecificContentType("multipart/form-data")
-	AssertEqual(t, "multipart/form-data", cType)
+	require.Equal(t, "multipart/form-data", cType)
 
 	cType = ParseVendorSpecificContentType("application/vnd.api+json; version=1")
-	AssertEqual(t, "application/json", cType)
+	require.Equal(t, "application/json", cType)
 
 	cType = ParseVendorSpecificContentType("application/vnd.api+json")
-	AssertEqual(t, "application/json", cType)
+	require.Equal(t, "application/json", cType)
 
 	cType = ParseVendorSpecificContentType("application/vnd.dummy+x-www-form-urlencoded")
-	AssertEqual(t, "application/x-www-form-urlencoded", cType)
+	require.Equal(t, "application/x-www-form-urlencoded", cType)
 
 	cType = ParseVendorSpecificContentType("something invalid")
-	AssertEqual(t, "something invalid", cType)
+	require.Equal(t, "something invalid", cType)
 }
 
 func Benchmark_ParseVendorSpecificContentType(b *testing.B) {
@@ -84,42 +86,42 @@ func Benchmark_ParseVendorSpecificContentType(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			cType = ParseVendorSpecificContentType("application/vnd.api+json; version=1")
 		}
-		AssertEqual(b, "application/json", cType)
+		require.Equal(b, "application/json", cType)
 	})
 
 	b.Run("defaultContentType", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			cType = ParseVendorSpecificContentType("application/json")
 		}
-		AssertEqual(b, "application/json", cType)
+		require.Equal(b, "application/json", cType)
 	})
 }
 
 func Test_StatusMessage(t *testing.T) {
 	t.Parallel()
 	res := StatusMessage(204)
-	AssertEqual(t, "No Content", res)
+	require.Equal(t, "No Content", res)
 
 	res = StatusMessage(404)
-	AssertEqual(t, "Not Found", res)
+	require.Equal(t, "Not Found", res)
 
 	res = StatusMessage(426)
-	AssertEqual(t, "Upgrade Required", res)
+	require.Equal(t, "Upgrade Required", res)
 
 	res = StatusMessage(511)
-	AssertEqual(t, "Network Authentication Required", res)
+	require.Equal(t, "Network Authentication Required", res)
 
 	res = StatusMessage(1337)
-	AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 
 	res = StatusMessage(-1)
-	AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 
 	res = StatusMessage(0)
-	AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 
 	res = StatusMessage(600)
-	AssertEqual(t, "", res)
+	require.Equal(t, "", res)
 }
 
 // go test -run=^$ -bench=Benchmark_StatusMessage -benchmem -count=2
@@ -129,12 +131,12 @@ func Benchmark_StatusMessage(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = StatusMessage(http.StatusNotExtended)
 		}
-		AssertEqual(b, "Not Extended", res)
+		require.Equal(b, "Not Extended", res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = http.StatusText(http.StatusNotExtended)
 		}
-		AssertEqual(b, "Not Extended", res)
+		require.Equal(b, "Not Extended", res)
 	})
 }

utils/json_test.go

@@ -3,6 +3,8 @@ package utils
 import (
 	"encoding/json"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 type sampleStructure struct {
@@ -21,9 +23,9 @@ func Test_GolangJSONEncoder(t *testing.T) {
 	)
 
 	raw, err := jsonEncoder(ss)
-	AssertEqual(t, err, nil)
+	require.NoError(t, err)
 
-	AssertEqual(t, string(raw), importantString)
+	require.Equal(t, string(raw), importantString)
 }
 
 func Test_DefaultJSONEncoder(t *testing.T) {
@@ -38,9 +40,9 @@ func Test_DefaultJSONEncoder(t *testing.T) {
 	)
 
 	raw, err := jsonEncoder(ss)
-	AssertEqual(t, err, nil)
+	require.NoError(t, err)
 
-	AssertEqual(t, string(raw), importantString)
+	require.Equal(t, string(raw), importantString)
 }
 
 func Test_DefaultJSONDecoder(t *testing.T) {
@@ -53,6 +55,6 @@ func Test_DefaultJSONDecoder(t *testing.T) {
 	)
 
 	err := jsonDecoder(importantString, &ss)
-	AssertEqual(t, err, nil)
-	AssertEqual(t, "Hello World", ss.ImportantString)
+	require.NoError(t, err)
+	require.Equal(t, "Hello World", ss.ImportantString)
 }

utils/strings_test.go

@@ -7,11 +7,13 @@ package utils
 import (
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ToUpper(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, "/MY/NAME/IS/:PARAM/*", ToUpper("/my/name/is/:param/*"))
+	require.Equal(t, "/MY/NAME/IS/:PARAM/*", ToUpper("/my/name/is/:param/*"))
 }
 
 const (
@@ -26,23 +28,23 @@ func Benchmark_ToUpper(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = ToUpper(largeStr)
 		}
-		AssertEqual(b, upperStr, res)
+		require.Equal(b, upperStr, res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = strings.ToUpper(largeStr)
 		}
-		AssertEqual(b, upperStr, res)
+		require.Equal(b, upperStr, res)
 	})
 }
 
 func Test_ToLower(t *testing.T) {
 	t.Parallel()
-	AssertEqual(t, "/my/name/is/:param/*", ToLower("/MY/NAME/IS/:PARAM/*"))
-	AssertEqual(t, "/my1/name/is/:param/*", ToLower("/MY1/NAME/IS/:PARAM/*"))
-	AssertEqual(t, "/my2/name/is/:param/*", ToLower("/MY2/NAME/IS/:PARAM/*"))
-	AssertEqual(t, "/my3/name/is/:param/*", ToLower("/MY3/NAME/IS/:PARAM/*"))
-	AssertEqual(t, "/my4/name/is/:param/*", ToLower("/MY4/NAME/IS/:PARAM/*"))
+	require.Equal(t, "/my/name/is/:param/*", ToLower("/MY/NAME/IS/:PARAM/*"))
+	require.Equal(t, "/my1/name/is/:param/*", ToLower("/MY1/NAME/IS/:PARAM/*"))
+	require.Equal(t, "/my2/name/is/:param/*", ToLower("/MY2/NAME/IS/:PARAM/*"))
+	require.Equal(t, "/my3/name/is/:param/*", ToLower("/MY3/NAME/IS/:PARAM/*"))
+	require.Equal(t, "/my4/name/is/:param/*", ToLower("/MY4/NAME/IS/:PARAM/*"))
 }
 
 func Benchmark_ToLower(b *testing.B) {
@@ -51,12 +53,12 @@ func Benchmark_ToLower(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = ToLower(largeStr)
 		}
-		AssertEqual(b, lowerStr, res)
+		require.Equal(b, lowerStr, res)
 	})
 	b.Run("default", func(b *testing.B) {
 		for n := 0; n < b.N; n++ {
 			res = strings.ToLower(largeStr)
 		}
-		AssertEqual(b, lowerStr, res)
+		require.Equal(b, lowerStr, res)
 	})
 }

utils/xml_test.go

@@ -3,6 +3,8 @@ package utils
 import (
 	"encoding/xml"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 type serversXMLStructure struct {
@@ -33,9 +35,9 @@ func Test_GolangXMLEncoder(t *testing.T) {
 	)
 
 	raw, err := xmlEncoder(ss)
-	AssertEqual(t, err, nil)
+	require.NoError(t, err)
 
-	AssertEqual(t, string(raw), xmlString)
+	require.Equal(t, string(raw), xmlString)
 }
 
 func Test_DefaultXMLEncoder(t *testing.T) {
@@ -53,7 +55,7 @@ func Test_DefaultXMLEncoder(t *testing.T) {
 	)
 
 	raw, err := xmlEncoder(ss)
-	AssertEqual(t, err, nil)
+	require.NoError(t, err)
 
-	AssertEqual(t, string(raw), xmlString)
+	require.Equal(t, string(raw), xmlString)
 }