test: replace atomic operations with atomic types (#2048)

alexandear · web-flow · commit 51b494732003 · 2025-08-07T19:02:12.000-04:00
diff --git a/client_test.go b/client_test.go
@@ -252,10 +252,10 @@ func TestClientInvalidURI(t *testing.T) {
 	t.Parallel()
 
 	ln := fasthttputil.NewInmemoryListener()
-	requests := int64(0)
+	var requests atomic.Int64
 	s := &Server{
 		Handler: func(_ *RequestCtx) {
-			atomic.AddInt64(&requests, 1)
+			requests.Add(1)
 		},
 	}
 	go s.Serve(ln) //nolint:errcheck
@@ -275,7 +275,7 @@ func TestClientInvalidURI(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error (missing required Host header in request)")
 	}
-	if n := atomic.LoadInt64(&requests); n != 0 {
+	if n := requests.Load(); n != 0 {
 		t.Fatalf("0 requests expected, got %d", n)
 	}
 }
@@ -1470,12 +1470,12 @@ func TestHostClientMaxConnDuration(t *testing.T) {
 
 	ln := fasthttputil.NewInmemoryListener()
 
-	connectionCloseCount := uint32(0)
+	var connectionCloseCount atomic.Uint32
 	s := &Server{
 		Handler: func(ctx *RequestCtx) {
 			ctx.WriteString("abcd") //nolint:errcheck
 			if ctx.Request.ConnectionClose() {
-				atomic.AddUint32(&connectionCloseCount, 1)
+				connectionCloseCount.Add(1)
 			}
 		},
 	}
@@ -1518,7 +1518,7 @@ func TestHostClientMaxConnDuration(t *testing.T) {
 		t.Fatalf("timeout")
 	}
 
-	if connectionCloseCount == 0 {
+	if connectionCloseCount.Load() == 0 {
 		t.Fatalf("expecting at least one 'Connection: close' request header")
 	}
 }
@@ -2936,7 +2936,7 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {
 		MaxConnWaitTimeout: 10 * time.Millisecond,
 	}
 
-	var errNoFreeConnsCount uint32
+	var errNoFreeConnsCount atomic.Uint32
 	for i := 0; i < 5; i++ {
 		wg.Add(1)
 		go func() {
@@ -2952,7 +2952,7 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {
 				if err != ErrNoFreeConns {
 					t.Errorf("unexpected error: %v. Expecting %v", err, ErrNoFreeConns)
 				}
-				atomic.AddUint32(&errNoFreeConnsCount, 1)
+				errNoFreeConnsCount.Add(1)
 			} else {
 				if resp.StatusCode() != StatusOK {
 					t.Errorf("unexpected status code %d. Expecting %d", resp.StatusCode(), StatusOK)
@@ -2976,8 +2976,8 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {
 	if c.connsWait.len() > 0 {
 		t.Errorf("connsWait has %v items remaining", c.connsWait.len())
 	}
-	if errNoFreeConnsCount == 0 {
-		t.Errorf("unexpected errorCount: %d. Expecting > 0", errNoFreeConnsCount)
+	if count := errNoFreeConnsCount.Load(); count == 0 {
+		t.Errorf("unexpected errorCount: %d. Expecting > 0", count)
 	}
 	if err := ln.Close(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -3033,7 +3033,7 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {
 		MaxConnWaitTimeout: maxConnWaitTimeout,
 	}
 
-	var errTimeoutCount uint32
+	var errTimeoutCount atomic.Uint32
 	for i := 0; i < 5; i++ {
 		wg.Add(1)
 		go func() {
@@ -3049,7 +3049,7 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {
 				if err != ErrTimeout {
 					t.Errorf("unexpected error: %v. Expecting %v", err, ErrTimeout)
 				}
-				atomic.AddUint32(&errTimeoutCount, 1)
+				errTimeoutCount.Add(1)
 			} else {
 				if resp.StatusCode() != StatusOK {
 					t.Errorf("unexpected status code %d. Expecting %d", resp.StatusCode(), StatusOK)
@@ -3077,8 +3077,8 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {
 		w.mu.Unlock()
 	}
 	c.connsLock.Unlock()
-	if errTimeoutCount == 0 {
-		t.Errorf("unexpected errTimeoutCount: %d. Expecting > 0", errTimeoutCount)
+	if count := errTimeoutCount.Load(); count == 0 {
+		t.Errorf("unexpected errTimeoutCount: %d. Expecting > 0", count)
 	}
 	if err := ln.Close(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
diff --git a/client_timing_test.go b/client_timing_test.go
@@ -101,9 +101,9 @@ func BenchmarkClientGetTimeoutFastServer(b *testing.B) {
 		},
 	}
 
-	nn := uint32(0)
+	var nn atomic.Uint32
 	b.RunParallel(func(pb *testing.PB) {
-		url := fmt.Sprintf("http://foobar%d.com/aaa/bbb", atomic.AddUint32(&nn, 1))
+		url := fmt.Sprintf("http://foobar%d.com/aaa/bbb", nn.Add(1))
 		var statusCode int
 		var bodyBuf []byte
 		var err error
@@ -132,11 +132,11 @@ func BenchmarkClientDoFastServer(b *testing.B) {
 		MaxConnsPerHost: runtime.GOMAXPROCS(-1),
 	}
 
-	nn := uint32(0)
+	var nn atomic.Uint32
 	b.RunParallel(func(pb *testing.PB) {
 		var req Request
 		var resp Response
-		req.Header.SetRequestURI(fmt.Sprintf("http://foobar%d.com/aaa/bbb", atomic.AddUint32(&nn, 1)))
+		req.Header.SetRequestURI(fmt.Sprintf("http://foobar%d.com/aaa/bbb", nn.Add(1)))
 		for pb.Next() {
 			if err := c.Do(&req, &resp); err != nil {
 				b.Fatalf("unexpected error: %v", err)
@@ -163,9 +163,9 @@ func BenchmarkNetHTTPClientDoFastServer(b *testing.B) {
 		},
 	}
 
-	nn := uint32(0)
+	var nn atomic.Uint32
 	b.RunParallel(func(pb *testing.PB) {
-		req, err := http.NewRequest(MethodGet, fmt.Sprintf("http://foobar%d.com/aaa/bbb", atomic.AddUint32(&nn, 1)), http.NoBody)
+		req, err := http.NewRequest(MethodGet, fmt.Sprintf("http://foobar%d.com/aaa/bbb", nn.Add(1)), http.NoBody)
 		if err != nil {
 			b.Fatalf("unexpected error: %v", err)
 		}
diff --git a/coarsetime_test.go b/coarsetime_test.go
@@ -7,31 +7,31 @@ import (
 )
 
 func BenchmarkCoarseTimeNow(b *testing.B) {
-	var zeroTimeCount uint64
+	var zeroTimeCount atomic.Uint64
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			t := CoarseTimeNow()
 			if t.IsZero() {
-				atomic.AddUint64(&zeroTimeCount, 1)
+				zeroTimeCount.Add(1)
 			}
 		}
 	})
-	if zeroTimeCount > 0 {
+	if zeroTimeCount.Load() > 0 {
 		b.Fatalf("zeroTimeCount must be zero")
 	}
 }
 
 func BenchmarkTimeNow(b *testing.B) {
-	var zeroTimeCount uint64
+	var zeroTimeCount atomic.Uint64
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			t := time.Now()
 			if t.IsZero() {
-				atomic.AddUint64(&zeroTimeCount, 1)
+				zeroTimeCount.Add(1)
 			}
 		}
 	})
-	if zeroTimeCount > 0 {
+	if zeroTimeCount.Load() > 0 {
 		b.Fatalf("zeroTimeCount must be zero")
 	}
 }
diff --git a/server_timing_test.go b/server_timing_test.go
@@ -170,11 +170,11 @@ func BenchmarkServerTimeoutError(b *testing.B) {
 	clientsCount := 10
 	requestsPerConn := 1
 	ch := make(chan struct{}, b.N)
-	n := uint32(0)
+	var n atomic.Uint32
 	responseBody := []byte("123")
 	s := &Server{
 		Handler: func(ctx *RequestCtx) {
-			if atomic.AddUint32(&n, 1)&7 == 0 {
+			if n.Add(1)&7 == 0 {
 				ctx.TimeoutError("xxx")
 				go func() {
 					ctx.Success("foobar", responseBody)
@@ -196,7 +196,7 @@ type fakeServerConn struct {
 	ln            *fakeListener
 	requestsCount int
 	pos           int
-	closed        uint32
+	closed        atomic.Bool
 }
 
 func (c *fakeServerConn) Read(b []byte) (int, error) {
@@ -235,7 +235,7 @@ func (c *fakeServerConn) RemoteAddr() net.Addr {
 }
 
 func (c *fakeServerConn) Close() error {
-	if atomic.AddUint32(&c.closed, 1) == 1 {
+	if c.closed.CompareAndSwap(false, true) {
 		c.ln.ch <- c
 	}
 	return nil
@@ -283,7 +283,7 @@ func (ln *fakeListener) Accept() (net.Conn, error) {
 
 	c := <-ln.ch
 	c.requestsCount = requestsCount
-	c.closed = 0
+	c.closed.Store(false)
 	c.pos = 0
 
 	return c, nil
diff --git a/stackless/func_test.go b/stackless/func_test.go
@@ -10,9 +10,9 @@ import (
 func TestNewFuncSimple(t *testing.T) {
 	t.Parallel()
 
-	var n uint64
+	var n atomic.Uint64
 	f := NewFunc(func(ctx any) {
-		atomic.AddUint64(&n, uint64(ctx.(int)))
+		n.Add(uint64(ctx.(int)))
 	})
 
 	iterations := 4 * 1024
@@ -21,20 +21,20 @@ func TestNewFuncSimple(t *testing.T) {
 			t.Fatalf("f mustn't return false")
 		}
 	}
-	if n != uint64(2*iterations) {
-		t.Fatalf("Unexpected n: %d. Expecting %d", n, 2*iterations)
+	if got := n.Load(); got != uint64(2*iterations) {
+		t.Fatalf("Unexpected n: %d. Expecting %d", got, 2*iterations)
 	}
 }
 
 func TestNewFuncMulti(t *testing.T) {
 	t.Parallel()
 
-	var n1, n2 uint64
+	var n1, n2 atomic.Uint64
 	f1 := NewFunc(func(ctx any) {
-		atomic.AddUint64(&n1, uint64(ctx.(int)))
+		n1.Add(uint64(ctx.(int)))
 	})
 	f2 := NewFunc(func(ctx any) {
-		atomic.AddUint64(&n2, uint64(ctx.(int)))
+		n2.Add(uint64(ctx.(int)))
 	})
 
 	iterations := 4 * 1024
@@ -81,10 +81,10 @@ func TestNewFuncMulti(t *testing.T) {
 		t.Fatalf("timeout")
 	}
 
-	if n1 != uint64(3*iterations) {
-		t.Fatalf("unexpected n1: %d. Expecting %d", n1, 3*iterations)
+	if got1 := n1.Load(); got1 != uint64(3*iterations) {
+		t.Fatalf("unexpected n1: %d. Expecting %d", got1, 3*iterations)
 	}
-	if n2 != uint64(5*iterations) {
-		t.Fatalf("unexpected n2: %d. Expecting %d", n2, 5*iterations)
+	if got2 := n2.Load(); got2 != uint64(5*iterations) {
+		t.Fatalf("unexpected n2: %d. Expecting %d", got2, 5*iterations)
 	}
 }
diff --git a/stackless/func_timing_test.go b/stackless/func_timing_test.go
@@ -6,9 +6,9 @@ import (
 )
 
 func BenchmarkFuncOverhead(b *testing.B) {
-	var n uint64
+	var n atomic.Uint64
 	f := NewFunc(func(ctx any) {
-		atomic.AddUint64(&n, *(ctx.(*uint64)))
+		n.Add(*(ctx.(*uint64)))
 	})
 	b.RunParallel(func(pb *testing.PB) {
 		x := uint64(1)
@@ -18,23 +18,23 @@ func BenchmarkFuncOverhead(b *testing.B) {
 			}
 		}
 	})
-	if n != uint64(b.N) {
-		b.Fatalf("unexpected n: %d. Expecting %d", n, b.N)
+	if got := n.Load(); got != uint64(b.N) {
+		b.Fatalf("unexpected n: %d. Expecting %d", got, b.N)
 	}
 }
 
 func BenchmarkFuncPure(b *testing.B) {
-	var n uint64
+	var n atomic.Uint64
 	f := func(x *uint64) {
-		atomic.AddUint64(&n, *x)
+		n.Add(*x)
 	}
 	b.RunParallel(func(pb *testing.PB) {
 		x := uint64(1)
 		for pb.Next() {
 			f(&x)
 		}
 	})
-	if n != uint64(b.N) {
-		b.Fatalf("unexpected n: %d. Expecting %d", n, b.N)
+	if got := n.Load(); got != uint64(b.N) {
+		b.Fatalf("unexpected n: %d. Expecting %d", got, b.N)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -252,10 +252,10 @@ func TestClientInvalidURI(t *testing.T) {`
`252`	`252`	`t.Parallel()`
`253`	`253`
`254`	`254`	`ln := fasthttputil.NewInmemoryListener()`
`255`		`- requests := int64(0)`
	`255`	`+ var requests atomic.Int64`
`256`	`256`	`s := &Server{`
`257`	`257`	`Handler: func(_ *RequestCtx) {`
`258`		`- atomic.AddInt64(&requests, 1)`
	`258`	`+ requests.Add(1)`
`259`	`259`	`},`
`260`	`260`	`}`
`261`	`261`	`go s.Serve(ln) //nolint:errcheck`
`@@ -275,7 +275,7 @@ func TestClientInvalidURI(t *testing.T) {`
`275`	`275`	`if err == nil {`
`276`	`276`	`t.Fatal("expected error (missing required Host header in request)")`
`277`	`277`	`}`
`278`		`- if n := atomic.LoadInt64(&requests); n != 0 {`
	`278`	`+ if n := requests.Load(); n != 0 {`
`279`	`279`	`t.Fatalf("0 requests expected, got %d", n)`
`280`	`280`	`}`
`281`	`281`	`}`
`@@ -1470,12 +1470,12 @@ func TestHostClientMaxConnDuration(t *testing.T) {`
`1470`	`1470`
`1471`	`1471`	`ln := fasthttputil.NewInmemoryListener()`
`1472`	`1472`
`1473`		`- connectionCloseCount := uint32(0)`
	`1473`	`+ var connectionCloseCount atomic.Uint32`
`1474`	`1474`	`s := &Server{`
`1475`	`1475`	`Handler: func(ctx *RequestCtx) {`
`1476`	`1476`	`ctx.WriteString("abcd") //nolint:errcheck`
`1477`	`1477`	`if ctx.Request.ConnectionClose() {`
`1478`		`- atomic.AddUint32(&connectionCloseCount, 1)`
	`1478`	`+ connectionCloseCount.Add(1)`
`1479`	`1479`	`}`
`1480`	`1480`	`},`
`1481`	`1481`	`}`
`@@ -1518,7 +1518,7 @@ func TestHostClientMaxConnDuration(t *testing.T) {`
`1518`	`1518`	`t.Fatalf("timeout")`
`1519`	`1519`	`}`
`1520`	`1520`
`1521`		`- if connectionCloseCount == 0 {`
	`1521`	`+ if connectionCloseCount.Load() == 0 {`
`1522`	`1522`	`t.Fatalf("expecting at least one 'Connection: close' request header")`
`1523`	`1523`	`}`
`1524`	`1524`	`}`
`@@ -2936,7 +2936,7 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {`
`2936`	`2936`	`MaxConnWaitTimeout: 10 * time.Millisecond,`
`2937`	`2937`	`}`
`2938`	`2938`
`2939`		`- var errNoFreeConnsCount uint32`
	`2939`	`+ var errNoFreeConnsCount atomic.Uint32`
`2940`	`2940`	`for i := 0; i < 5; i++ {`
`2941`	`2941`	`wg.Add(1)`
`2942`	`2942`	`go func() {`
`@@ -2952,7 +2952,7 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {`
`2952`	`2952`	`if err != ErrNoFreeConns {`
`2953`	`2953`	`t.Errorf("unexpected error: %v. Expecting %v", err, ErrNoFreeConns)`
`2954`	`2954`	`}`
`2955`		`- atomic.AddUint32(&errNoFreeConnsCount, 1)`
	`2955`	`+ errNoFreeConnsCount.Add(1)`
`2956`	`2956`	`} else {`
`2957`	`2957`	`if resp.StatusCode() != StatusOK {`
`2958`	`2958`	`t.Errorf("unexpected status code %d. Expecting %d", resp.StatusCode(), StatusOK)`
`@@ -2976,8 +2976,8 @@ func TestHostClientMaxConnWaitTimeoutError(t *testing.T) {`
`2976`	`2976`	`if c.connsWait.len() > 0 {`
`2977`	`2977`	`t.Errorf("connsWait has %v items remaining", c.connsWait.len())`
`2978`	`2978`	`}`
`2979`		`- if errNoFreeConnsCount == 0 {`
`2980`		`- t.Errorf("unexpected errorCount: %d. Expecting > 0", errNoFreeConnsCount)`
	`2979`	`+ if count := errNoFreeConnsCount.Load(); count == 0 {`
	`2980`	`+ t.Errorf("unexpected errorCount: %d. Expecting > 0", count)`
`2981`	`2981`	`}`
`2982`	`2982`	`if err := ln.Close(); err != nil {`
`2983`	`2983`	`t.Fatalf("unexpected error: %v", err)`
`@@ -3033,7 +3033,7 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {`
`3033`	`3033`	`MaxConnWaitTimeout: maxConnWaitTimeout,`
`3034`	`3034`	`}`
`3035`	`3035`
`3036`		`- var errTimeoutCount uint32`
	`3036`	`+ var errTimeoutCount atomic.Uint32`
`3037`	`3037`	`for i := 0; i < 5; i++ {`
`3038`	`3038`	`wg.Add(1)`
`3039`	`3039`	`go func() {`
`@@ -3049,7 +3049,7 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {`
`3049`	`3049`	`if err != ErrTimeout {`
`3050`	`3050`	`t.Errorf("unexpected error: %v. Expecting %v", err, ErrTimeout)`
`3051`	`3051`	`}`
`3052`		`- atomic.AddUint32(&errTimeoutCount, 1)`
	`3052`	`+ errTimeoutCount.Add(1)`
`3053`	`3053`	`} else {`
`3054`	`3054`	`if resp.StatusCode() != StatusOK {`
`3055`	`3055`	`t.Errorf("unexpected status code %d. Expecting %d", resp.StatusCode(), StatusOK)`
`@@ -3077,8 +3077,8 @@ func TestHostClientMaxConnWaitTimeoutWithEarlierDeadline(t *testing.T) {`
`3077`	`3077`	`w.mu.Unlock()`
`3078`	`3078`	`}`
`3079`	`3079`	`c.connsLock.Unlock()`
`3080`		`- if errTimeoutCount == 0 {`
`3081`		`- t.Errorf("unexpected errTimeoutCount: %d. Expecting > 0", errTimeoutCount)`
	`3080`	`+ if count := errTimeoutCount.Load(); count == 0 {`
	`3081`	`+ t.Errorf("unexpected errTimeoutCount: %d. Expecting > 0", count)`
`3082`	`3082`	`}`
`3083`	`3083`	`if err := ln.Close(); err != nil {`
`3084`	`3084`	`t.Fatalf("unexpected error: %v", err)`
Original file line number	Diff line number	Diff line change
`@@ -7,31 +7,31 @@ import (`
`7`	`7`	`)`
`8`	`8`
`9`	`9`	`func BenchmarkCoarseTimeNow(b *testing.B) {`
`10`		`- var zeroTimeCount uint64`
	`10`	`+ var zeroTimeCount atomic.Uint64`
`11`	`11`	`b.RunParallel(func(pb *testing.PB) {`
`12`	`12`	`for pb.Next() {`
`13`	`13`	`t := CoarseTimeNow()`
`14`	`14`	`if t.IsZero() {`
`15`		`- atomic.AddUint64(&zeroTimeCount, 1)`
	`15`	`+ zeroTimeCount.Add(1)`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`	`})`
`19`		`- if zeroTimeCount > 0 {`
	`19`	`+ if zeroTimeCount.Load() > 0 {`
`20`	`20`	`b.Fatalf("zeroTimeCount must be zero")`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func BenchmarkTimeNow(b *testing.B) {`
`25`		`- var zeroTimeCount uint64`
	`25`	`+ var zeroTimeCount atomic.Uint64`
`26`	`26`	`b.RunParallel(func(pb *testing.PB) {`
`27`	`27`	`for pb.Next() {`
`28`	`28`	`t := time.Now()`
`29`	`29`	`if t.IsZero() {`
`30`		`- atomic.AddUint64(&zeroTimeCount, 1)`
	`30`	`+ zeroTimeCount.Add(1)`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`})`
`34`		`- if zeroTimeCount > 0 {`
	`34`	`+ if zeroTimeCount.Load() > 0 {`
`35`	`35`	`b.Fatalf("zeroTimeCount must be zero")`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,9 @@ import (`
`6`	`6`	`)`
`7`	`7`
`8`	`8`	`func BenchmarkFuncOverhead(b *testing.B) {`
`9`		`- var n uint64`
	`9`	`+ var n atomic.Uint64`
`10`	`10`	`f := NewFunc(func(ctx any) {`
`11`		`- atomic.AddUint64(&n, (ctx.(uint64)))`
	`11`	`+ n.Add((ctx.(uint64)))`
`12`	`12`	`})`
`13`	`13`	`b.RunParallel(func(pb *testing.PB) {`
`14`	`14`	`x := uint64(1)`
`@@ -18,23 +18,23 @@ func BenchmarkFuncOverhead(b *testing.B) {`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`	`})`
`21`		`- if n != uint64(b.N) {`
`22`		`- b.Fatalf("unexpected n: %d. Expecting %d", n, b.N)`
	`21`	`+ if got := n.Load(); got != uint64(b.N) {`
	`22`	`+ b.Fatalf("unexpected n: %d. Expecting %d", got, b.N)`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`func BenchmarkFuncPure(b *testing.B) {`
`27`		`- var n uint64`
	`27`	`+ var n atomic.Uint64`
`28`	`28`	`f := func(x *uint64) {`
`29`		`- atomic.AddUint64(&n, *x)`
	`29`	`+ n.Add(*x)`
`30`	`30`	`}`
`31`	`31`	`b.RunParallel(func(pb *testing.PB) {`
`32`	`32`	`x := uint64(1)`
`33`	`33`	`for pb.Next() {`
`34`	`34`	`f(&x)`
`35`	`35`	`}`
`36`	`36`	`})`
`37`		`- if n != uint64(b.N) {`
`38`		`- b.Fatalf("unexpected n: %d. Expecting %d", n, b.N)`
	`37`	`+ if got := n.Load(); got != uint64(b.N) {`
	`38`	`+ b.Fatalf("unexpected n: %d. Expecting %d", got, b.N)`
`39`	`39`	`}`
`40`	`40`	`}`