diff --git a/kbuilder/insert_test.go b/kbuilder/insert_test.go
index 88b6058..ed7f21e 100644
--- a/kbuilder/insert_test.go
+++ b/kbuilder/insert_test.go
@@ -3,7 +3,7 @@ package kbuilder_test
 import (
 	"testing"
 
-	"github.com/ditointernet/go-assert"
+	tt "github.com/vingarcia/ksql/internal/testtools"
 	"github.com/vingarcia/ksql/kbuilder"
 )
 
@@ -80,13 +80,13 @@ func TestInsertQuery(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.desc, func(t *testing.T) {
 			b, err := kbuilder.New("postgres")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			query, params, err := b.Build(test.query)
 
 			expectError(t, test.expectedErr, err)
-			assert.Equal(t, test.expectedQuery, query)
-			assert.Equal(t, test.expectedParams, params)
+			tt.AssertEqual(t, query, test.expectedQuery)
+			tt.AssertEqual(t, params, test.expectedParams)
 		})
 	}
 }
diff --git a/kbuilder/query_test.go b/kbuilder/query_test.go
index d1eec32..dfd0c78 100644
--- a/kbuilder/query_test.go
+++ b/kbuilder/query_test.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/ditointernet/go-assert"
 	"github.com/stretchr/testify/require"
+	tt "github.com/vingarcia/ksql/internal/testtools"
 	"github.com/vingarcia/ksql/kbuilder"
 )
 
@@ -124,13 +124,13 @@ func TestSelectQuery(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.desc, func(t *testing.T) {
 			b, err := kbuilder.New("postgres")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			query, params, err := b.Build(test.query)
 
 			expectError(t, test.expectedErr, err)
-			assert.Equal(t, test.expectedQuery, query)
-			assert.Equal(t, test.expectedParams, params)
+			tt.AssertEqual(t, query, test.expectedQuery)
+			tt.AssertEqual(t, params, test.expectedParams)
 		})
 	}
 }
diff --git a/ksql_test.go b/ksql_test.go
index d1e8bbf..1f3b579 100644
--- a/ksql_test.go
+++ b/ksql_test.go
@@ -3,8 +3,6 @@ package ksql
 import (
 	"testing"
 
-	"github.com/ditointernet/go-assert"
-
 	tt "github.com/vingarcia/ksql/internal/testtools"
 )
 
@@ -25,9 +23,9 @@ func TestNewAdapterWith(t *testing.T) {
 				dialectName,
 			)
 
-			assert.Equal(t, nil, err)
-			assert.Equal(t, supportedDialects[dialectName], db.dialect)
-			assert.Equal(t, dialectName, db.driver)
+			tt.AssertNoErr(t, err)
+			tt.AssertEqual(t, db.dialect, supportedDialects[dialectName])
+			tt.AssertEqual(t, db.driver, dialectName)
 		}
 	})
 
@@ -37,6 +35,6 @@ func TestNewAdapterWith(t *testing.T) {
 			"fake-dialect-name",
 		)
 
-		assert.NotEqual(t, nil, err)
+		tt.AssertNotEqual(t, err, nil)
 	})
 }
diff --git a/ksqltest/testhelpers_test.go b/ksqltest/testhelpers_test.go
index 6dda318..f582e6f 100644
--- a/ksqltest/testhelpers_test.go
+++ b/ksqltest/testhelpers_test.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/ditointernet/go-assert"
 	tt "github.com/vingarcia/ksql/internal/testtools"
 	"github.com/vingarcia/ksql/nullable"
 )
@@ -20,11 +19,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "my name",
 			"age_attr":  22,
-		}, m)
+		})
 	})
 
 	t.Run("should not ignore zero value attrs, if they are not pointers", func(t *testing.T) {
@@ -33,11 +32,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  0,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "",
 			"age_attr":  0,
-		}, m)
+		})
 	})
 
 	type S2 struct {
@@ -53,11 +52,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  &age,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name": "",
 			"age":  0,
-		}, m)
+		})
 	})
 
 	t.Run("should ignore nil pointers", func(t *testing.T) {
@@ -66,8 +65,8 @@ func TestStructToMap(t *testing.T) {
 			Age:  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{}, m)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{})
 	})
 
 	t.Run("should ignore fields not tagged with ksql", func(t *testing.T) {
@@ -81,11 +80,11 @@ func TestStructToMap(t *testing.T) {
 			NotPartOfTheQuery: 42,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "fake-name",
 			"age_attr":  42,
-		}, m)
+		})
 	})
 
 	t.Run("should return error for duplicated ksql tag names", func(t *testing.T) {
@@ -99,7 +98,7 @@ func TestStructToMap(t *testing.T) {
 			DuplicatedName: "fake-duplicated-name",
 		})
 
-		assert.NotEqual(t, nil, err)
+		tt.AssertNotEqual(t, err, nil)
 	})
 
 	t.Run("should return error for structs with no ksql tags", func(t *testing.T) {
@@ -111,7 +110,7 @@ func TestStructToMap(t *testing.T) {
 			Age:  42,
 		})
 
-		assert.NotEqual(t, nil, err)
+		tt.AssertNotEqual(t, err, nil)
 	})
 }
 
