diff --git a/conv/convert_format_test.go b/conv/convert_format_test.go
index 07c07e6e..bafdfdfc 100644
--- a/conv/convert_format_test.go
+++ b/conv/convert_format_test.go
@@ -35,18 +35,18 @@ func TestConvertBool(t *testing.T) {
 	for k := range evaluatesAsTrue {
 		r, err := ConvertBool(k)
 		require.NoError(t, err)
-		assert.True(t, r)
+		assert.TrueT(t, r)
 	}
 	for _, k := range []string{"a", "", "0", "false", "unchecked", "anythingElse"} {
 		r, err := ConvertBool(k)
 		require.NoError(t, err)
-		assert.False(t, r)
+		assert.FalseT(t, r)
 	}
 }
 
 func TestFormatBool(t *testing.T) {
-	assert.Equal(t, "true", FormatBool(true))
-	assert.Equal(t, "false", FormatBool(false))
+	assert.EqualT(t, "true", FormatBool(true))
+	assert.EqualT(t, "false", FormatBool(false))
 }
 
 func TestConvertFloat(t *testing.T) {
@@ -58,11 +58,11 @@ func TestConvertFloat(t *testing.T) {
 			str := FormatFloat(f)
 			c1, err := ConvertFloat32(str)
 			require.NoError(t, err)
-			assert.InDelta(t, f, c1, 1e-6)
+			assert.InDeltaT(t, f, c1, 1e-6)
 
 			c2, err := ConvertFloat[float32](str)
 			require.NoError(t, err)
-			assert.InDelta(t, c1, c2, 1e-6)
+			assert.InDeltaT(t, c1, c2, 1e-6)
 		}
 
 		for _, f := range invalidFloats {
@@ -82,11 +82,11 @@ func TestConvertFloat(t *testing.T) {
 			str := FormatFloat(f)
 			c1, err := ConvertFloat64(str)
 			require.NoError(t, err)
-			assert.InDelta(t, f, c1, 1e-6)
+			assert.InDeltaT(t, f, c1, 1e-6)
 
 			c2, err := ConvertFloat64(str)
 			require.NoError(t, err)
-			assert.InDelta(t, c1, c2, 1e-6)
+			assert.InDeltaT(t, c1, c2, 1e-6)
 		}
 
 		for _, f := range invalidFloats {
@@ -108,11 +108,11 @@ func TestConvertInteger(t *testing.T) {
 			str := FormatInteger(f)
 			c1, err := ConvertInt8(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertInteger[int8](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidInts {
@@ -132,11 +132,11 @@ func TestConvertInteger(t *testing.T) {
 			str := FormatInteger(f)
 			c1, err := ConvertInt16(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertInteger[int16](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidInts {
@@ -156,11 +156,11 @@ func TestConvertInteger(t *testing.T) {
 			str := FormatInteger(f)
 			c1, err := ConvertInt32(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertInteger[int32](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidInts {
@@ -180,11 +180,11 @@ func TestConvertInteger(t *testing.T) {
 			str := FormatInteger(f)
 			c1, err := ConvertInt64(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertInt64(str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidInts {
@@ -206,11 +206,11 @@ func TestConvertUinteger(t *testing.T) {
 			str := FormatUinteger(f)
 			c1, err := ConvertUint8(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertUinteger[uint8](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidInts {
@@ -230,11 +230,11 @@ func TestConvertUinteger(t *testing.T) {
 			str := FormatUinteger(f)
 			c1, err := ConvertUint16(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertUinteger[uint16](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidUints {
@@ -254,11 +254,11 @@ func TestConvertUinteger(t *testing.T) {
 			str := FormatUinteger(f)
 			c1, err := ConvertUint32(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertUint32(str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 
 		for _, f := range invalidUints {
@@ -278,11 +278,11 @@ func TestConvertUinteger(t *testing.T) {
 			str := FormatUinteger(f)
 			c1, err := ConvertUint64(str)
 			require.NoError(t, err)
-			assert.Equal(t, f, c1)
+			assert.EqualT(t, f, c1)
 
 			c2, err := ConvertUinteger[uint64](str)
 			require.NoError(t, err)
-			assert.Equal(t, c1, c2)
+			assert.EqualT(t, c1, c2)
 		}
 		for _, f := range invalidUints {
 			_, err := ConvertUint64(f)
@@ -323,35 +323,35 @@ func testNotIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing
 	_ = skipKnownFailure
 
 	return func(t *testing.T) {
-		assert.False(t, fn(math.Inf(1)))
-		assert.False(t, fn(maxJSONFloat+1))
-		assert.False(t, fn(minJSONFloat-1))
-		assert.False(t, fn(math.SmallestNonzeroFloat64))
-		assert.False(t, fn(0.5))
-		assert.False(t, fn(0.25))
-		assert.False(t, fn(1.00/func() float64 { return 2.00 }()))
-		assert.False(t, fn(1.00/func() float64 { return 4.00 }()))
-		assert.False(t, fn(epsilon))
+		assert.FalseT(t, fn(math.Inf(1)))
+		assert.FalseT(t, fn(maxJSONFloat+1))
+		assert.FalseT(t, fn(minJSONFloat-1))
+		assert.FalseT(t, fn(math.SmallestNonzeroFloat64))
+		assert.FalseT(t, fn(0.5))
+		assert.FalseT(t, fn(0.25))
+		assert.FalseT(t, fn(1.00/func() float64 { return 2.00 }()))
+		assert.FalseT(t, fn(1.00/func() float64 { return 4.00 }()))
+		assert.FalseT(t, fn(epsilon))
 	}
 }
 
 func testIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing.T) {
 	// wrapping in a function forces non-constant evaluation to test float64 rounding behavior
 	return func(t *testing.T) {
-		assert.True(t, fn(0.0))
-		assert.True(t, fn(1.0))
-		assert.True(t, fn(maxJSONFloat))
-		assert.True(t, fn(minJSONFloat))
+		assert.TrueT(t, fn(0.0))
+		assert.TrueT(t, fn(1.0))
+		assert.TrueT(t, fn(maxJSONFloat))
+		assert.TrueT(t, fn(minJSONFloat))
 		if !skipKnownFailure {
-			assert.True(t, fn(1/0.01*67.15000001))
+			assert.TrueT(t, fn(1/0.01*67.15000001))
 		}
 		if !skipKnownFailure {
-			assert.True(t, fn(1.00/func() float64 { return 0.01 }()*4643.4))
+			assert.TrueT(t, fn(1.00/func() float64 { return 0.01 }()*4643.4))
 		}
-		assert.True(t, fn(1.00/func() float64 { return 1.00 / 3.00 }()))
-		assert.True(t, fn(math.SmallestNonzeroFloat64/2))
-		assert.True(t, fn(math.SmallestNonzeroFloat64/3))
-		assert.True(t, fn(math.SmallestNonzeroFloat64/4))
+		assert.TrueT(t, fn(1.00/func() float64 { return 1.00 / 3.00 }()))
+		assert.TrueT(t, fn(math.SmallestNonzeroFloat64/2))
+		assert.TrueT(t, fn(math.SmallestNonzeroFloat64/3))
+		assert.TrueT(t, fn(math.SmallestNonzeroFloat64/4))
 	}
 }
 
diff --git a/conv/convert_types_test.go b/conv/convert_types_test.go
index e1a1222a..83b39f64 100644
--- a/conv/convert_types_test.go
+++ b/conv/convert_types_test.go
@@ -131,7 +131,7 @@ func TestPointer(t *testing.T) {
 }
 
 func assertSingleValue(t *testing.T, inElem, elem reflect.Value, expectPointer bool, idx int) {
-	require.Equalf(t,
+	require.EqualTf(t,
 		expectPointer, (elem.Kind() == reflect.Ptr),
 		"unexpected expectPointer=%t value type %T at idx %d", expectPointer, elem, idx,
 	)
@@ -144,7 +144,7 @@ func assertSingleValue(t *testing.T, inElem, elem reflect.Value, expectPointer b
 		elem = reflect.Indirect(elem)
 	}
 
-	require.Truef(t,
+	require.TrueTf(t,
 		(elem.Kind() == reflect.Ptr && elem.IsNil()) ||
 			typeutils.IsZero(elem.Interface()) == (inElem.Kind() == reflect.Ptr && inElem.IsNil()) ||
 			typeutils.IsZero(inElem.Interface()),
@@ -168,10 +168,10 @@ func assertValues(t *testing.T, in, out any, expectPointer bool, idx int) {
 
 	switch vin.Kind() { //nolint:exhaustive
 	case reflect.Slice, reflect.Map:
-		require.Equalf(t, vin.Kind(), vout.Kind(),
+		require.EqualTf(t, vin.Kind(), vout.Kind(),
 			"unexpected output type at idx %d", idx,
 		)
-		require.Equalf(t, vin.Len(), vout.Len(),
+		require.EqualTf(t, vin.Len(), vout.Len(),
 			"unexpected len at idx %d", idx,
 		)
 
diff --git a/conv_iface_test.go b/conv_iface_test.go
index 2dd88580..9feac141 100644
--- a/conv_iface_test.go
+++ b/conv_iface_test.go
@@ -16,15 +16,15 @@ func TestConvIface(t *testing.T) {
 
 	t.Run("deprecated Convert functions should work", func(t *testing.T) {
 		// only check happy path - more comprehensive testing is carried out inside the called package
-		assert.True(t, IsFloat64AJSONInteger(1.00))
+		assert.TrueT(t, IsFloat64AJSONInteger(1.00))
 
 		b, err := ConvertBool("true")
 		require.NoError(t, err)
-		assert.True(t, b)
+		assert.TrueT(t, b)
 
 		f32, err := ConvertFloat32("1.05")
 		require.NoError(t, err)
-		assert.InDelta(t, float32(1.05), f32, epsilon)
+		assert.InDeltaT(t, float32(1.05), f32, epsilon)
 
 		f64, err := ConvertFloat64("1.05")
 		require.NoError(t, err)
@@ -32,93 +32,93 @@ func TestConvIface(t *testing.T) {
 
 		i8, err := ConvertInt8("2")
 		require.NoError(t, err)
-		assert.Equal(t, int8(2), i8)
+		assert.EqualT(t, int8(2), i8)
 
 		i16, err := ConvertInt16("2")
 		require.NoError(t, err)
-		assert.Equal(t, int16(2), i16)
+		assert.EqualT(t, int16(2), i16)
 
 		i32, err := ConvertInt32("2")
 		require.NoError(t, err)
-		assert.Equal(t, int32(2), i32)
+		assert.EqualT(t, int32(2), i32)
 
 		i64, err := ConvertInt64("2")
 		require.NoError(t, err)
-		assert.Equal(t, int64(2), i64)
+		assert.EqualT(t, int64(2), i64)
 
 		u8, err := ConvertUint8("2")
 		require.NoError(t, err)
-		assert.Equal(t, uint8(2), u8)
+		assert.EqualT(t, uint8(2), u8)
 
 		u16, err := ConvertUint16("2")
 		require.NoError(t, err)
-		assert.Equal(t, uint16(2), u16)
+		assert.EqualT(t, uint16(2), u16)
 
 		u32, err := ConvertUint32("2")
 		require.NoError(t, err)
-		assert.Equal(t, uint32(2), u32)
+		assert.EqualT(t, uint32(2), u32)
 
 		u64, err := ConvertUint64("2")
 		require.NoError(t, err)
-		assert.Equal(t, uint64(2), u64)
+		assert.EqualT(t, uint64(2), u64)
 	})
 
 	t.Run("deprecated Format functions should work", func(t *testing.T) {
-		assert.Equal(t, "true", FormatBool(true))
-		assert.Equal(t, "1.05", FormatFloat32(1.05))
-		assert.Equal(t, "1.05", FormatFloat64(1.05))
-		assert.Equal(t, "1", FormatInt8(1))
-		assert.Equal(t, "1", FormatInt16(1))
-		assert.Equal(t, "1", FormatInt32(1))
-		assert.Equal(t, "1", FormatInt64(1))
-		assert.Equal(t, "1", FormatUint8(1))
-		assert.Equal(t, "1", FormatUint16(1))
-		assert.Equal(t, "1", FormatUint32(1))
-		assert.Equal(t, "1", FormatUint64(1))
+		assert.EqualT(t, "true", FormatBool(true))
+		assert.EqualT(t, "1.05", FormatFloat32(1.05))
+		assert.EqualT(t, "1.05", FormatFloat64(1.05))
+		assert.EqualT(t, "1", FormatInt8(1))
+		assert.EqualT(t, "1", FormatInt16(1))
+		assert.EqualT(t, "1", FormatInt32(1))
+		assert.EqualT(t, "1", FormatInt64(1))
+		assert.EqualT(t, "1", FormatUint8(1))
+		assert.EqualT(t, "1", FormatUint16(1))
+		assert.EqualT(t, "1", FormatUint32(1))
+		assert.EqualT(t, "1", FormatUint64(1))
 	})
 
 	t.Run("deprecated pointer functions should work", func(t *testing.T) {
-		assert.Equal(t, "a", StringValue(String("a")))
+		assert.EqualT(t, "a", StringValue(String("a")))
 		assert.Equal(t, []string{"a"}, StringValueSlice(StringSlice([]string{"a"})))
 		assert.Equal(t, map[string]string{"1": "a"}, StringValueMap(StringMap(map[string]string{"1": "a"})))
 
-		assert.True(t, BoolValue(Bool(true)))
+		assert.TrueT(t, BoolValue(Bool(true)))
 		assert.Equal(t, []bool{true}, BoolValueSlice(BoolSlice([]bool{true})))
 		assert.Equal(t, map[string]bool{"1": true}, BoolValueMap(BoolMap(map[string]bool{"1": true})))
 
-		assert.Equal(t, 1, IntValue(Int(1)))
+		assert.EqualT(t, 1, IntValue(Int(1)))
 		assert.Equal(t, []int{1}, IntValueSlice(IntSlice([]int{1})))
 		assert.Equal(t, map[string]int{"1": 1}, IntValueMap(IntMap(map[string]int{"1": 1})))
 
-		assert.Equal(t, int32(1), Int32Value(Int32(1)))
+		assert.EqualT(t, int32(1), Int32Value(Int32(1)))
 		assert.Equal(t, []int32{1}, Int32ValueSlice(Int32Slice([]int32{1})))
 		assert.Equal(t, map[string]int32{"1": 1}, Int32ValueMap(Int32Map(map[string]int32{"1": 1})))
 
-		assert.Equal(t, int64(1), Int64Value(Int64(1)))
+		assert.EqualT(t, int64(1), Int64Value(Int64(1)))
 		assert.Equal(t, []int64{1}, Int64ValueSlice(Int64Slice([]int64{1})))
 		assert.Equal(t, map[string]int64{"1": 1}, Int64ValueMap(Int64Map(map[string]int64{"1": 1})))
 
-		assert.Equal(t, uint16(1), Uint16Value(Uint16(1)))
+		assert.EqualT(t, uint16(1), Uint16Value(Uint16(1)))
 		assert.Equal(t, []uint16{1}, Uint16ValueSlice(Uint16Slice([]uint16{1})))
 		assert.Equal(t, map[string]uint16{"1": 1}, Uint16ValueMap(Uint16Map(map[string]uint16{"1": 1})))
 
-		assert.Equal(t, uint32(1), Uint32Value(Uint32(1)))
+		assert.EqualT(t, uint32(1), Uint32Value(Uint32(1)))
 		assert.Equal(t, []uint32{1}, Uint32ValueSlice(Uint32Slice([]uint32{1})))
 		assert.Equal(t, map[string]uint32{"1": 1}, Uint32ValueMap(Uint32Map(map[string]uint32{"1": 1})))
 
-		assert.Equal(t, uint64(1), Uint64Value(Uint64(1)))
+		assert.EqualT(t, uint64(1), Uint64Value(Uint64(1)))
 		assert.Equal(t, []uint64{1}, Uint64ValueSlice(Uint64Slice([]uint64{1})))
 		assert.Equal(t, map[string]uint64{"1": 1}, Uint64ValueMap(Uint64Map(map[string]uint64{"1": 1})))
 
-		assert.Equal(t, uint(1), UintValue(Uint(1)))
+		assert.EqualT(t, uint(1), UintValue(Uint(1)))
 		assert.Equal(t, []uint{1}, UintValueSlice(UintSlice([]uint{1})))
 		assert.Equal(t, map[string]uint{"1": 1}, UintValueMap(UintMap(map[string]uint{"1": 1})))
 
-		assert.InDelta(t, float32(1.00), Float32Value(Float32(1.00)), epsilon)
+		assert.InDeltaT(t, float32(1.00), Float32Value(Float32(1.00)), epsilon)
 		assert.Equal(t, []float32{1.00}, Float32ValueSlice(Float32Slice([]float32{1.00})))
 		assert.Equal(t, map[string]float32{"1": 1.00}, Float32ValueMap(Float32Map(map[string]float32{"1": 1.00})))
 
-		assert.InDelta(t, float64(1.00), Float64Value(Float64(1)), epsilon)
+		assert.InDeltaT(t, float64(1.00), Float64Value(Float64(1)), epsilon)
 		assert.Equal(t, []float64{1.00}, Float64ValueSlice(Float64Slice([]float64{1.00})))
 		assert.Equal(t, map[string]float64{"1": 1.00}, Float64ValueMap(Float64Map(map[string]float64{"1": 1.00})))
 
diff --git a/fileutils/path_test.go b/fileutils/path_test.go
index c0413458..79d7c16f 100644
--- a/fileutils/path_test.go
+++ b/fileutils/path_test.go
@@ -73,7 +73,7 @@ func assertPath(t testing.TB, expected, actual string) bool {
 	fp, err := filepath.EvalSymlinks(expected)
 	require.NoError(t, err)
 
-	return assert.Equal(t, fp, actual)
+	return assert.EqualT(t, fp, actual)
 }
 
 func TestFullGOPATH(t *testing.T) {
@@ -82,5 +82,5 @@ func TestFullGOPATH(t *testing.T) {
 	t.Setenv(GOPATHKey, ngp)
 
 	expected := ngp + ":" + runtime.GOROOT() //nolint: staticcheck // this is a deprecated function
-	assert.Equal(t, expected, FullGoSearchPath())
+	assert.EqualT(t, expected, FullGoSearchPath())
 }
diff --git a/jsonname/name_provider_test.go b/jsonname/name_provider_test.go
index 92d1a207..b1b5ce85 100644
--- a/jsonname/name_provider_test.go
+++ b/jsonname/name_provider_test.go
@@ -22,101 +22,101 @@ func TestNameProvider(t *testing.T) {
 	var obj = testNameStruct{}
 
 	nm, ok := provider.GetGoName(obj, "name")
-	assert.True(t, ok)
-	assert.Equal(t, "Name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "Name", nm)
 
 	nm, ok = provider.GetGoName(obj, "plain")
-	assert.True(t, ok)
-	assert.Equal(t, "NotTheSame", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "NotTheSame", nm)
 
 	nm, ok = provider.GetGoName(obj, "doesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetGoName(obj, "ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	tpe := reflect.TypeOf(obj)
 	nm, ok = provider.GetGoNameForType(tpe, "name")
-	assert.True(t, ok)
-	assert.Equal(t, "Name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "Name", nm)
 
 	nm, ok = provider.GetGoNameForType(tpe, "plain")
-	assert.True(t, ok)
-	assert.Equal(t, "NotTheSame", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "NotTheSame", nm)
 
 	nm, ok = provider.GetGoNameForType(tpe, "doesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetGoNameForType(tpe, "ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	ptr := &obj
 	nm, ok = provider.GetGoName(ptr, "name")
-	assert.True(t, ok)
-	assert.Equal(t, "Name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "Name", nm)
 
 	nm, ok = provider.GetGoName(ptr, "plain")
-	assert.True(t, ok)
-	assert.Equal(t, "NotTheSame", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "NotTheSame", nm)
 
 	nm, ok = provider.GetGoName(ptr, "doesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetGoName(ptr, "ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONName(obj, "Name")
-	assert.True(t, ok)
-	assert.Equal(t, "name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "name", nm)
 
 	nm, ok = provider.GetJSONName(obj, "NotTheSame")
-	assert.True(t, ok)
-	assert.Equal(t, "plain", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "plain", nm)
 
 	nm, ok = provider.GetJSONName(obj, "DoesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONName(obj, "Ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONNameForType(tpe, "Name")
-	assert.True(t, ok)
-	assert.Equal(t, "name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "name", nm)
 
 	nm, ok = provider.GetJSONNameForType(tpe, "NotTheSame")
-	assert.True(t, ok)
-	assert.Equal(t, "plain", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "plain", nm)
 
 	nm, ok = provider.GetJSONNameForType(tpe, "doesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONNameForType(tpe, "Ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONName(ptr, "Name")
-	assert.True(t, ok)
-	assert.Equal(t, "name", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "name", nm)
 
 	nm, ok = provider.GetJSONName(ptr, "NotTheSame")
-	assert.True(t, ok)
-	assert.Equal(t, "plain", nm)
+	assert.TrueT(t, ok)
+	assert.EqualT(t, "plain", nm)
 
 	nm, ok = provider.GetJSONName(ptr, "doesNotExist")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nm, ok = provider.GetJSONName(ptr, "Ignored")
-	assert.False(t, ok)
+	assert.FalseT(t, ok)
 	assert.Empty(t, nm)
 
 	nms := provider.GetJSONNames(ptr)
diff --git a/jsonutils/adapters/ifaces/registry_ifaces_test.go b/jsonutils/adapters/ifaces/registry_ifaces_test.go
index 01cb8ae8..07025ce7 100644
--- a/jsonutils/adapters/ifaces/registry_ifaces_test.go
+++ b/jsonutils/adapters/ifaces/registry_ifaces_test.go
@@ -40,7 +40,7 @@ func TestRegistryIfaces(t *testing.T) {
 				expected: "<unknown>",
 			},
 		} {
-			assert.Equal(t, test.expected, test.in.String())
+			assert.EqualT(t, test.expected, test.in.String())
 		}
 	})
 
@@ -66,7 +66,7 @@ func TestRegistryIfaces(t *testing.T) {
 				expected: "",
 			},
 		} {
-			assert.Equal(t, test.expected, test.in.String())
+			assert.EqualT(t, test.expected, test.in.String())
 		}
 	})
 }
diff --git a/jsonutils/adapters/registry_test.go b/jsonutils/adapters/registry_test.go
index b7f1bb4c..333c9dce 100644
--- a/jsonutils/adapters/registry_test.go
+++ b/jsonutils/adapters/registry_test.go
@@ -38,7 +38,7 @@ func TestRegistryUnmarshal(t *testing.T) {
 			require.NotEmpty(t, jazon)
 
 			mockAdapter, ok := adapter.(*MockAdapter1)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			calls := mockAdapter.UnmarshalCalls()
 			require.Len(t, calls, 1)
 		})
@@ -58,7 +58,7 @@ func TestRegistryUnmarshal(t *testing.T) {
 
 			t.Run("should have called the adapter's OrderedUnmarshal method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter1)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.OrderedUnmarshalCalls()
 				require.Len(t, calls, 1)
 			})
@@ -66,10 +66,10 @@ func TestRegistryUnmarshal(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.orderedUnmarshalerCache, 1)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.orderedUnmarshalerCache, key)
+				require.MapContainsT(t, reg.orderedUnmarshalerCache, key)
 				entry := reg.orderedUnmarshalerCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityOrderedUnmarshalJSON))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityOrderedUnmarshalJSON))
 			})
 		})
 
@@ -84,7 +84,7 @@ func TestRegistryUnmarshal(t *testing.T) {
 			require.NotEmpty(t, jazon)
 
 			mockAdapter, ok := adapter.(*MockAdapter1)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			calls := mockAdapter.OrderedUnmarshalCalls()
 			require.Len(t, calls, 1)
 		})
@@ -115,7 +115,7 @@ func TestRegistryMarshal(t *testing.T) {
 			require.NotEmpty(t, jazon)
 
 			mockAdapter, ok := adapter.(*MockAdapter1)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			calls := mockAdapter.MarshalCalls()
 			require.Len(t, calls, 1)
 		})
@@ -134,7 +134,7 @@ func TestRegistryMarshal(t *testing.T) {
 
 			t.Run("should have called the adapter's OrderedMarshal method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter1)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.OrderedMarshalCalls()
 				require.Len(t, calls, 1)
 			})
@@ -142,10 +142,10 @@ func TestRegistryMarshal(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.orderedMarshalerCache, 1)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.orderedMarshalerCache, key)
+				require.MapContainsT(t, reg.orderedMarshalerCache, key)
 				entry := reg.orderedMarshalerCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityOrderedMarshalJSON))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityOrderedMarshalJSON))
 			})
 		})
 
@@ -159,7 +159,7 @@ func TestRegistryMarshal(t *testing.T) {
 			require.NotEmpty(t, jazon)
 
 			mockAdapter, ok := adapter.(*MockAdapter1)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			calls := mockAdapter.OrderedMarshalCalls()
 			require.Len(t, calls, 1)
 		})
@@ -193,7 +193,7 @@ func TestRegistryMarshal(t *testing.T) {
 
 			t.Run("should have called the adapter's MarshalJSON method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter2)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.MarshalCalls()
 				require.Len(t, calls, 1)
 			})
@@ -201,10 +201,10 @@ func TestRegistryMarshal(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.marshalerCache, 2)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.marshalerCache, key)
+				require.MapContainsT(t, reg.marshalerCache, key)
 				entry := reg.marshalerCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter2", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter2", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
 			})
 		})
 
@@ -221,7 +221,7 @@ func TestRegistryMarshal(t *testing.T) {
 
 			t.Run("should have called the adapter's MarshalJSON method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter1)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.MarshalCalls()
 				require.Len(t, calls, 1)
 			})
@@ -229,10 +229,10 @@ func TestRegistryMarshal(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.marshalerCache, 3)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.marshalerCache, key)
+				require.MapContainsT(t, reg.marshalerCache, key)
 				entry := reg.marshalerCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
 			})
 		})
 
@@ -251,7 +251,7 @@ func TestRegistryMarshal(t *testing.T) {
 
 			t.Run("should have called the adapter's Unmarshal method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter1)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.UnmarshalCalls()
 				require.Len(t, calls, 1)
 			})
@@ -259,10 +259,10 @@ func TestRegistryMarshal(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.unmarshalerCache, 1)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.unmarshalerCache, key)
+				require.MapContainsT(t, reg.unmarshalerCache, key)
 				entry := reg.unmarshalerCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityUnmarshalJSON))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityUnmarshalJSON))
 			})
 		})
 	})
@@ -293,7 +293,7 @@ func TestRegistryOrderedMap(t *testing.T) {
 
 			t.Run("should have called the adapter's NewOrderedMap method", func(t *testing.T) {
 				mockAdapter, ok := adapter.(*MockAdapter1)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := mockAdapter.NewOrderedMapCalls()
 				require.Len(t, calls, 1)
 			})
@@ -301,10 +301,10 @@ func TestRegistryOrderedMap(t *testing.T) {
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.orderedMapCache, 1)
 				key := reflect.TypeOf(nil)
-				require.Contains(t, reg.orderedMapCache, key)
+				require.MapContainsT(t, reg.orderedMapCache, key)
 				entry := reg.orderedMapCache[key]
-				require.Equal(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
-				require.True(t, entry.What.Has(ifaces.CapabilityOrderedMap))
+				require.EqualT(t, "github.com/go-openapi/swag/jsonutils/adapters.MockAdapter1", entry.Who)
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityOrderedMap))
 			})
 		})
 	})
