Repository: cilium/ebpf
Pull request #1253 (2023-12-05 12:13:04)

test: Migrate tests to github.com/go-quicktest/qt
Fixes: #1251

lmb: @sayboras let me know when you've had a chance to rebase.
sayboras: > let me know when you've had a chance to rebase.

sure, I didn't notice that my local fork was using master instead of main.

Patch:
diff --git a/go.mod b/go.mod
index d23b64d..b93f662 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,7 @@ module github.com/cilium/ebpf
 go 1.20
 
 require (
-	github.com/frankban/quicktest v1.14.5
+	github.com/go-quicktest/qt v1.101.0
 	github.com/google/go-cmp v0.5.9
 	golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2
 	golang.org/x/sys v0.15.0
@@ -12,5 +12,5 @@ require (
 require (
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
-	github.com/rogpeppe/go-internal v1.9.0 // indirect
+	github.com/rogpeppe/go-internal v1.11.0 // indirect
 )
diff --git a/go.sum b/go.sum
index ae728e3..6879796 100644
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,6 @@
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/frankban/quicktest v1.14.5 h1:dfYrrRyLtiqT9GyKXgdh+k4inNeTvmGbuSgZ3lx3GhA=
-github.com/frankban/quicktest v1.14.5/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
+github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -8,8 +8,9 @@ github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3x
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2 h1:Jvc7gsqn21cJHCmAWx0LiimpP18LZmUxkT5Mp7EZ1mI=
 golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=


Test patch:
diff --git a/asm/instruction_test.go b/asm/instruction_test.go
index 48109fa..e8d3495 100644
--- a/asm/instruction_test.go
+++ b/asm/instruction_test.go
@@ -10,7 +10,7 @@ import (
 	"math"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 var test64bitImmProg = []byte{
@@ -110,23 +110,23 @@ func TestSignedJump(t *testing.T) {
 func TestInstructionRewriteMapConstant(t *testing.T) {
 	ins := LoadMapValue(R0, 123, 321)
 
-	qt.Assert(t, ins.MapPtr(), qt.Equals, 123)
-	qt.Assert(t, ins.mapOffset(), qt.Equals, uint32(321))
+	qt.Assert(t, qt.Equals(ins.MapPtr(), 123))
+	qt.Assert(t, qt.Equals(ins.mapOffset(), 321))
 
-	qt.Assert(t, ins.RewriteMapPtr(-1), qt.IsNil)
-	qt.Assert(t, ins.MapPtr(), qt.Equals, -1)
+	qt.Assert(t, qt.IsNil(ins.RewriteMapPtr(-1)))
+	qt.Assert(t, qt.Equals(ins.MapPtr(), -1))
 
-	qt.Assert(t, ins.RewriteMapPtr(1), qt.IsNil)
-	qt.Assert(t, ins.MapPtr(), qt.Equals, 1)
+	qt.Assert(t, qt.IsNil(ins.RewriteMapPtr(1)))
+	qt.Assert(t, qt.Equals(ins.MapPtr(), 1))
 
 	// mapOffset should be unchanged after rewriting the pointer.
-	qt.Assert(t, ins.mapOffset(), qt.Equals, uint32(321))
+	qt.Assert(t, qt.Equals(ins.mapOffset(), 321))
 
-	qt.Assert(t, ins.RewriteMapOffset(123), qt.IsNil)
-	qt.Assert(t, ins.mapOffset(), qt.Equals, uint32(123))
+	qt.Assert(t, qt.IsNil(ins.RewriteMapOffset(123)))
+	qt.Assert(t, qt.Equals(ins.mapOffset(), 123))
 
 	// MapPtr should be unchanged.
-	qt.Assert(t, ins.MapPtr(), qt.Equals, 1)
+	qt.Assert(t, qt.Equals(ins.MapPtr(), 1))
 
 	ins = Mov.Imm(R1, 32)
 	if err := ins.RewriteMapPtr(1); err == nil {
@@ -304,8 +304,6 @@ func TestInstructionIterator(t *testing.T) {
 }
 
 func TestMetadataCopyOnWrite(t *testing.T) {
-	c := qt.New(t)
-
 	// Setting metadata should copy Instruction and modify the metadata pointer
 	// of the new object without touching the old Instruction.
 
@@ -313,25 +311,25 @@ func TestMetadataCopyOnWrite(t *testing.T) {
 	ins := Ja.Label("my_func")
 	ins2 := ins.WithReference("my_func2")
 
-	c.Assert(ins.Reference(), qt.Equals, "my_func", qt.Commentf("WithReference updated ins"))
-	c.Assert(ins2.Reference(), qt.Equals, "my_func2", qt.Commentf("WithReference didn't update ins2"))
+	qt.Assert(t, qt.Equals(ins.Reference(), "my_func"), qt.Commentf("WithReference updated ins"))
+	qt.Assert(t, qt.Equals(ins2.Reference(), "my_func2"), qt.Commentf("WithReference didn't update ins2"))
 
 	// Symbol
 	ins = Ja.Label("").WithSymbol("my_sym")
 	ins2 = ins.WithSymbol("my_sym2")
 
-	c.Assert(ins.Symbol(), qt.Equals, "my_sym", qt.Commentf("WithSymbol updated ins"))
-	c.Assert(ins2.Symbol(), qt.Equals, "my_sym2", qt.Commentf("WithSymbol didn't update ins2"))
+	qt.Assert(t, qt.Equals(ins.Symbol(), "my_sym"), qt.Commentf("WithSymbol updated ins"))
+	qt.Assert(t, qt.Equals(ins2.Symbol(), "my_sym2"), qt.Commentf("WithSymbol didn't update ins2"))
 
 	// Map
 	ins = LoadMapPtr(R1, 0)
 	ins2 = ins
 
 	testMap := testFDer(1)
-	c.Assert(ins2.AssociateMap(testMap), qt.IsNil, qt.Commentf("failed to associate map with ins2"))
+	qt.Assert(t, qt.IsNil(ins2.AssociateMap(testMap)), qt.Commentf("failed to associate map with ins2"))
 
-	c.Assert(ins.Map(), qt.IsNil, qt.Commentf("AssociateMap updated ins"))
-	c.Assert(ins2.Map(), qt.Equals, testMap, qt.Commentf("AssociateMap didn't update ins2"))
+	qt.Assert(t, qt.IsNil(ins.Map()), qt.Commentf("AssociateMap updated ins"))
+	qt.Assert(t, qt.Equals[FDer](ins2.Map(), testMap), qt.Commentf("AssociateMap didn't update ins2"))
 }
 
 type testFDer int
diff --git a/asm/metadata_test.go b/asm/metadata_test.go
index 2d70a95..52fd5f8 100644
--- a/asm/metadata_test.go
+++ b/asm/metadata_test.go
@@ -4,44 +4,44 @@ import (
 	"testing"
 	"unsafe"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestMetadata(t *testing.T) {
 	var m Metadata
 
 	// Metadata should be the size of a pointer.
-	qt.Assert(t, unsafe.Sizeof(m), qt.Equals, unsafe.Sizeof(uintptr(0)))
+	qt.Assert(t, qt.Equals(unsafe.Sizeof(m), unsafe.Sizeof(uintptr(0))))
 
 	// A lookup in a nil meta should return nil.
-	qt.Assert(t, m.Get(bool(false)), qt.IsNil)
+	qt.Assert(t, qt.IsNil(m.Get(bool(false))))
 
 	// We can look up anything we inserted.
 	m.Set(bool(false), int(0))
 	m.Set(int(1), int(1))
-	qt.Assert(t, m.Get(bool(false)), qt.Equals, int(0))
-	qt.Assert(t, m.Get(int(1)), qt.Equals, int(1))
+	qt.Assert(t, qt.Equals(m.Get(bool(false)), 0))
+	qt.Assert(t, qt.Equals(m.Get(1), 1))
 
 	// We have copy on write semantics
 	old := m
 	m.Set(bool(false), int(1))
-	qt.Assert(t, m.Get(bool(false)), qt.Equals, int(1))
-	qt.Assert(t, m.Get(int(1)), qt.Equals, int(1))
-	qt.Assert(t, old.Get(bool(false)), qt.Equals, int(0))
-	qt.Assert(t, old.Get(int(1)), qt.Equals, int(1))
+	qt.Assert(t, qt.Equals(m.Get(bool(false)), 1))
+	qt.Assert(t, qt.Equals(m.Get(int(1)), 1))
+	qt.Assert(t, qt.Equals(old.Get(bool(false)), 0))
+	qt.Assert(t, qt.Equals(old.Get(int(1)), 1))
 
 	// Newtypes are handled distinctly.
 	type b bool
 	m.Set(b(false), int(42))
-	qt.Assert(t, m.Get(bool(false)), qt.Equals, int(1))
-	qt.Assert(t, m.Get(int(1)), qt.Equals, int(1))
-	qt.Assert(t, m.Get(b(false)), qt.Equals, int(42))
+	qt.Assert(t, qt.Equals(m.Get(bool(false)), 1))
+	qt.Assert(t, qt.Equals(m.Get(int(1)), 1))
+	qt.Assert(t, qt.Equals(m.Get(b(false)), 42))
 
 	// Setting nil removes a key.
 	m.Set(bool(false), nil)
-	qt.Assert(t, m.Get(bool(false)), qt.IsNil)
-	qt.Assert(t, m.Get(int(1)), qt.Equals, int(1))
-	qt.Assert(t, m.Get(b(false)), qt.Equals, int(42))
+	qt.Assert(t, qt.IsNil(m.Get(bool(false))))
+	qt.Assert(t, qt.Equals(m.Get(int(1)), 1))
+	qt.Assert(t, qt.Equals(m.Get(b(false)), 42))
 }
 
 func BenchmarkMetadata(b *testing.B) {
diff --git a/asm/opcode_test.go b/asm/opcode_test.go
index f6f7673..e73eb86 100644
--- a/asm/opcode_test.go
+++ b/asm/opcode_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestGetSetJumpOp(t *testing.T) {
@@ -13,11 +13,11 @@ func TestGetSetJumpOp(t *testing.T) {
 			opcode := OpCode(class).SetJumpOp(op)
 
 			if valid {
-				qt.Assert(t, opcode, qt.Not(qt.Equals), InvalidOpCode)
-				qt.Assert(t, opcode.JumpOp(), qt.Equals, op)
+				qt.Assert(t, qt.Not(qt.Equals(opcode, InvalidOpCode)))
+				qt.Assert(t, qt.Equals(opcode.JumpOp(), op))
 			} else {
-				qt.Assert(t, opcode, qt.Equals, InvalidOpCode)
-				qt.Assert(t, opcode.JumpOp(), qt.Equals, InvalidJumpOp)
+				qt.Assert(t, qt.Equals(opcode, InvalidOpCode))
+				qt.Assert(t, qt.Equals(opcode.JumpOp(), InvalidJumpOp))
 			}
 		})
 	}
diff --git a/btf/btf_test.go b/btf/btf_test.go
index 843acad..fd8790d 100644
--- a/btf/btf_test.go
+++ b/btf/btf_test.go
@@ -9,9 +9,10 @@ import (
 	"os"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
-	qt "github.com/frankban/quicktest"
 )
 
 func vmlinuxSpec(tb testing.TB) *Spec {
@@ -339,10 +340,10 @@ func TestSpecCopy(t *testing.T) {
 	cpy := spec.Copy()
 
 	have := typesFromSpec(t, spec)
-	qt.Assert(t, len(spec.types) > 0, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(len(spec.types) > 0))
 
 	want := typesFromSpec(t, cpy)
-	qt.Assert(t, want, qt.HasLen, len(have))
+	qt.Assert(t, qt.HasLen(want, len(have)))
 
 	for i := range want {
 		if _, ok := have[i].(*Void); ok {
@@ -362,10 +363,10 @@ func TestSpecTypeByID(t *testing.T) {
 	spec := specFromTypes(t, nil)
 
 	_, err := spec.TypeByID(0)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	_, err = spec.TypeByID(1)
-	qt.Assert(t, err, qt.ErrorIs, ErrNotFound)
+	qt.Assert(t, qt.ErrorIs(err, ErrNotFound))
 }
 
 func ExampleSpec_TypeByName() {
@@ -409,7 +410,7 @@ func TestTypesIterator(t *testing.T) {
 			t.Fatal("Iterator ended early at item", i)
 		}
 
-		qt.Assert(t, iter.Type, qt.DeepEquals, typ)
+		qt.Assert(t, qt.DeepEquals(iter.Type, typ))
 	}
 
 	if iter.Next() {
@@ -441,8 +442,8 @@ func TestLoadSplitSpecFromReader(t *testing.T) {
 	}
 
 	typeByID, err := splitSpec.TypeByID(typeID)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, typeByID, qt.Equals, typ)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(typeByID, typ))
 
 	fnType := typ.(*Func)
 	fnProto := fnType.Type.(*FuncProto)
@@ -492,15 +493,15 @@ func TestFixupDatasecLayout(t *testing.T) {
 		},
 	}
 
-	qt.Assert(t, fixupDatasecLayout(ds), qt.IsNil)
+	qt.Assert(t, qt.IsNil(fixupDatasecLayout(ds)))
 
-	qt.Assert(t, ds.Size, qt.Equals, uint32(40))
-	qt.Assert(t, ds.Vars[0].Offset, qt.Equals, uint32(0))
-	qt.Assert(t, ds.Vars[1].Offset, qt.Equals, uint32(4))
-	qt.Assert(t, ds.Vars[2].Offset, qt.Equals, uint32(5))
-	qt.Assert(t, ds.Vars[3].Offset, qt.Equals, uint32(6))
-	qt.Assert(t, ds.Vars[4].Offset, qt.Equals, uint32(16))
-	qt.Assert(t, ds.Vars[5].Offset, qt.Equals, uint32(32))
+	qt.Assert(t, qt.Equals(ds.Size, 40))
+	qt.Assert(t, qt.Equals(ds.Vars[0].Offset, 0))
+	qt.Assert(t, qt.Equals(ds.Vars[1].Offset, 4))
+	qt.Assert(t, qt.Equals(ds.Vars[2].Offset, 5))
+	qt.Assert(t, qt.Equals(ds.Vars[3].Offset, 6))
+	qt.Assert(t, qt.Equals(ds.Vars[4].Offset, 16))
+	qt.Assert(t, qt.Equals(ds.Vars[5].Offset, 32))
 }
 
 func BenchmarkSpecCopy(b *testing.B) {
diff --git a/btf/core_test.go b/btf/core_test.go
index 3308efb..a7c2c39 100644
--- a/btf/core_test.go
+++ b/btf/core_test.go
@@ -7,11 +7,12 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
+
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
-	"github.com/google/go-cmp/cmp"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 	"golang.org/x/exp/slices"
 )
 
@@ -256,9 +257,9 @@ func TestCOREFindEnumValue(t *testing.T) {
 	for _, test := range valid {
 		t.Run(test.name, func(t *testing.T) {
 			local, target, err := coreFindEnumValue(test.local, test.acc, test.target)
-			qt.Assert(t, err, qt.IsNil)
-			qt.Check(t, local.Value, qt.Equals, test.localValue)
-			qt.Check(t, target.Value, qt.Equals, test.targetValue)
+			qt.Assert(t, qt.IsNil(err))
+			qt.Check(t, qt.Equals(local.Value, test.localValue))
+			qt.Check(t, qt.Equals(target.Value, test.targetValue))
 		})
 	}
 }
@@ -523,7 +524,7 @@ func TestCOREFindField(t *testing.T) {
 	for _, test := range valid {
 		t.Run(test.name, func(t *testing.T) {
 			localField, targetField, err := coreFindField(test.local, test.acc, test.target)
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 			checkCOREField(t, "local", localField, test.localField)
 			checkCOREField(t, "target", targetField, test.targetField)
 		})
@@ -632,8 +633,8 @@ func TestCORECopyWithoutQualifiers(t *testing.T) {
 			root.Type = test.fn(root)
 
 			cycle, ok := Copy(root, UnderlyingType).(*cycle)
-			qt.Assert(t, ok, qt.IsTrue)
-			qt.Assert(t, cycle.root, qt.Equals, root)
+			qt.Assert(t, qt.IsTrue(ok))
+			qt.Assert(t, qt.Equals[Type](cycle.root, root))
 		})
 	}
 
@@ -644,7 +645,7 @@ func TestCORECopyWithoutQualifiers(t *testing.T) {
 				want := &Pointer{Target: &Int{Name: "z"}}
 
 				got := Copy(v, UnderlyingType)
-				qt.Assert(t, got, qt.DeepEquals, want)
+				qt.Assert(t, qt.DeepEquals[Type](got, want))
 			})
 		}
 	}
@@ -660,7 +661,7 @@ func TestCORECopyWithoutQualifiers(t *testing.T) {
 		}
 
 		got := Copy(v, UnderlyingType)
-		qt.Assert(t, got, qt.DeepEquals, root)
+		qt.Assert(t, qt.DeepEquals[Type](got, root))
 	})
 }
 
@@ -671,8 +672,8 @@ func TestCOREReloFieldSigned(t *testing.T) {
 				typ, coreAccessor{0}, reloFieldSigned, 0,
 			}
 			fixup, err := coreCalculateFixup(relo, &Void{}, 0, internal.NativeEndian)
-			qt.Assert(t, fixup.poison, qt.IsTrue)
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsTrue(fixup.poison))
+			qt.Assert(t, qt.IsNil(err))
 		})
 	}
 
