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

namespace GuzzleHttp\Tests\Psr7;

use GuzzleHttp\Psr7\Stream;

/**
 * @covers GuzzleHttp\Psr7\Stream
 */
class StreamTest extends BaseTest
{
    public static $isFReadError = false;

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

        new Stream(true);
    }

    public function testConstructorInitializesProperties()
    {
        $handle = fopen('php://temp', 'r+');
        fwrite($handle, 'data');
        $stream = new Stream($handle);
        self::assertTrue($stream-&gt;isReadable());
        self::assertTrue($stream-&gt;isWritable());
        self::assertTrue($stream-&gt;isSeekable());
        self::assertSame('php://temp', $stream-&gt;getMetadata('uri'));
        $this-&gt;assertInternalTypeGuzzle('array', $stream-&gt;getMetadata());
        self::assertSame(4, $stream-&gt;getSize());
        self::assertFalse($stream-&gt;eof());
        $stream-&gt;close();
    }

    public function testConstructorInitializesPropertiesWithRbPlus()
    {
        $handle = fopen('php://temp', 'rb+');
        fwrite($handle, 'data');
        $stream = new Stream($handle);
        self::assertTrue($stream-&gt;isReadable());
        self::assertTrue($stream-&gt;isWritable());
        self::assertTrue($stream-&gt;isSeekable());
        self::assertSame('php://temp', $stream-&gt;getMetadata('uri'));
        $this-&gt;assertInternalTypeGuzzle('array', $stream-&gt;getMetadata());
        self::assertSame(4, $stream-&gt;getSize());
        self::assertFalse($stream-&gt;eof());
        $stream-&gt;close();
    }

    public function testStreamClosesHandleOnDestruct()
    {
        $handle = fopen('php://temp', 'r');
        $stream = new Stream($handle);
        unset($stream);
        self::assertFalse(is_resource($handle));
    }

    public function testConvertsToString()
    {
        $handle = fopen('php://temp', 'w+');
        fwrite($handle, 'data');
        $stream = new Stream($handle);
        self::assertSame('data', (string) $stream);
        self::assertSame('data', (string) $stream);
        $stream-&gt;close();
    }

    public function testConvertsToStringNonSeekableStream()
    {
        if (defined('HHVM_VERSION')) {
            self::markTestSkipped('This does not work on HHVM.');
        }

        $handle = popen('echo foo', 'r');
        $stream = new Stream($handle);
        self::assertFalse($stream-&gt;isSeekable());
        self::assertSame('foo', trim((string) $stream));
    }

    public function testConvertsToStringNonSeekablePartiallyReadStream()
    {
        if (defined('HHVM_VERSION')) {
            self::markTestSkipped('This does not work on HHVM.');
        }

        $handle = popen('echo bar', 'r');
        $stream = new Stream($handle);
        $firstLetter = $stream-&gt;read(1);
        self::assertFalse($stream-&gt;isSeekable());
        self::assertSame('b', $firstLetter);
        self::assertSame('ar', trim((string) $stream));
    }

    public function testGetsContents()
    {
        $handle = fopen('php://temp', 'w+');
        fwrite($handle, 'data');
        $stream = new Stream($handle);
        self::assertSame('', $stream-&gt;getContents());
        $stream-&gt;seek(0);
        self::assertSame('data', $stream-&gt;getContents());
        self::assertSame('', $stream-&gt;getContents());
        $stream-&gt;close();
    }

    public function testChecksEof()
    {
        $handle = fopen('php://temp', 'w+');
        fwrite($handle, 'data');
        $stream = new Stream($handle);
        self::assertSame(4, $stream-&gt;tell(), 'Stream cursor already at the end');
        self::assertFalse($stream-&gt;eof(), 'Stream still not eof');
        self::assertSame('', $stream-&gt;read(1), 'Need to read one more byte to reach eof');
        self::assertTrue($stream-&gt;eof());
        $stream-&gt;close();
    }

    public function testGetSize()
    {
        $size = filesize(__FILE__);
        $handle = fopen(__FILE__, 'r');
        $stream = new Stream($handle);
        self::assertSame($size, $stream-&gt;getSize());
        // Load from cache
        self::assertSame($size, $stream-&gt;getSize());
        $stream-&gt;close();
    }

    public function testEnsuresSizeIsConsistent()
    {
        $h = fopen('php://temp', 'w+');
        self::assertSame(3, fwrite($h, 'foo'));
        $stream = new Stream($h);
        self::assertSame(3, $stream-&gt;getSize());
        self::assertSame(4, $stream-&gt;write('test'));
        self::assertSame(7, $stream-&gt;getSize());
        self::assertSame(7, $stream-&gt;getSize());
        $stream-&gt;close();
    }

    public function testProvidesStreamPosition()
    {
        $handle = fopen('php://temp', 'w+');
        $stream = new Stream($handle);
        self::assertSame(0, $stream-&gt;tell());
        $stream-&gt;write('foo');
        self::assertSame(3, $stream-&gt;tell());
        $stream-&gt;seek(1);
        self::assertSame(1, $stream-&gt;tell());
        self::assertSame(ftell($handle), $stream-&gt;tell());
        $stream-&gt;close();
    }

    public function testDetachStreamAndClearProperties()
    {
        $handle = fopen('php://temp', 'r');
        $stream = new Stream($handle);
        self::assertSame($handle, $stream-&gt;detach());
        $this-&gt;assertInternalTypeGuzzle('resource', $handle, 'Stream is not closed');
        self::assertNull($stream-&gt;detach());

        $this-&gt;assertStreamStateAfterClosedOrDetached($stream);

        $stream-&gt;close();
    }

    public function testCloseResourceAndClearProperties()
    {
        $handle = fopen('php://temp', 'r');
        $stream = new Stream($handle);
        $stream-&gt;close();

        self::assertFalse(is_resource($handle));

        $this-&gt;assertStreamStateAfterClosedOrDetached($stream);
    }

    private function assertStreamStateAfterClosedOrDetached(Stream $stream)
    {
        self::assertFalse($stream-&gt;isReadable());
        self::assertFalse($stream-&gt;isWritable());
        self::assertFalse($stream-&gt;isSeekable());
        self::assertNull($stream-&gt;getSize());
        self::assertSame([], $stream-&gt;getMetadata());
        self::assertNull($stream-&gt;getMetadata('foo'));

        $throws = function (callable $fn) {
            try {
                $fn();
            } catch (\Exception $e) {
                $this-&gt;assertStringContainsStringGuzzle('Stream is detached', $e-&gt;getMessage());

                return;
            }

            $this-&gt;fail('Exception should be thrown after the stream is detached.');
        };

        $throws(function () use ($stream) {
            $stream-&gt;read(10);
        });
        $throws(function () use ($stream) {
            $stream-&gt;write('bar');
        });
        $throws(function () use ($stream) {
            $stream-&gt;seek(10);
        });
        $throws(function () use ($stream) {
            $stream-&gt;tell();
        });
        $throws(function () use ($stream) {
            $stream-&gt;eof();
        });
        $throws(function () use ($stream) {
            $stream-&gt;getContents();
        });
        self::assertSame('', (string) $stream);
    }

    public function testStreamReadingWithZeroLength()
    {
        $r = fopen('php://temp', 'r');
        $stream = new Stream($r);

        self::assertSame('', $stream-&gt;read(0));

        $stream-&gt;close();
    }

    public function testStreamReadingWithNegativeLength()
    {
        $r = fopen('php://temp', 'r');
        $stream = new Stream($r);

        $this-&gt;expectExceptionGuzzle('RuntimeException', 'Length parameter cannot be negative');

        try {
            $stream-&gt;read(-1);
        } catch (\Exception $e) {
            $stream-&gt;close();
            throw $e;
        }

        $stream-&gt;close();
    }

    public function testStreamReadingFreadError()
    {
        self::$isFReadError = true;
        $r = fopen('php://temp', 'r');
        $stream = new Stream($r);

        $this-&gt;expectExceptionGuzzle('RuntimeException', 'Unable to read from stream');

        try {
            $stream-&gt;read(1);
        } catch (\Exception $e) {
            self::$isFReadError = false;
            $stream-&gt;close();
            throw $e;
        }

        self::$isFReadError = false;
        $stream-&gt;close();
    }

    /**
     * @dataProvider gzipModeProvider
     *
     * @param string $mode
     * @param bool   $readable
     * @param bool   $writable
     */
    public function testGzipStreamModes($mode, $readable, $writable)
    {
        if (defined('HHVM_VERSION')) {
            self::markTestSkipped('This does not work on HHVM.');
        }

        $r = gzopen('php://temp', $mode);
        $stream = new Stream($r);

        self::assertSame($readable, $stream-&gt;isReadable());
        self::assertSame($writable, $stream-&gt;isWritable());

        $stream-&gt;close();
    }

    public function gzipModeProvider()
    {
        return [
            ['mode' =&gt; 'rb9', 'readable' =&gt; true, 'writable' =&gt; false],
            ['mode' =&gt; 'wb2', 'readable' =&gt; false, 'writable' =&gt; true],
        ];
    }

    /**
     * @dataProvider readableModeProvider
     *
     * @param string $mode
     */
    public function testReadableStream($mode)
    {
        $r = fopen('php://temp', $mode);
        $stream = new Stream($r);

        self::assertTrue($stream-&gt;isReadable());

        $stream-&gt;close();
    }

    public function readableModeProvider()
    {
        return [
            ['r'],
            ['w+'],
            ['r+'],
            ['x+'],
            ['c+'],
            ['rb'],
            ['w+b'],
            ['r+b'],
            ['x+b'],
            ['c+b'],
            ['rt'],
            ['w+t'],
            ['r+t'],
            ['x+t'],
            ['c+t'],
            ['a+'],
            ['rb+'],
        ];
    }

    public function testWriteOnlyStreamIsNotReadable()
    {
        $r = fopen('php://output', 'w');
        $stream = new Stream($r);

        self::assertFalse($stream-&gt;isReadable());

        $stream-&gt;close();
    }

    /**
     * @dataProvider writableModeProvider
     *
     * @param string $mode
     */
    public function testWritableStream($mode)
    {
        $r = fopen('php://temp', $mode);
        $stream = new Stream($r);

        self::assertTrue($stream-&gt;isWritable());

        $stream-&gt;close();
    }

    public function writableModeProvider()
    {
        return [
            ['w'],
            ['w+'],
            ['rw'],
            ['r+'],
            ['x+'],
            ['c+'],
            ['wb'],
            ['w+b'],
            ['r+b'],
            ['rb+'],
            ['x+b'],
            ['c+b'],
            ['w+t'],
            ['r+t'],
            ['x+t'],
            ['c+t'],
            ['a'],
            ['a+'],
        ];
    }

    public function testReadOnlyStreamIsNotWritable()
    {
        $r = fopen('php://input', 'r');
        $stream = new Stream($r);

        self::assertFalse($stream-&gt;isWritable());

        $stream-&gt;close();
    }
}

namespace GuzzleHttp\Psr7;

use GuzzleHttp\Tests\Psr7\StreamTest;

function fread($handle, $length)
{
    return StreamTest::$isFReadError ? false : \fread($handle, $length);
}
</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>