Use ::class keyword when possible

fabpot · fabpot · commit 0da0af2a0efb · 2021-01-11T11:34:08.000+01:00
diff --git a/Tests/CookieTest.php b/Tests/CookieTest.php
@@ -52,7 +52,7 @@ public function testInstantiationThrowsExceptionIfRawCookieNameContainsSpecialCh
      */
     public function testWithRawThrowsExceptionIfCookieNameContainsSpecialCharacters($name)
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         Cookie::create($name)->withRaw();
     }
 
diff --git a/Tests/JsonResponseTest.php b/Tests/JsonResponseTest.php
@@ -97,7 +97,7 @@ public function testCreate()
     {
         $response = JsonResponse::create(['foo' => 'bar'], 204);
 
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertEquals('{"foo":"bar"}', $response->getContent());
         $this->assertEquals(204, $response->getStatusCode());
     }
@@ -108,7 +108,7 @@ public function testCreate()
     public function testStaticCreateEmptyJsonObject()
     {
         $response = JsonResponse::create();
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('{}', $response->getContent());
     }
 
@@ -118,7 +118,7 @@ public function testStaticCreateEmptyJsonObject()
     public function testStaticCreateJsonArray()
     {
         $response = JsonResponse::create([0, 1, 2, 3]);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('[0,1,2,3]', $response->getContent());
     }
 
@@ -128,7 +128,7 @@ public function testStaticCreateJsonArray()
     public function testStaticCreateJsonObject()
     {
         $response = JsonResponse::create(['foo' => 'bar']);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('{"foo":"bar"}', $response->getContent());
     }
 
@@ -138,20 +138,20 @@ public function testStaticCreateJsonObject()
     public function testStaticCreateWithSimpleTypes()
     {
         $response = JsonResponse::create('foo');
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('"foo"', $response->getContent());
 
         $response = JsonResponse::create(0);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('0', $response->getContent());
 
         $response = JsonResponse::create(0.1);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertEquals(0.1, $response->getContent());
         $this->assertIsString($response->getContent());
 
         $response = JsonResponse::create(true);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);
+        $this->assertInstanceOf(JsonResponse::class, $response);
         $this->assertSame('true', $response->getContent());
     }
 
