diff --git a/.github/workflows/phpunit.yaml b/.github/workflows/phpunit.yaml
index dd812f6..baa5e08 100644
--- a/.github/workflows/phpunit.yaml
+++ b/.github/workflows/phpunit.yaml
@@ -32,7 +32,7 @@ jobs:
         run: composer install
 
       - name: Run tests with code coverage.
-        run: php -ddisable_functions=time vendor/bin/phpunit --coverage-clover=coverage.xml --colors=always
+        run: composer test
 
       - name: Upload coverage to Codecov.
         if: matrix.os == 'ubuntu-latest'
diff --git a/composer.json b/composer.json
index 2d65638..fab504a 100644
--- a/composer.json
+++ b/composer.json
@@ -24,6 +24,6 @@
         }
     },
     "scripts": {
-        "test": "php -ddisable_functions=time vendor/bin/phpunit"
+        "test": "php -ddisable_functions=time,header,headers_sent vendor/bin/phpunit"
     }
 }
diff --git a/src/Mocker.php b/src/Mocker.php
index 70fb975..5755a22 100644
--- a/src/Mocker.php
+++ b/src/Mocker.php
@@ -103,9 +103,19 @@ private function normalizeMocks(array $mocks): array
 
     private function generateFunction(mixed $groupedMocks): string
     {
+        $stubs = require __DIR__ . '/stubs.php';
         $innerOutputs = [];
         foreach ($groupedMocks as $functionName => $_) {
-            $function = "fn() => \\$functionName(...\$arguments)";
+            $signatureArguments = $stubs[$functionName]['signatureArguments'] ?? '...$arguments';
+            if (isset($stubs[$functionName]['arguments'])) {
+                $arrayArguments = sprintf('[%s]', $stubs[$functionName]['arguments']);
+                $unpackedArguments = $stubs[$functionName]['arguments'];
+            } else {
+                $arrayArguments = '$arguments';
+                $unpackedArguments = '...$arguments';
+            }
+
+            $function = "fn($signatureArguments) => \\$functionName($unpackedArguments)";
             if ($_[0]['function'] !== false) {
                 $function = is_string($_[0]['function'])
                     ? $_[0]['function']
@@ -113,13 +123,13 @@ private function generateFunction(mixed $groupedMocks): string
             }
 
             $string = <<<PHP
-                function $functionName(...\$arguments)
+                function $functionName($signatureArguments)
                 {
-                    \$position = MockerState::saveTrace(__NAMESPACE__, "$functionName", \$arguments);
-                    if (MockerState::checkCondition(__NAMESPACE__, "$functionName", \$arguments)) {
-                        \$result = MockerState::getResult(__NAMESPACE__, "$functionName", \$arguments);
+                    \$position = MockerState::saveTrace(__NAMESPACE__, "$functionName", $unpackedArguments);
+                    if (MockerState::checkCondition(__NAMESPACE__, "$functionName", $arrayArguments)) {
+                        \$result = MockerState::getResult(__NAMESPACE__, "$functionName", $unpackedArguments);
                     } else {
-                        \$result = MockerState::getDefaultResult(__NAMESPACE__, "$functionName", $function);
+                        \$result = MockerState::getDefaultResult(__NAMESPACE__, "$functionName", $function, $unpackedArguments);
                     }
                     
                     return MockerState::saveTraceResult(__NAMESPACE__, "$functionName", \$position, \$result);
diff --git a/src/MockerState.php b/src/MockerState.php
index 8dba420..3e492e8 100644
--- a/src/MockerState.php
+++ b/src/MockerState.php
@@ -14,7 +14,7 @@ final class MockerState
     public static function addCondition(
         string $namespace,
         string $functionName,
-        array $arguments,
+        array|string $arguments,
         mixed $result,
         bool $default = false
     ): void {
@@ -39,7 +39,7 @@ public static function addCondition(
     public static function checkCondition(
         string $namespace,
         string $functionName,
-        array $expectedArguments,
+        array|string $expectedArguments,
     ): bool {
         $mocks = self::$state[$namespace][$functionName] ?? [];
 
@@ -51,10 +51,10 @@ public static function checkCondition(
         return false;
     }
 
-    private static function compareArguments(array $arguments, array $expectedArguments): bool
+    private static function compareArguments(array $arguments, array|string $expectedArguments): bool
     {
         return $arguments['arguments'] === $expectedArguments
-            || array_values($arguments['arguments']) === $expectedArguments;
+            || (is_array($arguments['arguments']) && array_values($arguments['arguments']) === $expectedArguments);
     }
 
     private static function replaceResult(
@@ -75,13 +75,13 @@ private static function replaceResult(
     public static function getResult(
         string $namespace,
         string $functionName,
-        array $expectedArguments,
+        &...$expectedArguments,
     ): mixed {
         $mocks = self::$state[$namespace][$functionName] ?? [];
 
         foreach ($mocks as $mock) {
             if (self::compareArguments($mock, $expectedArguments)) {
-                return $mock['result'];
+                return is_callable($mock['result']) ? $mock['result'](...$expectedArguments) : $mock['result'];
             }
         }
         return false;
@@ -91,12 +91,13 @@ public static function getDefaultResult(
         string $namespace,
         string $functionName,
         callable $fallback,
+        &...$arguments,
     ): mixed {
         if (isset(self::$defaults[$namespace][$functionName])) {
             return self::$defaults[$namespace][$functionName];
         }
 
-        return $fallback();
+        return $fallback(...$arguments);
     }
 
     public static function saveState(): void
@@ -113,11 +114,11 @@ public static function resetState(): void
     public static function saveTrace(
         string $namespace,
         string $functionName,
-        array $arguments
+        &...$arguments
     ): int {
         $position = count(self::$traces[$namespace][$functionName] ?? []);
         self::$traces[$namespace][$functionName][$position] = [
-            'arguments' => $arguments,
+            'arguments' => &$arguments,
             'trace' => debug_backtrace(),
         ];
 
diff --git a/src/stubs.php b/src/stubs.php
new file mode 100644
index 0000000..d38f654
--- /dev/null
+++ b/src/stubs.php
@@ -0,0 +1,14 @@
+<?php
+
+return [
+    'headers_sent' => [
+        'signature' => 'headers_sent(&$filename, &$line): bool',
+        'signatureArguments' => '&$filename, &$line',
+        'arguments' => '$filename, $line',
+    ],
+    'time' => [
+        'signature' => 'time(): int',
+        'signatureArguments' => '',
+        'arguments' => '',
+    ],
+];
\ No newline at end of file
diff --git a/tests/Integration/HeaderTest.php b/tests/Integration/HeaderTest.php
new file mode 100644
index 0000000..c33ded1
--- /dev/null
+++ b/tests/Integration/HeaderTest.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xepozz\InternalMocker\Tests\Integration;
+
+use PHPUnit\Framework\TestCase;
+use Xepozz\InternalMocker\MockerState;
+
+final class HeaderTest extends TestCase
+{
+    public function testRun()
+    {
+        header('Content-Type: application/json');
+
+        $trace = MockerState::getTraces(
+            '',
+            'header',
+        );
+
+        $this->assertEquals(['Content-Type: application/json'], $trace[0]['arguments']);
+    }
+}
\ No newline at end of file
diff --git a/tests/Integration/HeadersSentTest.php b/tests/Integration/HeadersSentTest.php
new file mode 100644
index 0000000..bed5105
--- /dev/null
+++ b/tests/Integration/HeadersSentTest.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xepozz\InternalMocker\Tests\Integration;
+
+use PHPUnit\Framework\TestCase;
+use Xepozz\InternalMocker\MockerState;
+
+final class HeadersSentTest extends TestCase
+{
+    public function testCheckReferences()
+    {
+        MockerState::addCondition(
+            '',
+            'headers_sent',
+            [null, null],
+            fn (&$file, &$line) => $file = $line = 123,
+        );
+        headers_sent($file, $line);
+
+        $trace = MockerState::getTraces(
+            '',
+            'headers_sent',
+        );
+
+        $this->assertEquals(123, $file);
+        $this->assertEquals(123, $line);
+        $this->assertEquals([123, 123], $trace[0]['arguments']);
+    }
+}
\ No newline at end of file
diff --git a/tests/Integration/TraceTest.php b/tests/Integration/TraceTest.php
index 99e990b..3369158 100644
--- a/tests/Integration/TraceTest.php
+++ b/tests/Integration/TraceTest.php
@@ -67,12 +67,12 @@ public function testBacktrace(): void
 
         $this->assertEquals(['test'], $traces[0]['arguments']);
         $this->assertEquals('saveTrace', $traces[0]['trace'][0]['function']);
-        $this->assertEquals(120, $traces[0]['trace'][0]['line']);
+        $this->assertEquals(144, $traces[0]['trace'][0]['line']);
         $this->assertEquals(
             [
                 __NAMESPACE__,
                 'serialize',
-                ['test'],
+                'test',
             ],
             $traces[0]['trace'][0]['args'],
         );
diff --git a/tests/MockerExtension.php b/tests/MockerExtension.php
index c62b1c2..1c2d6ea 100644
--- a/tests/MockerExtension.php
+++ b/tests/MockerExtension.php
@@ -74,6 +74,15 @@ public static function load(): void
                 'name' => 'time',
                 'function' => fn () => `date +%s`,
             ],
+            [
+                'namespace' => '',
+                'name' => 'header',
+                'function' => fn (string $value) => true,
+            ],
+            [
+                'namespace' => '',
+                'name' => 'headers_sent',
+            ],
         ];
 
         $mocker = new Mocker();
diff --git a/tests/MockerTest.php b/tests/MockerTest.php
index cb127ed..a084b9a 100644
--- a/tests/MockerTest.php
+++ b/tests/MockerTest.php
@@ -47,13 +47,13 @@ public function generateProvider()
                 namespace Xepozz\InternalMocker\Tests\Integration {
                     use Xepozz\InternalMocker\MockerState;
 
-                    function time(...\$arguments)
+                    function time()
                     {
-                        \$position = MockerState::saveTrace(__NAMESPACE__, "time", \$arguments);
-                        if (MockerState::checkCondition(__NAMESPACE__, "time", \$arguments)) {
-                            \$result = MockerState::getResult(__NAMESPACE__, "time", \$arguments);
+                        \$position = MockerState::saveTrace(__NAMESPACE__, "time", );
+                        if (MockerState::checkCondition(__NAMESPACE__, "time", [])) {
+                            \$result = MockerState::getResult(__NAMESPACE__, "time", );
                         } else {
-                            \$result = MockerState::getDefaultResult(__NAMESPACE__, "time", fn() => \\time(...\$arguments));
+                            \$result = MockerState::getDefaultResult(__NAMESPACE__, "time", fn() => \\time(), );
                         }
                         
                         return MockerState::saveTraceResult(__NAMESPACE__, "time", \$position, \$result);
@@ -108,11 +108,11 @@ function time(...\$arguments)
 
                     function str_contains(...\$arguments)
                     {
-                        \$position = MockerState::saveTrace(__NAMESPACE__, "str_contains", \$arguments);
+                        \$position = MockerState::saveTrace(__NAMESPACE__, "str_contains", ...\$arguments);
                         if (MockerState::checkCondition(__NAMESPACE__, "str_contains", \$arguments)) {
-                            \$result = MockerState::getResult(__NAMESPACE__, "str_contains", \$arguments);
+                            \$result = MockerState::getResult(__NAMESPACE__, "str_contains", ...\$arguments);
                         } else {
-                            \$result = MockerState::getDefaultResult(__NAMESPACE__, "str_contains", fn() => \\str_contains(...\$arguments));
+                            \$result = MockerState::getDefaultResult(__NAMESPACE__, "str_contains", fn(...\$arguments) => \\str_contains(...\$arguments), ...\$arguments);
                         }
                         
                         return MockerState::saveTraceResult(__NAMESPACE__, "str_contains", \$position, \$result);