fix: testing error

Author: fupeng1

promise.go

@@ -272,6 +272,19 @@ func (p *Promise[T]) Finally(onFinally func()) *Promise[T] {
 }
 
 func (p *Promise[T]) Await() (T, error) {
+	// Check if already completed without locking
+	state := p.getState()
+	if state == Fulfilled {
+		value, _ := p.getValue()
+		return value, nil
+	}
+	if state == Rejected {
+		var zero T
+		err, _ := p.getError()
+		return zero, err
+	}
+
+	// Still pending, wait for completion
 	p.mu.Lock()
 	if p.done == nil {
 		p.done = make(chan struct{})
@@ -281,6 +294,7 @@ func (p *Promise[T]) Await() (T, error) {
 
 	<-done
 
+	// Check final state
 	if p.getState() == Fulfilled {
 		value, _ := p.getValue()
 		return value, nil
@@ -292,6 +306,19 @@ func (p *Promise[T]) Await() (T, error) {
 
 // AwaitWithContext waits for Promise completion with context
 func (p *Promise[T]) AwaitWithContext(ctx context.Context) (T, error) {
+	// Check if already completed without locking
+	state := p.getState()
+	if state == Fulfilled {
+		value, _ := p.getValue()
+		return value, nil
+	}
+	if state == Rejected {
+		var zero T
+		err, _ := p.getError()
+		return zero, err
+	}
+
+	// Still pending, wait for completion or context cancellation
 	p.mu.Lock()
 	if p.done == nil {
 		p.done = make(chan struct{})
@@ -306,6 +333,7 @@ func (p *Promise[T]) AwaitWithContext(ctx context.Context) (T, error) {
 	case <-done:
 	}
 
+	// Check final state
 	if p.getState() == Fulfilled {
 		value, _ := p.getValue()
 		return value, nil

promise_test.go

@@ -12,12 +12,13 @@ import (
 
 // TestMain provides setup and teardown for the entire test suite
 func TestMain(m *testing.M) {
-	mgr := GetDefaultMgr()
-
 	// Run tests
 	code := m.Run()
 
-	mgr.Close()
+	// Cleanup: close the current default manager and wait for shutdown
+	currentMgr := GetDefaultMgr()
+	currentMgr.Close()
+	currentMgr.WaitForShutdown()
 
 	if code != 0 {
 		panic(fmt.Sprintf("Tests failed with code %d", code))
@@ -1086,14 +1087,17 @@ func TestWithResolvers(t *testing.T) {
 	t.Run("Multiple resolves should only take first", func(t *testing.T) {
 		promise, resolve, _ := WithResolvers[string]()
 
+		// Use a channel to ensure the first resolve happens before the second
+		firstDone := make(chan struct{})
+
 		// Multiple resolves
 		go func() {
-			time.Sleep(5 * time.Millisecond)
 			resolve("first")
+			close(firstDone)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
-			resolve("second")
+			<-firstDone       // Wait for first resolve to complete
+			resolve("second") // This should be ignored
 		}()
 
 		result, err := promise.Await()
@@ -1108,14 +1112,17 @@ func TestWithResolvers(t *testing.T) {
 	t.Run("Multiple rejects should only take first", func(t *testing.T) {
 		promise, _, reject := WithResolvers[string]()
 
+		// Use a channel to ensure the first reject happens before the second
+		firstDone := make(chan struct{})
+
 		// Multiple rejects
 		go func() {
-			time.Sleep(5 * time.Millisecond)
 			reject(errors.New("first reject"))
+			close(firstDone)
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
-			reject(errors.New("second reject"))
+			<-firstDone                         // Wait for first reject to complete
+			reject(errors.New("second reject")) // This should be ignored
 		}()
 
 		_, err := promise.Await()

types.go

@@ -118,13 +118,7 @@ func (p *Promise[T]) setState(state State) bool {
 	}
 
 	// Now try to transition from Pending to target state
-	if p.state.CompareAndSwap(Pending, state) {
-		return true
-	}
-
-	// If transition failed, check current state
-	currentState := p.state.Load().(State)
-	return currentState == state // Return true if already in target state
+	return p.state.CompareAndSwap(Pending, state)
 }
 
 // Helper function: safely get value