Upgraded PHPUnit ^4.8 -> ^7.

Bilge · Bilge · commit 424a92649687 · 2018-04-13T12:43:10.000+01:00
diff --git a/composer.json b/composer.json
@@ -18,7 +18,7 @@
     "psr/cache": "^1"
   },
   "require-dev": {
-    "phpunit/phpunit": "^4.8",
+    "phpunit/phpunit": "^7.1.3",
     "mockery/mockery": "^1"
   },
   "suggest" : {
diff --git a/test/Integration/Porter/Collection/CountableProviderRecordsTest.php b/test/Integration/Porter/Collection/CountableProviderRecordsTest.php
@@ -1,13 +1,14 @@
 <?php
 namespace ScriptFUSIONTest\Integration\Porter\Collection;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Collection\CountableProviderRecords;
 use ScriptFUSION\Porter\Provider\Resource\ProviderResource;
 
 /**
  * @see CountableProviderRecords
  */
-final class CountableProviderRecordsTest extends \PHPUnit_Framework_TestCase
+final class CountableProviderRecordsTest extends TestCase
 {
     /**
      * Tests that counting the collection matches the passed count value.
diff --git a/test/Integration/Porter/Connector/CachingConnectorTest.php b/test/Integration/Porter/Connector/CachingConnectorTest.php
@@ -3,6 +3,7 @@
 
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use Mockery\MockInterface;
+use PHPUnit\Framework\TestCase;
 use Psr\Cache\CacheItemInterface;
 use Psr\Cache\CacheItemPoolInterface;
 use ScriptFUSION\Porter\Cache\CacheKeyGenerator;
@@ -18,7 +19,7 @@
 /**
  * @see CachingConnector
  */
-final class CachingConnectorTest extends \PHPUnit_Framework_TestCase
+final class CachingConnectorTest extends TestCase
 {
     use MockeryPHPUnitIntegration;
 
@@ -178,7 +179,8 @@ public function testFetchThrowsInvalidCacheKeyExceptionOnNonStringCacheKey(): vo
                 ->getMock()
         );
 
-        $this->setExpectedException(InvalidCacheKeyException::class, 'Cache key must be a string.');
+        $this->expectException(InvalidCacheKeyException::class);
+        $this->expectExceptionMessage('Cache key must be a string.');
         $connector->fetch($this->context, 'baz');
     }
 
@@ -192,7 +194,8 @@ public function testFetchThrowsInvalidCacheKeyExceptionOnNonPSR6CompliantCacheKe
                 ->getMock()
         );
 
-        $this->setExpectedException(InvalidCacheKeyException::class, 'contains one or more reserved characters');
+        $this->expectException(InvalidCacheKeyException::class);
+        $this->expectExceptionMessage('contains one or more reserved characters');
         $connector->fetch($this->context, 'baz');
     }
 
diff --git a/test/Integration/Porter/Connector/ConnectionContextTest.php b/test/Integration/Porter/Connector/ConnectionContextTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace ScriptFUSIONTest\Integration\Porter\Connector;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Connector\ConnectionContext;
 use ScriptFUSION\Porter\Connector\FetchExceptionHandler\StatelessFetchExceptionHandler;
 use ScriptFUSION\Porter\Connector\RecoverableConnectorException;
@@ -10,7 +11,7 @@
 /**
  * @see ConnectionContext
  */