@@ -126,9 +125,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "Breno", user.Name)
-		assert.Equal(t, 22, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "Breno")
+		tt.AssertEqual(t, user.Age, 22)
 	})
 
 	t.Run("should fill ptr fields with ptr values", func(t *testing.T) {
@@ -141,9 +140,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nullable.Int(22),
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, nullable.String("Breno"), user.Name)
-		assert.Equal(t, nullable.Int(22), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, nullable.String("Breno"))
+		tt.AssertEqual(t, user.Age, nullable.Int(22))
 	})
 
 	t.Run("should fill ptr fields with non-ptr values", func(t *testing.T) {
@@ -156,9 +155,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, nullable.String("Breno"), user.Name)
-		assert.Equal(t, nullable.Int(22), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, nullable.String("Breno"))
+		tt.AssertEqual(t, user.Age, nullable.Int(22))
 	})
 
 	t.Run("should fill non ptr fields with ptr values", func(t *testing.T) {
@@ -171,9 +170,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nullable.Int(22),
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "Breno", user.Name)
-		assert.Equal(t, 22, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "Breno")
+		tt.AssertEqual(t, user.Age, 22)
 	})
 
 	t.Run("should fill ptr fields with nil when necessary", func(t *testing.T) {
@@ -186,9 +185,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, (*string)(nil), user.Name)
-		assert.Equal(t, (*int)(nil), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, (*string)(nil))
+		tt.AssertEqual(t, user.Age, (*int)(nil))
 	})
 
 	t.Run("should interpret nil fields as zero values when necessary", func(t *testing.T) {
@@ -204,9 +203,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "", user.Name)
-		assert.Equal(t, 0, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "")
+		tt.AssertEqual(t, user.Age, 0)
 	})
 
 	t.Run("should ignore extra or missing fields", func(t *testing.T) {
@@ -295,7 +294,7 @@ func TestFillSliceWith(t *testing.T) {
 			},
 		})
 
-		tt.AssertEqual(t, err, nil)
+		tt.AssertNoErr(t, err)
 		tt.AssertEqual(t, len(users), 3)
 		tt.AssertEqual(t, users[0].Name, "Jorge")
 		tt.AssertEqual(t, users[1].Name, "Luciana")
diff --git a/kstructs/testhelpers_test.go b/kstructs/testhelpers_test.go
index 92f12bf..d7fd65b 100644
--- a/kstructs/testhelpers_test.go
+++ b/kstructs/testhelpers_test.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/ditointernet/go-assert"
 	tt "github.com/vingarcia/ksql/internal/testtools"
 	"github.com/vingarcia/ksql/nullable"
 )
@@ -20,11 +19,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "my name",
 			"age_attr":  22,
-		}, m)
+		})
 	})
 
 	t.Run("should not ignore zero value attrs, if they are not pointers", func(t *testing.T) {
@@ -33,11 +32,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  0,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "",
 			"age_attr":  0,
-		}, m)
+		})
 	})
 
 	type S2 struct {
@@ -53,11 +52,11 @@ func TestStructToMap(t *testing.T) {
 			Age:  &age,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name": "",
 			"age":  0,
-		}, m)
+		})
 	})
 
 	t.Run("should ignore nil pointers", func(t *testing.T) {
@@ -66,8 +65,8 @@ func TestStructToMap(t *testing.T) {
 			Age:  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{}, m)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{})
 	})
 
 	t.Run("should ignore fields not tagged with ksql", func(t *testing.T) {
@@ -81,11 +80,11 @@ func TestStructToMap(t *testing.T) {
 			NotPartOfTheQuery: 42,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, map[string]interface{}{
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, m, map[string]interface{}{
 			"name_attr": "fake-name",
 			"age_attr":  42,
-		}, m)
+		})
 	})
 
 	t.Run("should return error for duplicated ksql tag names", func(t *testing.T) {
@@ -99,7 +98,7 @@ func TestStructToMap(t *testing.T) {
 			DuplicatedName: "fake-duplicated-name",
 		})
 
-		assert.NotEqual(t, nil, err)
+		tt.AssertNotEqual(t, err, nil)
 	})
 
 	t.Run("should return error for structs with no ksql tags", func(t *testing.T) {
@@ -111,7 +110,7 @@ func TestStructToMap(t *testing.T) {
 			Age:  42,
 		})
 
-		assert.NotEqual(t, nil, err)
+		tt.AssertNotEqual(t, err, nil)
 	})
 }
 