@@ -681,7 +682,7 @@ func TestCOREReloFieldSigned(t *testing.T) {
 			&Array{}, coreAccessor{0}, reloFieldSigned, 0,
 		}
 		_, err := coreCalculateFixup(relo, &Array{}, 0, internal.NativeEndian)
-		qt.Assert(t, err, qt.ErrorIs, errNoSignedness)
+		qt.Assert(t, qt.ErrorIs(err, errNoSignedness))
 	})
 }
 
@@ -698,7 +699,7 @@ func TestCOREReloFieldShiftU64(t *testing.T) {
 	} {
 		t.Run(relo.kind.String(), func(t *testing.T) {
 			_, err := coreCalculateFixup(relo, typ, 1, internal.NativeEndian)
-			qt.Assert(t, err, qt.ErrorIs, errUnsizedType)
+			qt.Assert(t, qt.ErrorIs(err, errUnsizedType))
 		})
 	}
 }
@@ -708,22 +709,22 @@ func BenchmarkCORESkBuff(b *testing.B) {
 
 	var skb *Struct
 	err := spec.TypeByName("sk_buff", &skb)
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	skbID, err := spec.TypeID(skb)
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	lenIndex := slices.IndexFunc(skb.Members, func(m Member) bool {
 		return m.Name == "len"
 	})
-	qt.Assert(b, lenIndex, qt.Not(qt.Equals), -1)
+	qt.Assert(b, qt.Not(qt.Equals(lenIndex, -1)))
 
 	var pktHashTypes *Enum
 	err = spec.TypeByName("pkt_hash_types", &pktHashTypes)
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	pktHashTypesID, err := spec.TypeID(pktHashTypes)
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	for _, relo := range []*CORERelocation{
 		{skb, coreAccessor{0, lenIndex}, reloFieldByteOffset, skbID},
diff --git a/btf/marshal_test.go b/btf/marshal_test.go
index baa26a1..c09aae0 100644
--- a/btf/marshal_test.go
+++ b/btf/marshal_test.go
@@ -6,11 +6,11 @@ import (
 	"math"
 	"testing"
 
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/testutils"
+	"github.com/go-quicktest/qt"
 	"github.com/google/go-cmp/cmp"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/testutils"
 )
 
 func TestBuilderMarshal(t *testing.T) {
@@ -28,16 +28,16 @@ func TestBuilderMarshal(t *testing.T) {
 	}
 
 	b, err := NewBuilder(want)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	cpy := *b
 	buf, err := b.Marshal(nil, &MarshalOptions{Order: internal.NativeEndian})
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, b, qt.CmpEquals(cmp.AllowUnexported(*b)), &cpy, qt.Commentf("Marshaling should not change Builder state"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.CmpEquals(b, &cpy, cmp.AllowUnexported(*b)), qt.Commentf("Marshaling should not change Builder state"))
 
 	have, err := loadRawSpec(bytes.NewReader(buf), internal.NativeEndian, nil)
-	qt.Assert(t, err, qt.IsNil, qt.Commentf("Couldn't parse BTF"))
-	qt.Assert(t, have.types, qt.DeepEquals, want)
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("Couldn't parse BTF"))
+	qt.Assert(t, qt.DeepEquals(have.types, want))
 }
 
 func TestBuilderAdd(t *testing.T) {
@@ -50,24 +50,24 @@ func TestBuilderAdd(t *testing.T) {
 
 	var b Builder
 	id, err := b.Add(pi)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, id, qt.Equals, TypeID(1), qt.Commentf("First non-void type doesn't get id 1"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(id, TypeID(1)), qt.Commentf("First non-void type doesn't get id 1"))
 
 	id, err = b.Add(pi)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, id, qt.Equals, TypeID(1))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(id, TypeID(1)))
 
 	id, err = b.Add(i)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, id, qt.Equals, TypeID(2), qt.Commentf("Second type doesn't get id 2"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(id, TypeID(2)), qt.Commentf("Second type doesn't get id 2"))
 
 	id, err = b.Add(i)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, id, qt.Equals, TypeID(2), qt.Commentf("Adding a type twice returns different ids"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(id, TypeID(2)), qt.Commentf("Adding a type twice returns different ids"))
 
 	id, err = b.Add(&Typedef{"baz", i})
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, id, qt.Equals, TypeID(3))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(id, TypeID(3)))
 }
 
 func TestRoundtripVMlinux(t *testing.T) {
@@ -98,12 +98,12 @@ limitTypes:
 	}
 
 	b, err := NewBuilder(types)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, KernelMarshalOptions())
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	rebuilt, err := loadRawSpec(bytes.NewReader(buf), binary.LittleEndian, nil)
-	qt.Assert(t, err, qt.IsNil, qt.Commentf("round tripping BTF failed"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("round tripping BTF failed"))
 
 	if n := len(rebuilt.types); n > math.MaxUint16 {
 		t.Logf("Rebuilt BTF contains %d types which exceeds uint16, test may fail on older kernels", n)
@@ -111,7 +111,7 @@ limitTypes:
 
 	h, err := NewHandleFromRawBTF(buf)
 	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, err, qt.IsNil, qt.Commentf("loading rebuilt BTF failed"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("loading rebuilt BTF failed"))
 	h.Close()
 }
 
@@ -127,29 +127,29 @@ func TestMarshalEnum64(t *testing.T) {
 	}
 
 	b, err := NewBuilder([]Type{enum})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, &MarshalOptions{
 		Order:         internal.NativeEndian,
 		ReplaceEnum64: true,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	spec, err := loadRawSpec(bytes.NewReader(buf), internal.NativeEndian, nil)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	var have *Union
 	err = spec.TypeByName("enum64", &have)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	placeholder := &Int{Name: "enum64_placeholder", Size: 8, Encoding: Signed}
-	qt.Assert(t, have, qt.DeepEquals, &Union{
+	qt.Assert(t, qt.DeepEquals(have, &Union{
 		Name: "enum64",
 		Size: 8,
 		Members: []Member{
 			{Name: "A", Type: placeholder},
 			{Name: "B", Type: placeholder},
 		},
-	})
+	}))
 }
 
 func BenchmarkMarshaler(b *testing.B) {
@@ -186,9 +186,9 @@ func marshalNativeEndian(tb testing.TB, types []Type) []byte {
 	tb.Helper()
 
 	b, err := NewBuilder(types)
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 	buf, err := b.Marshal(nil, nil)
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 	return buf
 }
 
@@ -197,7 +197,7 @@ func specFromTypes(tb testing.TB, types []Type) *Spec {
 
 	btf := marshalNativeEndian(tb, types)
 	spec, err := loadRawSpec(bytes.NewReader(btf), internal.NativeEndian, nil)
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 
 	return spec
 }
diff --git a/btf/strings_test.go b/btf/strings_test.go
index e97c626..7c1510d 100644
--- a/btf/strings_test.go
+++ b/btf/strings_test.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestStringTable(t *testing.T) {
@@ -66,18 +66,18 @@ func TestStringTableBuilder(t *testing.T) {
 	stb := newStringTableBuilder(0)
 
 	_, err := readStringTable(bytes.NewReader(stb.AppendEncoded(nil)), nil)
-	qt.Assert(t, err, qt.IsNil, qt.Commentf("Can't parse string table"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("Can't parse string table"))
 
 	_, err = stb.Add("foo\x00bar")
-	qt.Assert(t, err, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(err))
 
 	empty, err := stb.Add("")
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, empty, qt.Equals, uint32(0), qt.Commentf("The empty string is not at index 0"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(empty, 0), qt.Commentf("The empty string is not at index 0"))
 
 	foo1, _ := stb.Add("foo")
 	foo2, _ := stb.Add("foo")
-	qt.Assert(t, foo1, qt.Equals, foo2, qt.Commentf("Adding the same string returns different offsets"))
+	qt.Assert(t, qt.Equals(foo1, foo2), qt.Commentf("Adding the same string returns different offsets"))
 
 	table := stb.AppendEncoded(nil)
 	if n := bytes.Count(table, []byte("foo")); n != 1 {
@@ -85,7 +85,7 @@ func TestStringTableBuilder(t *testing.T) {
 	}
 
 	_, err = readStringTable(bytes.NewReader(table), nil)
-	qt.Assert(t, err, qt.IsNil, qt.Commentf("Can't parse string table"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("Can't parse string table"))
 }
 
 func BenchmarkStringTableZeroLookup(b *testing.B) {
diff --git a/btf/traversal_test.go b/btf/traversal_test.go
index 8d25081..c8919f8 100644
--- a/btf/traversal_test.go
+++ b/btf/traversal_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestPostorderTraversal(t *testing.T) {
@@ -16,10 +16,10 @@ func TestPostorderTraversal(t *testing.T) {
 	pending := []Type{str, cst, ptr}
 	iter := postorderTraversal(ptr, nil)
 	for iter.Next() {
-		qt.Assert(t, iter.Type, qt.Equals, pending[0])
+		qt.Assert(t, qt.Equals(iter.Type, pending[0]))
 		pending = pending[1:]
 	}
-	qt.Assert(t, pending, qt.HasLen, 0)
+	qt.Assert(t, qt.HasLen(pending, 0))
 
 	i := &Int{Name: "foo"}
 	// i appears twice at the same nesting depth.
@@ -27,11 +27,11 @@ func TestPostorderTraversal(t *testing.T) {
 	seen := make(map[Type]bool)
 	iter = postorderTraversal(arr, nil)
 	for iter.Next() {
-		qt.Assert(t, seen[iter.Type], qt.IsFalse)
+		qt.Assert(t, qt.IsFalse(seen[iter.Type]))
 		seen[iter.Type] = true
 	}
-	qt.Assert(t, seen[arr], qt.IsTrue)
-	qt.Assert(t, seen[i], qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(seen[arr]))
+	qt.Assert(t, qt.IsTrue(seen[i]))
 }
 
 func TestPostorderTraversalVmlinux(t *testing.T) {
@@ -59,7 +59,7 @@ func TestPostorderTraversalVmlinux(t *testing.T) {
 			}
 
 			walkType(typ, func(child *Type) {
-				qt.Check(t, seen[*child], qt.IsTrue, qt.Commentf("missing child %s", *child))
+				qt.Check(t, qt.IsTrue(seen[*child]), qt.Commentf("missing child %s", *child))
 			})
 		})
 	}
diff --git a/btf/types_test.go b/btf/types_test.go
index ce84a28..21dab90 100644
--- a/btf/types_test.go
+++ b/btf/types_test.go
@@ -8,7 +8,7 @@ import (
 	"reflect"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 	"github.com/google/go-cmp/cmp"
 )
 
@@ -87,7 +87,7 @@ func TestCopy(t *testing.T) {
 		}, nil)
 
 		outStruct := out.(*Struct)
-		qt.Assert(t, outStruct.Members[0].Type, qt.Equals, outStruct.Members[1].Type)
+		qt.Assert(t, qt.Equals(outStruct.Members[0].Type, outStruct.Members[1].Type))
 	})
 }
 
@@ -100,29 +100,29 @@ func TestAs(t *testing.T) {
 
 	// It's possible to retrieve qualifiers and Typedefs.
 	haveVol, ok := as[*Volatile](vol)
-	qt.Assert(t, ok, qt.IsTrue)
-	qt.Assert(t, haveVol, qt.Equals, vol)
+	qt.Assert(t, qt.IsTrue(ok))
+	qt.Assert(t, qt.Equals(haveVol, vol))
 
 	haveTd, ok := as[*Typedef](vol)
-	qt.Assert(t, ok, qt.IsTrue)
-	qt.Assert(t, haveTd, qt.Equals, td)
+	qt.Assert(t, qt.IsTrue(ok))
+	qt.Assert(t, qt.Equals(haveTd, td))
 
 	haveCst, ok := as[*Const](vol)
-	qt.Assert(t, ok, qt.IsTrue)
-	qt.Assert(t, haveCst, qt.Equals, cst)
+	qt.Assert(t, qt.IsTrue(ok))
+	qt.Assert(t, qt.Equals(haveCst, cst))
 
 	// Make sure we don't skip Pointer.
 	haveI, ok := as[*Int](vol)
-	qt.Assert(t, ok, qt.IsFalse)
-	qt.Assert(t, haveI, qt.IsNil)
+	qt.Assert(t, qt.IsFalse(ok))
+	qt.Assert(t, qt.IsNil(haveI))
 
 	// Make sure we can always retrieve Pointer.
 	for _, typ := range []Type{
 		td, cst, vol, ptr,
 	} {
 		have, ok := as[*Pointer](typ)
-		qt.Assert(t, ok, qt.IsTrue)
-		qt.Assert(t, have, qt.Equals, ptr)
+		qt.Assert(t, qt.IsTrue(ok))
+		qt.Assert(t, qt.Equals(have, ptr))
 	}
 }
 
@@ -243,9 +243,9 @@ func TestTagMarshaling(t *testing.T) {
 			s := specFromTypes(t, []Type{typ})
 
 			have, err := s.TypeByID(1)
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 
-			qt.Assert(t, have, qt.DeepEquals, typ)
+			qt.Assert(t, qt.DeepEquals(have, typ))
 		})
 	}
 }
@@ -319,11 +319,11 @@ func TestFormatType(t *testing.T) {
 			t.Log(str)
 
 			for _, want := range test.contains {
-				qt.Assert(t, str, qt.Contains, want)
+				qt.Assert(t, qt.StringContains(str, want))
 			}
 
 			for _, notWant := range test.omits {
-				qt.Assert(t, str, qt.Not(qt.Contains), notWant)
+				qt.Assert(t, qt.Not(qt.StringContains(str, notWant)))
 			}
 		})
 	}
@@ -373,8 +373,8 @@ func TestUnderlyingType(t *testing.T) {
 			root.Type = test.fn(root)
 
 			got, ok := UnderlyingType(root).(*cycle)
-			qt.Assert(t, ok, qt.IsTrue)
-			qt.Assert(t, got.root, qt.Equals, root)
+			qt.Assert(t, qt.IsTrue(ok))
+			qt.Assert(t, qt.Equals[Type](got.root, root))
 		})
 	}
 
@@ -382,7 +382,7 @@ func TestUnderlyingType(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			want := &Int{}
 			got := UnderlyingType(test.fn(want))
-			qt.Assert(t, got, qt.Equals, want)
+			qt.Assert(t, qt.Equals[Type](got, want))
 		})
 	}
 }