@@ -334,7 +334,7 @@ func TestGlobalRegistry(t *testing.T) {
 			defer adp.Redeem()
 
 			_, isStdLib := adp.(*stdlib.Adapter)
-			require.True(t, isStdLib)
+			require.TrueT(t, isStdLib)
 		})
 
 		t.Run("should resolve to the stdlib adapter for UnmarshalJSON", func(t *testing.T) {
@@ -344,7 +344,7 @@ func TestGlobalRegistry(t *testing.T) {
 			defer adp.Redeem()
 
 			_, isStdLib := adp.(*stdlib.Adapter)
-			require.True(t, isStdLib)
+			require.TrueT(t, isStdLib)
 		})
 
 		t.Run("should resolve to the stdlib adapter for OrderedMarshalJSON", func(t *testing.T) {
@@ -354,7 +354,7 @@ func TestGlobalRegistry(t *testing.T) {
 			defer adp.Redeem()
 
 			_, isStdLib := adp.(*stdlib.Adapter)
-			require.True(t, isStdLib)
+			require.TrueT(t, isStdLib)
 		})
 
 		t.Run("should resolve to the stdlib adapter for OrderedUnmarshalJSON", func(t *testing.T) {
@@ -364,7 +364,7 @@ func TestGlobalRegistry(t *testing.T) {
 			defer adp.Redeem()
 
 			_, isStdLib := adp.(*stdlib.Adapter)
-			require.True(t, isStdLib)
+			require.TrueT(t, isStdLib)
 		})
 
 		t.Run("should resolve to the stdlib adapter for OrderedMap", func(t *testing.T) {
@@ -374,7 +374,7 @@ func TestGlobalRegistry(t *testing.T) {
 			require.IsType(t, expectedMap, orderedMap)
 
 			_, isStdLib := orderedMap.(*stdlib.MapSlice)
-			require.True(t, isStdLib)
+			require.TrueT(t, isStdLib)
 		})
 	})
 }
@@ -396,26 +396,26 @@ func testUnmarshal[ValueType any, AdapterType ifaces.UnmarshalAdapter](reg *Regi
 
 			t.Run("should have called the adapter's Unmarshal method", func(t *testing.T) {
 				_, ok := adapter.(AdapterType)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				auditable, ok := adapter.(interface{ UnmarshalCallsLen() int })
-				require.True(t, ok)
+				require.TrueT(t, ok)
 
 				calls := auditable.UnmarshalCallsLen()
-				require.Equal(t, 1, calls)
+				require.EqualT(t, 1, calls)
 			})
 
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.unmarshalerCache, 1)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.unmarshalerCache, key)
+				require.MapContainsT(t, reg.unmarshalerCache, key)
 				entry := reg.unmarshalerCache[key]
 				mockAdapter, ok := adapter.(AdapterType)
