refactor: use atomic.Int32 type (#22)

Author: reugn

once_test.go

@@ -23,22 +23,22 @@ func TestOnce(t *testing.T) {
 
 func TestOnceConcurrent(t *testing.T) {
 var once Once[int32]
-var count int32
+var count atomic.Int32
 var wg sync.WaitGroup
 
 for i := 0; i < 10; i++ {
 wg.Add(1)
 go func() {
 defer wg.Done()
 result, _ := once.Do(func() (int32, error) {
-newCount := atomic.AddInt32(&count, 1)
+newCount := count.Add(1)
 return newCount, nil
 })
-atomic.StoreInt32(&count, result)
+count.Store(result)
 }()
 }
 wg.Wait()
-assert.Equal(t, count, 1)
+assert.Equal(t, int(count.Load()), 1)
 }
 
 func TestOncePanic(t *testing.T) {

wait_group_context.go

@@ -13,8 +13,8 @@ import (
 type WaitGroupContext struct {
 ctx context.Context
 done chan struct{}
-counter int32
-state int32
+counter atomic.Int32
+state atomic.Int32
 }
 
 // NewWaitGroupContext returns a new WaitGroupContext with Context ctx.
@@ -29,10 +29,10 @@ func NewWaitGroupContext(ctx context.Context) *WaitGroupContext {
 // If the counter becomes zero, all goroutines blocked on Wait are released.
 // If the counter goes negative, Add panics.
 func (wgc *WaitGroupContext) Add(delta int) {
-counter := atomic.AddInt32(&wgc.counter, int32(delta))
-if counter == 0 && atomic.CompareAndSwapInt32(&wgc.state, 0, 1) {
+counter := wgc.counter.Add(int32(delta))
+if counter == 0 && wgc.state.CompareAndSwap(0, 1) {
 wgc.release()
-} else if counter < 0 && atomic.LoadInt32(&wgc.state) == 0 {
+} else if counter < 0 && wgc.state.Load() == 0 {
 panic("async: negative WaitGroupContext counter")
 }
 }

wait_group_context_test.go

@@ -2,44 +2,45 @@ package async
 
 import (
 "context"
+"sync/atomic"
 "testing"
 "time"
 
 "github.com/reugn/async/internal/assert"
 )
 
 func TestWaitGroupContext(t *testing.T) {
-result := 0
+var result atomic.Int32
 wgc := NewWaitGroupContext(context.Background())
 wgc.Add(2)
 
 go func() {
 defer wgc.Done()
 time.Sleep(time.Millisecond * 10)
-result++
+result.Add(1)
 }()
 go func() {
 defer wgc.Done()
 time.Sleep(time.Millisecond * 20)
-result += 2
+result.Add(2)
 }()
 go func() {
 wgc.Wait()
-result += 3
+result.Add(3)
 }()
 
 wgc.Wait()
 time.Sleep(time.Millisecond * 10)
 
-assert.Equal(t, result, 6)
+assert.Equal(t, int(result.Load()), 6)
 }
 
 func TestWaitGroupContextCanceled(t *testing.T) {
-result := 0
+var result atomic.Int32
 ctx, cancelFunc := context.WithCancel(context.Background())
 go func() {
 time.Sleep(time.Millisecond * 100)
-result += 10
+result.Add(10)
 cancelFunc()
 }()
 wgc := NewWaitGroupContext(ctx)
@@ -48,22 +49,22 @@ func TestWaitGroupContextCanceled(t *testing.T) {
 go func() {
 defer wgc.Done()
 time.Sleep(time.Millisecond * 10)
-result++
+result.Add(1)
 }()
 go func() {
 defer wgc.Done()
 time.Sleep(time.Millisecond * 300)
-result += 2
+result.Add(2)
 }()
 go func() {
 wgc.Wait()
-result += 100
+result.Add(100)
 }()
 
 wgc.Wait()
 time.Sleep(time.Millisecond * 10)
 
-assert.Equal(t, result, 111)
+assert.Equal(t, int(result.Load()), 111)
 }
 
 func TestWaitGroupContextPanic(t *testing.T) {