diff --git a/cmd/bpf2go/main_test.go b/cmd/bpf2go/main_test.go
index f292412..8b22433 100644
--- a/cmd/bpf2go/main_test.go
+++ b/cmd/bpf2go/main_test.go
@@ -12,7 +12,7 @@ import (
 	"strings"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 	"github.com/google/go-cmp/cmp"
 )
 
@@ -255,7 +255,7 @@ func TestCTypes(t *testing.T) {
 			t.Fatalf("Set returned an error for %q: %s", value, err)
 		}
 	}
-	qt.Assert(t, ct, qt.ContentEquals, cTypes(valid))
+	qt.Assert(t, qt.ContentEquals(ct, valid))
 
 	for _, value := range []string{
 		"",
@@ -274,8 +274,8 @@ func TestCTypes(t *testing.T) {
 	}
 
 	ct = nil
-	qt.Assert(t, ct.Set("foo"), qt.IsNil)
-	qt.Assert(t, ct.Set("foo"), qt.IsNotNil)
+	qt.Assert(t, qt.IsNil(ct.Set("foo")))
+	qt.Assert(t, qt.IsNotNil(ct.Set("foo")))
 }
 
 func TestParseArgs(t *testing.T) {
@@ -290,8 +290,8 @@ func TestParseArgs(t *testing.T) {
 		basePath, _ := filepath.Abs("barfoo")
 		args := []string{"-makebase", basePath, stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.makeBase, qt.Equals, basePath)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.makeBase, basePath))
 	})
 
 	t.Run("makebase from env", func(t *testing.T) {
@@ -299,8 +299,8 @@ func TestParseArgs(t *testing.T) {
 		args := []string{stem, csource}
 		t.Setenv("BPF2GO_MAKEBASE", basePath)
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.makeBase, qt.Equals, basePath)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.makeBase, basePath))
 	})
 
 	t.Run("makebase flag overrides env", func(t *testing.T) {
@@ -309,119 +309,119 @@ func TestParseArgs(t *testing.T) {
 		args := []string{"-makebase", basePathFlag, stem, csource}
 		t.Setenv("BPF2GO_MAKEBASE", basePathEnv)
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.makeBase, qt.Equals, basePathFlag)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.makeBase, basePathFlag))
 	})
 
 	t.Run("cc defaults to clang", func(t *testing.T) {
 		args := []string{stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cc, qt.Equals, "clang")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.cc, "clang"))
 	})
 
 	t.Run("cc", func(t *testing.T) {
 		args := []string{"-cc", "barfoo", stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cc, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.cc, "barfoo"))
 	})
 
 	t.Run("cc from env", func(t *testing.T) {
 		args := []string{stem, csource}
 		t.Setenv("BPF2GO_CC", "barfoo")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cc, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.cc, "barfoo"))
 	})
 
 	t.Run("cc flag overrides env", func(t *testing.T) {
 		args := []string{"-cc", "barfoo", stem, csource}
 		t.Setenv("BPF2GO_CC", "foobar")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cc, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.cc, "barfoo"))
 	})
 
 	t.Run("strip defaults to llvm-strip", func(t *testing.T) {
 		args := []string{stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.strip, qt.Equals, "llvm-strip")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.strip, "llvm-strip"))
 	})
 
 	t.Run("strip", func(t *testing.T) {
 		args := []string{"-strip", "barfoo", stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.strip, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.strip, "barfoo"))
 	})
 
 	t.Run("strip from env", func(t *testing.T) {
 		args := []string{stem, csource}
 		t.Setenv("BPF2GO_STRIP", "barfoo")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.strip, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.strip, "barfoo"))
 	})
 
 	t.Run("strip flag overrides env", func(t *testing.T) {
 		args := []string{"-strip", "barfoo", stem, csource}
 		t.Setenv("BPF2GO_STRIP", "foobar")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.strip, qt.Equals, "barfoo")
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(b2g.strip, "barfoo"))
 	})
 
 	t.Run("no strip defaults to false", func(t *testing.T) {
 		args := []string{stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.disableStripping, qt.IsFalse)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.IsFalse(b2g.disableStripping))
 	})
 
 	t.Run("no strip", func(t *testing.T) {
 		args := []string{"-no-strip", stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.disableStripping, qt.IsTrue)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.IsTrue(b2g.disableStripping))
 	})
 
 	t.Run("cflags flag", func(t *testing.T) {
 		args := []string{"-cflags", "x y z", stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cFlags, qt.DeepEquals, []string{"x", "y", "z"})
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.DeepEquals(b2g.cFlags, []string{"x", "y", "z"}))
 	})
 
 	t.Run("cflags multi flag", func(t *testing.T) {
 		args := []string{"-cflags", "x y z", "-cflags", "u v", stem, csource}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cFlags, qt.DeepEquals, []string{"u", "v"})
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.DeepEquals(b2g.cFlags, []string{"u", "v"}))
 	})
 
 	t.Run("cflags flag and args", func(t *testing.T) {
 		args := []string{"-cflags", "x y z", "stem", csource, "--", "u", "v"}
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cFlags, qt.DeepEquals, []string{"x", "y", "z", "u", "v"})
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.DeepEquals(b2g.cFlags, []string{"x", "y", "z", "u", "v"}))
 	})
 
 	t.Run("cflags from env", func(t *testing.T) {
 		args := []string{stem, csource}
 		t.Setenv("BPF2GO_CFLAGS", "x y z")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cFlags, qt.DeepEquals, []string{"x", "y", "z"})
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.DeepEquals(b2g.cFlags, []string{"x", "y", "z"}))
 	})
 
 	t.Run("cflags flag overrides env", func(t *testing.T) {
 		args := []string{"-cflags", "u v", stem, csource}
 		t.Setenv("BPF2GO_CFLAGS", "x y z")
 		b2g, err := newB2G(&bytes.Buffer{}, pkg, outputDir, args)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, b2g.cFlags, qt.DeepEquals, []string{"u", "v"})
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.DeepEquals(b2g.cFlags, []string{"u", "v"}))
 	})
 }
 