-				require.True(t, ok)
-				require.Equal(t,
+				require.TrueT(t, ok)
+				require.EqualT(t,
 					fmt.Sprintf("github.com/go-openapi/swag/jsonutils/%s", reflect.Indirect(reflect.ValueOf(mockAdapter)).Type()),
 					entry.Who,
 				)
-				require.True(t, entry.What.Has(ifaces.CapabilityUnmarshalJSON))
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityUnmarshalJSON))
 			})
 		})
 	}
@@ -437,25 +437,25 @@ func testMarshal[ValueType any, AdapterType ifaces.MarshalAdapter](reg *Registra
 
 			t.Run("should have called the adapter's MarshalJSON method", func(t *testing.T) {
 				_, ok := adapter.(AdapterType)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				auditable, ok := adapter.(interface{ MarshalCallsLen() int })
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				calls := auditable.MarshalCallsLen()
-				require.Equal(t, 1, calls)
+				require.EqualT(t, 1, calls)
 			})
 
 			t.Run("should have cached the route for this type", func(t *testing.T) {
 				require.Len(t, reg.marshalerCache, 1)
 				key := reflect.TypeOf(value)
-				require.Contains(t, reg.marshalerCache, key)
+				require.MapContainsT(t, reg.marshalerCache, key)
 				entry := reg.marshalerCache[key]
 				mockAdapter, ok := adapter.(AdapterType)
-				require.True(t, ok)
-				require.Equal(t,
+				require.TrueT(t, ok)
+				require.EqualT(t,
 					fmt.Sprintf("github.com/go-openapi/swag/jsonutils/%s", reflect.Indirect(reflect.ValueOf(mockAdapter)).Type()),
 					entry.Who,
 				)
-				require.True(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
+				require.TrueT(t, entry.What.Has(ifaces.CapabilityMarshalJSON))
 			})
 		})
 	}
diff --git a/jsonutils/adapters/stdlib/json/lexer_test.go b/jsonutils/adapters/stdlib/json/lexer_test.go
index 0174c94f..4afe79a9 100644
--- a/jsonutils/adapters/stdlib/json/lexer_test.go
+++ b/jsonutils/adapters/stdlib/json/lexer_test.go
@@ -14,8 +14,8 @@ import (
 
 func TestToken(t *testing.T) {
 	t.Run("token should be stringable for debugging and error formatting", func(t *testing.T) {
-		assert.Equal(t, "invalid token", invalidToken.String())
-		assert.Equal(t, "EOF", eofToken.String())
+		assert.EqualT(t, "invalid token", invalidToken.String())
+		assert.EqualT(t, "EOF", eofToken.String())
 	})
 
 	t.Run("token should be able to map all tokens from encoding/json.Token", func(t *testing.T) {
@@ -23,7 +23,7 @@ func TestToken(t *testing.T) {
 		tok := token{
 			Token: stdtok,
 		}
-		assert.Equal(t, tokenNumber, tok.Kind())
+		assert.EqualT(t, tokenNumber, tok.Kind())
 	})
 
 	t.Run("token should detect JSON delimiters", func(t *testing.T) {
@@ -32,7 +32,7 @@ func TestToken(t *testing.T) {
 		tok = token{
 			Token: stdjson.Delim(','),
 		}
-		assert.Equal(t, byte(','), tok.Delim())
+		assert.EqualT(t, byte(','), tok.Delim())
 	})
 }
 
@@ -48,30 +48,30 @@ func TestBytesReader(t *testing.T) {
 
 		n, err := r.Read(buf)
 		require.NoError(t, err)
-		require.Equal(t, bufferSize, n)
+		require.EqualT(t, bufferSize, n)
 		require.Equal(t, []byte("123"), buf[:n])
-		assert.Equal(t, bufferSize, r.offset)
+		assert.EqualT(t, bufferSize, r.offset)
 
 		n, err = r.Read(buf)
 		require.NoError(t, err)
-		require.Equal(t, bufferSize, n)
+		require.EqualT(t, bufferSize, n)
 		require.Equal(t, []byte("456"), buf[:n])
-		assert.Equal(t, 2*bufferSize, r.offset)
+		assert.EqualT(t, 2*bufferSize, r.offset)
 
 		n, err = r.Read(buf)
 		require.NoError(t, err)
-		require.Equal(t, bufferSize, n)
+		require.EqualT(t, bufferSize, n)
 		require.Equal(t, []byte("789"), buf[:n])
-		assert.Equal(t, 3*bufferSize, r.offset)
+		assert.EqualT(t, 3*bufferSize, r.offset)
 
 		n, err = r.Read(buf)
 		require.NoError(t, err)
-		require.Equal(t, 1, n)
+		require.EqualT(t, 1, n)
 		require.Equal(t, []byte("0"), buf[:n])
-		assert.Equal(t, len(r.buf), r.offset)
+		assert.EqualT(t, len(r.buf), r.offset)
 
 		n, err = r.Read(buf)
-		require.Equal(t, 0, n)
+		require.EqualT(t, 0, n)
 		require.ErrorIs(t, err, io.EOF)
 	})
 
@@ -86,9 +86,9 @@ func TestBytesReader(t *testing.T) {
 
 		n, err := r.Read(buf)
 		require.NoError(t, err)
-		require.Equal(t, len(r.buf), n)
+		require.EqualT(t, len(r.buf), n)
 		require.Equal(t, r.buf, buf[:n])
-		assert.Equal(t, len(r.buf), r.offset)
+		assert.EqualT(t, len(r.buf), r.offset)
 	})
 }
 
