Cleaned up UploadedFileTest by providing return types and parameter types everywhere

Ocramius · Ocramius · commit 091487a175a4 · 2022-07-06T11:21:17.000+02:00
diff --git a/psalm-baseline.xml b/psalm-baseline.xml
@@ -1164,54 +1164,10 @@
     </MissingReturnType>
   </file>
   <file src="test/UploadedFileTest.php">
-    <MissingParamType occurrences="6">
-      <code>$path</code>
-      <code>$status</code>
-      <code>$status</code>
-      <code>$status</code>
-      <code>$status</code>
-      <code>$streamOrFile</code>
-    </MissingParamType>
-    <MissingPropertyType occurrences="1">
-      <code>$tmpFile</code>
-    </MissingPropertyType>
-    <MissingReturnType occurrences="24">
-      <code>errorConstantsAndMessages</code>
-      <code>invalidErrorStatuses</code>
-      <code>invalidMovePaths</code>
-      <code>invalidStreams</code>
-      <code>nonOkErrorStatus</code>
-      <code>testCannotRetrieveStreamAfterMove</code>
-      <code>testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent</code>
-      <code>testGetStreamRaisesExceptionWhenErrorStatusPresent</code>
-      <code>testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected</code>
-      <code>testGetStreamReturnsOriginalStreamObject</code>
-      <code>testGetStreamReturnsStreamForFile</code>
-      <code>testGetStreamReturnsWrappedPhpStream</code>
-      <code>testMoveCannotBeCalledMoreThanOnce</code>
-      <code>testMoveRaisesExceptionForInvalidPath</code>
-      <code>testMoveToCreatesStreamIfOnlyAFilenameWasProvided</code>
-      <code>testMoveToRaisesExceptionWhenErrorStatusPresent</code>
-      <code>testMoveToRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected</code>
-      <code>testMovesFileToDesignatedPath</code>
-      <code>testRaisesExceptionOnInvalidErrorStatus</code>
-      <code>testRaisesExceptionOnInvalidStreamOrFile</code>
-      <code>testValidClientFilename</code>
-      <code>testValidClientMediaType</code>
-      <code>testValidNullClientFilename</code>
-      <code>testValidSize</code>
-    </MissingReturnType>
-    <MixedArgument occurrences="6">
+    <MixedArgument occurrences="2">
       <code>$path</code>
-      <code>$status</code>
-      <code>$status</code>
-      <code>$status</code>
-      <code>$status</code>
       <code>$streamOrFile</code>
     </MixedArgument>
-    <UndefinedThisPropertyAssignment occurrences="1">
-      <code>$this-&gt;tmpfile</code>
-    </UndefinedThisPropertyAssignment>
   </file>
   <file src="test/UriTest.php">
     <InvalidScalarArgument occurrences="2">
diff --git a/test/UploadedFileTest.php b/test/UploadedFileTest.php
@@ -30,12 +30,13 @@
 use const UPLOAD_ERR_OK;
 use const UPLOAD_ERR_PARTIAL;
 
-class UploadedFileTest extends TestCase
+final class UploadedFileTest extends TestCase
 {
     /** @var false|null|string */
-    protected $orgFile;
+    private $orgFile;
 
-    protected $tmpFile;
+    /** @var mixed */
+    private $tmpFile;
 
     protected function setUp() : void
     {
@@ -54,7 +55,8 @@ protected function tearDown() : void
         }
     }
 