diff --git a/cmd/bpf2go/output_test.go b/cmd/bpf2go/output_test.go
index 2b5e9ad..4d9d394 100644
--- a/cmd/bpf2go/output_test.go
+++ b/cmd/bpf2go/output_test.go
@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+	"github.com/google/go-cmp/cmp"
+
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
-	qt "github.com/frankban/quicktest"
-	"github.com/google/go-cmp/cmp"
 )
 
 func TestOrderTypes(t *testing.T) {
@@ -33,8 +34,8 @@ func TestOrderTypes(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			result, err := sortTypes(test.in)
-			qt.Assert(t, err, qt.IsNil)
-			qt.Assert(t, len(result), qt.Equals, len(test.out))
+			qt.Assert(t, qt.IsNil(err))
+			qt.Assert(t, qt.Equals(len(result), len(test.out)))
 			for i, o := range test.out {
 				if result[i] != o {
 					t.Fatalf("Index %d: expected %p got %p", i, o, result[i])
@@ -57,15 +58,15 @@ func TestOrderTypes(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			result, err := sortTypes(test.in)
-			qt.Assert(t, err, qt.IsNotNil)
-			qt.Assert(t, result, qt.IsNil)
+			qt.Assert(t, qt.IsNotNil(err))
+			qt.Assert(t, qt.IsNil(result))
 		})
 	}
 }
 
-var typesEqual = qt.CmpEquals(cmp.Comparer(func(a, b btf.Type) bool {
+var typesEqualComparer = cmp.Comparer(func(a, b btf.Type) bool {
 	return a == b
-}))
+})
 
 func TestCollectFromSpec(t *testing.T) {
 	spec, err := ebpf.LoadCollectionSpec(fmt.Sprintf("testdata/minimal-%s.elf", internal.ClangEndian))
@@ -79,19 +80,19 @@ func TestCollectFromSpec(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	qt.Assert(t, maps, qt.ContentEquals, []string{"map1"})
-	qt.Assert(t, programs, qt.ContentEquals, []string{"filter"})
-	qt.Assert(t, types, typesEqual, []btf.Type{map1.Key, map1.Value})
+	qt.Assert(t, qt.ContentEquals(maps, []string{"map1"}))
+	qt.Assert(t, qt.ContentEquals(programs, []string{"filter"}))
+	qt.Assert(t, qt.CmpEquals(types, []btf.Type{map1.Key, map1.Value}, typesEqualComparer))
 
 	_, _, types, err = collectFromSpec(spec, nil, true)
 	if err != nil {
 		t.Fatal(err)
 	}
-	qt.Assert(t, types, typesEqual, ([]btf.Type)(nil))
+	qt.Assert(t, qt.CmpEquals[[]btf.Type](types, nil, typesEqualComparer))
 
 	_, _, types, err = collectFromSpec(spec, []string{"barfoo"}, true)
 	if err != nil {
 		t.Fatal(err)
 	}
-	qt.Assert(t, types, typesEqual, []btf.Type{map1.Value})
+	qt.Assert(t, qt.CmpEquals(types, []btf.Type{map1.Value}, typesEqualComparer))
 }
diff --git a/collection_test.go b/collection_test.go
index 6e9b98a..75a3454 100644
--- a/collection_test.go
+++ b/collection_test.go
@@ -8,12 +8,13 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/testutils/fdtrace"
-	qt "github.com/frankban/quicktest"
 )
 
 func TestMain(m *testing.M) {
@@ -367,19 +368,19 @@ func TestCollectionRewriteConstants(t *testing.T) {
 		"fake_constant_one": uint32(1),
 		"fake_constant_two": uint32(2),
 	})
-	qt.Assert(t, err, qt.IsNotNil, qt.Commentf("RewriteConstants did not fail"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("RewriteConstants did not fail"))
 
 	var mErr *MissingConstantsError
 	if !errors.As(err, &mErr) {
 		t.Fatal("Error doesn't wrap MissingConstantsError:", err)
 	}
-	qt.Assert(t, mErr.Constants, qt.ContentEquals, []string{"fake_constant_one", "fake_constant_two"})
+	qt.Assert(t, qt.ContentEquals(mErr.Constants, []string{"fake_constant_one", "fake_constant_two"}))
 
 	err = cs.RewriteConstants(map[string]interface{}{
 		"the_constant": uint32(0x42424242),
 	})
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, cs.Maps[".rodata"].Contents[0].Value, qt.ContentEquals, []byte{0x42, 0x42, 0x42, 0x42})
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.ContentEquals(cs.Maps[".rodata"].Contents[0].Value.([]byte), []byte{0x42, 0x42, 0x42, 0x42}))
 }
 
 func TestCollectionSpec_LoadAndAssign_LazyLoading(t *testing.T) {
@@ -589,20 +590,20 @@ func TestCollectionAssign(t *testing.T) {
 	}
 
 	coll, err := NewCollection(cs)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer coll.Close()
 
-	qt.Assert(t, coll.Assign(&objs), qt.IsNil)
+	qt.Assert(t, qt.IsNil(coll.Assign(&objs)))
 	defer objs.Program.Close()
 	defer objs.Map.Close()
 
 	// Check that objs has received ownership of map and prog
-	qt.Assert(t, objs.Program.FD() >= 0, qt.IsTrue)
-	qt.Assert(t, objs.Map.FD() >= 0, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(objs.Program.FD() >= 0))
+	qt.Assert(t, qt.IsTrue(objs.Map.FD() >= 0))
 
 	// Check that the collection has lost ownership
-	qt.Assert(t, coll.Programs["prog1"], qt.IsNil)
-	qt.Assert(t, coll.Maps["map1"], qt.IsNil)
+	qt.Assert(t, qt.IsNil(coll.Programs["prog1"]))
+	qt.Assert(t, qt.IsNil(coll.Maps["map1"]))
 }
 
 func TestCollectionAssignFail(t *testing.T) {
@@ -634,14 +635,14 @@ func TestCollectionAssignFail(t *testing.T) {
 	}
 
 	coll, err := NewCollection(cs)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer coll.Close()
 
-	qt.Assert(t, coll.Assign(&objs), qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(coll.Assign(&objs)))
 
 	// Check that the collection has retained ownership
-	qt.Assert(t, coll.Programs["prog1"], qt.IsNotNil)
-	qt.Assert(t, coll.Maps["map1"], qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(coll.Programs["prog1"]))
+	qt.Assert(t, qt.IsNotNil(coll.Maps["map1"]))
 }
 
 func TestIncompleteLoadAndAssign(t *testing.T) {
@@ -734,7 +735,7 @@ func BenchmarkNewCollectionManyProgs(b *testing.B) {
 
 func BenchmarkLoadCollectionManyProgs(b *testing.B) {
 	file, err := os.Open(fmt.Sprintf("testdata/manyprogs-%s.elf", internal.ClangEndian))
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 	defer file.Close()
 
 	b.ReportAllocs()
diff --git a/elf_reader_test.go b/elf_reader_test.go
index 1ffcb57..d223b3e 100644
--- a/elf_reader_test.go
+++ b/elf_reader_test.go
@@ -20,7 +20,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestLoadCollectionSpec(t *testing.T) {
@@ -711,7 +711,7 @@ func TestKconfigConfig(t *testing.T) {
 		}
 
 		// CONFIG_HZ must have a value.
-		qt.Assert(t, value, qt.Not(qt.Equals), 0)
+		qt.Assert(t, qt.Not(qt.Equals(value, 0)))
 	})
 }
 
@@ -1152,7 +1152,7 @@ func loadTargetProgram(tb testing.TB, spec *CollectionSpec, file, program string
 		tb.Fatalf("Can't read %s: %s", file, err)
 	}
 
-	qt.Assert(tb, targetSpec.Programs[program], qt.IsNotNil)
+	qt.Assert(tb, qt.IsNotNil(targetSpec.Programs[program]))
 
 	coll, err := NewCollectionWithOptions(targetSpec, CollectionOptions{
 		Programs: ProgramOptions{LogDisabled: true},
@@ -1296,7 +1296,7 @@ func TestELFSectionProgramTypes(t *testing.T) {
 		t.Run(tc.Section, func(t *testing.T) {
 			pt, at, fl, extra := getProgType(tc.Section)
 			have := testcase{tc.Section, pt, at, fl, extra}
-			qt.Assert(t, have, qt.DeepEquals, tc)
+			qt.Assert(t, qt.DeepEquals(have, tc))
 		})
 	}
 }
@@ -1329,9 +1329,9 @@ func TestMatchSectionName(t *testing.T) {
 		name := fmt.Sprintf("%s:%s", testcase.pattern, testcase.input)
 		t.Run(name, func(t *testing.T) {
 			extra, matches := matchSectionName(testcase.input, testcase.pattern)
-			qt.Assert(t, matches, qt.Equals, testcase.matches)
+			qt.Assert(t, qt.Equals(matches, testcase.matches))
 			if testcase.matches {
-				qt.Assert(t, extra, qt.Equals, testcase.extra)
+				qt.Assert(t, qt.Equals(extra, testcase.extra))
 			}
 		})
 	}
diff --git a/info_test.go b/info_test.go
index 9324bba..30bf415 100644
--- a/info_test.go
+++ b/info_test.go
@@ -7,13 +7,14 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/sys"
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/unix"
-	qt "github.com/frankban/quicktest"
 )
 
 func TestMapInfoFromProc(t *testing.T) {
@@ -122,14 +123,14 @@ func TestProgramInfo(t *testing.T) {
 
 			if name == "proc" {
 				_, ok := info.CreatedByUID()
-				qt.Assert(t, ok, qt.IsFalse)
+				qt.Assert(t, qt.IsFalse(ok))
 			} else {
 				uid, ok := info.CreatedByUID()
 				if testutils.IsKernelLessThan(t, "4.15") {
-					qt.Assert(t, ok, qt.IsFalse)
+					qt.Assert(t, qt.IsFalse(ok))
 				} else {
-					qt.Assert(t, ok, qt.IsTrue)
-					qt.Assert(t, uid, qt.Equals, uint32(os.Getuid()))
+					qt.Assert(t, qt.IsTrue(ok))
+					qt.Assert(t, qt.Equals(uid, uint32(os.Getuid())))
 				}
 			}
 		})
@@ -143,7 +144,7 @@ func TestProgramInfoMapIDs(t *testing.T) {
 		ValueSize:  4,
 		MaxEntries: 1,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer arr.Close()
 
 	prog, err := NewProgram(&ProgramSpec{
@@ -155,28 +156,28 @@ func TestProgramInfoMapIDs(t *testing.T) {
 		},
 		License: "MIT",
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer prog.Close()
 
 	info, err := prog.Info()
 	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	ids, ok := info.MapIDs()
 	switch {
 	case testutils.IsKernelLessThan(t, "4.15"):
-		qt.Assert(t, ok, qt.IsFalse)
-		qt.Assert(t, ids, qt.HasLen, 0)
+		qt.Assert(t, qt.IsFalse(ok))
+		qt.Assert(t, qt.HasLen(ids, 0))
 
 	default:
-		qt.Assert(t, ok, qt.IsTrue)
+		qt.Assert(t, qt.IsTrue(ok))
 
 		mapInfo, err := arr.Info()
-		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, qt.IsNil(err))
 
 		mapID, ok := mapInfo.ID()
-		qt.Assert(t, ok, qt.IsTrue)
-		qt.Assert(t, ids, qt.ContentEquals, []MapID{mapID})
+		qt.Assert(t, qt.IsTrue(ok))
+		qt.Assert(t, qt.ContentEquals(ids, []MapID{mapID}))
 	}
 }
 
@@ -189,22 +190,22 @@ func TestProgramInfoMapIDsNoMaps(t *testing.T) {
 		},
 		License: "MIT",
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer prog.Close()
 
 	info, err := prog.Info()
 	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	ids, ok := info.MapIDs()
 	switch {
 	case testutils.IsKernelLessThan(t, "4.15"):
-		qt.Assert(t, ok, qt.IsFalse)
-		qt.Assert(t, ids, qt.HasLen, 0)
+		qt.Assert(t, qt.IsFalse(ok))
+		qt.Assert(t, qt.HasLen(ids, 0))
 
 	default:
-		qt.Assert(t, ok, qt.IsTrue)
-		qt.Assert(t, ids, qt.HasLen, 0)
+		qt.Assert(t, qt.IsTrue(ok))
+		qt.Assert(t, qt.HasLen(ids, 0))
 	}
 }
 
diff --git a/internal/errors_test.go b/internal/errors_test.go
index 4b755fa..0320d60 100644
--- a/internal/errors_test.go
+++ b/internal/errors_test.go
@@ -5,8 +5,9 @@ import (
 	"os"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/internal/unix"
-	qt "github.com/frankban/quicktest"
 )
 
 func TestVerifierErrorWhitespace(t *testing.T) {
@@ -20,7 +21,7 @@ func TestVerifierErrorWhitespace(t *testing.T) {
 	)
 
 	err := ErrorWithLog("frob", errors.New("test"), b, false)
-	qt.Assert(t, err.Error(), qt.Equals, "frob: test: unreachable insn 28")
+	qt.Assert(t, qt.Equals(err.Error(), "frob: test: unreachable insn 28"))
 
 	for _, log := range [][]byte{
 		nil,
@@ -28,51 +29,51 @@ func TestVerifierErrorWhitespace(t *testing.T) {
 		[]byte(" "),
 	} {
 		err = ErrorWithLog("frob", errors.New("test"), log, false)
-		qt.Assert(t, err.Error(), qt.Equals, "frob: test", qt.Commentf("empty log %q has incorrect format", log))
+		qt.Assert(t, qt.Equals(err.Error(), "frob: test"), qt.Commentf("empty log %q has incorrect format", log))
 	}
 }
 
 func TestVerifierErrorWrapping(t *testing.T) {
 	ve := ErrorWithLog("frob", unix.ENOENT, nil, false)
-	qt.Assert(t, ve, qt.ErrorIs, unix.ENOENT, qt.Commentf("should wrap provided error"))
-	qt.Assert(t, ve.Truncated, qt.IsFalse, qt.Commentf("verifier log should not be marked as truncated"))
+	qt.Assert(t, qt.ErrorIs(ve, unix.ENOENT), qt.Commentf("should wrap provided error"))
+	qt.Assert(t, qt.IsFalse(ve.Truncated), qt.Commentf("verifier log should not be marked as truncated"))
 
 	ve = ErrorWithLog("frob", unix.EINVAL, nil, true)
-	qt.Assert(t, ve, qt.ErrorIs, unix.EINVAL, qt.Commentf("should wrap provided error"))
-	qt.Assert(t, ve.Truncated, qt.IsTrue, qt.Commentf("verifier log should be marked as truncated"))
+	qt.Assert(t, qt.ErrorIs(ve, unix.EINVAL), qt.Commentf("should wrap provided error"))
+	qt.Assert(t, qt.IsTrue(ve.Truncated), qt.Commentf("verifier log should be marked as truncated"))
 
 	ve = ErrorWithLog("frob", unix.EINVAL, []byte("foo"), false)
-	qt.Assert(t, ve, qt.ErrorIs, unix.EINVAL, qt.Commentf("should wrap provided error"))
-	qt.Assert(t, ve.Error(), qt.Contains, "foo", qt.Commentf("verifier log should appear in error string"))
+	qt.Assert(t, qt.ErrorIs(ve, unix.EINVAL), qt.Commentf("should wrap provided error"))
+	qt.Assert(t, qt.StringContains(ve.Error(), "foo"), qt.Commentf("verifier log should appear in error string"))
 
 	ve = ErrorWithLog("frob", unix.ENOSPC, []byte("foo"), true)
-	qt.Assert(t, ve, qt.ErrorIs, unix.ENOSPC, qt.Commentf("should wrap provided error"))
-	qt.Assert(t, ve.Error(), qt.Contains, "foo", qt.Commentf("verifier log should appear in error string"))
-	qt.Assert(t, ve.Truncated, qt.IsTrue, qt.Commentf("verifier log should be marked truncated"))
+	qt.Assert(t, qt.ErrorIs(ve, unix.ENOSPC), qt.Commentf("should wrap provided error"))
+	qt.Assert(t, qt.StringContains(ve.Error(), "foo"), qt.Commentf("verifier log should appear in error string"))
+	qt.Assert(t, qt.IsTrue(ve.Truncated), qt.Commentf("verifier log should be marked truncated"))
 }
 
 func TestVerifierErrorSummary(t *testing.T) {
 	// Suppress the last line containing 'processed ... insns'.
 	errno524 := readErrorFromFile(t, "testdata/errno524.log")
-	qt.Assert(t, errno524.Error(), qt.Contains, "JIT doesn't support bpf-to-bpf calls")
-	qt.Assert(t, errno524.Error(), qt.Not(qt.Contains), "processed 39 insns")
+	qt.Assert(t, qt.StringContains(errno524.Error(), "JIT doesn't support bpf-to-bpf calls"))
+	qt.Assert(t, qt.Not(qt.StringContains(errno524.Error(), "processed 39 insns")))
 
 	// Include the previous line if the current one starts with a tab.
 	invalidMember := readErrorFromFile(t, "testdata/invalid-member.log")
-	qt.Assert(t, invalidMember.Error(), qt.Contains, "STRUCT task_struct size=7744 vlen=218: cpus_mask type_id=109 bitfield_size=0 bits_offset=7744 Invalid member")
+	qt.Assert(t, qt.StringContains(invalidMember.Error(), "STRUCT task_struct size=7744 vlen=218: cpus_mask type_id=109 bitfield_size=0 bits_offset=7744 Invalid member"))
 
 	// Only include the last line.
 	issue43 := readErrorFromFile(t, "testdata/issue-43.log")
-	qt.Assert(t, issue43.Error(), qt.Contains, "[11] FUNC helper_func2 type_id=10 vlen != 0")
-	qt.Assert(t, issue43.Error(), qt.Not(qt.Contains), "[10] FUNC_PROTO (anon) return=3 args=(3 arg)")
+	qt.Assert(t, qt.StringContains(issue43.Error(), "[11] FUNC helper_func2 type_id=10 vlen != 0"))
+	qt.Assert(t, qt.Not(qt.StringContains(issue43.Error(), "[10] FUNC_PROTO (anon) return=3 args=(3 arg)")))
 
 	// Include instruction that caused invalid register access.
 	invalidR0 := readErrorFromFile(t, "testdata/invalid-R0.log")
-	qt.Assert(t, invalidR0.Error(), qt.Contains, "0: (95) exit: R0 !read_ok")
+	qt.Assert(t, qt.StringContains(invalidR0.Error(), "0: (95) exit: R0 !read_ok"))
 
 	// Include symbol that doesn't match context type.
 	invalidCtx := readErrorFromFile(t, "testdata/invalid-ctx-access.log")
-	qt.Assert(t, invalidCtx.Error(), qt.Contains, "func '__x64_sys_recvfrom' arg0 type FWD is not a struct: invalid bpf_context access off=0 size=8")
+	qt.Assert(t, qt.StringContains(invalidCtx.Error(), "func '__x64_sys_recvfrom' arg0 type FWD is not a struct: invalid bpf_context access off=0 size=8"))
 }
 
 func readErrorFromFile(tb testing.TB, file string) *VerifierError {
diff --git a/internal/kconfig/kconfig_test.go b/internal/kconfig/kconfig_test.go
index f026114..3621237 100644
--- a/internal/kconfig/kconfig_test.go
+++ b/internal/kconfig/kconfig_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func BenchmarkParse(b *testing.B) {
@@ -77,7 +77,7 @@ func TestParse(t *testing.T) {
 		"CONFIG_STR":      `"abracad"`,
 		"CONFIG_FOO":      `"foo"`,
 	}
-	qt.Assert(t, config, qt.DeepEquals, expected)
+	qt.Assert(t, qt.DeepEquals(config, expected))
 }
 
 func TestParseFiltered(t *testing.T) {
@@ -97,7 +97,7 @@ func TestParseFiltered(t *testing.T) {
 	}
 
 	expected := map[string]string{"CONFIG_FOO": `"foo"`}
-	qt.Assert(t, config, qt.DeepEquals, expected)
+	qt.Assert(t, qt.DeepEquals(config, expected))
 }
 
 func TestParseGzipped(t *testing.T) {
@@ -132,7 +132,7 @@ func TestParseGzippedFiltered(t *testing.T) {
 	}
 
 	expected := map[string]string{"CONFIG_HZ": "1000"}
-	qt.Assert(t, config, qt.DeepEquals, expected)
+	qt.Assert(t, qt.DeepEquals(config, expected))
 }
 
 func TestProcessKconfigBadLine(t *testing.T) {
@@ -141,10 +141,10 @@ func TestProcessKconfigBadLine(t *testing.T) {
 	m := make(map[string]string)
 
 	err := processKconfigLine([]byte("CONFIG_FOO"), m, nil)
-	qt.Assert(t, err, qt.IsNotNil, qt.Commentf("line has no '='"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("line has no '='"))
 
 	err = processKconfigLine([]byte("CONFIG_FOO="), m, nil)
-	qt.Assert(t, err, qt.IsNotNil, qt.Commentf("line has no value"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("line has no value"))
 }
 
 func TestPutValue(t *testing.T) {
@@ -396,7 +396,7 @@ func TestPutValue(t *testing.T) {
 		if len(c.comment) > 0 {
 			err := PutValue(make([]byte, 0), c.typ, c.value)
 
-			qt.Assert(t, err, qt.IsNotNil, qt.Commentf(c.comment))
+			qt.Assert(t, qt.IsNotNil(err), qt.Commentf(c.comment))
 
 			continue
 		}
@@ -411,8 +411,8 @@ func TestPutValue(t *testing.T) {
 		data := make([]byte, len(expected))
 		err = PutValue(data, c.typ, c.value)
 
-		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, qt.IsNil(err))
 
-		qt.Assert(t, data, qt.DeepEquals, expected)
+		qt.Assert(t, qt.DeepEquals(data, expected))
 	}
 }
diff --git a/internal/output_test.go b/internal/output_test.go
index 1ce169d..b2e6fca 100644
--- a/internal/output_test.go
+++ b/internal/output_test.go
@@ -3,7 +3,7 @@ package internal
 import (
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestIdentifier(t *testing.T) {
@@ -32,10 +32,10 @@ func TestIdentifier(t *testing.T) {
 func TestGoTypeName(t *testing.T) {
 	type foo struct{}
 	type bar[T any] struct{}
-	qt.Assert(t, GoTypeName(foo{}), qt.Equals, "foo")
-	qt.Assert(t, GoTypeName(new(foo)), qt.Equals, "foo")
-	qt.Assert(t, GoTypeName(new(*foo)), qt.Equals, "foo")
-	qt.Assert(t, GoTypeName(bar[int]{}), qt.Equals, "bar[int]")
+	qt.Assert(t, qt.Equals(GoTypeName(foo{}), "foo"))
+	qt.Assert(t, qt.Equals(GoTypeName(new(foo)), "foo"))
+	qt.Assert(t, qt.Equals(GoTypeName(new(*foo)), "foo"))
+	qt.Assert(t, qt.Equals(GoTypeName(bar[int]{}), "bar[int]"))
 	// Broken in the stdlib, see GoTypeName for details.
 	// qt.Assert(t, GoTypeName(bar[qt.C]{}), qt.Equals, "bar[quicktest.C]")
 }
diff --git a/internal/statfs_test.go b/internal/statfs_test.go
index 6d795cd..0ff4c5d 100644
--- a/internal/statfs_test.go
+++ b/internal/statfs_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestFSType(t *testing.T) {
@@ -17,7 +17,7 @@ func TestFSType(t *testing.T) {
 		{"/sys/fs/bpf", unix.BPF_FS_MAGIC},
 	} {
 		fst, err := FSType(fs.path)
-		qt.Assert(t, err, qt.IsNil)
-		qt.Assert(t, fst, qt.Equals, fs.magic)
+		qt.Assert(t, qt.IsNil(err))
+		qt.Assert(t, qt.Equals(fst, fs.magic))
 	}
 }
diff --git a/internal/sys/fd_test.go b/internal/sys/fd_test.go
index b84121c..6aaa412 100644
--- a/internal/sys/fd_test.go
+++ b/internal/sys/fd_test.go
@@ -5,8 +5,9 @@ import (
 	"syscall"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/internal/unix"
-	qt "github.com/frankban/quicktest"
 )
 
 func init() {
@@ -35,15 +36,15 @@ func reserveFdZero() {
 
 func TestFD(t *testing.T) {
 	_, err := NewFD(-1)
-	qt.Assert(t, err, qt.IsNotNil, qt.Commentf("negative fd should be rejected"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("negative fd should be rejected"))
 
 	fd, err := NewFD(0)
-	qt.Assert(t, err, qt.IsNil)
-	qt.Assert(t, fd.Int(), qt.Not(qt.Equals), 0, qt.Commentf("fd value should not be zero"))
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Not(qt.Equals(fd.Int(), 0)), qt.Commentf("fd value should not be zero"))
 
 	var stat unix.Stat_t
 	err = unix.Fstat(0, &stat)
-	qt.Assert(t, err, qt.ErrorIs, unix.EBADF, qt.Commentf("zero fd should be closed"))
+	qt.Assert(t, qt.ErrorIs(err, unix.EBADF), qt.Commentf("zero fd should be closed"))
 
 	reserveFdZero()
 }
@@ -51,16 +52,16 @@ func TestFD(t *testing.T) {
 func TestFDFile(t *testing.T) {
 	fd := newFD(openFd(t))
 	file := fd.File("test")
-	qt.Assert(t, file, qt.IsNotNil)
-	qt.Assert(t, file.Close(), qt.IsNil)
-	qt.Assert(t, fd.File("closed"), qt.IsNil)
+	qt.Assert(t, qt.IsNotNil(file))
+	qt.Assert(t, qt.IsNil(file.Close()))
+	qt.Assert(t, qt.IsNil(fd.File("closed")))
 
 	_, err := fd.Dup()
-	qt.Assert(t, err, qt.ErrorIs, ErrClosedFd)
+	qt.Assert(t, qt.ErrorIs(err, ErrClosedFd))
 }
 
 func openFd(tb testing.TB) int {
 	fd, err := unix.Open(os.DevNull, syscall.O_RDONLY, 0)
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 	return fd
 }
diff --git a/internal/sys/signals_test.go b/internal/sys/signals_test.go
index b3ecfa1..0e8dcc7 100644
--- a/internal/sys/signals_test.go
+++ b/internal/sys/signals_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestSigset(t *testing.T) {
@@ -65,8 +65,8 @@ func TestProfilerSignal(t *testing.T) {
 	}
 
 	want := have
-	qt.Assert(t, sigsetAdd(&want, unix.SIGPROF), qt.IsNil)
-	qt.Assert(t, have, qt.Equals, want)
+	qt.Assert(t, qt.IsNil(sigsetAdd(&want, unix.SIGPROF)))
+	qt.Assert(t, qt.Equals(have, want))
 
 	unmaskProfilerSignal()
 
@@ -74,5 +74,5 @@ func TestProfilerSignal(t *testing.T) {
 		t.Fatal("get sigmask:", err)
 	}
 
-	qt.Assert(t, have, qt.Equals, old)
+	qt.Assert(t, qt.Equals(have, old))
 }
diff --git a/internal/sys/syscall_test.go b/internal/sys/syscall_test.go
index dd0b394..ed6f802 100644
--- a/internal/sys/syscall_test.go
+++ b/internal/sys/syscall_test.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestObjName(t *testing.T) {
@@ -36,7 +36,7 @@ func TestWrappedErrno(t *testing.T) {
 	}
 
 	notsupp := wrappedErrno{ENOTSUPP}
-	qt.Assert(t, notsupp.Error(), qt.Contains, "operation not supported")
+	qt.Assert(t, qt.StringContains(notsupp.Error(), "operation not supported"))
 }
 
 func TestSyscallError(t *testing.T) {
diff --git a/internal/sysenc/buffer_test.go b/internal/sysenc/buffer_test.go
index d6fc64e..5918198 100644
--- a/internal/sysenc/buffer_test.go
+++ b/internal/sysenc/buffer_test.go
@@ -4,24 +4,25 @@ import (
 	"testing"
 	"unsafe"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/internal/sys"
 	"github.com/cilium/ebpf/internal/sysenc"
-	qt "github.com/frankban/quicktest"
 )
 
 func TestZeroBuffer(t *testing.T) {
 	var zero sysenc.Buffer
 
-	qt.Assert(t, zero.CopyTo(make([]byte, 1)), qt.Equals, 0)
-	qt.Assert(t, zero.Pointer(), qt.Equals, sys.Pointer{})
-	qt.Assert(t, zero.Unmarshal(new(uint16)), qt.IsNotNil)
+	qt.Assert(t, qt.Equals(zero.CopyTo(make([]byte, 1)), 0))
+	qt.Assert(t, qt.Equals(zero.Pointer(), sys.Pointer{}))
+	qt.Assert(t, qt.IsNotNil(zero.Unmarshal(new(uint16))))
 }
 
 func TestUnsafeBuffer(t *testing.T) {
 	ptr := unsafe.Pointer(new(uint16))
 	buf := sysenc.UnsafeBuffer(ptr)
 
-	qt.Assert(t, buf.CopyTo(make([]byte, 1)), qt.Equals, 0)
-	qt.Assert(t, buf.Pointer(), qt.Equals, sys.NewPointer(ptr))
-	qt.Assert(t, buf.Unmarshal(new(uint16)), qt.IsNil)
+	qt.Assert(t, qt.Equals(buf.CopyTo(make([]byte, 1)), 0))
+	qt.Assert(t, qt.Equals(buf.Pointer(), sys.NewPointer(ptr)))
+	qt.Assert(t, qt.IsNil(buf.Unmarshal(new(uint16))))
 }
diff --git a/internal/sysenc/layout_test.go b/internal/sysenc/layout_test.go
index 255af23..3628c12 100644
--- a/internal/sysenc/layout_test.go
+++ b/internal/sysenc/layout_test.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestHasUnexportedFields(t *testing.T) {
@@ -31,7 +31,7 @@ func TestHasUnexportedFields(t *testing.T) {
 	} {
 		t.Run(fmt.Sprintf("%T", test.value), func(t *testing.T) {
 			have := hasUnexportedFields(reflect.TypeOf(test.value))
-			qt.Assert(t, have, qt.Equals, test.result)
+			qt.Assert(t, qt.Equals(have, test.result))
 		})
 	}
 }
diff --git a/internal/sysenc/marshal_test.go b/internal/sysenc/marshal_test.go
index 95f7651..96b8a98 100644
--- a/internal/sysenc/marshal_test.go
+++ b/internal/sysenc/marshal_test.go
@@ -8,9 +8,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/cilium/ebpf/internal"
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"github.com/cilium/ebpf/internal"
 )
 
 type testcase struct {
@@ -69,8 +70,8 @@ func TestMarshal(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			qt.Assert(t, buf.CopyTo(have), qt.Equals, want.Len())
-			qt.Assert(t, have, qt.CmpEquals(cmpopts.EquateEmpty()), want.Bytes())
+			qt.Assert(t, qt.Equals(buf.CopyTo(have), want.Len()))
+			qt.Assert(t, qt.CmpEquals(have, want.Bytes(), cmpopts.EquateEmpty()))
 		})
 	}
 }
@@ -93,7 +94,7 @@ func TestMarshalAllocations(t *testing.T) {
 
 		value := test.new()
 		t.Run(fmt.Sprintf("%T", value), func(t *testing.T) {
-			qt.Assert(t, allocationsPerMarshal(t, value), qt.Equals, float64(0))
+			qt.Assert(t, qt.Equals(allocationsPerMarshal(t, value), 0))
 		})
 	}
 }
@@ -109,8 +110,8 @@ func TestUnmarshal(t *testing.T) {
 			want := test.new()
 			buf := randomiseValue(t, want)
 
-			qt.Assert(t, Unmarshal(value, buf), qt.IsNil)
-			qt.Assert(t, value, qt.DeepEquals, want)
+			qt.Assert(t, qt.IsNil(Unmarshal(value, buf)))
+			qt.Assert(t, qt.DeepEquals(value, want))
 		})
 	}
 }
@@ -137,7 +138,7 @@ func TestUnmarshalAllocations(t *testing.T) {
 
 		t.Run(fmt.Sprintf("%T", value), func(t *testing.T) {
 			buf := make([]byte, binary.Size(value))
-			qt.Assert(t, allocationsPerUnmarshal(t, value, buf), qt.Equals, float64(0))
+			qt.Assert(t, qt.Equals(allocationsPerUnmarshal(t, value, buf), 0))
 		})
 	}
 }
@@ -147,7 +148,7 @@ func TestUnsafeBackingMemory(t *testing.T) {
 		t.Helper()
 
 		var buf bytes.Buffer
-		qt.Assert(t, binary.Write(&buf, internal.NativeEndian, data), qt.IsNil)
+		qt.Assert(t, qt.IsNil(binary.Write(&buf, internal.NativeEndian, data)))
 		return buf.Bytes()
 	}
 
@@ -186,7 +187,7 @@ func TestUnsafeBackingMemory(t *testing.T) {
 		t.Run("valid: "+test.name, func(t *testing.T) {
 			want := marshalNative(t, test.value)
 			have := unsafeBackingMemory(test.value)
-			qt.Assert(t, have, qt.DeepEquals, want)
+			qt.Assert(t, qt.DeepEquals(have, want))
 		})
 	}
 
@@ -243,7 +244,7 @@ func TestUnsafeBackingMemory(t *testing.T) {
 		},
 	} {
 		t.Run("invalid: "+test.name, func(t *testing.T) {
-			qt.Assert(t, unsafeBackingMemory(test.value), qt.IsNil)
+			qt.Assert(t, qt.IsNil(unsafeBackingMemory(test.value)))
 		})
 	}
 }
@@ -295,7 +296,7 @@ func randomiseValue(tb testing.TB, value any) []byte {
 	}
 
 	err := binary.Read(bytes.NewReader(buf), internal.NativeEndian, value)
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 
 	return buf
 }
diff --git a/internal/tracefs/kprobe_test.go b/internal/tracefs/kprobe_test.go
index 6921410..e0d6e9b 100644
--- a/internal/tracefs/kprobe_test.go
+++ b/internal/tracefs/kprobe_test.go
@@ -5,19 +5,17 @@ import (
 	"os"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 // Global symbol, present on all tested kernels.
 const ksym = "vprintk"
 
 func TestKprobeTraceFSGroup(t *testing.T) {
-	c := qt.New(t)
-
 	// Expect <prefix>_<16 random hex chars>.
 	g, err := RandomGroup("ebpftest")
-	c.Assert(err, qt.IsNil)
-	c.Assert(g, qt.Matches, `ebpftest_[a-f0-9]{16}`)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Matches(g, `ebpftest_[a-f0-9]{16}`))
 
 	// Expect error when the generator's output exceeds 63 characters.
 	p := make([]byte, 47) // 63 - 17 (length of the random suffix and underscore) + 1
@@ -25,11 +23,11 @@ func TestKprobeTraceFSGroup(t *testing.T) {
 		p[i] = byte('a')
 	}
 	_, err = RandomGroup(string(p))
-	c.Assert(err, qt.Not(qt.IsNil))
+	qt.Assert(t, qt.Not(qt.IsNil(err)))
 
 	// Reject non-alphanumeric characters.
 	_, err = RandomGroup("/")
-	c.Assert(err, qt.Not(qt.IsNil))
+	qt.Assert(t, qt.Not(qt.IsNil(err)))
 }
 
 func TestKprobeToken(t *testing.T) {
@@ -65,15 +63,15 @@ func TestNewEvent(t *testing.T) {
 			args.Group, _ = RandomGroup("ebpftest")
 
 			evt, err := NewEvent(args)
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 			defer evt.Close()
 
 			_, err = NewEvent(args)
-			qt.Assert(t, err, qt.ErrorIs, os.ErrExist,
+			qt.Assert(t, qt.ErrorIs(err, os.ErrExist),
 				qt.Commentf("expected consecutive event creation to contain os.ErrExist"))
 
-			qt.Assert(t, evt.Close(), qt.IsNil)
-			qt.Assert(t, evt.Close(), qt.ErrorIs, os.ErrClosed)
+			qt.Assert(t, qt.IsNil(evt.Close()))
+			qt.Assert(t, qt.ErrorIs(evt.Close(), os.ErrClosed))
 		})
 	}
 }
diff --git a/internal/tracefs/perf_event_test.go b/internal/tracefs/perf_event_test.go
index ded1279..59e933b 100644
--- a/internal/tracefs/perf_event_test.go
+++ b/internal/tracefs/perf_event_test.go
@@ -5,15 +5,14 @@ import (
 	"fmt"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestEventID(t *testing.T) {
-	c := qt.New(t)
 
 	eid, err := EventID("syscalls", "sys_enter_mmap")
-	c.Assert(err, qt.IsNil)
-	c.Assert(eid, qt.Not(qt.Equals), 0)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Not(qt.Equals(eid, 0)))
 }
 
 func TestSanitizePath(t *testing.T) {
@@ -82,5 +81,5 @@ func TestSanitizeIdentifier(t *testing.T) {
 
 func TestGetTracefsPath(t *testing.T) {
 	_, err := getTracefsPath()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 }
diff --git a/internal/vdso_test.go b/internal/vdso_test.go
index ab2d4a7..d500a61 100644
--- a/internal/vdso_test.go
+++ b/internal/vdso_test.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestAuxvVDSOMemoryAddress(t *testing.T) {
@@ -53,7 +53,7 @@ func TestAuxvNoVDSO(t *testing.T) {
 
 func TestVDSOVersion(t *testing.T) {
 	_, err := vdsoVersion()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 }
 
 func TestLinuxVersionCodeEmbedded(t *testing.T) {
diff --git a/link/kprobe_test.go b/link/kprobe_test.go
index ed54d09..7ac0a42 100644
--- a/link/kprobe_test.go
+++ b/link/kprobe_test.go
@@ -5,7 +5,7 @@ import (
 	"os"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/asm"
@@ -38,16 +38,14 @@ func TestKprobe(t *testing.T) {
 		})
 	}
 
-	c := qt.New(t)
-
 	k, err := Kprobe("bogus", prog, nil)
-	c.Assert(err, qt.ErrorIs, os.ErrNotExist, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrNotExist), qt.Commentf("got error: %s", err))
 	if k != nil {
 		k.Close()
 	}
 
 	k, err = Kprobe(ksym, prog, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer k.Close()
 
 	testLink(t, k, prog)
@@ -104,8 +102,6 @@ func TestKretprobe(t *testing.T) {
 		})
 	}
 
-	c := qt.New(t)
-
 	k, err := Kretprobe("bogus", prog, nil)
 	if !(errors.Is(err, os.ErrNotExist) || errors.Is(err, unix.EINVAL)) {
 		t.Fatal(err)
@@ -115,28 +111,26 @@ func TestKretprobe(t *testing.T) {
 	}
 
 	k, err = Kretprobe(ksym, prog, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer k.Close()
 
 	testLink(t, k, prog)
 }
 
 func TestKprobeErrors(t *testing.T) {
-	c := qt.New(t)
-
 	// Invalid Kprobe incantations. Kretprobe uses the same code paths
 	// with a different ret flag.
 	_, err := Kprobe("", nil, nil) // empty symbol
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Kprobe("_", nil, nil) // empty prog
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Kprobe(".", &ebpf.Program{}, nil) // illegal chars in symbol
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Kprobe("foo", &ebpf.Program{}, nil) // wrong prog type
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 }
 
 // Test k(ret)probe creation using perf_kprobe PMU.
@@ -144,33 +138,29 @@ func TestKprobeCreatePMU(t *testing.T) {
 	// Requires at least 4.17 (e12f03d7031a "perf/core: Implement the 'perf_kprobe' PMU")
 	testutils.SkipOnOldKernel(t, "4.17", "perf_kprobe PMU")
 
-	c := qt.New(t)
-
 	// kprobe happy path. printk is always present.
 	pk, err := pmuProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer pk.Close()
 
 	// kretprobe happy path.
 	pr, err := pmuProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym, Ret: true})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer pr.Close()
 
 	// Expect os.ErrNotExist when specifying a non-existent kernel symbol
 	// on kernels 4.17 and up.
 	_, err = pmuProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: "bogus"})
-	c.Assert(errors.Is(err, os.ErrNotExist), qt.IsTrue, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrNotExist), qt.Commentf("got error: %s", err))
 
 	// A kernel bug was fixed in 97c753e62e6c where EINVAL was returned instead
 	// of ENOENT, but only for kretprobes.
 	_, err = pmuProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: "bogus", Ret: true})
