Use required.NoError for faster failure in tests

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

10 files changed, 110 insertions, 100 deletions

diff --git a/funcs/base64_test.go b/funcs/base64_test.go
index 54cd993b..de02bdaa 100644
--- a/funcs/base64_test.go
+++ b/funcs/base64_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateBase64Funcs(t *testing.T) {
@@ -45,7 +46,7 @@ func TestBase64DecodeBytes(t *testing.T) {
 
 	bf := &Base64Funcs{}
 	out, err := bf.DecodeBytes("Zm9vYmFy")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foobar", string(out))
 }
 
diff --git a/funcs/coll_test.go b/funcs/coll_test.go
index 96bb9248..3139f1ec 100644
--- a/funcs/coll_test.go
+++ b/funcs/coll_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateCollFuncs(t *testing.T) {
@@ -38,11 +39,11 @@ func TestFlatten(t *testing.T) {
 	assert.Error(t, err)
 
 	out, err := c.Flatten([]interface{}{1, []interface{}{[]int{2}, 3}})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []interface{}{1, 2, 3}, out)
 
 	out, err = c.Flatten(1, []interface{}{1, []interface{}{[]int{2}, 3}})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []interface{}{1, []int{2}, 3}, out)
 }
 
@@ -72,7 +73,7 @@ func TestPick(t *testing.T) {
 		"":    "baz",
 	}
 	out, err := c.Pick("baz", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, map[string]interface{}{}, out)
 
 	expected := map[string]interface{}{
@@ -80,18 +81,18 @@ func TestPick(t *testing.T) {
 		"bar": true,
 	}
 	out, err = c.Pick("foo", "bar", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 
 	expected = map[string]interface{}{
 		"": "baz",
 	}
 	out, err = c.Pick("", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 
 	out, err = c.Pick("foo", "bar", "", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, in, out)
 }
 
@@ -121,7 +122,7 @@ func TestOmit(t *testing.T) {
 		"":    "baz",
 	}
 	out, err := c.Omit("baz", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, in, out)
 
 	expected := map[string]interface{}{
@@ -129,18 +130,18 @@ func TestOmit(t *testing.T) {
 		"bar": true,
 	}
 	out, err = c.Omit("", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 
 	expected = map[string]interface{}{
 		"": "baz",
 	}
 	out, err = c.Omit("foo", "bar", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 
 	out, err = c.Omit("foo", "bar", "", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, map[string]interface{}{}, out)
 }
 
@@ -165,14 +166,14 @@ func TestGoSlice(t *testing.T) {
 	// valid slice, no slicing
 	in = reflect.ValueOf([]int{1})
 	out, err := c.GoSlice(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, reflect.TypeOf([]int{}), out.Type())
 	assert.EqualValues(t, []int{1}, out.Interface())
 
 	// valid slice, slicing
 	in = reflect.ValueOf([]string{"foo", "bar", "baz"})
 	out, err = c.GoSlice(in, reflect.ValueOf(1), reflect.ValueOf(3))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, reflect.TypeOf([]string{}), out.Type())
 	assert.EqualValues(t, []string{"bar", "baz"}, out.Interface())
 }
diff --git a/funcs/crypto_test.go b/funcs/crypto_test.go
index a2480498..163fbd55 100644
--- a/funcs/crypto_test.go
+++ b/funcs/crypto_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/hairyhenderson/gomplate/v4/internal/config"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateCryptoFuncs(t *testing.T) {
@@ -35,11 +36,11 @@ func TestPBKDF2(t *testing.T) {
 	c := testCryptoNS()
 	dk, err := c.PBKDF2("password", []byte("IEEE"), "4096", 32)
 	assert.Equal(t, "f42c6fc52df0ebef9ebb4b90b38a5f902e83fe1b135a70e23aed762e9710a12e", dk)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dk, err = c.PBKDF2([]byte("password"), "IEEE", 4096, "64", "SHA-512")
 	assert.Equal(t, "c16f4cb6d03e23614399dee5e7f676fb1da0eb9471b6a74a6c5bc934c6ec7d2ab7028fbb1000b1beb97f17646045d8144792352f6676d13b20a4c03754903d7e", dk)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = c.PBKDF2(nil, nil, nil, nil, "bogus")
 	assert.Error(t, err)
@@ -51,7 +52,7 @@ func TestWPAPSK(t *testing.T) {
 	c := testCryptoNS()
 	dk, err := c.WPAPSK("password", "MySSID")
 	assert.Equal(t, "3a98def84b11644a17ebcc9b17955d2360ce8b8a85b8a78413fc551d722a84e7", dk)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestSHA(t *testing.T) {
@@ -89,7 +90,7 @@ func TestBcrypt(t *testing.T) {
 		t.Parallel()
 
 		actual, err := c.Bcrypt(in)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, strings.HasPrefix(actual, "$2a$10$"))
 	})
 
@@ -97,7 +98,7 @@ func TestBcrypt(t *testing.T) {
 		t.Parallel()
 
 		actual, err := c.Bcrypt(0, in)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, strings.HasPrefix(actual, "$2a$10$"))
 	})
 
@@ -105,7 +106,7 @@ func TestBcrypt(t *testing.T) {
 		t.Parallel()
 
 		actual, err := c.Bcrypt(4, in)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, strings.HasPrefix(actual, "$2a$04$"))
 	})
 
