�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2F'>sapi</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2Ffpm%2F'>fpm</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2Ffpm%2Ftests%2F'>tests</a>/</p><hr><h3>✏️ Editing: response.inc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

namespace FPM;

abstract class BaseResponse
{
    /**
     * Tester instance
     * @var Tester
     */
    private Tester $tester;

    /**
     * @var bool
     */
    protected bool $debugOutputted = false;

    /**
     * @param Tester $tester
     */
    public function __construct(Tester $tester)
    {
        $this-&gt;tester = $tester;
    }

    /**
     * Debug response output.
     *
     * @return void
     */
    abstract function debugOutput(): void;

    /**
     * Emit error message
     *
     * @param string $message
     * @param bool   $throw
     *
     * @return bool
     * @throws \Exception
     */
    protected function error(string $message, bool $throw = false): bool
    {
        $errorMessage = &quot;ERROR: $message\n&quot;;
        if ($throw) {
            throw new \Exception($errorMessage);
        }
        if ( ! $this-&gt;debugOutputted) {
            $this-&gt;debugOutput();
        }
        echo $errorMessage;

        $this-&gt;tester-&gt;printLogs();

        return false;
    }
}

class Response extends BaseResponse
{
    const HEADER_SEPARATOR = &quot;\r\n\r\n&quot;;

    /**
     * @var array
     */
    private array $data;

    /**
     * @var string
     */
    private $rawData;

    /**
     * @var string
     */
    private $rawHeaders;

    /**
     * @var string
     */
    private $rawBody;

    /**
     * @var array
     */
    private $headers;

    /**
     * @var bool
     */
    private $valid;

    /**
     * @var bool
     */
    private bool $expectInvalid;

    /**
     * @param Tester            $tester
     * @param string|array|null $data
     * @param bool              $expectInvalid
     */
    public function __construct(Tester $tester, $data = null, bool $expectInvalid = false)
    {
        parent::__construct($tester);

        if ( ! is_array($data)) {
            $data = [
                &#039;response&#039;     =&gt; $data,
                &#039;err_response&#039; =&gt; null,
                &#039;out_response&#039; =&gt; $data,
            ];
        }

        $this-&gt;data          = $data;
        $this-&gt;expectInvalid = $expectInvalid;
    }

