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

namespace GuzzleHttp\Tests\Psr7;

use GuzzleHttp\Psr7;
use GuzzleHttp\Psr7\FnStream;
use GuzzleHttp\Psr7\NoSeekStream;

class UtilsTest extends BaseTest
{
    public function testCopiesToString()
    {
        $s = Psr7\Utils::streamFor('foobaz');
        self::assertSame('foobaz', Psr7\Utils::copyToString($s));
        $s-&gt;seek(0);
        self::assertSame('foo', Psr7\Utils::copyToString($s, 3));
        self::assertSame('baz', Psr7\Utils::copyToString($s, 3));
        self::assertSame('', Psr7\Utils::copyToString($s));
    }

    public function testCopiesToStringStopsWhenReadFails()
    {
        $s1 = Psr7\Utils::streamFor('foobaz');
        $s1 = FnStream::decorate($s1, [
            'read' =&gt; function () {
                return '';
            },
        ]);
        $result = Psr7\Utils::copyToString($s1);
        self::assertSame('', $result);
    }

    public function testCopiesToStream()
    {
        $s1 = Psr7\Utils::streamFor('foobaz');
        $s2 = Psr7\Utils::streamFor('');
        Psr7\Utils::copyToStream($s1, $s2);
        self::assertSame('foobaz', (string)$s2);
        $s2 = Psr7\Utils::streamFor('');
        $s1-&gt;seek(0);
        Psr7\Utils::copyToStream($s1, $s2, 3);
        self::assertSame('foo', (string)$s2);
        Psr7\Utils::copyToStream($s1, $s2, 3);
        self::assertSame('foobaz', (string)$s2);
    }

    public function testStopsCopyToStreamWhenWriteFails()
    {
        $s1 = Psr7\Utils::streamFor('foobaz');
        $s2 = Psr7\Utils::streamFor('');
        $s2 = FnStream::decorate($s2, [
            'write' =&gt; function () {
                return 0;
            },
        ]);
        Psr7\Utils::copyToStream($s1, $s2);
        self::assertSame('', (string)$s2);
    }

    public function testStopsCopyToSteamWhenWriteFailsWithMaxLen()
    {
        $s1 = Psr7\Utils::streamFor('foobaz');
        $s2 = Psr7\Utils::streamFor('');
        $s2 = FnStream::decorate($s2, [
            'write' =&gt; function () {
                return 0;
            },
        ]);
        Psr7\Utils::copyToStream($s1, $s2, 10);
        self::assertSame('', (string)$s2);
    }

    public function testCopyToStreamReadsInChunksInsteadOfAllInMemory()
    {
        $sizes = [];
        $s1 = new Psr7\FnStream([
            'eof' =&gt; function () {
                return false;
            },
            'read' =&gt; function ($size) use (&amp;$sizes) {
                $sizes[] = $size;
                return str_repeat('.', $size);
            },
        ]);
        $s2 = Psr7\Utils::streamFor('');
        Psr7\Utils::copyToStream($s1, $s2, 16394);
        $s2-&gt;seek(0);
        self::assertSame(16394, strlen($s2-&gt;getContents()));
        self::assertSame(8192, $sizes[0]);
        self::assertSame(8192, $sizes[1]);
        self::assertSame(10, $sizes[2]);
    }

    public function testStopsCopyToSteamWhenReadFailsWithMaxLen()
    {
        $s1 = Psr7\Utils::streamFor('foobaz');
        $s1 = FnStream::decorate($s1, [
            'read' =&gt; function () {
                return '';
            },
        ]);
        $s2 = Psr7\Utils::streamFor('');
        Psr7\Utils::copyToStream($s1, $s2, 10);
        self::assertSame('', (string)$s2);
    }

    public function testReadsLines()
    {
        $s = Psr7\Utils::streamFor(&quot;foo\nbaz\nbar&quot;);
        self::assertSame(&quot;foo\n&quot;, Psr7\Utils::readLine($s));
        self::assertSame(&quot;baz\n&quot;, Psr7\Utils::readLine($s));
        self::assertSame('bar', Psr7\Utils::readLine($s));
    }

    public function testReadsLinesUpToMaxLength()
    {
        $s = Psr7\Utils::streamFor(&quot;12345\n&quot;);
        self::assertSame('123', Psr7\Utils::readLine($s, 4));
        self::assertSame(&quot;45\n&quot;, Psr7\Utils::readLine($s));
    }