@@ -96,12 +96,12 @@ func TestLexer(t *testing.T) {
 	t.Run("lexer should be interruptible by setting error state", func(t *testing.T) {
 		l := newLexer([]byte("123"))
 		l.SetErr(ErrStdlib)
-		require.False(t, l.Ok())
+		require.FalseT(t, l.Ok())
 		require.Error(t, l.Error())
 
 		require.Equal(t, invalidToken, l.NextToken())
-		require.False(t, l.IsDelim(','))
-		require.False(t, l.IsNull())
+		require.FalseT(t, l.IsDelim(','))
+		require.FalseT(t, l.IsNull())
 		require.Zero(t, l.Number())
 		require.NotPanics(t, func() {
 			l.Null()
@@ -113,11 +113,11 @@ func TestLexer(t *testing.T) {
 		l.next = token{Token: stdjson.Delim('{')}
 
 		l.Delim('{')
-		require.True(t, l.Ok())
+		require.TrueT(t, l.Ok())
 
 		l.next = token{Token: "123"}
 		l.Delim('{')
-		require.False(t, l.Ok())
+		require.FalseT(t, l.Ok())
 	})
 
 	t.Run("lexer should detect null", func(t *testing.T) {
@@ -125,11 +125,11 @@ func TestLexer(t *testing.T) {
 		l.next = token{Token: nil}
 
 		l.Null()
-		require.True(t, l.Ok())
+		require.TrueT(t, l.Ok())
 
 		l.next = token{Token: "123"}
 		l.Null()
-		require.False(t, l.Ok())
+		require.FalseT(t, l.Ok())
 	})
 
 	t.Run("lexer should detect bool", func(t *testing.T) {
@@ -137,18 +137,18 @@ func TestLexer(t *testing.T) {
 		l.next = token{Token: false}
 
 		b := l.Bool()
-		require.True(t, l.Ok())
-		require.False(t, b)
+		require.TrueT(t, l.Ok())
+		require.FalseT(t, b)
 
 		l.next = token{Token: true}
 		b = l.Bool()
-		require.True(t, l.Ok())
-		require.True(t, b)
+		require.TrueT(t, l.Ok())
+		require.TrueT(t, b)
 
 		l.next = token{Token: "x"}
 		b = l.Bool()
-		require.False(t, l.Ok())
-		require.False(t, b)
+		require.FalseT(t, l.Ok())
+		require.FalseT(t, b)
 	})
 
 	t.Run("lexer should detect JSON number as string", func(t *testing.T) {
@@ -158,22 +158,22 @@ func TestLexer(t *testing.T) {
 		l.next = token{Token: stdjson.Number("123")}
 
 		n := l.Number()
-		require.True(t, l.Ok())
+		require.TrueT(t, l.Ok())
 		require.Equal(t, int64(123), n)
 
 		l.next = token{Token: stdjson.Number("123.4")}
 		n = l.Number()
-		require.True(t, l.Ok())
+		require.TrueT(t, l.Ok())
 		require.InDelta(t, float64(123.4), n, epsilon)
 
 		l.next = token{Token: 123.4}
 		n = l.Number()
-		require.True(t, l.Ok())
+		require.TrueT(t, l.Ok())
 		require.InDelta(t, float64(123.4), n, epsilon)
 
 		l.next = token{Token: "123.4"}
 		n = l.Number()
-		require.False(t, l.Ok())
+		require.FalseT(t, l.Ok())
 		require.Zero(t, n)
 	})
 }
diff --git a/jsonutils/adapters/stdlib/json/writer_test.go b/jsonutils/adapters/stdlib/json/writer_test.go
index fbf33959..52f297c0 100644
--- a/jsonutils/adapters/stdlib/json/writer_test.go
+++ b/jsonutils/adapters/stdlib/json/writer_test.go
@@ -21,17 +21,17 @@ func TestWriter(t *testing.T) {
 
 		w.err = ErrStdlib
 		w.RawString(str)
-		require.Equal(t, marker, w.buf.String())
+		require.EqualT(t, marker, w.buf.String())
 
 		raw := func() ([]byte, error) { return []byte(str), nil }
 		w.Raw(raw())
-		require.Equal(t, marker, w.buf.String())
+		require.EqualT(t, marker, w.buf.String())
 
 		w.RawByte('x')
-		require.Equal(t, marker, w.buf.String())
+		require.EqualT(t, marker, w.buf.String())
 
 		w.String(str)
-		require.Equal(t, marker, w.buf.String())
+		require.EqualT(t, marker, w.buf.String())
 
 		result, err := w.BuildBytes()
 		require.Nil(t, result)
@@ -43,7 +43,7 @@ func TestWriter(t *testing.T) {
 		w.RawString(marker)
 		raw := func() ([]byte, error) { return []byte(str), ErrStdlib }
 		w.Raw(raw())
-		require.Equal(t, marker, w.buf.String())
+		require.EqualT(t, marker, w.buf.String())
 
 		result, err := w.BuildBytes()
 		require.Nil(t, result)
diff --git a/jsonutils/adapters/testintegration/benchmarks/payloads_test.go b/jsonutils/adapters/testintegration/benchmarks/payloads_test.go
index 718e0a08..643effa4 100644
--- a/jsonutils/adapters/testintegration/benchmarks/payloads_test.go
+++ b/jsonutils/adapters/testintegration/benchmarks/payloads_test.go
@@ -46,7 +46,7 @@ func verifyPayload[T any](constructor func() *T) func(*testing.T) {
 			t.Run(fmt.Sprintf("value of type %T should MarshalEasyJSON", value), func(t *testing.T) {
 				var val any = value
 				easyMarshaler, ok := val.(easyjson.Marshaler)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				jw := jwriter.Writer{}
 				easyMarshaler.MarshalEasyJSON(&jw)
 				data, err := jw.BuildBytes()
@@ -58,7 +58,7 @@ func verifyPayload[T any](constructor func() *T) func(*testing.T) {
 					target := new(T)
 					var tgt any = target
 					easyUnmarshaler, ok := tgt.(easyjson.Unmarshaler)
-					require.True(t, ok)
+					require.TrueT(t, ok)
 					jl := jlexer.Lexer{Data: data}
 					easyUnmarshaler.UnmarshalEasyJSON(&jl)
 					require.NoError(t, jl.Error())
diff --git a/jsonutils/adapters/testintegration/integration_test.go b/jsonutils/adapters/testintegration/integration_test.go
index c25cf035..ab883b2c 100644
--- a/jsonutils/adapters/testintegration/integration_test.go
+++ b/jsonutils/adapters/testintegration/integration_test.go
@@ -24,7 +24,7 @@ func TestIntegration(t *testing.T) {
 		m := a.NewOrderedMap(reasonableLength) // returns ifaces.OrderedMap
 		stdm, ok := m.(*stdlib.MapSlice)
 
-		require.True(t, ok)
+		require.TrueT(t, ok)
 
 		return stdm
 	}
@@ -36,14 +36,14 @@ func TestIntegration(t *testing.T) {
 		withAssertionsAfterRead(func(v any) func(*testing.T) {
 			return func(t *testing.T) {
 				value, ok := v.(EasyOrderedObject)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				require.Len(t, value.UnmarshalEasyJSONCalls(), 1)
 			}
 		}),
 		withAssertionsAfterWrite(func(v any) func(*testing.T) {
 			return func(t *testing.T) {
 				value, ok := v.(EasyOrderedObject)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 				require.Len(t, value.MarshalEasyJSONCalls(), 1)
 			}
 		}),
diff --git a/jsonutils/fixtures_test/harness.go b/jsonutils/fixtures_test/harness.go
index 31a3f71d..d8519f57 100644
--- a/jsonutils/fixtures_test/harness.go
+++ b/jsonutils/fixtures_test/harness.go
@@ -101,7 +101,7 @@ func (h *Harness) Get(name string) (Fixture, bool) {
 
 func (h *Harness) ShouldGet(name string) Fixture {
 	fixture, ok := h.Get(name)
-	require.True(h.t, ok)
+	require.TrueT(h.t, ok)
 
 	return fixture
 }
@@ -236,7 +236,7 @@ func JSONEqualOrderedBytes(t testing.TB, expected, actual []byte) {
 			require.NoError(t, err)
 			return
 		}
-		require.Less(t, count, len(expectedTokens))
+		require.LessT(t, count, len(expectedTokens))
 		require.Equalf(t, expectedTokens[count], tok, "json token differs: %d", count)
 		count++
 	}
@@ -280,7 +280,7 @@ func YAMLEqualOrderedBytes(t testing.TB, expected, actual []byte) {
 	t.Helper()
 
 	// TODO: add YAMLEqBytes to testify
-	require.YAMLEq(t, string(expected), string(actual)) // necessary but not sufficient condition
+	require.YAMLEqT(t, string(expected), string(actual)) // necessary but not sufficient condition
 
 	// strip all indentation and comments (anchors not supported)
 	strippedExpected := rexStripIndent.ReplaceAll(expected, []byte(""))
diff --git a/jsonutils/fixtures_test/harness_test.go b/jsonutils/fixtures_test/harness_test.go
index 1ed9a4b5..c75af3d7 100644
--- a/jsonutils/fixtures_test/harness_test.go
+++ b/jsonutils/fixtures_test/harness_test.go
@@ -15,7 +15,7 @@ func TestHarness(t *testing.T) {
 	h.Init()
 
 	f1, ok := h.Get("with JSON object")
-	require.True(t, ok)
+	require.TrueT(t, ok)
 	require.NotNil(t, f1)
 
 	f2 := h.ShouldGet("with JSON object inside")
@@ -28,7 +28,7 @@ func TestHarness(t *testing.T) {
 		require.NotEmptyf(t, test.JSONPayload, "JSON payload empty for %s", name)
 		require.NotEmptyf(t, test.YAMLPayload, "YAML payload empty for %s", name)
 		require.NotEmptyf(t, test.JSONBytes(), "JSON bytes payload empty for %s", name)
-		require.Equal(t, test.Error, test.ExpectError())
+		require.EqualT(t, test.Error, test.ExpectError())
 		if !test.ExpectError() {
 			require.NotEmptyf(t, test.YAMLBytes(), "YAML bytes payload empty for %s", name)
 		}
@@ -37,18 +37,18 @@ func TestHarness(t *testing.T) {
 
 	countWithoutError := 0
 	for name, test := range h.AllTests(WithoutError(true)) {
-		require.Falsef(t, test.ExpectError(), "test %s did not expect an error", name)
+		require.FalseTf(t, test.ExpectError(), "test %s did not expect an error", name)
 		countWithoutError++
 	}
 	require.NotZero(t, countWithoutError)
 
 	countWithError := 0
 	for name, test := range h.AllTests(WithError(true)) {
-		require.Truef(t, test.ExpectError(), "test %s expected an error", name)
+		require.TrueTf(t, test.ExpectError(), "test %s expected an error", name)
 		countWithError++
 	}
 	require.NotZero(t, countWithError)
-	require.Equal(t, count, countWithoutError+countWithError)
+	require.EqualT(t, count, countWithoutError+countWithError)
 }
 
 func TestLoadFixture(t *testing.T) {
diff --git a/jsonutils/json_test.go b/jsonutils/json_test.go
index b149b7e9..3c551160 100644
--- a/jsonutils/json_test.go
+++ b/jsonutils/json_test.go
@@ -100,7 +100,7 @@ func TestReadWriteJSON(t *testing.T) {
 				require.NoError(t, ReadJSON(rtjson, &obj1))
 
 				t.Run("this should copy the object", func(t *testing.T) {
-					require.Equal(t, obj, obj1)
+					require.EqualT(t, obj, obj1)
 				})
 			})
 
@@ -109,7 +109,7 @@ func TestReadWriteJSON(t *testing.T) {
 				require.NoError(t, obj11.UnmarshalJSON(rtjson))
 
 				t.Run("this should copy the object", func(t *testing.T) {
-					require.Equal(t, obj, obj11)
+					require.EqualT(t, obj, obj11)
 				})
 			})
 
@@ -118,7 +118,7 @@ func TestReadWriteJSON(t *testing.T) {
 				require.NoError(t, json.Unmarshal(rtjson, &obj11))
 
 				t.Run("this should copy the object", func(t *testing.T) {
-					require.Equal(t, obj, obj11)
+					require.EqualT(t, obj, obj11)
 				})
 			})
 		})
@@ -129,7 +129,7 @@ func TestReadWriteJSON(t *testing.T) {
 				var obj2 AggregationObject
 
 				require.NoError(t, ReadJSON([]byte(jsons), &obj2))
-				require.Equal(t, AggregationObject{SharedCounters: SharedCounters{Counter1: 123, Counter2: 456}, Count: 999}, obj2)
+				require.EqualT(t, AggregationObject{SharedCounters: SharedCounters{Counter1: 123, Counter2: 456}, Count: 999}, obj2)
 			})
 		})
 		t.Run("using FromDynamicJSON", func(t *testing.T) {
@@ -138,18 +138,18 @@ func TestReadWriteJSON(t *testing.T) {
 
 			require.NoError(t, FromDynamicJSON(obj, &obj2))
 			asMap, ok := obj2.(map[string]any)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			assert.Len(t, asMap, 3) // 3 fields in struct
 			c1, ok := asMap["counter1"]
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			assert.InDelta(t, float64(304), c1, epsilon)
 
 			c2, ok := asMap["counter2:"]
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			assert.InDelta(t, float64(948), c2, epsilon)
 
 			c, ok := asMap["count"]
-			require.True(t, ok)
+			require.TrueT(t, ok)
 			assert.InDelta(t, float64(290), c, epsilon)
 		})
 
diff --git a/jsonutils/ordered_map_test.go b/jsonutils/ordered_map_test.go
index 4f9fa5f0..319630c5 100644
--- a/jsonutils/ordered_map_test.go
+++ b/jsonutils/ordered_map_test.go
@@ -63,7 +63,7 @@ func TestJSONMapSlice(t *testing.T) {
 		require.NoError(t, FromDynamicJSON(data, &obj))
 
 		asMap, ok := obj.(map[string]any)
-		require.True(t, ok)
+		require.TrueT(t, ok)
 		assert.Len(t, asMap, 3) // 3 fields in struct
 
 		var target JSONMapSlice
diff --git a/jsonutils_iface_test.go b/jsonutils_iface_test.go
index a1e720fc..3c87cb2f 100644
--- a/jsonutils_iface_test.go
+++ b/jsonutils_iface_test.go
@@ -40,18 +40,18 @@ func TestJSONUtilsIface(t *testing.T) {
 				require.NoError(t, FromDynamicJSON(a, &b))
 
 				_, isMap := b.(map[string]any)
-				assert.True(t, isMap)
+				assert.TrueT(t, isMap)
 			})
 
 			t.Run("ToDynamicJSON into a map", func(t *testing.T) {
 				c := ToDynamicJSON(a)
 				_, isMap := c.(map[string]any)
-				assert.True(t, isMap)
+				assert.TrueT(t, isMap)
 
 				t.Run("DynamicJSONToStruct back to struct", func(t *testing.T) {
 					a.A = 0
 					require.NoError(t, DynamicJSONToStruct(c, &a))
-					assert.Equalf(t, 1, a.A, "expected to restore original value")
+					assert.EqualTf(t, 1, a.A, "expected to restore original value")
 				})
 			})
 		})
diff --git a/loading/json_test.go b/loading/json_test.go
index f2e94a1e..586b15f1 100644
--- a/loading/json_test.go
+++ b/loading/json_test.go
@@ -14,10 +14,10 @@ import (
 
 func TestJSONMatcher(t *testing.T) {
 	t.Run("should recognize a json file", func(t *testing.T) {
-		assert.True(t, JSONMatcher("local.json"))
-		assert.True(t, JSONMatcher("local.jso"))
-		assert.True(t, JSONMatcher("local.jsn"))
-		assert.False(t, JSONMatcher("local.yml"))
+		assert.TrueT(t, JSONMatcher("local.json"))
+		assert.TrueT(t, JSONMatcher("local.jso"))
+		assert.TrueT(t, JSONMatcher("local.jsn"))
+		assert.FalseT(t, JSONMatcher("local.yml"))
 	})
 }
 
diff --git a/loading/loading_test.go b/loading/loading_test.go
index 047f85b0..4bf0bc15 100644
--- a/loading/loading_test.go
+++ b/loading/loading_test.go
@@ -27,7 +27,7 @@ func TestLoadFromHTTP(t *testing.T) {
 		content, err := LoadFromFileOrHTTP(ts.URL)
 		require.NoError(t, err)
 
-		assert.YAMLEq(t, string(yamlPetStore), string(content))
+		assert.YAMLEqT(t, string(yamlPetStore), string(content))
 	})
 
 	t.Run("should not load from invalid URL", func(t *testing.T) {
@@ -170,7 +170,7 @@ func TestLoadFromHTTP(t *testing.T) {
 			WithFS(rooted),
 		)
 		require.NoError(t, err)
-		assert.YAMLEq(t, string(yamlPetStore), string(b))
+		assert.YAMLEqT(t, string(yamlPetStore), string(b))
 	})
 
 	t.Run("should load from memory file system (single file)", func(t *testing.T) {
@@ -181,7 +181,7 @@ func TestLoadFromHTTP(t *testing.T) {
 			WithFS(mapfs),
 		)
 		require.NoError(t, err)
-		assert.Equal(t, string("content"), string(b))
+		assert.EqualT(t, string("content"), string(b))
 	})
 
 	t.Run("should load from local embedded file system (path)", func(t *testing.T) {
@@ -191,7 +191,7 @@ func TestLoadFromHTTP(t *testing.T) {
 			WithFS(embeddedFixtures),
 		)
 		require.NoError(t, err)
-		assert.YAMLEq(t, string(yamlPetStore), string(b))
+		assert.YAMLEqT(t, string(yamlPetStore), string(b))
 	})
 }
 
@@ -207,19 +207,19 @@ func TestLoadStrategy(t *testing.T) {
 	t.Run("should serve local strategy", func(t *testing.T) {
 		ldr := LoadStrategy("blah", loader, remLoader)
 		b, _ := ldr("")
-		assert.YAMLEq(t, string(yamlPetStore), string(b))
+		assert.YAMLEqT(t, string(yamlPetStore), string(b))
 	})
 
 	t.Run("should serve remote strategy with http", func(t *testing.T) {
 		ldr := LoadStrategy("http://blah", loader, remLoader)
 		b, _ := ldr("")
-		assert.Equal(t, thisIsNotIt, string(b))
+		assert.EqualT(t, thisIsNotIt, string(b))
 	})
 
 	t.Run("should serve remote strategy with https", func(t *testing.T) {
 		ldr := LoadStrategy("https://blah", loader, remLoader)
 		b, _ := ldr("")
-		assert.Equal(t, thisIsNotIt, string(b))
+		assert.EqualT(t, thisIsNotIt, string(b))
 	})
 }
 
@@ -374,17 +374,17 @@ func TestLoadStrategyFile(t *testing.T) {
 				b, err := loader(tc.Path)
 				if tc.ExpectError {
 					require.Error(t, err)
-					assert.False(t, called)
+					assert.FalseT(t, called)
 
 					return
 				}
 
 				require.NoError(t, err)
-				assert.True(t, called)
+				assert.TrueT(t, called)
 				assert.Equal(t, []byte(thisIsIt), b)
 
 				if tc.ExpectedWindows != "" && runtime.GOOS == "windows" {
-					assert.Equalf(t, tc.ExpectedWindows, pth,
+					assert.EqualTf(t, tc.ExpectedWindows, pth,
 						"expected local LoadStrategy(%q) to open: %q (windows)",
 						tc.Path, tc.ExpectedWindows,
 					)
@@ -392,7 +392,7 @@ func TestLoadStrategyFile(t *testing.T) {
 					return
 				}
 
-				assert.Equalf(t, tc.Expected, pth,
+				assert.EqualTf(t, tc.Expected, pth,
 					"expected local LoadStrategy(%q) to open: %q (any OS)",
 					tc.Path, tc.Expected,
 				)
diff --git a/loading/yaml_test.go b/loading/yaml_test.go
index 00652a73..4726d560 100644
--- a/loading/yaml_test.go
+++ b/loading/yaml_test.go
@@ -15,9 +15,9 @@ import (
 
 func TestYAMLMatcher(t *testing.T) {
 	t.Run("should recognize a yaml file", func(t *testing.T) {
-		assert.True(t, YAMLMatcher("local.yml"))
-		assert.True(t, YAMLMatcher("local.yaml"))
-		assert.False(t, YAMLMatcher("local.json"))
+		assert.TrueT(t, YAMLMatcher("local.yml"))
+		assert.TrueT(t, YAMLMatcher("local.yaml"))
+		assert.FalseT(t, YAMLMatcher("local.json"))
 	})
 }
 
diff --git a/loading_iface_test.go b/loading_iface_test.go
index 344cdaad..a3fb1e41 100644
--- a/loading_iface_test.go
+++ b/loading_iface_test.go
@@ -124,14 +124,14 @@ func TestLoadFromHTTP(t *testing.T) {
 			}
 			ldr := LoadStrategy("not_http", loader, remLoader)
 			b, _ := ldr("")
-			assert.Equal(t, "local", string(b))
+			assert.EqualT(t, "local", string(b))
 		})
 	})
 }
 
 func TestYAMLDoc(t *testing.T) {
 	t.Run("deprecated loading YAML functions should work", func(t *testing.T) {
-		require.True(t, YAMLMatcher("a.yml"))
+		require.TrueT(t, YAMLMatcher("a.yml"))
 
 		ts := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, _ *http.Request) {
 			rw.WriteHeader(http.StatusOK)
diff --git a/mangling/initialism_index_test.go b/mangling/initialism_index_test.go
index 96496dad..0ea8c817 100644
--- a/mangling/initialism_index_test.go
+++ b/mangling/initialism_index_test.go
@@ -70,13 +70,13 @@ func TestInitialismPlural(t *testing.T) {
 	idx.add("Series")
 	idx.add("Serie")
 
-	assert.Equal(t, simplePlural, idx.pluralForm("ID"))
-	assert.Equal(t, invariantPlural, idx.pluralForm("HTTP"))
-	assert.Equal(t, invariantPlural, idx.pluralForm("HTTPS"))
-	assert.Equal(t, invariantPlural, idx.pluralForm("DNS"))
-	assert.Equal(t, invariantPlural, idx.pluralForm("Serie"))
-	assert.Equal(t, invariantPlural, idx.pluralForm("Series"))
-	assert.Equal(t, notPlural, idx.pluralForm("xyz"))
+	assert.EqualT(t, simplePlural, idx.pluralForm("ID"))
+	assert.EqualT(t, invariantPlural, idx.pluralForm("HTTP"))
+	assert.EqualT(t, invariantPlural, idx.pluralForm("HTTPS"))
+	assert.EqualT(t, invariantPlural, idx.pluralForm("DNS"))
+	assert.EqualT(t, invariantPlural, idx.pluralForm("Serie"))
+	assert.EqualT(t, invariantPlural, idx.pluralForm("Series"))
+	assert.EqualT(t, notPlural, idx.pluralForm("xyz"))
 }
 
 func TestInitialismSanitize(t *testing.T) {
@@ -90,7 +90,7 @@ func TestInitialismSanitize(t *testing.T) {
 		for _, key := range ignoredKeys {
 			idx.add(key)
 			_, ok := idx.index[key]
-			assert.Falsef(t, ok,
+			assert.FalseTf(t, ok,
 				"expected key %q not to be indexed", key,
 			)
 		}
@@ -109,14 +109,14 @@ func TestInitialismSanitize(t *testing.T) {
 		for _, key := range trimmedKeys {
 			idx.add(key)
 			_, ok := idx.index[key]
-			assert.Falsef(t, ok,
+			assert.FalseTf(t, ok,
 				"expected key %q not to be indexed", key,
 			)
 
 			trimmedKey := strings.TrimSpace(key)
 			require.Len(t, trimmedKey, 3) // ensure trimmed
 			_, trimmedOk := idx.index[trimmedKey]
-			assert.Truef(t, trimmedOk,
+			assert.TrueTf(t, trimmedOk,
 				"expected %q (trimmed as %q) to be indexed", key, trimmedKey,
 			)
 		}
@@ -130,9 +130,9 @@ func TestInitialismSanitize(t *testing.T) {
 		idx.add(key)
 
 		_, ok := idx.index[key]
-		assert.False(t, ok)
+		assert.FalseT(t, ok)
 
 		_, capitalizedOk := idx.index[strings.ToUpper(key)]
-		assert.True(t, capitalizedOk)
+		assert.TrueT(t, capitalizedOk)
 	})
 }
diff --git a/mangling/name_lexem_test.go b/mangling/name_lexem_test.go
index e721f92c..241c1ad0 100644
--- a/mangling/name_lexem_test.go
+++ b/mangling/name_lexem_test.go
@@ -18,12 +18,12 @@ func TestLexemEdgeCases(t *testing.T) {
 
 		t.Run("should not titleize", func(t *testing.T) {
 			ok := l.WriteTitleized(&b, true)
-			assert.False(t, ok)
+			assert.FalseT(t, ok)
 			assert.Empty(t, b.Bytes())
 		})
 		t.Run("should not lower", func(t *testing.T) {
 			ok := l.WriteLower(&b, true)
-			assert.False(t, ok)
+			assert.FalseT(t, ok)
 			assert.Empty(t, b.Bytes())
 		})
 	})
@@ -35,12 +35,12 @@ func TestLexemEdgeCases(t *testing.T) {
 
 		t.Run("should not titleize", func(t *testing.T) {
 			ok := l.WriteTitleized(&b, true)
-			assert.False(t, ok)
+			assert.FalseT(t, ok)
 			assert.Empty(t, b.Bytes())
 		})
 		t.Run("should not lower", func(t *testing.T) {
 			ok := l.WriteLower(&b, true)
-			assert.False(t, ok)
+			assert.FalseT(t, ok)
 		})
 	})
 
@@ -51,12 +51,12 @@ func TestLexemEdgeCases(t *testing.T) {
 
 		t.Run("should titleize but do nothing", func(t *testing.T) {
 			ok := l.WriteTitleized(&b, true)
-			assert.True(t, ok)
+			assert.TrueT(t, ok)
 			assert.Empty(t, b.Bytes())
 		})
 		t.Run("should not lower but do nothing", func(t *testing.T) {
 			ok := l.WriteLower(&b, true)
-			assert.True(t, ok)
+			assert.TrueT(t, ok)
 			assert.Empty(t, b.Bytes())
 		})
 	})
diff --git a/mangling/name_mangler_test.go b/mangling/name_mangler_test.go
index fea133bf..626eacd0 100644
--- a/mangling/name_mangler_test.go
+++ b/mangling/name_mangler_test.go
@@ -29,9 +29,9 @@ func TestManglerToGoName_Issue158(t *testing.T) {
 	m := NewNameMangler()
 
 	t.Run("should detect trailing pluralized initialisms", func(t *testing.T) {
-		require.Equal(t, "LinkLocalIPs", m.ToGoName("LinkLocalIPs"))
-		require.Equal(t, "NativeBaseURLs", m.ToGoName("nativeBaseURLs"))
-		require.Equal(t, "SiteURLs", m.ToGoName("siteURLs"))
+		require.EqualT(t, "LinkLocalIPs", m.ToGoName("LinkLocalIPs"))
+		require.EqualT(t, "NativeBaseURLs", m.ToGoName("nativeBaseURLs"))
+		require.EqualT(t, "SiteURLs", m.ToGoName("siteURLs"))
 	})
 }
 
@@ -43,7 +43,7 @@ func TestManglerToGoName_Issue159(t *testing.T) {
 
 	// require.Equal(t, "TTLs", m.ToGoName("TTLs"))
 	// require.Equal(t, "TTLsS", m.ToGoName("TTLsS"))
-	require.Equal(t, "TTLss", m.ToGoName("TTLss"))
+	require.EqualT(t, "TTLss", m.ToGoName("TTLss"))
 }
 
 func TestManglerToGoName(t *testing.T) {
@@ -81,7 +81,7 @@ func TestManglerToGoName(t *testing.T) {
 		t.Run("ToGoName should convert names as expected", func(t *testing.T) {
 			for _, sample := range samples {
 				result := m.ToGoName(sample.str)
-				assert.Equal(t, sample.out, result,
+				assert.EqualT(t, sample.out, result,
 					"expected ToGoName(%q) == %q but got %q", sample.str, sample.out, result)
 			}
 		})
@@ -110,7 +110,7 @@ func TestManglerToGoName(t *testing.T) {
 
 			for _, sample := range samples {
 				result := m.ToGoName(sample.str)
-				assert.Equal(t, sample.out, result,
+				assert.EqualT(t, sample.out, result,
 					"with initialism %q, expected ToGoName(%q) == %q but got %q", k, sample.str, sample.out, result)
 			}
 		}
@@ -149,7 +149,7 @@ func TestManglerToGoName(t *testing.T) {
 			)
 
 			for _, sample := range samples {
-				assert.Equal(t, sample.out, m.ToGoName(sample.str))
+				assert.EqualT(t, sample.out, m.ToGoName(sample.str))
 			}
 		})
 
@@ -174,7 +174,7 @@ func TestManglerToGoName(t *testing.T) {
 			)
 
 			for _, sample := range samples {
-				assert.Equal(t, sample.out, m.ToGoName(sample.str))
+				assert.EqualT(t, sample.out, m.ToGoName(sample.str))
 			}
 		})
 	})
@@ -212,7 +212,7 @@ func TestManglerToGoName(t *testing.T) {
 		}
 
 		for _, sample := range samples {
-			assert.Equal(t, sample.out, m.ToGoName(sample.str))
+			assert.EqualT(t, sample.out, m.ToGoName(sample.str))
 		}
 	})
 
@@ -235,7 +235,7 @@ func TestManglerToGoName(t *testing.T) {
 			{"a€ b", "AEurob"},
 		}
 		for _, sample := range samples {
-			assert.Equal(t, sample.out, m.ToGoName(sample.str))
+			assert.EqualT(t, sample.out, m.ToGoName(sample.str))
 		}
 	})
 }
@@ -267,7 +267,7 @@ func TestManglerToFileName(t *testing.T) {
 
 	for _, sample := range samples {
 		result := m.ToFileName(sample.str)
-		assert.Equal(t, sample.out, m.ToFileName(sample.str),
+		assert.EqualT(t, sample.out, m.ToFileName(sample.str),
 			"ToFileName(%q) == %q but got %q", sample.str, sample.out, result)
 	}
 }
@@ -291,7 +291,7 @@ func TestManglerToCommandName(t *testing.T) {
 	}
 
 	for _, sample := range samples {
-		assert.Equal(t, sample.out, m.ToCommandName(sample.str))
+		assert.EqualT(t, sample.out, m.ToCommandName(sample.str))
 	}
 }
 
@@ -314,7 +314,7 @@ func TestManglerToHumanName(t *testing.T) {
 	}
 
 	for _, sample := range samples {
-		assert.Equal(t, sample.out, m.ToHumanNameLower(sample.str))
+		assert.EqualT(t, sample.out, m.ToHumanNameLower(sample.str))
 	}
 }
 
@@ -337,7 +337,7 @@ func TestManglerToJSONName(t *testing.T) {
 	}
 
 	for _, sample := range samples {
-		assert.Equal(t, sample.out, m.ToJSONName(sample.str))
+		assert.EqualT(t, sample.out, m.ToJSONName(sample.str))
 	}
 }
 
@@ -351,11 +351,11 @@ func TestManglerCamelize(t *testing.T) {
 	})
 
 	t.Run("with single byte", func(t *testing.T) {
-		assert.Equal(t, "A", m.Camelize("a"))
+		assert.EqualT(t, "A", m.Camelize("a"))
 	})
 
 	t.Run("with single multi-byte rune", func(t *testing.T) {
-		assert.Equal(t, "Ã", m.Camelize("ã"))
+		assert.EqualT(t, "Ã", m.Camelize("ã"))
 	})
 
 	samples := []translationSample{
@@ -377,7 +377,7 @@ func TestManglerCamelize(t *testing.T) {
 
 	for _, sample := range samples {
 		res := m.Camelize(sample.str)
-		assert.Equalf(t, sample.out, res, "expected Camelize(%q)=%q, got %q", sample.str, sample.out, res)
+		assert.EqualTf(t, sample.out, res, "expected Camelize(%q)=%q, got %q", sample.str, sample.out, res)
 	}
 }
 
@@ -403,7 +403,7 @@ func TestManglerToHumanNameTitle(t *testing.T) {
 
 	for _, sample := range samples {
 		res := m.ToHumanNameTitle(sample.str)
-		assert.Equalf(t, sample.out, res, "expected ToHumanNameTitle(%q)=%q, got %q", sample.str, sample.out, res)
+		assert.EqualTf(t, sample.out, res, "expected ToHumanNameTitle(%q)=%q, got %q", sample.str, sample.out, res)
 	}
 }
 
@@ -434,7 +434,7 @@ func TestManglerToVarName(t *testing.T) {
 
 	for _, sample := range samples {
 		res := m.ToVarName(sample.str)
-		assert.Equalf(t, sample.out, res, "expected ToVarName(%q)=%q, got %q", sample.str, sample.out, res)
+		assert.EqualTf(t, sample.out, res, "expected ToVarName(%q)=%q, got %q", sample.str, sample.out, res)
 	}
 
 	t.Run("with Unicode edge cases", func(t *testing.T) {
@@ -470,7 +470,7 @@ func TestManglerToVarName(t *testing.T) {
 		}
 
 		for _, sample := range samples {
-			assert.Equal(t, sample.out, m.ToVarName(sample.str))
+			assert.EqualT(t, sample.out, m.ToVarName(sample.str))
 		}
 	})
 }
@@ -480,9 +480,9 @@ func TestManglerInitialisms(t *testing.T) {
 		m := NewNameMangler()
 		m.AddInitialisms("ELB", "OLTP")
 
-		assert.Equal(t, "ELBEndpoint", m.ToGoName("elb_endpoint"))
-		assert.Equal(t, "HTTPEndpoint", m.ToGoName("http_endpoint"))
-		assert.Equal(t, "OLTPEndpoint", m.ToGoName("oltp endpoint"))
+		assert.EqualT(t, "ELBEndpoint", m.ToGoName("elb_endpoint"))
+		assert.EqualT(t, "HTTPEndpoint", m.ToGoName("http_endpoint"))
+		assert.EqualT(t, "OLTPEndpoint", m.ToGoName("oltp endpoint"))
 	})
 
 	t.Run("with Initialisms", func(t *testing.T) {
@@ -490,8 +490,8 @@ func TestManglerInitialisms(t *testing.T) {
 			WithInitialisms("ELB", "OLTP"),
 		)
 
-		assert.Equal(t, "ELBEndpoint", m.ToGoName("elb_endpoint"))
-		assert.Equal(t, "HttpEndpoint", m.ToGoName("http_endpoint")) // no recognized as initialisms (default override)
-		assert.Equal(t, "OLTPEndpoint", m.ToGoName("oltp endpoint"))
+		assert.EqualT(t, "ELBEndpoint", m.ToGoName("elb_endpoint"))
+		assert.EqualT(t, "HttpEndpoint", m.ToGoName("http_endpoint")) // no recognized as initialisms (default override)
+		assert.EqualT(t, "OLTPEndpoint", m.ToGoName("oltp endpoint"))
 	})
 }