@@ -236,22 +236,22 @@ public function testItAcceptsJsonAsString()
 
     public function testSetCallbackInvalidIdentifier()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         $response = new JsonResponse('foo');
         $response->setCallback('+invalid');
     }
 
     public function testSetContent()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         new JsonResponse("\xB1\x31");
     }
 
     public function testSetContentJsonSerializeError()
     {
-        $this->expectException('Exception');
+        $this->expectException(\Exception::class);
         $this->expectExceptionMessage('This error is expected');
-        if (!interface_exists('JsonSerializable', false)) {
+        if (!interface_exists(\JsonSerializable::class, false)) {
             $this->markTestSkipped('JsonSerializable is required.');
         }
 
@@ -299,7 +299,7 @@ public function testConstructorWithObjectWithoutToStringMethodThrowsAnException(
     }
 }
 
-if (interface_exists('JsonSerializable', false)) {
+if (interface_exists(\JsonSerializable::class, false)) {
     class JsonSerializableObject implements \JsonSerializable
     {
         public function jsonSerialize()
diff --git a/Tests/RedirectResponseTest.php b/Tests/RedirectResponseTest.php
@@ -25,14 +25,14 @@ public function testGenerateMetaRedirect()
 
     public function testRedirectResponseConstructorEmptyUrl()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('Cannot redirect to an empty URL.');
         new RedirectResponse('');
     }
 
     public function testRedirectResponseConstructorWrongStatusCode()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         new RedirectResponse('foo.bar', 404);
     }
 
@@ -66,7 +66,7 @@ public function testCreate()
     {
         $response = RedirectResponse::create('foo', 301);
 
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\RedirectResponse', $response);
+        $this->assertInstanceOf(RedirectResponse::class, $response);
         $this->assertEquals(301, $response->getStatusCode());
     }
 
diff --git a/Tests/ResponseTest.php b/Tests/ResponseTest.php
@@ -27,7 +27,7 @@ public function testCreate()
     {
         $response = Response::create('foo', 301, ['Foo' => 'bar']);
 
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Response', $response);
+        $this->assertInstanceOf(Response::class, $response);
         $this->assertEquals(301, $response->getStatusCode());
         $this->assertEquals('bar', $response->headers->get('foo'));
     }
@@ -614,7 +614,7 @@ public function testSetCache()
             $response->setCache(['wrong option' => 'value']);
             $this->fail('->setCache() throws an InvalidArgumentException if an option is not supported');
         } catch (\Exception $e) {
-            $this->assertInstanceOf('InvalidArgumentException', $e, '->setCache() throws an InvalidArgumentException if an option is not supported');
+            $this->assertInstanceOf(\InvalidArgumentException::class, $e, '->setCache() throws an InvalidArgumentException if an option is not supported');
             $this->assertStringContainsString('"wrong option"', $e->getMessage());
         }
 
diff --git a/Tests/Session/Storage/NativeSessionStorageTest.php b/Tests/Session/Storage/NativeSessionStorageTest.php
@@ -71,14 +71,14 @@ public function testBag()
 
     public function testRegisterBagException()
     {
-        $this->expectException('InvalidArgumentException');
+        $this->expectException(\InvalidArgumentException::class);
         $storage = $this->getStorage();
         $storage->getBag('non_existing');
     }
 
     public function testRegisterBagForAStartedSessionThrowsException()
     {
-        $this->expectException('LogicException');
+        $this->expectException(\LogicException::class);
         $storage = $this->getStorage();
         $storage->start();
         $storage->registerBag(new AttributeBag());
@@ -210,22 +210,22 @@ public function testSetSaveHandler()
         $this->iniSet('session.save_handler', 'files');
         $storage = $this->getStorage();
         $storage->setSaveHandler();
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
         $storage->setSaveHandler(null);
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
         $storage->setSaveHandler(new SessionHandlerProxy(new NativeFileSessionHandler()));
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
         $storage->setSaveHandler(new NativeFileSessionHandler());
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
         $storage->setSaveHandler(new SessionHandlerProxy(new NullSessionHandler()));
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
         $storage->setSaveHandler(new NullSessionHandler());
-        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $this->assertInstanceOf(SessionHandlerProxy::class, $storage->getSaveHandler());
     }
 
     public function testStarted()
     {
-        $this->expectException('RuntimeException');
+        $this->expectException(\RuntimeException::class);
         $storage = $this->getStorage();
 
         $this->assertFalse($storage->getSaveHandler()->isActive());

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public function testInstantiationThrowsExceptionIfRawCookieNameContainsSpecialCh`
`52`	`52`	`*/`
`53`	`53`	`public function testWithRawThrowsExceptionIfCookieNameContainsSpecialCharacters($name)`
`54`	`54`	`{`
`55`		`- $this->expectException('InvalidArgumentException');`
	`55`	`+ $this->expectException(\InvalidArgumentException::class);`
`56`	`56`	`Cookie::create($name)->withRaw();`
`57`	`57`	`}`
`58`	`58`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ public function testCreate()`
`97`	`97`	`{`
`98`	`98`	`$response = JsonResponse::create(['foo' => 'bar'], 204);`
`99`	`99`
`100`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`100`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`101`	`101`	`$this->assertEquals('{"foo":"bar"}', $response->getContent());`
`102`	`102`	`$this->assertEquals(204, $response->getStatusCode());`
`103`	`103`	`}`
`@@ -108,7 +108,7 @@ public function testCreate()`
`108`	`108`	`public function testStaticCreateEmptyJsonObject()`
`109`	`109`	`{`
`110`	`110`	`$response = JsonResponse::create();`
`111`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`111`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`112`	`112`	`$this->assertSame('{}', $response->getContent());`
`113`	`113`	`}`
`114`	`114`
`@@ -118,7 +118,7 @@ public function testStaticCreateEmptyJsonObject()`
`118`	`118`	`public function testStaticCreateJsonArray()`
`119`	`119`	`{`
`120`	`120`	`$response = JsonResponse::create([0, 1, 2, 3]);`
`121`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`121`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`122`	`122`	`$this->assertSame('[0,1,2,3]', $response->getContent());`
`123`	`123`	`}`
`124`	`124`
`@@ -128,7 +128,7 @@ public function testStaticCreateJsonArray()`
`128`	`128`	`public function testStaticCreateJsonObject()`
`129`	`129`	`{`
`130`	`130`	`$response = JsonResponse::create(['foo' => 'bar']);`
`131`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`131`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`132`	`132`	`$this->assertSame('{"foo":"bar"}', $response->getContent());`
`133`	`133`	`}`
`134`	`134`
`@@ -138,20 +138,20 @@ public function testStaticCreateJsonObject()`
`138`	`138`	`public function testStaticCreateWithSimpleTypes()`
`139`	`139`	`{`
`140`	`140`	`$response = JsonResponse::create('foo');`
`141`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`141`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`142`	`142`	`$this->assertSame('"foo"', $response->getContent());`
`143`	`143`
`144`	`144`	`$response = JsonResponse::create(0);`
`145`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`145`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`146`	`146`	`$this->assertSame('0', $response->getContent());`
`147`	`147`
`148`	`148`	`$response = JsonResponse::create(0.1);`
`149`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`149`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`150`	`150`	`$this->assertEquals(0.1, $response->getContent());`
`151`	`151`	`$this->assertIsString($response->getContent());`
`152`	`152`
`153`	`153`	`$response = JsonResponse::create(true);`
`154`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\JsonResponse', $response);`
	`154`	`+ $this->assertInstanceOf(JsonResponse::class, $response);`
`155`	`155`	`$this->assertSame('true', $response->getContent());`
`156`	`156`	`}`
`157`	`157`
`@@ -236,22 +236,22 @@ public function testItAcceptsJsonAsString()`
`236`	`236`
`237`	`237`	`public function testSetCallbackInvalidIdentifier()`
`238`	`238`	`{`
`239`		`- $this->expectException('InvalidArgumentException');`
	`239`	`+ $this->expectException(\InvalidArgumentException::class);`
`240`	`240`	`$response = new JsonResponse('foo');`
`241`	`241`	`$response->setCallback('+invalid');`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`public function testSetContent()`
`245`	`245`	`{`
`246`		`- $this->expectException('InvalidArgumentException');`
	`246`	`+ $this->expectException(\InvalidArgumentException::class);`
`247`	`247`	`new JsonResponse("\xB1\x31");`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`public function testSetContentJsonSerializeError()`
`251`	`251`	`{`
`252`		`- $this->expectException('Exception');`
	`252`	`+ $this->expectException(\Exception::class);`
`253`	`253`	`$this->expectExceptionMessage('This error is expected');`
`254`		`- if (!interface_exists('JsonSerializable', false)) {`
	`254`	`+ if (!interface_exists(\JsonSerializable::class, false)) {`
`255`	`255`	`$this->markTestSkipped('JsonSerializable is required.');`
`256`	`256`	`}`
`257`	`257`
`@@ -299,7 +299,7 @@ public function testConstructorWithObjectWithoutToStringMethodThrowsAnException(`
`299`	`299`	`}`
`300`	`300`	`}`
`301`	`301`
`302`		`-if (interface_exists('JsonSerializable', false)) {`
	`302`	`+if (interface_exists(\JsonSerializable::class, false)) {`
`303`	`303`	`class JsonSerializableObject implements \JsonSerializable`
`304`	`304`	`{`
`305`	`305`	`public function jsonSerialize()`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ public function testGenerateMetaRedirect()`
`25`	`25`
`26`	`26`	`public function testRedirectResponseConstructorEmptyUrl()`
`27`	`27`	`{`
`28`		`- $this->expectException('InvalidArgumentException');`
	`28`	`+ $this->expectException(\InvalidArgumentException::class);`
`29`	`29`	`$this->expectExceptionMessage('Cannot redirect to an empty URL.');`
`30`	`30`	`new RedirectResponse('');`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public function testRedirectResponseConstructorWrongStatusCode()`
`34`	`34`	`{`
`35`		`- $this->expectException('InvalidArgumentException');`
	`35`	`+ $this->expectException(\InvalidArgumentException::class);`
`36`	`36`	`new RedirectResponse('foo.bar', 404);`
`37`	`37`	`}`
`38`	`38`
`@@ -66,7 +66,7 @@ public function testCreate()`
`66`	`66`	`{`
`67`	`67`	`$response = RedirectResponse::create('foo', 301);`
`68`	`68`
`69`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\RedirectResponse', $response);`
	`69`	`+ $this->assertInstanceOf(RedirectResponse::class, $response);`
`70`	`70`	`$this->assertEquals(301, $response->getStatusCode());`
`71`	`71`	`}`
`72`	`72`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public function testCreate()`
`27`	`27`	`{`
`28`	`28`	`$response = Response::create('foo', 301, ['Foo' => 'bar']);`
`29`	`29`
`30`		`- $this->assertInstanceOf('Symfony\Component\HttpFoundation\Response', $response);`
	`30`	`+ $this->assertInstanceOf(Response::class, $response);`
`31`	`31`	`$this->assertEquals(301, $response->getStatusCode());`
`32`	`32`	`$this->assertEquals('bar', $response->headers->get('foo'));`
`33`	`33`	`}`
`@@ -614,7 +614,7 @@ public function testSetCache()`
`614`	`614`	`$response->setCache(['wrong option' => 'value']);`
`615`	`615`	`$this->fail('->setCache() throws an InvalidArgumentException if an option is not supported');`
`616`	`616`	`} catch (\Exception $e) {`
`617`		`- $this->assertInstanceOf('InvalidArgumentException', $e, '->setCache() throws an InvalidArgumentException if an option is not supported');`
	`617`	`+ $this->assertInstanceOf(\InvalidArgumentException::class, $e, '->setCache() throws an InvalidArgumentException if an option is not supported');`
`618`	`618`	`$this->assertStringContainsString('"wrong option"', $e->getMessage());`
`619`	`619`	`}`
`620`	`620`