-    public function invalidStreams()
+    /** @return non-empty-array<non-empty-string, array{mixed}> */
+    public function invalidStreams(): array
     {
         return [
             'null'         => [null],
@@ -73,22 +75,24 @@ public function invalidStreams()
 
     /**
      * @dataProvider invalidStreams
+     * @param mixed $streamOrFile
      */
-    public function testRaisesExceptionOnInvalidStreamOrFile($streamOrFile)
+    public function testRaisesExceptionOnInvalidStreamOrFile($streamOrFile): void
     {
         $this->expectException(InvalidArgumentException::class);
 
         new UploadedFile($streamOrFile, 0, UPLOAD_ERR_OK);
     }
 
-    public function testValidSize()
+    public function testValidSize(): void
     {
         $uploaded = new UploadedFile(fopen('php://temp', 'wb+'), 123, UPLOAD_ERR_OK);
 
         $this->assertSame(123, $uploaded->getSize());
     }
 
-    public function invalidErrorStatuses()
+    /** @return non-empty-array<non-empty-string, array{int}> */
+    public function invalidErrorStatuses(): array
     {
         return [
             'negative' => [-1],
@@ -99,48 +103,48 @@ public function invalidErrorStatuses()
     /**
      * @dataProvider invalidErrorStatuses
      */
-    public function testRaisesExceptionOnInvalidErrorStatus($status)
+    public function testRaisesExceptionOnInvalidErrorStatus(int $status): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('status');
 
         new UploadedFile(fopen('php://temp', 'wb+'), 0, $status);
     }
 
-    public function testValidClientFilename()
+    public function testValidClientFilename(): void
     {
         $file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, 'boo.txt');
         $this->assertSame('boo.txt', $file->getClientFilename());
     }
 
-    public function testValidNullClientFilename()
+    public function testValidNullClientFilename(): void
     {
         $file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, null);
         $this->assertSame(null, $file->getClientFilename());
     }
 
-    public function testValidClientMediaType()
+    public function testValidClientMediaType(): void
     {
         $file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, 'foobar.baz', 'mediatype');
         $this->assertSame('mediatype', $file->getClientMediaType());
     }
 
-    public function testGetStreamReturnsOriginalStreamObject()
+    public function testGetStreamReturnsOriginalStreamObject(): void
     {
         $stream = new Stream('php://temp');
         $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);
         $this->assertSame($stream, $upload->getStream());
     }
 
-    public function testGetStreamReturnsWrappedPhpStream()
+    public function testGetStreamReturnsWrappedPhpStream(): void
     {
         $stream = fopen('php://temp', 'wb+');
         $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);
         $uploadStream = $upload->getStream()->detach();
         $this->assertSame($stream, $uploadStream);
     }
 
-    public function testGetStreamReturnsStreamForFile()
+    public function testGetStreamReturnsStreamForFile(): void
     {
         $this->tmpFile = $stream = tempnam(sys_get_temp_dir(), 'diac');
         $upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);
@@ -150,10 +154,7 @@ public function testGetStreamReturnsStreamForFile()
         $this->assertSame($stream, $r->getValue($uploadStream));
     }
 
-    /**
-     * @return void
-     */
-    public function testMovesFileToDesignatedPath()
+    public function testMovesFileToDesignatedPath(): void
     {
         $originalContents = 'Foo bar!';
         $stream = new Stream('php://temp', 'wb+');
@@ -167,7 +168,8 @@ public function testMovesFileToDesignatedPath()
         $this->assertSame($originalContents, $contents);
     }
 