    /**
     * @param mixed  $body
     * @param string $contentType
     *
     * @return Response
     */
    public function expectBody($body, $contentType = &#039;text/html&#039;)
    {
        if ($multiLine = is_array($body)) {
            $body = implode(&quot;\n&quot;, $body);
        }

        if ( ! $this-&gt;checkIfValid()) {
            $this-&gt;error(&#039;Response is invalid&#039;);
        } elseif ( ! $this-&gt;checkDefaultHeaders($contentType)) {
            $this-&gt;error(&#039;Response default headers not found&#039;);
        } elseif ($body !== $this-&gt;rawBody) {
            if ($multiLine) {
                $this-&gt;error(
                    &quot;==&gt; The expected body:\n$body\n&quot; .
                    &quot;==&gt; does not match the actual body:\n$this-&gt;rawBody&quot;
                );
            } else {
                $this-&gt;error(
                    &quot;The expected body &#039;$body&#039; does not match actual body &#039;$this-&gt;rawBody&#039;&quot;
                );
            }
        }

        return $this;
    }

    /**
     * Expect status field with value that matches the supplied pattern.
     *
     * @param string $fieldName
     * @param string $pattern
     *
     * @return Response
     */
    public function expectJsonBodyPatternForStatusField(string $fieldName, string $pattern): Response
    {
        $rawData = $this-&gt;getBody(&#039;application/json&#039;);
        $data = json_decode($rawData, true);
        if (preg_match(&#039;|&#039; . $pattern . &#039;|&#039;, $data[$fieldName]) &gt; 0) {
            return $this;
        }

        $this-&gt;error(
            &quot;Field $fieldName did not match pattern $pattern in status data &#039;$rawData&#039;&quot;
        );

        return $this;
    }

    /**
     * Expect that one of the processes in json status process list has a field with value that
     * matches the supplied pattern.
     *
     * @param string $fieldName
     * @param string $pattern
     *
     * @return Response
     */
    public function expectJsonBodyPatternForStatusProcessField(string $fieldName, string $pattern): Response
    {
        $rawData = $this-&gt;getBody(&#039;application/json&#039;);
        $data = json_decode($rawData, true);
        if (empty($data[&#039;processes&#039;]) || !is_array($data[&#039;processes&#039;])) {
            $this-&gt;error(
                &quot;The body data is not a valid status json containing processes field &#039;$rawData&#039;&quot;
            );
        }
        foreach ($data[&#039;processes&#039;] as $process) {
            if (preg_match(&#039;|&#039; . $pattern . &#039;|&#039;, $process[$fieldName]) &gt; 0) {
                return $this;
            }
        }

        $this-&gt;error(
            &quot;No field $fieldName matched pattern $pattern for any process in status data &#039;$rawData&#039;&quot;
        );

        return $this;
    }

    /**
     * @return Response
     */
    public function expectEmptyBody()
    {
        return $this-&gt;expectBody(&#039;&#039;);
    }

    /**
     * Expect header in the response.
     *
     * @param string $name  Header name.
     * @param string $value Header value.
     *
     * @return Response
     */
    public function expectHeader($name, $value, $useRegex = false): Response
    {
        $this-&gt;checkHeader($name, $value, $useRegex);

        return $this;
    }

    /**
     * @param string $name
     * @return Response
     */
    public function expectNoHeader($name)
    {
        $this-&gt;checkNoHeader($name);

        return $this;
    }

    /**
     * Expect error in the response.
     *
     * @param string|null $errorMessage Expected error message.
     *
     * @return Response
     */
    public function expectError($errorMessage): Response
    {
        $errorData = $this-&gt;getErrorData();
        if ($errorData !== $errorMessage) {
            $expectedErrorMessage = $errorMessage !== null
                ? &quot;The expected error message &#039;$errorMessage&#039; is not equal to returned error &#039;$errorData&#039;&quot;
                : &quot;No error message expected but received &#039;$errorData&#039;&quot;;
            $this-&gt;error($expectedErrorMessage);
        }

        return $this;
    }

    /**
     * Expect error pattern in the response.
     *
     * @param string $errorMessagePattern Expected error message RegExp pattern.
     *
     * @return Response
     */
    public function expectErrorPattern(string $errorMessagePattern): Response
    {
        $errorData = $this-&gt;getErrorData();
        if (preg_match($errorMessagePattern, $errorData) === 0) {
            $this-&gt;error(
                &quot;The expected error pattern $errorMessagePattern does not match the returned error &#039;$errorData&#039;&quot;
            );
            $this-&gt;debugOutput();
        }

        return $this;
    }

    /**
     * Expect response status.
     *
     * @param string|null $status Expected status.
     *
     * @return Response
     */
    public function expectStatus(string|null $status): Response {
        $headers = $this-&gt;getHeaders();
        if (is_null($status) &amp;&amp; !isset($headers[&#039;status&#039;])) {
            return $this;
        }
        if (!is_null($status) &amp;&amp; !isset($headers[&#039;status&#039;])) {
            $this-&gt;error(&#039;Status is expected but not supplied&#039;);
        } elseif ($status !== $headers[&#039;status&#039;]) {
            $statusMessage = $status === null ? &quot;expected not to be set&quot;: &quot;expected to be $status&quot;;
            $this-&gt;error(&quot;Status is $statusMessage but the actual value is {$headers[&#039;status&#039;]}&quot;);
        }

        return $this;
    }

    /**
     * Expect response status not to be set.
     *
     * @return Response
     */
    public function expectNoStatus(): Response {
        return $this-&gt;expectStatus(null);
    }

    /**
     * Expect no error in the response.
     *
     * @return Response
     */
    public function expectNoError(): Response
    {
        return $this-&gt;expectError(null);
    }

    /**
     * Get response body.
     *
     * @param string $contentType Expect body to have specified content type.
     *
     * @return string|null
     */
    public function getBody(string $contentType = &#039;text/html&#039;): ?string
    {
        if ($this-&gt;checkIfValid() &amp;&amp; $this-&gt;checkDefaultHeaders($contentType)) {
            return $this-&gt;rawBody;
        }

        return null;
    }

    /**
     * Print raw body.
     *
     * @param string $contentType Expect body to have specified content type.
     */
    public function dumpBody(string $contentType = &#039;text/html&#039;)
    {
        var_dump($this-&gt;getBody($contentType));
    }

    /**
     * Print raw body.
     *
     * @param string $contentType Expect body to have specified content type.
     */
    public function printBody(string $contentType = &#039;text/html&#039;)
    {
        echo $this-&gt;getBody($contentType) . &quot;\n&quot;;
    }

    /**
     * Debug response output
     */
    public function debugOutput(): void
    {
        echo &quot;&gt;&gt;&gt; Response\n&quot;;
        echo &quot;----------------- OUT -----------------\n&quot;;
        echo $this-&gt;data[&#039;out_response&#039;] . &quot;\n&quot;;
        echo &quot;----------------- ERR -----------------\n&quot;;
        echo $this-&gt;data[&#039;err_response&#039;] . &quot;\n&quot;;
        echo &quot;---------------------------------------\n\n&quot;;

        $this-&gt;debugOutputted = true;
    }

    /**
     * @return string|null
     */
    public function getErrorData(): ?string
    {
        return $this-&gt;data[&#039;err_response&#039;];
    }

    /**
     * Check if the response is valid and if not emit error message
     *
     * @return bool
     */
    private function checkIfValid(): bool
    {
        if ($this-&gt;isValid()) {
            return true;
        }

        if ( ! $this-&gt;expectInvalid) {
            $this-&gt;error(&quot;The response is invalid: $this-&gt;rawData&quot;);
        }

        return false;
    }

    /**
     * Check default headers that should be present.
     *
     * @param string $contentType
     *
     * @return bool
     */
    private function checkDefaultHeaders($contentType): bool
    {
        // check default headers
        return (
            ( ! ini_get(&#039;expose_php&#039;) || $this-&gt;checkHeader(&#039;X-Powered-By&#039;, &#039;|^PHP/8|&#039;, true)) &amp;&amp;
            $this-&gt;checkHeader(&#039;Content-type&#039;, &#039;|^&#039; . $contentType . &#039;(;\s?charset=\w+)?|&#039;, true)
        );
    }

    /**
     * Check a specified header.
     *
     * @param string $name     Header name.
     * @param string $value    Header value.
     * @param bool   $useRegex Whether value is regular expression.
     *
     * @return bool
     */
    private function checkHeader(string $name, string $value, $useRegex = false): bool
    {
        $lcName  = strtolower($name);
        $headers = $this-&gt;getHeaders();
        if ( ! isset($headers[$lcName])) {
            return $this-&gt;error(&quot;The header $name is not present&quot;);
        }
        $header = $headers[$lcName];

        if ( ! $useRegex) {
            if ($header === $value) {
                return true;
            }

            return $this-&gt;error(&quot;The header $name value &#039;$header&#039; is not the same as &#039;$value&#039;&quot;);
        }

        if ( ! preg_match($value, $header)) {
            return $this-&gt;error(&quot;The header $name value &#039;$header&#039; does not match RegExp &#039;$value&#039;&quot;);
        }

        return true;
    }

    /**
     * @param string $name
     * @return bool
     */
    private function checkNoHeader(string $name)
    {
        $lcName = strtolower($name);
        $headers = $this-&gt;getHeaders();
        if (isset($headers[$lcName])) {
            return $this-&gt;error(&quot;The header $name is present&quot;);
        }

        return true;
    }

    /**
     * Get all headers.
     *
     * @return array|null
     */
    private function getHeaders(): ?array
    {
        if ( ! $this-&gt;isValid()) {
            return null;
        }

        if (is_array($this-&gt;headers)) {
            return $this-&gt;headers;
        }

        $headerRows = explode(&quot;\r\n&quot;, $this-&gt;rawHeaders);
        $headers    = [];
        foreach ($headerRows as $headerRow) {
            $colonPosition = strpos($headerRow, &#039;:&#039;);
            if ($colonPosition === false) {
                $this-&gt;error(&quot;Invalid header row (no colon): $headerRow&quot;);
            }
            $headers[strtolower(substr($headerRow, 0, $colonPosition))] = trim(
                substr($headerRow, $colonPosition + 1)
            );
        }

        return ($this-&gt;headers = $headers);
    }

    /**
     * @return bool
     */
    private function isValid()
    {
        if ($this-&gt;valid === null) {
            $this-&gt;processData();
        }

        return $this-&gt;valid;
    }

    /**
     * Process data and set validity and raw data
     */
    private function processData()
    {
        $this-&gt;rawData = $this-&gt;data[&#039;out_response&#039;];
        $this-&gt;valid   = (
            ! is_null($this-&gt;rawData) &amp;&amp;
            strpos($this-&gt;rawData, self::HEADER_SEPARATOR)
        );
        if ($this-&gt;valid) {
            list ($this-&gt;rawHeaders, $this-&gt;rawBody) = array_map(
                &#039;trim&#039;,
                explode(self::HEADER_SEPARATOR, $this-&gt;rawData)
            );
        }
    }
}

class ValuesResponse extends BaseResponse
{
    /**
     * @var array
     */
    private array $values;

    /**
     * @param Tester            $tester
     * @param string|array|null $values
     * @throws \Exception
     */
    public function __construct(Tester $tester, $values = null)
    {
        parent::__construct($tester);

        if ( ! is_array($values)) {
            if ( ! is_null($values) ) {
                $this-&gt;error(&#039;Invalid values supplied&#039;, true);
            }
            $this-&gt;values = [];
        } else {
            $this-&gt;values = $values;
        }
    }

    /**
     * Expect value.
     *
     * @param string $name
     * @param mixed  $value
     * @return ValuesResponse
     * @throws \Exception
     */
    public function expectValue(string $name, $value = null)
    {
        if ( ! isset($this-&gt;values[$name])) {
            $this-&gt;error(&quot;Value $name not found in values&quot;);
        }
        if ( ! is_null($value) &amp;&amp; $value !== $this-&gt;values[$name]) {
            $this-&gt;error(&quot;Value $name is {$this-&gt;values[$name]} but expected $value&quot;);
        }
        return $this;
    }

    /**
     * Get values.
     *
     * @return array
     */
    public function getValues()
    {
        return $this-&gt;values;
    }

    /**
     * Debug output data.
     */
    public function debugOutput(): void
    {
        echo &quot;&gt;&gt;&gt; ValuesResponse\n&quot;;
        echo &quot;----------------- Values -----------------\n&quot;;
        var_dump($this-&gt;values);
        echo &quot;---------------------------------------\n\n&quot;;
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fsapi%2Ffpm%2Ftests'>🔙 Back</a></p>