    public function testReadLinesEof()
    {
        // Should return empty string on EOF
        $s = Psr7\Utils::streamFor(&quot;foo\nbar&quot;);
        while (!$s-&gt;eof()) {
            Psr7\Utils::readLine($s);
        }
        self::assertSame('', Psr7\Utils::readLine($s));
    }

    public function testReadsLineUntilFalseReturnedFromRead()
    {
        $s = $this-&gt;getMockBuilder('GuzzleHttp\Psr7\Stream')
            -&gt;setMethods(['read', 'eof'])
            -&gt;disableOriginalConstructor()
            -&gt;getMock();
        $s-&gt;expects(self::exactly(2))
            -&gt;method('read')
            -&gt;will(self::returnCallback(function () {
                static $c = false;
                if ($c) {
                    return false;
                }
                $c = true;
                return 'h';
            }));
        $s-&gt;expects(self::exactly(2))
            -&gt;method('eof')
            -&gt;will(self::returnValue(false));
        self::assertSame('h', Psr7\Utils::readLine($s));
    }

    public function testCalculatesHash()
    {
        $s = Psr7\Utils::streamFor('foobazbar');
        self::assertSame(md5('foobazbar'), Psr7\Utils::hash($s, 'md5'));
    }

    public function testCalculatesHashThrowsWhenSeekFails()
    {
        $s = new NoSeekStream(Psr7\Utils::streamFor('foobazbar'));
        $s-&gt;read(2);

        $this-&gt;expectExceptionGuzzle('RuntimeException');

        Psr7\Utils::hash($s, 'md5');
    }

    public function testCalculatesHashSeeksToOriginalPosition()
    {
        $s = Psr7\Utils::streamFor('foobazbar');
        $s-&gt;seek(4);
        self::assertSame(md5('foobazbar'), Psr7\Utils::hash($s, 'md5'));
        self::assertSame(4, $s-&gt;tell());
    }

    public function testOpensFilesSuccessfully()
    {
        $r = Psr7\Utils::tryFopen(__FILE__, 'r');
        $this-&gt;assertInternalTypeGuzzle('resource', $r);
        fclose($r);
    }

    public function testThrowsExceptionNotWarning()
    {
        $this-&gt;expectExceptionGuzzle('RuntimeException', 'Unable to open &quot;/path/to/does/not/exist&quot; using mode &quot;r&quot;');

        Psr7\Utils::tryFopen('/path/to/does/not/exist', 'r');
    }

    public function testThrowsExceptionNotValueError()
    {
        $this-&gt;expectExceptionGuzzle('RuntimeException', 'Unable to open &quot;&quot; using mode &quot;r&quot;');

        Psr7\Utils::tryFopen('', 'r');
    }

    public function testCreatesUriForValue()
    {
        self::assertInstanceOf('GuzzleHttp\Psr7\Uri', Psr7\Utils::uriFor('/foo'));
        self::assertInstanceOf(
            'GuzzleHttp\Psr7\Uri',
            Psr7\Utils::uriFor(new Psr7\Uri('/foo'))
        );
    }

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

