<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: RequestTest.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php

namespace GuzzleHttp\Tests\Psr7;

use GuzzleHttp\Psr7;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Uri;

/**
 * @covers GuzzleHttp\Psr7\MessageTrait
 * @covers GuzzleHttp\Psr7\Request
 */
class RequestTest extends BaseTest
{
    public function testRequestUriMayBeString()
    {
        $r = new Request('GET', '/');
        self::assertSame('/', (string) $r-&gt;getUri());
    }

    public function testRequestUriMayBeUri()
    {
        $uri = new Uri('/');
        $r = new Request('GET', $uri);
        self::assertSame($uri, $r-&gt;getUri());
    }

    public function testValidateRequestUri()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException');

        new Request('GET', '///');
    }

    public function testCanConstructWithBody()
    {
        $r = new Request('GET', '/', [], 'baz');
        self::assertInstanceOf('Psr\Http\Message\StreamInterface', $r-&gt;getBody());
        self::assertSame('baz', (string) $r-&gt;getBody());
    }

    public function testNullBody()
    {
        $r = new Request('GET', '/', [], null);
        self::assertInstanceOf('Psr\Http\Message\StreamInterface', $r-&gt;getBody());
        self::assertSame('', (string) $r-&gt;getBody());
    }

    public function testFalseyBody()
    {
        $r = new Request('GET', '/', [], '0');
        self::assertInstanceOf('Psr\Http\Message\StreamInterface', $r-&gt;getBody());
        self::assertSame('0', (string) $r-&gt;getBody());
    }

    public function testConstructorDoesNotReadStreamBody()
    {
        $streamIsRead = false;
        $body = Psr7\FnStream::decorate(Psr7\Utils::streamFor(''), [
            '__toString' =&gt; function () use (&amp;$streamIsRead) {
                $streamIsRead = true;
                return '';
            }
        ]);

        $r = new Request('GET', '/', [], $body);
        self::assertFalse($streamIsRead);
        self::assertSame($body, $r-&gt;getBody());
    }

    public function testCapitalizesMethod()
    {
        $r = new Request('get', '/');
        self::assertSame('GET', $r-&gt;getMethod());
    }

    public function testCapitalizesWithMethod()
    {
        $r = new Request('GET', '/');
        self::assertSame('PUT', $r-&gt;withMethod('put')-&gt;getMethod());
    }

    public function testWithUri()
    {
        $r1 = new Request('GET', '/');
        $u1 = $r1-&gt;getUri();
        $u2 = new Uri('http://www.example.com');
        $r2 = $r1-&gt;withUri($u2);
        self::assertNotSame($r1, $r2);
        self::assertSame($u2, $r2-&gt;getUri());
        self::assertSame($u1, $r1-&gt;getUri());
    }

    /**
     * @dataProvider invalidMethodsProvider
     */
    public function testConstructWithInvalidMethods($method)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException');
        new Request($method, '/');
    }

    /**
     * @dataProvider invalidMethodsProvider
     */
    public function testWithInvalidMethods($method)
    {
        $r = new Request('get', '/');
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException');
        $r-&gt;withMethod($method);
    }

    public function invalidMethodsProvider()
    {
        return [
            [null],
            [false],
            [['foo']],
            [new \stdClass()],
        ];
    }

    public function testSameInstanceWhenSameUri()
    {
        $r1 = new Request('GET', 'http://foo.com');
        $r2 = $r1-&gt;withUri($r1-&gt;getUri());
        self::assertSame($r1, $r2);
    }

    public function testWithRequestTarget()
    {
        $r1 = new Request('GET', '/');
        $r2 = $r1-&gt;withRequestTarget('*');
        self::assertSame('*', $r2-&gt;getRequestTarget());
        self::assertSame('/', $r1-&gt;getRequestTarget());
    }

    public function testRequestTargetDoesNotAllowSpaces()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException');

        $r1 = new Request('GET', '/');
        $r1-&gt;withRequestTarget('/foo bar');
    }

    public function testRequestTargetDefaultsToSlash()
    {
        $r1 = new Request('GET', '');
        self::assertSame('/', $r1-&gt;getRequestTarget());
        $r2 = new Request('GET', '*');
        self::assertSame('*', $r2-&gt;getRequestTarget());
        $r3 = new Request('GET', 'http://foo.com/bar baz/');
        self::assertSame('/bar%20baz/', $r3-&gt;getRequestTarget());
    }

    public function testBuildsRequestTarget()
    {
        $r1 = new Request('GET', 'http://foo.com/baz?bar=bam');
        self::assertSame('/baz?bar=bam', $r1-&gt;getRequestTarget());
    }

    public function testBuildsRequestTargetWithFalseyQuery()
    {
        $r1 = new Request('GET', 'http://foo.com/baz?0');
        self::assertSame('/baz?0', $r1-&gt;getRequestTarget());
    }

    public function testHostIsAddedFirst()
    {
        $r = new Request('GET', 'http://foo.com/baz?bar=bam', ['Foo' =&gt; 'Bar']);
        self::assertSame([
            'Host' =&gt; ['foo.com'],
            'Foo'  =&gt; ['Bar']
        ], $r-&gt;getHeaders());
    }

    public function testHeaderValueWithWhitespace()
    {
        $r = new Request('GET', 'https://example.com/', [
            'User-Agent' =&gt; 'Linux f0f489981e90 5.10.104-linuxkit 1 SMP Wed Mar 9 19:05:23 UTC 2022 x86_64'
        ]);
        self::assertSame([
            'Host' =&gt; ['example.com'],
            'User-Agent' =&gt; ['Linux f0f489981e90 5.10.104-linuxkit 1 SMP Wed Mar 9 19:05:23 UTC 2022 x86_64']
        ], $r-&gt;getHeaders());
    }

    public function testCanGetHeaderAsCsv()
    {
        $r = new Request('GET', 'http://foo.com/baz?bar=bam', [
            'Foo' =&gt; ['a', 'b', 'c']
        ]);
        self::assertSame('a, b, c', $r-&gt;getHeaderLine('Foo'));
        self::assertSame('', $r-&gt;getHeaderLine('Bar'));
    }

    public function testHostIsNotOverwrittenWhenPreservingHost()
    {
        $r = new Request('GET', 'http://foo.com/baz?bar=bam', ['Host' =&gt; 'a.com']);
        self::assertSame(['Host' =&gt; ['a.com']], $r-&gt;getHeaders());
        $r2 = $r-&gt;withUri(new Uri('http://www.foo.com/bar'), true);
        self::assertSame('a.com', $r2-&gt;getHeaderLine('Host'));
    }

    public function testWithUriSetsHostIfNotSet()
    {
        $r = (new Request('GET', 'http://foo.com/baz?bar=bam'))-&gt;withoutHeader('Host');
        self::assertSame([], $r-&gt;getHeaders());
        $r2 = $r-&gt;withUri(new Uri('http://www.baz.com/bar'), true);
        self::assertSame('www.baz.com', $r2-&gt;getHeaderLine('Host'));
    }

    public function testOverridesHostWithUri()
    {
        $r = new Request('GET', 'http://foo.com/baz?bar=bam');
        self::assertSame(['Host' =&gt; ['foo.com']], $r-&gt;getHeaders());
        $r2 = $r-&gt;withUri(new Uri('http://www.baz.com/bar'));
        self::assertSame('www.baz.com', $r2-&gt;getHeaderLine('Host'));
    }

    public function testAggregatesHeaders()
    {
        $r = new Request('GET', '', [
            'ZOO' =&gt; 'zoobar',
            'zoo' =&gt; ['foobar', 'zoobar']
        ]);
        self::assertSame(['ZOO' =&gt; ['zoobar', 'foobar', 'zoobar']], $r-&gt;getHeaders());
        self::assertSame('zoobar, foobar, zoobar', $r-&gt;getHeaderLine('zoo'));
    }

    public function testAddsPortToHeader()
    {
        $r = new Request('GET', 'http://foo.com:8124/bar');
        self::assertSame('foo.com:8124', $r-&gt;getHeaderLine('host'));
    }

    public function testAddsPortToHeaderAndReplacePreviousPort()
    {
        $r = new Request('GET', 'http://foo.com:8124/bar');
        $r = $r-&gt;withUri(new Uri('http://foo.com:8125/bar'));
        self::assertSame('foo.com:8125', $r-&gt;getHeaderLine('host'));
    }

    /**
     * @dataProvider provideHeaderValuesContainingNotAllowedChars
     */
    public function testContainsNotAllowedCharsOnHeaderValue($value)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', sprintf('&quot;%s&quot; is not valid header value', $value));
        $r = new Request(
            'GET',
            'http://foo.com/baz?bar=bam',
            [
                'testing' =&gt; $value
            ]
        );
    }

    /**
     * @return iterable
     */
    public function provideHeaderValuesContainingNotAllowedChars()
    {
        // Explicit tests for newlines as the most common exploit vector.
        $tests = [
            [&quot;new\nline&quot;],
            [&quot;new\r\nline&quot;],
            [&quot;new\rline&quot;],
            // Line folding is technically allowed, but deprecated.
            // We don't support it.
            [&quot;new\r\n line&quot;],
            [&quot;newline\n&quot;],
            [&quot;\nnewline&quot;],
            [&quot;newline\r\n&quot;],
            [&quot;\r\nnewline&quot;],
        ];

        for ($i = 0; $i &lt;= 0xff; $i++) {
            if (\chr($i) == &quot;\t&quot;) {
                continue;
            }
            if (\chr($i) == &quot; &quot;) {
                continue;
            }
            if ($i &gt;= 0x21 &amp;&amp; $i &lt;= 0x7e) {
                continue;
            }
            if ($i &gt;= 0x80) {
                continue;
            }

            $tests[] = [&quot;foo&quot; . \chr($i) . &quot;bar&quot;];
            $tests[] = [&quot;foo&quot; . \chr($i)];
        }

        return $tests;
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Fvendor%2Fguzzlehttp%2Fpsr7%2Ftests'>🔙 Back</a>