diff --git a/mangling/split_test.go b/mangling/split_test.go
index 278409e4..a71b3fb0 100644
--- a/mangling/split_test.go
+++ b/mangling/split_test.go
@@ -29,8 +29,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 3)
 
-			assert.Equal(t, "PluralizedInitialismIDs", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_initialism_ids", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedInitialismIDs", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_initialism_ids", m.ToFileName(plurals))
 		})
 
 		t.Run("with initialism trailed by capital", func(t *testing.T) {
@@ -41,8 +41,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 4)
 
-			assert.Equal(t, "PluralizedInitialismIDsX", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_initialism_ids_x", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedInitialismIDsX", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_initialism_ids_x", m.ToFileName(plurals))
 		})
 
 		t.Run("with middle initialism", func(t *testing.T) {
@@ -53,8 +53,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 3)
 
-			assert.Equal(t, "PluralizedIDsInitialism", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_ids_initialism", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedIDsInitialism", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_ids_initialism", m.ToFileName(plurals))
 		})
 
 		t.Run("with upper-cased pluralized initialism", func(t *testing.T) {
@@ -65,8 +65,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 4)
 
-			assert.Equal(t, "PluralizedIDSInitialism", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_id_s_initialism", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedIDSInitialism", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_id_s_initialism", m.ToFileName(plurals))
 		})
 
 		t.Run("with leading initialism", func(t *testing.T) {
@@ -77,8 +77,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 3)
 
-			assert.Equal(t, "IDsPluralizedInitialism", m.ToGoName(plurals))
-			assert.Equal(t, "ids_pluralized_initialism", m.ToFileName(plurals))
+			assert.EqualT(t, "IDsPluralizedInitialism", m.ToGoName(plurals))
+			assert.EqualT(t, "ids_pluralized_initialism", m.ToFileName(plurals))
 		})
 
 		t.Run("with added non-default initialisms", func(t *testing.T) {
@@ -89,8 +89,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 3)
 
-			assert.Equal(t, "PluralizedInitialismELBs", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_initialism_elbs", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedInitialismELBs", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_initialism_elbs", m.ToFileName(plurals))
 		})
 	})
 
