+ Support ob_start with coroutines and tests

Author: EdmondDantes

tests/output_buffer/001-ob_start_basic_isolation.phpt

@@ -0,0 +1,42 @@
+--TEST--
+Output Buffer: Basic ob_start isolation with suspend
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Main starts\n";
+
+ob_start();
+echo "Main buffer before";
+
+spawn(function() {
+    echo "Coroutine starts\n";
+    
+    ob_start();
+    echo "Before suspend";
+    
+    suspend(); // Coroutine loses control
+    
+    echo " After suspend";
+    $content = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Got: '$content'\n";
+});
+
+suspend(); // Main also loses control
+
+echo " Main buffer after";
+$main_content = ob_get_contents();
+ob_end_clean();
+
+echo "Main got: '$main_content'\n";
+
+?>
+--EXPECT--
+Main starts
+Coroutine starts
+Main got: 'Main buffer before Main buffer after'
+Got: 'Before suspend After suspend'

tests/output_buffer/002-multiple_coroutines_isolation.phpt

@@ -0,0 +1,55 @@
+--TEST--
+Output Buffer: Multiple coroutines with independent buffers
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Start\n";
+
+spawn(function() {
+    ob_start();
+    echo "Coroutine A: part1";
+    
+    suspend(); // Switch context
+    
+    echo " part2";
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "A got: '$content'\n";
+});
+
+spawn(function() {
+    ob_start();
+    echo "Coroutine B: part1";
+    
+    suspend(); // Switch context
+    
+    echo " part2";
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "B got: '$content'\n";
+});
+
+spawn(function() {
+    ob_start();
+    echo "Coroutine C: part1";
+    
+    suspend(); // Switch context
+    
+    echo " part2";
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "C got: '$content'\n";
+});
+
+echo "End\n";
+
+?>
+--EXPECT--
+Start
+End
+A got: 'Coroutine A: part1 part2'
+B got: 'Coroutine B: part1 part2'
+C got: 'Coroutine C: part1 part2'

tests/output_buffer/003-nested_ob_start.phpt

@@ -0,0 +1,37 @@
+--TEST--
+Output Buffer: Nested ob_start in coroutines
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Start\n";
+
+spawn(function() {
+    ob_start();
+    echo "Level 1: ";
+    
+    ob_start();
+    echo "Level 2: ";
+    
+    suspend(); // Context switch with nested buffers
+    
+    echo "content";
+    $level2 = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Got level2: '$level2' ";
+    $level1 = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Got level1: '$level1'\n";
+});
+
+echo "End\n";
+
+?>
+--EXPECT--
+Start
+End
+Got level1: 'Level 1: Got level2: 'Level 2: content' '

tests/output_buffer/004-ob_flush_isolation.phpt

@@ -0,0 +1,49 @@
+--TEST--
+Output Buffer: ob_flush and ob_clean isolation
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Start\n";
+
+spawn(function() {
+    ob_start();
+    echo "Before flush\n";
+    
+    suspend(); // Context switch
+    
+    ob_flush(); // Should flush only this coroutine's buffer
+    echo " After flush";
+    
+    suspend(); // Another context switch
+    
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "Remaining: '$content'\n";
+});
+
+spawn(function() {
+    ob_start();
+    echo "Other coroutine";
+    
+    suspend(); // Context switch
+    
+    ob_clean(); // Should clean only this coroutine's buffer
+    echo "After clean";
+    
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "Got: '$content'\n";
+});
+
+echo "End\n";
+
+?>
+--EXPECT--
+Start
+End
+Before flush
+Got: 'After clean'
+Remaining: ' After flush'

tests/output_buffer/005-mixed_buffering.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Output Buffer: Mixed buffered and non-buffered output
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Main without buffer\n";
+
+spawn(function() {
+    echo "Coroutine 1 without buffer\n";
+    
+    ob_start();
+    echo "Now with buffer";
+    
+    suspend(); // Context switch
+    
+    echo " continued";
+    $content = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Buffered was: '$content'\n";
+});
+
+spawn(function() {
+    ob_start();
+    echo "Coroutine 2 always buffered";
+    
+    suspend(); // Context switch
+    
+    echo " until end";
+    $content = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Got: '$content'\n";
+});
+
+echo "Main still without buffer\n";
+
+?>
+--EXPECT--
+Main without buffer
+Main still without buffer
+Coroutine 1 without buffer
+Buffered was: 'Now with buffer continued'
+Got: 'Coroutine 2 always buffered until end'

tests/output_buffer/006-exception_handling.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Output Buffer: Exception handling with ob_start
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\suspend;
+
+echo "Start\n";
+
+spawn(function() {
+    ob_start();
+    echo "Before exception";
+    
+    suspend(); // Context switch
+    
+    try {
+        throw new Exception("Test exception");
+    } catch (Exception $e) {
+        echo " Caught: " . $e->getMessage();
+    }
+    
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "Got: '$content'\n";
+});
+
+spawn(function() {
+    ob_start();
+    echo "Normal coroutine";
+    
+    suspend(); // Context switch
+    
+    echo " continues";
+    $content = ob_get_contents();
+    ob_end_clean();
+    echo "Got: '$content'\n";
+});
+
+echo "End\n";
+
+?>
+--EXPECT--
+Start
+End
+Got: 'Before exception Caught: Test exception'
+Got: 'Normal coroutine continues'

tests/output_buffer/README.md

@@ -0,0 +1,39 @@
+# Output Buffer Isolation Tests
+
+This directory contains tests for output buffer isolation between coroutines using `ob_start()` and related functions.
+
+## Test Cases
+
+### 001-ob_start_basic_isolation.phpt
+Tests basic isolation of `ob_start()` buffers between main coroutine and spawned coroutines with context switching via `suspend()`.
+
+### 002-multiple_coroutines_isolation.phpt
+Tests that multiple coroutines can each have their own independent output buffers that don't interfere with each other.
+
+### 003-nested_ob_start.phpt
+Tests nested `ob_start()` calls within a single coroutine to ensure the buffer stack is properly maintained across context switches.
+
+### 004-ob_flush_isolation.phpt
+Tests `ob_flush()` and `ob_clean()` operations work correctly within each coroutine's isolated buffer context.
+
+### 005-mixed_buffering.phpt
+Tests scenarios where some coroutines use output buffering and others don't, ensuring proper isolation.
+
+### 006-exception_handling.phpt
+Tests that output buffer isolation works correctly even when exceptions are thrown within coroutines.
+
+## Key Testing Scenarios
+
+- **Context Switching**: All tests use `suspend()` to force context switches and verify buffer state is preserved
+- **Buffer Isolation**: Each coroutine should have completely independent output buffers
+- **State Preservation**: Buffer content should be maintained across context switches
+- **Nested Buffers**: Buffer stacks should be properly isolated per coroutine
+- **Exception Safety**: Buffer isolation should work even when exceptions occur
+
+## Expected Behavior
+
+When `ob_start()` is called within a coroutine, it should:
+1. Create an isolated output buffer for that coroutine
+2. Automatically register a context switch handler for the coroutine
+3. Save/restore buffer state when the coroutine loses/regains control
+4. Not interfere with output buffers in other coroutines or the main thread