-final class ConnectionContextTest extends \PHPUnit_Framework_TestCase
+final class ConnectionContextTest extends TestCase
 {
     /**
      * Tests that when retry() is called multiple times, the original fetch exception handler is unmodified.
diff --git a/test/Integration/Porter/PorterTest.php b/test/Integration/Porter/PorterTest.php
@@ -3,6 +3,7 @@
 
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use Mockery\MockInterface;
+use PHPUnit\Framework\TestCase;
 use Psr\Container\ContainerInterface;
 use ScriptFUSION\Porter\Cache\CacheUnavailableException;
 use ScriptFUSION\Porter\Collection\FilteredRecords;
@@ -30,7 +31,7 @@
 use ScriptFUSION\Retry\FailingTooHardException;
 use ScriptFUSIONTest\MockFactory;
 
-final class PorterTest extends \PHPUnit_Framework_TestCase
+final class PorterTest extends TestCase
 {
     use MockeryPHPUnitIntegration;
 
@@ -133,7 +134,7 @@ public function testImportConnectorWithOptions(): void
         $this->provider->shouldReceive('getConnector')
             ->andReturn(\Mockery::mock(Connector::class, ConnectorOptions::class));
 
-        $this->setExpectedException(\LogicException::class);
+        $this->expectException(\LogicException::class);
         $this->porter->import($this->specification);
     }
 
@@ -181,13 +182,14 @@ public function testImportFailure(): void
     {
         $this->resource->shouldReceive('fetch')->andReturn(null);
 
-        $this->setExpectedException(\TypeError::class, \get_class($this->resource));
+        $this->expectException(\TypeError::class);
+        $this->expectExceptionMessage(\get_class($this->resource));
         $this->porter->import($this->specification);
     }
 
     public function testImportUnregisteredProvider(): void
     {
-        $this->setExpectedException(ProviderNotFoundException::class);
+        $this->expectException(ProviderNotFoundException::class);
 
         $this->porter->import($this->specification->setProviderName('foo'));
     }
@@ -200,7 +202,7 @@ public function testImportForeignResource(): void
         // Replace existing provider with a different one.
         $this->registerProvider(MockFactory::mockProvider(), get_class($this->provider));
 
-        $this->setExpectedException(ForeignResourceException::class);
+        $this->expectException(ForeignResourceException::class);
         $this->porter->import($this->specification);
     }
 
@@ -228,7 +230,7 @@ public function testImportOneOfMany(): void
     {
         $this->resource->shouldReceive('fetch')->andReturn(new \ArrayIterator([['foo'], ['bar']]));
 
-        $this->setExpectedException(ImportException::class);
+        $this->expectException(ImportException::class);
         $this->porter->importOne($this->specification);
     }
 
@@ -243,7 +245,7 @@ public function testOneTry(): void
     {
         $this->arrangeConnectorException(new RecoverableConnectorException);
 
-        $this->setExpectedException(FailingTooHardException::class, '1');
+        $this->expectException(FailingTooHardException::class, '1');
         $this->porter->import($this->specification->setMaxFetchAttempts(1));
     }
 
@@ -255,7 +257,7 @@ public function testDerivedRecoverableException(): void
     {
         $this->arrangeConnectorException(new RecoverableConnectorException);
 
-        $this->setExpectedException(FailingTooHardException::class);
+        $this->expectException(FailingTooHardException::class);
         $this->porter->import($this->specification->setMaxFetchAttempts(1));
     }
 
@@ -267,10 +269,8 @@ public function testDefaultTries(): void
     {
         $this->arrangeConnectorException(new RecoverableConnectorException);
 
-        $this->setExpectedException(
-            FailingTooHardException::class,
-            (string)ImportSpecification::DEFAULT_FETCH_ATTEMPTS
-        );
+        $this->expectException(FailingTooHardException::class);
+        $this->expectExceptionMessage((string)ImportSpecification::DEFAULT_FETCH_ATTEMPTS);
         $this->porter->import($this->specification);
     }
 
@@ -282,7 +282,7 @@ public function testUnrecoverableException(): void
         // Subclass Exception so it's not an ancestor of any other exception.
         $this->arrangeConnectorException($exception = \Mockery::mock(\Exception::class));
 
-        $this->setExpectedException(get_class($exception));
+        $this->expectException(get_class($exception));
         $this->porter->import($this->specification);
     }
 
@@ -303,7 +303,7 @@ public function testCustomFetchExceptionHandler(): void
 
         $this->arrangeConnectorException(new RecoverableConnectorException);
 
-        $this->setExpectedException(FailingTooHardException::class);
+        $this->expectException(FailingTooHardException::class);
         $this->porter->import($this->specification);
     }
 
@@ -335,7 +335,7 @@ function (\Exception $exception) use ($connectorException) {
             })
         ;
 
-        $this->setExpectedException(\RuntimeException::class);
+        $this->expectException(\RuntimeException::class);
         $this->porter->importOne($this->specification);
     }
 
@@ -371,7 +371,7 @@ static function () {
      */
     public function testCacheUnavailable(): void
     {
-        $this->setExpectedException(CacheUnavailableException::class);
+        $this->expectException(CacheUnavailableException::class);
 
         $this->porter->import($this->specification->enableCache());
     }
diff --git a/test/Integration/Porter/Specification/StaticDataImportSpecificationTest.php b/test/Integration/Porter/Specification/StaticDataImportSpecificationTest.php
@@ -1,14 +1,15 @@
 <?php
 namespace ScriptFUSIONTest\Integration\Porter\Specification;
 
+use PHPUnit\Framework\TestCase;
 use Psr\Container\ContainerInterface;
 use ScriptFUSION\Porter\Porter;
 use ScriptFUSION\Porter\Specification\StaticDataImportSpecification;
 
 /**
  * @see StaticDataImportSpecification
  */
-final class StaticDataImportSpecificationTest extends \PHPUnit_Framework_TestCase
+final class StaticDataImportSpecificationTest extends TestCase
 {
     public function test(): void
     {
diff --git a/test/Unit/Porter/Cache/CacheItemTest.php b/test/Unit/Porter/Cache/CacheItemTest.php
@@ -1,10 +1,11 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Cache;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Cache\CacheItem;
 use ScriptFUSION\Porter\Cache\NotImplementedException;
 
-final class CacheItemTest extends \PHPUnit_Framework_TestCase
+final class CacheItemTest extends TestCase
 {
     /** @var CacheItem */
     private $item;
@@ -36,14 +37,14 @@ public function testSet(): void
 
     public function testExpiresAt(): void
     {
-        $this->setExpectedException(NotImplementedException::class);
+        $this->expectException(NotImplementedException::class);
 
         $this->item->expiresAt(null);
     }
 
     public function testExpiresAfter(): void
     {
-        $this->setExpectedException(NotImplementedException::class);
+        $this->expectException(NotImplementedException::class);
 
         $this->item->expiresAfter(null);
     }
diff --git a/test/Unit/Porter/Cache/JsonCacheKeyGeneratorTest.php b/test/Unit/Porter/Cache/JsonCacheKeyGeneratorTest.php
@@ -1,10 +1,11 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Cache;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Cache\JsonCacheKeyGenerator;
 use ScriptFUSIONTest\Stubs\TestOptions;
 
-final class JsonCacheKeyGeneratorTest extends \PHPUnit_Framework_TestCase
+final class JsonCacheKeyGeneratorTest extends TestCase
 {
     public function testGenerateCacheKey(): void
     {
diff --git a/test/Unit/Porter/Cache/MemoryCacheTest.php b/test/Unit/Porter/Cache/MemoryCacheTest.php
@@ -1,11 +1,12 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Cache;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Cache\CacheItem;
 use ScriptFUSION\Porter\Cache\InvalidArgumentException;
 use ScriptFUSION\Porter\Cache\MemoryCache;
 
-final class MemoryCacheTest extends \PHPUnit_Framework_TestCase
+final class MemoryCacheTest extends TestCase
 {
     /** @var MemoryCache */
     private $cache;
@@ -69,7 +70,7 @@ public function testDeleteItems(): void
 
     public function testDeleteInvalidItem(): void
     {
-        $this->setExpectedException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
 
         $this->cache->deleteItems(['foo', 'bar']);
     }
diff --git a/test/Unit/Porter/Collection/PorterRecordsTest.php b/test/Unit/Porter/Collection/PorterRecordsTest.php
@@ -1,11 +1,12 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Collection;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Collection\PorterRecords;
 use ScriptFUSION\Porter\Collection\RecordCollection;
 use ScriptFUSION\Porter\Specification\ImportSpecification;
 
-final class PorterRecordsTest extends \PHPUnit_Framework_TestCase
+final class PorterRecordsTest extends TestCase
 {
     public function test(): void
     {
diff --git a/test/Unit/Porter/Collection/ProviderRecordsTest.php b/test/Unit/Porter/Collection/ProviderRecordsTest.php
@@ -1,10 +1,11 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Collection;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Collection\ProviderRecords;
 use ScriptFUSION\Porter\Provider\Resource\ProviderResource;
 
-final class ProviderRecordsTest extends \PHPUnit_Framework_TestCase
+final class ProviderRecordsTest extends TestCase
 {
     public function test(): void
     {
diff --git a/test/Unit/Porter/Collection/RecordCollectionTest.php b/test/Unit/Porter/Collection/RecordCollectionTest.php
@@ -1,12 +1,13 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Collection;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Collection\RecordCollection;
 
 /**
  * @see RecordCollection
  */
-final class RecordCollectionTest extends \PHPUnit_Framework_TestCase
+final class RecordCollectionTest extends TestCase
 {
     public function testFindParent(): void
     {
@@ -45,7 +46,7 @@ public function testNonArrayYield(): void
             [new \ArrayIterator(['foo'])]
         )->makePartial();
 
-        $this->setExpectedException(\TypeError::class, 'must be of the type array');
+        $this->expectException(\TypeError::class, 'must be of the type array');
         $collection->current();
     }
 }
diff --git a/test/Unit/Porter/Connector/FetchExceptionHandler/StatelessFetchExceptionHandlerTest.php b/test/Unit/Porter/Connector/FetchExceptionHandler/StatelessFetchExceptionHandlerTest.php
@@ -1,15 +1,18 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Connector\FetchExceptionHandler;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Connector\FetchExceptionHandler\StatelessFetchExceptionHandler;
 
 /**
  * @see StatelessFetchExceptionHandler
  */
-final class StatelessFetchExceptionHandlerTest extends \PHPUnit_Framework_TestCase
+final class StatelessFetchExceptionHandlerTest extends TestCase
 {
     /**
      * Tests that the initialize() method does not throw any exception. This test exists solely for code coverage.
+     *
+     * @doesNotPerformAssertions
      */
     public function testInitialize(): void
     {
diff --git a/test/Unit/Porter/Connector/ImportConnectorTest.php b/test/Unit/Porter/Connector/ImportConnectorTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace ScriptFUSIONTest\Unit\Porter\Connector;
 
+use PHPUnit\Framework\TestCase;
 use ScriptFUSION\Porter\Cache\CacheUnavailableException;
 use ScriptFUSION\Porter\Connector\CachingConnector;
 use ScriptFUSION\Porter\Connector\Connector;
@@ -12,7 +13,7 @@
 /**
  * @see ImportConnector
  */
-final class ImportConnectorTest extends \PHPUnit_Framework_TestCase
+final class ImportConnectorTest extends TestCase
 {
     /**
      * Tests that when fetching, the specified context and source are passed verbatim to the underlying connector.
@@ -71,7 +72,7 @@ public function testFetchCacheEnabled(): void
      */
     public function testFetchCacheEnabledButNotAvailable(): void
     {
-        $this->setExpectedException(CacheUnavailableException::class);
+        $this->expectException(CacheUnavailableException::class);
 
         new ImportConnector(
             \Mockery::mock(Connector::class),
@@ -105,7 +106,7 @@ public function testSetExceptionHandlerTwice(): void
 
         $connector->setExceptionHandler($handler = \Mockery::mock(FetchExceptionHandler::class));
 
-        $this->setExpectedException(\LogicException::class);
+        $this->expectException(\LogicException::class);
         $connector->setExceptionHandler($handler);
     }
 
diff --git a/test/Unit/Porter/Connector/NullConnectorTest.php b/test/Unit/Porter/Connector/NullConnectorTest.php
diff --git a/test/Unit/Porter/ImportSpecificationTest.php b/test/Unit/Porter/ImportSpecificationTest.php
diff --git a/test/Unit/Porter/Options/EncapsulatedOptionsTest.php b/test/Unit/Porter/Options/EncapsulatedOptionsTest.php
diff --git a/test/Unit/Porter/PorterAwareTraitTest.php b/test/Unit/Porter/PorterAwareTraitTest.php
diff --git a/test/Unit/Porter/Provider/Resource/NullResourceTest.php b/test/Unit/Porter/Provider/Resource/NullResourceTest.php

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;`
`5`	`5`	`use Mockery\MockInterface;`
	`6`	`+use PHPUnit\Framework\TestCase;`
`6`	`7`	`use Psr\Container\ContainerInterface;`
`7`	`8`	`use ScriptFUSION\Porter\Cache\CacheUnavailableException;`
`8`	`9`	`use ScriptFUSION\Porter\Collection\FilteredRecords;`
`@@ -30,7 +31,7 @@`
`30`	`31`	`use ScriptFUSION\Retry\FailingTooHardException;`
`31`	`32`	`use ScriptFUSIONTest\MockFactory;`
`32`	`33`
`33`		`-final class PorterTest extends \PHPUnit_Framework_TestCase`
	`34`	`+final class PorterTest extends TestCase`
`34`	`35`	`{`
`35`	`36`	`use MockeryPHPUnitIntegration;`
`36`	`37`
`@@ -133,7 +134,7 @@ public function testImportConnectorWithOptions(): void`
`133`	`134`	`$this->provider->shouldReceive('getConnector')`
`134`	`135`	`->andReturn(\Mockery::mock(Connector::class, ConnectorOptions::class));`
`135`	`136`
`136`		`- $this->setExpectedException(\LogicException::class);`
	`137`	`+ $this->expectException(\LogicException::class);`
`137`	`138`	`$this->porter->import($this->specification);`
`138`	`139`	`}`
`139`	`140`
`@@ -181,13 +182,14 @@ public function testImportFailure(): void`
`181`	`182`	`{`
`182`	`183`	`$this->resource->shouldReceive('fetch')->andReturn(null);`
`183`	`184`
`184`		`- $this->setExpectedException(\TypeError::class, \get_class($this->resource));`
	`185`	`+ $this->expectException(\TypeError::class);`
	`186`	`+ $this->expectExceptionMessage(\get_class($this->resource));`
`185`	`187`	`$this->porter->import($this->specification);`
`186`	`188`	`}`
`187`	`189`
`188`	`190`	`public function testImportUnregisteredProvider(): void`
`189`	`191`	`{`
`190`		`- $this->setExpectedException(ProviderNotFoundException::class);`
	`192`	`+ $this->expectException(ProviderNotFoundException::class);`
`191`	`193`
`192`	`194`	`$this->porter->import($this->specification->setProviderName('foo'));`
`193`	`195`	`}`
`@@ -200,7 +202,7 @@ public function testImportForeignResource(): void`
`200`	`202`	`// Replace existing provider with a different one.`
`201`	`203`	`$this->registerProvider(MockFactory::mockProvider(), get_class($this->provider));`
`202`	`204`
`203`		`- $this->setExpectedException(ForeignResourceException::class);`
	`205`	`+ $this->expectException(ForeignResourceException::class);`
`204`	`206`	`$this->porter->import($this->specification);`
`205`	`207`	`}`
`206`	`208`
`@@ -228,7 +230,7 @@ public function testImportOneOfMany(): void`
`228`	`230`	`{`
`229`	`231`	`$this->resource->shouldReceive('fetch')->andReturn(new \ArrayIterator([['foo'], ['bar']]));`
`230`	`232`
`231`		`- $this->setExpectedException(ImportException::class);`
	`233`	`+ $this->expectException(ImportException::class);`
`232`	`234`	`$this->porter->importOne($this->specification);`
`233`	`235`	`}`
`234`	`236`
`@@ -243,7 +245,7 @@ public function testOneTry(): void`
`243`	`245`	`{`
`244`	`246`	`$this->arrangeConnectorException(new RecoverableConnectorException);`
`245`	`247`
`246`		`- $this->setExpectedException(FailingTooHardException::class, '1');`
	`248`	`+ $this->expectException(FailingTooHardException::class, '1');`
`247`	`249`	`$this->porter->import($this->specification->setMaxFetchAttempts(1));`
`248`	`250`	`}`
`249`	`251`
`@@ -255,7 +257,7 @@ public function testDerivedRecoverableException(): void`
`255`	`257`	`{`
`256`	`258`	`$this->arrangeConnectorException(new RecoverableConnectorException);`
`257`	`259`
`258`		`- $this->setExpectedException(FailingTooHardException::class);`
	`260`	`+ $this->expectException(FailingTooHardException::class);`
`259`	`261`	`$this->porter->import($this->specification->setMaxFetchAttempts(1));`
`260`	`262`	`}`
`261`	`263`
`@@ -267,10 +269,8 @@ public function testDefaultTries(): void`
`267`	`269`	`{`
`268`	`270`	`$this->arrangeConnectorException(new RecoverableConnectorException);`
`269`	`271`
`270`		`- $this->setExpectedException(`
`271`		`- FailingTooHardException::class,`
`272`		`- (string)ImportSpecification::DEFAULT_FETCH_ATTEMPTS`
`273`		`- );`
	`272`	`+ $this->expectException(FailingTooHardException::class);`
	`273`	`+ $this->expectExceptionMessage((string)ImportSpecification::DEFAULT_FETCH_ATTEMPTS);`
`274`	`274`	`$this->porter->import($this->specification);`
`275`	`275`	`}`
`276`	`276`
`@@ -282,7 +282,7 @@ public function testUnrecoverableException(): void`
`282`	`282`	`// Subclass Exception so it's not an ancestor of any other exception.`
`283`	`283`	`$this->arrangeConnectorException($exception = \Mockery::mock(\Exception::class));`
`284`	`284`
`285`		`- $this->setExpectedException(get_class($exception));`
	`285`	`+ $this->expectException(get_class($exception));`
`286`	`286`	`$this->porter->import($this->specification);`
`287`	`287`	`}`
`288`	`288`
`@@ -303,7 +303,7 @@ public function testCustomFetchExceptionHandler(): void`
`303`	`303`
`304`	`304`	`$this->arrangeConnectorException(new RecoverableConnectorException);`
`305`	`305`
`306`		`- $this->setExpectedException(FailingTooHardException::class);`
	`306`	`+ $this->expectException(FailingTooHardException::class);`
`307`	`307`	`$this->porter->import($this->specification);`
`308`	`308`	`}`
`309`	`309`
`@@ -335,7 +335,7 @@ function (\Exception $exception) use ($connectorException) {`
`335`	`335`	`})`
`336`	`336`	`;`
`337`	`337`
`338`		`- $this->setExpectedException(\RuntimeException::class);`
	`338`	`+ $this->expectException(\RuntimeException::class);`
`339`	`339`	`$this->porter->importOne($this->specification);`
`340`	`340`	`}`
`341`	`341`
`@@ -371,7 +371,7 @@ static function () {`
`371`	`371`	`*/`
`372`	`372`	`public function testCacheUnavailable(): void`
`373`	`373`	`{`
`374`		`- $this->setExpectedException(CacheUnavailableException::class);`
	`374`	`+ $this->expectException(CacheUnavailableException::class);`
`375`	`375`
`376`	`376`	`$this->porter->import($this->specification->enableCache());`
`377`	`377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`	`1`	`<?php`
`2`	`2`	`namespace ScriptFUSIONTest\Unit\Porter\Cache;`
`3`	`3`
	`4`	`+use PHPUnit\Framework\TestCase;`
`4`	`5`	`use ScriptFUSION\Porter\Cache\CacheItem;`
`5`	`6`	`use ScriptFUSION\Porter\Cache\NotImplementedException;`
`6`	`7`
`7`		`-final class CacheItemTest extends \PHPUnit_Framework_TestCase`
	`8`	`+final class CacheItemTest extends TestCase`
`8`	`9`	`{`
`9`	`10`	`/** @var CacheItem */`
`10`	`11`	`private $item;`
`@@ -36,14 +37,14 @@ public function testSet(): void`
`36`	`37`
`37`	`38`	`public function testExpiresAt(): void`
`38`	`39`	`{`
`39`		`- $this->setExpectedException(NotImplementedException::class);`
	`40`	`+ $this->expectException(NotImplementedException::class);`
`40`	`41`
`41`	`42`	`$this->item->expiresAt(null);`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`public function testExpiresAfter(): void`
`45`	`46`	`{`
`46`		`- $this->setExpectedException(NotImplementedException::class);`
	`47`	`+ $this->expectException(NotImplementedException::class);`
`47`	`48`
`48`	`49`	`$this->item->expiresAfter(null);`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`	`1`	`<?php`
`2`	`2`	`namespace ScriptFUSIONTest\Unit\Porter\Cache;`
`3`	`3`
	`4`	`+use PHPUnit\Framework\TestCase;`
`4`	`5`	`use ScriptFUSION\Porter\Cache\CacheItem;`
`5`	`6`	`use ScriptFUSION\Porter\Cache\InvalidArgumentException;`
`6`	`7`	`use ScriptFUSION\Porter\Cache\MemoryCache;`
`7`	`8`
`8`		`-final class MemoryCacheTest extends \PHPUnit_Framework_TestCase`
	`9`	`+final class MemoryCacheTest extends TestCase`
`9`	`10`	`{`
`10`	`11`	`/** @var MemoryCache */`
`11`	`12`	`private $cache;`
`@@ -69,7 +70,7 @@ public function testDeleteItems(): void`
`69`	`70`
`70`	`71`	`public function testDeleteInvalidItem(): void`
`71`	`72`	`{`
`72`		`- $this->setExpectedException(InvalidArgumentException::class);`
	`73`	`+ $this->expectException(InvalidArgumentException::class);`
`73`	`74`
`74`	`75`	`$this->cache->deleteItems(['foo', 'bar']);`
`75`	`76`	`}`