@@ -126,9 +125,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "Breno", user.Name)
-		assert.Equal(t, 22, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "Breno")
+		tt.AssertEqual(t, user.Age, 22)
 	})
 
 	t.Run("should fill ptr fields with ptr values", func(t *testing.T) {
@@ -141,9 +140,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nullable.Int(22),
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, nullable.String("Breno"), user.Name)
-		assert.Equal(t, nullable.Int(22), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, nullable.String("Breno"))
+		tt.AssertEqual(t, user.Age, nullable.Int(22))
 	})
 
 	t.Run("should fill ptr fields with non-ptr values", func(t *testing.T) {
@@ -156,9 +155,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  22,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, nullable.String("Breno"), user.Name)
-		assert.Equal(t, nullable.Int(22), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, nullable.String("Breno"))
+		tt.AssertEqual(t, user.Age, nullable.Int(22))
 	})
 
 	t.Run("should fill non ptr fields with ptr values", func(t *testing.T) {
@@ -171,9 +170,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nullable.Int(22),
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "Breno", user.Name)
-		assert.Equal(t, 22, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "Breno")
+		tt.AssertEqual(t, user.Age, 22)
 	})
 
 	t.Run("should fill ptr fields with nil when necessary", func(t *testing.T) {
@@ -186,9 +185,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, (*string)(nil), user.Name)
-		assert.Equal(t, (*int)(nil), user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, (*string)(nil))
+		tt.AssertEqual(t, user.Age, (*int)(nil))
 	})
 
 	t.Run("should interpret nil fields as zero values when necessary", func(t *testing.T) {
@@ -204,9 +203,9 @@ func TestFillStructWith(t *testing.T) {
 			"age":  nil,
 		})
 
-		assert.Equal(t, nil, err)
-		assert.Equal(t, "", user.Name)
-		assert.Equal(t, 0, user.Age)
+		tt.AssertNoErr(t, err)
+		tt.AssertEqual(t, user.Name, "")
+		tt.AssertEqual(t, user.Age, 0)
 	})
 
 	t.Run("should ignore extra or missing fields", func(t *testing.T) {
@@ -295,7 +294,7 @@ func TestFillSliceWith(t *testing.T) {
 			},
 		})
 
-		tt.AssertEqual(t, err, nil)
+		tt.AssertNoErr(t, err)
 		tt.AssertEqual(t, len(users), 3)
 		tt.AssertEqual(t, users[0].Name, "Jorge")
 		tt.AssertEqual(t, users[1].Name, "Luciana")
diff --git a/test_adapters.go b/test_adapters.go
index fa3b4ae..8933807 100644
--- a/test_adapters.go
+++ b/test_adapters.go
@@ -6,10 +6,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"strings"
 	"testing"
 
-	"github.com/ditointernet/go-assert"
 	"github.com/pkg/errors"
 	tt "github.com/vingarcia/ksql/internal/testtools"
 	"github.com/vingarcia/ksql/nullable"