@@ -128,7 +129,7 @@ func TestRSAGenerateKey(t *testing.T) {
 	assert.Error(t, err)
 
 	key, err := c.RSAGenerateKey(2048)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, strings.HasPrefix(key,
 		"-----BEGIN RSA PRIVATE KEY-----"))
 	assert.True(t, strings.HasSuffix(key,
@@ -144,7 +145,7 @@ func TestECDSAGenerateKey(t *testing.T) {
 	assert.Error(t, err)
 
 	key, err := c.ECDSAGenerateKey("P-256")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, strings.HasPrefix(key,
 		"-----BEGIN EC PRIVATE KEY-----"))
 	assert.True(t, strings.HasSuffix(key,
@@ -159,7 +160,7 @@ func TestECDSADerivePublicKey(t *testing.T) {
 
 	key, _ := c.ECDSAGenerateKey("P-256")
 	pub, err := c.ECDSADerivePublicKey(key)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, strings.HasPrefix(pub,
 		"-----BEGIN PUBLIC KEY-----"))
 	assert.True(t, strings.HasSuffix(pub,
@@ -175,20 +176,20 @@ func TestRSACrypt(t *testing.T) {
 
 	c := testCryptoNS()
 	key, err := c.RSAGenerateKey()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	pub, err := c.RSADerivePublicKey(key)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	in := "hello world"
 	enc, err := c.RSAEncrypt(pub, in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dec, err := c.RSADecrypt(key, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, in, dec)
 
 	b, err := c.RSADecryptBytes(key, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, dec, string(b))
 }
 
@@ -204,24 +205,24 @@ func TestAESCrypt(t *testing.T) {
 	assert.Error(t, err)
 
 	enc, err := c.EncryptAES(key, in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dec, err := c.DecryptAES(key, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, in, dec)
 
 	b, err := c.DecryptAESBytes(key, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, dec, string(b))
 
 	enc, err = c.EncryptAES(key, 128, in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	dec, err = c.DecryptAES(key, 128, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, in, dec)
 
 	b, err = c.DecryptAESBytes(key, 128, enc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, dec, string(b))
 }
diff --git a/funcs/file_test.go b/funcs/file_test.go
index 372d00d8..d36f7f65 100644
--- a/funcs/file_test.go
+++ b/funcs/file_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateFileFuncs(t *testing.T) {
@@ -75,6 +76,6 @@ func TestFileWalk(t *testing.T) {
 
 	actualPaths, err := ff.Walk(string(filepath.Separator) + "tmp")
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expectedPaths, actualPaths)
 }
diff --git a/funcs/random_test.go b/funcs/random_test.go
index f32641c3..00f0042a 100644
--- a/funcs/random_test.go
+++ b/funcs/random_test.go
@@ -7,6 +7,7 @@ import (
 	"unicode/utf8"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateRandomFuncs(t *testing.T) {
@@ -31,11 +32,11 @@ func TestASCII(t *testing.T) {
 
 	f := RandomFuncs{}
 	s, err := f.ASCII(0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, s)
 
 	s, err = f.ASCII(100)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, s, 100)
 	assert.Regexp(t, "^[[:print:]]*$", s)
 }
@@ -49,11 +50,11 @@ func TestAlpha(t *testing.T) {
 
 	f := RandomFuncs{}
 	s, err := f.Alpha(0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, s)
 
 	s, err = f.Alpha(100)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, s, 100)
 	assert.Regexp(t, "^[[:alpha:]]*$", s)
 }
@@ -67,11 +68,11 @@ func TestAlphaNum(t *testing.T) {
 
 	f := RandomFuncs{}
 	s, err := f.AlphaNum(0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, s)
 
 	s, err = f.AlphaNum(100)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, s, 100)
 	assert.Regexp(t, "^[[:alnum:]]*$", s)
 }
@@ -80,7 +81,7 @@ func TestToCodePoints(t *testing.T) {
 	t.Parallel()
 
 	l, u, err := toCodePoints("a", "b")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 'a', l)
 	assert.Equal(t, 'b', u)
 
@@ -91,17 +92,17 @@ func TestToCodePoints(t *testing.T) {
 	assert.Error(t, err)
 
 	l, u, err = toCodePoints("0xD700", "0x0001FFFF")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, '\ud700', l)
 	assert.Equal(t, '\U0001ffff', u)
 
 	l, u, err = toCodePoints("0011", "0777")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, rune(0011), l)
 	assert.Equal(t, rune(0777), u)
 
 	l, u, err = toCodePoints("♬", "♟")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, rune(0x266C), l)
 	assert.Equal(t, '♟', u)
 }
@@ -115,38 +116,38 @@ func TestString(t *testing.T) {
 
 	f := RandomFuncs{}
 	out, err := f.String(1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, out, 1)
 
 	out, err = f.String(42)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, out, 42)
 
 	_, err = f.String(0)
 	assert.Error(t, err)
 
 	out, err = f.String(8, "[a-z]")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, "^[a-z]{8}$", out)
 
 	out, err = f.String(10, 0x23, 0x26)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, "^[#$%&]{10}$", out)
 
 	out, err = f.String(8, '\U0001f062', '\U0001f093')
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, "^[🁢-🂓]{8}$", out)
 
 	out, err = f.String(8, '\U0001f062', '\U0001f093')
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, "^[🁢-🂓]{8}$", out)
 
 	out, err = f.String(8, "♚", "♟")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, "^[♚-♟]{8}$", out)
 
 	out, err = f.String(100, "♠", "♣")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 100, utf8.RuneCountInString(out))
 	assert.Regexp(t, "^[♠-♣]{100}$", out)
 }