-	c.Assert(errors.Is(err, os.ErrNotExist), qt.IsTrue, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrNotExist), qt.Commentf("got error: %s", err))
 }
 
 // Test fallback behaviour on kernels without perf_kprobe PMU available.
 func TestKprobePMUUnavailable(t *testing.T) {
-	c := qt.New(t)
-
 	pk, err := pmuProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym})
 	if err == nil {
 		pk.Close()
@@ -178,7 +168,7 @@ func TestKprobePMUUnavailable(t *testing.T) {
 	}
 
 	// Only allow a PMU creation with a valid kernel symbol to fail with ErrNotSupported.
-	c.Assert(errors.Is(err, ErrNotSupported), qt.IsTrue, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, ErrNotSupported), qt.Commentf("got error: %s", err))
 }
 
 func BenchmarkKprobeCreatePMU(b *testing.B) {
@@ -196,47 +186,45 @@ func BenchmarkKprobeCreatePMU(b *testing.B) {
 
 // Test tracefs k(ret)probe creation on all kernel versions.
 func TestKprobeTraceFS(t *testing.T) {
-	c := qt.New(t)
-
 	// Open and close tracefs k(ret)probes, checking all errors.
 	kp, err := tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym})
-	c.Assert(err, qt.IsNil)
-	c.Assert(kp.Close(), qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.IsNil(kp.Close()))
 
 	kp, err = tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym, Ret: true})
