fix: make assert.CollectT concurrency safe

assert/assertions.go

@@ -13,6 +13,7 @@ import (
 	"runtime"
 	"runtime/debug"
 	"strings"
+	"sync"
 	"time"
 	"unicode"
 	"unicode/utf8"
@@ -1862,10 +1863,13 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t
 // CollectT implements the TestingT interface and collects all errors.
 type CollectT struct {
 	errors []error
+	mu     sync.RWMutex
 }
 
 // Errorf collects the error.
 func (c *CollectT) Errorf(format string, args ...interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.errors = append(c.errors, fmt.Errorf(format, args...))
 }
 
@@ -1876,6 +1880,8 @@ func (c *CollectT) FailNow() {
 
 // Reset clears the collected errors.
 func (c *CollectT) Reset() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.errors = nil
 }
 
@@ -1884,11 +1890,20 @@ func (c *CollectT) Copy(t TestingT) {
 	if tt, ok := t.(tHelper); ok {
 		tt.Helper()
 	}
+	c.mu.RLock()
+	defer c.mu.RUnlock()
 	for _, err := range c.errors {
 		t.Errorf("%v", err)
 	}
 }
 
+// HasErrors returns true if any errors were collected.
+func (c *CollectT) HasErrors() bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.errors) > 0
+}
+
 // EventuallyWithT asserts that given condition will be met in waitFor time,
 // periodically checking target function each tick. In contrast to Eventually,
 // it supplies a CollectT to the condition function, so that the condition
@@ -1931,10 +1946,10 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time
 			collect.Reset()
 			go func() {
 				condition(collect)
-				ch <- len(collect.errors) == 0
+				ch <- collect.HasErrors()
 			}()
-		case v := <-ch:
-			if v {
+		case hasErrors := <-ch:
+			if !hasErrors {
 				return true
 			}
 			tick = ticker.C

assert/assertions_test.go

@@ -2786,6 +2786,13 @@ func TestEventuallyWithTTrue(t *testing.T) {
 	Len(t, mockT.errors, 0)
 }
 
+func TestEventuallyWithT_ConcurrencySafe(t *testing.T) {
+	mockT := new(CollectT)
+	EventuallyWithT(mockT, func(c *CollectT) {
+		NoError(c, AnError)
+	}, time.Millisecond, time.Nanosecond)
+}
+
 func TestNeverFalse(t *testing.T) {
 	condition := func() bool {
 		return false