@@ -162,14 +163,14 @@ func TestItem(t *testing.T) {
 	assert.Error(t, err)
 
 	i, err := f.Item([]string{"foo"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foo", i)
 
 	in := []string{"foo", "bar"}
 	got := ""
 	for j := 0; j < 10; j++ {
 		i, err = f.Item(in)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		got += i.(string)
 	}
 	assert.NotEqual(t, "foofoofoofoofoofoofoofoofoofoo", got)
@@ -181,22 +182,22 @@ func TestNumber(t *testing.T) {
 
 	f := RandomFuncs{}
 	n, err := f.Number()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, 0 <= n && n <= 100, n)
 
 	_, err = f.Number(-1)
 	assert.Error(t, err)
 
 	n, err = f.Number(0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(0), n)
 
 	n, err = f.Number(9, 9)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(9), n)
 
 	n, err = f.Number(-10, -10)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(-10), n)
 }
 
@@ -205,18 +206,18 @@ func TestFloat(t *testing.T) {
 
 	f := RandomFuncs{}
 	n, err := f.Float()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.InDelta(t, 0.5, n, 0.5)
 
 	n, err = f.Float(0.5)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.InDelta(t, 0.25, n, 0.25)
 
 	n, err = f.Float(490, 500)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.InDelta(t, 495, n, 5)
 
 	n, err = f.Float(-500, 500)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.InDelta(t, 0, n, 500)
 }
diff --git a/funcs/regexp_test.go b/funcs/regexp_test.go
index cf7852d6..4e133bb3 100644
--- a/funcs/regexp_test.go
+++ b/funcs/regexp_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateReFuncs(t *testing.T) {
@@ -44,18 +45,18 @@ func TestFind(t *testing.T) {
 
 	re := &ReFuncs{}
 	f, err := re.Find(`[a-z]+`, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foo", f)
 
 	_, err = re.Find(`[a-`, "")
 	assert.Error(t, err)
 
 	f, err = re.Find("4", 42)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "4", f)
 
 	f, err = re.Find(false, 42)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "", f)
 }
 