-	c.Assert(err, qt.IsNil)
-	c.Assert(kp.Close(), qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.IsNil(kp.Close()))
 
 	// Create two identical trace events, ensure their IDs differ.
 	k1, err := tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer k1.Close()
-	c.Assert(k1.tracefsEvent, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(k1.tracefsEvent))
 
 	k2, err := tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer k2.Close()
-	c.Assert(k2.tracefsEvent, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(k2.tracefsEvent))
 
 	// Compare the kprobes' tracefs IDs.
-	c.Assert(k1.tracefsEvent.ID(), qt.Not(qt.Equals), k2.tracefsEvent.ID())
+	qt.Assert(t, qt.Not(qt.Equals(k1.tracefsEvent.ID(), k2.tracefsEvent.ID())))
 
 	// Expect an error when supplying an invalid custom group name
 	_, err = tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym, Group: "/"})
-	c.Assert(err, qt.Not(qt.IsNil))
+	qt.Assert(t, qt.Not(qt.IsNil(err)))
 
 	cg := "customgroup"
 	k3, err := tracefsProbe(tracefs.ProbeArgs{Type: tracefs.Kprobe, Symbol: ksym, Group: cg})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer k3.Close()
-	c.Assert(k3.tracefsEvent.Group(), qt.Matches, `customgroup_[a-f0-9]{16}`)
+	qt.Assert(t, qt.Matches(k3.tracefsEvent.Group(), `customgroup_[a-f0-9]{16}`))
 
 	// Prepare probe args.
 	args := tracefs.ProbeArgs{Type: tracefs.Kprobe, Group: "testgroup", Symbol: "symbol"}
 
 	// Write a k(ret)probe event for a non-existing symbol.
 	_, err = tracefs.NewEvent(args)
-	c.Assert(errors.Is(err, os.ErrNotExist), qt.IsTrue, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrNotExist), qt.Commentf("got error: %s", err))
 
 	// A kernel bug was fixed in 97c753e62e6c where EINVAL was returned instead
 	// of ENOENT, but only for kretprobes.