@@ -103,8 +103,8 @@ func TestSplitPluralized(t *testing.T) {
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 4)
 
-			assert.Equal(t, "PluralizedHTTPsInitialism", m.ToGoName(plurals))
-			assert.Equal(t, "pluralized_http_s_initialism", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedHTTPsInitialism", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralized_http_s_initialism", m.ToFileName(plurals))
 		})
 
 		t.Run("with continued word", func(t *testing.T) {
@@ -115,9 +115,9 @@ func TestSplitPluralized(t *testing.T) {
 
 				require.NotNil(t, lexems)
 				require.Len(t, *lexems, 9)
-				assert.Equal(t, "PluralizedHTTPsIsNotAnInitialism", m.ToGoName(plurals))
-				assert.Equal(t, "pluralizedHTTPsIsNotAnInitialism", m.ToVarName(plurals))
-				assert.Equal(t, "pluralized_h_t_t_ps_is_not_an_initialism", m.ToFileName(plurals))
+				assert.EqualT(t, "PluralizedHTTPsIsNotAnInitialism", m.ToGoName(plurals))
+				assert.EqualT(t, "pluralizedHTTPsIsNotAnInitialism", m.ToVarName(plurals))
+				assert.EqualT(t, "pluralized_h_t_t_ps_is_not_an_initialism", m.ToFileName(plurals))
 			})
 
 			t.Run("no initialism (pluralizable)", func(t *testing.T) {
@@ -127,9 +127,9 @@ func TestSplitPluralized(t *testing.T) {
 
 				require.NotNil(t, lexems)
 				require.Len(t, *lexems, 7)
-				assert.Equal(t, "PluralizedELBsisNotAnInitialism", m.ToGoName(plurals))
-				assert.Equal(t, "pluralizedELBsisNotAnInitialism", m.ToVarName(plurals))
-				assert.Equal(t, "pluralized_e_l_bsis_not_an_initialism", m.ToFileName(plurals))
+				assert.EqualT(t, "PluralizedELBsisNotAnInitialism", m.ToGoName(plurals))
+				assert.EqualT(t, "pluralizedELBsisNotAnInitialism", m.ToVarName(plurals))
+				assert.EqualT(t, "pluralized_e_l_bsis_not_an_initialism", m.ToFileName(plurals))
 			})
 
 			t.Run("no initialism (no plural)", func(t *testing.T) {
@@ -139,9 +139,9 @@ func TestSplitPluralized(t *testing.T) {
 
 				require.NotNil(t, lexems)
 				require.Len(t, *lexems, 8)
-				assert.Equal(t, "PluralizedELBxIsNotAnInitialism", m.ToGoName(plurals))
-				assert.Equal(t, "pluralizedELBxIsNotAnInitialism", m.ToVarName(plurals))
-				assert.Equal(t, "pluralized_e_l_bx_is_not_an_initialism", m.ToFileName(plurals))
+				assert.EqualT(t, "PluralizedELBxIsNotAnInitialism", m.ToGoName(plurals))
+				assert.EqualT(t, "pluralizedELBxIsNotAnInitialism", m.ToVarName(plurals))
+				assert.EqualT(t, "pluralized_e_l_bx_is_not_an_initialism", m.ToFileName(plurals))
 			})
 
 			t.Run("with initialism trailed by lowercase", func(t *testing.T) {
@@ -152,8 +152,8 @@ func TestSplitPluralized(t *testing.T) {
 				require.NotNil(t, lexems)
 				require.Len(t, *lexems, 4)
 
-				assert.Equal(t, "PluralizedInitialismIDsx", m.ToGoName(plurals))
-				assert.Equal(t, "pluralized_initialism_i_dsx", m.ToFileName(plurals))
+				assert.EqualT(t, "PluralizedInitialismIDsx", m.ToGoName(plurals))
+				assert.EqualT(t, "pluralized_initialism_i_dsx", m.ToFileName(plurals))
 			})
 		})
 
@@ -164,9 +164,9 @@ func TestSplitPluralized(t *testing.T) {
 
 			require.NotNil(t, lexems)
 			require.Len(t, *lexems, 5)
-			assert.Equal(t, "PluralizedHTTPSIsAnInitialism", m.ToGoName(plurals))
-			assert.Equal(t, "pluralizedHTTPSIsAnInitialism", m.ToVarName(plurals))
-			assert.Equal(t, "pluralized_https_is_an_initialism", m.ToFileName(plurals))
+			assert.EqualT(t, "PluralizedHTTPSIsAnInitialism", m.ToGoName(plurals))
+			assert.EqualT(t, "pluralizedHTTPSIsAnInitialism", m.ToVarName(plurals))
+			assert.EqualT(t, "pluralized_https_is_an_initialism", m.ToFileName(plurals))
 		})
 	})
 }