@@ -64,11 +65,11 @@ func TestFindAll(t *testing.T) {
 
 	re := &ReFuncs{}
 	f, err := re.FindAll(`[a-z]+`, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.FindAll(`[a-z]+`, -1, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.FindAll(`[a-`, "")
@@ -81,19 +82,19 @@ func TestFindAll(t *testing.T) {
 	assert.Error(t, err)
 
 	f, err = re.FindAll(`[a-z]+`, 0, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, f)
 
 	f, err = re.FindAll(`[a-z]+`, 2, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar"}, f)
 
 	f, err = re.FindAll(`[a-z]+`, 14, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.FindAll(`qux`, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, f)
 }
 
@@ -102,11 +103,11 @@ func TestSplit(t *testing.T) {
 
 	re := &ReFuncs{}
 	f, err := re.Split(` `, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.Split(`\s+`, -1, `foo  bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.Split(`[a-`, "")
@@ -119,19 +120,19 @@ func TestSplit(t *testing.T) {
 	assert.Error(t, err)
 
 	f, err = re.Split(` `, 0, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, f)
 
 	f, err = re.Split(`\s+`, 2, `foo bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar baz"}, f)
 
 	f, err = re.Split(`\s`, 14, `foo  bar baz`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "", "bar", "baz"}, f)
 
 	f, err = re.Split(`[\s,.]`, 14, `foo bar.baz,qux`)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"foo", "bar", "baz", "qux"}, f)
 }
 
@@ -140,6 +141,6 @@ func TestReplaceLiteral(t *testing.T) {
 
 	re := &ReFuncs{}
 	r, err := re.ReplaceLiteral("i", "ello$1", "hi world")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "hello$1 world", r)
 }
diff --git a/funcs/strings_test.go b/funcs/strings_test.go
index 9da5299e..e3ce4edb 100644
--- a/funcs/strings_test.go
+++ b/funcs/strings_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateStringFuncs(t *testing.T) {
@@ -53,7 +54,7 @@ func TestIndent(t *testing.T) {
 
 	for _, d := range testdata {
 		out, err := sf.Indent(d.args...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, d.out, out)
 	}
 }
@@ -108,15 +109,15 @@ func TestAbbrev(t *testing.T) {
 	assert.Error(t, err)
 
 	s, err := sf.Abbrev(3, "foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foo", s)
 
 	s, err = sf.Abbrev(2, 6, "foobar")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foobar", s)
 
 	s, err = sf.Abbrev(6, 9, "foobarbazquxquux")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "...baz...", s)
 }
 
@@ -230,26 +231,26 @@ func TestRuneCount(t *testing.T) {
 	sf := &StringFuncs{}
 
 	n, err := sf.RuneCount("")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, n)
 
 	n, err = sf.RuneCount("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 3, n)
 
 	n, err = sf.RuneCount("foo", "bar")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 6, n)
 
 	n, err = sf.RuneCount(42, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 6, n)
 
 	n, err = sf.RuneCount("😂\U0001F602")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 2, n)
 
 	n, err = sf.RuneCount("\U0001F600", 3.14)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 5, n)
 }
diff --git a/funcs/test_test.go b/funcs/test_test.go
index 2bcd7039..91cb5c95 100644
--- a/funcs/test_test.go
+++ b/funcs/test_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateTestFuncs(t *testing.T) {
@@ -33,10 +34,10 @@ func TestAssert(t *testing.T) {
 	assert.Error(t, err)
 
 	_, err = f.Assert(true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = f.Assert("foo", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = f.Assert("foo", "false")
 	assert.EqualError(t, err, "assertion failed: foo")
@@ -79,11 +80,11 @@ func TestRequired(t *testing.T) {
 	assert.Nil(t, v)
 
 	v, err = f.Required(0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v, 0)
 
 	v, err = f.Required("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v, "foo")
 }
 
diff --git a/funcs/time_test.go b/funcs/time_test.go
index 08a9d195..f77de1f3 100644
--- a/funcs/time_test.go
+++ b/funcs/time_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateTimeFuncs(t *testing.T) {
@@ -77,5 +78,5 @@ func TestParseNum(t *testing.T) {
 	i, f, err = parseNum(nil)
 	assert.Zero(t, i)
 	assert.Zero(t, f)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
diff --git a/funcs/uuid_test.go b/funcs/uuid_test.go
index 88ef52b5..42e497c7 100644
--- a/funcs/uuid_test.go
+++ b/funcs/uuid_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateUUIDFuncs(t *testing.T) {
@@ -36,7 +37,7 @@ func TestV1(t *testing.T) {
 
 	u := UUIDNS()
 	i, err := u.V1()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, uuidV1Pattern, i)
 }
 
@@ -45,7 +46,7 @@ func TestV4(t *testing.T) {
 
 	u := UUIDNS()
 	i, err := u.V4()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Regexp(t, uuidV4Pattern, i)
 }
 
@@ -54,7 +55,7 @@ func TestNil(t *testing.T) {
 
 	u := UUIDNS()
 	i, err := u.Nil()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "00000000-0000-0000-0000-000000000000", i)
 }
 
@@ -64,12 +65,12 @@ func TestIsValid(t *testing.T) {
 	u := UUIDNS()
 	in := interface{}(false)
 	i, err := u.IsValid(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, i)
 
 	in = 12345
 	i, err = u.IsValid(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, i)
 
 	testdata := []interface{}{
@@ -81,7 +82,7 @@ func TestIsValid(t *testing.T) {
 
 	for _, d := range testdata {
 		i, err = u.IsValid(d)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.True(t, i)
 	}
 }
@@ -109,7 +110,7 @@ func TestParse(t *testing.T) {
 
 	for _, d := range testdata {
 		uid, err := u.Parse(d)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, in, uid.String())
 	}
 }