tests: Convert from testify to quicktest

2 files changed, 41 insertions, 42 deletions

diff --git a/tpl/math/init_test.go b/tpl/math/init_test.go
index f1882c1a2..6c0ce0a93 100644
--- a/tpl/math/init_test.go
+++ b/tpl/math/init_test.go
@@ -16,12 +16,14 @@ package math
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/deps"
+	"github.com/gohugoio/hugo/htesting/hqt"
 	"github.com/gohugoio/hugo/tpl/internal"
-	"github.com/stretchr/testify/require"
 )
 
 func TestInit(t *testing.T) {
+	c := qt.New(t)
 	var found bool
 	var ns *internal.TemplateFuncsNamespace
 
@@ -33,6 +35,6 @@ func TestInit(t *testing.T) {
 		}
 	}
 
-	require.True(t, found)
-	require.IsType(t, &Namespace{}, ns.Context())
+	c.Assert(found, qt.Equals, true)
+	c.Assert(ns.Context(), hqt.IsSameType, &Namespace{})
 }
diff --git a/tpl/math/math_test.go b/tpl/math/math_test.go
index f2e6236af..0beec8204 100644
--- a/tpl/math/math_test.go
+++ b/tpl/math/math_test.go
@@ -14,20 +14,19 @@
 package math
 
 import (
-	"fmt"
 	"math"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestBasicNSArithmetic(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		fn     func(a, b interface{}) (interface{}, error)
 		a      interface{}
 		b      interface{}
@@ -42,26 +41,25 @@ func TestBasicNSArithmetic(t *testing.T) {
 		{ns.Div, 4, 2, int64(2)},
 		{ns.Div, 1.0, "foo", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := test.fn(test.a, test.b)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestCeil(t *testing.T) {
 	t.Parallel()
-
+	c := qt.New(t)
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		x      interface{}
 		expect interface{}
 	}{
@@ -75,26 +73,26 @@ func TestCeil(t *testing.T) {
 		{-1.5, -1.0},
 		{"abc", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.Ceil(test.x)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestFloor(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		x      interface{}
 		expect interface{}
 	}{
@@ -108,26 +106,26 @@ func TestFloor(t *testing.T) {
 		{-1.5, -2.0},
 		{"abc", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.Floor(test.x)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestLog(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		a      interface{}
 		expect interface{}
 	}{
@@ -138,12 +136,11 @@ func TestLog(t *testing.T) {
 		{3.1, float64(1.1314)},
 		{"abc", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.Log(test.a)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
@@ -153,17 +150,18 @@ func TestLog(t *testing.T) {
 			result = float64(int(result*10000)) / 10000
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestMod(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		a      interface{}
 		b      interface{}
 		expect interface{}
@@ -184,26 +182,26 @@ func TestMod(t *testing.T) {
 		{"aaa", "0", false},
 		{"3", "aaa", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.Mod(test.a, test.b)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestModBool(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		a      interface{}
 		b      interface{}
 		expect interface{}
@@ -230,26 +228,26 @@ func TestModBool(t *testing.T) {
 		{"aaa", "0", nil},
 		{"3", "aaa", nil},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.ModBool(test.a, test.b)
 
 		if test.expect == nil {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }
 
 func TestRound(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	ns := New()
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		x      interface{}
 		expect interface{}
 	}{
@@ -263,16 +261,15 @@ func TestRound(t *testing.T) {
 		{-1.5, -2.0},
 		{"abc", false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
 
 		result, err := ns.Round(test.x)
 
 		if b, ok := test.expect.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-		assert.Equal(t, test.expect, result, errMsg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
 	}
 }