diff --git a/mangling/util_test.go b/mangling/util_test.go
index cdfdd975..3526a819 100644
--- a/mangling/util_test.go
+++ b/mangling/util_test.go
@@ -18,53 +18,53 @@ func titleize(s string) string { return strings.ToTitle(s[:1]) + lower(s[1:]) }
 
 func TestIsEqualFoldIgnoreSpace(t *testing.T) {
 	t.Run("should find equal", func(t *testing.T) {
-		require.True(t, isEqualFoldIgnoreSpace([]rune(""), ""))
-		require.True(t, isEqualFoldIgnoreSpace([]rune(""), "  "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune(""), ""))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune(""), "  "))
 
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), " a"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), "a "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), " a "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), " a"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), "a "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), " a "))
 
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), "\ta\t"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), "a"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("A"), "\u00A0a\u00A0"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), "\ta\t"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), "a"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("A"), "\u00A0a\u00A0"))
 
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), "ab "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), "ab "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " ab "))
 
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), "AB "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), "AB "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB "))
 
-		require.True(t, isEqualFoldIgnoreSpace([]rune("À"), " à"))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("À"), "à "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("À"), " à "))
-		require.True(t, isEqualFoldIgnoreSpace([]rune("À"), " à "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("À"), " à"))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("À"), "à "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("À"), " à "))
+		require.TrueT(t, isEqualFoldIgnoreSpace([]rune("À"), " à "))
 	})
 
 	t.Run("should find different", func(t *testing.T) {
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
 
-		require.False(t, isEqualFoldIgnoreSpace([]rune("AB"), " A B "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("AB"), " a b "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB \u00A0\u00A0x"))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB \u00A0\u00A0é"))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("AB"), " A B "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("AB"), " a b "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB \u00A0\u00A0x"))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("AB"), " AB \u00A0\u00A0é"))
 
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), ""))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), " b "))
 
-		require.False(t, isEqualFoldIgnoreSpace([]rune("A"), " à"))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("À"), " bà"))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("À"), "àb "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("À"), " a "))
-		require.False(t, isEqualFoldIgnoreSpace([]rune("À"), "Á"))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("A"), " à"))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("À"), " bà"))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("À"), "àb "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("À"), " a "))
+		require.FalseT(t, isEqualFoldIgnoreSpace([]rune("À"), "Á"))
 	})
 }