diff --git a/link/link_test.go b/link/link_test.go
index 6297d4b..8bb2863 100644
--- a/link/link_test.go
+++ b/link/link_test.go
@@ -15,7 +15,7 @@ import (
 	"github.com/cilium/ebpf/internal/testutils/fdtrace"
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestMain(m *testing.M) {
@@ -62,13 +62,13 @@ func TestUnpinRawLink(t *testing.T) {
 	link, _ := newPinnedRawLink(t, cgroup, prog)
 	defer link.Close()
 
-	qt.Assert(t, link.IsPinned(), qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(link.IsPinned()))
 
 	if err := link.Unpin(); err != nil {
 		t.Fatal(err)
 	}
 
-	qt.Assert(t, link.IsPinned(), qt.IsFalse)
+	qt.Assert(t, qt.IsFalse(link.IsPinned()))
 }
 
 func TestRawLinkLoadPinnedWithOptions(t *testing.T) {
@@ -76,7 +76,7 @@ func TestRawLinkLoadPinnedWithOptions(t *testing.T) {
 	link, path := newPinnedRawLink(t, cgroup, prog)
 	defer link.Close()
 
-	qt.Assert(t, link.IsPinned(), qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(link.IsPinned()))
 
 	// It seems like the kernel ignores BPF_F_RDONLY when updating a link,
 	// so we can't test this.
diff --git a/link/program_test.go b/link/program_test.go
index 3fabe3f..18f197c 100644
--- a/link/program_test.go
+++ b/link/program_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/internal/testutils"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestProgramAlter(t *testing.T) {
@@ -51,11 +51,11 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 	testutils.SkipOnOldKernel(t, "6.6", "attach anchor")
 
 	iface, err := net.InterfaceByName("lo")
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	a := mustLoadProgram(t, ebpf.SchedCLS, 0, "")
 	info, err := a.Info()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	aID, _ := info.ID()
 
 	err = RawAttachProgram(RawAttachProgramOptions{
@@ -63,7 +63,7 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 		Program: a,
 		Attach:  ebpf.AttachTCXIngress,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer RawDetachProgram(RawDetachProgramOptions{
 		Target:  iface.Index,
 		Program: a,
@@ -75,11 +75,11 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 		Program:   mustLoadProgram(t, ebpf.SchedCLS, 0, ""),
 		Attach:    ebpf.AttachTCXIngress,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer link.Close()
 
 	linkInfo, err := link.Info()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	b := mustLoadProgram(t, ebpf.SchedCLS, 0, "")
 
@@ -98,7 +98,7 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 				Attach:  ebpf.AttachTCXIngress,
 				Anchor:  anchor,
 			})
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 
 			// Detach doesn't allow first or last anchor.
 			if _, ok := anchor.(firstAnchor); ok {
@@ -113,7 +113,7 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 				Attach:  ebpf.AttachTCXIngress,
 				Anchor:  anchor,
 			})
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 		})
 	}
 
@@ -124,12 +124,12 @@ func TestRawAttachProgramAnchor(t *testing.T) {
 		Attach:  ebpf.AttachTCXIngress,
 		Anchor:  ReplaceProgram(a),
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	err = RawDetachProgram(RawDetachProgramOptions{
 		Target:  iface.Index,
 		Program: b,
 		Attach:  ebpf.AttachTCXIngress,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 }
diff --git a/link/query_test.go b/link/query_test.go
index c02a21c..731ec47 100644
--- a/link/query_test.go
+++ b/link/query_test.go
@@ -7,7 +7,7 @@ import (
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/internal/testutils"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 	"golang.org/x/exp/slices"
 )
 
@@ -22,29 +22,29 @@ func TestQueryPrograms(t *testing.T) {
 			prog, link, opts := fn(t)
 			result, err := QueryPrograms(opts)
 			testutils.SkipIfNotSupported(t, err)
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 
 			progInfo, err := prog.Info()
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 			progID, _ := progInfo.ID()
 
 			i := slices.IndexFunc(result.Programs, func(ap AttachedProgram) bool {
 				return ap.ID == progID
 			})
-			qt.Assert(t, i, qt.Not(qt.Equals), -1)
+			qt.Assert(t, qt.Not(qt.Equals(i, -1)))
 
 			if name == "tcx" {
-				qt.Assert(t, result.Revision, qt.Not(qt.Equals), uint64(0))
+				qt.Assert(t, qt.Not(qt.Equals(result.Revision, 0)))
 			}
 
 			if result.HaveLinkInfo() {
 				ap := result.Programs[i]
 				linkInfo, err := link.Info()
-				qt.Assert(t, err, qt.IsNil)
+				qt.Assert(t, qt.IsNil(err))
 
 				linkID, ok := ap.LinkID()
-				qt.Assert(t, ok, qt.IsTrue)
-				qt.Assert(t, linkID, qt.Equals, linkInfo.ID)
+				qt.Assert(t, qt.IsTrue(ok))
+				qt.Assert(t, qt.Equals(linkID, linkInfo.ID))
 			}
 		})
 	}
@@ -58,7 +58,7 @@ func queryCgroupProgAttachFixtures(t *testing.T) (*ebpf.Program, Link, QueryOpti
 		t.Fatal("Can't create link:", err)
 	}
 	t.Cleanup(func() {
-		qt.Assert(t, link.Close(), qt.IsNil)
+		qt.Assert(t, qt.IsNil(link.Close()))
 	})
 
 	return prog, nil, QueryOptions{
@@ -76,7 +76,7 @@ func queryCgroupLinkFixtures(t *testing.T) (*ebpf.Program, Link, QueryOptions) {
 		t.Fatal("Can't create link:", err)
 	}
 	t.Cleanup(func() {
-		qt.Assert(t, link.Close(), qt.IsNil)
+		qt.Assert(t, qt.IsNil(link.Close()))
 	})
 
 	return prog, nil, QueryOptions{
@@ -112,7 +112,7 @@ func queryNetNSFixtures(t *testing.T) (*ebpf.Program, Link, QueryOptions) {
 	})
 
 	netns, err := os.Open("/proc/self/ns/net")
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	t.Cleanup(func() { netns.Close() })
 
 	return prog, nil, QueryOptions{
diff --git a/link/tcx_test.go b/link/tcx_test.go
index 53ac959..89c89d3 100644
--- a/link/tcx_test.go
+++ b/link/tcx_test.go
@@ -6,7 +6,7 @@ import (
 	"net"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/internal/testutils"
@@ -31,11 +31,11 @@ func TestTCXAnchor(t *testing.T) {
 	linkA, iface := mustAttachTCX(t, a, ebpf.AttachTCXEgress)
 
 	programInfo, err := a.Info()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	programID, _ := programInfo.ID()
 
 	linkInfo, err := linkA.Info()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	linkID := linkInfo.ID
 
 	for _, anchor := range []Anchor{
@@ -53,8 +53,8 @@ func TestTCXAnchor(t *testing.T) {
 				Interface: iface,
 				Anchor:    anchor,
 			})
-			qt.Assert(t, err, qt.IsNil)
-			qt.Assert(t, linkB.Close(), qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
+			qt.Assert(t, qt.IsNil(linkB.Close()))
 		})
 	}
 }
@@ -63,7 +63,7 @@ func TestTCXExpectedRevision(t *testing.T) {
 	testutils.SkipOnOldKernel(t, "6.6", "TCX link")
 
 	iface, err := net.InterfaceByName("lo")
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	_, err = AttachTCX(TCXOptions{
 		Program:          mustLoadProgram(t, ebpf.SchedCLS, ebpf.AttachNone, ""),
@@ -71,20 +71,20 @@ func TestTCXExpectedRevision(t *testing.T) {
 		Interface:        iface.Index,
 		ExpectedRevision: math.MaxUint64,
 	})
-	qt.Assert(t, err, qt.ErrorIs, unix.ESTALE)
+	qt.Assert(t, qt.ErrorIs(err, unix.ESTALE))
 }
 
 func mustAttachTCX(tb testing.TB, prog *ebpf.Program, attachType ebpf.AttachType) (Link, int) {
 	iface, err := net.InterfaceByName("lo")
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 
 	link, err := AttachTCX(TCXOptions{
 		Program:   prog,
 		Attach:    attachType,
 		Interface: iface.Index,
 	})
-	qt.Assert(tb, err, qt.IsNil)
-	tb.Cleanup(func() { qt.Assert(tb, link.Close(), qt.IsNil) })
+	qt.Assert(tb, qt.IsNil(err))
+	tb.Cleanup(func() { qt.Assert(tb, qt.IsNil(link.Close())) })
 
 	return link, iface.Index
 }
diff --git a/link/tracepoint_test.go b/link/tracepoint_test.go
index a6397ae..a58f1f2 100644
--- a/link/tracepoint_test.go
+++ b/link/tracepoint_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestTracepoint(t *testing.T) {
@@ -43,20 +43,18 @@ func TestTracepointMissing(t *testing.T) {
 }
 
 func TestTracepointErrors(t *testing.T) {
-	c := qt.New(t)
-
 	// Invalid Tracepoint incantations.
 	_, err := Tracepoint("", "", nil, nil) // empty names
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Tracepoint("_", "_", nil, nil) // empty prog
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Tracepoint(".", "+", &ebpf.Program{}, nil) // illegal chars in group/name
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 
 	_, err = Tracepoint("foo", "bar", &ebpf.Program{}, nil) // wrong prog type
-	c.Assert(errors.Is(err, errInvalidInput), qt.IsTrue)
+	qt.Assert(t, qt.ErrorIs(err, errInvalidInput))
 }
 
 func TestTracepointProgramCall(t *testing.T) {
diff --git a/link/uprobe_test.go b/link/uprobe_test.go
index 61f045e..1616bde 100644
--- a/link/uprobe_test.go
+++ b/link/uprobe_test.go
@@ -8,7 +8,7 @@ import (
 	"path"
 	"testing"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 
 	"github.com/cilium/ebpf"
 	"github.com/cilium/ebpf/internal/testutils"
@@ -43,8 +43,6 @@ func TestExecutable(t *testing.T) {
 }
 
 func TestExecutableOffset(t *testing.T) {
-	c := qt.New(t)
-
 	symbolOffset, err := bashEx.address(bashSym, &UprobeOptions{})
 	if err != nil {
 		t.Fatal(err)
@@ -54,52 +52,48 @@ func TestExecutableOffset(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	c.Assert(offset, qt.Equals, uint64(0x1))
+	qt.Assert(t, qt.Equals(offset, 0x1))
 
 	offset, err = bashEx.address(bashSym, &UprobeOptions{Offset: 0x2})
 	if err != nil {
 		t.Fatal(err)
 	}
-	c.Assert(offset, qt.Equals, symbolOffset+0x2)
+	qt.Assert(t, qt.Equals(offset, symbolOffset+0x2))
 
 	offset, err = bashEx.address(bashSym, &UprobeOptions{Address: 0x1, Offset: 0x2})
 	if err != nil {
 		t.Fatal(err)
 	}
-	c.Assert(offset, qt.Equals, uint64(0x1+0x2))
+	qt.Assert(t, qt.Equals(offset, 0x1+0x2))
 }
 
 func TestExecutableLazyLoadSymbols(t *testing.T) {
-	c := qt.New(t)
-
 	ex, err := OpenExecutable("/bin/bash")
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	// Addresses must be empty, will be lazy loaded.
-	c.Assert(ex.addresses, qt.DeepEquals, map[string]uint64{})
+	qt.Assert(t, qt.DeepEquals(ex.addresses, map[string]uint64{}))
 
 	prog := mustLoadProgram(t, ebpf.Kprobe, 0, "")
 	up, err := ex.Uprobe(bashSym, prog, &UprobeOptions{Address: 123})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	up.Close()
 
 	// Addresses must still be empty as Address has been provided via options.
-	c.Assert(ex.addresses, qt.DeepEquals, map[string]uint64{})
+	qt.Assert(t, qt.DeepEquals(ex.addresses, map[string]uint64{}))
 
 	up, err = ex.Uprobe(bashSym, prog, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	up.Close()
 
 	// Symbol table should be loaded.
-	c.Assert(len(ex.addresses), qt.Not(qt.Equals), 0)
+	qt.Assert(t, qt.Not(qt.HasLen(ex.addresses, 0)))
 }
 
 func TestUprobe(t *testing.T) {
-	c := qt.New(t)
-
 	prog := mustLoadProgram(t, ebpf.Kprobe, 0, "")
 
 	up, err := bashEx.Uprobe(bashSym, prog, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer up.Close()
 
 	testLink(t, up, prog)
@@ -152,12 +146,10 @@ func TestUprobeWithNonExistentPID(t *testing.T) {
 }
 
 func TestUretprobe(t *testing.T) {
-	c := qt.New(t)
-
 	prog := mustLoadProgram(t, ebpf.Kprobe, 0, "")
 
 	up, err := bashEx.Uretprobe(bashSym, prog, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer up.Close()
 
 	testLink(t, up, prog)
@@ -168,11 +160,9 @@ func TestUprobeCreatePMU(t *testing.T) {
 	// Requires at least 4.17 (e12f03d7031a "perf/core: Implement the 'perf_kprobe' PMU")
 	testutils.SkipOnOldKernel(t, "4.17", "perf_kprobe PMU")
 
-	c := qt.New(t)
-
 	// Fetch the offset from the /bin/bash Executable already defined.
 	off, err := bashEx.address(bashSym, &UprobeOptions{})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	// Prepare probe args.
 	args := tracefs.ProbeArgs{
@@ -185,23 +175,21 @@ func TestUprobeCreatePMU(t *testing.T) {
 
 	// uprobe PMU
 	pu, err := pmuProbe(args)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer pu.Close()
 
 	// uretprobe PMU
 	args.Ret = true
 	pr, err := pmuProbe(args)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer pr.Close()
 }
 
 // Test fallback behaviour on kernels without perf_uprobe PMU available.
 func TestUprobePMUUnavailable(t *testing.T) {
-	c := qt.New(t)
-
 	// Fetch the offset from the /bin/bash Executable already defined.
 	off, err := bashEx.address(bashSym, &UprobeOptions{})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	// Prepare probe args.
 	args := tracefs.ProbeArgs{
@@ -219,16 +207,14 @@ func TestUprobePMUUnavailable(t *testing.T) {
 	}
 
 	// Expect ErrNotSupported.
-	c.Assert(errors.Is(err, ErrNotSupported), qt.IsTrue, qt.Commentf("got error: %s", err))
+	qt.Assert(t, qt.ErrorIs(err, ErrNotSupported), qt.Commentf("got error: %s", err))
 }
 
 // Test tracefs u(ret)probe creation on all kernel versions.
 func TestUprobeTraceFS(t *testing.T) {
-	c := qt.New(t)
-
 	// Fetch the offset from the /bin/bash Executable already defined.
 	off, err := bashEx.address(bashSym, &UprobeOptions{})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	// Prepare probe args.
 	args := tracefs.ProbeArgs{
@@ -241,39 +227,39 @@ func TestUprobeTraceFS(t *testing.T) {
 
 	// Open and close tracefs u(ret)probes, checking all errors.
 	up, err := tracefsProbe(args)
-	c.Assert(err, qt.IsNil)
-	c.Assert(up.Close(), qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.IsNil(up.Close()))
 
 	args.Ret = true
 	up, err = tracefsProbe(args)
-	c.Assert(err, qt.IsNil)
-	c.Assert(up.Close(), qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.IsNil(up.Close()))
 
 	// Create two identical trace events, ensure their IDs differ.
 	args.Ret = false
 	u1, err := tracefsProbe(args)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer u1.Close()
-	c.Assert(u1.tracefsEvent, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(u1.tracefsEvent))
 
 	u2, err := tracefsProbe(args)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer u2.Close()
-	c.Assert(u2.tracefsEvent, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(u2.tracefsEvent))
 
 	// Compare the uprobes' tracefs IDs.
-	c.Assert(u1.tracefsEvent.ID(), qt.Not(qt.Equals), u2.tracefsEvent.ID())
+	qt.Assert(t, qt.Not(qt.Equals(u1.tracefsEvent.ID(), u2.tracefsEvent.ID())))
 
 	// Expect an error when supplying an invalid custom group name
 	args.Group = "/"
 	_, err = tracefsProbe(args)
-	c.Assert(err, qt.Not(qt.IsNil))
+	qt.Assert(t, qt.Not(qt.IsNil(err)))
 
 	args.Group = "customgroup"
 	u3, err := tracefsProbe(args)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer u3.Close()
-	c.Assert(u3.tracefsEvent.Group(), qt.Matches, `customgroup_[a-f0-9]{16}`)
+	qt.Assert(t, qt.Matches(u3.tracefsEvent.Group(), `customgroup_[a-f0-9]{16}`))
 }
 
 func TestUprobeProgramCall(t *testing.T) {
diff --git a/linker_test.go b/linker_test.go
index 3c76ff7..e75c50c 100644
--- a/linker_test.go
+++ b/linker_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestFindReferences(t *testing.T) {
@@ -112,34 +112,33 @@ func TestForwardFunctionDeclaration(t *testing.T) {
 }
 
 func TestSplitSymbols(t *testing.T) {
-	c := qt.New(t)
 
 	// Splitting an empty insns results in an error.
 	_, err := splitSymbols(asm.Instructions{})
-	c.Assert(err, qt.IsNotNil, qt.Commentf("empty insns"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("empty insns"))
 
 	// Splitting non-empty insns without a leading Symbol is an error.
 	_, err = splitSymbols(asm.Instructions{
 		asm.Return(),
 	})
-	c.Assert(err, qt.IsNotNil, qt.Commentf("insns without leading Symbol"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("insns without leading Symbol"))
 
 	// Non-empty insns with a single Instruction that is a Symbol.
 	insns := asm.Instructions{
 		asm.Return().WithSymbol("sym"),
 	}
 	m, err := splitSymbols(insns)
-	c.Assert(err, qt.IsNil, qt.Commentf("insns with a single Symbol"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("insns with a single Symbol"))
 
-	c.Assert(len(m), qt.Equals, 1)
-	c.Assert(len(m["sym"]), qt.Equals, 1)
+	qt.Assert(t, qt.HasLen(m, 1))
+	qt.Assert(t, qt.HasLen(m["sym"], 1))
 
 	// Insns containing duplicate Symbols.
 	_, err = splitSymbols(asm.Instructions{
 		asm.Return().WithSymbol("sym"),
 		asm.Return().WithSymbol("sym"),
 	})
-	c.Assert(err, qt.IsNotNil, qt.Commentf("insns containing duplicate Symbols"))
+	qt.Assert(t, qt.IsNotNil(err), qt.Commentf("insns containing duplicate Symbols"))
 
 	// Insns with multiple Symbols and subprogs of various lengths.
 	m, err = splitSymbols(asm.Instructions{
@@ -157,11 +156,11 @@ func TestSplitSymbols(t *testing.T) {
 		asm.Mov.Imm(asm.R0, 2),
 		asm.Return(),
 	})
-	c.Assert(err, qt.IsNil, qt.Commentf("insns with multiple Symbols"))
+	qt.Assert(t, qt.IsNil(err), qt.Commentf("insns with multiple Symbols"))
 
-	c.Assert(len(m), qt.Equals, 4)
-	c.Assert(len(m["sym1"]), qt.Equals, 1)
-	c.Assert(len(m["sym2"]), qt.Equals, 2)
-	c.Assert(len(m["sym3"]), qt.Equals, 3)
-	c.Assert(len(m["sym4"]), qt.Equals, 4)
+	qt.Assert(t, qt.HasLen(m, 4))
+	qt.Assert(t, qt.HasLen(m["sym1"], 1))
+	qt.Assert(t, qt.HasLen(m["sym2"], 2))
+	qt.Assert(t, qt.HasLen(m["sym3"], 3))
+	qt.Assert(t, qt.HasLen(m["sym4"], 4))
 }
diff --git a/map_test.go b/map_test.go
index 6e7710a..e370c0a 100644
--- a/map_test.go
+++ b/map_test.go
@@ -16,7 +16,7 @@ import (
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 var (
@@ -75,12 +75,12 @@ func TestMap(t *testing.T) {
 	}
 
 	sliceVal := make([]uint32, 1)
-	qt.Assert(t, m.Lookup(uint32(0), sliceVal), qt.IsNil)
-	qt.Assert(t, sliceVal, qt.DeepEquals, []uint32{42})
+	qt.Assert(t, qt.IsNil(m.Lookup(uint32(0), sliceVal)))
+	qt.Assert(t, qt.DeepEquals(sliceVal, []uint32{42}))
 
 	var slice []byte
-	qt.Assert(t, m.Lookup(uint32(0), &slice), qt.IsNil)
-	qt.Assert(t, slice, qt.DeepEquals, internal.NativeEndian.AppendUint32(nil, 42))
+	qt.Assert(t, qt.IsNil(m.Lookup(uint32(0), &slice)))
+	qt.Assert(t, qt.DeepEquals(slice, internal.NativeEndian.AppendUint32(nil, 42)))
 
 	var k uint32
 	if err := m.NextKey(uint32(0), &k); err != nil {
@@ -132,8 +132,8 @@ func TestMapBatch(t *testing.T) {
 	for _, m := range []*Map{array, hash} {
 		t.Run(m.Type().String(), func(t *testing.T) {
 			count, err := m.BatchUpdate(keys, values, nil)
-			qt.Assert(t, err, qt.IsNil)
-			qt.Assert(t, count, qt.Equals, len(contents))
+			qt.Assert(t, qt.IsNil(err))
+			qt.Assert(t, qt.Equals(count, len(contents)))
 
 			n := len(contents) / 2 // cut buffer in half
 			lookupKeys := make([]uint32, n)
@@ -147,15 +147,15 @@ func TestMapBatch(t *testing.T) {
 				if errors.Is(err, ErrKeyNotExist) {
 					break
 				}
-				qt.Assert(t, err, qt.IsNil)
+				qt.Assert(t, qt.IsNil(err))
 
-				qt.Assert(t, count <= len(lookupKeys), qt.IsTrue)
+				qt.Assert(t, qt.IsTrue(count <= len(lookupKeys)))
 				for i, key := range lookupKeys[:count] {
 					value := lookupValues[i]
-					qt.Assert(t, value, qt.Equals, contents[key], qt.Commentf("value for key %d should match", key))
+					qt.Assert(t, qt.Equals(value, contents[key]), qt.Commentf("value for key %d should match", key))
 				}
 			}
-			qt.Assert(t, total, qt.Equals, len(contents))
+			qt.Assert(t, qt.Equals(total, len(contents)))
 
 			if m.Type() == Array {
 				// Array doesn't support batch delete
@@ -170,18 +170,18 @@ func TestMapBatch(t *testing.T) {
 				if errors.Is(err, ErrKeyNotExist) {
 					break
 				}
-				qt.Assert(t, err, qt.IsNil)
+				qt.Assert(t, qt.IsNil(err))
 
-				qt.Assert(t, count, qt.Equals, len(lookupKeys))
+				qt.Assert(t, qt.Equals(count, len(lookupKeys)))
 				for i, key := range lookupKeys {
 					value := lookupValues[i]
-					qt.Assert(t, value, qt.Equals, contents[key], qt.Commentf("value for key %d should match", key))
+					qt.Assert(t, qt.Equals(value, contents[key]), qt.Commentf("value for key %d should match", key))
 				}
 			}
-			qt.Assert(t, total, qt.Equals, len(contents))
+			qt.Assert(t, qt.Equals(total, len(contents)))
 
 			var v uint32
-			qt.Assert(t, m.Lookup(uint32(0), &v), qt.ErrorIs, ErrKeyNotExist)
+			qt.Assert(t, qt.ErrorIs(m.Lookup(uint32(0), &v), ErrKeyNotExist))
 		})
 	}
 }
@@ -211,10 +211,10 @@ func TestMapBatchCursorReuse(t *testing.T) {
 	var cursor BatchCursor
 	_, err = arr1.BatchLookup(&cursor, tmp, tmp, nil)
 	testutils.SkipIfNotSupported(t, err)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	_, err = arr2.BatchLookup(&cursor, tmp, tmp, nil)
-	qt.Assert(t, err, qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(err))
 }
 
 func TestMapLookupKeyTooSmall(t *testing.T) {
@@ -222,8 +222,8 @@ func TestMapLookupKeyTooSmall(t *testing.T) {
 	defer m.Close()
 
 	var small uint16
-	qt.Assert(t, m.Put(uint32(0), uint32(1234)), qt.IsNil)
-	qt.Assert(t, m.Lookup(uint32(0), &small), qt.IsNotNil)
+	qt.Assert(t, qt.IsNil(m.Put(uint32(0), uint32(1234))))
+	qt.Assert(t, qt.IsNotNil(m.Lookup(uint32(0), &small)))
 }
 
 func TestBatchAPIMapDelete(t *testing.T) {
@@ -428,7 +428,6 @@ func TestMapCloneNil(t *testing.T) {
 
 func TestMapPin(t *testing.T) {
 	m := createArray(t)
-	c := qt.New(t)
 
 	if err := m.Put(uint32(0), uint32(42)); err != nil {
 		t.Fatal("Can't put:", err)
@@ -443,7 +442,7 @@ func TestMapPin(t *testing.T) {
 	}
 
 	pinned := m.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	m.Close()
 
@@ -525,7 +524,6 @@ func TestMapPinMultiple(t *testing.T) {
 	testutils.SkipOnOldKernel(t, "4.9", "atomic re-pinning was introduced in 4.9 series")
 
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 
 	spec := spec1.Copy()
 
@@ -535,35 +533,33 @@ func TestMapPinMultiple(t *testing.T) {
 	}
 	defer m1.Close()
 	pinned := m1.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	newPath := filepath.Join(tmp, "bar")
 	err = m1.Pin(newPath)
 	testutils.SkipIfNotSupported(t, err)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	oldPath := filepath.Join(tmp, spec.Name)
 	if _, err := os.Stat(oldPath); err == nil {
 		t.Fatal("Previous pinned map path still exists:", err)
 	}
 	m2, err := LoadPinnedMap(newPath, nil)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	pinned = m2.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 	defer m2.Close()
 }
 
 func TestMapPinWithEmptyPath(t *testing.T) {
 	m := createArray(t)
-	c := qt.New(t)
 
 	err := m.Pin("")
 
-	c.Assert(err, qt.Not(qt.IsNil))
+	qt.Assert(t, qt.Not(qt.IsNil(err)))
 }
 
 func TestMapPinFailReplace(t *testing.T) {
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 	spec := spec1.Copy()
 	spec2 := spec1.Copy()
 	spec2.Name = spec1.Name + "bar"
@@ -578,16 +574,15 @@ func TestMapPinFailReplace(t *testing.T) {
 		t.Fatal("Failed to create map2:", err)
 	}
 	defer m2.Close()
-	c.Assert(m.IsPinned(), qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(m.IsPinned()))
 	newPath := filepath.Join(tmp, spec2.Name)
 
-	c.Assert(m.Pin(newPath), qt.Not(qt.IsNil), qt.Commentf("Pin didn't"+
+	qt.Assert(t, qt.Not(qt.IsNil(m.Pin(newPath))), qt.Commentf("Pin didn't"+
 		" fail new path from replacing an existing path"))
 }
 
 func TestMapUnpin(t *testing.T) {
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 	spec := spec1.Copy()
 
 	m, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
@@ -597,11 +592,11 @@ func TestMapUnpin(t *testing.T) {
 	defer m.Close()
 
 	pinned := m.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 	path := filepath.Join(tmp, spec.Name)
 	m2, err := LoadPinnedMap(path, nil)
 	testutils.SkipIfNotSupported(t, err)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m2.Close()
 
 	if err = m.Unpin(); err != nil {
@@ -614,23 +609,22 @@ func TestMapUnpin(t *testing.T) {
 
 func TestMapLoadPinned(t *testing.T) {
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 
 	spec := spec1.Copy()
 
 	m1, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m1.Close()
 	pinned := m1.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	path := filepath.Join(tmp, spec.Name)
 	m2, err := LoadPinnedMap(path, nil)
 	testutils.SkipIfNotSupported(t, err)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m2.Close()
 	pinned = m2.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 }
 
 func TestMapLoadReusePinned(t *testing.T) {
@@ -653,11 +647,11 @@ func TestMapLoadReusePinned(t *testing.T) {
 			}
 
 			m1, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 			defer m1.Close()
 
 			m2, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
-			qt.Assert(t, err, qt.IsNil)
+			qt.Assert(t, qt.IsNil(err))
 			defer m2.Close()
 		})
 	}
@@ -665,25 +659,24 @@ func TestMapLoadReusePinned(t *testing.T) {
 
 func TestMapLoadPinnedUnpin(t *testing.T) {
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 
 	spec := spec1.Copy()
 
 	m1, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m1.Close()
 	pinned := m1.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	path := filepath.Join(tmp, spec.Name)
 	m2, err := LoadPinnedMap(path, nil)
 	testutils.SkipIfNotSupported(t, err)
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m2.Close()
 	err = m1.Unpin()
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	err = m2.Unpin()
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 }
 
 func TestMapLoadPinnedWithOptions(t *testing.T) {
@@ -750,7 +743,7 @@ func TestMapPinFlags(t *testing.T) {
 	m, err := NewMapWithOptions(spec, MapOptions{
 		PinPath: tmp,
 	})
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	m.Close()
 
 	_, err = NewMapWithOptions(spec, MapOptions{
@@ -1101,7 +1094,7 @@ func TestMapIteratorAllocations(t *testing.T) {
 	var k, v uint32
 	iter := arr.Iterate()
 	// Allocate any necessary temporary buffers.
-	qt.Assert(t, iter.Next(&k, &v), qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(iter.Next(&k, &v)))
 
 	allocs := testing.AllocsPerRun(1, func() {
 		if !iter.Next(&k, &v) {
@@ -1109,7 +1102,7 @@ func TestMapIteratorAllocations(t *testing.T) {
 		}
 	})
 
-	qt.Assert(t, allocs, qt.Equals, float64(0))
+	qt.Assert(t, qt.Equals(allocs, float64(0)))
 }
 
 func TestMapIterateHashKeyOneByteFull(t *testing.T) {
@@ -1695,7 +1688,6 @@ func TestNewMapFromID(t *testing.T) {
 
 func TestMapPinning(t *testing.T) {
 	tmp := testutils.TempBPFFS(t)
-	c := qt.New(t)
 
 	spec := &MapSpec{
 		Name:       "test",
@@ -1712,10 +1704,10 @@ func TestMapPinning(t *testing.T) {
 	}
 	defer m1.Close()
 	pinned := m1.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	m1Info, err := m1.Info()
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	if err := m1.Put(uint32(0), uint32(42)); err != nil {
 		t.Fatal("Can't write value:", err)
@@ -1729,11 +1721,11 @@ func TestMapPinning(t *testing.T) {
 	defer m2.Close()
 
 	m2Info, err := m2.Info()
-	c.Assert(err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	if m1ID, ok := m1Info.ID(); ok {
 		m2ID, _ := m2Info.ID()
-		c.Assert(m2ID, qt.Equals, m1ID)
+		qt.Assert(t, qt.Equals(m2ID, m1ID))
 	}
 
 	var value uint32
@@ -1757,8 +1749,8 @@ func TestMapPinning(t *testing.T) {
 	}
 
 	// Check if error string mentions both KeySize and ValueSize.
-	c.Assert(err.Error(), qt.Contains, "KeySize")
-	c.Assert(err.Error(), qt.Contains, "ValueSize")
+	qt.Assert(t, qt.StringContains(err.Error(), "KeySize"))
+	qt.Assert(t, qt.StringContains(err.Error(), "ValueSize"))
 }
 
 func TestPerfEventArrayCompatible(t *testing.T) {
@@ -1767,13 +1759,13 @@ func TestPerfEventArrayCompatible(t *testing.T) {
 	}
 
 	m, err := NewMap(ms)
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 	defer m.Close()
 
-	qt.Assert(t, ms.Compatible(m), qt.IsNil)
+	qt.Assert(t, qt.IsNil(ms.Compatible(m)))
 
 	ms.MaxEntries = m.MaxEntries() - 1
-	qt.Assert(t, ms.Compatible(m), qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(ms.Compatible(m)))
 }
 
 type benchValue struct {
@@ -2042,7 +2034,7 @@ func BenchmarkIterate(b *testing.B) {
 
 	_, err = m.BatchUpdate(keys, values, nil)
 	testutils.SkipIfNotSupported(b, err)
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	b.Run("MapIterator", func(b *testing.B) {
 		var k, v uint64
diff --git a/marshalers_test.go b/marshalers_test.go
index 6695791..b91d9e8 100644
--- a/marshalers_test.go
+++ b/marshalers_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/cilium/ebpf/internal"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestUnmarshalPerCPUValue(t *testing.T) {
@@ -27,11 +27,11 @@ func TestUnmarshalPerCPUValue(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	qt.Assert(t, slice, qt.DeepEquals, expected)
+	qt.Assert(t, qt.DeepEquals(slice, expected))
 
 	smallSlice := make([]uint32, possibleCPUs-1)
-	qt.Assert(t, unmarshalPerCPUValue(smallSlice, elemLength, buf), qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(unmarshalPerCPUValue(smallSlice, elemLength, buf)))
 
 	nilElemSlice := make([]*uint32, possibleCPUs)
-	qt.Assert(t, unmarshalPerCPUValue(nilElemSlice, elemLength, buf), qt.IsNotNil)
+	qt.Assert(t, qt.IsNotNil(unmarshalPerCPUValue(nilElemSlice, elemLength, buf)))
 }
diff --git a/perf/reader_test.go b/perf/reader_test.go
index d693c49..27316ad 100644
--- a/perf/reader_test.go
+++ b/perf/reader_test.go
@@ -18,7 +18,7 @@ import (
 	"github.com/cilium/ebpf/internal/testutils/fdtrace"
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 var (
@@ -38,19 +38,19 @@ func TestPerfReader(t *testing.T) {
 	}
 	defer rd.Close()
 
-	qt.Assert(t, rd.BufferSize(), qt.Equals, 4096)
+	qt.Assert(t, qt.Equals(rd.BufferSize(), 4096))
 
 	outputSamples(t, events, 5, 5)
 
 	_, rem := checkRecord(t, rd)
-	qt.Assert(t, rem >= 5, qt.IsTrue, qt.Commentf("expected at least 5 Remaining"))
+	qt.Assert(t, qt.IsTrue(rem >= 5), qt.Commentf("expected at least 5 Remaining"))
 
 	_, rem = checkRecord(t, rd)
-	qt.Assert(t, rem, qt.Equals, 0, qt.Commentf("expected zero Remaining"))
+	qt.Assert(t, qt.Equals(rem, 0), qt.Commentf("expected zero Remaining"))
 
 	rd.SetDeadline(time.Now().Add(4 * time.Millisecond))
 	_, err = rd.Read()
-	qt.Assert(t, errors.Is(err, os.ErrDeadlineExceeded), qt.IsTrue, qt.Commentf("expected os.ErrDeadlineExceeded"))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrDeadlineExceeded), qt.Commentf("expected os.ErrDeadlineExceeded"))
 }
 
 func TestReaderSetDeadline(t *testing.T) {
@@ -165,15 +165,15 @@ func checkRecord(tb testing.TB, rd *Reader) (id int, remaining int) {
 	tb.Helper()
 
 	rec, err := rd.Read()
-	qt.Assert(tb, err, qt.IsNil)
+	qt.Assert(tb, qt.IsNil(err))
 
-	qt.Assert(tb, rec.CPU >= 0, qt.IsTrue, qt.Commentf("Record has invalid CPU number"))
+	qt.Assert(tb, qt.IsTrue(rec.CPU >= 0), qt.Commentf("Record has invalid CPU number"))
 
 	size := int(rec.RawSample[0])
-	qt.Assert(tb, len(rec.RawSample) >= size, qt.IsTrue, qt.Commentf("RawSample is at least size bytes"))
+	qt.Assert(tb, qt.IsTrue(len(rec.RawSample) >= size), qt.Commentf("RawSample is at least size bytes"))
 
 	for i, v := range rec.RawSample[2:size] {
-		qt.Assert(tb, v, qt.Equals, byte(0xff), qt.Commentf("filler at position %d should match", i+2))
+		qt.Assert(tb, qt.Equals(v, 0xff), qt.Commentf("filler at position %d should match", i+2))
 	}
 
 	// padding is ignored since it's value is undefined.
@@ -302,18 +302,18 @@ func TestPerfReaderOverwritable(t *testing.T) {
 	defer rd.Close()
 
 	_, err = rd.Read()
-	qt.Assert(t, err, qt.ErrorIs, errMustBePaused)
+	qt.Assert(t, qt.ErrorIs(err, errMustBePaused))
 
 	outputSamples(t, events, sampleSizes...)
 
-	qt.Assert(t, rd.Pause(), qt.IsNil)
+	qt.Assert(t, qt.IsNil(rd.Pause()))
 	rd.SetDeadline(time.Now())
 
 	nextID := maxEvents
 	for i := 0; i < maxEvents; i++ {
 		id, rem := checkRecord(t, rd)
-		qt.Assert(t, id, qt.Equals, nextID)
-		qt.Assert(t, rem, qt.Equals, -1)
+		qt.Assert(t, qt.Equals(id, nextID))
+		qt.Assert(t, qt.Equals(rem, -1))
 		nextID--
 	}
 }
@@ -333,7 +333,7 @@ func TestPerfReaderOverwritableEmpty(t *testing.T) {
 
 	rd.SetDeadline(time.Now().Add(4 * time.Millisecond))
 	_, err = rd.Read()
-	qt.Assert(t, errors.Is(err, os.ErrDeadlineExceeded), qt.IsTrue, qt.Commentf("expected os.ErrDeadlineExceeded"))
+	qt.Assert(t, qt.ErrorIs(err, os.ErrDeadlineExceeded), qt.Commentf("expected os.ErrDeadlineExceeded"))
 
 	err = rd.Resume()
 	if err != nil {
@@ -481,12 +481,12 @@ func TestPause(t *testing.T) {
 
 	// Pause/Resume after close should be no-op.
 	err = rd.Pause()
-	qt.Assert(t, err, qt.Not(qt.Equals), ErrClosed, qt.Commentf("returns unwrapped ErrClosed"))
-	qt.Assert(t, errors.Is(err, ErrClosed), qt.IsTrue, qt.Commentf("doesn't wrap ErrClosed"))
+	qt.Assert(t, qt.Not(qt.Equals(err, ErrClosed)), qt.Commentf("returns unwrapped ErrClosed"))
+	qt.Assert(t, qt.ErrorIs(err, ErrClosed), qt.Commentf("doesn't wrap ErrClosed"))
 
 	err = rd.Resume()
-	qt.Assert(t, err, qt.Not(qt.Equals), ErrClosed, qt.Commentf("returns unwrapped ErrClosed"))
-	qt.Assert(t, errors.Is(err, ErrClosed), qt.IsTrue, qt.Commentf("doesn't wrap ErrClosed"))
+	qt.Assert(t, qt.Not(qt.Equals(err, ErrClosed)), qt.Commentf("returns unwrapped ErrClosed"))
+	qt.Assert(t, qt.ErrorIs(err, ErrClosed), qt.Commentf("doesn't wrap ErrClosed"))
 }
 
 func BenchmarkReader(b *testing.B) {
diff --git a/perf/ring_test.go b/perf/ring_test.go
index b8cff90..f394dc0 100644
--- a/perf/ring_test.go
+++ b/perf/ring_test.go
@@ -5,8 +5,9 @@ import (
 	"os"
 	"testing"
 
+	"github.com/go-quicktest/qt"
+
 	"github.com/cilium/ebpf/internal/unix"
-	qt "github.com/frankban/quicktest"
 )
 
 func TestRingBufferReader(t *testing.T) {
@@ -88,8 +89,8 @@ func checkReadBuffer(t *testing.T, r io.Reader, want []byte, wantErr error, buf
 
 	n, err := r.Read(buf)
 	buf = buf[:n]
-	qt.Assert(t, err, qt.Equals, wantErr)
-	qt.Assert(t, buf, qt.DeepEquals, want)
+	qt.Assert(t, qt.Equals(err, wantErr))
+	qt.Assert(t, qt.DeepEquals(buf, want))
 }
 
 func makeBuffer(size int) []byte {
diff --git a/prog_test.go b/prog_test.go
index dbf2e04..42831bb 100644
--- a/prog_test.go
+++ b/prog_test.go
@@ -14,7 +14,7 @@ import (
 	"testing"
 	"time"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
@@ -273,7 +273,6 @@ func TestProgramClose(t *testing.T) {
 
 func TestProgramPin(t *testing.T) {
 	prog := mustSocketFilter(t)
-	c := qt.New(t)
 
 	tmp := testutils.TempBPFFS(t)
 
@@ -283,7 +282,7 @@ func TestProgramPin(t *testing.T) {
 	}
 
 	pinned := prog.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	prog.Close()
 
@@ -315,7 +314,6 @@ func TestProgramPin(t *testing.T) {
 
 func TestProgramUnpin(t *testing.T) {
 	prog := mustSocketFilter(t)
-	c := qt.New(t)
 
 	tmp := testutils.TempBPFFS(t)
 
@@ -325,7 +323,7 @@ func TestProgramUnpin(t *testing.T) {
 	}
 
 	pinned := prog.IsPinned()
-	c.Assert(pinned, qt.IsTrue)
+	qt.Assert(t, qt.IsTrue(pinned))
 
 	if err := prog.Unpin(); err != nil {
 		t.Fatal("Failed to unpin program:", err)
@@ -931,7 +929,7 @@ func TestProgramInstructions(t *testing.T) {
 func BenchmarkNewProgram(b *testing.B) {
 	testutils.SkipOnOldKernel(b, "5.18", "kfunc support")
 	spec, err := LoadCollectionSpec(fmt.Sprintf("testdata/kfunc-%s.elf", internal.ClangEndian))
-	qt.Assert(b, err, qt.IsNil)
+	qt.Assert(b, qt.IsNil(err))
 
 	b.ReportAllocs()
 	b.ResetTimer()
diff --git a/rlimit/rlimit_test.go b/rlimit/rlimit_test.go
index 29312be..9b2cd94 100644
--- a/rlimit/rlimit_test.go
+++ b/rlimit/rlimit_test.go
@@ -6,28 +6,28 @@ import (
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/unix"
 
-	qt "github.com/frankban/quicktest"
+	"github.com/go-quicktest/qt"
 )
 
 func TestRemoveMemlock(t *testing.T) {
 	var before unix.Rlimit
-	qt.Assert(t, unix.Prlimit(0, unix.RLIMIT_MEMLOCK, nil, &before), qt.IsNil)
+	qt.Assert(t, qt.IsNil(unix.Prlimit(0, unix.RLIMIT_MEMLOCK, nil, &before)))
 
 	err := RemoveMemlock()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	var after unix.Rlimit
-	qt.Assert(t, unix.Prlimit(0, unix.RLIMIT_MEMLOCK, nil, &after), qt.IsNil)
+	qt.Assert(t, qt.IsNil(unix.Prlimit(0, unix.RLIMIT_MEMLOCK, nil, &after)))
 
 	// We can't use testutils here due to an import cycle.
 	version, err := internal.KernelVersion()
-	qt.Assert(t, err, qt.IsNil)
+	qt.Assert(t, qt.IsNil(err))
 
 	if version.Less(unsupportedMemcgAccounting.MinimumVersion) {
-		qt.Assert(t, after.Cur, qt.Equals, uint64(unix.RLIM_INFINITY), qt.Commentf("cur should be INFINITY"))
-		qt.Assert(t, after.Max, qt.Equals, uint64(unix.RLIM_INFINITY), qt.Commentf("max should be INFINITY"))
+		qt.Assert(t, qt.Equals(after.Cur, unix.RLIM_INFINITY), qt.Commentf("cur should be INFINITY"))
+		qt.Assert(t, qt.Equals(after.Max, unix.RLIM_INFINITY), qt.Commentf("max should be INFINITY"))
 	} else {
-		qt.Assert(t, after.Cur, qt.Equals, before.Cur, qt.Commentf("cur should be unchanged"))
-		qt.Assert(t, after.Max, qt.Equals, before.Max, qt.Commentf("max should be unchanged"))
+		qt.Assert(t, qt.Equals(after.Cur, before.Cur), qt.Commentf("cur should be unchanged"))
+		qt.Assert(t, qt.Equals(after.Max, before.Max), qt.Commentf("max should be unchanged"))
 	}
 }