@@ -318,7 +316,7 @@ func QueryTest(
 						getUserByName(db, driver, &joao, "João Ribeiro")
 
 						_, err = db.ExecContext(ctx, `INSERT INTO users (name, age, address) VALUES ('Bia Ribeiro', 0, '{"country":"BR"}')`)
-						assert.Equal(t, nil, err)
+						tt.AssertNoErr(t, err)
 						var bia user
 						getUserByName(db, driver, &bia, "Bia Ribeiro")
 
@@ -723,15 +721,15 @@ func InsertTest(
 					}
 
 					err := c.Insert(ctx, usersTable, &u)
-					assert.Equal(t, nil, err)
-					assert.NotEqual(t, 0, u.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertNotEqual(t, u.ID, 0)
 
 					result := user{}
 					err = getUserByID(c.db, c.dialect, &result, u.ID)
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
-					assert.Equal(t, u.Name, result.Name)
-					assert.Equal(t, u.Address, result.Address)
+					tt.AssertEqual(t, result.Name, u.Name)
+					tt.AssertEqual(t, result.Address, u.Address)
 				})
 
 				t.Run("should insert ignoring the ID with multiple ids", func(t *testing.T) {
@@ -758,15 +756,15 @@ func InsertTest(
 					}
 
 					err = c.Insert(ctx, table, &u)
-					assert.Equal(t, nil, err)
-					assert.Equal(t, uint(0), u.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, u.ID, uint(0))
 
 					result := user{}
 					err = getUserByName(c.db, driver, &result, "No ID returned")
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
-					assert.Equal(t, u.Age, result.Age)
-					assert.Equal(t, u.Address, result.Address)
+					tt.AssertEqual(t, result.Age, u.Age)
+					tt.AssertEqual(t, result.Address, u.Address)
 				})
 
 				t.Run("should work with anonymous structs", func(t *testing.T) {
@@ -780,7 +778,7 @@ func InsertTest(
 						Name    string                 `ksql:"name"`
 						Address map[string]interface{} `ksql:"address,json"`
 					}{Name: "fake-name", Address: map[string]interface{}{"city": "bar"}})
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 				})
 
 				t.Run("should work with preset IDs", func(t *testing.T) {
@@ -796,12 +794,12 @@ func InsertTest(
 						Name string `ksql:"name"`
 						Age  int    `ksql:"age"`
 					}{Name: "Preset Name", Age: 5455})
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
 					var inserted user
 					err := getUserByName(db, driver, &inserted, "Preset Name")
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 5455, inserted.Age)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, inserted.Age, 5455)
 				})
 			})
 
@@ -885,27 +883,27 @@ func InsertTest(
 				c := newTestDB(db, driver)
 
 				err = c.Insert(ctx, usersTable, "foo")
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 
 				err = c.Insert(ctx, usersTable, nullable.String("foo"))
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 
 				err = c.Insert(ctx, usersTable, map[string]interface{}{
 					"name": "foo",
 					"age":  12,
 				})
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 
 				cantInsertSlice := []interface{}{
 					&user{Name: "foo", Age: 22},
 					&user{Name: "bar", Age: 32},
 				}
 				err = c.Insert(ctx, usersTable, cantInsertSlice)
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 
 				// We might want to support this in the future, but not for now:
 				err = c.Insert(ctx, usersTable, user{Name: "not a ptr to user", Age: 42})
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 			})
 
 			t.Run("should report error if for some reason the insertMethod is invalid", func(t *testing.T) {
@@ -919,7 +917,7 @@ func InsertTest(
 				c.dialect = brokenDialect{}
 
 				err = c.Insert(ctx, usersTable, &user{Name: "foo"})
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 			})
 
 			t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@@ -931,7 +929,7 @@ func InsertTest(
 
 				var u *user
 				err := c.Insert(ctx, usersTable, u)
-				assert.NotEqual(t, nil, err)
+				tt.AssertNotEqual(t, err, nil)
 			})
 
 			t.Run("should report error if table contains an empty ID name", func(t *testing.T) {
@@ -968,10 +966,8 @@ func InsertTest(
 					NonExistingColumn int    `ksql:"non_existing"`
 					Name              string `ksql:"name"`
 				}{NonExistingColumn: 42, Name: "fake-name"})
-				assert.NotEqual(t, nil, err)
-				msg := err.Error()
-				assert.Equal(t, true, strings.Contains(msg, "column"))
-				assert.Equal(t, true, strings.Contains(msg, "non_existing"))
+
+				tt.AssertErrContains(t, err, "column", "non_existing")
 			})
 
 			t.Run("should not panic if the ID column doesn't exist in the database", func(t *testing.T) {
@@ -1001,13 +997,13 @@ func InsertTest(
 					Age  int    `ksql:"age"`
 					Name string `ksql:"name"`
 				}{Age: 42, Name: "Inserted With no ID"})
-				assert.Equal(t, nil, err)
+				tt.AssertNoErr(t, err)
 
 				var u user
 				err = getUserByName(db, driver, &u, "Inserted With no ID")
-				assert.Equal(t, nil, err)
-				assert.NotEqual(t, uint(0), u.ID)
-				assert.Equal(t, 42, u.Age)
+				tt.AssertNoErr(t, err)
+				tt.AssertNotEqual(t, u.ID, uint(0))
+				tt.AssertEqual(t, u.Age, 42)
 			})
 		})
 	})
@@ -1083,40 +1079,40 @@ func DeleteTest(
 					}
 
 					err := c.Insert(ctx, usersTable, &u1)
