Async core

Zend/tests/async/continuation_switch.phpt

@@ -0,0 +1,26 @@
+--TEST--
+Async\Continuation: switchTo runs the body on its own stack and returns to the switcher
+--FILE--
+<?php
+$a = Async\Continuation::create(function (): void {
+    echo "  A\n";
+});
+
+$b = Async\Continuation::create(function (): void {
+    $sum = 0;
+    for ($i = 0; $i < 1000; $i++) {
+        $sum += $i;   // real VM work on the continuation's own stack
+    }
+    echo "  B sum=$sum\n";
+});
+
+echo "before\n";
+$a->switchTo();
+$b->switchTo();
+echo "after\n";
+?>
+--EXPECT--
+before
+  A
+  B sum=499500
+after

Zend/tests/async/continuation_symmetric_nested.phpt

@@ -0,0 +1,25 @@
+--TEST--
+Async\Continuation: a coroutine switches into another mid-run; the inner returns to the outer (symmetric)
+--FILE--
+<?php
+$b = Async\Continuation::create(function (): void {
+    echo "  B: runs to completion\n";
+    // returns -> control goes back to B's switcher (A)
+});
+
+$a = Async\Continuation::create(function () use ($b): void {
+    echo "  A: 1\n";
+    $b->switchTo();            // A -> B mid-run; B completes -> back to A
+    echo "  A: 2 (after B)\n";
+});
+
+echo "main -> A\n";
+$a->switchTo();               // main -> A -> B(done) -> A(done) -> main
+echo "main: done\n";
+?>
+--EXPECT--
+main -> A
+  A: 1
+  B: runs to completion
+  A: 2 (after B)
+main: done

Zend/tests/async/continuation_value_exception.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Async\Continuation: switchTo() returns the body's value and re-raises its exception
+--FILE--
+<?php
+var_dump(Async\Continuation::create(fn () => 42)->switchTo());
+var_dump(Async\Continuation::create(fn () => "hi")->switchTo());
+
+try {
+    Async\Continuation::create(function () {
+        throw new RuntimeException("boom");
+    })->switchTo();
+} catch (RuntimeException $e) {
+    echo "caught: ", $e->getMessage(), "\n";
+}
+
+echo "survived\n";
+?>
+--EXPECT--
+int(42)
+string(2) "hi"
+caught: boom
+survived

Zend/tests/async/fiber_lowlevel_null.phpt

@@ -0,0 +1,35 @@
+--TEST--
+interceptFiber returning null keeps the fiber on the low-level path
+--FILE--
+<?php
+Async\SchedulerHook::register('test', new class extends Async\AbstractScheduler {
+    public function interceptFiber(Fiber $fiber): ?object {
+        echo "intercept: null\n";
+        return null;
+    }
+    public function enqueue(object $coroutine): bool { return true; }
+    public function suspend(bool $fromMain, bool $isBailout): ?object {
+        // Never called for the low-level fiber itself; the engine invokes it
+        // for the after-main handover (script end, then after destructors).
+        echo "suspend(fromMain: ", var_export($fromMain, true), ")\n";
+        return null;
+    }
+});
+
+// A low-level fiber behaves exactly as classic Fiber even with a scheduler.
+$fiber = new Fiber(function (int $x): int {
+    $y = Fiber::suspend($x + 1);
+    return $y * 10;
+});
+
+var_dump($fiber->start(5));
+var_dump($fiber->resume(4));
+var_dump($fiber->getReturn());
+?>
+--EXPECT--
+intercept: null
+int(6)
+NULL
+int(40)
+suspend(fromMain: true)
+suspend(fromMain: true)

Zend/tests/async/fiber_managed_after_main.phpt