        Psr7\Utils::uriFor([]);
    }

    public function testKeepsPositionOfResource()
    {
        $h = fopen(__FILE__, 'r');
        fseek($h, 10);
        $stream = Psr7\Utils::streamFor($h);
        self::assertSame(10, $stream-&gt;tell());
        $stream-&gt;close();
    }

    public function testCreatesWithFactory()
    {
        $stream = Psr7\Utils::streamFor('foo');
        self::assertInstanceOf('GuzzleHttp\Psr7\Stream', $stream);
        self::assertSame('foo', $stream-&gt;getContents());
        $stream-&gt;close();
    }

    public function testFactoryCreatesFromEmptyString()
    {
        $s = Psr7\Utils::streamFor();
        self::assertInstanceOf('GuzzleHttp\Psr7\Stream', $s);
    }

    public function testFactoryCreatesFromNull()
    {
        $s = Psr7\Utils::streamFor(null);
        self::assertInstanceOf('GuzzleHttp\Psr7\Stream', $s);
    }

    public function testFactoryCreatesFromResource()
    {
        $r = fopen(__FILE__, 'r');
        $s = Psr7\Utils::streamFor($r);
        self::assertInstanceOf('GuzzleHttp\Psr7\Stream', $s);
        self::assertSame(file_get_contents(__FILE__), (string)$s);
    }

    public function testFactoryCreatesFromObjectWithToString()
    {
        $r = new HasToString();
        $s = Psr7\Utils::streamFor($r);
        self::assertInstanceOf('GuzzleHttp\Psr7\Stream', $s);
        self::assertSame('foo', (string)$s);
    }

    public function testCreatePassesThrough()
    {
        $s = Psr7\Utils::streamFor('foo');
        self::assertSame($s, Psr7\Utils::streamFor($s));
    }

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

        Psr7\Utils::streamFor(new \stdClass());
    }

    public function testReturnsCustomMetadata()
    {
        $s = Psr7\Utils::streamFor('foo', ['metadata' =&gt; ['hwm' =&gt; 3]]);
        self::assertSame(3, $s-&gt;getMetadata('hwm'));
        self::assertArrayHasKey('hwm', $s-&gt;getMetadata());
    }

    public function testCanSetSize()
    {
        $s = Psr7\Utils::streamFor('', ['size' =&gt; 10]);
        self::assertSame(10, $s-&gt;getSize());
    }

    public function testCanCreateIteratorBasedStream()
    {
        $a = new \ArrayIterator(['foo', 'bar', '123']);
        $p = Psr7\Utils::streamFor($a);
        self::assertInstanceOf('GuzzleHttp\Psr7\PumpStream', $p);
        self::assertSame('foo', $p-&gt;read(3));
        self::assertFalse($p-&gt;eof());
        self::assertSame('b', $p-&gt;read(1));
        self::assertSame('a', $p-&gt;read(1));
        self::assertSame('r12', $p-&gt;read(3));
        self::assertFalse($p-&gt;eof());
        self::assertSame('3', $p-&gt;getContents());
        self::assertTrue($p-&gt;eof());
        self::assertSame(9, $p-&gt;tell());
    }

    public function testConvertsRequestsToStrings()
    {
        $request = new Psr7\Request('PUT', 'http://foo.com/hi?123', [
            'Baz' =&gt; 'bar',
            'Qux' =&gt; 'ipsum',
        ], 'hello', '1.0');
        self::assertSame(
            &quot;PUT /hi?123 HTTP/1.0\r\nHost: foo.com\r\nBaz: bar\r\nQux: ipsum\r\n\r\nhello&quot;,
            Psr7\Message::toString($request)
        );
    }

    public function testConvertsResponsesToStrings()
    {
        $response = new Psr7\Response(200, [
            'Baz' =&gt; 'bar',
            'Qux' =&gt; 'ipsum',
        ], 'hello', '1.0', 'FOO');
        self::assertSame(
            &quot;HTTP/1.0 200 FOO\r\nBaz: bar\r\nQux: ipsum\r\n\r\nhello&quot;,
            Psr7\Message::toString($response)
        );
    }

    public function testCorrectlyRendersSetCookieHeadersToString()
    {
        $response = new Psr7\Response(200, [
            'Set-Cookie' =&gt; ['bar','baz','qux']
        ], 'hello', '1.0', 'FOO');
        self::assertSame(
            &quot;HTTP/1.0 200 FOO\r\nSet-Cookie: bar\r\nSet-Cookie: baz\r\nSet-Cookie: qux\r\n\r\nhello&quot;,
            Psr7\Message::toString($response)
        );
    }

    public function testCanModifyRequestWithUri()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, [
            'uri' =&gt; new Psr7\Uri('http://www.foo.com'),
        ]);
        self::assertSame('http://www.foo.com', (string)$r2-&gt;getUri());
        self::assertSame('www.foo.com', (string)$r2-&gt;getHeaderLine('host'));
    }

    public function testCanModifyRequestWithUriAndPort()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com:8000');
        $r2 = Psr7\Utils::modifyRequest($r1, [
            'uri' =&gt; new Psr7\Uri('http://www.foo.com:8000'),
        ]);
        self::assertSame('http://www.foo.com:8000', (string)$r2-&gt;getUri());
        self::assertSame('www.foo.com:8000', (string)$r2-&gt;getHeaderLine('host'));
    }

    public function testCanModifyRequestWithCaseInsensitiveHeader()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com', ['User-Agent' =&gt; 'foo']);
        $r2 = Psr7\Utils::modifyRequest($r1, ['set_headers' =&gt; ['User-agent' =&gt; 'bar']]);
        self::assertSame('bar', $r2-&gt;getHeaderLine('User-Agent'));
        self::assertSame('bar', $r2-&gt;getHeaderLine('User-agent'));
    }

    public function testReturnsAsIsWhenNoChanges()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, []);
        self::assertInstanceOf('GuzzleHttp\Psr7\Request', $r2);

        $r1 = new Psr7\ServerRequest('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, []);
        self::assertInstanceOf('Psr\Http\Message\ServerRequestInterface', $r2);
    }

    public function testReturnsUriAsIsWhenNoChanges()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, ['set_headers' =&gt; ['foo' =&gt; 'bar']]);
        self::assertNotSame($r1, $r2);
        self::assertSame('bar', $r2-&gt;getHeaderLine('foo'));
    }

    public function testRemovesHeadersFromMessage()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com', ['foo' =&gt; 'bar']);
        $r2 = Psr7\Utils::modifyRequest($r1, ['remove_headers' =&gt; ['foo']]);
        self::assertNotSame($r1, $r2);
        self::assertFalse($r2-&gt;hasHeader('foo'));
    }

    public function testAddsQueryToUri()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, ['query' =&gt; 'foo=bar']);
        self::assertNotSame($r1, $r2);
        self::assertSame('foo=bar', $r2-&gt;getUri()-&gt;getQuery());
    }

    public function testModifyRequestKeepInstanceOfRequest()
    {
        $r1 = new Psr7\Request('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, ['remove_headers' =&gt; ['non-existent']]);
        self::assertInstanceOf('GuzzleHttp\Psr7\Request', $r2);

        $r1 = new Psr7\ServerRequest('GET', 'http://foo.com');
        $r2 = Psr7\Utils::modifyRequest($r1, ['remove_headers' =&gt; ['non-existent']]);
        self::assertInstanceOf('Psr\Http\Message\ServerRequestInterface', $r2);
    }

    public function testModifyServerRequestWithUploadedFiles()
    {
        $request = new Psr7\ServerRequest('GET', 'http://example.com/bla');
        $file = new Psr7\UploadedFile('Test', 100, \UPLOAD_ERR_OK);
        $request = $request-&gt;withUploadedFiles([$file]);

        /** @var Psr7\ServerRequest $modifiedRequest */
        $modifiedRequest = Psr7\Utils::modifyRequest($request, ['set_headers' =&gt; ['foo' =&gt; 'bar']]);

        self::assertCount(1, $modifiedRequest-&gt;getUploadedFiles());

        $files = $modifiedRequest-&gt;getUploadedFiles();
        self::assertInstanceOf('GuzzleHttp\Psr7\UploadedFile', $files[0]);
    }

    public function testModifyServerRequestWithCookies()
    {
        $request = (new Psr7\ServerRequest('GET', 'http://example.com/bla'))
            -&gt;withCookieParams(['name' =&gt; 'value']);

        /** @var Psr7\ServerRequest $modifiedRequest */
        $modifiedRequest = Psr7\Utils::modifyRequest($request, ['set_headers' =&gt; ['foo' =&gt; 'bar']]);

        self::assertSame(['name' =&gt; 'value'], $modifiedRequest-&gt;getCookieParams());
    }

    public function testModifyServerRequestParsedBody()
    {
        $request = (new Psr7\ServerRequest('GET', 'http://example.com/bla'))
            -&gt;withParsedBody(['name' =&gt; 'value']);

        /** @var Psr7\ServerRequest $modifiedRequest */
        $modifiedRequest = Psr7\Utils::modifyRequest($request, ['set_headers' =&gt; ['foo' =&gt; 'bar']]);

        self::assertSame(['name' =&gt; 'value'], $modifiedRequest-&gt;getParsedBody());
    }

    public function testModifyServerRequestQueryParams()
    {
        $request = (new Psr7\ServerRequest('GET', 'http://example.com/bla'))
            -&gt;withQueryParams(['name' =&gt; 'value']);

        /** @var Psr7\ServerRequest $modifiedRequest */
        $modifiedRequest = Psr7\Utils::modifyRequest($request, ['set_headers' =&gt; ['foo' =&gt; 'bar']]);

        self::assertSame(['name' =&gt; 'value'], $modifiedRequest-&gt;getQueryParams());
    }

    public function testModifyServerRequestRetainsAttributes()
    {
        $request = (new Psr7\ServerRequest('GET', 'http://example.com/bla'))
            -&gt;withAttribute('foo', 'bar');

        /** @var Psr7\ServerRequest $modifiedRequest */
        $modifiedRequest = Psr7\Utils::modifyRequest($request, []);

        self::assertSame(['foo' =&gt; 'bar'], $modifiedRequest-&gt;getAttributes());
    }
}
</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>