tests: Convert from testify to quicktest

bufferpool/bufpool_test.go

@@ -14,14 +14,18 @@
 package bufferpool
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	qt "github.com/frankban/quicktest"
 )
 
 func TestBufferPool(t *testing.T) {
+	c := qt.New(t)
+
 	buff := GetBuffer()
 	buff.WriteString("do be do be do")
-	assert.Equal(t, "do be do be do", buff.String())
+	c.Assert(buff.String(), qt.Equals, "do be do be do")
 	PutBuffer(buff)
-	assert.Equal(t, 0, buff.Len())
+
+	c.Assert(buff.Len(), qt.Equals, 0)
 }

cache/filecache/filecache_config_test.go

@@ -24,14 +24,14 @@ import (
 
 	"github.com/gohugoio/hugo/config"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestDecodeConfig(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configStr := `
 resourceDir = "myresources"
@@ -55,27 +55,27 @@ dir = "/path/to/c3"
 `
 
 	cfg, err := config.FromConfigString(configStr, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
 	decoded, err := DecodeConfig(fs, cfg)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal(5, len(decoded))
+	c.Assert(len(decoded), qt.Equals, 5)
 
 	c2 := decoded["getcsv"]
-	assert.Equal("11h0m0s", c2.MaxAge.String())
-	assert.Equal(filepath.FromSlash("/path/to/c2/filecache/getcsv"), c2.Dir)
+	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
+	c.Assert(c2.Dir, qt.Equals, filepath.FromSlash("/path/to/c2/filecache/getcsv"))
 
 	c3 := decoded["images"]
-	assert.Equal(time.Duration(-1), c3.MaxAge)
-	assert.Equal(filepath.FromSlash("/path/to/c3/filecache/images"), c3.Dir)
+	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
+	c.Assert(c3.Dir, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))
 
 }
 
 func TestDecodeConfigIgnoreCache(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configStr := `
 resourceDir = "myresources"
@@ -100,21 +100,21 @@ dir = "/path/to/c3"
 `
 
 	cfg, err := config.FromConfigString(configStr, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
 	decoded, err := DecodeConfig(fs, cfg)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal(5, len(decoded))
+	c.Assert(len(decoded), qt.Equals, 5)
 
 	for _, v := range decoded {
-		assert.Equal(time.Duration(0), v.MaxAge)
+		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
 	}
 
 }
 
 func TestDecodeConfigDefault(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	cfg := newTestConfig()
 
 	if runtime.GOOS == "windows" {
@@ -130,28 +130,28 @@ func TestDecodeConfigDefault(t *testing.T) {
 
 	decoded, err := DecodeConfig(fs, cfg)
 
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal(5, len(decoded))
+	c.Assert(len(decoded), qt.Equals, 5)
 
 	imgConfig := decoded[cacheKeyImages]
 	jsonConfig := decoded[cacheKeyGetJSON]
 
 	if runtime.GOOS == "windows" {
-		assert.Equal(filepath.FromSlash("_gen/images"), imgConfig.Dir)
+		c.Assert(imgConfig.Dir, qt.Equals, filepath.FromSlash("_gen/images"))
 	} else {
-		assert.Equal("_gen/images", imgConfig.Dir)
-		assert.Equal("/cache/thecache/hugoproject/filecache/getjson", jsonConfig.Dir)
+		c.Assert(imgConfig.Dir, qt.Equals, "_gen/images")
+		c.Assert(jsonConfig.Dir, qt.Equals, "/cache/thecache/hugoproject/filecache/getjson")
 	}
 
-	assert.True(imgConfig.isResourceDir)
-	assert.False(jsonConfig.isResourceDir)
+	c.Assert(imgConfig.isResourceDir, qt.Equals, true)
+	c.Assert(jsonConfig.isResourceDir, qt.Equals, false)
 }
 
 func TestDecodeConfigInvalidDir(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configStr := `
 resourceDir = "myresources"
@@ -173,11 +173,11 @@ dir = "/"
 	}
 
 	cfg, err := config.FromConfigString(configStr, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
 
 	_, err = DecodeConfig(fs, cfg)
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 
 }
 

cache/filecache/filecache_pruner_test.go

@@ -20,13 +20,13 @@ import (
 
 	"github.com/spf13/afero"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestPrune(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configStr := `
 resourceDir = "myresources"
@@ -53,10 +53,10 @@ dir = ":resourceDir/_gen"
 `
 
 	for _, name := range []string{cacheKeyGetCSV, cacheKeyGetJSON, cacheKeyAssets, cacheKeyImages} {
-		msg := fmt.Sprintf("cache: %s", name)
+		msg := qt.Commentf("cache: %s", name)
 		p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
 		caches, err := NewCaches(p)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		cache := caches[name]
 		for i := 0; i < 10; i++ {
 			id := fmt.Sprintf("i%d", i)
@@ -70,21 +70,21 @@ dir = ":resourceDir/_gen"
 		}
 
 		count, err := caches.Prune()
-		assert.NoError(err)
-		assert.Equal(5, count, msg)
+		c.Assert(err, qt.IsNil)
+		c.Assert(count, qt.Equals, 5, msg)
 
 		for i := 0; i < 10; i++ {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.getString(id)
 			if i < 5 {
-				assert.Equal("", v, id)
+				c.Assert(v, qt.Equals, "")
 			} else {
-				assert.Equal("abc", v, id)
+				c.Assert(v, qt.Equals, "abc")
 			}
 		}
 
 		caches, err = NewCaches(p)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		cache = caches[name]
 		// Touch one and then prune.
 		cache.GetOrCreateBytes("i5", func() ([]byte, error) {
@@ -92,17 +92,17 @@ dir = ":resourceDir/_gen"
 		})
 
 		count, err = caches.Prune()
-		assert.NoError(err)
-		assert.Equal(4, count)
+		c.Assert(err, qt.IsNil)
+		c.Assert(count, qt.Equals, 4)
 
 		// Now only the i5 should be left.
 		for i := 0; i < 10; i++ {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.getString(id)
 			if i != 5 {
-				assert.Equal("", v, id)
+				c.Assert(v, qt.Equals, "")
 			} else {
-				assert.Equal("abc", v, id)
+				c.Assert(v, qt.Equals, "abc")
 			}
 		}
 

cache/filecache/filecache_test.go

@@ -19,7 +19,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"regexp"
 	"strings"
 	"sync"
 	"testing"
@@ -35,19 +34,19 @@ import (
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/afero"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestFileCache(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tempWorkingDir, err := ioutil.TempDir("", "hugo_filecache_test_work")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer os.Remove(tempWorkingDir)
 
 	tempCacheDir, err := ioutil.TempDir("", "hugo_filecache_test_cache")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer os.Remove(tempCacheDir)
 
 	osfs := afero.NewOsFs()
@@ -89,30 +88,30 @@ dir = ":cacheDir/c"
 		p := newPathsSpec(t, osfs, configStr)
 
 		caches, err := NewCaches(p)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		cache := caches.Get("GetJSON")
-		assert.NotNil(cache)
-		assert.Equal("10h0m0s", cache.maxAge.String())
+		c.Assert(cache, qt.Not(qt.IsNil))
+		c.Assert(cache.maxAge.String(), qt.Equals, "10h0m0s")
 
 		bfs, ok := cache.Fs.(*afero.BasePathFs)
-		assert.True(ok)
+		c.Assert(ok, qt.Equals, true)
 		filename, err := bfs.RealPath("key")
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		if test.cacheDir != "" {
-			assert.Equal(filepath.Join(test.cacheDir, "c/"+filecacheRootDirname+"/getjson/key"), filename)
+			c.Assert(filename, qt.Equals, filepath.Join(test.cacheDir, "c/"+filecacheRootDirname+"/getjson/key"))
 		} else {
 			// Temp dir.
-			assert.Regexp(regexp.MustCompile(".*hugo_cache.*"+filecacheRootDirname+".*key"), filename)
+			c.Assert(filename, qt.Matches, ".*hugo_cache.*"+filecacheRootDirname+".*key")
 		}
 
 		cache = caches.Get("Images")
-		assert.NotNil(cache)
-		assert.Equal(time.Duration(-1), cache.maxAge)
+		c.Assert(cache, qt.Not(qt.IsNil))
+		c.Assert(cache.maxAge, qt.Equals, time.Duration(-1))
 		bfs, ok = cache.Fs.(*afero.BasePathFs)
-		assert.True(ok)
+		c.Assert(ok, qt.Equals, true)
 		filename, _ = bfs.RealPath("key")
-		assert.Equal(filepath.FromSlash("_gen/images/key"), filename)
+		c.Assert(filename, qt.Equals, filepath.FromSlash("_gen/images/key"))
 
 		rf := func(s string) func() (io.ReadCloser, error) {
 			return func() (io.ReadCloser, error) {
@@ -130,55 +129,55 @@ dir = ":cacheDir/c"
 			return []byte("bcd"), nil
 		}
 
-		for _, c := range []*Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
+		for _, ca := range []*Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
 			for i := 0; i < 2; i++ {
-				info, r, err := c.GetOrCreate("a", rf("abc"))
-				assert.NoError(err)
-				assert.NotNil(r)
-				assert.Equal("a", info.Name)
+				info, r, err := ca.GetOrCreate("a", rf("abc"))
+				c.Assert(err, qt.IsNil)
+				c.Assert(r, qt.Not(qt.IsNil))
+				c.Assert(info.Name, qt.Equals, "a")
 				b, _ := ioutil.ReadAll(r)
 				r.Close()
-				assert.Equal("abc", string(b))
+				c.Assert(string(b), qt.Equals, "abc")
 
-				info, b, err = c.GetOrCreateBytes("b", bf)
-				assert.NoError(err)
-				assert.NotNil(r)
-				assert.Equal("b", info.Name)
-				assert.Equal("bcd", string(b))
+				info, b, err = ca.GetOrCreateBytes("b", bf)
+				c.Assert(err, qt.IsNil)
+				c.Assert(r, qt.Not(qt.IsNil))
+				c.Assert(info.Name, qt.Equals, "b")
+				c.Assert(string(b), qt.Equals, "bcd")
 
-				_, b, err = c.GetOrCreateBytes("a", bf)
-				assert.NoError(err)
-				assert.Equal("abc", string(b))
+				_, b, err = ca.GetOrCreateBytes("a", bf)
+				c.Assert(err, qt.IsNil)
+				c.Assert(string(b), qt.Equals, "abc")
 
-				_, r, err = c.GetOrCreate("a", rf("bcd"))
-				assert.NoError(err)
+				_, r, err = ca.GetOrCreate("a", rf("bcd"))
+				c.Assert(err, qt.IsNil)
 				b, _ = ioutil.ReadAll(r)
 				r.Close()
-				assert.Equal("abc", string(b))
+				c.Assert(string(b), qt.Equals, "abc")
 			}
 		}
 
-		assert.NotNil(caches.Get("getJSON"))
+		c.Assert(caches.Get("getJSON"), qt.Not(qt.IsNil))
 
 		info, w, err := caches.ImageCache().WriteCloser("mykey")
-		assert.NoError(err)
-		assert.Equal("mykey", info.Name)
+		c.Assert(err, qt.IsNil)
+		c.Assert(info.Name, qt.Equals, "mykey")
 		io.WriteString(w, "Hugo is great!")
 		w.Close()
-		assert.Equal("Hugo is great!", caches.ImageCache().getString("mykey"))
+		c.Assert(caches.ImageCache().getString("mykey"), qt.Equals, "Hugo is great!")
 
 		info, r, err := caches.ImageCache().Get("mykey")
-		assert.NoError(err)
-		assert.NotNil(r)
-		assert.Equal("mykey", info.Name)
+		c.Assert(err, qt.IsNil)
+		c.Assert(r, qt.Not(qt.IsNil))
+		c.Assert(info.Name, qt.Equals, "mykey")
 		b, _ := ioutil.ReadAll(r)
 		r.Close()
-		assert.Equal("Hugo is great!", string(b))
+		c.Assert(string(b), qt.Equals, "Hugo is great!")
 
 		info, b, err = caches.ImageCache().GetBytes("mykey")
-		assert.NoError(err)
-		assert.Equal("mykey", info.Name)
-		assert.Equal("Hugo is great!", string(b))
+		c.Assert(err, qt.IsNil)
+		c.Assert(info.Name, qt.Equals, "mykey")
+		c.Assert(string(b), qt.Equals, "Hugo is great!")
 
 	}
 
@@ -187,7 +186,7 @@ dir = ":cacheDir/c"
 func TestFileCacheConcurrent(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configStr := `
 resourceDir = "myresources"
@@ -208,7 +207,7 @@ dir = "/cache/c"
 	p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
 
 	caches, err := NewCaches(p)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	const cacheName = "getjson"
 
@@ -225,16 +224,16 @@ dir = "/cache/c"
 		go func(i int) {
 			defer wg.Done()
 			for j := 0; j < 20; j++ {
-				c := caches.Get(cacheName)
-				assert.NotNil(c)
+				ca := caches.Get(cacheName)
+				c.Assert(ca, qt.Not(qt.IsNil))
 				filename, data := filenameData(i)
-				_, r, err := c.GetOrCreate(filename, func() (io.ReadCloser, error) {
+				_, r, err := ca.GetOrCreate(filename, func() (io.ReadCloser, error) {
 					return hugio.ToReadCloser(strings.NewReader(data)), nil
 				})
-				assert.NoError(err)
+				c.Assert(err, qt.IsNil)
 				b, _ := ioutil.ReadAll(r)
 				r.Close()
-				assert.Equal(data, string(b))
+				c.Assert(string(b), qt.Equals, data)
 				// Trigger some expiration.
 				time.Sleep(50 * time.Millisecond)
 			}
@@ -245,9 +244,9 @@ dir = "/cache/c"
 }
 
 func TestCleanID(t *testing.T) {
-	assert := require.New(t)
-	assert.Equal(filepath.FromSlash("a/b/c.txt"), cleanID(filepath.FromSlash("/a/b//c.txt")))
-	assert.Equal(filepath.FromSlash("a/b/c.txt"), cleanID(filepath.FromSlash("a/b//c.txt")))
+	c := qt.New(t)
+	c.Assert(cleanID(filepath.FromSlash("/a/b//c.txt")), qt.Equals, filepath.FromSlash("a/b/c.txt"))
+	c.Assert(cleanID(filepath.FromSlash("a/b//c.txt")), qt.Equals, filepath.FromSlash("a/b/c.txt"))
 }
 
 func initConfig(fs afero.Fs, cfg config.Provider) error {
@@ -288,12 +287,12 @@ func initConfig(fs afero.Fs, cfg config.Provider) error {
 }
 
 func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec {
-	assert := require.New(t)
+	c := qt.New(t)
 	cfg, err := config.FromConfigString(configStr, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	initConfig(fs, cfg)
 	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, cfg), cfg, nil)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	return p
 
 }

cache/namedmemcache/named_cache_test.go

@@ -18,12 +18,12 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestNamedCache(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cache := New()
 
@@ -35,24 +35,24 @@ func TestNamedCache(t *testing.T) {
 
 	for i := 0; i < 5; i++ {
 		v1, err := cache.GetOrCreate("a1", create)
-		assert.NoError(err)
-		assert.Equal(1, v1)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v1, qt.Equals, 1)
 		v2, err := cache.GetOrCreate("a2", create)
-		assert.NoError(err)
-		assert.Equal(2, v2)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v2, qt.Equals, 2)
 	}
 
 	cache.Clear()
 
 	v3, err := cache.GetOrCreate("a2", create)
-	assert.NoError(err)
-	assert.Equal(3, v3)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v3, qt.Equals, 3)
 }
 
 func TestNamedCacheConcurrent(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	var wg sync.WaitGroup
 
@@ -71,8 +71,8 @@ func TestNamedCacheConcurrent(t *testing.T) {
 			for j := 0; j < 100; j++ {
 				id := fmt.Sprintf("id%d", j)
 				v, err := cache.GetOrCreate(id, create(j))
-				assert.NoError(err)
-				assert.Equal(j, v)
+				c.Assert(err, qt.IsNil)
+				c.Assert(v, qt.Equals, j)
 			}
 		}()
 	}

cache/partitioned_lazy_cache_test.go

@@ -18,13 +18,13 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestNewPartitionedLazyCache(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	p1 := Partition{
 		Key: "p1",
@@ -51,28 +51,28 @@ func TestNewPartitionedLazyCache(t *testing.T) {
 	cache := NewPartitionedLazyCache(p1, p2)
 
 	v, err := cache.Get("p1", "p1_1")
-	assert.NoError(err)
-	assert.Equal("p1v1", v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.Equals, "p1v1")
 
 	v, err = cache.Get("p1", "p2_1")
-	assert.NoError(err)
-	assert.Nil(v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.IsNil)
 
 	v, err = cache.Get("p1", "p1_nil")
-	assert.NoError(err)
-	assert.Nil(v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.IsNil)
 
 	v, err = cache.Get("p2", "p2_3")
-	assert.NoError(err)
-	assert.Equal("p2v3", v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.Equals, "p2v3")
 
 	v, err = cache.Get("doesnotexist", "p1_1")
-	assert.NoError(err)
-	assert.Nil(v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.IsNil)
 
 	v, err = cache.Get("p1", "doesnotexist")
-	assert.NoError(err)
-	assert.Nil(v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.IsNil)
 
 	errorP := Partition{
 		Key: "p3",
@@ -84,18 +84,18 @@ func TestNewPartitionedLazyCache(t *testing.T) {
 	cache = NewPartitionedLazyCache(errorP)
 
 	v, err = cache.Get("p1", "doesnotexist")
-	assert.NoError(err)
-	assert.Nil(v)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.IsNil)
 
 	_, err = cache.Get("p3", "doesnotexist")
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 
 }
 
 func TestConcurrentPartitionedLazyCache(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	var wg sync.WaitGroup
 
@@ -129,8 +129,8 @@ func TestConcurrentPartitionedLazyCache(t *testing.T) {
 			defer wg.Done()
 			for j := 0; j < 10; j++ {
 				v, err := cache.Get("p1", "p1_1")
-				assert.NoError(err)
-				assert.Equal("p1v1", v)
+				c.Assert(err, qt.IsNil)
+				c.Assert(v, qt.Equals, "p1v1")
 			}
 		}()
 	}

codegen/methods_test.go

@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/common/herrors"
-	"github.com/stretchr/testify/require"
 )
 
 func TestMethods(t *testing.T) {
@@ -33,47 +33,47 @@ func TestMethods(t *testing.T) {
 	)
 
 	dir, _ := os.Getwd()
-	c := NewInspector(dir)
+	insp := NewInspector(dir)
 
 	t.Run("MethodsFromTypes", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
-		methods := c.MethodsFromTypes([]reflect.Type{zeroI}, nil)
+		methods := insp.MethodsFromTypes([]reflect.Type{zeroI}, nil)
 
 		methodsStr := fmt.Sprint(methods)
 
-		assert.Contains(methodsStr, "Method1(arg0 herrors.ErrorContext)")
-		assert.Contains(methodsStr, "Method7() interface {}")
-		assert.Contains(methodsStr, "Method0() string\n Method4() string")
-		assert.Contains(methodsStr, "MethodEmbed3(arg0 string) string\n MethodEmbed1() string")
+		c.Assert(methodsStr, qt.Contains, "Method1(arg0 herrors.ErrorContext)")
+		c.Assert(methodsStr, qt.Contains, "Method7() interface {}")
+		c.Assert(methodsStr, qt.Contains, "Method0() string\n Method4() string")
+		c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string\n MethodEmbed1() string")
 
-		assert.Contains(methods.Imports(), "github.com/gohugoio/hugo/common/herrors")
+		c.Assert(methods.Imports(), qt.Contains, "github.com/gohugoio/hugo/common/herrors")
 	})
 
 	t.Run("EmbedOnly", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
-		methods := c.MethodsFromTypes([]reflect.Type{zeroIEOnly}, nil)
+		methods := insp.MethodsFromTypes([]reflect.Type{zeroIEOnly}, nil)
 
 		methodsStr := fmt.Sprint(methods)
 
-		assert.Contains(methodsStr, "MethodEmbed3(arg0 string) string")
+		c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string")
 
 	})
 
 	t.Run("ToMarshalJSON", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
-		m, pkg := c.MethodsFromTypes(
+		m, pkg := insp.MethodsFromTypes(
 			[]reflect.Type{zeroI},
 			[]reflect.Type{zeroIE}).ToMarshalJSON("*page", "page")
 
-		assert.Contains(m, "method6 := p.Method6()")
-		assert.Contains(m, "Method0: method0,")
-		assert.Contains(m, "return json.Marshal(&s)")
+		c.Assert(m, qt.Contains, "method6 := p.Method6()")
+		c.Assert(m, qt.Contains, "Method0: method0,")
+		c.Assert(m, qt.Contains, "return json.Marshal(&s)")
 
-		assert.Contains(pkg, "github.com/gohugoio/hugo/common/herrors")
-		assert.Contains(pkg, "encoding/json")
+		c.Assert(pkg, qt.Contains, "github.com/gohugoio/hugo/common/herrors")
+		c.Assert(pkg, qt.Contains, "encoding/json")
 
 		fmt.Println(pkg)
 

commands/commands_test.go

@@ -25,29 +25,29 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestExecute(t *testing.T) {
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	dir, err := createSimpleTestSite(t, testSiteConfig{})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	defer func() {
 		os.RemoveAll(dir)
 	}()
 
 	resp := Execute([]string{"-s=" + dir})
-	assert.NoError(resp.Err)
+	c.Assert(resp.Err, qt.IsNil)
 	result := resp.Result
-	assert.True(len(result.Sites) == 1)
-	assert.True(len(result.Sites[0].RegularPages()) == 1)
+	c.Assert(len(result.Sites) == 1, qt.Equals, true)
+	c.Assert(len(result.Sites[0].RegularPages()) == 1, qt.Equals, true)
 }
 
 func TestCommandsPersistentFlags(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	noOpRunE := func(cmd *cobra.Command, args []string) error {
 		return nil
@@ -83,10 +83,10 @@ func TestCommandsPersistentFlags(t *testing.T) {
 		for _, command := range commands {
 			if b, ok := command.(commandsBuilderGetter); ok {
 				v := b.getCommandsBuilder().hugoBuilderCommon
-				assert.Equal("myconfig.toml", v.cfgFile)
-				assert.Equal("myconfigdir", v.cfgDir)
-				assert.Equal("mysource", v.source)
-				assert.Equal("https://example.com/b/", v.baseURL)
+				c.Assert(v.cfgFile, qt.Equals, "myconfig.toml")
+				c.Assert(v.cfgDir, qt.Equals, "myconfigdir")
+				c.Assert(v.source, qt.Equals, "mysource")
+				c.Assert(v.baseURL, qt.Equals, "https://example.com/b/")
 			}
 
 			if srvCmd, ok := command.(*serverCmd); ok {
@@ -94,32 +94,32 @@ func TestCommandsPersistentFlags(t *testing.T) {
 			}
 		}
 
-		assert.NotNil(sc)
-		assert.True(sc.navigateToChanged)
-		assert.True(sc.disableLiveReload)
-		assert.True(sc.noHTTPCache)
-		assert.True(sc.renderToDisk)
-		assert.Equal(1366, sc.serverPort)
-		assert.Equal("testing", sc.environment)
+		c.Assert(sc, qt.Not(qt.IsNil))
+		c.Assert(sc.navigateToChanged, qt.Equals, true)
+		c.Assert(sc.disableLiveReload, qt.Equals, true)
+		c.Assert(sc.noHTTPCache, qt.Equals, true)
+		c.Assert(sc.renderToDisk, qt.Equals, true)
+		c.Assert(sc.serverPort, qt.Equals, 1366)
+		c.Assert(sc.environment, qt.Equals, "testing")
 
 		cfg := viper.New()
 		sc.flagsToConfig(cfg)
-		assert.Equal("/tmp/mydestination", cfg.GetString("publishDir"))
-		assert.Equal("mycontent", cfg.GetString("contentDir"))
-		assert.Equal("mylayouts", cfg.GetString("layoutDir"))
-		assert.Equal([]string{"mytheme"}, cfg.GetStringSlice("theme"))
-		assert.Equal("mythemes", cfg.GetString("themesDir"))
-		assert.Equal("https://example.com/b/", cfg.GetString("baseURL"))
+		c.Assert(cfg.GetString("publishDir"), qt.Equals, "/tmp/mydestination")
+		c.Assert(cfg.GetString("contentDir"), qt.Equals, "mycontent")
+		c.Assert(cfg.GetString("layoutDir"), qt.Equals, "mylayouts")
+		c.Assert(cfg.GetStringSlice("theme"), qt.DeepEquals, []string{"mytheme"})
+		c.Assert(cfg.GetString("themesDir"), qt.Equals, "mythemes")
+		c.Assert(cfg.GetString("baseURL"), qt.Equals, "https://example.com/b/")
 
-		assert.Equal([]string{"page", "home"}, cfg.Get("disableKinds"))
+		c.Assert(cfg.Get("disableKinds"), qt.DeepEquals, []string{"page", "home"})
 
-		assert.True(cfg.GetBool("gc"))
+		c.Assert(cfg.GetBool("gc"), qt.Equals, true)
 
 		// The flag is named path-warnings
-		assert.True(cfg.GetBool("logPathWarnings"))
+		c.Assert(cfg.GetBool("logPathWarnings"), qt.Equals, true)
 
 		// The flag is named i18n-warnings
-		assert.True(cfg.GetBool("logI18nWarnings"))
+		c.Assert(cfg.GetBool("logI18nWarnings"), qt.Equals, true)
 
 	}}}
 
@@ -136,7 +136,7 @@ func TestCommandsPersistentFlags(t *testing.T) {
 		}
 		rootCmd := root.getCommand()
 		rootCmd.SetArgs(test.args)
-		assert.NoError(rootCmd.Execute())
+		c.Assert(rootCmd.Execute(), qt.IsNil)
 		test.check(b.commands)
 	}
 
@@ -144,13 +144,13 @@ func TestCommandsPersistentFlags(t *testing.T) {
 
 func TestCommandsExecute(t *testing.T) {
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	dir, err := createSimpleTestSite(t, testSiteConfig{})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	dirOut, err := ioutil.TempDir("", "hugo-cli-out")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	defer func() {
 		os.RemoveAll(dir)
@@ -200,17 +200,17 @@ func TestCommandsExecute(t *testing.T) {
 
 		_, err := hugoCmd.ExecuteC()
 		if test.expectErrToContain != "" {
-			assert.Error(err, fmt.Sprintf("%v", test.commands))
-			assert.Contains(err.Error(), test.expectErrToContain)
+			c.Assert(err, qt.Not(qt.IsNil))
+			c.Assert(err.Error(), qt.Contains, test.expectErrToContain)
 		} else {
-			assert.NoError(err, fmt.Sprintf("%v", test.commands))
+			c.Assert(err, qt.IsNil)
 		}
 
 		// Assert that we have not left any development debug artifacts in
 		// the code.
 		if b.c != nil {
 			_, ok := b.c.destinationFs.(types.DevMarker)
-			assert.False(ok)
+			c.Assert(ok, qt.Equals, false)
 		}
 
 	}

commands/hugo_test.go

@@ -17,12 +17,12 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 // Issue #5662
 func TestHugoWithContentDirOverride(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	hugoCmd := newCommandsBuilder().addAll().build()
 	cmd := hugoCmd.getCommand()
@@ -38,7 +38,7 @@ contentDir = "thisdoesnotexist"
 
 `
 	dir, err := createSimpleTestSite(t, testSiteConfig{configTOML: cfgStr, contentDir: contentDir})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	defer func() {
 		os.RemoveAll(dir)
@@ -47,6 +47,6 @@ contentDir = "thisdoesnotexist"
 	cmd.SetArgs([]string{"-s=" + dir, "-c=" + contentDir})
 
 	_, err = cmd.ExecuteC()
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 }

commands/import_jekyll_test.go

@@ -15,12 +15,14 @@ package commands
 
 import (
 	"encoding/json"
-	"github.com/stretchr/testify/assert"
 	"testing"
 	"time"
+
+	qt "github.com/frankban/quicktest"
 )
 
 func TestParseJekyllFilename(t *testing.T) {
+	c := qt.New(t)
 	filenameArray := []string{
 		"2015-01-02-test.md",
 		"2012-03-15-中文.markup",
@@ -36,13 +38,14 @@ func TestParseJekyllFilename(t *testing.T) {
 
 	for i, filename := range filenameArray {
 		postDate, postName, err := parseJekyllFilename(filename)
-		assert.Equal(t, err, nil)
-		assert.Equal(t, expectResult[i].postDate.Format("2006-01-02"), postDate.Format("2006-01-02"))
-		assert.Equal(t, expectResult[i].postName, postName)
+		c.Assert(err, qt.IsNil)
+		c.Assert(expectResult[i].postDate.Format("2006-01-02"), qt.Equals, postDate.Format("2006-01-02"))
+		c.Assert(expectResult[i].postName, qt.Equals, postName)
 	}
 }
 
 func TestConvertJekyllMetadata(t *testing.T) {
+	c := qt.New(t)
 	testDataList := []struct {
 		metadata interface{}
 		postName string
@@ -73,14 +76,15 @@ func TestConvertJekyllMetadata(t *testing.T) {
 
 	for _, data := range testDataList {
 		result, err := convertJekyllMetaData(data.metadata, data.postName, data.postDate, data.draft)
-		assert.Equal(t, nil, err)
+		c.Assert(err, qt.IsNil)
 		jsonResult, err := json.Marshal(result)
-		assert.Equal(t, nil, err)
-		assert.Equal(t, data.expect, string(jsonResult))
+		c.Assert(err, qt.IsNil)
+		c.Assert(string(jsonResult), qt.Equals, data.expect)
 	}
 }
 
 func TestConvertJekyllContent(t *testing.T) {
+	c := qt.New(t)
 	testDataList := []struct {
 		metadata interface{}
 		content  string
@@ -124,6 +128,6 @@ func TestConvertJekyllContent(t *testing.T) {
 
 	for _, data := range testDataList {
 		result := convertJekyllContent(data.metadata, data.content)
-		assert.Equal(t, data.expect, result)
+		c.Assert(data.expect, qt.Equals, result)
 	}
 }

commands/list_test.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/require"
 )
 
 func captureStdout(f func() (*cobra.Command, error)) (string, error) {
@@ -33,10 +33,10 @@ func captureStdout(f func() (*cobra.Command, error)) (string, error) {
 }
 
 func TestListAll(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	dir, err := createSimpleTestSite(t, testSiteConfig{})
 
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	hugoCmd := newCommandsBuilder().addAll().build()
 	cmd := hugoCmd.getCommand()
@@ -48,24 +48,25 @@ func TestListAll(t *testing.T) {
 	cmd.SetArgs([]string{"-s=" + dir, "list", "all"})
 
 	out, err := captureStdout(cmd.ExecuteC)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	r := csv.NewReader(strings.NewReader(out))
 
 	header, err := r.Read()
-	assert.NoError(err)
 
-	assert.Equal([]string{
+	c.Assert(err, qt.IsNil)
+	c.Assert(header, qt.DeepEquals, []string{
 		"path", "slug", "title",
 		"date", "expiryDate", "publishDate",
 		"draft", "permalink",
-	}, header)
+	})
 
 	record, err := r.Read()
-	assert.NoError(err)
-	assert.Equal([]string{
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(record, qt.DeepEquals, []string{
 		filepath.Join("content", "p1.md"), "", "P1",
 		"0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z",
 		"false", "https://example.org/p1/",
-	}, record)
+	})
 }

commands/new_content_test.go

@@ -19,19 +19,20 @@ import (
 
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+
+	qt "github.com/frankban/quicktest"
 )
 
 // Issue #1133
 func TestNewContentPathSectionWithForwardSlashes(t *testing.T) {
+	c := qt.New(t)
 	p, s := newContentPathSection(nil, "/post/new.md")
-	assert.Equal(t, filepath.FromSlash("/post/new.md"), p)
-	assert.Equal(t, "post", s)
+	c.Assert(p, qt.Equals, filepath.FromSlash("/post/new.md"))
+	c.Assert(s, qt.Equals, "post")
 }
 
 func checkNewSiteInited(fs *hugofs.Fs, basepath string, t *testing.T) {
-
+	c := qt.New(t)
 	paths := []string{
 		filepath.Join(basepath, "layouts"),
 		filepath.Join(basepath, "content"),
@@ -43,77 +44,82 @@ func checkNewSiteInited(fs *hugofs.Fs, basepath string, t *testing.T) {
 
 	for _, path := range paths {
 		_, err := fs.Source.Stat(path)
-		require.NoError(t, err)
+		c.Assert(err, qt.IsNil)
 	}
 }
 
 func TestDoNewSite(t *testing.T) {
+	c := qt.New(t)
 	n := newNewSiteCmd()
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 
-	require.NoError(t, n.doNewSite(fs, basepath, false))
+	c.Assert(n.doNewSite(fs, basepath, false), qt.IsNil)
 
 	checkNewSiteInited(fs, basepath, t)
 }
 
 func TestDoNewSite_noerror_base_exists_but_empty(t *testing.T) {
+	c := qt.New(t)
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 	n := newNewSiteCmd()
 
-	require.NoError(t, fs.Source.MkdirAll(basepath, 0777))
+	c.Assert(fs.Source.MkdirAll(basepath, 0777), qt.IsNil)
 
-	require.NoError(t, n.doNewSite(fs, basepath, false))
+	c.Assert(n.doNewSite(fs, basepath, false), qt.IsNil)
 }
 
 func TestDoNewSite_error_base_exists(t *testing.T) {
+	c := qt.New(t)
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 	n := newNewSiteCmd()
 
-	require.NoError(t, fs.Source.MkdirAll(basepath, 0777))
+	c.Assert(fs.Source.MkdirAll(basepath, 0777), qt.IsNil)
 	_, err := fs.Source.Create(filepath.Join(basepath, "foo"))
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 	// Since the directory already exists and isn't empty, expect an error
-	require.Error(t, n.doNewSite(fs, basepath, false))
+	c.Assert(n.doNewSite(fs, basepath, false), qt.Not(qt.IsNil))
 
 }
 
 func TestDoNewSite_force_empty_dir(t *testing.T) {
+	c := qt.New(t)
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 	n := newNewSiteCmd()
 
-	require.NoError(t, fs.Source.MkdirAll(basepath, 0777))
-
-	require.NoError(t, n.doNewSite(fs, basepath, true))
+	c.Assert(fs.Source.MkdirAll(basepath, 0777), qt.IsNil)
+	c.Assert(n.doNewSite(fs, basepath, true), qt.IsNil)
 
 	checkNewSiteInited(fs, basepath, t)
 }
 
 func TestDoNewSite_error_force_dir_inside_exists(t *testing.T) {
+	c := qt.New(t)
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 	n := newNewSiteCmd()
 
 	contentPath := filepath.Join(basepath, "content")
 
-	require.NoError(t, fs.Source.MkdirAll(contentPath, 0777))
-	require.Error(t, n.doNewSite(fs, basepath, true))
+	c.Assert(fs.Source.MkdirAll(contentPath, 0777), qt.IsNil)
+	c.Assert(n.doNewSite(fs, basepath, true), qt.Not(qt.IsNil))
 }
 
 func TestDoNewSite_error_force_config_inside_exists(t *testing.T) {
+	c := qt.New(t)
 	basepath := filepath.Join("base", "blog")
 	_, fs := newTestCfg()
 	n := newNewSiteCmd()
 
 	configPath := filepath.Join(basepath, "config.toml")
-	require.NoError(t, fs.Source.MkdirAll(basepath, 0777))
+	c.Assert(fs.Source.MkdirAll(basepath, 0777), qt.IsNil)
 	_, err := fs.Source.Create(configPath)
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 
-	require.Error(t, n.doNewSite(fs, basepath, true))
+	c.Assert(n.doNewSite(fs, basepath, true), qt.Not(qt.IsNil))
 }
 
 func newTestCfg() (*viper.Viper, *hugofs.Fs) {

commands/server_test.go

@@ -24,8 +24,8 @@ import (
 
 	"github.com/gohugoio/hugo/helpers"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestServer(t *testing.T) {
@@ -33,9 +33,9 @@ func TestServer(t *testing.T) {
 		// TODO(bep) not sure why server tests have started to fail on the Windows CI server.
 		t.Skip("Skip server test on appveyor")
 	}
-	assert := require.New(t)
+	c := qt.New(t)
 	dir, err := createSimpleTestSite(t, testSiteConfig{})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	// Let us hope that this port is available on all systems ...
 	port := 1331
@@ -54,7 +54,7 @@ func TestServer(t *testing.T) {
 
 	go func() {
 		_, err = cmd.ExecuteC()
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 	}()
 
 	// There is no way to know exactly when the server is ready for connections.
@@ -63,12 +63,12 @@ func TestServer(t *testing.T) {
 	time.Sleep(2 * time.Second)
 
 	resp, err := http.Get("http://localhost:1331/")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer resp.Body.Close()
 	homeContent := helpers.ReaderToString(resp.Body)
 
-	assert.Contains(homeContent, "List: Hugo Commands")
-	assert.Contains(homeContent, "Environment: development")
+	c.Assert(homeContent, qt.Contains, "List: Hugo Commands")
+	c.Assert(homeContent, qt.Contains, "Environment: development")
 
 	// Stop the server.
 	stop <- true
@@ -118,14 +118,14 @@ func TestFixURL(t *testing.T) {
 }
 
 func TestRemoveErrorPrefixFromLog(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	content := `ERROR 2018/10/07 13:11:12 Error while rendering "home": template: _default/baseof.html:4:3: executing "main" at <partial "logo" .>: error calling partial: template: partials/logo.html:5:84: executing "partials/logo.html" at <$resized.AHeight>: can't evaluate field AHeight in type *resource.Image
 ERROR 2018/10/07 13:11:12 Rebuild failed: logged 1 error(s)
 `
 
 	withoutError := removeErrorPrefixFromLog(content)
 
-	assert.False(strings.Contains(withoutError, "ERROR"), withoutError)
+	c.Assert(strings.Contains(withoutError, "ERROR"), qt.Equals, false)
 
 }
 

common/collections/append_test.go

@@ -14,17 +14,16 @@
 package collections
 
 import (
-	"fmt"
-	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestAppend(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		start    interface{}
 		addend   []interface{}
 		expected interface{}
@@ -59,20 +58,16 @@ func TestAppend(t *testing.T) {
 			false},
 	} {
 
-		errMsg := fmt.Sprintf("[%d]", i)
-
 		result, err := Append(test.start, test.addend...)
 
 		if b, ok := test.expected.(bool); ok && !b {
-			require.Error(t, err, errMsg)
+
+			c.Assert(err, qt.Not(qt.IsNil))
 			continue
 		}
 
-		require.NoError(t, err, errMsg)
-
-		if !reflect.DeepEqual(test.expected, result) {
-			t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)
-		}
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.DeepEquals, test.expected)
 	}
 
 }

common/collections/slice_test.go

@@ -15,10 +15,9 @@ package collections
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 
-	"github.com/alecthomas/assert"
+	qt "github.com/frankban/quicktest"
 )
 
 var _ Slicer = (*tstSlicer)(nil)
@@ -34,15 +33,15 @@ type testSlicerInterface interface {
 type testSlicerInterfaces []testSlicerInterface
 
 type tstSlicerIn1 struct {
-	name string
+	TheName string
 }
 
 type tstSlicerIn2 struct {
-	name string
+	TheName string
 }
 
 type tstSlicer struct {
-	name string
+	TheName string
 }
 
 func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
@@ -75,11 +74,11 @@ func (p *tstSlicerIn2) Slice(in interface{}) (interface{}, error) {
 }
 
 func (p *tstSlicerIn1) Name() string {
-	return p.name
+	return p.TheName
 }
 
 func (p *tstSlicerIn2) Name() string {
-	return p.name
+	return p.TheName
 }
 
 func (p *tstSlicer) Slice(in interface{}) (interface{}, error) {
@@ -100,6 +99,7 @@ type tstSlicers []*tstSlicer
 
 func TestSlice(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
 	for i, test := range []struct {
 		args     []interface{}
@@ -114,12 +114,11 @@ func TestSlice(t *testing.T) {
 		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}, testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}},
 		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}, []interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test.args)
+		errMsg := qt.Commentf("[%d] %v", i, test.args)
 
 		result := Slice(test.args...)
 
-		assert.Equal(t, test.expected, result, errMsg)
+		c.Assert(test.expected, qt.DeepEquals, result, errMsg)
 	}
 
-	assert.Len(t, Slice(), 0)
 }

common/herrors/error_locator_test.go

@@ -18,11 +18,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestErrorLocator(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	lineMatcher := func(m LineMatcher) bool {
 		return strings.Contains(m.Line, "THEONE")
@@ -39,45 +39,45 @@ LINE 8
 `
 
 	location := locateErrorInString(lines, lineMatcher)
-	assert.Equal([]string{"LINE 3", "LINE 4", "This is THEONE", "LINE 6", "LINE 7"}, location.Lines)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"LINE 3", "LINE 4", "This is THEONE", "LINE 6", "LINE 7"})
 
 	pos := location.Position()
-	assert.Equal(5, pos.LineNumber)
-	assert.Equal(2, location.LinesPos)
+	c.Assert(pos.LineNumber, qt.Equals, 5)
+	c.Assert(location.LinesPos, qt.Equals, 2)
 
-	assert.Equal([]string{"This is THEONE"}, locateErrorInString(`This is THEONE`, lineMatcher).Lines)
+	c.Assert(locateErrorInString(`This is THEONE`, lineMatcher).Lines, qt.DeepEquals, []string{"This is THEONE"})
 
 	location = locateErrorInString(`L1
 This is THEONE
 L2
 `, lineMatcher)
-	assert.Equal(2, location.Position().LineNumber)
-	assert.Equal(1, location.LinesPos)
-	assert.Equal([]string{"L1", "This is THEONE", "L2", ""}, location.Lines)
+	c.Assert(location.Position().LineNumber, qt.Equals, 2)
+	c.Assert(location.LinesPos, qt.Equals, 1)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "This is THEONE", "L2", ""})
 
 	location = locateErrorInString(`This is THEONE
 L2
 `, lineMatcher)
-	assert.Equal(0, location.LinesPos)
-	assert.Equal([]string{"This is THEONE", "L2", ""}, location.Lines)
+	c.Assert(location.LinesPos, qt.Equals, 0)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"This is THEONE", "L2", ""})
 
 	location = locateErrorInString(`L1
 This THEONE
 `, lineMatcher)
-	assert.Equal([]string{"L1", "This THEONE", ""}, location.Lines)
-	assert.Equal(1, location.LinesPos)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "This THEONE", ""})
+	c.Assert(location.LinesPos, qt.Equals, 1)
 
 	location = locateErrorInString(`L1
 L2
 This THEONE
 `, lineMatcher)
-	assert.Equal([]string{"L1", "L2", "This THEONE", ""}, location.Lines)
-	assert.Equal(2, location.LinesPos)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"L1", "L2", "This THEONE", ""})
+	c.Assert(location.LinesPos, qt.Equals, 2)
 
 	location = locateErrorInString("NO MATCH", lineMatcher)
-	assert.Equal(-1, location.Position().LineNumber)
-	assert.Equal(-1, location.LinesPos)
-	assert.Equal(0, len(location.Lines))
+	c.Assert(location.Position().LineNumber, qt.Equals, -1)
+	c.Assert(location.LinesPos, qt.Equals, -1)
+	c.Assert(len(location.Lines), qt.Equals, 0)
 
 	lineMatcher = func(m LineMatcher) bool {
 		return m.LineNumber == 6
@@ -94,9 +94,9 @@ H
 I
 J`, lineMatcher)
 
-	assert.Equal([]string{"D", "E", "F", "G", "H"}, location.Lines)
-	assert.Equal(6, location.Position().LineNumber)
-	assert.Equal(2, location.LinesPos)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"D", "E", "F", "G", "H"})
+	c.Assert(location.Position().LineNumber, qt.Equals, 6)
+	c.Assert(location.LinesPos, qt.Equals, 2)
 
 	// Test match EOF
 	lineMatcher = func(m LineMatcher) bool {
@@ -108,9 +108,9 @@ B
 C
 `, lineMatcher)
 
-	assert.Equal([]string{"B", "C", ""}, location.Lines)
-	assert.Equal(4, location.Position().LineNumber)
-	assert.Equal(2, location.LinesPos)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"B", "C", ""})
+	c.Assert(location.Position().LineNumber, qt.Equals, 4)
+	c.Assert(location.LinesPos, qt.Equals, 2)
 
 	offsetMatcher := func(m LineMatcher) bool {
 		return m.Offset == 1
@@ -122,8 +122,8 @@ C
 D
 E`, offsetMatcher)
 
-	assert.Equal([]string{"A", "B", "C", "D"}, location.Lines)
-	assert.Equal(2, location.Position().LineNumber)
-	assert.Equal(1, location.LinesPos)
+	c.Assert(location.Lines, qt.DeepEquals, []string{"A", "B", "C", "D"})
+	c.Assert(location.Position().LineNumber, qt.Equals, 2)
+	c.Assert(location.LinesPos, qt.Equals, 1)
 
 }

common/herrors/file_error_test.go

@@ -14,18 +14,17 @@
 package herrors
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/pkg/errors"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestToLineNumberError(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	for i, test := range []struct {
 		in           error
@@ -43,15 +42,15 @@ func TestToLineNumberError(t *testing.T) {
 
 		got := ToFileError("template", test.in)
 
-		errMsg := fmt.Sprintf("[%d][%T]", i, got)
+		errMsg := qt.Commentf("[%d][%T]", i, got)
 		le, ok := got.(FileError)
-		assert.True(ok)
+		c.Assert(ok, qt.Equals, true)
 
-		assert.True(ok, errMsg)
+		c.Assert(ok, qt.Equals, true, errMsg)
 		pos := le.Position()
-		assert.Equal(test.lineNumber, pos.LineNumber, errMsg)
-		assert.Equal(test.columnNumber, pos.ColumnNumber, errMsg)
-		assert.Error(errors.Cause(got))
+		c.Assert(pos.LineNumber, qt.Equals, test.lineNumber, errMsg)
+		c.Assert(pos.ColumnNumber, qt.Equals, test.columnNumber, errMsg)
+		c.Assert(errors.Cause(got), qt.Not(qt.IsNil))
 	}
 
 }

common/hreflect/helpers_test.go

@@ -18,16 +18,16 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestIsTruthful(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
-	assert.True(IsTruthful(true))
-	assert.False(IsTruthful(false))
-	assert.True(IsTruthful(time.Now()))
-	assert.False(IsTruthful(time.Time{}))
+	c.Assert(IsTruthful(true), qt.Equals, true)
+	c.Assert(IsTruthful(false), qt.Equals, false)
+	c.Assert(IsTruthful(time.Now()), qt.Equals, true)
+	c.Assert(IsTruthful(time.Time{}), qt.Equals, false)
 }
 
 func BenchmarkIsTruthFul(b *testing.B) {

common/hugo/hugo_test.go

@@ -17,19 +17,19 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestHugoInfo(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	hugoInfo := NewInfo("")
 
-	assert.Equal(CurrentVersion.Version(), hugoInfo.Version())
-	assert.IsType(VersionString(""), hugoInfo.Version())
-	assert.Equal(commitHash, hugoInfo.CommitHash)
-	assert.Equal(buildDate, hugoInfo.BuildDate)
-	assert.Equal("production", hugoInfo.Environment)
-	assert.Contains(hugoInfo.Generator(), fmt.Sprintf("Hugo %s", hugoInfo.Version()))
+	c.Assert(hugoInfo.Version(), qt.Equals, CurrentVersion.Version())
+	c.Assert(fmt.Sprintf("%T", VersionString("")), qt.Equals, fmt.Sprintf("%T", hugoInfo.Version()))
+	c.Assert(hugoInfo.CommitHash, qt.Equals, commitHash)
+	c.Assert(hugoInfo.BuildDate, qt.Equals, buildDate)
+	c.Assert(hugoInfo.Environment, qt.Equals, "production")
+	c.Assert(string(hugoInfo.Generator()), qt.Contains, fmt.Sprintf("Hugo %s", hugoInfo.Version()))
 
 }

common/hugo/version_test.go

@@ -16,70 +16,73 @@ package hugo
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestHugoVersion(t *testing.T) {
-	assert.Equal(t, "0.15-DEV", version(0.15, 0, "-DEV"))
-	assert.Equal(t, "0.15.2-DEV", version(0.15, 2, "-DEV"))
+	c := qt.New(t)
+
+	c.Assert(version(0.15, 0, "-DEV"), qt.Equals, "0.15-DEV")
+	c.Assert(version(0.15, 2, "-DEV"), qt.Equals, "0.15.2-DEV")
 
 	v := Version{Number: 0.21, PatchLevel: 0, Suffix: "-DEV"}
 
-	require.Equal(t, v.ReleaseVersion().String(), "0.21")
-	require.Equal(t, "0.21-DEV", v.String())
-	require.Equal(t, "0.22", v.Next().String())
+	c.Assert(v.ReleaseVersion().String(), qt.Equals, "0.21")
+	c.Assert(v.String(), qt.Equals, "0.21-DEV")
+	c.Assert(v.Next().String(), qt.Equals, "0.22")
 	nextVersionString := v.Next().Version()
-	require.Equal(t, "0.22", nextVersionString.String())
-	require.True(t, nextVersionString.Eq("0.22"))
-	require.False(t, nextVersionString.Eq("0.21"))
-	require.True(t, nextVersionString.Eq(nextVersionString))
-	require.Equal(t, "0.20.3", v.NextPatchLevel(3).String())
+	c.Assert(nextVersionString.String(), qt.Equals, "0.22")
+	c.Assert(nextVersionString.Eq("0.22"), qt.Equals, true)
+	c.Assert(nextVersionString.Eq("0.21"), qt.Equals, false)
+	c.Assert(nextVersionString.Eq(nextVersionString), qt.Equals, true)
+	c.Assert(v.NextPatchLevel(3).String(), qt.Equals, "0.20.3")
 
 	// We started to use full semver versions even for main
 	// releases in v0.54.0
 	v = Version{Number: 0.53, PatchLevel: 0}
-	require.Equal(t, "0.53", v.String())
-	require.Equal(t, "0.54.0", v.Next().String())
-	require.Equal(t, "0.55.0", v.Next().Next().String())
+	c.Assert(v.String(), qt.Equals, "0.53")
+	c.Assert(v.Next().String(), qt.Equals, "0.54.0")
+	c.Assert(v.Next().Next().String(), qt.Equals, "0.55.0")
 	v = Version{Number: 0.54, PatchLevel: 0, Suffix: "-DEV"}
-	require.Equal(t, "0.54.0-DEV", v.String())
+	c.Assert(v.String(), qt.Equals, "0.54.0-DEV")
 }
 
 func TestCompareVersions(t *testing.T) {
-	require.Equal(t, 0, compareVersions(0.20, 0, 0.20))
-	require.Equal(t, 0, compareVersions(0.20, 0, float32(0.20)))
-	require.Equal(t, 0, compareVersions(0.20, 0, float64(0.20)))
-	require.Equal(t, 1, compareVersions(0.19, 1, 0.20))
-	require.Equal(t, 1, compareVersions(0.19, 3, "0.20.2"))
-	require.Equal(t, -1, compareVersions(0.19, 1, 0.01))
-	require.Equal(t, 1, compareVersions(0, 1, 3))
-	require.Equal(t, 1, compareVersions(0, 1, int32(3)))
-	require.Equal(t, 1, compareVersions(0, 1, int64(3)))
-	require.Equal(t, 0, compareVersions(0.20, 0, "0.20"))
-	require.Equal(t, 0, compareVersions(0.20, 1, "0.20.1"))
-	require.Equal(t, -1, compareVersions(0.20, 1, "0.20"))
-	require.Equal(t, 1, compareVersions(0.20, 0, "0.20.1"))
-	require.Equal(t, 1, compareVersions(0.20, 1, "0.20.2"))
-	require.Equal(t, 1, compareVersions(0.21, 1, "0.22.1"))
-	require.Equal(t, -1, compareVersions(0.22, 0, "0.22-DEV"))
-	require.Equal(t, 1, compareVersions(0.22, 0, "0.22.1-DEV"))
-	require.Equal(t, 1, compareVersionsWithSuffix(0.22, 0, "-DEV", "0.22"))
-	require.Equal(t, -1, compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22"))
-	require.Equal(t, 0, compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22.1-DEV"))
+	c := qt.New(t)
 
+	c.Assert(compareVersions(0.20, 0, 0.20), qt.Equals, 0)
+	c.Assert(compareVersions(0.20, 0, float32(0.20)), qt.Equals, 0)
+	c.Assert(compareVersions(0.20, 0, float64(0.20)), qt.Equals, 0)
+	c.Assert(compareVersions(0.19, 1, 0.20), qt.Equals, 1)
+	c.Assert(compareVersions(0.19, 3, "0.20.2"), qt.Equals, 1)
+	c.Assert(compareVersions(0.19, 1, 0.01), qt.Equals, -1)
+	c.Assert(compareVersions(0, 1, 3), qt.Equals, 1)
+	c.Assert(compareVersions(0, 1, int32(3)), qt.Equals, 1)
+	c.Assert(compareVersions(0, 1, int64(3)), qt.Equals, 1)
+	c.Assert(compareVersions(0.20, 0, "0.20"), qt.Equals, 0)
+	c.Assert(compareVersions(0.20, 1, "0.20.1"), qt.Equals, 0)
+	c.Assert(compareVersions(0.20, 1, "0.20"), qt.Equals, -1)
+	c.Assert(compareVersions(0.20, 0, "0.20.1"), qt.Equals, 1)
+	c.Assert(compareVersions(0.20, 1, "0.20.2"), qt.Equals, 1)
+	c.Assert(compareVersions(0.21, 1, "0.22.1"), qt.Equals, 1)
+	c.Assert(compareVersions(0.22, 0, "0.22-DEV"), qt.Equals, -1)
+	c.Assert(compareVersions(0.22, 0, "0.22.1-DEV"), qt.Equals, 1)
+	c.Assert(compareVersionsWithSuffix(0.22, 0, "-DEV", "0.22"), qt.Equals, 1)
+	c.Assert(compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22"), qt.Equals, -1)
+	c.Assert(compareVersionsWithSuffix(0.22, 1, "-DEV", "0.22.1-DEV"), qt.Equals, 0)
 }
 
 func TestParseHugoVersion(t *testing.T) {
-	require.Equal(t, "0.25", MustParseVersion("0.25").String())
-	require.Equal(t, "0.25.2", MustParseVersion("0.25.2").String())
-	require.Equal(t, "0.25-test", MustParseVersion("0.25-test").String())
-	require.Equal(t, "0.25-DEV", MustParseVersion("0.25-DEV").String())
+	c := qt.New(t)
 
+	c.Assert(MustParseVersion("0.25").String(), qt.Equals, "0.25")
+	c.Assert(MustParseVersion("0.25.2").String(), qt.Equals, "0.25.2")
+	c.Assert(MustParseVersion("0.25-test").String(), qt.Equals, "0.25-test")
+	c.Assert(MustParseVersion("0.25-DEV").String(), qt.Equals, "0.25-DEV")
 }
 
 func TestGoMinorVersion(t *testing.T) {
-	assert := require.New(t)
-	assert.Equal(12, goMinorVersion("go1.12.5"))
-	assert.True(GoMinorVersion() >= 11)
+	c := qt.New(t)
+	c.Assert(goMinorVersion("go1.12.5"), qt.Equals, 12)
+	c.Assert(GoMinorVersion() >= 11, qt.Equals, true)
 }

common/loggers/loggers_test.go

@@ -16,17 +16,17 @@ package loggers
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestLogger(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	l := NewWarningLogger()
 
 	l.ERROR.Println("One error")
 	l.ERROR.Println("Two error")
 	l.WARN.Println("A warning")
 
-	assert.Equal(uint64(2), l.ErrorCounter.Count())
+	c.Assert(l.ErrorCounter.Count(), qt.Equals, uint64(2))
 
 }

common/maps/maps_test.go

@@ -17,7 +17,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestToLower(t *testing.T) {
@@ -74,7 +74,7 @@ func TestToLower(t *testing.T) {
 }
 
 func TestRenameKeys(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	m := map[string]interface{}{
 		"a":    32,
@@ -112,7 +112,7 @@ func TestRenameKeys(t *testing.T) {
 		"{ren1,sub/*/ren1}", "new1",
 		"{Ren2,sub/ren2}", "new2",
 	)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	renamer.Rename(m)
 

common/maps/params_test.go

@@ -16,7 +16,7 @@ package maps
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestGetNestedParam(t *testing.T) {
@@ -33,19 +33,19 @@ func TestGetNestedParam(t *testing.T) {
 		},
 	}
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	must := func(keyStr, separator string, candidates ...map[string]interface{}) interface{} {
 		v, err := GetNestedParam(keyStr, separator, candidates...)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		return v
 	}
 
-	assert.Equal(1, must("first", "_", m))
-	assert.Equal(1, must("First", "_", m))
-	assert.Equal(2, must("with_underscore", "_", m))
-	assert.Equal("blue", must("nested_color", "_", m))
-	assert.Equal("green", must("nested.nestednested.color", ".", m))
-	assert.Nil(must("string.name", ".", m))
+	c.Assert(must("first", "_", m), qt.Equals, 1)
+	c.Assert(must("First", "_", m), qt.Equals, 1)
+	c.Assert(must("with_underscore", "_", m), qt.Equals, 2)
+	c.Assert(must("nested_color", "_", m), qt.Equals, "blue")
+	c.Assert(must("nested.nestednested.color", ".", m), qt.Equals, "green")
+	c.Assert(must("string.name", ".", m), qt.IsNil)
 
 }

common/maps/scratch_test.go

@@ -18,31 +18,31 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestScratchAdd(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.Add("int1", 10)
 	scratch.Add("int1", 20)
 	scratch.Add("int2", 20)
 
-	assert.Equal(int64(30), scratch.Get("int1"))
-	assert.Equal(20, scratch.Get("int2"))
+	c.Assert(scratch.Get("int1"), qt.Equals, int64(30))
+	c.Assert(scratch.Get("int2"), qt.Equals, 20)
 
 	scratch.Add("float1", float64(10.5))
 	scratch.Add("float1", float64(20.1))
 
-	assert.Equal(float64(30.6), scratch.Get("float1"))
+	c.Assert(scratch.Get("float1"), qt.Equals, float64(30.6))
 
 	scratch.Add("string1", "Hello ")
 	scratch.Add("string1", "big ")
 	scratch.Add("string1", "World!")
 
-	assert.Equal("Hello big World!", scratch.Get("string1"))
+	c.Assert(scratch.Get("string1"), qt.Equals, "Hello big World!")
 
 	scratch.Add("scratch", scratch)
 	_, err := scratch.Add("scratch", scratch)
@@ -55,14 +55,14 @@ func TestScratchAdd(t *testing.T) {
 
 func TestScratchAddSlice(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 
 	_, err := scratch.Add("intSlice", []int{1, 2})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	_, err = scratch.Add("intSlice", 3)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	sl := scratch.Get("intSlice")
 	expected := []int{1, 2, 3}
@@ -72,7 +72,7 @@ func TestScratchAddSlice(t *testing.T) {
 	}
 	_, err = scratch.Add("intSlice", []int{4, 5})
 
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	sl = scratch.Get("intSlice")
 	expected = []int{1, 2, 3, 4, 5}
@@ -85,49 +85,49 @@ func TestScratchAddSlice(t *testing.T) {
 // https://github.com/gohugoio/hugo/issues/5275
 func TestScratchAddTypedSliceToInterfaceSlice(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.Set("slice", []interface{}{})
 
 	_, err := scratch.Add("slice", []int{1, 2})
-	assert.NoError(err)
-	assert.Equal([]int{1, 2}, scratch.Get("slice"))
+	c.Assert(err, qt.IsNil)
+	c.Assert(scratch.Get("slice"), qt.DeepEquals, []int{1, 2})
 
 }
 
 // https://github.com/gohugoio/hugo/issues/5361
 func TestScratchAddDifferentTypedSliceToInterfaceSlice(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.Set("slice", []string{"foo"})
 
 	_, err := scratch.Add("slice", []int{1, 2})
-	assert.NoError(err)
-	assert.Equal([]interface{}{"foo", 1, 2}, scratch.Get("slice"))
+	c.Assert(err, qt.IsNil)
+	c.Assert(scratch.Get("slice"), qt.DeepEquals, []interface{}{"foo", 1, 2})
 
 }
 
 func TestScratchSet(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.Set("key", "val")
-	assert.Equal("val", scratch.Get("key"))
+	c.Assert(scratch.Get("key"), qt.Equals, "val")
 }
 
 func TestScratchDelete(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.Set("key", "val")
 	scratch.Delete("key")
 	scratch.Add("key", "Lucy Parsons")
-	assert.Equal("Lucy Parsons", scratch.Get("key"))
+	c.Assert(scratch.Get("key"), qt.Equals, "Lucy Parsons")
 }
 
 // Issue #2005
@@ -177,7 +177,7 @@ func TestScratchGet(t *testing.T) {
 
 func TestScratchSetInMap(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	scratch := NewScratch()
 	scratch.SetInMap("key", "lux", "Lux")
@@ -185,7 +185,7 @@ func TestScratchSetInMap(t *testing.T) {
 	scratch.SetInMap("key", "zyx", "Zyx")
 	scratch.SetInMap("key", "abc", "Abc (updated)")
 	scratch.SetInMap("key", "def", "Def")
-	assert.Equal([]interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"}, scratch.GetSortedMapValues("key"))
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
 }
 
 func TestScratchGetSortedMapValues(t *testing.T) {

common/math/math_test.go

@@ -14,17 +14,16 @@
 package math
 
 import (
-	"fmt"
 	"testing"
 
-	"github.com/alecthomas/assert"
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestDoArithmetic(t *testing.T) {
 	t.Parallel()
+	c := qt.New(t)
 
-	for i, test := range []struct {
+	for _, test := range []struct {
 		a      interface{}
 		b      interface{}
 		op     rune
@@ -94,16 +93,14 @@ func TestDoArithmetic(t *testing.T) {
 		{"foo", "bar", '-', false},
 		{3, 2, '%', false},
 	} {
-		errMsg := fmt.Sprintf("[%d] %v", i, test)
-
 		result, err := DoArithmetic(test.a, test.b, test.op)
 
 		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(test.expect, qt.Equals, result)
 	}
 }

common/text/position_test.go

@@ -16,18 +16,18 @@ package text
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestPositionStringFormatter(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pos := Position{Filename: "/my/file.txt", LineNumber: 12, ColumnNumber: 13, Offset: 14}
 
-	assert.Equal("/my/file.txt|13|12", createPositionStringFormatter(":file|:col|:line")(pos))
-	assert.Equal("13|/my/file.txt|12", createPositionStringFormatter(":col|:file|:line")(pos))
-	assert.Equal("好:13", createPositionStringFormatter("好::col")(pos))
-	assert.Equal("\"/my/file.txt:12:13\"", createPositionStringFormatter("")(pos))
-	assert.Equal("\"/my/file.txt:12:13\"", pos.String())
+	c.Assert(createPositionStringFormatter(":file|:col|:line")(pos), qt.Equals, "/my/file.txt|13|12")
+	c.Assert(createPositionStringFormatter(":col|:file|:line")(pos), qt.Equals, "13|/my/file.txt|12")
+	c.Assert(createPositionStringFormatter("好::col")(pos), qt.Equals, "好:13")
+	c.Assert(createPositionStringFormatter("")(pos), qt.Equals, "\"/my/file.txt:12:13\"")
+	c.Assert(pos.String(), qt.Equals, "\"/my/file.txt:12:13\"")
 
 }

common/types/evictingqueue_test.go

@@ -17,36 +17,36 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestEvictingStringQueue(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	queue := NewEvictingStringQueue(3)
 
-	assert.Equal("", queue.Peek())
+	c.Assert(queue.Peek(), qt.Equals, "")
 	queue.Add("a")
 	queue.Add("b")
 	queue.Add("a")
-	assert.Equal("b", queue.Peek())
+	c.Assert(queue.Peek(), qt.Equals, "b")
 	queue.Add("b")
-	assert.Equal("b", queue.Peek())
+	c.Assert(queue.Peek(), qt.Equals, "b")
 
 	queue.Add("a")
 	queue.Add("b")
 
-	assert.True(queue.Contains("a"))
-	assert.False(queue.Contains("foo"))
+	c.Assert(queue.Contains("a"), qt.Equals, true)
+	c.Assert(queue.Contains("foo"), qt.Equals, false)
 
-	assert.Equal([]string{"b", "a"}, queue.PeekAll())
-	assert.Equal("b", queue.Peek())
+	c.Assert(queue.PeekAll(), qt.DeepEquals, []string{"b", "a"})
+	c.Assert(queue.Peek(), qt.Equals, "b")
 	queue.Add("c")
 	queue.Add("d")
 	// Overflowed, a should now be removed.
-	assert.Equal([]string{"d", "c", "b"}, queue.PeekAll())
-	assert.Len(queue.PeekAllSet(), 3)
-	assert.True(queue.PeekAllSet()["c"])
+	c.Assert(queue.PeekAll(), qt.DeepEquals, []string{"d", "c", "b"})
+	c.Assert(len(queue.PeekAllSet()), qt.Equals, 3)
+	c.Assert(queue.PeekAllSet()["c"], qt.Equals, true)
 }
 
 func TestEvictingStringQueueConcurrent(t *testing.T) {

common/types/types_test.go

@@ -16,14 +16,14 @@ package types
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestKeyValues(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	kv := NewKeyValuesStrings("key", "a1", "a2")
 
-	assert.Equal("key", kv.KeyString())
-	assert.Equal([]interface{}{"a1", "a2"}, kv.Values)
+	c.Assert(kv.KeyString(), qt.Equals, "key")
+	c.Assert(kv.Values, qt.DeepEquals, []interface{}{"a1", "a2"})
 }

compare/compare_strings_test.go

@@ -14,17 +14,16 @@
 package compare
 
 import (
-	"fmt"
 	"sort"
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestCompare(t *testing.T) {
-	assert := require.New(t)
-	for i, test := range []struct {
+	c := qt.New(t)
+	for _, test := range []struct {
 		a string
 		b string
 	}{
@@ -47,13 +46,13 @@ func TestCompare(t *testing.T) {
 		expect := strings.Compare(strings.ToLower(test.a), strings.ToLower(test.b))
 		got := compareFold(test.a, test.b)
 
-		assert.Equal(expect, got, fmt.Sprintf("test %d: %d", i, expect))
+		c.Assert(got, qt.Equals, expect)
 
 	}
 }
 
 func TestLexicographicSort(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	s := []string{"b", "Bz", "ba", "A", "Ba", "ba"}
 
@@ -61,6 +60,6 @@ func TestLexicographicSort(t *testing.T) {
 		return LessStrings(s[i], s[j])
 	})
 
-	assert.Equal([]string{"A", "b", "Ba", "ba", "ba", "Bz"}, s)
+	c.Assert(s, qt.DeepEquals, []string{"A", "b", "Ba", "ba", "ba", "Bz"})
 
 }

config/configLoader_test.go

@@ -17,18 +17,18 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestIsValidConfigFileName(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	for _, ext := range ValidConfigFileExtensions {
 		filename := "config." + ext
-		assert.True(IsValidConfigFilename(filename), ext)
-		assert.True(IsValidConfigFilename(strings.ToUpper(filename)))
+		c.Assert(IsValidConfigFilename(filename), qt.Equals, true)
+		c.Assert(IsValidConfigFilename(strings.ToUpper(filename)), qt.Equals, true)
 	}
 
-	assert.False(IsValidConfigFilename(""))
-	assert.False(IsValidConfigFilename("config.toml.swp"))
+	c.Assert(IsValidConfigFilename(""), qt.Equals, false)
+	c.Assert(IsValidConfigFilename("config.toml.swp"), qt.Equals, false)
 }

config/configProvider_test.go

@@ -16,12 +16,12 @@ package config
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestGetStringSlicePreserveString(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	cfg := viper.New()
 
 	s := "This is a string"
@@ -30,7 +30,7 @@ func TestGetStringSlicePreserveString(t *testing.T) {
 	cfg.Set("s1", s)
 	cfg.Set("s2", sSlice)
 
-	assert.Equal([]string{s}, GetStringSlicePreserveString(cfg, "s1"))
-	assert.Equal(sSlice, GetStringSlicePreserveString(cfg, "s2"))
-	assert.Nil(GetStringSlicePreserveString(cfg, "s3"))
+	c.Assert(GetStringSlicePreserveString(cfg, "s1"), qt.DeepEquals, []string{s})
+	c.Assert(GetStringSlicePreserveString(cfg, "s2"), qt.DeepEquals, sSlice)
+	c.Assert(GetStringSlicePreserveString(cfg, "s3"), qt.IsNil)
 }

config/env_test.go

@@ -16,17 +16,17 @@ package config
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestSetEnvVars(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 	vars := []string{"FOO=bar", "HUGO=cool", "BAR=foo"}
 	SetEnvVars(&vars, "HUGO", "rocking!", "NEW", "bar")
-	assert.Equal([]string{"FOO=bar", "HUGO=rocking!", "BAR=foo", "NEW=bar"}, vars)
+	c.Assert(vars, qt.DeepEquals, []string{"FOO=bar", "HUGO=rocking!", "BAR=foo", "NEW=bar"})
 
 	key, val := SplitEnvVar("HUGO=rocks")
-	assert.Equal("HUGO", key)
-	assert.Equal("rocks", val)
+	c.Assert(key, qt.Equals, "HUGO")
+	c.Assert(val, qt.Equals, "rocks")
 }

config/privacy/privacyConfig_test.go

@@ -16,13 +16,13 @@ package privacy
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/config"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestDecodeConfigFromTOML(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -52,30 +52,27 @@ privacyEnhanced = true
 simple = true
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	pc, err := DecodeConfig(cfg)
-	assert.NoError(err)
-	assert.NotNil(pc)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pc, qt.Not(qt.IsNil))
+
+	got := []bool{
+		pc.Disqus.Disable, pc.GoogleAnalytics.Disable,
+		pc.GoogleAnalytics.RespectDoNotTrack, pc.GoogleAnalytics.AnonymizeIP,
+		pc.GoogleAnalytics.UseSessionStorage, pc.Instagram.Disable,
+		pc.Instagram.Simple, pc.Twitter.Disable, pc.Twitter.EnableDNT,
+		pc.Twitter.Simple, pc.Vimeo.Disable, pc.Vimeo.Simple,
+		pc.YouTube.PrivacyEnhanced, pc.YouTube.Disable,
+	}
+
+	c.Assert(got, qt.All(qt.Equals), true)
 
-	assert.True(pc.Disqus.Disable)
-	assert.True(pc.GoogleAnalytics.Disable)
-	assert.True(pc.GoogleAnalytics.RespectDoNotTrack)
-	assert.True(pc.GoogleAnalytics.AnonymizeIP)
-	assert.True(pc.GoogleAnalytics.UseSessionStorage)
-	assert.True(pc.Instagram.Disable)
-	assert.True(pc.Instagram.Simple)
-	assert.True(pc.Twitter.Disable)
-	assert.True(pc.Twitter.EnableDNT)
-	assert.True(pc.Twitter.Simple)
-	assert.True(pc.Vimeo.Disable)
-	assert.True(pc.Vimeo.Simple)
-	assert.True(pc.YouTube.PrivacyEnhanced)
-	assert.True(pc.YouTube.Disable)
 }
 
 func TestDecodeConfigFromTOMLCaseInsensitive(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -86,19 +83,19 @@ someOtherValue = "foo"
 PrivacyENhanced = true
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	pc, err := DecodeConfig(cfg)
-	assert.NoError(err)
-	assert.NotNil(pc)
-	assert.True(pc.YouTube.PrivacyEnhanced)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pc, qt.Not(qt.IsNil))
+	c.Assert(pc.YouTube.PrivacyEnhanced, qt.Equals, true)
 }
 
 func TestDecodeConfigDefault(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pc, err := DecodeConfig(viper.New())
-	assert.NoError(err)
-	assert.NotNil(pc)
-	assert.False(pc.YouTube.PrivacyEnhanced)
+	c.Assert(err, qt.IsNil)
+	c.Assert(pc, qt.Not(qt.IsNil))
+	c.Assert(pc.YouTube.PrivacyEnhanced, qt.Equals, false)
 }

config/services/servicesConfig_test.go

@@ -16,13 +16,13 @@ package services
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/config"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestDecodeConfigFromTOML(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -39,31 +39,31 @@ disableInlineCSS = true
 disableInlineCSS = true
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	config, err := DecodeConfig(cfg)
-	assert.NoError(err)
-	assert.NotNil(config)
+	c.Assert(err, qt.IsNil)
+	c.Assert(config, qt.Not(qt.IsNil))
 
-	assert.Equal("DS", config.Disqus.Shortname)
-	assert.Equal("ga_id", config.GoogleAnalytics.ID)
+	c.Assert(config.Disqus.Shortname, qt.Equals, "DS")
+	c.Assert(config.GoogleAnalytics.ID, qt.Equals, "ga_id")
 
-	assert.True(config.Instagram.DisableInlineCSS)
+	c.Assert(config.Instagram.DisableInlineCSS, qt.Equals, true)
 }
 
 // Support old root-level GA settings etc.
 func TestUseSettingsFromRootIfSet(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cfg := viper.New()
 	cfg.Set("disqusShortname", "root_short")
 	cfg.Set("googleAnalytics", "ga_root")
 
 	config, err := DecodeConfig(cfg)
-	assert.NoError(err)
-	assert.NotNil(config)
+	c.Assert(err, qt.IsNil)
+	c.Assert(config, qt.Not(qt.IsNil))
 
-	assert.Equal("root_short", config.Disqus.Shortname)
-	assert.Equal("ga_root", config.GoogleAnalytics.ID)
+	c.Assert(config.Disqus.Shortname, qt.Equals, "root_short")
+	c.Assert(config.GoogleAnalytics.ID, qt.Equals, "ga_root")
 
 }

create/content_test.go

@@ -27,11 +27,11 @@ import (
 
 	"github.com/gohugoio/hugo/hugofs"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/create"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/spf13/afero"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestNewContent(t *testing.T) {
@@ -62,25 +62,25 @@ func TestNewContent(t *testing.T) {
 			"{{</* comment */>}}\n{{%/* comment */%}}"}}, // shortcodes
 	}
 
-	for i, c := range cases {
-		c := c
-		t.Run(fmt.Sprintf("%s-%d", c.kind, i), func(t *testing.T) {
+	for i, cas := range cases {
+		cas := cas
+		t.Run(fmt.Sprintf("%s-%d", cas.kind, i), func(t *testing.T) {
 			t.Parallel()
-			assert := require.New(t)
+			c := qt.New(t)
 			mm := afero.NewMemMapFs()
-			assert.NoError(initFs(mm))
-			cfg, fs := newTestCfg(assert, mm)
+			c.Assert(initFs(mm), qt.IsNil)
+			cfg, fs := newTestCfg(c, mm)
 			h, err := hugolib.NewHugoSites(deps.DepsCfg{Cfg: cfg, Fs: fs})
-			assert.NoError(err)
+			c.Assert(err, qt.IsNil)
 
-			assert.NoError(create.NewContent(h, c.kind, c.path))
+			c.Assert(create.NewContent(h, cas.kind, cas.path), qt.IsNil)
 
-			fname := filepath.FromSlash(c.path)
+			fname := filepath.FromSlash(cas.path)
 			if !strings.HasPrefix(fname, "content") {
 				fname = filepath.Join("content", fname)
 			}
 			content := readFileFromFs(t, fs.Source, fname)
-			for _, v := range c.expected {
+			for _, v := range cas.expected {
 				found := strings.Contains(content, v)
 				if !found {
 					t.Fatalf("[%d] %q missing from output:\n%q", i, v, content)
@@ -93,13 +93,13 @@ func TestNewContent(t *testing.T) {
 
 func TestNewContentFromDir(t *testing.T) {
 	mm := afero.NewMemMapFs()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	archetypeDir := filepath.Join("archetypes", "my-bundle")
-	assert.NoError(mm.MkdirAll(archetypeDir, 0755))
+	c.Assert(mm.MkdirAll(archetypeDir, 0755), qt.IsNil)
 
 	archetypeThemeDir := filepath.Join("themes", "mytheme", "archetypes", "my-theme-bundle")
-	assert.NoError(mm.MkdirAll(archetypeThemeDir, 0755))
+	c.Assert(mm.MkdirAll(archetypeThemeDir, 0755), qt.IsNil)
 
 	contentFile := `
 File: %s
@@ -108,38 +108,38 @@ Name: {{ replace .Name "-" " " | title }}
 i18n: {{ T "hugo" }}
 `
 
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755))
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.nn.md"), []byte(fmt.Sprintf(contentFile, "index.nn.md")), 0755))
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.nn.md"), []byte(fmt.Sprintf(contentFile, "index.nn.md")), 0755), qt.IsNil)
 
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeDir, "pages", "bio.md"), []byte(fmt.Sprintf(contentFile, "bio.md")), 0755))
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755))
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeDir, "resources", "hugo2.xml"), []byte(`hugo2: {{ printf "no template handling in here" }}`), 0755))
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "pages", "bio.md"), []byte(fmt.Sprintf(contentFile, "bio.md")), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "resources", "hugo2.xml"), []byte(`hugo2: {{ printf "no template handling in here" }}`), 0755), qt.IsNil)
 
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeThemeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755))
-	assert.NoError(afero.WriteFile(mm, filepath.Join(archetypeThemeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755))
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeThemeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeThemeDir, "resources", "hugo1.json"), []byte(`hugo1: {{ printf "no template handling in here" }}`), 0755), qt.IsNil)
 
-	assert.NoError(initFs(mm))
-	cfg, fs := newTestCfg(assert, mm)
+	c.Assert(initFs(mm), qt.IsNil)
+	cfg, fs := newTestCfg(c, mm)
 
 	h, err := hugolib.NewHugoSites(deps.DepsCfg{Cfg: cfg, Fs: fs})
-	assert.NoError(err)
-	assert.Equal(2, len(h.Sites))
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(h.Sites), qt.Equals, 2)
 
-	assert.NoError(create.NewContent(h, "my-bundle", "post/my-post"))
+	c.Assert(create.NewContent(h, "my-bundle", "post/my-post"), qt.IsNil)
 
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo2.xml")), `hugo2: {{ printf "no template handling in here" }}`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/resources/hugo2.xml")), `hugo2: {{ printf "no template handling in here" }}`)
 
 	// Content files should get the correct site context.
 	// TODO(bep) archetype check i18n
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Post`, `i18n: Hugo Rocks!`)
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.nn.md")), `File: index.nn.md`, `Site Lang: nn`, `Name: My Post`, `i18n: Hugo Rokkar!`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Post`, `i18n: Hugo Rocks!`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.nn.md")), `File: index.nn.md`, `Site Lang: nn`, `Name: My Post`, `i18n: Hugo Rokkar!`)
 
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/pages/bio.md")), `File: bio.md`, `Site Lang: en`, `Name: My Post`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/pages/bio.md")), `File: bio.md`, `Site Lang: en`, `Name: My Post`)
 