@@ -0,0 +1,46 @@
+--TEST--
+After-main handover runs deferred managed coroutines; abandoned ones die cleanly
+--FILE--
+<?php
+Async\SchedulerHook::register('test', new class extends Async\AbstractScheduler {
+    public SplQueue $queue;
+    public function __construct() { $this->queue = new SplQueue(); }
+    public function interceptFiber(Fiber $fiber): ?object {
+        return new class($fiber) {
+            public function __construct(public readonly Fiber $fiber) {}
+        };
+    }
+    public function enqueue(object $coroutine): bool {
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function suspend(bool $fromMain, bool $isBailout): ?object {
+        // This scheduler defers everything: nothing runs until after main.
+        if (!$fromMain) {
+            return null;
+        }
+        while (!$this->queue->isEmpty()) {
+            $fiber = $this->queue->dequeue()->fiber;
+            $fiber->isStarted() ? $fiber->resume() : $fiber->start();
+        }
+        return null;
+    }
+});
+
+$fiber = new Fiber(function (): void {
+    echo "ran after main\n";
+    Fiber::suspend();
+    echo "never printed: nobody resumes\n";
+});
+
+// The deferring scheduler does not run the fiber here.
+var_dump($fiber->start());
+var_dump($fiber->isStarted());
+
+echo "end of script\n";
+?>
+--EXPECT--
+NULL
+bool(false)
+end of script
+ran after main

Zend/tests/async/fiber_managed_basic.phpt

@@ -0,0 +1,58 @@
+--TEST--
+A fiber adopted by the scheduler runs through the coroutine path
+--FILE--
+<?php
+$scheduler = new class extends Async\AbstractScheduler {
+    public SplQueue $queue;
+    public array $log = [];
+    public function __construct() { $this->queue = new SplQueue(); }
+    public function interceptFiber(Fiber $fiber): ?object {
+        $this->log[] = 'intercept';
+        return new class($fiber) {
+            public function __construct(public readonly Fiber $fiber) {}
+        };
+    }
+    public function enqueue(object $coroutine): bool {
+        $this->log[] = 'enqueue';
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function resume(object $coroutine, ?Throwable $error = null): bool {
+        $this->log[] = 'resume';
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function suspend(bool $fromMain, bool $isBailout): ?object {
+        $this->log[] = 'suspend';
+        while (!$this->queue->isEmpty()) {
+            $fiber = $this->queue->dequeue()->fiber;
+            $fiber->isStarted() ? $fiber->resume() : $fiber->start();
+            if (!$fromMain) {
+                return null;
+            }
+        }
+        return null;
+    }
+};
+
+Async\SchedulerHook::register('test', $scheduler);
+
+$fiber = new Fiber(function (int $x): int {
+    $y = Fiber::suspend($x + 1);
+    return $y * 10;
+});
+
+var_dump($fiber->start(5));
+var_dump($fiber->isSuspended());
+var_dump($fiber->resume(4));
+var_dump($fiber->isTerminated());
+var_dump($fiber->getReturn());
+echo implode(',', $scheduler->log), "\n";
+?>
+--EXPECT--
+int(6)
+bool(true)
+NULL
+bool(true)
+int(40)
+intercept,enqueue,suspend,resume,suspend

Zend/tests/async/fiber_managed_throw.phpt

@@ -0,0 +1,50 @@
+--TEST--
+Fiber::throw() on a managed fiber delivers the exception at the suspension point
+--FILE--
+<?php
+Async\SchedulerHook::register('test', new class extends Async\AbstractScheduler {
+    public SplQueue $queue;
+    public function __construct() { $this->queue = new SplQueue(); }
+    public function interceptFiber(Fiber $fiber): ?object {
+        return new class($fiber) {
+            public function __construct(public readonly Fiber $fiber) {}
+        };
+    }
+    public function enqueue(object $coroutine): bool {
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function resume(object $coroutine, ?Throwable $error = null): bool {
+        echo "resume hook error: ", $error === null ? 'none' : get_class($error), "\n";
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function suspend(bool $fromMain, bool $isBailout): ?object {
+        while (!$this->queue->isEmpty()) {
+            $fiber = $this->queue->dequeue()->fiber;
+            $fiber->isStarted() ? $fiber->resume() : $fiber->start();
+            if (!$fromMain) {
+                return null;
+            }
+        }
+        return null;
+    }
+});
+
+$fiber = new Fiber(function (): string {
+    try {
+        Fiber::suspend('waiting');
+    } catch (RuntimeException $e) {
+        return 'caught: ' . $e->getMessage();
+    }
+    return 'not reached';
+});
+
+var_dump($fiber->start());
+$fiber->throw(new RuntimeException('boom'));
+var_dump($fiber->getReturn());
+?>
+--EXPECT--
+string(7) "waiting"
+resume hook error: RuntimeException
+string(12) "caught: boom"

Zend/tests/async/fiber_managed_uncaught.phpt

@@ -0,0 +1,43 @@
+--TEST--
+An uncaught exception in a managed fiber surfaces at the start()/resume() caller
+--FILE--
+<?php
+Async\SchedulerHook::register('test', new class extends Async\AbstractScheduler {
+    public SplQueue $queue;
+    public function __construct() { $this->queue = new SplQueue(); }
+    public function interceptFiber(Fiber $fiber): ?object {
+        return new class($fiber) {
+            public function __construct(public readonly Fiber $fiber) {}
+        };
+    }
+    public function enqueue(object $coroutine): bool {
+        $this->queue->enqueue($coroutine);
+        return true;
+    }
+    public function suspend(bool $fromMain, bool $isBailout): ?object {
+        while (!$this->queue->isEmpty()) {
+            $fiber = $this->queue->dequeue()->fiber;
+            $fiber->isStarted() ? $fiber->resume() : $fiber->start();
+            if (!$fromMain) {
+                return null;
+            }
+        }
+        return null;
+    }
+});
+
+$fiber = new Fiber(function (): void {
+    throw new RuntimeException('escaped');
+});
+
+try {
+    $fiber->start();
+} catch (RuntimeException $e) {
+    echo "caught: ", $e->getMessage(), "\n";
+}
+
+var_dump($fiber->isTerminated());
+?>
+--EXPECT--
+caught: escaped
+bool(true)

Zend/tests/async/microtasks_basic.phpt

@@ -0,0 +1,44 @@
+--TEST--
+Microtasks: defer() forwards to the scheduler's defer() hook; the queue is the scheduler's
+--FILE--
+<?php
+$scheduler = new class extends Async\AbstractScheduler {
+    public SplQueue $tasks;
+    public function __construct() { $this->tasks = new SplQueue(); }
+    public function enqueue(object $coroutine): bool { return true; }
+    public function suspend(bool $fromMain, bool $isBailout): ?object { return null; }
+    public function defer(callable $task): bool {
+        // The queue is owned by the scheduler, not by the engine.
+        $this->tasks->enqueue($task);
+        return true;
+    }
+};
+
+Async\SchedulerHook::register('test', $scheduler);
+
+Async\SchedulerHook::defer(function (): void {
+    echo "task 1\n";
+
+    // Queued while draining: the scheduler decides the semantics; this
+    // one drains everything queued before it finishes (classic microtasks).
+    Async\SchedulerHook::defer(function (): void {
+        echo "task 3 (queued by task 1)\n";
+    });
+});
+
+Async\SchedulerHook::defer(function (): void {
+    echo "task 2\n";
+});
+
+// The scheduler drains its own queue on its tick; simulate one here.
+while (!$scheduler->tasks->isEmpty()) {
+    ($scheduler->tasks->dequeue())();
+}
+
+echo "drained\n";
+?>
+--EXPECT--
+task 1
+task 2
+task 3 (queued by task 1)
+drained