-					assert.Equal(t, nil, err)
-					assert.NotEqual(t, uint(0), u1.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertNotEqual(t, u1.ID, uint(0))
 
 					result := user{}
 					err = getUserByID(c.db, c.dialect, &result, u1.ID)
-					assert.Equal(t, nil, err)
-					assert.Equal(t, u1.ID, result.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, result.ID, u1.ID)
 
 					u2 := user{
 						Name: "Won't be deleted",
 					}
 
 					err = c.Insert(ctx, usersTable, &u2)
-					assert.Equal(t, nil, err)
-					assert.NotEqual(t, uint(0), u2.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertNotEqual(t, u2.ID, uint(0))
 
 					result = user{}
 					err = getUserByID(c.db, c.dialect, &result, u2.ID)
-					assert.Equal(t, nil, err)
-					assert.Equal(t, u2.ID, result.ID)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, result.ID, u2.ID)
 
 					err = c.Delete(ctx, usersTable, test.deletionKeyForUser(u1))
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
 					result = user{}
 					err = getUserByID(c.db, c.dialect, &result, u1.ID)
-					assert.Equal(t, sql.ErrNoRows, err)
+					tt.AssertEqual(t, err, sql.ErrNoRows)
 
 					result = user{}
 					err = getUserByID(c.db, c.dialect, &result, u2.ID)
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
-					assert.NotEqual(t, uint(0), result.ID)
-					assert.Equal(t, "Won't be deleted", result.Name)
+					tt.AssertNotEqual(t, result.ID, uint(0))
+					tt.AssertEqual(t, result.Name, "Won't be deleted")
 				})
 			}
 		})
@@ -1200,7 +1196,7 @@ func DeleteTest(
 			c := newTestDB(db, driver)
 
 			err = c.Delete(ctx, usersTable, 4200)
-			assert.Equal(t, ErrRecordNotFound, err)
+			tt.AssertEqual(t, err, ErrRecordNotFound)
 		})
 
 		t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@@ -1212,7 +1208,7 @@ func DeleteTest(
 
 			var u *user
 			err := c.Delete(ctx, usersTable, u)
-			assert.NotEqual(t, nil, err)
+			tt.AssertNotEqual(t, err, nil)
 		})
 
 		t.Run("should report error if one of the ids is missing from the input", func(t *testing.T) {
@@ -1361,22 +1357,22 @@ func UpdateTest(
 				Name: "Letícia",
 			}
 			_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 0)`)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			err = getUserByName(db, driver, &u, "Letícia")
-			assert.Equal(t, nil, err)
-			assert.NotEqual(t, uint(0), u.ID)
+			tt.AssertNoErr(t, err)
+			tt.AssertNotEqual(t, u.ID, uint(0))
 
 			err = c.Update(ctx, usersTable, user{
 				ID:   u.ID,
 				Name: "Thayane",
 			})
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var result user
 			err = getUserByID(c.db, c.dialect, &result, u.ID)
-			assert.Equal(t, nil, err)
-			assert.Equal(t, "Thayane", result.Name)
+			tt.AssertNoErr(t, err)
+			tt.AssertEqual(t, result.Name, "Thayane")
 		})
 
 		t.Run("should update one &user{} correctly", func(t *testing.T) {
@@ -1390,22 +1386,22 @@ func UpdateTest(
 				Name: "Letícia",
 			}
 			_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 0)`)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			err = getUserByName(db, driver, &u, "Letícia")
-			assert.Equal(t, nil, err)
-			assert.NotEqual(t, uint(0), u.ID)
+			tt.AssertNoErr(t, err)
+			tt.AssertNotEqual(t, u.ID, uint(0))
 
 			err = c.Update(ctx, usersTable, &user{
 				ID:   u.ID,
 				Name: "Thayane",
 			})
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var result user
 			err = getUserByID(c.db, c.dialect, &result, u.ID)
-			assert.Equal(t, nil, err)
-			assert.Equal(t, "Thayane", result.Name)
+			tt.AssertNoErr(t, err)
+			tt.AssertEqual(t, result.Name, "Thayane")
 		})
 
 		t.Run("should ignore null pointers on partial updates", func(t *testing.T) {
@@ -1422,12 +1418,12 @@ func UpdateTest(
 			}
 
 			_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 22)`)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var u user
 			err = getUserByName(db, driver, &u, "Letícia")
-			assert.Equal(t, nil, err)
-			assert.NotEqual(t, uint(0), u.ID)
+			tt.AssertNoErr(t, err)
+			tt.AssertNotEqual(t, u.ID, uint(0))
 
 			err = c.Update(ctx, usersTable, partialUser{
 				ID: u.ID,
@@ -1436,13 +1432,13 @@ func UpdateTest(
 				// Should not be updated because it is null:
 				Age: nil,
 			})
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var result user
 			err = getUserByID(c.db, c.dialect, &result, u.ID)
-			assert.Equal(t, nil, err)
-			assert.Equal(t, "", result.Name)
-			assert.Equal(t, 22, result.Age)
+			tt.AssertNoErr(t, err)
+			tt.AssertEqual(t, result.Name, "")
+			tt.AssertEqual(t, result.Age, 22)
 		})
 
 		t.Run("should update valid pointers on partial updates", func(t *testing.T) {
@@ -1459,12 +1455,12 @@ func UpdateTest(
 			}
 
 			_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 22)`)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var u user
 			err = getUserByName(db, driver, &u, "Letícia")
