chore(test): enhance tests using t.Parallel()

Utilize t.Parallel() in unit tests to enable concurrent execution. This
takes advantage of multiple CPU cores, reducing the overall test suite
runtime.

Critically, this practice elevates the detection of insidious race
conditions and state leakages—issues that often remain concealed during
serial test execution.

cmd/tracee-bench/main_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestParseQueryResString(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		resultString   string
 		expectedResult float64

cmd/tracee-rules/main_test.go

@@ -12,6 +12,8 @@ import (
 )
 
 func Test_listSigs(t *testing.T) {
+	t.Parallel()
+
 	fakeSigs := []*signature.FakeSignature{
 		{
 			FakeGetMetadata: func() (detect.SignatureMetadata, error) {
@@ -54,6 +56,8 @@ BAR-1      bar signature                       4.5.6   bar signature helps with
 }
 
 func Test_listEvents(t *testing.T) {
+	t.Parallel()
+
 	fakeSigs := []*signature.FakeSignature{
 		{
 			FakeGetSelectedEvents: func() ([]detect.SignatureEventSelector, error) {

cmd/tracee-rules/output_test.go

@@ -21,6 +21,8 @@ import (
 )
 
 func Test_setupOutput(t *testing.T) {
+	t.Parallel()
+
 	var testCases = []struct {
 		name           string
 		inputEvent     protocol.Event
@@ -125,6 +127,8 @@ func checkOutput(t *testing.T, testName string, actualOutput *SyncBuffer, expect
 }
 
 func Test_sendToWebhook(t *testing.T) {
+	t.Parallel()
+
 	var testCases = []struct {
 		name               string
 		inputTemplateFile  string
@@ -170,7 +174,11 @@ func Test_sendToWebhook(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
+		tc := tc
+
 		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
 			ts := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
 				got, err := io.ReadAll(request.Body)
 				require.NoError(t, err)
@@ -209,6 +217,8 @@ func Test_sendToWebhook(t *testing.T) {
 }
 
 func TestOutputTemplates(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		testName     string
 		finding      detect.Finding
@@ -272,7 +282,11 @@ func TestOutputTemplates(t *testing.T) {
 	require.NoError(t, err)
 
 	for _, tc := range testCases {
+		tc := tc
+
 		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+
 			var buf bytes.Buffer
 			err := jsonTemplate.Execute(&buf, tc.finding)
 			require.NoError(t, err)

pkg/bucketscache/bucketscache_test.go

@@ -10,6 +10,8 @@ import (
 )
 
 func TestBucketsCache(t *testing.T) {
+	t.Parallel()
+
 	var cache bucketscache.BucketsCache
 	cache.Init(5)
 	cache.AddBucketItem(1, 32)

pkg/bufferdecoder/decoder_test.go

@@ -11,6 +11,8 @@ import (
 )
 
 func TestDecodeContext(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	ctxExpected := Context{
 		Ts:          11,
@@ -49,6 +51,8 @@ func TestDecodeContext(t *testing.T) {
 }
 
 func TestDecodeUint8(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint8 = 42
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -69,6 +73,8 @@ func TestDecodeUint8(t *testing.T) {
 }
 
 func TestDecodeInt8(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected int8 = -42
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -89,6 +95,8 @@ func TestDecodeInt8(t *testing.T) {
 }
 
 func TestDecodeUint16(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint16 = 5555
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -109,6 +117,8 @@ func TestDecodeUint16(t *testing.T) {
 }
 
 func TestDecodeUint16BigEndian(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint16 = 5555
 	err := binary.Write(buf, binary.BigEndian, expected)
@@ -128,6 +138,8 @@ func TestDecodeUint16BigEndian(t *testing.T) {
 	assert.Equal(t, 2, cursorAfter-cursorBefore) // cursor should move 2 byte
 }
 func TestDecodeInt16(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected int16 = -3456
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -148,6 +160,8 @@ func TestDecodeInt16(t *testing.T) {
 }
 
 func TestDecodeUint32(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint32 = 5555
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -168,6 +182,8 @@ func TestDecodeUint32(t *testing.T) {
 }
 
 func TestDecodeUint32BigEndian(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint32 = 5555
 	err := binary.Write(buf, binary.BigEndian, expected)
@@ -187,6 +203,8 @@ func TestDecodeUint32BigEndian(t *testing.T) {
 	assert.Equal(t, cursorAfter-cursorBefore, 4) // cursor should move 4 byte
 }
 func TestDecodeInt32(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected int32 = -3456
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -207,6 +225,8 @@ func TestDecodeInt32(t *testing.T) {
 }
 
 func TestDecodeUint64(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected uint64 = 5555
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -227,6 +247,8 @@ func TestDecodeUint64(t *testing.T) {
 }
 
 func TestDecodeInt64(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	var expected int64 = -3456
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -247,6 +269,8 @@ func TestDecodeInt64(t *testing.T) {
 }
 
 func TestDecodeBoolTrue(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := true
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -267,6 +291,8 @@ func TestDecodeBoolTrue(t *testing.T) {
 }
 
 func TestDecodeBoolFalse(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := false
 	err := binary.Write(buf, binary.LittleEndian, expected)
@@ -288,6 +314,8 @@ func TestDecodeBoolFalse(t *testing.T) {
 
 // TODO DecodeBytes and DecodeIntArray
 func TestDecodeBytes(t *testing.T) {
+	t.Parallel()
+
 	type JustAStruct struct {
 		A1 uint32
 		A2 uint64
@@ -313,6 +341,8 @@ func TestDecodeBytes(t *testing.T) {
 }
 
 func TestDecodeIntArray(t *testing.T) {
+	t.Parallel()
+
 	var raw []byte
 	raw = append(raw, 1, 2, 3, 4, 5, 6, 7, 8)
 	decoder := New(raw)
@@ -329,6 +359,8 @@ func TestDecodeIntArray(t *testing.T) {
 }
 
 func TestDecodeSlimCred(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := SlimCred{
 		Uid:            43,
@@ -358,6 +390,8 @@ func TestDecodeSlimCred(t *testing.T) {
 }
 
 func TestDecodeChunkMeta(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := ChunkMeta{
 		BinType:  54,
@@ -377,6 +411,8 @@ func TestDecodeChunkMeta(t *testing.T) {
 }
 
 func TestDecodeVfsWriteMeta(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := VfsFileMeta{
 		DevID: 54,
@@ -395,6 +431,8 @@ func TestDecodeVfsWriteMeta(t *testing.T) {
 }
 
 func TestDecodeKernelModuleMeta(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := KernelModuleMeta{
 		DevID: 7489,
@@ -413,6 +451,8 @@ func TestDecodeKernelModuleMeta(t *testing.T) {
 }
 
 func TestDecodeBpfObjectMeta(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := BpfObjectMeta{
 		Name: [16]byte{80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80},
@@ -431,6 +471,8 @@ func TestDecodeBpfObjectMeta(t *testing.T) {
 }
 
 func TestDecodeMprotectWriteMeta(t *testing.T) {
+	t.Parallel()
+
 	buf := new(bytes.Buffer)
 	expected := MprotectWriteMeta{
 		Pid: 12,

pkg/bufferdecoder/eventsreader_test.go

@@ -10,6 +10,8 @@ import (
 )
 
 func TestReadArgFromBuff(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name          string
 		input         []byte
@@ -165,22 +167,30 @@ func TestReadArgFromBuff(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		decoder := New(tc.input)
-		_, actual, err := readArgFromBuff(0, decoder, tc.params)
-
-		if tc.expectedError != nil {
-			assert.ErrorContains(t, err, tc.expectedError.Error())
-		}
-		assert.Equal(t, tc.expectedArg, actual.Value)
-
-		if tc.name == "unknown" {
-			continue
-		}
-		assert.Empty(t, decoder.BuffLen()-decoder.ReadAmountBytes(), tc.name) // passed in buffer should be emptied out
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			decoder := New(tc.input)
+			_, actual, err := readArgFromBuff(0, decoder, tc.params)
+
+			if tc.expectedError != nil {
+				assert.ErrorContains(t, err, tc.expectedError.Error())
+			}
+			assert.Equal(t, tc.expectedArg, actual.Value)
+
+			if tc.name == "unknown" {
+				return
+			}
+			assert.Empty(t, decoder.BuffLen()-decoder.ReadAmountBytes(), tc.name) // passed in buffer should be emptied out
+		})
 	}
 }
 
 func TestPrintUint32IP(t *testing.T) {
+	t.Parallel()
+
 	var input uint32 = 3232238339
 	ip := PrintUint32IP(input)
 
@@ -189,6 +199,8 @@ func TestPrintUint32IP(t *testing.T) {
 }
 
 func TestPrint16BytesSliceIP(t *testing.T) {
+	t.Parallel()
+
 	input := []byte{32, 1, 13, 184, 133, 163, 0, 0, 0, 0, 138, 46, 3, 112, 115, 52}
 	ip := Print16BytesSliceIP(input)
 

pkg/bufferdecoder/protocol_test.go

@@ -15,35 +15,47 @@ import (
 // If so, then this means you need to update the decoder functions and GetSizeBytes functions.
 
 func TestContextSize(t *testing.T) {
+	t.Parallel()
+
 	var v Context
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size, int(v.GetSizeBytes()))
 }
 func TestChunkMetaSize(t *testing.T) {
+	t.Parallel()
+
 	var v ChunkMeta
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size-7, int(v.GetSizeBytes()))
 }
 
 func TestVfsWriteMetaSize(t *testing.T) {
+	t.Parallel()
+
 	var v VfsFileMeta
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size-4, int(v.GetSizeBytes()))
 }
 
 func TestKernelModuleMetaSize(t *testing.T) {
+	t.Parallel()
+
 	var v KernelModuleMeta
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size-4, int(v.GetSizeBytes()))
 }
 
 func TestBpfObjectMetaSize(t *testing.T) {
+	t.Parallel()
+
 	var v BpfObjectMeta
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size, int(v.GetSizeBytes()))
 }
 
 func TestMprotectWriteMetaSize(t *testing.T) {
+	t.Parallel()
+
 	var v MprotectWriteMeta
 	size := int(unsafe.Sizeof(v))
 	assert.Equal(t, size-4, int(v.GetSizeBytes()))

pkg/changelog/changelog_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestChangelog(t *testing.T) {
+	t.Parallel()
+
 	cl := NewChangelog[int]()
 
 	// Test GetCurrent on an empty changelog