-    public function invalidMovePaths()
+    /** @return non-empty-array<non-empty-string, array{mixed}> */
+    public function invalidMovePaths(): array
     {
         return [
             'null'   => [null],
@@ -183,8 +185,10 @@ public function invalidMovePaths()
 
     /**
      * @dataProvider invalidMovePaths
+     *
+     * @param mixed $path
      */
-    public function testMoveRaisesExceptionForInvalidPath($path)
+    public function testMoveRaisesExceptionForInvalidPath($path): void
     {
         $stream = new Stream('php://temp', 'wb+');
         $stream->write('Foo bar!');
@@ -198,7 +202,7 @@ public function testMoveRaisesExceptionForInvalidPath($path)
         $upload->moveTo($path);
     }
 
-    public function testMoveCannotBeCalledMoreThanOnce()
+    public function testMoveCannotBeCalledMoreThanOnce(): void
     {
         $stream = new Stream('php://temp', 'wb+');
         $stream->write('Foo bar!');
@@ -214,7 +218,7 @@ public function testMoveCannotBeCalledMoreThanOnce()
         $upload->moveTo($to);
     }
 
-    public function testCannotRetrieveStreamAfterMove()
+    public function testCannotRetrieveStreamAfterMove(): void
     {
         $stream = new Stream('php://temp', 'wb+');
         $stream->write('Foo bar!');
@@ -230,7 +234,8 @@ public function testCannotRetrieveStreamAfterMove()
         $upload->getStream();
     }
 
-    public function nonOkErrorStatus()
+    /** @return non-empty-array<non-empty-string, array{positive-int}> */
+    public function nonOkErrorStatus(): array
     {
         return [
             'UPLOAD_ERR_INI_SIZE'   => [ UPLOAD_ERR_INI_SIZE ],
@@ -247,7 +252,7 @@ public function nonOkErrorStatus()
      * @dataProvider nonOkErrorStatus
      * @group 60
      */
-    public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent($status)
+    public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent(int $status): void
     {
         $uploadedFile = new UploadedFile('not ok', 0, $status);
         $this->assertSame($status, $uploadedFile->getError());
@@ -257,7 +262,7 @@ public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorSta
      * @dataProvider nonOkErrorStatus
      * @group 60
      */
-    public function testMoveToRaisesExceptionWhenErrorStatusPresent($status)
+    public function testMoveToRaisesExceptionWhenErrorStatusPresent(int $status): void
     {
         $uploadedFile = new UploadedFile('not ok', 0, $status);
 
@@ -271,7 +276,7 @@ public function testMoveToRaisesExceptionWhenErrorStatusPresent($status)
      * @dataProvider nonOkErrorStatus
      * @group 60
      */
-    public function testGetStreamRaisesExceptionWhenErrorStatusPresent($status)
+    public function testGetStreamRaisesExceptionWhenErrorStatusPresent(int $status): void
     {
         $uploadedFile = new UploadedFile('not ok', 0, $status);
 
@@ -283,9 +288,8 @@ public function testGetStreamRaisesExceptionWhenErrorStatusPresent($status)
 
     /**
      * @group 82
-     * @return void
      */
-    public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided()
+    public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided(): void
     {
         $this->orgFile = tempnam(sys_get_temp_dir(), 'ORG');
         $this->tmpFile = tempnam(sys_get_temp_dir(), 'DIA');
@@ -301,7 +305,8 @@ public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided()
         $this->assertSame($original, $contents);
     }
 
-    public function errorConstantsAndMessages()
+    /** @return iterable<int, array{int, non-empty-string}> */
+    public function errorConstantsAndMessages(): iterable
     {
         foreach (UploadedFile::ERROR_MESSAGES as $constant => $message) {
             if ($constant === UPLOAD_ERR_OK) {
@@ -311,13 +316,11 @@ public function errorConstantsAndMessages()
         }
     }
 
-    /**
-     * @dataProvider errorConstantsAndMessages
-     * @param int $constant Upload error constant
-     * @param string $message Associated error message
-     */
-    public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected($constant, $message)
-    {
+    /** @dataProvider errorConstantsAndMessages */
+    public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected(
+        int $constant,
+        string $message
+    ): void {
         $uploadedFile = new UploadedFile(__FILE__, 100, $constant);
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage($message);
@@ -326,21 +329,18 @@ public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErro
 
     /**
      * @dataProvider errorConstantsAndMessages
-     * @param int $constant Upload error constant
-     * @param string $message Associated error message
      */
-    public function testMoveToRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected($constant, $message)
-    {
+    public function testMoveToRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected(
+        int $constant,
+        string $message
+    ): void {
         $uploadedFile = new UploadedFile(__FILE__, 100, $constant);
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage($message);
         $uploadedFile->moveTo('/tmp/foo');
     }
 
-    /**
-     * @return void
-     */
-    public function testMoveToInCLIShouldRemoveOriginalFile()
+    public function testMoveToInCLIShouldRemoveOriginalFile(): void
     {
         $this->orgFile = tempnam(sys_get_temp_dir(), 'ORG');
         file_put_contents($this->orgFile, 'Hello');

Original file line number	Diff line number	Diff line change
`@@ -30,12 +30,13 @@`
`30`	`30`	`use const UPLOAD_ERR_OK;`
`31`	`31`	`use const UPLOAD_ERR_PARTIAL;`
`32`	`32`
`33`		`-class UploadedFileTest extends TestCase`
	`33`	`+final class UploadedFileTest extends TestCase`
`34`	`34`	`{`
`35`	`35`	`/** @var false\|null\|string */`
`36`		`- protected $orgFile;`
	`36`	`+ private $orgFile;`
`37`	`37`
`38`		`- protected $tmpFile;`
	`38`	`+ /** @var mixed */`
	`39`	`+ private $tmpFile;`
`39`	`40`
`40`	`41`	`protected function setUp() : void`
`41`	`42`	`{`
`@@ -54,7 +55,8 @@ protected function tearDown() : void`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`
`57`		`- public function invalidStreams()`
	`58`	`+ /** @return non-empty-array<non-empty-string, array{mixed}> */`
	`59`	`+ public function invalidStreams(): array`
`58`	`60`	`{`
`59`	`61`	`return [`
`60`	`62`	`'null' => [null],`
`@@ -73,22 +75,24 @@ public function invalidStreams()`
`73`	`75`
`74`	`76`	`/**`
`75`	`77`	`* @dataProvider invalidStreams`
	`78`	`+ * @param mixed $streamOrFile`
`76`	`79`	`*/`
`77`		`- public function testRaisesExceptionOnInvalidStreamOrFile($streamOrFile)`
	`80`	`+ public function testRaisesExceptionOnInvalidStreamOrFile($streamOrFile): void`
`78`	`81`	`{`
`79`	`82`	`$this->expectException(InvalidArgumentException::class);`
`80`	`83`
`81`	`84`	`new UploadedFile($streamOrFile, 0, UPLOAD_ERR_OK);`
`82`	`85`	`}`
`83`	`86`
`84`		`- public function testValidSize()`
	`87`	`+ public function testValidSize(): void`
`85`	`88`	`{`
`86`	`89`	`$uploaded = new UploadedFile(fopen('php://temp', 'wb+'), 123, UPLOAD_ERR_OK);`
`87`	`90`
`88`	`91`	`$this->assertSame(123, $uploaded->getSize());`
`89`	`92`	`}`
`90`	`93`
`91`		`- public function invalidErrorStatuses()`
	`94`	`+ /** @return non-empty-array<non-empty-string, array{int}> */`
	`95`	`+ public function invalidErrorStatuses(): array`
`92`	`96`	`{`
`93`	`97`	`return [`
`94`	`98`	`'negative' => [-1],`
`@@ -99,48 +103,48 @@ public function invalidErrorStatuses()`
`99`	`103`	`/**`
`100`	`104`	`* @dataProvider invalidErrorStatuses`
`101`	`105`	`*/`
`102`		`- public function testRaisesExceptionOnInvalidErrorStatus($status)`
	`106`	`+ public function testRaisesExceptionOnInvalidErrorStatus(int $status): void`
`103`	`107`	`{`
`104`	`108`	`$this->expectException(InvalidArgumentException::class);`
`105`	`109`	`$this->expectExceptionMessage('status');`
`106`	`110`
`107`	`111`	`new UploadedFile(fopen('php://temp', 'wb+'), 0, $status);`
`108`	`112`	`}`
`109`	`113`
`110`		`- public function testValidClientFilename()`
	`114`	`+ public function testValidClientFilename(): void`
`111`	`115`	`{`
`112`	`116`	`$file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, 'boo.txt');`
`113`	`117`	`$this->assertSame('boo.txt', $file->getClientFilename());`
`114`	`118`	`}`
`115`	`119`
`116`		`- public function testValidNullClientFilename()`
	`120`	`+ public function testValidNullClientFilename(): void`
`117`	`121`	`{`
`118`	`122`	`$file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, null);`
`119`	`123`	`$this->assertSame(null, $file->getClientFilename());`
`120`	`124`	`}`
`121`	`125`
`122`		`- public function testValidClientMediaType()`
	`126`	`+ public function testValidClientMediaType(): void`
`123`	`127`	`{`
`124`	`128`	`$file = new UploadedFile(fopen('php://temp', 'wb+'), 0, UPLOAD_ERR_OK, 'foobar.baz', 'mediatype');`
`125`	`129`	`$this->assertSame('mediatype', $file->getClientMediaType());`
`126`	`130`	`}`
`127`	`131`
`128`		`- public function testGetStreamReturnsOriginalStreamObject()`
	`132`	`+ public function testGetStreamReturnsOriginalStreamObject(): void`
`129`	`133`	`{`
`130`	`134`	`$stream = new Stream('php://temp');`
`131`	`135`	`$upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);`
`132`	`136`	`$this->assertSame($stream, $upload->getStream());`
`133`	`137`	`}`
`134`	`138`
`135`		`- public function testGetStreamReturnsWrappedPhpStream()`
	`139`	`+ public function testGetStreamReturnsWrappedPhpStream(): void`
`136`	`140`	`{`
`137`	`141`	`$stream = fopen('php://temp', 'wb+');`
`138`	`142`	`$upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);`
`139`	`143`	`$uploadStream = $upload->getStream()->detach();`
`140`	`144`	`$this->assertSame($stream, $uploadStream);`
`141`	`145`	`}`
`142`	`146`
`143`		`- public function testGetStreamReturnsStreamForFile()`
	`147`	`+ public function testGetStreamReturnsStreamForFile(): void`
`144`	`148`	`{`
`145`	`149`	`$this->tmpFile = $stream = tempnam(sys_get_temp_dir(), 'diac');`
`146`	`150`	`$upload = new UploadedFile($stream, 0, UPLOAD_ERR_OK);`
`@@ -150,10 +154,7 @@ public function testGetStreamReturnsStreamForFile()`
`150`	`154`	`$this->assertSame($stream, $r->getValue($uploadStream));`
`151`	`155`	`}`
`152`	`156`
`153`		`- /**`
`154`		`- * @return void`
`155`		`- */`
`156`		`- public function testMovesFileToDesignatedPath()`
	`157`	`+ public function testMovesFileToDesignatedPath(): void`
`157`	`158`	`{`
`158`	`159`	`$originalContents = 'Foo bar!';`
`159`	`160`	`$stream = new Stream('php://temp', 'wb+');`
`@@ -167,7 +168,8 @@ public function testMovesFileToDesignatedPath()`
`167`	`168`	`$this->assertSame($originalContents, $contents);`
`168`	`169`	`}`
`169`	`170`
`170`		`- public function invalidMovePaths()`
	`171`	`+ /** @return non-empty-array<non-empty-string, array{mixed}> */`
	`172`	`+ public function invalidMovePaths(): array`
`171`	`173`	`{`
`172`	`174`	`return [`
`173`	`175`	`'null' => [null],`
`@@ -183,8 +185,10 @@ public function invalidMovePaths()`
`183`	`185`
`184`	`186`	`/**`
`185`	`187`	`* @dataProvider invalidMovePaths`
	`188`	`+ *`
	`189`	`+ * @param mixed $path`
`186`	`190`	`*/`
`187`		`- public function testMoveRaisesExceptionForInvalidPath($path)`
	`191`	`+ public function testMoveRaisesExceptionForInvalidPath($path): void`
`188`	`192`	`{`
`189`	`193`	`$stream = new Stream('php://temp', 'wb+');`
`190`	`194`	`$stream->write('Foo bar!');`
`@@ -198,7 +202,7 @@ public function testMoveRaisesExceptionForInvalidPath($path)`
`198`	`202`	`$upload->moveTo($path);`
`199`	`203`	`}`
`200`	`204`
`201`		`- public function testMoveCannotBeCalledMoreThanOnce()`
	`205`	`+ public function testMoveCannotBeCalledMoreThanOnce(): void`
`202`	`206`	`{`
`203`	`207`	`$stream = new Stream('php://temp', 'wb+');`
`204`	`208`	`$stream->write('Foo bar!');`
`@@ -214,7 +218,7 @@ public function testMoveCannotBeCalledMoreThanOnce()`
`214`	`218`	`$upload->moveTo($to);`
`215`	`219`	`}`
`216`	`220`
`217`		`- public function testCannotRetrieveStreamAfterMove()`
	`221`	`+ public function testCannotRetrieveStreamAfterMove(): void`
`218`	`222`	`{`
`219`	`223`	`$stream = new Stream('php://temp', 'wb+');`
`220`	`224`	`$stream->write('Foo bar!');`
`@@ -230,7 +234,8 @@ public function testCannotRetrieveStreamAfterMove()`
`230`	`234`	`$upload->getStream();`
`231`	`235`	`}`
`232`	`236`
`233`		`- public function nonOkErrorStatus()`
	`237`	`+ /** @return non-empty-array<non-empty-string, array{positive-int}> */`
	`238`	`+ public function nonOkErrorStatus(): array`
`234`	`239`	`{`
`235`	`240`	`return [`
`236`	`241`	`'UPLOAD_ERR_INI_SIZE' => [ UPLOAD_ERR_INI_SIZE ],`
`@@ -247,7 +252,7 @@ public function nonOkErrorStatus()`
`247`	`252`	`* @dataProvider nonOkErrorStatus`
`248`	`253`	`* @group 60`
`249`	`254`	`*/`
`250`		`- public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent($status)`
	`255`	`+ public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorStatusPresent(int $status): void`
`251`	`256`	`{`
`252`	`257`	`$uploadedFile = new UploadedFile('not ok', 0, $status);`
`253`	`258`	`$this->assertSame($status, $uploadedFile->getError());`
`@@ -257,7 +262,7 @@ public function testConstructorDoesNotRaiseExceptionForInvalidStreamWhenErrorSta`
`257`	`262`	`* @dataProvider nonOkErrorStatus`
`258`	`263`	`* @group 60`
`259`	`264`	`*/`
`260`		`- public function testMoveToRaisesExceptionWhenErrorStatusPresent($status)`
	`265`	`+ public function testMoveToRaisesExceptionWhenErrorStatusPresent(int $status): void`
`261`	`266`	`{`
`262`	`267`	`$uploadedFile = new UploadedFile('not ok', 0, $status);`
`263`	`268`
`@@ -271,7 +276,7 @@ public function testMoveToRaisesExceptionWhenErrorStatusPresent($status)`
`271`	`276`	`* @dataProvider nonOkErrorStatus`
`272`	`277`	`* @group 60`
`273`	`278`	`*/`
`274`		`- public function testGetStreamRaisesExceptionWhenErrorStatusPresent($status)`
	`279`	`+ public function testGetStreamRaisesExceptionWhenErrorStatusPresent(int $status): void`
`275`	`280`	`{`
`276`	`281`	`$uploadedFile = new UploadedFile('not ok', 0, $status);`
`277`	`282`
`@@ -283,9 +288,8 @@ public function testGetStreamRaisesExceptionWhenErrorStatusPresent($status)`
`283`	`288`
`284`	`289`	`/**`
`285`	`290`	`* @group 82`
`286`		`- * @return void`
`287`	`291`	`*/`
`288`		`- public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided()`
	`292`	`+ public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided(): void`
`289`	`293`	`{`
`290`	`294`	`$this->orgFile = tempnam(sys_get_temp_dir(), 'ORG');`
`291`	`295`	`$this->tmpFile = tempnam(sys_get_temp_dir(), 'DIA');`
`@@ -301,7 +305,8 @@ public function testMoveToCreatesStreamIfOnlyAFilenameWasProvided()`
`301`	`305`	`$this->assertSame($original, $contents);`
`302`	`306`	`}`
`303`	`307`
`304`		`- public function errorConstantsAndMessages()`
	`308`	`+ /** @return iterable<int, array{int, non-empty-string}> */`
	`309`	`+ public function errorConstantsAndMessages(): iterable`
`305`	`310`	`{`
`306`	`311`	`foreach (UploadedFile::ERROR_MESSAGES as $constant => $message) {`
`307`	`312`	`if ($constant === UPLOAD_ERR_OK) {`
`@@ -311,13 +316,11 @@ public function errorConstantsAndMessages()`
`311`	`316`	`}`
`312`	`317`	`}`
`313`	`318`
`314`		`- /**`
`315`		`- * @dataProvider errorConstantsAndMessages`
`316`		`- * @param int $constant Upload error constant`
`317`		`- * @param string $message Associated error message`
`318`		`- */`
`319`		`- public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected($constant, $message)`
`320`		`- {`
	`319`	`+ /** @dataProvider errorConstantsAndMessages */`
	`320`	`+ public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected(`
	`321`	`+ int $constant,`
	`322`	`+ string $message`
	`323`	`+ ): void {`
`321`	`324`	`$uploadedFile = new UploadedFile(__FILE__, 100, $constant);`
`322`	`325`	`$this->expectException(RuntimeException::class);`
`323`	`326`	`$this->expectExceptionMessage($message);`
`@@ -326,21 +329,18 @@ public function testGetStreamRaisesExceptionWithAppropriateMessageWhenUploadErro`
`326`	`329`
`327`	`330`	`/**`
`328`	`331`	`* @dataProvider errorConstantsAndMessages`
`329`		`- * @param int $constant Upload error constant`
`330`		`- * @param string $message Associated error message`
`331`	`332`	`*/`
`332`		`- public function testMoveToRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected($constant, $message)`
`333`		`- {`
	`333`	`+ public function testMoveToRaisesExceptionWithAppropriateMessageWhenUploadErrorDetected(`
	`334`	`+ int $constant,`
	`335`	`+ string $message`
	`336`	`+ ): void {`
`334`	`337`	`$uploadedFile = new UploadedFile(__FILE__, 100, $constant);`
`335`	`338`	`$this->expectException(RuntimeException::class);`
`336`	`339`	`$this->expectExceptionMessage($message);`
`337`	`340`	`$uploadedFile->moveTo('/tmp/foo');`
`338`	`341`	`}`
`339`	`342`
`340`		`- /**`
`341`		`- * @return void`
`342`		`- */`
`343`		`- public function testMoveToInCLIShouldRemoveOriginalFile()`
	`343`	`+ public function testMoveToInCLIShouldRemoveOriginalFile(): void`
`344`	`344`	`{`
`345`	`345`	`$this->orgFile = tempnam(sys_get_temp_dir(), 'ORG');`
`346`	`346`	`file_put_contents($this->orgFile, 'Hello');`