-			assert.Equal(t, nil, err)
-			assert.NotEqual(t, uint(0), u.ID)
+			tt.AssertNoErr(t, err)
+			tt.AssertNotEqual(t, u.ID, uint(0))
 
 			// Should update all fields:
 			err = c.Update(ctx, usersTable, partialUser{
@@ -1472,14 +1468,14 @@ func UpdateTest(
 				Name: "Thay",
 				Age:  nullable.Int(42),
 			})
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var result user
 			err = getUserByID(c.db, c.dialect, &result, u.ID)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
-			assert.Equal(t, "Thay", result.Name)
-			assert.Equal(t, 42, result.Age)
+			tt.AssertEqual(t, result.Name, "Thay")
+			tt.AssertEqual(t, result.Age, 42)
 		})
 
 		t.Run("should return ErrRecordNotFound when asked to update an inexistent user", func(t *testing.T) {
@@ -1493,7 +1489,7 @@ func UpdateTest(
 				ID:   4200,
 				Name: "Thayane",
 			})
-			assert.Equal(t, ErrRecordNotFound, err)
+			tt.AssertEqual(t, err, ErrRecordNotFound)
 		})
 
 		t.Run("should report database errors correctly", func(t *testing.T) {
@@ -1507,7 +1503,7 @@ func UpdateTest(
 				ID:   1,
 				Name: "Thayane",
 			})
-			assert.NotEqual(t, nil, err)
+			tt.AssertNotEqual(t, err, nil)
 		})
 
 		t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@@ -1519,7 +1515,7 @@ func UpdateTest(
 
 			var u *user
 			err := c.Update(ctx, usersTable, u)
-			assert.NotEqual(t, nil, err)
+			tt.AssertNotEqual(t, err, nil)
 		})
 	})
 }
@@ -1581,11 +1577,11 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 1, length)
-					assert.NotEqual(t, uint(0), u.ID)
-					assert.Equal(t, "User1", u.Name)
-					assert.Equal(t, "BR", u.Address.Country)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, length, 1)
+					tt.AssertNotEqual(t, u.ID, uint(0))
+					tt.AssertEqual(t, u.Name, "User1")
+					tt.AssertEqual(t, u.Address.Country, "BR")
 				})
 
 				t.Run("should query one chunk correctly", func(t *testing.T) {
@@ -1617,17 +1613,17 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 1, len(lengths))
-					assert.Equal(t, 2, lengths[0])
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(lengths), 1)
+					tt.AssertEqual(t, lengths[0], 2)
 
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.Equal(t, "US", users[0].Address.Country)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertEqual(t, users[0].Address.Country, "US")
 
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.Equal(t, "BR", users[1].Address.Country)
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertEqual(t, users[1].Address.Country, "BR")
 				})
 
 				t.Run("should query chunks of 1 correctly", func(t *testing.T) {
@@ -1659,17 +1655,17 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 2, len(users))
-					assert.Equal(t, []int{1, 1}, lengths)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(users), 2)
+					tt.AssertEqual(t, lengths, []int{1, 1})
 
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.Equal(t, "US", users[0].Address.Country)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertEqual(t, users[0].Address.Country, "US")
 
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.Equal(t, "BR", users[1].Address.Country)
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertEqual(t, users[1].Address.Country, "BR")
 				})
 
 				t.Run("should load partially filled chunks correctly", func(t *testing.T) {
@@ -1702,15 +1698,15 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 3, len(users))
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.NotEqual(t, uint(0), users[2].ID)
-					assert.Equal(t, "User3", users[2].Name)
-					assert.Equal(t, []int{2, 1}, lengths)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(users), 3)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertNotEqual(t, users[2].ID, uint(0))
+					tt.AssertEqual(t, users[2].Name, "User3")
+					tt.AssertEqual(t, lengths, []int{2, 1})
 				})
 
 				// xxx
@@ -1738,11 +1734,11 @@ func QueryChunksTest(
 					_ = c.Insert(ctx, usersTable, &thatiana)
 
 					_, err := db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, thatiana.ID, `, 'Thatiana Post1')`))
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 					_, err = db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, thatiana.ID, `, 'Thatiana Post2')`))
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 					_, err = db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, joao.ID, `, 'Thiago Post1')`))
-					assert.Equal(t, nil, err)
+					tt.AssertNoErr(t, err)
 
 					var lengths []int
 					var users []user
