From 9e571827055dedb46b78c5db3d17d6913f14870b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?=
 <bjorn.erik.pedersen@gmail.com>
Date: Sat, 10 Aug 2019 21:05:17 +0200
Subject: tests: Convert from testify to quicktest

---
 resources/page/page_data_test.go                 |  16 +--
 resources/page/page_kinds_test.go                |  23 ++--
 resources/page/pagegroup_test.go                 |   8 +-
 resources/page/pagemeta/page_frontmatter_test.go | 124 ++++++++++---------
 resources/page/pages_cache_test.go               |  21 ++--
 resources/page/pages_prev_next_test.go           |  30 +++--
 resources/page/pages_related_test.go             |  36 +++---
 resources/page/pages_sort_test.go                |  86 +++++++------
 resources/page/pages_test.go                     |  36 +++---
 resources/page/pagination_test.go                | 149 ++++++++++++-----------
 resources/page/permalinks_test.go                |  35 +++---
 11 files changed, 291 insertions(+), 273 deletions(-)

(limited to 'resources/page')

diff --git a/resources/page/page_data_test.go b/resources/page/page_data_test.go
index b6641bcd7..f161fad3c 100644
--- a/resources/page/page_data_test.go
+++ b/resources/page/page_data_test.go
@@ -19,15 +19,15 @@ import (
 
 	"text/template"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestPageData(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	data := make(Data)
 
-	assert.Nil(data.Pages())
+	c.Assert(data.Pages(), qt.IsNil)
 
 	pages := Pages{
 		&testPage{title: "a1"},
@@ -36,22 +36,22 @@ func TestPageData(t *testing.T) {
 
 	data["pages"] = pages
 
-	assert.Equal(pages, data.Pages())
+	c.Assert(data.Pages(), eq, pages)
 
 	data["pages"] = func() Pages {
 		return pages
 	}
 
-	assert.Equal(pages, data.Pages())
+	c.Assert(data.Pages(), eq, pages)
 
 	templ, err := template.New("").Parse(`Pages: {{ .Pages }}`)
 
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	var buff bytes.Buffer
 
-	assert.NoError(templ.Execute(&buff, data))
+	c.Assert(templ.Execute(&buff, data), qt.IsNil)
 
-	assert.Contains(buff.String(), "Pages(2)")
+	c.Assert(buff.String(), qt.Contains, "Pages(2)")
 
 }
diff --git a/resources/page/page_kinds_test.go b/resources/page/page_kinds_test.go
index 12f1c598e..7fba7e1d2 100644
--- a/resources/page/page_kinds_test.go
+++ b/resources/page/page_kinds_test.go
@@ -16,22 +16,23 @@ package page
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestKind(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	// Add tests for these constants to make sure they don't change
-	require.Equal(t, "page", KindPage)
-	require.Equal(t, "home", KindHome)
-	require.Equal(t, "section", KindSection)
-	require.Equal(t, "taxonomy", KindTaxonomy)
-	require.Equal(t, "taxonomyTerm", KindTaxonomyTerm)
+	c.Assert(KindPage, qt.Equals, "page")
+	c.Assert(KindHome, qt.Equals, "home")
+	c.Assert(KindSection, qt.Equals, "section")
+	c.Assert(KindTaxonomy, qt.Equals, "taxonomy")
+	c.Assert(KindTaxonomyTerm, qt.Equals, "taxonomyTerm")
 
-	require.Equal(t, KindTaxonomyTerm, GetKind("TAXONOMYTERM"))
-	require.Equal(t, KindTaxonomy, GetKind("Taxonomy"))
-	require.Equal(t, KindPage, GetKind("Page"))
-	require.Equal(t, KindHome, GetKind("Home"))
-	require.Equal(t, KindSection, GetKind("SEction"))
+	c.Assert(GetKind("TAXONOMYTERM"), qt.Equals, KindTaxonomyTerm)
+	c.Assert(GetKind("Taxonomy"), qt.Equals, KindTaxonomy)
+	c.Assert(GetKind("Page"), qt.Equals, KindPage)
+	c.Assert(GetKind("Home"), qt.Equals, KindHome)
+	c.Assert(GetKind("SEction"), qt.Equals, KindSection)
 
 }
diff --git a/resources/page/pagegroup_test.go b/resources/page/pagegroup_test.go
index 51ac09034..26a25c381 100644
--- a/resources/page/pagegroup_test.go
+++ b/resources/page/pagegroup_test.go
@@ -18,8 +18,8 @@ import (
 	"strings"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/cast"
-	"github.com/stretchr/testify/require"
 )
 
 type pageGroupTestObject struct {
@@ -204,7 +204,7 @@ func TestGroupByParamInReverseOrder(t *testing.T) {
 }
 
 func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	testStr := "TestString"
 	p := newTestPage()
 	p.params["custom_param"] = testStr
@@ -212,8 +212,8 @@ func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
 
 	groups, err := pages.GroupByParam("custom_param")
 
-	assert.NoError(err)
-	assert.Equal(testStr, groups[0].Key)
+	c.Assert(err, qt.IsNil)
+	c.Assert(groups[0].Key, qt.Equals, testStr)
 
 }
 
diff --git a/resources/page/pagemeta/page_frontmatter_test.go b/resources/page/pagemeta/page_frontmatter_test.go
index 313f704d9..f96d186da 100644
--- a/resources/page/pagemeta/page_frontmatter_test.go
+++ b/resources/page/pagemeta/page_frontmatter_test.go
@@ -14,7 +14,6 @@
 package pagemeta
 
 import (
-	"fmt"
 	"strings"
 	"testing"
 	"time"
@@ -22,14 +21,14 @@ import (
 	"github.com/gohugoio/hugo/resources/resource"
 	"github.com/spf13/viper"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestDateAndSlugFromBaseFilename(t *testing.T) {
 
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tests := []struct {
 		name string
@@ -50,15 +49,14 @@ func TestDateAndSlugFromBaseFilename(t *testing.T) {
 		{"asdfasdf.md", "0001-01-01", ""},
 	}
 
-	for i, test := range tests {
+	for _, test := range tests {
 		expecteFDate, err := time.Parse("2006-01-02", test.date)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
-		errMsg := fmt.Sprintf("Test %d", i)
 		gotDate, gotSlug := dateAndSlugFromBaseFilename(test.name)
 
-		assert.Equal(expecteFDate, gotDate, errMsg)
-		assert.Equal(test.slug, gotSlug, errMsg)
+		c.Assert(gotDate, qt.Equals, expecteFDate)
+		c.Assert(gotSlug, qt.Equals, test.slug)
 
 	}
 }
@@ -73,7 +71,7 @@ func newTestFd() *FrontMatterDescriptor {
 }
 
 func TestFrontMatterNewConfig(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cfg := viper.New()
 
@@ -85,20 +83,20 @@ func TestFrontMatterNewConfig(t *testing.T) {
 	})
 
 	fc, err := newFrontmatterConfig(cfg)
-	assert.NoError(err)
-	assert.Equal([]string{"publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
-	assert.Equal([]string{"publishdate", "pubdate", "published"}, fc.lastmod)
-	assert.Equal([]string{"lastmod", "modified"}, fc.expiryDate)
-	assert.Equal([]string{"date"}, fc.publishDate)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fc.date, qt.DeepEquals, []string{"publishdate", "pubdate", "published", "lastmod", "modified"})
+	c.Assert(fc.lastmod, qt.DeepEquals, []string{"publishdate", "pubdate", "published"})
+	c.Assert(fc.expiryDate, qt.DeepEquals, []string{"lastmod", "modified"})
+	c.Assert(fc.publishDate, qt.DeepEquals, []string{"date"})
 
 	// Default
 	cfg = viper.New()
 	fc, err = newFrontmatterConfig(cfg)
-	assert.NoError(err)
-	assert.Equal([]string{"date", "publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
-	assert.Equal([]string{":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"}, fc.lastmod)
-	assert.Equal([]string{"expirydate", "unpublishdate"}, fc.expiryDate)
-	assert.Equal([]string{"publishdate", "pubdate", "published", "date"}, fc.publishDate)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fc.date, qt.DeepEquals, []string{"date", "publishdate", "pubdate", "published", "lastmod", "modified"})
+	c.Assert(fc.lastmod, qt.DeepEquals, []string{":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"})
+	c.Assert(fc.expiryDate, qt.DeepEquals, []string{"expirydate", "unpublishdate"})
+	c.Assert(fc.publishDate, qt.DeepEquals, []string{"publishdate", "pubdate", "published", "date"})
 
 	// :default keyword
 	cfg.Set("frontmatter", map[string]interface{}{
@@ -108,16 +106,16 @@ func TestFrontMatterNewConfig(t *testing.T) {
 		"publishDate": []string{"d4", ":default"},
 	})
 	fc, err = newFrontmatterConfig(cfg)
-	assert.NoError(err)
-	assert.Equal([]string{"d1", "date", "publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
-	assert.Equal([]string{"d2", ":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"}, fc.lastmod)
-	assert.Equal([]string{"d3", "expirydate", "unpublishdate"}, fc.expiryDate)
-	assert.Equal([]string{"d4", "publishdate", "pubdate", "published", "date"}, fc.publishDate)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fc.date, qt.DeepEquals, []string{"d1", "date", "publishdate", "pubdate", "published", "lastmod", "modified"})
+	c.Assert(fc.lastmod, qt.DeepEquals, []string{"d2", ":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"})
+	c.Assert(fc.expiryDate, qt.DeepEquals, []string{"d3", "expirydate", "unpublishdate"})
+	c.Assert(fc.publishDate, qt.DeepEquals, []string{"d4", "publishdate", "pubdate", "published", "date"})
 
 }
 
 func TestFrontMatterDatesHandlers(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	for _, handlerID := range []string{":filename", ":fileModTime", ":git"} {
 
@@ -128,7 +126,7 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
 		})
 
 		handler, err := NewFrontmatterHandler(nil, cfg)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		d1, _ := time.Parse("2006-01-02", "2018-02-01")
 		d2, _ := time.Parse("2006-01-02", "2018-02-02")
@@ -143,15 +141,15 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
 			d.GitAuthorDate = d1
 		}
 		d.Frontmatter["date"] = d2
-		assert.NoError(handler.HandleDates(d))
-		assert.Equal(d1, d.Dates.FDate)
-		assert.Equal(d2, d.Params["date"])
+		c.Assert(handler.HandleDates(d), qt.IsNil)
+		c.Assert(d.Dates.FDate, qt.Equals, d1)
+		c.Assert(d.Params["date"], qt.Equals, d2)
 
 		d = newTestFd()
 		d.Frontmatter["date"] = d2
-		assert.NoError(handler.HandleDates(d))
-		assert.Equal(d2, d.Dates.FDate)
-		assert.Equal(d2, d.Params["date"])
+		c.Assert(handler.HandleDates(d), qt.IsNil)
+		c.Assert(d.Dates.FDate, qt.Equals, d2)
+		c.Assert(d.Params["date"], qt.Equals, d2)
 
 	}
 }
@@ -159,7 +157,7 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
 func TestFrontMatterDatesCustomConfig(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cfg := viper.New()
 	cfg.Set("frontmatter", map[string]interface{}{
@@ -169,10 +167,10 @@ func TestFrontMatterDatesCustomConfig(t *testing.T) {
 	})
 
 	handler, err := NewFrontmatterHandler(nil, cfg)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	testDate, err := time.Parse("2006-01-02", "2018-02-01")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	d := newTestFd()
 	d.Frontmatter["mydate"] = testDate
@@ -185,29 +183,29 @@ func TestFrontMatterDatesCustomConfig(t *testing.T) {
 	testDate = testDate.Add(24 * time.Hour)
 	d.Frontmatter["expirydate"] = testDate
 
-	assert.NoError(handler.HandleDates(d))
+	c.Assert(handler.HandleDates(d), qt.IsNil)
 
-	assert.Equal(1, d.Dates.FDate.Day())
-	assert.Equal(4, d.Dates.FLastmod.Day())
-	assert.Equal(4, d.Dates.FPublishDate.Day())
-	assert.Equal(5, d.Dates.FExpiryDate.Day())
+	c.Assert(d.Dates.FDate.Day(), qt.Equals, 1)
+	c.Assert(d.Dates.FLastmod.Day(), qt.Equals, 4)
+	c.Assert(d.Dates.FPublishDate.Day(), qt.Equals, 4)
+	c.Assert(d.Dates.FExpiryDate.Day(), qt.Equals, 5)
 
-	assert.Equal(d.Dates.FDate, d.Params["date"])
-	assert.Equal(d.Dates.FDate, d.Params["mydate"])
-	assert.Equal(d.Dates.FPublishDate, d.Params["publishdate"])
-	assert.Equal(d.Dates.FExpiryDate, d.Params["expirydate"])
+	c.Assert(d.Params["date"], qt.Equals, d.Dates.FDate)
+	c.Assert(d.Params["mydate"], qt.Equals, d.Dates.FDate)
+	c.Assert(d.Params["publishdate"], qt.Equals, d.Dates.FPublishDate)
+	c.Assert(d.Params["expirydate"], qt.Equals, d.Dates.FExpiryDate)
 
-	assert.False(handler.IsDateKey("date")) // This looks odd, but is configured like this.
-	assert.True(handler.IsDateKey("mydate"))
-	assert.True(handler.IsDateKey("publishdate"))
-	assert.True(handler.IsDateKey("pubdate"))
+	c.Assert(handler.IsDateKey("date"), qt.Equals, false) // This looks odd, but is configured like this.
+	c.Assert(handler.IsDateKey("mydate"), qt.Equals, true)
+	c.Assert(handler.IsDateKey("publishdate"), qt.Equals, true)
+	c.Assert(handler.IsDateKey("pubdate"), qt.Equals, true)
 
 }
 
 func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cfg := viper.New()
 
@@ -217,7 +215,7 @@ func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
 	})
 
 	handler, err := NewFrontmatterHandler(nil, cfg)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	testDate, _ := time.Parse("2006-01-02", "2018-02-01")
 	d := newTestFd()
@@ -226,27 +224,27 @@ func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
 	d.Frontmatter["mypubdate"] = testDate.Add(2 * 24 * time.Hour)
 	d.Frontmatter["publishdate"] = testDate.Add(3 * 24 * time.Hour)
 
-	assert.NoError(handler.HandleDates(d))
+	c.Assert(handler.HandleDates(d), qt.IsNil)
 
-	assert.Equal(1, d.Dates.FDate.Day())
-	assert.Equal(2, d.Dates.FLastmod.Day())
-	assert.Equal(4, d.Dates.FPublishDate.Day())
-	assert.True(d.Dates.FExpiryDate.IsZero())
+	c.Assert(d.Dates.FDate.Day(), qt.Equals, 1)
+	c.Assert(d.Dates.FLastmod.Day(), qt.Equals, 2)
+	c.Assert(d.Dates.FPublishDate.Day(), qt.Equals, 4)
+	c.Assert(d.Dates.FExpiryDate.IsZero(), qt.Equals, true)
 
 }
 
 func TestExpandDefaultValues(t *testing.T) {
-	assert := require.New(t)
-	assert.Equal([]string{"a", "b", "c", "d"}, expandDefaultValues([]string{"a", ":default", "d"}, []string{"b", "c"}))
-	assert.Equal([]string{"a", "b", "c"}, expandDefaultValues([]string{"a", "b", "c"}, []string{"a", "b", "c"}))
-	assert.Equal([]string{"b", "c", "a", "b", "c", "d"}, expandDefaultValues([]string{":default", "a", ":default", "d"}, []string{"b", "c"}))
+	c := qt.New(t)
+	c.Assert(expandDefaultValues([]string{"a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"a", "b", "c", "d"})
+	c.Assert(expandDefaultValues([]string{"a", "b", "c"}, []string{"a", "b", "c"}), qt.DeepEquals, []string{"a", "b", "c"})
+	c.Assert(expandDefaultValues([]string{":default", "a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"b", "c", "a", "b", "c", "d"})
 
 }
 
 func TestFrontMatterDateFieldHandler(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	handlers := new(frontmatterFieldHandlers)
 
@@ -256,7 +254,7 @@ func TestFrontMatterDateFieldHandler(t *testing.T) {
 	h := handlers.newDateFieldHandler("date", func(d *FrontMatterDescriptor, t time.Time) { d.Dates.FDate = t })
 
 	handled, err := h(fd)
-	assert.True(handled)
-	assert.NoError(err)
-	assert.Equal(d, fd.Dates.FDate)
+	c.Assert(handled, qt.Equals, true)
+	c.Assert(err, qt.IsNil)
+	c.Assert(fd.Dates.FDate, qt.Equals, d)
 }
diff --git a/resources/page/pages_cache_test.go b/resources/page/pages_cache_test.go
index b83283408..825bdc31f 100644
--- a/resources/page/pages_cache_test.go
+++ b/resources/page/pages_cache_test.go
@@ -19,11 +19,12 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestPageCache(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	c1 := newPageCache()
 
 	changeFirst := func(p Pages) {
@@ -50,21 +51,21 @@ func TestPageCache(t *testing.T) {
 			defer wg.Done()
 			for k, pages := range testPageSets {
 				l1.Lock()
-				p, c := c1.get("k1", nil, pages)
-				assert.Equal(t, !atomic.CompareAndSwapUint64(&o1, uint64(k), uint64(k+1)), c)
+				p, ca := c1.get("k1", nil, pages)
+				c.Assert(ca, qt.Equals, !atomic.CompareAndSwapUint64(&o1, uint64(k), uint64(k+1)))
 				l1.Unlock()
 				p2, c2 := c1.get("k1", nil, p)
-				assert.True(t, c2)
-				assert.True(t, pagesEqual(p, p2))
-				assert.True(t, pagesEqual(p, pages))
-				assert.NotNil(t, p)
+				c.Assert(c2, qt.Equals, true)
+				c.Assert(pagesEqual(p, p2), qt.Equals, true)
+				c.Assert(pagesEqual(p, pages), qt.Equals, true)
+				c.Assert(p, qt.Not(qt.IsNil))
 
 				l2.Lock()
 				p3, c3 := c1.get("k2", changeFirst, pages)
-				assert.Equal(t, !atomic.CompareAndSwapUint64(&o2, uint64(k), uint64(k+1)), c3)
+				c.Assert(c3, qt.Equals, !atomic.CompareAndSwapUint64(&o2, uint64(k), uint64(k+1)))
 				l2.Unlock()
-				assert.NotNil(t, p3)
-				assert.Equal(t, p3[0].(*testPage).description, "changed")
+				c.Assert(p3, qt.Not(qt.IsNil))
+				c.Assert("changed", qt.Equals, p3[0].(*testPage).description)
 			}
 		}()
 	}
diff --git a/resources/page/pages_prev_next_test.go b/resources/page/pages_prev_next_test.go
index c39ad0603..a75335f00 100644
--- a/resources/page/pages_prev_next_test.go
+++ b/resources/page/pages_prev_next_test.go
@@ -16,8 +16,8 @@ package page
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/cast"
-	"github.com/stretchr/testify/assert"
 )
 
 type pagePNTestObject struct {
@@ -36,18 +36,20 @@ var pagePNTestSources = []pagePNTestObject{
 
 func TestPrev(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	pages := preparePageGroupTestPages(t)
-	assert.Equal(t, pages.Prev(pages[0]), pages[4])
-	assert.Equal(t, pages.Prev(pages[1]), pages[0])
-	assert.Equal(t, pages.Prev(pages[4]), pages[3])
+	c.Assert(pages[4], qt.Equals, pages.Prev(pages[0]))
+	c.Assert(pages[0], qt.Equals, pages.Prev(pages[1]))
+	c.Assert(pages[3], qt.Equals, pages.Prev(pages[4]))
 }
 
 func TestNext(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	pages := preparePageGroupTestPages(t)
-	assert.Equal(t, pages.Next(pages[0]), pages[1])
-	assert.Equal(t, pages.Next(pages[1]), pages[2])
-	assert.Equal(t, pages.Next(pages[4]), pages[0])
+	c.Assert(pages[1], qt.Equals, pages.Next(pages[0]))
+	c.Assert(pages[2], qt.Equals, pages.Next(pages[1]))
+	c.Assert(pages[0], qt.Equals, pages.Next(pages[4]))
 }
 
 func prepareWeightedPagesPrevNext(t *testing.T) WeightedPages {
@@ -68,16 +70,18 @@ func prepareWeightedPagesPrevNext(t *testing.T) WeightedPages {
 
 func TestWeightedPagesPrev(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	w := prepareWeightedPagesPrevNext(t)
-	assert.Equal(t, w.Prev(w[0].Page), w[4].Page)
-	assert.Equal(t, w.Prev(w[1].Page), w[0].Page)
-	assert.Equal(t, w.Prev(w[4].Page), w[3].Page)
+	c.Assert(w[4].Page, qt.Equals, w.Prev(w[0].Page))
+	c.Assert(w[0].Page, qt.Equals, w.Prev(w[1].Page))
+	c.Assert(w[3].Page, qt.Equals, w.Prev(w[4].Page))
 }
 
 func TestWeightedPagesNext(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	w := prepareWeightedPagesPrevNext(t)
-	assert.Equal(t, w.Next(w[0].Page), w[1].Page)
-	assert.Equal(t, w.Next(w[1].Page), w[2].Page)
-	assert.Equal(t, w.Next(w[4].Page), w[0].Page)
+	c.Assert(w[1].Page, qt.Equals, w.Next(w[0].Page))
+	c.Assert(w[2].Page, qt.Equals, w.Next(w[1].Page))
+	c.Assert(w[0].Page, qt.Equals, w.Next(w[4].Page))
 }
diff --git a/resources/page/pages_related_test.go b/resources/page/pages_related_test.go
index 016b492c8..be75a62cd 100644
--- a/resources/page/pages_related_test.go
+++ b/resources/page/pages_related_test.go
@@ -19,11 +19,11 @@ import (
 
 	"github.com/gohugoio/hugo/common/types"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestRelated(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	t.Parallel()
 
@@ -53,28 +53,28 @@ func TestRelated(t *testing.T) {
 
 	result, err := pages.RelatedTo(types.NewKeyValuesStrings("keywords", "hugo", "rocks"))
 
-	assert.NoError(err)
-	assert.Len(result, 2)
-	assert.Equal("Page 2", result[0].Title())
-	assert.Equal("Page 1", result[1].Title())
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(result), qt.Equals, 2)
+	c.Assert(result[0].Title(), qt.Equals, "Page 2")
+	c.Assert(result[1].Title(), qt.Equals, "Page 1")
 
 	result, err = pages.Related(pages[0])
-	assert.NoError(err)
-	assert.Len(result, 2)
-	assert.Equal("Page 2", result[0].Title())
-	assert.Equal("Page 3", result[1].Title())
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(result), qt.Equals, 2)
+	c.Assert(result[0].Title(), qt.Equals, "Page 2")
+	c.Assert(result[1].Title(), qt.Equals, "Page 3")
 
 	result, err = pages.RelatedIndices(pages[0], "keywords")
-	assert.NoError(err)
-	assert.Len(result, 2)
-	assert.Equal("Page 2", result[0].Title())
-	assert.Equal("Page 3", result[1].Title())
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(result), qt.Equals, 2)
+	c.Assert(result[0].Title(), qt.Equals, "Page 2")
+	c.Assert(result[1].Title(), qt.Equals, "Page 3")
 
 	result, err = pages.RelatedTo(types.NewKeyValuesStrings("keywords", "bep", "rocks"))
-	assert.NoError(err)
-	assert.Len(result, 2)
-	assert.Equal("Page 2", result[0].Title())
-	assert.Equal("Page 3", result[1].Title())
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(result), qt.Equals, 2)
+	c.Assert(result[0].Title(), qt.Equals, "Page 2")
+	c.Assert(result[1].Title(), qt.Equals, "Page 3")
 }
 
 func mustParseDate(s string) time.Time {
diff --git a/resources/page/pages_sort_test.go b/resources/page/pages_sort_test.go
index c781de2f3..c9eb37c06 100644
--- a/resources/page/pages_sort_test.go
+++ b/resources/page/pages_sort_test.go
@@ -18,14 +18,22 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gohugoio/hugo/htesting/hqt"
+	"github.com/gohugoio/hugo/source"
+
 	"github.com/gohugoio/hugo/resources/resource"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
+var eq = qt.CmpEquals(hqt.DeepAllowUnexported(
+	&testPage{},
+	&source.FileInfo{},
+))
+
 func TestDefaultSort(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	d1 := time.Now()
 	d2 := d1.Add(-1 * time.Hour)
 	d3 := d1.Add(-2 * time.Hour)
@@ -37,31 +45,31 @@ func TestDefaultSort(t *testing.T) {
 	setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "c", "d"}, [4]int{4, 3, 2, 1}, p)
 	SortByDefault(p)
 
-	assert.Equal(t, 1, p[0].Weight())
+	c.Assert(p[0].Weight(), qt.Equals, 1)
 
 	// Consider zero weight, issue #2673
 	setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "d", "c"}, [4]int{0, 0, 0, 1}, p)
 	SortByDefault(p)
 
-	assert.Equal(t, 1, p[0].Weight())
+	c.Assert(p[0].Weight(), qt.Equals, 1)
 
 	// next by date
 	setSortVals([4]time.Time{d3, d4, d1, d2}, [4]string{"a", "b", "c", "d"}, [4]int{1, 1, 1, 1}, p)
 	SortByDefault(p)
-	assert.Equal(t, d1, p[0].Date())
+	c.Assert(p[0].Date(), qt.Equals, d1)
 
 	// finally by link title
 	setSortVals([4]time.Time{d3, d3, d3, d3}, [4]string{"b", "c", "a", "d"}, [4]int{1, 1, 1, 1}, p)
 	SortByDefault(p)
-	assert.Equal(t, "al", p[0].LinkTitle())
-	assert.Equal(t, "bl", p[1].LinkTitle())
-	assert.Equal(t, "cl", p[2].LinkTitle())
+	c.Assert(p[0].LinkTitle(), qt.Equals, "al")
+	c.Assert(p[1].LinkTitle(), qt.Equals, "bl")
+	c.Assert(p[2].LinkTitle(), qt.Equals, "cl")
 }
 
 // https://github.com/gohugoio/hugo/issues/4953
 func TestSortByLinkTitle(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 	pages := createSortTestPages(6)
 
 	for i, p := range pages {
@@ -81,11 +89,10 @@ func TestSortByLinkTitle(t *testing.T) {
 	bylt := pages.ByLinkTitle()
 
 	for i, p := range bylt {
-		msg := fmt.Sprintf("test: %d", i)
 		if i < 3 {
-			assert.Equal(fmt.Sprintf("linkTitle%d", i+3), p.LinkTitle(), msg)
+			c.Assert(p.LinkTitle(), qt.Equals, fmt.Sprintf("linkTitle%d", i+3))
 		} else {
-			assert.Equal(fmt.Sprintf("title%d", i-3), p.LinkTitle(), msg)
+			c.Assert(p.LinkTitle(), qt.Equals, fmt.Sprintf("title%d", i-3))
 		}
 	}
 }
@@ -124,30 +131,33 @@ func TestSortByN(t *testing.T) {
 
 func TestLimit(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	p := createSortTestPages(10)
 	firstFive := p.Limit(5)
-	assert.Equal(t, 5, len(firstFive))
+	c.Assert(len(firstFive), qt.Equals, 5)
 	for i := 0; i < 5; i++ {
-		assert.Equal(t, p[i], firstFive[i])
+		c.Assert(firstFive[i], qt.Equals, p[i])
 	}
-	assert.Equal(t, p, p.Limit(10))
-	assert.Equal(t, p, p.Limit(11))
+	c.Assert(p.Limit(10), eq, p)
+	c.Assert(p.Limit(11), eq, p)
 }
 
 func TestPageSortReverse(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	p1 := createSortTestPages(10)
-	assert.Equal(t, 0, p1[0].(*testPage).fuzzyWordCount)
-	assert.Equal(t, 9, p1[9].(*testPage).fuzzyWordCount)
+	c.Assert(p1[0].(*testPage).fuzzyWordCount, qt.Equals, 0)
+	c.Assert(p1[9].(*testPage).fuzzyWordCount, qt.Equals, 9)
 	p2 := p1.Reverse()
-	assert.Equal(t, 9, p2[0].(*testPage).fuzzyWordCount)
-	assert.Equal(t, 0, p2[9].(*testPage).fuzzyWordCount)
+	c.Assert(p2[0].(*testPage).fuzzyWordCount, qt.Equals, 9)
+	c.Assert(p2[9].(*testPage).fuzzyWordCount, qt.Equals, 0)
 	// cached
-	assert.True(t, pagesEqual(p2, p1.Reverse()))
+	c.Assert(pagesEqual(p2, p1.Reverse()), qt.Equals, true)
 }
 
 func TestPageSortByParam(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	var k interface{} = "arbitrarily.nested"
 
 	unsorted := createSortTestPages(10)
@@ -158,10 +168,10 @@ func TestPageSortByParam(t *testing.T) {
 	lastSetValue, _ := unsorted[8].Param(k)
 	unsetValue, _ := unsorted[9].Param(k)
 
-	assert.Equal(t, "xyz100", firstSetValue)
-	assert.Equal(t, "xyz99", secondSetValue)
-	assert.Equal(t, "xyz92", lastSetValue)
-	assert.Equal(t, nil, unsetValue)
+	c.Assert(firstSetValue, qt.Equals, "xyz100")
+	c.Assert(secondSetValue, qt.Equals, "xyz99")
+	c.Assert(lastSetValue, qt.Equals, "xyz92")
+	c.Assert(unsetValue, qt.Equals, nil)
 
 	sorted := unsorted.ByParam("arbitrarily.nested")
 	firstSetSortedValue, _ := sorted[0].Param(k)
@@ -169,14 +179,16 @@ func TestPageSortByParam(t *testing.T) {
 	lastSetSortedValue, _ := sorted[8].Param(k)
 	unsetSortedValue, _ := sorted[9].Param(k)
 
-	assert.Equal(t, firstSetValue, firstSetSortedValue)
-	assert.Equal(t, secondSetValue, lastSetSortedValue)
-	assert.Equal(t, lastSetValue, secondSetSortedValue)
-	assert.Equal(t, unsetValue, unsetSortedValue)
+	c.Assert(firstSetSortedValue, qt.Equals, firstSetValue)
+	c.Assert(lastSetSortedValue, qt.Equals, secondSetValue)
+	c.Assert(secondSetSortedValue, qt.Equals, lastSetValue)
+	c.Assert(unsetSortedValue, qt.Equals, unsetValue)
 }
 
 func TestPageSortByParamNumeric(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
+
 	var k interface{} = "arbitrarily.nested"
 
 	n := 10
@@ -200,10 +212,10 @@ func TestPageSortByParamNumeric(t *testing.T) {
 	lastSetValue, _ := unsorted[8].Param(k)
 	unsetValue, _ := unsorted[9].Param(k)
 
-	assert.Equal(t, 100, firstSetValue)
-	assert.Equal(t, 99, secondSetValue)
-	assert.Equal(t, 92, lastSetValue)
-	assert.Equal(t, nil, unsetValue)
+	c.Assert(firstSetValue, qt.Equals, 100)
+	c.Assert(secondSetValue, qt.Equals, 99)
+	c.Assert(lastSetValue, qt.Equals, 92)
+	c.Assert(unsetValue, qt.Equals, nil)
 
 	sorted := unsorted.ByParam("arbitrarily.nested")
 	firstSetSortedValue, _ := sorted[0].Param(k)
@@ -211,10 +223,10 @@ func TestPageSortByParamNumeric(t *testing.T) {
 	lastSetSortedValue, _ := sorted[8].Param(k)
 	unsetSortedValue, _ := sorted[9].Param(k)
 
-	assert.Equal(t, 92, firstSetSortedValue)
-	assert.Equal(t, 93, secondSetSortedValue)
-	assert.Equal(t, 100, lastSetSortedValue)
-	assert.Equal(t, unsetValue, unsetSortedValue)
+	c.Assert(firstSetSortedValue, qt.Equals, 92)
+	c.Assert(secondSetSortedValue, qt.Equals, 93)
+	c.Assert(lastSetSortedValue, qt.Equals, 100)
+	c.Assert(unsetSortedValue, qt.Equals, unsetValue)
 }
 
 func BenchmarkSortByWeightAndReverse(b *testing.B) {
diff --git a/resources/page/pages_test.go b/resources/page/pages_test.go
index c90d9f5d4..18b10f5bd 100644
--- a/resources/page/pages_test.go
+++ b/resources/page/pages_test.go
@@ -16,7 +16,7 @@ package page
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestProbablyEq(t *testing.T) {
@@ -27,50 +27,50 @@ func TestProbablyEq(t *testing.T) {
 	pages123 := Pages{p1, p2, p3}
 
 	t.Run("Pages", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
-		assert.True(pages12.ProbablyEq(pages12))
-		assert.False(pages123.ProbablyEq(pages12))
-		assert.False(pages12.ProbablyEq(pages21))
+		c.Assert(pages12.ProbablyEq(pages12), qt.Equals, true)
+		c.Assert(pages123.ProbablyEq(pages12), qt.Equals, false)
+		c.Assert(pages12.ProbablyEq(pages21), qt.Equals, false)
 	})
 
 	t.Run("PageGroup", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
-		assert.True(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "a", Pages: pages12}))
-		assert.False(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "b", Pages: pages12}))
+		c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "a", Pages: pages12}), qt.Equals, true)
+		c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "b", Pages: pages12}), qt.Equals, false)
 
 	})
 
 	t.Run("PagesGroup", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
 		pg1, pg2 := PageGroup{Key: "a", Pages: pages12}, PageGroup{Key: "b", Pages: pages123}
 
-		assert.True(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg1, pg2}))
-		assert.False(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg2, pg1}))
+		c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg1, pg2}), qt.Equals, true)
+		c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg2, pg1}), qt.Equals, false)
 
 	})
 
 }
 
 func TestToPages(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	p1, p2 := &testPage{title: "p1"}, &testPage{title: "p2"}
 	pages12 := Pages{p1, p2}
 
 	mustToPages := func(in interface{}) Pages {
 		p, err := ToPages(in)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		return p
 	}
 
-	assert.Equal(Pages{}, mustToPages(nil))
-	assert.Equal(pages12, mustToPages(pages12))
-	assert.Equal(pages12, mustToPages([]Page{p1, p2}))
-	assert.Equal(pages12, mustToPages([]interface{}{p1, p2}))
+	c.Assert(mustToPages(nil), eq, Pages{})
+	c.Assert(mustToPages(pages12), eq, pages12)
+	c.Assert(mustToPages([]Page{p1, p2}), eq, pages12)
+	c.Assert(mustToPages([]interface{}{p1, p2}), eq, pages12)
 
 	_, err := ToPages("not a page")
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 }
diff --git a/resources/page/pagination_test.go b/resources/page/pagination_test.go
index 1308d60d1..f4441a892 100644
--- a/resources/page/pagination_test.go
+++ b/resources/page/pagination_test.go
@@ -20,43 +20,44 @@ import (
 
 	"github.com/spf13/viper"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/output"
-	"github.com/stretchr/testify/require"
 )
 
 func TestSplitPages(t *testing.T) {
 	t.Parallel()
-
+	c := qt.New(t)
 	pages := createTestPages(21)
 	chunks := splitPages(pages, 5)
-	require.Equal(t, 5, len(chunks))
+	c.Assert(len(chunks), qt.Equals, 5)
 
 	for i := 0; i < 4; i++ {
-		require.Equal(t, 5, chunks[i].Len())
+		c.Assert(chunks[i].Len(), qt.Equals, 5)
 	}
 
 	lastChunk := chunks[4]
-	require.Equal(t, 1, lastChunk.Len())
+	c.Assert(lastChunk.Len(), qt.Equals, 1)
 
 }
 
 func TestSplitPageGroups(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	pages := createTestPages(21)
 	groups, _ := pages.GroupBy("Weight", "desc")
 	chunks := splitPageGroups(groups, 5)
-	require.Equal(t, 5, len(chunks))
+	c.Assert(len(chunks), qt.Equals, 5)
 
 	firstChunk := chunks[0]
 
 	// alternate weight 5 and 10
 	if groups, ok := firstChunk.(PagesGroup); ok {
-		require.Equal(t, 5, groups.Len())
+		c.Assert(groups.Len(), qt.Equals, 5)
 		for _, pg := range groups {
 			// first group 10 in weight
-			require.Equal(t, 10, pg.Key)
+			c.Assert(pg.Key, qt.Equals, 10)
 			for _, p := range pg.Pages {
-				require.True(t, p.FuzzyWordCount()%2 == 0) // magic test
+				c.Assert(p.FuzzyWordCount()%2 == 0, qt.Equals, true) // magic test
 			}
 		}
 	} else {
@@ -66,12 +67,12 @@ func TestSplitPageGroups(t *testing.T) {
 	lastChunk := chunks[4]
 
 	if groups, ok := lastChunk.(PagesGroup); ok {
-		require.Equal(t, 1, groups.Len())
+		c.Assert(groups.Len(), qt.Equals, 1)
 		for _, pg := range groups {
 			// last should have 5 in weight
-			require.Equal(t, 5, pg.Key)
+			c.Assert(pg.Key, qt.Equals, 5)
 			for _, p := range pg.Pages {
-				require.True(t, p.FuzzyWordCount()%2 != 0) // magic test
+				c.Assert(p.FuzzyWordCount()%2 != 0, qt.Equals, true) // magic test
 			}
 		}
 	} else {
@@ -82,6 +83,7 @@ func TestSplitPageGroups(t *testing.T) {
 
 func TestPager(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	pages := createTestPages(21)
 	groups, _ := pages.GroupBy("Weight", "desc")
 
@@ -90,64 +92,65 @@ func TestPager(t *testing.T) {
 	}
 
 	_, err := newPaginatorFromPages(pages, -1, urlFactory)
-	require.NotNil(t, err)
+	c.Assert(err, qt.Not(qt.IsNil))
 
 	_, err = newPaginatorFromPageGroups(groups, -1, urlFactory)
-	require.NotNil(t, err)
+	c.Assert(err, qt.Not(qt.IsNil))
 
 	pag, err := newPaginatorFromPages(pages, 5, urlFactory)
-	require.Nil(t, err)
+	c.Assert(err, qt.IsNil)
 	doTestPages(t, pag)
 	first := pag.Pagers()[0].First()
-	require.Equal(t, "Pager 1", first.String())
-	require.NotEmpty(t, first.Pages())
-	require.Empty(t, first.PageGroups())
+	c.Assert(first.String(), qt.Equals, "Pager 1")
+	c.Assert(first.Pages(), qt.Not(qt.HasLen), 0)
+	c.Assert(first.PageGroups(), qt.HasLen, 0)
 
 	pag, err = newPaginatorFromPageGroups(groups, 5, urlFactory)
-	require.Nil(t, err)
+	c.Assert(err, qt.IsNil)
 	doTestPages(t, pag)
 	first = pag.Pagers()[0].First()
-	require.NotEmpty(t, first.PageGroups())
-	require.Empty(t, first.Pages())
+	c.Assert(first.PageGroups(), qt.Not(qt.HasLen), 0)
+	c.Assert(first.Pages(), qt.HasLen, 0)
 
 }
 
 func doTestPages(t *testing.T, paginator *Paginator) {
-
+	c := qt.New(t)
 	paginatorPages := paginator.Pagers()
 
-	require.Equal(t, 5, len(paginatorPages))
-	require.Equal(t, 21, paginator.TotalNumberOfElements())
-	require.Equal(t, 5, paginator.PageSize())
-	require.Equal(t, 5, paginator.TotalPages())
+	c.Assert(len(paginatorPages), qt.Equals, 5)
+	c.Assert(paginator.TotalNumberOfElements(), qt.Equals, 21)
+	c.Assert(paginator.PageSize(), qt.Equals, 5)
+	c.Assert(paginator.TotalPages(), qt.Equals, 5)
 
 	first := paginatorPages[0]
-	require.Equal(t, template.HTML("page/1/"), first.URL())
-	require.Equal(t, first, first.First())
-	require.True(t, first.HasNext())
-	require.Equal(t, paginatorPages[1], first.Next())
-	require.False(t, first.HasPrev())
-	require.Nil(t, first.Prev())
-	require.Equal(t, 5, first.NumberOfElements())
-	require.Equal(t, 1, first.PageNumber())
+	c.Assert(first.URL(), qt.Equals, template.HTML("page/1/"))
+	c.Assert(first.First(), qt.Equals, first)
+	c.Assert(first.HasNext(), qt.Equals, true)
+	c.Assert(first.Next(), qt.Equals, paginatorPages[1])
+	c.Assert(first.HasPrev(), qt.Equals, false)
+	c.Assert(first.Prev(), qt.IsNil)
+	c.Assert(first.NumberOfElements(), qt.Equals, 5)
+	c.Assert(first.PageNumber(), qt.Equals, 1)
 
 	third := paginatorPages[2]
-	require.True(t, third.HasNext())
-	require.True(t, third.HasPrev())
-	require.Equal(t, paginatorPages[1], third.Prev())
+	c.Assert(third.HasNext(), qt.Equals, true)
+	c.Assert(third.HasPrev(), qt.Equals, true)
+	c.Assert(third.Prev(), qt.Equals, paginatorPages[1])
 
 	last := paginatorPages[4]
-	require.Equal(t, template.HTML("page/5/"), last.URL())
-	require.Equal(t, last, last.Last())
-	require.False(t, last.HasNext())
-	require.Nil(t, last.Next())
-	require.True(t, last.HasPrev())
-	require.Equal(t, 1, last.NumberOfElements())
-	require.Equal(t, 5, last.PageNumber())
+	c.Assert(last.URL(), qt.Equals, template.HTML("page/5/"))
+	c.Assert(last.Last(), qt.Equals, last)
+	c.Assert(last.HasNext(), qt.Equals, false)
+	c.Assert(last.Next(), qt.IsNil)
+	c.Assert(last.HasPrev(), qt.Equals, true)
+	c.Assert(last.NumberOfElements(), qt.Equals, 1)
+	c.Assert(last.PageNumber(), qt.Equals, 5)
 }
 
 func TestPagerNoPages(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	pages := createTestPages(0)
 	groups, _ := pages.GroupBy("Weight", "desc")
 
@@ -159,49 +162,50 @@ func TestPagerNoPages(t *testing.T) {
 	doTestPagerNoPages(t, paginator)
 
 	first := paginator.Pagers()[0].First()
-	require.Empty(t, first.PageGroups())
-	require.Empty(t, first.Pages())
+	c.Assert(first.PageGroups(), qt.HasLen, 0)
+	c.Assert(first.Pages(), qt.HasLen, 0)
 
 	paginator, _ = newPaginatorFromPageGroups(groups, 5, urlFactory)
 	doTestPagerNoPages(t, paginator)
 
 	first = paginator.Pagers()[0].First()
-	require.Empty(t, first.PageGroups())
-	require.Empty(t, first.Pages())
+	c.Assert(first.PageGroups(), qt.HasLen, 0)
+	c.Assert(first.Pages(), qt.HasLen, 0)
 
 }
 
 func doTestPagerNoPages(t *testing.T, paginator *Paginator) {
 	paginatorPages := paginator.Pagers()
-
-	require.Equal(t, 1, len(paginatorPages))
-	require.Equal(t, 0, paginator.TotalNumberOfElements())
-	require.Equal(t, 5, paginator.PageSize())
-	require.Equal(t, 0, paginator.TotalPages())
+	c := qt.New(t)
+	c.Assert(len(paginatorPages), qt.Equals, 1)
+	c.Assert(paginator.TotalNumberOfElements(), qt.Equals, 0)
+	c.Assert(paginator.PageSize(), qt.Equals, 5)
+	c.Assert(paginator.TotalPages(), qt.Equals, 0)
 
 	// pageOne should be nothing but the first
 	pageOne := paginatorPages[0]
-	require.NotNil(t, pageOne.First())
-	require.False(t, pageOne.HasNext())
-	require.False(t, pageOne.HasPrev())
-	require.Nil(t, pageOne.Next())
-	require.Equal(t, 1, len(pageOne.Pagers()))
-	require.Equal(t, 0, pageOne.Pages().Len())
-	require.Equal(t, 0, pageOne.NumberOfElements())
-	require.Equal(t, 0, pageOne.TotalNumberOfElements())
-	require.Equal(t, 0, pageOne.TotalPages())
-	require.Equal(t, 1, pageOne.PageNumber())
-	require.Equal(t, 5, pageOne.PageSize())
+	c.Assert(pageOne.First(), qt.Not(qt.IsNil))
+	c.Assert(pageOne.HasNext(), qt.Equals, false)
+	c.Assert(pageOne.HasPrev(), qt.Equals, false)
+	c.Assert(pageOne.Next(), qt.IsNil)
+	c.Assert(len(pageOne.Pagers()), qt.Equals, 1)
+	c.Assert(pageOne.Pages().Len(), qt.Equals, 0)
+	c.Assert(pageOne.NumberOfElements(), qt.Equals, 0)
+	c.Assert(pageOne.TotalNumberOfElements(), qt.Equals, 0)
+	c.Assert(pageOne.TotalPages(), qt.Equals, 0)
+	c.Assert(pageOne.PageNumber(), qt.Equals, 1)
+	c.Assert(pageOne.PageSize(), qt.Equals, 5)
 
 }
 
 func TestPaginationURLFactory(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	cfg := viper.New()
 	cfg.Set("paginatePath", "zoo")
 
 	for _, uglyURLs := range []bool{false, true} {
-		t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {
+		c.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(c *qt.C) {
 
 			tests := []struct {
 				name         string
@@ -231,9 +235,9 @@ func TestPaginationURLFactory(t *testing.T) {
 				got := factory(test.page)
 
 				if uglyURLs {
-					require.Equal(t, test.expectedUgly, got)
+					c.Assert(got, qt.Equals, test.expectedUgly)
 				} else {
-					require.Equal(t, test.expected, got)
+					c.Assert(got, qt.Equals, test.expected)
 				}
 
 			}
@@ -279,6 +283,7 @@ func TestProbablyEqualPageLists(t *testing.T) {
 
 func TestPaginationPage(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 	urlFactory := func(page int) string {
 		return fmt.Sprintf("page/%d/", page)
 	}
@@ -298,10 +303,10 @@ func TestPaginationPage(t *testing.T) {
 	page21, _ := f2.page(1)
 	page2Nil, _ := f2.page(3)
 
-	require.Equal(t, 3, page11.FuzzyWordCount())
-	require.Nil(t, page1Nil)
+	c.Assert(page11.FuzzyWordCount(), qt.Equals, 3)
+	c.Assert(page1Nil, qt.IsNil)
 
-	require.NotNil(t, page21)
-	require.Equal(t, 3, page21.FuzzyWordCount())
-	require.Nil(t, page2Nil)
+	c.Assert(page21, qt.Not(qt.IsNil))
+	c.Assert(page21.FuzzyWordCount(), qt.Equals, 3)
+	c.Assert(page2Nil, qt.IsNil)
 }
diff --git a/resources/page/permalinks_test.go b/resources/page/permalinks_test.go
index d7af7e06d..c9e55e7bd 100644
--- a/resources/page/permalinks_test.go
+++ b/resources/page/permalinks_test.go
@@ -19,7 +19,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 // testdataPermalinks is used by a couple of tests; the expandsTo content is
@@ -47,7 +47,7 @@ var testdataPermalinks = []struct {
 func TestPermalinkExpansion(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	page := newTestPageWithFile("/test-page/index.md")
 	page.title = "Spf13 Vim 3.0 Release and new website"
@@ -56,10 +56,7 @@ func TestPermalinkExpansion(t *testing.T) {
 	page.section = "blue"
 	page.slug = "The Slug"
 
-	for i, item := range testdataPermalinks {
-
-		msg := fmt.Sprintf("Test %d", i)
-
+	for _, item := range testdataPermalinks {
 		if !item.valid {
 			continue
 		}
@@ -72,11 +69,11 @@ func TestPermalinkExpansion(t *testing.T) {
 		ps.Cfg.Set("permalinks", permalinksConfig)
 
 		expander, err := NewPermalinkExpander(ps)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		expanded, err := expander.Expand("posts", page)
-		assert.NoError(err)
-		assert.Equal(item.expandsTo, expanded, msg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(expanded, qt.Equals, item.expandsTo)
 
 	}
 }
@@ -84,7 +81,7 @@ func TestPermalinkExpansion(t *testing.T) {
 func TestPermalinkExpansionMultiSection(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	page := newTestPage()
 	page.title = "Page Title"
@@ -102,22 +99,22 @@ func TestPermalinkExpansionMultiSection(t *testing.T) {
 	ps.Cfg.Set("permalinks", permalinksConfig)
 
 	expander, err := NewPermalinkExpander(ps)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	expanded, err := expander.Expand("posts", page)
-	assert.NoError(err)
-	assert.Equal("/the-slug", expanded)
+	c.Assert(err, qt.IsNil)
+	c.Assert(expanded, qt.Equals, "/the-slug")
 
 	expanded, err = expander.Expand("blog", page)
-	assert.NoError(err)
-	assert.Equal("/blue/2012", expanded)
+	c.Assert(err, qt.IsNil)
+	c.Assert(expanded, qt.Equals, "/blue/2012")
 
 }
 
 func TestPermalinkExpansionConcurrent(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	permalinksConfig := map[string]string{
 		"posts": "/:slug/",
@@ -127,7 +124,7 @@ func TestPermalinkExpansionConcurrent(t *testing.T) {
 	ps.Cfg.Set("permalinks", permalinksConfig)
 
 	expander, err := NewPermalinkExpander(ps)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	var wg sync.WaitGroup
 
@@ -139,8 +136,8 @@ func TestPermalinkExpansionConcurrent(t *testing.T) {
 			for j := 1; j < 20; j++ {
 				page.slug = fmt.Sprintf("slug%d", i+j)
 				expanded, err := expander.Expand("posts", page)
-				assert.NoError(err)
-				assert.Equal(fmt.Sprintf("/%s/", page.slug), expanded)
+				c.Assert(err, qt.IsNil)
+				c.Assert(expanded, qt.Equals, fmt.Sprintf("/%s/", page.slug))
 			}
 		}(i)
 	}
-- 
cgit v1.2.3