use ParallelException instead of Exception as fallback

src/Output/ParallelException.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Spatie\Async\Output;
+
+class ParallelException extends \Exception
+{
+    /** @var string */
+    protected $originalClass;
+
+    /** @var string */
+    protected $originalTrace;
+
+    public function __construct(string $message, string $originalClass, string $originalTrace)
+    {
+        parent::__construct($message);
+        $this->originalClass = $originalClass;
+        $this->originalTrace = $originalTrace;
+    }
+
+    /** @return string */
+    public function getOriginalClass(): string
+    {
+        return $this->originalClass;
+    }
+
+    /** @return string */
+    public function getOriginalTrace(): string
+    {
+        return $this->originalTrace;
+    }
+}

src/Output/SerializableException.php

@@ -2,7 +2,6 @@
 
 namespace Spatie\Async\Output;
 
-use ArgumentCountError;
 use Throwable;
 
 class SerializableException
@@ -28,8 +27,8 @@ public function asThrowable(): Throwable
         try {
             /** @var Throwable $throwable */
             $throwable = new $this->class($this->message."\n\n".$this->trace);
-        } catch (ArgumentCountError $exception) {
-            $throwable = new \Exception($this->message."\n\n".$this->trace);
+        } catch (Throwable $exception) {
+            $throwable = new ParallelException($this->message, $this->class, $this->trace);
         }
 
         return $throwable;

tests/ErrorHandlingTest.php

@@ -7,6 +7,7 @@
 use ParseError;
 use PHPUnit\Framework\TestCase;
 use Spatie\Async\Output\ParallelError;
+use Spatie\Async\Output\ParallelException;
 use Spatie\Async\Pool;
 
 class ErrorHandlingTest extends TestCase
@@ -34,17 +35,40 @@ public function it_can_handle_complex_exceptions_via_catch_callback()
     {
         $pool = Pool::create();
 
-        foreach (range(1, 5) as $i) {
-            $pool->add(function () {
-                throw new MyComplexException('test', (object) ['error' => 'wrong query']);
-            })->catch(function (MyComplexException $e) {
-                $this->assertRegExp('/test/', $e->getMessage());
+        $originalExceptionCount = 0;
+        $fallbackExceptionCount = 0;
+
+        $pool
+            ->add(function () {
+                throw new MyExceptionWithAComplexArgument('test', (object) ['error' => 'wrong query']);
+            })
+            ->catch(function (MyExceptionWithAComplexArgument $e) use (&$originalExceptionCount) {
+                $originalExceptionCount += 1;
+            })
+            ->catch(function (ParallelException $e) use (&$fallbackExceptionCount) {
+                $fallbackExceptionCount += 1;
+                $this->assertEquals('test', $e->getMessage());
+                $this->assertEquals(MyExceptionWithAComplexArgument::class, $e->getOriginalClass());
+            });
+
+        $pool
+            ->add(function () use (&$originalExceptionCount) {
+                throw new MyExceptionWithAComplexFirstArgument((object) ['error' => 'wrong query'], 'test');
+            })
+            ->catch(function (MyExceptionWithAComplexFirstArgument $e) use (&$originalExceptionCount) {
+                $originalExceptionCount += 1;
+            })
+            ->catch(function (ParallelException $e) use (&$fallbackExceptionCount) {
+                $fallbackExceptionCount += 1;
+                $this->assertEquals('test', $e->getMessage());
+                $this->assertEquals(MyExceptionWithAComplexFirstArgument::class, $e->getOriginalClass());
             });
-        }
 
         $pool->wait();
 
-        $this->assertCount(5, $pool->getFailed(), (string) $pool->status());
+        $this->assertCount(2, $pool->getFailed(), (string) $pool->status());
+        $this->assertEquals(0, $originalExceptionCount);
+        $this->assertEquals(2, $fallbackExceptionCount);
     }
 
     /** @test */

tests/MyComplexException.php → tests/MyExceptionWithAComplexArgument.php

@@ -5,7 +5,7 @@
 use Exception;
 use stdClass;
 
-class MyComplexException extends Exception
+class MyExceptionWithAComplexArgument extends Exception
 {
     public $payload;
 

tests/MyExceptionWithAComplexFirstArgument.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Spatie\Async\Tests;
+
+use Exception;
+use stdClass;
+
+class MyExceptionWithAComplexFirstArgument extends Exception
+{
+    public $payload;
+
+    public function __construct(stdClass $payload, string $message)
+    {
+        parent::__construct($message);
+        $this->payload = $payload;
+    }
+}