diff --git a/mangling_iface_test.go b/mangling_iface_test.go
index d447e4ce..1929a6a5 100644
--- a/mangling_iface_test.go
+++ b/mangling_iface_test.go
@@ -16,27 +16,27 @@ func TestManglingIface(t *testing.T) {
 	)
 
 	t.Run("deprecated name mangling functions should work", func(t *testing.T) {
-		assert.Equal(t, "HelloSwagger", ToGoName(sample))
-		assert.Equal(t, "HTTPServer", ToGoName(sampleWithInitialism))
-		assert.Equal(t, "helloSwagger", ToVarName(sample))
-		assert.Equal(t, "httpServer", ToVarName(sampleWithInitialism))
-		assert.Equal(t, "hello_swagger", ToFileName(sample))
-		assert.Equal(t, "http_server", ToFileName(sampleWithInitialism))
-		assert.Equal(t, "hello-swagger", ToCommandName(sample))
-		assert.Equal(t, "http-server", ToCommandName(sampleWithInitialism))
-		assert.Equal(t, "hello swagger", ToHumanNameLower(sample))
-		assert.Equal(t, "Http server", ToHumanNameLower(sampleWithInitialism))
-		assert.Equal(t, "Hello Swagger", ToHumanNameTitle(sample))
-		assert.Equal(t, "Http Server", ToHumanNameTitle(sampleWithInitialism))
-
-		assert.Equal(t, "Swagger", Camelize("SWAGGER"))
-		assert.Equal(t, "helloSwagger", ToJSONName(sample))
+		assert.EqualT(t, "HelloSwagger", ToGoName(sample))
+		assert.EqualT(t, "HTTPServer", ToGoName(sampleWithInitialism))
+		assert.EqualT(t, "helloSwagger", ToVarName(sample))
+		assert.EqualT(t, "httpServer", ToVarName(sampleWithInitialism))
+		assert.EqualT(t, "hello_swagger", ToFileName(sample))
+		assert.EqualT(t, "http_server", ToFileName(sampleWithInitialism))
+		assert.EqualT(t, "hello-swagger", ToCommandName(sample))
+		assert.EqualT(t, "http-server", ToCommandName(sampleWithInitialism))
+		assert.EqualT(t, "hello swagger", ToHumanNameLower(sample))
+		assert.EqualT(t, "Http server", ToHumanNameLower(sampleWithInitialism))
+		assert.EqualT(t, "Hello Swagger", ToHumanNameTitle(sample))
+		assert.EqualT(t, "Http Server", ToHumanNameTitle(sampleWithInitialism))
+
+		assert.EqualT(t, "Swagger", Camelize("SWAGGER"))
+		assert.EqualT(t, "helloSwagger", ToJSONName(sample))
 
 		t.Run("with global config", func(t *testing.T) {
 			AddInitialisms("ELB")                                   // adding non-default initialism
 			GoNamePrefixFunc = func(_ string) string { return "Z" } // adding non-default prefix function
 
-			assert.Equal(t, "Z本HelloELB", ToGoName("本 hello Elb"))
+			assert.EqualT(t, "Z本HelloELB", ToGoName("本 hello Elb"))
 		})
 	})
 }
diff --git a/netutils/net_test.go b/netutils/net_test.go
index b4309d20..1a0d590e 100644
--- a/netutils/net_test.go
+++ b/netutils/net_test.go
@@ -32,7 +32,7 @@ func TestSplitHostPort(t *testing.T) {
 			require.Error(t, err)
 		}
 
-		assert.Equal(t, e.Host, h)
-		assert.Equal(t, e.Port, p)
+		assert.EqualT(t, e.Host, h)
+		assert.EqualT(t, e.Port, p)
 	}
 }
diff --git a/netutils_iface_test.go b/netutils_iface_test.go
index 45635af7..84441086 100644
--- a/netutils_iface_test.go
+++ b/netutils_iface_test.go
@@ -14,7 +14,7 @@ func TestNetUtilsIface(t *testing.T) {
 	t.Run("deprecated functions should work", func(t *testing.T) {
 		host, port, err := SplitHostPort("localhost:1000")
 		require.NoError(t, err)
-		assert.Equal(t, "localhost", host)
-		assert.Equal(t, 1000, port)
+		assert.EqualT(t, "localhost", host)
+		assert.EqualT(t, 1000, port)
 	})
 }
diff --git a/stringutils/strings_test.go b/stringutils/strings_test.go
index de31b517..9f8bd0df 100644
--- a/stringutils/strings_test.go
+++ b/stringutils/strings_test.go
@@ -12,20 +12,20 @@ import (
 func TestContainsStringsCI(t *testing.T) {
 	list := []string{"hello", "world", "and", "such"}
 
-	assert.True(t, ContainsStringsCI(list, "hELLo"))
-	assert.True(t, ContainsStringsCI(list, "world"))
-	assert.True(t, ContainsStringsCI(list, "AND"))
-	assert.False(t, ContainsStringsCI(list, "nuts"))
+	assert.TrueT(t, ContainsStringsCI(list, "hELLo"))
+	assert.TrueT(t, ContainsStringsCI(list, "world"))
+	assert.TrueT(t, ContainsStringsCI(list, "AND"))
+	assert.FalseT(t, ContainsStringsCI(list, "nuts"))
 }
 
 func TestContainsStrings(t *testing.T) {
 	list := []string{"hello", "world", "and", "such"}
 
-	assert.True(t, ContainsStrings(list, "hello"))
-	assert.False(t, ContainsStrings(list, "hELLo"))
-	assert.True(t, ContainsStrings(list, "world"))
-	assert.False(t, ContainsStrings(list, "World"))
-	assert.True(t, ContainsStrings(list, "and"))
-	assert.False(t, ContainsStrings(list, "AND"))
-	assert.False(t, ContainsStrings(list, "nuts"))
+	assert.TrueT(t, ContainsStrings(list, "hello"))
+	assert.FalseT(t, ContainsStrings(list, "hELLo"))
+	assert.TrueT(t, ContainsStrings(list, "world"))
+	assert.FalseT(t, ContainsStrings(list, "World"))
+	assert.TrueT(t, ContainsStrings(list, "and"))
+	assert.FalseT(t, ContainsStrings(list, "AND"))
+	assert.FalseT(t, ContainsStrings(list, "nuts"))
 }
diff --git a/stringutils_iface_test.go b/stringutils_iface_test.go
index 2fcd43cd..55bdf4bf 100644
--- a/stringutils_iface_test.go
+++ b/stringutils_iface_test.go
@@ -12,8 +12,8 @@ import (
 
 func TestStringUtilsIface(t *testing.T) {
 	t.Run("deprecated functions should work", func(t *testing.T) {
-		assert.True(t, ContainsStrings([]string{"a", "b"}, "a"))
-		assert.True(t, ContainsStringsCI([]string{"a", "b"}, "A"))
+		assert.TrueT(t, ContainsStrings([]string{"a", "b"}, "a"))
+		assert.TrueT(t, ContainsStringsCI([]string{"a", "b"}, "A"))
 		require.Len(t, JoinByFormat([]string{"a", "b"}, "pipes"), 1)
 		require.Len(t, SplitByFormat("a|b", "pipes"), 2)
 	})
diff --git a/typeutils/types_test.go b/typeutils/types_test.go
index b5c891a8..2114ad56 100644
--- a/typeutils/types_test.go
+++ b/typeutils/types_test.go
@@ -135,7 +135,7 @@ func TestIsNil(t *testing.T) {
 		c,
 		f,
 	} {
-		require.True(t, IsNil(value))
+		require.TrueT(t, IsNil(value))
 	}
 
 	for _, value := range []any{
@@ -147,7 +147,7 @@ func TestIsNil(t *testing.T) {
 		"",
 		false,
 	} {
-		require.False(t, IsNil(value))
+		require.FalseT(t, IsNil(value))
 	}
 
 }
diff --git a/typeutils_iface_test.go b/typeutils_iface_test.go
index b4fe8639..56ece905 100644
--- a/typeutils_iface_test.go
+++ b/typeutils_iface_test.go
@@ -12,6 +12,6 @@ import (
 func TestTypeUtilsIface(t *testing.T) {
 	t.Run("deprecated type utility functions should work", func(t *testing.T) {
 		// only check happy path - more comprehensive testing is carried out inside the called package
-		require.True(t, IsZero(0))
+		require.TrueT(t, IsZero(0))
 	})
 }
diff --git a/yamlutils/ordered_map_test.go b/yamlutils/ordered_map_test.go
index 7562dce3..efe10b39 100644
--- a/yamlutils/ordered_map_test.go
+++ b/yamlutils/ordered_map_test.go
@@ -43,9 +43,9 @@ func TestOrderedMap(t *testing.T) {
 						require.NotEmpty(t, y) // "null" token
 					}
 					b, ok := y.([]byte)
-					require.True(t, ok)
+					require.TrueT(t, ok)
 
-					assert.Equal(t, test.YAMLPayload, string(b))
+					assert.EqualT(t, test.YAMLPayload, string(b))
 				})
 
 				t.Run("should marshal back to JSON", func(t *testing.T) {
@@ -98,9 +98,9 @@ func TestOrderedMap(t *testing.T) {
 						require.NoError(t, err)
 
 						text, ok := reconstructed.([]byte)
-						require.True(t, ok)
+						require.TrueT(t, ok)
 
-						assert.YAMLEq(t, string(fixture2224), string(text))
+						assert.YAMLEqT(t, string(fixture2224), string(text))
 					})
 
 					t.Run("should marshal back to JSON", func(t *testing.T) {
@@ -130,7 +130,7 @@ func TestMarshalYAML(t *testing.T) {
 		require.NoError(t, json.Unmarshal([]byte(jazon), &data))
 		ny, err := data.MarshalYAML()
 		require.NoError(t, err)
-		assert.Equal(t, expected, string(ny.([]byte)))
+		assert.EqualT(t, expected, string(ny.([]byte)))
 	})
 
 	t.Run("marshalYAML should be deterministic", func(t *testing.T) {
@@ -144,7 +144,7 @@ func TestMarshalYAML(t *testing.T) {
 			require.NoError(t, json.Unmarshal([]byte(jazon), &data))
 			ny, err := data.MarshalYAML()
 			require.NoError(t, err)
-			assert.Equal(t, expected, string(ny.([]byte)))
+			assert.EqualT(t, expected, string(ny.([]byte)))
 		}
 	})
 
@@ -165,9 +165,9 @@ func TestMarshalYAML(t *testing.T) {
 				require.NoError(t, err)
 				require.NotNil(t, y)
 				b, ok := y.([]byte)
-				require.True(t, ok)
+				require.TrueT(t, ok)
 
-				assert.Equal(t, expected, string(b))
+				assert.EqualT(t, expected, string(b))
 			})
 
 			t.Run("should marshal back to JSON", func(t *testing.T) {
@@ -201,9 +201,9 @@ a:
 			require.NoError(t, err)
 			require.NotNil(t, y)
 			b, ok := y.([]byte)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 
-			assert.YAMLEq(t, expected, string(b))
+			assert.YAMLEqT(t, expected, string(b))
 		})
 	})
 
@@ -296,7 +296,7 @@ float:
 			require.NoError(t, err)
 			require.NotNil(t, y)
 			b, ok := y.([]byte)
-			require.True(t, ok)
+			require.TrueT(t, ok)
 
 			fixtures.YAMLEqualOrdered(t, expected, string(b))
 		})
diff --git a/yamlutils/yaml_test.go b/yamlutils/yaml_test.go
index b2f4ea6f..ece53aa7 100644
--- a/yamlutils/yaml_test.go
+++ b/yamlutils/yaml_test.go
@@ -203,7 +203,7 @@ func TestWithYKey(t *testing.T) {
 		} `json:"definitions"`
 	}
 	require.NoError(t, json.Unmarshal(jsond, &yt))
-	assert.Equal(t, "integer", yt.Definitions.Viewbox.Properties.Y.Type)
+	assert.EqualT(t, "integer", yt.Definitions.Viewbox.Properties.Y.Type)
 }
 
 func TestMapKeyTypes(t *testing.T) {
@@ -232,7 +232,7 @@ func TestYAMLTags(t *testing.T) {
 		t.Run("doc should marshal as the original doc", func(t *testing.T) {
 			text, err := yaml.Marshal(doc)
 			require.NoError(t, err)
-			assert.YAMLEq(t, string(fixtureSpecTags), string(text))
+			assert.YAMLEqT(t, string(fixtureSpecTags), string(text))
 		})
 
 		t.Run("doc should marshal to JSON", func(t *testing.T) {
@@ -248,12 +248,12 @@ func TestYAMLTags(t *testing.T) {
 					require.NoError(t, err)
 
 					buf, ok := text.([]byte)
-					require.True(t, ok)
+					require.TrueT(t, ok)
 
 					// standard YAML used by [assert.YAMLEq] interprets YAML timestamp as [time.Time],
 					// but in our context, we use string
 					neutralizeTimestamp := strings.ReplaceAll(string(fixtureSpecTags), "default:", "default: !!str ")
-					assert.YAMLEq(t, neutralizeTimestamp, string(buf))
+					assert.YAMLEqT(t, neutralizeTimestamp, string(buf))
 				})
 			})
 		})