@@ -1769,20 +1765,20 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 3, len(posts))
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(posts), 3)
 
-					assert.Equal(t, joao.ID, users[0].ID)
-					assert.Equal(t, "Thiago Ribeiro", users[0].Name)
-					assert.Equal(t, "Thiago Post1", posts[0].Title)
+					tt.AssertEqual(t, users[0].ID, joao.ID)
+					tt.AssertEqual(t, users[0].Name, "Thiago Ribeiro")
+					tt.AssertEqual(t, posts[0].Title, "Thiago Post1")
 
-					assert.Equal(t, thatiana.ID, users[1].ID)
-					assert.Equal(t, "Thatiana Ribeiro", users[1].Name)
-					assert.Equal(t, "Thatiana Post1", posts[1].Title)
+					tt.AssertEqual(t, users[1].ID, thatiana.ID)
+					tt.AssertEqual(t, users[1].Name, "Thatiana Ribeiro")
+					tt.AssertEqual(t, posts[1].Title, "Thatiana Post1")
 
-					assert.Equal(t, thatiana.ID, users[2].ID)
-					assert.Equal(t, "Thatiana Ribeiro", users[2].Name)
-					assert.Equal(t, "Thatiana Post2", posts[2].Title)
+					tt.AssertEqual(t, users[2].ID, thatiana.ID)
+					tt.AssertEqual(t, users[2].Name, "Thatiana Ribeiro")
+					tt.AssertEqual(t, posts[2].Title, "Thatiana Post2")
 				})
 
 				t.Run("should abort the first iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
@@ -1815,13 +1811,13 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 2, len(users))
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.Equal(t, []int{2}, lengths)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(users), 2)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertEqual(t, lengths, []int{2})
 				})
 
 				t.Run("should abort the last iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
@@ -1856,15 +1852,15 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.Equal(t, nil, err)
-					assert.Equal(t, 3, len(users))
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.NotEqual(t, uint(0), users[2].ID)
-					assert.Equal(t, "User3", users[2].Name)
-					assert.Equal(t, []int{2, 1}, lengths)
+					tt.AssertNoErr(t, err)
+					tt.AssertEqual(t, len(users), 3)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertNotEqual(t, users[2].ID, uint(0))
+					tt.AssertEqual(t, users[2].Name, "User3")
+					tt.AssertEqual(t, lengths, []int{2, 1})
 				})
 
 				t.Run("should return error if the callback returns an error in the first iteration", func(t *testing.T) {
@@ -1897,13 +1893,13 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.NotEqual(t, nil, err)
-					assert.Equal(t, 2, len(users))
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.Equal(t, []int{2}, lengths)
+					tt.AssertNotEqual(t, err, nil)
+					tt.AssertEqual(t, len(users), 2)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertEqual(t, lengths, []int{2})
 				})
 
 				t.Run("should return error if the callback returns an error in the last iteration", func(t *testing.T) {
@@ -1938,15 +1934,15 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.NotEqual(t, nil, err)
-					assert.Equal(t, 3, len(users))
-					assert.NotEqual(t, uint(0), users[0].ID)
-					assert.Equal(t, "User1", users[0].Name)
-					assert.NotEqual(t, uint(0), users[1].ID)
-					assert.Equal(t, "User2", users[1].Name)
-					assert.NotEqual(t, uint(0), users[2].ID)
-					assert.Equal(t, "User3", users[2].Name)
-					assert.Equal(t, []int{2, 1}, lengths)
+					tt.AssertNotEqual(t, err, nil)
+					tt.AssertEqual(t, len(users), 3)
+					tt.AssertNotEqual(t, users[0].ID, uint(0))
+					tt.AssertEqual(t, users[0].Name, "User1")
+					tt.AssertNotEqual(t, users[1].ID, uint(0))
+					tt.AssertEqual(t, users[1].Name, "User2")
+					tt.AssertNotEqual(t, users[2].ID, uint(0))
+					tt.AssertEqual(t, users[2].Name, "User3")
+					tt.AssertEqual(t, lengths, []int{2, 1})
 				})
 
 				t.Run("should report error if the input function is invalid", func(t *testing.T) {
@@ -1989,7 +1985,7 @@ func QueryChunksTest(
 							ChunkSize:    2,
 							ForEachChunk: fn,
 						})
-						assert.NotEqual(t, nil, err)
+						tt.AssertNotEqual(t, err, nil)
 					}
 				})
 
