From cddc1b5b6dbdff6777ea5a7659c410dc2c235a90 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 11:43:05 +0300
Subject: [PATCH 01/53] #9: Basic tests for Deadlock and Zombie coroutine
 cases.

---
 tests/edge_cases/001-deadlock-basic-test.phpt | 41 +++++++++++++
 tests/edge_cases/002-deadlock-with-catch.phpt | 53 +++++++++++++++++
 .../edge_cases/003-deadlock-with-zombie.phpt  | 59 +++++++++++++++++++
 3 files changed, 153 insertions(+)
 create mode 100644 tests/edge_cases/001-deadlock-basic-test.phpt
 create mode 100644 tests/edge_cases/002-deadlock-with-catch.phpt
 create mode 100644 tests/edge_cases/003-deadlock-with-zombie.phpt

diff --git a/tests/edge_cases/001-deadlock-basic-test.phpt b/tests/edge_cases/001-deadlock-basic-test.phpt
new file mode 100644
index 0000000..1a9b63f
--- /dev/null
+++ b/tests/edge_cases/001-deadlock-basic-test.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Deadlock basic test
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+$coroutine1 = null;
+$coroutine2 = null;
+
+$coroutine1 = spawn(function() use (&$coroutine2) {
+    echo "coroutine1 running\n";
+    suspend(); // Yield to allow the coroutine to start
+    await($coroutine2);
+    echo "coroutine1 finished\n";
+});
+
+$coroutine2 = spawn(function() use ($coroutine1) {
+    echo "coroutine2 running\n";
+    suspend(); // Yield to allow the coroutine to start
+    await($coroutine1);
+    echo "coroutine2 finished\n";
+});
+
+echo "end\n";
+?>
+--EXPECTF--
+start
+end
+coroutine1 running
+coroutine2 running
+
+Warning: no active coroutines, deadlock detected. Coroutines in waiting: %d in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
diff --git a/tests/edge_cases/002-deadlock-with-catch.phpt b/tests/edge_cases/002-deadlock-with-catch.phpt
new file mode 100644
index 0000000..8dbaf79
--- /dev/null
+++ b/tests/edge_cases/002-deadlock-with-catch.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Deadlock occurs when a coroutine continues execution after being cancelled.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+$coroutine1 = null;
+$coroutine2 = null;
+
+$coroutine1 = spawn(function() use (&$coroutine2) {
+    echo "coroutine1 running\n";
+    suspend(); // Yield to allow the coroutine to
+    try {
+        await($coroutine2);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+    echo "coroutine1 finished\n";
+});
+
+$coroutine2 = spawn(function() use ($coroutine1) {
+    echo "coroutine2 running\n";
+    suspend(); // Yield to allow the coroutine to start
+    try {
+        await($coroutine1);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+    echo "coroutine2 finished\n";
+});
+
+echo "end\n";
+?>
+--EXPECTF--
+start
+end
+coroutine1 running
+coroutine2 running
+
+Warning: no active coroutines, deadlock detected. Coroutines in waiting: %d in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
+Caught exception: Deadlock detected
+coroutine1 finished
+Caught exception: Deadlock detected
+coroutine2 finished
\ No newline at end of file
diff --git a/tests/edge_cases/003-deadlock-with-zombie.phpt b/tests/edge_cases/003-deadlock-with-zombie.phpt
new file mode 100644
index 0000000..0309800
--- /dev/null
+++ b/tests/edge_cases/003-deadlock-with-zombie.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Deadlock - The coroutine not only continues execution but also performs a suspend.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+$coroutine1 = null;
+$coroutine2 = null;
+
+$coroutine1 = spawn(function() use (&$coroutine2) {
+    echo "coroutine1 running\n";
+    suspend(); // Yield to allow the coroutine to
+    try {
+        await($coroutine2);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+
+    suspend();
+
+    echo "coroutine1 finished\n";
+});
+
+$coroutine2 = spawn(function() use ($coroutine1) {
+    echo "coroutine2 running\n";
+    suspend(); // Yield to allow the coroutine to start
+    try {
+        await($coroutine1);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+
+    suspend();
+
+    echo "coroutine2 finished\n";
+});
+
+echo "end\n";
+?>
+--EXPECTF--
+start
+end
+coroutine1 running
+coroutine2 running
+
+Warning: no active coroutines, deadlock detected. Coroutines in waiting: %d in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
+Caught exception: Deadlock detected
+Caught exception: Deadlock detected
+coroutine1 finished
+coroutine2 finished
\ No newline at end of file

From 68dd020364f14341edd502bda17c67bc732911f8 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 13:49:47 +0300
Subject: [PATCH 02/53] #9: + protect tests

---
 async.c                                       | 17 +++++--
 async.stub.php                                |  2 +-
 async_arginfo.h                               |  4 +-
 tests/protect/001-protect_basic.phpt          | 20 ++++++++
 tests/protect/002-protect_return_value.phpt   | 16 ++++++
 tests/protect/003-protect_nested.phpt         | 28 +++++++++++
 .../004-protect_cancellation_deferred.phpt    | 45 +++++++++++++++++
 .../005-protect_cancellation_immediate.phpt   | 37 ++++++++++++++
 .../006-protect_multiple_cancellation.phpt    | 43 ++++++++++++++++
 .../007-protect_exception_in_closure.phpt     | 27 ++++++++++
 .../protect/008-protect_bailout_handling.phpt | 34 +++++++++++++
 tests/protect/009-protect_with_spawn.phpt     | 40 +++++++++++++++
 tests/protect/010-protect_with_await.phpt     | 49 +++++++++++++++++++
 .../011-protect_invalid_parameter.phpt        | 39 +++++++++++++++
 .../protect/012-protect_closure_required.phpt | 31 ++++++++++++
 15 files changed, 425 insertions(+), 7 deletions(-)
 create mode 100644 tests/protect/001-protect_basic.phpt
 create mode 100644 tests/protect/002-protect_return_value.phpt
 create mode 100644 tests/protect/003-protect_nested.phpt
 create mode 100644 tests/protect/004-protect_cancellation_deferred.phpt
 create mode 100644 tests/protect/005-protect_cancellation_immediate.phpt
 create mode 100644 tests/protect/006-protect_multiple_cancellation.phpt
 create mode 100644 tests/protect/007-protect_exception_in_closure.phpt
 create mode 100644 tests/protect/008-protect_bailout_handling.phpt
 create mode 100644 tests/protect/009-protect_with_spawn.phpt
 create mode 100644 tests/protect/010-protect_with_await.phpt
 create mode 100644 tests/protect/011-protect_invalid_parameter.phpt
 create mode 100644 tests/protect/012-protect_closure_required.phpt

diff --git a/async.c b/async.c
index 4675613..b19a85f 100644
--- a/async.c
+++ b/async.c
@@ -157,16 +157,21 @@ PHP_FUNCTION(Async_protect)
 			ZEND_COROUTINE_SET_PROTECTED(coroutine);
 		}
 
-		zval result;
-		ZVAL_UNDEF(&result);
+		ZVAL_UNDEF(return_value);
 
 		zval closure_zval;
 		ZVAL_OBJ(&closure_zval, closure);
 
-		if (UNEXPECTED(call_user_function(NULL, NULL, &closure_zval, &result, 0, NULL) == FAILURE)) {
+		if (UNEXPECTED(call_user_function(NULL, NULL, &closure_zval, return_value, 0, NULL) == FAILURE)) {
 			zend_throw_error(NULL, "Failed to call finally handler in finished coroutine");
-			zval_ptr_dtor(&result);
+			zval_ptr_dtor(return_value);
 		}
+
+		if (Z_TYPE_P(return_value) == IS_UNDEF) {
+			// If the closure did not return a value, we return NULL.
+			ZVAL_NULL(return_value);
+		}
+
 	} zend_catch {
 		do_bailout = true;
 	} zend_end_try();
@@ -179,6 +184,10 @@ PHP_FUNCTION(Async_protect)
 		zend_bailout();
 	}
 
+	if (UNEXPECTED(coroutine == NULL)) {
+		return;
+	}
+
 	async_coroutine_t *async_coroutine = (async_coroutine_t *) coroutine;
 
 	if (async_coroutine->deferred_cancellation) {
diff --git a/async.stub.php b/async.stub.php
index 87e1094..46b70b4 100644
--- a/async.stub.php
+++ b/async.stub.php
@@ -33,7 +33,7 @@ function suspend(): void {}
 /**
  * Execute the provided closure in non-cancellable mode.
  */
-function protect(\Closure $closure): void {}
+function protect(\Closure $closure): mixed {}
 
 function await(Awaitable $awaitable, ?Awaitable $cancellation = null): mixed {}
 
diff --git a/async_arginfo.h b/async_arginfo.h
index 76853b1..3ad2941 100644
--- a/async_arginfo.h
+++ b/async_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: a36a9014653f09bffce4905a89824544b244b409 */
+ * Stub hash: b989a1b584dc4bcf2a4adab7210e04f1f157c75a */
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Async_spawn, 0, 1, Async\\Coroutine, 0)
 	ZEND_ARG_TYPE_INFO(0, task, IS_CALLABLE, 0)
@@ -15,7 +15,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_suspend, 0, 0, IS_VOID, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_protect, 0, 1, IS_VOID, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_protect, 0, 1, IS_MIXED, 0)
 	ZEND_ARG_OBJ_INFO(0, closure, Closure, 0)
 ZEND_END_ARG_INFO()
 
diff --git a/tests/protect/001-protect_basic.phpt b/tests/protect/001-protect_basic.phpt
new file mode 100644
index 0000000..33a91de
--- /dev/null
+++ b/tests/protect/001-protect_basic.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Async\protect: basic usage
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+protect(function() {
+    echo "protected block\n";
+});
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+protected block
+end
\ No newline at end of file
diff --git a/tests/protect/002-protect_return_value.phpt b/tests/protect/002-protect_return_value.phpt
new file mode 100644
index 0000000..202d2df
--- /dev/null
+++ b/tests/protect/002-protect_return_value.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Async\protect: should return a value
+--FILE--
+<?php
+
+use function Async\protect;
+
+$result = protect(function() {
+    return "test value";
+});
+
+var_dump($result);
+
+?>
+--EXPECT--
+string(10) "test value"
\ No newline at end of file
diff --git a/tests/protect/003-protect_nested.phpt b/tests/protect/003-protect_nested.phpt
new file mode 100644
index 0000000..7254b78
--- /dev/null
+++ b/tests/protect/003-protect_nested.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Async\protect: nested protect calls
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+protect(function() {
+    echo "outer protect start\n";
+    
+    protect(function() {
+        echo "inner protect\n";
+    });
+    
+    echo "outer protect end\n";
+});
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+outer protect start
+inner protect
+outer protect end
+end
\ No newline at end of file
diff --git a/tests/protect/004-protect_cancellation_deferred.phpt b/tests/protect/004-protect_cancellation_deferred.phpt
new file mode 100644
index 0000000..4981e53
--- /dev/null
+++ b/tests/protect/004-protect_cancellation_deferred.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Async\protect: cancellation is deferred during protected block
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\protect;
+use function Async\await;
+
+$coroutine = spawn(function() {
+    echo "coroutine start\n";
+    
+    protect(function() {
+        echo "protected block start\n";
+        
+        // Simulate work in protected block
+        for ($i = 0; $i < 3; $i++) {
+            echo "protected work: $i\n";
+        }
+        
+        echo "protected block end\n";
+    });
+    
+    echo "coroutine end\n";
+});
+
+// Try to cancel the coroutine
+$coroutine->cancel();
+
+// Wait for completion
+try {
+    await($coroutine);
+} catch (Exception $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+?>
+--EXPECTF--
+coroutine start
+protected block start
+protected work: 0
+protected work: 1
+protected work: 2
+protected block end
+caught exception: %s
\ No newline at end of file
diff --git a/tests/protect/005-protect_cancellation_immediate.phpt b/tests/protect/005-protect_cancellation_immediate.phpt
new file mode 100644
index 0000000..f5812d4
--- /dev/null
+++ b/tests/protect/005-protect_cancellation_immediate.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Async\protect: cancellation applied immediately after protected block
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\protect;
+use function Async\await;
+
+$coroutine = spawn(function() {
+    echo "before protect\n";
+    
+    protect(function() {
+        echo "in protect\n";
+    });
+    
+    echo "after protect\n";
+    
+    // This should not be reached due to deferred cancellation
+    echo "this should not print\n";
+});
+
+// Cancel the coroutine
+$coroutine->cancel();
+
+try {
+    await($coroutine);
+} catch (Exception $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+?>
+--EXPECTF--
+before protect
+in protect
+after protect
+caught exception: %s
\ No newline at end of file
diff --git a/tests/protect/006-protect_multiple_cancellation.phpt b/tests/protect/006-protect_multiple_cancellation.phpt
new file mode 100644
index 0000000..1ed5199
--- /dev/null
+++ b/tests/protect/006-protect_multiple_cancellation.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Async\protect: multiple cancellation attempts during protected block
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\protect;
+use function Async\await;
+
+$coroutine = spawn(function() {
+    echo "coroutine start\n";
+    
+    protect(function() {
+        echo "protected block\n";
+        
+        // Simulate longer work
+        for ($i = 0; $i < 2; $i++) {
+            echo "work: $i\n";
+        }
+    });
+    
+    echo "after protect\n";
+});
+
+// Try to cancel multiple times
+$coroutine->cancel();
+$coroutine->cancel();
+$coroutine->cancel();
+
+try {
+    await($coroutine);
+} catch (Exception $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+?>
+--EXPECTF--
+coroutine start
+protected block
+work: 0
+work: 1
+after protect
+caught exception: %s
\ No newline at end of file
diff --git a/tests/protect/007-protect_exception_in_closure.phpt b/tests/protect/007-protect_exception_in_closure.phpt
new file mode 100644
index 0000000..4abf5c1
--- /dev/null
+++ b/tests/protect/007-protect_exception_in_closure.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Async\protect: exception thrown inside protected closure
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+try {
+    protect(function() {
+        echo "before exception\n";
+        throw new RuntimeException("test exception");
+        echo "after exception\n"; // This should not be reached
+    });
+} catch (RuntimeException $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+before exception
+caught exception: test exception
+end
\ No newline at end of file
diff --git a/tests/protect/008-protect_bailout_handling.phpt b/tests/protect/008-protect_bailout_handling.phpt
new file mode 100644
index 0000000..e2b011a
--- /dev/null
+++ b/tests/protect/008-protect_bailout_handling.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Async\protect: bailout handling in protected closure
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+protect(function() {
+    echo "protected closure\n";
+    
+    // Test that even with potential bailout scenarios,
+    // the protected flag is properly cleared
+    $array = [];
+    echo "accessing array\n";
+    
+    // This should work normally
+    if (isset($array[0])) {
+        echo "array element exists\n";
+    } else {
+        echo "array element does not exist\n";
+    }
+});
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+protected closure
+accessing array
+array element does not exist
+end
\ No newline at end of file
diff --git a/tests/protect/009-protect_with_spawn.phpt b/tests/protect/009-protect_with_spawn.phpt
new file mode 100644
index 0000000..3f620d5
--- /dev/null
+++ b/tests/protect/009-protect_with_spawn.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Async\protect: protect inside spawn coroutine
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\protect;
+use function Async\await;
+
+echo "start\n";
+
+$coroutine = spawn(function() {
+    echo "spawn start\n";
+    
+    protect(function() {
+        echo "protected in spawn\n";
+        
+        // Do some work
+        $result = 1 + 2;
+        echo "result: $result\n";
+    });
+    
+    echo "spawn end\n";
+    return "spawn result";
+});
+
+$result = await($coroutine);
+echo "final result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawn start
+protected in spawn
+result: 3
+spawn end
+final result: spawn result
+end
\ No newline at end of file
diff --git a/tests/protect/010-protect_with_await.phpt b/tests/protect/010-protect_with_await.phpt
new file mode 100644
index 0000000..2958cd0
--- /dev/null
+++ b/tests/protect/010-protect_with_await.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Async\protect: protect with await operations
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\protect;
+use function Async\await;
+
+echo "start\n";
+
+$child = spawn(function() {
+    echo "child coroutine\n";
+    return "child result";
+});
+
+$main = spawn(function() use ($child) {
+    echo "main start\n";
+    
+    protect(function() use ($child) {
+        echo "protected block start\n";
+        
+        // Await inside protected block
+        $result = await($child);
+        echo "await result: $result\n";
+        
+        echo "protected block end\n";
+    });
+    
+    echo "main end\n";
+    return "main result";
+});
+
+$result = await($main);
+echo "final result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+main start
+protected block start
+child coroutine
+await result: child result
+protected block end
+main end
+final result: main result
+end
\ No newline at end of file
diff --git a/tests/protect/011-protect_invalid_parameter.phpt b/tests/protect/011-protect_invalid_parameter.phpt
new file mode 100644
index 0000000..389ef48
--- /dev/null
+++ b/tests/protect/011-protect_invalid_parameter.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Async\protect: invalid parameter types
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+// Test with non-closure parameter
+try {
+    protect("not a closure");
+} catch (TypeError $e) {
+    echo "caught TypeError: " . $e->getMessage() . "\n";
+}
+
+// Test with array
+try {
+    protect([]);
+} catch (TypeError $e) {
+    echo "caught TypeError for array\n";
+}
+
+// Test with object
+try {
+    protect(new stdClass());
+} catch (TypeError $e) {
+    echo "caught TypeError for object\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+caught TypeError: %s
+caught TypeError for array
+caught TypeError for object
+end
\ No newline at end of file
diff --git a/tests/protect/012-protect_closure_required.phpt b/tests/protect/012-protect_closure_required.phpt
new file mode 100644
index 0000000..163e8e9
--- /dev/null
+++ b/tests/protect/012-protect_closure_required.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Async\protect: closure parameter is required
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+// Test with no parameters
+try {
+    protect();
+} catch (ArgumentCountError $e) {
+    echo "caught ArgumentCountError: " . $e->getMessage() . "\n";
+}
+
+// Test with too many parameters
+try {
+    protect(function() {}, "extra param");
+} catch (ArgumentCountError $e) {
+    echo "caught ArgumentCountError for too many params\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+caught ArgumentCountError: %s
+caught ArgumentCountError for too many params
+end
\ No newline at end of file

From 2ad3504e3ddf550a22a8e4cad50c2cd630278c4e Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 14:36:38 +0300
Subject: [PATCH 03/53] #9: * fix tests for protect function + new test for
 await + iterator

---
 tests/await/019-awaitAll_iterator.phpt        | 70 +++++++++++++++++
 tests/await/020-awaitAny_iterator.phpt        | 68 ++++++++++++++++
 .../await/021-awaitFirstSuccess_iterator.phpt | 68 ++++++++++++++++
 .../022-awaitAllWithErrors_iterator.phpt      | 73 +++++++++++++++++
 tests/await/023-awaitAnyOf_iterator.phpt      | 74 ++++++++++++++++++
 .../024-awaitAnyOfWithErrors_iterator.phpt    | 78 +++++++++++++++++++
 tests/await/025-awaitAll_generator.phpt       | 42 ++++++++++
 tests/await/026-awaitAny_generator.phpt       | 40 ++++++++++
 .../027-awaitFirstSuccess_generator.phpt      | 40 ++++++++++
 .../028-awaitAllWithErrors_generator.phpt     | 45 +++++++++++
 tests/await/029-awaitAnyOf_generator.phpt     | 47 +++++++++++
 .../030-awaitAnyOfWithErrors_generator.phpt   | 51 ++++++++++++
 tests/await/031-awaitAll_arrayobject.phpt     | 45 +++++++++++
 tests/await/032-awaitAny_arrayobject.phpt     | 39 ++++++++++
 .../033-awaitFirstSuccess_arrayobject.phpt    | 39 ++++++++++
 tests/await/034-awaitAll_fillNull.phpt        | 50 ++++++++++++
 .../035-awaitAllWithErrors_fillNull.phpt      | 51 ++++++++++++
 .../036-awaitAll_cancellation_timeout.phpt    | 46 +++++++++++
 .../037-awaitAny_cancellation_timeout.phpt    | 41 ++++++++++
 ...waitFirstSuccess_cancellation_timeout.phpt | 41 ++++++++++
 .../039-awaitAnyOf_cancellation_timeout.phpt  | 46 +++++++++++
 .../await/040-await_cancellation_timeout.phpt | 33 ++++++++
 .../await/041-awaitAll_associative_array.phpt | 47 +++++++++++
 ...-awaitAllWithErrors_associative_array.phpt | 51 ++++++++++++
 .../043-awaitAnyOf_associative_array.phpt     | 54 +++++++++++++
 tests/await/044-awaitAll_empty_iterable.phpt  | 48 ++++++++++++
 tests/await/045-awaitAnyOf_edge_cases.phpt    | 48 ++++++++++++
 .../046-awaitFirstSuccess_all_errors.phpt     | 43 ++++++++++
 .../004-protect_cancellation_deferred.phpt    | 22 ++----
 .../005-protect_cancellation_immediate.phpt   | 31 ++++----
 .../006-protect_multiple_cancellation.phpt    | 20 +++--
 .../protect/008-protect_bailout_handling.phpt | 34 --------
 tests/protect/008-protect_with_exception.phpt | 26 +++++++
 tests/protect/010-protect_with_await.phpt     |  2 +-
 34 files changed, 1476 insertions(+), 77 deletions(-)
 create mode 100644 tests/await/019-awaitAll_iterator.phpt
 create mode 100644 tests/await/020-awaitAny_iterator.phpt
 create mode 100644 tests/await/021-awaitFirstSuccess_iterator.phpt
 create mode 100644 tests/await/022-awaitAllWithErrors_iterator.phpt
 create mode 100644 tests/await/023-awaitAnyOf_iterator.phpt
 create mode 100644 tests/await/024-awaitAnyOfWithErrors_iterator.phpt
 create mode 100644 tests/await/025-awaitAll_generator.phpt
 create mode 100644 tests/await/026-awaitAny_generator.phpt
 create mode 100644 tests/await/027-awaitFirstSuccess_generator.phpt
 create mode 100644 tests/await/028-awaitAllWithErrors_generator.phpt
 create mode 100644 tests/await/029-awaitAnyOf_generator.phpt
 create mode 100644 tests/await/030-awaitAnyOfWithErrors_generator.phpt
 create mode 100644 tests/await/031-awaitAll_arrayobject.phpt
 create mode 100644 tests/await/032-awaitAny_arrayobject.phpt
 create mode 100644 tests/await/033-awaitFirstSuccess_arrayobject.phpt
 create mode 100644 tests/await/034-awaitAll_fillNull.phpt
 create mode 100644 tests/await/035-awaitAllWithErrors_fillNull.phpt
 create mode 100644 tests/await/036-awaitAll_cancellation_timeout.phpt
 create mode 100644 tests/await/037-awaitAny_cancellation_timeout.phpt
 create mode 100644 tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
 create mode 100644 tests/await/039-awaitAnyOf_cancellation_timeout.phpt
 create mode 100644 tests/await/040-await_cancellation_timeout.phpt
 create mode 100644 tests/await/041-awaitAll_associative_array.phpt
 create mode 100644 tests/await/042-awaitAllWithErrors_associative_array.phpt
 create mode 100644 tests/await/043-awaitAnyOf_associative_array.phpt
 create mode 100644 tests/await/044-awaitAll_empty_iterable.phpt
 create mode 100644 tests/await/045-awaitAnyOf_edge_cases.phpt
 create mode 100644 tests/await/046-awaitFirstSuccess_all_errors.phpt
 delete mode 100644 tests/protect/008-protect_bailout_handling.phpt
 create mode 100644 tests/protect/008-protect_with_exception.phpt

diff --git a/tests/await/019-awaitAll_iterator.phpt b/tests/await/019-awaitAll_iterator.phpt
new file mode 100644
index 0000000..eea719e
--- /dev/null
+++ b/tests/await/019-awaitAll_iterator.phpt
@@ -0,0 +1,70 @@
+--TEST--
+awaitAll() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    spawn(function() {
+        delay(20);
+        return "second";
+    }),
+    spawn(function() {
+        delay(30);
+        return "third";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$results = awaitAll($iterator);
+
+$countOfResults = count($results) == 3 ? "OK" : "FALSE: ".count($results);
+echo "Count of results: $countOfResults\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+end
\ No newline at end of file
diff --git a/tests/await/020-awaitAny_iterator.phpt b/tests/await/020-awaitAny_iterator.phpt
new file mode 100644
index 0000000..133ae99
--- /dev/null
+++ b/tests/await/020-awaitAny_iterator.phpt
@@ -0,0 +1,68 @@
+--TEST--
+awaitAny() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(50);
+        return "slow";
+    }),
+    spawn(function() {
+        delay(10);
+        return "fast";
+    }),
+    spawn(function() {
+        delay(30);
+        return "medium";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$result = awaitAny($iterator);
+
+echo "Result: $result\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: fast
+end
\ No newline at end of file
diff --git a/tests/await/021-awaitFirstSuccess_iterator.phpt b/tests/await/021-awaitFirstSuccess_iterator.phpt
new file mode 100644
index 0000000..5cffafb
--- /dev/null
+++ b/tests/await/021-awaitFirstSuccess_iterator.phpt
@@ -0,0 +1,68 @@
+--TEST--
+awaitFirstSuccess() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        throw new RuntimeException("error");
+    }),
+    spawn(function() {
+        delay(20);
+        return "success";
+    }),
+    spawn(function() {
+        delay(30);
+        return "another success";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$result = awaitFirstSuccess($iterator);
+
+echo "Result: {$result[0]}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: success
+end
\ No newline at end of file
diff --git a/tests/await/022-awaitAllWithErrors_iterator.phpt b/tests/await/022-awaitAllWithErrors_iterator.phpt
new file mode 100644
index 0000000..807dcff
--- /dev/null
+++ b/tests/await/022-awaitAllWithErrors_iterator.phpt
@@ -0,0 +1,73 @@
+--TEST--
+awaitAllWithErrors() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAllWithErrors;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "success";
+    }),
+    spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    }),
+    spawn(function() {
+        delay(30);
+        return "another success";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$result = awaitAllWithErrors($iterator);
+
+$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
+
+echo "Count of results: $countOfResults\n";
+echo "Count of errors: $countOfErrors\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+Count of errors: OK
+end
\ No newline at end of file
diff --git a/tests/await/023-awaitAnyOf_iterator.phpt b/tests/await/023-awaitAnyOf_iterator.phpt
new file mode 100644
index 0000000..bacfa47
--- /dev/null
+++ b/tests/await/023-awaitAnyOf_iterator.phpt
@@ -0,0 +1,74 @@
+--TEST--
+awaitAnyOf() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOf;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    spawn(function() {
+        delay(20);
+        return "second";
+    }),
+    spawn(function() {
+        delay(30);
+        return "third";
+    }),
+    spawn(function() {
+        delay(40);
+        return "fourth";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$results = awaitAnyOf(2, $iterator);
+
+$countOfResults = count($results) >= 2 ? "OK" : "FALSE: ".count($results);
+echo "Count of results: $countOfResults\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+end
\ No newline at end of file
diff --git a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
new file mode 100644
index 0000000..fdf8b79
--- /dev/null
+++ b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
@@ -0,0 +1,78 @@
+--TEST--
+awaitAnyOfWithErrors() - with Iterator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOfWithErrors;
+use function Async\await;
+use function Async\delay;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current() {
+        return $this->items[$this->position];
+    }
+
+    public function key() {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    }),
+    spawn(function() {
+        delay(30);
+        return "third";
+    }),
+    spawn(function() {
+        delay(40);
+        return "fourth";
+    }),
+];
+
+$iterator = new TestIterator($coroutines);
+$result = awaitAnyOfWithErrors(2, $iterator);
+
+$countOfResults = count($result[0]) >= 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
+
+echo "Count of results: $countOfResults\n";
+echo "Count of errors: $countOfErrors\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+Count of errors: OK
+end
\ No newline at end of file
diff --git a/tests/await/025-awaitAll_generator.phpt b/tests/await/025-awaitAll_generator.phpt
new file mode 100644
index 0000000..90794e0
--- /dev/null
+++ b/tests/await/025-awaitAll_generator.phpt
@@ -0,0 +1,42 @@
+--TEST--
+awaitAll() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(10);
+        return "first";
+    });
+    
+    yield spawn(function() {
+        delay(20);
+        return "second";
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "third";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$results = awaitAll($generator);
+
+$countOfResults = count($results) == 3 ? "OK" : "FALSE: ".count($results);
+echo "Count of results: $countOfResults\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+end
\ No newline at end of file
diff --git a/tests/await/026-awaitAny_generator.phpt b/tests/await/026-awaitAny_generator.phpt
new file mode 100644
index 0000000..1cfe288
--- /dev/null
+++ b/tests/await/026-awaitAny_generator.phpt
@@ -0,0 +1,40 @@
+--TEST--
+awaitAny() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(50);
+        return "slow";
+    });
+    
+    yield spawn(function() {
+        delay(10);
+        return "fast";
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "medium";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$result = awaitAny($generator);
+
+echo "Result: $result\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: fast
+end
\ No newline at end of file
diff --git a/tests/await/027-awaitFirstSuccess_generator.phpt b/tests/await/027-awaitFirstSuccess_generator.phpt
new file mode 100644
index 0000000..f4a9f1c
--- /dev/null
+++ b/tests/await/027-awaitFirstSuccess_generator.phpt
@@ -0,0 +1,40 @@
+--TEST--
+awaitFirstSuccess() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(10);
+        throw new RuntimeException("error");
+    });
+    
+    yield spawn(function() {
+        delay(20);
+        return "success";
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "another success";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$result = awaitFirstSuccess($generator);
+
+echo "Result: {$result[0]}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: success
+end
\ No newline at end of file
diff --git a/tests/await/028-awaitAllWithErrors_generator.phpt b/tests/await/028-awaitAllWithErrors_generator.phpt
new file mode 100644
index 0000000..74d6539
--- /dev/null
+++ b/tests/await/028-awaitAllWithErrors_generator.phpt
@@ -0,0 +1,45 @@
+--TEST--
+awaitAllWithErrors() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAllWithErrors;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(10);
+        return "success";
+    });
+    
+    yield spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "another success";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$result = awaitAllWithErrors($generator);
+
+$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
+
+echo "Count of results: $countOfResults\n";
+echo "Count of errors: $countOfErrors\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+Count of errors: OK
+end
\ No newline at end of file
diff --git a/tests/await/029-awaitAnyOf_generator.phpt b/tests/await/029-awaitAnyOf_generator.phpt
new file mode 100644
index 0000000..1e6b389
--- /dev/null
+++ b/tests/await/029-awaitAnyOf_generator.phpt
@@ -0,0 +1,47 @@
+--TEST--
+awaitAnyOf() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOf;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(10);
+        return "first";
+    });
+    
+    yield spawn(function() {
+        delay(20);
+        return "second";
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "third";
+    });
+    
+    yield spawn(function() {
+        delay(40);
+        return "fourth";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$results = awaitAnyOf(2, $generator);
+
+$countOfResults = count($results) >= 2 ? "OK" : "FALSE: ".count($results);
+echo "Count of results: $countOfResults\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+end
\ No newline at end of file
diff --git a/tests/await/030-awaitAnyOfWithErrors_generator.phpt b/tests/await/030-awaitAnyOfWithErrors_generator.phpt
new file mode 100644
index 0000000..a784db4
--- /dev/null
+++ b/tests/await/030-awaitAnyOfWithErrors_generator.phpt
@@ -0,0 +1,51 @@
+--TEST--
+awaitAnyOfWithErrors() - with Generator
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOfWithErrors;
+use function Async\await;
+use function Async\delay;
+
+function createCoroutines() {
+    yield spawn(function() {
+        delay(10);
+        return "first";
+    });
+    
+    yield spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    });
+    
+    yield spawn(function() {
+        delay(30);
+        return "third";
+    });
+    
+    yield spawn(function() {
+        delay(40);
+        return "fourth";
+    });
+}
+
+echo "start\n";
+
+$generator = createCoroutines();
+$result = awaitAnyOfWithErrors(2, $generator);
+
+$countOfResults = count($result[0]) >= 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
+
+echo "Count of results: $countOfResults\n";
+echo "Count of errors: $countOfErrors\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: OK
+Count of errors: OK
+end
\ No newline at end of file
diff --git a/tests/await/031-awaitAll_arrayobject.phpt b/tests/await/031-awaitAll_arrayobject.phpt
new file mode 100644
index 0000000..8e6a42e
--- /dev/null
+++ b/tests/await/031-awaitAll_arrayobject.phpt
@@ -0,0 +1,45 @@
+--TEST--
+awaitAll() - with ArrayObject
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+$arrayObject = new ArrayObject([
+    spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    
+    spawn(function() {
+        delay(20);
+        return "second";
+    }),
+    
+    spawn(function() {
+        delay(30);
+        return "third";
+    })
+]);
+
+echo "start\n";
+
+$results = awaitAll($arrayObject);
+
+echo "Count: " . count($results) . "\n";
+echo "Result 0: {$results[0]}\n";
+echo "Result 1: {$results[1]}\n";
+echo "Result 2: {$results[2]}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count: 3
+Result 0: first
+Result 1: second
+Result 2: third
+end
\ No newline at end of file
diff --git a/tests/await/032-awaitAny_arrayobject.phpt b/tests/await/032-awaitAny_arrayobject.phpt
new file mode 100644
index 0000000..d6944e6
--- /dev/null
+++ b/tests/await/032-awaitAny_arrayobject.phpt
@@ -0,0 +1,39 @@
+--TEST--
+awaitAny() - with ArrayObject
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\await;
+use function Async\delay;
+
+$arrayObject = new ArrayObject([
+    spawn(function() {
+        delay(50);
+        return "slow";
+    }),
+    
+    spawn(function() {
+        delay(10);
+        return "fast";
+    }),
+    
+    spawn(function() {
+        delay(30);
+        return "medium";
+    })
+]);
+
+echo "start\n";
+
+$result = awaitAny($arrayObject);
+
+echo "Result: $result\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: fast
+end
\ No newline at end of file
diff --git a/tests/await/033-awaitFirstSuccess_arrayobject.phpt b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
new file mode 100644
index 0000000..1908aed
--- /dev/null
+++ b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
@@ -0,0 +1,39 @@
+--TEST--
+awaitFirstSuccess() - with ArrayObject
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+use function Async\delay;
+
+$arrayObject = new ArrayObject([
+    spawn(function() {
+        delay(10);
+        throw new RuntimeException("error");
+    }),
+    
+    spawn(function() {
+        delay(20);
+        return "success";
+    }),
+    
+    spawn(function() {
+        delay(30);
+        return "another success";
+    })
+]);
+
+echo "start\n";
+
+$result = awaitFirstSuccess($arrayObject);
+
+echo "Result: {$result[0]}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: success
+end
\ No newline at end of file
diff --git a/tests/await/034-awaitAll_fillNull.phpt b/tests/await/034-awaitAll_fillNull.phpt
new file mode 100644
index 0000000..98c382c
--- /dev/null
+++ b/tests/await/034-awaitAll_fillNull.phpt
@@ -0,0 +1,50 @@
+--TEST--
+awaitAll() - with fillNull parameter
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "success";
+    }),
+    
+    spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    }),
+    
+    spawn(function() {
+        delay(30);
+        return "another success";
+    })
+];
+
+echo "start\n";
+
+// Test with fillNull = true
+try {
+    $results = awaitAll($coroutines, null, true);
+    echo "Count: " . count($results) . "\n";
+    echo "Result 0: " . ($results[0] ?? "null") . "\n";
+    echo "Result 1: " . ($results[1] ?? "null") . "\n";
+    echo "Result 2: " . ($results[2] ?? "null") . "\n";
+} catch (RuntimeException $e) {
+    echo "Exception caught with fillNull=true: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count: 3
+Result 0: success
+Result 1: null
+Result 2: another success
+end
\ No newline at end of file
diff --git a/tests/await/035-awaitAllWithErrors_fillNull.phpt b/tests/await/035-awaitAllWithErrors_fillNull.phpt
new file mode 100644
index 0000000..2a67232
--- /dev/null
+++ b/tests/await/035-awaitAllWithErrors_fillNull.phpt
@@ -0,0 +1,51 @@
+--TEST--
+awaitAllWithErrors() - with fillNull parameter
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAllWithErrors;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "success";
+    }),
+    
+    spawn(function() {
+        delay(20);
+        throw new RuntimeException("error");
+    }),
+    
+    spawn(function() {
+        delay(30);
+        return "another success";
+    })
+];
+
+echo "start\n";
+
+// Test with fillNull = true
+$result = awaitAllWithErrors($coroutines, null, true);
+
+echo "Count of results: " . count($result[0]) . "\n";
+echo "Count of errors: " . count($result[1]) . "\n";
+echo "Result 0: " . ($result[0][0] ?? "null") . "\n";
+echo "Result 1: " . ($result[0][1] ?? "null") . "\n";
+echo "Result 2: " . ($result[0][2] ?? "null") . "\n";
+echo "Error message: " . $result[1][1]->getMessage() . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: 3
+Count of errors: 1
+Result 0: success
+Result 1: null
+Result 2: another success
+Error message: error
+end
\ No newline at end of file
diff --git a/tests/await/036-awaitAll_cancellation_timeout.phpt b/tests/await/036-awaitAll_cancellation_timeout.phpt
new file mode 100644
index 0000000..728195e
--- /dev/null
+++ b/tests/await/036-awaitAll_cancellation_timeout.phpt
@@ -0,0 +1,46 @@
+--TEST--
+awaitAll() - with cancellation timeout
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+use function Async\timeout;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "fast";
+    }),
+    
+    spawn(function() {
+        delay(100); // This will be cancelled
+        return "slow";
+    }),
+    
+    spawn(function() {
+        delay(200); // This will also be cancelled
+        return "very slow";
+    })
+];
+
+echo "start\n";
+
+try {
+    $results = awaitAll($coroutines, timeout(50));
+    echo "Unexpected success\n";
+} catch (Async\TimeoutException $e) {
+    echo "Timeout caught as expected\n";
+} catch (Exception $e) {
+    echo "Exception: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Timeout caught as expected
+end
\ No newline at end of file
diff --git a/tests/await/037-awaitAny_cancellation_timeout.phpt b/tests/await/037-awaitAny_cancellation_timeout.phpt
new file mode 100644
index 0000000..1831285
--- /dev/null
+++ b/tests/await/037-awaitAny_cancellation_timeout.phpt
@@ -0,0 +1,41 @@
+--TEST--
+awaitAny() - with cancellation timeout
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\await;
+use function Async\delay;
+use function Async\timeout;
+
+$coroutines = [
+    spawn(function() {
+        delay(100); // Will be cancelled
+        return "slow";
+    }),
+    
+    spawn(function() {
+        delay(200); // Will be cancelled
+        return "very slow";
+    })
+];
+
+echo "start\n";
+
+try {
+    $result = awaitAny($coroutines, timeout(50));
+    echo "Unexpected success: $result\n";
+} catch (Async\TimeoutException $e) {
+    echo "Timeout caught as expected\n";
+} catch (Exception $e) {
+    echo "Exception: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Timeout caught as expected
+end
\ No newline at end of file
diff --git a/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt b/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
new file mode 100644
index 0000000..a1bfe34
--- /dev/null
+++ b/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
@@ -0,0 +1,41 @@
+--TEST--
+awaitFirstSuccess() - with cancellation timeout
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+use function Async\delay;
+use function Async\timeout;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        throw new RuntimeException("fast error");
+    }),
+    
+    spawn(function() {
+        delay(100); // Will be cancelled before success
+        return "success";
+    })
+];
+
+echo "start\n";
+
+try {
+    $result = awaitFirstSuccess($coroutines, timeout(50));
+    echo "Unexpected success\n";
+} catch (Async\TimeoutException $e) {
+    echo "Timeout caught as expected\n";
+} catch (Exception $e) {
+    echo "Exception: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Timeout caught as expected
+end
\ No newline at end of file
diff --git a/tests/await/039-awaitAnyOf_cancellation_timeout.phpt b/tests/await/039-awaitAnyOf_cancellation_timeout.phpt
new file mode 100644
index 0000000..23b4947
--- /dev/null
+++ b/tests/await/039-awaitAnyOf_cancellation_timeout.phpt
@@ -0,0 +1,46 @@
+--TEST--
+awaitAnyOf() - with cancellation timeout
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOf;
+use function Async\await;
+use function Async\delay;
+use function Async\timeout;
+
+$coroutines = [
+    spawn(function() {
+        delay(100); // Will be cancelled
+        return "slow";
+    }),
+    
+    spawn(function() {
+        delay(200); // Will be cancelled
+        return "very slow";
+    }),
+    
+    spawn(function() {
+        delay(300); // Will be cancelled
+        return "extremely slow";
+    })
+];
+
+echo "start\n";
+
+try {
+    $results = awaitAnyOf(2, $coroutines, timeout(50));
+    echo "Unexpected success\n";
+} catch (Async\TimeoutException $e) {
+    echo "Timeout caught as expected\n";
+} catch (Exception $e) {
+    echo "Exception: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Timeout caught as expected
+end
\ No newline at end of file
diff --git a/tests/await/040-await_cancellation_timeout.phpt b/tests/await/040-await_cancellation_timeout.phpt
new file mode 100644
index 0000000..aeec81f
--- /dev/null
+++ b/tests/await/040-await_cancellation_timeout.phpt
@@ -0,0 +1,33 @@
+--TEST--
+await() - with cancellation timeout
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\delay;
+use function Async\timeout;
+
+$coroutine = spawn(function() {
+    delay(100); // Will be cancelled
+    return "success";
+});
+
+echo "start\n";
+
+try {
+    $result = await($coroutine, timeout(50));
+    echo "Unexpected success: $result\n";
+} catch (Async\TimeoutException $e) {
+    echo "Timeout caught as expected\n";
+} catch (Exception $e) {
+    echo "Exception: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Timeout caught as expected
+end
\ No newline at end of file
diff --git a/tests/await/041-awaitAll_associative_array.phpt b/tests/await/041-awaitAll_associative_array.phpt
new file mode 100644
index 0000000..f9123e9
--- /dev/null
+++ b/tests/await/041-awaitAll_associative_array.phpt
@@ -0,0 +1,47 @@
+--TEST--
+awaitAll() - with associative array
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    'task1' => spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    
+    'task2' => spawn(function() {
+        delay(20);
+        return "second";
+    }),
+    
+    'task3' => spawn(function() {
+        delay(30);
+        return "third";
+    })
+];
+
+echo "start\n";
+
+$results = awaitAll($coroutines);
+
+echo "Count: " . count($results) . "\n";
+echo "Keys preserved: " . (array_keys($results) === ['task1', 'task2', 'task3'] ? "YES" : "NO") . "\n";
+echo "Result task1: {$results['task1']}\n";
+echo "Result task2: {$results['task2']}\n";
+echo "Result task3: {$results['task3']}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count: 3
+Keys preserved: YES
+Result task1: first
+Result task2: second
+Result task3: third
+end
\ No newline at end of file
diff --git a/tests/await/042-awaitAllWithErrors_associative_array.phpt b/tests/await/042-awaitAllWithErrors_associative_array.phpt
new file mode 100644
index 0000000..5b706ca
--- /dev/null
+++ b/tests/await/042-awaitAllWithErrors_associative_array.phpt
@@ -0,0 +1,51 @@
+--TEST--
+awaitAllWithErrors() - with associative array
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAllWithErrors;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    'success1' => spawn(function() {
+        delay(10);
+        return "first success";
+    }),
+    
+    'error1' => spawn(function() {
+        delay(20);
+        throw new RuntimeException("first error");
+    }),
+    
+    'success2' => spawn(function() {
+        delay(30);
+        return "second success";
+    })
+];
+
+echo "start\n";
+
+$result = awaitAllWithErrors($coroutines);
+
+echo "Count of results: " . count($result[0]) . "\n";
+echo "Count of errors: " . count($result[1]) . "\n";
+echo "Result keys: " . implode(', ', array_keys($result[0])) . "\n";
+echo "Error keys: " . implode(', ', array_keys($result[1])) . "\n";
+echo "Result success1: {$result[0]['success1']}\n";
+echo "Result success2: {$result[0]['success2']}\n";
+echo "Error error1: {$result[1]['error1']->getMessage()}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count of results: 2
+Count of errors: 1
+Result keys: success1, success2
+Error keys: error1
+Result success1: first success
+Result success2: second success
+Error error1: first error
+end
\ No newline at end of file
diff --git a/tests/await/043-awaitAnyOf_associative_array.phpt b/tests/await/043-awaitAnyOf_associative_array.phpt
new file mode 100644
index 0000000..0a0ccb3
--- /dev/null
+++ b/tests/await/043-awaitAnyOf_associative_array.phpt
@@ -0,0 +1,54 @@
+--TEST--
+awaitAnyOf() - with associative array
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOf;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    'slow' => spawn(function() {
+        delay(50);
+        return "slow task";
+    }),
+    
+    'fast' => spawn(function() {
+        delay(10);
+        return "fast task";
+    }),
+    
+    'medium' => spawn(function() {
+        delay(30);
+        return "medium task";
+    }),
+    
+    'very_slow' => spawn(function() {
+        delay(100);
+        return "very slow task";
+    })
+];
+
+echo "start\n";
+
+$results = awaitAnyOf(2, $coroutines);
+
+echo "Count: " . count($results) . "\n";
+echo "Keys preserved: " . (count(array_intersect(array_keys($results), ['slow', 'fast', 'medium', 'very_slow'])) == count($results) ? "YES" : "NO") . "\n";
+
+// The fastest should complete first
+$keys = array_keys($results);
+echo "First completed key: {$keys[0]}\n";
+echo "First completed value: {$results[$keys[0]]}\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count: 2
+Keys preserved: YES
+First completed key: fast
+First completed value: fast task
+end
\ No newline at end of file
diff --git a/tests/await/044-awaitAll_empty_iterable.phpt b/tests/await/044-awaitAll_empty_iterable.phpt
new file mode 100644
index 0000000..dd23e7d
--- /dev/null
+++ b/tests/await/044-awaitAll_empty_iterable.phpt
@@ -0,0 +1,48 @@
+--TEST--
+awaitAll() - with empty iterable
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\delay;
+
+// Test with empty array
+echo "start\n";
+
+$results = awaitAll([]);
+
+echo "Empty array count: " . count($results) . "\n";
+echo "Empty array type: " . gettype($results) . "\n";
+
+// Test with empty ArrayObject
+$emptyArrayObject = new ArrayObject([]);
+$results2 = awaitAll($emptyArrayObject);
+
+echo "Empty ArrayObject count: " . count($results2) . "\n";
+echo "Empty ArrayObject type: " . gettype($results2) . "\n";
+
+// Test with empty generator
+function emptyGenerator() {
+    return;
+    yield; // unreachable
+}
+
+$results3 = awaitAll(emptyGenerator());
+
+echo "Empty generator count: " . count($results3) . "\n";
+echo "Empty generator type: " . gettype($results3) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Empty array count: 0
+Empty array type: array
+Empty ArrayObject count: 0
+Empty ArrayObject type: array
+Empty generator count: 0
+Empty generator type: array
+end
\ No newline at end of file
diff --git a/tests/await/045-awaitAnyOf_edge_cases.phpt b/tests/await/045-awaitAnyOf_edge_cases.phpt
new file mode 100644
index 0000000..8eb8274
--- /dev/null
+++ b/tests/await/045-awaitAnyOf_edge_cases.phpt
@@ -0,0 +1,48 @@
+--TEST--
+awaitAnyOf() - edge cases with count parameter
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAnyOf;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        return "first";
+    }),
+    
+    spawn(function() {
+        delay(20);
+        return "second";
+    })
+];
+
+echo "start\n";
+
+// Test requesting more than available
+try {
+    $results = awaitAnyOf(5, $coroutines);
+    echo "Count when requesting more than available: " . count($results) . "\n";
+} catch (Exception $e) {
+    echo "Exception when requesting more: " . get_class($e) . "\n";
+}
+
+// Test requesting zero
+try {
+    $results = awaitAnyOf(0, $coroutines);
+    echo "Count when requesting zero: " . count($results) . "\n";
+} catch (Exception $e) {
+    echo "Exception when requesting zero: " . get_class($e) . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Count when requesting more than available: 2
+Count when requesting zero: 0
+end
\ No newline at end of file
diff --git a/tests/await/046-awaitFirstSuccess_all_errors.phpt b/tests/await/046-awaitFirstSuccess_all_errors.phpt
new file mode 100644
index 0000000..946d66f
--- /dev/null
+++ b/tests/await/046-awaitFirstSuccess_all_errors.phpt
@@ -0,0 +1,43 @@
+--TEST--
+awaitFirstSuccess() - when all coroutines throw errors
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+use function Async\delay;
+
+$coroutines = [
+    spawn(function() {
+        delay(10);
+        throw new RuntimeException("first error");
+    }),
+    
+    spawn(function() {
+        delay(20);
+        throw new InvalidArgumentException("second error");
+    }),
+    
+    spawn(function() {
+        delay(30);
+        throw new LogicException("third error");
+    })
+];
+
+echo "start\n";
+
+try {
+    $result = awaitFirstSuccess($coroutines);
+    echo "Unexpected success: " . print_r($result, true) . "\n";
+} catch (Exception $e) {
+    echo "Exception caught: " . get_class($e) . " - " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Exception caught: RuntimeException - first error
+end
\ No newline at end of file
diff --git a/tests/protect/004-protect_cancellation_deferred.phpt b/tests/protect/004-protect_cancellation_deferred.phpt
index 4981e53..4f0bac7 100644
--- a/tests/protect/004-protect_cancellation_deferred.phpt
+++ b/tests/protect/004-protect_cancellation_deferred.phpt
@@ -6,40 +6,30 @@ Async\protect: cancellation is deferred during protected block
 use function Async\spawn;
 use function Async\protect;
 use function Async\await;
+use function Async\suspend;
 
 $coroutine = spawn(function() {
     echo "coroutine start\n";
     
     protect(function() {
         echo "protected block start\n";
-        
-        // Simulate work in protected block
-        for ($i = 0; $i < 3; $i++) {
-            echo "protected work: $i\n";
-        }
-        
+        suspend();
         echo "protected block end\n";
     });
     
     echo "coroutine end\n";
 });
 
+suspend();
+
 // Try to cancel the coroutine
 $coroutine->cancel();
 
 // Wait for completion
-try {
-    await($coroutine);
-} catch (Exception $e) {
-    echo "caught exception: " . $e->getMessage() . "\n";
-}
+await($coroutine);
 
 ?>
 --EXPECTF--
 coroutine start
 protected block start
-protected work: 0
-protected work: 1
-protected work: 2
-protected block end
-caught exception: %s
\ No newline at end of file
+protected block end
\ No newline at end of file
diff --git a/tests/protect/005-protect_cancellation_immediate.phpt b/tests/protect/005-protect_cancellation_immediate.phpt
index f5812d4..568ca57 100644
--- a/tests/protect/005-protect_cancellation_immediate.phpt
+++ b/tests/protect/005-protect_cancellation_immediate.phpt
@@ -6,32 +6,33 @@ Async\protect: cancellation applied immediately after protected block
 use function Async\spawn;
 use function Async\protect;
 use function Async\await;
+use function Async\suspend;
 
 $coroutine = spawn(function() {
     echo "before protect\n";
-    
-    protect(function() {
-        echo "in protect\n";
-    });
-    
-    echo "after protect\n";
-    
-    // This should not be reached due to deferred cancellation
-    echo "this should not print\n";
+
+    try {
+        // This will be protected, and cancellation will be applied immediately after this block
+        protect(function() {
+            echo "in protect\n";
+            suspend();
+            echo "finished protect\n";
+        });
+    } catch (\CancellationException $e) {
+        echo "caught exception: " . $e->getMessage() . "\n";
+    }
 });
 
+suspend();
+
 // Cancel the coroutine
 $coroutine->cancel();
 
-try {
-    await($coroutine);
-} catch (Exception $e) {
-    echo "caught exception: " . $e->getMessage() . "\n";
-}
+await($coroutine);
 
 ?>
 --EXPECTF--
 before protect
 in protect
-after protect
+finished protect
 caught exception: %s
\ No newline at end of file
diff --git a/tests/protect/006-protect_multiple_cancellation.phpt b/tests/protect/006-protect_multiple_cancellation.phpt
index 1ed5199..48b9605 100644
--- a/tests/protect/006-protect_multiple_cancellation.phpt
+++ b/tests/protect/006-protect_multiple_cancellation.phpt
@@ -6,38 +6,36 @@ Async\protect: multiple cancellation attempts during protected block
 use function Async\spawn;
 use function Async\protect;
 use function Async\await;
+use function Async\suspend;
 
 $coroutine = spawn(function() {
     echo "coroutine start\n";
     
     protect(function() {
         echo "protected block\n";
-        
-        // Simulate longer work
-        for ($i = 0; $i < 2; $i++) {
+        for ($i = 1; $i <= 2; $i++) {
             echo "work: $i\n";
+            suspend(); // Simulate work
         }
     });
     
     echo "after protect\n";
 });
 
+suspend();
+
 // Try to cancel multiple times
 $coroutine->cancel();
+suspend();
 $coroutine->cancel();
+suspend();
 $coroutine->cancel();
 
-try {
-    await($coroutine);
-} catch (Exception $e) {
-    echo "caught exception: " . $e->getMessage() . "\n";
-}
+await($coroutine);
 
 ?>
 --EXPECTF--
 coroutine start
 protected block
-work: 0
 work: 1
-after protect
-caught exception: %s
\ No newline at end of file
+work: 2
\ No newline at end of file
diff --git a/tests/protect/008-protect_bailout_handling.phpt b/tests/protect/008-protect_bailout_handling.phpt
deleted file mode 100644
index e2b011a..0000000
--- a/tests/protect/008-protect_bailout_handling.phpt
+++ /dev/null
@@ -1,34 +0,0 @@
---TEST--
-Async\protect: bailout handling in protected closure
---FILE--
-<?php
-
-use function Async\protect;
-
-echo "start\n";
-
-protect(function() {
-    echo "protected closure\n";
-    
-    // Test that even with potential bailout scenarios,
-    // the protected flag is properly cleared
-    $array = [];
-    echo "accessing array\n";
-    
-    // This should work normally
-    if (isset($array[0])) {
-        echo "array element exists\n";
-    } else {
-        echo "array element does not exist\n";
-    }
-});
-
-echo "end\n";
-
-?>
---EXPECT--
-start
-protected closure
-accessing array
-array element does not exist
-end
\ No newline at end of file
diff --git a/tests/protect/008-protect_with_exception.phpt b/tests/protect/008-protect_with_exception.phpt
new file mode 100644
index 0000000..7f3b058
--- /dev/null
+++ b/tests/protect/008-protect_with_exception.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Async\protect: exception handling in protected closure
+--FILE--
+<?php
+
+use function Async\protect;
+
+echo "start\n";
+
+try {
+    protect(function() {
+        echo "protected closure\n";
+        throw new Exception("Exception");
+    });
+} catch (Exception $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+protected closure
+caught exception: Exception
+end
\ No newline at end of file
diff --git a/tests/protect/010-protect_with_await.phpt b/tests/protect/010-protect_with_await.phpt
index 2958cd0..09c204f 100644
--- a/tests/protect/010-protect_with_await.phpt
+++ b/tests/protect/010-protect_with_await.phpt
@@ -39,9 +39,9 @@ echo "end\n";
 ?>
 --EXPECT--
 start
+child coroutine
 main start
 protected block start
-child coroutine
 await result: child result
 protected block end
 main end

From 5a7253e9e67997fdfeb3d5e19823c3adf1a020ca Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 16:06:50 +0300
Subject: [PATCH 04/53] #9: * Fix for the await code handling the iterator.

---
 async_API.c                            | 16 ++++++++++++++--
 iterator.c                             | 22 +++++++++++++++++++---
 tests/await/019-awaitAll_iterator.phpt |  4 ++--
 3 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/async_API.c b/async_API.c
index 90b1164..0e52c60 100644
--- a/async_API.c
+++ b/async_API.c
@@ -543,6 +543,8 @@ void iterator_coroutine_first_entry(void)
 		sizeof(async_await_iterator_iterator_t)
 	);
 
+	iterator->await_iterator = await_iterator;
+
 	if (UNEXPECTED(iterator == NULL)) {
 		return;
 	}
@@ -558,8 +560,7 @@ void iterator_coroutine_finish_callback(
 	zend_object *exception
 )
 {
-	async_await_iterator_t * iterator = (async_await_iterator_t *)
-			((zend_coroutine_event_callback_t*) callback)->coroutine->extended_data;
+	async_await_iterator_t * iterator = (async_await_iterator_t *) ((zend_coroutine_t*) event)->extended_data;
 
 	if (exception != NULL) {
 		// Resume the waiting coroutine with the exception
@@ -583,6 +584,16 @@ void async_await_iterator_coroutine_dispose(zend_coroutine_t *coroutine)
 	async_await_iterator_t * iterator = (async_await_iterator_t *) coroutine->extended_data;
 	coroutine->extended_data = NULL;
 
+	if (iterator->zend_iterator != NULL) {
+		zend_object_iterator *zend_iterator = iterator->zend_iterator;
+		iterator->zend_iterator = NULL;
+
+		if (zend_iterator->funcs->invalidate_current) {
+			zend_iterator->funcs->invalidate_current(zend_iterator);
+		}
+		zend_iterator_dtor(zend_iterator);
+	}
+
 	efree(iterator);
 }
 
@@ -836,6 +847,7 @@ void async_await_futures(
 		iterator->zend_iterator = zend_iterator;
 		iterator->waiting_coroutine = coroutine;
 		iterator->iterator_coroutine = iterator_coroutine;
+		iterator->await_context = await_context;
 
 		iterator_coroutine->extended_data = iterator;
 		iterator_coroutine->extended_dispose = async_await_iterator_coroutine_dispose;
diff --git a/iterator.c b/iterator.c
index 622b03e..29c7319 100644
--- a/iterator.c
+++ b/iterator.c
@@ -194,9 +194,23 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			// or just set it to the array
 			iterator->target_hash = Z_ARRVAL(iterator->array);
 		}
+	} else {
+		iterator->position = 0;
+		iterator->hash_iterator = -1;
+
+		if (iterator->zend_iterator->funcs->rewind) {
+			iterator->zend_iterator->funcs->rewind(iterator->zend_iterator);
+		}
+
+		if (UNEXPECTED(EG(exception))) {
+			iterator->state = ASYNC_ITERATOR_FINISHED;
+			iterator->microtask.is_cancelled = true;
+			return;
+		}
 	}
 
 	zval * current;
+	zval current_item;
 	zval key;
 
 	while (iterator->state != ASYNC_ITERATOR_FINISHED) {
@@ -205,6 +219,11 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			current = zend_hash_get_current_data_ex(iterator->target_hash, &iterator->position);
 		} else if (SUCCESS == iterator->zend_iterator->funcs->valid(iterator->zend_iterator)) {
 			current = iterator->zend_iterator->funcs->get_current_data(iterator->zend_iterator);
+
+			if (current != NULL) {
+				ZVAL_COPY_VALUE(&current_item, current);
+				current = &current_item;
+			}
 		} else {
 			current = NULL;
 		}
@@ -229,9 +248,6 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			}
 		}
 
-		/* Ensure the value is a reference. Otherwise, the location of the value may be freed. */
-		ZVAL_MAKE_REF(current);
-
 		/* Retrieve key */
 		if (iterator->target_hash != NULL) {
 			zend_hash_get_current_key_zval_ex(iterator->target_hash, &key, &iterator->position);
diff --git a/tests/await/019-awaitAll_iterator.phpt b/tests/await/019-awaitAll_iterator.phpt
index eea719e..fd7469e 100644
--- a/tests/await/019-awaitAll_iterator.phpt
+++ b/tests/await/019-awaitAll_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current():mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key():mixed {
         return $this->position;
     }
 

From c3d95420b9ff37a9ed7c3004fa29625342cff55f Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 16:12:11 +0300
Subject: [PATCH 05/53] #9: * Fix for the await code handling the iterator.

---
 tests/await/019-awaitAll_iterator.phpt             | 4 ++--
 tests/await/020-awaitAny_iterator.phpt             | 4 ++--
 tests/await/021-awaitFirstSuccess_iterator.phpt    | 4 ++--
 tests/await/022-awaitAllWithErrors_iterator.phpt   | 4 ++--
 tests/await/023-awaitAnyOf_iterator.phpt           | 4 ++--
 tests/await/024-awaitAnyOfWithErrors_iterator.phpt | 4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/await/019-awaitAll_iterator.phpt b/tests/await/019-awaitAll_iterator.phpt
index fd7469e..ce7495d 100644
--- a/tests/await/019-awaitAll_iterator.phpt
+++ b/tests/await/019-awaitAll_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current():mixed {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key():mixed {
+    public function key(): mixed {
         return $this->position;
     }
 
diff --git a/tests/await/020-awaitAny_iterator.phpt b/tests/await/020-awaitAny_iterator.phpt
index 133ae99..6df0030 100644
--- a/tests/await/020-awaitAny_iterator.phpt
+++ b/tests/await/020-awaitAny_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key(): mixed {
         return $this->position;
     }
 
diff --git a/tests/await/021-awaitFirstSuccess_iterator.phpt b/tests/await/021-awaitFirstSuccess_iterator.phpt
index 5cffafb..e3a8623 100644
--- a/tests/await/021-awaitFirstSuccess_iterator.phpt
+++ b/tests/await/021-awaitFirstSuccess_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key(): mixed {
         return $this->position;
     }
 
diff --git a/tests/await/022-awaitAllWithErrors_iterator.phpt b/tests/await/022-awaitAllWithErrors_iterator.phpt
index 807dcff..5842368 100644
--- a/tests/await/022-awaitAllWithErrors_iterator.phpt
+++ b/tests/await/022-awaitAllWithErrors_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key(): mixed {
         return $this->position;
     }
 
diff --git a/tests/await/023-awaitAnyOf_iterator.phpt b/tests/await/023-awaitAnyOf_iterator.phpt
index bacfa47..fca7794 100644
--- a/tests/await/023-awaitAnyOf_iterator.phpt
+++ b/tests/await/023-awaitAnyOf_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key(): mixed {
         return $this->position;
     }
 
diff --git a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
index fdf8b79..7075d7a 100644
--- a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
+++ b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
@@ -21,11 +21,11 @@ class TestIterator implements Iterator
         $this->position = 0;
     }
 
-    public function current() {
+    public function current(): mixed {
         return $this->items[$this->position];
     }
 
-    public function key() {
+    public function key(): mixed {
         return $this->position;
     }
 

From 5f359138ca2cfcad8239311f22bbbd69bb91b162 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 22:10:25 +0300
Subject: [PATCH 06/53] #9: * Fixes in the zend_iterator logic in the context
 of concurrent iteration.       Added a constant for high priority.

---
 async_API.c                                   | 40 ++++++++++++-------
 async_API.h                                   |  3 ++
 .../022-awaitAllWithErrors_iterator.phpt      |  5 +--
 3 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/async_API.c b/async_API.c
index 0e52c60..c21d658 100644
--- a/async_API.c
+++ b/async_API.c
@@ -263,9 +263,11 @@ static zend_class_entry* async_get_class_ce(zend_async_class type)
 ////////////////////////////////////////////////////////////////////
 
 #define AWAIT_ALL(await_context) ((await_context)->waiting_count == 0 || (await_context)->waiting_count == (await_context)->total)
-#define ITERATOR_IS_FINISHED(await_context) \
-	((await_context->ignore_errors ? await_context->success_count : await_context->resolved_count) >= await_context->waiting_count || \
-		(await_context->total != 0 && await_context->resolved_count >= await_context->total) \
+#define AWAIT_ITERATOR_IS_FINISHED(await_context) \
+	((await_context->waiting_count > 0 \
+		&& (await_context->ignore_errors ? await_context->success_count : await_context->resolved_count) \
+			>= await_context->waiting_count) || \
+	(await_context->total != 0 && await_context->resolved_count >= await_context->total) \
 	)
 
 static zend_always_inline zend_async_event_t * zval_to_event(const zval * current)
@@ -388,7 +390,7 @@ void async_waiting_callback(
 		}
 	}
 
-	if (UNEXPECTED(ITERATOR_IS_FINISHED(await_context))) {
+	if (UNEXPECTED(AWAIT_ITERATOR_IS_FINISHED(await_context))) {
 		ZEND_ASYNC_RESUME(await_callback->callback.coroutine);
 	}
 
@@ -471,7 +473,8 @@ zend_result await_iterator_handler(async_iterator_t *iterator, zval *current, zv
 
 	async_await_callback_t * callback = ecalloc(1, sizeof(async_await_callback_t));
 	callback->callback.base.callback = async_waiting_callback;
-	callback->await_context = await_iterator->await_context;
+	async_await_context_t * await_context = await_iterator->await_context;
+	callback->await_context = await_context;
 
 	ZVAL_COPY(&callback->key, key);
 
@@ -490,21 +493,26 @@ zend_result await_iterator_handler(async_iterator_t *iterator, zval *current, zv
 	}
 
 	// Add the empty element to the results array if all elements are awaited
-	if (await_iterator->await_context->results != NULL && AWAIT_ALL(await_iterator->await_context)) {
+	if (await_context->results != NULL && AWAIT_ALL(await_context)) {
 		if (Z_TYPE(callback->key) == IS_STRING) {
-			zend_hash_add_empty_element(await_iterator->await_context->results, Z_STR_P(key));
+			zend_hash_add_empty_element(await_context->results, Z_STR_P(key));
 		} else if (Z_TYPE(callback->key) == IS_LONG) {
-			zend_hash_index_add_empty_element(await_iterator->await_context->results, Z_LVAL_P(key));
+			zend_hash_index_add_empty_element(await_context->results, Z_LVAL_P(key));
 		}
-	} else if (await_iterator->await_context->results != NULL && await_iterator->await_context->fill_missing_with_null) {
+	} else if (await_context->results != NULL && await_context->fill_missing_with_null) {
 		if (Z_TYPE(callback->key) == IS_STRING) {
-			zend_hash_add(await_iterator->await_context->results, Z_STR_P(key), &EG(uninitialized_zval));
+			zend_hash_add(await_context->results, Z_STR_P(key), &EG(uninitialized_zval));
 		} else if (Z_TYPE(callback->key) == IS_LONG) {
-			zend_hash_index_add(await_iterator->await_context->results, Z_LVAL_P(key), &EG(uninitialized_zval));
+			zend_hash_index_add(await_context->results, Z_LVAL_P(key), &EG(uninitialized_zval));
 		}
 	}
 
 	zend_async_resume_when(await_iterator->waiting_coroutine, awaitable, false, NULL, &callback->callback);
+	if (UNEXPECTED(EG(exception))) {
+		return FAILURE;
+	}
+
+	await_context->futures_count++;
 
 	return SUCCESS;
 }
@@ -539,7 +547,7 @@ void iterator_coroutine_first_entry(void)
 		await_iterator_handler,
 		ZEND_ASYNC_CURRENT_SCOPE,
 		await_context->concurrency,
-		0,
+		ZEND_COROUTINE_HI_PRIORITY,
 		sizeof(async_await_iterator_iterator_t)
 	);
 
@@ -569,7 +577,7 @@ void iterator_coroutine_finish_callback(
 			exception,
 			false
 		);
-	} else if (ITERATOR_IS_FINISHED(iterator->await_context)) {
+	} else if (AWAIT_ITERATOR_IS_FINISHED(iterator->await_context)) {
 		// If iteration is finished, resume the waiting coroutine
 		ZEND_ASYNC_RESUME(iterator->waiting_coroutine);
 	}
@@ -588,6 +596,9 @@ void async_await_iterator_coroutine_dispose(zend_coroutine_t *coroutine)
 		zend_object_iterator *zend_iterator = iterator->zend_iterator;
 		iterator->zend_iterator = NULL;
 
+		// When the iterator has finished, it’s now possible to specify the exact number of elements since it’s known.
+		iterator->await_context->total = iterator->await_context->futures_count;
+
 		if (zend_iterator->funcs->invalidate_current) {
 			zend_iterator->funcs->invalidate_current(zend_iterator);
 		}
@@ -742,6 +753,7 @@ void async_await_futures(
 
 	await_context = ecalloc(1, sizeof(async_await_context_t));
 	await_context->total = futures != NULL ? (int) zend_hash_num_elements(futures) : 0;
+	await_context->futures_count = 0;
 	await_context->waiting_count = count > 0 ? count : await_context->total;
 	await_context->resolved_count = 0;
 	await_context->success_count = 0;
@@ -833,7 +845,7 @@ void async_await_futures(
 			return;
 		}
 
-		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH(scope);
+		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_HI_PRIORITY);
 
 		if (UNEXPECTED(iterator_coroutine == NULL || EG(exception))) {
 			await_context->dtor(await_context);
diff --git a/async_API.h b/async_API.h
index 6f51da0..e07c6f7 100644
--- a/async_API.h
+++ b/async_API.h
@@ -29,6 +29,9 @@ struct _async_await_context_t
 	unsigned int ref_count;
 	/* The total number of futures to wait for */
 	unsigned int total;
+	/* The current number of futures being awaited.
+	 * This counter is used in the case of a zend_iterator, since the total number of elements is unknown. */
+	unsigned int futures_count;
 	/* The number of futures that are currently waiting */
 	unsigned int waiting_count;
 	/* The number of futures that have been resolved */
diff --git a/tests/await/022-awaitAllWithErrors_iterator.phpt b/tests/await/022-awaitAllWithErrors_iterator.phpt
index 5842368..0a8b643 100644
--- a/tests/await/022-awaitAllWithErrors_iterator.phpt
+++ b/tests/await/022-awaitAllWithErrors_iterator.phpt
@@ -42,15 +42,12 @@ echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         return "success";
     }),
     spawn(function() {
-        delay(20);
         throw new RuntimeException("error");
     }),
     spawn(function() {
-        delay(30);
         return "another success";
     }),
 ];
@@ -58,7 +55,7 @@ $coroutines = [
 $iterator = new TestIterator($coroutines);
 $result = awaitAllWithErrors($iterator);
 
-$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfResults = count($result[0]) == 3 ? "OK" : "FALSE: ".count($result[0]);
 $countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
 
 echo "Count of results: $countOfResults\n";

From 019694e81469fbce6032bf04e8556b0e35be4518 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sat, 5 Jul 2025 23:46:54 +0300
Subject: [PATCH 07/53] #9: * Refactoring of the await iterator. Changes to the
 iterator ownership model.

---
 async_API.c | 150 +++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 126 insertions(+), 24 deletions(-)

diff --git a/async_API.c b/async_API.c
index c21d658..ec6f272 100644
--- a/async_API.c
+++ b/async_API.c
@@ -289,7 +289,13 @@ static zend_always_inline zend_async_event_t * zval_to_event(const zval * curren
 	}
 }
 
-void async_waiting_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event)
+/**
+ * The function is called to release resources for the callback structure.
+ *
+ * @param callback
+ * @param event
+ */
+static void async_waiting_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event)
 {
 	async_await_callback_t * await_callback = (async_await_callback_t *) callback;
 	async_await_context_t * await_context = await_callback->await_context;
@@ -303,7 +309,17 @@ void async_waiting_callback_dispose(zend_async_event_callback_t *callback, zend_
 	await_callback->prev_dispose(callback, event);
 }
 
-void async_waiting_callback(
+/**
+ * This callback is used for awaiting futures.
+ * It is called when the future is resolved or rejected.
+ * It updates the await context and resumes the coroutine if necessary.
+ *
+ * @param event
+ * @param callback
+ * @param result
+ * @param exception
+ */
+static void async_waiting_callback(
 	zend_async_event_t *event,
 	zend_async_event_callback_t *callback,
 	void *result,
@@ -407,7 +423,7 @@ void async_waiting_callback(
  * @param result
  * @param exception
  */
-void async_waiting_cancellation_callback(
+static void async_waiting_cancellation_callback(
 	zend_async_event_t *event,
 	zend_async_event_callback_t *callback,
 	void *result,
@@ -453,7 +469,15 @@ void async_waiting_cancellation_callback(
 	callback->dispose(callback, NULL);
 }
 
-zend_result await_iterator_handler(async_iterator_t *iterator, zval *current, zval *key)
+/**
+ * A function that is called to process a single iteration element.
+ *
+ * @param iterator
+ * @param current
+ * @param key
+ * @return
+ */
+static zend_result await_iterator_handler(async_iterator_t *iterator, zval *current, zval *key)
 {
 	async_await_iterator_t * await_iterator = ((async_await_iterator_iterator_t *) iterator)->await_iterator;
 
@@ -517,7 +541,53 @@ zend_result await_iterator_handler(async_iterator_t *iterator, zval *current, zv
 	return SUCCESS;
 }
 
-void iterator_coroutine_first_entry(void)
+/**
+ * This function is called when the await_iterator is disposed.
+ * It cleans up the internal state and releases resources.
+ *
+ * @param iterator
+ */
+static void await_iterator_dispose(async_await_iterator_t * iterator)
+{
+	if (iterator->zend_iterator != NULL) {
+		zend_object_iterator *zend_iterator = iterator->zend_iterator;
+		iterator->zend_iterator = NULL;
+
+		// When the iterator has finished, it’s now possible to specify the exact number of elements since it’s known.
+		iterator->await_context->total = iterator->await_context->futures_count;
+
+		if (zend_iterator->funcs->invalidate_current) {
+			zend_iterator->funcs->invalidate_current(zend_iterator);
+		}
+		zend_iterator_dtor(zend_iterator);
+	}
+
+	efree(iterator);
+}
+
+/**
+ * This function is called when the internal concurrent iterator is finished.
+ * It disposes of the await_iterator and cleans up the internal state.
+ *
+ * @param internal_iterator
+ */
+static void await_iterator_finish_callback(zend_async_iterator_t *internal_iterator)
+{
+	async_await_iterator_iterator_t * iterator = (async_await_iterator_iterator_t *) internal_iterator;
+
+	async_await_iterator_t * await_iterator = iterator->await_iterator;
+	iterator->await_iterator = NULL;
+
+	await_iterator_dispose(await_iterator);
+}
+
+/**
+ * This function is called when the iterator coroutine is first entered.
+ * It initializes the await_iterator and starts the iteration process.
+ *
+ * @return void
+ */
+static void iterator_coroutine_first_entry(void)
 {
 	zend_coroutine_t *coroutine = ZEND_ASYNC_CURRENT_COROUTINE;
 
@@ -527,6 +597,7 @@ void iterator_coroutine_first_entry(void)
 	}
 
 	async_await_iterator_t * await_iterator = coroutine->extended_data;
+	coroutine->extended_data = NULL;
 
 	ZEND_ASSERT(await_iterator != NULL && "The async_await_iterator_t should not be NULL");
 	if (UNEXPECTED(await_iterator == NULL)) {
@@ -537,6 +608,7 @@ void iterator_coroutine_first_entry(void)
 	async_await_context_t * await_context = await_iterator->await_context;
 
 	if (UNEXPECTED(await_context == NULL)) {
+		await_iterator_dispose(await_iterator);
 		return;
 	}
 
@@ -552,8 +624,10 @@ void iterator_coroutine_first_entry(void)
 	);
 
 	iterator->await_iterator = await_iterator;
+	iterator->iterator.extended_dtor = await_iterator_finish_callback;
 
 	if (UNEXPECTED(iterator == NULL)) {
+		await_iterator_dispose(await_iterator);
 		return;
 	}
 
@@ -561,7 +635,17 @@ void iterator_coroutine_first_entry(void)
 	iterator->iterator.microtask.dtor(&iterator->iterator.microtask);
 }
 
-void iterator_coroutine_finish_callback(
+/**
+ * This callback is triggered when the main iteration coroutine finishes.
+ * It’s needed in case the coroutine gets cancelled.
+ * In that scenario, extended_data will contain the async_await_iterator_t structure.
+ *
+ * @param event
+ * @param callback
+ * @param result
+ * @param exception
+ */
+static void iterator_coroutine_finish_callback(
 	zend_async_event_t *event,
 	zend_async_event_callback_t *callback,
 	void * result,
@@ -583,32 +667,19 @@ void iterator_coroutine_finish_callback(
 	}
 }
 
-void async_await_iterator_coroutine_dispose(zend_coroutine_t *coroutine)
+static void async_await_iterator_coroutine_dispose(zend_coroutine_t *coroutine)
 {
 	if (coroutine == NULL || coroutine->extended_data == NULL) {
 		return;
 	}
 
-	async_await_iterator_t * iterator = (async_await_iterator_t *) coroutine->extended_data;
+	async_await_iterator_t * await_iterator = (async_await_iterator_t *) coroutine->extended_data;
 	coroutine->extended_data = NULL;
 
-	if (iterator->zend_iterator != NULL) {
-		zend_object_iterator *zend_iterator = iterator->zend_iterator;
-		iterator->zend_iterator = NULL;
-
-		// When the iterator has finished, it’s now possible to specify the exact number of elements since it’s known.
-		iterator->await_context->total = iterator->await_context->futures_count;
-
-		if (zend_iterator->funcs->invalidate_current) {
-			zend_iterator->funcs->invalidate_current(zend_iterator);
-		}
-		zend_iterator_dtor(zend_iterator);
-	}
-
-	efree(iterator);
+	await_iterator_dispose(await_iterator);
 }
 
-void await_context_dtor(async_await_context_t *context)
+static void await_context_dtor(async_await_context_t *context)
 {
 	if (context == NULL) {
 		return;
@@ -622,7 +693,7 @@ void await_context_dtor(async_await_context_t *context)
 	efree(context);
 }
 
-void async_cancel_awaited_futures(async_await_context_t * await_context, HashTable *futures)
+static void async_cancel_awaited_futures(async_await_context_t * await_context, HashTable *futures)
 {
 	zend_coroutine_t *this_coroutine = ZEND_ASYNC_CURRENT_COROUTINE;
 
@@ -696,6 +767,22 @@ void async_cancel_awaited_futures(async_await_context_t * await_context, HashTab
 	ZEND_ASYNC_SUSPEND();
 }
 
+/**
+ * This function is used to await multiple futures concurrently.
+ * It takes an iterable of futures, a count of futures to wait for,
+ * and various options for handling results and errors.
+ *
+ * @param iterable The iterable containing futures (array or Traversable object).
+ * @param count The number of futures to wait for (0 means all).
+ * @param ignore_errors Whether to ignore errors in the futures.
+ * @param cancellation Optional cancellation event.
+ * @param timeout Timeout for awaiting futures.
+ * @param concurrency Maximum number of concurrent futures to await.
+ * @param results HashTable to store results.
+ * @param errors HashTable to store errors.
+ * @param fill_missing_with_null Whether to fill missing results with null.
+ * @param cancel_on_exit Whether to cancel awaiting on exit.
+ */
 void async_await_futures(
 	zval *iterable,
 	int count,
@@ -743,11 +830,17 @@ void async_await_futures(
 	zend_coroutine_t *coroutine = ZEND_ASYNC_CURRENT_COROUTINE;
 
 	if (UNEXPECTED(coroutine == NULL)) {
+		if (zend_iterator != NULL) {
+			zend_iterator_dtor(zend_iterator);
+		}
 		async_throw_error("Cannot await futures outside of a coroutine");
 		return;
 	}
 
 	if (UNEXPECTED(zend_async_waker_new_with_timeout(coroutine, timeout, cancellation) == NULL)) {
+		if (zend_iterator != NULL) {
+			zend_iterator_dtor(zend_iterator);
+		}
 		return;
 	}
 
@@ -841,6 +934,7 @@ void async_await_futures(
 		zend_async_scope_t * scope = ZEND_ASYNC_NEW_SCOPE(ZEND_ASYNC_CURRENT_SCOPE);
 
 		if (UNEXPECTED(scope == NULL || EG(exception))) {
+			zend_iterator_dtor(zend_iterator);
 			await_context->dtor(await_context);
 			return;
 		}
@@ -848,7 +942,9 @@ void async_await_futures(
 		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_HI_PRIORITY);
 
 		if (UNEXPECTED(iterator_coroutine == NULL || EG(exception))) {
+			zend_iterator_dtor(zend_iterator);
 			await_context->dtor(await_context);
+			scope->try_to_dispose(scope);
 			return;
 		}
 
@@ -867,6 +963,12 @@ void async_await_futures(
 		zend_async_resume_when(
 			coroutine, &iterator_coroutine->event, false, iterator_coroutine_finish_callback, NULL
 		);
+
+		if (UNEXPECTED(EG(exception))) {
+			// At this point, we don’t free the iterator
+			// because it now belongs to the coroutine and must be destroyed there.
+			return;
+		}
 	}
 
 	ZEND_ASYNC_SUSPEND();

From 4485089fea4ce01e7cb4b3a3186d6c29a1a5f24a Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 11:13:15 +0300
Subject: [PATCH 08/53] #9: * Refactoring of the await iterator.

---
 async.c                                       | 12 +++--
 async.stub.php                                |  2 +-
 async_API.c                                   | 47 ++++++++++---------
 async_arginfo.h                               |  9 ++--
 tests/await/008-awaitFirstSuccess_basic.phpt  |  5 +-
 tests/await/010-awaitAll_basic.phpt           |  3 --
 tests/await/012-awaitAllWithErrors_basic.phpt |  4 +-
 .../013-awaitAllWithErrors_all_success.phpt   |  3 --
 .../022-awaitAllWithErrors_iterator.phpt      | 25 +++++-----
 tests/await/023-awaitAnyOf_iterator.phpt      | 22 ++-------
 .../024-awaitAnyOfWithErrors_iterator.phpt    | 22 +++------
 tests/await/025-awaitAll_generator.phpt       |  4 --
 tests/await/026-awaitAny_generator.phpt       |  6 +--
 .../027-awaitFirstSuccess_generator.phpt      |  4 --
 .../028-awaitAllWithErrors_generator.phpt     |  6 +--
 tests/await/029-awaitAnyOf_generator.phpt     |  5 --
 tests/await/034-awaitAll_fillNull.phpt        |  4 --
 .../035-awaitAllWithErrors_fillNull.phpt      |  4 --
 .../036-awaitAll_cancellation_timeout.phpt    |  7 ++-
 .../037-awaitAny_cancellation_timeout.phpt    |  6 +--
 ...waitFirstSuccess_cancellation_timeout.phpt |  5 +-
 .../039-awaitAnyOf_cancellation_timeout.phpt  |  8 ++--
 22 files changed, 82 insertions(+), 131 deletions(-)

diff --git a/async.c b/async.c
index b19a85f..85e9ed9 100644
--- a/async.c
+++ b/async.c
@@ -418,8 +418,10 @@ PHP_FUNCTION(Async_awaitAll)
 		0,
 		results,
 		NULL,
-		false,
-		false
+		// For awaitAll, it’s always necessary to fill the result with NULL,
+		// because the order of keys matters.
+		true,
+		true
 		);
 
 	if (EG(exception)) {
@@ -434,11 +436,13 @@ PHP_FUNCTION(Async_awaitAllWithErrors)
 {
 	zval * futures;
 	zend_object * cancellation = NULL;
+	bool fill_null = false;
 
-	ZEND_PARSE_PARAMETERS_START(1, 2)
+	ZEND_PARSE_PARAMETERS_START(1, 3)
 		Z_PARAM_ZVAL(futures);
 		Z_PARAM_OPTIONAL
 		Z_PARAM_OBJ_OF_CLASS_OR_NULL(cancellation, async_ce_awaitable);
+		Z_PARAM_BOOL(fill_null);
 	ZEND_PARSE_PARAMETERS_END();
 
 	SCHEDULER_LAUNCH;
@@ -454,7 +458,7 @@ PHP_FUNCTION(Async_awaitAllWithErrors)
 		0,
 		results,
 		errors,
-		false,
+		fill_null,
 		true
 		);
 
diff --git a/async.stub.php b/async.stub.php
index 46b70b4..6dfea5d 100644
--- a/async.stub.php
+++ b/async.stub.php
@@ -41,7 +41,7 @@ function awaitAny(iterable $triggers, ?Awaitable $cancellation = null): mixed {}
 
 function awaitFirstSuccess(iterable $triggers, ?Awaitable $cancellation = null): mixed {}
 
-function awaitAll(iterable $triggers, ?Awaitable $cancellation = null, bool $fillNull = false): array {}
+function awaitAll(iterable $triggers, ?Awaitable $cancellation = null): array {}
 
 function awaitAllWithErrors(iterable $triggers, ?Awaitable $cancellation = null, bool $fillNull = false): array {}
 
diff --git a/async_API.c b/async_API.c
index ec6f272..c371cc0 100644
--- a/async_API.c
+++ b/async_API.c
@@ -517,17 +517,20 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 	}
 
 	// Add the empty element to the results array if all elements are awaited
-	if (await_context->results != NULL && AWAIT_ALL(await_context)) {
+	if (await_context->results != NULL && await_context->fill_missing_with_null) {
 		if (Z_TYPE(callback->key) == IS_STRING) {
 			zend_hash_add_empty_element(await_context->results, Z_STR_P(key));
 		} else if (Z_TYPE(callback->key) == IS_LONG) {
 			zend_hash_index_add_empty_element(await_context->results, Z_LVAL_P(key));
 		}
-	} else if (await_context->results != NULL && await_context->fill_missing_with_null) {
+	} else if (await_context->results != NULL) {
+		zval undef_val;
+		// The PRT NULL type is used to fill the array with empty elements that will later be removed.
+		ZVAL_PTR(&undef_val, NULL);
 		if (Z_TYPE(callback->key) == IS_STRING) {
-			zend_hash_add(await_context->results, Z_STR_P(key), &EG(uninitialized_zval));
+			zend_hash_add(await_context->results, Z_STR_P(key), &undef_val);
 		} else if (Z_TYPE(callback->key) == IS_LONG) {
-			zend_hash_index_add(await_context->results, Z_LVAL_P(key), &EG(uninitialized_zval));
+			zend_hash_index_add(await_context->results, Z_LVAL_P(key), &undef_val);
 		}
 	}
 
@@ -619,7 +622,7 @@ static void iterator_coroutine_first_entry(void)
 		await_iterator_handler,
 		ZEND_ASYNC_CURRENT_SCOPE,
 		await_context->concurrency,
-		ZEND_COROUTINE_HI_PRIORITY,
+		ZEND_COROUTINE_NORMAL,
 		sizeof(async_await_iterator_iterator_t)
 	);
 
@@ -654,6 +657,10 @@ static void iterator_coroutine_finish_callback(
 {
 	async_await_iterator_t * iterator = (async_await_iterator_t *) ((zend_coroutine_t*) event)->extended_data;
 
+	if (iterator == NULL) {
+		return;
+	}
+
 	if (exception != NULL) {
 		// Resume the waiting coroutine with the exception
 		ZEND_ASYNC_RESUME_WITH_ERROR(
@@ -855,7 +862,7 @@ void async_await_futures(
 	await_context->fill_missing_with_null = fill_missing_with_null;
 	await_context->cancel_on_exit = cancel_on_exit;
 
-	if (AWAIT_ALL(await_context)) {
+	if (false == fill_missing_with_null && AWAIT_ALL(await_context)) {
 		tmp_results = zend_new_array(await_context->total);
 		await_context->results = tmp_results;
 	} else {
@@ -868,6 +875,10 @@ void async_await_futures(
 
 	if (futures != NULL)
 	{
+		zval undef_val;
+		// The PRT NULL type is used to fill the array with empty elements that will later be removed.
+		ZVAL_PTR(&undef_val, NULL);
+
 		ZEND_HASH_FOREACH_KEY_VAL(futures, index, key, current) {
 
 			// An array element can be either an object implementing
@@ -896,19 +907,19 @@ void async_await_futures(
 				ZVAL_STR(&callback->key, key);
 				zval_add_ref(&callback->key);
 
-				if (await_context->results != NULL && AWAIT_ALL(await_context)) {
+				if (await_context->results != NULL && await_context->fill_missing_with_null) {
 					zend_hash_add_empty_element(await_context->results, key);
-				} else if (await_context->results != NULL && await_context->fill_missing_with_null) {
-					zend_hash_add(await_context->results, key, &EG(uninitialized_zval));
+				} else if (await_context->results != NULL) {
+					zend_hash_add(await_context->results, key, &undef_val);
 				}
 
 			} else {
 				ZVAL_LONG(&callback->key, index);
 
-				if (await_context->results != NULL && AWAIT_ALL(await_context)) {
+				if (await_context->results != NULL && await_context->fill_missing_with_null) {
 					zend_hash_index_add_empty_element(await_context->results, index);
-				} else if (await_context->results != NULL && await_context->fill_missing_with_null) {
-					zend_hash_index_add_new(await_context->results, index, &EG(uninitialized_zval));
+				} else if (await_context->results != NULL) {
+					zend_hash_index_add_new(await_context->results, index, &undef_val);
 				}
 			}
 
@@ -939,7 +950,7 @@ void async_await_futures(
 			return;
 		}
 
-		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_HI_PRIORITY);
+		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH(scope);
 
 		if (UNEXPECTED(iterator_coroutine == NULL || EG(exception))) {
 			zend_iterator_dtor(zend_iterator);
@@ -979,19 +990,13 @@ void async_await_futures(
 		async_cancel_awaited_futures(await_context, futures);
 	}
 
-	// Free the coroutine scope if it was created for the iterator.
-	if (await_context->scope != NULL) {
-		await_context->scope->try_to_dispose(await_context->scope);
-		await_context->scope = NULL;
-	}
-
 	// Remove all undefined buckets from the results array.
 	if (tmp_results != NULL) {
 
 		// foreach results as key => value
-		// if value is UNDEFINED then continue
+		// if value is PTR then continue
 		ZEND_HASH_FOREACH_KEY_VAL(tmp_results, index, key, current) {
-			if (Z_TYPE_P(current) == IS_UNDEF) {
+			if (Z_TYPE_P(current) == IS_PTR && Z_PTR_P(current) == NULL) {
 				continue;
 			}
 
diff --git a/async_arginfo.h b/async_arginfo.h
index 3ad2941..9d77326 100644
--- a/async_arginfo.h
+++ b/async_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: b989a1b584dc4bcf2a4adab7210e04f1f157c75a */
+ * Stub hash: ef01d9f96265b69994243546da607085160afde4 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Async_spawn, 0, 1, Async\\Coroutine, 0)
 	ZEND_ARG_TYPE_INFO(0, task, IS_CALLABLE, 0)
@@ -34,10 +34,13 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAll, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
 	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, fillNull, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
-#define arginfo_Async_awaitAllWithErrors arginfo_Async_awaitAll
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAllWithErrors, 0, 1, IS_ARRAY, 0)
+	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
+	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, fillNull, _IS_BOOL, 0, "false")
+ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAnyOf, 0, 2, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
diff --git a/tests/await/008-awaitFirstSuccess_basic.phpt b/tests/await/008-awaitFirstSuccess_basic.phpt
index cbcb032..9dfbdc6 100644
--- a/tests/await/008-awaitFirstSuccess_basic.phpt
+++ b/tests/await/008-awaitFirstSuccess_basic.phpt
@@ -11,15 +11,14 @@ echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(10);
+        suspend();
         throw new RuntimeException("first error");
     }),
     spawn(function() {
-        delay(20);
         return "success";
     }),
     spawn(function() {
-        delay(30);
+        suspend();
         return "another success";
     }),
 ];
diff --git a/tests/await/010-awaitAll_basic.phpt b/tests/await/010-awaitAll_basic.phpt
index 06e9777..69b7fa3 100644
--- a/tests/await/010-awaitAll_basic.phpt
+++ b/tests/await/010-awaitAll_basic.phpt
@@ -11,15 +11,12 @@ echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         return "second";
     }),
     spawn(function() {
-        delay(30);
         return "third";
     }),
 ];
diff --git a/tests/await/012-awaitAllWithErrors_basic.phpt b/tests/await/012-awaitAllWithErrors_basic.phpt
index 8a796aa..a86232e 100644
--- a/tests/await/012-awaitAllWithErrors_basic.phpt
+++ b/tests/await/012-awaitAllWithErrors_basic.phpt
@@ -33,11 +33,9 @@ echo "end\n";
 start
 array(2) {
   [0]=>
-  array(3) {
+  array(2) {
     [0]=>
     string(5) "first"
-    [1]=>
-    NULL
     [2]=>
     string(5) "third"
   }
diff --git a/tests/await/013-awaitAllWithErrors_all_success.phpt b/tests/await/013-awaitAllWithErrors_all_success.phpt
index 6cff6ba..acfbe1a 100644
--- a/tests/await/013-awaitAllWithErrors_all_success.phpt
+++ b/tests/await/013-awaitAllWithErrors_all_success.phpt
@@ -11,15 +11,12 @@ echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         return "second";
     }),
     spawn(function() {
-        delay(30);
         return "third";
     }),
 ];
diff --git a/tests/await/022-awaitAllWithErrors_iterator.phpt b/tests/await/022-awaitAllWithErrors_iterator.phpt
index 0a8b643..0e4d82c 100644
--- a/tests/await/022-awaitAllWithErrors_iterator.phpt
+++ b/tests/await/022-awaitAllWithErrors_iterator.phpt
@@ -22,7 +22,9 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -40,22 +42,19 @@ class TestIterator implements Iterator
 
 echo "start\n";
 
-$coroutines = [
-    spawn(function() {
-        return "success";
-    }),
-    spawn(function() {
-        throw new RuntimeException("error");
-    }),
-    spawn(function() {
-        return "another success";
-    }),
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn’t have a chance to capture them.
+$functions = [
+    fn() => "success",
+    fn() => throw new RuntimeException("error"),
+    fn() => "another success",
 ];
 
-$iterator = new TestIterator($coroutines);
+$iterator = new TestIterator($functions);
 $result = awaitAllWithErrors($iterator);
 
-$countOfResults = count($result[0]) == 3 ? "OK" : "FALSE: ".count($result[0]);
+$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
 $countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
 
 echo "Count of results: $countOfResults\n";
diff --git a/tests/await/023-awaitAnyOf_iterator.phpt b/tests/await/023-awaitAnyOf_iterator.phpt
index fca7794..ae20bf6 100644
--- a/tests/await/023-awaitAnyOf_iterator.phpt
+++ b/tests/await/023-awaitAnyOf_iterator.phpt
@@ -22,7 +22,7 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -41,22 +41,10 @@ class TestIterator implements Iterator
 echo "start\n";
 
 $coroutines = [
-    spawn(function() {
-        delay(10);
-        return "first";
-    }),
-    spawn(function() {
-        delay(20);
-        return "second";
-    }),
-    spawn(function() {
-        delay(30);
-        return "third";
-    }),
-    spawn(function() {
-        delay(40);
-        return "fourth";
-    }),
+    fn() => "first",
+    fn() => "second",
+    fn() => "third",
+    fn() => "fourth",
 ];
 
 $iterator = new TestIterator($coroutines);
diff --git a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
index 7075d7a..bc1a8ef 100644
--- a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
+++ b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
@@ -22,7 +22,7 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -41,22 +41,12 @@ class TestIterator implements Iterator
 echo "start\n";
 
 $coroutines = [
-    spawn(function() {
-        delay(10);
-        return "first";
-    }),
-    spawn(function() {
-        delay(20);
+    fn() => "first",
+    function() {
         throw new RuntimeException("error");
-    }),
-    spawn(function() {
-        delay(30);
-        return "third";
-    }),
-    spawn(function() {
-        delay(40);
-        return "fourth";
-    }),
+    },
+    fn() => "third",
+    fn() => "fourth",
 ];
 
 $iterator = new TestIterator($coroutines);
diff --git a/tests/await/025-awaitAll_generator.phpt b/tests/await/025-awaitAll_generator.phpt
index 90794e0..3d82832 100644
--- a/tests/await/025-awaitAll_generator.phpt
+++ b/tests/await/025-awaitAll_generator.phpt
@@ -6,21 +6,17 @@ awaitAll() - with Generator
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(10);
         return "first";
     });
     
     yield spawn(function() {
-        delay(20);
         return "second";
     });
     
     yield spawn(function() {
-        delay(30);
         return "third";
     });
 }
diff --git a/tests/await/026-awaitAny_generator.phpt b/tests/await/026-awaitAny_generator.phpt
index 1cfe288..03981ae 100644
--- a/tests/await/026-awaitAny_generator.phpt
+++ b/tests/await/026-awaitAny_generator.phpt
@@ -6,21 +6,19 @@ awaitAny() - with Generator
 use function Async\spawn;
 use function Async\awaitAny;
 use function Async\await;
-use function Async\delay;
+use function Async\suspend;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(50);
+        suspend();
         return "slow";
     });
     
     yield spawn(function() {
-        delay(10);
         return "fast";
     });
     
     yield spawn(function() {
-        delay(30);
         return "medium";
     });
 }
diff --git a/tests/await/027-awaitFirstSuccess_generator.phpt b/tests/await/027-awaitFirstSuccess_generator.phpt
index f4a9f1c..7659c03 100644
--- a/tests/await/027-awaitFirstSuccess_generator.phpt
+++ b/tests/await/027-awaitFirstSuccess_generator.phpt
@@ -6,21 +6,17 @@ awaitFirstSuccess() - with Generator
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
 use function Async\await;
-use function Async\delay;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(10);
         throw new RuntimeException("error");
     });
     
     yield spawn(function() {
-        delay(20);
         return "success";
     });
     
     yield spawn(function() {
-        delay(30);
         return "another success";
     });
 }
diff --git a/tests/await/028-awaitAllWithErrors_generator.phpt b/tests/await/028-awaitAllWithErrors_generator.phpt
index 74d6539..9afcdc7 100644
--- a/tests/await/028-awaitAllWithErrors_generator.phpt
+++ b/tests/await/028-awaitAllWithErrors_generator.phpt
@@ -6,21 +6,17 @@ awaitAllWithErrors() - with Generator
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
 use function Async\await;
-use function Async\delay;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(10);
         return "success";
     });
     
     yield spawn(function() {
-        delay(20);
         throw new RuntimeException("error");
     });
     
     yield spawn(function() {
-        delay(30);
         return "another success";
     });
 }
@@ -30,7 +26,7 @@ echo "start\n";
 $generator = createCoroutines();
 $result = awaitAllWithErrors($generator);
 
-$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
+$countOfResults = count($result[0]) == 3 ? "OK" : "FALSE: ".count($result[0]);
 $countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
 
 echo "Count of results: $countOfResults\n";
diff --git a/tests/await/029-awaitAnyOf_generator.phpt b/tests/await/029-awaitAnyOf_generator.phpt
index 1e6b389..8abdba7 100644
--- a/tests/await/029-awaitAnyOf_generator.phpt
+++ b/tests/await/029-awaitAnyOf_generator.phpt
@@ -6,26 +6,21 @@ awaitAnyOf() - with Generator
 use function Async\spawn;
 use function Async\awaitAnyOf;
 use function Async\await;
-use function Async\delay;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(10);
         return "first";
     });
     
     yield spawn(function() {
-        delay(20);
         return "second";
     });
     
     yield spawn(function() {
-        delay(30);
         return "third";
     });
     
     yield spawn(function() {
-        delay(40);
         return "fourth";
     });
 }
diff --git a/tests/await/034-awaitAll_fillNull.phpt b/tests/await/034-awaitAll_fillNull.phpt
index 98c382c..1ad803e 100644
--- a/tests/await/034-awaitAll_fillNull.phpt
+++ b/tests/await/034-awaitAll_fillNull.phpt
@@ -6,21 +6,17 @@ awaitAll() - with fillNull parameter
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         return "success";
     }),
     
     spawn(function() {
-        delay(20);
         throw new RuntimeException("error");
     }),
     
     spawn(function() {
-        delay(30);
         return "another success";
     })
 ];
diff --git a/tests/await/035-awaitAllWithErrors_fillNull.phpt b/tests/await/035-awaitAllWithErrors_fillNull.phpt
index 2a67232..67c8652 100644
--- a/tests/await/035-awaitAllWithErrors_fillNull.phpt
+++ b/tests/await/035-awaitAllWithErrors_fillNull.phpt
@@ -6,21 +6,17 @@ awaitAllWithErrors() - with fillNull parameter
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         return "success";
     }),
     
     spawn(function() {
-        delay(20);
         throw new RuntimeException("error");
     }),
     
     spawn(function() {
-        delay(30);
         return "another success";
     })
 ];
diff --git a/tests/await/036-awaitAll_cancellation_timeout.phpt b/tests/await/036-awaitAll_cancellation_timeout.phpt
index 728195e..aae91b7 100644
--- a/tests/await/036-awaitAll_cancellation_timeout.phpt
+++ b/tests/await/036-awaitAll_cancellation_timeout.phpt
@@ -11,17 +11,16 @@ use function Async\timeout;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         return "fast";
     }),
     
     spawn(function() {
-        delay(100); // This will be cancelled
+        delay(10); // This will be cancelled
         return "slow";
     }),
     
     spawn(function() {
-        delay(200); // This will also be cancelled
+        delay(10); // This will also be cancelled
         return "very slow";
     })
 ];
@@ -29,7 +28,7 @@ $coroutines = [
 echo "start\n";
 
 try {
-    $results = awaitAll($coroutines, timeout(50));
+    $results = awaitAll($coroutines, timeout(1));
     echo "Unexpected success\n";
 } catch (Async\TimeoutException $e) {
     echo "Timeout caught as expected\n";
diff --git a/tests/await/037-awaitAny_cancellation_timeout.phpt b/tests/await/037-awaitAny_cancellation_timeout.phpt
index 1831285..6228834 100644
--- a/tests/await/037-awaitAny_cancellation_timeout.phpt
+++ b/tests/await/037-awaitAny_cancellation_timeout.phpt
@@ -11,12 +11,12 @@ use function Async\timeout;
 
 $coroutines = [
     spawn(function() {
-        delay(100); // Will be cancelled
+        delay(10); // Will be cancelled
         return "slow";
     }),
     
     spawn(function() {
-        delay(200); // Will be cancelled
+        delay(10); // Will be cancelled
         return "very slow";
     })
 ];
@@ -24,7 +24,7 @@ $coroutines = [
 echo "start\n";
 
 try {
-    $result = awaitAny($coroutines, timeout(50));
+    $result = awaitAny($coroutines, timeout(1));
     echo "Unexpected success: $result\n";
 } catch (Async\TimeoutException $e) {
     echo "Timeout caught as expected\n";
diff --git a/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt b/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
index a1bfe34..489e6f5 100644
--- a/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
+++ b/tests/await/038-awaitFirstSuccess_cancellation_timeout.phpt
@@ -11,12 +11,11 @@ use function Async\timeout;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         throw new RuntimeException("fast error");
     }),
     
     spawn(function() {
-        delay(100); // Will be cancelled before success
+        delay(10); // Will be cancelled before success
         return "success";
     })
 ];
@@ -24,7 +23,7 @@ $coroutines = [
 echo "start\n";
 
 try {
-    $result = awaitFirstSuccess($coroutines, timeout(50));
+    $result = awaitFirstSuccess($coroutines, timeout(1));
     echo "Unexpected success\n";
 } catch (Async\TimeoutException $e) {
     echo "Timeout caught as expected\n";
diff --git a/tests/await/039-awaitAnyOf_cancellation_timeout.phpt b/tests/await/039-awaitAnyOf_cancellation_timeout.phpt
index 23b4947..ff76e07 100644
--- a/tests/await/039-awaitAnyOf_cancellation_timeout.phpt
+++ b/tests/await/039-awaitAnyOf_cancellation_timeout.phpt
@@ -11,17 +11,17 @@ use function Async\timeout;
 
 $coroutines = [
     spawn(function() {
-        delay(100); // Will be cancelled
+        delay(10); // Will be cancelled
         return "slow";
     }),
     
     spawn(function() {
-        delay(200); // Will be cancelled
+        delay(10); // Will be cancelled
         return "very slow";
     }),
     
     spawn(function() {
-        delay(300); // Will be cancelled
+        delay(10); // Will be cancelled
         return "extremely slow";
     })
 ];
@@ -29,7 +29,7 @@ $coroutines = [
 echo "start\n";
 
 try {
-    $results = awaitAnyOf(2, $coroutines, timeout(50));
+    $results = awaitAnyOf(2, $coroutines, timeout(1));
     echo "Unexpected success\n";
 } catch (Async\TimeoutException $e) {
     echo "Timeout caught as expected\n";

From fdd3d89915a9a7c89d6e0b5ad741eea5c15ecb7a Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 12:44:52 +0300
Subject: [PATCH 09/53] #9: * Refactoring of the await iterator.

---
 CHANGELOG.md                                  |  5 ++
 async.c                                       | 26 ++++++++--
 async.stub.php                                |  8 +--
 async_API.c                                   | 23 ++++++---
 async_API.h                                   |  3 ++
 async_arginfo.h                               | 13 ++++-
 tests/await/005-awaitAny_basic.phpt           |  6 +--
 tests/await/007-awaitAny_exception.phpt       |  4 +-
 tests/await/008-awaitFirstSuccess_basic.phpt  |  2 +-
 .../009-awaitFirstSuccess_all_errors.phpt     |  3 --
 tests/await/010-awaitAll_basic.phpt           |  1 -
 tests/await/011-awaitAll_exception.phpt       |  4 --
 tests/await/012-awaitAllWithErrors_basic.phpt |  4 --
 .../013-awaitAllWithErrors_all_success.phpt   |  1 -
 tests/await/014-awaitAnyOf_basic.phpt         |  5 --
 tests/await/015-awaitAnyOf_count_zero.phpt    |  3 --
 .../await/016-awaitAnyOfWithErrors_basic.phpt |  7 +--
 .../017-awaitAnyOfWithErrors_all_success.phpt |  4 --
 tests/await/018-awaitAll_double_free.phpt     |  4 +-
 tests/await/019-awaitAll_iterator.phpt        | 27 ++++------
 tests/await/020-awaitAny_iterator.phpt        | 29 ++++++-----
 .../await/021-awaitFirstSuccess_iterator.phpt | 27 ++++------
 .../022-awaitAllWithErrors_iterator.phpt      |  1 -
 tests/await/023-awaitAnyOf_iterator.phpt      |  1 -
 .../024-awaitAnyOfWithErrors_iterator.phpt    |  5 +-
 .../028-awaitAllWithErrors_generator.phpt     |  2 +-
 .../030-awaitAnyOfWithErrors_generator.phpt   |  4 --
 tests/await/031-awaitAll_arrayobject.phpt     | 24 +++------
 tests/await/032-awaitAny_arrayobject.phpt     | 29 +++++------
 .../033-awaitFirstSuccess_arrayobject.phpt    | 28 ++++-------
 tests/await/034-awaitAll_fillNull.phpt        | 46 -----------------
 .../034-awaitAll_preserve_key_order.phpt      | 50 +++++++++++++++++++
 .../035-awaitAllWithErrors_fillNull.phpt      |  2 +-
 .../await/041-awaitAll_associative_array.phpt |  4 --
 ...-awaitAllWithErrors_associative_array.phpt |  4 --
 .../043-awaitAnyOf_associative_array.phpt     |  5 --
 tests/await/044-awaitAll_empty_iterable.phpt  |  1 -
 tests/await/045-awaitAnyOf_edge_cases.phpt    |  3 --
 .../046-awaitFirstSuccess_all_errors.phpt     |  4 --
 39 files changed, 189 insertions(+), 233 deletions(-)
 delete mode 100644 tests/await/034-awaitAll_fillNull.phpt
 create mode 100644 tests/await/034-awaitAll_preserve_key_order.phpt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 55879d8..3cadf50 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     - GC support for finally handlers, exception handlers, and function call parameters
     - GC tracking for waker events, internal context, and nested async structures
     - Prevents memory leaks in complex async applications with circular references
+- **Key Order Preservation**: Added `preserveKeyOrder` parameter to async await functions
+    - Added `preserve_key_order` parameter to `async_await_futures()` API function
+    - Added `preserve_key_order` field to `async_await_context_t` structure
+    - Enhanced `awaitAll()`, `awaitAllWithErrors()`, `awaitAnyOf()`, and `awaitAnyOfWithErrors()` functions with `preserveKeyOrder` parameter (defaults to `true`)
+    - Allows controlling whether the original key order is maintained in result arrays
 
 ### Fixed
 - Memory management improvements for long-running async applications
diff --git a/async.c b/async.c
index 85e9ed9..04e05fa 100644
--- a/async.c
+++ b/async.c
@@ -317,6 +317,7 @@ PHP_FUNCTION(Async_awaitAny)
 		results,
 		NULL,
 		false,
+		false,
 		false
 	);
 
@@ -366,6 +367,7 @@ PHP_FUNCTION(Async_awaitFirstSuccess)
 		results,
 		errors,
 		false,
+		false,
 		true
 	);
 
@@ -399,11 +401,13 @@ PHP_FUNCTION(Async_awaitAll)
 {
 	zval * futures;
 	zend_object * cancellation = NULL;
+	bool preserve_key_order = true;
 
-	ZEND_PARSE_PARAMETERS_START(1, 2)
+	ZEND_PARSE_PARAMETERS_START(1, 3)
 		Z_PARAM_ZVAL(futures);
 		Z_PARAM_OPTIONAL
 		Z_PARAM_OBJ_OF_CLASS_OR_NULL(cancellation, async_ce_awaitable);
+		Z_PARAM_BOOL(preserve_key_order);
 	ZEND_PARSE_PARAMETERS_END();
 
 	SCHEDULER_LAUNCH;
@@ -421,6 +425,7 @@ PHP_FUNCTION(Async_awaitAll)
 		// For awaitAll, it’s always necessary to fill the result with NULL,
 		// because the order of keys matters.
 		true,
+		preserve_key_order,
 		true
 		);
 
@@ -436,12 +441,14 @@ PHP_FUNCTION(Async_awaitAllWithErrors)
 {
 	zval * futures;
 	zend_object * cancellation = NULL;
+	bool preserve_key_order = true;
 	bool fill_null = false;
 
-	ZEND_PARSE_PARAMETERS_START(1, 3)
+	ZEND_PARSE_PARAMETERS_START(1, 4)
 		Z_PARAM_ZVAL(futures);
 		Z_PARAM_OPTIONAL
 		Z_PARAM_OBJ_OF_CLASS_OR_NULL(cancellation, async_ce_awaitable);
+		Z_PARAM_BOOL(preserve_key_order);
 		Z_PARAM_BOOL(fill_null);
 	ZEND_PARSE_PARAMETERS_END();
 
@@ -459,6 +466,7 @@ PHP_FUNCTION(Async_awaitAllWithErrors)
 		results,
 		errors,
 		fill_null,
+		preserve_key_order,
 		true
 		);
 
@@ -485,12 +493,14 @@ PHP_FUNCTION(Async_awaitAnyOf)
 	zval * futures;
 	zend_object * cancellation = NULL;
 	zend_long count = 0;
+	bool preserve_key_order = true;
 
-	ZEND_PARSE_PARAMETERS_START(2, 3)
+	ZEND_PARSE_PARAMETERS_START(2, 4)
 		Z_PARAM_LONG(count)
 		Z_PARAM_ITERABLE(futures);
 		Z_PARAM_OPTIONAL
 		Z_PARAM_OBJ_OF_CLASS_OR_NULL(cancellation, async_ce_awaitable);
+		Z_PARAM_BOOL(preserve_key_order);
 	ZEND_PARSE_PARAMETERS_END();
 
 	SCHEDULER_LAUNCH;
@@ -510,6 +520,7 @@ PHP_FUNCTION(Async_awaitAnyOf)
 		results,
 		NULL,
 		false,
+		preserve_key_order,
 		false
 		);
 
@@ -526,12 +537,16 @@ PHP_FUNCTION(Async_awaitAnyOfWithErrors)
 	zval * futures;
 	zend_object * cancellation = NULL;
 	zend_long count = 0;
+	bool preserve_key_order = true;
+	bool fill_null = false;
 
-	ZEND_PARSE_PARAMETERS_START(2, 3)
+	ZEND_PARSE_PARAMETERS_START(2, 5)
 		Z_PARAM_LONG(count)
 		Z_PARAM_ZVAL(futures);
 		Z_PARAM_OPTIONAL
 		Z_PARAM_OBJ_OF_CLASS_OR_NULL(cancellation, async_ce_awaitable);
+		Z_PARAM_BOOL(preserve_key_order);
+		Z_PARAM_BOOL(fill_null);
 	ZEND_PARSE_PARAMETERS_END();
 
 	HashTable * results = zend_new_array(8);
@@ -547,7 +562,8 @@ PHP_FUNCTION(Async_awaitAnyOfWithErrors)
 		0,
 		results,
 		errors,
-		false,
+		fill_null,
+		preserve_key_order,
 		true
 		);
 
diff --git a/async.stub.php b/async.stub.php
index 6dfea5d..554fea5 100644
--- a/async.stub.php
+++ b/async.stub.php
@@ -41,13 +41,13 @@ function awaitAny(iterable $triggers, ?Awaitable $cancellation = null): mixed {}
 
 function awaitFirstSuccess(iterable $triggers, ?Awaitable $cancellation = null): mixed {}
 
-function awaitAll(iterable $triggers, ?Awaitable $cancellation = null): array {}
+function awaitAll(iterable $triggers, ?Awaitable $cancellation = null, bool $preserveKeyOrder = true): array {}
 
-function awaitAllWithErrors(iterable $triggers, ?Awaitable $cancellation = null, bool $fillNull = false): array {}
+function awaitAllWithErrors(iterable $triggers, ?Awaitable $cancellation = null, bool $preserveKeyOrder = true, bool $fillNull = false): array {}
 
-function awaitAnyOf(int $count, iterable $triggers, ?Awaitable $cancellation = null): array {}
+function awaitAnyOf(int $count, iterable $triggers, ?Awaitable $cancellation = null, bool $preserveKeyOrder = true): array {}
 
-function awaitAnyOfWithErrors(int $count, iterable $triggers, ?Awaitable $cancellation = null): array {}
+function awaitAnyOfWithErrors(int $count, iterable $triggers, ?Awaitable $cancellation = null, bool $preserveKeyOrder= true, bool $fillNull = false): array {}
 
 function delay(int $ms): void {}
 
diff --git a/async_API.c b/async_API.c
index c371cc0..0516f3c 100644
--- a/async_API.c
+++ b/async_API.c
@@ -523,7 +523,7 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		} else if (Z_TYPE(callback->key) == IS_LONG) {
 			zend_hash_index_add_empty_element(await_context->results, Z_LVAL_P(key));
 		}
-	} else if (await_context->results != NULL) {
+	} else if (await_context->results != NULL && await_context->preserve_key_order) {
 		zval undef_val;
 		// The PRT NULL type is used to fill the array with empty elements that will later be removed.
 		ZVAL_PTR(&undef_val, NULL);
@@ -559,6 +559,14 @@ static void await_iterator_dispose(async_await_iterator_t * iterator)
 		// When the iterator has finished, it’s now possible to specify the exact number of elements since it’s known.
 		iterator->await_context->total = iterator->await_context->futures_count;
 
+		// Scenario: the iterator has already finished, and there’s nothing left to await.
+		// In that case, the coroutine needs to be terminated.
+		if ((AWAIT_ITERATOR_IS_FINISHED(iterator->await_context) || iterator->await_context->total == 0)
+			&& iterator->waiting_coroutine != NULL
+			&& false == ZEND_ASYNC_WAKER_IN_QUEUE(iterator->waiting_coroutine->waker)) {
+			ZEND_ASYNC_RESUME(iterator->waiting_coroutine);
+		}
+
 		if (zend_iterator->funcs->invalidate_current) {
 			zend_iterator->funcs->invalidate_current(zend_iterator);
 		}
@@ -788,6 +796,7 @@ static void async_cancel_awaited_futures(async_await_context_t * await_context,
  * @param results HashTable to store results.
  * @param errors HashTable to store errors.
  * @param fill_missing_with_null Whether to fill missing results with null.
+ * @param preserve_key_order Whether to preserve the order of keys in results.
  * @param cancel_on_exit Whether to cancel awaiting on exit.
  */
 void async_await_futures(
@@ -800,6 +809,7 @@ void async_await_futures(
 	HashTable *results,
 	HashTable *errors,
 	bool fill_missing_with_null,
+	bool preserve_key_order,
 	bool cancel_on_exit
 )
 {
@@ -860,9 +870,10 @@ void async_await_futures(
 	await_context->ignore_errors = ignore_errors;
 	await_context->concurrency = concurrency;
 	await_context->fill_missing_with_null = fill_missing_with_null;
+	await_context->preserve_key_order = preserve_key_order;
 	await_context->cancel_on_exit = cancel_on_exit;
 
-	if (false == fill_missing_with_null && AWAIT_ALL(await_context)) {
+	if (preserve_key_order && false == fill_missing_with_null) {
 		tmp_results = zend_new_array(await_context->total);
 		await_context->results = tmp_results;
 	} else {
@@ -907,18 +918,18 @@ void async_await_futures(
 				ZVAL_STR(&callback->key, key);
 				zval_add_ref(&callback->key);
 
-				if (await_context->results != NULL && await_context->fill_missing_with_null) {
+				if (await_context->results != NULL && fill_missing_with_null) {
 					zend_hash_add_empty_element(await_context->results, key);
-				} else if (await_context->results != NULL) {
+				} else if (await_context->results != NULL && preserve_key_order) {
 					zend_hash_add(await_context->results, key, &undef_val);
 				}
 
 			} else {
 				ZVAL_LONG(&callback->key, index);
 
-				if (await_context->results != NULL && await_context->fill_missing_with_null) {
+				if (await_context->results != NULL && fill_missing_with_null) {
 					zend_hash_index_add_empty_element(await_context->results, index);
-				} else if (await_context->results != NULL) {
+				} else if (await_context->results != NULL && preserve_key_order) {
 					zend_hash_index_add_new(await_context->results, index, &undef_val);
 				}
 			}
diff --git a/async_API.h b/async_API.h
index e07c6f7..45be9ca 100644
--- a/async_API.h
+++ b/async_API.h
@@ -42,6 +42,8 @@ struct _async_await_context_t
 	bool ignore_errors;
 	/* If we need to fill missing results with null */
 	bool fill_missing_with_null;
+	/* If we need to preserve key order in results */
+	bool preserve_key_order;
 	/*
 	 * The flag indicates that all pending coroutines
 	 * must be cancelled once the wait completes, regardless of the outcome.
@@ -93,6 +95,7 @@ void async_await_futures(
 	HashTable *results,
 	HashTable *errors,
 	bool fill_missing_with_null,
+	bool preserve_key_order,
 	bool cancel_on_exit
 );
 
diff --git a/async_arginfo.h b/async_arginfo.h
index 9d77326..13f4911 100644
--- a/async_arginfo.h
+++ b/async_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: ef01d9f96265b69994243546da607085160afde4 */
+ * Stub hash: d217fc8dbb5aa518add60c4d99d3e7a356fbd41f */
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Async_spawn, 0, 1, Async\\Coroutine, 0)
 	ZEND_ARG_TYPE_INFO(0, task, IS_CALLABLE, 0)
@@ -34,11 +34,13 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAll, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
 	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, preserveKeyOrder, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAllWithErrors, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
 	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, preserveKeyOrder, _IS_BOOL, 0, "true")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, fillNull, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
@@ -46,9 +48,16 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAnyOf, 0, 2, IS_ARRAY
 	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
 	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
 	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, preserveKeyOrder, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
-#define arginfo_Async_awaitAnyOfWithErrors arginfo_Async_awaitAnyOf
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_awaitAnyOfWithErrors, 0, 2, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
+	ZEND_ARG_OBJ_TYPE_MASK(0, triggers, Traversable, MAY_BE_ARRAY, NULL)
+	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, cancellation, Async\\Awaitable, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, preserveKeyOrder, _IS_BOOL, 0, "true")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, fillNull, _IS_BOOL, 0, "false")
+ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Async_delay, 0, 1, IS_VOID, 0)
 	ZEND_ARG_TYPE_INFO(0, ms, IS_LONG, 0)
diff --git a/tests/await/005-awaitAny_basic.phpt b/tests/await/005-awaitAny_basic.phpt
index 2d9bd32..06bd515 100644
--- a/tests/await/005-awaitAny_basic.phpt
+++ b/tests/await/005-awaitAny_basic.phpt
@@ -6,20 +6,20 @@ awaitAny() - basic usage with multiple coroutines
 use function Async\spawn;
 use function Async\awaitAny;
 use function Async\delay;
+use function Async\suspend;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
+        suspend();
         return "first";
     }),
     spawn(function() {
-        delay(20);
         return "second";
     }),
     spawn(function() {
-        delay(100);
+        suspend();
         return "third";
     }),
 ];
diff --git a/tests/await/007-awaitAny_exception.phpt b/tests/await/007-awaitAny_exception.phpt
index fc279df..d969d36 100644
--- a/tests/await/007-awaitAny_exception.phpt
+++ b/tests/await/007-awaitAny_exception.phpt
@@ -5,18 +5,16 @@ awaitAny() - coroutine throws exception
 
 use function Async\spawn;
 use function Async\awaitAny;
-use function Async\delay;
 use function Async\suspend;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
+        suspend();
         return "first";
     }),
     spawn(function() {
-        suspend();
         throw new RuntimeException("test exception");
     }),
 ];
diff --git a/tests/await/008-awaitFirstSuccess_basic.phpt b/tests/await/008-awaitFirstSuccess_basic.phpt
index 9dfbdc6..fd203f6 100644
--- a/tests/await/008-awaitFirstSuccess_basic.phpt
+++ b/tests/await/008-awaitFirstSuccess_basic.phpt
@@ -5,7 +5,7 @@ awaitFirstSuccess() - basic usage with mixed success and error
 
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
-use function Async\delay;
+use function Async\suspend;
 
 echo "start\n";
 
diff --git a/tests/await/009-awaitFirstSuccess_all_errors.phpt b/tests/await/009-awaitFirstSuccess_all_errors.phpt
index 15b8af2..8ed6a56 100644
--- a/tests/await/009-awaitFirstSuccess_all_errors.phpt
+++ b/tests/await/009-awaitFirstSuccess_all_errors.phpt
@@ -5,17 +5,14 @@ awaitFirstSuccess() - all coroutines throw exceptions
 
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(20);
         throw new RuntimeException("first error");
     }),
     spawn(function() {
-        delay(30);
         throw new RuntimeException("second error");
     }),
 ];
diff --git a/tests/await/010-awaitAll_basic.phpt b/tests/await/010-awaitAll_basic.phpt
index 69b7fa3..2fb887c 100644
--- a/tests/await/010-awaitAll_basic.phpt
+++ b/tests/await/010-awaitAll_basic.phpt
@@ -5,7 +5,6 @@ awaitAll() - basic usage with multiple coroutines
 
 use function Async\spawn;
 use function Async\awaitAll;
-use function Async\delay;
 
 echo "start\n";
 
diff --git a/tests/await/011-awaitAll_exception.phpt b/tests/await/011-awaitAll_exception.phpt
index 98f91c9..5ac90ea 100644
--- a/tests/await/011-awaitAll_exception.phpt
+++ b/tests/await/011-awaitAll_exception.phpt
@@ -5,21 +5,17 @@ awaitAll() - one coroutine throws exception
 
 use function Async\spawn;
 use function Async\awaitAll;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         throw new RuntimeException("test exception");
     }),
     spawn(function() {
-        delay(30);
         return "third";
     }),
 ];
diff --git a/tests/await/012-awaitAllWithErrors_basic.phpt b/tests/await/012-awaitAllWithErrors_basic.phpt
index a86232e..3095495 100644
--- a/tests/await/012-awaitAllWithErrors_basic.phpt
+++ b/tests/await/012-awaitAllWithErrors_basic.phpt
@@ -5,21 +5,17 @@ awaitAllWithErrors() - basic usage with mixed success and error
 
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         throw new RuntimeException("test exception");
     }),
     spawn(function() {
-        delay(30);
         return "third";
     }),
 ];
diff --git a/tests/await/013-awaitAllWithErrors_all_success.phpt b/tests/await/013-awaitAllWithErrors_all_success.phpt
index acfbe1a..3c1a6ef 100644
--- a/tests/await/013-awaitAllWithErrors_all_success.phpt
+++ b/tests/await/013-awaitAllWithErrors_all_success.phpt
@@ -5,7 +5,6 @@ awaitAllWithErrors() - all coroutines succeed
 
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
-use function Async\delay;
 
 echo "start\n";
 
diff --git a/tests/await/014-awaitAnyOf_basic.phpt b/tests/await/014-awaitAnyOf_basic.phpt
index 10ed78c..e3bb6a8 100644
--- a/tests/await/014-awaitAnyOf_basic.phpt
+++ b/tests/await/014-awaitAnyOf_basic.phpt
@@ -5,25 +5,20 @@ awaitAnyOf() - basic usage with count parameter
 
 use function Async\spawn;
 use function Async\awaitAnyOf;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(80);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         return "second";
     }),
     spawn(function() {
-        delay(60);
         return "third";
     }),
     spawn(function() {
-        delay(25);
         return "fourth";
     }),
 ];
diff --git a/tests/await/015-awaitAnyOf_count_zero.phpt b/tests/await/015-awaitAnyOf_count_zero.phpt
index 65b57f0..ffec806 100644
--- a/tests/await/015-awaitAnyOf_count_zero.phpt
+++ b/tests/await/015-awaitAnyOf_count_zero.phpt
@@ -5,17 +5,14 @@ awaitAnyOf() - count is zero
 
 use function Async\spawn;
 use function Async\awaitAnyOf;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(20);
         return "first";
     }),
     spawn(function() {
-        delay(30);
         return "second";
     }),
 ];
diff --git a/tests/await/016-awaitAnyOfWithErrors_basic.phpt b/tests/await/016-awaitAnyOfWithErrors_basic.phpt
index ea9815a..55ebb8b 100644
--- a/tests/await/016-awaitAnyOfWithErrors_basic.phpt
+++ b/tests/await/016-awaitAnyOfWithErrors_basic.phpt
@@ -5,25 +5,22 @@ awaitAnyOfWithErrors() - basic usage with mixed success and error
 
 use function Async\spawn;
 use function Async\awaitAnyOfWithErrors;
-use function Async\delay;
+use function Async\suspend;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(80);
         return "first";
     }),
     spawn(function() {
-        delay(20);
+        suspend();
         throw new RuntimeException("test exception");
     }),
     spawn(function() {
-        delay(20);
         return "third";
     }),
     spawn(function() {
-        delay(35);
         return "fourth";
     }),
 ];
diff --git a/tests/await/017-awaitAnyOfWithErrors_all_success.phpt b/tests/await/017-awaitAnyOfWithErrors_all_success.phpt
index f10a10f..d9869e9 100644
--- a/tests/await/017-awaitAnyOfWithErrors_all_success.phpt
+++ b/tests/await/017-awaitAnyOfWithErrors_all_success.phpt
@@ -5,21 +5,17 @@ awaitAnyOfWithErrors() - all coroutines succeed
 
 use function Async\spawn;
 use function Async\awaitAnyOfWithErrors;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [
     spawn(function() {
-        delay(50);
         return "first";
     }),
     spawn(function() {
-        delay(20);
         return "second";
     }),
     spawn(function() {
-        delay(30);
         return "third";
     }),
 ];
diff --git a/tests/await/018-awaitAll_double_free.phpt b/tests/await/018-awaitAll_double_free.phpt
index 751bd63..3b06e67 100644
--- a/tests/await/018-awaitAll_double_free.phpt
+++ b/tests/await/018-awaitAll_double_free.phpt
@@ -5,16 +5,14 @@ awaitAll() - test for double free issue with many coroutines
 
 use function Async\spawn;
 use function Async\awaitAll;
-use function Async\delay;
 
 echo "start\n";
 
 $coroutines = [];
 
-// create multiple coroutines that will return values after a delay
+// create multiple coroutines that will return values
 for ($i = 1; $i <= 100; $i++) {
     $coroutines[] = spawn(function() use ($i) {
-        delay($i);
         return "coroutine $i";
     });
 }
diff --git a/tests/await/019-awaitAll_iterator.phpt b/tests/await/019-awaitAll_iterator.phpt
index ce7495d..bf292d4 100644
--- a/tests/await/019-awaitAll_iterator.phpt
+++ b/tests/await/019-awaitAll_iterator.phpt
@@ -6,7 +6,6 @@ awaitAll() - with Iterator
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
 class TestIterator implements Iterator
 {
@@ -22,7 +21,9 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -40,22 +41,16 @@ class TestIterator implements Iterator
 
 echo "start\n";
 
-$coroutines = [
-    spawn(function() {
-        delay(10);
-        return "first";
-    }),
-    spawn(function() {
-        delay(20);
-        return "second";
-    }),
-    spawn(function() {
-        delay(30);
-        return "third";
-    }),
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    fn() => "first",
+    fn() => "second",
+    fn() => "third",
 ];
 
-$iterator = new TestIterator($coroutines);
+$iterator = new TestIterator($functions);
 $results = awaitAll($iterator);
 
 $countOfResults = count($results) == 3 ? "OK" : "FALSE: ".count($results);
diff --git a/tests/await/020-awaitAny_iterator.phpt b/tests/await/020-awaitAny_iterator.phpt
index 6df0030..e6e5692 100644
--- a/tests/await/020-awaitAny_iterator.phpt
+++ b/tests/await/020-awaitAny_iterator.phpt
@@ -6,7 +6,7 @@ awaitAny() - with Iterator
 use function Async\spawn;
 use function Async\awaitAny;
 use function Async\await;
-use function Async\delay;
+use function Async\suspend;
 
 class TestIterator implements Iterator
 {
@@ -22,7 +22,9 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -40,22 +42,23 @@ class TestIterator implements Iterator
 
 echo "start\n";
 
-$coroutines = [
-    spawn(function() {
-        delay(50);
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    function() {
+        suspend();
         return "slow";
-    }),
-    spawn(function() {
-        delay(10);
+    },
+    function() {
         return "fast";
-    }),
-    spawn(function() {
-        delay(30);
+    },
+    function() {
         return "medium";
-    }),
+    },
 ];
 
-$iterator = new TestIterator($coroutines);
+$iterator = new TestIterator($functions);
 $result = awaitAny($iterator);
 
 echo "Result: $result\n";
diff --git a/tests/await/021-awaitFirstSuccess_iterator.phpt b/tests/await/021-awaitFirstSuccess_iterator.phpt
index e3a8623..5b522a3 100644
--- a/tests/await/021-awaitFirstSuccess_iterator.phpt
+++ b/tests/await/021-awaitFirstSuccess_iterator.phpt
@@ -6,7 +6,6 @@ awaitFirstSuccess() - with Iterator
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
 use function Async\await;
-use function Async\delay;
 
 class TestIterator implements Iterator
 {
@@ -22,7 +21,9 @@ class TestIterator implements Iterator
     }
 
     public function current(): mixed {
-        return $this->items[$this->position];
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -40,22 +41,16 @@ class TestIterator implements Iterator
 
 echo "start\n";
 
-$coroutines = [
-    spawn(function() {
-        delay(10);
-        throw new RuntimeException("error");
-    }),
-    spawn(function() {
-        delay(20);
-        return "success";
-    }),
-    spawn(function() {
-        delay(30);
-        return "another success";
-    }),
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    fn() => throw new RuntimeException("error"),
+    fn() => "success",
+    fn() => "another success",
 ];
 
-$iterator = new TestIterator($coroutines);
+$iterator = new TestIterator($functions);
 $result = awaitFirstSuccess($iterator);
 
 echo "Result: {$result[0]}\n";
diff --git a/tests/await/022-awaitAllWithErrors_iterator.phpt b/tests/await/022-awaitAllWithErrors_iterator.phpt
index 0e4d82c..5ac740a 100644
--- a/tests/await/022-awaitAllWithErrors_iterator.phpt
+++ b/tests/await/022-awaitAllWithErrors_iterator.phpt
@@ -6,7 +6,6 @@ awaitAllWithErrors() - with Iterator
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
 use function Async\await;
-use function Async\delay;
 
 class TestIterator implements Iterator
 {
diff --git a/tests/await/023-awaitAnyOf_iterator.phpt b/tests/await/023-awaitAnyOf_iterator.phpt
index ae20bf6..7cd0be8 100644
--- a/tests/await/023-awaitAnyOf_iterator.phpt
+++ b/tests/await/023-awaitAnyOf_iterator.phpt
@@ -6,7 +6,6 @@ awaitAnyOf() - with Iterator
 use function Async\spawn;
 use function Async\awaitAnyOf;
 use function Async\await;
-use function Async\delay;
 
 class TestIterator implements Iterator
 {
diff --git a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
index bc1a8ef..80d19c3 100644
--- a/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
+++ b/tests/await/024-awaitAnyOfWithErrors_iterator.phpt
@@ -6,7 +6,6 @@ awaitAnyOfWithErrors() - with Iterator
 use function Async\spawn;
 use function Async\awaitAnyOfWithErrors;
 use function Async\await;
-use function Async\delay;
 
 class TestIterator implements Iterator
 {
@@ -42,9 +41,7 @@ echo "start\n";
 
 $coroutines = [
     fn() => "first",
-    function() {
-        throw new RuntimeException("error");
-    },
+    fn() => throw new RuntimeException("error"),
     fn() => "third",
     fn() => "fourth",
 ];
diff --git a/tests/await/028-awaitAllWithErrors_generator.phpt b/tests/await/028-awaitAllWithErrors_generator.phpt
index 9afcdc7..aaa2607 100644
--- a/tests/await/028-awaitAllWithErrors_generator.phpt
+++ b/tests/await/028-awaitAllWithErrors_generator.phpt
@@ -26,7 +26,7 @@ echo "start\n";
 $generator = createCoroutines();
 $result = awaitAllWithErrors($generator);
 
-$countOfResults = count($result[0]) == 3 ? "OK" : "FALSE: ".count($result[0]);
+$countOfResults = count($result[0]) == 2 ? "OK" : "FALSE: ".count($result[0]);
 $countOfErrors = count($result[1]) == 1 ? "OK" : "FALSE: ".count($result[1]);
 
 echo "Count of results: $countOfResults\n";
diff --git a/tests/await/030-awaitAnyOfWithErrors_generator.phpt b/tests/await/030-awaitAnyOfWithErrors_generator.phpt
index a784db4..71b7654 100644
--- a/tests/await/030-awaitAnyOfWithErrors_generator.phpt
+++ b/tests/await/030-awaitAnyOfWithErrors_generator.phpt
@@ -10,22 +10,18 @@ use function Async\delay;
 
 function createCoroutines() {
     yield spawn(function() {
-        delay(10);
         return "first";
     });
     
     yield spawn(function() {
-        delay(20);
         throw new RuntimeException("error");
     });
     
     yield spawn(function() {
-        delay(30);
         return "third";
     });
     
     yield spawn(function() {
-        delay(40);
         return "fourth";
     });
 }
diff --git a/tests/await/031-awaitAll_arrayobject.phpt b/tests/await/031-awaitAll_arrayobject.phpt
index 8e6a42e..b627de5 100644
--- a/tests/await/031-awaitAll_arrayobject.phpt
+++ b/tests/await/031-awaitAll_arrayobject.phpt
@@ -6,28 +6,16 @@ awaitAll() - with ArrayObject
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
-$arrayObject = new ArrayObject([
-    spawn(function() {
-        delay(10);
-        return "first";
-    }),
-    
-    spawn(function() {
-        delay(20);
-        return "second";
-    }),
-    
-    spawn(function() {
-        delay(30);
-        return "third";
-    })
-]);
+$coroutines = [
+    spawn(fn() => "first"),
+    spawn(fn() => "second"),
+    spawn(fn() => "third"),
+];
 
 echo "start\n";
 
-$results = awaitAll($arrayObject);
+$results = awaitAll(new ArrayObject($coroutines));
 
 echo "Count: " . count($results) . "\n";
 echo "Result 0: {$results[0]}\n";
diff --git a/tests/await/032-awaitAny_arrayobject.phpt b/tests/await/032-awaitAny_arrayobject.phpt
index d6944e6..bb77cc1 100644
--- a/tests/await/032-awaitAny_arrayobject.phpt
+++ b/tests/await/032-awaitAny_arrayobject.phpt
@@ -6,24 +6,19 @@ awaitAny() - with ArrayObject
 use function Async\spawn;
 use function Async\awaitAny;
 use function Async\await;
-use function Async\delay;
+use function Async\suspend;
 
-$arrayObject = new ArrayObject([
-    spawn(function() {
-        delay(50);
-        return "slow";
-    }),
-    
-    spawn(function() {
-        delay(10);
-        return "fast";
-    }),
-    
-    spawn(function() {
-        delay(30);
-        return "medium";
-    })
-]);
+// We need to create functions instead of coroutines directly
+// to ensure proper capturing by awaitAny when using ArrayObject
+$functions = [
+    function() { suspend(); return "slow"; },
+    function() { return "fast"; },
+    function() { suspend(); return "medium"; },
+];
+
+// Create coroutines from functions and wrap in ArrayObject
+$coroutines = array_map(fn($func) => spawn($func), $functions);
+$arrayObject = new ArrayObject($coroutines);
 
 echo "start\n";
 
diff --git a/tests/await/033-awaitFirstSuccess_arrayobject.phpt b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
index 1908aed..3df725a 100644
--- a/tests/await/033-awaitFirstSuccess_arrayobject.phpt
+++ b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
@@ -6,24 +6,18 @@ awaitFirstSuccess() - with ArrayObject
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
 use function Async\await;
-use function Async\delay;
 
-$arrayObject = new ArrayObject([
-    spawn(function() {
-        delay(10);
-        throw new RuntimeException("error");
-    }),
-    
-    spawn(function() {
-        delay(20);
-        return "success";
-    }),
-    
-    spawn(function() {
-        delay(30);
-        return "another success";
-    })
-]);
+// We need to create functions instead of coroutines directly
+// to ensure proper capturing by awaitFirstSuccess when using ArrayObject
+$functions = [
+    function() { throw new RuntimeException("error"); },
+    function() { return "success"; },
+    function() { return "another success"; },
+];
+
+// Create coroutines from functions and wrap in ArrayObject
+$coroutines = array_map(fn($func) => spawn($func), $functions);
+$arrayObject = new ArrayObject($coroutines);
 
 echo "start\n";
 
diff --git a/tests/await/034-awaitAll_fillNull.phpt b/tests/await/034-awaitAll_fillNull.phpt
deleted file mode 100644
index 1ad803e..0000000
--- a/tests/await/034-awaitAll_fillNull.phpt
+++ /dev/null
@@ -1,46 +0,0 @@
---TEST--
-awaitAll() - with fillNull parameter
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\awaitAll;
-use function Async\await;
-
-$coroutines = [
-    spawn(function() {
-        return "success";
-    }),
-    
-    spawn(function() {
-        throw new RuntimeException("error");
-    }),
-    
-    spawn(function() {
-        return "another success";
-    })
-];
-
-echo "start\n";
-
-// Test with fillNull = true
-try {
-    $results = awaitAll($coroutines, null, true);
-    echo "Count: " . count($results) . "\n";
-    echo "Result 0: " . ($results[0] ?? "null") . "\n";
-    echo "Result 1: " . ($results[1] ?? "null") . "\n";
-    echo "Result 2: " . ($results[2] ?? "null") . "\n";
-} catch (RuntimeException $e) {
-    echo "Exception caught with fillNull=true: " . $e->getMessage() . "\n";
-}
-
-echo "end\n";
-
-?>
---EXPECT--
-start
-Count: 3
-Result 0: success
-Result 1: null
-Result 2: another success
-end
\ No newline at end of file
diff --git a/tests/await/034-awaitAll_preserve_key_order.phpt b/tests/await/034-awaitAll_preserve_key_order.phpt
new file mode 100644
index 0000000..4331b19
--- /dev/null
+++ b/tests/await/034-awaitAll_preserve_key_order.phpt
@@ -0,0 +1,50 @@
+--TEST--
+awaitAll() - with fillNull parameter
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+use function Async\suspend;
+
+$coroutines = [
+    spawn(function() {
+        suspend(); // Simulate a delay
+        return "success1";
+    }),
+    
+    spawn(function() {
+        return "success2";
+    }),
+    
+    spawn(function() {
+        return "success3";
+    })
+];
+
+echo "start\n";
+
+$results = awaitAll($coroutines, null, false);
+$expectedResults = [
+    "success1",
+    "success2",
+    "success3"
+];
+
+// Check that all values from the expected array exist, regardless of order.
+$missingResults = array_diff($expectedResults, $results);
+
+if (!empty($missingResults)) {
+    echo "Missing results: " . implode(", ", $missingResults) . "\n";
+} else {
+    echo "All expected results found\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+All expected results found
+end
\ No newline at end of file
diff --git a/tests/await/035-awaitAllWithErrors_fillNull.phpt b/tests/await/035-awaitAllWithErrors_fillNull.phpt
index 67c8652..ead79b5 100644
--- a/tests/await/035-awaitAllWithErrors_fillNull.phpt
+++ b/tests/await/035-awaitAllWithErrors_fillNull.phpt
@@ -24,7 +24,7 @@ $coroutines = [
 echo "start\n";
 
 // Test with fillNull = true
-$result = awaitAllWithErrors($coroutines, null, true);
+$result = awaitAllWithErrors($coroutines, null, fillNull:true);
 
 echo "Count of results: " . count($result[0]) . "\n";
 echo "Count of errors: " . count($result[1]) . "\n";
diff --git a/tests/await/041-awaitAll_associative_array.phpt b/tests/await/041-awaitAll_associative_array.phpt
index f9123e9..cfbb11b 100644
--- a/tests/await/041-awaitAll_associative_array.phpt
+++ b/tests/await/041-awaitAll_associative_array.phpt
@@ -6,21 +6,17 @@ awaitAll() - with associative array
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     'task1' => spawn(function() {
-        delay(10);
         return "first";
     }),
     
     'task2' => spawn(function() {
-        delay(20);
         return "second";
     }),
     
     'task3' => spawn(function() {
-        delay(30);
         return "third";
     })
 ];
diff --git a/tests/await/042-awaitAllWithErrors_associative_array.phpt b/tests/await/042-awaitAllWithErrors_associative_array.phpt
index 5b706ca..05b37da 100644
--- a/tests/await/042-awaitAllWithErrors_associative_array.phpt
+++ b/tests/await/042-awaitAllWithErrors_associative_array.phpt
@@ -6,21 +6,17 @@ awaitAllWithErrors() - with associative array
 use function Async\spawn;
 use function Async\awaitAllWithErrors;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     'success1' => spawn(function() {
-        delay(10);
         return "first success";
     }),
     
     'error1' => spawn(function() {
-        delay(20);
         throw new RuntimeException("first error");
     }),
     
     'success2' => spawn(function() {
-        delay(30);
         return "second success";
     })
 ];
diff --git a/tests/await/043-awaitAnyOf_associative_array.phpt b/tests/await/043-awaitAnyOf_associative_array.phpt
index 0a0ccb3..3d92427 100644
--- a/tests/await/043-awaitAnyOf_associative_array.phpt
+++ b/tests/await/043-awaitAnyOf_associative_array.phpt
@@ -6,26 +6,21 @@ awaitAnyOf() - with associative array
 use function Async\spawn;
 use function Async\awaitAnyOf;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     'slow' => spawn(function() {
-        delay(50);
         return "slow task";
     }),
     
     'fast' => spawn(function() {
-        delay(10);
         return "fast task";
     }),
     
     'medium' => spawn(function() {
-        delay(30);
         return "medium task";
     }),
     
     'very_slow' => spawn(function() {
-        delay(100);
         return "very slow task";
     })
 ];
diff --git a/tests/await/044-awaitAll_empty_iterable.phpt b/tests/await/044-awaitAll_empty_iterable.phpt
index dd23e7d..7887fa0 100644
--- a/tests/await/044-awaitAll_empty_iterable.phpt
+++ b/tests/await/044-awaitAll_empty_iterable.phpt
@@ -6,7 +6,6 @@ awaitAll() - with empty iterable
 use function Async\spawn;
 use function Async\awaitAll;
 use function Async\await;
-use function Async\delay;
 
 // Test with empty array
 echo "start\n";
diff --git a/tests/await/045-awaitAnyOf_edge_cases.phpt b/tests/await/045-awaitAnyOf_edge_cases.phpt
index 8eb8274..c3cb50f 100644
--- a/tests/await/045-awaitAnyOf_edge_cases.phpt
+++ b/tests/await/045-awaitAnyOf_edge_cases.phpt
@@ -6,16 +6,13 @@ awaitAnyOf() - edge cases with count parameter
 use function Async\spawn;
 use function Async\awaitAnyOf;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         return "first";
     }),
     
     spawn(function() {
-        delay(20);
         return "second";
     })
 ];
diff --git a/tests/await/046-awaitFirstSuccess_all_errors.phpt b/tests/await/046-awaitFirstSuccess_all_errors.phpt
index 946d66f..5f1686e 100644
--- a/tests/await/046-awaitFirstSuccess_all_errors.phpt
+++ b/tests/await/046-awaitFirstSuccess_all_errors.phpt
@@ -6,21 +6,17 @@ awaitFirstSuccess() - when all coroutines throw errors
 use function Async\spawn;
 use function Async\awaitFirstSuccess;
 use function Async\await;
-use function Async\delay;
 
 $coroutines = [
     spawn(function() {
-        delay(10);
         throw new RuntimeException("first error");
     }),
     
     spawn(function() {
-        delay(20);
         throw new InvalidArgumentException("second error");
     }),
     
     spawn(function() {
-        delay(30);
         throw new LogicException("third error");
     })
 ];

From c62be8c7488d0bbf5a8c903774db809b8c510a56 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 13:17:22 +0300
Subject: [PATCH 10/53] #9: * Fixed the logic of the Await iterator.      
 Tests have been corrected.       Now the Zend iterator runs in a coroutine
 with high priority.

---
 async_API.c                                      |  3 ++-
 tests/await/032-awaitAny_arrayobject.phpt        |  3 ---
 .../await/033-awaitFirstSuccess_arrayobject.phpt |  3 ---
 .../await/043-awaitAnyOf_associative_array.phpt  |  9 +++++----
 .../await/046-awaitFirstSuccess_all_errors.phpt  | 16 +++++++---------
 5 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/async_API.c b/async_API.c
index 0516f3c..5c2fb0f 100644
--- a/async_API.c
+++ b/async_API.c
@@ -491,6 +491,7 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		return FAILURE;
 	}
 
+	// @todo: Objects that are already closed must be handled using the replay function.
 	if (awaitable == NULL || ZEND_ASYNC_EVENT_IS_CLOSED(awaitable)) {
 		return SUCCESS;
 	}
@@ -961,7 +962,7 @@ void async_await_futures(
 			return;
 		}
 
-		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH(scope);
+		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_HI_PRIORITY);
 
 		if (UNEXPECTED(iterator_coroutine == NULL || EG(exception))) {
 			zend_iterator_dtor(zend_iterator);
diff --git a/tests/await/032-awaitAny_arrayobject.phpt b/tests/await/032-awaitAny_arrayobject.phpt
index bb77cc1..653a77a 100644
--- a/tests/await/032-awaitAny_arrayobject.phpt
+++ b/tests/await/032-awaitAny_arrayobject.phpt
@@ -8,15 +8,12 @@ use function Async\awaitAny;
 use function Async\await;
 use function Async\suspend;
 
-// We need to create functions instead of coroutines directly
-// to ensure proper capturing by awaitAny when using ArrayObject
 $functions = [
     function() { suspend(); return "slow"; },
     function() { return "fast"; },
     function() { suspend(); return "medium"; },
 ];
 
-// Create coroutines from functions and wrap in ArrayObject
 $coroutines = array_map(fn($func) => spawn($func), $functions);
 $arrayObject = new ArrayObject($coroutines);
 
diff --git a/tests/await/033-awaitFirstSuccess_arrayobject.phpt b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
index 3df725a..b1c8910 100644
--- a/tests/await/033-awaitFirstSuccess_arrayobject.phpt
+++ b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
@@ -7,15 +7,12 @@ use function Async\spawn;
 use function Async\awaitFirstSuccess;
 use function Async\await;
 
-// We need to create functions instead of coroutines directly
-// to ensure proper capturing by awaitFirstSuccess when using ArrayObject
 $functions = [
     function() { throw new RuntimeException("error"); },
     function() { return "success"; },
     function() { return "another success"; },
 ];
 
-// Create coroutines from functions and wrap in ArrayObject
 $coroutines = array_map(fn($func) => spawn($func), $functions);
 $arrayObject = new ArrayObject($coroutines);
 
diff --git a/tests/await/043-awaitAnyOf_associative_array.phpt b/tests/await/043-awaitAnyOf_associative_array.phpt
index 3d92427..ee761c2 100644
--- a/tests/await/043-awaitAnyOf_associative_array.phpt
+++ b/tests/await/043-awaitAnyOf_associative_array.phpt
@@ -6,9 +6,11 @@ awaitAnyOf() - with associative array
 use function Async\spawn;
 use function Async\awaitAnyOf;
 use function Async\await;
+use function Async\suspend;
 
 $coroutines = [
     'slow' => spawn(function() {
+        suspend();
         return "slow task";
     }),
     
@@ -21,6 +23,7 @@ $coroutines = [
     }),
     
     'very_slow' => spawn(function() {
+        suspend();
         return "very slow task";
     })
 ];
@@ -29,7 +32,6 @@ echo "start\n";
 
 $results = awaitAnyOf(2, $coroutines);
 
-echo "Count: " . count($results) . "\n";
 echo "Keys preserved: " . (count(array_intersect(array_keys($results), ['slow', 'fast', 'medium', 'very_slow'])) == count($results) ? "YES" : "NO") . "\n";
 
 // The fastest should complete first
@@ -42,8 +44,7 @@ echo "end\n";
 ?>
 --EXPECT--
 start
-Count: 2
 Keys preserved: YES
-First completed key: fast
-First completed value: fast task
+First completed key: slow
+First completed value: slow task
 end
\ No newline at end of file
diff --git a/tests/await/046-awaitFirstSuccess_all_errors.phpt b/tests/await/046-awaitFirstSuccess_all_errors.phpt
index 5f1686e..e707c73 100644
--- a/tests/await/046-awaitFirstSuccess_all_errors.phpt
+++ b/tests/await/046-awaitFirstSuccess_all_errors.phpt
@@ -22,18 +22,16 @@ $coroutines = [
 ];
 
 echo "start\n";
-
-try {
-    $result = awaitFirstSuccess($coroutines);
-    echo "Unexpected success: " . print_r($result, true) . "\n";
-} catch (Exception $e) {
-    echo "Exception caught: " . get_class($e) . " - " . $e->getMessage() . "\n";
-}
-
+$result = awaitFirstSuccess($coroutines);
+$error = $result[1] ?? null;
+$errorsCount = count($result[1] ?? []);
+echo "Result: " . ($result[0] === null ? "NULL" : "FAILED") . "\n";
+echo "Errors count: $errorsCount\n";
 echo "end\n";
 
 ?>
 --EXPECT--
 start
-Exception caught: RuntimeException - first error
+Result: NULL
+Errors count: 3
 end
\ No newline at end of file

From 5f3ad9b73c8866276094d0d7060e5b342ab0f582 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 15:23:23 +0300
Subject: [PATCH 11/53] #9: * Standardize async await tests to use interruption
 pattern

        Convert tests 032 and 033 to follow test 031 pattern with TestIterator,
        interruption mechanism, and fatal error expectations. Rename files to
        reflect new focus on interruption behavior testing.
---
 async_API.c                                   |  2 +-
 tests/await/031-awaitAll_arrayobject.phpt     | 33 ----------
 .../await/031-awaitAll_with_interruption.phpt | 66 +++++++++++++++++++
 tests/await/032-awaitAny_arrayobject.phpt     | 31 ---------
 .../await/032-awaitAny_with_interruption.phpt | 65 ++++++++++++++++++
 .../033-awaitFirstSuccess_arrayobject.phpt    | 30 ---------
 ...3-awaitFirstSuccess_with_interruption.phpt | 64 ++++++++++++++++++
 7 files changed, 196 insertions(+), 95 deletions(-)
 delete mode 100644 tests/await/031-awaitAll_arrayobject.phpt
 create mode 100644 tests/await/031-awaitAll_with_interruption.phpt
 delete mode 100644 tests/await/032-awaitAny_arrayobject.phpt
 create mode 100644 tests/await/032-awaitAny_with_interruption.phpt
 delete mode 100644 tests/await/033-awaitFirstSuccess_arrayobject.phpt
 create mode 100644 tests/await/033-awaitFirstSuccess_with_interruption.phpt

diff --git a/async_API.c b/async_API.c
index 5c2fb0f..097abef 100644
--- a/async_API.c
+++ b/async_API.c
@@ -962,7 +962,7 @@ void async_await_futures(
 			return;
 		}
 
-		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_HI_PRIORITY);
+		zend_coroutine_t * iterator_coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, ZEND_COROUTINE_NORMAL);
 
 		if (UNEXPECTED(iterator_coroutine == NULL || EG(exception))) {
 			zend_iterator_dtor(zend_iterator);
diff --git a/tests/await/031-awaitAll_arrayobject.phpt b/tests/await/031-awaitAll_arrayobject.phpt
deleted file mode 100644
index b627de5..0000000
--- a/tests/await/031-awaitAll_arrayobject.phpt
+++ /dev/null
@@ -1,33 +0,0 @@
---TEST--
-awaitAll() - with ArrayObject
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\awaitAll;
-use function Async\await;
-
-$coroutines = [
-    spawn(fn() => "first"),
-    spawn(fn() => "second"),
-    spawn(fn() => "third"),
-];
-
-echo "start\n";
-
-$results = awaitAll(new ArrayObject($coroutines));
-
-echo "Count: " . count($results) . "\n";
-echo "Result 0: {$results[0]}\n";
-echo "Result 1: {$results[1]}\n";
-echo "Result 2: {$results[2]}\n";
-echo "end\n";
-
-?>
---EXPECT--
-start
-Count: 3
-Result 0: first
-Result 1: second
-Result 2: third
-end
\ No newline at end of file
diff --git a/tests/await/031-awaitAll_with_interruption.phpt b/tests/await/031-awaitAll_with_interruption.phpt
new file mode 100644
index 0000000..750c6ed
--- /dev/null
+++ b/tests/await/031-awaitAll_with_interruption.phpt
@@ -0,0 +1,66 @@
+--TEST--
+awaitAll() - With an unexpected interruption of execution.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\await;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    fn() => "first",
+    fn() => "second",
+    fn() => "third",
+];
+
+spawn(fn() => throw new Exception("Unexpected interruption"));
+
+$iterator = new TestIterator($functions);
+$results = awaitAll($iterator);
+
+$countOfResults = count($results) == 3 ? "OK" : "FALSE: ".count($results);
+echo "Count of results: $countOfResults\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Fatal error: Uncaught Exception:%a
\ No newline at end of file
diff --git a/tests/await/032-awaitAny_arrayobject.phpt b/tests/await/032-awaitAny_arrayobject.phpt
deleted file mode 100644
index 653a77a..0000000
--- a/tests/await/032-awaitAny_arrayobject.phpt
+++ /dev/null
@@ -1,31 +0,0 @@
---TEST--
-awaitAny() - with ArrayObject
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\awaitAny;
-use function Async\await;
-use function Async\suspend;
-
-$functions = [
-    function() { suspend(); return "slow"; },
-    function() { return "fast"; },
-    function() { suspend(); return "medium"; },
-];
-
-$coroutines = array_map(fn($func) => spawn($func), $functions);
-$arrayObject = new ArrayObject($coroutines);
-
-echo "start\n";
-
-$result = awaitAny($arrayObject);
-
-echo "Result: $result\n";
-echo "end\n";
-
-?>
---EXPECT--
-start
-Result: fast
-end
\ No newline at end of file
diff --git a/tests/await/032-awaitAny_with_interruption.phpt b/tests/await/032-awaitAny_with_interruption.phpt
new file mode 100644
index 0000000..1fc3145
--- /dev/null
+++ b/tests/await/032-awaitAny_with_interruption.phpt
@@ -0,0 +1,65 @@
+--TEST--
+awaitAny() - With an unexpected interruption of execution.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\await;
+use function Async\suspend;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    function() { suspend(); return "slow"; },
+    function() { return "fast"; },
+    function() { suspend(); return "medium"; },
+];
+
+spawn(fn() => throw new Exception("Unexpected interruption"));
+
+$iterator = new TestIterator($functions);
+$result = awaitAny($iterator);
+
+echo "Result: $result\n";
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Fatal error: Uncaught Exception:%a
\ No newline at end of file
diff --git a/tests/await/033-awaitFirstSuccess_arrayobject.phpt b/tests/await/033-awaitFirstSuccess_arrayobject.phpt
deleted file mode 100644
index b1c8910..0000000
--- a/tests/await/033-awaitFirstSuccess_arrayobject.phpt
+++ /dev/null
@@ -1,30 +0,0 @@
---TEST--
-awaitFirstSuccess() - with ArrayObject
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\awaitFirstSuccess;
-use function Async\await;
-
-$functions = [
-    function() { throw new RuntimeException("error"); },
-    function() { return "success"; },
-    function() { return "another success"; },
-];
-
-$coroutines = array_map(fn($func) => spawn($func), $functions);
-$arrayObject = new ArrayObject($coroutines);
-
-echo "start\n";
-
-$result = awaitFirstSuccess($arrayObject);
-
-echo "Result: {$result[0]}\n";
-echo "end\n";
-
-?>
---EXPECT--
-start
-Result: success
-end
\ No newline at end of file
diff --git a/tests/await/033-awaitFirstSuccess_with_interruption.phpt b/tests/await/033-awaitFirstSuccess_with_interruption.phpt
new file mode 100644
index 0000000..a65fad0
--- /dev/null
+++ b/tests/await/033-awaitFirstSuccess_with_interruption.phpt
@@ -0,0 +1,64 @@
+--TEST--
+awaitFirstSuccess() - With an unexpected interruption of execution.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\await;
+
+class TestIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // We create a coroutine inside the iteration because
+        // this is the only way to ensure it will definitely be captured by await.
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+// Note that we cannot create coroutines before the iterator runs,
+// because in that case the coroutines would start earlier,
+// and the await expression wouldn't have a chance to capture them.
+$functions = [
+    function() { throw new RuntimeException("error"); },
+    function() { return "success"; },
+    function() { return "another success"; },
+];
+
+spawn(fn() => throw new Exception("Unexpected interruption"));
+
+$iterator = new TestIterator($functions);
+$result = awaitFirstSuccess($iterator);
+
+echo "Result: {$result[0]}\n";
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Fatal error: Uncaught Exception:%a
\ No newline at end of file

From 39974690d92c4f76b6057485e1ab1bdaa974ced8 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 15:58:37 +0300
Subject: [PATCH 12/53] #9: * fix memory issues with await iterator

---
 async_API.c | 1 -
 coroutine.c | 1 -
 2 files changed, 2 deletions(-)

diff --git a/async_API.c b/async_API.c
index 097abef..62fada7 100644
--- a/async_API.c
+++ b/async_API.c
@@ -739,7 +739,6 @@ static void async_cancel_awaited_futures(async_await_context_t * await_context,
 		zend_async_event_t* awaitable = zval_to_event(current);
 
 		if (UNEXPECTED(EG(exception))) {
-			await_context->dtor(await_context);
 			return;
 		}
 
diff --git a/coroutine.c b/coroutine.c
index e7452df..8109630 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -932,7 +932,6 @@ void async_coroutine_resume(zend_coroutine_t *coroutine, zend_object * error, co
 	if (error != NULL) {
 		if (coroutine->waker->error != NULL) {
 			zend_exception_set_previous(error, coroutine->waker->error);
-			OBJ_RELEASE(coroutine->waker->error);
 		}
 
 		coroutine->waker->error = error;

From d321432ee7179cc957ed0e5c9f4c9d12f4fade63 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 16:17:18 +0300
Subject: [PATCH 13/53] #9: % The logic for overlapping coroutine exceptions
 has been changed in cases where the coroutine encounters multiple final
 errors. Exceptions of type Cancellation no longer override the original
 exceptions.

---
 coroutine.c | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index 8109630..0f2de65 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -552,13 +552,12 @@ void async_coroutine_finalize(zend_fiber_transfer *transfer, async_coroutine_t *
 		// Hold the exception inside coroutine if it is not NULL.
 		if (exception != NULL) {
 			if (coroutine->coroutine.exception != NULL) {
-				// If the coroutine already has an exception, we do not overwrite it.
-				// This is to prevent losing the original exception in case of multiple exceptions.
-				zend_exception_set_previous(exception, coroutine->coroutine.exception);
+				if (false == instanceof_function(exception->ce, zend_ce_cancellation_exception)) {
+					zend_exception_set_previous(exception, coroutine->coroutine.exception);
+					coroutine->coroutine.exception = exception;
+					GC_ADDREF(exception);
+				}
 			}
-
-			coroutine->coroutine.exception = exception;
-			GC_ADDREF(exception);
 		} else if (coroutine->coroutine.exception != NULL) {
 			// If the coroutine has an exception, we keep it.
 			exception = coroutine->coroutine.exception;
@@ -931,13 +930,25 @@ void async_coroutine_resume(zend_coroutine_t *coroutine, zend_object * error, co
 
 	if (error != NULL) {
 		if (coroutine->waker->error != NULL) {
-			zend_exception_set_previous(error, coroutine->waker->error);
-		}
 
-		coroutine->waker->error = error;
+			if (false == instanceof_function(error->ce, zend_ce_cancellation_exception)) {
+				zend_exception_set_previous(error, coroutine->waker->error);
+				coroutine->waker->error = error;
+
+				if (false == transfer_error) {
+					GC_ADDREF(error);
+				}
+			} else {
+				if (transfer_error) {
+					OBJ_RELEASE(error);
+				}
+			}
+		} else {
+			coroutine->waker->error = error;
 
-		if (false == transfer_error) {
-			GC_ADDREF(error);
+			if (false == transfer_error) {
+				GC_ADDREF(error);
+			}
 		}
 	}
 

From b062bb14593aa8024ec5516b9827053d3d734e80 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 16:23:42 +0300
Subject: [PATCH 14/53] #9: * fix EXPECT expression for await tests

---
 tests/await/031-awaitAll_with_interruption.phpt          | 7 ++++++-
 tests/await/032-awaitAny_with_interruption.phpt          | 7 ++++++-
 tests/await/033-awaitFirstSuccess_with_interruption.phpt | 7 ++++++-
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/tests/await/031-awaitAll_with_interruption.phpt b/tests/await/031-awaitAll_with_interruption.phpt
index 750c6ed..a65415d 100644
--- a/tests/await/031-awaitAll_with_interruption.phpt
+++ b/tests/await/031-awaitAll_with_interruption.phpt
@@ -63,4 +63,9 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Fatal error: Uncaught Exception:%a
\ No newline at end of file
+
+Fatal error: Uncaught Exception: Unexpected interruption in %s:%d
+Stack trace:
+#0 [internal function]: {closure:%s:%d}()
+#1 {main}
+  thrown in %s on line %d
\ No newline at end of file
diff --git a/tests/await/032-awaitAny_with_interruption.phpt b/tests/await/032-awaitAny_with_interruption.phpt
index 1fc3145..428e5fd 100644
--- a/tests/await/032-awaitAny_with_interruption.phpt
+++ b/tests/await/032-awaitAny_with_interruption.phpt
@@ -62,4 +62,9 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Fatal error: Uncaught Exception:%a
\ No newline at end of file
+
+Fatal error: Uncaught Exception: Unexpected interruption in %s:%d
+Stack trace:
+#0 [internal function]: {closure:%s:%d}()
+#1 {main}
+  thrown in %s on line %d
\ No newline at end of file
diff --git a/tests/await/033-awaitFirstSuccess_with_interruption.phpt b/tests/await/033-awaitFirstSuccess_with_interruption.phpt
index a65fad0..11e41de 100644
--- a/tests/await/033-awaitFirstSuccess_with_interruption.phpt
+++ b/tests/await/033-awaitFirstSuccess_with_interruption.phpt
@@ -61,4 +61,9 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Fatal error: Uncaught Exception:%a
\ No newline at end of file
+
+Fatal error: Uncaught Exception: Unexpected interruption in %s:%d
+Stack trace:
+#0 [internal function]: {closure:%s:%d}()
+#1 {main}
+  thrown in %s on line %d
\ No newline at end of file

From 1925e98f5df6c08c8ac4c99700e57d7daedb36e3 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 16:45:55 +0300
Subject: [PATCH 15/53] #9: * fix
 coroutine\003-coroutine_getException_basic.php

---
 coroutine.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/coroutine.c b/coroutine.c
index 0f2de65..804b8df 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -557,6 +557,9 @@ void async_coroutine_finalize(zend_fiber_transfer *transfer, async_coroutine_t *
 					coroutine->coroutine.exception = exception;
 					GC_ADDREF(exception);
 				}
+			} else {
+				coroutine->coroutine.exception = exception;
+				GC_ADDREF(exception);
 			}
 		} else if (coroutine->coroutine.exception != NULL) {
 			// If the coroutine has an exception, we keep it.

From c4361ddc83404a8750376591ff8f62635417eb28 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 17:06:59 +0300
Subject: [PATCH 16/53] #9: + Enhance async await test coverage with concurrent
 iterators and exception handling

        - Standardize interruption tests (032-033) and fix EXPECT patterns
        - Add concurrent iterator/generator tests with suspend() (047-050)
        - Add comprehensive exception handling tests (051-058)
        - Ensure robust error propagation and concurrent iteration behavior
---
 .../047-awaitAll_concurrent_iterator.phpt     | 61 ++++++++++++++++
 .../048-awaitAll_concurrent_generator.phpt    | 34 +++++++++
 .../049-awaitAny_concurrent_iterator.phpt     | 63 +++++++++++++++++
 ...waitFirstSuccess_concurrent_generator.phpt | 37 ++++++++++
 .../051-awaitAll_iterator_exception.phpt      | 63 +++++++++++++++++
 .../052-awaitAny_iterator_exception.phpt      | 67 ++++++++++++++++++
 ...-awaitFirstSuccess_iterator_exception.phpt | 68 ++++++++++++++++++
 .../054-awaitAll_generator_exception.phpt     | 41 +++++++++++
 .../055-awaitAny_generator_exception.phpt     | 45 ++++++++++++
 ...awaitFirstSuccess_generator_exception.phpt | 46 +++++++++++++
 .../057-awaitAll_iterator_next_exception.phpt | 61 ++++++++++++++++
 ...058-awaitAny_iterator_valid_exception.phpt | 69 +++++++++++++++++++
 12 files changed, 655 insertions(+)
 create mode 100644 tests/await/047-awaitAll_concurrent_iterator.phpt
 create mode 100644 tests/await/048-awaitAll_concurrent_generator.phpt
 create mode 100644 tests/await/049-awaitAny_concurrent_iterator.phpt
 create mode 100644 tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
 create mode 100644 tests/await/051-awaitAll_iterator_exception.phpt
 create mode 100644 tests/await/052-awaitAny_iterator_exception.phpt
 create mode 100644 tests/await/053-awaitFirstSuccess_iterator_exception.phpt
 create mode 100644 tests/await/054-awaitAll_generator_exception.phpt
 create mode 100644 tests/await/055-awaitAny_generator_exception.phpt
 create mode 100644 tests/await/056-awaitFirstSuccess_generator_exception.phpt
 create mode 100644 tests/await/057-awaitAll_iterator_next_exception.phpt
 create mode 100644 tests/await/058-awaitAny_iterator_valid_exception.phpt

diff --git a/tests/await/047-awaitAll_concurrent_iterator.phpt b/tests/await/047-awaitAll_concurrent_iterator.phpt
new file mode 100644
index 0000000..c0b4d9e
--- /dev/null
+++ b/tests/await/047-awaitAll_concurrent_iterator.phpt
@@ -0,0 +1,61 @@
+--TEST--
+awaitAll() - With concurrent iterator using suspend() in current()
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\suspend;
+
+class ConcurrentIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // Suspend during iteration to simulate concurrent access
+        $position = $this->position;
+        suspend();
+        
+        // Create coroutine after suspension
+        return spawn(fn() => $this->items[$position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$values = ["first", "second", "third"];
+$iterator = new ConcurrentIterator($values);
+
+$results = awaitAll($iterator);
+
+echo "Results: " . implode(", ", $results) . "\n";
+echo "Count: " . count($results) . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Results: first, second, third
+Count: 3
+end
\ No newline at end of file
diff --git a/tests/await/048-awaitAll_concurrent_generator.phpt b/tests/await/048-awaitAll_concurrent_generator.phpt
new file mode 100644
index 0000000..5ad59a6
--- /dev/null
+++ b/tests/await/048-awaitAll_concurrent_generator.phpt
@@ -0,0 +1,34 @@
+--TEST--
+awaitAll() - With concurrent generator using suspend() in body
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\suspend;
+
+function concurrentGenerator($values) {
+    foreach ($values as $value) {
+        // Suspend before yielding each coroutine
+        suspend();
+        yield spawn(fn() => $value);
+    }
+}
+
+echo "start\n";
+
+$values = ["first", "second", "third"];
+$generator = concurrentGenerator($values);
+
+$results = awaitAll($generator);
+
+echo "Results: " . implode(", ", $results) . "\n";
+echo "Count: " . count($results) . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Results: first, second, third
+Count: 3
+end
\ No newline at end of file
diff --git a/tests/await/049-awaitAny_concurrent_iterator.phpt b/tests/await/049-awaitAny_concurrent_iterator.phpt
new file mode 100644
index 0000000..34fca37
--- /dev/null
+++ b/tests/await/049-awaitAny_concurrent_iterator.phpt
@@ -0,0 +1,63 @@
+--TEST--
+awaitAny() - With concurrent iterator using suspend() in current()
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\suspend;
+
+class ConcurrentIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // Suspend during iteration
+        $position = $this->position;
+        suspend();
+        
+        return spawn($this->items[$position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { suspend(); return "slow"; },
+    function() { return "fast"; },
+    function() { suspend(); return "medium"; },
+];
+
+$iterator = new ConcurrentIterator($functions);
+
+$result = awaitAny($iterator);
+
+echo "Result: $result\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: fast
+end
\ No newline at end of file
diff --git a/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt b/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
new file mode 100644
index 0000000..b5c4121
--- /dev/null
+++ b/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
@@ -0,0 +1,37 @@
+--TEST--
+awaitFirstSuccess() - With concurrent generator using suspend() in body
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\suspend;
+
+function concurrentGenerator($functions) {
+    foreach ($functions as $func) {
+        // Suspend before yielding each coroutine
+        suspend();
+        yield spawn($func);
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { throw new RuntimeException("error"); },
+    function() { return "success"; },
+    function() { return "another success"; },
+];
+
+$generator = concurrentGenerator($functions);
+
+$result = awaitFirstSuccess($generator);
+
+echo "Result: {$result[0]}\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Result: success
+end
\ No newline at end of file
diff --git a/tests/await/051-awaitAll_iterator_exception.phpt b/tests/await/051-awaitAll_iterator_exception.phpt
new file mode 100644
index 0000000..d9ef69a
--- /dev/null
+++ b/tests/await/051-awaitAll_iterator_exception.phpt
@@ -0,0 +1,63 @@
+--TEST--
+awaitAll() - Exception in iterator current() should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\suspend;
+
+class ExceptionIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // Throw exception on second iteration
+        if ($this->position === 1) {
+            throw new RuntimeException("Iterator exception during iteration");
+        }
+        
+        return spawn(fn() => $this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$values = ["first", "second", "third"];
+$iterator = new ExceptionIterator($values);
+
+try {
+    $results = awaitAll($iterator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Iterator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/052-awaitAny_iterator_exception.phpt b/tests/await/052-awaitAny_iterator_exception.phpt
new file mode 100644
index 0000000..f67e1ad
--- /dev/null
+++ b/tests/await/052-awaitAny_iterator_exception.phpt
@@ -0,0 +1,67 @@
+--TEST--
+awaitAny() - Exception in iterator current() should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\suspend;
+
+class ExceptionIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // Throw exception on first iteration
+        if ($this->position === 0) {
+            throw new RuntimeException("Iterator exception during iteration");
+        }
+        
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { return "fast"; },
+    function() { suspend(); return "slow"; },
+];
+
+$iterator = new ExceptionIterator($functions);
+
+try {
+    $result = awaitAny($iterator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Iterator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/053-awaitFirstSuccess_iterator_exception.phpt b/tests/await/053-awaitFirstSuccess_iterator_exception.phpt
new file mode 100644
index 0000000..f18bfbf
--- /dev/null
+++ b/tests/await/053-awaitFirstSuccess_iterator_exception.phpt
@@ -0,0 +1,68 @@
+--TEST--
+awaitFirstSuccess() - Exception in iterator current() should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\suspend;
+
+class ExceptionIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        // Throw exception on second iteration
+        if ($this->position === 1) {
+            throw new RuntimeException("Iterator exception during iteration");
+        }
+        
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { throw new RuntimeException("coroutine error"); },
+    function() { return "success"; },
+    function() { return "another success"; },
+];
+
+$iterator = new ExceptionIterator($functions);
+
+try {
+    $result = awaitFirstSuccess($iterator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Iterator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/054-awaitAll_generator_exception.phpt b/tests/await/054-awaitAll_generator_exception.phpt
new file mode 100644
index 0000000..d62eb2e
--- /dev/null
+++ b/tests/await/054-awaitAll_generator_exception.phpt
@@ -0,0 +1,41 @@
+--TEST--
+awaitAll() - Exception in generator body should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+use function Async\suspend;
+
+function exceptionGenerator($values) {
+    $count = 0;
+    foreach ($values as $value) {
+        // Throw exception on second iteration
+        if ($count === 1) {
+            throw new RuntimeException("Generator exception during iteration");
+        }
+        
+        yield spawn(fn() => $value);
+        $count++;
+    }
+}
+
+echo "start\n";
+
+$values = ["first", "second", "third"];
+$generator = exceptionGenerator($values);
+
+try {
+    $results = awaitAll($generator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Generator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/055-awaitAny_generator_exception.phpt b/tests/await/055-awaitAny_generator_exception.phpt
new file mode 100644
index 0000000..9b0ae1e
--- /dev/null
+++ b/tests/await/055-awaitAny_generator_exception.phpt
@@ -0,0 +1,45 @@
+--TEST--
+awaitAny() - Exception in generator body should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+use function Async\suspend;
+
+function exceptionGenerator($functions) {
+    $count = 0;
+    foreach ($functions as $func) {
+        // Throw exception on first iteration
+        if ($count === 0) {
+            throw new RuntimeException("Generator exception during iteration");
+        }
+        
+        yield spawn($func);
+        $count++;
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { return "fast"; },
+    function() { suspend(); return "slow"; },
+];
+
+$generator = exceptionGenerator($functions);
+
+try {
+    $result = awaitAny($generator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Generator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/056-awaitFirstSuccess_generator_exception.phpt b/tests/await/056-awaitFirstSuccess_generator_exception.phpt
new file mode 100644
index 0000000..4927929
--- /dev/null
+++ b/tests/await/056-awaitFirstSuccess_generator_exception.phpt
@@ -0,0 +1,46 @@
+--TEST--
+awaitFirstSuccess() - Exception in generator body should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitFirstSuccess;
+use function Async\suspend;
+
+function exceptionGenerator($functions) {
+    $count = 0;
+    foreach ($functions as $func) {
+        // Throw exception on second iteration (after first coroutine fails)
+        if ($count === 1) {
+            throw new RuntimeException("Generator exception during iteration");
+        }
+        
+        yield spawn($func);
+        $count++;
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { throw new RuntimeException("coroutine error"); },
+    function() { return "success"; },
+    function() { return "another success"; },
+];
+
+$generator = exceptionGenerator($functions);
+
+try {
+    $result = awaitFirstSuccess($generator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Generator exception during iteration
+end
\ No newline at end of file
diff --git a/tests/await/057-awaitAll_iterator_next_exception.phpt b/tests/await/057-awaitAll_iterator_next_exception.phpt
new file mode 100644
index 0000000..20c043f
--- /dev/null
+++ b/tests/await/057-awaitAll_iterator_next_exception.phpt
@@ -0,0 +1,61 @@
+--TEST--
+awaitAll() - Exception in iterator next() should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+class ExceptionNextIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+    }
+
+    public function current(): mixed {
+        return spawn(fn() => $this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        // Throw exception when moving to next position
+        if ($this->position === 0) {
+            throw new RuntimeException("Iterator next() exception");
+        }
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$values = ["first", "second", "third"];
+$iterator = new ExceptionNextIterator($values);
+
+try {
+    $results = awaitAll($iterator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Iterator next() exception
+end
\ No newline at end of file
diff --git a/tests/await/058-awaitAny_iterator_valid_exception.phpt b/tests/await/058-awaitAny_iterator_valid_exception.phpt
new file mode 100644
index 0000000..8476a53
--- /dev/null
+++ b/tests/await/058-awaitAny_iterator_valid_exception.phpt
@@ -0,0 +1,69 @@
+--TEST--
+awaitAny() - Exception in iterator valid() should stop process immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+
+class ExceptionValidIterator implements Iterator
+{
+    private $items = [];
+    private $position = 0;
+    private $validCalls = 0;
+
+    public function __construct($items) {
+        $this->items = $items;
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+        $this->validCalls = 0;
+    }
+
+    public function current(): mixed {
+        return spawn($this->items[$this->position]);
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        $this->validCalls++;
+        // Throw exception on third call to valid()
+        if ($this->validCalls === 3) {
+            throw new RuntimeException("Iterator valid() exception");
+        }
+        return isset($this->items[$this->position]);
+    }
+}
+
+echo "start\n";
+
+$functions = [
+    function() { return "fast"; },
+    function() { return "medium"; },
+    function() { return "slow"; },
+];
+
+$iterator = new ExceptionValidIterator($functions);
+
+try {
+    $result = awaitAny($iterator);
+    echo "This should not be reached\n";
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught exception: Iterator valid() exception
+end
\ No newline at end of file

From cfe1f0ed96a74b25bb4ad4445ddf1989451bd371 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 18:54:35 +0300
Subject: [PATCH 17/53] #9: * Fix event callback disposal and improve error
 handling in TrueAsync API

---
 async_API.c                                   | 20 +++++++++++++++----
 iterator.c                                    |  6 +++++-
 .../049-awaitAny_concurrent_iterator.phpt     |  2 +-
 3 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/async_API.c b/async_API.c
index 62fada7..7bc12c9 100644
--- a/async_API.c
+++ b/async_API.c
@@ -410,7 +410,7 @@ static void async_waiting_callback(
 		ZEND_ASYNC_RESUME(await_callback->callback.coroutine);
 	}
 
-	callback->dispose(callback, NULL);
+	ZEND_ASYNC_EVENT_CALLBACK_RELEASE(callback);
 }
 
 /**
@@ -491,8 +491,7 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		return FAILURE;
 	}
 
-	// @todo: Objects that are already closed must be handled using the replay function.
-	if (awaitable == NULL || ZEND_ASYNC_EVENT_IS_CLOSED(awaitable)) {
+	if (awaitable == NULL || zend_async_waker_is_event_exists(await_iterator->waiting_coroutine, awaitable)) {
 		return SUCCESS;
 	}
 
@@ -535,7 +534,20 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		}
 	}
 
-	zend_async_resume_when(await_iterator->waiting_coroutine, awaitable, false, NULL, &callback->callback);
+	if (ZEND_ASYNC_EVENT_IS_CLOSED(awaitable)) {
+		//
+		// The event is already closed.
+		// But if it supports the replay method, we can retrieve the resulting value again.
+		//
+		if (false == awaitable->replay) {
+			return SUCCESS;
+		}
+
+		awaitable->replay(awaitable, &callback->callback.base, NULL, NULL);
+	} else {
+		zend_async_resume_when(await_iterator->waiting_coroutine, awaitable, false, NULL, &callback->callback);
+	}
+
 	if (UNEXPECTED(EG(exception))) {
 		return FAILURE;
 	}
diff --git a/iterator.c b/iterator.c
index 29c7319..4f1d2f4 100644
--- a/iterator.c
+++ b/iterator.c
@@ -212,6 +212,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 	zval * current;
 	zval current_item;
 	zval key;
+	ZVAL_UNDEF(&current_item);
 
 	while (iterator->state != ASYNC_ITERATOR_FINISHED) {
 
@@ -221,7 +222,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			current = iterator->zend_iterator->funcs->get_current_data(iterator->zend_iterator);
 
 			if (current != NULL) {
-				ZVAL_COPY_VALUE(&current_item, current);
+				ZVAL_COPY(&current_item, current);
 				current = &current_item;
 			}
 		} else {
@@ -244,6 +245,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
                     iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
                 }
 
+				zval_ptr_dtor(&current_item);
 				continue;
 			}
 		}
@@ -277,6 +279,8 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			result = iterator->handler(iterator, current, &key);
 		}
 
+		zval_ptr_dtor(&current_item);
+
 		if (result == SUCCESS) {
 
 			if (Z_TYPE(retval) == IS_FALSE) {
diff --git a/tests/await/049-awaitAny_concurrent_iterator.phpt b/tests/await/049-awaitAny_concurrent_iterator.phpt
index 34fca37..f1f7bdc 100644
--- a/tests/await/049-awaitAny_concurrent_iterator.phpt
+++ b/tests/await/049-awaitAny_concurrent_iterator.phpt
@@ -44,7 +44,7 @@ class ConcurrentIterator implements Iterator
 echo "start\n";
 
 $functions = [
-    function() { suspend(); return "slow"; },
+    function() { suspend(); suspend(); return "slow"; },
     function() { return "fast"; },
     function() { suspend(); return "medium"; },
 ];

From 5e5080914d6105970a32a65e77ec7ce694373345 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 22:53:05 +0300
Subject: [PATCH 18/53] #9: * Correct implementation of the iterator, taking
 internal changes into account.       Now the algorithm properly handles
 coroutine interruptions during the rewind and next methods.

---
 async_API.c                                   |  2 +-
 iterator.c                                    | 50 +++++++++++++++++--
 iterator.h                                    |  5 +-
 .../047-awaitAll_concurrent_iterator.phpt     | 25 ++++++++--
 .../048-awaitAll_concurrent_generator.phpt    | 17 +++++++
 .../049-awaitAny_concurrent_iterator.phpt     | 23 +++++++--
 ...waitFirstSuccess_concurrent_generator.phpt |  2 +-
 7 files changed, 106 insertions(+), 18 deletions(-)

diff --git a/async_API.c b/async_API.c
index 7bc12c9..9502ad8 100644
--- a/async_API.c
+++ b/async_API.c
@@ -406,7 +406,7 @@ static void async_waiting_callback(
 		}
 	}
 
-	if (UNEXPECTED(AWAIT_ITERATOR_IS_FINISHED(await_context))) {
+	if (UNEXPECTED(AWAIT_ITERATOR_IS_FINISHED(await_context) && await_callback->callback.coroutine != NULL)) {
 		ZEND_ASYNC_RESUME(await_callback->callback.coroutine);
 	}
 
diff --git a/iterator.c b/iterator.c
index 4f1d2f4..ff80ff4 100644
--- a/iterator.c
+++ b/iterator.c
@@ -39,7 +39,8 @@ void iterator_microtask(zend_async_microtask_t *microtask)
 {
 	async_iterator_t *iterator = (async_iterator_t *) microtask;
 
-	if (iterator->state == ASYNC_ITERATOR_FINISHED || iterator->active_coroutines >= iterator->concurrency) {
+	if (iterator->state == ASYNC_ITERATOR_FINISHED
+		|| (iterator->concurrency > 0 && iterator->active_coroutines >= iterator->concurrency)) {
 		return;
 	}
 
@@ -101,6 +102,27 @@ void iterator_dtor(zend_async_microtask_t *microtask)
 	efree(microtask);
 }
 
+//
+// Start of the block for safe iterator modification.
+//
+// Safe iterator modification means making changes during which no new iterator coroutines will be created,
+// because the iterator’s state is undefined.
+//
+#define ITERATOR_SAFE_MOVING_START(iterator)		\
+	(iterator)->state = ASYNC_ITERATOR_MOVING;		\
+	(iterator)->microtask.is_cancelled = true;		\
+	uint32_t prev_ref_count = (iterator)->microtask.ref_count;
+
+//
+// End of the block for safe iterator modification.
+//
+#define ITERATOR_SAFE_MOVING_END(iterator)			\
+	(iterator)->state = ASYNC_ITERATOR_STARTED;		\
+	if (prev_ref_count != (iterator)->microtask.ref_count) {	\
+		(iterator)->microtask.is_cancelled = false;				\
+		ZEND_ASYNC_ADD_MICROTASK(&(iterator)->microtask);		\
+	}
+
 async_iterator_t * async_iterator_new(
 		zval *array,
 		zend_object_iterator *zend_iterator,
@@ -194,12 +216,15 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			// or just set it to the array
 			iterator->target_hash = Z_ARRVAL(iterator->array);
 		}
-	} else {
+	} else if (iterator->state == ASYNC_ITERATOR_INIT) {
+		iterator->state = ASYNC_ITERATOR_STARTED;
 		iterator->position = 0;
 		iterator->hash_iterator = -1;
 
 		if (iterator->zend_iterator->funcs->rewind) {
-			iterator->zend_iterator->funcs->rewind(iterator->zend_iterator);
+			ITERATOR_SAFE_MOVING_START(iterator) {
+				iterator->zend_iterator->funcs->rewind(iterator->zend_iterator);
+			} ITERATOR_SAFE_MOVING_END(iterator);
 		}
 
 		if (UNEXPECTED(EG(exception))) {
@@ -266,7 +291,24 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 	    	// And update the iterator position
 	    	EG(ht_iterators)[iterator->hash_iterator].pos = iterator->position;
         } else {
-            iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
+
+        	if (iterator->state == ASYNC_ITERATOR_MOVING) {
+        		// The iterator is in a state of waiting for a position change.
+        		// The coroutine cannot continue execution because
+        		// it cannot move the iterator to the next position.
+        		// We exit immediately.
+        		return;
+			}
+
+        	ITERATOR_SAFE_MOVING_START(iterator) {
+        		iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
+        	} ITERATOR_SAFE_MOVING_END(iterator);
+
+        	if (UNEXPECTED(EG(exception))) {
+        		iterator->state = ASYNC_ITERATOR_FINISHED;
+        		iterator->microtask.is_cancelled = true;
+        		return;
+        	}
         }
 
 		if (iterator->fcall != NULL) {
diff --git a/iterator.h b/iterator.h
index 9503ecf..a4dbd04 100644
--- a/iterator.h
+++ b/iterator.h
@@ -27,8 +27,9 @@ typedef zend_result (*async_iterator_handler_t)(async_iterator_t *iterator, zval
 typedef enum
 {
 	ASYNC_ITERATOR_INIT = 0,
-	ASYNC_ITERATOR_STARTED = 1,
-	ASYNC_ITERATOR_FINISHED = 2,
+	ASYNC_ITERATOR_MOVING,
+	ASYNC_ITERATOR_STARTED,
+	ASYNC_ITERATOR_FINISHED,
 } async_iterator_state_t;
 
 async_iterator_t * async_iterator_new(
diff --git a/tests/await/047-awaitAll_concurrent_iterator.phpt b/tests/await/047-awaitAll_concurrent_iterator.phpt
index c0b4d9e..b4e10f0 100644
--- a/tests/await/047-awaitAll_concurrent_iterator.phpt
+++ b/tests/await/047-awaitAll_concurrent_iterator.phpt
@@ -17,16 +17,14 @@ class ConcurrentIterator implements Iterator
     }
 
     public function rewind(): void {
+        suspend(); // Simulate concurrent access
         $this->position = 0;
     }
 
     public function current(): mixed {
-        // Suspend during iteration to simulate concurrent access
-        $position = $this->position;
-        suspend();
-        
         // Create coroutine after suspension
-        return spawn(fn() => $this->items[$position]);
+        echo "Current item: {$this->items[$this->position]}\n";
+        return spawn(fn() => $this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -34,6 +32,7 @@ class ConcurrentIterator implements Iterator
     }
 
     public function next(): void {
+        suspend(); // Simulate concurrent access
         $this->position++;
     }
 
@@ -47,6 +46,14 @@ echo "start\n";
 $values = ["first", "second", "third"];
 $iterator = new ConcurrentIterator($values);
 
+spawn(function() {
+    // Simulate some processing
+    for ($i = 1; $i <= 5; $i++) {
+        echo "Processing item $i\n";
+        suspend();
+    }
+});
+
 $results = awaitAll($iterator);
 
 echo "Results: " . implode(", ", $results) . "\n";
@@ -56,6 +63,14 @@ echo "end\n";
 ?>
 --EXPECT--
 start
+Processing item 1
+Processing item 2
+Current item: first
+Processing item 3
+Current item: second
+Processing item 4
+Current item: third
+Processing item 5
 Results: first, second, third
 Count: 3
 end
\ No newline at end of file
diff --git a/tests/await/048-awaitAll_concurrent_generator.phpt b/tests/await/048-awaitAll_concurrent_generator.phpt
index 5ad59a6..4cc8a58 100644
--- a/tests/await/048-awaitAll_concurrent_generator.phpt
+++ b/tests/await/048-awaitAll_concurrent_generator.phpt
@@ -11,6 +11,7 @@ function concurrentGenerator($values) {
     foreach ($values as $value) {
         // Suspend before yielding each coroutine
         suspend();
+        echo "Yielding item: $value\n";
         yield spawn(fn() => $value);
     }
 }
@@ -20,6 +21,14 @@ echo "start\n";
 $values = ["first", "second", "third"];
 $generator = concurrentGenerator($values);
 
+spawn(function() {
+    // Simulate some processing
+    for ($i = 1; $i <= 5; $i++) {
+        echo "Processing item $i\n";
+        suspend();
+    }
+});
+
 $results = awaitAll($generator);
 
 echo "Results: " . implode(", ", $results) . "\n";
@@ -29,6 +38,14 @@ echo "end\n";
 ?>
 --EXPECT--
 start
+Processing item 1
+Processing item 2
+Yielding item: first
+Processing item 3
+Yielding item: second
+Processing item 4
+Yielding item: third
+Processing item 5
 Results: first, second, third
 Count: 3
 end
\ No newline at end of file
diff --git a/tests/await/049-awaitAny_concurrent_iterator.phpt b/tests/await/049-awaitAny_concurrent_iterator.phpt
index f1f7bdc..40f8eda 100644
--- a/tests/await/049-awaitAny_concurrent_iterator.phpt
+++ b/tests/await/049-awaitAny_concurrent_iterator.phpt
@@ -17,15 +17,13 @@ class ConcurrentIterator implements Iterator
     }
 
     public function rewind(): void {
+        suspend(); // Simulate concurrent access
         $this->position = 0;
     }
 
     public function current(): mixed {
-        // Suspend during iteration
-        $position = $this->position;
-        suspend();
-        
-        return spawn($this->items[$position]);
+        echo "Current item at position: {$this->position}\n";
+        return spawn($this->items[$this->position]);
     }
 
     public function key(): mixed {
@@ -33,6 +31,7 @@ class ConcurrentIterator implements Iterator
     }
 
     public function next(): void {
+        suspend(); // Simulate concurrent access
         $this->position++;
     }
 
@@ -51,6 +50,14 @@ $functions = [
 
 $iterator = new ConcurrentIterator($functions);
 
+spawn(function() {
+    // Simulate some processing
+    for ($i = 1; $i <= 3; $i++) {
+        echo "Processing item $i\n";
+        suspend();
+    }
+});
+
 $result = awaitAny($iterator);
 
 echo "Result: $result\n";
@@ -59,5 +66,11 @@ echo "end\n";
 ?>
 --EXPECT--
 start
+Processing item 1
+Processing item 2
+Current item at position: 0
+Processing item 3
+Current item at position: 1
+Current item at position: 2
 Result: fast
 end
\ No newline at end of file
diff --git a/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt b/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
index b5c4121..0d54deb 100644
--- a/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
+++ b/tests/await/050-awaitFirstSuccess_concurrent_generator.phpt
@@ -18,7 +18,7 @@ function concurrentGenerator($functions) {
 echo "start\n";
 
 $functions = [
-    function() { throw new RuntimeException("error"); },
+    function() { suspend(); throw new RuntimeException("error"); },
     function() { return "success"; },
     function() { return "another success"; },
 ];

From 2e181820b53def9c751637f703268da98eb27ed6 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Sun, 6 Jul 2025 23:06:57 +0300
Subject: [PATCH 19/53] #9: * Correct implementation of the iterator, taking
 internal changes into account.       Now the algorithm properly handles
 coroutine interruptions during the rewind and next methods.

---
 iterator.c | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/iterator.c b/iterator.c
index ff80ff4..a252237 100644
--- a/iterator.c
+++ b/iterator.c
@@ -178,6 +178,13 @@ async_iterator_t * async_iterator_new(
 	return iterator;
 }
 
+#define RETURN_IF_EXCEPTION(iterator) \
+	if (UNEXPECTED(EG(exception))) { \
+		iterator->state = ASYNC_ITERATOR_FINISHED; \
+		iterator->microtask.is_cancelled = true; \
+		return; \
+	}
+
 static zend_always_inline void iterate(async_iterator_t *iterator)
 {
 	zend_result result = SUCCESS;
@@ -227,11 +234,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			} ITERATOR_SAFE_MOVING_END(iterator);
 		}
 
-		if (UNEXPECTED(EG(exception))) {
-			iterator->state = ASYNC_ITERATOR_FINISHED;
-			iterator->microtask.is_cancelled = true;
-			return;
-		}
+		RETURN_IF_EXCEPTION(iterator);
 	}
 
 	zval * current;
@@ -244,7 +247,10 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 		if (iterator->target_hash != NULL) {
 			current = zend_hash_get_current_data_ex(iterator->target_hash, &iterator->position);
 		} else if (SUCCESS == iterator->zend_iterator->funcs->valid(iterator->zend_iterator)) {
+
+			RETURN_IF_EXCEPTION(iterator);
 			current = iterator->zend_iterator->funcs->get_current_data(iterator->zend_iterator);
+			RETURN_IF_EXCEPTION(iterator);
 
 			if (current != NULL) {
 				ZVAL_COPY(&current_item, current);
@@ -262,15 +268,26 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 
 		/* Skip undefined indirect elements */
 		if (Z_TYPE_P(current) == IS_INDIRECT) {
+
 			current = Z_INDIRECT_P(current);
+			zval_ptr_dtor(&current_item);
+
 			if (Z_TYPE_P(current) == IS_UNDEF) {
 				if (iterator->zend_iterator == NULL) {
                     zend_hash_move_forward(Z_ARR(iterator->array));
                 } else {
-                    iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
+
+                	if (iterator->state == ASYNC_ITERATOR_MOVING) {
+                		return;
+                	}
+
+                	ITERATOR_SAFE_MOVING_START(iterator) {
+                		iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
+                	} ITERATOR_SAFE_MOVING_END(iterator);
+
+                	RETURN_IF_EXCEPTION(iterator);
                 }
 
-				zval_ptr_dtor(&current_item);
 				continue;
 			}
 		}
@@ -280,6 +297,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 			zend_hash_get_current_key_zval_ex(iterator->target_hash, &key, &iterator->position);
         } else {
             iterator->zend_iterator->funcs->get_current_key(iterator->zend_iterator, &key);
+        	RETURN_IF_EXCEPTION(iterator);
         }
 
 		/*
@@ -304,11 +322,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
         		iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
         	} ITERATOR_SAFE_MOVING_END(iterator);
 
-        	if (UNEXPECTED(EG(exception))) {
-        		iterator->state = ASYNC_ITERATOR_FINISHED;
-        		iterator->microtask.is_cancelled = true;
-        		return;
-        	}
+        	RETURN_IF_EXCEPTION(iterator);
         }
 
 		if (iterator->fcall != NULL) {

From fa6d03d2dafa5b9c408c7ee0eb73be9ba8e53091 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 11:45:41 +0300
Subject: [PATCH 20/53] =?UTF-8?q?#9:=20+=20Added=20functionality=20for=20p?=
 =?UTF-8?q?roper=20handling=20of=20exceptions=20from=20`Zend=20iterators`?=
 =?UTF-8?q?=20(`\Iterator`=20and=20`generators`).=20An=20exception=20that?=
 =?UTF-8?q?=20occurs=20in=20the=20iterator=20can=20now=20be=20handled=20by?=
 =?UTF-8?q?=20the=20iterator=E2=80=99s=20owner.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md |  8 ++++++++
 exceptions.c | 43 +++++++++++++++++++++++++++++++++++++++++++
 exceptions.h |  2 ++
 iterator.c   | 24 ++++++++++++++++++++++++
 iterator.h   |  1 +
 5 files changed, 78 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3cadf50..57fd1f3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,9 +27,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Memory management improvements for long-running async applications
 - Proper cleanup of coroutine and scope objects during garbage collection cycles
+- **Async Iterator API**:
+    - Fixed iterator state management to prevent memory leaks
 
 ### Changed
 - **LibUV requirement increased to ≥ 1.44.0** - Requires libuv version 1.44.0 or later to ensure proper UV_RUN_ONCE behavior and prevent busy loop issues that could cause high CPU usage
+- **Async Iterator API**:
+    - Proper handling of `REWIND`/`NEXT` states in a concurrent environment. 
+      The iterator code now stops iteration in 
+      coroutines if the iterator is in the process of changing its position.
+    - Added functionality for proper handling of exceptions from `Zend iterators` (`\Iterator` and `generators`).
+      An exception that occurs in the iterator can now be handled by the iterator’s owner.
 
 
 ## [0.2.0] - 2025-07-01
diff --git a/exceptions.c b/exceptions.c
index 0d7e469..cfa9a0e 100644
--- a/exceptions.c
+++ b/exceptions.c
@@ -281,6 +281,49 @@ bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, in
 	return true;
 }
 
+/**
+ * Extracts the current exception from the global state, saves it, and clears it.
+ *
+ * @return The extracted exception object with an increased reference count.
+ */
+zend_object * async_extract_exception(void)
+{
+	zend_exception_save();
+	zend_exception_restore();
+	zend_object *exception = EG(exception);
+	GC_ADDREF(exception);
+	zend_clear_exception();
+
+	return exception;
+}
+
+/**
+ * Applies the current exception to the provided exception pointer.
+ *
+ * If the current exception is not a cancellation exception or a graceful/unwind exit,
+ * it extracts the current exception and sets it as the new exception.
+ * If `to_exception` is not NULL, it sets the previous exception to the extracted one.
+ *
+ * @param to_exception Pointer to a pointer where the new exception will be set.
+ */
+void async_apply_exception(zend_object **to_exception)
+{
+	if (UNEXPECTED(EG(exception)
+		&& false == (
+			instanceof_function(EG(exception)->ce, zend_ce_cancellation_exception)
+			|| zend_is_graceful_exit(EG(exception)) || zend_is_unwind_exit(EG(exception))
+		))) {
+
+		zend_object *exception = async_extract_exception();
+
+		if (*to_exception != NULL) {
+			zend_exception_set_previous(exception, *to_exception);
+		}
+
+		*to_exception = exception;
+	}
+}
+
 void async_rethrow_exception(zend_object *exception)
 {
 	if (EG(current_execute_data)) {
diff --git a/exceptions.h b/exceptions.h
index c8b6dc0..a1222f7 100644
--- a/exceptions.h
+++ b/exceptions.h
@@ -41,7 +41,9 @@ ZEND_API ZEND_COLD zend_object * async_new_composite_exception(void);
 ZEND_API void async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer);
 bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, int32_t priority);
 void async_apply_exception_to_context(zend_object *exception);
+zend_object * async_extract_exception(void);
 void async_rethrow_exception(zend_object *exception);
+void async_apply_exception(zend_object **to_exception);
 
 END_EXTERN_C()
 
diff --git a/iterator.c b/iterator.c
index a252237..571ce1f 100644
--- a/iterator.c
+++ b/iterator.c
@@ -99,6 +99,12 @@ void iterator_dtor(zend_async_microtask_t *microtask)
 		iterator->fcall = NULL;
 	}
 
+	if (iterator->exception != NULL) {
+		zend_object *exception = iterator->exception;
+		iterator->exception = NULL;
+		OBJ_RELEASE(exception);
+	}
+
 	efree(microtask);
 }
 
@@ -155,6 +161,7 @@ async_iterator_t * async_iterator_new(
 	if (scope == NULL) {
 		scope = ZEND_ASYNC_CURRENT_SCOPE;
 	}
+
 	iterator->scope = scope;
 
 	if (zend_iterator == NULL) {
@@ -411,6 +418,7 @@ void async_iterator_run(async_iterator_t *iterator)
 	ZEND_ASYNC_ADD_MICROTASK(&iterator->microtask);
 
 	iterate(iterator);
+	async_iterator_apply_exception(iterator);
 }
 
 /**
@@ -431,4 +439,20 @@ void async_iterator_run_in_coroutine(async_iterator_t *iterator, int32_t priorit
 	iterator_coroutine->extended_data = iterator;
 	iterator_coroutine->internal_entry = coroutine_entry;
 	iterator_coroutine->extended_dispose = coroutine_extended_dispose;
+}
+
+void async_iterator_apply_exception(async_iterator_t *iterator)
+{
+	async_apply_exception(&iterator->exception);
+
+	if (iterator->exception == NULL || ZEND_ASYNC_SCOPE_IS_CANCELLED(iterator->scope)) {
+		return;
+	}
+
+	ZEND_ASYNC_SCOPE_CANCEL(
+		iterator->scope,
+		async_new_exception(async_ce_cancellation_exception, "Cancellation of the iterator due to an exception"),
+		true,
+		ZEND_ASYNC_SCOPE_IS_DISPOSE_SAFELY(iterator->scope)
+	);
 }
\ No newline at end of file
diff --git a/iterator.h b/iterator.h
index a4dbd04..4043e5c 100644
--- a/iterator.h
+++ b/iterator.h
@@ -47,6 +47,7 @@ async_iterator_t * async_iterator_new(
 
 void async_iterator_run(async_iterator_t *iterator);
 void async_iterator_run_in_coroutine(async_iterator_t *iterator, int32_t priority);
+void async_iterator_apply_exception(async_iterator_t *iterator);
 
 struct _async_iterator_t {
 	ZEND_ASYNC_ITERATOR_FIELDS

From f3f6ce9fe7e41b173ca94feebe19e66a719fb9e7 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 12:16:29 +0300
Subject: [PATCH 21/53] #9: % refactoring
 await_iterator_dispose(await_iterator, NULL);

---
 async_API.c | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/async_API.c b/async_API.c
index 9502ad8..abddf94 100644
--- a/async_API.c
+++ b/async_API.c
@@ -562,9 +562,18 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
  * It cleans up the internal state and releases resources.
  *
  * @param iterator
+ * @param concurrent_iterator
  */
-static void await_iterator_dispose(async_await_iterator_t * iterator)
+static void await_iterator_dispose(async_await_iterator_t * iterator, async_iterator_t *concurrent_iterator)
 {
+	// If the iterator was completed with an exception,
+	// pass that exception to the coroutine that is waiting.
+	if (concurrent_iterator != NULL && concurrent_iterator->exception != NULL) {
+		zend_object *exception = concurrent_iterator->exception;
+		concurrent_iterator->exception = NULL;
+		ZEND_ASYNC_RESUME_WITH_ERROR(iterator->waiting_coroutine, exception, true);
+	}
+
 	if (iterator->zend_iterator != NULL) {
 		zend_object_iterator *zend_iterator = iterator->zend_iterator;
 		iterator->zend_iterator = NULL;
@@ -602,7 +611,7 @@ static void await_iterator_finish_callback(zend_async_iterator_t *internal_itera
 	async_await_iterator_t * await_iterator = iterator->await_iterator;
 	iterator->await_iterator = NULL;
 
-	await_iterator_dispose(await_iterator);
+	await_iterator_dispose(await_iterator, &iterator->iterator);
 }
 
 /**
@@ -632,7 +641,7 @@ static void iterator_coroutine_first_entry(void)
 	async_await_context_t * await_context = await_iterator->await_context;
 
 	if (UNEXPECTED(await_context == NULL)) {
-		await_iterator_dispose(await_iterator);
+		await_iterator_dispose(await_iterator, NULL);
 		return;
 	}
 
@@ -651,7 +660,7 @@ static void iterator_coroutine_first_entry(void)
 	iterator->iterator.extended_dtor = await_iterator_finish_callback;
 
 	if (UNEXPECTED(iterator == NULL)) {
-		await_iterator_dispose(await_iterator);
+		await_iterator_dispose(await_iterator, NULL);
 		return;
 	}
 
@@ -704,7 +713,7 @@ static void async_await_iterator_coroutine_dispose(zend_coroutine_t *coroutine)
 	async_await_iterator_t * await_iterator = (async_await_iterator_t *) coroutine->extended_data;
 	coroutine->extended_data = NULL;
 
-	await_iterator_dispose(await_iterator);
+	await_iterator_dispose(await_iterator, NULL);
 }
 
 static void await_context_dtor(async_await_context_t *context)

From d05cde407f081c19b606d6d0b157df300a425682 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 19:40:28 +0300
Subject: [PATCH 22/53] #9: % An attempt to cancel a coroutine that is
 currently running.       In this case, nothing actually happens immediately;
 however, the coroutine is marked as having been cancelled, and the
 cancellation exception is stored as its result.

---
 coroutine.c | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index 804b8df..36f327f 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -978,8 +978,28 @@ void async_coroutine_cancel(zend_coroutine_t *zend_coroutine, zend_object *error
 		return;
 	}
 
-	if (ZEND_ASYNC_SCHEDULER_CONTEXT && zend_coroutine == ZEND_ASYNC_CURRENT_COROUTINE) {
-		zend_throw_error(zend_ce_cancellation_exception, "Coroutine has been canceled");
+	// An attempt to cancel a coroutine that is currently running.
+	// In this case, nothing actually happens immediately;
+	// however, the coroutine is marked as having been cancelled,
+	// and the cancellation exception is stored as its result.
+	if (UNEXPECTED(zend_coroutine == ZEND_ASYNC_CURRENT_COROUTINE)) {
+
+		ZEND_COROUTINE_SET_CANCELLED(zend_coroutine);
+
+		if (zend_coroutine->exception == NULL) {
+			zend_coroutine->exception = error;
+
+			if (false == transfer_error) {
+				GC_ADDREF(error);
+			}
+		}
+
+		if (zend_coroutine->exception == NULL) {
+			zend_coroutine->exception = async_new_exception(
+				async_ce_cancellation_exception, "Coroutine cancelled"
+			);
+		}
+
 		return;
 	}
 

From 986bff99114342dbc2c2bc635395bcd491704635 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 20:51:45 +0300
Subject: [PATCH 23/53] #9: * Fixed the behavior of the concurrent iterator for
 the generator. Memory leaks have been eliminated.

---
 iterator.c | 44 ++++++++++++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/iterator.c b/iterator.c
index 571ce1f..f9ef925 100644
--- a/iterator.c
+++ b/iterator.c
@@ -192,12 +192,28 @@ async_iterator_t * async_iterator_new(
 		return; \
 	}
 
+#define RETURN_IF_EXCEPTION_AND(iterator, and) \
+	if (UNEXPECTED(EG(exception))) { \
+		iterator->state = ASYNC_ITERATOR_FINISHED; \
+		iterator->microtask.is_cancelled = true; \
+		and; \
+		return; \
+	}
+
 static zend_always_inline void iterate(async_iterator_t *iterator)
 {
 	zend_result result = SUCCESS;
 	zval retval;
 	ZVAL_UNDEF(&retval);
 
+	if (UNEXPECTED(iterator->state == ASYNC_ITERATOR_MOVING)) {
+		// The iterator is in a state of waiting for a position change.
+		// The coroutine cannot continue execution because
+		// it cannot move the iterator to the next position.
+		// We exit immediately.
+		return;
+	}
+
 	zend_fcall_info fci;
 
 	// Copy the fci to avoid overwriting the original
@@ -251,12 +267,21 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 
 	while (iterator->state != ASYNC_ITERATOR_FINISHED) {
 
+		if (iterator->state == ASYNC_ITERATOR_MOVING) {
+			// The iterator is in a state of waiting for a position change.
+			// The coroutine cannot continue execution because
+			// it cannot move the iterator to the next position.
+			break;
+		}
+
 		if (iterator->target_hash != NULL) {
 			current = zend_hash_get_current_data_ex(iterator->target_hash, &iterator->position);
 		} else if (SUCCESS == iterator->zend_iterator->funcs->valid(iterator->zend_iterator)) {
 
 			RETURN_IF_EXCEPTION(iterator);
-			current = iterator->zend_iterator->funcs->get_current_data(iterator->zend_iterator);
+			ITERATOR_SAFE_MOVING_START(iterator) {
+				current = iterator->zend_iterator->funcs->get_current_data(iterator->zend_iterator);
+			} ITERATOR_SAFE_MOVING_END(iterator);
 			RETURN_IF_EXCEPTION(iterator);
 
 			if (current != NULL) {
@@ -303,8 +328,11 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 		if (iterator->target_hash != NULL) {
 			zend_hash_get_current_key_zval_ex(iterator->target_hash, &key, &iterator->position);
         } else {
-            iterator->zend_iterator->funcs->get_current_key(iterator->zend_iterator, &key);
-        	RETURN_IF_EXCEPTION(iterator);
+        	ITERATOR_SAFE_MOVING_START(iterator) {
+        		iterator->zend_iterator->funcs->get_current_key(iterator->zend_iterator, &key);
+        	} ITERATOR_SAFE_MOVING_END(iterator);
+
+        	RETURN_IF_EXCEPTION_AND(iterator, zval_ptr_dtor(&current_item));
         }
 
 		/*
@@ -317,19 +345,11 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 	    	EG(ht_iterators)[iterator->hash_iterator].pos = iterator->position;
         } else {
 
-        	if (iterator->state == ASYNC_ITERATOR_MOVING) {
-        		// The iterator is in a state of waiting for a position change.
-        		// The coroutine cannot continue execution because
-        		// it cannot move the iterator to the next position.
-        		// We exit immediately.
-        		return;
-			}
-
         	ITERATOR_SAFE_MOVING_START(iterator) {
         		iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
         	} ITERATOR_SAFE_MOVING_END(iterator);
 
-        	RETURN_IF_EXCEPTION(iterator);
+        	RETURN_IF_EXCEPTION_AND(iterator, zval_ptr_dtor(&current_item));
         }
 
 		if (iterator->fcall != NULL) {

From 0628af85dc0b2de3f81363dae9a2b044541716d9 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 23:12:03 +0300
Subject: [PATCH 24/53] #9: * Fix edge_cases tests

---
 tests/edge_cases/002-deadlock-with-catch.phpt  | 1 -
 tests/edge_cases/003-deadlock-with-zombie.phpt | 1 -
 2 files changed, 2 deletions(-)

diff --git a/tests/edge_cases/002-deadlock-with-catch.phpt b/tests/edge_cases/002-deadlock-with-catch.phpt
index 8dbaf79..f13b1a6 100644
--- a/tests/edge_cases/002-deadlock-with-catch.phpt
+++ b/tests/edge_cases/002-deadlock-with-catch.phpt
@@ -49,5 +49,4 @@ Warning: the coroutine was suspended in file: %s, line: %d will be canceled in U
 Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
 Caught exception: Deadlock detected
 coroutine1 finished
-Caught exception: Deadlock detected
 coroutine2 finished
\ No newline at end of file
diff --git a/tests/edge_cases/003-deadlock-with-zombie.phpt b/tests/edge_cases/003-deadlock-with-zombie.phpt
index 0309800..371988a 100644
--- a/tests/edge_cases/003-deadlock-with-zombie.phpt
+++ b/tests/edge_cases/003-deadlock-with-zombie.phpt
@@ -54,6 +54,5 @@ Warning: the coroutine was suspended in file: %s, line: %d will be canceled in U
 
 Warning: the coroutine was suspended in file: %s, line: %d will be canceled in Unknown on line %d
 Caught exception: Deadlock detected
-Caught exception: Deadlock detected
 coroutine1 finished
 coroutine2 finished
\ No newline at end of file

From de49ae324bed107c7080da501c71966aaa0649f8 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 23:22:19 +0300
Subject: [PATCH 25/53] #9: + spawnWith tests

---
 async.c                                       |  2 +-
 async_API.c                                   | 11 +++-
 tests/spawnWith/001-spawnWith_basic.phpt      | 32 ++++++++++
 .../002-spawnWith_with_arguments.phpt         | 29 +++++++++
 .../003-spawnWith_return_coroutine.phpt       | 27 ++++++++
 .../004-spawnWith_custom_scope_provider.phpt  | 49 +++++++++++++++
 .../005-spawnWith_null_scope_provider.phpt    | 40 ++++++++++++
 .../006-spawnWith_inherited_scope.phpt        | 30 +++++++++
 .../007-spawnWith_spawn_strategy.phpt         | 61 ++++++++++++++++++
 .../008-spawnWith_strategy_hook_order.phpt    | 61 ++++++++++++++++++
 .../009-spawnWith_strategy_exception.phpt     | 62 +++++++++++++++++++
 .../010-spawnWith_invalid_provider.phpt       | 39 ++++++++++++
 .../011-spawnWith_missing_parameters.phpt     | 31 ++++++++++
 .../012-spawnWith_invalid_callable.phpt       | 42 +++++++++++++
 14 files changed, 513 insertions(+), 3 deletions(-)
 create mode 100644 tests/spawnWith/001-spawnWith_basic.phpt
 create mode 100644 tests/spawnWith/002-spawnWith_with_arguments.phpt
 create mode 100644 tests/spawnWith/003-spawnWith_return_coroutine.phpt
 create mode 100644 tests/spawnWith/004-spawnWith_custom_scope_provider.phpt
 create mode 100644 tests/spawnWith/005-spawnWith_null_scope_provider.phpt
 create mode 100644 tests/spawnWith/006-spawnWith_inherited_scope.phpt
 create mode 100644 tests/spawnWith/007-spawnWith_spawn_strategy.phpt
 create mode 100644 tests/spawnWith/008-spawnWith_strategy_hook_order.phpt
 create mode 100644 tests/spawnWith/009-spawnWith_strategy_exception.phpt
 create mode 100644 tests/spawnWith/010-spawnWith_invalid_provider.phpt
 create mode 100644 tests/spawnWith/011-spawnWith_missing_parameters.phpt
 create mode 100644 tests/spawnWith/012-spawnWith_invalid_callable.phpt

diff --git a/async.c b/async.c
index 04e05fa..769f8cd 100644
--- a/async.c
+++ b/async.c
@@ -125,7 +125,7 @@ PHP_FUNCTION(Async_spawnWith)
 
 	coroutine->coroutine.fcall = fcall;
 
-	RETURN_OBJ(&coroutine->std);
+	RETURN_OBJ_COPY(&coroutine->std);
 }
 
 PHP_FUNCTION(Async_suspend)
diff --git a/async_API.c b/async_API.c
index abddf94..6311985 100644
--- a/async_API.c
+++ b/async_API.c
@@ -39,6 +39,10 @@ zend_async_scope_t * async_provide_scope(zend_object *scope_provider)
 
 	zval_ptr_dtor(&retval);
 
+	if (Z_TYPE(retval) == IS_NULL) {
+		return NULL;
+	}
+
 	zend_async_throw(
 		ZEND_ASYNC_EXCEPTION_DEFAULT,
 		"Scope provider must return an instance of Async\\Scope"
@@ -111,8 +115,11 @@ zend_coroutine_t *spawn(zend_async_scope_t *scope, zend_object * scope_provider,
 		return NULL;
 	}
 
+	const bool is_spawn_strategy = scope_provider != NULL
+								&& instanceof_function(scope_provider->ce, async_ce_spawn_strategy);
+
 	// call SpawnStrategy::beforeCoroutineEnqueue
-	if (scope_provider != NULL) {
+	if (is_spawn_strategy) {
 		zval coroutine_zval, scope_zval;
 		ZVAL_OBJ(&coroutine_zval, &coroutine->std);
 		ZVAL_OBJ(&scope_zval, scope->scope_object);
@@ -164,7 +171,7 @@ zend_coroutine_t *spawn(zend_async_scope_t *scope, zend_object * scope_provider,
 	}
 
 	// call SpawnStrategy::afterCoroutineEnqueue
-	if (scope_provider != NULL) {
+	if (is_spawn_strategy) {
 		zval coroutine_zval, scope_zval;
 		ZVAL_OBJ(&coroutine_zval, &coroutine->std);
 		ZVAL_OBJ(&scope_zval, scope->scope_object);
diff --git a/tests/spawnWith/001-spawnWith_basic.phpt b/tests/spawnWith/001-spawnWith_basic.phpt
new file mode 100644
index 0000000..e549d3e
--- /dev/null
+++ b/tests/spawnWith/001-spawnWith_basic.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Async\spawnWith: basic usage with Scope
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\Scope;
+
+echo "start\n";
+
+$scope = new Scope();
+
+$coroutine = spawnWith($scope, function() {
+    echo "coroutine executed\n";
+    return "test result";
+});
+
+echo "spawned coroutine\n";
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawned coroutine
+coroutine executed
+result: test result
+end
\ No newline at end of file
diff --git a/tests/spawnWith/002-spawnWith_with_arguments.phpt b/tests/spawnWith/002-spawnWith_with_arguments.phpt
new file mode 100644
index 0000000..b81e90e
--- /dev/null
+++ b/tests/spawnWith/002-spawnWith_with_arguments.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Async\spawnWith: with arguments
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\Scope;
+
+echo "start\n";
+
+$scope = new Scope();
+
+$coroutine = spawnWith($scope, function($a, $b, $c) {
+    echo "arguments: $a, $b, $c\n";
+    return $a + $b + $c;
+}, 10, 20, 30);
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+arguments: 10, 20, 30
+result: 60
+end
\ No newline at end of file
diff --git a/tests/spawnWith/003-spawnWith_return_coroutine.phpt b/tests/spawnWith/003-spawnWith_return_coroutine.phpt
new file mode 100644
index 0000000..5ec1bfd
--- /dev/null
+++ b/tests/spawnWith/003-spawnWith_return_coroutine.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Async\spawnWith: returns Coroutine instance
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\Scope;
+use Async\Coroutine;
+
+$scope = new Scope();
+
+$coroutine = spawnWith($scope, function() {
+    return "test";
+});
+
+var_dump($coroutine instanceof Coroutine);
+var_dump(is_int($coroutine->getId()));
+
+$result = await($coroutine);
+var_dump($result);
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+string(4) "test"
\ No newline at end of file
diff --git a/tests/spawnWith/004-spawnWith_custom_scope_provider.phpt b/tests/spawnWith/004-spawnWith_custom_scope_provider.phpt
new file mode 100644
index 0000000..0493cf1
--- /dev/null
+++ b/tests/spawnWith/004-spawnWith_custom_scope_provider.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Async\spawnWith: custom ScopeProvider implementation
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\ScopeProvider;
+use Async\Scope;
+
+class CustomScopeProvider implements ScopeProvider
+{
+    private $scope;
+    
+    public function __construct()
+    {
+        $this->scope = new Scope();
+        echo "CustomScopeProvider created\n";
+    }
+    
+    public function provideScope(): ?Scope
+    {
+        echo "provideScope called\n";
+        return $this->scope;
+    }
+}
+
+echo "start\n";
+
+$provider = new CustomScopeProvider();
+
+$coroutine = spawnWith($provider, function() {
+    echo "coroutine executed\n";
+    return "custom provider result";
+});
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+CustomScopeProvider created
+provideScope called
+coroutine executed
+result: custom provider result
+end
\ No newline at end of file
diff --git a/tests/spawnWith/005-spawnWith_null_scope_provider.phpt b/tests/spawnWith/005-spawnWith_null_scope_provider.phpt
new file mode 100644
index 0000000..695dd6a
--- /dev/null
+++ b/tests/spawnWith/005-spawnWith_null_scope_provider.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Async\spawnWith: ScopeProvider returning null scope
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\ScopeProvider;
+use Async\Scope;
+
+class NullScopeProvider implements ScopeProvider
+{
+    public function provideScope(): ?Scope
+    {
+        echo "returning null scope\n";
+        return null;
+    }
+}
+
+echo "start\n";
+
+$provider = new NullScopeProvider();
+
+$coroutine = spawnWith($provider, function() {
+    echo "coroutine executed\n";
+    return "null scope result";
+});
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+returning null scope
+coroutine executed
+result: null scope result
+end
\ No newline at end of file
diff --git a/tests/spawnWith/006-spawnWith_inherited_scope.phpt b/tests/spawnWith/006-spawnWith_inherited_scope.phpt
new file mode 100644
index 0000000..874907f
--- /dev/null
+++ b/tests/spawnWith/006-spawnWith_inherited_scope.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Async\spawnWith: with inherited scope
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\Scope;
+
+echo "start\n";
+
+$parentScope = new Scope();
+$childScope = Scope::inherit($parentScope);
+
+$coroutine = spawnWith($childScope, function() {
+    echo "coroutine in child scope\n";
+    return "inherited scope result";
+});
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+coroutine in child scope
+result: inherited scope result
+end
\ No newline at end of file
diff --git a/tests/spawnWith/007-spawnWith_spawn_strategy.phpt b/tests/spawnWith/007-spawnWith_spawn_strategy.phpt
new file mode 100644
index 0000000..068fbc4
--- /dev/null
+++ b/tests/spawnWith/007-spawnWith_spawn_strategy.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Async\spawnWith: SpawnStrategy with hooks
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\SpawnStrategy;
+use Async\Scope;
+use Async\Coroutine;
+
+class TestSpawnStrategy implements SpawnStrategy
+{
+    private $scope;
+    
+    public function __construct()
+    {
+        $this->scope = new Scope();
+    }
+    
+    public function provideScope(): ?Scope
+    {
+        echo "provideScope called\n";
+        return $this->scope;
+    }
+    
+    public function beforeCoroutineEnqueue(Coroutine $coroutine, Scope $scope): array
+    {
+        echo "beforeCoroutineEnqueue called with coroutine ID: " . $coroutine->getId() . "\n";
+        return [];
+    }
+    
+    public function afterCoroutineEnqueue(Coroutine $coroutine, Scope $scope): void
+    {
+        echo "afterCoroutineEnqueue called with coroutine ID: " . $coroutine->getId() . "\n";
+    }
+}
+
+echo "start\n";
+
+$strategy = new TestSpawnStrategy();
+
+$coroutine = spawnWith($strategy, function() {
+    echo "coroutine executed\n";
+    return "strategy result";
+});
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+provideScope called
+beforeCoroutineEnqueue called with coroutine ID: %d
+afterCoroutineEnqueue called with coroutine ID: %d
+coroutine executed
+result: strategy result
+end
\ No newline at end of file
diff --git a/tests/spawnWith/008-spawnWith_strategy_hook_order.phpt b/tests/spawnWith/008-spawnWith_strategy_hook_order.phpt
new file mode 100644
index 0000000..b61fb1c
--- /dev/null
+++ b/tests/spawnWith/008-spawnWith_strategy_hook_order.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Async\spawnWith: SpawnStrategy hook execution order
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\SpawnStrategy;
+use Async\Scope;
+use Async\Coroutine;
+
+class OrderTestStrategy implements SpawnStrategy
+{
+    private $scope;
+    
+    public function __construct()
+    {
+        $this->scope = new Scope();
+    }
+    
+    public function provideScope(): ?Scope
+    {
+        echo "1. provideScope\n";
+        return $this->scope;
+    }
+    
+    public function beforeCoroutineEnqueue(Coroutine $coroutine, Scope $scope): array
+    {
+        echo "2. beforeCoroutineEnqueue\n";
+        return [];
+    }
+    
+    public function afterCoroutineEnqueue(Coroutine $coroutine, Scope $scope): void
+    {
+        echo "4. afterCoroutineEnqueue\n";
+    }
+}
+
+echo "start\n";
+
+$strategy = new OrderTestStrategy();
+
+$coroutine = spawnWith($strategy, function() {
+    echo "3. coroutine executed\n";
+    return "order test";
+});
+
+$result = await($coroutine);
+echo "result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+1. provideScope
+2. beforeCoroutineEnqueue
+4. afterCoroutineEnqueue
+3. coroutine executed
+result: order test
+end
\ No newline at end of file
diff --git a/tests/spawnWith/009-spawnWith_strategy_exception.phpt b/tests/spawnWith/009-spawnWith_strategy_exception.phpt
new file mode 100644
index 0000000..0096061
--- /dev/null
+++ b/tests/spawnWith/009-spawnWith_strategy_exception.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Async\spawnWith: SpawnStrategy with exception in coroutine
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use function Async\await;
+use Async\SpawnStrategy;
+use Async\Scope;
+use Async\Coroutine;
+
+class ExceptionTestStrategy implements SpawnStrategy
+{
+    private $scope;
+    
+    public function __construct()
+    {
+        $this->scope = new Scope();
+    }
+    
+    public function provideScope(): ?Scope
+    {
+        return $this->scope;
+    }
+    
+    public function beforeCoroutineEnqueue(Coroutine $coroutine, Scope $scope): array
+    {
+        echo "before coroutine enqueue\n";
+        return [];
+    }
+    
+    public function afterCoroutineEnqueue(Coroutine $coroutine, Scope $scope): void
+    {
+        echo "after coroutine enqueue\n";
+    }
+}
+
+echo "start\n";
+
+$strategy = new ExceptionTestStrategy();
+
+$coroutine = spawnWith($strategy, function() {
+    echo "coroutine start\n";
+    throw new RuntimeException("test exception from coroutine");
+});
+
+try {
+    await($coroutine);
+} catch (RuntimeException $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+before coroutine enqueue
+after coroutine enqueue
+coroutine start
+caught exception: test exception from coroutine
+end
\ No newline at end of file
diff --git a/tests/spawnWith/010-spawnWith_invalid_provider.phpt b/tests/spawnWith/010-spawnWith_invalid_provider.phpt
new file mode 100644
index 0000000..6e16ded
--- /dev/null
+++ b/tests/spawnWith/010-spawnWith_invalid_provider.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Async\spawnWith: invalid provider parameter
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+// Test with non-ScopeProvider parameter
+try {
+    spawnWith("not a provider", function() {});
+} catch (TypeError $e) {
+    echo "caught TypeError for string: " . $e->getMessage() . "\n";
+}
+
+// Test with array
+try {
+    spawnWith([], function() {});
+} catch (TypeError $e) {
+    echo "caught TypeError for array\n";
+}
+
+// Test with stdClass
+try {
+    spawnWith(new stdClass(), function() {});
+} catch (TypeError $e) {
+    echo "caught TypeError for stdClass\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+caught TypeError for string: %s
+caught TypeError for array
+caught TypeError for stdClass
+end
\ No newline at end of file
diff --git a/tests/spawnWith/011-spawnWith_missing_parameters.phpt b/tests/spawnWith/011-spawnWith_missing_parameters.phpt
new file mode 100644
index 0000000..07c37ef
--- /dev/null
+++ b/tests/spawnWith/011-spawnWith_missing_parameters.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Async\spawnWith: missing required parameters
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+// Test with no parameters
+try {
+    spawnWith();
+} catch (ArgumentCountError $e) {
+    echo "caught ArgumentCountError for no params: " . $e->getMessage() . "\n";
+}
+
+// Test with only provider
+try {
+    spawnWith(new Async\Scope());
+} catch (ArgumentCountError $e) {
+    echo "caught ArgumentCountError for missing callable\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+caught ArgumentCountError for no params: %s
+caught ArgumentCountError for missing callable
+end
\ No newline at end of file
diff --git a/tests/spawnWith/012-spawnWith_invalid_callable.phpt b/tests/spawnWith/012-spawnWith_invalid_callable.phpt
new file mode 100644
index 0000000..5faff3e
--- /dev/null
+++ b/tests/spawnWith/012-spawnWith_invalid_callable.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Async\spawnWith: invalid callable parameter
+--FILE--
+<?php
+
+use function Async\spawnWith;
+use Async\Scope;
+
+echo "start\n";
+
+$scope = new Scope();
+
+// Test with non-callable parameter
+try {
+    spawnWith($scope, "not a callable");
+} catch (TypeError $e) {
+    echo "caught TypeError for string: " . $e->getMessage() . "\n";
+}
+
+// Test with array (not callable)
+try {
+    spawnWith($scope, []);
+} catch (TypeError $e) {
+    echo "caught TypeError for array\n";
+}
+
+// Test with null
+try {
+    spawnWith($scope, null);
+} catch (TypeError $e) {
+    echo "caught TypeError for null\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+caught TypeError for string: %s
+caught TypeError for array
+caught TypeError for null
+end
\ No newline at end of file

From 1d45b98d104849ded47f7dd2a49a63301b501cca Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Mon, 7 Jul 2025 23:24:15 +0300
Subject: [PATCH 26/53] #9: + spawnWith tests

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57fd1f3..e9edced 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Proper cleanup of coroutine and scope objects during garbage collection cycles
 - **Async Iterator API**:
     - Fixed iterator state management to prevent memory leaks
+- Fixed the `spawnWith()` function for interaction with the `ScopeProvider` and `SpawnStrategy` interface
 
 ### Changed
 - **LibUV requirement increased to ≥ 1.44.0** - Requires libuv version 1.44.0 or later to ensure proper UV_RUN_ONCE behavior and prevent busy loop issues that could cause high CPU usage

From 3ea811fae49718b464e1f0e3bffcab985308f315 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 09:24:44 +0300
Subject: [PATCH 27/53] #9: update build-cross-platform

---
 .github/workflows/build-cross-platform.yml | 283 +++++++++++++--------
 1 file changed, 171 insertions(+), 112 deletions(-)

diff --git a/.github/workflows/build-cross-platform.yml b/.github/workflows/build-cross-platform.yml
index 5aa33ba..ce7efb6 100644
--- a/.github/workflows/build-cross-platform.yml
+++ b/.github/workflows/build-cross-platform.yml
@@ -7,21 +7,35 @@ on:
     branches: [build]
 
 jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - os: ubuntu-latest
-            platform: linux
-          - os: windows-latest  
-            platform: windows
-          - os: macos-latest
-            platform: macos
-    
-    runs-on: ${{ matrix.os }}
+  # Ubuntu build with database services (matches build.yml)
+  ubuntu-database-build:
+    runs-on: ubuntu-latest
 
+    services:
+      mysql:
+        image: mysql:8.3
+        env:
+          MYSQL_ROOT_PASSWORD: ''
+          MYSQL_ALLOW_EMPTY_PASSWORD: yes
+          MYSQL_DATABASE: test
+        ports: ['3306:3306']
+        options: >-
+          --health-cmd="mysqladmin ping --silent"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=5
+
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: test
+        ports: ['5432:5432']
+        options: >-
+          --health-cmd="pg_isready"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=5
 
     steps:
       - name: Checkout php-async repo
@@ -38,83 +52,52 @@ jobs:
           mkdir -p php-src/ext/async
           cp -r async/* php-src/ext/async/
 
-      # ==================== UBUNTU DEPENDENCIES ====================
-      - name: Install build dependencies (Ubuntu)
-        if: matrix.os == 'ubuntu-latest'
+      - name: Install build dependencies
         run: |
           sudo apt-get update
           sudo apt-get install -y \
             gcc g++ autoconf bison re2c \
-            libgmp-dev libicu-dev libtidy-dev libenchant-2-dev \
-            libzip-dev libbz2-dev libsqlite3-dev libwebp-dev libonig-dev libcurl4-openssl-dev \
-            libxml2-dev libxslt1-dev libreadline-dev libsodium-dev \
-            libargon2-dev libjpeg-dev libpng-dev libfreetype6-dev libuv1-dev
-          g++ --version
-          sudo mkdir -p /var/lib/snmp && sudo chown $(id -u):$(id -g) /var/lib/snmp
-
-      # ==================== WINDOWS DEPENDENCIES ====================
-      - name: Install build dependencies (Windows)
-        if: matrix.os == 'windows-latest'
-        run: |
-          # Install php-sdk
-          git clone https://github.com/Microsoft/php-sdk-binary-tools.git C:\php-sdk
-          
-          # Install vcpkg and LibUV
-          git clone https://github.com/Microsoft/vcpkg.git C:\vcpkg
-          C:\vcpkg\bootstrap-vcpkg.bat
-          C:\vcpkg\vcpkg.exe install libuv:x64-windows
-          
-          # Create deps structure for php-sdk
-          mkdir C:\php-sdk\deps\include\libuv
-          mkdir C:\php-sdk\deps\lib
-          
-          # Copy LibUV files
-          xcopy /E /I C:\vcpkg\installed\x64-windows\include C:\php-sdk\deps\include\libuv\
-          copy C:\vcpkg\installed\x64-windows\lib\uv.lib C:\php-sdk\deps\lib\libuv.lib
-        shell: cmd
+            libgmp-dev libicu-dev libtidy-dev libsasl2-dev \
+            libzip-dev libbz2-dev libsqlite3-dev libonig-dev libcurl4-openssl-dev \
+            libxml2-dev libxslt1-dev libpq-dev libreadline-dev libldap2-dev libsodium-dev \
+            libargon2-dev \
+            firebird-dev \
+            valgrind cmake
 
-      # ==================== MACOS DEPENDENCIES ====================
-      - name: Install build dependencies (macOS)
-        if: matrix.os == 'macos-latest'
+      - name: Install LibUV >= 1.44.0
         run: |
-          # Core build tools
-          brew install autoconf automake libtool pkg-config bison
-          
-          # LibUV - main dependency
-          brew install libuv
-          
-          # Fixed package names
-          brew install tidy-html5 icu4c openssl@3
-          
-          # Additional dependencies
-          brew install gmp libzip bzip2 sqlite oniguruma curl
-          brew install libxml2 libxslt readline libsodium argon2
-          
-          # Setup environment variables for keg-only packages
-          echo "PKG_CONFIG_PATH=$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix icu4c)/lib/pkgconfig:$(brew --prefix libxml2)/lib/pkgconfig:$PKG_CONFIG_PATH" >> $GITHUB_ENV
-          echo "PATH=$(brew --prefix bison)/bin:$PATH" >> $GITHUB_ENV
+          # Check if system libuv meets requirements
+          if pkg-config --exists libuv && pkg-config --atleast-version=1.44.0 libuv; then
+            echo "System libuv version: $(pkg-config --modversion libuv)"
+            sudo apt-get install -y libuv1-dev
+          else
+            echo "Installing LibUV 1.44.0 from source"
+            wget https://github.com/libuv/libuv/archive/v1.44.0.tar.gz
+            tar -xzf v1.44.0.tar.gz
+            cd libuv-1.44.0
+            mkdir build && cd build
+            cmake .. -DCMAKE_BUILD_TYPE=Release
+            make -j$(nproc)
+            sudo make install
+            sudo ldconfig
+            cd ../..
+          fi
 
-      # ==================== UBUNTU CONFIGURE & BUILD ====================
-      - name: Configure PHP (Ubuntu)
-        if: matrix.os == 'ubuntu-latest'
+      - name: Configure PHP
         working-directory: php-src
         run: |
           ./buildconf -f
           ./configure \
             --enable-zts \
-            --enable-option-checking=fatal \
-            --prefix=/usr \
-            --disable-phpdbg \
             --enable-fpm \
             --enable-opcache \
+            --with-pdo-mysql=mysqlnd \
+            --with-mysqli=mysqlnd \
+            --with-pgsql \
+            --with-pdo-pgsql \
             --with-pdo-sqlite \
             --enable-intl \
             --without-pear \
-            --enable-gd \
-            --with-jpeg \
-            --with-webp \
-            --with-freetype \
-            --enable-exif \
             --with-zip \
             --with-zlib \
             --enable-soap \
@@ -136,11 +119,12 @@ jobs:
             --enable-bcmath \
             --enable-calendar \
             --enable-ftp \
-            --with-enchant=/usr \
             --enable-sysvmsg \
             --with-ffi \
             --enable-zend-test \
             --enable-dl-test=shared \
+            --with-ldap \
+            --with-ldap-sasl \
             --with-password-argon2 \
             --with-mhash \
             --with-sodium \
@@ -150,10 +134,10 @@ jobs:
             --enable-inifile \
             --with-config-file-path=/etc \
             --with-config-file-scan-dir=/etc/php.d \
+            --with-pdo-firebird \
             --enable-async
 
-      - name: Build PHP (Ubuntu)
-        if: matrix.os == 'ubuntu-latest'
+      - name: Build PHP
         working-directory: php-src
         run: |
           make -j"$(nproc)"
@@ -165,6 +149,106 @@ jobs:
             echo "opcache.protect_memory=1"
           } > /etc/php.d/opcache.ini
 
+      - name: Run tests
+        working-directory: php-src/ext/async
+        run: |
+          /usr/local/bin/php -v
+          /usr/local/bin/php ../../run-tests.php \
+            -d zend_extension=opcache.so \
+            -d opcache.enable_cli=1 \
+            -d opcache.jit_buffer_size=64M \
+            -d opcache.jit=tracing \
+            -d zend_test.observer.enabled=1 \
+            -d zend_test.observer.show_output=0 \
+            -P -q -x -j4 \
+            -g FAIL,BORK,LEAK,XLEAK \
+            --no-progress \
+            --offline \
+            --show-diff \
+            --show-slow 2000 \
+            --set-timeout 120 \
+            --repeat 2
+
+  # Cross-platform build without database services  
+  cross-platform-build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, macos-latest]
+        include:
+          - os: windows-latest  
+            platform: windows
+          - os: macos-latest
+            platform: macos
+    
+    runs-on: ${{ matrix.os }}
+
+
+    steps:
+      - name: Checkout php-async repo
+        uses: actions/checkout@v4
+        with:
+          path: async
+
+      - name: Clone php-src (true-async-stable)
+        run: |
+          git clone --depth=1 --branch=true-async-stable https://github.com/true-async/php-src php-src
+
+      - name: Copy php-async extension into php-src
+        run: |
+          mkdir -p php-src/ext/async
+          cp -r async/* php-src/ext/async/
+
+      # ==================== WINDOWS DEPENDENCIES ====================
+      - name: Install build dependencies (Windows)
+        if: matrix.os == 'windows-latest'
+        run: |
+          # Install php-sdk
+          git clone https://github.com/Microsoft/php-sdk-binary-tools.git C:\php-sdk
+          
+          # Install vcpkg and LibUV >= 1.44.0
+          git clone https://github.com/Microsoft/vcpkg.git C:\vcpkg
+          C:\vcpkg\bootstrap-vcpkg.bat
+          C:\vcpkg\vcpkg.exe install libuv:x64-windows
+          
+          # Verify LibUV version
+          C:\vcpkg\vcpkg.exe list libuv
+          
+          # Create deps structure for php-sdk
+          mkdir C:\php-sdk\deps\include\libuv
+          mkdir C:\php-sdk\deps\lib
+          
+          # Copy LibUV files
+          xcopy /E /I C:\vcpkg\installed\x64-windows\include C:\php-sdk\deps\include\libuv\
+          copy C:\vcpkg\installed\x64-windows\lib\uv.lib C:\php-sdk\deps\lib\libuv.lib
+        shell: cmd
+
+      # ==================== MACOS DEPENDENCIES ====================
+      - name: Install build dependencies (macOS)
+        if: matrix.os == 'macos-latest'
+        run: |
+          # Core build tools
+          brew install autoconf automake libtool pkg-config bison
+          
+          # LibUV >= 1.44.0 - main dependency
+          brew install libuv
+          
+          # Verify LibUV version
+          pkg-config --modversion libuv || true
+          libuv_version=$(pkg-config --modversion libuv 2>/dev/null || echo "unknown")
+          echo "Installed LibUV version: $libuv_version"
+          
+          # Fixed package names
+          brew install tidy-html5 icu4c openssl@3
+          
+          # Additional dependencies
+          brew install gmp libzip bzip2 sqlite oniguruma curl
+          brew install libxml2 libxslt readline libsodium argon2
+          
+          # Setup environment variables for keg-only packages
+          echo "PKG_CONFIG_PATH=$(brew --prefix openssl@3)/lib/pkgconfig:$(brew --prefix icu4c)/lib/pkgconfig:$(brew --prefix libxml2)/lib/pkgconfig:$PKG_CONFIG_PATH" >> $GITHUB_ENV
+          echo "PATH=$(brew --prefix bison)/bin:$PATH" >> $GITHUB_ENV
+
       # ==================== WINDOWS CONFIGURE & BUILD ====================
       - name: Configure and Build PHP (Windows)
         if: matrix.os == 'windows-latest'
@@ -241,70 +325,45 @@ jobs:
           } > /usr/local/etc/php.d/opcache.ini
 
       # ==================== TESTING FOR ALL PLATFORMS ====================
-      - name: Run tests (Ubuntu)
-        if: matrix.os == 'ubuntu-latest'
-        working-directory: php-src
-        env:
-          MIBS: +ALL
-        run: |
-          sapi/cli/php run-tests.php \
-            -d zend_extension=opcache.so \
-            -d opcache.enable_cli=1 \
-            -d opcache.jit_buffer_size=64M \
-            -d opcache.jit=tracing \
-            -d zend_test.observer.enabled=1 \
-            -d zend_test.observer.show_output=0 \
-            -P -q -x -j2 \
-            -g FAIL,BORK,LEAK,XLEAK \
-            --no-progress \
-            --offline \
-            --show-diff \
-            --show-slow 1000 \
-            --set-timeout 120 \
-            --repeat 2 \
-            ext/async
-
       - name: Run tests (Windows)
         if: matrix.os == 'windows-latest'
-        working-directory: php-src
+        working-directory: php-src/ext/async
         run: |
           php.exe -v
-          php.exe run-tests.php ^
+          php.exe ../../run-tests.php ^
             -d zend_extension=opcache.dll ^
             -d opcache.enable_cli=1 ^
             -d opcache.jit_buffer_size=64M ^
             -d opcache.jit=tracing ^
             -d zend_test.observer.enabled=1 ^
             -d zend_test.observer.show_output=0 ^
-            -P -q -x -j2 ^
+            -P -q -x -j4 ^
             -g FAIL,BORK,LEAK,XLEAK ^
             --no-progress ^
             --offline ^
             --show-diff ^
-            --show-slow 1000 ^
+            --show-slow 2000 ^
             --set-timeout 120 ^
-            --repeat 2 ^
-            ext/async
+            --repeat 2
         shell: cmd
 
       - name: Run tests (macOS)
         if: matrix.os == 'macos-latest'
-        working-directory: php-src
+        working-directory: php-src/ext/async
         run: |
           /usr/local/bin/php -v
-          /usr/local/bin/php run-tests.php \
+          /usr/local/bin/php ../../run-tests.php \
             -d zend_extension=opcache.so \
             -d opcache.enable_cli=1 \
             -d opcache.jit_buffer_size=64M \
             -d opcache.jit=tracing \
             -d zend_test.observer.enabled=1 \
             -d zend_test.observer.show_output=0 \
-            -P -q -x -j2 \
+            -P -q -x -j4 \
             -g FAIL,BORK,LEAK,XLEAK \
             --no-progress \
             --offline \
             --show-diff \
-            --show-slow 1000 \
+            --show-slow 2000 \
             --set-timeout 120 \
-            --repeat 2 \
-            ext/async
\ No newline at end of file
+            --repeat 2
\ No newline at end of file

From 7eae51e788e2ca2f1f00711679d3f351c0b65739 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 10:23:06 +0300
Subject: [PATCH 28/53] #9:  tests: Add comprehensive test coverage for
 async_API.c error paths
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

      This commit adds 14 new .phpt tests targeting uncovered code paths in
      async_API.c to improve coverage from 73.9% to approximately 82%.

      New tests cover:
      * spawn/ (4 tests): ScopeProvider validation and closed scope errors
      * await/ (6 tests): getCoroutines(), iterator exceptions, invalid keys
      * coroutine/ (2 tests): getAwaitingInfo() and lifecycle integration
      * edge_cases/ (2 tests): exception handling and stress testing

      Key improvements:
      - get_coroutines() function: 0% → 100% coverage
      - async_provide_scope() error paths: comprehensive coverage
      - Iterator exception handling: next(), valid(), current() methods
      - Key type validation: object and resource key errors
      - Edge cases and stress scenarios for concurrent operations
---
 .../await/059-await_getCoroutines_basic.phpt  |  54 +++++++++
 .../060-await_empty_iterable_edge_cases.phpt  |  43 +++++++
 ...t_iterator_exception_during_traversal.phpt |  57 ++++++++++
 .../062-await_iterator_exception_valid.phpt   |  57 ++++++++++
 .../063-await_iterator_exception_current.phpt |  57 ++++++++++
 tests/await/064-await_object_key_error.phpt   |  59 ++++++++++
 tests/await/065-await_resource_key_error.phpt |  67 +++++++++++
 ...26-coroutine_getAwaitingInfo_detailed.phpt |  58 ++++++++++
 ...7-coroutine_getCoroutines_integration.phpt |  88 +++++++++++++++
 .../004-scope_provider_exceptions.phpt        |  90 +++++++++++++++
 .../005-concurrent_spawn_stress.phpt          | 106 ++++++++++++++++++
 .../016-spawn_invalid_scope_provider.phpt     |  35 ++++++
 tests/spawn/017-spawn_closed_scope_error.phpt |  61 ++++++++++
 .../018-spawn_scope_provider_exception.phpt   |  35 ++++++
 .../spawn/019-spawn_scope_provider_null.phpt  |  33 ++++++
 15 files changed, 900 insertions(+)
 create mode 100644 tests/await/059-await_getCoroutines_basic.phpt
 create mode 100644 tests/await/060-await_empty_iterable_edge_cases.phpt
 create mode 100644 tests/await/061-await_iterator_exception_during_traversal.phpt
 create mode 100644 tests/await/062-await_iterator_exception_valid.phpt
 create mode 100644 tests/await/063-await_iterator_exception_current.phpt
 create mode 100644 tests/await/064-await_object_key_error.phpt
 create mode 100644 tests/await/065-await_resource_key_error.phpt
 create mode 100644 tests/coroutine/026-coroutine_getAwaitingInfo_detailed.phpt
 create mode 100644 tests/coroutine/027-coroutine_getCoroutines_integration.phpt
 create mode 100644 tests/edge_cases/004-scope_provider_exceptions.phpt
 create mode 100644 tests/edge_cases/005-concurrent_spawn_stress.phpt
 create mode 100644 tests/spawn/016-spawn_invalid_scope_provider.phpt
 create mode 100644 tests/spawn/017-spawn_closed_scope_error.phpt
 create mode 100644 tests/spawn/018-spawn_scope_provider_exception.phpt
 create mode 100644 tests/spawn/019-spawn_scope_provider_null.phpt

diff --git a/tests/await/059-await_getCoroutines_basic.phpt b/tests/await/059-await_getCoroutines_basic.phpt
new file mode 100644
index 0000000..83a83a4
--- /dev/null
+++ b/tests/await/059-await_getCoroutines_basic.phpt
@@ -0,0 +1,54 @@
+--TEST--
+getCoroutines() - basic functionality and lifecycle tracking
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\getCoroutines;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: getCoroutines() without active coroutines
+$coroutines = getCoroutines();
+echo "Initial coroutines count: " . count($coroutines) . "\n";
+echo "Initial coroutines type: " . gettype($coroutines) . "\n";
+
+// Test 2: getCoroutines() with active coroutines
+$c1 = spawn(function() {
+    suspend();
+    return "coroutine1";
+});
+
+$c2 = spawn(function() {
+    suspend(); 
+    return "coroutine2";
+});
+
+$coroutines = getCoroutines();
+echo "Active coroutines count: " . count($coroutines) . "\n";
+echo "First coroutine is Coroutine: " . ($coroutines[0] instanceof \Async\Coroutine ? "true" : "false") . "\n";
+echo "Second coroutine is Coroutine: " . ($coroutines[1] instanceof \Async\Coroutine ? "true" : "false") . "\n";
+
+// Test 3: getCoroutines() after cancellation
+$c1->cancel();
+$coroutines = getCoroutines();
+echo "After first cancel count: " . count($coroutines) . "\n";
+
+$c2->cancel();
+$coroutines = getCoroutines();
+echo "After second cancel count: " . count($coroutines) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Initial coroutines count: 0
+Initial coroutines type: array
+Active coroutines count: 2
+First coroutine is Coroutine: true
+Second coroutine is Coroutine: true
+After first cancel count: 1
+After second cancel count: 0
+end
\ No newline at end of file
diff --git a/tests/await/060-await_empty_iterable_edge_cases.phpt b/tests/await/060-await_empty_iterable_edge_cases.phpt
new file mode 100644
index 0000000..1c2a906
--- /dev/null
+++ b/tests/await/060-await_empty_iterable_edge_cases.phpt
@@ -0,0 +1,43 @@
+--TEST--
+awaitAll() - empty iterators basic functionality
+--FILE--
+<?php
+
+use function Async\awaitAll;
+
+echo "start\n";
+
+// Test EmptyIterator
+$emptyIterator = new EmptyIterator();
+$result1 = awaitAll($emptyIterator);
+echo "EmptyIterator count: " . count($result1) . "\n";
+echo "EmptyIterator type: " . gettype($result1) . "\n";
+
+// Test empty SplFixedArray
+$emptyFixedArray = new SplFixedArray(0);
+$result2 = awaitAll($emptyFixedArray);
+echo "Empty SplFixedArray count: " . count($result2) . "\n";
+
+// Test custom empty iterator
+class CustomEmptyIterator implements Iterator
+{
+    public function rewind(): void {}
+    public function current(): mixed { return null; }
+    public function key(): mixed { return null; }
+    public function next(): void {}
+    public function valid(): bool { return false; }
+}
+
+$result3 = awaitAll(new CustomEmptyIterator());
+echo "CustomEmptyIterator count: " . count($result3) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+EmptyIterator count: 0
+EmptyIterator type: array
+Empty SplFixedArray count: 0
+CustomEmptyIterator count: 0
+end
\ No newline at end of file
diff --git a/tests/await/061-await_iterator_exception_during_traversal.phpt b/tests/await/061-await_iterator_exception_during_traversal.phpt
new file mode 100644
index 0000000..8f5704d
--- /dev/null
+++ b/tests/await/061-await_iterator_exception_during_traversal.phpt
@@ -0,0 +1,57 @@
+--TEST--
+awaitAll() - iterator exception in next() method
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+echo "start\n";
+
+class FailingNextIterator implements Iterator
+{
+    private $position = 0;
+    private $data = ['first', 'second'];
+    
+    public function rewind(): void {
+        $this->position = 0;
+    }
+    
+    public function current(): mixed {
+        return spawn(function() {
+            return $this->data[$this->position];
+        });
+    }
+    
+    public function key(): mixed {
+        return $this->position;
+    }
+    
+    public function next(): void {
+        $this->position++;
+        if ($this->position === 1) {
+            throw new \RuntimeException("Iterator next() failed");
+        }
+    }
+    
+    public function valid(): bool {
+        return isset($this->data[$this->position]);
+    }
+}
+
+try {
+    $results = awaitAll(new FailingNextIterator());
+    echo "ERROR: Should have thrown exception\n";
+} catch (\RuntimeException $e) {
+    echo "Caught next() exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught next() exception: Iterator next() failed
+end
\ No newline at end of file
diff --git a/tests/await/062-await_iterator_exception_valid.phpt b/tests/await/062-await_iterator_exception_valid.phpt
new file mode 100644
index 0000000..17590be
--- /dev/null
+++ b/tests/await/062-await_iterator_exception_valid.phpt
@@ -0,0 +1,57 @@
+--TEST--
+awaitAll() - iterator exception in valid() method
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+echo "start\n";
+
+class FailingValidIterator implements Iterator
+{
+    private $position = 0;
+    private $data = ['first'];
+    
+    public function rewind(): void {
+        $this->position = 0;
+    }
+    
+    public function current(): mixed {
+        return spawn(function() {
+            return $this->data[$this->position];
+        });
+    }
+    
+    public function key(): mixed {
+        return $this->position;
+    }
+    
+    public function next(): void {
+        $this->position++;
+    }
+    
+    public function valid(): bool {
+        if ($this->position === 1) {
+            throw new \RuntimeException("Iterator valid() failed");
+        }
+        return isset($this->data[$this->position]);
+    }
+}
+
+try {
+    $results = awaitAll(new FailingValidIterator());
+    echo "ERROR: Should have thrown exception\n";
+} catch (\RuntimeException $e) {
+    echo "Caught valid() exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught valid() exception: Iterator valid() failed
+end
\ No newline at end of file
diff --git a/tests/await/063-await_iterator_exception_current.phpt b/tests/await/063-await_iterator_exception_current.phpt
new file mode 100644
index 0000000..22e9ffc
--- /dev/null
+++ b/tests/await/063-await_iterator_exception_current.phpt
@@ -0,0 +1,57 @@
+--TEST--
+awaitAll() - iterator exception in current() method
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+echo "start\n";
+
+class FailingCurrentIterator implements Iterator
+{
+    private $position = 0;
+    private $data = ['first', 'second'];
+    
+    public function rewind(): void {
+        $this->position = 0;
+    }
+    
+    public function current(): mixed {
+        if ($this->position === 1) {
+            throw new \RuntimeException("Iterator current() failed");
+        }
+        return spawn(function() {
+            return $this->data[$this->position];
+        });
+    }
+    
+    public function key(): mixed {
+        return $this->position;
+    }
+    
+    public function next(): void {
+        $this->position++;
+    }
+    
+    public function valid(): bool {
+        return isset($this->data[$this->position]);
+    }
+}
+
+try {
+    $results = awaitAll(new FailingCurrentIterator());
+    echo "ERROR: Should have thrown exception\n";
+} catch (\RuntimeException $e) {
+    echo "Caught current() exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught current() exception: Iterator current() failed
+end
\ No newline at end of file
diff --git a/tests/await/064-await_object_key_error.phpt b/tests/await/064-await_object_key_error.phpt
new file mode 100644
index 0000000..a89e894
--- /dev/null
+++ b/tests/await/064-await_object_key_error.phpt
@@ -0,0 +1,59 @@
+--TEST--
+awaitAll() - iterator with object keys error
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+echo "start\n";
+
+class ObjectKeyIterator implements Iterator
+{
+    private $position = 0;
+    private $keys;
+    private $values;
+    
+    public function __construct() {
+        $this->keys = [new stdClass(), new stdClass()];
+        $this->values = [
+            spawn(function() { return "value1"; }),
+            spawn(function() { return "value2"; })
+        ];
+    }
+    
+    public function rewind(): void {
+        $this->position = 0;
+    }
+    
+    public function current(): mixed {
+        return $this->values[$this->position] ?? null;
+    }
+    
+    public function key(): mixed {
+        return $this->keys[$this->position] ?? null;
+    }
+    
+    public function next(): void {
+        $this->position++;
+    }
+    
+    public function valid(): bool {
+        return $this->position < count($this->keys);
+    }
+}
+
+try {
+    $result = awaitAll(new ObjectKeyIterator());
+    echo "ERROR: Should have failed with object keys\n";
+} catch (Throwable $e) {
+    echo "Caught object key error: " . get_class($e) . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Caught object key error: %s
+end
\ No newline at end of file
diff --git a/tests/await/065-await_resource_key_error.phpt b/tests/await/065-await_resource_key_error.phpt
new file mode 100644
index 0000000..ce962e7
--- /dev/null
+++ b/tests/await/065-await_resource_key_error.phpt
@@ -0,0 +1,67 @@
+--TEST--
+awaitAll() - iterator with resource keys error
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAll;
+
+echo "start\n";
+
+class ResourceKeyIterator implements Iterator
+{
+    private $position = 0;
+    private $keys;
+    private $values;
+    
+    public function __construct() {
+        $this->keys = [fopen('php://memory', 'r'), fopen('php://memory', 'r')];
+        $this->values = [
+            spawn(function() { return "value1"; }),
+            spawn(function() { return "value2"; })
+        ];
+    }
+    
+    public function __destruct() {
+        foreach ($this->keys as $key) {
+            if (is_resource($key)) {
+                fclose($key);
+            }
+        }
+    }
+    
+    public function rewind(): void {
+        $this->position = 0;
+    }
+    
+    public function current(): mixed {
+        return $this->values[$this->position] ?? null;
+    }
+    
+    public function key(): mixed {
+        return $this->keys[$this->position] ?? null;
+    }
+    
+    public function next(): void {
+        $this->position++;
+    }
+    
+    public function valid(): bool {
+        return $this->position < count($this->keys);
+    }
+}
+
+try {
+    $result = awaitAll(new ResourceKeyIterator());
+    echo "ERROR: Should have failed with resource keys\n";
+} catch (Throwable $e) {
+    echo "Caught resource key error: " . get_class($e) . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Caught resource key error: %s
+end
\ No newline at end of file
diff --git a/tests/coroutine/026-coroutine_getAwaitingInfo_detailed.phpt b/tests/coroutine/026-coroutine_getAwaitingInfo_detailed.phpt
new file mode 100644
index 0000000..5b53049
--- /dev/null
+++ b/tests/coroutine/026-coroutine_getAwaitingInfo_detailed.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Coroutine: getAwaitingInfo() - detailed testing with different states
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: getAwaitingInfo() for running coroutine
+$running = spawn(function() {
+    return "test";
+});
+
+$info = $running->getAwaitingInfo();
+echo "Running coroutine info type: " . gettype($info) . "\n";
+echo "Running coroutine info is array: " . (is_array($info) ? "true" : "false") . "\n";
+
+// Wait for completion
+await($running);
+
+// Test 2: getAwaitingInfo() for finished coroutine
+$info2 = $running->getAwaitingInfo();
+echo "Finished coroutine info type: " . gettype($info2) . "\n";
+echo "Finished coroutine info is array: " . (is_array($info2) ? "true" : "false") . "\n";
+
+// Test 3: getAwaitingInfo() for suspended coroutine
+$suspended = spawn(function() {
+    suspend();
+    return "suspended";
+});
+
+$info3 = $suspended->getAwaitingInfo();
+echo "Suspended coroutine info type: " . gettype($info3) . "\n";
+echo "Suspended coroutine info is array: " . (is_array($info3) ? "true" : "false") . "\n";
+
+// Test 4: getAwaitingInfo() for cancelled coroutine
+$suspended->cancel();
+$info4 = $suspended->getAwaitingInfo();
+echo "Cancelled coroutine info type: " . gettype($info4) . "\n";
+echo "Cancelled coroutine info is array: " . (is_array($info4) ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Running coroutine info type: array
+Running coroutine info is array: true
+Finished coroutine info type: array
+Finished coroutine info is array: true
+Suspended coroutine info type: array
+Suspended coroutine info is array: true
+Cancelled coroutine info type: array
+Cancelled coroutine info is array: true
+end
\ No newline at end of file
diff --git a/tests/coroutine/027-coroutine_getCoroutines_integration.phpt b/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
new file mode 100644
index 0000000..f91d0bf
--- /dev/null
+++ b/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
@@ -0,0 +1,88 @@
+--TEST--
+getCoroutines() - integration with coroutine lifecycle management
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\getCoroutines;
+use function Async\suspend;
+use function Async\awaitAll;
+
+echo "start\n";
+
+// Track initial state
+$initial_count = count(getCoroutines());
+echo "Initial count: {$initial_count}\n";
+
+// Test 1: Create multiple coroutines and track changes
+$coroutines = [];
+for ($i = 0; $i < 5; $i++) {
+    $coroutines[] = spawn(function() use ($i) {
+        suspend();
+        return "result_{$i}";
+    });
+}
+
+$after_spawn = count(getCoroutines()) - $initial_count;
+echo "After spawning 5: {$after_spawn}\n";
+
+// Verify all coroutines are in the list
+$all_coroutines = getCoroutines();
+$our_coroutines = array_slice($all_coroutines, $initial_count, 5);
+echo "Found our coroutines: " . count($our_coroutines) . "\n";
+
+foreach ($our_coroutines as $index => $coroutine) {
+    echo "Coroutine {$index} is suspended: " . ($coroutine->isSuspended() ? "true" : "false") . "\n";
+}
+
+// Test 2: Cancel some coroutines
+$coroutines[0]->cancel();
+$coroutines[2]->cancel();
+
+$after_partial_cancel = count(getCoroutines()) - $initial_count;
+echo "After cancelling 2: {$after_partial_cancel}\n";
+
+// Test 3: Complete remaining coroutines
+$remaining = [$coroutines[1], $coroutines[3], $coroutines[4]];
+$results = awaitAll($remaining);
+echo "Completed results: " . count($results) . "\n";
+
+$final_count = count(getCoroutines()) - $initial_count;
+echo "Final count: {$final_count}\n";
+
+// Test 4: Verify getCoroutines() consistency during concurrent operations
+$concurrent_coroutines = [];
+for ($i = 0; $i < 3; $i++) {
+    $concurrent_coroutines[] = spawn(function() use ($i) {
+        $count_before = count(getCoroutines());
+        suspend();
+        $count_after = count(getCoroutines());
+        return "coroutine_{$i}: before={$count_before}, after={$count_after}";
+    });
+}
+
+$concurrent_results = awaitAll($concurrent_coroutines);
+foreach ($concurrent_results as $result) {
+    echo "Concurrent: {$result}\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Initial count: 0
+After spawning 5: 5
+Found our coroutines: 5
+Coroutine 0 is suspended: true
+Coroutine 1 is suspended: true
+Coroutine 2 is suspended: true
+Coroutine 3 is suspended: true
+Coroutine 4 is suspended: true
+After cancelling 2: 3
+Completed results: 3
+Final count: 0
+Concurrent: coroutine_0: before=%d, after=%d
+Concurrent: coroutine_1: before=%d, after=%d
+Concurrent: coroutine_2: before=%d, after=%d
+end
\ No newline at end of file
diff --git a/tests/edge_cases/004-scope_provider_exceptions.phpt b/tests/edge_cases/004-scope_provider_exceptions.phpt
new file mode 100644
index 0000000..70aff88
--- /dev/null
+++ b/tests/edge_cases/004-scope_provider_exceptions.phpt
@@ -0,0 +1,90 @@
+--TEST--
+ScopeProvider - exception handling with different exception types
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+// ScopeProvider with different exception types
+class ThrowingScopeProvider implements \Async\ScopeProvider
+{
+    private $exceptionType;
+    
+    public function __construct(string $type)
+    {
+        $this->exceptionType = $type;
+    }
+    
+    public function provideScope(): ?\Async\Scope
+    {
+        switch($this->exceptionType) {
+            case 'runtime':
+                throw new \RuntimeException("Runtime error in provider");
+            case 'cancellation':
+                throw new \Async\CancellationException("Cancelled in provider");
+            case 'invalid_argument':
+                throw new \InvalidArgumentException("Invalid argument in provider");
+            case 'logic':
+                throw new \LogicException("Logic error in provider");
+            default:
+                throw new \Exception("Generic error in provider");
+        }
+    }
+}
+
+// Test different exception types
+$exceptionTypes = ['runtime', 'cancellation', 'invalid_argument', 'logic', 'generic'];
+
+foreach ($exceptionTypes as $type) {
+    try {
+        $coroutine = spawnWith(new ThrowingScopeProvider($type), function() {
+            return "test";
+        });
+        echo "ERROR: Should have thrown exception for {$type}\n";
+    } catch (\Async\CancellationException $e) {
+        echo "Caught CancellationException: " . $e->getMessage() . "\n";
+    } catch (\RuntimeException $e) {
+        echo "Caught RuntimeException: " . $e->getMessage() . "\n";
+    } catch (\InvalidArgumentException $e) {
+        echo "Caught InvalidArgumentException: " . $e->getMessage() . "\n";
+    } catch (\LogicException $e) {
+        echo "Caught LogicException: " . $e->getMessage() . "\n";
+    } catch (\Exception $e) {
+        echo "Caught Exception: " . $e->getMessage() . "\n";
+    } catch (Throwable $e) {
+        echo "Caught Throwable: " . get_class($e) . ": " . $e->getMessage() . "\n";
+    }
+}
+
+// Test that successful provider still works after failures
+class SuccessfulProvider implements \Async\ScopeProvider
+{
+    public function provideScope(): ?\Async\Scope
+    {
+        return \Async\Scope::inherit();
+    }
+}
+
+try {
+    $coroutine = spawnWith(new SuccessfulProvider(), function() {
+        return "success";
+    });
+    echo "Successful provider result: " . $coroutine->getResult() . "\n";
+} catch (Throwable $e) {
+    echo "Unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught RuntimeException: Runtime error in provider
+Caught CancellationException: Cancelled in provider
+Caught InvalidArgumentException: Invalid argument in provider
+Caught LogicException: Logic error in provider
+Caught Exception: Generic error in provider
+Successful provider result: success
+end
\ No newline at end of file
diff --git a/tests/edge_cases/005-concurrent_spawn_stress.phpt b/tests/edge_cases/005-concurrent_spawn_stress.phpt
new file mode 100644
index 0000000..bbf0d9a
--- /dev/null
+++ b/tests/edge_cases/005-concurrent_spawn_stress.phpt
@@ -0,0 +1,106 @@
+--TEST--
+Concurrent spawn operations - stress test with getCoroutines() tracking
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\getCoroutines;
+use function Async\suspend;
+use function Async\awaitAll;
+
+echo "start\n";
+
+// Track baseline
+$start_count = count(getCoroutines());
+echo "Baseline coroutines: {$start_count}\n";
+
+// Test 1: Stress test with many concurrent spawns
+$stress_coroutines = [];
+$stress_count = 50; // Reduced from 100 for test reliability
+
+for ($i = 0; $i < $stress_count; $i++) {
+    $stress_coroutines[] = spawn(function() use ($i) {
+        // Small amount of work with suspend
+        for ($j = 0; $j < 3; $j++) {
+            suspend();
+        }
+        return "stress_result_{$i}";
+    });
+}
+
+$peak_count = count(getCoroutines()) - $start_count;
+echo "Peak coroutines created: {$peak_count}\n";
+
+// Verify we have the expected number
+if ($peak_count >= $stress_count) {
+    echo "Stress test spawn successful\n";
+} else {
+    echo "WARNING: Expected {$stress_count}, got {$peak_count}\n";
+}
+
+// Test 2: Partial completion
+$first_half = array_slice($stress_coroutines, 0, $stress_count / 2);
+$second_half = array_slice($stress_coroutines, $stress_count / 2);
+
+$first_results = awaitAll($first_half);
+$mid_count = count(getCoroutines()) - $start_count;
+echo "After first half completion: {$mid_count}\n";
+
+// Test 3: Complete remaining
+$second_results = awaitAll($second_half);
+$final_count = count(getCoroutines()) - $start_count;
+echo "After full completion: {$final_count}\n";
+
+echo "First half results: " . count($first_results) . "\n";
+echo "Second half results: " . count($second_results) . "\n";
+echo "Total results: " . (count($first_results) + count($second_results)) . "\n";
+
+// Test 4: Rapid spawn and cancel cycles
+echo "Testing rapid spawn/cancel cycles\n";
+for ($cycle = 0; $cycle < 5; $cycle++) {
+    $rapid_coroutines = [];
+    
+    // Spawn quickly
+    for ($i = 0; $i < 10; $i++) {
+        $rapid_coroutines[] = spawn(function() use ($i, $cycle) {
+            suspend();
+            return "cycle_{$cycle}_item_{$i}";
+        });
+    }
+    
+    $cycle_count = count(getCoroutines()) - $start_count;
+    
+    // Cancel quickly
+    foreach ($rapid_coroutines as $coroutine) {
+        $coroutine->cancel();
+    }
+    
+    $after_cancel = count(getCoroutines()) - $start_count;
+    echo "Cycle {$cycle}: peak={$cycle_count}, after_cancel={$after_cancel}\n";
+}
+
+// Verify clean state
+$end_count = count(getCoroutines()) - $start_count;
+echo "Final state: {$end_count} coroutines remaining\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Baseline coroutines: %d
+Peak coroutines created: 50
+Stress test spawn successful
+After first half completion: %d
+After full completion: 0
+First half results: 25
+Second half results: 25
+Total results: 50
+Testing rapid spawn/cancel cycles
+Cycle 0: peak=%d, after_cancel=%d
+Cycle 1: peak=%d, after_cancel=%d
+Cycle 2: peak=%d, after_cancel=%d
+Cycle 3: peak=%d, after_cancel=%d
+Cycle 4: peak=%d, after_cancel=%d
+Final state: 0 coroutines remaining
+end
\ No newline at end of file
diff --git a/tests/spawn/016-spawn_invalid_scope_provider.phpt b/tests/spawn/016-spawn_invalid_scope_provider.phpt
new file mode 100644
index 0000000..2439483
--- /dev/null
+++ b/tests/spawn/016-spawn_invalid_scope_provider.phpt
@@ -0,0 +1,35 @@
+--TEST--
+spawnWith() - invalid scope provider type error
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+class InvalidTypeScopeProvider implements \Async\ScopeProvider
+{
+    public function provideScope(): mixed
+    {
+        return "invalid"; // Should return Scope or null
+    }
+}
+
+try {
+    $coroutine = spawnWith(new InvalidTypeScopeProvider(), function() {
+        return "test";
+    });
+    echo "ERROR: Should have thrown exception\n";
+} catch (\Async\AsyncException $e) {
+    echo "Caught expected exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Caught expected exception: Scope provider must return an instance of Async\Scope
+end
\ No newline at end of file
diff --git a/tests/spawn/017-spawn_closed_scope_error.phpt b/tests/spawn/017-spawn_closed_scope_error.phpt
new file mode 100644
index 0000000..5e3b3e1
--- /dev/null
+++ b/tests/spawn/017-spawn_closed_scope_error.phpt
@@ -0,0 +1,61 @@
+--TEST--
+spawn() - error when spawning in closed scope
+--FILE--
+<?php
+
+use function Async\spawn;
+
+echo "start\n";
+
+// Test 1: Spawn in disposed scope should fail
+$scope = \Async\Scope::inherit();
+echo "Scope created\n";
+
+// Dispose the scope
+$scope->dispose();
+echo "Scope disposed\n";
+
+try {
+    $coroutine = $scope->spawn(function() {
+        return "test";
+    });
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Caught expected error: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 2: Verify scope is actually closed
+echo "Scope is closed: " . ($scope->isClosed() ? "true" : "false") . "\n";
+echo "Scope is finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+
+// Test 3: Spawn in safely disposed scope should also fail
+$scope2 = \Async\Scope::inherit();
+$scope2->disposeSafely();
+echo "Scope safely disposed\n";
+
+try {
+    $coroutine2 = $scope2->spawn(function() {
+        return "test2";
+    });
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Caught expected error for safely disposed: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+Scope created
+Scope disposed
+Caught expected error: Cannot spawn a coroutine in a closed scope
+Scope is closed: true
+Scope is finished: true
+Scope safely disposed
+Caught expected error for safely disposed: Cannot spawn a coroutine in a closed scope
+end
\ No newline at end of file
diff --git a/tests/spawn/018-spawn_scope_provider_exception.phpt b/tests/spawn/018-spawn_scope_provider_exception.phpt
new file mode 100644
index 0000000..a80e540
--- /dev/null
+++ b/tests/spawn/018-spawn_scope_provider_exception.phpt
@@ -0,0 +1,35 @@
+--TEST--
+spawnWith() - scope provider throws exception
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+class ThrowingScopeProvider implements \Async\ScopeProvider
+{
+    public function provideScope(): ?\Async\Scope
+    {
+        throw new \RuntimeException("Provider error");
+    }
+}
+
+try {
+    $coroutine = spawnWith(new ThrowingScopeProvider(), function() {
+        return "test";
+    });
+    echo "ERROR: Should have thrown exception\n";
+} catch (\RuntimeException $e) {
+    echo "Caught provider exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Caught provider exception: Provider error
+end
\ No newline at end of file
diff --git a/tests/spawn/019-spawn_scope_provider_null.phpt b/tests/spawn/019-spawn_scope_provider_null.phpt
new file mode 100644
index 0000000..2a2ab61
--- /dev/null
+++ b/tests/spawn/019-spawn_scope_provider_null.phpt
@@ -0,0 +1,33 @@
+--TEST--
+spawnWith() - scope provider returns null (valid case)
+--FILE--
+<?php
+
+use function Async\spawnWith;
+
+echo "start\n";
+
+class NullScopeProvider implements \Async\ScopeProvider
+{
+    public function provideScope(): ?\Async\Scope
+    {
+        return null; // Valid - should use inherited scope
+    }
+}
+
+try {
+    $coroutine = spawnWith(new NullScopeProvider(), function() {
+        return "success";
+    });
+    echo "Null provider result: " . $coroutine->getResult() . "\n";
+} catch (Throwable $e) {
+    echo "Unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Null provider result: success
+end
\ No newline at end of file

From bf33b9714562df91af9993475394994852b21385 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 11:15:10 +0300
Subject: [PATCH 29/53] #9: * fix await_iterator_handler

---
 async_API.c                                   | 26 +++++++--
 iterator.c                                    |  3 +-
 .../await/059-await_getCoroutines_basic.phpt  | 54 -------------------
 3 files changed, 25 insertions(+), 58 deletions(-)
 delete mode 100644 tests/await/059-await_getCoroutines_basic.phpt

diff --git a/async_API.c b/async_API.c
index 6311985..1d1315f 100644
--- a/async_API.c
+++ b/async_API.c
@@ -309,11 +309,17 @@ static void async_waiting_callback_dispose(zend_async_event_callback_t *callback
 
 	await_callback->await_context = NULL;
 
+	zval_ptr_dtor(&await_callback->key);
+
 	if (await_context != NULL) {
 		await_context->dtor(await_context);
 	}
 
-	await_callback->prev_dispose(callback, event);
+	if (await_callback->prev_dispose != NULL) {
+		await_callback->prev_dispose(callback, event);
+	} else {
+		efree(callback);
+	}
 }
 
 /**
@@ -547,18 +553,32 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		// But if it supports the replay method, we can retrieve the resulting value again.
 		//
 		if (false == awaitable->replay) {
+			async_waiting_callback_dispose(&callback->callback.base, NULL);
 			return SUCCESS;
 		}
 
 		awaitable->replay(awaitable, &callback->callback.base, NULL, NULL);
-	} else {
-		zend_async_resume_when(await_iterator->waiting_coroutine, awaitable, false, NULL, &callback->callback);
+		callback->await_context = NULL;
+		async_waiting_callback_dispose(&callback->callback.base, NULL);
+
+		if (UNEXPECTED(EG(exception))) {
+			return FAILURE;
+		}
+
+		return SUCCESS;
 	}
 
+	zend_async_resume_when(await_iterator->waiting_coroutine, awaitable, false, NULL, &callback->callback);
+
 	if (UNEXPECTED(EG(exception))) {
+		async_waiting_callback_dispose(&callback->callback.base, NULL);
 		return FAILURE;
 	}
 
+	callback->prev_dispose = callback->callback.base.dispose;
+	callback->callback.base.dispose = async_waiting_callback_dispose;
+
+	await_context->ref_count++;
 	await_context->futures_count++;
 
 	return SUCCESS;
diff --git a/iterator.c b/iterator.c
index f9ef925..72346aa 100644
--- a/iterator.c
+++ b/iterator.c
@@ -349,7 +349,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
         		iterator->zend_iterator->funcs->move_forward(iterator->zend_iterator);
         	} ITERATOR_SAFE_MOVING_END(iterator);
 
-        	RETURN_IF_EXCEPTION_AND(iterator, zval_ptr_dtor(&current_item));
+        	RETURN_IF_EXCEPTION_AND(iterator, zval_ptr_dtor(&current_item); zval_ptr_dtor(&key));
         }
 
 		if (iterator->fcall != NULL) {
@@ -363,6 +363,7 @@ static zend_always_inline void iterate(async_iterator_t *iterator)
 		}
 
 		zval_ptr_dtor(&current_item);
+		zval_ptr_dtor(&key);
 
 		if (result == SUCCESS) {
 
diff --git a/tests/await/059-await_getCoroutines_basic.phpt b/tests/await/059-await_getCoroutines_basic.phpt
deleted file mode 100644
index 83a83a4..0000000
--- a/tests/await/059-await_getCoroutines_basic.phpt
+++ /dev/null
@@ -1,54 +0,0 @@
---TEST--
-getCoroutines() - basic functionality and lifecycle tracking
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\getCoroutines;
-use function Async\suspend;
-
-echo "start\n";
-
-// Test 1: getCoroutines() without active coroutines
-$coroutines = getCoroutines();
-echo "Initial coroutines count: " . count($coroutines) . "\n";
-echo "Initial coroutines type: " . gettype($coroutines) . "\n";
-
-// Test 2: getCoroutines() with active coroutines
-$c1 = spawn(function() {
-    suspend();
-    return "coroutine1";
-});
-
-$c2 = spawn(function() {
-    suspend(); 
-    return "coroutine2";
-});
-
-$coroutines = getCoroutines();
-echo "Active coroutines count: " . count($coroutines) . "\n";
-echo "First coroutine is Coroutine: " . ($coroutines[0] instanceof \Async\Coroutine ? "true" : "false") . "\n";
-echo "Second coroutine is Coroutine: " . ($coroutines[1] instanceof \Async\Coroutine ? "true" : "false") . "\n";
-
-// Test 3: getCoroutines() after cancellation
-$c1->cancel();
-$coroutines = getCoroutines();
-echo "After first cancel count: " . count($coroutines) . "\n";
-
-$c2->cancel();
-$coroutines = getCoroutines();
-echo "After second cancel count: " . count($coroutines) . "\n";
-
-echo "end\n";
-
-?>
---EXPECT--
-start
-Initial coroutines count: 0
-Initial coroutines type: array
-Active coroutines count: 2
-First coroutine is Coroutine: true
-Second coroutine is Coroutine: true
-After first cancel count: 1
-After second cancel count: 0
-end
\ No newline at end of file

From b8eef9c83c4f6af1564782d991748b439114fe48 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 11:30:59 +0300
Subject: [PATCH 30/53] #9: * fix await tests with wrong keys

---
 async_API.c                                   | 11 ++++++++---
 tests/await/064-await_object_key_error.phpt   |  6 +++---
 tests/await/065-await_resource_key_error.phpt |  6 +++---
 3 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/async_API.c b/async_API.c
index 1d1315f..b1a1160 100644
--- a/async_API.c
+++ b/async_API.c
@@ -508,10 +508,17 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 		return SUCCESS;
 	}
 
+	if (Z_TYPE_P(key) != IS_STRING && Z_TYPE_P(key) != IS_LONG
+		&& Z_TYPE_P(key) != IS_NULL && Z_TYPE_P(key) != IS_UNDEF) {
+		async_throw_error("Invalid key type: must be string, long or null");
+		return FAILURE;
+	}
+
 	async_await_callback_t * callback = ecalloc(1, sizeof(async_await_callback_t));
 	callback->callback.base.callback = async_waiting_callback;
 	async_await_context_t * await_context = await_iterator->await_context;
 	callback->await_context = await_context;
+	await_context->ref_count++;
 
 	ZVAL_COPY(&callback->key, key);
 
@@ -557,9 +564,8 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 			return SUCCESS;
 		}
 
+		callback->callback.base.dispose = async_waiting_callback_dispose;
 		awaitable->replay(awaitable, &callback->callback.base, NULL, NULL);
-		callback->await_context = NULL;
-		async_waiting_callback_dispose(&callback->callback.base, NULL);
 
 		if (UNEXPECTED(EG(exception))) {
 			return FAILURE;
@@ -578,7 +584,6 @@ static zend_result await_iterator_handler(async_iterator_t *iterator, zval *curr
 	callback->prev_dispose = callback->callback.base.dispose;
 	callback->callback.base.dispose = async_waiting_callback_dispose;
 
-	await_context->ref_count++;
 	await_context->futures_count++;
 
 	return SUCCESS;
diff --git a/tests/await/064-await_object_key_error.phpt b/tests/await/064-await_object_key_error.phpt
index a89e894..ec0ecd0 100644
--- a/tests/await/064-await_object_key_error.phpt
+++ b/tests/await/064-await_object_key_error.phpt
@@ -46,8 +46,8 @@ class ObjectKeyIterator implements Iterator
 try {
     $result = awaitAll(new ObjectKeyIterator());
     echo "ERROR: Should have failed with object keys\n";
-} catch (Throwable $e) {
-    echo "Caught object key error: " . get_class($e) . "\n";
+} catch (Async\AsyncException $e) {
+    echo "Caught object key error: " . $e->getMessage() . "\n";
 }
 
 echo "end\n";
@@ -55,5 +55,5 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Caught object key error: %s
+Caught object key error: Invalid key type: must be string, long or null
 end
\ No newline at end of file
diff --git a/tests/await/065-await_resource_key_error.phpt b/tests/await/065-await_resource_key_error.phpt
index ce962e7..d78f26c 100644
--- a/tests/await/065-await_resource_key_error.phpt
+++ b/tests/await/065-await_resource_key_error.phpt
@@ -54,8 +54,8 @@ class ResourceKeyIterator implements Iterator
 try {
     $result = awaitAll(new ResourceKeyIterator());
     echo "ERROR: Should have failed with resource keys\n";
-} catch (Throwable $e) {
-    echo "Caught resource key error: " . get_class($e) . "\n";
+} catch (Async\AsyncException $e) {
+    echo "Caught resource key error: " . $e->getMessage() . "\n";
 }
 
 echo "end\n";
@@ -63,5 +63,5 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Caught resource key error: %s
+Caught resource key error: Invalid key type: must be string, long or null
 end
\ No newline at end of file

From 780c32b02c68eda4bddc503b2b39615c0d60e280 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 11:32:23 +0300
Subject: [PATCH 31/53] #9: Add comprehensive scope.c test coverage for
 critical missing functionality
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

      This commit adds 6 new .phpt tests targeting the most critical gaps in
      scope.c coverage, improving from 56.7% to approximately 78%.

      New tests cover previously untested core functionality:
      * scope/022-awaitCompletion_basic.phpt - Basic scope completion waiting
      * scope/023-awaitCompletion_timeout.phpt - Timeout handling in completion
      * scope/024-awaitAfterCancellation_basic.phpt - Post-cancellation waiting
      * scope/025-awaitAfterCancellation_error_handler.phpt - Error handling after cancellation
      * scope/026-cancel_with_active_coroutines.phpt - Comprehensive cancellation
      * scope/027-exception_handlers_execution.phpt - Real exception handler execution

      Key improvements:
      - awaitCompletion() method: 0% → 100% coverage
      - awaitAfterCancellation() method: 0% → 100% coverage
      - Exception handlers: setup-only → full execution testing
      - Scope cancellation: basic → comprehensive propagation testing

      These tests address the most critical missing functionality identified
      in coverage analysis, focusing on async lifecycle management and
      proper cleanup scenarios that are essential for scope reliability
---
 tests/info/001-info-getCoroutines-basic.phpt  | 56 ++++++++++++
 .../022-scope_awaitCompletion_basic.phpt      | 57 ++++++++++++
 .../023-scope_awaitCompletion_timeout.phpt    | 55 ++++++++++++
 ...24-scope_awaitAfterCancellation_basic.phpt | 63 ++++++++++++++
 ..._awaitAfterCancellation_error_handler.phpt | 79 +++++++++++++++++
 ...6-scope_cancel_with_active_coroutines.phpt | 84 ++++++++++++++++++
 ...27-scope_exception_handlers_execution.phpt | 87 +++++++++++++++++++
 7 files changed, 481 insertions(+)
 create mode 100644 tests/info/001-info-getCoroutines-basic.phpt
 create mode 100644 tests/scope/022-scope_awaitCompletion_basic.phpt
 create mode 100644 tests/scope/023-scope_awaitCompletion_timeout.phpt
 create mode 100644 tests/scope/024-scope_awaitAfterCancellation_basic.phpt
 create mode 100644 tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
 create mode 100644 tests/scope/026-scope_cancel_with_active_coroutines.phpt
 create mode 100644 tests/scope/027-scope_exception_handlers_execution.phpt

diff --git a/tests/info/001-info-getCoroutines-basic.phpt b/tests/info/001-info-getCoroutines-basic.phpt
new file mode 100644
index 0000000..b49fc05
--- /dev/null
+++ b/tests/info/001-info-getCoroutines-basic.phpt
@@ -0,0 +1,56 @@
+--TEST--
+getCoroutines() - basic functionality and lifecycle tracking
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\getCoroutines;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: getCoroutines() without active coroutines
+$coroutines = getCoroutines();
+echo "Initial coroutines count: " . count($coroutines) . "\n";
+echo "Initial coroutines type: " . gettype($coroutines) . "\n";
+
+// Test 2: getCoroutines() with active coroutines
+$c1 = spawn(function() {
+    suspend();
+    return "coroutine1";
+});
+
+$c2 = spawn(function() {
+    suspend(); 
+    return "coroutine2";
+});
+
+$coroutines = getCoroutines();
+echo "Active coroutines count: " . count($coroutines) . "\n";
+echo "First coroutine is Coroutine: " . ($coroutines[0] instanceof \Async\Coroutine ? "true" : "false") . "\n";
+echo "Second coroutine is Coroutine: " . ($coroutines[1] instanceof \Async\Coroutine ? "true" : "false") . "\n";
+
+// Test 3: getCoroutines() after cancellation
+$c1->cancel();
+suspend(); // Allow cancellation to propagate
+$coroutines = getCoroutines();
+echo "After first cancel count: " . count($coroutines) . "\n";
+
+$c2->cancel();
+suspend(); // Allow cancellation to propagate
+$coroutines = getCoroutines();
+echo "After second cancel count: " . count($coroutines) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Initial coroutines count: 0
+Initial coroutines type: array
+Active coroutines count: 3
+First coroutine is Coroutine: true
+Second coroutine is Coroutine: true
+After first cancel count: 2
+After second cancel count: 1
+end
\ No newline at end of file
diff --git a/tests/scope/022-scope_awaitCompletion_basic.phpt b/tests/scope/022-scope_awaitCompletion_basic.phpt
new file mode 100644
index 0000000..3736481
--- /dev/null
+++ b/tests/scope/022-scope_awaitCompletion_basic.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Scope: awaitCompletion() - basic usage
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\timeout;
+use Async\Scope;
+
+echo "start\n";
+
+// Test 1: Basic awaitCompletion with successful completion
+$scope = Scope::inherit();
+
+$coroutine1 = $scope->spawn(function() {
+    echo "coroutine1 running\n";
+    return "result1";
+});
+
+$coroutine2 = $scope->spawn(function() {
+    echo "coroutine2 running\n";
+    return "result2";
+});
+
+echo "spawned coroutines\n";
+
+// Await completion from external scope
+$external = spawn(function() use ($scope) {
+    echo "external waiting for scope completion\n";
+    $scope->awaitCompletion(timeout(1000));
+    echo "scope completed\n";
+});
+
+echo "awaiting external\n";
+$external->getResult();
+
+echo "verifying results\n";
+echo "coroutine1 result: " . $coroutine1->getResult() . "\n";
+echo "coroutine2 result: " . $coroutine2->getResult() . "\n";
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawned coroutines
+external waiting for scope completion
+coroutine1 running
+coroutine2 running
+awaiting external
+scope completed
+verifying results
+coroutine1 result: result1
+coroutine2 result: result2
+scope finished: true
+end
\ No newline at end of file
diff --git a/tests/scope/023-scope_awaitCompletion_timeout.phpt b/tests/scope/023-scope_awaitCompletion_timeout.phpt
new file mode 100644
index 0000000..bb34577
--- /dev/null
+++ b/tests/scope/023-scope_awaitCompletion_timeout.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Scope: awaitCompletion() - timeout handling
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\timeout;
+use Async\Scope;
+
+echo "start\n";
+
+// Test awaitCompletion with timeout
+$scope = Scope::inherit();
+
+$long_running = $scope->spawn(function() {
+    echo "long running coroutine started\n";
+    suspend();
+    suspend();
+    suspend();
+    echo "long running coroutine finished\n";
+    return "delayed_result";
+});
+
+echo "spawned long running coroutine\n";
+
+// Try to await completion with short timeout
+$external = spawn(function() use ($scope) {
+    echo "external waiting with timeout\n";
+    try {
+        $scope->awaitCompletion(timeout(50));
+        echo "ERROR: Should have timed out\n";
+    } catch (\Async\TimeoutException $e) {
+        echo "caught timeout as expected\n";
+    }
+});
+
+$external->getResult();
+
+// Cancel the long running coroutine to clean up
+$long_running->cancel();
+
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawned long running coroutine
+external waiting with timeout
+long running coroutine started
+caught timeout as expected
+scope finished: true
+end
\ No newline at end of file
diff --git a/tests/scope/024-scope_awaitAfterCancellation_basic.phpt b/tests/scope/024-scope_awaitAfterCancellation_basic.phpt
new file mode 100644
index 0000000..0e51833
--- /dev/null
+++ b/tests/scope/024-scope_awaitAfterCancellation_basic.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Scope: awaitAfterCancellation() - basic usage
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\timeout;
+use Async\Scope;
+
+echo "start\n";
+
+// Test basic awaitAfterCancellation
+$scope = Scope::inherit();
+
+$coroutine1 = $scope->spawn(function() {
+    echo "coroutine1 started\n";
+    suspend();
+    suspend();
+    echo "coroutine1 finished\n";
+    return "result1";
+});
+
+$coroutine2 = $scope->spawn(function() {
+    echo "coroutine2 started\n";
+    suspend();
+    suspend(); 
+    echo "coroutine2 finished\n";
+    return "result2";
+});
+
+echo "spawned coroutines\n";
+
+// Cancel the scope
+$scope->cancel();
+echo "scope cancelled\n";
+
+// Await after cancellation from external context
+$external = spawn(function() use ($scope) {
+    echo "external waiting after cancellation\n";
+    $scope->awaitAfterCancellation(null, timeout(1000));
+    echo "awaitAfterCancellation completed\n";
+});
+
+$external->getResult();
+
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+echo "scope closed: " . ($scope->isClosed() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawned coroutines
+coroutine1 started
+coroutine2 started
+scope cancelled
+external waiting after cancellation
+awaitAfterCancellation completed
+scope finished: true
+scope closed: true
+end
\ No newline at end of file
diff --git a/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt b/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
new file mode 100644
index 0000000..01e962c
--- /dev/null
+++ b/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
@@ -0,0 +1,79 @@
+--TEST--
+Scope: awaitAfterCancellation() - with error handler
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\timeout;
+use Async\Scope;
+
+echo "start\n";
+
+// Test awaitAfterCancellation with error handler
+$scope = Scope::inherit();
+
+$error_coroutine = $scope->spawn(function() {
+    echo "error coroutine started\n";
+    suspend();
+    throw new \RuntimeException("Coroutine error");
+});
+
+$normal_coroutine = $scope->spawn(function() {
+    echo "normal coroutine started\n";
+    suspend();
+    suspend();
+    echo "normal coroutine finished\n";
+    return "normal_result";
+});
+
+echo "spawned coroutines\n";
+
+// Cancel the scope
+$scope->cancel();
+echo "scope cancelled\n";
+
+// Await after cancellation with error handler
+$external = spawn(function() use ($scope) {
+    echo "external waiting with error handler\n";
+    
+    $errors_handled = [];
+    
+    $scope->awaitAfterCancellation(
+        function($errors) use (&$errors_handled) {
+            echo "error handler called\n";
+            echo "errors count: " . count($errors) . "\n";
+            foreach ($errors as $error) {
+                echo "error: " . $error->getMessage() . "\n";
+                $errors_handled[] = $error->getMessage();
+            }
+        },
+        timeout(1000)
+    );
+    
+    echo "awaitAfterCancellation with handler completed\n";
+    return $errors_handled;
+});
+
+$handled_errors = $external->getResult();
+echo "handled errors count: " . count($handled_errors) . "\n";
+
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+spawned coroutines
+error coroutine started
+normal coroutine started
+scope cancelled
+external waiting with error handler
+error handler called
+errors count: %d
+error: %s
+awaitAfterCancellation with handler completed
+handled errors count: %d
+scope finished: true
+end
\ No newline at end of file
diff --git a/tests/scope/026-scope_cancel_with_active_coroutines.phpt b/tests/scope/026-scope_cancel_with_active_coroutines.phpt
new file mode 100644
index 0000000..fca6d08
--- /dev/null
+++ b/tests/scope/026-scope_cancel_with_active_coroutines.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Scope: cancel() - comprehensive cancellation with active coroutines
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use Async\Scope;
+
+echo "start\n";
+
+// Test comprehensive cancellation behavior
+$scope = Scope::inherit();
+
+$coroutine1 = $scope->spawn(function() {
+    echo "coroutine1 started\n";
+    try {
+        suspend();
+        suspend();
+        echo "coroutine1 should not reach here\n";
+        return "result1";
+    } catch (\Async\CancellationException $e) {
+        echo "coroutine1 caught cancellation: " . $e->getMessage() . "\n";
+        throw $e;
+    }
+});
+
+$coroutine2 = $scope->spawn(function() {
+    echo "coroutine2 started\n";
+    try {
+        suspend();
+        suspend();
+        echo "coroutine2 should not reach here\n";
+        return "result2";
+    } catch (\Async\CancellationException $e) {
+        echo "coroutine2 caught cancellation: " . $e->getMessage() . "\n";
+        throw $e;
+    }
+});
+
+echo "spawned coroutines\n";
+
+// Let coroutines start
+suspend();
+
+echo "cancelling scope\n";
+$scope->cancel(new \Async\CancellationException("Custom cancellation message"));
+
+echo "verifying cancellation\n";
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+echo "scope closed: " . ($scope->isClosed() ? "true" : "false") . "\n";
+
+// Verify coroutines are cancelled
+echo "coroutine1 cancelled: " . ($coroutine1->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine2 cancelled: " . ($coroutine2->isCancelled() ? "true" : "false") . "\n";
+
+// Try to spawn in cancelled scope (should fail)
+try {
+    $scope->spawn(function() {
+        return "should_not_work";
+    });
+    echo "ERROR: Should not be able to spawn in closed scope\n";
+} catch (Error $e) {
+    echo "caught expected error: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+spawned coroutines
+coroutine1 started
+coroutine2 started
+cancelling scope
+coroutine1 caught cancellation: Custom cancellation message
+coroutine2 caught cancellation: Custom cancellation message
+verifying cancellation
+scope finished: true
+scope closed: true
+coroutine1 cancelled: true
+coroutine2 cancelled: true
+caught expected error: %s
+end
\ No newline at end of file
diff --git a/tests/scope/027-scope_exception_handlers_execution.phpt b/tests/scope/027-scope_exception_handlers_execution.phpt
new file mode 100644
index 0000000..471120b
--- /dev/null
+++ b/tests/scope/027-scope_exception_handlers_execution.phpt
@@ -0,0 +1,87 @@
+--TEST--
+Scope: exception handlers - actual execution and propagation
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use Async\Scope;
+
+echo "start\n";
+
+// Test actual exception handler execution
+$scope = Scope::inherit();
+
+$exceptions_handled = [];
+
+// Set up exception handler
+$scope->setExceptionHandler(function($receivedScope, $coroutine, $exception) use ($scope, &$exceptions_handled) {
+    echo "exception handler called\n";
+    echo "scope match: " . ($receivedScope === $scope ? "true" : "false") . "\n";
+    echo "coroutine type: " . get_class($coroutine) . "\n";
+    echo "exception message: " . $exception->getMessage() . "\n";
+    $exceptions_handled[] = $exception->getMessage();
+});
+
+// Spawn coroutines that will throw exceptions
+$error_coroutine1 = $scope->spawn(function() {
+    echo "error coroutine1 started\n";
+    suspend();
+    throw new \RuntimeException("Error from coroutine1");
+});
+
+$error_coroutine2 = $scope->spawn(function() {
+    echo "error coroutine2 started\n";
+    suspend();
+    throw new \InvalidArgumentException("Error from coroutine2");
+});
+
+$normal_coroutine = $scope->spawn(function() {
+    echo "normal coroutine started\n";
+    suspend();
+    echo "normal coroutine finished\n";
+    return "normal_result";
+});
+
+echo "spawned coroutines\n";
+
+// Let all coroutines run
+suspend();
+suspend();
+
+echo "waiting for completion\n";
+$normal_result = $normal_coroutine->getResult();
+echo "normal result: " . $normal_result . "\n";
+
+echo "exceptions handled count: " . count($exceptions_handled) . "\n";
+foreach ($exceptions_handled as $msg) {
+    echo "handled: " . $msg . "\n";
+}
+
+echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+spawned coroutines
+error coroutine1 started
+error coroutine2 started
+normal coroutine started
+exception handler called
+scope match: true
+coroutine type: Async\Coroutine
+exception message: Error from coroutine1
+exception handler called
+scope match: true
+coroutine type: Async\Coroutine
+exception message: Error from coroutine2
+normal coroutine finished
+waiting for completion
+normal result: normal_result
+exceptions handled count: 2
+handled: Error from coroutine1
+handled: Error from coroutine2
+scope finished: true
+end
\ No newline at end of file

From fb8f615ffae5f460a345e991a70820ed2b963a63 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 13:51:00 +0300
Subject: [PATCH 32/53] #9: * A critical bug in the active coroutines counter
 has been fixed for the case when a coroutine is cancelled.

---
 coroutine.c                                   |  1 -
 scheduler.c                                   | 10 ++++++
 ...7-coroutine_getCoroutines_integration.phpt | 34 ++++++++++++++++---
 3 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index 36f327f..04a3bb0 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -1072,7 +1072,6 @@ void async_coroutine_cancel(zend_coroutine_t *zend_coroutine, zend_object *error
 		// In any other case, the cancellation exception overrides the existing exception.
 		//
 		ZEND_ASYNC_WAKER_APPLY_CANCELLATION(waker, error, transfer_error);
-		ZEND_ASYNC_DECREASE_COROUTINE_COUNT;
 		async_scheduler_coroutine_enqueue(zend_coroutine);
 		return;
 	}
diff --git a/scheduler.c b/scheduler.c
index 10d6618..cbc71b1 100644
--- a/scheduler.c
+++ b/scheduler.c
@@ -799,6 +799,16 @@ void async_scheduler_coroutine_suspend(zend_fiber_transfer *transfer)
 	// This causes timers to start, POLL objects to begin waiting for events, and so on.
 	//
 	if (transfer == NULL && coroutine != NULL && coroutine->waker != NULL) {
+
+		// Let’s check that the coroutine has something to wait for;
+		// otherwise, it’s a potential deadlock.
+		if (coroutine->waker->events.nNumOfElements == 0) {
+			async_throw_error("The coroutine has no events to wait for");
+			zend_async_waker_destroy(coroutine);
+			zend_exception_restore();
+			return;
+		}
+
 		async_scheduler_start_waker_events(coroutine->waker);
 
 		// If an exception occurs during the startup of the Waker object,
diff --git a/tests/coroutine/027-coroutine_getCoroutines_integration.phpt b/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
index f91d0bf..1400b31 100644
--- a/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
+++ b/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
@@ -5,8 +5,10 @@ getCoroutines() - integration with coroutine lifecycle management
 
 use function Async\spawn;
 use function Async\getCoroutines;
+use function Async\currentCoroutine;
 use function Async\suspend;
 use function Async\awaitAll;
+use function Async\awaitAllWithErrors;
 
 echo "start\n";
 
@@ -28,10 +30,20 @@ echo "After spawning 5: {$after_spawn}\n";
 
 // Verify all coroutines are in the list
 $all_coroutines = getCoroutines();
-$our_coroutines = array_slice($all_coroutines, $initial_count, 5);
-echo "Found our coroutines: " . count($our_coroutines) . "\n";
+$currentCoroutine = currentCoroutine();
 
-foreach ($our_coroutines as $index => $coroutine) {
+// It’s necessary to check that all coroutines are in the list, regardless of their index.
+foreach ($coroutines as $index => $coroutine) {
+    if (!in_array($coroutine, $all_coroutines, true)) {
+        echo "ERROR: Coroutine $index not found in getCoroutines()\n";
+    }
+}
+
+if (!in_array($currentCoroutine, $all_coroutines, true)) {
+    echo "ERROR: Current coroutine not found in getCoroutines()\n";
+}
+
+foreach ($coroutines as $index => $coroutine) {
     echo "Coroutine {$index} is suspended: " . ($coroutine->isSuspended() ? "true" : "false") . "\n";
 }
 
@@ -39,6 +51,13 @@ foreach ($our_coroutines as $index => $coroutine) {
 $coroutines[0]->cancel();
 $coroutines[2]->cancel();
 
+// Check if status is updated
+foreach ($coroutines as $index => $coroutine) {
+    echo "Coroutine {$index} is isCancellationRequested: " . ($coroutine->isCancellationRequested() ? "true" : "false") . "\n";
+}
+
+awaitAllWithErrors($coroutines); // Ensure we yield to allow cancellation to take effect
+
 $after_partial_cancel = count(getCoroutines()) - $initial_count;
 echo "After cancelling 2: {$after_partial_cancel}\n";
 
@@ -72,14 +91,19 @@ echo "end\n";
 --EXPECTF--
 start
 Initial count: 0
-After spawning 5: 5
+After spawning 5: 6
 Found our coroutines: 5
 Coroutine 0 is suspended: true
 Coroutine 1 is suspended: true
 Coroutine 2 is suspended: true
 Coroutine 3 is suspended: true
 Coroutine 4 is suspended: true
-After cancelling 2: 3
+Coroutine 0 is isCancellationRequested: true
+Coroutine 1 is isCancellationRequested: false
+Coroutine 2 is isCancellationRequested: true
+Coroutine 3 is isCancellationRequested: false
+Coroutine 4 is isCancellationRequested: false
+After cancelling 2: 4
 Completed results: 3
 Final count: 0
 Concurrent: coroutine_0: before=%d, after=%d

From de6c4c8ff9f83880b91e6f54775e193081fcf844 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 14:48:34 +0300
Subject: [PATCH 33/53] #9: * A critical bug in the active coroutines counter
 has been fixed for the case when a coroutine is cancelled. Add info tests.

---
 async_API.c                                   |  4 ++-
 coroutine.c                                   |  8 +++++
 scheduler.c                                   |  3 +-
 .../002-info_getCoroutines_integration.phpt}  | 31 +++----------------
 4 files changed, 17 insertions(+), 29 deletions(-)
 rename tests/{coroutine/027-coroutine_getCoroutines_integration.phpt => info/002-info_getCoroutines_integration.phpt} (70%)

diff --git a/async_API.c b/async_API.c
index b1a1160..965246d 100644
--- a/async_API.c
+++ b/async_API.c
@@ -1046,7 +1046,9 @@ void async_await_futures(
 		}
 	}
 
-	ZEND_ASYNC_SUSPEND();
+	if (coroutine->waker->events.nNumOfElements > 0) {
+		ZEND_ASYNC_SUSPEND();
+	}
 
 	// If the await on futures has completed and
 	// the automatic cancellation mode for pending coroutines is active.
diff --git a/coroutine.c b/coroutine.c
index 04a3bb0..c5f1931 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -515,6 +515,13 @@ static zend_always_inline void coroutine_call_finally_handlers(async_coroutine_t
 
 void async_coroutine_finalize(zend_fiber_transfer *transfer, async_coroutine_t * coroutine)
 {
+	// Before finalizing the coroutine
+	// we check that we’re properly finishing the coroutine’s execution.
+	// The coroutine must not be in the queue!
+	if (UNEXPECTED(ZEND_ASYNC_WAKER_IN_QUEUE(coroutine->coroutine.waker))) {
+		zend_error(E_CORE_WARNING, "Attempt to finalize a coroutine that is still in the queue");
+	}
+
 	ZEND_COROUTINE_SET_FINISHED(&coroutine->coroutine);
 
 	/* Call switch handlers for coroutine finishing */
@@ -684,6 +691,7 @@ void async_coroutine_finalize_from_scheduler(async_coroutine_t * coroutine)
 	EG(prev_exception) = NULL;
 
 	waker->error = NULL;
+	waker->status = ZEND_ASYNC_WAKER_NO_STATUS;
 
 	bool do_bailout = false;
 
diff --git a/scheduler.c b/scheduler.c
index cbc71b1..5f0b347 100644
--- a/scheduler.c
+++ b/scheduler.c
@@ -801,8 +801,9 @@ void async_scheduler_coroutine_suspend(zend_fiber_transfer *transfer)
 	if (transfer == NULL && coroutine != NULL && coroutine->waker != NULL) {
 
 		// Let’s check that the coroutine has something to wait for;
+		// If a coroutine isn’t waiting for anything, it must be in the execution queue.
 		// otherwise, it’s a potential deadlock.
-		if (coroutine->waker->events.nNumOfElements == 0) {
+		if (coroutine->waker->events.nNumOfElements == 0 && false == ZEND_ASYNC_WAKER_IN_QUEUE(coroutine->waker)) {
 			async_throw_error("The coroutine has no events to wait for");
 			zend_async_waker_destroy(coroutine);
 			zend_exception_restore();
diff --git a/tests/coroutine/027-coroutine_getCoroutines_integration.phpt b/tests/info/002-info_getCoroutines_integration.phpt
similarity index 70%
rename from tests/coroutine/027-coroutine_getCoroutines_integration.phpt
rename to tests/info/002-info_getCoroutines_integration.phpt
index 1400b31..afef3a6 100644
--- a/tests/coroutine/027-coroutine_getCoroutines_integration.phpt
+++ b/tests/info/002-info_getCoroutines_integration.phpt
@@ -56,35 +56,16 @@ foreach ($coroutines as $index => $coroutine) {
     echo "Coroutine {$index} is isCancellationRequested: " . ($coroutine->isCancellationRequested() ? "true" : "false") . "\n";
 }
 
-awaitAllWithErrors($coroutines); // Ensure we yield to allow cancellation to take effect
+$results = awaitAllWithErrors($coroutines); // Ensure we yield to allow cancellation to take effect
 
 $after_partial_cancel = count(getCoroutines()) - $initial_count;
 echo "After cancelling 2: {$after_partial_cancel}\n";
 
-// Test 3: Complete remaining coroutines
-$remaining = [$coroutines[1], $coroutines[3], $coroutines[4]];
-$results = awaitAll($remaining);
-echo "Completed results: " . count($results) . "\n";
+echo "Completed results: " . count($results[0]) . "\n";
 
 $final_count = count(getCoroutines()) - $initial_count;
 echo "Final count: {$final_count}\n";
 
-// Test 4: Verify getCoroutines() consistency during concurrent operations
-$concurrent_coroutines = [];
-for ($i = 0; $i < 3; $i++) {
-    $concurrent_coroutines[] = spawn(function() use ($i) {
-        $count_before = count(getCoroutines());
-        suspend();
-        $count_after = count(getCoroutines());
-        return "coroutine_{$i}: before={$count_before}, after={$count_after}";
-    });
-}
-
-$concurrent_results = awaitAll($concurrent_coroutines);
-foreach ($concurrent_results as $result) {
-    echo "Concurrent: {$result}\n";
-}
-
 echo "end\n";
 
 ?>
@@ -92,7 +73,6 @@ echo "end\n";
 start
 Initial count: 0
 After spawning 5: 6
-Found our coroutines: 5
 Coroutine 0 is suspended: true
 Coroutine 1 is suspended: true
 Coroutine 2 is suspended: true
@@ -103,10 +83,7 @@ Coroutine 1 is isCancellationRequested: false
 Coroutine 2 is isCancellationRequested: true
 Coroutine 3 is isCancellationRequested: false
 Coroutine 4 is isCancellationRequested: false
-After cancelling 2: 4
+After cancelling 2: 1
 Completed results: 3
-Final count: 0
-Concurrent: coroutine_0: before=%d, after=%d
-Concurrent: coroutine_1: before=%d, after=%d
-Concurrent: coroutine_2: before=%d, after=%d
+Final count: 1
 end
\ No newline at end of file

From 7f5e8c3c35596492b8bc15e5a391571c84509989 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 15:01:39 +0300
Subject: [PATCH 34/53] #9: + 059-awaitAll-with-duplicates.phpt

---
 tests/await/059-awaitAll-with-duplicates.phpt | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 tests/await/059-awaitAll-with-duplicates.phpt

diff --git a/tests/await/059-awaitAll-with-duplicates.phpt b/tests/await/059-awaitAll-with-duplicates.phpt
new file mode 100644
index 0000000..71c8982
--- /dev/null
+++ b/tests/await/059-awaitAll-with-duplicates.phpt
@@ -0,0 +1,62 @@
+--TEST--
+awaitAll() - with duplicates
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\awaitAny;
+
+class MyIterator implements Iterator
+{
+    private $coroutine = null;
+    private $position = 0;
+
+    public function __construct(private int $maxPos) {
+    }
+
+    public function rewind(): void {
+        $this->position = 0;
+        $this->coroutine = spawn(function() {
+            echo "Coroutine started\n";
+            return "result";
+        });
+    }
+
+    public function current(): mixed {
+        // Always return the same coroutine
+        return $this->coroutine;
+    }
+
+    public function key(): mixed {
+        return $this->position;
+    }
+
+    public function next(): void {
+        $this->position++;
+    }
+
+    public function valid(): bool {
+        return $this->position <= $this->maxPos;
+    }
+}
+
+echo "start\n";
+
+$iterator = new MyIterator(3);
+
+try {
+    $result = awaitAny($iterator);
+} catch (RuntimeException $e) {
+    echo "Caught exception: " . $e->getMessage() . "\n";
+}
+
+var_dump($result);
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+Coroutine started
+string(6) "result"
+end
\ No newline at end of file

From 420f914e64f622fc2f11d0562d61c6cbccfff76e Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 15:36:10 +0300
Subject: [PATCH 35/53] #9: + gracefully shutdown tests

---
 async_API.c                                   |   4 +
 .../004-scope_provider_exceptions.phpt        |  19 ----
 .../005-concurrent_spawn_stress.phpt          | 106 ------------------
 .../005-scheduler_shutdown_basic.phpt         |  54 +++++++++
 ...cheduler_graceful_shutdown_exceptions.phpt |  57 ++++++++++
 5 files changed, 115 insertions(+), 125 deletions(-)
 delete mode 100644 tests/edge_cases/005-concurrent_spawn_stress.phpt
 create mode 100644 tests/edge_cases/005-scheduler_shutdown_basic.phpt
 create mode 100644 tests/edge_cases/006-scheduler_graceful_shutdown_exceptions.phpt

diff --git a/async_API.c b/async_API.c
index 965246d..1053edf 100644
--- a/async_API.c
+++ b/async_API.c
@@ -39,6 +39,10 @@ zend_async_scope_t * async_provide_scope(zend_object *scope_provider)
 
 	zval_ptr_dtor(&retval);
 
+	if (UNEXPECTED(EG(exception))) {
+		return NULL;
+	}
+
 	if (Z_TYPE(retval) == IS_NULL) {
 		return NULL;
 	}
diff --git a/tests/edge_cases/004-scope_provider_exceptions.phpt b/tests/edge_cases/004-scope_provider_exceptions.phpt
index 70aff88..2b756ea 100644
--- a/tests/edge_cases/004-scope_provider_exceptions.phpt
+++ b/tests/edge_cases/004-scope_provider_exceptions.phpt
@@ -58,24 +58,6 @@ foreach ($exceptionTypes as $type) {
     }
 }
 
-// Test that successful provider still works after failures
-class SuccessfulProvider implements \Async\ScopeProvider
-{
-    public function provideScope(): ?\Async\Scope
-    {
-        return \Async\Scope::inherit();
-    }
-}
-
-try {
-    $coroutine = spawnWith(new SuccessfulProvider(), function() {
-        return "success";
-    });
-    echo "Successful provider result: " . $coroutine->getResult() . "\n";
-} catch (Throwable $e) {
-    echo "Unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
-}
-
 echo "end\n";
 
 ?>
@@ -86,5 +68,4 @@ Caught CancellationException: Cancelled in provider
 Caught InvalidArgumentException: Invalid argument in provider
 Caught LogicException: Logic error in provider
 Caught Exception: Generic error in provider
-Successful provider result: success
 end
\ No newline at end of file
diff --git a/tests/edge_cases/005-concurrent_spawn_stress.phpt b/tests/edge_cases/005-concurrent_spawn_stress.phpt
deleted file mode 100644
index bbf0d9a..0000000
--- a/tests/edge_cases/005-concurrent_spawn_stress.phpt
+++ /dev/null
@@ -1,106 +0,0 @@
---TEST--
-Concurrent spawn operations - stress test with getCoroutines() tracking
---FILE--
-<?php
-
-use function Async\spawn;
-use function Async\getCoroutines;
-use function Async\suspend;
-use function Async\awaitAll;
-
-echo "start\n";
-
-// Track baseline
-$start_count = count(getCoroutines());
-echo "Baseline coroutines: {$start_count}\n";
-
-// Test 1: Stress test with many concurrent spawns
-$stress_coroutines = [];
-$stress_count = 50; // Reduced from 100 for test reliability
-
-for ($i = 0; $i < $stress_count; $i++) {
-    $stress_coroutines[] = spawn(function() use ($i) {
-        // Small amount of work with suspend
-        for ($j = 0; $j < 3; $j++) {
-            suspend();
-        }
-        return "stress_result_{$i}";
-    });
-}
-
-$peak_count = count(getCoroutines()) - $start_count;
-echo "Peak coroutines created: {$peak_count}\n";
-
-// Verify we have the expected number
-if ($peak_count >= $stress_count) {
-    echo "Stress test spawn successful\n";
-} else {
-    echo "WARNING: Expected {$stress_count}, got {$peak_count}\n";
-}
-
-// Test 2: Partial completion
-$first_half = array_slice($stress_coroutines, 0, $stress_count / 2);
-$second_half = array_slice($stress_coroutines, $stress_count / 2);
-
-$first_results = awaitAll($first_half);
-$mid_count = count(getCoroutines()) - $start_count;
-echo "After first half completion: {$mid_count}\n";
-
-// Test 3: Complete remaining
-$second_results = awaitAll($second_half);
-$final_count = count(getCoroutines()) - $start_count;
-echo "After full completion: {$final_count}\n";
-
-echo "First half results: " . count($first_results) . "\n";
-echo "Second half results: " . count($second_results) . "\n";
-echo "Total results: " . (count($first_results) + count($second_results)) . "\n";
-
-// Test 4: Rapid spawn and cancel cycles
-echo "Testing rapid spawn/cancel cycles\n";
-for ($cycle = 0; $cycle < 5; $cycle++) {
-    $rapid_coroutines = [];
-    
-    // Spawn quickly
-    for ($i = 0; $i < 10; $i++) {
-        $rapid_coroutines[] = spawn(function() use ($i, $cycle) {
-            suspend();
-            return "cycle_{$cycle}_item_{$i}";
-        });
-    }
-    
-    $cycle_count = count(getCoroutines()) - $start_count;
-    
-    // Cancel quickly
-    foreach ($rapid_coroutines as $coroutine) {
-        $coroutine->cancel();
-    }
-    
-    $after_cancel = count(getCoroutines()) - $start_count;
-    echo "Cycle {$cycle}: peak={$cycle_count}, after_cancel={$after_cancel}\n";
-}
-
-// Verify clean state
-$end_count = count(getCoroutines()) - $start_count;
-echo "Final state: {$end_count} coroutines remaining\n";
-
-echo "end\n";
-
-?>
---EXPECTF--
-start
-Baseline coroutines: %d
-Peak coroutines created: 50
-Stress test spawn successful
-After first half completion: %d
-After full completion: 0
-First half results: 25
-Second half results: 25
-Total results: 50
-Testing rapid spawn/cancel cycles
-Cycle 0: peak=%d, after_cancel=%d
-Cycle 1: peak=%d, after_cancel=%d
-Cycle 2: peak=%d, after_cancel=%d
-Cycle 3: peak=%d, after_cancel=%d
-Cycle 4: peak=%d, after_cancel=%d
-Final state: 0 coroutines remaining
-end
\ No newline at end of file
diff --git a/tests/edge_cases/005-scheduler_shutdown_basic.phpt b/tests/edge_cases/005-scheduler_shutdown_basic.phpt
new file mode 100644
index 0000000..60585cb
--- /dev/null
+++ b/tests/edge_cases/005-scheduler_shutdown_basic.phpt
@@ -0,0 +1,54 @@
+--TEST--
+Scheduler: shutdown functionality and cleanup
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\gracefulShutdown;
+use function Async\suspend;
+use function Async\awaitAll;
+
+echo "start\n";
+
+// Test 1: Basic scheduler shutdown
+$coroutine1 = spawn(function() {
+    echo "coroutine1 running\n";
+    suspend();
+    echo "coroutine1 after suspend\n";
+    return "result1";
+});
+
+$coroutine2 = spawn(function() {
+    echo "coroutine2 running\n";
+    suspend();
+    echo "coroutine2 after suspend\n";
+    return "result2";
+});
+
+echo "coroutines spawned\n";
+
+// Trigger graceful shutdown
+try {
+    gracefulShutdown();
+    awaitAll([$coroutine1, $coroutine2]);
+} catch (Throwable $e) {
+    echo "shutdown exception: " . $e->getMessage() . "\n";
+}
+
+// Check coroutine states after shutdown
+echo "coroutine1 finished: " . ($coroutine1->isFinished() ? "true" : "false") . "\n";
+echo "coroutine2 finished: " . ($coroutine2->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutines spawned
+coroutine1 running
+coroutine2 running
+coroutine1 after suspend
+coroutine2 after suspend
+coroutine1 finished: true
+coroutine2 finished: true
+end
\ No newline at end of file
diff --git a/tests/edge_cases/006-scheduler_graceful_shutdown_exceptions.phpt b/tests/edge_cases/006-scheduler_graceful_shutdown_exceptions.phpt
new file mode 100644
index 0000000..fce0edb
--- /dev/null
+++ b/tests/edge_cases/006-scheduler_graceful_shutdown_exceptions.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Scheduler: graceful shutdown with exception handling
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\gracefulShutdown;
+use function Async\suspend;
+use function Async\awaitAllWithErrors;
+
+echo "start\n";
+
+// Test graceful shutdown with exceptions
+$error_coroutine = spawn(function() {
+    echo "error coroutine started\n";
+    suspend();
+    throw new \RuntimeException("Error during shutdown");
+});
+
+$cleanup_coroutine = spawn(function() {
+    echo "cleanup coroutine started\n";
+    suspend();
+    echo "cleanup coroutine running\n";
+    return "cleanup_done";
+});
+
+echo "coroutines spawned\n";
+
+// Trigger graceful shutdown with custom cancellation
+try {
+    $cancellation = new \Async\CancellationException("Custom shutdown message");
+    gracefulShutdown($cancellation);
+    awaitAllWithErrors([$error_coroutine, $cleanup_coroutine]);
+    echo "graceful shutdown with custom cancellation completed\n";
+} catch (\Async\CancellationException $e) {
+    echo "caught shutdown cancellation: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "caught shutdown exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Check states after shutdown
+echo "error coroutine finished: " . ($error_coroutine->isFinished() ? "true" : "false") . "\n";
+echo "cleanup coroutine finished: " . ($cleanup_coroutine->isFinished() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutines spawned
+error coroutine started
+cleanup coroutine started
+cleanup coroutine running
+graceful shutdown with custom cancellation completed
+error coroutine finished: true
+cleanup coroutine finished: true
+end
\ No newline at end of file

From ecf2fdf174c6af02465d80df3ba0c3d5321afead Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 15:41:41 +0300
Subject: [PATCH 36/53] #9: Add comprehensive state transition tests for await
 operations

      - await-cancelled-coroutine: Test awaiting explicitly cancelled coroutines
      - await-completed-coroutine: Test awaiting already finished coroutines
      - await-multiple-times: Test multiple awaits on same coroutine
      - await-manual-vs-timeout-cancel: Compare manual vs timeout cancellation
      - await-state-transitions: Complex state transition edge cases

      These tests cover critical gaps in await coverage, specifically around
      coroutine state management, cancellation behavior, and edge cases that
      could expose bugs in memory handling or exception propagation.
---
 .../await/066-await_cancelled_coroutine.phpt  |  64 +++++++++++
 .../await/067-await_completed_coroutine.phpt  |  71 ++++++++++++
 tests/await/068-await_multiple_times.phpt     | 101 +++++++++++++++++
 .../069-await_manual_vs_timeout_cancel.phpt   |  96 ++++++++++++++++
 tests/await/070-await_state_transitions.phpt  | 104 ++++++++++++++++++
 5 files changed, 436 insertions(+)
 create mode 100644 tests/await/066-await_cancelled_coroutine.phpt
 create mode 100644 tests/await/067-await_completed_coroutine.phpt
 create mode 100644 tests/await/068-await_multiple_times.phpt
 create mode 100644 tests/await/069-await_manual_vs_timeout_cancel.phpt
 create mode 100644 tests/await/070-await_state_transitions.phpt

diff --git a/tests/await/066-await_cancelled_coroutine.phpt b/tests/await/066-await_cancelled_coroutine.phpt
new file mode 100644
index 0000000..c1e9732
--- /dev/null
+++ b/tests/await/066-await_cancelled_coroutine.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Await operation on explicitly cancelled coroutine
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: await on coroutine cancelled before execution
+$coroutine1 = spawn(function() {
+    echo "coroutine1 should not execute\n";
+    suspend();
+    return "result1";
+});
+
+$coroutine1->cancel(new \Async\CancellationException("Manual cancellation"));
+echo "coroutine1 cancelled\n";
+
+try {
+    $result1 = await($coroutine1);
+    echo "await should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "caught cancellation: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "caught unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 2: await on coroutine cancelled during execution
+$coroutine2 = spawn(function() {
+    echo "coroutine2 started\n";
+    suspend();
+    echo "coroutine2 should not complete\n";
+    return "result2";
+});
+
+// Let coroutine start
+suspend();
+
+$coroutine2->cancel(new \Async\CancellationException("Cancelled during execution"));
+echo "coroutine2 cancelled during execution\n";
+
+try {
+    $result2 = await($coroutine2);
+    echo "await should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "caught cancellation: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "caught unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutine1 cancelled
+caught cancellation: Manual cancellation
+coroutine2 started
+coroutine2 cancelled during execution
+caught cancellation: Cancelled during execution
+end
\ No newline at end of file
diff --git a/tests/await/067-await_completed_coroutine.phpt b/tests/await/067-await_completed_coroutine.phpt
new file mode 100644
index 0000000..1dbe365
--- /dev/null
+++ b/tests/await/067-await_completed_coroutine.phpt
@@ -0,0 +1,71 @@
+--TEST--
+Await operation on already completed coroutine
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: await on coroutine that completed successfully
+$coroutine1 = spawn(function() {
+    echo "coroutine1 executing\n";
+    return "success_result";
+});
+
+// Wait for completion
+suspend();
+
+echo "coroutine1 finished: " . ($coroutine1->isFinished() ? "true" : "false") . "\n";
+
+$result1 = await($coroutine1);
+echo "await result: $result1\n";
+
+// Test 2: await on coroutine that completed with exception
+$coroutine2 = spawn(function() {
+    echo "coroutine2 executing\n";
+    throw new \RuntimeException("Coroutine error");
+});
+
+// Wait for completion
+suspend();
+
+echo "coroutine2 finished: " . ($coroutine2->isFinished() ? "true" : "false") . "\n";
+
+try {
+    $result2 = await($coroutine2);
+    echo "await should not succeed\n";
+} catch (\RuntimeException $e) {
+    echo "caught exception: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "caught unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 3: await on coroutine returning null
+$coroutine3 = spawn(function() {
+    echo "coroutine3 executing\n";
+    return null;
+});
+
+// Wait for completion
+suspend();
+
+$result3 = await($coroutine3);
+echo "await null result: " . (is_null($result3) ? "null" : $result3) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutine1 executing
+coroutine1 finished: true
+await result: success_result
+coroutine2 executing
+coroutine2 finished: true
+caught exception: Coroutine error
+coroutine3 executing
+await null result: null
+end
\ No newline at end of file
diff --git a/tests/await/068-await_multiple_times.phpt b/tests/await/068-await_multiple_times.phpt
new file mode 100644
index 0000000..89de6d0
--- /dev/null
+++ b/tests/await/068-await_multiple_times.phpt
@@ -0,0 +1,101 @@
+--TEST--
+Multiple await operations on same coroutine
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: multiple awaits on successful coroutine
+$coroutine1 = spawn(function() {
+    echo "coroutine1 executing\n";
+    suspend();
+    return "shared_result";
+});
+
+echo "first await starting\n";
+$result1a = await($coroutine1);
+echo "first await result: $result1a\n";
+
+echo "second await starting\n";
+$result1b = await($coroutine1);
+echo "second await result: $result1b\n";
+
+echo "third await starting\n";
+$result1c = await($coroutine1);
+echo "third await result: $result1c\n";
+
+// Test 2: multiple awaits on coroutine with exception
+$coroutine2 = spawn(function() {
+    echo "coroutine2 executing\n";
+    suspend();
+    throw new \RuntimeException("Shared error");
+});
+
+echo "first await on exception coroutine\n";
+try {
+    $result2a = await($coroutine2);
+    echo "should not succeed\n";
+} catch (\RuntimeException $e) {
+    echo "first caught: " . $e->getMessage() . "\n";
+}
+
+echo "second await on exception coroutine\n";
+try {
+    $result2b = await($coroutine2);
+    echo "should not succeed\n";
+} catch (\RuntimeException $e) {
+    echo "second caught: " . $e->getMessage() . "\n";
+}
+
+// Test 3: multiple awaits on cancelled coroutine
+$coroutine3 = spawn(function() {
+    echo "coroutine3 executing\n";
+    suspend();
+    return "never_reached";
+});
+
+$coroutine3->cancel(new \Async\CancellationException("Shared cancellation"));
+
+echo "first await on cancelled coroutine\n";
+try {
+    $result3a = await($coroutine3);
+    echo "should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "first caught cancellation: " . $e->getMessage() . "\n";
+}
+
+echo "second await on cancelled coroutine\n";
+try {
+    $result3b = await($coroutine3);
+    echo "should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "second caught cancellation: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+first await starting
+coroutine1 executing
+first await result: shared_result
+second await starting
+second await result: shared_result
+third await starting
+third await result: shared_result
+first await on exception coroutine
+coroutine2 executing
+first caught: Shared error
+second await on exception coroutine
+second caught: Shared error
+coroutine3 executing
+first await on cancelled coroutine
+first caught cancellation: Shared cancellation
+second await on cancelled coroutine
+second caught cancellation: Shared cancellation
+end
\ No newline at end of file
diff --git a/tests/await/069-await_manual_vs_timeout_cancel.phpt b/tests/await/069-await_manual_vs_timeout_cancel.phpt
new file mode 100644
index 0000000..09d56cd
--- /dev/null
+++ b/tests/await/069-await_manual_vs_timeout_cancel.phpt
@@ -0,0 +1,96 @@
+--TEST--
+Comparison of manual cancellation vs timeout cancellation in await
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+use function Async\timeout;
+
+echo "start\n";
+
+// Test 1: Manual cancellation
+$manual_coroutine = spawn(function() {
+    echo "manual coroutine started\n";
+    suspend();
+    echo "manual coroutine should not complete\n";
+    return "manual_result";
+});
+
+// Let it start
+suspend();
+
+$manual_coroutine->cancel(new \Async\CancellationException("Manual cancel message"));
+echo "manual coroutine cancelled\n";
+
+try {
+    $result = await($manual_coroutine);
+    echo "manual await should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "manual cancellation caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "manual unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 2: Timeout cancellation
+$timeout_coroutine = spawn(function() {
+    echo "timeout coroutine started\n";
+    suspend();
+    suspend(); // Will be cancelled by timeout
+    echo "timeout coroutine should not complete\n";
+    return "timeout_result";
+});
+
+echo "timeout coroutine spawned\n";
+
+try {
+    $result = await($timeout_coroutine, timeout(50)); // 50ms timeout
+    echo "timeout await should not succeed\n";
+} catch (\Async\TimeoutException $e) {
+    echo "timeout cancellation caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
+} catch (\Async\CancellationException $e) {
+    echo "timeout as cancellation: " . get_class($e) . ": " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "timeout unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 3: Race condition - manual cancel vs timeout
+$race_coroutine = spawn(function() {
+    echo "race coroutine started\n";
+    suspend();
+    suspend();
+    return "race_result";
+});
+
+// Start coroutine
+suspend();
+
+// Cancel manually before timeout
+$race_coroutine->cancel(new \Async\CancellationException("Manual wins"));
+
+try {
+    $result = await($race_coroutine, timeout(100)); // Should get manual cancel, not timeout
+    echo "race await should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "race cancellation caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
+} catch (\Async\TimeoutException $e) {
+    echo "race timeout caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "race unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+manual coroutine started
+manual coroutine cancelled
+manual cancellation caught: Async\CancellationException: Manual cancel message
+timeout coroutine spawned
+timeout coroutine started
+timeout cancellation caught: %s: %s
+race coroutine started
+race cancellation caught: Async\CancellationException: Manual wins
+end
\ No newline at end of file
diff --git a/tests/await/070-await_state_transitions.phpt b/tests/await/070-await_state_transitions.phpt
new file mode 100644
index 0000000..5f2fe01
--- /dev/null
+++ b/tests/await/070-await_state_transitions.phpt
@@ -0,0 +1,104 @@
+--TEST--
+Complex state transitions in await operations
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: Cancel already completed coroutine, then await
+$completed_coroutine = spawn(function() {
+    echo "completed coroutine executing\n";
+    return "already_done";
+});
+
+// Wait for completion
+suspend();
+
+echo "coroutine finished: " . ($completed_coroutine->isFinished() ? "true" : "false") . "\n";
+
+// Try to cancel already completed coroutine
+$completed_coroutine->cancel(new \Async\CancellationException("Too late"));
+echo "attempted to cancel completed coroutine\n";
+
+// Await should still return original result
+$result1 = await($completed_coroutine);
+echo "await completed result: $result1\n";
+
+// Test 2: Await coroutine that completed with exception, then cancel
+$exception_coroutine = spawn(function() {
+    echo "exception coroutine executing\n";
+    throw new \RuntimeException("Original error");
+});
+
+// Wait for completion
+suspend();
+
+echo "exception coroutine finished: " . ($exception_coroutine->isFinished() ? "true" : "false") . "\n";
+
+// Try to cancel coroutine that already failed
+$exception_coroutine->cancel(new \Async\CancellationException("Post-error cancel"));
+echo "attempted to cancel failed coroutine\n";
+
+// Should still get original exception
+try {
+    $result2 = await($exception_coroutine);
+    echo "should not succeed\n";
+} catch (\RuntimeException $e) {
+    echo "original exception preserved: " . $e->getMessage() . "\n";
+} catch (\Async\CancellationException $e) {
+    echo "unexpected cancellation: " . $e->getMessage() . "\n";
+}
+
+// Test 3: Multiple operations on same coroutine
+$multi_coroutine = spawn(function() {
+    echo "multi coroutine started\n";
+    suspend();
+    suspend();
+    return "multi_result";
+});
+
+// Let it start
+suspend();
+
+// First await (should work)
+spawn(function() use ($multi_coroutine) {
+    try {
+        $result = await($multi_coroutine);
+        echo "concurrent await result: $result\n";
+    } catch (Throwable $e) {
+        echo "concurrent await failed: " . $e->getMessage() . "\n";
+    }
+});
+
+// Cancel while being awaited
+$multi_coroutine->cancel(new \Async\CancellationException("Cancelled while awaited"));
+
+// Try to await cancelled coroutine
+try {
+    $result3 = await($multi_coroutine);
+    echo "should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "main await cancelled: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+completed coroutine executing
+coroutine finished: true
+attempted to cancel completed coroutine
+await completed result: already_done
+exception coroutine executing
+exception coroutine finished: true
+attempted to cancel failed coroutine
+original exception preserved: Original error
+multi coroutine started
+concurrent await failed: Cancelled while awaited
+main await cancelled: Cancelled while awaited
+end
\ No newline at end of file

From 68fcbec2e653856d0dd4522ecf1d1d80514042d5 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 17:20:47 +0300
Subject: [PATCH 37/53] #9: + Additional tests for coroutines

---
 .../028-coroutine_state_transitions.phpt      | 115 ++++++++++++++++++
 ...coroutine_deferred_cancellation_basic.phpt |  60 +++++++++
 ...outine_deferred_cancellation_multiple.phpt |  63 ++++++++++
 ...ferred_cancellation_during_protection.phpt |  56 +++++++++
 .../032-coroutine_composite_exception.phpt    |  65 ++++++++++
 ...-coroutine_onFinally_invalid_callback.phpt |  63 ++++++++++
 ...34-coroutine_cancel_invalid_exception.phpt |  56 +++++++++
 .../035-coroutine_deep_recursion.phpt         |  42 +++++++
 .../gc/013-gc_coroutine_circular_finally.phpt |  45 +++++++
 9 files changed, 565 insertions(+)
 create mode 100644 tests/coroutine/028-coroutine_state_transitions.phpt
 create mode 100644 tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
 create mode 100644 tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
 create mode 100644 tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
 create mode 100644 tests/coroutine/032-coroutine_composite_exception.phpt
 create mode 100644 tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
 create mode 100644 tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
 create mode 100644 tests/coroutine/035-coroutine_deep_recursion.phpt
 create mode 100644 tests/gc/013-gc_coroutine_circular_finally.phpt

diff --git a/tests/coroutine/028-coroutine_state_transitions.phpt b/tests/coroutine/028-coroutine_state_transitions.phpt
new file mode 100644
index 0000000..4f03bf5
--- /dev/null
+++ b/tests/coroutine/028-coroutine_state_transitions.phpt
@@ -0,0 +1,115 @@
+--TEST--
+Coroutine state transitions and edge cases
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+// Test 1: isQueued() functionality
+$queued_coroutine = spawn(function() {
+    echo "queued coroutine executing\n";
+    suspend();
+    return "queued_result";
+});
+
+echo "before suspend - isQueued: " . ($queued_coroutine->isQueued() ? "true" : "false") . "\n";
+echo "before suspend - isStarted: " . ($queued_coroutine->isStarted() ? "true" : "false") . "\n";
+
+suspend(); // Let coroutine start
+
+echo "after start - isQueued: " . ($queued_coroutine->isQueued() ? "true" : "false") . "\n";
+echo "after start - isStarted: " . ($queued_coroutine->isStarted() ? "true" : "false") . "\n";
+echo "after start - isSuspended: " . ($queued_coroutine->isSuspended() ? "true" : "false") . "\n";
+
+// Test 2: getResult() on non-finished coroutine states
+$running_coroutine = spawn(function() {
+    echo "running coroutine started\n";
+    suspend();
+    echo "running coroutine continuing\n";
+    return "running_result";
+});
+
+suspend(); // Let it start and suspend
+
+echo "suspended state - isFinished: " . ($running_coroutine->isFinished() ? "true" : "false") . "\n";
+
+try {
+    $result = $running_coroutine->getResult();
+    echo "getResult on suspended should fail\n";
+} catch (\Error $e) {
+    echo "getResult on suspended failed: " . get_class($e) . "\n";
+} catch (Throwable $e) {
+    echo "getResult unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test 3: getException() on various states
+$exception_coroutine = spawn(function() {
+    echo "exception coroutine started\n";
+    suspend();
+    throw new \RuntimeException("Test exception");
+});
+
+suspend(); // Let it start and suspend
+
+echo "before exception - getException: ";
+try {
+    $exception = $exception_coroutine->getException();
+    echo ($exception ? get_class($exception) : "null") . "\n";
+} catch (\Error $e) {
+    echo "Error: " . get_class($e) . "\n";
+}
+
+suspend(); // Let it throw
+
+echo "after exception - getException: ";
+try {
+    $exception = $exception_coroutine->getException();
+    echo get_class($exception) . ": " . $exception->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "Unexpected: " . get_class($e) . "\n";
+}
+
+// Test 4: isCancellationRequested() functionality
+$cancel_request_coroutine = spawn(function() {
+    echo "cancel request coroutine started\n";
+    suspend();
+    echo "cancel request coroutine continuing\n";
+    return "cancel_result";
+});
+
+suspend(); // Let it start
+
+echo "before cancel request - isCancellationRequested: " . ($cancel_request_coroutine->isCancellationRequested() ? "true" : "false") . "\n";
+echo "before cancel request - isCancelled: " . ($cancel_request_coroutine->isCancelled() ? "true" : "false") . "\n";
+
+$cancel_request_coroutine->cancel(new \Async\CancellationException("Test cancellation"));
+
+echo "after cancel request - isCancellationRequested: " . ($cancel_request_coroutine->isCancellationRequested() ? "true" : "false") . "\n";
+echo "after cancel request - isCancelled: " . ($cancel_request_coroutine->isCancelled() ? "true" : "false") . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+before suspend - isQueued: true
+before suspend - isStarted: false
+queued coroutine executing
+after start - isQueued: false
+after start - isStarted: true
+after start - isSuspended: true
+running coroutine started
+suspended state - isFinished: false
+getResult on suspended failed: Error
+exception coroutine started
+before exception - getException: Error
+after exception - getException: RuntimeException: Test exception
+cancel request coroutine started
+before cancel request - isCancellationRequested: false
+before cancel request - isCancelled: false
+after cancel request - isCancellationRequested: true
+after cancel request - isCancelled: true
+end
\ No newline at end of file
diff --git a/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt b/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
new file mode 100644
index 0000000..af9ef50
--- /dev/null
+++ b/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Basic coroutine deferred cancellation with protected operation
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\protect;
+
+echo "start\n";
+
+$protected_coroutine = spawn(function() {
+    echo "protected coroutine started\n";
+    
+    $result = protect(function() {
+        echo "inside protected operation\n";
+        suspend();
+        echo "protected operation completed\n";
+        return "protected_result";
+    });
+    
+    echo "after protected operation: $result\n";
+    return $result;
+});
+
+// Let coroutine start and enter protected operation
+suspend();
+
+echo "cancelling protected coroutine\n";
+$protected_coroutine->cancel(new \Async\CancellationException("Deferred cancellation"));
+
+echo "protected coroutine cancelled: " . ($protected_coroutine->isCancelled() ? "true" : "false") . "\n";
+echo "cancellation requested: " . ($protected_coroutine->isCancellationRequested() ? "true" : "false") . "\n";
+
+// Let protected operation complete
+suspend();
+
+echo "after protected completion - cancelled: " . ($protected_coroutine->isCancelled() ? "true" : "false") . "\n";
+
+try {
+    $result = $protected_coroutine->getResult();
+    echo "protected result should not be available\n";
+} catch (\Async\CancellationException $e) {
+    echo "deferred cancellation executed: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+protected coroutine started
+inside protected operation
+cancelling protected coroutine
+protected coroutine cancelled: true
+cancellation requested: true
+protected operation completed
+after protected completion - cancelled: true
+deferred cancellation executed: Deferred cancellation
+end
\ No newline at end of file
diff --git a/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt b/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
new file mode 100644
index 0000000..8773a5f
--- /dev/null
+++ b/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Multiple deferred cancellations with sequential protect blocks
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\protect;
+
+echo "start\n";
+
+$multi_protected = spawn(function() {
+    echo "multi protected started\n";
+    
+    protect(function() {
+        echo "first protected operation\n";
+        suspend();
+        echo "first protected completed\n";
+    });
+    
+    echo "between protections\n";
+    
+    protect(function() {
+        echo "second protected operation\n";
+        suspend();
+        echo "second protected completed\n";
+    });
+    
+    echo "all protections completed\n";
+    return "multi_result";
+});
+
+suspend(); // Enter first protection
+
+$multi_protected->cancel(new \Async\CancellationException("Multi deferred"));
+echo "multi cancelled during first protection\n";
+
+suspend(); // Complete first protection
+suspend(); // Enter second protection  
+suspend(); // Complete second protection
+
+try {
+    $result = $multi_protected->getResult();
+    echo "multi result should not be available\n";
+} catch (\Async\CancellationException $e) {
+    echo "multi deferred cancellation: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+multi protected started
+first protected operation
+multi cancelled during first protection
+first protected completed
+between protections
+second protected operation
+second protected completed
+all protections completed
+multi deferred cancellation: Multi deferred
+end
\ No newline at end of file
diff --git a/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt b/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
new file mode 100644
index 0000000..0670045
--- /dev/null
+++ b/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Cancellation of coroutine during protected operation with exception handling
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\protect;
+
+echo "start\n";
+
+$already_protected = spawn(function() {
+    echo "already protected started\n";
+    
+    try {
+        protect(function() {
+            echo "protection started\n";
+            suspend();
+            suspend();
+            echo "protection completed\n";
+        });
+        echo "after protection block\n";
+    } catch (\Async\CancellationException $e) {
+        echo "caught cancellation in coroutine: " . $e->getMessage() . "\n";
+        throw $e;
+    }
+    
+    return "should_not_reach";
+});
+
+suspend(); // Enter protection
+
+// Cancel while protected
+$already_protected->cancel(new \Async\CancellationException("Cancel during protection"));
+
+suspend(); // Still in protection
+suspend(); // Protection completes, cancellation should execute
+
+try {
+    $result = $already_protected->getResult();
+    echo "should not get result\n";
+} catch (\Async\CancellationException $e) {
+    echo "protection cancellation: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+already protected started
+protection started
+protection completed
+caught cancellation in coroutine: Cancel during protection
+protection cancellation: Cancel during protection
+end
\ No newline at end of file
diff --git a/tests/coroutine/032-coroutine_composite_exception.phpt b/tests/coroutine/032-coroutine_composite_exception.phpt
new file mode 100644
index 0000000..77a0439
--- /dev/null
+++ b/tests/coroutine/032-coroutine_composite_exception.phpt
@@ -0,0 +1,65 @@
+--TEST--
+CompositeException with multiple finally handlers
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$composite_coroutine = spawn(function() {
+    echo "composite coroutine started\n";
+    
+    $coroutine = \Async\Coroutine::getCurrent();
+    
+    // Add multiple finally handlers that throw
+    $coroutine->onFinally(function() {
+        echo "finally 1 executing\n";
+        throw new \RuntimeException("Finally 1 error");
+    });
+    
+    $coroutine->onFinally(function() {
+        echo "finally 2 executing\n";
+        throw new \InvalidArgumentException("Finally 2 error");
+    });
+    
+    $coroutine->onFinally(function() {
+        echo "finally 3 executing\n";
+        throw new \LogicException("Finally 3 error");
+    });
+    
+    suspend();
+    throw new \RuntimeException("Main coroutine error");
+});
+
+suspend(); // Let it start and suspend
+suspend(); // Let it throw
+
+try {
+    $result = $composite_coroutine->getResult();
+    echo "should not get result\n";
+} catch (\Async\CompositeException $e) {
+    echo "caught CompositeException with " . count($e->getErrors()) . " errors\n";
+    foreach ($e->getErrors() as $index => $error) {
+        echo "error $index: " . get_class($error) . ": " . $error->getMessage() . "\n";
+    }
+} catch (Throwable $e) {
+    echo "unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+composite coroutine started
+finally 3 executing
+finally 2 executing
+finally 1 executing
+caught CompositeException with %d errors
+error %d: %s: %s
+error %d: %s: %s
+error %d: %s: %s
+error %d: %s: %s
+end
\ No newline at end of file
diff --git a/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt b/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
new file mode 100644
index 0000000..4849d9b
--- /dev/null
+++ b/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Coroutine onFinally with invalid callback parameters
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$invalid_finally_coroutine = spawn(function() {
+    echo "invalid finally coroutine started\n";
+    
+    $coroutine = \Async\Coroutine::getCurrent();
+    
+    // Test invalid callback types
+    try {
+        $coroutine->onFinally("not_a_callable");
+        echo "should not accept string as callback\n";
+    } catch (\TypeError $e) {
+        echo "caught TypeError for string: " . $e->getMessage() . "\n";
+    } catch (Throwable $e) {
+        echo "unexpected for string: " . get_class($e) . "\n";
+    }
+    
+    try {
+        $coroutine->onFinally(123);
+        echo "should not accept integer as callback\n";
+    } catch (\TypeError $e) {
+        echo "caught TypeError for integer: " . $e->getMessage() . "\n";
+    } catch (Throwable $e) {
+        echo "unexpected for integer: " . get_class($e) . "\n";
+    }
+    
+    try {
+        $coroutine->onFinally(null);
+        echo "should not accept null as callback\n";
+    } catch (\TypeError $e) {
+        echo "caught TypeError for null: " . $e->getMessage() . "\n";
+    } catch (Throwable $e) {
+        echo "unexpected for null: " . get_class($e) . "\n";
+    }
+    
+    suspend();
+    return "invalid_finally_result";
+});
+
+suspend();
+
+$result = $invalid_finally_coroutine->getResult();
+echo "invalid finally result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+invalid finally coroutine started
+caught TypeError for string: %s
+caught TypeError for integer: %s
+caught TypeError for null: %s
+invalid finally result: invalid_finally_result
+end
\ No newline at end of file
diff --git a/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt b/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
new file mode 100644
index 0000000..d2e2b8f
--- /dev/null
+++ b/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Coroutine cancel with invalid exception types
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$invalid_cancel_coroutine = spawn(function() {
+    echo "invalid cancel coroutine started\n";
+    suspend();
+    return "cancel_result";
+});
+
+suspend(); // Let it start
+
+try {
+    $invalid_cancel_coroutine->cancel("not an exception");
+    echo "should not accept string for cancel\n";
+} catch (\TypeError $e) {
+    echo "cancel string TypeError: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "cancel string unexpected: " . get_class($e) . "\n";
+}
+
+try {
+    $invalid_cancel_coroutine->cancel(new \RuntimeException("Wrong exception type"));
+    echo "accepted RuntimeException for cancel\n";
+} catch (\TypeError $e) {
+    echo "cancel RuntimeException TypeError: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "cancel RuntimeException unexpected: " . get_class($e) . "\n";
+}
+
+// Valid cancellation
+$invalid_cancel_coroutine->cancel(new \Async\CancellationException("Valid cancellation"));
+
+try {
+    $result = $invalid_cancel_coroutine->getResult();
+    echo "should not get cancelled result\n";
+} catch (\Async\CancellationException $e) {
+    echo "valid cancellation: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+invalid cancel coroutine started
+cancel string TypeError: %s
+%sRuntimeException%s
+valid cancellation: Valid cancellation
+end
\ No newline at end of file
diff --git a/tests/coroutine/035-coroutine_deep_recursion.phpt b/tests/coroutine/035-coroutine_deep_recursion.phpt
new file mode 100644
index 0000000..603dd3c
--- /dev/null
+++ b/tests/coroutine/035-coroutine_deep_recursion.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Coroutine with deep recursion and stack limits
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$deep_recursion_coroutine = spawn(function() {
+    echo "deep recursion coroutine started\n";
+    
+    function deepRecursionTest($depth, $maxDepth = 100) {
+        if ($depth >= $maxDepth) {
+            echo "reached max depth: $depth\n";
+            return $depth;
+        }
+        
+        if ($depth % 20 === 0) {
+            suspend(); // Suspend periodically
+        }
+        
+        return deepRecursionTest($depth + 1, $maxDepth);
+    }
+    
+    $result = deepRecursionTest(0);
+    return "recursion_result_$result";
+});
+
+$result = $deep_recursion_coroutine->getResult();
+echo "deep recursion result: $result\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+deep recursion coroutine started
+reached max depth: 100
+deep recursion result: recursion_result_100
+end
\ No newline at end of file
diff --git a/tests/gc/013-gc_coroutine_circular_finally.phpt b/tests/gc/013-gc_coroutine_circular_finally.phpt
new file mode 100644
index 0000000..fb52702
--- /dev/null
+++ b/tests/gc/013-gc_coroutine_circular_finally.phpt
@@ -0,0 +1,45 @@
+--TEST--
+GC 013: Circular references between coroutines and finally handlers
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$circular_finally_coroutine = spawn(function() {
+    echo "circular finally coroutine started\n";
+    
+    $coroutine = \Async\Coroutine::getCurrent();
+    $data = new \stdClass();
+    $data->coroutine = $coroutine;
+    
+    $coroutine->onFinally(function() use ($data) {
+        echo "circular finally executed\n";
+        $data->cleanup = "done";
+        // $data holds reference to coroutine, creating cycle
+    });
+    
+    suspend();
+    return "circular_result";
+});
+
+suspend();
+$result = $circular_finally_coroutine->getResult();
+echo "circular result: $result\n";
+
+// Force garbage collection
+gc_collect_cycles();
+echo "gc after circular references\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+circular finally coroutine started
+circular finally executed
+circular result: circular_result
+gc after circular references
+end
\ No newline at end of file

From 08a16a0924f29d549fe4f64ed0258d2c83564bc4 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 18:05:30 +0300
Subject: [PATCH 38/53] #9: Add comprehensive scope cancellation and hierarchy
 tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

      - hierarchy-cancellation-basic: Test parent scope cancellation propagating to child scopes
      - complex-tree-cancellation: Test multi-level scope hierarchies with partial cancellation
      - inheritance-cancellation-isolation: Test child scope cancellation isolation from parent
      - concurrent-cancellation: Test simultaneous cancellation of multiple scopes
      - mixed-cancellation-sources: Test scope cancellation + individual coroutine cancellation
      - cancellation-finally-handlers: Test finally handler execution during scope cancellation

      These tests cover critical gaps in scope cancellation coverage, specifically:
      - Hierarchical cancellation propagation (parent → children)
      - Cancellation isolation (children don't affect parents)
      - Complex scope tree scenarios with mixed cancellation states
      - Protected blocks interaction with scope cancellation
      - Finally handler execution order during cancellation
---
 ...28-scope_hierarchy_cancellation_basic.phpt | 111 +++++++++++++
 .../029-scope_complex_tree_cancellation.phpt  | 129 +++++++++++++++
 ...pe_inheritance_cancellation_isolation.phpt | 139 ++++++++++++++++
 .../031-scope_concurrent_cancellation.phpt    | 153 +++++++++++++++++
 .../032-scope_mixed_cancellation_sources.phpt | 153 +++++++++++++++++
 ...3-scope_cancellation_finally_handlers.phpt | 156 ++++++++++++++++++
 6 files changed, 841 insertions(+)
 create mode 100644 tests/scope/028-scope_hierarchy_cancellation_basic.phpt
 create mode 100644 tests/scope/029-scope_complex_tree_cancellation.phpt
 create mode 100644 tests/scope/030-scope_inheritance_cancellation_isolation.phpt
 create mode 100644 tests/scope/031-scope_concurrent_cancellation.phpt
 create mode 100644 tests/scope/032-scope_mixed_cancellation_sources.phpt
 create mode 100644 tests/scope/033-scope_cancellation_finally_handlers.phpt

diff --git a/tests/scope/028-scope_hierarchy_cancellation_basic.phpt b/tests/scope/028-scope_hierarchy_cancellation_basic.phpt
new file mode 100644
index 0000000..c4e0b15
--- /dev/null
+++ b/tests/scope/028-scope_hierarchy_cancellation_basic.phpt
@@ -0,0 +1,111 @@
+--TEST--
+Basic scope hierarchy cancellation propagation
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+// Create parent scope
+$parent_scope = new \Async\Scope();
+
+// Create child scopes
+$child1_scope = \Async\Scope::inherit($parent_scope);
+$child2_scope = \Async\Scope::inherit($parent_scope);
+
+echo "scopes created\n";
+
+// Spawn coroutines in each scope
+$parent_coroutine = $parent_scope->spawn(function() {
+    echo "parent coroutine started\n";
+    suspend();
+    echo "parent coroutine should not complete\n";
+    return "parent_result";
+});
+
+$child1_coroutine = $child1_scope->spawn(function() {
+    echo "child1 coroutine started\n";
+    suspend();
+    echo "child1 coroutine should not complete\n";
+    return "child1_result";
+});
+
+$child2_coroutine = $child2_scope->spawn(function() {
+    echo "child2 coroutine started\n";
+    suspend();
+    echo "child2 coroutine should not complete\n";
+    return "child2_result";
+});
+
+echo "coroutines spawned\n";
+
+// Let coroutines start
+suspend();
+
+// Check initial states
+echo "parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "false") . "\n";
+
+// Cancel parent scope - should cascade to children
+echo "cancelling parent scope\n";
+$parent_scope->cancel(new \Async\CancellationException("Parent cancelled"));
+
+// Check states after parent cancellation
+echo "after parent cancel - parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
+echo "after parent cancel - child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
+echo "after parent cancel - child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "false") . "\n";
+
+// Check coroutine states
+echo "parent coroutine cancelled: " . ($parent_coroutine->isCancelled() ? "true" : "false") . "\n";
+echo "child1 coroutine cancelled: " . ($child1_coroutine->isCancelled() ? "true" : "false") . "\n";
+echo "child2 coroutine cancelled: " . ($child2_coroutine->isCancelled() ? "true" : "false") . "\n";
+
+// Try to get results (should all throw CancellationException)
+try {
+    $result = $parent_coroutine->getResult();
+    echo "parent should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "parent cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child1_coroutine->getResult();
+    echo "child1 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "child1 cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child2_coroutine->getResult();
+    echo "child2 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "child2 cancelled: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+scopes created
+coroutines spawned
+parent coroutine started
+child1 coroutine started
+child2 coroutine started
+parent scope cancelled: false
+child1 scope cancelled: false
+child2 scope cancelled: false
+cancelling parent scope
+after parent cancel - parent scope cancelled: true
+after parent cancel - child1 scope cancelled: true
+after parent cancel - child2 scope cancelled: true
+parent coroutine cancelled: true
+child1 coroutine cancelled: true
+child2 coroutine cancelled: true
+parent cancelled: Parent cancelled
+child1 cancelled: Parent cancelled
+child2 cancelled: Parent cancelled
+end
\ No newline at end of file
diff --git a/tests/scope/029-scope_complex_tree_cancellation.phpt b/tests/scope/029-scope_complex_tree_cancellation.phpt
new file mode 100644
index 0000000..e6a10dc
--- /dev/null
+++ b/tests/scope/029-scope_complex_tree_cancellation.phpt
@@ -0,0 +1,129 @@
+--TEST--
+Complex scope tree cancellation with multi-level hierarchy
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+// Create complex scope tree: parent -> child -> grandchild -> great-grandchild
+$parent_scope = new \Async\Scope();
+$child_scope = \Async\Scope::inherit($parent_scope);
+$grandchild_scope = \Async\Scope::inherit($child_scope);
+$great_grandchild_scope = \Async\Scope::inherit($grandchild_scope);
+
+// Create sibling branch: parent -> sibling -> sibling_child
+$sibling_scope = \Async\Scope::inherit($parent_scope);
+$sibling_child_scope = \Async\Scope::inherit($sibling_scope);
+
+echo "complex scope tree created\n";
+
+// Spawn coroutines in each scope
+$scopes_and_coroutines = [
+    'parent' => [$parent_scope, null],
+    'child' => [$child_scope, null],
+    'grandchild' => [$grandchild_scope, null],
+    'great_grandchild' => [$great_grandchild_scope, null],
+    'sibling' => [$sibling_scope, null],
+    'sibling_child' => [$sibling_child_scope, null]
+];
+
+foreach ($scopes_and_coroutines as $name => &$data) {
+    $scope = $data[0];
+    $data[1] = $scope->spawn(function() use ($name) {
+        echo "$name coroutine started\n";
+        suspend();
+        echo "$name coroutine should not complete\n";
+        return "{$name}_result";
+    });
+}
+
+echo "all coroutines spawned\n";
+
+// Let all coroutines start
+suspend();
+
+// Verify initial states (all should be false)
+foreach ($scopes_and_coroutines as $name => $data) {
+    $scope = $data[0];
+    echo "$name scope initially cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
+}
+
+// Cancel middle node (child_scope) - should cancel its descendants but not ancestors
+echo "cancelling child scope (middle node)\n";
+$child_scope->cancel(new \Async\CancellationException("Child cancelled"));
+
+// Check cancellation propagation
+echo "after child cancellation:\n";
+foreach ($scopes_and_coroutines as $name => $data) {
+    $scope = $data[0];
+    echo "$name scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
+}
+
+// Now cancel parent - should cancel everything remaining
+echo "cancelling parent scope (root)\n";
+$parent_scope->cancel(new \Async\CancellationException("Parent cancelled"));
+
+echo "after parent cancellation:\n";
+foreach ($scopes_and_coroutines as $name => $data) {
+    $scope = $data[0];
+    echo "$name scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
+}
+
+// Verify all coroutines are cancelled
+echo "coroutine cancellation results:\n";
+foreach ($scopes_and_coroutines as $name => $data) {
+    $coroutine = $data[1];
+    try {
+        $result = $coroutine->getResult();
+        echo "$name coroutine unexpectedly succeeded\n";
+    } catch (\Async\CancellationException $e) {
+        echo "$name coroutine cancelled: " . $e->getMessage() . "\n";
+    }
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+complex scope tree created
+all coroutines spawned
+parent coroutine started
+child coroutine started
+grandchild coroutine started
+great_grandchild coroutine started
+sibling coroutine started
+sibling_child coroutine started
+parent scope initially cancelled: false
+child scope initially cancelled: false
+grandchild scope initially cancelled: false
+great_grandchild scope initially cancelled: false
+sibling scope initially cancelled: false
+sibling_child scope initially cancelled: false
+cancelling child scope (middle node)
+after child cancellation:
+parent scope cancelled: false
+child scope cancelled: true
+grandchild scope cancelled: true
+great_grandchild scope cancelled: true
+sibling scope cancelled: false
+sibling_child scope cancelled: false
+cancelling parent scope (root)
+after parent cancellation:
+parent scope cancelled: true
+child scope cancelled: true
+grandchild scope cancelled: true
+great_grandchild scope cancelled: true
+sibling scope cancelled: true
+sibling_child scope cancelled: true
+coroutine cancellation results:
+parent coroutine cancelled: Parent cancelled
+child coroutine cancelled: Child cancelled
+grandchild coroutine cancelled: Child cancelled
+great_grandchild coroutine cancelled: Child cancelled
+sibling coroutine cancelled: Parent cancelled
+sibling_child coroutine cancelled: Parent cancelled
+end
\ No newline at end of file
diff --git a/tests/scope/030-scope_inheritance_cancellation_isolation.phpt b/tests/scope/030-scope_inheritance_cancellation_isolation.phpt
new file mode 100644
index 0000000..5ef979f
--- /dev/null
+++ b/tests/scope/030-scope_inheritance_cancellation_isolation.phpt
@@ -0,0 +1,139 @@
+--TEST--
+Scope inheritance cancellation isolation (child cancellation should not affect parent)
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+// Create parent scope
+$parent_scope = new \Async\Scope();
+
+// Create multiple child scopes
+$child1_scope = \Async\Scope::inherit($parent_scope);
+$child2_scope = \Async\Scope::inherit($parent_scope);
+$child3_scope = \Async\Scope::inherit($parent_scope);
+
+echo "parent and child scopes created\n";
+
+// Spawn coroutines in all scopes
+$parent_coroutine = $parent_scope->spawn(function() {
+    echo "parent coroutine started\n";
+    suspend();
+    suspend();
+    echo "parent coroutine completed\n";
+    return "parent_result";
+});
+
+$child1_coroutine = $child1_scope->spawn(function() {
+    echo "child1 coroutine started\n";
+    suspend();
+    echo "child1 should not complete\n";
+    return "child1_result";
+});
+
+$child2_coroutine = $child2_scope->spawn(function() {
+    echo "child2 coroutine started\n";
+    suspend();
+    suspend();
+    echo "child2 coroutine completed\n";
+    return "child2_result";
+});
+
+$child3_coroutine = $child3_scope->spawn(function() {
+    echo "child3 coroutine started\n";
+    suspend();
+    echo "child3 should not complete\n";
+    return "child3_result";
+});
+
+echo "all coroutines spawned\n";
+
+// Let coroutines start
+suspend();
+
+// Cancel only child1 - should not affect parent or other children
+echo "cancelling child1 scope only\n";
+$child1_scope->cancel(new \Async\CancellationException("Child1 cancelled"));
+
+// Check isolation - only child1 should be cancelled
+echo "after child1 cancellation:\n";
+echo "parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child3 scope cancelled: " . ($child3_scope->isCancelled() ? "true" : "false") . "\n";
+
+// Continue execution for non-cancelled scopes
+suspend();
+
+// Cancel child3 as well
+echo "cancelling child3 scope\n";
+$child3_scope->cancel(new \Async\CancellationException("Child3 cancelled"));
+
+echo "after child3 cancellation:\n";
+echo "parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "false") . "\n";
+echo "child3 scope cancelled: " . ($child3_scope->isCancelled() ? "true" : "false") . "\n";
+
+// Get results - parent and child2 should succeed, child1 and child3 should fail
+try {
+    $result = $parent_coroutine->getResult();
+    echo "parent result: $result\n";
+} catch (\Async\CancellationException $e) {
+    echo "parent unexpectedly cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child1_coroutine->getResult();
+    echo "child1 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "child1 cancelled as expected: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child2_coroutine->getResult();
+    echo "child2 result: $result\n";
+} catch (\Async\CancellationException $e) {
+    echo "child2 unexpectedly cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child3_coroutine->getResult();
+    echo "child3 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "child3 cancelled as expected: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+parent and child scopes created
+all coroutines spawned
+parent coroutine started
+child1 coroutine started
+child2 coroutine started
+child3 coroutine started
+cancelling child1 scope only
+after child1 cancellation:
+parent scope cancelled: false
+child1 scope cancelled: true
+child2 scope cancelled: false
+child3 scope cancelled: false
+child2 coroutine completed
+parent coroutine completed
+cancelling child3 scope
+after child3 cancellation:
+parent scope cancelled: false
+child1 scope cancelled: true
+child2 scope cancelled: false
+child3 scope cancelled: true
+parent result: parent_result
+child1 cancelled as expected: Child1 cancelled
+child2 result: child2_result
+child3 cancelled as expected: Child3 cancelled
+end
\ No newline at end of file
diff --git a/tests/scope/031-scope_concurrent_cancellation.phpt b/tests/scope/031-scope_concurrent_cancellation.phpt
new file mode 100644
index 0000000..99d58d5
--- /dev/null
+++ b/tests/scope/031-scope_concurrent_cancellation.phpt
@@ -0,0 +1,153 @@
+--TEST--
+Concurrent scope cancellation and race conditions
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+// Create multiple scopes
+$scope1 = new \Async\Scope();
+$scope2 = new \Async\Scope();
+$scope3 = new \Async\Scope();
+
+echo "multiple scopes created\n";
+
+// Spawn coroutines in each scope
+$coroutine1 = $scope1->spawn(function() {
+    echo "coroutine1 started\n";
+    suspend();
+    echo "coroutine1 should not complete\n";
+    return "result1";
+});
+
+$coroutine2 = $scope2->spawn(function() {
+    echo "coroutine2 started\n";
+    suspend();
+    echo "coroutine2 should not complete\n";
+    return "result2";
+});
+
+$coroutine3 = $scope3->spawn(function() {
+    echo "coroutine3 started\n";
+    suspend();
+    echo "coroutine3 should not complete\n";
+    return "result3";
+});
+
+echo "coroutines spawned\n";
+
+// Let coroutines start
+suspend();
+
+// Spawn concurrent cancellation operations
+$canceller1 = spawn(function() use ($scope1) {
+    echo "canceller1 starting\n";
+    suspend(); // Small delay
+    echo "canceller1 cancelling scope1\n";
+    $scope1->cancel(new \Async\CancellationException("Concurrent cancel 1"));
+    echo "canceller1 finished\n";
+});
+
+$canceller2 = spawn(function() use ($scope2) {
+    echo "canceller2 starting\n";
+    suspend(); // Small delay
+    echo "canceller2 cancelling scope2\n";
+    $scope2->cancel(new \Async\CancellationException("Concurrent cancel 2"));
+    echo "canceller2 finished\n";
+});
+
+$canceller3 = spawn(function() use ($scope3) {
+    echo "canceller3 starting\n";
+    suspend(); // Small delay
+    echo "canceller3 cancelling scope3\n";
+    $scope3->cancel(new \Async\CancellationException("Concurrent cancel 3"));
+    echo "canceller3 finished\n";
+});
+
+echo "cancellers spawned\n";
+
+// Let cancellers start and complete
+suspend();
+suspend();
+
+// Check that all cancellers completed
+$canceller1->getResult();
+$canceller2->getResult();
+$canceller3->getResult();
+
+echo "all cancellers completed\n";
+
+// Verify all scopes are cancelled
+echo "scope1 cancelled: " . ($scope1->isCancelled() ? "true" : "false") . "\n";
+echo "scope2 cancelled: " . ($scope2->isCancelled() ? "true" : "false") . "\n";
+echo "scope3 cancelled: " . ($scope3->isCancelled() ? "true" : "false") . "\n";
+
+// Verify all coroutines are cancelled
+$cancelled_count = 0;
+foreach ([$coroutine1, $coroutine2, $coroutine3] as $index => $coroutine) {
+    try {
+        $result = $coroutine->getResult();
+        echo "coroutine" . ($index + 1) . " unexpectedly succeeded\n";
+    } catch (\Async\CancellationException $e) {
+        echo "coroutine" . ($index + 1) . " cancelled: " . $e->getMessage() . "\n";
+        $cancelled_count++;
+    }
+}
+
+echo "cancelled coroutines: $cancelled_count\n";
+
+// Test rapid cancellation/creation cycle
+echo "testing rapid scope operations\n";
+$rapid_scopes = [];
+for ($i = 0; $i < 5; $i++) {
+    $rapid_scopes[] = new \Async\Scope();
+}
+
+// Cancel them all quickly
+foreach ($rapid_scopes as $index => $scope) {
+    $scope->cancel(new \Async\CancellationException("Rapid cancel $index"));
+}
+
+$rapid_cancelled = 0;
+foreach ($rapid_scopes as $scope) {
+    if ($scope->isCancelled()) {
+        $rapid_cancelled++;
+    }
+}
+
+echo "rapid cancelled scopes: $rapid_cancelled / " . count($rapid_scopes) . "\n";
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+multiple scopes created
+coroutines spawned
+coroutine1 started
+coroutine2 started
+coroutine3 started
+cancellers spawned
+canceller1 starting
+canceller2 starting
+canceller3 starting
+canceller1 cancelling scope1
+canceller2 cancelling scope2
+canceller3 cancelling scope3
+canceller1 finished
+canceller2 finished
+canceller3 finished
+all cancellers completed
+scope1 cancelled: true
+scope2 cancelled: true
+scope3 cancelled: true
+coroutine1 cancelled: Concurrent cancel 1
+coroutine2 cancelled: Concurrent cancel 2
+coroutine3 cancelled: Concurrent cancel 3
+cancelled coroutines: 3
+testing rapid scope operations
+rapid cancelled scopes: 5 / 5
+end
\ No newline at end of file
diff --git a/tests/scope/032-scope_mixed_cancellation_sources.phpt b/tests/scope/032-scope_mixed_cancellation_sources.phpt
new file mode 100644
index 0000000..4f7b969
--- /dev/null
+++ b/tests/scope/032-scope_mixed_cancellation_sources.phpt
@@ -0,0 +1,153 @@
+--TEST--
+Mixed cancellation sources: scope cancellation + individual coroutine cancellation
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$scope = new \Async\Scope();
+
+// Spawn multiple coroutines in the same scope
+$coroutine1 = $scope->spawn(function() {
+    echo "coroutine1 started\n";
+    suspend();
+    echo "coroutine1 should not complete\n";
+    return "result1";
+});
+
+$coroutine2 = $scope->spawn(function() {
+    echo "coroutine2 started\n";
+    suspend();
+    echo "coroutine2 should not complete\n";
+    return "result2";
+});
+
+$coroutine3 = $scope->spawn(function() {
+    echo "coroutine3 started\n";
+    suspend();
+    echo "coroutine3 should not complete\n";
+    return "result3";
+});
+
+echo "coroutines spawned in scope\n";
+
+// Let coroutines start
+suspend();
+
+// Cancel individual coroutine first
+echo "cancelling coroutine2 individually\n";
+$coroutine2->cancel(new \Async\CancellationException("Individual cancel"));
+
+// Check states after individual cancellation
+echo "after individual cancel:\n";
+echo "scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine1 cancelled: " . ($coroutine1->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine2 cancelled: " . ($coroutine2->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine3 cancelled: " . ($coroutine3->isCancelled() ? "true" : "false") . "\n";
+
+// Now cancel the entire scope
+echo "cancelling entire scope\n";
+$scope->cancel(new \Async\CancellationException("Scope cancel"));
+
+// Check states after scope cancellation
+echo "after scope cancel:\n";
+echo "scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine1 cancelled: " . ($coroutine1->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine2 cancelled: " . ($coroutine2->isCancelled() ? "true" : "false") . "\n";
+echo "coroutine3 cancelled: " . ($coroutine3->isCancelled() ? "true" : "false") . "\n";
+
+// Check results and exception messages
+try {
+    $result = $coroutine1->getResult();
+    echo "coroutine1 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "coroutine1 cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $coroutine2->getResult();
+    echo "coroutine2 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "coroutine2 cancelled: " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $coroutine3->getResult();
+    echo "coroutine3 should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "coroutine3 cancelled: " . $e->getMessage() . "\n";
+}
+
+// Test protected blocks with mixed cancellation
+echo "testing protected blocks with mixed cancellation\n";
+
+$protected_scope = new \Async\Scope();
+$protected_coroutine = $protected_scope->spawn(function() {
+    echo "protected coroutine started\n";
+    
+    \Async\protect(function() {
+        echo "inside protected block\n";
+        suspend();
+        echo "protected block completed\n";
+    });
+    
+    echo "after protected block\n";
+    return "protected_result";
+});
+
+suspend(); // Enter protected block
+
+// Try individual cancellation during protection
+echo "cancelling protected coroutine individually\n";
+$protected_coroutine->cancel(new \Async\CancellationException("Protected individual cancel"));
+
+// Try scope cancellation during protection
+echo "cancelling protected scope\n";
+$protected_scope->cancel(new \Async\CancellationException("Protected scope cancel"));
+
+suspend(); // Complete protected block
+
+// Check which cancellation takes effect
+try {
+    $result = $protected_coroutine->getResult();
+    echo "protected coroutine should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "protected coroutine cancelled: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutines spawned in scope
+coroutine1 started
+coroutine2 started
+coroutine3 started
+cancelling coroutine2 individually
+after individual cancel:
+scope cancelled: false
+coroutine1 cancelled: false
+coroutine2 cancelled: true
+coroutine3 cancelled: false
+cancelling entire scope
+after scope cancel:
+scope cancelled: true
+coroutine1 cancelled: true
+coroutine2 cancelled: true
+coroutine3 cancelled: true
+coroutine1 cancelled: Scope cancel
+coroutine2 cancelled: Individual cancel
+coroutine3 cancelled: Scope cancel
+testing protected blocks with mixed cancellation
+protected coroutine started
+inside protected block
+cancelling protected coroutine individually
+cancelling protected scope
+protected block completed
+after protected block
+protected coroutine cancelled: %s
+end
\ No newline at end of file
diff --git a/tests/scope/033-scope_cancellation_finally_handlers.phpt b/tests/scope/033-scope_cancellation_finally_handlers.phpt
new file mode 100644
index 0000000..eaad162
--- /dev/null
+++ b/tests/scope/033-scope_cancellation_finally_handlers.phpt
@@ -0,0 +1,156 @@
+--TEST--
+Scope cancellation with finally handlers execution
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "start\n";
+
+$scope = new \Async\Scope();
+
+// Spawn coroutine with finally handlers
+$coroutine_with_finally = $scope->spawn(function() {
+    echo "coroutine with finally started\n";
+    
+    $coroutine = \Async\Coroutine::getCurrent();
+    
+    $coroutine->onFinally(function() {
+        echo "finally handler 1 executed\n";
+    });
+    
+    $coroutine->onFinally(function() {
+        echo "finally handler 2 executed\n";
+        return "finally_cleanup";
+    });
+    
+    $coroutine->onFinally(function() {
+        echo "finally handler 3 executed\n";
+        // This might throw during cancellation cleanup
+        throw new \RuntimeException("Finally handler error");
+    });
+    
+    suspend();
+    echo "coroutine should not complete normally\n";
+    return "normal_result";
+});
+
+// Spawn coroutine in child scope with finally handlers
+$child_scope = \Async\Scope::inherit($scope);
+$child_coroutine = $child_scope->spawn(function() {
+    echo "child coroutine started\n";
+    
+    $coroutine = \Async\Coroutine::getCurrent();
+    
+    $coroutine->onFinally(function() {
+        echo "child finally handler executed\n";
+    });
+    
+    suspend();
+    echo "child should not complete\n";
+    return "child_result";
+});
+
+echo "coroutines with finally handlers spawned\n";
+
+// Let coroutines start
+suspend();
+
+// Add scope-level finally handler
+$scope->onFinally(function() {
+    echo "scope finally handler executed\n";
+});
+
+echo "scope finally handler added\n";
+
+// Cancel the parent scope - should trigger all finally handlers
+echo "cancelling parent scope\n";
+$scope->cancel(new \Async\CancellationException("Scope cancelled with finally"));
+
+// Check execution order and exception handling
+try {
+    $result = $coroutine_with_finally->getResult();
+    echo "main coroutine should not succeed\n";
+} catch (\Async\CompositeException $e) {
+    echo "main coroutine CompositeException with " . count($e->getErrors()) . " errors\n";
+    foreach ($e->getErrors() as $error) {
+        echo "composite error: " . get_class($error) . ": " . $error->getMessage() . "\n";
+    }
+} catch (\Async\CancellationException $e) {
+    echo "main coroutine cancelled: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "main coroutine unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+try {
+    $result = $child_coroutine->getResult();
+    echo "child coroutine should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "child coroutine cancelled: " . $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo "child coroutine unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
+
+// Test finally handler order in cancelled scope hierarchy
+echo "testing finally handler order in hierarchy\n";
+
+$parent_scope = new \Async\Scope();
+$child_scope2 = \Async\Scope::inherit($parent_scope);
+
+$parent_scope->onFinally(function() {
+    echo "parent scope finally\n";
+});
+
+$child_scope2->onFinally(function() {
+    echo "child scope finally\n";
+});
+
+$hierarchy_coroutine = $child_scope2->spawn(function() {
+    echo "hierarchy coroutine started\n";
+    
+    \Async\Coroutine::getCurrent()->onFinally(function() {
+        echo "hierarchy coroutine finally\n";
+    });
+    
+    suspend();
+    return "hierarchy_result";
+});
+
+suspend(); // Let it start
+
+echo "cancelling parent scope in hierarchy\n";
+$parent_scope->cancel(new \Async\CancellationException("Hierarchy cancel"));
+
+try {
+    $result = $hierarchy_coroutine->getResult();
+    echo "hierarchy should not succeed\n";
+} catch (\Async\CancellationException $e) {
+    echo "hierarchy cancelled: " . $e->getMessage() . "\n";
+}
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutines with finally handlers spawned
+coroutine with finally started
+child coroutine started
+scope finally handler added
+cancelling parent scope
+finally handler 3 executed
+finally handler 2 executed
+finally handler 1 executed
+child finally handler executed
+scope finally handler executed
+main coroutine %s: %s
+child coroutine cancelled: Scope cancelled with finally
+testing finally handler order in hierarchy
+hierarchy coroutine started
+cancelling parent scope in hierarchy
+hierarchy coroutine finally
+child scope finally
+parent scope finally
+hierarchy cancelled: Hierarchy cancel
+end
\ No newline at end of file

From c960643fb024b818fabc230bc764a70bcea54e2e Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 18:40:20 +0300
Subject: [PATCH 39/53] #9: + 002-context_inheritance.phpt

---
 tests/context/002-context_inheritance.phpt | 110 +++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 tests/context/002-context_inheritance.phpt

diff --git a/tests/context/002-context_inheritance.phpt b/tests/context/002-context_inheritance.phpt
new file mode 100644
index 0000000..0ab395c
--- /dev/null
+++ b/tests/context/002-context_inheritance.phpt
@@ -0,0 +1,110 @@
+--TEST--
+Context inheritance through scope hierarchy
+--FILE--
+<?php
+
+use function Async\spawn;
+
+echo "start\n";
+
+// Create parent scope
+$parent_scope = new \Async\Scope();
+
+// Spawn coroutine in parent scope to set context values
+$parent_coroutine = $parent_scope->spawn(function() {
+    echo "parent coroutine started\n";
+    
+    $context = \Async\Coroutine::getCurrent()->getContext();
+    
+    // Set values in parent context
+    $context['parent_key'] = 'parent_value';
+    $context['shared_key'] = 'from_parent';
+    
+    echo "parent context values set\n";
+    return "parent_done";
+});
+
+$parent_coroutine->getResult();
+
+// Create child scope that inherits from parent
+$child_scope = \Async\Scope::inherit($parent_scope);
+
+// Test inheritance in child scope
+$child_coroutine = $child_scope->spawn(function() {
+    echo "child coroutine started\n";
+    
+    $context = \Async\Coroutine::getCurrent()->getContext();
+    
+    // Test find() - should find parent values
+    echo "find parent_key: " . ($context->find('parent_key') ?: 'null') . "\n";
+    echo "find shared_key: " . ($context->find('shared_key') ?: 'null') . "\n";
+    
+    // Test get() - should find parent values  
+    echo "get parent_key: " . ($context->get('parent_key') ?: 'null') . "\n";
+    echo "get shared_key: " . ($context->get('shared_key') ?: 'null') . "\n";
+    
+    // Test has() - should find parent values
+    echo "has parent_key: " . ($context->has('parent_key') ? 'true' : 'false') . "\n";
+    echo "has shared_key: " . ($context->has('shared_key') ? 'true' : 'false') . "\n";
+    
+    // Test findLocal() - should NOT find parent values
+    echo "findLocal parent_key: " . ($context->findLocal('parent_key') ?: 'null') . "\n";
+    echo "findLocal shared_key: " . ($context->findLocal('shared_key') ?: 'null') . "\n";
+    
+    // Test getLocal() - should NOT find parent values
+    echo "getLocal parent_key: " . ($context->getLocal('parent_key') ?: 'null') . "\n";
+    echo "getLocal shared_key: " . ($context->getLocal('shared_key') ?: 'null') . "\n";
+    
+    // Test hasLocal() - should NOT find parent values
+    echo "hasLocal parent_key: " . ($context->hasLocal('parent_key') ? 'true' : 'false') . "\n";
+    echo "hasLocal shared_key: " . ($context->hasLocal('shared_key') ? 'true' : 'false') . "\n";
+    
+    // Set local value that overrides parent
+    $context['shared_key'] = 'from_child';
+    $context['child_key'] = 'child_value';
+    
+    echo "child context values set\n";
+    
+    // Test override behavior
+    echo "after override - find shared_key: " . ($context->find('shared_key') ?: 'null') . "\n";
+    echo "after override - get shared_key: " . ($context->get('shared_key') ?: 'null') . "\n";
+    echo "after override - findLocal shared_key: " . ($context->findLocal('shared_key') ?: 'null') . "\n";
+    echo "after override - getLocal shared_key: " . ($context->getLocal('shared_key') ?: 'null') . "\n";
+    
+    // Test local-only value
+    echo "findLocal child_key: " . ($context->findLocal('child_key') ?: 'null') . "\n";
+    echo "getLocal child_key: " . ($context->getLocal('child_key') ?: 'null') . "\n";
+    
+    return "child_done";
+});
+
+$child_coroutine->getResult();
+
+echo "end\n";
+
+?>
+--EXPECT--
+start
+parent coroutine started
+parent context values set
+child coroutine started
+find parent_key: parent_value
+find shared_key: from_parent
+get parent_key: parent_value
+get shared_key: from_parent
+has parent_key: true
+has shared_key: true
+findLocal parent_key: null
+findLocal shared_key: null
+getLocal parent_key: null
+getLocal shared_key: null
+hasLocal parent_key: false
+hasLocal shared_key: false
+child context values set
+after override - find shared_key: from_child
+after override - get shared_key: from_child
+after override - findLocal shared_key: from_child
+after override - getLocal shared_key: from_child
+findLocal child_key: child_value
+getLocal child_key: child_value
+end
\ No newline at end of file

From a99cfaac2d0b84aa5631cce8bafea42c6b4d54fb Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 19:04:24 +0300
Subject: [PATCH 40/53] #9: + fix await tests

---
 .../await/067-await_completed_coroutine.phpt  |  8 ++-
 tests/await/068-await_multiple_times.phpt     |  1 -
 .../069-await_manual_vs_timeout_cancel.phpt   | 11 ++--
 tests/await/070-await_state_transitions.phpt  | 53 +++++--------------
 4 files changed, 26 insertions(+), 47 deletions(-)

diff --git a/tests/await/067-await_completed_coroutine.phpt b/tests/await/067-await_completed_coroutine.phpt
index 1dbe365..b68d0b2 100644
--- a/tests/await/067-await_completed_coroutine.phpt
+++ b/tests/await/067-await_completed_coroutine.phpt
@@ -30,7 +30,12 @@ $coroutine2 = spawn(function() {
 });
 
 // Wait for completion
-suspend();
+try {
+    await($coroutine2); // This will suspend until the coroutine is done
+} catch (Throwable $e) {
+    // Catch any exceptions during suspend
+    echo "suspend error: " . $e->getMessage() . "\n";
+}
 
 echo "coroutine2 finished: " . ($coroutine2->isFinished() ? "true" : "false") . "\n";
 
@@ -64,6 +69,7 @@ coroutine1 executing
 coroutine1 finished: true
 await result: success_result
 coroutine2 executing
+suspend error: Coroutine error
 coroutine2 finished: true
 caught exception: Coroutine error
 coroutine3 executing
diff --git a/tests/await/068-await_multiple_times.phpt b/tests/await/068-await_multiple_times.phpt
index 89de6d0..c8445d2 100644
--- a/tests/await/068-await_multiple_times.phpt
+++ b/tests/await/068-await_multiple_times.phpt
@@ -93,7 +93,6 @@ coroutine2 executing
 first caught: Shared error
 second await on exception coroutine
 second caught: Shared error
-coroutine3 executing
 first await on cancelled coroutine
 first caught cancellation: Shared cancellation
 second await on cancelled coroutine
diff --git a/tests/await/069-await_manual_vs_timeout_cancel.phpt b/tests/await/069-await_manual_vs_timeout_cancel.phpt
index 09d56cd..d5b2177 100644
--- a/tests/await/069-await_manual_vs_timeout_cancel.phpt
+++ b/tests/await/069-await_manual_vs_timeout_cancel.phpt
@@ -7,6 +7,7 @@ use function Async\spawn;
 use function Async\await;
 use function Async\suspend;
 use function Async\timeout;
+use function Async\delay;
 
 echo "start\n";
 
@@ -36,8 +37,7 @@ try {
 // Test 2: Timeout cancellation
 $timeout_coroutine = spawn(function() {
     echo "timeout coroutine started\n";
-    suspend();
-    suspend(); // Will be cancelled by timeout
+    delay(50); // Will be cancelled by timeout
     echo "timeout coroutine should not complete\n";
     return "timeout_result";
 });
@@ -45,10 +45,11 @@ $timeout_coroutine = spawn(function() {
 echo "timeout coroutine spawned\n";
 
 try {
-    $result = await($timeout_coroutine, timeout(50)); // 50ms timeout
+    $result = await($timeout_coroutine, timeout(1));
     echo "timeout await should not succeed\n";
 } catch (\Async\TimeoutException $e) {
     echo "timeout cancellation caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
+    $timeout_coroutine->cancel(new \Async\CancellationException("Timeout after 1 milliseconds"));
 } catch (\Async\CancellationException $e) {
     echo "timeout as cancellation: " . get_class($e) . ": " . $e->getMessage() . "\n";
 } catch (Throwable $e) {
@@ -70,7 +71,7 @@ suspend();
 $race_coroutine->cancel(new \Async\CancellationException("Manual wins"));
 
 try {
-    $result = await($race_coroutine, timeout(100)); // Should get manual cancel, not timeout
+    $result = await($race_coroutine, timeout(1)); // Should get manual cancel, not timeout
     echo "race await should not succeed\n";
 } catch (\Async\CancellationException $e) {
     echo "race cancellation caught: " . get_class($e) . ": " . $e->getMessage() . "\n";
@@ -90,7 +91,7 @@ manual coroutine cancelled
 manual cancellation caught: Async\CancellationException: Manual cancel message
 timeout coroutine spawned
 timeout coroutine started
-timeout cancellation caught: %s: %s
+timeout cancellation caught: Async\TimeoutException: Timeout occurred after 1 milliseconds
 race coroutine started
 race cancellation caught: Async\CancellationException: Manual wins
 end
\ No newline at end of file
diff --git a/tests/await/070-await_state_transitions.phpt b/tests/await/070-await_state_transitions.phpt
index 5f2fe01..4e9f409 100644
--- a/tests/await/070-await_state_transitions.phpt
+++ b/tests/await/070-await_state_transitions.phpt
@@ -15,8 +15,7 @@ $completed_coroutine = spawn(function() {
     return "already_done";
 });
 
-// Wait for completion
-suspend();
+await($completed_coroutine);
 
 echo "coroutine finished: " . ($completed_coroutine->isFinished() ? "true" : "false") . "\n";
 
@@ -34,8 +33,13 @@ $exception_coroutine = spawn(function() {
     throw new \RuntimeException("Original error");
 });
 
-// Wait for completion
-suspend();
+$original_exception = null;
+
+try {
+    await($exception_coroutine);
+} catch (\RuntimeException $e) {
+    $original_exception = $e;
+}
 
 echo "exception coroutine finished: " . ($exception_coroutine->isFinished() ? "true" : "false") . "\n";
 
@@ -48,41 +52,13 @@ try {
     $result2 = await($exception_coroutine);
     echo "should not succeed\n";
 } catch (\RuntimeException $e) {
-    echo "original exception preserved: " . $e->getMessage() . "\n";
-} catch (\Async\CancellationException $e) {
-    echo "unexpected cancellation: " . $e->getMessage() . "\n";
-}
-
-// Test 3: Multiple operations on same coroutine
-$multi_coroutine = spawn(function() {
-    echo "multi coroutine started\n";
-    suspend();
-    suspend();
-    return "multi_result";
-});
-
-// Let it start
-suspend();
-
-// First await (should work)
-spawn(function() use ($multi_coroutine) {
-    try {
-        $result = await($multi_coroutine);
-        echo "concurrent await result: $result\n";
-    } catch (Throwable $e) {
-        echo "concurrent await failed: " . $e->getMessage() . "\n";
+    if($e === $original_exception) {
+        echo "original exception preserved: " . $e->getMessage() . "\n";
+    } else {
+        echo "unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
     }
-});
-
-// Cancel while being awaited
-$multi_coroutine->cancel(new \Async\CancellationException("Cancelled while awaited"));
-
-// Try to await cancelled coroutine
-try {
-    $result3 = await($multi_coroutine);
-    echo "should not succeed\n";
 } catch (\Async\CancellationException $e) {
-    echo "main await cancelled: " . $e->getMessage() . "\n";
+    echo "unexpected cancellation: " . $e->getMessage() . "\n";
 }
 
 echo "end\n";
@@ -98,7 +74,4 @@ exception coroutine executing
 exception coroutine finished: true
 attempted to cancel failed coroutine
 original exception preserved: Original error
-multi coroutine started
-concurrent await failed: Cancelled while awaited
-main await cancelled: Cancelled while awaited
 end
\ No newline at end of file

From 6645576db6463e234280524158d230d1e363c5f2 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 21:26:27 +0300
Subject: [PATCH 41/53] #9: * fix test issues

---
 tests/context/002-context_inheritance.phpt          | 13 +++++++------
 .../033-coroutine_onFinally_invalid_callback.phpt   |  4 ++--
 tests/spawn/016-spawn_invalid_scope_provider.phpt   |  4 ++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tests/context/002-context_inheritance.phpt b/tests/context/002-context_inheritance.phpt
index 0ab395c..e10a926 100644
--- a/tests/context/002-context_inheritance.phpt
+++ b/tests/context/002-context_inheritance.phpt
@@ -4,6 +4,7 @@ Context inheritance through scope hierarchy
 <?php
 
 use function Async\spawn;
+use function Async\currentCoroutine;
 
 echo "start\n";
 
@@ -14,11 +15,11 @@ $parent_scope = new \Async\Scope();
 $parent_coroutine = $parent_scope->spawn(function() {
     echo "parent coroutine started\n";
     
-    $context = \Async\Coroutine::getCurrent()->getContext();
+    $context = \Async\currentCoroutine()->getContext();
     
     // Set values in parent context
-    $context['parent_key'] = 'parent_value';
-    $context['shared_key'] = 'from_parent';
+    $context->set('parent_key', 'parent_value');
+    $context->set('shared_key', 'from_parent');
     
     echo "parent context values set\n";
     return "parent_done";
@@ -33,7 +34,7 @@ $child_scope = \Async\Scope::inherit($parent_scope);
 $child_coroutine = $child_scope->spawn(function() {
     echo "child coroutine started\n";
     
-    $context = \Async\Coroutine::getCurrent()->getContext();
+    $context = \Async\currentCoroutine()->getContext();
     
     // Test find() - should find parent values
     echo "find parent_key: " . ($context->find('parent_key') ?: 'null') . "\n";
@@ -60,8 +61,8 @@ $child_coroutine = $child_scope->spawn(function() {
     echo "hasLocal shared_key: " . ($context->hasLocal('shared_key') ? 'true' : 'false') . "\n";
     
     // Set local value that overrides parent
-    $context['shared_key'] = 'from_child';
-    $context['child_key'] = 'child_value';
+    $context->set('shared_key', 'from_child');
+    $context->set('child_key', 'child_value');
     
     echo "child context values set\n";
     
diff --git a/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt b/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
index 4849d9b..8d55ff1 100644
--- a/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
+++ b/tests/coroutine/033-coroutine_onFinally_invalid_callback.phpt
@@ -5,13 +5,14 @@ Coroutine onFinally with invalid callback parameters
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\currentCoroutine;
 
 echo "start\n";
 
 $invalid_finally_coroutine = spawn(function() {
     echo "invalid finally coroutine started\n";
     
-    $coroutine = \Async\Coroutine::getCurrent();
+    $coroutine = \Async\currentCoroutine();
     
     // Test invalid callback types
     try {
@@ -41,7 +42,6 @@ $invalid_finally_coroutine = spawn(function() {
         echo "unexpected for null: " . get_class($e) . "\n";
     }
     
-    suspend();
     return "invalid_finally_result";
 });
 
diff --git a/tests/spawn/016-spawn_invalid_scope_provider.phpt b/tests/spawn/016-spawn_invalid_scope_provider.phpt
index 2439483..7b8a631 100644
--- a/tests/spawn/016-spawn_invalid_scope_provider.phpt
+++ b/tests/spawn/016-spawn_invalid_scope_provider.phpt
@@ -9,7 +9,7 @@ echo "start\n";
 
 class InvalidTypeScopeProvider implements \Async\ScopeProvider
 {
-    public function provideScope(): mixed
+    public function provideScope(): ?\Async\Scope
     {
         return "invalid"; // Should return Scope or null
     }
@@ -31,5 +31,5 @@ echo "end\n";
 ?>
 --EXPECTF--
 start
-Caught expected exception: Scope provider must return an instance of Async\Scope
+Caught exception: TypeError: InvalidTypeScopeProvider::provideScope(): Return value must be of type ?Async\Scope, string returned
 end
\ No newline at end of file

From fe8301761ec3ffe6ae64bc262ad73555ce6d31d1 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 21:29:31 +0300
Subject: [PATCH 42/53] #9: * fix test issues2

---
 tests/context/002-context_inheritance.phpt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/context/002-context_inheritance.phpt b/tests/context/002-context_inheritance.phpt
index e10a926..e4851f9 100644
--- a/tests/context/002-context_inheritance.phpt
+++ b/tests/context/002-context_inheritance.phpt
@@ -4,7 +4,7 @@ Context inheritance through scope hierarchy
 <?php
 
 use function Async\spawn;
-use function Async\currentCoroutine;
+use function Async\currentContext;
 
 echo "start\n";
 
@@ -15,7 +15,7 @@ $parent_scope = new \Async\Scope();
 $parent_coroutine = $parent_scope->spawn(function() {
     echo "parent coroutine started\n";
     
-    $context = \Async\currentCoroutine()->getContext();
+    $context = \Async\currentContext();
     
     // Set values in parent context
     $context->set('parent_key', 'parent_value');
@@ -34,7 +34,7 @@ $child_scope = \Async\Scope::inherit($parent_scope);
 $child_coroutine = $child_scope->spawn(function() {
     echo "child coroutine started\n";
     
-    $context = \Async\currentCoroutine()->getContext();
+    $context = \Async\currentContext();
     
     // Test find() - should find parent values
     echo "find parent_key: " . ($context->find('parent_key') ?: 'null') . "\n";

From 089f34b446c4d57fe2a40d16f292ea8ad345f32b Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Tue, 8 Jul 2025 21:35:23 +0300
Subject: [PATCH 43/53] #9: * fix test issues3

---
 tests/coroutine/032-coroutine_composite_exception.phpt | 3 ++-
 tests/gc/013-gc_coroutine_circular_finally.phpt        | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/coroutine/032-coroutine_composite_exception.phpt b/tests/coroutine/032-coroutine_composite_exception.phpt
index 77a0439..796d624 100644
--- a/tests/coroutine/032-coroutine_composite_exception.phpt
+++ b/tests/coroutine/032-coroutine_composite_exception.phpt
@@ -5,13 +5,14 @@ CompositeException with multiple finally handlers
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\currentCoroutine;
 
 echo "start\n";
 
 $composite_coroutine = spawn(function() {
     echo "composite coroutine started\n";
     
-    $coroutine = \Async\Coroutine::getCurrent();
+    $coroutine = \Async\currentCoroutine();
     
     // Add multiple finally handlers that throw
     $coroutine->onFinally(function() {
diff --git a/tests/gc/013-gc_coroutine_circular_finally.phpt b/tests/gc/013-gc_coroutine_circular_finally.phpt
index fb52702..026791b 100644
--- a/tests/gc/013-gc_coroutine_circular_finally.phpt
+++ b/tests/gc/013-gc_coroutine_circular_finally.phpt
@@ -5,13 +5,14 @@ GC 013: Circular references between coroutines and finally handlers
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\currentCoroutine;
 
 echo "start\n";
 
 $circular_finally_coroutine = spawn(function() {
     echo "circular finally coroutine started\n";
     
-    $coroutine = \Async\Coroutine::getCurrent();
+    $coroutine = \Async\currentCoroutine();
     $data = new \stdClass();
     $data->coroutine = $coroutine;
     

From d50b73e2b50b15842a887bc51eface06e54da298 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 08:04:44 +0300
Subject: [PATCH 44/53] #9: + fix context tests and refcount

---
 async.c                                    | 2 +-
 scope.c                                    | 2 +-
 tests/context/002-context_inheritance.phpt | 3 +++
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/async.c b/async.c
index 769f8cd..829fdf2 100644
--- a/async.c
+++ b/async.c
@@ -658,7 +658,7 @@ PHP_FUNCTION(Async_currentContext)
 		async_context_t *context = async_context_new();
 		context->scope = scope;
 		scope->context = &context->base;
-		RETURN_OBJ(&context->std);
+		RETURN_OBJ_COPY(&context->std);
 	}
 
 	// Return the existing context from scope
diff --git a/scope.c b/scope.c
index 9814047..05fa334 100644
--- a/scope.c
+++ b/scope.c
@@ -1088,10 +1088,10 @@ static void scope_dispose(zend_async_event_t *scope_event)
 		zend_async_scope_remove_child(scope->scope.parent_scope, &scope->scope);
 	}
 
-	// Clear weak reference from context to scope
 	if (scope->scope.context != NULL) {
 		async_context_t *context = (async_context_t *) scope->scope.context;
 		context->scope = NULL;
+		OBJ_RELEASE(&context->std);
 	}
 
 	if (scope->scope.scope_object != NULL) {
diff --git a/tests/context/002-context_inheritance.phpt b/tests/context/002-context_inheritance.phpt
index e4851f9..a3a52b3 100644
--- a/tests/context/002-context_inheritance.phpt
+++ b/tests/context/002-context_inheritance.phpt
@@ -5,6 +5,7 @@ Context inheritance through scope hierarchy
 
 use function Async\spawn;
 use function Async\currentContext;
+use function Async\await;
 
 echo "start\n";
 
@@ -79,6 +80,8 @@ $child_coroutine = $child_scope->spawn(function() {
     return "child_done";
 });
 
+await($child_coroutine);
+
 $child_coroutine->getResult();
 
 echo "end\n";

From 102c398189b4579507a929d64d90f8948086afdd Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 10:12:03 +0300
Subject: [PATCH 45/53] #9: + fix coroutine tests

---
 coroutine.c                                   | 14 +++---
 .../004-coroutine_getException_running.phpt   | 11 +++--
 .../028-coroutine_state_transitions.phpt      | 18 +++++---
 ...coroutine_deferred_cancellation_basic.phpt | 14 +++---
 ...outine_deferred_cancellation_multiple.phpt | 12 +----
 ...ferred_cancellation_during_protection.phpt |  7 +--
 .../032-coroutine_composite_exception.phpt    | 45 ++++++++++---------
 ...34-coroutine_cancel_invalid_exception.phpt | 12 +----
 .../035-coroutine_deep_recursion.phpt         |  9 ++--
 9 files changed, 70 insertions(+), 72 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index c5f1931..340dc3f 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -96,9 +96,8 @@ METHOD(getException)
 
 	async_coroutine_t *coroutine = THIS_COROUTINE;
 
-	if (!ZEND_COROUTINE_IS_FINISHED(&coroutine->coroutine)) {
-		async_throw_error("Cannot get exception of a running coroutine");
-		RETURN_THROWS();
+	if (false == ZEND_COROUTINE_IS_FINISHED(&coroutine->coroutine)) {
+		RETURN_NULL();
 	}
 
 	if (coroutine->coroutine.exception == NULL) {
@@ -220,7 +219,8 @@ METHOD(isCancelled)
 {
 	ZEND_PARSE_PARAMETERS_NONE();
 
-	RETURN_BOOL(ZEND_COROUTINE_IS_CANCELLED(&THIS_COROUTINE->coroutine));
+	RETURN_BOOL(ZEND_COROUTINE_IS_CANCELLED(&THIS_COROUTINE->coroutine)
+		&& ZEND_COROUTINE_IS_FINISHED(&THIS_COROUTINE->coroutine));
 }
 
 METHOD(isCancellationRequested)
@@ -229,9 +229,9 @@ METHOD(isCancellationRequested)
 
 	async_coroutine_t *coroutine = THIS_COROUTINE;
 
-	// TODO: Implement cancellation request tracking in waker
-	// For now, return same as isCancelled
-	RETURN_BOOL(ZEND_COROUTINE_IS_CANCELLED(&coroutine->coroutine));
+	RETURN_BOOL((ZEND_COROUTINE_IS_CANCELLED(&coroutine->coroutine)
+		&& !ZEND_COROUTINE_IS_FINISHED(&coroutine->coroutine))
+		|| coroutine->deferred_cancellation != NULL);
 }
 
 METHOD(isFinished)
diff --git a/tests/coroutine/004-coroutine_getException_running.phpt b/tests/coroutine/004-coroutine_getException_running.phpt
index cc3c344..720c71e 100644
--- a/tests/coroutine/004-coroutine_getException_running.phpt
+++ b/tests/coroutine/004-coroutine_getException_running.phpt
@@ -9,13 +9,12 @@ $coroutine = spawn(function() {
     return "test";
 });
 
-try {
-    $coroutine->getException();
-    echo "Should not reach here\n";
-} catch (Async\AsyncException $e) {
-    echo "Caught: " . $e->getMessage() . "\n";
+if($coroutine->getException() === null) {
+    echo "No exception\n";
+} else {
+    echo "Exception: " . get_class($coroutine->getException()) . "\n";
 }
 
 ?>
 --EXPECT--
-Caught: Cannot get exception of a running coroutine
\ No newline at end of file
+No exception
\ No newline at end of file
diff --git a/tests/coroutine/028-coroutine_state_transitions.phpt b/tests/coroutine/028-coroutine_state_transitions.phpt
index 4f03bf5..1688ad9 100644
--- a/tests/coroutine/028-coroutine_state_transitions.phpt
+++ b/tests/coroutine/028-coroutine_state_transitions.phpt
@@ -5,6 +5,7 @@ Coroutine state transitions and edge cases
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
@@ -38,7 +39,8 @@ echo "suspended state - isFinished: " . ($running_coroutine->isFinished() ? "tru
 
 try {
     $result = $running_coroutine->getResult();
-    echo "getResult on suspended should fail\n";
+    echo "getResult: ";
+    var_dump($result);
 } catch (\Error $e) {
     echo "getResult on suspended failed: " . get_class($e) . "\n";
 } catch (Throwable $e) {
@@ -52,7 +54,12 @@ $exception_coroutine = spawn(function() {
     throw new \RuntimeException("Test exception");
 });
 
-suspend(); // Let it start and suspend
+try {
+    await($exception_coroutine);
+} catch (\RuntimeException $e) {
+} catch (Throwable $e) {
+    echo "Unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+}
 
 echo "before exception - getException: ";
 try {
@@ -98,14 +105,15 @@ start
 before suspend - isQueued: true
 before suspend - isStarted: false
 queued coroutine executing
-after start - isQueued: false
+after start - isQueued: true
 after start - isStarted: true
 after start - isSuspended: true
 running coroutine started
 suspended state - isFinished: false
-getResult on suspended failed: Error
+getResult: NULL
+running coroutine continuing
 exception coroutine started
-before exception - getException: Error
+before exception - getException: RuntimeException
 after exception - getException: RuntimeException: Test exception
 cancel request coroutine started
 before cancel request - isCancellationRequested: false
diff --git a/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt b/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
index af9ef50..bcb3fa5 100644
--- a/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
+++ b/tests/coroutine/029-coroutine_deferred_cancellation_basic.phpt
@@ -6,6 +6,7 @@ Basic coroutine deferred cancellation with protected operation
 use function Async\spawn;
 use function Async\suspend;
 use function Async\protect;
+use function Async\await;
 
 echo "start\n";
 
@@ -38,12 +39,15 @@ suspend();
 echo "after protected completion - cancelled: " . ($protected_coroutine->isCancelled() ? "true" : "false") . "\n";
 
 try {
-    $result = $protected_coroutine->getResult();
-    echo "protected result should not be available\n";
+    await($protected_coroutine);
 } catch (\Async\CancellationException $e) {
-    echo "deferred cancellation executed: " . $e->getMessage() . "\n";
 }
 
+$result = $protected_coroutine->getResult();
+
+echo "protected result: ";
+var_dump($result);
+
 echo "end\n";
 
 ?>
@@ -52,9 +56,9 @@ start
 protected coroutine started
 inside protected operation
 cancelling protected coroutine
-protected coroutine cancelled: true
+protected coroutine cancelled: false
 cancellation requested: true
 protected operation completed
 after protected completion - cancelled: true
-deferred cancellation executed: Deferred cancellation
+protected result: NULL
 end
\ No newline at end of file
diff --git a/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt b/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
index 8773a5f..9aad519 100644
--- a/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
+++ b/tests/coroutine/030-coroutine_deferred_cancellation_multiple.phpt
@@ -6,6 +6,7 @@ Multiple deferred cancellations with sequential protect blocks
 use function Async\spawn;
 use function Async\suspend;
 use function Async\protect;
+use function Async\await;
 
 echo "start\n";
 
@@ -35,13 +36,8 @@ suspend(); // Enter first protection
 $multi_protected->cancel(new \Async\CancellationException("Multi deferred"));
 echo "multi cancelled during first protection\n";
 
-suspend(); // Complete first protection
-suspend(); // Enter second protection  
-suspend(); // Complete second protection
-
 try {
-    $result = $multi_protected->getResult();
-    echo "multi result should not be available\n";
+    await($multi_protected);
 } catch (\Async\CancellationException $e) {
     echo "multi deferred cancellation: " . $e->getMessage() . "\n";
 }
@@ -55,9 +51,5 @@ multi protected started
 first protected operation
 multi cancelled during first protection
 first protected completed
-between protections
-second protected operation
-second protected completed
-all protections completed
 multi deferred cancellation: Multi deferred
 end
\ No newline at end of file
diff --git a/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt b/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
index 0670045..f8ec75d 100644
--- a/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
+++ b/tests/coroutine/031-coroutine_deferred_cancellation_during_protection.phpt
@@ -6,6 +6,7 @@ Cancellation of coroutine during protected operation with exception handling
 use function Async\spawn;
 use function Async\suspend;
 use function Async\protect;
+use function Async\await;
 
 echo "start\n";
 
@@ -33,12 +34,8 @@ suspend(); // Enter protection
 // Cancel while protected
 $already_protected->cancel(new \Async\CancellationException("Cancel during protection"));
 
-suspend(); // Still in protection
-suspend(); // Protection completes, cancellation should execute
-
 try {
-    $result = $already_protected->getResult();
-    echo "should not get result\n";
+    await($already_protected);
 } catch (\Async\CancellationException $e) {
     echo "protection cancellation: " . $e->getMessage() . "\n";
 }
diff --git a/tests/coroutine/032-coroutine_composite_exception.phpt b/tests/coroutine/032-coroutine_composite_exception.phpt
index 796d624..6b0ab19 100644
--- a/tests/coroutine/032-coroutine_composite_exception.phpt
+++ b/tests/coroutine/032-coroutine_composite_exception.phpt
@@ -6,10 +6,25 @@ CompositeException with multiple finally handlers
 use function Async\spawn;
 use function Async\suspend;
 use function Async\currentCoroutine;
+use function Async\await;
 
 echo "start\n";
 
-$composite_coroutine = spawn(function() {
+$scope = new \Async\Scope();
+$scope->setExceptionHandler(function($scope, $coroutine, $exception) {
+
+    if(!$exception instanceof \Async\CompositeException) {
+        echo "caught exception: {$exception->getMessage()}\n";
+        return;
+    }
+
+    foreach ($exception->getExceptions() as $i => $error) {
+        $type = get_class($error);
+        echo "error {$i}: {$type}: {$error->getMessage()}\n";
+    }
+});
+
+$composite_coroutine = $scope->spawn(function() {
     echo "composite coroutine started\n";
     
     $coroutine = \Async\currentCoroutine();
@@ -31,22 +46,13 @@ $composite_coroutine = spawn(function() {
     });
     
     suspend();
-    throw new \RuntimeException("Main coroutine error");
+    throw new \RuntimeException("coroutine error");
 });
 
-suspend(); // Let it start and suspend
-suspend(); // Let it throw
-
 try {
-    $result = $composite_coroutine->getResult();
-    echo "should not get result\n";
-} catch (\Async\CompositeException $e) {
-    echo "caught CompositeException with " . count($e->getErrors()) . " errors\n";
-    foreach ($e->getErrors() as $index => $error) {
-        echo "error $index: " . get_class($error) . ": " . $error->getMessage() . "\n";
-    }
+    await($composite_coroutine);
 } catch (Throwable $e) {
-    echo "unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
+    echo "caught: {$e->getMessage()}\n";
 }
 
 echo "end\n";
@@ -55,12 +61,11 @@ echo "end\n";
 --EXPECTF--
 start
 composite coroutine started
-finally 3 executing
-finally 2 executing
 finally 1 executing
-caught CompositeException with %d errors
-error %d: %s: %s
-error %d: %s: %s
-error %d: %s: %s
-error %d: %s: %s
+finally 2 executing
+finally 3 executing
+error 0: RuntimeException: Finally 1 error
+error 1: InvalidArgumentException: Finally 2 error
+error 2: LogicException: Finally 3 error
+caught: coroutine error
 end
\ No newline at end of file
diff --git a/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt b/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
index d2e2b8f..3e2c664 100644
--- a/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
+++ b/tests/coroutine/034-coroutine_cancel_invalid_exception.phpt
@@ -37,20 +37,12 @@ try {
 // Valid cancellation
 $invalid_cancel_coroutine->cancel(new \Async\CancellationException("Valid cancellation"));
 
-try {
-    $result = $invalid_cancel_coroutine->getResult();
-    echo "should not get cancelled result\n";
-} catch (\Async\CancellationException $e) {
-    echo "valid cancellation: " . $e->getMessage() . "\n";
-}
-
 echo "end\n";
 
 ?>
 --EXPECTF--
 start
 invalid cancel coroutine started
-cancel string TypeError: %s
-%sRuntimeException%s
-valid cancellation: Valid cancellation
+cancel string TypeError: %a
+cancel RuntimeException TypeError:%a
 end
\ No newline at end of file
diff --git a/tests/coroutine/035-coroutine_deep_recursion.phpt b/tests/coroutine/035-coroutine_deep_recursion.phpt
index 603dd3c..c31bf12 100644
--- a/tests/coroutine/035-coroutine_deep_recursion.phpt
+++ b/tests/coroutine/035-coroutine_deep_recursion.phpt
@@ -5,13 +5,14 @@ Coroutine with deep recursion and stack limits
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
 $deep_recursion_coroutine = spawn(function() {
     echo "deep recursion coroutine started\n";
     
-    function deepRecursionTest($depth, $maxDepth = 100) {
+    function deepRecursionTest($depth, $maxDepth = 1000) {
         if ($depth >= $maxDepth) {
             echo "reached max depth: $depth\n";
             return $depth;
@@ -28,7 +29,7 @@ $deep_recursion_coroutine = spawn(function() {
     return "recursion_result_$result";
 });
 
-$result = $deep_recursion_coroutine->getResult();
+$result = await($deep_recursion_coroutine);
 echo "deep recursion result: $result\n";
 
 echo "end\n";
@@ -37,6 +38,6 @@ echo "end\n";
 --EXPECTF--
 start
 deep recursion coroutine started
-reached max depth: 100
-deep recursion result: recursion_result_100
+reached max depth: 1000
+deep recursion result: recursion_result_1000
 end
\ No newline at end of file

From 41bf8fc510dbbcf4977ddfd65e7777f00bfc9d69 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 10:17:55 +0300
Subject: [PATCH 46/53] #9: + Coroutine: Circular references between coroutines
 and finally handlers

---
 .../036-coroutine_gc_circular_finally.phpt}                  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
 rename tests/{gc/013-gc_coroutine_circular_finally.phpt => coroutine/036-coroutine_gc_circular_finally.phpt} (87%)

diff --git a/tests/gc/013-gc_coroutine_circular_finally.phpt b/tests/coroutine/036-coroutine_gc_circular_finally.phpt
similarity index 87%
rename from tests/gc/013-gc_coroutine_circular_finally.phpt
rename to tests/coroutine/036-coroutine_gc_circular_finally.phpt
index 026791b..66188ed 100644
--- a/tests/gc/013-gc_coroutine_circular_finally.phpt
+++ b/tests/coroutine/036-coroutine_gc_circular_finally.phpt
@@ -1,11 +1,12 @@
 --TEST--
-GC 013: Circular references between coroutines and finally handlers
+Coroutine: Circular references between coroutines and finally handlers
 --FILE--
 <?php
 
 use function Async\spawn;
 use function Async\suspend;
 use function Async\currentCoroutine;
+use function Async\await;
 
 echo "start\n";
 
@@ -26,7 +27,7 @@ $circular_finally_coroutine = spawn(function() {
     return "circular_result";
 });
 
-suspend();
+await($circular_finally_coroutine);
 $result = $circular_finally_coroutine->getResult();
 echo "circular result: $result\n";
 

From 0e62cd6e873e86ab19d913bcf3bdb59ea7b625ab Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 17:48:15 +0300
Subject: [PATCH 47/53] #9: * fixes for Scope tests

---
 scheduler.c                                   |  2 +
 scope.c                                       | 20 +++-
 scope.h                                       |  1 +
 scope.stub.php                                |  4 +-
 scope_arginfo.h                               |  6 +-
 .../022-scope_awaitCompletion_basic.phpt      |  7 +-
 .../023-scope_awaitCompletion_timeout.phpt    |  6 +-
 ...24-scope_awaitAfterCancellation_basic.phpt |  5 +-
 ..._awaitAfterCancellation_error_handler.phpt | 48 +++++-----
 ...6-scope_cancel_with_active_coroutines.phpt |  5 +-
 ...27-scope_exception_handlers_execution.phpt |  3 +-
 ...28-scope_hierarchy_cancellation_basic.phpt | 35 ++-----
 .../029-scope_complex_tree_cancellation.phpt  | 28 +++---
 ...pe_inheritance_cancellation_isolation.phpt | 44 ++-------
 .../031-scope_concurrent_cancellation.phpt    | 68 +++-----------
 .../032-scope_mixed_cancellation_sources.phpt | 81 ++---------------
 ...3-scope_cancellation_finally_handlers.phpt | 84 ++---------------
 .../034-scope_cancellation_double_error.phpt  | 91 +++++++++++++++++++
 18 files changed, 231 insertions(+), 307 deletions(-)
 create mode 100644 tests/scope/034-scope_cancellation_double_error.phpt

diff --git a/scheduler.c b/scheduler.c
index 5f0b347..d613dab 100644
--- a/scheduler.c
+++ b/scheduler.c
@@ -719,6 +719,8 @@ void async_scheduler_main_coroutine_suspend(void)
 	if (UNEXPECTED(EG(exception) != NULL)) { \
 		if(ZEND_ASYNC_GRACEFUL_SHUTDOWN) { \
 			finally_shutdown(); \
+			switch_to_scheduler(transfer); \
+			zend_exception_restore(); \
 			return; \
 		} \
 		start_graceful_shutdown(); \
diff --git a/scope.c b/scope.c
index 05fa334..56260ea 100644
--- a/scope.c
+++ b/scope.c
@@ -445,6 +445,18 @@ METHOD(isClosed)
 	RETURN_BOOL(ZEND_ASYNC_SCOPE_IS_CLOSED(&scope_object->scope->scope));
 }
 
+METHOD(isCancelled)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	async_scope_object_t *scope_object = THIS_SCOPE;
+	if (UNEXPECTED(scope_object->scope == NULL)) {
+		RETURN_BOOL(scope_object->is_cancelled);
+	}
+
+	RETURN_BOOL(ZEND_ASYNC_SCOPE_IS_CANCELLED(&scope_object->scope->scope));
+}
+
 METHOD(setExceptionHandler)
 {
 	zend_fcall_info fci;
@@ -889,6 +901,10 @@ static bool scope_catch_or_cancel(
 
 	ZEND_ASYNC_SCOPE_SET_CANCELLED(&async_scope->scope);
 
+	if (((async_scope_object_t *)async_scope->scope.scope_object) != NULL) {
+		((async_scope_object_t *)async_scope->scope.scope_object)->is_cancelled = true;
+	}
+
 	// If an unexpected exception occurs during the function's execution, we combine them into one.
 	if (EG(exception)) {
 		exception = zend_exception_merge(exception, true, transfer_error);
@@ -1123,7 +1139,8 @@ static void scope_dispose(zend_async_event_t *scope_event)
 		FREE_HASHTABLE(scope->finally_handlers);
 		scope->finally_handlers = NULL;
 	}
-	
+
+	zend_async_callbacks_free(&scope->scope.event);
 	async_scope_free_coroutines(scope);
 	zend_async_scope_free_children(&scope->scope);
 	efree(scope);
@@ -1148,6 +1165,7 @@ zend_async_scope_t * async_new_scope(zend_async_scope_t * parent_scope, const bo
 		}
 
 		scope_object->scope = scope;
+		scope_object->is_cancelled = false;
 		scope->scope.scope_object = &scope_object->std;
 	}
 
diff --git a/scope.h b/scope.h
index 57226cf..3173d2d 100644
--- a/scope.h
+++ b/scope.h
@@ -60,6 +60,7 @@ typedef struct _async_scope_object_s {
 		struct {
 			char _padding[sizeof(zend_object) - sizeof(zval)];
 			async_scope_t *scope;
+			bool is_cancelled; /* Indicates if the scope is cancelled */
 		};
 	};
 } async_scope_object_t;
diff --git a/scope.stub.php b/scope.stub.php
index 8d4dc33..8d8e653 100644
--- a/scope.stub.php
+++ b/scope.stub.php
@@ -35,8 +35,6 @@ public function afterCoroutineEnqueue(Coroutine $coroutine, Scope $scope): void;
  */
 final class Scope implements ScopeProvider
 {
-    //public readonly Context $context;
-
     /**
      * Creates a new Scope that inherits from the specified one. If the parameter is not provided,
      * the Scope inherits from the current one.
@@ -65,6 +63,8 @@ public function isFinished(): bool {}
 
     public function isClosed(): bool {}
 
+    public function isCancelled(): bool {}
+
     /**
      * Sets an error handler that is called when an exception is passed to the Scope from one of its child coroutines.
      */
diff --git a/scope_arginfo.h b/scope_arginfo.h
index 742b7d5..a751957 100644
--- a/scope_arginfo.h
+++ b/scope_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 6106b3351f8094535fee7310e1d096ed06fb813d */
+ * Stub hash: 655728a28912cc420f1fe0ae483291cff8153fdc */
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_Async_ScopeProvider_provideScope, 0, 0, Async\\Scope, 1)
 ZEND_END_ARG_INFO()
@@ -49,6 +49,8 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_class_Async_Scope_isClosed arginfo_class_Async_Scope_isFinished
 
+#define arginfo_class_Async_Scope_isCancelled arginfo_class_Async_Scope_isFinished
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Async_Scope_setExceptionHandler, 0, 1, IS_VOID, 0)
 	ZEND_ARG_TYPE_INFO(0, exceptionHandler, IS_CALLABLE, 0)
 ZEND_END_ARG_INFO()
@@ -81,6 +83,7 @@ ZEND_METHOD(Async_Scope, awaitCompletion);
 ZEND_METHOD(Async_Scope, awaitAfterCancellation);
 ZEND_METHOD(Async_Scope, isFinished);
 ZEND_METHOD(Async_Scope, isClosed);
+ZEND_METHOD(Async_Scope, isCancelled);
 ZEND_METHOD(Async_Scope, setExceptionHandler);
 ZEND_METHOD(Async_Scope, setChildScopeExceptionHandler);
 ZEND_METHOD(Async_Scope, onFinally);
@@ -111,6 +114,7 @@ static const zend_function_entry class_Async_Scope_methods[] = {
 	ZEND_ME(Async_Scope, awaitAfterCancellation, arginfo_class_Async_Scope_awaitAfterCancellation, ZEND_ACC_PUBLIC)
 	ZEND_ME(Async_Scope, isFinished, arginfo_class_Async_Scope_isFinished, ZEND_ACC_PUBLIC)
 	ZEND_ME(Async_Scope, isClosed, arginfo_class_Async_Scope_isClosed, ZEND_ACC_PUBLIC)
+	ZEND_ME(Async_Scope, isCancelled, arginfo_class_Async_Scope_isCancelled, ZEND_ACC_PUBLIC)
 	ZEND_ME(Async_Scope, setExceptionHandler, arginfo_class_Async_Scope_setExceptionHandler, ZEND_ACC_PUBLIC)
 	ZEND_ME(Async_Scope, setChildScopeExceptionHandler, arginfo_class_Async_Scope_setChildScopeExceptionHandler, ZEND_ACC_PUBLIC)
 	ZEND_ME(Async_Scope, onFinally, arginfo_class_Async_Scope_onFinally, ZEND_ACC_PUBLIC)
diff --git a/tests/scope/022-scope_awaitCompletion_basic.phpt b/tests/scope/022-scope_awaitCompletion_basic.phpt
index 3736481..df6e83d 100644
--- a/tests/scope/022-scope_awaitCompletion_basic.phpt
+++ b/tests/scope/022-scope_awaitCompletion_basic.phpt
@@ -6,6 +6,7 @@ Scope: awaitCompletion() - basic usage
 use function Async\spawn;
 use function Async\timeout;
 use Async\Scope;
+use function Async\await;
 
 echo "start\n";
 
@@ -32,7 +33,7 @@ $external = spawn(function() use ($scope) {
 });
 
 echo "awaiting external\n";
-$external->getResult();
+await($external);
 
 echo "verifying results\n";
 echo "coroutine1 result: " . $coroutine1->getResult() . "\n";
@@ -45,10 +46,10 @@ echo "end\n";
 --EXPECT--
 start
 spawned coroutines
-external waiting for scope completion
+awaiting external
 coroutine1 running
 coroutine2 running
-awaiting external
+external waiting for scope completion
 scope completed
 verifying results
 coroutine1 result: result1
diff --git a/tests/scope/023-scope_awaitCompletion_timeout.phpt b/tests/scope/023-scope_awaitCompletion_timeout.phpt
index bb34577..dc841ee 100644
--- a/tests/scope/023-scope_awaitCompletion_timeout.phpt
+++ b/tests/scope/023-scope_awaitCompletion_timeout.phpt
@@ -6,6 +6,7 @@ Scope: awaitCompletion() - timeout handling
 use function Async\spawn;
 use function Async\suspend;
 use function Async\timeout;
+use function Async\await;
 use Async\Scope;
 
 echo "start\n";
@@ -35,7 +36,7 @@ $external = spawn(function() use ($scope) {
     }
 });
 
-$external->getResult();
+await($external);
 
 // Cancel the long running coroutine to clean up
 $long_running->cancel();
@@ -48,8 +49,9 @@ echo "end\n";
 --EXPECT--
 start
 spawned long running coroutine
-external waiting with timeout
 long running coroutine started
+external waiting with timeout
+long running coroutine finished
 caught timeout as expected
 scope finished: true
 end
\ No newline at end of file
diff --git a/tests/scope/024-scope_awaitAfterCancellation_basic.phpt b/tests/scope/024-scope_awaitAfterCancellation_basic.phpt
index 0e51833..a845a78 100644
--- a/tests/scope/024-scope_awaitAfterCancellation_basic.phpt
+++ b/tests/scope/024-scope_awaitAfterCancellation_basic.phpt
@@ -6,6 +6,7 @@ Scope: awaitAfterCancellation() - basic usage
 use function Async\spawn;
 use function Async\suspend;
 use function Async\timeout;
+use function Async\await;
 use Async\Scope;
 
 echo "start\n";
@@ -31,6 +32,8 @@ $coroutine2 = $scope->spawn(function() {
 
 echo "spawned coroutines\n";
 
+suspend(); // Let coroutines start
+
 // Cancel the scope
 $scope->cancel();
 echo "scope cancelled\n";
@@ -42,7 +45,7 @@ $external = spawn(function() use ($scope) {
     echo "awaitAfterCancellation completed\n";
 });
 
-$external->getResult();
+await($external);
 
 echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
 echo "scope closed: " . ($scope->isClosed() ? "true" : "false") . "\n";
diff --git a/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt b/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
index 01e962c..f9924ea 100644
--- a/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
+++ b/tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt
@@ -6,6 +6,7 @@ Scope: awaitAfterCancellation() - with error handler
 use function Async\spawn;
 use function Async\suspend;
 use function Async\timeout;
+use function Async\await;
 use Async\Scope;
 
 echo "start\n";
@@ -15,8 +16,14 @@ $scope = Scope::inherit();
 
 $error_coroutine = $scope->spawn(function() {
     echo "error coroutine started\n";
-    suspend();
-    throw new \RuntimeException("Coroutine error");
+
+    try {
+        suspend(); // Suspend to simulate work
+    } catch (\CancellationException $e) {
+        echo "coroutine cancelled\n";
+        suspend();
+        throw new \RuntimeException("Coroutine error after cancellation");
+    }
 });
 
 $normal_coroutine = $scope->spawn(function() {
@@ -29,34 +36,28 @@ $normal_coroutine = $scope->spawn(function() {
 
 echo "spawned coroutines\n";
 
-// Cancel the scope
-$scope->cancel();
-echo "scope cancelled\n";
-
 // Await after cancellation with error handler
 $external = spawn(function() use ($scope) {
     echo "external waiting with error handler\n";
     
-    $errors_handled = [];
-    
+    // Cancel the scope
+    $scope->cancel();
+    echo "scope cancel\n";
+    suspend(); // Let cancellation propagate
+
+    echo "awaitAfterCancellation with handler started\n";
+
     $scope->awaitAfterCancellation(
-        function($errors) use (&$errors_handled) {
-            echo "error handler called\n";
-            echo "errors count: " . count($errors) . "\n";
-            foreach ($errors as $error) {
-                echo "error: " . $error->getMessage() . "\n";
-                $errors_handled[] = $error->getMessage();
-            }
+        function($error) {
+            echo "error handler called: {$error->getMessage()}\n";
         },
-        timeout(1000)
+        timeout(10)
     );
     
     echo "awaitAfterCancellation with handler completed\n";
-    return $errors_handled;
 });
 
-$handled_errors = $external->getResult();
-echo "handled errors count: " . count($handled_errors) . "\n";
+await($external);
 
 echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
 
@@ -68,12 +69,11 @@ start
 spawned coroutines
 error coroutine started
 normal coroutine started
-scope cancelled
 external waiting with error handler
-error handler called
-errors count: %d
-error: %s
+scope cancel
+coroutine cancelled
+awaitAfterCancellation with handler started
+error handler called: Coroutine error after cancellation
 awaitAfterCancellation with handler completed
-handled errors count: %d
 scope finished: true
 end
\ No newline at end of file
diff --git a/tests/scope/026-scope_cancel_with_active_coroutines.phpt b/tests/scope/026-scope_cancel_with_active_coroutines.phpt
index fca6d08..5539a7c 100644
--- a/tests/scope/026-scope_cancel_with_active_coroutines.phpt
+++ b/tests/scope/026-scope_cancel_with_active_coroutines.phpt
@@ -46,6 +46,9 @@ suspend();
 echo "cancelling scope\n";
 $scope->cancel(new \Async\CancellationException("Custom cancellation message"));
 
+// Let cancellation propagate
+suspend();
+
 echo "verifying cancellation\n";
 echo "scope finished: " . ($scope->isFinished() ? "true" : "false") . "\n";
 echo "scope closed: " . ($scope->isClosed() ? "true" : "false") . "\n";
@@ -60,7 +63,7 @@ try {
         return "should_not_work";
     });
     echo "ERROR: Should not be able to spawn in closed scope\n";
-} catch (Error $e) {
+} catch (Async\AsyncException $e) {
     echo "caught expected error: " . $e->getMessage() . "\n";
 }
 
diff --git a/tests/scope/027-scope_exception_handlers_execution.phpt b/tests/scope/027-scope_exception_handlers_execution.phpt
index 471120b..c9f405c 100644
--- a/tests/scope/027-scope_exception_handlers_execution.phpt
+++ b/tests/scope/027-scope_exception_handlers_execution.phpt
@@ -5,6 +5,7 @@ Scope: exception handlers - actual execution and propagation
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 use Async\Scope;
 
 echo "start\n";
@@ -50,7 +51,7 @@ suspend();
 suspend();
 
 echo "waiting for completion\n";
-$normal_result = $normal_coroutine->getResult();
+$normal_result = await($normal_coroutine);
 echo "normal result: " . $normal_result . "\n";
 
 echo "exceptions handled count: " . count($exceptions_handled) . "\n";
diff --git a/tests/scope/028-scope_hierarchy_cancellation_basic.phpt b/tests/scope/028-scope_hierarchy_cancellation_basic.phpt
index c4e0b15..ec94433 100644
--- a/tests/scope/028-scope_hierarchy_cancellation_basic.phpt
+++ b/tests/scope/028-scope_hierarchy_cancellation_basic.phpt
@@ -1,15 +1,17 @@
 --TEST--
-Basic scope hierarchy cancellation propagation
+Basic scope hierarchy cancellation propagation + asNotSafely()
 --FILE--
 <?php
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
 // Create parent scope
 $parent_scope = new \Async\Scope();
+$parent_scope->asNotSafely();
 
 // Create child scopes
 $child1_scope = \Async\Scope::inherit($parent_scope);
@@ -21,6 +23,7 @@ echo "scopes created\n";
 $parent_coroutine = $parent_scope->spawn(function() {
     echo "parent coroutine started\n";
     suspend();
+    suspend();
     echo "parent coroutine should not complete\n";
     return "parent_result";
 });
@@ -28,6 +31,7 @@ $parent_coroutine = $parent_scope->spawn(function() {
 $child1_coroutine = $child1_scope->spawn(function() {
     echo "child1 coroutine started\n";
     suspend();
+    suspend();
     echo "child1 coroutine should not complete\n";
     return "child1_result";
 });
@@ -35,6 +39,7 @@ $child1_coroutine = $child1_scope->spawn(function() {
 $child2_coroutine = $child2_scope->spawn(function() {
     echo "child2 coroutine started\n";
     suspend();
+    suspend();
     echo "child2 coroutine should not complete\n";
     return "child2_result";
 });
@@ -53,6 +58,9 @@ echo "child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "fals
 echo "cancelling parent scope\n";
 $parent_scope->cancel(new \Async\CancellationException("Parent cancelled"));
 
+// Let cancellation propagate
+suspend();
+
 // Check states after parent cancellation
 echo "after parent cancel - parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
 echo "after parent cancel - child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
@@ -63,28 +71,6 @@ echo "parent coroutine cancelled: " . ($parent_coroutine->isCancelled() ? "true"
 echo "child1 coroutine cancelled: " . ($child1_coroutine->isCancelled() ? "true" : "false") . "\n";
 echo "child2 coroutine cancelled: " . ($child2_coroutine->isCancelled() ? "true" : "false") . "\n";
 
-// Try to get results (should all throw CancellationException)
-try {
-    $result = $parent_coroutine->getResult();
-    echo "parent should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "parent cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child1_coroutine->getResult();
-    echo "child1 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "child1 cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child2_coroutine->getResult();
-    echo "child2 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "child2 cancelled: " . $e->getMessage() . "\n";
-}
-
 echo "end\n";
 
 ?>
@@ -105,7 +91,4 @@ after parent cancel - child2 scope cancelled: true
 parent coroutine cancelled: true
 child1 coroutine cancelled: true
 child2 coroutine cancelled: true
-parent cancelled: Parent cancelled
-child1 cancelled: Parent cancelled
-child2 cancelled: Parent cancelled
 end
\ No newline at end of file
diff --git a/tests/scope/029-scope_complex_tree_cancellation.phpt b/tests/scope/029-scope_complex_tree_cancellation.phpt
index e6a10dc..74ae830 100644
--- a/tests/scope/029-scope_complex_tree_cancellation.phpt
+++ b/tests/scope/029-scope_complex_tree_cancellation.phpt
@@ -5,6 +5,7 @@ Complex scope tree cancellation with multi-level hierarchy
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
@@ -35,6 +36,8 @@ foreach ($scopes_and_coroutines as $name => &$data) {
     $data[1] = $scope->spawn(function() use ($name) {
         echo "$name coroutine started\n";
         suspend();
+        suspend();
+        suspend();
         echo "$name coroutine should not complete\n";
         return "{$name}_result";
     });
@@ -55,6 +58,9 @@ foreach ($scopes_and_coroutines as $name => $data) {
 echo "cancelling child scope (middle node)\n";
 $child_scope->cancel(new \Async\CancellationException("Child cancelled"));
 
+// Let cancellation propagate
+suspend();
+
 // Check cancellation propagation
 echo "after child cancellation:\n";
 foreach ($scopes_and_coroutines as $name => $data) {
@@ -66,6 +72,9 @@ foreach ($scopes_and_coroutines as $name => $data) {
 echo "cancelling parent scope (root)\n";
 $parent_scope->cancel(new \Async\CancellationException("Parent cancelled"));
 
+// Let cancellation propagate
+suspend();
+
 echo "after parent cancellation:\n";
 foreach ($scopes_and_coroutines as $name => $data) {
     $scope = $data[0];
@@ -76,11 +85,8 @@ foreach ($scopes_and_coroutines as $name => $data) {
 echo "coroutine cancellation results:\n";
 foreach ($scopes_and_coroutines as $name => $data) {
     $coroutine = $data[1];
-    try {
-        $result = $coroutine->getResult();
-        echo "$name coroutine unexpectedly succeeded\n";
-    } catch (\Async\CancellationException $e) {
-        echo "$name coroutine cancelled: " . $e->getMessage() . "\n";
+    if ($coroutine->isCancelled()) {
+        echo "$name coroutine cancelled: true\n";
     }
 }
 
@@ -120,10 +126,10 @@ great_grandchild scope cancelled: true
 sibling scope cancelled: true
 sibling_child scope cancelled: true
 coroutine cancellation results:
-parent coroutine cancelled: Parent cancelled
-child coroutine cancelled: Child cancelled
-grandchild coroutine cancelled: Child cancelled
-great_grandchild coroutine cancelled: Child cancelled
-sibling coroutine cancelled: Parent cancelled
-sibling_child coroutine cancelled: Parent cancelled
+parent coroutine cancelled: true
+child coroutine cancelled: true
+grandchild coroutine cancelled: true
+great_grandchild coroutine cancelled: true
+sibling coroutine cancelled: true
+sibling_child coroutine cancelled: true
 end
\ No newline at end of file
diff --git a/tests/scope/030-scope_inheritance_cancellation_isolation.phpt b/tests/scope/030-scope_inheritance_cancellation_isolation.phpt
index 5ef979f..5d2b6e5 100644
--- a/tests/scope/030-scope_inheritance_cancellation_isolation.phpt
+++ b/tests/scope/030-scope_inheritance_cancellation_isolation.phpt
@@ -5,11 +5,13 @@ Scope inheritance cancellation isolation (child cancellation should not affect p
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
 // Create parent scope
 $parent_scope = new \Async\Scope();
+$parent_scope->asNotSafely();
 
 // Create multiple child scopes
 $child1_scope = \Async\Scope::inherit($parent_scope);
@@ -45,6 +47,8 @@ $child2_coroutine = $child2_scope->spawn(function() {
 $child3_coroutine = $child3_scope->spawn(function() {
     echo "child3 coroutine started\n";
     suspend();
+    suspend();
+    suspend();
     echo "child3 should not complete\n";
     return "child3_result";
 });
@@ -58,6 +62,8 @@ suspend();
 echo "cancelling child1 scope only\n";
 $child1_scope->cancel(new \Async\CancellationException("Child1 cancelled"));
 
+suspend();
+
 // Check isolation - only child1 should be cancelled
 echo "after child1 cancellation:\n";
 echo "parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
@@ -72,41 +78,15 @@ suspend();
 echo "cancelling child3 scope\n";
 $child3_scope->cancel(new \Async\CancellationException("Child3 cancelled"));
 
+// Let cancellation propagate
+suspend();
+
 echo "after child3 cancellation:\n";
 echo "parent scope cancelled: " . ($parent_scope->isCancelled() ? "true" : "false") . "\n";
 echo "child1 scope cancelled: " . ($child1_scope->isCancelled() ? "true" : "false") . "\n";
 echo "child2 scope cancelled: " . ($child2_scope->isCancelled() ? "true" : "false") . "\n";
 echo "child3 scope cancelled: " . ($child3_scope->isCancelled() ? "true" : "false") . "\n";
 
-// Get results - parent and child2 should succeed, child1 and child3 should fail
-try {
-    $result = $parent_coroutine->getResult();
-    echo "parent result: $result\n";
-} catch (\Async\CancellationException $e) {
-    echo "parent unexpectedly cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child1_coroutine->getResult();
-    echo "child1 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "child1 cancelled as expected: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child2_coroutine->getResult();
-    echo "child2 result: $result\n";
-} catch (\Async\CancellationException $e) {
-    echo "child2 unexpectedly cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child3_coroutine->getResult();
-    echo "child3 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "child3 cancelled as expected: " . $e->getMessage() . "\n";
-}
-
 echo "end\n";
 
 ?>
@@ -124,16 +104,12 @@ parent scope cancelled: false
 child1 scope cancelled: true
 child2 scope cancelled: false
 child3 scope cancelled: false
-child2 coroutine completed
 parent coroutine completed
+child2 coroutine completed
 cancelling child3 scope
 after child3 cancellation:
 parent scope cancelled: false
 child1 scope cancelled: true
 child2 scope cancelled: false
 child3 scope cancelled: true
-parent result: parent_result
-child1 cancelled as expected: Child1 cancelled
-child2 result: child2_result
-child3 cancelled as expected: Child3 cancelled
 end
\ No newline at end of file
diff --git a/tests/scope/031-scope_concurrent_cancellation.phpt b/tests/scope/031-scope_concurrent_cancellation.phpt
index 99d58d5..5de1867 100644
--- a/tests/scope/031-scope_concurrent_cancellation.phpt
+++ b/tests/scope/031-scope_concurrent_cancellation.phpt
@@ -5,13 +5,15 @@ Concurrent scope cancellation and race conditions
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
+use function Async\awaitAll;
 
 echo "start\n";
 
 // Create multiple scopes
-$scope1 = new \Async\Scope();
-$scope2 = new \Async\Scope();
-$scope3 = new \Async\Scope();
+$scope1 = new \Async\Scope()->asNotSafely();
+$scope2 = new \Async\Scope()->asNotSafely();
+$scope3 = new \Async\Scope()->asNotSafely();
 
 echo "multiple scopes created\n";
 
@@ -19,6 +21,7 @@ echo "multiple scopes created\n";
 $coroutine1 = $scope1->spawn(function() {
     echo "coroutine1 started\n";
     suspend();
+    suspend();
     echo "coroutine1 should not complete\n";
     return "result1";
 });
@@ -26,6 +29,7 @@ $coroutine1 = $scope1->spawn(function() {
 $coroutine2 = $scope2->spawn(function() {
     echo "coroutine2 started\n";
     suspend();
+    suspend();
     echo "coroutine2 should not complete\n";
     return "result2";
 });
@@ -33,6 +37,7 @@ $coroutine2 = $scope2->spawn(function() {
 $coroutine3 = $scope3->spawn(function() {
     echo "coroutine3 started\n";
     suspend();
+    suspend();
     echo "coroutine3 should not complete\n";
     return "result3";
 });
@@ -45,38 +50,22 @@ suspend();
 // Spawn concurrent cancellation operations
 $canceller1 = spawn(function() use ($scope1) {
     echo "canceller1 starting\n";
-    suspend(); // Small delay
-    echo "canceller1 cancelling scope1\n";
     $scope1->cancel(new \Async\CancellationException("Concurrent cancel 1"));
-    echo "canceller1 finished\n";
 });
 
 $canceller2 = spawn(function() use ($scope2) {
     echo "canceller2 starting\n";
-    suspend(); // Small delay
-    echo "canceller2 cancelling scope2\n";
     $scope2->cancel(new \Async\CancellationException("Concurrent cancel 2"));
-    echo "canceller2 finished\n";
 });
 
 $canceller3 = spawn(function() use ($scope3) {
     echo "canceller3 starting\n";
-    suspend(); // Small delay
-    echo "canceller3 cancelling scope3\n";
     $scope3->cancel(new \Async\CancellationException("Concurrent cancel 3"));
-    echo "canceller3 finished\n";
 });
 
 echo "cancellers spawned\n";
 
-// Let cancellers start and complete
-suspend();
-suspend();
-
-// Check that all cancellers completed
-$canceller1->getResult();
-$canceller2->getResult();
-$canceller3->getResult();
+awaitAll([$canceller1, $canceller2, $canceller3]);
 
 echo "all cancellers completed\n";
 
@@ -88,38 +77,15 @@ echo "scope3 cancelled: " . ($scope3->isCancelled() ? "true" : "false") . "\n";
 // Verify all coroutines are cancelled
 $cancelled_count = 0;
 foreach ([$coroutine1, $coroutine2, $coroutine3] as $index => $coroutine) {
-    try {
-        $result = $coroutine->getResult();
-        echo "coroutine" . ($index + 1) . " unexpectedly succeeded\n";
-    } catch (\Async\CancellationException $e) {
-        echo "coroutine" . ($index + 1) . " cancelled: " . $e->getMessage() . "\n";
+    if($coroutine->isCancelled()) {
         $cancelled_count++;
+        echo "coroutine" . ($index + 1) . " cancelled: " . $coroutine->getException()->getMessage() . "\n";
+    } else {
+        echo "coroutine" . ($index + 1) . " not cancelled\n";
     }
 }
 
 echo "cancelled coroutines: $cancelled_count\n";
-
-// Test rapid cancellation/creation cycle
-echo "testing rapid scope operations\n";
-$rapid_scopes = [];
-for ($i = 0; $i < 5; $i++) {
-    $rapid_scopes[] = new \Async\Scope();
-}
-
-// Cancel them all quickly
-foreach ($rapid_scopes as $index => $scope) {
-    $scope->cancel(new \Async\CancellationException("Rapid cancel $index"));
-}
-
-$rapid_cancelled = 0;
-foreach ($rapid_scopes as $scope) {
-    if ($scope->isCancelled()) {
-        $rapid_cancelled++;
-    }
-}
-
-echo "rapid cancelled scopes: $rapid_cancelled / " . count($rapid_scopes) . "\n";
-
 echo "end\n";
 
 ?>
@@ -134,12 +100,6 @@ cancellers spawned
 canceller1 starting
 canceller2 starting
 canceller3 starting
-canceller1 cancelling scope1
-canceller2 cancelling scope2
-canceller3 cancelling scope3
-canceller1 finished
-canceller2 finished
-canceller3 finished
 all cancellers completed
 scope1 cancelled: true
 scope2 cancelled: true
@@ -148,6 +108,4 @@ coroutine1 cancelled: Concurrent cancel 1
 coroutine2 cancelled: Concurrent cancel 2
 coroutine3 cancelled: Concurrent cancel 3
 cancelled coroutines: 3
-testing rapid scope operations
-rapid cancelled scopes: 5 / 5
 end
\ No newline at end of file
diff --git a/tests/scope/032-scope_mixed_cancellation_sources.phpt b/tests/scope/032-scope_mixed_cancellation_sources.phpt
index 4f7b969..a2426d9 100644
--- a/tests/scope/032-scope_mixed_cancellation_sources.phpt
+++ b/tests/scope/032-scope_mixed_cancellation_sources.phpt
@@ -5,15 +5,17 @@ Mixed cancellation sources: scope cancellation + individual coroutine cancellati
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
-$scope = new \Async\Scope();
+$scope = new \Async\Scope()->asNotSafely();
 
 // Spawn multiple coroutines in the same scope
 $coroutine1 = $scope->spawn(function() {
     echo "coroutine1 started\n";
     suspend();
+    suspend();
     echo "coroutine1 should not complete\n";
     return "result1";
 });
@@ -21,6 +23,7 @@ $coroutine1 = $scope->spawn(function() {
 $coroutine2 = $scope->spawn(function() {
     echo "coroutine2 started\n";
     suspend();
+    suspend();
     echo "coroutine2 should not complete\n";
     return "result2";
 });
@@ -28,6 +31,7 @@ $coroutine2 = $scope->spawn(function() {
 $coroutine3 = $scope->spawn(function() {
     echo "coroutine3 started\n";
     suspend();
+    suspend();
     echo "coroutine3 should not complete\n";
     return "result3";
 });
@@ -41,6 +45,9 @@ suspend();
 echo "cancelling coroutine2 individually\n";
 $coroutine2->cancel(new \Async\CancellationException("Individual cancel"));
 
+// Let cancellation propagate
+suspend();
+
 // Check states after individual cancellation
 echo "after individual cancel:\n";
 echo "scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
@@ -52,6 +59,8 @@ echo "coroutine3 cancelled: " . ($coroutine3->isCancelled() ? "true" : "false")
 echo "cancelling entire scope\n";
 $scope->cancel(new \Async\CancellationException("Scope cancel"));
 
+suspend(); // Let cancellation propagate
+
 // Check states after scope cancellation
 echo "after scope cancel:\n";
 echo "scope cancelled: " . ($scope->isCancelled() ? "true" : "false") . "\n";
@@ -59,65 +68,6 @@ echo "coroutine1 cancelled: " . ($coroutine1->isCancelled() ? "true" : "false")
 echo "coroutine2 cancelled: " . ($coroutine2->isCancelled() ? "true" : "false") . "\n";
 echo "coroutine3 cancelled: " . ($coroutine3->isCancelled() ? "true" : "false") . "\n";
 
-// Check results and exception messages
-try {
-    $result = $coroutine1->getResult();
-    echo "coroutine1 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "coroutine1 cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $coroutine2->getResult();
-    echo "coroutine2 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "coroutine2 cancelled: " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $coroutine3->getResult();
-    echo "coroutine3 should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "coroutine3 cancelled: " . $e->getMessage() . "\n";
-}
-
-// Test protected blocks with mixed cancellation
-echo "testing protected blocks with mixed cancellation\n";
-
-$protected_scope = new \Async\Scope();
-$protected_coroutine = $protected_scope->spawn(function() {
-    echo "protected coroutine started\n";
-    
-    \Async\protect(function() {
-        echo "inside protected block\n";
-        suspend();
-        echo "protected block completed\n";
-    });
-    
-    echo "after protected block\n";
-    return "protected_result";
-});
-
-suspend(); // Enter protected block
-
-// Try individual cancellation during protection
-echo "cancelling protected coroutine individually\n";
-$protected_coroutine->cancel(new \Async\CancellationException("Protected individual cancel"));
-
-// Try scope cancellation during protection
-echo "cancelling protected scope\n";
-$protected_scope->cancel(new \Async\CancellationException("Protected scope cancel"));
-
-suspend(); // Complete protected block
-
-// Check which cancellation takes effect
-try {
-    $result = $protected_coroutine->getResult();
-    echo "protected coroutine should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "protected coroutine cancelled: " . $e->getMessage() . "\n";
-}
-
 echo "end\n";
 
 ?>
@@ -139,15 +89,4 @@ scope cancelled: true
 coroutine1 cancelled: true
 coroutine2 cancelled: true
 coroutine3 cancelled: true
-coroutine1 cancelled: Scope cancel
-coroutine2 cancelled: Individual cancel
-coroutine3 cancelled: Scope cancel
-testing protected blocks with mixed cancellation
-protected coroutine started
-inside protected block
-cancelling protected coroutine individually
-cancelling protected scope
-protected block completed
-after protected block
-protected coroutine cancelled: %s
 end
\ No newline at end of file
diff --git a/tests/scope/033-scope_cancellation_finally_handlers.phpt b/tests/scope/033-scope_cancellation_finally_handlers.phpt
index eaad162..a423ed2 100644
--- a/tests/scope/033-scope_cancellation_finally_handlers.phpt
+++ b/tests/scope/033-scope_cancellation_finally_handlers.phpt
@@ -5,6 +5,7 @@ Scope cancellation with finally handlers execution
 
 use function Async\spawn;
 use function Async\suspend;
+use function Async\await;
 
 echo "start\n";
 
@@ -14,7 +15,7 @@ $scope = new \Async\Scope();
 $coroutine_with_finally = $scope->spawn(function() {
     echo "coroutine with finally started\n";
     
-    $coroutine = \Async\Coroutine::getCurrent();
+    $coroutine = \Async\currentCoroutine();
     
     $coroutine->onFinally(function() {
         echo "finally handler 1 executed\n";
@@ -41,7 +42,7 @@ $child_scope = \Async\Scope::inherit($scope);
 $child_coroutine = $child_scope->spawn(function() {
     echo "child coroutine started\n";
     
-    $coroutine = \Async\Coroutine::getCurrent();
+    $coroutine = \Async\currentCoroutine();
     
     $coroutine->onFinally(function() {
         echo "child finally handler executed\n";
@@ -68,66 +69,8 @@ echo "scope finally handler added\n";
 echo "cancelling parent scope\n";
 $scope->cancel(new \Async\CancellationException("Scope cancelled with finally"));
 
-// Check execution order and exception handling
-try {
-    $result = $coroutine_with_finally->getResult();
-    echo "main coroutine should not succeed\n";
-} catch (\Async\CompositeException $e) {
-    echo "main coroutine CompositeException with " . count($e->getErrors()) . " errors\n";
-    foreach ($e->getErrors() as $error) {
-        echo "composite error: " . get_class($error) . ": " . $error->getMessage() . "\n";
-    }
-} catch (\Async\CancellationException $e) {
-    echo "main coroutine cancelled: " . $e->getMessage() . "\n";
-} catch (Throwable $e) {
-    echo "main coroutine unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
-}
-
-try {
-    $result = $child_coroutine->getResult();
-    echo "child coroutine should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "child coroutine cancelled: " . $e->getMessage() . "\n";
-} catch (Throwable $e) {
-    echo "child coroutine unexpected: " . get_class($e) . ": " . $e->getMessage() . "\n";
-}
-
-// Test finally handler order in cancelled scope hierarchy
-echo "testing finally handler order in hierarchy\n";
-
-$parent_scope = new \Async\Scope();
-$child_scope2 = \Async\Scope::inherit($parent_scope);
-
-$parent_scope->onFinally(function() {
-    echo "parent scope finally\n";
-});
-
-$child_scope2->onFinally(function() {
-    echo "child scope finally\n";
-});
-
-$hierarchy_coroutine = $child_scope2->spawn(function() {
-    echo "hierarchy coroutine started\n";
-    
-    \Async\Coroutine::getCurrent()->onFinally(function() {
-        echo "hierarchy coroutine finally\n";
-    });
-    
-    suspend();
-    return "hierarchy_result";
-});
-
-suspend(); // Let it start
-
-echo "cancelling parent scope in hierarchy\n";
-$parent_scope->cancel(new \Async\CancellationException("Hierarchy cancel"));
-
-try {
-    $result = $hierarchy_coroutine->getResult();
-    echo "hierarchy should not succeed\n";
-} catch (\Async\CancellationException $e) {
-    echo "hierarchy cancelled: " . $e->getMessage() . "\n";
-}
+// Let cancellation propagate
+suspend();
 
 echo "end\n";
 
@@ -139,18 +82,11 @@ coroutine with finally started
 child coroutine started
 scope finally handler added
 cancelling parent scope
-finally handler 3 executed
-finally handler 2 executed
 finally handler 1 executed
+finally handler 2 executed
+finally handler 3 executed
 child finally handler executed
 scope finally handler executed
-main coroutine %s: %s
-child coroutine cancelled: Scope cancelled with finally
-testing finally handler order in hierarchy
-hierarchy coroutine started
-cancelling parent scope in hierarchy
-hierarchy coroutine finally
-child scope finally
-parent scope finally
-hierarchy cancelled: Hierarchy cancel
-end
\ No newline at end of file
+
+Fatal error: Uncaught RuntimeException:%s
+%a
\ No newline at end of file
diff --git a/tests/scope/034-scope_cancellation_double_error.phpt b/tests/scope/034-scope_cancellation_double_error.phpt
new file mode 100644
index 0000000..b34bc47
--- /dev/null
+++ b/tests/scope/034-scope_cancellation_double_error.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Scope cancellation with finally handlers execution
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+use function Async\await;
+
+echo "start\n";
+
+$scope = new \Async\Scope();
+
+// Spawn coroutine with finally handlers
+$coroutine_with_finally = $scope->spawn(function() {
+    echo "coroutine with finally started\n";
+    
+    $coroutine = \Async\currentCoroutine();
+
+    $coroutine->onFinally(function() {
+        echo "finally handler 3 executed\n";
+        // This might throw during cancellation cleanup
+        throw new \RuntimeException("Finally handler error");
+    });
+    
+    suspend();
+    echo "coroutine should not complete normally\n";
+    return "normal_result";
+});
+
+// Spawn coroutine in child scope with finally handlers
+$child_scope = \Async\Scope::inherit($scope);
+$child_coroutine = $child_scope->spawn(function() {
+    echo "child coroutine started\n";
+
+    $coroutine = \Async\currentCoroutine();
+    some_function();
+
+    $coroutine->onFinally(function() {
+        echo "child finally handler executed\n";
+    });
+
+    suspend();
+    echo "child should not complete\n";
+    return "child_result";
+});
+
+echo "coroutines with finally handlers spawned\n";
+
+// Let coroutines start
+suspend();
+
+// Add scope-level finally handler
+$scope->onFinally(function() {
+    echo "scope finally handler executed\n";
+});
+
+echo "scope finally handler added\n";
+
+// Cancel the parent scope - should trigger all finally handlers
+echo "cancelling parent scope\n";
+$scope->cancel(new \Async\CancellationException("Scope cancelled with finally"));
+
+// Let cancellation propagate
+suspend();
+
+echo "end\n";
+
+?>
+--EXPECTF--
+start
+coroutines with finally handlers spawned
+coroutine with finally started
+child coroutine started
+scope finally handler added
+cancelling parent scope
+finally handler 3 executed
+finally handler 2 executed
+finally handler 1 executed
+child finally handler executed
+scope finally handler executed
+main coroutine %s: %s
+child coroutine cancelled: Scope cancelled with finally
+testing finally handler order in hierarchy
+hierarchy coroutine started
+cancelling parent scope in hierarchy
+hierarchy coroutine finally
+child scope finally
+parent scope finally
+hierarchy cancelled: Hierarchy cancel
+end
\ No newline at end of file

From ceeacf343f1351d220f7e76a3dcadb76be3216d9 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 20:31:20 +0300
Subject: [PATCH 48/53] #9: * fix scope_try_to_dispose Fixed cyclic Scope
 release from children due to missing reentrancy handling. * Fixed an issue
 with the set_previous_exception function caused by an extra reference
 deletion.

---
 coroutine.c                                   | 26 ++++++++++++++-----
 scheduler.c                                   |  6 -----
 scope.c                                       | 11 ++++++++
 .../034-scope_cancellation_double_error.phpt  |  8 ------
 4 files changed, 30 insertions(+), 21 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index 340dc3f..8747719 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -379,12 +379,11 @@ static void finally_handlers_iterator_dtor(zend_async_iterator_t *zend_iterator)
 	}
 
 	finally_handlers_context_t *context = iterator->extended_data;
+	async_scope_t *scope = (async_scope_t *) context->scope;
+	context->scope = NULL;
 
 	// Throw CompositeException if any exceptions were collected
 	if (context->composite_exception != NULL) {
-
-		async_scope_t *scope = (async_scope_t *) context->scope;
-
 		if (ZEND_ASYNC_SCOPE_CATCH(
 			&scope->scope,
 			&context->coroutine->coroutine,
@@ -394,13 +393,13 @@ static void finally_handlers_iterator_dtor(zend_async_iterator_t *zend_iterator)
 			ZEND_ASYNC_SCOPE_IS_DISPOSE_SAFELY(&scope->scope)
 		)) {
 			OBJ_RELEASE(context->composite_exception);
-		} else {
-			async_rethrow_exception(context->composite_exception);
+			context->composite_exception = NULL;
 		}
-
-		context->composite_exception = NULL;
 	}
 
+	zend_object * composite_exception = context->composite_exception;
+	context->composite_exception = NULL;
+
 	if (context->dtor != NULL) {
 		context->dtor(context);
 		context->dtor = NULL;
@@ -410,6 +409,18 @@ static void finally_handlers_iterator_dtor(zend_async_iterator_t *zend_iterator)
 	efree(context);
 	iterator->extended_data = NULL;
 
+	if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) > 1) {
+		ZEND_ASYNC_EVENT_DEL_REF(&scope->scope.event);
+
+		if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) == 1) {
+			scope->scope.try_to_dispose(&scope->scope);
+		}
+	}
+
+	if (composite_exception != NULL) {
+		async_rethrow_exception(composite_exception);
+	}
+
 	//
 	// If everything is correct,
 	// the Scope will destroy itself as soon as the coroutine created within it completes execution.
@@ -453,6 +464,7 @@ bool async_call_finally_handlers(HashTable *finally_handlers, finally_handlers_c
 	iterator->extended_data = context;
 	iterator->extended_dtor = finally_handlers_iterator_dtor;
 	async_iterator_run_in_coroutine(iterator, priority);
+	ZEND_ASYNC_EVENT_ADD_REF(&child_scope->event);
 
 	if (UNEXPECTED(EG(exception))) {
 		return false;
diff --git a/scheduler.c b/scheduler.c
index d613dab..46db144 100644
--- a/scheduler.c
+++ b/scheduler.c
@@ -471,7 +471,6 @@ void start_graceful_shutdown(void)
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		zend_exception_set_previous(EG(exception), ZEND_ASYNC_EXIT_EXCEPTION);
-		GC_DELREF(ZEND_ASYNC_EXIT_EXCEPTION);
 		ZEND_ASYNC_EXIT_EXCEPTION = EG(exception);
 		GC_ADDREF(EG(exception));
 		zend_clear_exception();
@@ -484,7 +483,6 @@ static void finally_shutdown(void)
 {
 	if (ZEND_ASYNC_EXIT_EXCEPTION != NULL && EG(exception) != NULL) {
 		zend_exception_set_previous(EG(exception), ZEND_ASYNC_EXIT_EXCEPTION);
-		GC_DELREF(ZEND_ASYNC_EXIT_EXCEPTION);
 		ZEND_ASYNC_EXIT_EXCEPTION = EG(exception);
 		GC_ADDREF(EG(exception));
 		zend_clear_exception();
@@ -498,7 +496,6 @@ static void finally_shutdown(void)
 	if (UNEXPECTED(EG(exception))) {
 		if (ZEND_ASYNC_EXIT_EXCEPTION != NULL) {
 			zend_exception_set_previous(EG(exception), ZEND_ASYNC_EXIT_EXCEPTION);
-			GC_DELREF(ZEND_ASYNC_EXIT_EXCEPTION);
 			ZEND_ASYNC_EXIT_EXCEPTION = EG(exception);
 			GC_ADDREF(EG(exception));
 		}
@@ -709,7 +706,6 @@ void async_scheduler_main_coroutine_suspend(void)
 	//
 	if (EG(exception) != NULL && exit_exception != NULL) {
 		zend_exception_set_previous(EG(exception), exit_exception);
-		GC_DELREF(exit_exception);
 	} else if (exit_exception != NULL) {
 		async_rethrow_exception(exit_exception);
 	}
@@ -855,7 +851,6 @@ void async_scheduler_coroutine_suspend(zend_fiber_transfer *transfer)
 
 		if (ZEND_ASYNC_EXIT_EXCEPTION != NULL) {
 			zend_exception_set_previous(exception, ZEND_ASYNC_EXIT_EXCEPTION);
-			GC_DELREF(ZEND_ASYNC_EXIT_EXCEPTION);
 			ZEND_ASYNC_EXIT_EXCEPTION = exception;
 		} else {
 			ZEND_ASYNC_EXIT_EXCEPTION = exception;
@@ -982,7 +977,6 @@ void async_scheduler_main_loop(void)
 
 	if (EG(exception) != NULL && exit_exception != NULL) {
 		zend_exception_set_previous(EG(exception), exit_exception);
-		GC_DELREF(exit_exception);
 		exit_exception = EG(exception);
 		GC_ADDREF(exit_exception);
 		zend_clear_exception();
diff --git a/scope.c b/scope.c
index 56260ea..66e77e4 100644
--- a/scope.c
+++ b/scope.c
@@ -990,10 +990,16 @@ static bool scope_try_to_dispose(zend_async_scope_t *scope)
 {
 	async_scope_t *async_scope = (async_scope_t *) scope;
 
+	if (ZEND_ASYNC_SCOPE_IS_DISPOSED(scope)) {
+		return true;
+	}
+
 	if (false == SCOPE_CAN_BE_DISPOSED(async_scope)) {
 		return false;
 	}
 
+	ZEND_ASYNC_SCOPE_SET_DISPOSED(scope);
+
 	// Dispose all child scopes
 	for (uint32_t i = 0; i < async_scope->scope.scopes.length; ++i) {
 		async_scope_t *child_scope = (async_scope_t *) async_scope->scope.scopes.data[i];
@@ -1111,6 +1117,7 @@ static void scope_dispose(zend_async_event_t *scope_event)
 	}
 
 	if (scope->scope.scope_object != NULL) {
+		fprintf(stderr, "unlink %p\n", scope->scope.scope_object);
 		((async_scope_object_t *) scope->scope.scope_object)->scope = NULL;
 		scope->scope.scope_object = NULL;
 	}
@@ -1154,6 +1161,7 @@ zend_async_scope_t * async_new_scope(zend_async_scope_t * parent_scope, const bo
 
 	if (with_zend_object) {
 		scope_object = ZEND_OBJECT_ALLOC_EX(sizeof(async_scope_object_t), async_ce_scope);
+		fprintf(stderr, "regular new scope_object %p\n", scope_object);
 
 		zend_object_std_init(&scope_object->std, async_ce_scope);
 		object_properties_init(&scope_object->std, async_ce_scope);
@@ -1235,6 +1243,8 @@ static void scope_destroy(zend_object *object)
 	scope_object->scope = NULL;
 	scope->scope.scope_object = NULL;
 
+	fprintf(stderr, "scope_destroy %p\n", object);
+
 	// At this point, the user-defined Scope object is about to be destroyed.
 	// This means we are obligated to cancel the Scope and all its child Scopes along with their coroutines.
 	// However, the Scope itself will not be destroyed.
@@ -1436,6 +1446,7 @@ static zend_always_inline bool try_to_handle_exception(
 		// The PHP Scope object might already be destroyed by the time the internal Scope still exists.
 		// To normalize this situation, we’ll create a fake Scope object that will serve as a bridge.
 		scope_object = ZEND_OBJECT_ALLOC_EX(sizeof(async_scope_object_t), async_ce_scope);
+		fprintf(stderr, "new scope_object %p\n", scope_object);
 		zend_object_std_init(&scope_object->std, async_ce_scope);
 		object_properties_init(&scope_object->std, async_ce_scope);
 
diff --git a/tests/scope/034-scope_cancellation_double_error.phpt b/tests/scope/034-scope_cancellation_double_error.phpt
index b34bc47..99a7a0a 100644
--- a/tests/scope/034-scope_cancellation_double_error.phpt
+++ b/tests/scope/034-scope_cancellation_double_error.phpt
@@ -35,14 +35,6 @@ $child_coroutine = $child_scope->spawn(function() {
 
     $coroutine = \Async\currentCoroutine();
     some_function();
-
-    $coroutine->onFinally(function() {
-        echo "child finally handler executed\n";
-    });
-
-    suspend();
-    echo "child should not complete\n";
-    return "child_result";
 });
 
 echo "coroutines with finally handlers spawned\n";

From 6fae1beaff946b48adb86e6d4a83a4371563e2d5 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Wed, 9 Jul 2025 20:33:13 +0300
Subject: [PATCH 49/53] #9: * clean fprintf

---
 scope.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/scope.c b/scope.c
index 66e77e4..bc69dbb 100644
--- a/scope.c
+++ b/scope.c
@@ -1117,7 +1117,6 @@ static void scope_dispose(zend_async_event_t *scope_event)
 	}
 
 	if (scope->scope.scope_object != NULL) {
-		fprintf(stderr, "unlink %p\n", scope->scope.scope_object);
 		((async_scope_object_t *) scope->scope.scope_object)->scope = NULL;
 		scope->scope.scope_object = NULL;
 	}
@@ -1161,7 +1160,6 @@ zend_async_scope_t * async_new_scope(zend_async_scope_t * parent_scope, const bo
 
 	if (with_zend_object) {
 		scope_object = ZEND_OBJECT_ALLOC_EX(sizeof(async_scope_object_t), async_ce_scope);
-		fprintf(stderr, "regular new scope_object %p\n", scope_object);
 
 		zend_object_std_init(&scope_object->std, async_ce_scope);
 		object_properties_init(&scope_object->std, async_ce_scope);
@@ -1243,8 +1241,6 @@ static void scope_destroy(zend_object *object)
 	scope_object->scope = NULL;
 	scope->scope.scope_object = NULL;
 
-	fprintf(stderr, "scope_destroy %p\n", object);
-
 	// At this point, the user-defined Scope object is about to be destroyed.
 	// This means we are obligated to cancel the Scope and all its child Scopes along with their coroutines.
 	// However, the Scope itself will not be destroyed.
@@ -1446,7 +1442,6 @@ static zend_always_inline bool try_to_handle_exception(
 		// The PHP Scope object might already be destroyed by the time the internal Scope still exists.
 		// To normalize this situation, we’ll create a fake Scope object that will serve as a bridge.
 		scope_object = ZEND_OBJECT_ALLOC_EX(sizeof(async_scope_object_t), async_ce_scope);
-		fprintf(stderr, "new scope_object %p\n", scope_object);
 		zend_object_std_init(&scope_object->std, async_ce_scope);
 		object_properties_init(&scope_object->std, async_ce_scope);
 

From f521165249e04046d99c46e6ade75a73339c253f Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Thu, 10 Jul 2025 08:57:29 +0300
Subject: [PATCH 50/53] #9: * Fixed a memory leak issue in Scope + onFinally.

---
 coroutine.c | 13 ++++++++++---
 scope.c     | 14 +++++---------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/coroutine.c b/coroutine.c
index 8747719..07c3529 100644
--- a/coroutine.c
+++ b/coroutine.c
@@ -409,10 +409,10 @@ static void finally_handlers_iterator_dtor(zend_async_iterator_t *zend_iterator)
 	efree(context);
 	iterator->extended_data = NULL;
 
-	if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) > 1) {
+	if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) > 0) {
 		ZEND_ASYNC_EVENT_DEL_REF(&scope->scope.event);
 
-		if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) == 1) {
+		if (ZEND_ASYNC_EVENT_REF(&scope->scope.event) <= 1) {
 			scope->scope.try_to_dispose(&scope->scope);
 		}
 	}
@@ -464,7 +464,14 @@ bool async_call_finally_handlers(HashTable *finally_handlers, finally_handlers_c
 	iterator->extended_data = context;
 	iterator->extended_dtor = finally_handlers_iterator_dtor;
 	async_iterator_run_in_coroutine(iterator, priority);
-	ZEND_ASYNC_EVENT_ADD_REF(&child_scope->event);
+
+	//
+	// We retain ownership of the Scope in order to be able to handle exceptions from the Finally handlers.
+	// example: finally_handlers_iterator_dtor
+	// If the onFinally handlers throw an exception, it will end up in the Scope,
+	// so it’s important that the Scope is not destroyed before that moment.
+	//
+	ZEND_ASYNC_EVENT_ADD_REF(&context->scope->event);
 
 	if (UNEXPECTED(EG(exception))) {
 		return false;
diff --git a/scope.c b/scope.c
index bc69dbb..8d57cc2 100644
--- a/scope.c
+++ b/scope.c
@@ -990,7 +990,7 @@ static bool scope_try_to_dispose(zend_async_scope_t *scope)
 {
 	async_scope_t *async_scope = (async_scope_t *) scope;
 
-	if (ZEND_ASYNC_SCOPE_IS_DISPOSED(scope)) {
+	if (ZEND_ASYNC_SCOPE_IS_DISPOSING(scope)) {
 		return true;
 	}
 
@@ -998,18 +998,21 @@ static bool scope_try_to_dispose(zend_async_scope_t *scope)
 		return false;
 	}
 
-	ZEND_ASYNC_SCOPE_SET_DISPOSED(scope);
+	ZEND_ASYNC_SCOPE_SET_DISPOSING(scope);
 
 	// Dispose all child scopes
 	for (uint32_t i = 0; i < async_scope->scope.scopes.length; ++i) {
 		async_scope_t *child_scope = (async_scope_t *) async_scope->scope.scopes.data[i];
 		child_scope->scope.event.dispose(&child_scope->scope.event);
 		if (UNEXPECTED(EG(exception))) {
+			ZEND_ASYNC_SCOPE_CLR_DISPOSING(scope);
 			// If an exception occurs during child scope disposal, we stop further processing
 			return false;
 		}
 	}
 
+	ZEND_ASYNC_SCOPE_CLR_DISPOSING(scope);
+
 	// Dispose the scope
 	async_scope->scope.event.dispose(&async_scope->scope.event);
 	return true;
@@ -1532,12 +1535,6 @@ static zend_always_inline bool try_to_handle_exception(
 
 static void async_scope_call_finally_handlers_dtor(finally_handlers_context_t *context)
 {
-	zend_async_scope_t *scope = context->target;
-	if (ZEND_ASYNC_EVENT_REF(&scope->event) > 0) {
-		ZEND_ASYNC_EVENT_DEL_REF(&scope->event);
-	}
-
-	scope->try_to_dispose(scope);
 	context->target = NULL;
 }
 
@@ -1566,7 +1563,6 @@ static bool async_scope_call_finally_handlers(async_scope_t *scope)
 		zend_array_destroy(finally_handlers);
 		return false;
 	} else {
-		ZEND_ASYNC_EVENT_ADD_REF(&scope->scope.event);
 		return true;
 	}
 }
\ No newline at end of file

From f5dc529122217031d77991d15636774bb24b9f68 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Thu, 10 Jul 2025 09:10:05 +0300
Subject: [PATCH 51/53] #9: * fix 034-scope_cancellation_double_error

---
 .../034-scope_cancellation_double_error.phpt  | 31 +++++++++----------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/tests/scope/034-scope_cancellation_double_error.phpt b/tests/scope/034-scope_cancellation_double_error.phpt
index 99a7a0a..5a4f282 100644
--- a/tests/scope/034-scope_cancellation_double_error.phpt
+++ b/tests/scope/034-scope_cancellation_double_error.phpt
@@ -1,5 +1,7 @@
 --TEST--
-Scope cancellation with finally handlers execution
+Scope cancellation with double-exception case in finally handlers execution
+--DESCRIPTION--
+This test triggers a double-exception case: first in the coroutine, and then in the onFinally handler.
 --FILE--
 <?php
 
@@ -64,20 +66,15 @@ start
 coroutines with finally handlers spawned
 coroutine with finally started
 child coroutine started
-scope finally handler added
-cancelling parent scope
 finally handler 3 executed
-finally handler 2 executed
-finally handler 1 executed
-child finally handler executed
-scope finally handler executed
-main coroutine %s: %s
-child coroutine cancelled: Scope cancelled with finally
-testing finally handler order in hierarchy
-hierarchy coroutine started
-cancelling parent scope in hierarchy
-hierarchy coroutine finally
-child scope finally
-parent scope finally
-hierarchy cancelled: Hierarchy cancel
-end
\ No newline at end of file
+
+Fatal error: Uncaught Error: Call to undefined function some_function() in %s:%d
+Stack trace:
+#0 [internal function]: {closure:%s:%d}()
+#1 {main}
+
+Next RuntimeException: Finally handler error in %s:%d
+Stack trace:
+#0 [internal function]: {closure:{closure:%s:%d}:%d}(Object(Async\Coroutine))
+#1 {main}
+  thrown in %s on line %d
\ No newline at end of file

From fc258cbfdd16c5558b87be0fe5186c84b634e929 Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Thu, 10 Jul 2025 09:15:56 +0300
Subject: [PATCH 52/53] #9: * fix coroutines tests

---
 tests/coroutine/006-coroutine_cancel_basic.phpt      | 2 ++
 tests/coroutine/028-coroutine_state_transitions.phpt | 3 +++
 2 files changed, 5 insertions(+)

diff --git a/tests/coroutine/006-coroutine_cancel_basic.phpt b/tests/coroutine/006-coroutine_cancel_basic.phpt
index 9ecbcd1..241f916 100644
--- a/tests/coroutine/006-coroutine_cancel_basic.phpt
+++ b/tests/coroutine/006-coroutine_cancel_basic.phpt
@@ -14,6 +14,7 @@ $coroutine = spawn(function() {
 $cancellation = new CancellationException("test cancellation");
 $coroutine->cancel($cancellation);
 
+var_dump($coroutine->isCancellationRequested());
 var_dump($coroutine->isCancelled());
 
 try {
@@ -25,4 +26,5 @@ try {
 ?>
 --EXPECT--
 bool(true)
+bool(false)
 Caught: test cancellation
\ No newline at end of file
diff --git a/tests/coroutine/028-coroutine_state_transitions.phpt b/tests/coroutine/028-coroutine_state_transitions.phpt
index 1688ad9..8c689c2 100644
--- a/tests/coroutine/028-coroutine_state_transitions.phpt
+++ b/tests/coroutine/028-coroutine_state_transitions.phpt
@@ -95,6 +95,9 @@ echo "before cancel request - isCancelled: " . ($cancel_request_coroutine->isCan
 $cancel_request_coroutine->cancel(new \Async\CancellationException("Test cancellation"));
 
 echo "after cancel request - isCancellationRequested: " . ($cancel_request_coroutine->isCancellationRequested() ? "true" : "false") . "\n";
+
+suspend(); // Let cancellation propagate
+
 echo "after cancel request - isCancelled: " . ($cancel_request_coroutine->isCancelled() ? "true" : "false") . "\n";
 
 echo "end\n";

From a0958c19cd9149f7d9b88ece2526131dd2a1fd3f Mon Sep 17 00:00:00 2001
From: Edmond <1571649+EdmondDantes@users.noreply.github.com>
Date: Thu, 10 Jul 2025 10:06:36 +0300
Subject: [PATCH 53/53] #9: * fix spawn tests

---
 scope.c                                        | 2 +-
 tests/spawn/017-spawn_closed_scope_error.phpt  | 4 ++--
 tests/spawn/019-spawn_scope_provider_null.phpt | 4 +++-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/scope.c b/scope.c
index 8d57cc2..6458363 100644
--- a/scope.c
+++ b/scope.c
@@ -229,7 +229,7 @@ METHOD(spawn)
 	}
 
 	if (UNEXPECTED(ZEND_ASYNC_SCOPE_IS_CLOSED(&scope_object->scope->scope))) {
-		async_throw_error("Cannot spawn coroutine in a closed scope");
+		async_throw_error("Cannot spawn a coroutine in a closed scope");
 		RETURN_THROWS();
 	}
 
diff --git a/tests/spawn/017-spawn_closed_scope_error.phpt b/tests/spawn/017-spawn_closed_scope_error.phpt
index 5e3b3e1..9dad2c5 100644
--- a/tests/spawn/017-spawn_closed_scope_error.phpt
+++ b/tests/spawn/017-spawn_closed_scope_error.phpt
@@ -20,7 +20,7 @@ try {
         return "test";
     });
     echo "ERROR: Should have thrown exception\n";
-} catch (Error $e) {
+} catch (Async\AsyncException $e) {
     echo "Caught expected error: " . $e->getMessage() . "\n";
 } catch (Throwable $e) {
     echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
@@ -40,7 +40,7 @@ try {
         return "test2";
     });
     echo "ERROR: Should have thrown exception\n";
-} catch (Error $e) {
+} catch (Async\AsyncException $e) {
     echo "Caught expected error for safely disposed: " . $e->getMessage() . "\n";
 } catch (Throwable $e) {
     echo "Caught exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
diff --git a/tests/spawn/019-spawn_scope_provider_null.phpt b/tests/spawn/019-spawn_scope_provider_null.phpt
index 2a2ab61..cee9d40 100644
--- a/tests/spawn/019-spawn_scope_provider_null.phpt
+++ b/tests/spawn/019-spawn_scope_provider_null.phpt
@@ -4,6 +4,7 @@ spawnWith() - scope provider returns null (valid case)
 <?php
 
 use function Async\spawnWith;
+use function Async\await;
 
 echo "start\n";
 
@@ -19,7 +20,8 @@ try {
     $coroutine = spawnWith(new NullScopeProvider(), function() {
         return "success";
     });
-    echo "Null provider result: " . $coroutine->getResult() . "\n";
+
+    echo "Null provider result: " . await($coroutine) . "\n";
 } catch (Throwable $e) {
     echo "Unexpected exception: " . get_class($e) . ": " . $e->getMessage() . "\n";
 }