-	assert.NoError(create.NewContent(h, "my-theme-bundle", "post/my-theme-post"))
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Theme Post`, `i18n: Hugo Rocks!`)
-	assertContains(assert, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
+	c.Assert(create.NewContent(h, "my-theme-bundle", "post/my-theme-post"), qt.IsNil)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Theme Post`, `i18n: Hugo Rocks!`)
+	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
 
 }
 
@@ -221,9 +221,9 @@ Some text.
 	return nil
 }
 
-func assertContains(assert *require.Assertions, v interface{}, matches ...string) {
+func cContains(c *qt.C, v interface{}, matches ...string) {
 	for _, m := range matches {
-		assert.Contains(v, m)
+		c.Assert(v, qt.Contains, m)
 	}
 }
 
@@ -247,7 +247,7 @@ func readFileFromFs(t *testing.T, fs afero.Fs, filename string) string {
 	return string(b)
 }
 
-func newTestCfg(assert *require.Assertions, mm afero.Fs) (*viper.Viper, *hugofs.Fs) {
+func newTestCfg(c *qt.C, mm afero.Fs) (*viper.Viper, *hugofs.Fs) {
 
 	cfg := `
 
@@ -270,15 +270,15 @@ contentDir = "content_nn"
 
 	mm.MkdirAll(filepath.FromSlash("themes/mytheme"), 0777)
 
-	assert.NoError(afero.WriteFile(mm, filepath.Join("i18n", "en.toml"), []byte(`[hugo]
-other = "Hugo Rocks!"`), 0755))
-	assert.NoError(afero.WriteFile(mm, filepath.Join("i18n", "nn.toml"), []byte(`[hugo]
-other = "Hugo Rokkar!"`), 0755))
+	c.Assert(afero.WriteFile(mm, filepath.Join("i18n", "en.toml"), []byte(`[hugo]
+other = "Hugo Rocks!"`), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join("i18n", "nn.toml"), []byte(`[hugo]
+other = "Hugo Rokkar!"`), 0755), qt.IsNil)
 
-	assert.NoError(afero.WriteFile(mm, "config.toml", []byte(cfg), 0755))
+	c.Assert(afero.WriteFile(mm, "config.toml", []byte(cfg), 0755), qt.IsNil)
 
 	v, _, err := hugolib.LoadConfig(hugolib.ConfigSourceDescriptor{Fs: mm, Filename: "config.toml"})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	return v, hugofs.NewFrom(mm, v)
 

deploy/deployConfig_test.go

@@ -17,13 +17,13 @@ import (
 	"fmt"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/config"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestDecodeConfigFromTOML(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -77,42 +77,42 @@ gzip = true
 force = true
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	dcfg, err := decodeConfig(cfg)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	// Order.
-	assert.Equal(2, len(dcfg.Order))
-	assert.Equal("o1", dcfg.Order[0])
-	assert.Equal("o2", dcfg.Order[1])
-	assert.Equal(2, len(dcfg.ordering))
+	c.Assert(len(dcfg.Order), qt.Equals, 2)
+	c.Assert(dcfg.Order[0], qt.Equals, "o1")
+	c.Assert(dcfg.Order[1], qt.Equals, "o2")
+	c.Assert(len(dcfg.ordering), qt.Equals, 2)
 
 	// Targets.
-	assert.Equal(3, len(dcfg.Targets))
+	c.Assert(len(dcfg.Targets), qt.Equals, 3)
 	for i := 0; i < 3; i++ {
 		tgt := dcfg.Targets[i]
-		assert.Equal(fmt.Sprintf("name%d", i), tgt.Name)
-		assert.Equal(fmt.Sprintf("url%d", i), tgt.URL)
-		assert.Equal(fmt.Sprintf("cdn%d", i), tgt.CloudFrontDistributionID)
+		c.Assert(tgt.Name, qt.Equals, fmt.Sprintf("name%d", i))
+		c.Assert(tgt.URL, qt.Equals, fmt.Sprintf("url%d", i))
+		c.Assert(tgt.CloudFrontDistributionID, qt.Equals, fmt.Sprintf("cdn%d", i))
 	}
 
 	// Matchers.
-	assert.Equal(3, len(dcfg.Matchers))
+	c.Assert(len(dcfg.Matchers), qt.Equals, 3)
 	for i := 0; i < 3; i++ {
 		m := dcfg.Matchers[i]
-		assert.Equal(fmt.Sprintf("^pattern%d$", i), m.Pattern)
-		assert.NotNil(m.re)
-		assert.Equal(fmt.Sprintf("cachecontrol%d", i), m.CacheControl)
-		assert.Equal(fmt.Sprintf("contentencoding%d", i), m.ContentEncoding)
-		assert.Equal(fmt.Sprintf("contenttype%d", i), m.ContentType)
-		assert.Equal(i != 0, m.Gzip)
-		assert.Equal(i != 0, m.Force)
+		c.Assert(m.Pattern, qt.Equals, fmt.Sprintf("^pattern%d$", i))
+		c.Assert(m.re, qt.Not(qt.IsNil))
+		c.Assert(m.CacheControl, qt.Equals, fmt.Sprintf("cachecontrol%d", i))
+		c.Assert(m.ContentEncoding, qt.Equals, fmt.Sprintf("contentencoding%d", i))
+		c.Assert(m.ContentType, qt.Equals, fmt.Sprintf("contenttype%d", i))
+		c.Assert(m.Gzip, qt.Equals, i != 0)
+		c.Assert(m.Force, qt.Equals, i != 0)
 	}
 }
 
 func TestInvalidOrderingPattern(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -122,14 +122,14 @@ someOtherValue = "foo"
 order = ["["]  # invalid regular expression
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	_, err = decodeConfig(cfg)
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 }
 
 func TestInvalidMatcherPattern(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -140,17 +140,17 @@ someOtherValue = "foo"
 Pattern = "["  # invalid regular expression
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	_, err = decodeConfig(cfg)
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 }
 
 func TestDecodeConfigDefault(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	dcfg, err := decodeConfig(viper.New())
-	assert.NoError(err)
-	assert.Equal(0, len(dcfg.Targets))
-	assert.Equal(0, len(dcfg.Matchers))
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(dcfg.Targets), qt.Equals, 0)
+	c.Assert(len(dcfg.Matchers), qt.Equals, 0)
 }

go.mod

@@ -5,7 +5,6 @@ require (
 	github.com/BurntSushi/toml v0.3.1
 	github.com/PuerkitoBio/purell v1.1.0
 	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
-	github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38
 	github.com/alecthomas/chroma v0.6.4
 	github.com/alecthomas/repr v0.0.0-20181024024818-d37bc2a10ba1 // indirect
 	github.com/armon/go-radix v1.0.0
@@ -17,6 +16,7 @@ require (
 	github.com/dustin/go-humanize v1.0.0
 	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385
 	github.com/fortytw2/leaktest v1.3.0
+	github.com/frankban/quicktest v1.4.1
 	github.com/fsnotify/fsnotify v1.4.7
 	github.com/gobwas/glob v0.2.3
 	github.com/gohugoio/testmodBuilder/mods v0.0.0-20190520184928-c56af20f2e95
@@ -49,7 +49,6 @@ require (
 	github.com/spf13/jwalterweatherman v1.1.0
 	github.com/spf13/pflag v1.0.3
 	github.com/spf13/viper v1.4.0
-	github.com/stretchr/testify v1.3.0
 	github.com/tdewolff/minify/v2 v2.3.7
 	github.com/yosssi/ace v0.0.5
 	go.opencensus.io v0.22.0 // indirect
@@ -68,4 +67,4 @@ require (
 
 replace github.com/markbates/inflect => github.com/markbates/inflect v0.0.0-20171215194931-a12c3aec81a6
 
-go 1.13
+go 1.12

go.sum

@@ -103,6 +103,8 @@ github.com/fortytw2/leaktest v1.2.0 h1:cj6GCiwJDH7l3tMHLjZDo0QqPtrXJiWSI9JgpeQKw
 github.com/fortytw2/leaktest v1.2.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
 github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
 github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/frankban/quicktest v1.4.1 h1:Wv2VwvNn73pAdFIVUQRXYDFp31lXKbqblIXo/Q5GPSg=
+github.com/frankban/quicktest v1.4.1/go.mod h1:36zfPVQyHxymz4cH7wlDmVwDrJuljRB60qkgn7rorfQ=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=

helpers/content_renderer_test.go

@@ -18,8 +18,8 @@ import (
 	"regexp"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 // Renders a codeblock using Blackfriday
@@ -43,7 +43,7 @@ func (c ContentSpec) renderWithMmark(input string) string {
 }
 
 func TestCodeFence(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	type test struct {
 		enabled         bool
@@ -64,10 +64,10 @@ func TestCodeFence(t *testing.T) {
 			v.Set("pygmentsCodeFences", d.enabled)
 			v.Set("pygmentsUseClassic", useClassic)
 
-			c, err := NewContentSpec(v)
-			assert.NoError(err)
+			cs, err := NewContentSpec(v)
+			c.Assert(err, qt.IsNil)
 
-			result := c.render(d.input)
+			result := cs.render(d.input)
 
 			expectedRe, err := regexp.Compile(d.expected)
 
@@ -80,7 +80,7 @@ func TestCodeFence(t *testing.T) {
 				t.Errorf("Test %d failed. BlackFriday enabled:%t, Expected:\n%q got:\n%q", i, d.enabled, d.expected, result)
 			}
 
-			result = c.renderWithMmark(d.input)
+			result = cs.renderWithMmark(d.input)
 			matched = expectedRe.MatchString(result)
 			if !matched {
 				t.Errorf("Test %d failed. Mmark enabled:%t, Expected:\n%q got:\n%q", i, d.enabled, d.expected, result)

helpers/content_test.go

@@ -21,10 +21,9 @@ import (
 
 	"github.com/spf13/viper"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/miekg/mmark"
 	"github.com/russross/blackfriday"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 const tstHTMLContent = "<!DOCTYPE html><html><head><script src=\"http://two/foobar.js\"></script></head><body><nav><ul><li hugo-nav=\"section_0\"></li><li hugo-nav=\"section_1\"></li></ul></nav><article>content <a href=\"http://two/foobar\">foobar</a>. Follow up</article><p>This is some text.<br>And some more.</p></body></html>"
@@ -90,17 +89,19 @@ func BenchmarkStripHTML(b *testing.B) {
 }
 
 func TestStripEmptyNav(t *testing.T) {
+	c := qt.New(t)
 	cleaned := stripEmptyNav([]byte("do<nav>\n</nav>\n\nbedobedo"))
-	assert.Equal(t, []byte("dobedobedo"), cleaned)
+	c.Assert(cleaned, qt.DeepEquals, []byte("dobedobedo"))
 }
 
 func TestBytesToHTML(t *testing.T) {
-	assert.Equal(t, template.HTML("dobedobedo"), BytesToHTML([]byte("dobedobedo")))
+	c := qt.New(t)
+	c.Assert(BytesToHTML([]byte("dobedobedo")), qt.Equals, template.HTML("dobedobedo"))
 }
 
 func TestNewContentSpec(t *testing.T) {
 	cfg := viper.New()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	cfg.Set("summaryLength", 32)
 	cfg.Set("buildFuture", true)
@@ -109,11 +110,11 @@ func TestNewContentSpec(t *testing.T) {
 
 	spec, err := NewContentSpec(cfg)
 
-	assert.NoError(err)
-	assert.Equal(32, spec.summaryLength)
-	assert.True(spec.BuildFuture)
-	assert.True(spec.BuildExpired)
-	assert.True(spec.BuildDrafts)
+	c.Assert(err, qt.IsNil)
+	c.Assert(spec.summaryLength, qt.Equals, 32)
+	c.Assert(spec.BuildFuture, qt.Equals, true)
+	c.Assert(spec.BuildExpired, qt.Equals, true)
+	c.Assert(spec.BuildDrafts, qt.Equals, true)
 
 }
 

helpers/general_test.go

@@ -19,9 +19,8 @@ import (
 	"strings"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestGuessType(t *testing.T) {
@@ -188,6 +187,7 @@ func TestSliceToLower(t *testing.T) {
 }
 
 func TestReaderContains(t *testing.T) {
+	c := qt.New(t)
 	for i, this := range append(containsBenchTestData, containsAdditionalTestData...) {
 		result := ReaderContains(strings.NewReader(this.v1), this.v2)
 		if result != this.expect {
@@ -195,21 +195,21 @@ func TestReaderContains(t *testing.T) {
 		}
 	}
 
-	assert.False(t, ReaderContains(nil, []byte("a")))
-	assert.False(t, ReaderContains(nil, nil))
+	c.Assert(ReaderContains(nil, []byte("a")), qt.Equals, false)
+	c.Assert(ReaderContains(nil, nil), qt.Equals, false)
 }
 
 func TestGetTitleFunc(t *testing.T) {
 	title := "somewhere over the rainbow"
-	assert := require.New(t)
+	c := qt.New(t)
 
-	assert.Equal("Somewhere Over The Rainbow", GetTitleFunc("go")(title))
-	assert.Equal("Somewhere over the Rainbow", GetTitleFunc("chicago")(title), "Chicago style")
-	assert.Equal("Somewhere over the Rainbow", GetTitleFunc("Chicago")(title), "Chicago style")
-	assert.Equal("Somewhere Over the Rainbow", GetTitleFunc("ap")(title), "AP style")
-	assert.Equal("Somewhere Over the Rainbow", GetTitleFunc("ap")(title), "AP style")
-	assert.Equal("Somewhere Over the Rainbow", GetTitleFunc("")(title), "AP style")
-	assert.Equal("Somewhere Over the Rainbow", GetTitleFunc("unknown")(title), "AP style")
+	c.Assert(GetTitleFunc("go")(title), qt.Equals, "Somewhere Over The Rainbow")
+	c.Assert(GetTitleFunc("chicago")(title), qt.Equals, "Somewhere over the Rainbow")
+	c.Assert(GetTitleFunc("Chicago")(title), qt.Equals, "Somewhere over the Rainbow")
+	c.Assert(GetTitleFunc("ap")(title), qt.Equals, "Somewhere Over the Rainbow")
+	c.Assert(GetTitleFunc("ap")(title), qt.Equals, "Somewhere Over the Rainbow")
+	c.Assert(GetTitleFunc("")(title), qt.Equals, "Somewhere Over the Rainbow")
+	c.Assert(GetTitleFunc("unknown")(title), qt.Equals, "Somewhere Over the Rainbow")
 
 }
 
@@ -244,19 +244,20 @@ func TestUniqueStringsReuse(t *testing.T) {
 }
 
 func TestUniqueStringsSorted(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	in := []string{"a", "a", "b", "c", "b", "", "a", "", "d"}
 	output := UniqueStringsSorted(in)
 	expected := []string{"", "a", "b", "c", "d"}
-	assert.Equal(expected, output)
-	assert.Nil(UniqueStringsSorted(nil))
+	c.Assert(output, qt.DeepEquals, expected)
+	c.Assert(UniqueStringsSorted(nil), qt.IsNil)
 }
 
 func TestFindAvailablePort(t *testing.T) {
+	c := qt.New(t)
 	addr, err := FindAvailablePort()
-	assert.Nil(t, err)
-	assert.NotNil(t, addr)
-	assert.True(t, addr.Port > 0)
+	c.Assert(err, qt.IsNil)
+	c.Assert(addr, qt.Not(qt.IsNil))
+	c.Assert(addr.Port > 0, qt.Equals, true)
 }
 
 func TestFastMD5FromFile(t *testing.T) {
@@ -278,17 +279,17 @@ func TestFastMD5FromFile(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	req := require.New(t)
+	c := qt.New(t)
 
 	sf1, err := fs.Open("small.txt")
-	req.NoError(err)
+	c.Assert(err, qt.IsNil)
 	sf2, err := fs.Open("small2.txt")
-	req.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	bf1, err := fs.Open("bigger.txt")
-	req.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bf2, err := fs.Open("bigger2.txt")
-	req.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	defer sf1.Close()
 	defer sf2.Close()
@@ -296,24 +297,24 @@ func TestFastMD5FromFile(t *testing.T) {
 	defer bf2.Close()
 
 	m1, err := MD5FromFileFast(sf1)
-	req.NoError(err)
-	req.Equal("e9c8989b64b71a88b4efb66ad05eea96", m1)
+	c.Assert(err, qt.IsNil)
+	c.Assert(m1, qt.Equals, "e9c8989b64b71a88b4efb66ad05eea96")
 
 	m2, err := MD5FromFileFast(sf2)
-	req.NoError(err)
-	req.NotEqual(m1, m2)
+	c.Assert(err, qt.IsNil)
+	c.Assert(m2, qt.Not(qt.Equals), m1)
 
 	m3, err := MD5FromFileFast(bf1)
-	req.NoError(err)
-	req.NotEqual(m2, m3)
+	c.Assert(err, qt.IsNil)
+	c.Assert(m3, qt.Not(qt.Equals), m2)
 
 	m4, err := MD5FromFileFast(bf2)
-	req.NoError(err)
-	req.NotEqual(m3, m4)
+	c.Assert(err, qt.IsNil)
+	c.Assert(m4, qt.Not(qt.Equals), m3)
 
 	m5, err := MD5FromReader(bf2)
-	req.NoError(err)
-	req.NotEqual(m4, m5)
+	c.Assert(err, qt.IsNil)
+	c.Assert(m5, qt.Not(qt.Equals), m4)
 }
 
 func BenchmarkMD5FromFileFast(b *testing.B) {

helpers/path_test.go

@@ -27,7 +27,7 @@ import (
 
 	"github.com/gohugoio/hugo/langs"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/afero"
@@ -35,6 +35,7 @@ import (
 )
 
 func TestMakePath(t *testing.T) {
+	c := qt.New(t)
 	tests := []struct {
 		input         string
 		expected      string
@@ -61,7 +62,7 @@ func TestMakePath(t *testing.T) {
 
 		l := langs.NewDefaultLanguage(v)
 		p, err := NewPathSpec(hugofs.NewMem(v), l, nil)
-		require.NoError(t, err)
+		c.Assert(err, qt.IsNil)
 
 		output := p.MakePath(test.input)
 		if output != test.expected {
@@ -547,8 +548,8 @@ func TestAbsPathify(t *testing.T) {
 }
 
 func TestExtNoDelimiter(t *testing.T) {
-	assert := require.New(t)
-	assert.Equal("json", ExtNoDelimiter(filepath.FromSlash("/my/data.json")))
+	c := qt.New(t)
+	c.Assert(ExtNoDelimiter(filepath.FromSlash("/my/data.json")), qt.Equals, "json")
 }
 
 func TestFilename(t *testing.T) {
@@ -636,11 +637,11 @@ func TestExtractAndGroupRootPaths(t *testing.T) {
 
 	result := ExtractAndGroupRootPaths(in)
 
-	assert := require.New(t)
-	assert.Equal(filepath.FromSlash("[/a/b/{c,e} /c/d/e]"), fmt.Sprint(result))
+	c := qt.New(t)
+	c.Assert(fmt.Sprint(result), qt.Equals, filepath.FromSlash("[/a/b/{c,e} /c/d/e]"))
 
 	// Make sure the original is preserved
-	assert.Equal(inCopy, in)
+	c.Assert(in, qt.DeepEquals, inCopy)
 
 }
 

helpers/pathspec_test.go

@@ -17,13 +17,14 @@ import (
 	"path/filepath"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/hugofs"
 
 	"github.com/gohugoio/hugo/langs"
-	"github.com/stretchr/testify/require"
 )
 
 func TestNewPathSpecFromConfig(t *testing.T) {
+	c := qt.New(t)
 	v := newTestCfg()
 	l := langs.NewLanguage("no", v)
 	v.Set("disablePathToLower", true)
@@ -44,16 +45,16 @@ func TestNewPathSpecFromConfig(t *testing.T) {
 
 	p, err := NewPathSpec(fs, l, nil)
 
-	require.NoError(t, err)
-	require.True(t, p.CanonifyURLs)
-	require.True(t, p.DisablePathToLower)
-	require.True(t, p.RemovePathAccents)
-	require.True(t, p.UglyURLs)
-	require.Equal(t, "no", p.Language.Lang)
-	require.Equal(t, "side", p.PaginatePath)
+	c.Assert(err, qt.IsNil)
+	c.Assert(p.CanonifyURLs, qt.Equals, true)
+	c.Assert(p.DisablePathToLower, qt.Equals, true)
+	c.Assert(p.RemovePathAccents, qt.Equals, true)
+	c.Assert(p.UglyURLs, qt.Equals, true)
+	c.Assert(p.Language.Lang, qt.Equals, "no")
+	c.Assert(p.PaginatePath, qt.Equals, "side")
 
-	require.Equal(t, "http://base.com", p.BaseURL.String())
-	require.Equal(t, "thethemes", p.ThemesDir)
-	require.Equal(t, "thework", p.WorkingDir)
+	c.Assert(p.BaseURL.String(), qt.Equals, "http://base.com")
+	c.Assert(p.ThemesDir, qt.Equals, "thethemes")
+	c.Assert(p.WorkingDir, qt.Equals, "thework")
 
 }

helpers/pygments_test.go

@@ -20,12 +20,12 @@ import (
 
 	"github.com/alecthomas/chroma/formatters/html"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestParsePygmentsArgs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	for i, this := range []struct {
 		in                 string
@@ -46,7 +46,7 @@ func TestParsePygmentsArgs(t *testing.T) {
 		v.Set("pygmentsStyle", this.pygmentsStyle)
 		v.Set("pygmentsUseClasses", this.pygmentsUseClasses)
 		spec, err := NewContentSpec(v)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		result1, err := spec.createPygmentsOptionsString(this.in)
 		if b, ok := this.expect1.(bool); ok && !b {
@@ -67,7 +67,7 @@ func TestParsePygmentsArgs(t *testing.T) {
 }
 
 func TestParseDefaultPygmentsArgs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	expect := "encoding=utf8,noclasses=false,style=foo"
 
@@ -95,7 +95,7 @@ func TestParseDefaultPygmentsArgs(t *testing.T) {
 		}
 
 		spec, err := NewContentSpec(v)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		result, err := spec.createPygmentsOptionsString(this.in)
 		if err != nil {
@@ -134,22 +134,22 @@ func formatterChromaInfo(f *html.Formatter) chromaInfo {
 }
 
 func TestChromaHTMLHighlight(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	v := viper.New()
 	v.Set("pygmentsUseClasses", true)
 	spec, err := NewContentSpec(v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	result, err := spec.Highlight(`echo "Hello"`, "bash", "")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Contains(result, `<div class="highlight"><pre class="chroma"><code class="language-bash" data-lang="bash"><span class="nb">echo</span> <span class="s2">&#34;Hello&#34;</span></code></pre></div>`)
+	c.Assert(result, qt.Contains, `<div class="highlight"><pre class="chroma"><code class="language-bash" data-lang="bash"><span class="nb">echo</span> <span class="s2">&#34;Hello&#34;</span></code></pre></div>`)
 
 }
 
 func TestChromaHTMLFormatterFromOptions(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	for i, this := range []struct {
 		in                 string
@@ -158,40 +158,40 @@ func TestChromaHTMLFormatterFromOptions(t *testing.T) {
 		pygmentsOptions    string
 		assert             func(c chromaInfo)
 	}{
-		{"", "monokai", true, "style=manni,noclasses=true", func(c chromaInfo) {
-			assert.True(c.classes)
-			assert.False(c.lineNumbers)
-			assert.Equal(0, c.highlightRangesLen)
+		{"", "monokai", true, "style=manni,noclasses=true", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, true)
+			c.Assert(ci.lineNumbers, qt.Equals, false)
+			c.Assert(ci.highlightRangesLen, qt.Equals, 0)
 
 		}},
-		{"", nil, nil, "style=monokai,noclasses=false", func(c chromaInfo) {
-			assert.True(c.classes)
+		{"", nil, nil, "style=monokai,noclasses=false", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, true)
 		}},
-		{"linenos=sure,hl_lines=1 2 3", nil, nil, "style=monokai,noclasses=false", func(c chromaInfo) {
-			assert.True(c.classes)
-			assert.True(c.lineNumbers)
-			assert.Equal(3, c.highlightRangesLen)
-			assert.Equal("[[1 1] [2 2] [3 3]]", c.highlightRangesStr)
-			assert.Equal(1, c.baseLineNumber)
+		{"linenos=sure,hl_lines=1 2 3", nil, nil, "style=monokai,noclasses=false", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, true)
+			c.Assert(ci.lineNumbers, qt.Equals, true)
+			c.Assert(ci.highlightRangesLen, qt.Equals, 3)
+			c.Assert(ci.highlightRangesStr, qt.Equals, "[[1 1] [2 2] [3 3]]")
+			c.Assert(ci.baseLineNumber, qt.Equals, 1)
 		}},
-		{"linenos=inline,hl_lines=1,linenostart=4", nil, nil, "style=monokai,noclasses=false", func(c chromaInfo) {
-			assert.True(c.classes)
-			assert.True(c.lineNumbers)
-			assert.False(c.lineNumbersInTable)
-			assert.Equal(1, c.highlightRangesLen)
+		{"linenos=inline,hl_lines=1,linenostart=4", nil, nil, "style=monokai,noclasses=false", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, true)
+			c.Assert(ci.lineNumbers, qt.Equals, true)
+			c.Assert(ci.lineNumbersInTable, qt.Equals, false)
+			c.Assert(ci.highlightRangesLen, qt.Equals, 1)
 			// This compansates for https://github.com/alecthomas/chroma/issues/30
-			assert.Equal("[[4 4]]", c.highlightRangesStr)
-			assert.Equal(4, c.baseLineNumber)
+			c.Assert(ci.highlightRangesStr, qt.Equals, "[[4 4]]")
+			c.Assert(ci.baseLineNumber, qt.Equals, 4)
 		}},
-		{"linenos=table", nil, nil, "style=monokai", func(c chromaInfo) {
-			assert.True(c.lineNumbers)
-			assert.True(c.lineNumbersInTable)
+		{"linenos=table", nil, nil, "style=monokai", func(ci chromaInfo) {
+			c.Assert(ci.lineNumbers, qt.Equals, true)
+			c.Assert(ci.lineNumbersInTable, qt.Equals, true)
 		}},
-		{"style=monokai,noclasses=false", nil, nil, "style=manni,noclasses=true", func(c chromaInfo) {
-			assert.True(c.classes)
+		{"style=monokai,noclasses=false", nil, nil, "style=manni,noclasses=true", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, true)
 		}},
-		{"style=monokai,noclasses=true", "friendly", false, "style=manni,noclasses=false", func(c chromaInfo) {
-			assert.False(c.classes)
+		{"style=monokai,noclasses=true", "friendly", false, "style=manni,noclasses=false", func(ci chromaInfo) {
+			c.Assert(ci.classes, qt.Equals, false)
 		}},
 	} {
 		v := viper.New()
@@ -207,7 +207,7 @@ func TestChromaHTMLFormatterFromOptions(t *testing.T) {
 		}
 
 		spec, err := NewContentSpec(v)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		opts, err := spec.parsePygmentsOpts(this.in)
 		if err != nil {
@@ -257,7 +257,7 @@ func TestHlLinesToRanges(t *testing.T) {
 }
 
 func BenchmarkChromaHighlight(b *testing.B) {
-	assert := require.New(b)
+	c := qt.New(b)
 	v := viper.New()
 
 	v.Set("pygmentsstyle", "trac")
@@ -289,7 +289,7 @@ func GetTitleFunc(style string) func(s string) string {
 `
 
 	spec, err := NewContentSpec(v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	for i := 0; i < b.N; i++ {
 		_, err := spec.Highlight(code, "go", "linenos=inline,hl_lines=8 15-17")

helpers/url_test.go

@@ -14,14 +14,12 @@
 package helpers
 
 import (
-	"fmt"
 	"strings"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/langs"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestURLize(t *testing.T) {
@@ -111,7 +109,9 @@ func doTestAbsURL(t *testing.T, defaultInSubDir, addLanguage, multilingual bool,
 }
 
 func TestIsAbsURL(t *testing.T) {
-	for i, this := range []struct {
+	c := qt.New(t)
+
+	for _, this := range []struct {
 		a string
 		b bool
 	}{
@@ -122,7 +122,7 @@ func TestIsAbsURL(t *testing.T) {
 		{"/content", false},
 		{"content", false},
 	} {
-		require.True(t, IsAbsURL(this.a) == this.b, fmt.Sprintf("Test %d", i))
+		c.Assert(IsAbsURL(this.a) == this.b, qt.Equals, true)
 	}
 }
 
@@ -292,31 +292,33 @@ func TestAddContextRoot(t *testing.T) {
 }
 
 func TestPretty(t *testing.T) {
-	assert.Equal(t, PrettifyURLPath("/section/name.html"), "/section/name/index.html")
-	assert.Equal(t, PrettifyURLPath("/section/sub/name.html"), "/section/sub/name/index.html")
-	assert.Equal(t, PrettifyURLPath("/section/name/"), "/section/name/index.html")
-	assert.Equal(t, PrettifyURLPath("/section/name/index.html"), "/section/name/index.html")
-	assert.Equal(t, PrettifyURLPath("/index.html"), "/index.html")
-	assert.Equal(t, PrettifyURLPath("/name.xml"), "/name/index.xml")
-	assert.Equal(t, PrettifyURLPath("/"), "/")
-	assert.Equal(t, PrettifyURLPath(""), "/")
-	assert.Equal(t, PrettifyURL("/section/name.html"), "/section/name")
-	assert.Equal(t, PrettifyURL("/section/sub/name.html"), "/section/sub/name")
-	assert.Equal(t, PrettifyURL("/section/name/"), "/section/name")
-	assert.Equal(t, PrettifyURL("/section/name/index.html"), "/section/name")
-	assert.Equal(t, PrettifyURL("/index.html"), "/")
-	assert.Equal(t, PrettifyURL("/name.xml"), "/name/index.xml")
-	assert.Equal(t, PrettifyURL("/"), "/")
-	assert.Equal(t, PrettifyURL(""), "/")
+	c := qt.New(t)
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name.html"))
+	c.Assert("/section/sub/name/index.html", qt.Equals, PrettifyURLPath("/section/sub/name.html"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/"))
+	c.Assert("/section/name/index.html", qt.Equals, PrettifyURLPath("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, PrettifyURLPath("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURLPath("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURLPath("/"))
+	c.Assert("/", qt.Equals, PrettifyURLPath(""))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name.html"))
+	c.Assert("/section/sub/name", qt.Equals, PrettifyURL("/section/sub/name.html"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/"))
+	c.Assert("/section/name", qt.Equals, PrettifyURL("/section/name/index.html"))
+	c.Assert("/", qt.Equals, PrettifyURL("/index.html"))
+	c.Assert("/name/index.xml", qt.Equals, PrettifyURL("/name.xml"))
+	c.Assert("/", qt.Equals, PrettifyURL("/"))
+	c.Assert("/", qt.Equals, PrettifyURL(""))
 }
 
 func TestUgly(t *testing.T) {
-	assert.Equal(t, Uglify("/section/name.html"), "/section/name.html")
-	assert.Equal(t, Uglify("/section/sub/name.html"), "/section/sub/name.html")
-	assert.Equal(t, Uglify("/section/name/"), "/section/name.html")
-	assert.Equal(t, Uglify("/section/name/index.html"), "/section/name.html")
-	assert.Equal(t, Uglify("/index.html"), "/index.html")
-	assert.Equal(t, Uglify("/name.xml"), "/name.xml")
-	assert.Equal(t, Uglify("/"), "/")
-	assert.Equal(t, Uglify(""), "/")
+	c := qt.New(t)
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name.html"))
+	c.Assert("/section/sub/name.html", qt.Equals, Uglify("/section/sub/name.html"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/"))
+	c.Assert("/section/name.html", qt.Equals, Uglify("/section/name/index.html"))
+	c.Assert("/index.html", qt.Equals, Uglify("/index.html"))
+	c.Assert("/name.xml", qt.Equals, Uglify("/name.xml"))
+	c.Assert("/", qt.Equals, Uglify("/"))
+	c.Assert("/", qt.Equals, Uglify(""))
 }

htesting/hqt/checkers.go

@@ -0,0 +1,92 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hqt
+
+import (
+	"errors"
+	"reflect"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/google/go-cmp/cmp"
+)
+
+// IsSameType asserts that got is the same type as want.
+var IsSameType qt.Checker = &typeChecker{
+	argNames: []string{"got", "want"},
+}
+
+type argNames []string
+
+func (a argNames) ArgNames() []string {
+	return a
+}
+
+type typeChecker struct {
+	argNames
+}
+
+// Check implements Checker.Check by checking that got and args[0] is of the same type.
+func (c *typeChecker) Check(got interface{}, args []interface{}, note func(key string, value interface{})) (err error) {
+	if want := args[0]; reflect.TypeOf(got) != reflect.TypeOf(want) {
+		if _, ok := got.(error); ok && want == nil {
+			return errors.New("got non-nil error")
+		}
+		return errors.New("values are not of same type")
+	}
+	return nil
+}
+
+// DeepAllowUnexported creates an option to allow compare of unexported types
+// in the given list of types.
+// see https://github.com/google/go-cmp/issues/40#issuecomment-328615283
+func DeepAllowUnexported(vs ...interface{}) cmp.Option {
+	m := make(map[reflect.Type]struct{})
+	for _, v := range vs {
+		structTypes(reflect.ValueOf(v), m)
+	}
+	var typs []interface{}
+	for t := range m {
+		typs = append(typs, reflect.New(t).Elem().Interface())
+	}
+	return cmp.AllowUnexported(typs...)
+}
+
+func structTypes(v reflect.Value, m map[reflect.Type]struct{}) {
+	if !v.IsValid() {
+		return
+	}
+	switch v.Kind() {
+	case reflect.Ptr:
+		if !v.IsNil() {
+			structTypes(v.Elem(), m)
+		}
+	case reflect.Interface:
+		if !v.IsNil() {
+			structTypes(v.Elem(), m)
+		}
+	case reflect.Slice, reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			structTypes(v.Index(i), m)
+		}
+	case reflect.Map:
+		for _, k := range v.MapKeys() {
+			structTypes(v.MapIndex(k), m)
+		}
+	case reflect.Struct:
+		m[v.Type()] = struct{}{}
+		for i := 0; i < v.NumField(); i++ {
+			structTypes(v.Field(i), m)
+		}
+	}
+}

hugofs/files/classifier_test.go

@@ -17,33 +17,33 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestIsContentFile(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
-	assert.True(IsContentFile(filepath.FromSlash("my/file.md")))
-	assert.True(IsContentFile(filepath.FromSlash("my/file.ad")))
-	assert.False(IsContentFile(filepath.FromSlash("textfile.txt")))
-	assert.True(IsContentExt("md"))
-	assert.False(IsContentExt("json"))
+	c.Assert(IsContentFile(filepath.FromSlash("my/file.md")), qt.Equals, true)
+	c.Assert(IsContentFile(filepath.FromSlash("my/file.ad")), qt.Equals, true)
+	c.Assert(IsContentFile(filepath.FromSlash("textfile.txt")), qt.Equals, false)
+	c.Assert(IsContentExt("md"), qt.Equals, true)
+	c.Assert(IsContentExt("json"), qt.Equals, false)
 }
 
 func TestComponentFolders(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	// It's important that these are absolutely right and not changed.
-	assert.Equal(len(ComponentFolders), len(componentFoldersSet))
-	assert.True(IsComponentFolder("archetypes"))
-	assert.True(IsComponentFolder("layouts"))
-	assert.True(IsComponentFolder("data"))
-	assert.True(IsComponentFolder("i18n"))
-	assert.True(IsComponentFolder("assets"))
-	assert.False(IsComponentFolder("resources"))
-	assert.True(IsComponentFolder("static"))
-	assert.True(IsComponentFolder("content"))
-	assert.False(IsComponentFolder("foo"))
-	assert.False(IsComponentFolder(""))
+	c.Assert(len(componentFoldersSet), qt.Equals, len(ComponentFolders))
+	c.Assert(IsComponentFolder("archetypes"), qt.Equals, true)
+	c.Assert(IsComponentFolder("layouts"), qt.Equals, true)
+	c.Assert(IsComponentFolder("data"), qt.Equals, true)
+	c.Assert(IsComponentFolder("i18n"), qt.Equals, true)
+	c.Assert(IsComponentFolder("assets"), qt.Equals, true)
+	c.Assert(IsComponentFolder("resources"), qt.Equals, false)
+	c.Assert(IsComponentFolder("static"), qt.Equals, true)
+	c.Assert(IsComponentFolder("content"), qt.Equals, true)
+	c.Assert(IsComponentFolder("foo"), qt.Equals, false)
+	c.Assert(IsComponentFolder(""), qt.Equals, false)
 
 }

hugofs/filter_fs_test.go

@@ -17,7 +17,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestLangInfoFrom(t *testing.T) {
@@ -27,7 +27,7 @@ func TestLangInfoFrom(t *testing.T) {
 		"en": 20,
 	}
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tests := []struct {
 		input    string
@@ -42,7 +42,7 @@ func TestLangInfoFrom(t *testing.T) {
 
 	for _, test := range tests {
 		v1, v2, v3 := langInfoFrom(langs, test.input)
-		assert.Equal(test.expected, []string{v1, v2, v3})
+		c.Assert([]string{v1, v2, v3}, qt.DeepEquals, test.expected)
 	}
 
 }

hugofs/fs_test.go

@@ -16,45 +16,46 @@ package hugofs
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/htesting/hqt"
 	"github.com/spf13/afero"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestNewDefault(t *testing.T) {
+	c := qt.New(t)
 	v := viper.New()
 	f := NewDefault(v)
 
-	assert.NotNil(t, f.Source)
-	assert.IsType(t, new(afero.OsFs), f.Source)
-	assert.NotNil(t, f.Destination)
-	assert.IsType(t, new(afero.OsFs), f.Destination)
-	assert.NotNil(t, f.Os)
-	assert.IsType(t, new(afero.OsFs), f.Os)
-	assert.Nil(t, f.WorkingDir)
+	c.Assert(f.Source, qt.Not(qt.IsNil))
+	c.Assert(f.Source, hqt.IsSameType, new(afero.OsFs))
+	c.Assert(f.Os, qt.Not(qt.IsNil))
+	c.Assert(f.WorkingDir, qt.IsNil)
 
-	assert.IsType(t, new(afero.OsFs), Os)
 }
 
 func TestNewMem(t *testing.T) {
+	c := qt.New(t)
 	v := viper.New()
 	f := NewMem(v)
 
-	assert.NotNil(t, f.Source)
-	assert.IsType(t, new(afero.MemMapFs), f.Source)
-	assert.NotNil(t, f.Destination)
-	assert.IsType(t, new(afero.MemMapFs), f.Destination)
-	assert.IsType(t, new(afero.OsFs), f.Os)
-	assert.Nil(t, f.WorkingDir)
+	c.Assert(f.Source, qt.Not(qt.IsNil))
+	c.Assert(f.Source, hqt.IsSameType, new(afero.MemMapFs))
+	c.Assert(f.Destination, qt.Not(qt.IsNil))
+	c.Assert(f.Destination, hqt.IsSameType, new(afero.MemMapFs))
+	c.Assert(f.Os, hqt.IsSameType, new(afero.OsFs))
+	c.Assert(f.WorkingDir, qt.IsNil)
 }
 
 func TestWorkingDir(t *testing.T) {
+	c := qt.New(t)
 	v := viper.New()
 
 	v.Set("workingDir", "/a/b/")
 
 	f := NewMem(v)
 
-	assert.NotNil(t, f.WorkingDir)
-	assert.IsType(t, new(afero.BasePathFs), f.WorkingDir)
+	c.Assert(f.WorkingDir, qt.Not(qt.IsNil))
+	c.Assert(f.WorkingDir, hqt.IsSameType, new(afero.BasePathFs))
+
 }

hugofs/hashing_fs_test.go

@@ -16,8 +16,8 @@ package hugofs
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
 )
 
 type testHashReceiver struct {
@@ -31,23 +31,23 @@ func (t *testHashReceiver) OnFileClose(name, md5hash string) {
 }
 
 func TestHashingFs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	fs := afero.NewMemMapFs()
 	observer := &testHashReceiver{}
 	ofs := NewHashingFs(fs, observer)
 
 	f, err := ofs.Create("hashme")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	_, err = f.Write([]byte("content"))
-	assert.NoError(err)
-	assert.NoError(f.Close())
-	assert.Equal("9a0364b9e99bb480dd25e1f0284c8555", observer.sum)
-	assert.Equal("hashme", observer.name)
+	c.Assert(err, qt.IsNil)
+	c.Assert(f.Close(), qt.IsNil)
+	c.Assert(observer.sum, qt.Equals, "9a0364b9e99bb480dd25e1f0284c8555")
+	c.Assert(observer.name, qt.Equals, "hashme")
 
 	f, err = ofs.Create("nowrites")
-	assert.NoError(err)
-	assert.NoError(f.Close())
-	assert.Equal("d41d8cd98f00b204e9800998ecf8427e", observer.sum)
+	c.Assert(err, qt.IsNil)
+	c.Assert(f.Close(), qt.IsNil)
+	c.Assert(observer.sum, qt.Equals, "d41d8cd98f00b204e9800998ecf8427e")
 
 }

hugofs/nosymlink_test.go

@@ -24,28 +24,28 @@ import (
 
 	"github.com/spf13/afero"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func prepareSymlinks(t *testing.T) (string, func()) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	workDir, clean, err := htesting.CreateTempDir(Os, "hugo-symlink-test")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	wd, _ := os.Getwd()
 
 	blogDir := filepath.Join(workDir, "blog")
 	blogSubDir := filepath.Join(blogDir, "sub")
-	assert.NoError(os.MkdirAll(blogSubDir, 0777))
+	c.Assert(os.MkdirAll(blogSubDir, 0777), qt.IsNil)
 	blogFile1 := filepath.Join(blogDir, "a.txt")
 	blogFile2 := filepath.Join(blogSubDir, "b.txt")
 	afero.WriteFile(Os, filepath.Join(blogFile1), []byte("content1"), 0777)
 	afero.WriteFile(Os, filepath.Join(blogFile2), []byte("content2"), 0777)
 	os.Chdir(workDir)
-	assert.NoError(os.Symlink("blog", "symlinkdedir"))
+	c.Assert(os.Symlink("blog", "symlinkdedir"), qt.IsNil)
 	os.Chdir(blogDir)
-	assert.NoError(os.Symlink("sub", "symsub"))
-	assert.NoError(os.Symlink("a.txt", "symlinkdedfile.txt"))
+	c.Assert(os.Symlink("sub", "symsub"), qt.IsNil)
+	c.Assert(os.Symlink("a.txt", "symlinkdedfile.txt"), qt.IsNil)
 
 	return workDir, func() {
 		clean()
@@ -57,7 +57,7 @@ func TestNoSymlinkFs(t *testing.T) {
 	if skipSymlink() {
 		t.Skip("Skip; os.Symlink needs administrator rights on Windows")
 	}
-	assert := require.New(t)
+	c := qt.New(t)
 	workDir, clean := prepareSymlinks(t)
 	defer clean()
 
@@ -77,9 +77,9 @@ func TestNoSymlinkFs(t *testing.T) {
 
 			assertFileErr := func(err error) {
 				if allowFiles {
-					assert.NoError(err)
+					c.Assert(err, qt.IsNil)
 				} else {
-					assert.Equal(ErrPermissionSymlink, err)
+					c.Assert(err, qt.Equals, ErrPermissionSymlink)
 				}
 			}
 
@@ -87,8 +87,8 @@ func TestNoSymlinkFs(t *testing.T) {
 				t.Helper()
 				assertFileErr(err)
 				if err == nil {
-					assert.NotNil(fi)
-					assert.Equal(name, fi.Name())
+					c.Assert(fi, qt.Not(qt.IsNil))
+					c.Assert(fi.Name(), qt.Equals, name)
 				}
 			}
 
@@ -103,42 +103,42 @@ func TestNoSymlinkFs(t *testing.T) {
 				},
 			} {
 				_, err := stat(symlinkedDir)
-				assert.Equal(ErrPermissionSymlink, err)
+				c.Assert(err, qt.Equals, ErrPermissionSymlink)
 				fi, err := stat(symlinkedFile)
 				assertFileStat(symlinkedFilename, fi, err)
 
 				fi, err = stat(filepath.Join(workDir, "blog"))
-				assert.NoError(err)
-				assert.NotNil(fi)
+				c.Assert(err, qt.IsNil)
+				c.Assert(fi, qt.Not(qt.IsNil))
 
 				fi, err = stat(blogFile1)
-				assert.NoError(err)
-				assert.NotNil(fi)
+				c.Assert(err, qt.IsNil)
+				c.Assert(fi, qt.Not(qt.IsNil))
 			}
 
 			// Check Open
 			_, err := fs.Open(symlinkedDir)
-			assert.Equal(ErrPermissionSymlink, err)
+			c.Assert(err, qt.Equals, ErrPermissionSymlink)
 			_, err = fs.OpenFile(symlinkedDir, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
-			assert.Equal(ErrPermissionSymlink, err)
+			c.Assert(err, qt.Equals, ErrPermissionSymlink)
 			_, err = fs.OpenFile(symlinkedFile, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
 			assertFileErr(err)
 			_, err = fs.Open(symlinkedFile)
 			assertFileErr(err)
 			f, err := fs.Open(blogDir)
-			assert.NoError(err)
+			c.Assert(err, qt.IsNil)
 			f.Close()
 			f, err = fs.Open(blogFile1)
-			assert.NoError(err)
+			c.Assert(err, qt.IsNil)
 			f.Close()
 
 			// Check readdir
 			f, err = fs.Open(workDir)
-			assert.NoError(err)
+			c.Assert(err, qt.IsNil)
 			// There is at least one unsported symlink inside workDir
 			_, err = f.Readdir(-1)
 			f.Close()
-			assert.Equal(uint64(1), logger.WarnCounter.Count())
+			c.Assert(logger.WarnCounter.Count(), qt.Equals, uint64(1))
 
 		}
 	}

hugofs/rootmapping_fs_test.go

@@ -21,24 +21,24 @@ import (
 
 	"github.com/spf13/viper"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/htesting"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
 )
 
 func TestLanguageRootMapping(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := viper.New()
 	v.Set("contentDir", "content")
 
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
-	assert.NoError(afero.WriteFile(fs, filepath.Join("content/sv/svdir", "main.txt"), []byte("main sv"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", "sv-f.txt"), []byte("some sv blog content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/myenblogcontent", "en-f.txt"), []byte("some en blog content in a"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/myotherenblogcontent", "en-f2.txt"), []byte("some en content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/mysvdocs", "sv-docs.txt"), []byte("some sv docs content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/b/myenblogcontent", "en-b-f.txt"), []byte("some en content"), 0755))
+	c.Assert(afero.WriteFile(fs, filepath.Join("content/sv/svdir", "main.txt"), []byte("main sv"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", "sv-f.txt"), []byte("some sv blog content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/myenblogcontent", "en-f.txt"), []byte("some en blog content in a"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/myotherenblogcontent", "en-f2.txt"), []byte("some en content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/mysvdocs", "sv-docs.txt"), []byte("some sv docs content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/b/myenblogcontent", "en-b-f.txt"), []byte("some en content"), 0755), qt.IsNil)
 
 	rfs, err := NewRootMappingFs(fs,
 		RootMapping{
@@ -68,38 +68,38 @@ func TestLanguageRootMapping(t *testing.T) {
 		},
 	)
 
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	collected, err := collectFilenames(rfs, "content", "content")
-	assert.NoError(err)
-	assert.Equal([]string{"blog/en-f.txt", "blog/en-f2.txt", "blog/sv-f.txt", "blog/svdir/main.txt", "docs/sv-docs.txt"}, collected)
+	c.Assert(err, qt.IsNil)
+	c.Assert(collected, qt.DeepEquals, []string{"blog/en-f.txt", "blog/en-f2.txt", "blog/sv-f.txt", "blog/svdir/main.txt", "docs/sv-docs.txt"})
 
 	bfs := afero.NewBasePathFs(rfs, "content")
 	collected, err = collectFilenames(bfs, "", "")
-	assert.NoError(err)
-	assert.Equal([]string{"blog/en-f.txt", "blog/en-f2.txt", "blog/sv-f.txt", "blog/svdir/main.txt", "docs/sv-docs.txt"}, collected)
+	c.Assert(err, qt.IsNil)
+	c.Assert(collected, qt.DeepEquals, []string{"blog/en-f.txt", "blog/en-f2.txt", "blog/sv-f.txt", "blog/svdir/main.txt", "docs/sv-docs.txt"})
 
 	dirs, err := rfs.Dirs(filepath.FromSlash("content/blog"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal(4, len(dirs))
+	c.Assert(len(dirs), qt.Equals, 4)
 
 	getDirnames := func(name string, rfs *RootMappingFs) []string {
 		filename := filepath.FromSlash(name)
 		f, err := rfs.Open(filename)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		names, err := f.Readdirnames(-1)
 
 		f.Close()
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		info, err := rfs.Stat(filename)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		f2, err := info.(FileMetaInfo).Meta().Open()
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		names2, err := f2.Readdirnames(-1)
-		assert.NoError(err)
-		assert.Equal(names, names2)
+		c.Assert(err, qt.IsNil)
+		c.Assert(names2, qt.DeepEquals, names)
 		f2.Close()
 
 		return names
@@ -109,83 +109,83 @@ func TestLanguageRootMapping(t *testing.T) {
 		return rm.Meta.Lang() == "en"
 	})
 
-	assert.Equal([]string{"en-f.txt", "en-f2.txt"}, getDirnames("content/blog", rfsEn))
+	c.Assert(getDirnames("content/blog", rfsEn), qt.DeepEquals, []string{"en-f.txt", "en-f2.txt"})
 
 	rfsSv := rfs.Filter(func(rm RootMapping) bool {
 		return rm.Meta.Lang() == "sv"
 	})
 
-	assert.Equal([]string{"sv-f.txt", "svdir"}, getDirnames("content/blog", rfsSv))
+	c.Assert(getDirnames("content/blog", rfsSv), qt.DeepEquals, []string{"sv-f.txt", "svdir"})
 
 	// Make sure we have not messed with the original
-	assert.Equal([]string{"sv-f.txt", "en-f.txt", "svdir", "en-f2.txt"}, getDirnames("content/blog", rfs))
+	c.Assert(getDirnames("content/blog", rfs), qt.DeepEquals, []string{"sv-f.txt", "en-f.txt", "svdir", "en-f2.txt"})
 
-	assert.Equal([]string{"blog", "docs"}, getDirnames("content", rfsSv))
-	assert.Equal([]string{"blog", "docs"}, getDirnames("content", rfs))
+	c.Assert(getDirnames("content", rfsSv), qt.DeepEquals, []string{"blog", "docs"})
+	c.Assert(getDirnames("content", rfs), qt.DeepEquals, []string{"blog", "docs"})
 
 }
 
 func TestRootMappingFsDirnames(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
 	testfile := "myfile.txt"
-	assert.NoError(fs.Mkdir("f1t", 0755))
-	assert.NoError(fs.Mkdir("f2t", 0755))
-	assert.NoError(fs.Mkdir("f3t", 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("f2t", testfile), []byte("some content"), 0755))
+	c.Assert(fs.Mkdir("f1t", 0755), qt.IsNil)
+	c.Assert(fs.Mkdir("f2t", 0755), qt.IsNil)
+	c.Assert(fs.Mkdir("f3t", 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("f2t", testfile), []byte("some content"), 0755), qt.IsNil)
 
 	rfs, err := NewRootMappingFsFromFromTo(fs, "static/bf1", "f1t", "static/cf2", "f2t", "static/af3", "f3t")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	fif, err := rfs.Stat(filepath.Join("static/cf2", testfile))
-	assert.NoError(err)
-	assert.Equal("myfile.txt", fif.Name())
+	c.Assert(err, qt.IsNil)
+	c.Assert(fif.Name(), qt.Equals, "myfile.txt")
 	fifm := fif.(FileMetaInfo).Meta()
-	assert.Equal(filepath.FromSlash("f2t/myfile.txt"), fifm.Filename())
+	c.Assert(fifm.Filename(), qt.Equals, filepath.FromSlash("f2t/myfile.txt"))
 
 	root, err := rfs.Open(filepathSeparator)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	dirnames, err := root.Readdirnames(-1)
-	assert.NoError(err)
-	assert.Equal([]string{"bf1", "cf2", "af3"}, dirnames)
+	c.Assert(err, qt.IsNil)
+	c.Assert(dirnames, qt.DeepEquals, []string{"bf1", "cf2", "af3"})
 
 }
 
 func TestRootMappingFsFilename(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	workDir, clean, err := htesting.CreateTempDir(Os, "hugo-root-filename")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer clean()
 	fs := NewBaseFileDecorator(Os)
 
 	testfilename := filepath.Join(workDir, "f1t/foo/file.txt")
 
-	assert.NoError(fs.MkdirAll(filepath.Join(workDir, "f1t/foo"), 0777))
-	assert.NoError(afero.WriteFile(fs, testfilename, []byte("content"), 0666))
+	c.Assert(fs.MkdirAll(filepath.Join(workDir, "f1t/foo"), 0777), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, testfilename, []byte("content"), 0666), qt.IsNil)
 
 	rfs, err := NewRootMappingFsFromFromTo(fs, "static/f1", filepath.Join(workDir, "f1t"), "static/f2", filepath.Join(workDir, "f2t"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	fi, err := rfs.Stat(filepath.FromSlash("static/f1/foo/file.txt"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	fim := fi.(FileMetaInfo)
-	assert.Equal(testfilename, fim.Meta().Filename())
+	c.Assert(fim.Meta().Filename(), qt.Equals, testfilename)
 	_, err = rfs.Stat(filepath.FromSlash("static/f1"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 }
 
 func TestRootMappingFsMount(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
 	testfile := "test.txt"
 
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/mynoblogcontent", testfile), []byte("some no content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/myenblogcontent", testfile), []byte("some en content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", testfile), []byte("some sv content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", "other.txt"), []byte("some sv content"), 0755))
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/mynoblogcontent", testfile), []byte("some no content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/myenblogcontent", testfile), []byte("some en content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", testfile), []byte("some sv content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("themes/a/mysvblogcontent", "other.txt"), []byte("some sv content"), 0755), qt.IsNil)
 
 	bfs := afero.NewBasePathFs(fs, "themes/a").(*afero.BasePathFs)
 	rm := []RootMapping{
@@ -204,48 +204,48 @@ func TestRootMappingFsMount(t *testing.T) {
 	}
 
 	rfs, err := NewRootMappingFs(bfs, rm...)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	blog, err := rfs.Stat(filepath.FromSlash("content/blog"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	blogm := blog.(FileMetaInfo).Meta()
-	assert.Equal("sv", blogm.Lang()) // Last match
+	c.Assert(blogm.Lang(), qt.Equals, "sv") // Last match
 
 	f, err := blogm.Open()
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer f.Close()
 	dirs1, err := f.Readdirnames(-1)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	// Union with duplicate dir names filtered.
-	assert.Equal([]string{"test.txt", "test.txt", "other.txt", "test.txt"}, dirs1)
+	c.Assert(dirs1, qt.DeepEquals, []string{"test.txt", "test.txt", "other.txt", "test.txt"})
 
 	files, err := afero.ReadDir(rfs, filepath.FromSlash("content/blog"))
-	assert.NoError(err)
-	assert.Equal(4, len(files))
+	c.Assert(err, qt.IsNil)
+	c.Assert(len(files), qt.Equals, 4)
 
 	testfilefi := files[1]
-	assert.Equal(testfile, testfilefi.Name())
+	c.Assert(testfilefi.Name(), qt.Equals, testfile)
 
 	testfilem := testfilefi.(FileMetaInfo).Meta()
-	assert.Equal(filepath.FromSlash("themes/a/mynoblogcontent/test.txt"), testfilem.Filename())
+	c.Assert(testfilem.Filename(), qt.Equals, filepath.FromSlash("themes/a/mynoblogcontent/test.txt"))
 
 	tf, err := testfilem.Open()
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer tf.Close()
-	c, err := ioutil.ReadAll(tf)
-	assert.NoError(err)
-	assert.Equal("some no content", string(c))
+	b, err := ioutil.ReadAll(tf)
+	c.Assert(err, qt.IsNil)
+	c.Assert(string(b), qt.Equals, "some no content")
 
 }
 
 func TestRootMappingFsMountOverlap(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
-	assert.NoError(afero.WriteFile(fs, filepath.FromSlash("da/a.txt"), []byte("some no content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.FromSlash("db/b.txt"), []byte("some no content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.FromSlash("dc/c.txt"), []byte("some no content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.FromSlash("de/e.txt"), []byte("some no content"), 0755))
+	c.Assert(afero.WriteFile(fs, filepath.FromSlash("da/a.txt"), []byte("some no content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.FromSlash("db/b.txt"), []byte("some no content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.FromSlash("dc/c.txt"), []byte("some no content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.FromSlash("de/e.txt"), []byte("some no content"), 0755), qt.IsNil)
 
 	rm := []RootMapping{
 		RootMapping{
@@ -267,56 +267,56 @@ func TestRootMappingFsMountOverlap(t *testing.T) {
 	}
 
 	rfs, err := NewRootMappingFs(fs, rm...)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	getDirnames := func(name string) []string {
 		name = filepath.FromSlash(name)
 		f, err := rfs.Open(name)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		defer f.Close()
 		names, err := f.Readdirnames(-1)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		return names
 	}
 
-	assert.Equal([]string{"a.txt", "b", "e"}, getDirnames("static"))
-	assert.Equal([]string{"b.txt", "c"}, getDirnames("static/b"))
-	assert.Equal([]string{"c.txt"}, getDirnames("static/b/c"))
+	c.Assert(getDirnames("static"), qt.DeepEquals, []string{"a.txt", "b", "e"})
+	c.Assert(getDirnames("static/b"), qt.DeepEquals, []string{"b.txt", "c"})
+	c.Assert(getDirnames("static/b/c"), qt.DeepEquals, []string{"c.txt"})
 
 	fi, err := rfs.Stat(filepath.FromSlash("static/b/b.txt"))
-	assert.NoError(err)
-	assert.Equal("b.txt", fi.Name())
+	c.Assert(err, qt.IsNil)
+	c.Assert(fi.Name(), qt.Equals, "b.txt")
 
 }
 
 func TestRootMappingFsOs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	fs := afero.NewOsFs()
 
 	d, err := ioutil.TempDir("", "hugo-root-mapping")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer func() {
 		os.RemoveAll(d)
 	}()
 
 	testfile := "myfile.txt"
-	assert.NoError(fs.Mkdir(filepath.Join(d, "f1t"), 0755))
-	assert.NoError(fs.Mkdir(filepath.Join(d, "f2t"), 0755))
-	assert.NoError(fs.Mkdir(filepath.Join(d, "f3t"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join(d, "f2t", testfile), []byte("some content"), 0755))
+	c.Assert(fs.Mkdir(filepath.Join(d, "f1t"), 0755), qt.IsNil)
+	c.Assert(fs.Mkdir(filepath.Join(d, "f2t"), 0755), qt.IsNil)
+	c.Assert(fs.Mkdir(filepath.Join(d, "f3t"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join(d, "f2t", testfile), []byte("some content"), 0755), qt.IsNil)
 
 	rfs, err := NewRootMappingFsFromFromTo(fs, "static/bf1", filepath.Join(d, "f1t"), "static/cf2", filepath.Join(d, "f2t"), "static/af3", filepath.Join(d, "f3t"))
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	fif, err := rfs.Stat(filepath.Join("static/cf2", testfile))
-	assert.NoError(err)
-	assert.Equal("myfile.txt", fif.Name())
+	c.Assert(err, qt.IsNil)
+	c.Assert(fif.Name(), qt.Equals, "myfile.txt")
 
 	root, err := rfs.Open(filepathSeparator)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	dirnames, err := root.Readdirnames(-1)
-	assert.NoError(err)
-	assert.Equal([]string{"bf1", "cf2", "af3"}, dirnames)
+	c.Assert(err, qt.IsNil)
+	c.Assert(dirnames, qt.DeepEquals, []string{"bf1", "cf2", "af3"})
 
 }

hugofs/walk_test.go

@@ -29,11 +29,11 @@ import (
 
 	"github.com/spf13/afero"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestWalk(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
@@ -43,19 +43,19 @@ func TestWalk(t *testing.T) {
 
 	names, err := collectFilenames(fs, "", "")
 
-	assert.NoError(err)
-	assert.Equal([]string{"a.txt", "b.txt", "c.txt"}, names)
+	c.Assert(err, qt.IsNil)
+	c.Assert(names, qt.DeepEquals, []string{"a.txt", "b.txt", "c.txt"})
 }
 
 func TestWalkRootMappingFs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
 	testfile := "test.txt"
 
-	assert.NoError(afero.WriteFile(fs, filepath.Join("a/b", testfile), []byte("some content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("c/d", testfile), []byte("some content"), 0755))
-	assert.NoError(afero.WriteFile(fs, filepath.Join("e/f", testfile), []byte("some content"), 0755))
+	c.Assert(afero.WriteFile(fs, filepath.Join("a/b", testfile), []byte("some content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("c/d", testfile), []byte("some content"), 0755), qt.IsNil)
+	c.Assert(afero.WriteFile(fs, filepath.Join("e/f", testfile), []byte("some content"), 0755), qt.IsNil)
 
 	rm := []RootMapping{
 		RootMapping{
@@ -74,13 +74,13 @@ func TestWalkRootMappingFs(t *testing.T) {
 	}
 
 	rfs, err := NewRootMappingFs(fs, rm...)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs := afero.NewBasePathFs(rfs, "static")
 
 	names, err := collectFilenames(bfs, "", "")
 
-	assert.NoError(err)
-	assert.Equal([]string{"a/test.txt", "b/test.txt", "c/test.txt"}, names)
+	c.Assert(err, qt.IsNil)
+	c.Assert(names, qt.DeepEquals, []string{"a/test.txt", "b/test.txt", "c/test.txt"})
 
 }
 
@@ -92,9 +92,9 @@ func TestWalkSymbolicLink(t *testing.T) {
 	if skipSymlink() {
 		t.Skip("Skip; os.Symlink needs administrator rights on Windows")
 	}
-	assert := require.New(t)
+	c := qt.New(t)
 	workDir, clean, err := htesting.CreateTempDir(Os, "hugo-walk-sym")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer clean()
 	wd, _ := os.Getwd()
 	defer func() {
@@ -107,25 +107,25 @@ func TestWalkSymbolicLink(t *testing.T) {
 	docsDir := filepath.Join(workDir, "docs")
 	blogReal := filepath.Join(blogDir, "real")
 	blogRealSub := filepath.Join(blogReal, "sub")
-	assert.NoError(os.MkdirAll(blogRealSub, 0777))
-	assert.NoError(os.MkdirAll(docsDir, 0777))
+	c.Assert(os.MkdirAll(blogRealSub, 0777), qt.IsNil)
+	c.Assert(os.MkdirAll(docsDir, 0777), qt.IsNil)
 	afero.WriteFile(fs, filepath.Join(blogRealSub, "a.txt"), []byte("content"), 0777)
 	afero.WriteFile(fs, filepath.Join(docsDir, "b.txt"), []byte("content"), 0777)
 
 	os.Chdir(blogDir)
-	assert.NoError(os.Symlink("real", "symlinked"))
+	c.Assert(os.Symlink("real", "symlinked"), qt.IsNil)
 	os.Chdir(blogReal)
-	assert.NoError(os.Symlink("../real", "cyclic"))
+	c.Assert(os.Symlink("../real", "cyclic"), qt.IsNil)
 	os.Chdir(docsDir)
-	assert.NoError(os.Symlink("../blog/real/cyclic", "docsreal"))
+	c.Assert(os.Symlink("../blog/real/cyclic", "docsreal"), qt.IsNil)
 
 	t.Run("OS Fs", func(t *testing.T) {
-		assert := require.New(t)
+		c := qt.New(t)
 
 		names, err := collectFilenames(fs, workDir, workDir)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
-		assert.Equal([]string{"blog/real/sub/a.txt", "docs/b.txt"}, names)
+		c.Assert(names, qt.DeepEquals, []string{"blog/real/sub/a.txt", "docs/b.txt"})
 	})
 
 	t.Run("BasePath Fs", func(t *testing.T) {
@@ -135,15 +135,15 @@ func TestWalkSymbolicLink(t *testing.T) {
 			t.Skip("skip this for Go <= 1.11 due to a bug in Go's stdlib")
 
 		}
-		assert := require.New(t)
+		c := qt.New(t)
 
 		docsFs := afero.NewBasePathFs(fs, docsDir)
 
 		names, err := collectFilenames(docsFs, "", "")
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 
 		// Note: the docsreal folder is considered cyclic when walking from the root, but this works.
-		assert.Equal([]string{"b.txt", "docsreal/sub/a.txt"}, names)
+		c.Assert(names, qt.DeepEquals, []string{"b.txt", "docsreal/sub/a.txt"})
 	})
 
 }
@@ -177,13 +177,13 @@ func collectFilenames(fs afero.Fs, base, root string) ([]string, error) {
 }
 
 func BenchmarkWalk(b *testing.B) {
-	assert := require.New(b)
+	c := qt.New(b)
 	fs := NewBaseFileDecorator(afero.NewMemMapFs())
 
 	writeFiles := func(dir string, numfiles int) {
 		for i := 0; i < numfiles; i++ {
 			filename := filepath.Join(dir, fmt.Sprintf("file%d.txt", i))
-			assert.NoError(afero.WriteFile(fs, filename, []byte("content"), 0777))
+			c.Assert(afero.WriteFile(fs, filename, []byte("content"), 0777), qt.IsNil)
 		}
 	}
 

hugolib/alias_test.go

@@ -20,7 +20,7 @@ import (
 
 	"github.com/gohugoio/hugo/common/loggers"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 const pageWithAlias = `---
@@ -43,14 +43,14 @@ const aliasTemplate = "<html><body>ALIASTEMPLATE</body></html>"
 
 func TestAlias(t *testing.T) {
 	t.Parallel()
-	assert := require.New(t)
+	c := qt.New(t)
 
 	b := newTestSitesBuilder(t)
 	b.WithSimpleConfigFile().WithContent("blog/page.md", pageWithAlias)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	require.Len(t, b.H.Sites[0].RegularPages(), 1)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 1)
 
 	// the real page
 	b.AssertFileContent("public/blog/page/index.html", "For some moments the old man")
@@ -62,7 +62,7 @@ func TestAlias(t *testing.T) {
 func TestAliasMultipleOutputFormats(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	b := newTestSitesBuilder(t)
 	b.WithSimpleConfigFile().WithContent("blog/page.md", pageWithAliasMultipleOutputs)
@@ -82,7 +82,7 @@ func TestAliasMultipleOutputFormats(t *testing.T) {
 	// the alias redirectors
 	b.AssertFileContent("public/foo/bar/index.html", "<meta http-equiv=\"refresh\" content=\"0; ")
 	b.AssertFileContent("public/amp/foo/bar/index.html", "<meta http-equiv=\"refresh\" content=\"0; ")
-	assert.False(b.CheckExists("public/foo/bar/index.json"))
+	c.Assert(b.CheckExists("public/foo/bar/index.json"), qt.Equals, false)
 }
 
 func TestAliasTemplate(t *testing.T) {

hugolib/cascade_test.go

@@ -19,10 +19,9 @@ import (
 	"path"
 	"testing"
 
-	"github.com/alecthomas/assert"
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/stretchr/testify/require"
 )
 
 func BenchmarkCascade(b *testing.B) {
@@ -31,7 +30,7 @@ func BenchmarkCascade(b *testing.B) {
 	for i := 1; i <= len(allLangs); i += 2 {
 		langs := allLangs[0:i]
 		b.Run(fmt.Sprintf("langs-%d", len(langs)), func(b *testing.B) {
-			assert := require.New(b)
+			c := qt.New(b)
 			b.StopTimer()
 			builders := make([]*sitesBuilder, b.N)
 			for i := 0; i < b.N; i++ {
@@ -42,16 +41,15 @@ func BenchmarkCascade(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				builder := builders[i]
 				err := builder.BuildE(BuildCfg{})
-				assert.NoError(err)
+				c.Assert(err, qt.IsNil)
 				first := builder.H.Sites[0]
-				assert.NotNil(first)
+				c.Assert(first, qt.Not(qt.IsNil))
 			}
 		})
 	}
 }
 
 func TestCascade(t *testing.T) {
-	assert := assert.New(t)
 
 	allLangs := []string{"en", "nn", "nb", "sv"}
 
@@ -93,7 +91,7 @@ func TestCascade(t *testing.T) {
 		// Check output formats set in cascade
 		b.AssertFileContent("public/sect4/index.xml", `<link>https://example.org/sect4/index.xml</link>`)
 		b.AssertFileContent("public/sect4/p1/index.xml", `<link>https://example.org/sect4/p1/index.xml</link>`)
-		assert.False(b.CheckExists("public/sect2/index.xml"))
+		b.C.Assert(b.CheckExists("public/sect2/index.xml"), qt.Equals, false)
 
 		// Check cascade into bundled page
 		b.AssertFileContent("public/bundle1/index.html", `Resources: bp1.md|home.png|`)

hugolib/case_insensitive_test.go

@@ -21,9 +21,9 @@ import (
 
 	"github.com/gohugoio/hugo/hugofs"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
 )
 
 var (
@@ -135,6 +135,8 @@ Partial Site Global: {{ site.Params.COLOR }}|{{ site.Params.COLORS.YELLOW }}
 func TestCaseInsensitiveConfigurationVariations(t *testing.T) {
 	t.Parallel()
 
+	c := qt.New(t)
+
 	// See issues 2615, 1129, 2590 and maybe some others
 	// Also see 2598
 	//
@@ -152,11 +154,11 @@ func TestCaseInsensitiveConfigurationVariations(t *testing.T) {
 	caseMixingTestsWriteCommonSources(t, mm)
 
 	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Filename: "config.toml"})
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 
 	fs := hugofs.NewFrom(mm, cfg)
 
-	th := testHelper{cfg, fs, t}
+	th := newTestHelper(cfg, fs, t)
 
 	writeSource(t, fs, filepath.Join("layouts", "_default", "baseof.html"), `
 Block Page Colors: {{ .Params.COLOR }}|{{ .Params.Colors.Blue }}	
@@ -258,17 +260,17 @@ func TestCaseInsensitiveConfigurationForAllTemplateEngines(t *testing.T) {
 }
 
 func doTestCaseInsensitiveConfigurationForTemplateEngine(t *testing.T, suffix string, templateFixer func(s string) string) {
-
+	c := qt.New(t)
 	mm := afero.NewMemMapFs()
 
 	caseMixingTestsWriteCommonSources(t, mm)
 
 	cfg, err := LoadConfigDefault(mm)
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 
 	fs := hugofs.NewFrom(mm, cfg)
 
-	th := testHelper{cfg, fs, t}
+	th := newTestHelper(cfg, fs, t)
 
 	t.Log("Testing", suffix)
 

hugolib/collections_test.go

@@ -17,11 +17,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestGroupFunc(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pageContent := `
 ---
@@ -39,14 +39,14 @@ title: "Page"
 `)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	require.Len(t, b.H.Sites[0].RegularPages(), 2)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 2)
 
 	b.AssertFileContent("public/index.html", "cool: 2")
 }
 
 func TestSliceFunc(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pageContent := `
 ---
@@ -78,8 +78,8 @@ tags_weight: %d
 `)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	require.Len(t, b.H.Sites[0].RegularPages(), 2)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 2)
 
 	b.AssertFileContent("public/index.html",
 		"pages:2:page.Pages:Page(/page1.md)/Page(/page2.md)",
@@ -88,7 +88,7 @@ tags_weight: %d
 }
 
 func TestUnionFunc(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pageContent := `
 ---
@@ -110,8 +110,8 @@ tags_weight: %d
 `)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	require.Len(t, b.H.Sites[0].RegularPages(), 3)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 3)
 
 	b.AssertFileContent("public/index.html",
 		"unionPages: page.Pages 3",
@@ -119,7 +119,7 @@ tags_weight: %d
 }
 
 func TestCollectionsFuncs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pageContent := `
 ---
@@ -151,8 +151,8 @@ Symdiff: {{ range $symdiff }}{{ .RelPermalink }}|{{ end }}
 `)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	require.Len(t, b.H.Sites[0].RegularPages(), 3)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 3)
 
 	b.AssertFileContent("public/index.html",
 		"uniqPages: page.Pages 3",
@@ -164,7 +164,7 @@ Symdiff: {{ range $symdiff }}{{ .RelPermalink }}|{{ end }}
 }
 
 func TestAppendFunc(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	pageContent := `
 ---
@@ -203,8 +203,8 @@ tags_weight: %d
 `)
 	b.CreateSites().Build(BuildCfg{})
 
-	assert.Equal(1, len(b.H.Sites))
-	assert.Len(b.H.Sites[0].RegularPages(), 2)
+	c.Assert(len(b.H.Sites), qt.Equals, 1)
+	c.Assert(len(b.H.Sites[0].RegularPages()), qt.Equals, 2)
 
 	b.AssertFileContent("public/index.html",
 		"pages:2:page.Pages:Page(/page2.md)/Page(/page1.md)",

hugolib/config_test.go

@@ -19,15 +19,15 @@ import (
 	"path/filepath"
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/afero"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func TestLoadConfig(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	// Add a random config variable for testing.
 	// side = page in Norwegian.
@@ -40,16 +40,16 @@ func TestLoadConfig(t *testing.T) {
 	writeToFs(t, mm, "hugo.toml", configContent)
 
 	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Filename: "hugo.toml"})
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal("side", cfg.GetString("paginatePath"))
+	c.Assert(cfg.GetString("paginatePath"), qt.Equals, "side")
 
 }
 
 func TestLoadMultiConfig(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	// Add a random config variable for testing.
 	// side = page in Norwegian.
@@ -67,16 +67,16 @@ func TestLoadMultiConfig(t *testing.T) {
 	writeToFs(t, mm, "override.toml", configContentSub)
 
 	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Filename: "base.toml,override.toml"})
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal("top", cfg.GetString("paginatePath"))
-	assert.Equal("same", cfg.GetString("DontChange"))
+	c.Assert(cfg.GetString("paginatePath"), qt.Equals, "top")
+	c.Assert(cfg.GetString("DontChange"), qt.Equals, "same")
 }
 
 func TestLoadConfigFromTheme(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	mainConfigBasic := `
 theme = "test-theme"
@@ -291,7 +291,7 @@ map[string]interface {}{
 }
 `, got["menus"])
 
-	assert.Equal("https://example.com/", got["baseurl"])
+	c.Assert(got["baseurl"], qt.Equals, "https://example.com/")
 
 	if true {
 		return
@@ -314,7 +314,7 @@ map[string]interface {}{
   },
 }`, got["params"])
 
-	assert.Nil(got["languages"])
+	c.Assert(got["languages"], qt.IsNil)
 	b.AssertObject(`
 map[string]interface {}{
   "text/m1": map[string]interface {}{
@@ -365,7 +365,7 @@ map[string]interface {}{
 func TestPrivacyConfig(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	tomlConfig := `
 
@@ -380,14 +380,14 @@ privacyEnhanced = true
 	b.WithConfigFile("toml", tomlConfig)
 	b.Build(BuildCfg{SkipRender: true})
 
-	assert.True(b.H.Sites[0].Info.Config().Privacy.YouTube.PrivacyEnhanced)
+	c.Assert(b.H.Sites[0].Info.Config().Privacy.YouTube.PrivacyEnhanced, qt.Equals, true)
 
 }
 
 func TestLoadConfigModules(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	// https://github.com/gohugoio/hugoThemes#themetoml
 
@@ -469,18 +469,20 @@ path="n4"
 	var graphb bytes.Buffer
 	modulesClient.Graph(&graphb)
 
-	assert.Equal(`project n1
+	expected := `project n1
 n1 o1
 o1 n2
 n1 n3
 project n4
-`, graphb.String())
+`
+
+	c.Assert(graphb.String(), qt.Equals, expected)
 
 }
 
 func TestLoadConfigWithOsEnvOverrides(t *testing.T) {
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	baseConfig := `
 
@@ -512,13 +514,13 @@ resamplefilter = "CatmullRom"
 
 	cfg := b.H.Cfg
 
-	assert.Equal("test", cfg.Get("environment"))
-	assert.Equal(false, cfg.GetBool("enablegitinfo"))
-	assert.Equal("new", cfg.Get("new"))
-	assert.Equal("top", cfg.Get("imaging.anchor"))
-	assert.Equal(int64(75), cfg.Get("imaging.quality"))
-	assert.Equal([]interface{}{"c", "d"}, cfg.Get("stringSlice"))
-	assert.Equal([]interface{}{5.32}, cfg.Get("floatSlice"))
-	assert.Equal([]interface{}{5, 8, 9}, cfg.Get("intSlice"))
+	c.Assert(cfg.Get("environment"), qt.Equals, "test")
+	c.Assert(cfg.GetBool("enablegitinfo"), qt.Equals, false)
+	c.Assert(cfg.Get("new"), qt.Equals, "new")
+	c.Assert(cfg.Get("imaging.anchor"), qt.Equals, "top")
+	c.Assert(cfg.Get("imaging.quality"), qt.Equals, int64(75))
+	c.Assert(cfg.Get("stringSlice"), qt.DeepEquals, []interface{}{"c", "d"})
+	c.Assert(cfg.Get("floatSlice"), qt.DeepEquals, []interface{}{5.32})
+	c.Assert(cfg.Get("intSlice"), qt.DeepEquals, []interface{}{5, 8, 9})
 
 }

hugolib/configdir_test.go

@@ -19,15 +19,15 @@ import (
 
 	"github.com/gohugoio/hugo/common/herrors"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/htesting"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
 )
 
 func TestLoadConfigDir(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configContent := `
 baseURL = "https://example.org"
@@ -107,29 +107,29 @@ p3 = "p3params_no_production"
 	fb.Build()
 
 	cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Environment: "development", Filename: "hugo.toml", AbsConfigDir: "config"})
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
-	assert.Equal("pag_development", cfg.GetString("paginatePath")) // /config/development/config.toml
+	c.Assert(cfg.GetString("paginatePath"), qt.Equals, "pag_development") // /config/development/config.toml
 
-	assert.Equal(10, cfg.GetInt("languages.no.weight"))                          //  /config.toml
-	assert.Equal("Norsk_no_default", cfg.GetString("languages.no.languageName")) // /config/_default/languages.no.toml
+	c.Assert(cfg.GetInt("languages.no.weight"), qt.Equals, 10)                          //  /config.toml
+	c.Assert(cfg.GetString("languages.no.languageName"), qt.Equals, "Norsk_no_default") // /config/_default/languages.no.toml
 
-	assert.Equal("p1_base", cfg.GetString("params.p1"))
-	assert.Equal("p2params_default", cfg.GetString("params.p2")) // Is in both _default and production
-	assert.Equal("p3params_development", cfg.GetString("params.p3"))
-	assert.Equal("p3params_no_development", cfg.GetString("languages.no.params.p3"))
+	c.Assert(cfg.GetString("params.p1"), qt.Equals, "p1_base")
+	c.Assert(cfg.GetString("params.p2"), qt.Equals, "p2params_default") // Is in both _default and production
+	c.Assert(cfg.GetString("params.p3"), qt.Equals, "p3params_development")
+	c.Assert(cfg.GetString("languages.no.params.p3"), qt.Equals, "p3params_no_development")
 
-	assert.Equal(2, len(cfg.Get("menus.docs").(([]map[string]interface{}))))
+	c.Assert(len(cfg.Get("menus.docs").(([]map[string]interface{}))), qt.Equals, 2)
 	noMenus := cfg.Get("languages.no.menus.docs")
-	assert.NotNil(noMenus)
-	assert.Equal(1, len(noMenus.(([]map[string]interface{}))))
+	c.Assert(noMenus, qt.Not(qt.IsNil))
+	c.Assert(len(noMenus.(([]map[string]interface{}))), qt.Equals, 1)
 
 }
 
 func TestLoadConfigDirError(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	configContent := `
 baseURL = "https://example.org"
@@ -145,10 +145,10 @@ baseURL = "https://example.org"
 	fb.Add("config.toml", `invalid & syntax`).Build()
 
 	_, _, err := LoadConfig(ConfigSourceDescriptor{Fs: mm, Environment: "development", Filename: "hugo.toml", AbsConfigDir: "config"})
-	assert.Error(err)
+	c.Assert(err, qt.Not(qt.IsNil))
 
 	fe := herrors.UnwrapErrorWithFileContext(err)
-	assert.NotNil(fe)
-	assert.Equal(filepath.FromSlash("config/development/config.toml"), fe.Position().Filename)
+	c.Assert(fe, qt.Not(qt.IsNil))
+	c.Assert(fe.Position().Filename, qt.Equals, filepath.FromSlash("config/development/config.toml"))
 
 }

hugolib/datafiles_test.go

@@ -16,7 +16,6 @@ package hugolib
 import (
 	"path/filepath"
 	"reflect"
-	"strings"
 	"testing"
 
 	"github.com/gohugoio/hugo/common/loggers"
@@ -26,7 +25,7 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestDataDir(t *testing.T) {
@@ -377,6 +376,7 @@ func TestDataFromShortcode(t *testing.T) {
 
 	var (
 		cfg, fs = newTestCfg()
+		c       = qt.New(t)
 	)
 
 	writeSource(t, fs, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
@@ -392,7 +392,7 @@ Slogan from shortcode: {{< d >}}
 	buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
 
 	content := readSource(t, fs, "public/c/index.html")
-	require.True(t, strings.Contains(content, "Slogan from template: Hugo Rocks!"), content)
-	require.True(t, strings.Contains(content, "Slogan from shortcode: Hugo Rocks!"), content)
 
+	c.Assert(content, qt.Contains, "Slogan from template: Hugo Rocks!")
+	c.Assert(content, qt.Contains, "Slogan from shortcode: Hugo Rocks!")
 }

hugolib/disableKinds_test.go

@@ -18,10 +18,10 @@ import (
 
 	"fmt"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/resources/page"
 
 	"github.com/gohugoio/hugo/helpers"
-	"github.com/stretchr/testify/require"
 )
 
 func TestDisableKindsNoneDisabled(t *testing.T) {
@@ -104,8 +104,6 @@ categories:
 	b.Build(BuildCfg{})
 	h := b.H
 
-	require.Len(t, h.Sites, 1)
-
 	assertDisabledKinds(b, h.Sites[0], disabled...)
 
 }
@@ -181,7 +179,7 @@ func assertDisabledKinds(b *sitesBuilder, s *Site, disabled ...string) {
 
 func assertDisabledKind(b *sitesBuilder, kindAssert func(bool) bool, disabled []string, kind, path, matcher string) {
 	isDisabled := stringSliceContains(kind, disabled...)
-	require.True(b.T, kindAssert(isDisabled), fmt.Sprintf("%s: %t", kind, isDisabled))
+	b.Assert(kindAssert(isDisabled), qt.Equals, true)
 
 	if kind == kindRSS && !isDisabled {
 		// If the home page is also disabled, there is not RSS to look for.
@@ -193,8 +191,8 @@ func assertDisabledKind(b *sitesBuilder, kindAssert func(bool) bool, disabled []
 	if isDisabled {
 		// Path should not exist
 		fileExists, err := helpers.Exists(path, b.Fs.Destination)
-		require.False(b.T, fileExists)
-		require.NoError(b.T, err)
+		b.Assert(err, qt.IsNil)
+		b.Assert(fileExists, qt.Equals, false)
 
 	} else {
 		b.AssertFileContent(path, matcher)

hugolib/embedded_shortcodes_test.go

@@ -26,8 +26,8 @@ import (
 
 	"github.com/gohugoio/hugo/deps"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/tpl"
-	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -45,6 +45,7 @@ func TestShortcodeCrossrefs(t *testing.T) {
 func doTestShortcodeCrossrefs(t *testing.T, relative bool) {
 	var (
 		cfg, fs = newTestCfg()
+		c       = qt.New(t)
 	)
 
 	cfg.Set("baseURL", testBaseURL)
@@ -69,10 +70,10 @@ func doTestShortcodeCrossrefs(t *testing.T, relative bool) {
 
 	s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
 
-	require.Len(t, s.RegularPages(), 1)
+	c.Assert(len(s.RegularPages()), qt.Equals, 1)
 
 	content, err := s.RegularPages()[0].Content()
-	require.NoError(t, err)
+	c.Assert(err, qt.IsNil)
 	output := cast.ToString(content)
 
 	if !strings.Contains(output, expected) {
@@ -100,7 +101,7 @@ void do();
 
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		cfg.Set("pygmentsStyle", "bw")
@@ -148,7 +149,7 @@ func TestShortcodeFigure(t *testing.T) {
 
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		writeSource(t, fs, filepath.Join("content", "simple.md"), fmt.Sprintf(`---
@@ -187,7 +188,7 @@ func TestShortcodeYoutube(t *testing.T) {
 	} {
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		writeSource(t, fs, filepath.Join("content", "simple.md"), fmt.Sprintf(`---
@@ -226,7 +227,7 @@ func TestShortcodeVimeo(t *testing.T) {
 	} {
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		writeSource(t, fs, filepath.Join("content", "simple.md"), fmt.Sprintf(`---
@@ -259,7 +260,7 @@ func TestShortcodeGist(t *testing.T) {
 	} {
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		writeSource(t, fs, filepath.Join("content", "simple.md"), fmt.Sprintf(`---
@@ -302,7 +303,7 @@ func TestShortcodeTweet(t *testing.T) {
 
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		withTemplate := func(templ tpl.TemplateHandler) error {
@@ -357,7 +358,7 @@ func TestShortcodeInstagram(t *testing.T) {
 
 		var (
 			cfg, fs = newTestCfg()
-			th      = testHelper{cfg, fs, t}
+			th      = newTestHelper(cfg, fs, t)
 		)
 
 		withTemplate := func(templ tpl.TemplateHandler) error {

hugolib/embedded_templates_test.go

@@ -16,7 +16,7 @@ package hugolib
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 // Just some simple test of the embedded templates to avoid
@@ -25,8 +25,8 @@ import (
 func _TestEmbeddedTemplates(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
-	assert.True(true)
+	c := qt.New(t)
+	c.Assert(true, qt.Equals, true)
 
 	home := []string{"index.html", `
 GA:

hugolib/fileInfo_test.go

@@ -16,16 +16,16 @@ package hugolib
 import (
 	"testing"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/spf13/cast"
-	"github.com/stretchr/testify/require"
 )
 
 func TestFileInfo(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
 		t.Parallel()
-		assert := require.New(t)
+		c := qt.New(t)
 		fi := &fileInfo{}
 		_, err := cast.ToStringE(fi)
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 	})
 }

hugolib/filesystems/basefs_test.go

@@ -27,11 +27,11 @@ import (
 
 	"github.com/spf13/afero"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib/paths"
 	"github.com/gohugoio/hugo/modules"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 func initConfig(fs afero.Fs, cfg config.Provider) error {
@@ -72,7 +72,7 @@ func initConfig(fs afero.Fs, cfg config.Provider) error {
 }
 
 func TestNewBaseFs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := viper.New()
 
 	fs := hugofs.NewMem(v)
@@ -119,54 +119,52 @@ theme = ["atheme"]
 	setConfigAndWriteSomeFilesTo(fs.Source, v, "resourceDir", "myrsesource", 10)
 
 	v.Set("publishDir", "public")
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
-	assert.NotNil(bfs)
+	c.Assert(err, qt.IsNil)
+	c.Assert(bfs, qt.Not(qt.IsNil))
 
 	root, err := bfs.I18n.Fs.Open("")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	dirnames, err := root.Readdirnames(-1)
-	assert.NoError(err)
-	assert.Equal([]string{"f1.txt", "f2.txt", "f3.txt", "f4.txt", "f3.txt", "theme-file-btheme.txt", "f3.txt", "theme-file-atheme.txt"}, dirnames)
+	c.Assert(err, qt.IsNil)
+	c.Assert(dirnames, qt.DeepEquals, []string{"f1.txt", "f2.txt", "f3.txt", "f4.txt", "f3.txt", "theme-file-btheme.txt", "f3.txt", "theme-file-atheme.txt"})
 
 	root, err = bfs.Data.Fs.Open("")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	dirnames, err = root.Readdirnames(-1)
-	assert.NoError(err)
-	assert.Equal([]string{"f1.txt", "f2.txt", "f3.txt", "f4.txt", "f5.txt", "f6.txt", "f7.txt", "f3.txt", "theme-file-btheme.txt", "f3.txt", "theme-file-atheme.txt"}, dirnames)
+	c.Assert(err, qt.IsNil)
+	c.Assert(dirnames, qt.DeepEquals, []string{"f1.txt", "f2.txt", "f3.txt", "f4.txt", "f5.txt", "f6.txt", "f7.txt", "f3.txt", "theme-file-btheme.txt", "f3.txt", "theme-file-atheme.txt"})
 
-	//printFs(bfs.Work, "", os.Stdout)
+	checkFileCount(bfs.Layouts.Fs, "", c, 7)
 
-	checkFileCount(bfs.Layouts.Fs, "", assert, 7)
+	checkFileCount(bfs.Content.Fs, "", c, 3)
+	checkFileCount(bfs.I18n.Fs, "", c, 8) // 4 + 4 themes
 
-	checkFileCount(bfs.Content.Fs, "", assert, 3)
-	checkFileCount(bfs.I18n.Fs, "", assert, 8) // 4 + 4 themes
+	checkFileCount(bfs.Static[""].Fs, "", c, 6)
+	checkFileCount(bfs.Data.Fs, "", c, 11)       // 7 + 4 themes
+	checkFileCount(bfs.Archetypes.Fs, "", c, 10) // 8 + 2 themes
+	checkFileCount(bfs.Assets.Fs, "", c, 9)
+	checkFileCount(bfs.Work, "", c, 82)
 
-	checkFileCount(bfs.Static[""].Fs, "", assert, 6)
-	checkFileCount(bfs.Data.Fs, "", assert, 11)       // 7 + 4 themes
-	checkFileCount(bfs.Archetypes.Fs, "", assert, 10) // 8 + 2 themes
-	checkFileCount(bfs.Assets.Fs, "", assert, 9)
-	checkFileCount(bfs.Work, "", assert, 82)
-
-	assert.True(bfs.IsData(filepath.Join(workingDir, "mydata", "file1.txt")))
-	assert.True(bfs.IsI18n(filepath.Join(workingDir, "myi18n", "file1.txt")))
-	assert.True(bfs.IsLayout(filepath.Join(workingDir, "mylayouts", "file1.txt")))
-	assert.True(bfs.IsStatic(filepath.Join(workingDir, "mystatic", "file1.txt")))
-	assert.True(bfs.IsAsset(filepath.Join(workingDir, "myassets", "file1.txt")))
+	c.Assert(bfs.IsData(filepath.Join(workingDir, "mydata", "file1.txt")), qt.Equals, true)
+	c.Assert(bfs.IsI18n(filepath.Join(workingDir, "myi18n", "file1.txt")), qt.Equals, true)
+	c.Assert(bfs.IsLayout(filepath.Join(workingDir, "mylayouts", "file1.txt")), qt.Equals, true)
+	c.Assert(bfs.IsStatic(filepath.Join(workingDir, "mystatic", "file1.txt")), qt.Equals, true)
+	c.Assert(bfs.IsAsset(filepath.Join(workingDir, "myassets", "file1.txt")), qt.Equals, true)
 
 	contentFilename := filepath.Join(workingDir, "mycontent", "file1.txt")
-	assert.True(bfs.IsContent(contentFilename))
+	c.Assert(bfs.IsContent(contentFilename), qt.Equals, true)
 	rel := bfs.RelContentDir(contentFilename)
-	assert.Equal("file1.txt", rel)
+	c.Assert(rel, qt.Equals, "file1.txt")
 
 	// Check Work fs vs theme
-	checkFileContent(bfs.Work, "file-root.txt", assert, "content-project")
-	checkFileContent(bfs.Work, "theme-root-atheme.txt", assert, "content:atheme")
+	checkFileContent(bfs.Work, "file-root.txt", c, "content-project")
+	checkFileContent(bfs.Work, "theme-root-atheme.txt", c, "content:atheme")
 
 	// https://github.com/gohugoio/hugo/issues/5318
 	// Check both project and theme.
@@ -174,10 +172,10 @@ theme = ["atheme"]
 		for _, filename := range []string{"/f1.txt", "/theme-file-atheme.txt"} {
 			filename = filepath.FromSlash(filename)
 			f, err := fs.Open(filename)
-			assert.NoError(err)
+			c.Assert(err, qt.IsNil)
 			name := f.Name()
 			f.Close()
-			assert.Equal(filename, name)
+			c.Assert(name, qt.Equals, filename)
 		}
 	}
 }
@@ -199,35 +197,35 @@ func createConfig() *viper.Viper {
 }
 
 func TestNewBaseFsEmpty(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := createConfig()
 	fs := hugofs.NewMem(v)
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
-	assert.NotNil(bfs)
-	assert.NotNil(bfs.Archetypes.Fs)
-	assert.NotNil(bfs.Layouts.Fs)
-	assert.NotNil(bfs.Data.Fs)
-	assert.NotNil(bfs.I18n.Fs)
-	assert.NotNil(bfs.Work)
-	assert.NotNil(bfs.Content.Fs)
-	assert.NotNil(bfs.Static)
+	c.Assert(err, qt.IsNil)
+	c.Assert(bfs, qt.Not(qt.IsNil))
+	c.Assert(bfs.Archetypes.Fs, qt.Not(qt.IsNil))
+	c.Assert(bfs.Layouts.Fs, qt.Not(qt.IsNil))
+	c.Assert(bfs.Data.Fs, qt.Not(qt.IsNil))
+	c.Assert(bfs.I18n.Fs, qt.Not(qt.IsNil))
+	c.Assert(bfs.Work, qt.Not(qt.IsNil))
+	c.Assert(bfs.Content.Fs, qt.Not(qt.IsNil))
+	c.Assert(bfs.Static, qt.Not(qt.IsNil))
 }
 
 func TestRealDirs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := createConfig()
 	fs := hugofs.NewDefault(v)
 	sfs := fs.Source
 
 	root, err := afero.TempDir(sfs, "", "realdir")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	themesDir, err := afero.TempDir(sfs, "", "themesDir")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	defer func() {
 		os.RemoveAll(root)
 		os.RemoveAll(themesDir)
@@ -237,14 +235,14 @@ func TestRealDirs(t *testing.T) {
 	v.Set("themesDir", themesDir)
 	v.Set("theme", "mytheme")
 
-	assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf1"), 0755))
-	assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf2"), 0755))
-	assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf2"), 0755))
-	assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf3"), 0755))
-	assert.NoError(sfs.MkdirAll(filepath.Join(root, "resources"), 0755))
-	assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "resources"), 0755))
+	c.Assert(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf1"), 0755), qt.IsNil)
+	c.Assert(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf2"), 0755), qt.IsNil)
+	c.Assert(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf2"), 0755), qt.IsNil)
+	c.Assert(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf3"), 0755), qt.IsNil)
+	c.Assert(sfs.MkdirAll(filepath.Join(root, "resources"), 0755), qt.IsNil)
+	c.Assert(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "resources"), 0755), qt.IsNil)
 
-	assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "js", "f2"), 0755))
+	c.Assert(sfs.MkdirAll(filepath.Join(root, "myassets", "js", "f2"), 0755), qt.IsNil)
 
 	afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "scss", "sf1", "a1.scss")), []byte("content"), 0755)
 	afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "scss", "sf2", "a3.scss")), []byte("content"), 0755)
@@ -259,27 +257,27 @@ func TestRealDirs(t *testing.T) {
 	afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "js", "f2", "a1.js")), []byte("content"), 0755)
 	afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "js", "a2.js")), []byte("content"), 0755)
 
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
-	assert.NotNil(bfs)
+	c.Assert(err, qt.IsNil)
+	c.Assert(bfs, qt.Not(qt.IsNil))
 
-	checkFileCount(bfs.Assets.Fs, "", assert, 6)
+	checkFileCount(bfs.Assets.Fs, "", c, 6)
 
 	realDirs := bfs.Assets.RealDirs("scss")
-	assert.Equal(2, len(realDirs))
-	assert.Equal(filepath.Join(root, "myassets/scss"), realDirs[0])
-	assert.Equal(filepath.Join(themesDir, "mytheme/assets/scss"), realDirs[len(realDirs)-1])
+	c.Assert(len(realDirs), qt.Equals, 2)
+	c.Assert(realDirs[0], qt.Equals, filepath.Join(root, "myassets/scss"))
+	c.Assert(realDirs[len(realDirs)-1], qt.Equals, filepath.Join(themesDir, "mytheme/assets/scss"))
 
-	assert.NotNil(bfs.theBigFs)
+	c.Assert(bfs.theBigFs, qt.Not(qt.IsNil))
 
 }
 
 func TestStaticFs(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := createConfig()
 	workDir := "mywork"
 	v.Set("workingDir", workDir)
@@ -296,21 +294,21 @@ func TestStaticFs(t *testing.T) {
 	afero.WriteFile(fs.Source, filepath.Join(themeStaticDir, "f2.txt"), []byte("Hugo Themes Still Rocks!"), 0755)
 	afero.WriteFile(fs.Source, filepath.Join(themeStaticDir2, "f2.txt"), []byte("Hugo Themes Rocks in t2!"), 0755)
 
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	sfs := bfs.StaticFs("en")
-	checkFileContent(sfs, "f1.txt", assert, "Hugo Rocks!")
-	checkFileContent(sfs, "f2.txt", assert, "Hugo Themes Still Rocks!")
+	checkFileContent(sfs, "f1.txt", c, "Hugo Rocks!")
+	checkFileContent(sfs, "f2.txt", c, "Hugo Themes Still Rocks!")
 
 }
 
 func TestStaticFsMultiHost(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := createConfig()
 	workDir := "mywork"
 	v.Set("workingDir", workDir)
@@ -340,30 +338,30 @@ func TestStaticFsMultiHost(t *testing.T) {
 	afero.WriteFile(fs.Source, filepath.Join(themeStaticDir, "f1.txt"), []byte("Hugo Themes Rocks!"), 0755)
 	afero.WriteFile(fs.Source, filepath.Join(themeStaticDir, "f2.txt"), []byte("Hugo Themes Still Rocks!"), 0755)
 
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	enFs := bfs.StaticFs("en")
-	checkFileContent(enFs, "f1.txt", assert, "Hugo Rocks!")
-	checkFileContent(enFs, "f2.txt", assert, "Hugo Themes Still Rocks!")
+	checkFileContent(enFs, "f1.txt", c, "Hugo Rocks!")
+	checkFileContent(enFs, "f2.txt", c, "Hugo Themes Still Rocks!")
 
 	noFs := bfs.StaticFs("no")
-	checkFileContent(noFs, "f1.txt", assert, "Hugo Rocks in Norway!")
-	checkFileContent(noFs, "f2.txt", assert, "Hugo Themes Still Rocks!")
+	checkFileContent(noFs, "f1.txt", c, "Hugo Rocks in Norway!")
+	checkFileContent(noFs, "f2.txt", c, "Hugo Themes Still Rocks!")
 }
 
 func TestMakePathRelative(t *testing.T) {
-	assert := require.New(t)
+	c := qt.New(t)
 	v := createConfig()
 	fs := hugofs.NewMem(v)
 	workDir := "mywork"
 	v.Set("workingDir", workDir)
 
-	assert.NoError(fs.Source.MkdirAll(filepath.Join(workDir, "dist"), 0777))
-	assert.NoError(fs.Source.MkdirAll(filepath.Join(workDir, "static"), 0777))
+	c.Assert(fs.Source.MkdirAll(filepath.Join(workDir, "dist"), 0777), qt.IsNil)
+	c.Assert(fs.Source.MkdirAll(filepath.Join(workDir, "static"), 0777), qt.IsNil)
 
 	moduleCfg := map[string]interface{}{
 		"mounts": []interface{}{
@@ -380,35 +378,35 @@ func TestMakePathRelative(t *testing.T) {
 
 	v.Set("module", moduleCfg)
 
-	assert.NoError(initConfig(fs.Source, v))
+	c.Assert(initConfig(fs.Source, v), qt.IsNil)
 
 	p, err := paths.New(fs, v)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 	bfs, err := NewBase(p, nil)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	sfs := bfs.Static[""]
-	assert.NotNil(sfs)
+	c.Assert(sfs, qt.Not(qt.IsNil))
 
-	assert.Equal(filepath.FromSlash("/foo.txt"), sfs.MakePathRelative(filepath.Join(workDir, "static", "foo.txt")))
-	assert.Equal(filepath.FromSlash("/dist/foo.txt"), sfs.MakePathRelative(filepath.Join(workDir, "dist", "foo.txt")))
+	c.Assert(sfs.MakePathRelative(filepath.Join(workDir, "static", "foo.txt")), qt.Equals, filepath.FromSlash("/foo.txt"))
+	c.Assert(sfs.MakePathRelative(filepath.Join(workDir, "dist", "foo.txt")), qt.Equals, filepath.FromSlash("/dist/foo.txt"))
 }
 
-func checkFileCount(fs afero.Fs, dirname string, assert *require.Assertions, expected int) {
-	count, fnames, err := countFileaAndGetFilenames(fs, dirname)
-	assert.NoError(err, fnames)
-	assert.Equal(expected, count, fnames)
+func checkFileCount(fs afero.Fs, dirname string, c *qt.C, expected int) {
+	count, _, err := countFileaAndGetFilenames(fs, dirname)
+	c.Assert(err, qt.IsNil)
+	c.Assert(count, qt.Equals, expected)
 }
 
-func checkFileContent(fs afero.Fs, filename string, assert *require.Assertions, expected ...string) {
+func checkFileContent(fs afero.Fs, filename string, c *qt.C, expected ...string) {
 
 	b, err := afero.ReadFile(fs, filename)
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	content := string(b)
 
 	for _, e := range expected {
-		assert.Contains(content, e)
+		c.Assert(content, qt.Contains, e)
 	}
 }
 

hugolib/hugo_modules_test.go

@@ -33,9 +33,9 @@ import (
 	"github.com/gohugoio/hugo/htesting"
 	"github.com/gohugoio/hugo/hugofs"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/testmodBuilder/mods"
 	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
 )
 
 // TODO(bep) this fails when testmodBuilder is also building ...
@@ -60,12 +60,12 @@ func TestHugoModules(t *testing.T) {
 	rnd.Shuffle(len(testmods), func(i, j int) { testmods[i], testmods[j] = testmods[j], testmods[i] })
 
 	for _, m := range testmods[:2] {
-		assert := require.New(t)
+		c := qt.New(t)
 
 		v := viper.New()
 
 		workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-modules-test")
-		assert.NoError(err)
+		c.Assert(err, qt.IsNil)
 		defer clean()
 
 		configTemplate := `
@@ -375,9 +375,9 @@ min_version = "5.0.0"
 
 	b.Build(BuildCfg{})
 
-	assert := require.New(t)
+	c := qt.New(t)
 
-	assert.Equal(uint64(2), logger.WarnCounter.Count())
+	c.Assert(logger.WarnCounter.Count(), qt.Equals, uint64(2))
 
 }
 
@@ -389,13 +389,13 @@ func TestModulesSymlinks(t *testing.T) {
 		os.Chdir(wd)
 	}()
 
-	assert := require.New(t)
+	c := qt.New(t)
 	// We need to use the OS fs for this.
 	cfg := viper.New()
 	fs := hugofs.NewFrom(hugofs.Os, cfg)
 
 	workDir, clean, err := htesting.CreateTempDir(hugofs.Os, "hugo-mod-sym")
-	assert.NoError(err)
+	c.Assert(err, qt.IsNil)
 
 	defer clean()
 
@@ -406,11 +406,11 @@ Data: {{ .Site.Data }}
 	createDirsAndFiles := func(baseDir string) {
 		for _, dir := range files.ComponentFolders {
 			realDir := filepath.Join(baseDir, dir, "real")
-			assert.NoError(os.MkdirAll(realDir, 0777))
-			assert.NoError(afero.WriteFile(fs.Source, filepath.Join(realDir, "data.toml"), []byte("[hello]\nother = \"hello\""), 0777))
+			c.Assert(os.MkdirAll(realDir, 0777), qt.IsNil)
+			c.Assert(afero.WriteFile(fs.Source, filepath.Join(realDir, "data.toml"), []byte("[hello]\nother = \"hello\""), 0777), qt.IsNil)
 		}
 
-		assert.NoError(afero.WriteFile(fs.Source, filepath.Join(baseDir, "layouts", "index.html"), []byte(homeTemplate), 0777))
+		c.Assert(afero.WriteFile(fs.Source, filepath.Join(baseDir, "layouts", "index.html"), []byte(homeTemplate), 0777), qt.IsNil)
 	}
 
 	// Create project dirs and files.
@@ -421,10 +421,10 @@ Data: {{ .Site.Data }}
 
 	createSymlinks := func(baseDir, id string) {
 		for _, dir := range files.ComponentFolders {
-			assert.NoError(os.Chdir(filepath.Join(baseDir, dir)))
-			assert.NoError(os.Symlink("real", fmt.Sprintf("realsym%s", id)))
-			assert.NoError(os.Chdir(filepath.Join(baseDir, dir, "real")))
-			assert.NoError(os.Symlink("data.toml", fmt.Sprintf(filepath.FromSlash("datasym%s.toml"), id)))
+			c.Assert(os.Chdir(filepath.Join(baseDir, dir)), qt.IsNil)
+			c.Assert(os.Symlink("real", fmt.Sprintf("realsym%s", id)), qt.IsNil)
+			c.Assert(os.Chdir(filepath.Join(baseDir, dir, "real")), qt.IsNil)
+			c.Assert(os.Symlink("data.toml", fmt.Sprintf(filepath.FromSlash("datasym%s.toml"), id)), qt.IsNil)
 		}
 	}
 
@@ -451,7 +451,7 @@ weight = 2
 	b.Fs = fs
 
 	b.WithConfigFile("toml", config)
-	assert.NoError(os.Chdir(workDir))
+	c.Assert(os.Chdir(workDir), qt.IsNil)
 
 	b.Build(BuildCfg{})
 
@@ -493,10 +493,10 @@ weight = 2
 				}
 
 				if shouldFail {
-					assert.Error(err)
-					assert.Equal(hugofs.ErrPermissionSymlink, err, filename)
+					c.Assert(err, qt.Not(qt.IsNil))
+					c.Assert(err, qt.Equals, hugofs.ErrPermissionSymlink)
 				} else {
-					assert.NoError(err, filename)
+					c.Assert(err, qt.IsNil)
 				}
 			}
 

hugolib/hugo_sites_build_errors_test.go

@@ -11,31 +11,31 @@ import (
 
 	"github.com/fortytw2/leaktest"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/common/herrors"
-	"github.com/stretchr/testify/require"
 )
 
 type testSiteBuildErrorAsserter struct {
-	name   string
-	assert *require.Assertions
+	name string
+	c    *qt.C
 }
 
 func (t testSiteBuildErrorAsserter) getFileError(err error) *herrors.ErrorWithFileContext {
-	t.assert.NotNil(err, t.name)
+	t.c.Assert(err, qt.Not(qt.IsNil), qt.Commentf(t.name))
 	ferr := herrors.UnwrapErrorWithFileContext(err)
-	t.assert.NotNil(ferr, fmt.Sprintf("[%s] got %T: %+v\n%s", t.name, err, err, stackTrace()))
+	t.c.Assert(ferr, qt.Not(qt.IsNil))
 	return ferr
 }
 
 func (t testSiteBuildErrorAsserter) assertLineNumber(lineNumber int, err error) {
 	fe := t.getFileError(err)
-	t.assert.Equal(lineNumber, fe.Position().LineNumber, fmt.Sprintf("[%s]  got => %s\n%s", t.name, fe, stackTrace()))
+	t.c.Assert(fe.Position().LineNumber, qt.Equals, lineNumber)
 }
 
 func (t testSiteBuildErrorAsserter) assertErrorMessage(e1, e2 string) {
 	// The error message will contain filenames with OS slashes. Normalize before compare.
 	e1, e2 = filepath.ToSlash(e1), filepath.ToSlash(e2)
-	t.assert.Contains(e2, e1, stackTrace())
+	t.c.Assert(e2, qt.Contains, e1)
 
 }
 
@@ -89,9 +89,9 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertCreateError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(5, fe.Position().LineNumber)
-				a.assert.Equal(1, fe.Position().ColumnNumber)
-				a.assert.Equal("go-html-template", fe.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 5)
+				a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 1)
+				a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
 				a.assertErrorMessage("\"layouts/_default/single.html:5:1\": parse failed: template: _default/single.html:5: unexpected \"}\" in operand", fe.Error())
 
 			},
@@ -104,9 +104,9 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(5, fe.Position().LineNumber)
-				a.assert.Equal(14, fe.Position().ColumnNumber)
-				a.assert.Equal("go-html-template", fe.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 5)
+				a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 14)
+				a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
 				a.assertErrorMessage("\"layouts/_default/single.html:5:14\": execute of template failed", fe.Error())
 
 			},
@@ -119,9 +119,9 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(5, fe.Position().LineNumber)
-				a.assert.Equal(14, fe.Position().ColumnNumber)
-				a.assert.Equal("go-html-template", fe.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 5)
+				a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 14)
+				a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
 				a.assertErrorMessage("\"layouts/_default/single.html:5:14\": execute of template failed", fe.Error())
 
 			},
@@ -144,8 +144,8 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(7, fe.Position().LineNumber)
-				a.assert.Equal("md", fe.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 7)
+				a.c.Assert(fe.ChromaLexer, qt.Equals, "md")
 				// Make sure that it contains both the content file and template
 				a.assertErrorMessage(`content/myyaml.md:7:10": failed to render shortcode "sc"`, fe.Error())
 				a.assertErrorMessage(`shortcodes/sc.html:4:22: executing "shortcodes/sc.html" at <.Page.Titles>: can't evaluate`, fe.Error())
@@ -159,9 +159,9 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(7, fe.Position().LineNumber)
-				a.assert.Equal(10, fe.Position().ColumnNumber)
-				a.assert.Equal("md", fe.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 7)
+				a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 10)
+				a.c.Assert(fe.ChromaLexer, qt.Equals, "md")
 				a.assertErrorMessage(`"content/myyaml.md:7:10": failed to extract shortcode: template for shortcode "nono" not found`, fe.Error())
 			},
 		},
@@ -183,8 +183,8 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
-				a.assert.Equal(6, fe.Position().LineNumber)
-				a.assert.Equal("toml", fe.ErrorContext.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 6)
+				a.c.Assert(fe.ErrorContext.ChromaLexer, qt.Equals, "toml")
 
 			},
 		},
@@ -197,8 +197,8 @@ func TestSiteBuildErrors(t *testing.T) {
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
 				fe := a.getFileError(err)
 
-				a.assert.Equal(3, fe.Position().LineNumber)
-				a.assert.Equal("json", fe.ErrorContext.ChromaLexer)
+				a.c.Assert(fe.Position().LineNumber, qt.Equals, 3)
+				a.c.Assert(fe.ErrorContext.ChromaLexer, qt.Equals, "json")
 
 			},
 		},
@@ -211,14 +211,14 @@ func TestSiteBuildErrors(t *testing.T) {
 			},
 
 			assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
-				a.assert.Error(err)
+				a.c.Assert(err, qt.Not(qt.IsNil))
 				// This is fixed in latest Go source
 				if regexp.MustCompile("devel|12").MatchString(runtime.Version()) {
 					fe := a.getFileError(err)
-					a.assert.Equal(5, fe.Position().LineNumber)
-					a.assert.Equal(21, fe.Position().ColumnNumber)
+					a.c.Assert(fe.Position().LineNumber, qt.Equals, 5)
+					a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 21)
 				} else {
-					a.assert.Contains(err.Error(), `execute of template failed: panic in Execute`)
+					a.c.Assert(err.Error(), qt.Contains, `execute of template failed: panic in Execute`)
 				}
 			},
 		},
@@ -228,10 +228,10 @@ func TestSiteBuildErrors(t *testing.T) {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
-			assert := require.New(t)
+			c := qt.New(t)
 			errorAsserter := testSiteBuildErrorAsserter{
-				assert: assert,
-				name:   test.name,
+				c:    c,
+				name: test.name,
 			}
 
 			b := newTestSitesBuilder(t).WithSimpleConfigFile()
@@ -306,7 +306,7 @@ Some content.
 			if test.assertCreateError != nil {
 				test.assertCreateError(errorAsserter, createErr)
 			} else {
-				assert.NoError(createErr)
+				c.Assert(createErr, qt.IsNil)
 			}
 
 			if createErr == nil {
@@ -314,7 +314,7 @@ Some content.
 				if test.assertBuildError != nil {
 					test.assertBuildError(errorAsserter, buildErr)
 				} else {
-					assert.NoError(buildErr)
+					c.Assert(buildErr, qt.IsNil)
 				}
 			}
 		})

hugolib/hugo_sites_build_test.go

@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"time"
 
+	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/resources/page"
 
 	"github.com/fortytw2/leaktest"
@@ -15,7 +16,6 @@ import (
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
 )
 
 func TestMultiSitesMainLangInRoot(t *testing.T) {
@@ -26,7 +26,7 @@ func TestMultiSitesMainLangInRoot(t *testing.T) {
 }
 
 func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	siteConfig := map[string]interface{}{
 		"DefaultContentLanguage":         "fr",
@@ -49,29 +49,28 @@ func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
 	b.Build(BuildCfg{})
 
 	sites := b.H.Sites
-
-	require.Len(t, sites, 4)
+	c.Assert(len(sites), qt.Equals, 4)
 
 	enSite := sites[0]
 	frSite := sites[1]
 
-	assert.Equal("/en", enSite.Info.LanguagePrefix)
+	c.Assert(enSite.Info.LanguagePrefix, qt.Equals, "/en")
 
 	if defaultInSubDir {
-		assert.Equal("/fr", frSite.Info.LanguagePrefix)
+		c.Assert(frSite.Info.LanguagePrefix, qt.Equals, "/fr")
 	} else {
-		assert.Equal("", frSite.Info.LanguagePrefix)
+		c.Assert(frSite.Info.LanguagePrefix, qt.Equals, "")
 	}
 
-	assert.Equal("/blog/en/foo", enSite.PathSpec.RelURL("foo", true))
+	c.Assert(enSite.PathSpec.RelURL("foo", true), qt.Equals, "/blog/en/foo")
 
 	doc1en := enSite.RegularPages()[0]
 	doc1fr := frSite.RegularPages()[0]
 
 	enPerm := doc1en.Permalink()
 	enRelPerm := doc1en.RelPermalink()
-	assert.Equal("http://example.com/blog/en/sect/doc1-slug/", enPerm)
-	assert.Equal("/blog/en/sect/doc1-slug/", enRelPerm)
+	c.Assert(enPerm, qt.Equals, "http://example.com/blog/en/sect/doc1-slug/")
+	c.Assert(enRelPerm, qt.Equals, "/blog/en/sect/doc1-slug/")
 
 	frPerm := doc1fr.Permalink()
 	frRelPerm := doc1fr.RelPermalink()
@@ -80,15 +79,15 @@ func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
 	b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Single", "Hello")
 
 	if defaultInSubDir {
-		assert.Equal("http://example.com/blog/fr/sect/doc1/", frPerm)
-		assert.Equal("/blog/fr/sect/doc1/", frRelPerm)
+		c.Assert(frPerm, qt.Equals, "http://example.com/blog/fr/sect/doc1/")
+		c.Assert(frRelPerm, qt.Equals, "/blog/fr/sect/doc1/")
 
 		// should have a redirect on top level.
 		b.AssertFileContent("public/index.html", `<meta http-equiv="refresh" content="0; url=http://example.com/blog/fr" />`)
 	} else {
 		// Main language in root
-		assert.Equal("http://example.com/blog/sect/doc1/", frPerm)
-		assert.Equal("/blog/sect/doc1/", frRelPerm)
+		c.Assert(frPerm, qt.Equals, "http://example.com/blog/sect/doc1/")
+		c.Assert(frRelPerm, qt.Equals, "/blog/sect/doc1/")
 
 		// should have redirect back to root
 		b.AssertFileContent("public/fr/index.html", `<meta http-equiv="refresh" content="0; url=http://example.com/blog" />`)
@@ -154,7 +153,7 @@ func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
 func TestMultiSitesWithTwoLanguages(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 	b := newTestSitesBuilder(t).WithConfigFile("toml", `
 
 defaultContentLanguage = "nn"
@@ -179,23 +178,23 @@ p1 = "p1en"
 	b.Build(BuildCfg{SkipRender: true})
 	sites := b.H.Sites
 
-	assert.Len(sites, 2)
+	c.Assert(len(sites), qt.Equals, 2)
 
 	nnSite := sites[0]
 	nnHome := nnSite.getPage(page.KindHome)
-	assert.Len(nnHome.AllTranslations(), 2)
-	assert.Len(nnHome.Translations(), 1)
-	assert.True(nnHome.IsTranslated())
+	c.Assert(len(nnHome.AllTranslations()), qt.Equals, 2)
+	c.Assert(len(nnHome.Translations()), qt.Equals, 1)
+	c.Assert(nnHome.IsTranslated(), qt.Equals, true)
 
 	enHome := sites[1].getPage(page.KindHome)
 
 	p1, err := enHome.Param("p1")
-	assert.NoError(err)
-	assert.Equal("p1en", p1)
+	c.Assert(err, qt.IsNil)
+	c.Assert(p1, qt.Equals, "p1en")
 
 	p1, err = nnHome.Param("p1")
-	assert.NoError(err)
-	assert.Equal("p1nn", p1)
+	c.Assert(err, qt.IsNil)
+	c.Assert(p1, qt.Equals, "p1nn")
 }
 
 func TestMultiSitesBuild(t *testing.T) {
@@ -217,38 +216,38 @@ func TestMultiSitesBuild(t *testing.T) {
 }
 
 func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
-	assert := require.New(t)
+	c := qt.New(t)
 
 	b := newMultiSiteTestBuilder(t, configSuffix, configTemplate, nil)
 	b.CreateSites()
 
 	sites := b.H.Sites
-	assert.Equal(4, len(sites))
+	c.Assert(len(sites), qt.Equals, 4)
 
 	b.Build(BuildCfg{})
 
 	// Check site config
 	for _, s := range sites {
-		require.True(t, s.Info.defaultContentLanguageInSubdir, s.Info.title)
-		require.NotNil(t, s.disabledKinds)
+		c.Assert(s.Info.defaultContentLanguageInSubdir, qt.Equals, true)
+		c.Assert(s.disabledKinds, qt.Not(qt.IsNil))
 	}
 
 	gp1 := b.H.GetContentPage(filepath.FromSlash("content/sect/doc1.en.md"))
-	require.NotNil(t, gp1)
-	require.Equal(t, "doc1", gp1.Title())
+	c.Assert(gp1, qt.Not(qt.IsNil))
+	c.Assert(gp1.Title(), qt.Equals, "doc1")
 	gp2 := b.H.GetContentPage(filepath.FromSlash("content/dummysect/notfound.md"))
-	require.Nil(t, gp2)
+	c.Assert(gp2, qt.IsNil)
 
 	enSite := sites[0]
 	enSiteHome := enSite.getPage(page.KindHome)
-	require.True(t, enSiteHome.IsTranslated())
+	c.Assert(enSiteHome.IsTranslated(), qt.Equals, true)
 
-	require.Equal(t, "en", enSite.language.Lang)
+	c.Assert(enSite.language.Lang, qt.Equals, "en")
 
 	//dumpPages(enSite.RegularPages()...)
 
-	assert.Equal(5, len(enSite.RegularPages()))
-	assert.Equal(32, len(enSite.AllPages()))
+	c.Assert(len(enSite.RegularPages()), qt.Equals, 5)
+	c.Assert(len(enSite.AllPages()), qt.Equals, 32)
 
 	// Check 404s
 	b.AssertFileContent("public/en/404.html", "404|en|404 Page not found")
@@ -264,33 +263,33 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
 
 	doc2 := enSite.RegularPages()[1]
 	doc3 := enSite.RegularPages()[2]
-	require.Equal(t, doc2.Prev(), doc3, "doc3 should follow doc2, in .PrevPage")
+	c.Assert(doc3, qt.Equals, doc2.Prev())
 	doc1en := enSite.RegularPages()[0]
 	doc1fr := doc1en.Translations()[0]
 	b.AssertFileContent("public/fr/sect/doc1/index.html", "Permalink: http://example.com/blog/fr/sect/doc1/")
 
-	require.Equal(t, doc1en.Translations()[0], doc1fr, "doc1-en should have doc1-fr as translation")
-	require.Equal(t, doc1fr.Translations()[0], doc1en, "doc1-fr should have doc1-en as translation")
-	require.Equal(t, "fr", doc1fr.Language().Lang)
+	c.Assert(doc1fr, qt.Equals, doc1en.Translations()[0])
+	c.Assert(doc1en, qt.Equals, doc1fr.Translations()[0])
+	c.Assert(doc1fr.Language().Lang, qt.Equals, "fr")
 
 	doc4 := enSite.AllPages()[4]
-	require.Len(t, doc4.Translations(), 0, "found translations for doc4")
+	c.Assert(len(doc4.Translations()), qt.Equals, 0)
 
 	// Taxonomies and their URLs
-	require.Len(t, enSite.Taxonomies, 1, "should have 1 taxonomy")
+	c.Assert(len(enSite.Taxonomies), qt.Equals, 1)
 	tags := enSite.Taxonomies["tags"]
-	require.Len(t, tags, 2, "should have 2 different tags")
-	require.Equal(t, tags["tag1"][0].Page, doc1en, "first tag1 page should be doc1")
+	c.Assert(len(tags), qt.Equals, 2)
+	c.Assert(doc1en, qt.Equals, tags["tag1"][0].Page)
 
 	frSite := sites[1]
 
-	require.Equal(t, "fr", frSite.language.Lang)
-	require.Len(t, frSite.RegularPages(), 4, "should have 3 pages")
-	require.Len(t, frSite.AllPages(), 32, "should have 32 total pages (including translations and nodes)")
+	c.Assert(frSite.language.Lang, qt.Equals, "fr")
+	c.Assert(len(frSite.RegularPages()), qt.Equals, 4)
+	c.Assert(len(frSite.AllPages()), qt.Equals, 32)
 
 	for _, frenchPage := range frSite.RegularPages() {
 		p := frenchPage
-		require.Equal(t, "fr", p.Language().Lang)
+		c.Assert(p.Language().Lang, qt.Equals, "fr")
 	}
 
 	// See https://github.com/gohugoio/hugo/issues/4285
@@ -302,10 +301,10 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
 	getPageDoc1EnBase := enSite.getPage(page.KindPage, "sect/doc1")
 	getPageDoc1Fr := frSite.getPage(page.KindPage, filepath.ToSlash(doc1fr.File().Path()))
 	getPageDoc1FrBase := frSite.getPage(page.KindPage, "sect/doc1")
-	require.Equal(t, doc1en, getPageDoc1En)
-	require.Equal(t, doc1fr, getPageDoc1Fr)
-	require.Equal(t, doc1en, getPageDoc1EnBase)
-	require.Equal(t, doc1fr, getPageDoc1FrBase)
+	c.Assert(getPageDoc1En, qt.Equals, doc1en)
+	c.Assert(getPageDoc1Fr, qt.Equals, doc1fr)
+	c.Assert(getPageDoc1EnBase, qt.Equals, doc1en)
+	c.Assert(getPageDoc1FrBase, qt.Equals, doc1fr)
 
 	// Check redirect to main language, French
 	b.AssertFileContent("public/index.html", "0; url=http://example.com/blog/fr")
@@ -320,35 +319,35 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
 
 	// Check node translations
 	homeEn := enSite.getPage(page.KindHome)
-	require.NotNil(t, homeEn)
-	require.Len(t, homeEn.Translations(), 3)
-	require.Equal(t, "fr", homeEn.Translations()[0].Language().Lang)
-	require.Equal(t, "nn", homeEn.Translations()[1].Language().Lang)
-	require.Equal(t, "På nynorsk", homeEn.Translations()[1].Title())
-	require.Equal(t, "nb", homeEn.Translations()[2].Language().Lang)
-	require.Equal(t, "På bokmål", homeEn.Translations()[2].Title(), configSuffix)
-	require.Equal(t, "Bokmål", homeEn.Translations()[2].Language().LanguageName, configSuffix)
+	c.Assert(homeEn, qt.Not(qt.IsNil))
+	c.Assert(len(homeEn.Translations()), qt.Equals, 3)
+	c.Assert(homeEn.Translations()[0].Language().Lang, qt.Equals, "fr")
+	c.Assert(homeEn.Translations()[1].Language().Lang, qt.Equals, "nn")
+	c.Assert(homeEn.Translations()[1].Title(), qt.Equals, "På nynorsk")
+	c.Assert(homeEn.Translations()[2].Language().Lang, qt.Equals, "nb")
+	c.Assert(homeEn.Translations()[2].Title(), qt.Equals, "På bokmål")
+	c.Assert(homeEn.Translations()[2].Language().LanguageName, qt.Equals, "Bokmål")
 
 	sectFr := frSite.getPage(page.KindSection, "sect")
-	require.NotNil(t, sectFr)
+	c.Assert(sectFr, qt.Not(qt.IsNil))
 
-	require.Equal(t, "fr", sectFr.Language().Lang)
-	require.Len(t, sectFr.Translations(), 1)
-	require.Equal(t, "en", sectFr.Translations()[0].Language().Lang)
-	require.Equal(t, "Sects", sectFr.Translations()[0].Title())
+	c.Assert(sectFr.Language().Lang, qt.Equals, "fr")
+	c.Assert(len(sectFr.Translations()), qt.Equals, 1)
+	c.Assert(sectFr.Translations()[0].Language().Lang, qt.Equals, "en")
+	c.Assert(sectFr.Translations()[0].Title(), qt.Equals, "Sects")
 
 	nnSite := sites[2]
-	require.Equal(t, "nn", nnSite.language.Lang)
+	c.Assert(nnSite.language.Lang, qt.Equals, "nn")
 	taxNn := nnSite.getPage(page.KindTaxonomyTerm, "lag")
-	require.NotNil(t, taxNn)
-	require.Len(t, taxNn.Translations(), 1)
-	require.Equal(t, "nb", taxNn.Translations()[0].Language().Lang)
+	c.Assert(taxNn, qt.Not(qt.IsNil))
+	c.Assert(len(taxNn.Translations()), qt.Equals, 1)
+	c.Assert(taxNn.Translations()[0].Language().Lang, qt.Equals, "nb")
 
 	taxTermNn := nnSite.getPage(page.KindTaxonomy, "lag", "sogndal")
-	require.NotNil(t, taxTermNn)
-	require.Equal(t, taxTermNn, nnSite.getPage(page.KindTaxonomy, "LAG", "SOGNDAL"))
-	require.Len(t, taxTermNn.Translations(), 1)
-	require.Equal(t, "nb", taxTermNn.Translations()[0].Language().Lang)
+	c.Assert(taxTermNn, qt.Not(qt.IsNil))
+	c.Assert(nnSite.getPage(page.KindTaxonomy, "LAG", "SOGNDAL"), qt.Equals, taxTermNn)
+	c.Assert(len(taxTermNn.Translations()), qt.Equals, 1)
+	c.Assert(taxTermNn.Translations()[0].Language().Lang, qt.Equals, "nb")
 
 	// Check sitemap(s)
 	b.AssertFileContent("public/sitemap.xml",
@@ -360,54 +359,54 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
 	// Check taxonomies
 	enTags := enSite.Taxonomies["tags"]
 	frTags := frSite.Taxonomies["plaques"]
-	require.Len(t, enTags, 2, fmt.Sprintf("Tags in en: %v", enTags))
-	require.Len(t, frTags, 2, fmt.Sprintf("Tags in fr: %v", frTags))
-	require.NotNil(t, enTags["tag1"])
-	require.NotNil(t, frTags["FRtag1"])
+	c.Assert(len(enTags), qt.Equals, 2, qt.Commentf("Tags in en: %v", enTags))
+	c.Assert(len(frTags), qt.Equals, 2, qt.Commentf("Tags in fr: %v", frTags))
+	c.Assert(enTags["tag1"], qt.Not(qt.IsNil))
+	c.Assert(frTags["FRtag1"], qt.Not(qt.IsNil))
 	b.AssertFileContent("public/fr/plaques/FRtag1/index.html", "FRtag1|Bonjour|http://example.com/blog/fr/plaques/FRtag1/")
 
 	// Check Blackfriday config
-	require.True(t, strings.Contains(content(doc1fr), "&laquo;"), content(doc1fr))
-	require.False(t, strings.Contains(content(doc1en), "&laquo;"), content(doc1en))
-	require.True(t, strings.Contains(content(doc1en), "&ldquo;"), content(doc1en))
+	c.Assert(strings.Contains(content(doc1fr), "&laquo;"), qt.Equals, true)
+	c.Assert(strings.Contains(content(doc1en), "&laquo;"), qt.Equals, false)
+	c.Assert(strings.Contains(content(doc1en), "&ldquo;"), qt.Equals, true)
 
 	// en and nn have custom site menus
-	require.Len(t, frSite.Menus(), 0, "fr: "+configSuffix)
-	require.Len(t, enSite.Menus(), 1, "en: "+configSuffix)
-	require.Len(t, nnSite.Menus(), 1, "nn: "+configSuffix)
+	c.Assert(len(frSite.Menus()), qt.Equals, 0)
+	c.Assert(len(enSite.Menus()), qt.Equals, 1)
+	c.Assert(len(nnSite.Menus()), qt.Equals, 1)
 
-	require.Equal(t, "Home", enSite.Menus()["main"].ByName()[0].Name)
-	require.Equal(t, "Heim", nnSite.Menus()["main"].ByName()[0].Name)
+	c.Assert(enSite.Menus()["main"].ByName()[0].Name, qt.Equals, "Home")
+	c.Assert(nnSite.Menus()["main"].ByName()[0].Name, qt.Equals, "Heim")
 
 	// Issue #3108
 	prevPage := enSite.RegularPages()[0].Prev()
-	require.NotNil(t, prevPage)
-	require.Equal(t, page.KindPage, prevPage.Kind())
+	c.Assert(prevPage, qt.Not(qt.IsNil))
+	c.Assert(prevPage.Kind(), qt.Equals, page.KindPage)
 
 	for {
 		if prevPage == nil {
 			break
 		}
-		require.Equal(t, page.KindPage, prevPage.Kind())
+		c.Assert(prevPage.Kind(), qt.Equals, page.KindPage)
 		prevPage = prevPage.Prev()
 	}
 
 	// Check bundles
 	b.AssertFileContent("public/fr/bundles/b1/index.html", "RelPermalink: /blog/fr/bundles/b1/|")
 	bundleFr := frSite.getPage(page.KindPage, "bundles/b1/index.md")
-	require.NotNil(t, bundleFr)
-	require.Equal(t, 1, len(bundleFr.Resources()))
+	c.Assert(bundleFr, qt.Not(qt.IsNil))
+	c.Assert(len(bundleFr.Resources()), qt.Equals, 1)
 	logoFr := bundleFr.Resources().GetMatch("logo*")
-	require.NotNil(t, logoFr)
+	c.Assert(logoFr, qt.Not(qt.IsNil))
 	b.AssertFileContent("public/fr/bundles/b1/index.html", "Resources: image/png: /blog/fr/bundles/b1/logo.png")
 	b.AssertFileContent("public/fr/bundles/b1/logo.png", "PNG Data")
 
 	bundleEn := enSite.getPage(page.KindPage, "bundles/b1/index.en.md")
-	require.NotNil(t, bundleEn)
+	c.Assert(bundleEn, qt.Not(qt.IsNil))
 	b.AssertFileContent("public/en/bundles/b1/index.html", "RelPermalink: /blog/en/bundles/b1/|")
-	require.Equal(t, 1, len(bundleEn.Resources()))
+	c.Assert(len(bundleEn.Resources()), qt.Equals, 1)
 	logoEn := bundleEn.Resources().GetMatch("logo*")
-	require.NotNil(t, logoEn)
+	c.Assert(logoEn, qt.Not(qt.IsNil))
 	b.AssertFileContent("public/en/bundles/b1/index.html", "Resources: image/png: /blog/en/bundles/b1/logo.png")
 	b.AssertFileContent("public/en/bundles/b1/logo.png", "PNG Data")
 
@@ -420,7 +419,7 @@ func TestMultiSitesRebuild(t *testing.T) {
 		defer leaktest.CheckTimeout(t, 10*time.Second)()
 	}
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	b := newMultiSiteTestDefaultBuilder(t).Running().CreateSites().Build(BuildCfg{})
 
@@ -432,8 +431,8 @@ func TestMultiSitesRebuild(t *testing.T) {
 	enSite := sites[0]
 	frSite := sites[1]
 
-	assert.Len(enSite.RegularPages(), 5)
-	assert.Len(frSite.RegularPages(), 4)
+	c.Assert(len(enSite.RegularPages()), qt.Equals, 5)
+	c.Assert(len(frSite.RegularPages()), qt.Equals, 4)
 
 	// Verify translations
 	b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Hello")
@@ -444,8 +443,8 @@ func TestMultiSitesRebuild(t *testing.T) {
 	b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Single", "Shortcode: Hello")
 
 	homeEn := enSite.getPage(page.KindHome)
-	require.NotNil(t, homeEn)
-	assert.Len(homeEn.Translations(), 3)
+	c.Assert(homeEn, qt.Not(qt.IsNil))
+	c.Assert(len(homeEn.Translations()), qt.Equals, 3)
 
 	contentFs := b.H.Fs.Source
 
@@ -467,7 +466,7 @@ func TestMultiSitesRebuild(t *testing.T) {
 			},
 			[]fsnotify.Event{{Name: filepath.FromSlash("content/sect/doc2.en.md"), Op: fsnotify.Remove}},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 4, "1 en removed")
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 4, qt.Commentf("1 en removed"))
 
 			},
 		},
@@ -483,15 +482,15 @@ func TestMultiSitesRebuild(t *testing.T) {
 				{Name: filepath.FromSlash("content/new1.fr.md"), Op: fsnotify.Create},
 			},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6)
-				assert.Len(enSite.AllPages(), 34)
-				assert.Len(frSite.RegularPages(), 5)
-				require.Equal(t, "new_fr_1", frSite.RegularPages()[3].Title())
-				require.Equal(t, "new_en_2", enSite.RegularPages()[0].Title())
-				require.Equal(t, "new_en_1", enSite.RegularPages()[1].Title())
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
+				c.Assert(len(enSite.AllPages()), qt.Equals, 34)
+				c.Assert(len(frSite.RegularPages()), qt.Equals, 5)
+				c.Assert(frSite.RegularPages()[3].Title(), qt.Equals, "new_fr_1")
+				c.Assert(enSite.RegularPages()[0].Title(), qt.Equals, "new_en_2")
+				c.Assert(enSite.RegularPages()[1].Title(), qt.Equals, "new_en_1")
 
 				rendered := readDestination(t, fs, "public/en/new1/index.html")
-				require.True(t, strings.Contains(rendered, "new_en_1"), rendered)
+				c.Assert(strings.Contains(rendered, "new_en_1"), qt.Equals, true)
 			},
 		},
 		{
@@ -503,9 +502,9 @@ func TestMultiSitesRebuild(t *testing.T) {
 			},
 			[]fsnotify.Event{{Name: filepath.FromSlash("content/sect/doc1.en.md"), Op: fsnotify.Write}},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6)
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
 				doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
-				require.True(t, strings.Contains(doc1, "CHANGED"), doc1)
+				c.Assert(strings.Contains(doc1, "CHANGED"), qt.Equals, true)
 
 			},
 		},
@@ -521,10 +520,10 @@ func TestMultiSitesRebuild(t *testing.T) {
 				{Name: filepath.FromSlash("content/new1.en.md"), Op: fsnotify.Rename},
 			},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6, "Rename")
-				require.Equal(t, "new_en_1", enSite.RegularPages()[1].Title())
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6, qt.Commentf("Rename"))
+				c.Assert(enSite.RegularPages()[1].Title(), qt.Equals, "new_en_1")
 				rendered := readDestination(t, fs, "public/en/new1renamed/index.html")
-				require.True(t, strings.Contains(rendered, "new_en_1"), rendered)
+				c.Assert(rendered, qt.Contains, "new_en_1")
 			}},
 		{
 			// Change a template
@@ -536,11 +535,11 @@ func TestMultiSitesRebuild(t *testing.T) {
 			},
 			[]fsnotify.Event{{Name: filepath.FromSlash("layouts/_default/single.html"), Op: fsnotify.Write}},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6)
-				assert.Len(enSite.AllPages(), 34)
-				assert.Len(frSite.RegularPages(), 5)
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
+				c.Assert(len(enSite.AllPages()), qt.Equals, 34)
+				c.Assert(len(frSite.RegularPages()), qt.Equals, 5)
 				doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
-				require.True(t, strings.Contains(doc1, "Template Changed"), doc1)
+				c.Assert(strings.Contains(doc1, "Template Changed"), qt.Equals, true)
 			},
 		},
 		{
@@ -553,18 +552,18 @@ func TestMultiSitesRebuild(t *testing.T) {
 			},
 			[]fsnotify.Event{{Name: filepath.FromSlash("i18n/fr.yaml"), Op: fsnotify.Write}},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6)
-				assert.Len(enSite.AllPages(), 34)
-				assert.Len(frSite.RegularPages(), 5)
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
+				c.Assert(len(enSite.AllPages()), qt.Equals, 34)
+				c.Assert(len(frSite.RegularPages()), qt.Equals, 5)
 				docEn := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
-				require.True(t, strings.Contains(docEn, "Hello"), "No Hello")
+				c.Assert(strings.Contains(docEn, "Hello"), qt.Equals, true)
 				docFr := readDestination(t, fs, "public/fr/sect/doc1/index.html")
-				require.True(t, strings.Contains(docFr, "Salut"), "No Salut")
+				c.Assert(strings.Contains(docFr, "Salut"), qt.Equals, true)
 
 				homeEn := enSite.getPage(page.KindHome)
-				require.NotNil(t, homeEn)
-				assert.Len(homeEn.Translations(), 3)
-				require.Equal(t, "fr", homeEn.Translations()[0].Language().Lang)
+				c.Assert(homeEn, qt.Not(qt.IsNil))
+				c.Assert(len(homeEn.Translations()), qt.Equals, 3)
+				c.Assert(homeEn.Translations()[0].Language().Lang, qt.Equals, "fr")
 
 			},
 		},
@@ -577,9 +576,9 @@ func TestMultiSitesRebuild(t *testing.T) {
 				{Name: filepath.FromSlash("layouts/shortcodes/shortcode.html"), Op: fsnotify.Write},
 			},
 			func(t *testing.T) {
-				assert.Len(enSite.RegularPages(), 6)
-				assert.Len(enSite.AllPages(), 34)
-				assert.Len(frSite.RegularPages(), 5)
+				c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
+				c.Assert(len(enSite.AllPages()), qt.Equals, 34)
+				c.Assert(len(frSite.RegularPages()), qt.Equals, 5)
 				b.AssertFileContent("public/fr/sect/doc1/index.html", "Single", "Modified Shortcode: Salut")
 				b.AssertFileContent("public/en/sect/doc1-slug/index.html", "Single", "Modified Shortcode: Hello")
 			},
@@ -781,24 +780,24 @@ categories: ["mycat"]
 	} {
 
 		t.Run(path, func(t *testing.T) {
-			assert := require.New(t)
+			c := qt.New(t)
 
 			s1, _ := b.H.Sites[0].getPageNew(nil, path)
 			s2, _ := b.H.Sites[1].getPageNew(nil, path)
 
-			assert.NotNil(s1)
-			assert.NotNil(s2)
+			c.Assert(s1, qt.Not(qt.IsNil))
+			c.Assert(s2, qt.Not(qt.IsNil))
 
-			assert.Equal(1, len(s1.Translations()))
-			assert.Equal(1, len(s2.Translations()))
-			assert.Equal(s2, s1.Translations()[0])
-			assert.Equal(s1, s2.Translations()[0])
+			c.Assert(len(s1.Translations()), qt.Equals, 1)
+			c.Assert(len(s2.Translations()), qt.Equals, 1)
+			c.Assert(s1.Translations()[0], qt.Equals, s2)
+			c.Assert(s2.Translations()[0], qt.Equals, s1)
 
 			m1 := s1.Translations().MergeByLanguage(s2.Translations())
 			m2 := s2.Translations().MergeByLanguage(s1.Translations())
 
-			assert.Equal(1, len(m1))
-			assert.Equal(1, len(m2))
+			c.Assert(len(m1), qt.Equals, 1)
+			c.Assert(len(m2), qt.Equals, 1)
 		})
 
 	}

hugolib/hugo_sites_multihost_test.go

@@ -5,13 +5,13 @@ import (
 
 	"github.com/gohugoio/hugo/resources/page"
 
-	"github.com/stretchr/testify/require"
+	qt "github.com/frankban/quicktest"
 )
 
 func TestMultihosts(t *testing.T) {
 	t.Parallel()
 
-	assert := require.New(t)
+	c := qt.New(t)
 
 	var configTemplate = `
 paginate = 1
@@ -58,9 +58,9 @@ languageName = "Nynorsk"
 	s1 := b.H.Sites[0]
 
 	s1h := s1.getPage(page.KindHome)
-	assert.True(s1h.IsTranslated())
-	assert.Len(s1h.Translations(), 2)
-	assert.Equal("https://example.com/docs/", s1h.Permalink())
+	c.Assert(s1h.IsTranslated(), qt.Equals, true)
+	c.Assert(len(s1h.Translations()), qt.Equals, 2)
+	c.Assert(s1h.Permalink(), qt.Equals, "https://example.com/docs/")
 
 	// For “regular multilingual” we kept the aliases pages with url in front matter
 	// as a literal value that we use as is.
@@ -69,8 +69,8 @@ languageName = "Nynorsk"
 	//
 	// check url in front matter:
 	pageWithURLInFrontMatter := s1.getPage(page.KindPage, "sect/doc3.en.md")
-	assert.NotNil(pageWithURLInFrontMatter)
-	assert.Equal("/docs/superbob/", pageWithURLInFrontMatter.RelPermalink())
+	c.Assert(pageWithURLInFrontMatter, qt.Not(qt.IsNil))
+	c.Assert(pageWithURLInFrontMatter.RelPermalink(), qt.Equals, "/docs/superbob/")
 	b.AssertFileContent("public/en/superbob/index.html", "doc3|Hello|en")
 
 	// check alias:
@@ -80,7 +80,7 @@ languageName = "Nynorsk"
 	s2 := b.H.Sites[1]
 
 	s2h := s2.getPage(page.KindHome)
-	assert.Equal("https://example.fr/", s2h.Permalink())
+	c.Assert(s2h.Permalink(), qt.Equals, "https://example.fr/")
 
 	b.AssertFileContent("public/fr/index.html", "French Home Page", "String Resource: /docs/text/pipes.txt")
 	b.AssertFileContent("public/fr/text/pipes.txt", "Hugo Pipes")
@@ -96,17 +96,17 @@ languageName = "Nynorsk"
 	// Check bundles
 
 	bundleEn := s1.getPage(page.KindPage, "bundles/b1/index.en.md")
-	require.NotNil(t, bundleEn)
-	require.Equal(t, "/docs/bundles/b1/", bundleEn.RelPermalink())
-	require.Equal(t, 1, len(bundleEn.Resources()))
+	c.Assert(bundleEn, qt.Not(qt.IsNil))
+	c.Assert(bundleEn.RelPermalink(), qt.Equals, "/docs/bundles/b1/")
+	c.Assert(len(bundleEn.Resources()), qt.Equals, 1)
 
 	b.AssertFileContent("public/en/bundles/b1/logo.png", "PNG Data")
 	b.AssertFileContent("public/en/bundles/b1/index.html", " image/png: /docs/bundles/b1/logo.png")
 
 	bundleFr := s2.getPage(page.KindPage, "bundles/b1/index.md")
-	require.NotNil(t, bundleFr)
-	require.Equal(t, "/bundles/b1/", bundleFr.RelPermalink())
-	require.Equal(t, 1, len(bundleFr.Resources()))
+	c.Assert(bundleFr, qt.Not(qt.IsNil))
+	c.Assert(bundleFr.RelPermalink(), qt.Equals, "/bundles/b1/")
+	c.Assert(len(bundleFr.Resources()), qt.Equals, 1)
 	b.AssertFileContent("public/fr/bundles/b1/logo.png", "PNG Data")
 	b.AssertFileContent("public/fr/bundles/b1/index.html", " image/png: /bundles/b1/logo.png")
 

hugolib/hugo_smoke_test.go

@@ -18,13 +18,13 @@ import (
 	"strings"