@@ -2008,7 +2004,7 @@ func QueryChunksTest(
 							return nil
 						},
 					})
-					assert.NotEqual(t, nil, err)
+					tt.AssertNotEqual(t, err, nil)
 				})
 
 				t.Run("should report error if using nested struct and the query starts with SELECT", func(t *testing.T) {
@@ -2031,9 +2027,7 @@ func QueryChunksTest(
 						},
 					})
 
-					assert.NotEqual(t, nil, err)
-					assert.Equal(t, true, strings.Contains(err.Error(), "nested struct"), "unexpected error msg: "+err.Error())
-					assert.Equal(t, true, strings.Contains(err.Error(), "feature"), "unexpected error msg: "+err.Error())
+					tt.AssertErrContains(t, err, "nested struct", "feature")
 				})
 			})
 		}
@@ -2069,11 +2063,11 @@ func TransactionTest(
 				db.Query(ctx, &users, "SELECT * FROM users ORDER BY id ASC")
 				return nil
 			})
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
-			assert.Equal(t, 2, len(users))
-			assert.Equal(t, "User1", users[0].Name)
-			assert.Equal(t, "User2", users[1].Name)
+			tt.AssertEqual(t, len(users), 2)
+			tt.AssertEqual(t, users[0].Name, "User1")
+			tt.AssertEqual(t, users[1].Name, "User2")
 		})
 
 		t.Run("should rollback when there are errors", func(t *testing.T) {
@@ -2095,22 +2089,22 @@ func TransactionTest(
 
 			err = c.Transaction(ctx, func(db Provider) error {
 				err = db.Insert(ctx, usersTable, &user{Name: "User3"})
-				assert.Equal(t, nil, err)
+				tt.AssertNoErr(t, err)
 				err = db.Insert(ctx, usersTable, &user{Name: "User4"})
-				assert.Equal(t, nil, err)
+				tt.AssertNoErr(t, err)
 				_, err = db.Exec(ctx, "UPDATE users SET age = 22")
-				assert.Equal(t, nil, err)
+				tt.AssertNoErr(t, err)
 
 				return errors.New("fake-error")
 			})
-			assert.NotEqual(t, nil, err)
-			assert.Equal(t, "fake-error", err.Error())
+			tt.AssertNotEqual(t, err, nil)
+			tt.AssertEqual(t, err.Error(), "fake-error")
 
 			var users []user
 			err = c.Query(ctx, &users, "SELECT * FROM users ORDER BY id ASC")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
-			assert.Equal(t, []user{u1, u2}, users)
+			tt.AssertEqual(t, users, []user{u1, u2})
 		})
 	})
 }
@@ -2140,17 +2134,17 @@ func ScanRowsTest(
 			_ = c.Insert(ctx, usersTable, &user{Name: "User3", Age: 43})
 
 			rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User2'")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 			defer rows.Close()
 
-			assert.Equal(t, true, rows.Next())
+			tt.AssertEqual(t, rows.Next(), true)
 
 			var u user
 			err = scanRows(dialect, rows, &u)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
-			assert.Equal(t, "User2", u.Name)
-			assert.Equal(t, 14, u.Age)
+			tt.AssertEqual(t, u.Name, "User2")
+			tt.AssertEqual(t, u.Age, 14)
 		})
 
 		t.Run("should ignore extra columns from query", func(t *testing.T) {
@@ -2167,10 +2161,10 @@ func ScanRowsTest(
 			_ = c.Insert(ctx, usersTable, &user{Name: "User1", Age: 22})
 
 			rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User1'")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 			defer rows.Close()
 
-			assert.Equal(t, true, rows.Next())
+			tt.AssertEqual(t, rows.Next(), true)
 
 			var u struct {
 				ID  int `ksql:"id"`
@@ -2180,9 +2174,9 @@ func ScanRowsTest(
 				// Name string `ksql:"name"`
 			}
 			err = scanRows(dialect, rows, &u)
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
-			assert.Equal(t, 22, u.Age)
+			tt.AssertEqual(t, u.Age, 22)
 		})
 
 		t.Run("should report error for closed rows", func(t *testing.T) {
@@ -2197,13 +2191,13 @@ func ScanRowsTest(
 			defer closer.Close()
 
 			rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User2'")
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 
 			var u user
 			err = rows.Close()
-			assert.Equal(t, nil, err)
+			tt.AssertNoErr(t, err)
 			err = scanRows(dialect, rows, &u)
-			assert.NotEqual(t, nil, err)
+			tt.AssertNotEqual(t, err, nil)
 		})
 
 		t.Run("should report if record is not a pointer", func(t *testing.T) {